com.wallstop-studios.dxmessaging 2.0.0 → 2.1.0

package/Tests/Runtime/Core/Extensions/MessageBusExtensionsTests.cs

@@ -0,0 +1,278 @@
+namespace DxMessaging.Tests.Runtime.Core.Extensions
+{
+    using System;
+    using DxMessaging.Core;
+    using DxMessaging.Core.Extensions;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Core.Messages;
+    using NUnit.Framework;
+    using MessageBus = DxMessaging.Core.MessageBus.MessageBus;
+
+    [TestFixture]
+    public sealed class MessageBusExtensionsTests
+    {
+        private IMessageBus _originalGlobalBus;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _originalGlobalBus = MessageHandler.MessageBus;
+            MessageHandler.ResetGlobalMessageBus();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            MessageHandler.SetGlobalMessageBus(_originalGlobalBus);
+        }
+
+        [Test]
+        public void EmitUntargetedClassMessageUsesBus()
+        {
+            MessageBus bus = new MessageBus();
+            MessageHandler handler = new MessageHandler(new InstanceId(10), bus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
+            int count = 0;
+            _ = token.RegisterUntargeted<ClassUntargetedMessage>(
+                (ref ClassUntargetedMessage _) => count++
+            );
+            token.Enable();
+
+            ClassUntargetedMessage message = new ClassUntargetedMessage();
+            bus.EmitUntargeted(message);
+
+            Assert.AreEqual(1, count);
+            token.Disable();
+        }
+
+        [Test]
+        public void EmitUntargetedStructMessageUsesBus()
+        {
+            MessageBus bus = new MessageBus();
+            MessageHandler handler = new MessageHandler(new InstanceId(20), bus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
+            int count = 0;
+            _ = token.RegisterUntargeted<StructUntargetedMessage>(
+                (ref StructUntargetedMessage _) => count++
+            );
+            token.Enable();
+
+            StructUntargetedMessage message = new StructUntargetedMessage(1);
+            bus.EmitUntargeted(ref message);
+
+            Assert.AreEqual(1, count);
+            token.Disable();
+        }
+
+        [Test]
+        public void EmitUntargetedStructMessageHonorsInterceptorsAndPostProcessors()
+        {
+            MessageBus bus = new MessageBus();
+            MessageHandler handler = new MessageHandler(new InstanceId(21), bus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
+            StructInterceptedMessage intercepted = default;
+            int postProcessCount = 0;
+
+            _ = bus.RegisterUntargetedInterceptor<StructInterceptedMessage>(
+                (ref StructInterceptedMessage msg) =>
+                {
+                    msg.Value += 10;
+                    return true;
+                }
+            );
+
+            _ = token.RegisterUntargeted<StructInterceptedMessage>(
+                (ref StructInterceptedMessage msg) => intercepted = msg
+            );
+
+            _ = token.RegisterUntargetedPostProcessor<StructInterceptedMessage>(
+                (ref StructInterceptedMessage _) => postProcessCount++
+            );
+
+            token.Enable();
+
+            StructInterceptedMessage message = new StructInterceptedMessage(5);
+            bus.EmitUntargeted(ref message);
+
+            Assert.AreEqual(15, intercepted.Value);
+            Assert.AreEqual(1, postProcessCount);
+
+            token.Disable();
+        }
+
+        [Test]
+        public void EmitUntargetedRandomizedMatchesMessageExtensions()
+        {
+            MessageBus bus = new MessageBus();
+            MessageHandler handler = new MessageHandler(new InstanceId(25), bus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
+            int busSum = 0;
+
+            _ = token.RegisterUntargeted<StructUntargetedMessage>(
+                (ref StructUntargetedMessage msg) => busSum += msg.Value
+            );
+
+            token.Enable();
+
+            const int iterations = 256;
+            int[] values = new int[iterations];
+            Random random = new Random(1234);
+
+            for (int i = 0; i < iterations; i++)
+            {
+                int value = random.Next(-1_000, 1_000);
+                values[i] = value;
+                StructUntargetedMessage message = new StructUntargetedMessage(value);
+                bus.EmitUntargeted(ref message);
+            }
+
+            token.Disable();
+
+            MessageHandler handler2 = new MessageHandler(new InstanceId(26), bus) { active = true };
+            MessageRegistrationToken token2 = MessageRegistrationToken.Create(handler2, bus);
+            int messageSum = 0;
+
+            _ = token2.RegisterUntargeted<StructUntargetedMessage>(
+                (ref StructUntargetedMessage msg) => messageSum += msg.Value
+            );
+
+            token2.Enable();
+
+            for (int i = 0; i < iterations; i++)
+            {
+                StructUntargetedMessage message = new StructUntargetedMessage(values[i]);
+                message.EmitUntargeted(bus);
+            }
+
+            token2.Disable();
+
+            Assert.AreEqual(busSum, messageSum);
+        }
+
+        [Test]
+        public void EmitTargetedStructMessageUsesBus()
+        {
+            MessageBus bus = new MessageBus();
+            InstanceId target = new InstanceId(42);
+
+            MessageHandler handler = new MessageHandler(new InstanceId(30), bus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
+            int count = 0;
+            _ = token.RegisterTargeted<StructTargetedMessage>(
+                target,
+                (ref StructTargetedMessage _) => count++
+            );
+            token.Enable();
+
+            StructTargetedMessage message = new StructTargetedMessage(5);
+            bus.EmitTargeted(target, ref message);
+
+            Assert.AreEqual(1, count);
+            token.Disable();
+        }
+
+        [Test]
+        public void EmitBroadcastStructMessageUsesBus()
+        {
+            MessageBus bus = new MessageBus();
+            InstanceId source = new InstanceId(99);
+
+            MessageHandler handler = new MessageHandler(new InstanceId(40), bus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
+            int count = 0;
+            _ = token.RegisterBroadcast<StructBroadcastMessage>(
+                source,
+                (ref StructBroadcastMessage _) => count++
+            );
+            token.Enable();
+
+            StructBroadcastMessage message = new StructBroadcastMessage(7);
+            bus.EmitBroadcast(source, ref message);
+
+            Assert.AreEqual(1, count);
+            token.Disable();
+        }
+
+        [Test]
+        public void EmitStringHelpersUseBus()
+        {
+            MessageBus bus = new MessageBus();
+            InstanceId target = new InstanceId(11);
+            InstanceId source = new InstanceId(12);
+
+            MessageHandler handler = new MessageHandler(new InstanceId(50), bus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
+            string targeted = null;
+            string broadcast = null;
+            string untargeted = null;
+
+            _ = token.RegisterTargeted<StringMessage>(
+                target,
+                (ref StringMessage m) => targeted = m.message
+            );
+
+            _ = token.RegisterBroadcast<SourcedStringMessage>(
+                source,
+                (ref SourcedStringMessage m) => broadcast = m.message
+            );
+
+            _ = token.RegisterUntargeted<GlobalStringMessage>(
+                (ref GlobalStringMessage m) => untargeted = m.message
+            );
+
+            token.Enable();
+
+            bus.EmitAt(target, "target");
+            bus.EmitFrom(source, "broadcast");
+            bus.Emit("untargeted");
+
+            Assert.AreEqual("target", targeted);
+            Assert.AreEqual("broadcast", broadcast);
+            Assert.AreEqual("untargeted", untargeted);
+
+            token.Disable();
+        }
+
+        private sealed class ClassUntargetedMessage : IUntargetedMessage { }
+
+        private readonly struct StructUntargetedMessage : IUntargetedMessage
+        {
+            internal StructUntargetedMessage(int value)
+            {
+                Value = value;
+            }
+
+            internal int Value { get; }
+        }
+
+        private struct StructInterceptedMessage : IUntargetedMessage
+        {
+            internal StructInterceptedMessage(int value)
+            {
+                Value = value;
+            }
+
+            internal int Value;
+        }
+
+        private readonly struct StructTargetedMessage : ITargetedMessage
+        {
+            internal StructTargetedMessage(int value)
+            {
+                Value = value;
+            }
+
+            internal int Value { get; }
+        }
+
+        private readonly struct StructBroadcastMessage : IBroadcastMessage
+        {
+            internal StructBroadcastMessage(int value)
+            {
+                Value = value;
+            }
+
+            internal int Value { get; }
+        }
+    }
+}

package/Tests/Runtime/Core/Extensions/MessageBusExtensionsTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3eb102d745b7a274682d6de7f87281e8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Core/Extensions/MessageExtensionsProviderTests.cs

@@ -0,0 +1,289 @@
+namespace DxMessaging.Tests.Runtime.Core.Extensions
+{
+    using DxMessaging.Core;
+    using DxMessaging.Core.Extensions;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Core.Messages;
+    using NUnit.Framework;
+    using MessageBus = DxMessaging.Core.MessageBus.MessageBus;
+
+    [TestFixture]
+    public sealed class MessageExtensionsProviderTests
+    {
+        private IMessageBus _originalGlobalBus;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _originalGlobalBus = MessageHandler.MessageBus;
+            MessageHandler.ResetGlobalMessageBus();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            MessageHandler.SetGlobalMessageBus(_originalGlobalBus);
+        }
+
+        [Test]
+        public void GlobalMessageBusProviderReturnsGlobalSingleton()
+        {
+            MessageBus customBus = new();
+            MessageHandler.SetGlobalMessageBus(customBus);
+
+            IMessageBus resolved = GlobalMessageBusProvider.Instance.Resolve();
+
+            Assert.AreSame(customBus, resolved);
+        }
+
+        [Test]
+        public void EmitUntargetedWithProviderUsesProvidedBus()
+        {
+            MessageBus providerBus = new();
+            MessageHandler handler = new(new InstanceId(101), providerBus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, providerBus);
+            int providerCount = 0;
+            _ = token.RegisterUntargeted((ref TestUntargetedMessage _) => providerCount++);
+            token.Enable();
+
+            MessageHandler globalHandler = new(new InstanceId(102)) { active = true };
+            MessageRegistrationToken globalToken = MessageRegistrationToken.Create(
+                globalHandler,
+                MessageHandler.MessageBus
+            );
+            int globalCount = 0;
+            _ = globalToken.RegisterUntargeted((ref TestUntargetedMessage _) => globalCount++);
+            globalToken.Enable();
+
+            TestUntargetedMessage message = new(5);
+            TestMessageBusProvider provider = new(providerBus);
+            message.EmitUntargeted(messageBusProvider: provider);
+
+            Assert.AreEqual(1, providerCount);
+            Assert.AreEqual(0, globalCount);
+
+            token.Disable();
+            globalToken.Disable();
+        }
+
+        [Test]
+        public void EmitUntargetedWithNullProviderFallsBackToGlobalBus()
+        {
+            MessageHandler globalHandler = new(new InstanceId(201)) { active = true };
+            MessageRegistrationToken globalToken = MessageRegistrationToken.Create(
+                globalHandler,
+                MessageHandler.MessageBus
+            );
+            int globalCount = 0;
+            _ = globalToken.RegisterUntargeted((ref TestUntargetedMessage _) => globalCount++);
+            globalToken.Enable();
+
+            TestUntargetedMessage message = new(9);
+            NullMessageBusProvider provider = new();
+            message.EmitUntargeted(messageBusProvider: provider);
+
+            Assert.AreEqual(1, provider.ResolveCount);
+            Assert.AreEqual(1, globalCount);
+
+            globalToken.Disable();
+        }
+
+        [Test]
+        public void EmitUntargetedPrefersExplicitBusOverProvider()
+        {
+            MessageBus explicitBus = new();
+            MessageBus providerBus = new();
+
+            MessageHandler explicitHandler = new(new InstanceId(301), explicitBus)
+            {
+                active = true,
+            };
+            MessageRegistrationToken explicitToken = MessageRegistrationToken.Create(
+                explicitHandler,
+                explicitBus
+            );
+            int explicitCount = 0;
+            _ = explicitToken.RegisterUntargeted((ref TestUntargetedMessage _) => explicitCount++);
+            explicitToken.Enable();
+
+            MessageHandler providerHandler = new(new InstanceId(302), providerBus)
+            {
+                active = true,
+            };
+            MessageRegistrationToken providerToken = MessageRegistrationToken.Create(
+                providerHandler,
+                providerBus
+            );
+            int providerCount = 0;
+            _ = providerToken.RegisterUntargeted((ref TestUntargetedMessage _) => providerCount++);
+            providerToken.Enable();
+
+            TestUntargetedMessage message = new(11);
+            TestMessageBusProvider provider = new(providerBus);
+            message.EmitUntargeted(explicitBus, provider);
+
+            Assert.AreEqual(1, explicitCount);
+            Assert.AreEqual(0, providerCount);
+
+            explicitToken.Disable();
+            providerToken.Disable();
+        }
+
+        [Test]
+        public void EmitTargetedWithProviderRoutesToProviderBus()
+        {
+            MessageBus providerBus = new();
+            InstanceId target = new(901);
+
+            MessageHandler handler = new(new InstanceId(401), providerBus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, providerBus);
+            int providerCount = 0;
+            _ = token.RegisterTargeted(target, (ref TestTargetedMessage _) => providerCount++);
+            token.Enable();
+
+            MessageHandler globalHandler = new(new InstanceId(402)) { active = true };
+            MessageRegistrationToken globalToken = MessageRegistrationToken.Create(
+                globalHandler,
+                MessageHandler.MessageBus
+            );
+            int globalCount = 0;
+            _ = globalToken.RegisterTargeted(target, (ref TestTargetedMessage _) => globalCount++);
+            globalToken.Enable();
+
+            TestTargetedMessage message = new(17);
+            TestMessageBusProvider provider = new(providerBus);
+            message.EmitTargeted(target, messageBusProvider: provider);
+
+            Assert.AreEqual(1, providerCount);
+            Assert.AreEqual(0, globalCount);
+
+            token.Disable();
+            globalToken.Disable();
+        }
+
+        [Test]
+        public void EmitBroadcastWithProviderRoutesToProviderBus()
+        {
+            MessageBus providerBus = new();
+            InstanceId source = new(777);
+
+            MessageHandler handler = new(new InstanceId(501), providerBus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, providerBus);
+            int providerCount = 0;
+            _ = token.RegisterBroadcast(source, (ref TestBroadcastMessage _) => providerCount++);
+            token.Enable();
+
+            MessageHandler globalHandler = new(new InstanceId(502)) { active = true };
+            MessageRegistrationToken globalToken = MessageRegistrationToken.Create(
+                globalHandler,
+                MessageHandler.MessageBus
+            );
+            int globalCount = 0;
+            _ = globalToken.RegisterBroadcast(
+                source,
+                (ref TestBroadcastMessage _) => globalCount++
+            );
+            globalToken.Enable();
+
+            TestBroadcastMessage message = new(23);
+            TestMessageBusProvider provider = new(providerBus);
+            message.EmitBroadcast(source, messageBusProvider: provider);
+
+            Assert.AreEqual(1, providerCount);
+            Assert.AreEqual(0, globalCount);
+
+            token.Disable();
+            globalToken.Disable();
+        }
+
+        [Test]
+        public void StringEmitUsesProvidedBus()
+        {
+            MessageBus providerBus = new();
+            InstanceId target = new(1234);
+
+            MessageHandler handler = new(new InstanceId(601), providerBus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, providerBus);
+            string? received = null;
+            _ = token.RegisterTargeted(target, (ref StringMessage m) => received = m.message);
+            token.Enable();
+
+            MessageHandler globalHandler = new(new InstanceId(602)) { active = true };
+            MessageRegistrationToken globalToken = MessageRegistrationToken.Create(
+                globalHandler,
+                MessageHandler.MessageBus
+            );
+            string? globalReceived = null;
+            _ = globalToken.RegisterTargeted(
+                target,
+                (ref StringMessage m) => globalReceived = m.message
+            );
+            globalToken.Enable();
+
+            TestMessageBusProvider provider = new(providerBus);
+            "provider-route".Emit(target, messageBusProvider: provider);
+
+            Assert.AreEqual("provider-route", received);
+            Assert.IsNull(globalReceived);
+
+            token.Disable();
+            globalToken.Disable();
+        }
+
+        private sealed class TestMessageBusProvider : IMessageBusProvider
+        {
+            private readonly IMessageBus _bus;
+
+            public TestMessageBusProvider(IMessageBus bus)
+            {
+                _bus = bus;
+            }
+
+            public IMessageBus Resolve()
+            {
+                return _bus;
+            }
+        }
+
+        private sealed class NullMessageBusProvider : IMessageBusProvider
+        {
+            public int ResolveCount { get; private set; }
+
+            public IMessageBus Resolve()
+            {
+                ResolveCount++;
+                return null;
+            }
+        }
+
+        private readonly struct TestUntargetedMessage : IUntargetedMessage
+        {
+            public TestUntargetedMessage(int value)
+            {
+                Value = value;
+            }
+
+            public int Value { get; }
+        }
+
+        private readonly struct TestTargetedMessage : ITargetedMessage
+        {
+            public TestTargetedMessage(int value)
+            {
+                Value = value;
+            }
+
+            public int Value { get; }
+        }
+
+        private readonly struct TestBroadcastMessage : IBroadcastMessage
+        {
+            public TestBroadcastMessage(int value)
+            {
+                Value = value;
+            }
+
+            public int Value { get; }
+        }
+    }
+}

package/Tests/Runtime/Core/Extensions/MessageExtensionsProviderTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cbdf955d8072cd743bc4c6bb87a25a1a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Core/Extensions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 5f66800fd9454f54880213d6b7a72a72
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Core/IntegrationShimSmokeTests.cs

@@ -0,0 +1,57 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System;
+    using NUnit.Framework;
+
+    public sealed class IntegrationShimSmokeTests
+    {
+        [Test]
+        public void ZenjectShimTypeAvailableWhenDefined()
+        {
+#if ZENJECT_PRESENT
+            AssertIntegrationType(
+                "DxMessaging.Unity.Integrations.Zenject.DxMessagingRegistrationInstaller",
+                "WallstopStudios.DxMessaging.Zenject"
+            );
+#else
+            Assert.Ignore("ZENJECT_PRESENT not defined; skipping Zenject shim smoke test.");
+#endif
+        }
+
+        [Test]
+        public void VContainerShimTypeAvailableWhenDefined()
+        {
+#if VCONTAINER_PRESENT
+            AssertIntegrationType(
+                "DxMessaging.Unity.Integrations.VContainer.VContainerRegistrationExtensions",
+                "WallstopStudios.DxMessaging.VContainer"
+            );
+#else
+            Assert.Ignore("VCONTAINER_PRESENT not defined; skipping VContainer shim smoke test.");
+#endif
+        }
+
+        [Test]
+        public void ReflexShimTypeAvailableWhenDefined()
+        {
+#if REFLEX_PRESENT
+            AssertIntegrationType(
+                "DxMessaging.Unity.Integrations.Reflex.DxMessagingRegistrationInstaller",
+                "WallstopStudios.DxMessaging.Reflex"
+            );
+#else
+            Assert.Ignore("REFLEX_PRESENT not defined; skipping Reflex shim smoke test.");
+#endif
+        }
+
+        private static void AssertIntegrationType(string typeName, string assemblyName)
+        {
+            string qualifiedName = $"{typeName}, {assemblyName}";
+            Type type = Type.GetType(qualifiedName, throwOnError: false);
+            Assert.IsNotNull(
+                type,
+                $"Expected type '{qualifiedName}' to be available when the corresponding scripting define is set."
+            );
+        }
+    }
+}

package/Tests/Runtime/Core/IntegrationShimSmokeTests.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2f56f0d5a857ed048abc4485e4152810
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: