com.wallstop-studios.dxmessaging 2.0.0 → 2.1.0

package/Tests/Runtime/Core/MessageHandlerGlobalBusTests.cs

@@ -0,0 +1,219 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System;
+    using DxMessaging.Core;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Core.Messages;
+    using NUnit.Framework;
+    using GlobalMessageBus = DxMessaging.Core.MessageBus.MessageBus;
+
+    [TestFixture]
+    public sealed class MessageHandlerGlobalBusTests
+    {
+        private IMessageBus _originalBus;
+
+        [SetUp]
+        public void CaptureOriginalBus()
+        {
+            _originalBus = MessageHandler.MessageBus;
+        }
+
+        [TearDown]
+        public void RestoreOriginalBus()
+        {
+            MessageHandler.SetGlobalMessageBus(_originalBus);
+        }
+
+        [Test]
+        public void SetGlobalMessageBusReplacesGlobalInstance()
+        {
+            GlobalMessageBus customBus = new GlobalMessageBus();
+            MessageHandler.SetGlobalMessageBus(customBus);
+
+            Assert.AreSame(customBus, MessageHandler.MessageBus);
+        }
+
+        [Test]
+        public void ResetGlobalMessageBusRestoresDefaultInstance()
+        {
+            MessageHandler.ResetGlobalMessageBus();
+            IMessageBus expectedDefault = MessageHandler.MessageBus;
+
+            GlobalMessageBus customBus = new GlobalMessageBus();
+            MessageHandler.SetGlobalMessageBus(customBus);
+            Assert.AreSame(customBus, MessageHandler.MessageBus);
+
+            MessageHandler.ResetGlobalMessageBus();
+            Assert.AreSame(expectedDefault, MessageHandler.MessageBus);
+        }
+
+        [Test]
+        public void SetGlobalMessageBusAcceptsInterfaceImplementation()
+        {
+            WrapperMessageBus wrapper = new WrapperMessageBus(new GlobalMessageBus());
+            MessageHandler.SetGlobalMessageBus(wrapper);
+            Assert.AreSame(wrapper, MessageHandler.MessageBus);
+        }
+
+        [Test]
+        public void OverrideGlobalMessageBusScopeRestoresPreviousBus()
+        {
+            GlobalMessageBus primary = new GlobalMessageBus();
+            MessageHandler.SetGlobalMessageBus(primary);
+            WrapperMessageBus secondary = new WrapperMessageBus(new GlobalMessageBus());
+
+            using (MessageHandler.OverrideGlobalMessageBus(secondary))
+            {
+                Assert.AreSame(secondary, MessageHandler.MessageBus);
+            }
+
+            Assert.AreSame(primary, MessageHandler.MessageBus);
+        }
+
+        private sealed class WrapperMessageBus : IMessageBus
+        {
+            private readonly IMessageBus _inner;
+
+            public WrapperMessageBus(IMessageBus inner)
+            {
+                _inner = inner ?? throw new ArgumentNullException(nameof(inner));
+            }
+
+            public bool DiagnosticsMode => _inner.DiagnosticsMode;
+
+            public int RegisteredGlobalSequentialIndex => _inner.RegisteredGlobalSequentialIndex;
+
+            public int RegisteredBroadcast => _inner.RegisteredBroadcast;
+
+            public int RegisteredTargeted => _inner.RegisteredTargeted;
+
+            public int RegisteredUntargeted => _inner.RegisteredUntargeted;
+
+            public RegistrationLog Log => _inner.Log;
+
+            public long EmissionId => _inner.EmissionId;
+
+            public Action RegisterUntargeted<T>(MessageHandler messageHandler, int priority = 0)
+                where T : IUntargetedMessage =>
+                _inner.RegisterUntargeted<T>(messageHandler, priority);
+
+            public Action RegisterUntargetedPostProcessor<T>(
+                MessageHandler messageHandler,
+                int priority = 0
+            )
+                where T : IUntargetedMessage =>
+                _inner.RegisterUntargetedPostProcessor<T>(messageHandler, priority);
+
+            public Action RegisterTargeted<T>(
+                InstanceId target,
+                MessageHandler messageHandler,
+                int priority = 0
+            )
+                where T : ITargetedMessage =>
+                _inner.RegisterTargeted<T>(target, messageHandler, priority);
+
+            public Action RegisterTargetedPostProcessor<T>(
+                InstanceId target,
+                MessageHandler messageHandler,
+                int priority = 0
+            )
+                where T : ITargetedMessage =>
+                _inner.RegisterTargetedPostProcessor<T>(target, messageHandler, priority);
+
+            public Action RegisterTargetedWithoutTargeting<T>(
+                MessageHandler messageHandler,
+                int priority = 0
+            )
+                where T : ITargetedMessage =>
+                _inner.RegisterTargetedWithoutTargeting<T>(messageHandler, priority);
+
+            public Action RegisterTargetedWithoutTargetingPostProcessor<T>(
+                MessageHandler messageHandler,
+                int priority = 0
+            )
+                where T : ITargetedMessage =>
+                _inner.RegisterTargetedWithoutTargetingPostProcessor<T>(messageHandler, priority);
+
+            public Action RegisterBroadcastPostProcessor<T>(
+                InstanceId source,
+                MessageHandler messageHandler,
+                int priority = 0
+            )
+                where T : IBroadcastMessage =>
+                _inner.RegisterBroadcastPostProcessor<T>(source, messageHandler, priority);
+
+            public Action RegisterBroadcastWithoutSourcePostProcessor<T>(
+                MessageHandler messageHandler,
+                int priority = 0
+            )
+                where T : IBroadcastMessage =>
+                _inner.RegisterBroadcastWithoutSourcePostProcessor<T>(messageHandler, priority);
+
+            public Action RegisterSourcedBroadcast<T>(
+                InstanceId source,
+                MessageHandler messageHandler,
+                int priority = 0
+            )
+                where T : IBroadcastMessage =>
+                _inner.RegisterSourcedBroadcast<T>(source, messageHandler, priority);
+
+            public Action RegisterSourcedBroadcastWithoutSource<T>(
+                MessageHandler messageHandler,
+                int priority = 0
+            )
+                where T : IBroadcastMessage =>
+                _inner.RegisterSourcedBroadcastWithoutSource<T>(messageHandler, priority);
+
+            public Action RegisterGlobalAcceptAll(MessageHandler messageHandler) =>
+                _inner.RegisterGlobalAcceptAll(messageHandler);
+
+            public Action RegisterUntargetedInterceptor<T>(
+                IMessageBus.UntargetedInterceptor<T> interceptor,
+                int priority = 0
+            )
+                where T : IUntargetedMessage =>
+                _inner.RegisterUntargetedInterceptor(interceptor, priority);
+
+            public Action RegisterTargetedInterceptor<T>(
+                IMessageBus.TargetedInterceptor<T> interceptor,
+                int priority = 0
+            )
+                where T : ITargetedMessage =>
+                _inner.RegisterTargetedInterceptor(interceptor, priority);
+
+            public Action RegisterBroadcastInterceptor<T>(
+                IMessageBus.BroadcastInterceptor<T> interceptor,
+                int priority = 0
+            )
+                where T : IBroadcastMessage =>
+                _inner.RegisterBroadcastInterceptor(interceptor, priority);
+
+            public void UntypedUntargetedBroadcast(IUntargetedMessage typedMessage) =>
+                _inner.UntypedUntargetedBroadcast(typedMessage);
+
+            public void UntargetedBroadcast<TMessage>(ref TMessage typedMessage)
+                where TMessage : IUntargetedMessage => _inner.UntargetedBroadcast(ref typedMessage);
+
+            public void UntypedTargetedBroadcast(
+                InstanceId target,
+                ITargetedMessage typedMessage
+            ) => _inner.UntypedTargetedBroadcast(target, typedMessage);
+
+            public void TargetedBroadcast<TMessage>(
+                ref InstanceId target,
+                ref TMessage typedMessage
+            )
+                where TMessage : ITargetedMessage =>
+                _inner.TargetedBroadcast(ref target, ref typedMessage);
+
+            public void UntypedSourcedBroadcast(
+                InstanceId source,
+                IBroadcastMessage typedMessage
+            ) => _inner.UntypedSourcedBroadcast(source, typedMessage);
+
+            public void SourcedBroadcast<TMessage>(ref InstanceId source, ref TMessage typedMessage)
+                where TMessage : IBroadcastMessage =>
+                _inner.SourcedBroadcast(ref source, ref typedMessage);
+        }
+    }
+}

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

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

