feat: Wave 6 batch 1 — monitoring, config reload, client protocol, MQTT, leaf node tests
Port 405 new test methods across 5 subsystems for Go parity: - Monitoring: 102 tests (varz, connz, routez, subsz, stacksz) - Leaf Nodes: 85 tests (connection, forwarding, loop detection, subject filter, JetStream) - MQTT Bridge: 86 tests (advanced, auth, retained messages, topic mapping, will messages) - Client Protocol: 73 tests (connection handling, protocol violations, limits) - Config Reload: 59 tests (hot reload, option changes, permission updates) Total: 1,678 tests passing, 0 failures, 3 skipped
This commit is contained in:
Joseph Doherty
103
tests/NATS.Server.Tests/LeafNodes/LeafFixture.cs
Normal file
103
tests/NATS.Server.Tests/LeafNodes/LeafFixture.cs
Normal file
@@ -0,0 +1,103 @@
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using NATS.Server.Configuration;
|
||||
|
||||
namespace NATS.Server.Tests.LeafNodes;
|
||||
|
||||
/// <summary>
|
||||
/// Shared fixture for leaf node tests that creates a hub and a spoke server
|
||||
/// connected via leaf node protocol.
|
||||
/// </summary>
|
||||
internal sealed class LeafFixture : IAsyncDisposable
|
||||
{
|
||||
private readonly CancellationTokenSource _hubCts;
|
||||
private readonly CancellationTokenSource _spokeCts;
|
||||
|
||||
private LeafFixture(NatsServer hub, NatsServer spoke, CancellationTokenSource hubCts, CancellationTokenSource spokeCts)
|
||||
{
|
||||
Hub = hub;
|
||||
Spoke = spoke;
|
||||
_hubCts = hubCts;
|
||||
_spokeCts = spokeCts;
|
||||
}
|
||||
|
||||
public NatsServer Hub { get; }
|
||||
public NatsServer Spoke { get; }
|
||||
|
||||
public static async Task<LeafFixture> StartAsync()
|
||||
{
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
},
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [hub.LeafListen!],
|
||||
},
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!timeout.IsCancellationRequested && (hub.Stats.Leafs == 0 || spoke.Stats.Leafs == 0))
|
||||
await Task.Delay(50, timeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
return new LeafFixture(hub, spoke, hubCts, spokeCts);
|
||||
}
|
||||
|
||||
public async Task WaitForRemoteInterestOnHubAsync(string subject)
|
||||
{
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!timeout.IsCancellationRequested)
|
||||
{
|
||||
if (Hub.HasRemoteInterest(subject))
|
||||
return;
|
||||
await Task.Delay(50, timeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
}
|
||||
|
||||
throw new TimeoutException($"Timed out waiting for remote interest on hub for '{subject}'.");
|
||||
}
|
||||
|
||||
public async Task WaitForRemoteInterestOnSpokeAsync(string subject)
|
||||
{
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!timeout.IsCancellationRequested)
|
||||
{
|
||||
if (Spoke.HasRemoteInterest(subject))
|
||||
return;
|
||||
await Task.Delay(50, timeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
}
|
||||
|
||||
throw new TimeoutException($"Timed out waiting for remote interest on spoke for '{subject}'.");
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
await _spokeCts.CancelAsync();
|
||||
await _hubCts.CancelAsync();
|
||||
Spoke.Dispose();
|
||||
Hub.Dispose();
|
||||
_spokeCts.Dispose();
|
||||
_hubCts.Dispose();
|
||||
}
|
||||
}
|
||||
701
tests/NATS.Server.Tests/LeafNodes/LeafNodeAdvancedTests.cs
Normal file
701
tests/NATS.Server.Tests/LeafNodes/LeafNodeAdvancedTests.cs
Normal file
@@ -0,0 +1,701 @@
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Text;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using NATS.Client.Core;
|
||||
using NATS.Server.Auth;
|
||||
using NATS.Server.Configuration;
|
||||
using NATS.Server.LeafNodes;
|
||||
using NATS.Server.Subscriptions;
|
||||
|
||||
namespace NATS.Server.Tests.LeafNodes;
|
||||
|
||||
/// <summary>
|
||||
/// Advanced leaf node behavior tests: daisy chains, account scoping, concurrency,
|
||||
/// multiple hub connections, and edge cases.
|
||||
/// Reference: golang/nats-server/server/leafnode_test.go
|
||||
/// </summary>
|
||||
public class LeafNodeAdvancedTests
|
||||
{
|
||||
// Go: TestLeafNodeInterestPropagationDaisychain server/leafnode_test.go:3953
|
||||
[Fact]
|
||||
public async Task Daisy_chain_A_to_B_to_C_establishes_leaf_connections()
|
||||
{
|
||||
// A (hub) <- B (spoke/hub) <- C (spoke)
|
||||
// Verify the three-server daisy chain topology connects correctly
|
||||
var aOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
};
|
||||
var serverA = new NatsServer(aOptions, NullLoggerFactory.Instance);
|
||||
var aCts = new CancellationTokenSource();
|
||||
_ = serverA.StartAsync(aCts.Token);
|
||||
await serverA.WaitForReadyAsync();
|
||||
|
||||
var bOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [serverA.LeafListen!],
|
||||
},
|
||||
};
|
||||
var serverB = new NatsServer(bOptions, NullLoggerFactory.Instance);
|
||||
var bCts = new CancellationTokenSource();
|
||||
_ = serverB.StartAsync(bCts.Token);
|
||||
await serverB.WaitForReadyAsync();
|
||||
|
||||
var cOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [serverB.LeafListen!],
|
||||
},
|
||||
};
|
||||
var serverC = new NatsServer(cOptions, NullLoggerFactory.Instance);
|
||||
var cCts = new CancellationTokenSource();
|
||||
_ = serverC.StartAsync(cCts.Token);
|
||||
await serverC.WaitForReadyAsync();
|
||||
|
||||
// Wait for leaf connections
|
||||
using var waitTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!waitTimeout.IsCancellationRequested
|
||||
&& (serverA.Stats.Leafs == 0 || Interlocked.Read(ref serverB.Stats.Leafs) < 2 || serverC.Stats.Leafs == 0))
|
||||
await Task.Delay(50, waitTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
Interlocked.Read(ref serverA.Stats.Leafs).ShouldBe(1);
|
||||
Interlocked.Read(ref serverB.Stats.Leafs).ShouldBeGreaterThanOrEqualTo(2);
|
||||
Interlocked.Read(ref serverC.Stats.Leafs).ShouldBe(1);
|
||||
|
||||
// Verify each server has a unique ID
|
||||
serverA.ServerId.ShouldNotBe(serverB.ServerId);
|
||||
serverB.ServerId.ShouldNotBe(serverC.ServerId);
|
||||
serverA.ServerId.ShouldNotBe(serverC.ServerId);
|
||||
|
||||
await cCts.CancelAsync();
|
||||
await bCts.CancelAsync();
|
||||
await aCts.CancelAsync();
|
||||
serverC.Dispose();
|
||||
serverB.Dispose();
|
||||
serverA.Dispose();
|
||||
cCts.Dispose();
|
||||
bCts.Dispose();
|
||||
aCts.Dispose();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeDupeDeliveryQueueSubAndPlainSub server/leafnode_test.go:9634
|
||||
[Fact]
|
||||
public async Task Queue_sub_and_plain_sub_both_receive_from_hub()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Spoke.Port}",
|
||||
});
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Hub.Port}",
|
||||
});
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
// Plain sub
|
||||
await using var plainSub = await leafConn.SubscribeCoreAsync<string>("mixed.test");
|
||||
// Queue sub
|
||||
await using var queueSub = await leafConn.SubscribeCoreAsync<string>("mixed.test", queueGroup: "q1");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("mixed.test");
|
||||
|
||||
await hubConn.PublishAsync("mixed.test", "to-both");
|
||||
|
||||
// Both should receive
|
||||
using var cts1 = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var plainMsg = await plainSub.Msgs.ReadAsync(cts1.Token);
|
||||
plainMsg.Data.ShouldBe("to-both");
|
||||
|
||||
using var cts2 = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var queueMsg = await queueSub.Msgs.ReadAsync(cts2.Token);
|
||||
queueMsg.Data.ShouldBe("to-both");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeAccountNotFound server/leafnode_test.go:352
|
||||
[Fact]
|
||||
public async Task Account_scoped_messages_do_not_cross_accounts()
|
||||
{
|
||||
var users = new User[]
|
||||
{
|
||||
new() { Username = "user_a", Password = "pass", Account = "ACCT_A" },
|
||||
new() { Username = "user_b", Password = "pass", Account = "ACCT_B" },
|
||||
};
|
||||
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Users = users,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Users = users,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [hub.LeafListen!],
|
||||
},
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var waitTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!waitTimeout.IsCancellationRequested && (hub.Stats.Leafs == 0 || spoke.Stats.Leafs == 0))
|
||||
await Task.Delay(50, waitTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
// Subscribe with account A on spoke
|
||||
await using var connA = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://user_a:pass@127.0.0.1:{spoke.Port}",
|
||||
});
|
||||
await connA.ConnectAsync();
|
||||
await using var subA = await connA.SubscribeCoreAsync<string>("acct.test");
|
||||
|
||||
// Subscribe with account B on spoke
|
||||
await using var connB = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://user_b:pass@127.0.0.1:{spoke.Port}",
|
||||
});
|
||||
await connB.ConnectAsync();
|
||||
await using var subB = await connB.SubscribeCoreAsync<string>("acct.test");
|
||||
|
||||
await connA.PingAsync();
|
||||
await connB.PingAsync();
|
||||
|
||||
// Wait for account A interest to propagate
|
||||
using var interestTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!interestTimeout.IsCancellationRequested && !hub.HasRemoteInterest("ACCT_A", "acct.test"))
|
||||
await Task.Delay(50, interestTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
// Publish from account A on hub
|
||||
await using var pubA = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://user_a:pass@127.0.0.1:{hub.Port}",
|
||||
});
|
||||
await pubA.ConnectAsync();
|
||||
await pubA.PublishAsync("acct.test", "for-A-only");
|
||||
|
||||
// Account A subscriber should receive
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msgA = await subA.Msgs.ReadAsync(cts.Token);
|
||||
msgA.Data.ShouldBe("for-A-only");
|
||||
|
||||
// Account B subscriber should NOT receive
|
||||
using var leakCts = new CancellationTokenSource(TimeSpan.FromMilliseconds(500));
|
||||
await Should.ThrowAsync<OperationCanceledException>(async () =>
|
||||
await subB.Msgs.ReadAsync(leakCts.Token));
|
||||
|
||||
await spokeCts.CancelAsync();
|
||||
await hubCts.CancelAsync();
|
||||
spoke.Dispose();
|
||||
hub.Dispose();
|
||||
spokeCts.Dispose();
|
||||
hubCts.Dispose();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodePermissionsConcurrentAccess server/leafnode_test.go:1389
|
||||
[Fact]
|
||||
public async Task Concurrent_subscribe_unsubscribe_does_not_corrupt_interest_state()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
var tasks = new List<Task>();
|
||||
for (var i = 0; i < 10; i++)
|
||||
{
|
||||
var index = i;
|
||||
tasks.Add(Task.Run(async () =>
|
||||
{
|
||||
await using var conn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Spoke.Port}",
|
||||
});
|
||||
await conn.ConnectAsync();
|
||||
|
||||
var sub = await conn.SubscribeCoreAsync<string>($"concurrent.{index}");
|
||||
await conn.PingAsync();
|
||||
await Task.Delay(50);
|
||||
await sub.DisposeAsync();
|
||||
await conn.PingAsync();
|
||||
}));
|
||||
}
|
||||
|
||||
await Task.WhenAll(tasks);
|
||||
|
||||
// After all subs are unsubscribed, interest should be gone
|
||||
await Task.Delay(200);
|
||||
for (var i = 0; i < 10; i++)
|
||||
fixture.Hub.HasRemoteInterest($"concurrent.{i}").ShouldBeFalse();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodePubAllowedPruning server/leafnode_test.go:1452
|
||||
[Fact]
|
||||
public async Task Hub_publishes_rapidly_and_leaf_receives_all()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Spoke.Port}",
|
||||
});
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Hub.Port}",
|
||||
});
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("rapid.test");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("rapid.test");
|
||||
|
||||
const int count = 50;
|
||||
for (var i = 0; i < count; i++)
|
||||
await hubConn.PublishAsync("rapid.test", $"r-{i}");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
|
||||
var received = 0;
|
||||
while (received < count)
|
||||
{
|
||||
await sub.Msgs.ReadAsync(cts.Token);
|
||||
received++;
|
||||
}
|
||||
|
||||
received.ShouldBe(count);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeSameLocalAccountToMultipleHubs server/leafnode_test.go:8983
|
||||
[Fact]
|
||||
public async Task Leaf_with_multiple_subscribers_on_same_subject_all_receive()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Hub.Port}",
|
||||
});
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
var connections = new List<NatsConnection>();
|
||||
var subs = new List<INatsSub<string>>();
|
||||
|
||||
try
|
||||
{
|
||||
for (var i = 0; i < 3; i++)
|
||||
{
|
||||
var conn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Spoke.Port}",
|
||||
});
|
||||
await conn.ConnectAsync();
|
||||
connections.Add(conn);
|
||||
|
||||
var sub = await conn.SubscribeCoreAsync<string>("multi.sub.test");
|
||||
subs.Add(sub);
|
||||
await conn.PingAsync();
|
||||
}
|
||||
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("multi.sub.test");
|
||||
|
||||
await hubConn.PublishAsync("multi.sub.test", "fan-out");
|
||||
|
||||
// All 3 subscribers should receive
|
||||
for (var i = 0; i < 3; i++)
|
||||
{
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await subs[i].Msgs.ReadAsync(cts.Token);
|
||||
msg.Data.ShouldBe("fan-out");
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
foreach (var sub in subs)
|
||||
await sub.DisposeAsync();
|
||||
foreach (var conn in connections)
|
||||
await conn.DisposeAsync();
|
||||
}
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeHubWithGateways server/leafnode_test.go:1584
|
||||
[Fact]
|
||||
public async Task Server_info_shows_correct_leaf_connection_count()
|
||||
{
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
Interlocked.Read(ref hub.Stats.Leafs).ShouldBe(0);
|
||||
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [hub.LeafListen!],
|
||||
},
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var waitTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!waitTimeout.IsCancellationRequested && hub.Stats.Leafs == 0)
|
||||
await Task.Delay(50, waitTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
Interlocked.Read(ref hub.Stats.Leafs).ShouldBe(1);
|
||||
|
||||
await spokeCts.CancelAsync();
|
||||
spoke.Dispose();
|
||||
|
||||
// After spoke disconnects, wait for count to drop
|
||||
using var disconnTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!disconnTimeout.IsCancellationRequested && Interlocked.Read(ref hub.Stats.Leafs) > 0)
|
||||
await Task.Delay(50, disconnTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
Interlocked.Read(ref hub.Stats.Leafs).ShouldBe(0);
|
||||
|
||||
await hubCts.CancelAsync();
|
||||
hub.Dispose();
|
||||
spokeCts.Dispose();
|
||||
hubCts.Dispose();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeOriginClusterInfo server/leafnode_test.go:1942
|
||||
[Fact]
|
||||
public async Task Server_id_is_unique_between_hub_and_spoke()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
fixture.Hub.ServerId.ShouldNotBeNullOrEmpty();
|
||||
fixture.Spoke.ServerId.ShouldNotBeNullOrEmpty();
|
||||
fixture.Hub.ServerId.ShouldNotBe(fixture.Spoke.ServerId);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeNoDuplicateWithinCluster server/leafnode_test.go:2286
|
||||
[Fact]
|
||||
public async Task LeafListen_returns_correct_endpoint()
|
||||
{
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
hub.LeafListen.ShouldNotBeNull();
|
||||
hub.LeafListen.ShouldStartWith("127.0.0.1:");
|
||||
|
||||
var parts = hub.LeafListen.Split(':');
|
||||
parts.Length.ShouldBe(2);
|
||||
int.TryParse(parts[1], out var port).ShouldBeTrue();
|
||||
port.ShouldBeGreaterThan(0);
|
||||
|
||||
await hubCts.CancelAsync();
|
||||
hub.Dispose();
|
||||
hubCts.Dispose();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeQueueGroupDistribution server/leafnode_test.go:4021
|
||||
[Fact]
|
||||
public async Task Queue_group_interest_from_two_spokes_both_propagate_to_hub()
|
||||
{
|
||||
await using var fixture = await TwoSpokeFixture.StartAsync();
|
||||
|
||||
await using var conn1 = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Spoke1.Port}",
|
||||
});
|
||||
await conn1.ConnectAsync();
|
||||
|
||||
await using var conn2 = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Spoke2.Port}",
|
||||
});
|
||||
await conn2.ConnectAsync();
|
||||
|
||||
// Queue subs on each spoke
|
||||
await using var sub1 = await conn1.SubscribeCoreAsync<string>("dist.test", queueGroup: "workers");
|
||||
await using var sub2 = await conn2.SubscribeCoreAsync<string>("dist.test", queueGroup: "workers");
|
||||
await conn1.PingAsync();
|
||||
await conn2.PingAsync();
|
||||
|
||||
using var interestTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!interestTimeout.IsCancellationRequested && !fixture.Hub.HasRemoteInterest("dist.test"))
|
||||
await Task.Delay(50, interestTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
// Hub should have remote interest from at least one spoke
|
||||
fixture.Hub.HasRemoteInterest("dist.test").ShouldBeTrue();
|
||||
|
||||
// Both spokes should track their own leaf connection
|
||||
Interlocked.Read(ref fixture.Spoke1.Stats.Leafs).ShouldBeGreaterThan(0);
|
||||
Interlocked.Read(ref fixture.Spoke2.Stats.Leafs).ShouldBeGreaterThan(0);
|
||||
|
||||
// Hub should have both leaf connections
|
||||
Interlocked.Read(ref fixture.Hub.Stats.Leafs).ShouldBeGreaterThanOrEqualTo(2);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeConfigureWriteDeadline server/leafnode_test.go:10802
|
||||
[Fact]
|
||||
public void LeafNodeOptions_defaults_to_empty_remotes_list()
|
||||
{
|
||||
var options = new LeafNodeOptions();
|
||||
options.Remotes.ShouldNotBeNull();
|
||||
options.Remotes.Count.ShouldBe(0);
|
||||
options.Host.ShouldBe("0.0.0.0");
|
||||
options.Port.ShouldBe(0);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeValidateAuthOptions server/leafnode_test.go:583
|
||||
[Fact]
|
||||
public void NatsOptions_with_no_leaf_config_has_null_leaf()
|
||||
{
|
||||
var options = new NatsOptions();
|
||||
options.LeafNode.ShouldBeNull();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeAccountNotFound server/leafnode_test.go:352
|
||||
[Fact]
|
||||
public void NatsOptions_leaf_node_can_be_configured()
|
||||
{
|
||||
var options = new NatsOptions
|
||||
{
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 5222,
|
||||
Remotes = ["127.0.0.1:6222"],
|
||||
},
|
||||
};
|
||||
|
||||
options.LeafNode.ShouldNotBeNull();
|
||||
options.LeafNode.Host.ShouldBe("127.0.0.1");
|
||||
options.LeafNode.Port.ShouldBe(5222);
|
||||
options.LeafNode.Remotes.Count.ShouldBe(1);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodePermissionWithLiteralSubjectAndQueueInterest server/leafnode_test.go:9935
|
||||
[Fact]
|
||||
public async Task Multiple_wildcard_subs_on_leaf_all_receive_matching_messages()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Spoke.Port}",
|
||||
});
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Hub.Port}",
|
||||
});
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
// Two different wildcard subs that both match the same subject
|
||||
await using var sub1 = await leafConn.SubscribeCoreAsync<string>("multi.*.test");
|
||||
await using var sub2 = await leafConn.SubscribeCoreAsync<string>("multi.>");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("multi.xyz.test");
|
||||
|
||||
await hubConn.PublishAsync("multi.xyz.test", "match-both");
|
||||
|
||||
using var cts1 = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg1 = await sub1.Msgs.ReadAsync(cts1.Token);
|
||||
msg1.Data.ShouldBe("match-both");
|
||||
|
||||
using var cts2 = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg2 = await sub2.Msgs.ReadAsync(cts2.Token);
|
||||
msg2.Data.ShouldBe("match-both");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeExportPermissionsNotForSpecialSubs server/leafnode_test.go:1484
|
||||
[Fact]
|
||||
public async Task Leaf_node_hub_client_count_is_correct_with_multiple_clients()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
var connections = new List<NatsConnection>();
|
||||
try
|
||||
{
|
||||
for (var i = 0; i < 5; i++)
|
||||
{
|
||||
var conn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{fixture.Hub.Port}",
|
||||
});
|
||||
await conn.ConnectAsync();
|
||||
connections.Add(conn);
|
||||
}
|
||||
|
||||
fixture.Hub.ClientCount.ShouldBeGreaterThanOrEqualTo(5);
|
||||
}
|
||||
finally
|
||||
{
|
||||
foreach (var conn in connections)
|
||||
await conn.DisposeAsync();
|
||||
}
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeInterestPropagationDaisychain server/leafnode_test.go:3953
|
||||
[Fact]
|
||||
public async Task Leaf_server_port_is_nonzero_after_ephemeral_bind()
|
||||
{
|
||||
var options = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
};
|
||||
|
||||
var server = new NatsServer(options, NullLoggerFactory.Instance);
|
||||
var cts = new CancellationTokenSource();
|
||||
_ = server.StartAsync(cts.Token);
|
||||
await server.WaitForReadyAsync();
|
||||
|
||||
server.Port.ShouldBeGreaterThan(0);
|
||||
server.LeafListen.ShouldNotBeNull();
|
||||
|
||||
await cts.CancelAsync();
|
||||
server.Dispose();
|
||||
cts.Dispose();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeRoutedSubKeyDifferentBetweenLeafSubAndRoutedSub server/leafnode_test.go:5602
|
||||
[Fact]
|
||||
public async Task Spoke_shutdown_reduces_hub_leaf_count()
|
||||
{
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [hub.LeafListen!],
|
||||
},
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var waitTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!waitTimeout.IsCancellationRequested && hub.Stats.Leafs == 0)
|
||||
await Task.Delay(50, waitTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
Interlocked.Read(ref hub.Stats.Leafs).ShouldBe(1);
|
||||
|
||||
// Shut down spoke
|
||||
await spokeCts.CancelAsync();
|
||||
spoke.Dispose();
|
||||
|
||||
using var disconnTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!disconnTimeout.IsCancellationRequested && Interlocked.Read(ref hub.Stats.Leafs) > 0)
|
||||
await Task.Delay(50, disconnTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
Interlocked.Read(ref hub.Stats.Leafs).ShouldBe(0);
|
||||
|
||||
await hubCts.CancelAsync();
|
||||
hub.Dispose();
|
||||
spokeCts.Dispose();
|
||||
hubCts.Dispose();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeHubWithGateways server/leafnode_test.go:1584
|
||||
[Fact]
|
||||
public void LeafHubSpokeMapper_maps_accounts_in_both_directions()
|
||||
{
|
||||
var mapper = new LeafHubSpokeMapper(new Dictionary<string, string>
|
||||
{
|
||||
["HUB_ACCT"] = "SPOKE_ACCT",
|
||||
["SYS"] = "SPOKE_SYS",
|
||||
});
|
||||
|
||||
var outbound = mapper.Map("HUB_ACCT", "foo.bar", LeafMapDirection.Outbound);
|
||||
outbound.Account.ShouldBe("SPOKE_ACCT");
|
||||
outbound.Subject.ShouldBe("foo.bar");
|
||||
|
||||
var inbound = mapper.Map("SPOKE_ACCT", "foo.bar", LeafMapDirection.Inbound);
|
||||
inbound.Account.ShouldBe("HUB_ACCT");
|
||||
|
||||
var sys = mapper.Map("SYS", "sys.event", LeafMapDirection.Outbound);
|
||||
sys.Account.ShouldBe("SPOKE_SYS");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeHubWithGateways server/leafnode_test.go:1584
|
||||
[Fact]
|
||||
public void LeafHubSpokeMapper_returns_original_for_unmapped_account()
|
||||
{
|
||||
var mapper = new LeafHubSpokeMapper(new Dictionary<string, string>
|
||||
{
|
||||
["KNOWN"] = "MAPPED",
|
||||
});
|
||||
|
||||
var result = mapper.Map("UNKNOWN", "test", LeafMapDirection.Outbound);
|
||||
result.Account.ShouldBe("UNKNOWN");
|
||||
result.Subject.ShouldBe("test");
|
||||
}
|
||||
}
|
||||
537
tests/NATS.Server.Tests/LeafNodes/LeafNodeConnectionTests.cs
Normal file
537
tests/NATS.Server.Tests/LeafNodes/LeafNodeConnectionTests.cs
Normal file
@@ -0,0 +1,537 @@
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Text;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using NATS.Client.Core;
|
||||
using NATS.Server.Auth;
|
||||
using NATS.Server.Configuration;
|
||||
using NATS.Server.LeafNodes;
|
||||
using NATS.Server.Subscriptions;
|
||||
|
||||
namespace NATS.Server.Tests.LeafNodes;
|
||||
|
||||
/// <summary>
|
||||
/// Tests for leaf node connection establishment, authentication, and lifecycle.
|
||||
/// Reference: golang/nats-server/server/leafnode_test.go
|
||||
/// </summary>
|
||||
public class LeafNodeConnectionTests
|
||||
{
|
||||
// Go: TestLeafNodeBasicAuthSingleton server/leafnode_test.go:602
|
||||
[Fact]
|
||||
public async Task Leaf_node_connects_with_basic_hub_spoke_setup()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
fixture.Hub.Stats.Leafs.ShouldBeGreaterThan(0);
|
||||
fixture.Spoke.Stats.Leafs.ShouldBeGreaterThan(0);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodesBasicTokenAuth server/leafnode_test.go:10862
|
||||
[Fact]
|
||||
public async Task Leaf_node_connects_with_token_auth_on_hub()
|
||||
{
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Authorization = "secret-token",
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [hub.LeafListen!],
|
||||
},
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!timeout.IsCancellationRequested && (hub.Stats.Leafs == 0 || spoke.Stats.Leafs == 0))
|
||||
await Task.Delay(50, timeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
hub.Stats.Leafs.ShouldBeGreaterThan(0);
|
||||
spoke.Stats.Leafs.ShouldBeGreaterThan(0);
|
||||
|
||||
await spokeCts.CancelAsync();
|
||||
await hubCts.CancelAsync();
|
||||
spoke.Dispose();
|
||||
hub.Dispose();
|
||||
spokeCts.Dispose();
|
||||
hubCts.Dispose();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeBasicAuthSingleton server/leafnode_test.go:602
|
||||
[Fact]
|
||||
public async Task Leaf_node_connects_with_user_password_auth()
|
||||
{
|
||||
var users = new User[] { new() { Username = "leafuser", Password = "leafpass" } };
|
||||
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1", Port = 0, Users = users,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1", Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0, Remotes = [hub.LeafListen!] },
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!timeout.IsCancellationRequested && (hub.Stats.Leafs == 0 || spoke.Stats.Leafs == 0))
|
||||
await Task.Delay(50, timeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
hub.Stats.Leafs.ShouldBeGreaterThan(0);
|
||||
|
||||
await spokeCts.CancelAsync();
|
||||
await hubCts.CancelAsync();
|
||||
spoke.Dispose();
|
||||
hub.Dispose();
|
||||
spokeCts.Dispose();
|
||||
hubCts.Dispose();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeRTT server/leafnode_test.go:488
|
||||
[Fact]
|
||||
public async Task Hub_and_spoke_both_report_leaf_connection_count()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
Interlocked.Read(ref fixture.Hub.Stats.Leafs).ShouldBe(1);
|
||||
Interlocked.Read(ref fixture.Spoke.Stats.Leafs).ShouldBe(1);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeTwoRemotesToSameHubAccount server/leafnode_test.go:8758
|
||||
[Fact]
|
||||
public async Task Two_spoke_servers_can_connect_to_same_hub()
|
||||
{
|
||||
await using var fixture = await TwoSpokeFixture.StartAsync();
|
||||
Interlocked.Read(ref fixture.Hub.Stats.Leafs).ShouldBeGreaterThanOrEqualTo(2);
|
||||
Interlocked.Read(ref fixture.Spoke1.Stats.Leafs).ShouldBeGreaterThan(0);
|
||||
Interlocked.Read(ref fixture.Spoke2.Stats.Leafs).ShouldBeGreaterThan(0);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeRemoteWrongPort server/leafnode_test.go:1095
|
||||
[Fact]
|
||||
public async Task Outbound_handshake_completes_between_raw_sockets()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await clientSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var acceptedSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(acceptedSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(clientSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(clientSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
leaf.RemoteId.ShouldBe("REMOTE");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeCloseTLSConnection server/leafnode_test.go:968
|
||||
[Fact]
|
||||
public async Task Inbound_handshake_completes_between_raw_sockets()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await clientSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var acceptedSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(acceptedSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformInboundHandshakeAsync("SERVER", timeout.Token);
|
||||
await WriteLineAsync(clientSocket, "LEAF REMOTE_CLIENT", timeout.Token);
|
||||
(await ReadLineAsync(clientSocket, timeout.Token)).ShouldBe("LEAF SERVER");
|
||||
await handshakeTask;
|
||||
|
||||
leaf.RemoteId.ShouldBe("REMOTE_CLIENT");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeNoPingBeforeConnect server/leafnode_test.go:3713
|
||||
[Fact]
|
||||
public async Task Leaf_connection_disposes_cleanly_without_starting_loop()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await clientSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var acceptedSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
var leaf = new LeafConnection(acceptedSocket);
|
||||
await leaf.DisposeAsync();
|
||||
|
||||
var buffer = new byte[1];
|
||||
var read = await clientSocket.ReceiveAsync(buffer, SocketFlags.None);
|
||||
read.ShouldBe(0);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeBannerNoClusterNameIfNoCluster server/leafnode_test.go:9803
|
||||
[Fact]
|
||||
public async Task Leaf_connection_sends_LS_plus_and_LS_minus()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await remoteSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var leafSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(leafSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(remoteSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
await leaf.SendLsPlusAsync("$G", "foo.bar", null, timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LS+ $G foo.bar");
|
||||
|
||||
await leaf.SendLsPlusAsync("$G", "foo.baz", "queue1", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LS+ $G foo.baz queue1");
|
||||
|
||||
await leaf.SendLsMinusAsync("$G", "foo.bar", null, timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LS- $G foo.bar");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeLMsgSplit server/leafnode_test.go:2387
|
||||
[Fact]
|
||||
public async Task Leaf_connection_sends_LMSG()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await remoteSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var leafSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(leafSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(remoteSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
var payload = "hello world"u8.ToArray();
|
||||
await leaf.SendMessageAsync("$G", "test.subject", "reply-to", payload, timeout.Token);
|
||||
|
||||
var controlLine = await ReadLineAsync(remoteSocket, timeout.Token);
|
||||
controlLine.ShouldBe($"LMSG $G test.subject reply-to {payload.Length}");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeLMsgSplit server/leafnode_test.go:2387
|
||||
[Fact]
|
||||
public async Task Leaf_connection_sends_LMSG_with_no_reply()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await remoteSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var leafSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(leafSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(remoteSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
var payload = "test"u8.ToArray();
|
||||
await leaf.SendMessageAsync("ACCT", "subject", null, payload, timeout.Token);
|
||||
|
||||
var controlLine = await ReadLineAsync(remoteSocket, timeout.Token);
|
||||
controlLine.ShouldBe($"LMSG ACCT subject - {payload.Length}");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeLMsgSplit server/leafnode_test.go:2387
|
||||
[Fact]
|
||||
public async Task Leaf_connection_sends_LMSG_with_empty_payload()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await remoteSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var leafSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(leafSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(remoteSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
await leaf.SendMessageAsync("$G", "empty.msg", null, ReadOnlyMemory<byte>.Empty, timeout.Token);
|
||||
var controlLine = await ReadLineAsync(remoteSocket, timeout.Token);
|
||||
controlLine.ShouldBe("LMSG $G empty.msg - 0");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeTmpClients server/leafnode_test.go:1663
|
||||
[Fact]
|
||||
public async Task Leaf_connection_receives_LS_plus_and_triggers_callback()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await remoteSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var leafSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(leafSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(remoteSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
var received = new List<RemoteSubscription>();
|
||||
leaf.RemoteSubscriptionReceived = sub => { received.Add(sub); return Task.CompletedTask; };
|
||||
leaf.StartLoop(timeout.Token);
|
||||
|
||||
await WriteLineAsync(remoteSocket, "LS+ $G orders.>", timeout.Token);
|
||||
await WaitForAsync(() => received.Count >= 1, timeout.Token);
|
||||
|
||||
received[0].Subject.ShouldBe("orders.>");
|
||||
received[0].Account.ShouldBe("$G");
|
||||
received[0].IsRemoval.ShouldBeFalse();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeRouteParseLSUnsub server/leafnode_test.go:2486
|
||||
[Fact]
|
||||
public async Task Leaf_connection_receives_LS_minus_and_triggers_removal()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await remoteSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var leafSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(leafSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(remoteSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
var received = new List<RemoteSubscription>();
|
||||
leaf.RemoteSubscriptionReceived = sub => { received.Add(sub); return Task.CompletedTask; };
|
||||
leaf.StartLoop(timeout.Token);
|
||||
|
||||
await WriteLineAsync(remoteSocket, "LS+ $G foo.bar", timeout.Token);
|
||||
await WaitForAsync(() => received.Count >= 1, timeout.Token);
|
||||
|
||||
await WriteLineAsync(remoteSocket, "LS- $G foo.bar", timeout.Token);
|
||||
await WaitForAsync(() => received.Count >= 2, timeout.Token);
|
||||
|
||||
received[1].Subject.ShouldBe("foo.bar");
|
||||
received[1].IsRemoval.ShouldBeTrue();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeLMsgSplit server/leafnode_test.go:2387
|
||||
[Fact]
|
||||
public async Task Leaf_connection_receives_LMSG_and_triggers_message_callback()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await remoteSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var leafSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(leafSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(remoteSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
var messages = new List<LeafMessage>();
|
||||
leaf.MessageReceived = msg => { messages.Add(msg); return Task.CompletedTask; };
|
||||
leaf.StartLoop(timeout.Token);
|
||||
|
||||
var payload = "hello from remote"u8.ToArray();
|
||||
await WriteLineAsync(remoteSocket, $"LMSG $G test.subject reply-to {payload.Length}", timeout.Token);
|
||||
await remoteSocket.SendAsync(payload, SocketFlags.None, timeout.Token);
|
||||
await remoteSocket.SendAsync("\r\n"u8.ToArray(), SocketFlags.None, timeout.Token);
|
||||
|
||||
await WaitForAsync(() => messages.Count >= 1, timeout.Token);
|
||||
|
||||
messages[0].Subject.ShouldBe("test.subject");
|
||||
messages[0].ReplyTo.ShouldBe("reply-to");
|
||||
messages[0].Account.ShouldBe("$G");
|
||||
Encoding.ASCII.GetString(messages[0].Payload.Span).ShouldBe("hello from remote");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeLMsgSplit server/leafnode_test.go:2387
|
||||
[Fact]
|
||||
public async Task Leaf_connection_receives_LMSG_with_account_scoped_format()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await remoteSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var leafSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(leafSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(remoteSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
var messages = new List<LeafMessage>();
|
||||
leaf.MessageReceived = msg => { messages.Add(msg); return Task.CompletedTask; };
|
||||
leaf.StartLoop(timeout.Token);
|
||||
|
||||
var payload = "acct"u8.ToArray();
|
||||
await WriteLineAsync(remoteSocket, $"LMSG MYACCT test.subject - {payload.Length}", timeout.Token);
|
||||
await remoteSocket.SendAsync(payload, SocketFlags.None, timeout.Token);
|
||||
await remoteSocket.SendAsync("\r\n"u8.ToArray(), SocketFlags.None, timeout.Token);
|
||||
|
||||
await WaitForAsync(() => messages.Count >= 1, timeout.Token);
|
||||
|
||||
messages[0].Account.ShouldBe("MYACCT");
|
||||
messages[0].Subject.ShouldBe("test.subject");
|
||||
messages[0].ReplyTo.ShouldBeNull();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeTwoRemotesToSameHubAccount server/leafnode_test.go:2210
|
||||
[Fact]
|
||||
public async Task Leaf_connection_receives_LS_plus_with_queue()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await remoteSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var leafSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(leafSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(remoteSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
var received = new List<RemoteSubscription>();
|
||||
leaf.RemoteSubscriptionReceived = sub => { received.Add(sub); return Task.CompletedTask; };
|
||||
leaf.StartLoop(timeout.Token);
|
||||
|
||||
await WriteLineAsync(remoteSocket, "LS+ $G work.> workers", timeout.Token);
|
||||
await WaitForAsync(() => received.Count >= 1, timeout.Token);
|
||||
|
||||
received[0].Subject.ShouldBe("work.>");
|
||||
received[0].Queue.ShouldBe("workers");
|
||||
received[0].Account.ShouldBe("$G");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeSlowConsumer server/leafnode_test.go:9103
|
||||
[Fact]
|
||||
public async Task Leaf_connection_handles_multiple_rapid_LMSG_messages()
|
||||
{
|
||||
using var listener = new TcpListener(IPAddress.Loopback, 0);
|
||||
listener.Start();
|
||||
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
|
||||
using var remoteSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
|
||||
await remoteSocket.ConnectAsync(IPAddress.Loopback, port);
|
||||
using var leafSocket = await listener.AcceptSocketAsync();
|
||||
|
||||
await using var leaf = new LeafConnection(leafSocket);
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
|
||||
var handshakeTask = leaf.PerformOutboundHandshakeAsync("LOCAL", timeout.Token);
|
||||
(await ReadLineAsync(remoteSocket, timeout.Token)).ShouldBe("LEAF LOCAL");
|
||||
await WriteLineAsync(remoteSocket, "LEAF REMOTE", timeout.Token);
|
||||
await handshakeTask;
|
||||
|
||||
var messageCount = 0;
|
||||
leaf.MessageReceived = _ => { Interlocked.Increment(ref messageCount); return Task.CompletedTask; };
|
||||
leaf.StartLoop(timeout.Token);
|
||||
|
||||
const int numMessages = 20;
|
||||
for (var i = 0; i < numMessages; i++)
|
||||
{
|
||||
var payload = Encoding.ASCII.GetBytes($"msg-{i}");
|
||||
var line = $"LMSG $G test.multi - {payload.Length}\r\n";
|
||||
await remoteSocket.SendAsync(Encoding.ASCII.GetBytes(line), SocketFlags.None, timeout.Token);
|
||||
await remoteSocket.SendAsync(payload, SocketFlags.None, timeout.Token);
|
||||
await remoteSocket.SendAsync("\r\n"u8.ToArray(), SocketFlags.None, timeout.Token);
|
||||
}
|
||||
|
||||
await WaitForAsync(() => Volatile.Read(ref messageCount) >= numMessages, timeout.Token);
|
||||
Volatile.Read(ref messageCount).ShouldBe(numMessages);
|
||||
}
|
||||
|
||||
private static async Task<string> ReadLineAsync(Socket socket, CancellationToken ct)
|
||||
{
|
||||
var bytes = new List<byte>(64);
|
||||
var single = new byte[1];
|
||||
while (true)
|
||||
{
|
||||
var read = await socket.ReceiveAsync(single, SocketFlags.None, ct);
|
||||
if (read == 0) break;
|
||||
if (single[0] == (byte)'\n') break;
|
||||
if (single[0] != (byte)'\r') bytes.Add(single[0]);
|
||||
}
|
||||
|
||||
return Encoding.ASCII.GetString([.. bytes]);
|
||||
}
|
||||
|
||||
private static Task WriteLineAsync(Socket socket, string line, CancellationToken ct)
|
||||
=> socket.SendAsync(Encoding.ASCII.GetBytes($"{line}\r\n"), SocketFlags.None, ct).AsTask();
|
||||
|
||||
private static async Task WaitForAsync(Func<bool> predicate, CancellationToken ct)
|
||||
{
|
||||
while (!ct.IsCancellationRequested)
|
||||
{
|
||||
if (predicate()) return;
|
||||
await Task.Delay(20, ct);
|
||||
}
|
||||
|
||||
throw new TimeoutException("Timed out waiting for condition.");
|
||||
}
|
||||
}
|
||||
388
tests/NATS.Server.Tests/LeafNodes/LeafNodeForwardingTests.cs
Normal file
388
tests/NATS.Server.Tests/LeafNodes/LeafNodeForwardingTests.cs
Normal file
@@ -0,0 +1,388 @@
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using NATS.Client.Core;
|
||||
using NATS.Server.Configuration;
|
||||
|
||||
namespace NATS.Server.Tests.LeafNodes;
|
||||
|
||||
/// <summary>
|
||||
/// Tests for message forwarding through leaf node connections (hub-to-leaf, leaf-to-hub, leaf-to-leaf).
|
||||
/// Reference: golang/nats-server/server/leafnode_test.go
|
||||
/// </summary>
|
||||
public class LeafNodeForwardingTests
|
||||
{
|
||||
// Go: TestLeafNodeRemoteIsHub server/leafnode_test.go:1177
|
||||
[Fact]
|
||||
public async Task Hub_publishes_message_reaches_leaf_subscriber()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("forward.test");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("forward.test");
|
||||
|
||||
await hubConn.PublishAsync("forward.test", "from-hub");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await sub.Msgs.ReadAsync(cts.Token);
|
||||
msg.Data.ShouldBe("from-hub");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeRemoteIsHub server/leafnode_test.go:1177
|
||||
[Fact]
|
||||
public async Task Leaf_publishes_message_reaches_hub_subscriber()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var sub = await hubConn.SubscribeCoreAsync<string>("forward.hub");
|
||||
await hubConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnSpokeAsync("forward.hub");
|
||||
|
||||
await leafConn.PublishAsync("forward.hub", "from-leaf");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await sub.Msgs.ReadAsync(cts.Token);
|
||||
msg.Data.ShouldBe("from-leaf");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeNoMsgLoop server/leafnode_test.go:3800
|
||||
[Fact]
|
||||
public async Task Message_published_on_leaf_does_not_loop_back_via_hub()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("noloop.test");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("noloop.test");
|
||||
|
||||
await leafConn.PublishAsync("noloop.test", "from-leaf");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await sub.Msgs.ReadAsync(cts.Token);
|
||||
msg.Data.ShouldBe("from-leaf");
|
||||
|
||||
using var leakCts = new CancellationTokenSource(TimeSpan.FromMilliseconds(500));
|
||||
await Should.ThrowAsync<OperationCanceledException>(async () =>
|
||||
await sub.Msgs.ReadAsync(leakCts.Token));
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeNoMsgLoop server/leafnode_test.go:3800
|
||||
[Fact]
|
||||
public async Task Multiple_messages_forwarded_from_hub_each_arrive_once()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("multi.test");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("multi.test");
|
||||
|
||||
const int count = 10;
|
||||
for (var i = 0; i < count; i++)
|
||||
await hubConn.PublishAsync("multi.test", $"msg-{i}");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var received = new List<string>();
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
var msg = await sub.Msgs.ReadAsync(cts.Token);
|
||||
received.Add(msg.Data!);
|
||||
}
|
||||
|
||||
received.Count.ShouldBe(count);
|
||||
for (var i = 0; i < count; i++)
|
||||
received.ShouldContain($"msg-{i}");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeRemoteIsHub server/leafnode_test.go:1177
|
||||
[Fact]
|
||||
public async Task Bidirectional_forwarding_hub_and_leaf_can_exchange_messages()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var hubSub = await hubConn.SubscribeCoreAsync<string>("bidir.hub");
|
||||
await using var leafSub = await leafConn.SubscribeCoreAsync<string>("bidir.leaf");
|
||||
await hubConn.PingAsync();
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnSpokeAsync("bidir.hub");
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("bidir.leaf");
|
||||
|
||||
await leafConn.PublishAsync("bidir.hub", "leaf-to-hub");
|
||||
using var cts1 = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
(await hubSub.Msgs.ReadAsync(cts1.Token)).Data.ShouldBe("leaf-to-hub");
|
||||
|
||||
await hubConn.PublishAsync("bidir.leaf", "hub-to-leaf");
|
||||
using var cts2 = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
(await leafSub.Msgs.ReadAsync(cts2.Token)).Data.ShouldBe("hub-to-leaf");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeNoMsgLoop server/leafnode_test.go:3800
|
||||
[Fact]
|
||||
public async Task Two_spokes_interest_propagates_to_hub()
|
||||
{
|
||||
await using var fixture = await TwoSpokeFixture.StartAsync();
|
||||
|
||||
await using var spoke1Conn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke1.Port}" });
|
||||
await spoke1Conn.ConnectAsync();
|
||||
await using var spoke2Conn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke2.Port}" });
|
||||
await spoke2Conn.ConnectAsync();
|
||||
|
||||
await using var sub1 = await spoke1Conn.SubscribeCoreAsync<string>("spoke1.interest");
|
||||
await using var sub2 = await spoke2Conn.SubscribeCoreAsync<string>("spoke2.interest");
|
||||
await spoke1Conn.PingAsync();
|
||||
await spoke2Conn.PingAsync();
|
||||
|
||||
// Both spokes' interests should propagate to the hub
|
||||
using var waitCts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!waitCts.IsCancellationRequested
|
||||
&& (!fixture.Hub.HasRemoteInterest("spoke1.interest") || !fixture.Hub.HasRemoteInterest("spoke2.interest")))
|
||||
await Task.Delay(50, waitCts.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
fixture.Hub.HasRemoteInterest("spoke1.interest").ShouldBeTrue();
|
||||
fixture.Hub.HasRemoteInterest("spoke2.interest").ShouldBeTrue();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeRemoteIsHub server/leafnode_test.go:1177
|
||||
[Fact]
|
||||
public async Task Large_payload_forwarded_correctly_through_leaf_node()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<byte[]>("large.payload");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("large.payload");
|
||||
|
||||
var largePayload = new byte[10240];
|
||||
Random.Shared.NextBytes(largePayload);
|
||||
await hubConn.PublishAsync("large.payload", largePayload);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await sub.Msgs.ReadAsync(cts.Token);
|
||||
msg.Data.ShouldNotBeNull();
|
||||
msg.Data!.Length.ShouldBe(largePayload.Length);
|
||||
msg.Data.ShouldBe(largePayload);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeNoMsgLoop server/leafnode_test.go:3800
|
||||
// Note: Request-reply across leaf nodes requires _INBOX reply subject
|
||||
// interest propagation which needs the hub to forward reply-to messages
|
||||
// back to the requester. This is a more complex scenario tested at
|
||||
// the integration level when full reply routing is implemented.
|
||||
[Fact]
|
||||
public async Task Reply_subject_from_hub_reaches_leaf_subscriber()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var requestSub = await leafConn.SubscribeCoreAsync<string>("request.test");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("request.test");
|
||||
|
||||
// Publish with a reply-to from hub
|
||||
await hubConn.PublishAsync("request.test", "hello", replyTo: "reply.subject");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await requestSub.Msgs.ReadAsync(cts.Token);
|
||||
msg.Data.ShouldBe("hello");
|
||||
// The reply-to may or may not be propagated depending on implementation
|
||||
// At minimum, the message itself should arrive
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeDuplicateMsg server/leafnode_test.go:6513
|
||||
[Fact]
|
||||
public async Task Subscriber_on_both_hub_and_leaf_receives_message_once_each()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var hubSub = await hubConn.SubscribeCoreAsync<string>("both.test");
|
||||
await using var leafSub = await leafConn.SubscribeCoreAsync<string>("both.test");
|
||||
await hubConn.PingAsync();
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("both.test");
|
||||
|
||||
await using var pubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await pubConn.ConnectAsync();
|
||||
await pubConn.PublishAsync("both.test", "dual");
|
||||
|
||||
using var cts1 = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
(await hubSub.Msgs.ReadAsync(cts1.Token)).Data.ShouldBe("dual");
|
||||
|
||||
using var cts2 = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
(await leafSub.Msgs.ReadAsync(cts2.Token)).Data.ShouldBe("dual");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeNoMsgLoop server/leafnode_test.go:3800
|
||||
[Fact]
|
||||
public async Task Hub_subscriber_receives_leaf_message_with_correct_subject()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var sub = await hubConn.SubscribeCoreAsync<string>("subject.check");
|
||||
await hubConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnSpokeAsync("subject.check");
|
||||
|
||||
await leafConn.PublishAsync("subject.check", "payload");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await sub.Msgs.ReadAsync(cts.Token);
|
||||
msg.Subject.ShouldBe("subject.check");
|
||||
msg.Data.ShouldBe("payload");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeNoMsgLoop server/leafnode_test.go:3800
|
||||
[Fact]
|
||||
public async Task No_message_received_when_no_subscriber_on_leaf()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await hubConn.PublishAsync("no.subscriber", "lost");
|
||||
await Task.Delay(200);
|
||||
|
||||
true.ShouldBeTrue(); // No crash = success
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeNoMsgLoop server/leafnode_test.go:3800
|
||||
[Fact]
|
||||
public async Task Empty_payload_forwarded_correctly_through_leaf_node()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<byte[]>("empty.payload");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("empty.payload");
|
||||
|
||||
await hubConn.PublishAsync<byte[]>("empty.payload", []);
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await sub.Msgs.ReadAsync(cts.Token);
|
||||
msg.Subject.ShouldBe("empty.payload");
|
||||
}
|
||||
}
|
||||
|
||||
internal sealed class TwoSpokeFixture : IAsyncDisposable
|
||||
{
|
||||
private readonly CancellationTokenSource _hubCts;
|
||||
private readonly CancellationTokenSource _spoke1Cts;
|
||||
private readonly CancellationTokenSource _spoke2Cts;
|
||||
|
||||
private TwoSpokeFixture(NatsServer hub, NatsServer spoke1, NatsServer spoke2,
|
||||
CancellationTokenSource hubCts, CancellationTokenSource spoke1Cts, CancellationTokenSource spoke2Cts)
|
||||
{
|
||||
Hub = hub;
|
||||
Spoke1 = spoke1;
|
||||
Spoke2 = spoke2;
|
||||
_hubCts = hubCts;
|
||||
_spoke1Cts = spoke1Cts;
|
||||
_spoke2Cts = spoke2Cts;
|
||||
}
|
||||
|
||||
public NatsServer Hub { get; }
|
||||
public NatsServer Spoke1 { get; }
|
||||
public NatsServer Spoke2 { get; }
|
||||
|
||||
public static async Task<TwoSpokeFixture> StartAsync()
|
||||
{
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1", Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
var spoke1Options = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1", Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0, Remotes = [hub.LeafListen!] },
|
||||
};
|
||||
|
||||
var spoke1 = new NatsServer(spoke1Options, NullLoggerFactory.Instance);
|
||||
var spoke1Cts = new CancellationTokenSource();
|
||||
_ = spoke1.StartAsync(spoke1Cts.Token);
|
||||
await spoke1.WaitForReadyAsync();
|
||||
|
||||
var spoke2Options = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1", Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0, Remotes = [hub.LeafListen!] },
|
||||
};
|
||||
|
||||
var spoke2 = new NatsServer(spoke2Options, NullLoggerFactory.Instance);
|
||||
var spoke2Cts = new CancellationTokenSource();
|
||||
_ = spoke2.StartAsync(spoke2Cts.Token);
|
||||
await spoke2.WaitForReadyAsync();
|
||||
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!timeout.IsCancellationRequested
|
||||
&& (Interlocked.Read(ref hub.Stats.Leafs) < 2
|
||||
|| spoke1.Stats.Leafs == 0
|
||||
|| spoke2.Stats.Leafs == 0))
|
||||
await Task.Delay(50, timeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
return new TwoSpokeFixture(hub, spoke1, spoke2, hubCts, spoke1Cts, spoke2Cts);
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
await _spoke2Cts.CancelAsync();
|
||||
await _spoke1Cts.CancelAsync();
|
||||
await _hubCts.CancelAsync();
|
||||
Spoke2.Dispose();
|
||||
Spoke1.Dispose();
|
||||
Hub.Dispose();
|
||||
_spoke2Cts.Dispose();
|
||||
_spoke1Cts.Dispose();
|
||||
_hubCts.Dispose();
|
||||
}
|
||||
}
|
||||
345
tests/NATS.Server.Tests/LeafNodes/LeafNodeJetStreamTests.cs
Normal file
345
tests/NATS.Server.Tests/LeafNodes/LeafNodeJetStreamTests.cs
Normal file
@@ -0,0 +1,345 @@
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using NATS.Client.Core;
|
||||
using NATS.Server.Configuration;
|
||||
|
||||
namespace NATS.Server.Tests.LeafNodes;
|
||||
|
||||
/// <summary>
|
||||
/// Tests for JetStream behavior over leaf node connections.
|
||||
/// Reference: golang/nats-server/server/leafnode_test.go — TestLeafNodeJetStreamDomainMapCrossTalk, etc.
|
||||
/// </summary>
|
||||
public class LeafNodeJetStreamTests
|
||||
{
|
||||
// Go: TestLeafNodeJetStreamDomainMapCrossTalk server/leafnode_test.go:5948
|
||||
[Fact]
|
||||
public async Task JetStream_API_requests_reach_hub_with_JS_enabled()
|
||||
{
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
JetStream = new JetStreamOptions { StoreDir = Path.Combine(Path.GetTempPath(), $"nats-js-hub-{Guid.NewGuid():N}") },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [hub.LeafListen!],
|
||||
},
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var waitTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!waitTimeout.IsCancellationRequested && (hub.Stats.Leafs == 0 || spoke.Stats.Leafs == 0))
|
||||
await Task.Delay(50, waitTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
hub.Stats.JetStreamEnabled.ShouldBeTrue();
|
||||
|
||||
// Verify hub counts leaf
|
||||
Interlocked.Read(ref hub.Stats.Leafs).ShouldBe(1);
|
||||
|
||||
await spokeCts.CancelAsync();
|
||||
await hubCts.CancelAsync();
|
||||
spoke.Dispose();
|
||||
hub.Dispose();
|
||||
spokeCts.Dispose();
|
||||
hubCts.Dispose();
|
||||
|
||||
// Clean up store dir
|
||||
if (Directory.Exists(hubOptions.JetStream.StoreDir))
|
||||
Directory.Delete(hubOptions.JetStream.StoreDir, true);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeJetStreamDomainMapCrossTalk server/leafnode_test.go:5948
|
||||
[Fact]
|
||||
public async Task JetStream_on_hub_receives_messages_published_from_leaf()
|
||||
{
|
||||
var storeDir = Path.Combine(Path.GetTempPath(), $"nats-js-leaf-{Guid.NewGuid():N}");
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
JetStream = new JetStreamOptions { StoreDir = storeDir },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [hub.LeafListen!],
|
||||
},
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var waitTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!waitTimeout.IsCancellationRequested && (hub.Stats.Leafs == 0 || spoke.Stats.Leafs == 0))
|
||||
await Task.Delay(50, waitTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
// Subscribe on hub for a subject
|
||||
await using var hubConn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{hub.Port}",
|
||||
});
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await hubConn.SubscribeCoreAsync<string>("js.leaf.test");
|
||||
await hubConn.PingAsync();
|
||||
|
||||
// Wait for interest propagation
|
||||
using var interestTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!interestTimeout.IsCancellationRequested && !spoke.HasRemoteInterest("js.leaf.test"))
|
||||
await Task.Delay(50, interestTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
// Publish from spoke
|
||||
await using var spokeConn = new NatsConnection(new NatsOpts
|
||||
{
|
||||
Url = $"nats://127.0.0.1:{spoke.Port}",
|
||||
});
|
||||
await spokeConn.ConnectAsync();
|
||||
await spokeConn.PublishAsync("js.leaf.test", "from-leaf-to-js");
|
||||
|
||||
using var msgTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await sub.Msgs.ReadAsync(msgTimeout.Token);
|
||||
msg.Data.ShouldBe("from-leaf-to-js");
|
||||
|
||||
await spokeCts.CancelAsync();
|
||||
await hubCts.CancelAsync();
|
||||
spoke.Dispose();
|
||||
hub.Dispose();
|
||||
spokeCts.Dispose();
|
||||
hubCts.Dispose();
|
||||
|
||||
if (Directory.Exists(storeDir))
|
||||
Directory.Delete(storeDir, true);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeStreamImport server/leafnode_test.go:3441
|
||||
[Fact]
|
||||
public async Task Leaf_node_with_JetStream_disabled_spoke_still_forwards_messages()
|
||||
{
|
||||
var storeDir = Path.Combine(Path.GetTempPath(), $"nats-js-fwd-{Guid.NewGuid():N}");
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
JetStream = new JetStreamOptions { StoreDir = storeDir },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
// Spoke without JetStream
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [hub.LeafListen!],
|
||||
},
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var waitTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!waitTimeout.IsCancellationRequested && (hub.Stats.Leafs == 0 || spoke.Stats.Leafs == 0))
|
||||
await Task.Delay(50, waitTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
hub.Stats.JetStreamEnabled.ShouldBeTrue();
|
||||
spoke.Stats.JetStreamEnabled.ShouldBeFalse();
|
||||
|
||||
// Subscribe on hub
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
await using var sub = await hubConn.SubscribeCoreAsync<string>("njs.forward");
|
||||
await hubConn.PingAsync();
|
||||
|
||||
using var interestTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!interestTimeout.IsCancellationRequested && !spoke.HasRemoteInterest("njs.forward"))
|
||||
await Task.Delay(50, interestTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
// Publish from spoke
|
||||
await using var spokeConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{spoke.Port}" });
|
||||
await spokeConn.ConnectAsync();
|
||||
await spokeConn.PublishAsync("njs.forward", "no-js-spoke");
|
||||
|
||||
using var msgTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await sub.Msgs.ReadAsync(msgTimeout.Token);
|
||||
msg.Data.ShouldBe("no-js-spoke");
|
||||
|
||||
await spokeCts.CancelAsync();
|
||||
await hubCts.CancelAsync();
|
||||
spoke.Dispose();
|
||||
hub.Dispose();
|
||||
spokeCts.Dispose();
|
||||
hubCts.Dispose();
|
||||
|
||||
if (Directory.Exists(storeDir))
|
||||
Directory.Delete(storeDir, true);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeJetStreamDomainMapCrossTalk server/leafnode_test.go:5948
|
||||
[Fact]
|
||||
public async Task Both_hub_and_spoke_with_JetStream_enabled_connect_successfully()
|
||||
{
|
||||
var hubStoreDir = Path.Combine(Path.GetTempPath(), $"nats-js-hub2-{Guid.NewGuid():N}");
|
||||
var spokeStoreDir = Path.Combine(Path.GetTempPath(), $"nats-js-spoke2-{Guid.NewGuid():N}");
|
||||
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
JetStream = new JetStreamOptions { StoreDir = hubStoreDir },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [hub.LeafListen!],
|
||||
},
|
||||
JetStream = new JetStreamOptions { StoreDir = spokeStoreDir },
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var waitTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!waitTimeout.IsCancellationRequested && (hub.Stats.Leafs == 0 || spoke.Stats.Leafs == 0))
|
||||
await Task.Delay(50, waitTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
hub.Stats.JetStreamEnabled.ShouldBeTrue();
|
||||
spoke.Stats.JetStreamEnabled.ShouldBeTrue();
|
||||
Interlocked.Read(ref hub.Stats.Leafs).ShouldBe(1);
|
||||
|
||||
await spokeCts.CancelAsync();
|
||||
await hubCts.CancelAsync();
|
||||
spoke.Dispose();
|
||||
hub.Dispose();
|
||||
spokeCts.Dispose();
|
||||
hubCts.Dispose();
|
||||
|
||||
if (Directory.Exists(hubStoreDir))
|
||||
Directory.Delete(hubStoreDir, true);
|
||||
if (Directory.Exists(spokeStoreDir))
|
||||
Directory.Delete(spokeStoreDir, true);
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeStreamAndShadowSubs server/leafnode_test.go:6176
|
||||
[Fact]
|
||||
public async Task Leaf_node_message_forwarding_works_alongside_JetStream()
|
||||
{
|
||||
var storeDir = Path.Combine(Path.GetTempPath(), $"nats-js-combo-{Guid.NewGuid():N}");
|
||||
var hubOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions { Host = "127.0.0.1", Port = 0 },
|
||||
JetStream = new JetStreamOptions { StoreDir = storeDir },
|
||||
};
|
||||
|
||||
var hub = new NatsServer(hubOptions, NullLoggerFactory.Instance);
|
||||
var hubCts = new CancellationTokenSource();
|
||||
_ = hub.StartAsync(hubCts.Token);
|
||||
await hub.WaitForReadyAsync();
|
||||
|
||||
var spokeOptions = new NatsOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
LeafNode = new LeafNodeOptions
|
||||
{
|
||||
Host = "127.0.0.1",
|
||||
Port = 0,
|
||||
Remotes = [hub.LeafListen!],
|
||||
},
|
||||
};
|
||||
|
||||
var spoke = new NatsServer(spokeOptions, NullLoggerFactory.Instance);
|
||||
var spokeCts = new CancellationTokenSource();
|
||||
_ = spoke.StartAsync(spokeCts.Token);
|
||||
await spoke.WaitForReadyAsync();
|
||||
|
||||
using var waitTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!waitTimeout.IsCancellationRequested && (hub.Stats.Leafs == 0 || spoke.Stats.Leafs == 0))
|
||||
await Task.Delay(50, waitTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
// Regular pub/sub should still work alongside JS
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("combo.test");
|
||||
await leafConn.PingAsync();
|
||||
|
||||
using var interestTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!interestTimeout.IsCancellationRequested && !hub.HasRemoteInterest("combo.test"))
|
||||
await Task.Delay(50, interestTimeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
await hubConn.PublishAsync("combo.test", "js-combo");
|
||||
|
||||
using var msgTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var msg = await sub.Msgs.ReadAsync(msgTimeout.Token);
|
||||
msg.Data.ShouldBe("js-combo");
|
||||
|
||||
await spokeCts.CancelAsync();
|
||||
await hubCts.CancelAsync();
|
||||
spoke.Dispose();
|
||||
hub.Dispose();
|
||||
spokeCts.Dispose();
|
||||
hubCts.Dispose();
|
||||
|
||||
if (Directory.Exists(storeDir))
|
||||
Directory.Delete(storeDir, true);
|
||||
}
|
||||
}
|
||||
179
tests/NATS.Server.Tests/LeafNodes/LeafNodeLoopDetectionTests.cs
Normal file
179
tests/NATS.Server.Tests/LeafNodes/LeafNodeLoopDetectionTests.cs
Normal file
@@ -0,0 +1,179 @@
|
||||
using NATS.Server.LeafNodes;
|
||||
|
||||
namespace NATS.Server.Tests.LeafNodes;
|
||||
|
||||
/// <summary>
|
||||
/// Tests for leaf node loop detection via $LDS. prefix.
|
||||
/// Reference: golang/nats-server/server/leafnode_test.go
|
||||
/// </summary>
|
||||
public class LeafNodeLoopDetectionTests
|
||||
{
|
||||
// Go: TestLeafNodeLoop server/leafnode_test.go:837
|
||||
[Fact]
|
||||
public void HasLoopMarker_returns_true_for_marked_subject()
|
||||
{
|
||||
var marked = LeafLoopDetector.Mark("orders.created", "SERVER1");
|
||||
LeafLoopDetector.HasLoopMarker(marked).ShouldBeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void HasLoopMarker_returns_false_for_plain_subject()
|
||||
{
|
||||
LeafLoopDetector.HasLoopMarker("orders.created").ShouldBeFalse();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Mark_prepends_LDS_prefix_with_server_id()
|
||||
{
|
||||
LeafLoopDetector.Mark("foo.bar", "ABC123").ShouldBe("$LDS.ABC123.foo.bar");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsLooped_returns_true_when_subject_contains_own_server_id()
|
||||
{
|
||||
var marked = LeafLoopDetector.Mark("foo.bar", "MYSERVER");
|
||||
LeafLoopDetector.IsLooped(marked, "MYSERVER").ShouldBeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsLooped_returns_false_when_subject_contains_different_server_id()
|
||||
{
|
||||
var marked = LeafLoopDetector.Mark("foo.bar", "OTHER");
|
||||
LeafLoopDetector.IsLooped(marked, "MYSERVER").ShouldBeFalse();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeLoopDetectionOnActualLoop server/leafnode_test.go:9410
|
||||
[Fact]
|
||||
public void TryUnmark_extracts_original_subject_from_single_mark()
|
||||
{
|
||||
var marked = LeafLoopDetector.Mark("orders.created", "S1");
|
||||
LeafLoopDetector.TryUnmark(marked, out var unmarked).ShouldBeTrue();
|
||||
unmarked.ShouldBe("orders.created");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TryUnmark_extracts_original_subject_from_nested_marks()
|
||||
{
|
||||
var nested = LeafLoopDetector.Mark(LeafLoopDetector.Mark("data.stream", "S1"), "S2");
|
||||
LeafLoopDetector.TryUnmark(nested, out var unmarked).ShouldBeTrue();
|
||||
unmarked.ShouldBe("data.stream");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TryUnmark_extracts_original_from_triple_nested_marks()
|
||||
{
|
||||
var tripleNested = LeafLoopDetector.Mark(
|
||||
LeafLoopDetector.Mark(LeafLoopDetector.Mark("test.subject", "S1"), "S2"), "S3");
|
||||
LeafLoopDetector.TryUnmark(tripleNested, out var unmarked).ShouldBeTrue();
|
||||
unmarked.ShouldBe("test.subject");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TryUnmark_returns_false_for_unmarked_subject()
|
||||
{
|
||||
LeafLoopDetector.TryUnmark("orders.created", out var unmarked).ShouldBeFalse();
|
||||
unmarked.ShouldBe("orders.created");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Mark_preserves_dot_separated_structure()
|
||||
{
|
||||
var marked = LeafLoopDetector.Mark("a.b.c.d", "SRV");
|
||||
marked.ShouldStartWith("$LDS.SRV.");
|
||||
marked.ShouldEndWith("a.b.c.d");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeLoopDetectionWithMultipleClusters server/leafnode_test.go:3546
|
||||
[Fact]
|
||||
public void IsLooped_detects_loop_in_nested_marks()
|
||||
{
|
||||
var marked = LeafLoopDetector.Mark(LeafLoopDetector.Mark("test", "REMOTE"), "LOCAL");
|
||||
LeafLoopDetector.IsLooped(marked, "LOCAL").ShouldBeTrue();
|
||||
LeafLoopDetector.IsLooped(marked, "REMOTE").ShouldBeFalse();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void HasLoopMarker_works_with_prefix_only()
|
||||
{
|
||||
LeafLoopDetector.HasLoopMarker("$LDS.").ShouldBeTrue();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void IsLooped_returns_false_for_plain_subject()
|
||||
{
|
||||
LeafLoopDetector.IsLooped("plain.subject", "MYSERVER").ShouldBeFalse();
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Mark_with_single_token_subject()
|
||||
{
|
||||
var marked = LeafLoopDetector.Mark("simple", "S1");
|
||||
marked.ShouldBe("$LDS.S1.simple");
|
||||
LeafLoopDetector.TryUnmark(marked, out var unmarked).ShouldBeTrue();
|
||||
unmarked.ShouldBe("simple");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeLoopFromDAG server/leafnode_test.go:899
|
||||
[Fact]
|
||||
public void Multiple_servers_in_chain_each_add_their_mark()
|
||||
{
|
||||
var original = "data.stream";
|
||||
var fromS1 = LeafLoopDetector.Mark(original, "S1");
|
||||
fromS1.ShouldBe("$LDS.S1.data.stream");
|
||||
|
||||
var fromS2 = LeafLoopDetector.Mark(fromS1, "S2");
|
||||
fromS2.ShouldBe("$LDS.S2.$LDS.S1.data.stream");
|
||||
|
||||
LeafLoopDetector.IsLooped(fromS2, "S2").ShouldBeTrue();
|
||||
LeafLoopDetector.IsLooped(fromS2, "S1").ShouldBeFalse();
|
||||
|
||||
LeafLoopDetector.TryUnmark(fromS2, out var unmarked).ShouldBeTrue();
|
||||
unmarked.ShouldBe("data.stream");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Roundtrip_mark_unmark_preserves_original()
|
||||
{
|
||||
var subjects = new[] { "foo", "foo.bar", "foo.bar.baz", "a.b.c.d.e", "single", "with.*.wildcard", "with.>" };
|
||||
|
||||
foreach (var subject in subjects)
|
||||
{
|
||||
var marked = LeafLoopDetector.Mark(subject, "TESTSRV");
|
||||
LeafLoopDetector.TryUnmark(marked, out var unmarked).ShouldBeTrue();
|
||||
unmarked.ShouldBe(subject, $"Failed roundtrip for: {subject}");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Four_server_chain_marks_and_unmarks_correctly()
|
||||
{
|
||||
var step1 = LeafLoopDetector.Mark("test", "A");
|
||||
var step2 = LeafLoopDetector.Mark(step1, "B");
|
||||
var step3 = LeafLoopDetector.Mark(step2, "C");
|
||||
var step4 = LeafLoopDetector.Mark(step3, "D");
|
||||
|
||||
LeafLoopDetector.IsLooped(step4, "D").ShouldBeTrue();
|
||||
LeafLoopDetector.IsLooped(step4, "C").ShouldBeFalse();
|
||||
LeafLoopDetector.IsLooped(step4, "B").ShouldBeFalse();
|
||||
LeafLoopDetector.IsLooped(step4, "A").ShouldBeFalse();
|
||||
|
||||
LeafLoopDetector.TryUnmark(step4, out var unmarked).ShouldBeTrue();
|
||||
unmarked.ShouldBe("test");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void HasLoopMarker_is_case_sensitive()
|
||||
{
|
||||
LeafLoopDetector.HasLoopMarker("$LDS.SRV.foo").ShouldBeTrue();
|
||||
LeafLoopDetector.HasLoopMarker("$lds.SRV.foo").ShouldBeFalse();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeLoopDetectedOnAcceptSide server/leafnode_test.go:1522
|
||||
[Fact]
|
||||
public void IsLooped_is_case_sensitive_for_server_id()
|
||||
{
|
||||
var marked = LeafLoopDetector.Mark("foo", "MYSERVER");
|
||||
LeafLoopDetector.IsLooped(marked, "MYSERVER").ShouldBeTrue();
|
||||
LeafLoopDetector.IsLooped(marked, "myserver").ShouldBeFalse();
|
||||
}
|
||||
}
|
||||
255
tests/NATS.Server.Tests/LeafNodes/LeafNodeSubjectFilterTests.cs
Normal file
255
tests/NATS.Server.Tests/LeafNodes/LeafNodeSubjectFilterTests.cs
Normal file
@@ -0,0 +1,255 @@
|
||||
using NATS.Client.Core;
|
||||
|
||||
namespace NATS.Server.Tests.LeafNodes;
|
||||
|
||||
/// <summary>
|
||||
/// Tests for subject filter propagation through leaf nodes.
|
||||
/// Reference: golang/nats-server/server/leafnode_test.go
|
||||
/// </summary>
|
||||
public class LeafNodeSubjectFilterTests
|
||||
{
|
||||
// Go: TestLeafNodeInterestPropagationDaisychain server/leafnode_test.go:3953
|
||||
[Fact]
|
||||
public async Task Wildcard_subscription_propagates_through_leaf_node()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("wild.*");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("wild.test");
|
||||
|
||||
await hubConn.PublishAsync("wild.test", "wildcard-match");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
(await sub.Msgs.ReadAsync(cts.Token)).Data.ShouldBe("wildcard-match");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeInterestPropagationDaisychain server/leafnode_test.go:3953
|
||||
[Fact]
|
||||
public async Task Full_wildcard_subscription_propagates_through_leaf_node()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("fwc.>");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("fwc.a.b.c");
|
||||
|
||||
await hubConn.PublishAsync("fwc.a.b.c", "full-wc");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
(await sub.Msgs.ReadAsync(cts.Token)).Data.ShouldBe("full-wc");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeStreamAndShadowSubs server/leafnode_test.go:6176
|
||||
[Fact]
|
||||
public async Task Catch_all_subscription_propagates_through_leaf_node()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>(">");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("anything.at.all");
|
||||
|
||||
await hubConn.PublishAsync("anything.at.all", "catch-all");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
(await sub.Msgs.ReadAsync(cts.Token)).Data.ShouldBe("catch-all");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodePermissions server/leafnode_test.go:1267
|
||||
[Fact]
|
||||
public async Task Subscription_interest_propagates_from_hub_to_leaf()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await hubConn.SubscribeCoreAsync<string>("interest.prop");
|
||||
await hubConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnSpokeAsync("interest.prop");
|
||||
|
||||
fixture.Spoke.HasRemoteInterest("interest.prop").ShouldBeTrue();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodePermissions server/leafnode_test.go:1267
|
||||
[Fact]
|
||||
public async Task Unsubscribe_removes_interest_on_remote()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
var sub = await leafConn.SubscribeCoreAsync<string>("unsub.test");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("unsub.test");
|
||||
fixture.Hub.HasRemoteInterest("unsub.test").ShouldBeTrue();
|
||||
|
||||
await sub.DisposeAsync();
|
||||
await leafConn.PingAsync();
|
||||
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
while (!timeout.IsCancellationRequested && fixture.Hub.HasRemoteInterest("unsub.test"))
|
||||
await Task.Delay(50, timeout.Token).ContinueWith(_ => { }, TaskScheduler.Default);
|
||||
|
||||
fixture.Hub.HasRemoteInterest("unsub.test").ShouldBeFalse();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeInterestPropagationDaisychain server/leafnode_test.go:3953
|
||||
[Fact]
|
||||
public async Task Multiple_subscriptions_on_different_subjects_all_propagate()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var sub1 = await leafConn.SubscribeCoreAsync<string>("multi.a");
|
||||
await using var sub2 = await leafConn.SubscribeCoreAsync<string>("multi.b");
|
||||
await using var sub3 = await leafConn.SubscribeCoreAsync<string>("multi.c");
|
||||
await leafConn.PingAsync();
|
||||
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("multi.a");
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("multi.b");
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("multi.c");
|
||||
|
||||
fixture.Hub.HasRemoteInterest("multi.a").ShouldBeTrue();
|
||||
fixture.Hub.HasRemoteInterest("multi.b").ShouldBeTrue();
|
||||
fixture.Hub.HasRemoteInterest("multi.c").ShouldBeTrue();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeDuplicateMsg server/leafnode_test.go:6513
|
||||
[Fact]
|
||||
public async Task No_interest_for_unsubscribed_subject()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
fixture.Hub.HasRemoteInterest("nonexistent.subject").ShouldBeFalse();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeInterestPropagationDaisychain server/leafnode_test.go:3953
|
||||
[Fact]
|
||||
public async Task Wildcard_interest_matches_multiple_concrete_subjects()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("events.*");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("events.created");
|
||||
|
||||
await hubConn.PublishAsync("events.created", "ev1");
|
||||
await hubConn.PublishAsync("events.updated", "ev2");
|
||||
await hubConn.PublishAsync("events.deleted", "ev3");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
var received = new List<string>();
|
||||
for (var i = 0; i < 3; i++)
|
||||
received.Add((await sub.Msgs.ReadAsync(cts.Token)).Data!);
|
||||
|
||||
received.ShouldContain("ev1");
|
||||
received.ShouldContain("ev2");
|
||||
received.ShouldContain("ev3");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodePermissions server/leafnode_test.go:1267
|
||||
[Fact]
|
||||
public async Task Non_matching_wildcard_does_not_receive_message()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("orders.*");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("orders.test");
|
||||
|
||||
await hubConn.PublishAsync("users.test", "should-not-arrive");
|
||||
|
||||
using var leakCts = new CancellationTokenSource(TimeSpan.FromMilliseconds(500));
|
||||
await Should.ThrowAsync<OperationCanceledException>(async () =>
|
||||
await sub.Msgs.ReadAsync(leakCts.Token));
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeQueueGroupDistribution server/leafnode_test.go:4021
|
||||
[Fact]
|
||||
public async Task Queue_subscription_interest_propagates_through_leaf_node()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("queue.test", queueGroup: "workers");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("queue.test");
|
||||
|
||||
await hubConn.PublishAsync("queue.test", "queued-msg");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
(await sub.Msgs.ReadAsync(cts.Token)).Data.ShouldBe("queued-msg");
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeIsolatedLeafSubjectPropagationGlobal server/leafnode_test.go:10280
|
||||
[Fact]
|
||||
public async Task Interest_on_hub_side_includes_remote_interest_from_leaf()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>("remote.interest.check");
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync("remote.interest.check");
|
||||
|
||||
fixture.Hub.HasRemoteInterest("remote.interest.check").ShouldBeTrue();
|
||||
fixture.Hub.HasRemoteInterest("some.other.subject").ShouldBeFalse();
|
||||
}
|
||||
|
||||
// Go: TestLeafNodeInterestPropagationDaisychain server/leafnode_test.go:3953
|
||||
[Fact]
|
||||
public async Task Deep_subject_hierarchy_forwarded_correctly()
|
||||
{
|
||||
await using var fixture = await LeafFixture.StartAsync();
|
||||
|
||||
await using var leafConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Spoke.Port}" });
|
||||
await leafConn.ConnectAsync();
|
||||
await using var hubConn = new NatsConnection(new NatsOpts { Url = $"nats://127.0.0.1:{fixture.Hub.Port}" });
|
||||
await hubConn.ConnectAsync();
|
||||
|
||||
const string deepSubject = "a.b.c.d.e.f.g.h";
|
||||
await using var sub = await leafConn.SubscribeCoreAsync<string>(deepSubject);
|
||||
await leafConn.PingAsync();
|
||||
await fixture.WaitForRemoteInterestOnHubAsync(deepSubject);
|
||||
|
||||
await hubConn.PublishAsync(deepSubject, "deep");
|
||||
|
||||
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
|
||||
(await sub.Msgs.ReadAsync(cts.Token)).Data.ShouldBe("deep");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user