Use more threads for xUnit tests (#722)

* use aggressive ParallelAlgorithm for xUnit tests Signed-off-by: Caleb Lloyd <[email protected]> * make NatsServer start async Signed-off-by: Caleb Lloyd <[email protected]> * try MaxParallelThreads=4.0x Signed-off-by: Caleb Lloyd <[email protected]> * more async Signed-off-by: Caleb Lloyd <[email protected]> * tighten connect loop Signed-off-by: Caleb Lloyd <[email protected]> --------- Signed-off-by: Caleb Lloyd <[email protected]>
nats-io · Jan 24, 2025 · 7b9ed5f · 7b9ed5f
1 parent c94fe02
commit 7b9ed5f
Show file tree

Hide file tree

Showing 67 changed files with 454 additions and 429 deletions.
diff --git a/tests/NATS.Client.CheckNativeAot/Program.cs b/tests/NATS.Client.CheckNativeAot/Program.cs
@@ -30,8 +30,8 @@ async Task RequestReplyTests()
 {
     Log("Request reply tests...");
 
-    await using var server = NatsServer.Start();
-    await using var nats = server.CreateClientConnection();
+    await using var server = await NatsServer.StartAsync();
+    await using var nats = await server.CreateClientConnectionAsync();
 
     var sub = await nats.SubscribeCoreAsync<int>("foo");
     var reg = sub.Register(async msg =>
@@ -65,8 +65,8 @@ async Task JetStreamTests()
 {
     Log("JetStream tests...");
 
-    await using var server = NatsServer.StartJS();
-    var nats = server.CreateClientConnection();
+    await using var server = await NatsServer.StartJSAsync();
+    var nats = await server.CreateClientConnectionAsync();
 
     // Happy user
     {
@@ -189,8 +189,8 @@ async Task KVTests()
 {
     Log("KV tests...");
 
-    await using var server = NatsServer.StartJS();
-    await using var nats = server.CreateClientConnection();
+    await using var server = await NatsServer.StartJSAsync();
+    await using var nats = await server.CreateClientConnectionAsync();
 
     var js = new NatsJSContext(nats);
     var kv = new NatsKVContext(js);
@@ -212,8 +212,8 @@ async Task ObjectStoreTests()
     var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
     var cancellationToken = cts.Token;
 
-    await using var server = NatsServer.StartJS();
-    await using var nats = server.CreateClientConnection();
+    await using var server = await NatsServer.StartJSAsync();
+    await using var nats = await server.CreateClientConnectionAsync();
     var js = new NatsJSContext(nats);
     var ob = new NatsObjContext(js);
 
@@ -269,8 +269,8 @@ async Task ServicesTests()
     var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
     var cancellationToken = cts.Token;
 
-    await using var server = NatsServer.Start();
-    await using var nats = server.CreateClientConnection();
+    await using var server = await NatsServer.StartAsync();
+    await using var nats = await server.CreateClientConnectionAsync();
     var svc = new NatsSvcContext(nats);
 
     await using var s1 = await svc.AddServiceAsync("s1", "1.0.0", cancellationToken: cancellationToken);
@@ -382,8 +382,8 @@ async Task ServicesTests2()
     var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10_0000));
     var cancellationToken = cts.Token;
 
-    await using var server = NatsServer.Start();
-    await using var nats = server.CreateClientConnection();
+    await using var server = await NatsServer.StartAsync();
+    await using var nats = await server.CreateClientConnectionAsync();
     var svc = new NatsSvcContext(nats);
 
     await using var s1 = await svc.AddServiceAsync("s1", "1.0.0", cancellationToken: cancellationToken);

diff --git a/tests/NATS.Client.Core.MemoryTests/NatsConsumeTests.cs b/tests/NATS.Client.Core.MemoryTests/NatsConsumeTests.cs
@@ -9,12 +9,12 @@ namespace NATS.Client.Core.MemoryTests;
 public class NatsConsumeTests
 {
     [Test]
-    public void Subscription_should_not_be_collected_when_in_consume_async_enumerator()
+    public async Task Subscription_should_not_be_collected_when_in_consume_async_enumerator()
     {
-        var server = NatsServer.StartJS();
+        var server = await NatsServer.StartJSAsync();
         try
         {
-            var nats = server.CreateClientConnection(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
+            var nats = await server.CreateClientConnectionAsync(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
             var js = new NatsJSContext(nats);
 
             nats.PingAsync().AsTask().GetAwaiter().GetResult();
@@ -101,12 +101,12 @@ public void Subscription_should_not_be_collected_when_in_consume_async_enumerato
     }
 
     [Test]
-    public void Subscription_should_not_be_collected_when_in_ordered_consume_async_enumerator()
+    public async Task Subscription_should_not_be_collected_when_in_ordered_consume_async_enumerator()
     {
-        var server = NatsServer.StartJS();
+        var server = await NatsServer.StartJSAsync();
         try
         {
-            var nats = server.CreateClientConnection(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
+            var nats = await server.CreateClientConnectionAsync(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
             var js = new NatsJSContext(nats);
 
             nats.PingAsync().AsTask().GetAwaiter().GetResult();

diff --git a/tests/NATS.Client.Core.MemoryTests/NatsSubTests.cs b/tests/NATS.Client.Core.MemoryTests/NatsSubTests.cs
@@ -7,12 +7,12 @@ namespace NATS.Client.Core.MemoryTests;
 public class NatsSubTests
 {
     [Test]
-    public void Subject_manager_should_not_hold_on_to_subscription_if_collected()
+    public async Task Subject_manager_should_not_hold_on_to_subscription_if_collected()
     {
-        var server = NatsServer.Start();
+        var server = await NatsServer.StartAsync();
         try
         {
-            var nats = server.CreateClientConnection(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
+            var nats = await server.CreateClientConnectionAsync(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
 
             async Task Isolator()
             {
@@ -43,14 +43,14 @@ async Task Isolator()
     }
 
     [Test]
-    public void Subscription_should_not_be_collected_subscribe_async()
+    public async Task Subscription_should_not_be_collected_subscribe_async()
     {
-        var server = NatsServer.Start();
+        var server = await NatsServer.StartAsync();
         try
         {
             const int iterations = 10;
             const string subject = "foo.data";
-            var nats = server.CreateClientConnection(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
+            var nats = await server.CreateClientConnectionAsync(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
             var received = Channel.CreateUnbounded<object>();
 
             var subTask = Task.Run(async () =>
@@ -75,14 +75,14 @@ public void Subscription_should_not_be_collected_subscribe_async()
     }
 
     [Test]
-    public void Subscription_should_not_be_collected_subscribe_core_async_read_all_async()
+    public async Task Subscription_should_not_be_collected_subscribe_core_async_read_all_async()
     {
-        var server = NatsServer.Start();
+        var server = await NatsServer.StartAsync();
         try
         {
             const int iterations = 10;
             const string subject = "foo.data";
-            var nats = server.CreateClientConnection(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
+            var nats = await server.CreateClientConnectionAsync(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
             var received = Channel.CreateUnbounded<object>();
 
             var subTask = Task.Run(async () =>
@@ -108,14 +108,14 @@ public void Subscription_should_not_be_collected_subscribe_core_async_read_all_a
     }
 
     [Test]
-    public void Subscription_should_not_be_collected_subscribe_core_async_read_async()
+    public async Task Subscription_should_not_be_collected_subscribe_core_async_read_async()
     {
-        var server = NatsServer.Start();
+        var server = await NatsServer.StartAsync();
         try
         {
             const int iterations = 10;
             const string subject = "foo.data";
-            var nats = server.CreateClientConnection(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
+            var nats = await server.CreateClientConnectionAsync(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
             var received = Channel.CreateUnbounded<object>();
 
             var subTask = Task.Run(async () =>
@@ -140,14 +140,14 @@ public void Subscription_should_not_be_collected_subscribe_core_async_read_async
     }
 
     [Test]
-    public void Subscription_should_not_be_collected_subscribe_core_async_wait_to_read_async()
+    public async Task Subscription_should_not_be_collected_subscribe_core_async_wait_to_read_async()
     {
-        var server = NatsServer.Start();
+        var server = await NatsServer.StartAsync();
         try
         {
             const int iterations = 10;
             const string subject = "foo.data";
-            var nats = server.CreateClientConnection(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
+            var nats = await server.CreateClientConnectionAsync(new NatsOpts { RequestTimeout = TimeSpan.FromSeconds(10) });
             var received = Channel.CreateUnbounded<object>();
 
             var subTask = Task.Run(async () =>

diff --git a/tests/NATS.Client.Core.Tests/AuthErrorTest.cs b/tests/NATS.Client.Core.Tests/AuthErrorTest.cs
@@ -12,7 +12,7 @@ public class AuthErrorTest
     [SkipOnPlatform("WINDOWS", "doesn't support HUP signal")]
     public async Task Auth_err_twice_will_stop_retries()
     {
-        await using var server = NatsServer.Start(
+        await using var server = await NatsServer.StartAsync(
             new NullOutputHelper(),
             new NatsServerOptsBuilder()
                 .AddServerConfigText(@"
@@ -32,7 +32,7 @@ public async Task Auth_err_twice_will_stop_retries()
                 },
             });
 
-        await using var nats = server.CreateClientConnection(new NatsOpts
+        await using var nats = await server.CreateClientConnectionAsync(new NatsOpts
         {
             AuthOpts = new NatsAuthOpts
             {
@@ -79,7 +79,7 @@ public async Task Auth_err_twice_will_stop_retries()
     [SkipOnPlatform("WINDOWS", "doesn't support HUP signal")]
     public async Task Auth_err_can_be_ignored_for_retires()
     {
-        await using var server = NatsServer.Start(
+        await using var server = await NatsServer.StartAsync(
             new NullOutputHelper(),
             new NatsServerOptsBuilder()
                 .AddServerConfigText(@"
@@ -99,7 +99,7 @@ public async Task Auth_err_can_be_ignored_for_retires()
                 },
             });
 
-        await using var nats = server.CreateClientConnection(new NatsOpts
+        await using var nats = await server.CreateClientConnectionAsync(new NatsOpts
         {
             AuthOpts = new NatsAuthOpts
             {

diff --git a/tests/NATS.Client.Core.Tests/ClusterTests.cs b/tests/NATS.Client.Core.Tests/ClusterTests.cs
@@ -20,6 +20,7 @@ public async Task Seed_urls_on_retry(bool userAuthInUrl)
                 }
             },
             userAuthInUrl);
+        await cluster1.StartAsync();
 
         await using var cluster2 = new NatsCluster(
             new NullOutputHelper(),
@@ -34,6 +35,7 @@ public async Task Seed_urls_on_retry(bool userAuthInUrl)
                 }
             },
             userAuthInUrl);
+        await cluster2.StartAsync();
 
         // Use the first node from each cluster as the seed
         // so that we can confirm seeds are used on retry

diff --git a/tests/NATS.Client.Core.Tests/ConnectionRetryTest.cs b/tests/NATS.Client.Core.Tests/ConnectionRetryTest.cs
@@ -9,8 +9,8 @@ public class ConnectionRetryTest
     [Fact]
     public async Task Max_retry_reached_after_disconnect()
     {
-        await using var server = NatsServer.Start();
-        await using var nats = server.CreateClientConnection(new NatsOpts { MaxReconnectRetry = 2, ReconnectWaitMax = TimeSpan.Zero, ReconnectWaitMin = TimeSpan.FromSeconds(.1), });
+        await using var server = await NatsServer.StartAsync();
+        await using var nats = await server.CreateClientConnectionAsync(new NatsOpts { MaxReconnectRetry = 2, ReconnectWaitMax = TimeSpan.Zero, ReconnectWaitMin = TimeSpan.FromSeconds(.1), });
 
         var signal = new WaitSignal();
         nats.ReconnectFailed += (_, _) =>
@@ -31,8 +31,8 @@ public async Task Max_retry_reached_after_disconnect()
     [Fact]
     public async Task Retry_and_connect_after_disconnected()
     {
-        await using var server = NatsServer.Start();
-        await using var nats = server.CreateClientConnection(new NatsOpts { MaxReconnectRetry = 10, ReconnectWaitMax = TimeSpan.Zero, ReconnectWaitMin = TimeSpan.FromSeconds(2), });
+        await using var server = await NatsServer.StartAsync();
+        await using var nats = await server.CreateClientConnectionAsync(new NatsOpts { MaxReconnectRetry = 10, ReconnectWaitMax = TimeSpan.Zero, ReconnectWaitMin = TimeSpan.FromSeconds(2), });
 
         var signal = new WaitSignal();
         nats.ReconnectFailed += (_, _) =>
@@ -49,7 +49,7 @@ public async Task Retry_and_connect_after_disconnected()
 
         await Task.Delay(TimeSpan.FromSeconds(5), cts.Token);
 
-        server.StartServerProcess();
+        await server.StartServerProcessAsync();
 
         var rtt = await nats.PingAsync(cts.Token);
         Assert.True(rtt > TimeSpan.Zero);
@@ -59,9 +59,9 @@ public async Task Retry_and_connect_after_disconnected()
     public async Task Reconnect_doesnt_drop_partially_sent_msgs()
     {
         const int msgSize = 1048576; // 1MiB
-        await using var server = NatsServer.Start();
+        await using var server = await NatsServer.StartAsync();
 
-        await using var pubConn = server.CreateClientConnection();
+        await using var pubConn = await server.CreateClientConnectionAsync();
         await pubConn.ConnectAsync();
 
         var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
@@ -71,7 +71,7 @@ public async Task Reconnect_doesnt_drop_partially_sent_msgs()
         var subActive = 0;
         var subTask = Task.Run(async () =>
         {
-            await using var subConn = server.CreateClientConnection();
+            await using var subConn = await server.CreateClientConnectionAsync();
             await using var sub = await subConn.SubscribeCoreAsync<NatsMemoryOwner<byte>>("test", cancellationToken: timeoutCts.Token);
             await foreach (var msg in sub.Msgs.ReadAllAsync(timeoutCts.Token))
             {

diff --git a/tests/NATS.Client.Core.Tests/LowLevelApiTest.cs b/tests/NATS.Client.Core.Tests/LowLevelApiTest.cs
@@ -12,8 +12,8 @@ public class LowLevelApiTest
     [Fact]
     public async Task Sub_custom_builder_test()
     {
-        await using var server = NatsServer.Start();
-        var nats = server.CreateClientConnection();
+        await using var server = await NatsServer.StartAsync();
+        var nats = await server.CreateClientConnectionAsync();
 
         var subject = "foo.*";
         var builder = new NatsSubCustomTestBuilder(_output);

diff --git a/tests/NATS.Client.Core.Tests/NATS.Client.Core.Tests.csproj b/tests/NATS.Client.Core.Tests/NATS.Client.Core.Tests.csproj
@@ -6,8 +6,9 @@
     <IsPackable>false</IsPackable>
     <NoWarn>$(NoWarn);CS8002</NoWarn>
     <ImplicitUsings>enable</ImplicitUsings>
-    <RunSettingsFilePath>$(MSBuildProjectDirectory)\test.runsettings</RunSettingsFilePath>
+    <RunSettingsFilePath>$(MSBuildProjectDirectory)\..\xunit.runsettings</RunSettingsFilePath>
     <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
   </PropertyGroup>
 
   <ItemGroup>

diff --git a/tests/NATS.Client.Core.Tests/NatsConnectionTest.Auth.cs b/tests/NATS.Client.Core.Tests/NatsConnectionTest.Auth.cs
@@ -208,20 +208,20 @@ public async Task UserCredentialAuthTest(Auth auth)
 
         var serverOpts = serverOptsBuilder.Build();
 
-        await using var server = NatsServer.Start(_output, serverOpts, clientOpts, useAuthInUrl);
+        await using var server = await NatsServer.StartAsync(_output, serverOpts, clientOpts, useAuthInUrl);
 
         var subject = Guid.NewGuid().ToString("N");
 
         _output.WriteLine("TRY ANONYMOUS CONNECTION");
         {
-            await using var failConnection = server.CreateClientConnection(ignoreAuthorizationException: true);
+            await using var failConnection = await server.CreateClientConnectionAsync(ignoreAuthorizationException: true);
             var natsException =
                 await Assert.ThrowsAsync<NatsException>(async () => await failConnection.PublishAsync(subject, 0));
             Assert.Contains("Authorization Violation", natsException.GetBaseException().Message);
         }
 
-        await using var subConnection = server.CreateClientConnection(clientOpts, useAuthInUrl: useAuthInUrl);
-        await using var pubConnection = server.CreateClientConnection(clientOpts, useAuthInUrl: useAuthInUrl);
+        await using var subConnection = await server.CreateClientConnectionAsync(clientOpts, useAuthInUrl: useAuthInUrl);
+        await using var pubConnection = await server.CreateClientConnectionAsync(clientOpts, useAuthInUrl: useAuthInUrl);
 
         var signalComplete1 = new WaitSignal();
         var signalComplete2 = new WaitSignal();
@@ -257,7 +257,7 @@ await Retry.Until(
         await disconnectSignal2;
 
         _output.WriteLine("START NEW SERVER");
-        await using var newServer = NatsServer.Start(_output, serverOpts, clientOpts, useAuthInUrl);
+        await using var newServer = await NatsServer.StartAsync(_output, serverOpts, clientOpts, useAuthInUrl);
         await subConnection.ConnectAsync(); // wait open again
         await pubConnection.ConnectAsync(); // wait open again
 

diff --git a/tests/NATS.Client.Core.Tests/NatsConnectionTest.Headers.cs b/tests/NATS.Client.Core.Tests/NatsConnectionTest.Headers.cs
@@ -5,9 +5,9 @@ public abstract partial class NatsConnectionTest
     [Fact]
     public async Task HeaderParsingTest()
     {
-        await using var server = NatsServer.Start(_output, _transportType);
+        await using var server = await NatsServer.StartAsync(_output, _transportType);
 
-        await using var nats = server.CreateClientConnection();
+        await using var nats = await server.CreateClientConnectionAsync();
 
         var sync = 0;
         var signal1 = new WaitSignal<NatsMsg<int>>();

diff --git a/tests/NATS.Client.Core.Tests/NatsConnectionTest.QueueGroups.cs b/tests/NATS.Client.Core.Tests/NatsConnectionTest.QueueGroups.cs
@@ -8,11 +8,11 @@ public async Task QueueGroupsTest()
         // Use high enough count to create some distribution among subscribers.
         const int messageCount = 100;
 
-        await using var server = NatsServer.Start(_output, _transportType);
+        await using var server = await NatsServer.StartAsync(_output, _transportType);
 
-        await using var conn1 = server.CreateClientConnection();
-        await using var conn2 = server.CreateClientConnection();
-        await using var conn3 = server.CreateClientConnection();
+        await using var conn1 = await server.CreateClientConnectionAsync();
+        await using var conn2 = await server.CreateClientConnectionAsync();
+        await using var conn3 = await server.CreateClientConnectionAsync();
 
         var sub1 = await conn1.SubscribeCoreAsync<int>("foo.*", queueGroup: "my-group");
         var sub2 = await conn2.SubscribeCoreAsync<int>("foo.*", queueGroup: "my-group");