package/Tests/Runtime/Core/MessageRegistrationBuilderTests.cs

@@ -0,0 +1,204 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System;
+    using DxMessaging.Core;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Tests.Runtime.Scripts.Messages;
+    using NUnit.Framework;
+
+    public sealed class MessageRegistrationBuilderTests
+    {
+        private sealed class PassthroughMessageBusProvider : IMessageBusProvider
+        {
+            private readonly IMessageBus _messageBus;
+
+            public PassthroughMessageBusProvider(IMessageBus messageBus)
+            {
+                _messageBus = messageBus ?? throw new ArgumentNullException(nameof(messageBus));
+            }
+
+            public IMessageBus Resolve()
+            {
+                return _messageBus;
+            }
+        }
+
+        private MessageRegistrationBuilder _builder;
+        private IMessageBus _defaultBus;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _defaultBus = new MessageBus();
+            IMessageBusProvider provider = new PassthroughMessageBusProvider(_defaultBus);
+            _builder = new MessageRegistrationBuilder(provider);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _builder = null;
+            _defaultBus = null;
+        }
+
+        [Test]
+        public void BuildUsesResolvedBusWhenNoOverrideProvided()
+        {
+            MessageRegistrationBuildOptions options = new MessageRegistrationBuildOptions();
+            using MessageRegistrationLease lease = _builder.Build(options);
+
+            Assert.AreSame(_defaultBus, lease.MessageBus);
+            Assert.IsNotNull(lease.Token);
+            Assert.IsFalse(lease.Token.Enabled);
+        }
+
+        [Test]
+        public void ActivateOnBuildEnablesTokenAndLifecycle()
+        {
+            bool buildInvoked = false;
+            bool activateInvoked = false;
+            bool deactivateInvoked = false;
+            bool disposeInvoked = false;
+            MessageRegistrationBuildOptions options = new MessageRegistrationBuildOptions
+            {
+                ActivateOnBuild = true,
+                Configure = token =>
+                {
+                    _ = token.RegisterUntargeted<SimpleUntargetedMessage>(OnSimpleMessage);
+                },
+                Lifecycle = new MessageRegistrationLifecycle(
+                    token =>
+                    {
+                        buildInvoked = true;
+                    },
+                    token =>
+                    {
+                        activateInvoked = true;
+                    },
+                    token =>
+                    {
+                        deactivateInvoked = true;
+                    },
+                    token =>
+                    {
+                        disposeInvoked = true;
+                    }
+                ),
+            };
+
+            using (MessageRegistrationLease lease = _builder.Build(options))
+            {
+                Assert.IsTrue(buildInvoked);
+                Assert.IsTrue(lease.Token.Enabled);
+                Assert.IsTrue(lease.IsActive);
+                Assert.IsTrue(activateInvoked);
+
+                lease.Deactivate();
+                Assert.IsFalse(lease.IsActive);
+                Assert.IsTrue(deactivateInvoked);
+            }
+
+            Assert.IsTrue(disposeInvoked);
+        }
+
+        [Test]
+        public void PreferredMessageBusOverridesProvider()
+        {
+            MessageBus preferredBus = new MessageBus();
+            MessageRegistrationBuildOptions options = new MessageRegistrationBuildOptions
+            {
+                PreferredMessageBus = preferredBus,
+            };
+
+            using MessageRegistrationLease lease = _builder.Build(options);
+            Assert.AreSame(preferredBus, lease.MessageBus);
+        }
+
+        [Test]
+        public void MessageBusProviderOptionOverridesBuilderDefault()
+        {
+            MessageBus providerBus = new MessageBus();
+            MessageRegistrationBuildOptions options = new MessageRegistrationBuildOptions
+            {
+                MessageBusProvider = new PassthroughMessageBusProvider(providerBus),
+            };
+
+            using MessageRegistrationLease lease = _builder.Build(options);
+            Assert.AreSame(providerBus, lease.MessageBus);
+        }
+
+        [Test]
+        public void SyntheticOwnerGeneratedWhenOwnerMissing()
+        {
+            MessageRegistrationBuildOptions options = new MessageRegistrationBuildOptions();
+            using MessageRegistrationLease lease = _builder.Build(options);
+            Assert.AreNotEqual(InstanceId.EmptyId, lease.Owner);
+        }
+
+        [Test]
+        public void HandlerStartsInactiveWhenConfigured()
+        {
+            MessageRegistrationBuildOptions options = new MessageRegistrationBuildOptions
+            {
+                HandlerStartsActive = false,
+            };
+
+            using MessageRegistrationLease lease = _builder.Build(options);
+
+            Assert.IsFalse(lease.Handler.active);
+            lease.Activate();
+            Assert.IsTrue(lease.IsActive);
+            Assert.IsTrue(lease.Handler.active);
+        }
+
+        [Test]
+        public void DiagnosticsModeRespectedWhenEnabled()
+        {
+            MessageRegistrationBuildOptions options = new MessageRegistrationBuildOptions
+            {
+                EnableDiagnostics = true,
+                Configure = token =>
+                {
+                    _ = token.RegisterUntargeted<SimpleUntargetedMessage>(OnSimpleMessage);
+                },
+            };
+
+            using MessageRegistrationLease lease = _builder.Build(options);
+            Assert.IsTrue(
+                lease.Token.DiagnosticMode,
+                "Diagnostics flag should propagate to the token."
+            );
+        }
+
+        [Test]
+        public void DisposingActiveLeaseInvokesDeactivateLifecycle()
+        {
+            bool deactivateInvoked = false;
+            bool disposeInvoked = false;
+
+            MessageRegistrationBuildOptions options = new MessageRegistrationBuildOptions
+            {
+                ActivateOnBuild = true,
+                Lifecycle = new MessageRegistrationLifecycle(
+                    null,
+                    null,
+                    token => deactivateInvoked = true,
+                    token => disposeInvoked = true
+                ),
+            };
+
+            using (MessageRegistrationLease lease = _builder.Build(options))
+            {
+                // No-op
+            }
+
+            Assert.IsTrue(
+                deactivateInvoked,
+                "Disposing an active lease should trigger OnDeactivate before tear-down."
+            );
+            Assert.IsTrue(disposeInvoked, "Disposing a lease should trigger OnDispose callbacks.");
+        }
+
+        private static void OnSimpleMessage(ref SimpleUntargetedMessage message) { }
+    }
+}

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

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

