dohertj2/natsdotnet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: rename remaining tests to NATS.Server.Core.Tests

Browse Source 
- Rename tests/NATS.Server.Tests -> tests/NATS.Server.Core.Tests
- Update solution file, InternalsVisibleTo, and csproj references
- Remove JETSTREAM_INTEGRATION_MATRIX and NATS.NKeys from csproj (moved to JetStream.Tests and Auth.Tests)
- Update all namespaces from NATS.Server.Tests.* to NATS.Server.Core.Tests.*
- Replace private GetFreePort/ReadUntilAsync helpers with TestUtilities calls
- Fix stale namespace in Transport.Tests/NetworkingGoParityTests.cs
This commit is contained in:
Joseph Doherty
2026-03-12 16:14:02 -04:00
parent 78b4bc2486
commit 7fbffffd05
114 changed files with 576 additions and 1121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

294
tests/NATS.Server.Core.Tests/Configuration/ConfigReloadParityTests.cs Normal file
View File

@@ -0,0 +1,294 @@
// Port of Go server/reload_test.go — TestConfigReloadMaxConnections,
// TestConfigReloadEnableUserAuthentication, TestConfigReloadDisableUserAuthentication,
// and connection-survival during reload.
// Reference: golang/nats-server/server/reload_test.go lines 1978, 720, 781.
using System.Net;
using System.Net.Sockets;
using System.Text;
using Microsoft.Extensions.Logging.Abstractions;
using NATS.Client.Core;
using NATS.Server.Configuration;
using NATS.Server.TestUtilities;
namespace NATS.Server.Core.Tests.Configuration;
/// <summary>
/// Parity tests for config hot reload behaviour.
/// Covers the three scenarios from Go's reload_test.go:
/// - MaxConnections reduction takes effect on new connections
/// - Enabling authentication rejects new unauthorised connections
/// - Existing connections survive a benign (logging) config reload
/// </summary>
public class ConfigReloadParityTests
{
// ─── Helpers ────────────────────────────────────────────────────────────
private static async Task<(NatsServer server, int port, CancellationTokenSource cts)> StartServerAsync(NatsOptions options)
{
var port = TestPortAllocator.GetFreePort();
options.Port = port;
var server = new NatsServer(options, NullLoggerFactory.Instance);
var cts = new CancellationTokenSource();
_ = server.StartAsync(cts.Token);
await server.WaitForReadyAsync();
return (server, port, cts);
}
/// <summary>
/// Connects a raw TCP client and reads the initial INFO line.
/// Returns the connected socket (caller owns disposal).
/// </summary>
private static async Task<Socket> RawConnectAsync(int port)
{
var sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
await sock.ConnectAsync(IPAddress.Loopback, port);
// Drain the INFO line so subsequent reads start at the NATS protocol layer.
var buf = new byte[4096];
await sock.ReceiveAsync(buf, SocketFlags.None);
return sock;
}
/// <summary>
/// Reads from <paramref name="sock"/> until the accumulated response contains
/// <paramref name="expected"/> or the timeout elapses.
/// </summary>
/// <summary>
/// Writes a config file, then calls <see cref="NatsServer.ReloadConfigOrThrow"/>.
/// Mirrors the pattern from JetStreamClusterReloadTests.
/// </summary>
private static void WriteConfigAndReload(NatsServer server, string configPath, string configText)
{
File.WriteAllText(configPath, configText);
server.ReloadConfigOrThrow();
}
// ─── Tests ──────────────────────────────────────────────────────────────
/// <summary>
/// Port of Go TestConfigReloadMaxConnections (reload_test.go:1978).
///
/// Verifies that reducing MaxConnections via hot reload causes the server to
/// reject new connections that would exceed the new limit. The .NET server
/// enforces the limit at accept-time, so existing connections are preserved
/// while future ones beyond the cap receive a -ERR response.
///
/// Go reference: max_connections.conf sets max_connections: 1 and the Go
/// server then closes one existing client; the .NET implementation rejects
/// new connections instead of kicking established ones.
/// </summary>
[Fact]
public async Task Reload_max_connections_takes_effect()
{
var configPath = Path.Combine(Path.GetTempPath(), $"natsdotnet-maxconn-{Guid.NewGuid():N}.conf");
try
{
// Allocate a port first so we can embed it in the config file.
// The server will bind to this port; the config file must match
// to avoid a non-reloadable Port-change error on reload.
var port = TestPortAllocator.GetFreePort();
// Start with no connection limit.
File.WriteAllText(configPath, $"port: {port}\nmax_connections: 65536");
var options = new NatsOptions { ConfigFile = configPath, Port = port };
var server = new NatsServer(options, NullLoggerFactory.Instance);
var cts = new CancellationTokenSource();
_ = server.StartAsync(cts.Token);
await server.WaitForReadyAsync();
try
{
// Establish two raw connections before limiting.
using var c1 = await RawConnectAsync(port);
using var c2 = await RawConnectAsync(port);
server.ClientCount.ShouldBe(2);
// Reload with MaxConnections = 2 (equal to current count).
// New connections beyond this cap must be rejected.
WriteConfigAndReload(server, configPath, $"port: {port}\nmax_connections: 2");
// Verify the limit is now in effect: a third connection should be
// rejected with -ERR 'maximum connections exceeded'.
using var c3 = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
await c3.ConnectAsync(IPAddress.Loopback, port);
// The server sends INFO then immediately -ERR and closes the socket.
var response = await SocketTestHelper.ReadUntilAsync(c3, "-ERR", timeoutMs: 5000);
response.ShouldContain("maximum connections exceeded");
}
finally
{
await cts.CancelAsync();
server.Dispose();
}
}
finally
{
if (File.Exists(configPath)) File.Delete(configPath);
}
}
/// <summary>
/// Port of Go TestConfigReloadEnableUserAuthentication (reload_test.go:720).
///
/// Verifies that enabling username/password authentication via hot reload
/// causes new unauthenticated connections to be rejected with an
/// "Authorization Violation" error, while connections using the new
/// credentials succeed.
/// </summary>
[Fact]
public async Task Reload_auth_changes_take_effect()
{
var configPath = Path.Combine(Path.GetTempPath(), $"natsdotnet-auth-{Guid.NewGuid():N}.conf");
try
{
// Allocate a port and embed it in every config write to prevent a
// non-reloadable Port-change error when the config file is updated.
var port = TestPortAllocator.GetFreePort();
// Start with no authentication required.
File.WriteAllText(configPath, $"port: {port}\ndebug: false");
var options = new NatsOptions { ConfigFile = configPath, Port = port };
var server = new NatsServer(options, NullLoggerFactory.Instance);
var cts = new CancellationTokenSource();
_ = server.StartAsync(cts.Token);
await server.WaitForReadyAsync();
try
{
// Confirm a connection works with no credentials.
await using var preReloadClient = new NatsConnection(new NatsOpts
{
Url = $"nats://127.0.0.1:{port}",
});
await preReloadClient.ConnectAsync();
await preReloadClient.PingAsync();
// Reload with user/password authentication enabled.
WriteConfigAndReload(server, configPath,
$"port: {port}\nauthorization {{\n user: tyler\n password: T0pS3cr3t\n}}");
// New connections without credentials must be rejected.
await using var noAuthClient = new NatsConnection(new NatsOpts
{
Url = $"nats://127.0.0.1:{port}",
MaxReconnectRetry = 0,
});
var ex = await Should.ThrowAsync<NatsException>(async () =>
{
await noAuthClient.ConnectAsync();
await noAuthClient.PingAsync();
});
ContainsInChain(ex, "Authorization Violation").ShouldBeTrue(
$"Expected 'Authorization Violation' in exception chain, but got: {ex}");
// New connections with the correct credentials must succeed.
await using var authClient = new NatsConnection(new NatsOpts
{
Url = $"nats://tyler:T0pS3cr3t@127.0.0.1:{port}",
});
await authClient.ConnectAsync();
await authClient.PingAsync();
}
finally
{
await cts.CancelAsync();
server.Dispose();
}
}
finally
{
if (File.Exists(configPath)) File.Delete(configPath);
}
}
/// <summary>
/// Port of Go TestConfigReloadDisableUserAuthentication (reload_test.go:781).
///
/// Verifies that disabling authentication via hot reload allows new
/// connections without credentials to succeed. Also verifies that
/// connections established before the reload survive the reload cycle
/// (the server must not close healthy clients on a logging-only reload).
/// </summary>
[Fact]
public async Task Reload_preserves_existing_connections()
{
var configPath = Path.Combine(Path.GetTempPath(), $"natsdotnet-preserve-{Guid.NewGuid():N}.conf");
try
{
// Allocate a port and embed it in every config write to prevent a
// non-reloadable Port-change error when the config file is updated.
var port = TestPortAllocator.GetFreePort();
// Start with debug disabled.
File.WriteAllText(configPath, $"port: {port}\ndebug: false");
var options = new NatsOptions { ConfigFile = configPath, Port = port };
var server = new NatsServer(options, NullLoggerFactory.Instance);
var cts = new CancellationTokenSource();
_ = server.StartAsync(cts.Token);
await server.WaitForReadyAsync();
try
{
// Establish a connection before the reload.
await using var client = new NatsConnection(new NatsOpts
{
Url = $"nats://127.0.0.1:{port}",
});
await client.ConnectAsync();
await client.PingAsync();
// The connection should be alive before reload.
client.ConnectionState.ShouldBe(NatsConnectionState.Open);
// Reload with a logging-only change (debug flag); this must not
// disconnect existing clients.
WriteConfigAndReload(server, configPath, $"port: {port}\ndebug: true");
// Give the server a moment to apply changes.
await Task.Delay(100);
// The pre-reload connection should still be alive.
client.ConnectionState.ShouldBe(NatsConnectionState.Open,
"Existing connection should survive a logging-only config reload");
// Verify the connection is still functional.
await client.PingAsync();
}
finally
{
await cts.CancelAsync();
server.Dispose();
}
}
finally
{
if (File.Exists(configPath)) File.Delete(configPath);
}
}
// ─── Private helpers ────────────────────────────────────────────────────
/// <summary>
/// Checks whether any exception in the chain contains the given substring,
/// matching the pattern used in AuthIntegrationTests.
/// </summary>
private static bool ContainsInChain(Exception ex, string substring)
{
Exception? current = ex;
while (current != null)
{
if (current.Message.Contains(substring, StringComparison.OrdinalIgnoreCase))
return true;
current = current.InnerException;
}
return false;
}
}