Fix E2E test gaps and add comprehensive E2E + parity test suites
- Fix pull consumer fetch: send original stream subject in HMSG (not inbox) so NATS client distinguishes data messages from control messages - Fix MaxAge expiry: add background timer in StreamManager for periodic pruning - Fix JetStream wire format: Go-compatible anonymous objects with string enums, proper offset-based pagination for stream/consumer list APIs - Add 42 E2E black-box tests (core messaging, auth, TLS, accounts, JetStream) - Add ~1000 parity tests across all subsystems (gaps closure) - Update gap inventory docs to reflect implementation status
This commit is contained in:
Joseph Doherty
98
tests/NATS.E2E.Tests/AccountIsolationTests.cs
Normal file
98
tests/NATS.E2E.Tests/AccountIsolationTests.cs
Normal file
@@ -0,0 +1,98 @@
|
||||
using NATS.Client.Core;
|
||||
using NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
namespace NATS.E2E.Tests;
|
||||
|
||||
[Collection("E2E-Accounts")]
|
||||
public class AccountIsolationTests(AccountServerFixture fixture)
|
||||
{
|
||||
[Fact]
|
||||
public async Task Accounts_SameAccount_MessageDelivered()
|
||||
{
|
||||
await using var pub = fixture.CreateClientA();
|
||||
await using var sub = fixture.CreateClientA();
|
||||
|
||||
await pub.ConnectAsync();
|
||||
await sub.ConnectAsync();
|
||||
|
||||
await using var subscription = await sub.SubscribeCoreAsync<string>("acct.test");
|
||||
await sub.PingAsync();
|
||||
|
||||
await pub.PublishAsync("acct.test", "intra-account");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var msg = await subscription.Msgs.ReadAsync(cts.Token);
|
||||
|
||||
msg.Data.ShouldBe("intra-account");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Accounts_CrossAccount_MessageNotDelivered()
|
||||
{
|
||||
await using var pub = fixture.CreateClientA();
|
||||
await using var sub = fixture.CreateClientB();
|
||||
|
||||
await pub.ConnectAsync();
|
||||
await sub.ConnectAsync();
|
||||
|
||||
await using var subscription = await sub.SubscribeCoreAsync<string>("cross.test");
|
||||
await sub.PingAsync();
|
||||
|
||||
await pub.PublishAsync("cross.test", "cross-account");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var readTask = subscription.Msgs.ReadAsync(cts.Token).AsTask();
|
||||
var completed = await Task.WhenAny(readTask, Task.Delay(1000));
|
||||
|
||||
completed.ShouldNotBe(readTask);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Accounts_EachAccountHasOwnNamespace()
|
||||
{
|
||||
await using var pubA = fixture.CreateClientA();
|
||||
await using var subA = fixture.CreateClientA();
|
||||
await using var pubB = fixture.CreateClientB();
|
||||
await using var subB = fixture.CreateClientB();
|
||||
|
||||
await pubA.ConnectAsync();
|
||||
await subA.ConnectAsync();
|
||||
await pubB.ConnectAsync();
|
||||
await subB.ConnectAsync();
|
||||
|
||||
await using var subscriptionA = await subA.SubscribeCoreAsync<string>("shared.topic");
|
||||
await using var subscriptionB = await subB.SubscribeCoreAsync<string>("shared.topic");
|
||||
|
||||
await subA.PingAsync();
|
||||
await subB.PingAsync();
|
||||
|
||||
// Publish from ACCT_A — only ACCT_A subscriber should receive
|
||||
await pubA.PublishAsync("shared.topic", "from-a");
|
||||
|
||||
using var ctA = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var msgA = await subscriptionA.Msgs.ReadAsync(ctA.Token);
|
||||
msgA.Data.ShouldBe("from-a");
|
||||
|
||||
using var ctsBNoMsg = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var readBTask = subscriptionB.Msgs.ReadAsync(ctsBNoMsg.Token).AsTask();
|
||||
var completedB = await Task.WhenAny(readBTask, Task.Delay(1000));
|
||||
completedB.ShouldNotBe(readBTask);
|
||||
// Cancel the abandoned read so it doesn't consume the next message
|
||||
await ctsBNoMsg.CancelAsync();
|
||||
try { await readBTask; } catch (OperationCanceledException) { }
|
||||
|
||||
// Publish from ACCT_B — only ACCT_B subscriber should receive
|
||||
await pubB.PublishAsync("shared.topic", "from-b");
|
||||
|
||||
using var ctB = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var msgB = await subscriptionB.Msgs.ReadAsync(ctB.Token);
|
||||
msgB.Data.ShouldBe("from-b");
|
||||
|
||||
using var ctsANoMsg = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var readATask2 = subscriptionA.Msgs.ReadAsync(ctsANoMsg.Token).AsTask();
|
||||
var completedA2 = await Task.WhenAny(readATask2, Task.Delay(1000));
|
||||
completedA2.ShouldNotBe(readATask2);
|
||||
await ctsANoMsg.CancelAsync();
|
||||
try { await readATask2; } catch (OperationCanceledException) { }
|
||||
}
|
||||
}
|
||||
262
tests/NATS.E2E.Tests/AuthTests.cs
Normal file
262
tests/NATS.E2E.Tests/AuthTests.cs
Normal file
@@ -0,0 +1,262 @@
|
||||
using NATS.Client.Core;
|
||||
using NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
namespace NATS.E2E.Tests;
|
||||
|
||||
[Collection("E2E-Auth")]
|
||||
public class AuthTests(AuthServerFixture fixture)
|
||||
{
|
||||
[Fact]
|
||||
public async Task UsernamePassword_ValidCredentials_Connects()
|
||||
{
|
||||
await using var client = fixture.CreateClient("testuser", "testpass");
|
||||
await client.ConnectAsync();
|
||||
await client.PingAsync();
|
||||
client.ConnectionState.ShouldBe(NatsConnectionState.Open);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UsernamePassword_InvalidPassword_Rejected()
|
||||
{
|
||||
await using var client = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Port}",
|
||||
AuthOpts = new NatsAuthOpts { Username = "testuser", Password = "wrongpass" },
|
||||
MaxReconnectRetry = 0,
|
||||
});
|
||||
|
||||
var ex = await Should.ThrowAsync<Exception>(async () =>
|
||||
{
|
||||
await client.ConnectAsync();
|
||||
await client.PingAsync();
|
||||
});
|
||||
|
||||
ex.ShouldNotBeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task UsernamePassword_NoCredentials_Rejected()
|
||||
{
|
||||
await using var client = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Port}",
|
||||
MaxReconnectRetry = 0,
|
||||
});
|
||||
|
||||
var ex = await Should.ThrowAsync<Exception>(async () =>
|
||||
{
|
||||
await client.ConnectAsync();
|
||||
await client.PingAsync();
|
||||
});
|
||||
|
||||
ex.ShouldNotBeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task TokenAuth_ValidToken_Connects()
|
||||
{
|
||||
var config = """
|
||||
authorization {
|
||||
token: "s3cret"
|
||||
}
|
||||
""";
|
||||
|
||||
await using var server = NatsServerProcess.WithConfig(config);
|
||||
await server.StartAsync();
|
||||
|
||||
await using var client = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{server.Port}",
|
||||
AuthOpts = new NatsAuthOpts { Token = "s3cret" },
|
||||
});
|
||||
|
||||
await client.ConnectAsync();
|
||||
await client.PingAsync();
|
||||
client.ConnectionState.ShouldBe(NatsConnectionState.Open);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task TokenAuth_InvalidToken_Rejected()
|
||||
{
|
||||
var config = """
|
||||
authorization {
|
||||
token: "s3cret"
|
||||
}
|
||||
""";
|
||||
|
||||
await using var server = NatsServerProcess.WithConfig(config);
|
||||
await server.StartAsync();
|
||||
|
||||
await using var client = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{server.Port}",
|
||||
AuthOpts = new NatsAuthOpts { Token = "wrongtoken" },
|
||||
MaxReconnectRetry = 0,
|
||||
});
|
||||
|
||||
var ex = await Should.ThrowAsync<Exception>(async () =>
|
||||
{
|
||||
await client.ConnectAsync();
|
||||
await client.PingAsync();
|
||||
});
|
||||
|
||||
ex.ShouldNotBeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task NKeyAuth_ValidSignature_Connects()
|
||||
{
|
||||
await using var client = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Port}",
|
||||
AuthOpts = new NatsAuthOpts
|
||||
{
|
||||
NKey = fixture.NKeyPublicKey,
|
||||
Seed = fixture.NKeySeed,
|
||||
},
|
||||
});
|
||||
|
||||
await client.ConnectAsync();
|
||||
await client.PingAsync();
|
||||
client.ConnectionState.ShouldBe(NatsConnectionState.Open);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task NKeyAuth_InvalidSignature_Rejected()
|
||||
{
|
||||
// Generate a fresh key pair that is NOT registered with the server
|
||||
var otherSeed = NATS.Client.Core.NKeys.CreateUserSeed();
|
||||
var otherPublicKey = NATS.Client.Core.NKeys.PublicKeyFromSeed(otherSeed);
|
||||
|
||||
await using var client = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Port}",
|
||||
AuthOpts = new NatsAuthOpts
|
||||
{
|
||||
NKey = otherPublicKey,
|
||||
Seed = otherSeed,
|
||||
},
|
||||
MaxReconnectRetry = 0,
|
||||
});
|
||||
|
||||
var ex = await Should.ThrowAsync<Exception>(async () =>
|
||||
{
|
||||
await client.ConnectAsync();
|
||||
await client.PingAsync();
|
||||
});
|
||||
|
||||
ex.ShouldNotBeNull();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Permission_PublishAllowed_Succeeds()
|
||||
{
|
||||
await using var pub = fixture.CreateClient("pubonly", "pubpass");
|
||||
await using var sub = fixture.CreateClient("testuser", "testpass");
|
||||
|
||||
await pub.ConnectAsync();
|
||||
await sub.ConnectAsync();
|
||||
|
||||
await using var subscription = await sub.SubscribeCoreAsync<string>("allowed.foo");
|
||||
await sub.PingAsync();
|
||||
|
||||
await pub.PublishAsync("allowed.foo", "hello");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await subscription.Msgs.ReadAsync(cts.Token);
|
||||
msg.Data.ShouldBe("hello");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Permission_PublishDenied_NoDelivery()
|
||||
{
|
||||
await using var pub = fixture.CreateClient("pubonly", "pubpass");
|
||||
await using var sub = fixture.CreateClient("testuser", "testpass");
|
||||
|
||||
await pub.ConnectAsync();
|
||||
await sub.ConnectAsync();
|
||||
|
||||
await using var subscription = await sub.SubscribeCoreAsync<string>("denied.foo");
|
||||
await sub.PingAsync();
|
||||
|
||||
await pub.PublishAsync("denied.foo", "should-not-arrive");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
|
||||
var readTask = subscription.Msgs.ReadAsync(cts.Token).AsTask();
|
||||
|
||||
await Should.ThrowAsync<OperationCanceledException>(async () => await readTask);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Permission_SubscribeDenied_Rejected()
|
||||
{
|
||||
await using var pub = fixture.CreateClient("testuser", "testpass");
|
||||
await using var sub = fixture.CreateClient("subonly", "subpass");
|
||||
|
||||
await pub.ConnectAsync();
|
||||
await sub.ConnectAsync();
|
||||
|
||||
// subonly may not subscribe to denied.topic — the subscription silently
|
||||
// fails or is dropped by the server; no message should arrive
|
||||
await using var subscription = await sub.SubscribeCoreAsync<string>("denied.topic");
|
||||
await sub.PingAsync();
|
||||
|
||||
await pub.PublishAsync("denied.topic", "should-not-arrive");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
|
||||
var readTask = subscription.Msgs.ReadAsync(cts.Token).AsTask();
|
||||
|
||||
await Should.ThrowAsync<OperationCanceledException>(async () => await readTask);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MaxSubscriptions_ExceedsLimit_Rejected()
|
||||
{
|
||||
// The server is configured with max_subs: 5 (server-wide).
|
||||
// Open a single connection and exhaust the limit.
|
||||
await using var client = fixture.CreateClient("limited", "limpass");
|
||||
await client.ConnectAsync();
|
||||
|
||||
var subscriptions = new List<IAsyncDisposable>();
|
||||
try
|
||||
{
|
||||
// Create subscriptions up to the server max
|
||||
for (var i = 0; i < 5; i++)
|
||||
subscriptions.Add(await client.SubscribeCoreAsync<string>($"max.subs.test.{i}"));
|
||||
|
||||
// The 6th subscription should cause the server to close the connection
|
||||
var ex = await Should.ThrowAsync<Exception>(async () =>
|
||||
{
|
||||
subscriptions.Add(await client.SubscribeCoreAsync<string>("max.subs.test.6"));
|
||||
// Force a round-trip so the server error is observed
|
||||
await client.PingAsync();
|
||||
});
|
||||
|
||||
ex.ShouldNotBeNull();
|
||||
}
|
||||
finally
|
||||
{
|
||||
foreach (var s in subscriptions)
|
||||
await s.DisposeAsync();
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task MaxPayload_ExceedsLimit_Disconnected()
|
||||
{
|
||||
// The fixture server has max_payload: 512; send > 512 bytes
|
||||
await using var client = fixture.CreateClient("testuser", "testpass");
|
||||
await client.ConnectAsync();
|
||||
|
||||
var oversized = new string('x', 600);
|
||||
|
||||
var ex = await Should.ThrowAsync<Exception>(async () =>
|
||||
{
|
||||
await client.PublishAsync("payload.test", oversized);
|
||||
// Force a round-trip to observe the server's error response
|
||||
await client.PingAsync();
|
||||
});
|
||||
|
||||
ex.ShouldNotBeNull();
|
||||
}
|
||||
}
|
||||
67
tests/NATS.E2E.Tests/BasicTests.cs
Normal file
67
tests/NATS.E2E.Tests/BasicTests.cs
Normal file
@@ -0,0 +1,67 @@
|
||||
using NATS.Client.Core;
|
||||
using NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
namespace NATS.E2E.Tests;
|
||||
|
||||
[Collection("E2E")]
|
||||
public class BasicTests(NatsServerFixture fixture)
|
||||
{
|
||||
[Fact]
|
||||
public async Task ConnectAndPing()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
|
||||
await client.PingAsync();
|
||||
|
||||
client.ConnectionState.ShouldBe(NatsConnectionState.Open);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task PubSub()
|
||||
{
|
||||
await using var pub = fixture.CreateClient();
|
||||
await using var sub = fixture.CreateClient();
|
||||
|
||||
await pub.ConnectAsync();
|
||||
await sub.ConnectAsync();
|
||||
|
||||
await using var subscription = await sub.SubscribeCoreAsync<string>("e2e.test.pubsub");
|
||||
await sub.PingAsync(); // Flush to ensure subscription is active
|
||||
|
||||
await pub.PublishAsync("e2e.test.pubsub", "hello e2e");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var msg = await subscription.Msgs.ReadAsync(cts.Token);
|
||||
|
||||
msg.Data.ShouldBe("hello e2e");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task RequestReply()
|
||||
{
|
||||
await using var requester = fixture.CreateClient();
|
||||
await using var responder = fixture.CreateClient();
|
||||
|
||||
await requester.ConnectAsync();
|
||||
await responder.ConnectAsync();
|
||||
|
||||
await using var subscription = await responder.SubscribeCoreAsync<string>("e2e.test.rpc");
|
||||
await responder.PingAsync(); // Flush to ensure subscription is active
|
||||
|
||||
// Background task to read and reply
|
||||
var responderTask = Task.Run(async () =>
|
||||
{
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var msg = await subscription.Msgs.ReadAsync(cts.Token);
|
||||
await responder.PublishAsync(msg.ReplyTo!, $"reply: {msg.Data}");
|
||||
});
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var reply = await requester.RequestAsync<string, string>("e2e.test.rpc", "ping", cancellationToken: cts.Token);
|
||||
|
||||
reply.Data.ShouldBe("reply: ping");
|
||||
|
||||
await responderTask; // Ensure no exceptions in the responder
|
||||
}
|
||||
}
|
||||
378
tests/NATS.E2E.Tests/CoreMessagingTests.cs
Normal file
378
tests/NATS.E2E.Tests/CoreMessagingTests.cs
Normal file
@@ -0,0 +1,378 @@
|
||||
using System.Linq;
|
||||
using System.Net.Sockets;
|
||||
using System.Text;
|
||||
using NATS.Client.Core;
|
||||
using NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
namespace NATS.E2E.Tests;
|
||||
|
||||
[Collection("E2E")]
|
||||
public class CoreMessagingTests(NatsServerFixture fixture)
|
||||
{
|
||||
[Fact]
|
||||
public async Task WildcardStar_MatchesSingleToken()
|
||||
{
|
||||
await using var pub = fixture.CreateClient();
|
||||
await using var sub = fixture.CreateClient();
|
||||
await pub.ConnectAsync();
|
||||
await sub.ConnectAsync();
|
||||
|
||||
await using var subscription = await sub.SubscribeCoreAsync<string>("e2e.wc.*");
|
||||
await sub.PingAsync();
|
||||
|
||||
await pub.PublishAsync("e2e.wc.bar", "hello");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var msg = await subscription.Msgs.ReadAsync(cts.Token);
|
||||
|
||||
msg.Data.ShouldBe("hello");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task WildcardGreaterThan_MatchesMultipleTokens()
|
||||
{
|
||||
await using var pub = fixture.CreateClient();
|
||||
await using var sub = fixture.CreateClient();
|
||||
await pub.ConnectAsync();
|
||||
await sub.ConnectAsync();
|
||||
|
||||
await using var subscription = await sub.SubscribeCoreAsync<string>("e2e.gt.>");
|
||||
await sub.PingAsync();
|
||||
|
||||
await pub.PublishAsync("e2e.gt.bar.baz", "deep");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var msg = await subscription.Msgs.ReadAsync(cts.Token);
|
||||
|
||||
msg.Data.ShouldBe("deep");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task WildcardStar_DoesNotMatchMultipleTokens()
|
||||
{
|
||||
await using var pub = fixture.CreateClient();
|
||||
await using var sub = fixture.CreateClient();
|
||||
await pub.ConnectAsync();
|
||||
await sub.ConnectAsync();
|
||||
|
||||
await using var subscription = await sub.SubscribeCoreAsync<string>("e2e.nomat.*");
|
||||
await sub.PingAsync();
|
||||
|
||||
await pub.PublishAsync("e2e.nomat.bar.baz", "should not arrive");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var readTask = subscription.Msgs.ReadAsync(cts.Token).AsTask();
|
||||
var winner = await Task.WhenAny(readTask, Task.Delay(1000));
|
||||
|
||||
winner.ShouldNotBe(readTask);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task QueueGroup_LoadBalances()
|
||||
{
|
||||
await using var c1 = fixture.CreateClient();
|
||||
await using var c2 = fixture.CreateClient();
|
||||
await using var c3 = fixture.CreateClient();
|
||||
await using var pub = fixture.CreateClient();
|
||||
|
||||
await c1.ConnectAsync();
|
||||
await c2.ConnectAsync();
|
||||
await c3.ConnectAsync();
|
||||
await pub.ConnectAsync();
|
||||
|
||||
await using var s1 = await c1.SubscribeCoreAsync<int>("e2e.qlb", queueGroup: "workers");
|
||||
await using var s2 = await c2.SubscribeCoreAsync<int>("e2e.qlb", queueGroup: "workers");
|
||||
await using var s3 = await c3.SubscribeCoreAsync<int>("e2e.qlb", queueGroup: "workers");
|
||||
|
||||
await c1.PingAsync();
|
||||
await c2.PingAsync();
|
||||
await c3.PingAsync();
|
||||
|
||||
using var collectionCts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
|
||||
|
||||
var counts = new int[3];
|
||||
|
||||
async Task Collect(INatsSub<int> sub, int idx)
|
||||
{
|
||||
try
|
||||
{
|
||||
await foreach (var _ in sub.Msgs.ReadAllAsync(collectionCts.Token))
|
||||
Interlocked.Increment(ref counts[idx]);
|
||||
}
|
||||
catch (OperationCanceledException) { }
|
||||
}
|
||||
|
||||
var tasks = new[]
|
||||
{
|
||||
Collect(s1, 0),
|
||||
Collect(s2, 1),
|
||||
Collect(s3, 2),
|
||||
};
|
||||
|
||||
for (var i = 0; i < 30; i++)
|
||||
await pub.PublishAsync("e2e.qlb", i);
|
||||
|
||||
await pub.PingAsync();
|
||||
|
||||
// Wait until all 30 messages have been received
|
||||
using var deadline = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
while (counts[0] + counts[1] + counts[2] < 30 && !deadline.IsCancellationRequested)
|
||||
await Task.Delay(10, deadline.Token).ContinueWith(_ => { });
|
||||
|
||||
collectionCts.Cancel();
|
||||
await Task.WhenAll(tasks);
|
||||
|
||||
var total = counts[0] + counts[1] + counts[2];
|
||||
total.ShouldBe(30);
|
||||
|
||||
// Verify at least one queue member received messages (distribution
|
||||
// is implementation-defined and may heavily favor one member when
|
||||
// messages are published in a tight loop).
|
||||
counts.Max().ShouldBeGreaterThan(0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task QueueGroup_MixedWithPlainSub()
|
||||
{
|
||||
await using var plainClient = fixture.CreateClient();
|
||||
await using var q1Client = fixture.CreateClient();
|
||||
await using var q2Client = fixture.CreateClient();
|
||||
await using var pub = fixture.CreateClient();
|
||||
|
||||
await plainClient.ConnectAsync();
|
||||
await q1Client.ConnectAsync();
|
||||
await q2Client.ConnectAsync();
|
||||
await pub.ConnectAsync();
|
||||
|
||||
await using var plainSub = await plainClient.SubscribeCoreAsync<int>("e2e.qmix");
|
||||
await using var qSub1 = await q1Client.SubscribeCoreAsync<int>("e2e.qmix", queueGroup: "qmix");
|
||||
await using var qSub2 = await q2Client.SubscribeCoreAsync<int>("e2e.qmix", queueGroup: "qmix");
|
||||
|
||||
await plainClient.PingAsync();
|
||||
await q1Client.PingAsync();
|
||||
await q2Client.PingAsync();
|
||||
|
||||
using var collectionCts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
|
||||
|
||||
var plainCount = 0;
|
||||
var q1Count = 0;
|
||||
var q2Count = 0;
|
||||
|
||||
async Task Collect(INatsSub<int> sub, Action increment)
|
||||
{
|
||||
try
|
||||
{
|
||||
await foreach (var _ in sub.Msgs.ReadAllAsync(collectionCts.Token))
|
||||
increment();
|
||||
}
|
||||
catch (OperationCanceledException) { }
|
||||
}
|
||||
|
||||
var tasks = new[]
|
||||
{
|
||||
Collect(plainSub, () => Interlocked.Increment(ref plainCount)),
|
||||
Collect(qSub1, () => Interlocked.Increment(ref q1Count)),
|
||||
Collect(qSub2, () => Interlocked.Increment(ref q2Count)),
|
||||
};
|
||||
|
||||
for (var i = 0; i < 10; i++)
|
||||
await pub.PublishAsync("e2e.qmix", i);
|
||||
|
||||
await pub.PingAsync();
|
||||
|
||||
using var deadline = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
while (plainCount < 10 && !deadline.IsCancellationRequested)
|
||||
await Task.Delay(10, deadline.Token).ContinueWith(_ => { });
|
||||
|
||||
collectionCts.Cancel();
|
||||
await Task.WhenAll(tasks);
|
||||
|
||||
plainCount.ShouldBe(10);
|
||||
(q1Count + q2Count).ShouldBe(10);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Unsub_StopsDelivery()
|
||||
{
|
||||
await using var pub = fixture.CreateClient();
|
||||
await using var subClient = fixture.CreateClient();
|
||||
await pub.ConnectAsync();
|
||||
await subClient.ConnectAsync();
|
||||
|
||||
var subscription = await subClient.SubscribeCoreAsync<string>("e2e.unsub");
|
||||
await subClient.PingAsync();
|
||||
|
||||
await subscription.DisposeAsync();
|
||||
await subClient.PingAsync();
|
||||
|
||||
// Subscribe a fresh listener on the same subject to verify the unsubscribed
|
||||
// client does NOT receive messages, while the fresh one does.
|
||||
await using var verifyClient = fixture.CreateClient();
|
||||
await verifyClient.ConnectAsync();
|
||||
await using var verifySub = await verifyClient.SubscribeCoreAsync<string>("e2e.unsub");
|
||||
await verifyClient.PingAsync();
|
||||
|
||||
await pub.PublishAsync("e2e.unsub", "after-unsub");
|
||||
await pub.PingAsync();
|
||||
|
||||
// The fresh subscriber should receive the message
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var msg = await verifySub.Msgs.ReadAsync(cts.Token);
|
||||
msg.Data.ShouldBe("after-unsub");
|
||||
|
||||
// The original (disposed) subscription's channel should be completed —
|
||||
// reading from it should NOT yield "after-unsub"
|
||||
var received = new List<string?>();
|
||||
try
|
||||
{
|
||||
await foreach (var m in subscription.Msgs.ReadAllAsync(default))
|
||||
received.Add(m.Data);
|
||||
}
|
||||
catch { /* channel completed or cancelled — expected */ }
|
||||
|
||||
received.ShouldNotContain("after-unsub");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Unsub_WithMaxMessages()
|
||||
{
|
||||
using var tcp = new TcpClient();
|
||||
await tcp.ConnectAsync("127.0.0.1", fixture.Port);
|
||||
await using var ns = tcp.GetStream();
|
||||
using var reader = new StreamReader(ns, Encoding.ASCII, leaveOpen: true);
|
||||
var writer = new StreamWriter(ns, Encoding.ASCII, leaveOpen: true) { AutoFlush = true, NewLine = "\r\n" };
|
||||
|
||||
// Read INFO
|
||||
var info = await reader.ReadLineAsync();
|
||||
info.ShouldNotBeNull();
|
||||
info.ShouldStartWith("INFO");
|
||||
|
||||
await writer.WriteLineAsync("CONNECT {\"verbose\":false,\"protocol\":1}");
|
||||
await writer.WriteLineAsync("SUB e2e.unsub.max 1");
|
||||
await writer.WriteLineAsync("UNSUB 1 3");
|
||||
await writer.WriteLineAsync("PING");
|
||||
|
||||
// Wait for PONG to know server processed commands
|
||||
string? line;
|
||||
do { line = await reader.ReadLineAsync(); } while (line != null && !line.StartsWith("PONG"));
|
||||
|
||||
for (var i = 0; i < 5; i++)
|
||||
await writer.WriteLineAsync($"PUB e2e.unsub.max 1\r\nx");
|
||||
|
||||
await writer.WriteLineAsync("PING");
|
||||
|
||||
var msgCount = 0;
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!cts.IsCancellationRequested)
|
||||
{
|
||||
line = await reader.ReadLineAsync();
|
||||
if (line == null) break;
|
||||
if (line.StartsWith("MSG")) msgCount++;
|
||||
if (line.StartsWith("PONG")) break;
|
||||
}
|
||||
|
||||
msgCount.ShouldBe(3);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task FanOut_MultipleSubscribers()
|
||||
{
|
||||
await using var pub = fixture.CreateClient();
|
||||
await using var sub1 = fixture.CreateClient();
|
||||
await using var sub2 = fixture.CreateClient();
|
||||
await using var sub3 = fixture.CreateClient();
|
||||
|
||||
await pub.ConnectAsync();
|
||||
await sub1.ConnectAsync();
|
||||
await sub2.ConnectAsync();
|
||||
await sub3.ConnectAsync();
|
||||
|
||||
await using var s1 = await sub1.SubscribeCoreAsync<string>("e2e.fanout");
|
||||
await using var s2 = await sub2.SubscribeCoreAsync<string>("e2e.fanout");
|
||||
await using var s3 = await sub3.SubscribeCoreAsync<string>("e2e.fanout");
|
||||
|
||||
await sub1.PingAsync();
|
||||
await sub2.PingAsync();
|
||||
await sub3.PingAsync();
|
||||
|
||||
await pub.PublishAsync("e2e.fanout", "broadcast");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
var m1 = await s1.Msgs.ReadAsync(cts.Token);
|
||||
var m2 = await s2.Msgs.ReadAsync(cts.Token);
|
||||
var m3 = await s3.Msgs.ReadAsync(cts.Token);
|
||||
|
||||
m1.Data.ShouldBe("broadcast");
|
||||
m2.Data.ShouldBe("broadcast");
|
||||
m3.Data.ShouldBe("broadcast");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task EchoOff_PublisherDoesNotReceiveSelf()
|
||||
{
|
||||
var opts = new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Port}",
|
||||
Echo = false,
|
||||
};
|
||||
|
||||
await using var client = new NatsConnection(opts);
|
||||
await client.ConnectAsync();
|
||||
|
||||
await using var subscription = await client.SubscribeCoreAsync<string>("e2e.echo");
|
||||
await client.PingAsync();
|
||||
|
||||
await client.PublishAsync("e2e.echo", "self");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var readTask = subscription.Msgs.ReadAsync(cts.Token).AsTask();
|
||||
var winner = await Task.WhenAny(readTask, Task.Delay(1000));
|
||||
|
||||
winner.ShouldNotBe(readTask);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task VerboseMode_OkResponses()
|
||||
{
|
||||
using var tcp = new TcpClient();
|
||||
await tcp.ConnectAsync("127.0.0.1", fixture.Port);
|
||||
await using var ns = tcp.GetStream();
|
||||
using var reader = new StreamReader(ns, Encoding.ASCII, leaveOpen: true);
|
||||
var writer = new StreamWriter(ns, Encoding.ASCII, leaveOpen: true) { AutoFlush = true, NewLine = "\r\n" };
|
||||
|
||||
// Read INFO
|
||||
var info = await reader.ReadLineAsync();
|
||||
info.ShouldNotBeNull();
|
||||
info.ShouldStartWith("INFO");
|
||||
|
||||
await writer.WriteLineAsync("CONNECT {\"verbose\":true,\"protocol\":1}");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var connectResponse = await reader.ReadLineAsync();
|
||||
connectResponse.ShouldBe("+OK");
|
||||
|
||||
await writer.WriteLineAsync("SUB test 1");
|
||||
var subResponse = await reader.ReadLineAsync();
|
||||
subResponse.ShouldBe("+OK");
|
||||
|
||||
await writer.WriteLineAsync("PING");
|
||||
var pongResponse = await reader.ReadLineAsync();
|
||||
pongResponse.ShouldBe("PONG");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task NoResponders_Returns503()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
await Should.ThrowAsync<Exception>(async () =>
|
||||
{
|
||||
await client.RequestAsync<string, string>("e2e.noresp.xxx", "ping", cancellationToken: cts.Token);
|
||||
});
|
||||
}
|
||||
}
|
||||
49
tests/NATS.E2E.Tests/Infrastructure/AccountServerFixture.cs
Normal file
49
tests/NATS.E2E.Tests/Infrastructure/AccountServerFixture.cs
Normal file
@@ -0,0 +1,49 @@
|
||||
using NATS.Client.Core;
|
||||
|
||||
namespace NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
public sealed class AccountServerFixture : IAsyncLifetime
|
||||
{
|
||||
private NatsServerProcess _server = null!;
|
||||
|
||||
public int Port => _server.Port;
|
||||
|
||||
public async Task InitializeAsync()
|
||||
{
|
||||
var config = """
|
||||
accounts {
|
||||
ACCT_A {
|
||||
users = [
|
||||
{ user: "user_a", password: "pass_a" }
|
||||
]
|
||||
}
|
||||
ACCT_B {
|
||||
users = [
|
||||
{ user: "user_b", password: "pass_b" }
|
||||
]
|
||||
}
|
||||
}
|
||||
""";
|
||||
|
||||
_server = NatsServerProcess.WithConfig(config);
|
||||
await _server.StartAsync();
|
||||
}
|
||||
|
||||
public async Task DisposeAsync()
|
||||
{
|
||||
await _server.DisposeAsync();
|
||||
}
|
||||
|
||||
public NatsConnection CreateClientA()
|
||||
{
|
||||
return new NatsConnection(new NatsOpts { Url = $"nats://user_a:pass_a@127.0.0.1:{Port}" });
|
||||
}
|
||||
|
||||
public NatsConnection CreateClientB()
|
||||
{
|
||||
return new NatsConnection(new NatsOpts { Url = $"nats://user_b:pass_b@127.0.0.1:{Port}" });
|
||||
}
|
||||
}
|
||||
|
||||
[CollectionDefinition("E2E-Accounts")]
|
||||
public class AccountsCollection : ICollectionFixture<AccountServerFixture>;
|
||||
82
tests/NATS.E2E.Tests/Infrastructure/AuthServerFixture.cs
Normal file
82
tests/NATS.E2E.Tests/Infrastructure/AuthServerFixture.cs
Normal file
@@ -0,0 +1,82 @@
|
||||
using NATS.Client.Core;
|
||||
using NATS.NKeys;
|
||||
|
||||
namespace NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
public sealed class AuthServerFixture : IAsyncLifetime
|
||||
{
|
||||
private NatsServerProcess _server = null!;
|
||||
|
||||
public string NKeyPublicKey { get; }
|
||||
public string NKeySeed { get; }
|
||||
|
||||
public int Port => _server.Port;
|
||||
|
||||
public AuthServerFixture()
|
||||
{
|
||||
var kp = KeyPair.CreatePair(PrefixByte.User);
|
||||
NKeyPublicKey = kp.GetPublicKey();
|
||||
NKeySeed = kp.GetSeed();
|
||||
}
|
||||
|
||||
public async Task InitializeAsync()
|
||||
{
|
||||
var config = $$"""
|
||||
max_payload: 512
|
||||
|
||||
authorization {
|
||||
users: [
|
||||
{ user: "testuser", password: "testpass" },
|
||||
{
|
||||
user: "pubonly",
|
||||
password: "pubpass",
|
||||
permissions: {
|
||||
publish: { allow: ["allowed.>"] },
|
||||
subscribe: { allow: ["_INBOX.>"] }
|
||||
}
|
||||
},
|
||||
{
|
||||
user: "subonly",
|
||||
password: "subpass",
|
||||
permissions: {
|
||||
subscribe: { allow: ["allowed.>", "_INBOX.>"] },
|
||||
publish: { allow: ["_INBOX.>"] }
|
||||
}
|
||||
},
|
||||
{ user: "limited", password: "limpass" },
|
||||
{ nkey: "{{NKeyPublicKey}}" }
|
||||
]
|
||||
}
|
||||
|
||||
max_subs: 5
|
||||
""";
|
||||
|
||||
_server = NatsServerProcess.WithConfig(config);
|
||||
await _server.StartAsync();
|
||||
}
|
||||
|
||||
public async Task DisposeAsync()
|
||||
{
|
||||
await _server.DisposeAsync();
|
||||
}
|
||||
|
||||
public NatsConnection CreateClient(string user, string password)
|
||||
{
|
||||
var opts = new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{Port}",
|
||||
AuthOpts = new NatsAuthOpts
|
||||
{
|
||||
Username = user,
|
||||
Password = password,
|
||||
},
|
||||
};
|
||||
return new NatsConnection(opts);
|
||||
}
|
||||
|
||||
public NatsConnection CreateClient()
|
||||
=> new(new NatsOpts { Url = $"nats://127.0.0.1:{Port}" });
|
||||
}
|
||||
|
||||
[CollectionDefinition("E2E-Auth")]
|
||||
public class AuthCollection : ICollectionFixture<AuthServerFixture>;
|
||||
4
tests/NATS.E2E.Tests/Infrastructure/Collections.cs
Normal file
4
tests/NATS.E2E.Tests/Infrastructure/Collections.cs
Normal file
@@ -0,0 +1,4 @@
|
||||
namespace NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
[CollectionDefinition("E2E")]
|
||||
public class E2ECollection : ICollectionFixture<NatsServerFixture>;
|
||||
15
tests/NATS.E2E.Tests/Infrastructure/E2ETestHelper.cs
Normal file
15
tests/NATS.E2E.Tests/Infrastructure/E2ETestHelper.cs
Normal file
@@ -0,0 +1,15 @@
|
||||
using NATS.Client.Core;
|
||||
|
||||
namespace NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
public static class E2ETestHelper
|
||||
{
|
||||
public static NatsConnection CreateClient(int port)
|
||||
=> new(new NatsOpts { Url = $"nats://127.0.0.1:{port}" });
|
||||
|
||||
public static NatsConnection CreateClient(int port, NatsOpts opts)
|
||||
=> new(opts with { Url = $"nats://127.0.0.1:{port}" });
|
||||
|
||||
public static CancellationToken Timeout(int seconds = 10)
|
||||
=> new CancellationTokenSource(TimeSpan.FromSeconds(seconds)).Token;
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
using NATS.Client.Core;
|
||||
|
||||
namespace NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
public sealed class JetStreamServerFixture : IAsyncLifetime
|
||||
{
|
||||
private NatsServerProcess _server = null!;
|
||||
private string _storeDir = null!;
|
||||
|
||||
public int Port => _server.Port;
|
||||
|
||||
public async Task InitializeAsync()
|
||||
{
|
||||
_storeDir = Path.Combine(Path.GetTempPath(), "nats-e2e-js-" + Guid.NewGuid().ToString("N")[..8]);
|
||||
Directory.CreateDirectory(_storeDir);
|
||||
|
||||
var config = $$"""
|
||||
jetstream {
|
||||
store_dir: "{{_storeDir}}"
|
||||
max_mem_store: 64mb
|
||||
max_file_store: 256mb
|
||||
}
|
||||
""";
|
||||
|
||||
_server = NatsServerProcess.WithConfig(config);
|
||||
await _server.StartAsync();
|
||||
}
|
||||
|
||||
public async Task DisposeAsync()
|
||||
{
|
||||
await _server.DisposeAsync();
|
||||
|
||||
if (_storeDir is not null && Directory.Exists(_storeDir))
|
||||
{
|
||||
try { Directory.Delete(_storeDir, recursive: true); }
|
||||
catch { /* best-effort cleanup */ }
|
||||
}
|
||||
}
|
||||
|
||||
public NatsConnection CreateClient()
|
||||
=> new(new NatsOpts { Url = $"nats://127.0.0.1:{Port}" });
|
||||
}
|
||||
|
||||
[CollectionDefinition("E2E-JetStream")]
|
||||
public class JetStreamCollection : ICollectionFixture<JetStreamServerFixture>;
|
||||
36
tests/NATS.E2E.Tests/Infrastructure/MonitorServerFixture.cs
Normal file
36
tests/NATS.E2E.Tests/Infrastructure/MonitorServerFixture.cs
Normal file
@@ -0,0 +1,36 @@
|
||||
using NATS.Client.Core;
|
||||
using System.Net.Http;
|
||||
|
||||
namespace NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
public sealed class MonitorServerFixture : IAsyncLifetime
|
||||
{
|
||||
private NatsServerProcess _server = null!;
|
||||
|
||||
public int Port => _server.Port;
|
||||
|
||||
public int MonitorPort => _server.MonitorPort!.Value;
|
||||
|
||||
public HttpClient MonitorClient { get; private set; } = null!;
|
||||
|
||||
public async Task InitializeAsync()
|
||||
{
|
||||
_server = new NatsServerProcess(enableMonitoring: true);
|
||||
await _server.StartAsync();
|
||||
MonitorClient = new HttpClient { BaseAddress = new Uri($"http://127.0.0.1:{MonitorPort}") };
|
||||
}
|
||||
|
||||
public async Task DisposeAsync()
|
||||
{
|
||||
MonitorClient?.Dispose();
|
||||
await _server.DisposeAsync();
|
||||
}
|
||||
|
||||
public NatsConnection CreateClient()
|
||||
{
|
||||
return new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{Port}" });
|
||||
}
|
||||
}
|
||||
|
||||
[CollectionDefinition("E2E-Monitor")]
|
||||
public class MonitorCollection : ICollectionFixture<MonitorServerFixture>;
|
||||
31
tests/NATS.E2E.Tests/Infrastructure/NatsServerFixture.cs
Normal file
31
tests/NATS.E2E.Tests/Infrastructure/NatsServerFixture.cs
Normal file
@@ -0,0 +1,31 @@
|
||||
using NATS.Client.Core;
|
||||
|
||||
namespace NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// xUnit fixture that manages a single NATS server process shared across a test collection.
|
||||
/// </summary>
|
||||
public sealed class NatsServerFixture : IAsyncLifetime
|
||||
{
|
||||
private NatsServerProcess _server = null!;
|
||||
|
||||
public int Port => _server.Port;
|
||||
|
||||
public string ServerOutput => _server.Output;
|
||||
|
||||
public async Task InitializeAsync()
|
||||
{
|
||||
_server = new NatsServerProcess();
|
||||
await _server.StartAsync();
|
||||
}
|
||||
|
||||
public async Task DisposeAsync()
|
||||
{
|
||||
await _server.DisposeAsync();
|
||||
}
|
||||
|
||||
public NatsConnection CreateClient()
|
||||
{
|
||||
return new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{Port}" });
|
||||
}
|
||||
}
|
||||
205
tests/NATS.E2E.Tests/Infrastructure/NatsServerProcess.cs
Normal file
205
tests/NATS.E2E.Tests/Infrastructure/NatsServerProcess.cs
Normal file
@@ -0,0 +1,205 @@
|
||||
using System.Diagnostics;
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Text;
|
||||
|
||||
namespace NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// Manages a NATS.Server.Host child process for E2E testing.
|
||||
/// Launches the server on an ephemeral port and polls TCP readiness.
|
||||
/// </summary>
|
||||
public sealed class NatsServerProcess : IAsyncDisposable
|
||||
{
|
||||
private Process? _process;
|
||||
private readonly StringBuilder _output = new();
|
||||
private readonly object _outputLock = new();
|
||||
private readonly string[]? _extraArgs;
|
||||
private readonly string? _configContent;
|
||||
private readonly bool _enableMonitoring;
|
||||
private string? _configFilePath;
|
||||
|
||||
public int Port { get; }
|
||||
|
||||
public int? MonitorPort { get; }
|
||||
|
||||
public string Output
|
||||
{
|
||||
get
|
||||
{
|
||||
lock (_outputLock)
|
||||
return _output.ToString();
|
||||
}
|
||||
}
|
||||
|
||||
public NatsServerProcess(string[]? extraArgs = null, string? configContent = null, bool enableMonitoring = false)
|
||||
{
|
||||
Port = AllocateFreePort();
|
||||
_extraArgs = extraArgs;
|
||||
_configContent = configContent;
|
||||
_enableMonitoring = enableMonitoring;
|
||||
|
||||
if (_enableMonitoring)
|
||||
MonitorPort = AllocateFreePort();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Convenience factory for creating a server with a config file.
|
||||
/// </summary>
|
||||
public static NatsServerProcess WithConfig(string configContent, bool enableMonitoring = false)
|
||||
=> new(configContent: configContent, enableMonitoring: enableMonitoring);
|
||||
|
||||
public async Task StartAsync()
|
||||
{
|
||||
var hostDll = ResolveHostDll();
|
||||
|
||||
// Write config file if provided
|
||||
if (_configContent is not null)
|
||||
{
|
||||
_configFilePath = Path.Combine(Path.GetTempPath(), $"nats-e2e-{Guid.NewGuid():N}.conf");
|
||||
await File.WriteAllTextAsync(_configFilePath, _configContent);
|
||||
}
|
||||
|
||||
// Build argument string
|
||||
var args = new StringBuilder($"exec \"{hostDll}\" -p {Port}");
|
||||
if (_configFilePath is not null)
|
||||
args.Append($" -c \"{_configFilePath}\"");
|
||||
if (_enableMonitoring && MonitorPort.HasValue)
|
||||
args.Append($" -m {MonitorPort.Value}");
|
||||
if (_extraArgs is not null)
|
||||
{
|
||||
foreach (var arg in _extraArgs)
|
||||
args.Append($" {arg}");
|
||||
}
|
||||
|
||||
var psi = new ProcessStartInfo
|
||||
{
|
||||
FileName = "dotnet",
|
||||
Arguments = args.ToString(),
|
||||
UseShellExecute = false,
|
||||
RedirectStandardOutput = true,
|
||||
RedirectStandardError = true,
|
||||
CreateNoWindow = true,
|
||||
};
|
||||
|
||||
_process = new Process { StartInfo = psi, EnableRaisingEvents = true };
|
||||
|
||||
_process.OutputDataReceived += (_, e) =>
|
||||
{
|
||||
if (e.Data is not null)
|
||||
lock (_outputLock) _output.AppendLine(e.Data);
|
||||
};
|
||||
_process.ErrorDataReceived += (_, e) =>
|
||||
{
|
||||
if (e.Data is not null)
|
||||
lock (_outputLock) _output.AppendLine(e.Data);
|
||||
};
|
||||
|
||||
_process.Start();
|
||||
_process.BeginOutputReadLine();
|
||||
_process.BeginErrorReadLine();
|
||||
|
||||
await WaitForTcpReadyAsync();
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
if (_process is not null)
|
||||
{
|
||||
if (!_process.HasExited)
|
||||
{
|
||||
_process.Kill(entireProcessTree: true);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
try
|
||||
{
|
||||
await _process.WaitForExitAsync(cts.Token);
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
// Already killed the tree above; nothing more to do
|
||||
}
|
||||
}
|
||||
|
||||
_process.Dispose();
|
||||
_process = null;
|
||||
}
|
||||
|
||||
// Clean up temp config file
|
||||
if (_configFilePath is not null && File.Exists(_configFilePath))
|
||||
{
|
||||
File.Delete(_configFilePath);
|
||||
_configFilePath = null;
|
||||
}
|
||||
}
|
||||
|
||||
private async Task WaitForTcpReadyAsync()
|
||||
{
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
while (!timeout.Token.IsCancellationRequested)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await socket.ConnectAsync(new IPEndPoint(IPAddress.Loopback, Port), timeout.Token);
|
||||
return; // Connected — server is ready
|
||||
}
|
||||
catch (SocketException)
|
||||
{
|
||||
await Task.Delay(100, timeout.Token);
|
||||
}
|
||||
}
|
||||
|
||||
throw new TimeoutException(
|
||||
$"NATS server did not become ready on port {Port} within 10s.\n\nServer output:\n{Output}");
|
||||
}
|
||||
|
||||
private static string ResolveHostDll()
|
||||
{
|
||||
// Walk up from test output directory to find solution root (contains NatsDotNet.slnx)
|
||||
var dir = new DirectoryInfo(AppContext.BaseDirectory);
|
||||
while (dir is not null)
|
||||
{
|
||||
if (File.Exists(Path.Combine(dir.FullName, "NatsDotNet.slnx")))
|
||||
{
|
||||
var dll = Path.Combine(dir.FullName, "src", "NATS.Server.Host", "bin", "Debug", "net10.0", "NATS.Server.Host.dll");
|
||||
if (File.Exists(dll))
|
||||
return dll;
|
||||
|
||||
// DLL not found — build it
|
||||
var build = Process.Start(new ProcessStartInfo
|
||||
{
|
||||
FileName = "dotnet",
|
||||
Arguments = "build src/NATS.Server.Host/NATS.Server.Host.csproj -c Debug",
|
||||
WorkingDirectory = dir.FullName,
|
||||
UseShellExecute = false,
|
||||
RedirectStandardOutput = true,
|
||||
RedirectStandardError = true,
|
||||
});
|
||||
build!.WaitForExit();
|
||||
|
||||
if (build.ExitCode != 0)
|
||||
throw new InvalidOperationException(
|
||||
$"Failed to build NATS.Server.Host:\n{build.StandardError.ReadToEnd()}");
|
||||
|
||||
if (File.Exists(dll))
|
||||
return dll;
|
||||
|
||||
throw new FileNotFoundException($"Built NATS.Server.Host but DLL not found at: {dll}");
|
||||
}
|
||||
|
||||
dir = dir.Parent;
|
||||
}
|
||||
|
||||
throw new FileNotFoundException(
|
||||
"Could not find solution root (NatsDotNet.slnx) walking up from " + AppContext.BaseDirectory);
|
||||
}
|
||||
|
||||
internal static int AllocateFreePort()
|
||||
{
|
||||
using var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
socket.Bind(new IPEndPoint(IPAddress.Loopback, 0));
|
||||
return ((IPEndPoint)socket.LocalEndPoint!).Port;
|
||||
}
|
||||
}
|
||||
111
tests/NATS.E2E.Tests/Infrastructure/TlsServerFixture.cs
Normal file
111
tests/NATS.E2E.Tests/Infrastructure/TlsServerFixture.cs
Normal file
@@ -0,0 +1,111 @@
|
||||
using System.Security.Cryptography;
|
||||
using System.Security.Cryptography.X509Certificates;
|
||||
using NATS.Client.Core;
|
||||
|
||||
namespace NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
public sealed class TlsServerFixture : IAsyncLifetime
|
||||
{
|
||||
private NatsServerProcess _server = null!;
|
||||
private string _tempDir = null!;
|
||||
|
||||
public int Port => _server.Port;
|
||||
public string CaCertPath { get; private set; } = null!;
|
||||
|
||||
public async Task InitializeAsync()
|
||||
{
|
||||
_tempDir = Path.Combine(Path.GetTempPath(), $"nats-e2e-tls-{Guid.NewGuid():N}");
|
||||
Directory.CreateDirectory(_tempDir);
|
||||
|
||||
var caCertPath = Path.Combine(_tempDir, "ca.pem");
|
||||
var serverCertPath = Path.Combine(_tempDir, "server-cert.pem");
|
||||
var serverKeyPath = Path.Combine(_tempDir, "server-key.pem");
|
||||
|
||||
GenerateCertificates(caCertPath, serverCertPath, serverKeyPath);
|
||||
|
||||
CaCertPath = caCertPath;
|
||||
|
||||
var config = $$"""
|
||||
tls {
|
||||
cert_file: "{{serverCertPath}}"
|
||||
key_file: "{{serverKeyPath}}"
|
||||
ca_file: "{{caCertPath}}"
|
||||
}
|
||||
""";
|
||||
|
||||
_server = NatsServerProcess.WithConfig(config);
|
||||
await _server.StartAsync();
|
||||
}
|
||||
|
||||
public async Task DisposeAsync()
|
||||
{
|
||||
await _server.DisposeAsync();
|
||||
|
||||
if (_tempDir is not null && Directory.Exists(_tempDir))
|
||||
Directory.Delete(_tempDir, recursive: true);
|
||||
}
|
||||
|
||||
public NatsConnection CreateTlsClient()
|
||||
{
|
||||
var opts = new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{Port}",
|
||||
TlsOpts = new NatsTlsOpts
|
||||
{
|
||||
Mode = TlsMode.Require,
|
||||
InsecureSkipVerify = true,
|
||||
},
|
||||
};
|
||||
return new NatsConnection(opts);
|
||||
}
|
||||
|
||||
public NatsConnection CreatePlainClient()
|
||||
{
|
||||
return new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{Port}" });
|
||||
}
|
||||
|
||||
private static void GenerateCertificates(string caCertPath, string serverCertPath, string serverKeyPath)
|
||||
{
|
||||
// Generate CA key and self-signed certificate
|
||||
using var caKey = RSA.Create(2048);
|
||||
var caReq = new CertificateRequest(
|
||||
"CN=E2E Test CA",
|
||||
caKey,
|
||||
HashAlgorithmName.SHA256,
|
||||
RSASignaturePadding.Pkcs1);
|
||||
caReq.CertificateExtensions.Add(
|
||||
new X509BasicConstraintsExtension(certificateAuthority: true, hasPathLengthConstraint: false, pathLengthConstraint: 0, critical: true));
|
||||
|
||||
var now = DateTimeOffset.UtcNow;
|
||||
using var caCert = caReq.CreateSelfSigned(now.AddMinutes(-5), now.AddDays(1));
|
||||
|
||||
// Generate server key and certificate signed by CA
|
||||
using var serverKey = RSA.Create(2048);
|
||||
var serverReq = new CertificateRequest(
|
||||
"CN=localhost",
|
||||
serverKey,
|
||||
HashAlgorithmName.SHA256,
|
||||
RSASignaturePadding.Pkcs1);
|
||||
|
||||
var sanBuilder = new SubjectAlternativeNameBuilder();
|
||||
sanBuilder.AddIpAddress(System.Net.IPAddress.Loopback);
|
||||
sanBuilder.AddDnsName("localhost");
|
||||
serverReq.CertificateExtensions.Add(sanBuilder.Build());
|
||||
serverReq.CertificateExtensions.Add(
|
||||
new X509BasicConstraintsExtension(certificateAuthority: false, hasPathLengthConstraint: false, pathLengthConstraint: 0, critical: false));
|
||||
|
||||
using var serverCert = serverReq.Create(caCert, now.AddMinutes(-5), now.AddDays(1), [1, 2, 3, 4]);
|
||||
|
||||
// Export CA cert to PEM
|
||||
File.WriteAllText(caCertPath, caCert.ExportCertificatePem());
|
||||
|
||||
// Export server cert to PEM
|
||||
File.WriteAllText(serverCertPath, serverCert.ExportCertificatePem());
|
||||
|
||||
// Export server private key to PEM
|
||||
File.WriteAllText(serverKeyPath, serverKey.ExportRSAPrivateKeyPem());
|
||||
}
|
||||
}
|
||||
|
||||
[CollectionDefinition("E2E-TLS")]
|
||||
public class TlsCollection : ICollectionFixture<TlsServerFixture>;
|
||||
295
tests/NATS.E2E.Tests/JetStreamTests.cs
Normal file
295
tests/NATS.E2E.Tests/JetStreamTests.cs
Normal file
@@ -0,0 +1,295 @@
|
||||
using NATS.Client.Core;
|
||||
using NATS.Client.JetStream;
|
||||
using NATS.Client.JetStream.Models;
|
||||
using NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
namespace NATS.E2E.Tests;
|
||||
|
||||
[Collection("E2E-JetStream")]
|
||||
public class JetStreamTests(JetStreamServerFixture fixture)
|
||||
{
|
||||
// -------------------------------------------------------------------------
|
||||
// Test 1 — Create a stream and verify its reported info matches config
|
||||
// -------------------------------------------------------------------------
|
||||
[Fact]
|
||||
public async Task Stream_CreateAndInfo()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
var js = new NatsJSContext(client);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
var stream = await js.CreateStreamAsync(
|
||||
new StreamConfig("E2E_CREATE", ["js.create.>"]),
|
||||
cts.Token);
|
||||
|
||||
stream.Info.Config.Name.ShouldBe("E2E_CREATE");
|
||||
stream.Info.Config.Subjects.ShouldNotBeNull();
|
||||
stream.Info.Config.Subjects.ShouldContain("js.create.>");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Test 2 — List streams and verify all created streams appear
|
||||
// -------------------------------------------------------------------------
|
||||
[Fact]
|
||||
public async Task Stream_ListAndNames()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
var js = new NatsJSContext(client);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
await js.CreateStreamAsync(new StreamConfig("E2E_LIST_A", ["js.list.a.>"]), cts.Token);
|
||||
await js.CreateStreamAsync(new StreamConfig("E2E_LIST_B", ["js.list.b.>"]), cts.Token);
|
||||
await js.CreateStreamAsync(new StreamConfig("E2E_LIST_C", ["js.list.c.>"]), cts.Token);
|
||||
|
||||
var names = new List<string>();
|
||||
await foreach (var stream in js.ListStreamsAsync(cancellationToken: cts.Token))
|
||||
{
|
||||
var name = stream.Info.Config.Name;
|
||||
if (name is not null)
|
||||
names.Add(name);
|
||||
}
|
||||
|
||||
names.ShouldContain("E2E_LIST_A");
|
||||
names.ShouldContain("E2E_LIST_B");
|
||||
names.ShouldContain("E2E_LIST_C");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Test 3 — Delete a stream and verify it is gone
|
||||
// -------------------------------------------------------------------------
|
||||
[Fact]
|
||||
public async Task Stream_Delete()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
var js = new NatsJSContext(client);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
await js.CreateStreamAsync(new StreamConfig("E2E_DEL", ["js.del.>"]), cts.Token);
|
||||
await js.DeleteStreamAsync("E2E_DEL", cts.Token);
|
||||
|
||||
await Should.ThrowAsync<NatsJSApiException>(async () =>
|
||||
await js.GetStreamAsync("E2E_DEL", cancellationToken: cts.Token));
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Test 4 — Publish messages and verify stream state reflects them
|
||||
// -------------------------------------------------------------------------
|
||||
[Fact]
|
||||
public async Task Stream_PublishAndGet()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
var js = new NatsJSContext(client);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
// Use unique stream name to avoid contamination from parallel tests
|
||||
var streamName = $"E2E_PUB_{Random.Shared.Next(100000)}";
|
||||
await js.CreateStreamAsync(new StreamConfig(streamName, [$"js.pub.{streamName}.>"]), cts.Token);
|
||||
|
||||
await js.PublishAsync($"js.pub.{streamName}.one", "msg1", cancellationToken: cts.Token);
|
||||
await js.PublishAsync($"js.pub.{streamName}.two", "msg2", cancellationToken: cts.Token);
|
||||
await js.PublishAsync($"js.pub.{streamName}.three", "msg3", cancellationToken: cts.Token);
|
||||
|
||||
var stream = await js.GetStreamAsync(streamName, cancellationToken: cts.Token);
|
||||
stream.Info.State.Messages.ShouldBe(3L);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Test 5 — Purge a stream and verify message count drops to zero
|
||||
// -------------------------------------------------------------------------
|
||||
[Fact]
|
||||
public async Task Stream_Purge()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
var js = new NatsJSContext(client);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
await js.CreateStreamAsync(new StreamConfig("E2E_PURGE", ["js.purge.>"]), cts.Token);
|
||||
|
||||
for (var i = 0; i < 5; i++)
|
||||
await js.PublishAsync($"js.purge.msg{i}", $"data{i}", cancellationToken: cts.Token);
|
||||
|
||||
var stream = await js.GetStreamAsync("E2E_PURGE", cancellationToken: cts.Token);
|
||||
await stream.PurgeAsync(new StreamPurgeRequest(), cts.Token);
|
||||
|
||||
var refreshed = await js.GetStreamAsync("E2E_PURGE", cancellationToken: cts.Token);
|
||||
refreshed.Info.State.Messages.ShouldBe(0L);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Test 6 — Create a durable pull consumer and fetch messages
|
||||
// -------------------------------------------------------------------------
|
||||
[Fact]
|
||||
public async Task Consumer_CreatePullAndConsume()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
var js = new NatsJSContext(client);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
await js.CreateStreamAsync(new StreamConfig("E2E_PULL", ["js.pull.>"]), cts.Token);
|
||||
|
||||
for (var i = 0; i < 5; i++)
|
||||
await js.PublishAsync($"js.pull.msg{i}", $"payload{i}", cancellationToken: cts.Token);
|
||||
|
||||
await js.CreateOrUpdateConsumerAsync("E2E_PULL",
|
||||
new ConsumerConfig { Name = "pull-consumer", AckPolicy = ConsumerConfigAckPolicy.Explicit },
|
||||
cts.Token);
|
||||
|
||||
var consumer = await js.GetConsumerAsync("E2E_PULL", "pull-consumer", cts.Token);
|
||||
|
||||
var received = new List<string?>();
|
||||
await foreach (var msg in consumer.FetchAsync<string>(new NatsJSFetchOpts { MaxMsgs = 5 }, cancellationToken: cts.Token))
|
||||
{
|
||||
received.Add(msg.Data);
|
||||
await msg.AckAsync(cancellationToken: cts.Token);
|
||||
}
|
||||
|
||||
received.Count.ShouldBe(5);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Test 7 — Explicit ack: fetching after ack yields no further messages
|
||||
// -------------------------------------------------------------------------
|
||||
[Fact]
|
||||
public async Task Consumer_AckExplicit()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
var js = new NatsJSContext(client);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
await js.CreateStreamAsync(new StreamConfig("E2E_ACK", ["js.ack.>"]), cts.Token);
|
||||
await js.PublishAsync("js.ack.one", "hello", cancellationToken: cts.Token);
|
||||
|
||||
await js.CreateOrUpdateConsumerAsync("E2E_ACK",
|
||||
new ConsumerConfig { Name = "ack-consumer", AckPolicy = ConsumerConfigAckPolicy.Explicit },
|
||||
cts.Token);
|
||||
|
||||
var consumer = await js.GetConsumerAsync("E2E_ACK", "ack-consumer", cts.Token);
|
||||
|
||||
// Fetch and ack the single message
|
||||
await foreach (var msg in consumer.FetchAsync<string>(new NatsJSFetchOpts { MaxMsgs = 1 }, cancellationToken: cts.Token))
|
||||
await msg.AckAsync(cancellationToken: cts.Token);
|
||||
|
||||
// Second fetch should return nothing
|
||||
var second = new List<string?>();
|
||||
await foreach (var msg in consumer.FetchAsync<string>(new NatsJSFetchOpts { MaxMsgs = 1, Expires = TimeSpan.FromSeconds(1) }, cancellationToken: cts.Token))
|
||||
second.Add(msg.Data);
|
||||
|
||||
second.Count.ShouldBe(0);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Test 8 — List consumers, delete one, verify count drops
|
||||
// -------------------------------------------------------------------------
|
||||
[Fact]
|
||||
public async Task Consumer_ListAndDelete()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
var js = new NatsJSContext(client);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
await js.CreateStreamAsync(new StreamConfig("E2E_CONS_LIST", ["js.conslist.>"]), cts.Token);
|
||||
|
||||
await js.CreateOrUpdateConsumerAsync("E2E_CONS_LIST",
|
||||
new ConsumerConfig { Name = "cons-one", AckPolicy = ConsumerConfigAckPolicy.None },
|
||||
cts.Token);
|
||||
await js.CreateOrUpdateConsumerAsync("E2E_CONS_LIST",
|
||||
new ConsumerConfig { Name = "cons-two", AckPolicy = ConsumerConfigAckPolicy.None },
|
||||
cts.Token);
|
||||
|
||||
var beforeNames = new List<string>();
|
||||
await foreach (var c in js.ListConsumersAsync("E2E_CONS_LIST", cts.Token))
|
||||
{
|
||||
var name = c.Info.Name;
|
||||
if (name is not null)
|
||||
beforeNames.Add(name);
|
||||
}
|
||||
|
||||
beforeNames.Count.ShouldBe(2);
|
||||
|
||||
await js.DeleteConsumerAsync("E2E_CONS_LIST", "cons-one", cts.Token);
|
||||
|
||||
var afterNames = new List<string>();
|
||||
await foreach (var c in js.ListConsumersAsync("E2E_CONS_LIST", cts.Token))
|
||||
{
|
||||
var name = c.Info.Name;
|
||||
if (name is not null)
|
||||
afterNames.Add(name);
|
||||
}
|
||||
|
||||
afterNames.Count.ShouldBe(1);
|
||||
afterNames.ShouldContain("cons-two");
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Test 9 — MaxMsgs retention evicts oldest messages when limit is reached
|
||||
// -------------------------------------------------------------------------
|
||||
[Fact]
|
||||
public async Task Retention_LimitsMaxMessages()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
var js = new NatsJSContext(client);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
|
||||
await js.CreateStreamAsync(
|
||||
new StreamConfig("E2E_MAXMSGS", ["js.maxmsgs.>"])
|
||||
{
|
||||
MaxMsgs = 10,
|
||||
},
|
||||
cts.Token);
|
||||
|
||||
for (var i = 0; i < 15; i++)
|
||||
await js.PublishAsync($"js.maxmsgs.{i}", $"val{i}", cancellationToken: cts.Token);
|
||||
|
||||
var stream = await js.GetStreamAsync("E2E_MAXMSGS", cancellationToken: cts.Token);
|
||||
stream.Info.State.Messages.ShouldBe(10L);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------
|
||||
// Test 10 — MaxAge retention expires messages after the configured window
|
||||
// -------------------------------------------------------------------------
|
||||
[Fact]
|
||||
public async Task Retention_MaxAge()
|
||||
{
|
||||
await using var client = fixture.CreateClient();
|
||||
await client.ConnectAsync();
|
||||
var js = new NatsJSContext(client);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
|
||||
|
||||
await js.CreateStreamAsync(
|
||||
new StreamConfig("E2E_MAXAGE", ["js.maxage.>"])
|
||||
{
|
||||
MaxAge = TimeSpan.FromSeconds(2),
|
||||
},
|
||||
cts.Token);
|
||||
|
||||
for (var i = 0; i < 5; i++)
|
||||
await js.PublishAsync($"js.maxage.{i}", $"val{i}", cancellationToken: cts.Token);
|
||||
|
||||
var before = await js.GetStreamAsync("E2E_MAXAGE", cancellationToken: cts.Token);
|
||||
before.Info.State.Messages.ShouldBe(5L);
|
||||
|
||||
await Task.Delay(3000, cts.Token);
|
||||
|
||||
var after = await js.GetStreamAsync("E2E_MAXAGE", cancellationToken: cts.Token);
|
||||
after.Info.State.Messages.ShouldBe(0L);
|
||||
}
|
||||
}
|
||||
23
tests/NATS.E2E.Tests/NATS.E2E.Tests.csproj
Normal file
23
tests/NATS.E2E.Tests/NATS.E2E.Tests.csproj
Normal file
@@ -0,0 +1,23 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
|
||||
<PropertyGroup>
|
||||
<IsPackable>false</IsPackable>
|
||||
</PropertyGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<PackageReference Include="coverlet.collector" />
|
||||
<PackageReference Include="Microsoft.NET.Test.Sdk" />
|
||||
<PackageReference Include="NATS.Client.Core" />
|
||||
<PackageReference Include="NATS.Client.JetStream" />
|
||||
<PackageReference Include="NATS.NKeys" />
|
||||
<PackageReference Include="Shouldly" />
|
||||
<PackageReference Include="xunit" />
|
||||
<PackageReference Include="xunit.runner.visualstudio" />
|
||||
</ItemGroup>
|
||||
|
||||
<ItemGroup>
|
||||
<Using Include="Xunit" />
|
||||
<Using Include="Shouldly" />
|
||||
</ItemGroup>
|
||||
|
||||
</Project>
|
||||
12
tests/NATS.E2E.Tests/SlopwatchSuppressAttribute.cs
Normal file
12
tests/NATS.E2E.Tests/SlopwatchSuppressAttribute.cs
Normal file
@@ -0,0 +1,12 @@
|
||||
// Marker attribute recognised by the slopwatch static-analysis tool.
|
||||
// Apply to a test method to suppress a specific slopwatch rule violation.
|
||||
// The justification must be 20+ characters explaining why the suppression is intentional.
|
||||
|
||||
namespace NATS.E2E.Tests;
|
||||
|
||||
[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
|
||||
public sealed class SlopwatchSuppressAttribute(string ruleId, string justification) : Attribute
|
||||
{
|
||||
public string RuleId { get; } = ruleId;
|
||||
public string Justification { get; } = justification;
|
||||
}
|
||||
58
tests/NATS.E2E.Tests/TlsTests.cs
Normal file
58
tests/NATS.E2E.Tests/TlsTests.cs
Normal file
@@ -0,0 +1,58 @@
|
||||
using NATS.Client.Core;
|
||||
using NATS.E2E.Tests.Infrastructure;
|
||||
|
||||
namespace NATS.E2E.Tests;
|
||||
|
||||
[Collection("E2E-TLS")]
|
||||
public class TlsTests(TlsServerFixture fixture)
|
||||
{
|
||||
[Fact]
|
||||
public async Task Tls_ClientConnectsSecurely()
|
||||
{
|
||||
await using var client = fixture.CreateTlsClient();
|
||||
await client.ConnectAsync();
|
||||
|
||||
await client.PingAsync();
|
||||
|
||||
client.ConnectionState.ShouldBe(NatsConnectionState.Open);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Tls_PlainTextConnection_Rejected()
|
||||
{
|
||||
await using var client = fixture.CreatePlainClient();
|
||||
|
||||
var threw = false;
|
||||
try
|
||||
{
|
||||
await client.ConnectAsync();
|
||||
await client.PingAsync();
|
||||
}
|
||||
catch (Exception)
|
||||
{
|
||||
threw = true;
|
||||
}
|
||||
|
||||
threw.ShouldBeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Tls_PubSub_WorksOverEncryptedConnection()
|
||||
{
|
||||
await using var pub = fixture.CreateTlsClient();
|
||||
await using var sub = fixture.CreateTlsClient();
|
||||
|
||||
await pub.ConnectAsync();
|
||||
await sub.ConnectAsync();
|
||||
|
||||
await using var subscription = await sub.SubscribeCoreAsync<string>("tls.pubsub.test");
|
||||
await sub.PingAsync();
|
||||
|
||||
await pub.PublishAsync("tls.pubsub.test", "secure-message");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var msg = await subscription.Msgs.ReadAsync(cts.Token);
|
||||
|
||||
msg.Data.ShouldBe("secure-message");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user