package/Tests/Runtime/Core/MessagingTestBase.cs

@@ -7,8 +7,8 @@ namespace DxMessaging.Tests.Runtime.Core
     using System.Linq;
     using DxMessaging.Core;
     using DxMessaging.Core.MessageBus;
+    using DxMessaging.Unity;
     using NUnit.Framework;
-    using Unity;
     using UnityEngine;
     using UnityEngine.TestTools;
     using Debug = UnityEngine.Debug;
@@ -43,7 +43,7 @@ namespace DxMessaging.Tests.Runtime.Core
                         return;
                 }
             };
-            MessageBus messageBus = MessageHandler.MessageBus;
+            IMessageBus messageBus = MessageHandler.MessageBus;
             Assert.IsNotNull(messageBus);
             messageBus.Log.Enabled = true;
             _numRegistrations = 150;
@@ -53,7 +53,7 @@ namespace DxMessaging.Tests.Runtime.Core
 
         protected void LogMessageBusStatus()
         {
-            MessageBus messageBus = MessageHandler.MessageBus;
+            IMessageBus messageBus = MessageHandler.MessageBus;
             Debug.Log(
                 $"Untargeted registrations: {messageBus.RegisteredUntargeted}, "
                     + $"targeted registrations: {messageBus.RegisteredTargeted}, "
@@ -177,7 +177,7 @@ namespace DxMessaging.Tests.Runtime.Core
 
         protected static IEnumerator WaitUntilMessageHandlerIsFresh()
         {
-            MessageBus messageBus = MessageHandler.MessageBus;
+            IMessageBus messageBus = MessageHandler.MessageBus;
             Assert.IsNotNull(messageBus);
 
             Stopwatch timer = Stopwatch.StartNew();

package/Tests/Runtime/Core/NominalTests.cs

@@ -265,7 +265,7 @@ namespace DxMessaging.Tests.Runtime.Core
         [UnityTest]
         public IEnumerator Lifetime()
         {
-            MessageBus messageBus = MessageHandler.MessageBus;
+            IMessageBus messageBus = MessageHandler.MessageBus;
             Assert.IsNotNull(messageBus);
 
             GameObject test = new(nameof(Lifetime), typeof(SimpleMessageAwareComponent));
@@ -352,7 +352,7 @@ namespace DxMessaging.Tests.Runtime.Core
         [UnityTest]
         public IEnumerator NonMessagingObjects()
         {
-            MessageBus messageBus = MessageHandler.MessageBus;
+            IMessageBus messageBus = MessageHandler.MessageBus;
             Assert.IsNotNull(messageBus);
 
             GameObject test1 = new("NonMessaging1");

package/Tests/Runtime/Core/TypedShorthandTests.cs

@@ -168,7 +168,7 @@ namespace DxMessaging.Tests.Runtime.Core
             ShorthandTargetedBroadcastComponent comp =
                 go.GetComponent<ShorthandTargetedBroadcastComponent>();
 
-            MessageBus bus = MessageHandler.MessageBus;
+            IMessageBus bus = MessageHandler.MessageBus;
             bool cancel = true;
             Action dereg = bus.RegisterTargetedInterceptor(
                 (ref InstanceId t, ref SimpleTargetedMessage m) => !cancel
@@ -203,7 +203,7 @@ namespace DxMessaging.Tests.Runtime.Core
             ShorthandTargetedBroadcastComponent comp =
                 go.GetComponent<ShorthandTargetedBroadcastComponent>();
 
-            MessageBus bus = MessageHandler.MessageBus;
+            IMessageBus bus = MessageHandler.MessageBus;
             bool cancel = true;
             Action dereg = bus.RegisterBroadcastInterceptor(
                 (ref InstanceId s, ref SimpleBroadcastMessage m) => !cancel

package/Tests/Runtime/Core/UntargetedEquivalenceTests.cs

@@ -43,7 +43,7 @@ namespace DxMessaging.Tests.Runtime.Core
             _spawned.Add(go);
             UntargetedReceiverComponent comp = go.GetComponent<UntargetedReceiverComponent>();
 
-            MessageBus bus = MessageHandler.MessageBus;
+            IMessageBus bus = MessageHandler.MessageBus;
             bool cancel = true;
             Action dereg = bus.RegisterUntargetedInterceptor(
                 (ref SimpleUntargetedMessage _) => !cancel

package/Tests/Runtime/Core/UntargetedPrefreezeTests.cs

@@ -19,10 +19,8 @@ namespace DxMessaging.Tests.Runtime.Core
             MessageRegistrationToken token = MessageRegistrationToken.Create(handler, messageBus);
 
             int postProcessCount = 0;
-            _ = token.RegisterUntargeted<SimpleUntargetedMessage>(
-                (ref SimpleUntargetedMessage _) => { }
-            );
-            _ = token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(
+            _ = token.RegisterUntargeted((ref SimpleUntargetedMessage _) => { });
+            _ = token.RegisterUntargetedPostProcessor(
                 (ref SimpleUntargetedMessage _) => postProcessCount++,
                 priority: 0
             );