Finished making integration test.

Author: Anton Vorontsov

tests/RabbitMQ.Client.Core.DependencyInjection.Tests/IntegrationTests/QueueServiceTests.cs

@@ -15,33 +15,14 @@ namespace RabbitMQ.Client.Core.DependencyInjection.Tests.IntegrationTests
     public class QueueServiceTests
     {
         readonly TimeSpan _globalTestsTimeout = TimeSpan.FromSeconds(60);
+
+        const string DefaultExchangeName = "exchange.name";
+        const string FirstRoutingKey = "first.routing.key";
+        const string SecondRoutingKey = "second.routing.key";
 
         [Fact]
         public async Task ShouldProperlyPublishAndConsumeMessages()
         {
-            var clientOptions = new RabbitMqClientOptions
-            {
-                HostName = "rabbitmq",
-                Port = 5672,
-                UserName = "guest",
-                Password = "guest",
-                VirtualHost = "/"
-            };
-            
-            var exchangeOptions = new RabbitMqExchangeOptions
-            {
-                Type = "direct",
-                DeadLetterExchange = "exchange.dlx",
-                Queues = new List<RabbitMqQueueOptions>
-                {
-                    new RabbitMqQueueOptions
-                    {
-                        Name = "test.queue",
-                        RoutingKeys = new HashSet<string> { "routing.key" }
-                    }
-                }
-            };
-
             var connectionFactoryMock = new Mock<RabbitMqConnectionFactory> { CallBase = true }
                 .As<IRabbitMqConnectionFactory>();
 
@@ -59,23 +40,56 @@ public async Task ShouldProperlyPublishAndConsumeMessages()
             serviceCollection
                 .AddSingleton(connectionFactoryMock.Object)
                 .AddSingleton(callerMock.Object)
-                .AddRabbitMqClient(clientOptions)
-                .AddConsumptionExchange("exchange.name", exchangeOptions)
-                .AddMessageHandlerTransient<StubMessageHandler>("routing.key");
+                .AddRabbitMqClient(GetClientOptions())
+                .AddConsumptionExchange(DefaultExchangeName, GetExchangeOptions())
+                .AddMessageHandlerTransient<StubMessageHandler>(FirstRoutingKey)
+                .AddNonCyclicMessageHandlerTransient<StubNonCyclicMessageHandler>(FirstRoutingKey)
+                .AddAsyncMessageHandlerTransient<StubAsyncMessageHandler>(SecondRoutingKey)
+                .AddAsyncNonCyclicMessageHandlerTransient<StubAsyncNonCyclicMessageHandler>(SecondRoutingKey);
 
             var serviceProvider = serviceCollection.BuildServiceProvider();
             var queueService = serviceProvider.GetRequiredService<IQueueService>();
             queueService.StartConsuming();
 
             var resetEvent = new AutoResetEvent(false);
-            consumer.Received += async (sender, @event) =>
+            consumer.Received += (sender, @event) =>
             {
                 resetEvent.Set();
+                return Task.CompletedTask;
             };
 
-            await queueService.SendAsync("message", "exchange.name", "routing.key");
+            await queueService.SendAsync(new { Message = "message" }, DefaultExchangeName, FirstRoutingKey);
             resetEvent.WaitOne(_globalTestsTimeout);
-            callerMock.Verify(x => x.Call(It.IsAny<string>()), Times.Once);
+            callerMock.Verify(x => x.Call(It.IsAny<string>()), Times.Exactly(2));
+            
+            await queueService.SendAsync(new { Message = "message" }, DefaultExchangeName, SecondRoutingKey);
+            resetEvent.WaitOne(_globalTestsTimeout);
+            callerMock.Verify(x => x.CallAsync(It.IsAny<string>()), Times.Exactly(2));
         }
+
+        RabbitMqClientOptions GetClientOptions() =>
+            new RabbitMqClientOptions
+            {
+                HostName = "rabbitmq",
+                Port = 5672,
+                UserName = "guest",
+                Password = "guest",
+                VirtualHost = "/"
+            };
+
+        RabbitMqExchangeOptions GetExchangeOptions() =>
+            new RabbitMqExchangeOptions
+            {
+                Type = "direct",
+                DeadLetterExchange = "exchange.dlx",
+                Queues = new List<RabbitMqQueueOptions>
+                {
+                    new RabbitMqQueueOptions
+                    {
+                        Name = "test.queue",
+                        RoutingKeys = new HashSet<string> { FirstRoutingKey, SecondRoutingKey }
+                    }
+                }
+            };
     }
 }

tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/IStubCaller.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 
 namespace RabbitMQ.Client.Core.DependencyInjection.Tests.Stubs
 {
@@ -9,5 +10,7 @@ public interface IStubCaller
         void Call(ReadOnlyMemory<byte> message);
 
         void Call(string message);
+        
+        Task CallAsync(string message);
     }
 }

tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubAsyncMessageHandler.cs

@@ -1,15 +1,20 @@
-using System;
 using System.Threading.Tasks;
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
 
 namespace RabbitMQ.Client.Core.DependencyInjection.Tests.Stubs
 {
     public class StubAsyncMessageHandler : IAsyncMessageHandler
     {
-        public Task Handle(string message, string routingKey)
+        readonly IStubCaller _caller;
+        
+        public StubAsyncMessageHandler(IStubCaller caller)
         {
-            Console.WriteLine($"{message}:{routingKey}");
-            return Task.CompletedTask;
+            _caller = caller;
+        }
+        
+        public async Task Handle(string message, string routingKey)
+        {
+            await _caller.CallAsync($"{message}:{routingKey}");
         }
     }
 }

tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubAsyncNonCyclicMessageHandler.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Threading.Tasks;
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
 using RabbitMQ.Client.Core.DependencyInjection.Services;
@@ -7,10 +6,16 @@ namespace RabbitMQ.Client.Core.DependencyInjection.Tests.Stubs
 {
     public class StubAsyncNonCyclicMessageHandler : IAsyncNonCyclicMessageHandler
     {
-        public Task Handle(string message, string routingKey, IQueueService queueService)
+        readonly IStubCaller _caller;
+        
+        public StubAsyncNonCyclicMessageHandler(IStubCaller caller)
         {
-            Console.WriteLine($"{message}:{routingKey}:{queueService.GetType()}");
-            return Task.CompletedTask;
+            _caller = caller;
+        }
+        
+        public async Task Handle(string message, string routingKey, IQueueService queueService)
+        {
+            await _caller.CallAsync($"{message}:{routingKey}:{queueService.GetType()}");
         }
     }
 }

tests/RabbitMQ.Client.Core.DependencyInjection.Tests/Stubs/StubNonCyclicMessageHandler.cs

@@ -1,14 +1,20 @@
-using System;
 using RabbitMQ.Client.Core.DependencyInjection.MessageHandlers;
 using RabbitMQ.Client.Core.DependencyInjection.Services;
 
 namespace RabbitMQ.Client.Core.DependencyInjection.Tests.Stubs
 {
     public class StubNonCyclicMessageHandler : INonCyclicMessageHandler
     {
+        readonly IStubCaller _caller;
+        
+        public StubNonCyclicMessageHandler(IStubCaller caller)
+        {
+            _caller = caller;
+        }
+        
         public void Handle(string message, string routingKey, IQueueService queueService)
         {
-            Console.WriteLine($"{message}:{routingKey}:{queueService.GetType()}");
+            _caller.Call($"{message}:{routingKey}:{queueService.GetType()}");
         }
     }
 }