MessageDescriptor can be created from types with no namespace (#49)

Nybus-project · Jan 22, 2019 · d300e95 · d300e95
1 parent c1e1c06
commit d300e95
Show file tree

Hide file tree

Showing 7 changed files with 246 additions and 3 deletions.
diff --git a/src/Nybus.Abstractions/Message.cs b/src/Nybus.Abstractions/Message.cs
@@ -96,10 +96,10 @@ public TEvent Event
     [AttributeUsage(AttributeTargets.Class)]
     public class MessageAttribute : Attribute
     {
-        public MessageAttribute(string name, string @namespace)
+        public MessageAttribute(string name, string @namespace = null)
         {
             Name = name ?? throw new ArgumentNullException(nameof(name));
-            Namespace = @namespace ?? throw new ArgumentNullException(nameof(@namespace));
+            Namespace = @namespace ?? MessageDescriptor.NamespaceFallback;
         }
 
         public string Name { get; }

diff --git a/src/Nybus.Abstractions/Utils/IMessageDescriptorStore.cs b/src/Nybus.Abstractions/Utils/IMessageDescriptorStore.cs
@@ -27,6 +27,8 @@ bool RegisterEventType<TEvent>()
 
     public class MessageDescriptor
     {
+        public const string NamespaceFallback = "$";
+
         public static MessageDescriptor CreateFromType(Type type)
         {
             if (type == null)
@@ -73,7 +75,7 @@ public static bool TryParse(string descriptorName, out MessageDescriptor descrip
         public MessageDescriptor(string name, string @namespace)
         {
             Name = name ?? throw new ArgumentNullException(nameof(name));
-            Namespace = @namespace ?? throw new ArgumentNullException(nameof(@namespace));
+            Namespace = @namespace ?? NamespaceFallback;
         }
 
         public string Name { get; }

diff --git a/tests/TestUtils/Commands.cs b/tests/TestUtils/Commands.cs
@@ -51,3 +51,8 @@ public class AttributeTestCommand : ICommand
         public string Message { get; set; }
     }
 }
+
+public class NoNamespaceCommand : ICommand
+{
+    public string Message { get; set; }
+}
diff --git a/tests/TestUtils/Events.cs b/tests/TestUtils/Events.cs
@@ -47,4 +47,9 @@ public class AttributeTestEvent : IEvent
     {
         public string Message { get; set; }
     }
+}
+
+public class NoNamespaceEvent : IEvent
+{
+    public string Message { get; set; }
 }
diff --git a/tests/Tests.Nybus.Abstractions/Utils/MessageDescriptorTests.cs b/tests/Tests.Nybus.Abstractions/Utils/MessageDescriptorTests.cs
@@ -38,6 +38,19 @@ public void MessageDescriptor_can_be_created_from_type(Type type)
             Assert.That(messageDescriptor.Namespace, Is.EqualTo(type.Namespace));
         }
 
+        [Test]
+        [InlineAutoMoqData(typeof(NoNamespaceCommand))]
+        [InlineAutoMoqData(typeof(NoNamespaceEvent))]
+        public void MessageDescriptor_can_be_created_from_type_with_no_namespace(Type type)
+        {
+            Assume.That(type.Namespace, Is.Null);
+
+            var messageDescriptor = new MessageDescriptor(type);
+
+            Assert.That(messageDescriptor.Name, Is.EqualTo(type.Name));
+            Assert.That(messageDescriptor.Namespace, Is.EqualTo(MessageDescriptor.NamespaceFallback));
+        }
+
         [Test, AutoMoqData]
         public void MessageDescriptor_can_be_created_from_MessageAttribute(MessageAttribute attribute)
         {
@@ -47,6 +60,16 @@ public void MessageDescriptor_can_be_created_from_MessageAttribute(MessageAttrib
             Assert.That(messageDescriptor.Namespace, Is.EqualTo(attribute.Namespace));
         }
 
+        [Test, AutoMoqData]
+        public void MessageDescriptor_can_be_created_from_MessageAttribute_with_no_namespace(string name)
+        {
+            var attribute = new MessageAttribute(name);
+            var messageDescriptor = new MessageDescriptor(attribute);
+
+            Assert.That(messageDescriptor.Name, Is.EqualTo(attribute.Name));
+            Assert.That(messageDescriptor.Namespace, Is.EqualTo(MessageDescriptor.NamespaceFallback));
+        }
+
         [Test, CustomAutoMoqData]
         public void TryParse_return_false_if_null()
         {

diff --git a/tests/integration/Tests.Integration.Nybus.Engine.InMemory/NoNamespaceMessageTests.cs b/tests/integration/Tests.Integration.Nybus.Engine.InMemory/NoNamespaceMessageTests.cs
@@ -0,0 +1,71 @@
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Nybus;
+
+namespace Tests
+{
+    [TestFixture]
+    public class NoNamespaceMessageTests
+    {
+        [Test, AutoMoqData]
+        public async Task Host_can_loopback_commands(ServiceCollection services, NoNamespaceCommand testCommand)
+        {
+            var commandReceived = Mock.Of<CommandReceivedAsync<NoNamespaceCommand>>();
+
+            services.AddLogging(l => l.AddDebug());
+
+            services.AddNybus(nybus =>
+            {
+                nybus.UseInMemoryBusEngine();
+
+                nybus.SubscribeToCommand(commandReceived);
+            });
+
+            var serviceProvider = services.BuildServiceProvider();
+
+            var host = serviceProvider.GetRequiredService<IBusHost>();
+
+            var bus = serviceProvider.GetRequiredService<IBus>();
+
+            await host.StartAsync();
+
+            await bus.InvokeCommandAsync(testCommand);
+
+            await host.StopAsync();
+
+            Mock.Get(commandReceived).Verify(p => p(It.IsAny<IDispatcher>(), It.IsAny<ICommandContext<NoNamespaceCommand>>()), Times.Once);
+        }
+
+        [Test, AutoMoqData]
+        public async Task Host_can_loopback_events(ServiceCollection services, NoNamespaceEvent testEvent)
+        {
+            var eventReceived = Mock.Of<EventReceivedAsync<NoNamespaceEvent>>();
+
+            services.AddLogging(l => l.AddDebug());
+
+            services.AddNybus(nybus =>
+            {
+                nybus.UseInMemoryBusEngine();
+
+                nybus.SubscribeToEvent(eventReceived);
+            });
+
+            var serviceProvider = services.BuildServiceProvider();
+
+            var host = serviceProvider.GetRequiredService<IBusHost>();
+
+            var bus = serviceProvider.GetRequiredService<IBus>();
+
+            await host.StartAsync();
+
+            await bus.RaiseEventAsync(testEvent);
+
+            await host.StopAsync();
+
+            Mock.Get(eventReceived).Verify(p => p(It.IsAny<IDispatcher>(), It.IsAny<IEventContext<NoNamespaceEvent>>()), Times.Once);
+        }
+    }
+}
diff --git a/tests/integration/Tests.Integration.Nybus.Engine.RabbitMq/NoNamespaceMessageTests.cs b/tests/integration/Tests.Integration.Nybus.Engine.RabbitMq/NoNamespaceMessageTests.cs
@@ -0,0 +1,137 @@
+using System;
+using System.Threading.Tasks;
+using FakeRabbitMQ;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using Nybus;
+using Nybus.Configuration;
+using static Tests.TestUtils;
+
+namespace Tests
+{
+    [TestFixture]
+    public class NoNamespaceMessageTests
+    {
+        [Test, AutoMoqData]
+        public async Task Host_can_loopback_commands(FakeServer server, NoNamespaceCommand testCommand)
+        {
+            var commandReceived = Mock.Of<CommandReceivedAsync<NoNamespaceCommand>>();
+
+            var host = CreateNybusHost(nybus =>
+            {
+                nybus.UseRabbitMqBusEngine(rabbitMq =>
+                {
+                    rabbitMq.Configure(configuration => configuration.ConnectionFactory = server.CreateConnectionFactory());
+                });
+
+                nybus.SubscribeToCommand(commandReceived);
+            });
+
+            await host.StartAsync();
+
+            await host.Bus.InvokeCommandAsync(testCommand);
+
+            await host.StopAsync();
+
+            Mock.Get(commandReceived).Verify(p => p(It.IsAny<IDispatcher>(), It.IsAny<ICommandContext<NoNamespaceCommand>>()));
+        }
+
+        [Test, AutoMoqData]
+        public async Task Host_can_loopback_events(FakeServer server, NoNamespaceEvent testEvent)
+        {
+            var eventReceived = Mock.Of<EventReceivedAsync<NoNamespaceEvent>>();
+
+            var host = CreateNybusHost(nybus =>
+            {
+                nybus.UseRabbitMqBusEngine(rabbitMq =>
+                {
+                    rabbitMq.Configure(configuration => configuration.ConnectionFactory = server.CreateConnectionFactory());
+                });
+
+                nybus.SubscribeToEvent(eventReceived);
+            });
+
+            await host.StartAsync();
+
+            await host.Bus.RaiseEventAsync(testEvent);
+
+            await host.StopAsync();
+
+            Mock.Get(eventReceived).Verify(p => p(It.IsAny<IDispatcher>(), It.IsAny<IEventContext<NoNamespaceEvent>>()));
+        }
+
+        [Test, AutoMoqData]
+        public async Task Hosts_can_exchange_commands(FakeServer server, NoNamespaceCommand testCommand)
+        {
+            var sender = CreateNybusHost(nybus =>
+            {
+                nybus.UseRabbitMqBusEngine(rabbitMq =>
+                {
+                    rabbitMq.Configure(configuration => configuration.ConnectionFactory = server.CreateConnectionFactory());
+                });
+            });
+
+            var commandReceived = Mock.Of<CommandReceivedAsync<NoNamespaceCommand>>();
+
+            var receiver = CreateNybusHost(nybus =>
+            {
+                nybus.UseRabbitMqBusEngine(rabbitMq =>
+                {
+                    rabbitMq.Configure(configuration => configuration.ConnectionFactory = server.CreateConnectionFactory());
+                });
+
+                nybus.SubscribeToCommand(commandReceived);
+            });
+
+            await sender.StartAsync();
+
+            await receiver.StartAsync();
+
+            await sender.Bus.InvokeCommandAsync(testCommand);
+
+            await receiver.StopAsync();
+
+            await sender.StopAsync();
+
+            Mock.Get(commandReceived).Verify(p => p(It.IsAny<IDispatcher>(), It.IsAny<ICommandContext<NoNamespaceCommand>>()));
+        }
+
+        [Test, AutoMoqData]
+        public async Task Hosts_can_exchange_events(FakeServer server, NoNamespaceEvent testEvent)
+        {
+            var sender = CreateNybusHost(nybus =>
+            {
+                nybus.UseRabbitMqBusEngine(rabbitMq =>
+                {
+                    rabbitMq.Configure(configuration => configuration.ConnectionFactory = server.CreateConnectionFactory());
+                });
+            });
+
+            var eventReceived = Mock.Of<EventReceivedAsync<NoNamespaceEvent>>();
+
+            var receiver = CreateNybusHost(nybus =>
+            {
+                nybus.UseRabbitMqBusEngine(rabbitMq =>
+                {
+                    rabbitMq.Configure(configuration => configuration.ConnectionFactory = server.CreateConnectionFactory());
+                });
+
+                nybus.SubscribeToEvent(eventReceived);
+            });
+
+            await sender.StartAsync();
+
+            await receiver.StartAsync();
+
+            await sender.Bus.RaiseEventAsync(testEvent);
+
+            await receiver.StopAsync();
+
+            await sender.StopAsync();
+
+            Mock.Get(eventReceived).Verify(p => p(It.IsAny<IDispatcher>(), It.IsAny<IEventContext<NoNamespaceEvent>>()));
+        }
+    }
+}