Set up some DI logic tests

Author: Anton Vorontsov

readme.md

@@ -175,10 +175,6 @@ Exchange sections define how to bind queues and exchanges with each other using
 
 For more information about `appsettings.json` and manual configuration features, see [rabbit-configuration](./docs/rabbit-configuration.md) and [exchange-configuration](./docs/exchange-configuration.md) documentation files.
 
-## Versioning
-
-For now this project uses semantic versioning that follows .Net Core versioning. That means that major and minor versions are equal to .Net Core major and minor versions but patch versions will be used independently.
-
 ## Changelog
 
 All notable changes are being tracked in the [changelog](./docs/changelog.md) file.

src/RabbitMQ.Client.Core.DependencyInjection/MessageHandlerDependencyInjectionExtensions.cs

@@ -840,8 +840,9 @@ static void MessageHandlerOrderingModelExists<TImplementation>(IServiceCollectio
         {
             var messageHandlerOrderingModel = services.FirstOrDefault(x => x.ServiceType == typeof(MessageHandlerOrderingModel)
                 && x.Lifetime == ServiceLifetime.Singleton
-                && x.ImplementationType == typeof(TImplementation)
-                && string.Equals(((MessageHandlerOrderingModel)x.ImplementationInstance).Exchange, exchange, StringComparison.OrdinalIgnoreCase)
+                && ((MessageHandlerOrderingModel)x.ImplementationInstance).MessageHandlerType == typeof(TImplementation)
+                && (string.Equals(((MessageHandlerOrderingModel)x.ImplementationInstance).Exchange, exchange, StringComparison.OrdinalIgnoreCase) 
+                    || (exchange is null && ((MessageHandlerOrderingModel)x.ImplementationInstance).Exchange is null))
                 && ((MessageHandlerOrderingModel)x.ImplementationInstance).Order != order
                 && routePatterns.Intersect(((MessageHandlerOrderingModel)x.ImplementationInstance).RoutePatterns).Any());
             if (messageHandlerOrderingModel is null)

tests/RabbitMQ.Client.Core.DependencyInjection.Tests/UnitTests/MessageHandlerDependencyInjectionExtensionsTests.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using RabbitMQ.Client.Core.DependencyInjection.Tests.UnitTests.Stubs;
+using Xunit;
+
+namespace RabbitMQ.Client.Core.DependencyInjection.Tests.UnitTests
+{
+    public class MessageHandlerDependencyInjectionExtensionsTests
+    {
+        [Fact]
+        public async Task ShouldProperlyThrowExceptionWhenRegisteringSameMessageHandlerTwiceForOneRoutingKeyWithDifferentOrder()
+        {
+            await Assert.ThrowsAsync<ArgumentException>(() =>
+                {
+                    new ServiceCollection()
+                        .AddMessageHandlerTransient<StubMessageHandler>("routing.key", 0)
+                        .AddMessageHandlerTransient<StubMessageHandler>("routing.key", 1);
+                    return Task.CompletedTask;
+                });
+        }
+        
+        [Fact]
+        public async Task ShouldProperlyThrowExceptionWhenRegisteringSameAsyncMessageHandlerTwiceForOneRoutingKeyWithDifferentOrder()
+        {
+            await Assert.ThrowsAsync<ArgumentException>(() =>
+            {
+                new ServiceCollection()
+                    .AddAsyncMessageHandlerTransient<StubAsyncMessageHandler>("routing.key", 0)
+                    .AddAsyncMessageHandlerTransient<StubAsyncMessageHandler>("routing.key", 1);
+                return Task.CompletedTask;
+            });
+        }
+        
+        [Fact]
+        public async Task ShouldProperlyThrowExceptionWhenRegisteringSameNonCyclicMessageHandlerTwiceForOneRoutingKeyWithDifferentOrder()
+        {
+            await Assert.ThrowsAsync<ArgumentException>(() =>
+            {
+                new ServiceCollection()
+                    .AddNonCyclicMessageHandlerTransient<StubNonCyclicMessageHandler>("routing.key", 0)
+                    .AddNonCyclicMessageHandlerTransient<StubNonCyclicMessageHandler>("routing.key", 1);
+                return Task.CompletedTask;
+            });
+        }
+        
+        [Fact]
+        public async Task ShouldProperlyThrowExceptionWhenRegisteringSameAsyncNonCyclicMessageHandlerTwiceForOneRoutingKeyWithDifferentOrder()
+        {
+            await Assert.ThrowsAsync<ArgumentException>(() =>
+            {
+                new ServiceCollection()
+                    .AddAsyncNonCyclicMessageHandlerTransient<StubAsyncNonCyclicMessageHandler>("routing.key", 0)
+                    .AddAsyncNonCyclicMessageHandlerTransient<StubAsyncNonCyclicMessageHandler>("routing.key", 1);
+                return Task.CompletedTask;
+            });
+        }
+    }
+}

tests/RabbitMQ.Client.Core.DependencyInjection.Tests/UnitTests/RabbitMqExchangeDependencyInjectionExtensionsTests.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using RabbitMQ.Client.Core.DependencyInjection.Configuration;
+using Xunit;
+
+namespace RabbitMQ.Client.Core.DependencyInjection.Tests.UnitTests
+{
+    public class RabbitMqExchangeDependencyInjectionExtensionsTests
+    {
+        [Fact]
+        public async Task ShouldProperlyThrowExceptionWhenRegisteringSameExchangeWithSameNameAndOptionsTwice()
+        {
+            await Assert.ThrowsAsync<ArgumentException>(() =>
+            {
+                new ServiceCollection()
+                    .AddExchange("exchange.name", true, new RabbitMqExchangeOptions())
+                    .AddExchange("exchange.name", false, new RabbitMqExchangeOptions());
+                return Task.CompletedTask;
+            });
+        }
+        
+        [Fact]
+        public async Task ShouldProperlyThrowExceptionWhenRegisteringSameExchangeWithSameNameAndConfigurationTwice()
+        {
+            await Assert.ThrowsAsync<ArgumentException>(() =>
+            {
+                var configurationMock = new Mock<IConfiguration>();
+                new ServiceCollection()
+                    .AddExchange("exchange.name", true, configurationMock.Object)
+                    .AddExchange("exchange.name", false, configurationMock.Object);
+                return Task.CompletedTask;
+            });
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+using System;
+using System.Threading.Tasks;
+
+namespace RabbitMQ.Client.Core.DependencyInjection.Tests.UnitTests.Stubs
+{
+    internal class StubAsyncMessageHandler : IAsyncMessageHandler
+    {
+        public Task Handle(string message, string routingKey)
+        {
+            Console.WriteLine($"{message}:{routingKey}");
+            return Task.CompletedTask;
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+using System;
+using System.Threading.Tasks;
+
+namespace RabbitMQ.Client.Core.DependencyInjection.Tests.UnitTests.Stubs
+{
+    internal class StubAsyncNonCyclicMessageHandler : IAsyncNonCyclicMessageHandler
+    {
+        public Task Handle(string message, string routingKey, IQueueService queueService)
+        {
+            Console.WriteLine($"{message}:{routingKey}:{queueService.GetType()}");
+            return Task.CompletedTask;
+        }
+    }
+}

tests/RabbitMQ.Client.Core.DependencyInjection.Tests/UnitTests/Stubs/StubMessageHandler.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace RabbitMQ.Client.Core.DependencyInjection.Tests.UnitTests.Stubs
+{
+    internal class StubMessageHandler : IMessageHandler
+    {
+        public void Handle(string message, string routingKey)
+        {
+            Console.WriteLine($"{message}:{routingKey}");
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+using System;
+
+namespace RabbitMQ.Client.Core.DependencyInjection.Tests.UnitTests.Stubs
+{
+    internal class StubNonCyclicMessageHandler : INonCyclicMessageHandler
+    {
+        public void Handle(string message, string routingKey, IQueueService queueService)
+        {
+            Console.WriteLine($"{message}:{routingKey}:{queueService.GetType()}");
+        }
+    }
+}