Minor change in integration tests

lukebakken · lukebakken · commit 15a7d1acbd28 · 2024-12-09T12:09:22.000-08:00
This uses the current time and a short uuid when creating test queues and exchanges.

Copied from rabbitmq/rabbitmq-amqp-dotnet-client

* Ensure unique toxic name because integration tests run in parallel per-TFM now.
* Use unique queue names.
diff --git a/projects/Test/Common/IntegrationFixture.cs b/projects/Test/Common/IntegrationFixture.cs
@@ -84,16 +84,9 @@ public abstract class IntegrationFixture : IAsyncLifetime
         public static readonly TimeSpan RecoveryInterval = TimeSpan.FromSeconds(2);
         public static readonly TimeSpan TestTimeout = TimeSpan.FromSeconds(5);
         public static readonly TimeSpan RequestedConnectionTimeout = TimeSpan.FromSeconds(1);
-        public static readonly Random S_Random;
 
         static IntegrationFixture()
         {
-
-#if NET
-            S_Random = Random.Shared;
-#else
-            S_Random = new Random();
-#endif
             s_isRunningInCI = InitIsRunningInCI();
             s_isVerbose = InitIsVerbose();
 
@@ -450,12 +443,12 @@ protected async Task WithTemporaryChannelAsync(Func<IChannel, Task> action)
 
         protected string GenerateExchangeName()
         {
-            return $"{_testDisplayName}-exchange-{Guid.NewGuid()}";
+            return $"{_testDisplayName}-exchange-{Now}-{GenerateShortUuid()}";
         }
 
         protected string GenerateQueueName()
         {
-            return $"{_testDisplayName}-queue-{Guid.NewGuid()}";
+            return $"{_testDisplayName}-queue-{Now}-{GenerateShortUuid()}";
         }
 
         protected Task WithTemporaryNonExclusiveQueueAsync(Func<IChannel, string, Task> action)
@@ -540,7 +533,7 @@ protected ConnectionFactory CreateConnectionFactory(
         {
             return new ConnectionFactory
             {
-                ClientProvidedName = $"{_testDisplayName}:{Util.Now}:{GetConnectionIdx()}",
+                ClientProvidedName = $"{_testDisplayName}:{Now}:{GetConnectionIdx()}",
                 ContinuationTimeout = WaitSpan,
                 HandshakeContinuationTimeout = WaitSpan,
                 ConsumerDispatchConcurrency = consumerDispatchConcurrency
@@ -631,10 +624,16 @@ protected static string GetUniqueString(ushort length)
         protected static byte[] GetRandomBody(ushort size = 1024)
         {
             byte[] body = new byte[size];
-            S_Random.NextBytes(body);
+            Util.S_Random.NextBytes(body);
             return body;
         }
 
+        protected static string Now => Util.Now;
+
+        protected static string GenerateShortUuid() => Util.GenerateShortUuid();
+
+        protected static int RandomNext(int min, int max) => Util.S_Random.Next(min, max);
+
         protected static Task WaitForRecoveryAsync(IConnection conn)
         {
             TaskCompletionSource<bool> tcs = PrepareForRecovery((AutorecoveringConnection)conn);
diff --git a/projects/Test/Common/Util.cs b/projects/Test/Common/Util.cs
@@ -10,6 +10,13 @@ namespace Test
 {
     public class Util : IDisposable
     {
+#if NET
+        private static readonly Random s_random = Random.Shared;
+#else
+        [ThreadStatic]
+        private static Random s_random;
+#endif
+
         private readonly ITestOutputHelper _output;
         private readonly ManagementClient _managementClient;
         private static readonly bool s_isWindows = false;
@@ -41,6 +48,21 @@ public Util(ITestOutputHelper output, string managementUsername, string manageme
             _managementClient = new ManagementClient(managementUri, managementUsername, managementPassword);
         }
 
+        public static Random S_Random
+        {
+            get
+            {
+#if NET
+                return s_random;
+#else
+                s_random ??= new Random();
+                return s_random;
+#endif
+            }
+        }
+
+        public static string GenerateShortUuid() => S_Random.Next().ToString("x");
+
         public static string Now => DateTime.UtcNow.ToString("s", CultureInfo.InvariantCulture);
 
         public static bool IsWindows => s_isWindows;
diff --git a/projects/Test/Integration/TestAsyncConsumer.cs b/projects/Test/Integration/TestAsyncConsumer.cs
@@ -703,7 +703,7 @@ await _channel.BasicPublishAsync(exchange: string.Empty, routingKey: queueName,
 
         private async Task ValidateConsumerDispatchConcurrency()
         {
-            ushort expectedConsumerDispatchConcurrency = (ushort)S_Random.Next(3, 10);
+            ushort expectedConsumerDispatchConcurrency = (ushort)RandomNext(3, 10);
             AutorecoveringChannel autorecoveringChannel = (AutorecoveringChannel)_channel;
             Assert.Equal(ConsumerDispatchConcurrency, autorecoveringChannel.ConsumerDispatcher.Concurrency);
             Assert.Equal(_consumerDispatchConcurrency, autorecoveringChannel.ConsumerDispatcher.Concurrency);
diff --git a/projects/Test/Integration/TestConcurrentAccessBase.cs.cs b/projects/Test/Integration/TestConcurrentAccessBase.cs.cs
@@ -54,7 +54,7 @@ protected async Task TestConcurrentOperationsAsync(Func<Task> action, int iterat
             {
                 for (int j = 0; j < iterations; j++)
                 {
-                    await Task.Delay(S_Random.Next(1, 10));
+                    await Task.Delay(RandomNext(1, 10));
                     tasks.Add(action());
                 }
             }
diff --git a/projects/Test/Integration/TestConnectionRecoveryWithoutSetup.cs b/projects/Test/Integration/TestConnectionRecoveryWithoutSetup.cs
@@ -114,7 +114,7 @@ public async Task TestConsumerWorkServiceRecovery()
             await using AutorecoveringConnection c = await CreateAutorecoveringConnectionAsync();
             await using (IChannel ch = await c.CreateChannelAsync())
             {
-                string q = (await ch.QueueDeclareAsync("dotnet-client.recovery.consumer_work_pool1",
+                string q = (await ch.QueueDeclareAsync(GenerateQueueName(),
                     false, false, false)).QueueName;
                 var cons = new AsyncEventingBasicConsumer(ch);
                 await ch.BasicConsumeAsync(q, true, cons);
@@ -143,7 +143,7 @@ public async Task TestConsumerWorkServiceRecovery()
         [Fact]
         public async Task TestConsumerRecoveryOnClientNamedQueueWithOneRecovery()
         {
-            const string q0 = "dotnet-client.recovery.queue1";
+            string q0 = GenerateQueueName();
             // connection #1
             await using AutorecoveringConnection c = await CreateAutorecoveringConnectionAsync();
             await using (IChannel ch = await c.CreateChannelAsync())
@@ -364,8 +364,7 @@ public async Task TestTopologyRecoveryConsumerFilter()
         [Fact]
         public async Task TestRecoveryWithTopologyDisabled()
         {
-            string queueName = GenerateQueueName() + "-dotnet-client.test.recovery.q2";
-
+            string queueName = GenerateQueueName();
             await using AutorecoveringConnection conn = await CreateAutorecoveringConnectionWithTopologyRecoveryDisabledAsync();
             await using (IChannel ch = await conn.CreateChannelAsync())
             {
diff --git a/projects/Test/Integration/TestExchangeDeclare.cs b/projects/Test/Integration/TestExchangeDeclare.cs
@@ -62,7 +62,7 @@ async Task f()
                 {
                     try
                     {
-                        await Task.Delay(S_Random.Next(5, 50));
+                        await Task.Delay(RandomNext(5, 50));
                         string exchangeName = GenerateExchangeName();
                         await _channel.ExchangeDeclareAsync(exchange: exchangeName, type: "fanout", false, false);
                         await _channel.ExchangeBindAsync(destination: ex_destination, source: exchangeName, routingKey: "unused");
@@ -87,7 +87,7 @@ async Task f()
                 {
                     try
                     {
-                        await Task.Delay(S_Random.Next(5, 50));
+                        await Task.Delay(RandomNext(5, 50));
                         await _channel.ExchangeUnbindAsync(destination: ex_destination, source: exchangeName, routingKey: "unused",
                             noWait: false, arguments: null);
                         await _channel.ExchangeDeleteAsync(exchange: exchangeName, ifUnused: false);
diff --git a/projects/Test/Integration/TestQueueDeclare.cs b/projects/Test/Integration/TestQueueDeclare.cs
@@ -103,7 +103,7 @@ async Task f()
                     {
                         // sleep for a random amount of time to increase the chances
                         // of thread interleaving. MK.
-                        await Task.Delay(S_Random.Next(5, 50));
+                        await Task.Delay(RandomNext(5, 50));
                         string queueName = GenerateQueueName();
                         QueueDeclareOk r = await _channel.QueueDeclareAsync(queue: queueName,
                             durable: false, exclusive: true, autoDelete: false);
@@ -136,7 +136,7 @@ async Task f()
                     string qname = q;
                     try
                     {
-                        await Task.Delay(S_Random.Next(5, 50));
+                        await Task.Delay(RandomNext(5, 50));
 
                         QueueDeclareOk r = await _channel.QueueDeclarePassiveAsync(qname);
                         Assert.Equal(qname, r.QueueName);
@@ -176,7 +176,7 @@ public async Task TestConcurrentQueueDeclare()
                             {
                                 // sleep for a random amount of time to increase the chances
                                 // of thread interleaving. MK.
-                                await Task.Delay(S_Random.Next(5, 50));
+                                await Task.Delay(RandomNext(5, 50));
                                 string q = GenerateQueueName();
                                 await _channel.QueueDeclareAsync(q, false, false, false);
                                 queueNames.Add(q);
@@ -201,7 +201,7 @@ public async Task TestConcurrentQueueDeclare()
                         {
                             try
                             {
-                                await Task.Delay(S_Random.Next(5, 50));
+                                await Task.Delay(RandomNext(5, 50));
                                 await _channel.QueueDeleteAsync(queueName);
                             }
                             catch (NotSupportedException e)
diff --git a/projects/Test/Integration/TestToxiproxy.cs b/projects/Test/Integration/TestToxiproxy.cs
@@ -221,7 +221,11 @@ public async Task TestThatStoppedSocketResultsInHeartbeatTimeout()
 
             Assert.True(await tcs.Task);
 
-            var timeoutToxic = new TimeoutToxic();
+            string toxicName = $"rmq-localhost-timeout-{Now}-{GenerateShortUuid()}";
+            var timeoutToxic = new TimeoutToxic
+            {
+                Name = toxicName
+            };
             timeoutToxic.Attributes.Timeout = 0;
             timeoutToxic.Toxicity = 1.0;
 
@@ -271,9 +275,11 @@ public async Task TestTcpReset_GH1464()
 
             Assert.True(await channelCreatedTcs.Task);
 
-            const string toxicName = "rmq-localhost-reset_peer";
-            var resetPeerToxic = new ResetPeerToxic();
-            resetPeerToxic.Name = toxicName;
+            string toxicName = $"rmq-localhost-reset_peer-{Now}-{GenerateShortUuid()}";
+            var resetPeerToxic = new ResetPeerToxic
+            {
+                Name = toxicName
+            };
             resetPeerToxic.Attributes.Timeout = 500;
             resetPeerToxic.Toxicity = 1.0;
 
@@ -354,9 +360,11 @@ public async Task TestPublisherConfirmationThrottling()
 
             await channelCreatedTcs.Task;
 
-            const string toxicName = "rmq-localhost-bandwidth";
-            var bandwidthToxic = new BandwidthToxic();
-            bandwidthToxic.Name = toxicName;
+            string toxicName = $"rmq-localhost-bandwidth-{Now}-{GenerateShortUuid()}";
+            var bandwidthToxic = new BandwidthToxic
+            {
+                Name = toxicName
+            };
             bandwidthToxic.Attributes.Rate = 0;
             bandwidthToxic.Toxicity = 1.0;
             bandwidthToxic.Stream = ToxicDirection.DownStream;
diff --git a/projects/Test/Integration/ToxiproxyManager.cs b/projects/Test/Integration/ToxiproxyManager.cs
@@ -2,14 +2,15 @@
 using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
+using Test;
 using Toxiproxy.Net;
 using Toxiproxy.Net.Toxics;
 
 namespace Integration
 {
     public class ToxiproxyManager : IDisposable
     {
-        private const string ProxyNamePrefix = "rmq-";
+        private const string ProxyNamePrefix = "rmq";
         private const ushort ProxyPortStart = 55669;
         private static int s_proxyPort = ProxyPortStart;
 
@@ -68,7 +69,7 @@ public ToxiproxyManager(string testDisplayName, bool isRunningInCI, bool isWindo
 
         public async Task InitializeAsync()
         {
-            _proxy.Name = $"{ProxyNamePrefix}{_testDisplayName}";
+            _proxy.Name = $"{ProxyNamePrefix}-{_testDisplayName}-{Util.Now}-{Util.GenerateShortUuid()}";
 
             try
             {

Original file line number	Diff line number	Diff line change
`@@ -84,16 +84,9 @@ public abstract class IntegrationFixture : IAsyncLifetime`
`84`	`84`	`public static readonly TimeSpan RecoveryInterval = TimeSpan.FromSeconds(2);`
`85`	`85`	`public static readonly TimeSpan TestTimeout = TimeSpan.FromSeconds(5);`
`86`	`86`	`public static readonly TimeSpan RequestedConnectionTimeout = TimeSpan.FromSeconds(1);`
`87`		`- public static readonly Random S_Random;`
`88`	`87`
`89`	`88`	`static IntegrationFixture()`
`90`	`89`	`{`
`91`		`-`
`92`		`-#if NET`
`93`		`- S_Random = Random.Shared;`
`94`		`-#else`
`95`		`- S_Random = new Random();`
`96`		`-#endif`
`97`	`90`	`s_isRunningInCI = InitIsRunningInCI();`
`98`	`91`	`s_isVerbose = InitIsVerbose();`
`99`	`92`
`@@ -450,12 +443,12 @@ protected async Task WithTemporaryChannelAsync(Func<IChannel, Task> action)`
`450`	`443`
`451`	`444`	`protected string GenerateExchangeName()`
`452`	`445`	`{`
`453`		`- return $"{_testDisplayName}-exchange-{Guid.NewGuid()}";`
	`446`	`+ return $"{_testDisplayName}-exchange-{Now}-{GenerateShortUuid()}";`
`454`	`447`	`}`
`455`	`448`
`456`	`449`	`protected string GenerateQueueName()`
`457`	`450`	`{`
`458`		`- return $"{_testDisplayName}-queue-{Guid.NewGuid()}";`
	`451`	`+ return $"{_testDisplayName}-queue-{Now}-{GenerateShortUuid()}";`
`459`	`452`	`}`
`460`	`453`
`461`	`454`	`protected Task WithTemporaryNonExclusiveQueueAsync(Func<IChannel, string, Task> action)`
`@@ -540,7 +533,7 @@ protected ConnectionFactory CreateConnectionFactory(`
`540`	`533`	`{`
`541`	`534`	`return new ConnectionFactory`
`542`	`535`	`{`
`543`		`- ClientProvidedName = $"{_testDisplayName}:{Util.Now}:{GetConnectionIdx()}",`
	`536`	`+ ClientProvidedName = $"{_testDisplayName}:{Now}:{GetConnectionIdx()}",`
`544`	`537`	`ContinuationTimeout = WaitSpan,`
`545`	`538`	`HandshakeContinuationTimeout = WaitSpan,`
`546`	`539`	`ConsumerDispatchConcurrency = consumerDispatchConcurrency`
`@@ -631,10 +624,16 @@ protected static string GetUniqueString(ushort length)`
`631`	`624`	`protected static byte[] GetRandomBody(ushort size = 1024)`
`632`	`625`	`{`
`633`	`626`	`byte[] body = new byte[size];`
`634`		`- S_Random.NextBytes(body);`
	`627`	`+ Util.S_Random.NextBytes(body);`
`635`	`628`	`return body;`
`636`	`629`	`}`
`637`	`630`
	`631`	`+ protected static string Now => Util.Now;`
	`632`	`+`
	`633`	`+ protected static string GenerateShortUuid() => Util.GenerateShortUuid();`
	`634`	`+`
	`635`	`+ protected static int RandomNext(int min, int max) => Util.S_Random.Next(min, max);`
	`636`	`+`
`638`	`637`	`protected static Task WaitForRecoveryAsync(IConnection conn)`
`639`	`638`	`{`
`640`	`639`	`TaskCompletionSource<bool> tcs = PrepareForRecovery((AutorecoveringConnection)conn);`
Original file line number	Diff line number	Diff line change
`@@ -703,7 +703,7 @@ await _channel.BasicPublishAsync(exchange: string.Empty, routingKey: queueName,`
`703`	`703`
`704`	`704`	`private async Task ValidateConsumerDispatchConcurrency()`
`705`	`705`	`{`
`706`		`- ushort expectedConsumerDispatchConcurrency = (ushort)S_Random.Next(3, 10);`
	`706`	`+ ushort expectedConsumerDispatchConcurrency = (ushort)RandomNext(3, 10);`
`707`	`707`	`AutorecoveringChannel autorecoveringChannel = (AutorecoveringChannel)_channel;`
`708`	`708`	`Assert.Equal(ConsumerDispatchConcurrency, autorecoveringChannel.ConsumerDispatcher.Concurrency);`
`709`	`709`	`Assert.Equal(_consumerDispatchConcurrency, autorecoveringChannel.ConsumerDispatcher.Concurrency);`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ protected async Task TestConcurrentOperationsAsync(Func<Task> action, int iterat`
`54`	`54`	`{`
`55`	`55`	`for (int j = 0; j < iterations; j++)`
`56`	`56`	`{`
`57`		`- await Task.Delay(S_Random.Next(1, 10));`
	`57`	`+ await Task.Delay(RandomNext(1, 10));`
`58`	`58`	`tasks.Add(action());`
`59`	`59`	`}`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ async Task f()`
`62`	`62`	`{`
`63`	`63`	`try`
`64`	`64`	`{`
`65`		`- await Task.Delay(S_Random.Next(5, 50));`
	`65`	`+ await Task.Delay(RandomNext(5, 50));`
`66`	`66`	`string exchangeName = GenerateExchangeName();`
`67`	`67`	`await _channel.ExchangeDeclareAsync(exchange: exchangeName, type: "fanout", false, false);`
`68`	`68`	`await _channel.ExchangeBindAsync(destination: ex_destination, source: exchangeName, routingKey: "unused");`
`@@ -87,7 +87,7 @@ async Task f()`
`87`	`87`	`{`
`88`	`88`	`try`
`89`	`89`	`{`
`90`		`- await Task.Delay(S_Random.Next(5, 50));`
	`90`	`+ await Task.Delay(RandomNext(5, 50));`
`91`	`91`	`await _channel.ExchangeUnbindAsync(destination: ex_destination, source: exchangeName, routingKey: "unused",`
`92`	`92`	`noWait: false, arguments: null);`
`93`	`93`	`await _channel.ExchangeDeleteAsync(exchange: exchangeName, ifUnused: false);`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ async Task f()`
`103`	`103`	`{`
`104`	`104`	`// sleep for a random amount of time to increase the chances`
`105`	`105`	`// of thread interleaving. MK.`
`106`		`- await Task.Delay(S_Random.Next(5, 50));`
	`106`	`+ await Task.Delay(RandomNext(5, 50));`
`107`	`107`	`string queueName = GenerateQueueName();`
`108`	`108`	`QueueDeclareOk r = await _channel.QueueDeclareAsync(queue: queueName,`
`109`	`109`	`durable: false, exclusive: true, autoDelete: false);`
`@@ -136,7 +136,7 @@ async Task f()`
`136`	`136`	`string qname = q;`
`137`	`137`	`try`
`138`	`138`	`{`
`139`		`- await Task.Delay(S_Random.Next(5, 50));`
	`139`	`+ await Task.Delay(RandomNext(5, 50));`
`140`	`140`
`141`	`141`	`QueueDeclareOk r = await _channel.QueueDeclarePassiveAsync(qname);`
`142`	`142`	`Assert.Equal(qname, r.QueueName);`
`@@ -176,7 +176,7 @@ public async Task TestConcurrentQueueDeclare()`
`176`	`176`	`{`
`177`	`177`	`// sleep for a random amount of time to increase the chances`
`178`	`178`	`// of thread interleaving. MK.`
`179`		`- await Task.Delay(S_Random.Next(5, 50));`
	`179`	`+ await Task.Delay(RandomNext(5, 50));`
`180`	`180`	`string q = GenerateQueueName();`
`181`	`181`	`await _channel.QueueDeclareAsync(q, false, false, false);`
`182`	`182`	`queueNames.Add(q);`
`@@ -201,7 +201,7 @@ public async Task TestConcurrentQueueDeclare()`
`201`	`201`	`{`
`202`	`202`	`try`
`203`	`203`	`{`
`204`		`- await Task.Delay(S_Random.Next(5, 50));`
	`204`	`+ await Task.Delay(RandomNext(5, 50));`
`205`	`205`	`await _channel.QueueDeleteAsync(queueName);`
`206`	`206`	`}`
`207`	`207`	`catch (NotSupportedException e)`
Original file line number	Diff line number	Diff line change
`@@ -2,14 +2,15 @@`
`2`	`2`	`using System.Net;`
`3`	`3`	`using System.Threading;`
`4`	`4`	`using System.Threading.Tasks;`
	`5`	`+using Test;`
`5`	`6`	`using Toxiproxy.Net;`
`6`	`7`	`using Toxiproxy.Net.Toxics;`
`7`	`8`
`8`	`9`	`namespace Integration`
`9`	`10`	`{`
`10`	`11`	`public class ToxiproxyManager : IDisposable`
`11`	`12`	`{`
`12`		`- private const string ProxyNamePrefix = "rmq-";`
	`13`	`+ private const string ProxyNamePrefix = "rmq";`
`13`	`14`	`private const ushort ProxyPortStart = 55669;`
`14`	`15`	`private static int s_proxyPort = ProxyPortStart;`
`15`	`16`
`@@ -68,7 +69,7 @@ public ToxiproxyManager(string testDisplayName, bool isRunningInCI, bool isWindo`
`68`	`69`
`69`	`70`	`public async Task InitializeAsync()`
`70`	`71`	`{`
`71`		`- _proxy.Name = $"{ProxyNamePrefix}{_testDisplayName}";`
	`72`	`+ _proxy.Name = $"{ProxyNamePrefix}-{_testDisplayName}-{Util.Now}-{Util.GenerateShortUuid()}";`
`72`	`73`
`73`	`74`	`try`
`74`	`75`	`{`