com.wallstop-studios.dxmessaging 2.0.0-rc27.3.1 → 2.1.0

package/Tests/Runtime/Benchmarks/ProviderResolutionBenchmarks.cs

@@ -0,0 +1,142 @@
+namespace DxMessaging.Tests.Runtime.Benchmarks
+{
+    using System;
+    using System.Diagnostics;
+    using DxMessaging.Core;
+    using DxMessaging.Core.Extensions;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Core.Messages;
+    using NUnit.Framework;
+
+    public sealed class ProviderResolutionBenchmarks : BenchmarkTestBase
+    {
+        private IMessageBus _originalBus;
+
+        [SetUp]
+        public void CaptureGlobalBus()
+        {
+            _originalBus = MessageHandler.MessageBus;
+            MessageHandler.ResetGlobalMessageBus();
+        }
+
+        [TearDown]
+        public void RestoreGlobalBus()
+        {
+            MessageHandler.SetGlobalMessageBus(_originalBus);
+        }
+
+        [Test]
+        public void ProviderResolutionPerformance()
+        {
+            string section = BenchmarkDocumentation.GetOperatingSystemSection();
+            BenchmarkSession session = new(section, "### ", Array.Empty<Func<string>>());
+
+            RunWithSession(
+                session,
+                () =>
+                {
+                    TimeSpan timeout = TimeSpan.FromSeconds(2);
+
+                    BenchmarkResult direct = RunBenchmark(timeout, useProvider: false);
+                    BenchmarkResult provider = RunBenchmark(timeout, useProvider: true);
+
+                    RecordBenchmark(
+                        "DxMessaging (Untargeted) - Direct Bus",
+                        direct.Count,
+                        direct.Duration,
+                        allocating: false
+                    );
+                    RecordBenchmark(
+                        "DxMessaging (Untargeted) - Provider",
+                        provider.Count,
+                        provider.Duration,
+                        allocating: false
+                    );
+
+                    double directOps = direct.OperationsPerSecond;
+                    double providerOps = provider.OperationsPerSecond;
+                    Assume.That(providerOps, Is.GreaterThan(0));
+
+                    double slowdown = directOps / providerOps;
+                    Assert.That(
+                        slowdown,
+                        Is.LessThanOrEqualTo(1.15d),
+                        $"Provider path must remain within 15% of direct bus dispatch. Direct: {directOps:N0} ops/s, Provider: {providerOps:N0} ops/s."
+                    );
+                }
+            );
+        }
+
+        private BenchmarkResult RunBenchmark(TimeSpan timeout, bool useProvider)
+        {
+            MessageBus bus = new();
+            MessageHandler handler = new(new InstanceId(5000), bus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler, bus);
+            _ = token.RegisterUntargeted((ref BenchmarkUntargetedMessage _) => { });
+            token.Enable();
+
+            Stopwatch stopwatch = Stopwatch.StartNew();
+            int count = 0;
+            BenchmarkUntargetedMessage message = new(0);
+            IMessageBusProvider provider = useProvider ? new StaticMessageBusProvider(bus) : null;
+
+            while (stopwatch.Elapsed < timeout)
+            {
+                if (useProvider)
+                {
+                    message.EmitUntargeted(messageBusProvider: provider);
+                }
+                else
+                {
+                    message.EmitUntargeted(bus);
+                }
+
+                count++;
+            }
+
+            stopwatch.Stop();
+            token.Disable();
+
+            return new BenchmarkResult(count, stopwatch.Elapsed);
+        }
+
+        private readonly struct BenchmarkResult
+        {
+            internal BenchmarkResult(int count, TimeSpan duration)
+            {
+                Count = count;
+                Duration = duration;
+            }
+
+            internal int Count { get; }
+            internal TimeSpan Duration { get; }
+            internal double OperationsPerSecond =>
+                Duration.TotalSeconds <= 0 ? 0 : Count / Duration.TotalSeconds;
+        }
+
+        private sealed class StaticMessageBusProvider : IMessageBusProvider
+        {
+            private readonly IMessageBus _bus;
+
+            internal StaticMessageBusProvider(IMessageBus bus)
+            {
+                _bus = bus;
+            }
+
+            public IMessageBus Resolve()
+            {
+                return _bus;
+            }
+        }
+
+        private readonly struct BenchmarkUntargetedMessage : IUntargetedMessage
+        {
+            internal BenchmarkUntargetedMessage(int value)
+            {
+                Value = value;
+            }
+
+            internal int Value { get; }
+        }
+    }
+}

package/Tests/Runtime/Benchmarks/ProviderResolutionBenchmarks.cs.meta

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

package/Tests/Runtime/Benchmarks/WallstopStudios.DxMessaging.Tests.Runtime.Benchmarks.asmdef

@@ -0,0 +1,50 @@
+{
+  "name": "WallstopStudios.DxMessaging.Tests.Runtime.Benchmarks",
+  "rootNamespace": "DxMessaging.Tests.Runtime.Benchmarks",
+  "references": [
+    "UnityEngine.TestRunner",
+    "UnityEditor.TestRunner",
+    "WallstopStudios.DxMessaging",
+    "WallstopStudios.DxMessaging.Tests.Runtime",
+    "Unity.PerformanceTesting",
+    "Zenject",
+    "MessagePipe",
+    "UniRx",
+    "UniTask"
+  ],
+  "includePlatforms": [],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": true,
+  "precompiledReferences": ["nunit.framework.dll"],
+  "autoReferenced": true,
+  "defineConstraints": ["UNITY_INCLUDE_TESTS"],
+  "versionDefines": [
+    {
+      "name": "com.cysharp.messagepipe",
+      "expression": "0.0.1",
+      "define": "MESSAGEPIPE_PRESENT"
+    },
+    {
+      "name": "com.neuecc.unirx",
+      "expression": "0.0.1",
+      "define": "UNIRX_PRESENT"
+    },
+    {
+      "name": "com.cysharp.unirx",
+      "expression": "0.0.1",
+      "define": "UNIRX_PRESENT"
+    },
+    {
+      "name": "com.svermeulen.extenject",
+      "expression": "0.0.1",
+      "define": "ZENJECT_PRESENT"
+    },
+    {
+      "name": "com.svermeulen.extenject",
+      "expression": "0.0.1",
+      "define": "ZENJECT_PRESENT"
+    }
+  ],
+  "noEngineReferences": false
+}

package/Tests/Runtime/Benchmarks/WallstopStudios.DxMessaging.Tests.Runtime.Benchmarks.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: bf76d018b2a2417c8deb1f803eedd719
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Runtime/Core/DefaultBusFallbackTests.cs

@@ -0,0 +1,333 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System.Collections;
+    using System.Collections.Generic;
+    using DxMessaging.Core;
+    using DxMessaging.Core.Extensions;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Tests.Runtime.Scripts.Components;
+    using DxMessaging.Tests.Runtime.Scripts.Messages;
+    using DxMessaging.Unity;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+
+    public sealed class DefaultBusFallbackTests : MessagingTestBase
+    {
+        private readonly List<MessageRegistrationHandle> _handles = new();
+        private readonly List<MessageRegistrationToken> _tokens = new();
+
+        [TearDown]
+        public void TearDown()
+        {
+            foreach (var token in _tokens)
+            {
+                foreach (var handle in _handles)
+                {
+                    token.RemoveRegistration(handle);
+                }
+                token.Disable();
+            }
+
+            _handles.Clear();
+            _tokens.Clear();
+        }
+
+        [Test]
+        public void HandlerUsesInjectedDefaultBusWhenTokenOmitsBus()
+        {
+            MessageBus customBus = new();
+            MessageHandler handler = new(new InstanceId(42), customBus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler);
+            _tokens.Add(token);
+
+            int callCount = 0;
+            MessageRegistrationHandle handle = token.RegisterUntargeted<SimpleUntargetedMessage>(
+                _ => ++callCount
+            );
+            _handles.Add(handle);
+
+            token.Enable();
+
+            SimpleUntargetedMessage message = new();
+            message.EmitUntargeted(customBus);
+            Assert.AreEqual(
+                1,
+                callCount,
+                "Handler should observe messages emitted through its injected bus."
+            );
+
+            message.EmitUntargeted();
+            Assert.AreEqual(
+                1,
+                callCount,
+                "Handler should remain isolated from the global bus when using an injected default."
+            );
+        }
+
+        [Test]
+        public void HandlerUsesInjectedDefaultBusForTargetedMessages()
+        {
+            MessageBus customBus = new();
+            MessageHandler handler = new(new InstanceId(99), customBus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler);
+            _tokens.Add(token);
+
+            InstanceId target = new(1234);
+            int callCount = 0;
+            MessageRegistrationHandle handle = token.RegisterTargeted<SimpleTargetedMessage>(
+                target,
+                _ => ++callCount
+            );
+            _handles.Add(handle);
+
+            token.Enable();
+
+            SimpleTargetedMessage message = new();
+            message.EmitTargeted(target, customBus);
+            Assert.AreEqual(
+                1,
+                callCount,
+                "Targeted handlers should fire when messages emit on the injected bus."
+            );
+
+            message.EmitTargeted(target);
+            Assert.AreEqual(
+                1,
+                callCount,
+                "Targeted handler should ignore global bus emissions when a default bus is injected."
+            );
+        }
+
+        [Test]
+        public void HandlerUsesInjectedDefaultBusForBroadcastMessages()
+        {
+            MessageBus customBus = new();
+            MessageHandler handler = new(new InstanceId(1337), customBus) { active = true };
+            MessageRegistrationToken token = MessageRegistrationToken.Create(handler);
+            _tokens.Add(token);
+
+            int callCount = 0;
+            MessageRegistrationHandle handle = token.RegisterBroadcastWithoutSource(
+                (ref InstanceId _, ref SimpleBroadcastMessage _) => ++callCount
+            );
+            _handles.Add(handle);
+
+            token.Enable();
+
+            SimpleBroadcastMessage message = new();
+            InstanceId source = new(777);
+            message.EmitBroadcast(source, customBus);
+            Assert.AreEqual(
+                1,
+                callCount,
+                "Broadcast handlers should observe emissions on the injected bus."
+            );
+
+            message.EmitBroadcast(source);
+            Assert.AreEqual(
+                1,
+                callCount,
+                "Broadcast handler should remain isolated from global emissions when using an injected default bus."
+            );
+        }
+
+        [UnityTest]
+        public IEnumerator MessagingComponentConfigureRebindsExistingHandlerToCustomBus()
+        {
+            MessageBus customBus = new();
+            GameObject go = new(
+                nameof(MessagingComponentConfigureRebindsExistingHandlerToCustomBus),
+                typeof(MessagingComponent),
+                typeof(ManualListenerComponent)
+            );
+            _spawned.Add(go);
+
+            MessagingComponent messagingComponent = go.GetComponent<MessagingComponent>();
+            messagingComponent.Configure(customBus, MessageBusRebindMode.RebindActive);
+
+            ManualListenerComponent listener = go.GetComponent<ManualListenerComponent>();
+            MessageRegistrationToken token = listener.RequestToken(messagingComponent);
+            _tokens.Add(token);
+
+            int callCount = 0;
+            MessageRegistrationHandle handle = token.RegisterUntargeted<SimpleUntargetedMessage>(
+                _ => ++callCount
+            );
+            _handles.Add(handle);
+            token.Enable();
+
+            SimpleUntargetedMessage message = new();
+            message.EmitUntargeted(customBus);
+            Assert.AreEqual(
+                1,
+                callCount,
+                "Configure should redirect tokens to the provided MessageBus."
+            );
+
+            message.EmitUntargeted();
+            Assert.AreEqual(
+                1,
+                callCount,
+                "Global emissions should not reach tokens configured to use a custom bus."
+            );
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator MessagingComponentConfigurePreserveDefersRebindUntilReenabled()
+        {
+            MessageBus initialBus = new();
+            MessageBus newBus = new();
+            GameObject go = new(
+                nameof(MessagingComponentConfigurePreserveDefersRebindUntilReenabled),
+                typeof(MessagingComponent),
+                typeof(ManualListenerComponent)
+            );
+            _spawned.Add(go);
+
+            MessagingComponent messagingComponent = go.GetComponent<MessagingComponent>();
+            messagingComponent.Configure(initialBus, MessageBusRebindMode.RebindActive);
+
+            ManualListenerComponent listener = go.GetComponent<ManualListenerComponent>();
+            MessageRegistrationToken token = listener.RequestToken(messagingComponent);
+            _tokens.Add(token);
+
+            int callCount = 0;
+            MessageRegistrationHandle handle = token.RegisterUntargeted<SimpleUntargetedMessage>(
+                _ => ++callCount
+            );
+            _handles.Add(handle);
+            token.Enable();
+
+            SimpleUntargetedMessage message = new();
+            message.EmitUntargeted(initialBus);
+            Assert.AreEqual(1, callCount, "Initial bus should deliver to the registered handler.");
+
+            messagingComponent.Configure(newBus, MessageBusRebindMode.PreserveRegistrations);
+
+            message.EmitUntargeted(newBus);
+            Assert.AreEqual(
+                1,
+                callCount,
+                "Preserve mode should avoid rebinding active registrations immediately."
+            );
+
+            message.EmitUntargeted(initialBus);
+            Assert.AreEqual(
+                2,
+                callCount,
+                "Handlers should continue observing the original bus until re-enabled."
+            );
+
+            token.Disable();
+            token.Enable();
+
+            message.EmitUntargeted(newBus);
+            Assert.AreEqual(
+                3,
+                callCount,
+                "Re-enabling the token should rebind handlers to the new bus."
+            );
+
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator MessageAwareComponentConfigureMessageBusAppliesOverride()
+        {
+            MessageBus customBus = new();
+            GameObject go = new(
+                nameof(MessageAwareComponentConfigureMessageBusAppliesOverride),
+                typeof(MessagingComponent),
+                typeof(BusAwareComponent)
+            );
+            _spawned.Add(go);
+
+            BusAwareComponent component = go.GetComponent<BusAwareComponent>();
+            component.ConfigureMessageBus(customBus, MessageBusRebindMode.RebindActive);
+
+            yield return null;
+
+            SimpleUntargetedMessage message = new();
+            message.EmitUntargeted(customBus);
+            Assert.AreEqual(
+                1,
+                component.Received,
+                "MessageAwareComponent should route through the configured bus."
+            );
+
+            message.EmitUntargeted();
+            Assert.AreEqual(
+                1,
+                component.Received,
+                "Global bus should no longer deliver to the component after override."
+            );
+        }
+
+        [UnityTest]
+        public IEnumerator MessageAwareComponentConfigureMessageBusPreserveDefersUntilReenable()
+        {
+            MessageBus initialBus = new();
+            MessageBus newBus = new();
+            GameObject go = new(
+                nameof(MessageAwareComponentConfigureMessageBusPreserveDefersUntilReenable),
+                typeof(MessagingComponent),
+                typeof(BusAwareComponent)
+            );
+            _spawned.Add(go);
+
+            BusAwareComponent component = go.GetComponent<BusAwareComponent>();
+            component.ConfigureMessageBus(initialBus, MessageBusRebindMode.RebindActive);
+
+            yield return null;
+
+            SimpleUntargetedMessage message = new();
+            message.EmitUntargeted(initialBus);
+            Assert.AreEqual(
+                1,
+                component.Received,
+                "Component should receive messages emitted via the initial bus."
+            );
+
+            component.ConfigureMessageBus(newBus, MessageBusRebindMode.PreserveRegistrations);
+
+            message.EmitUntargeted(newBus);
+            Assert.AreEqual(
+                1,
+                component.Received,
+                "Preserve mode should not rebind active handlers immediately."
+            );
+
+            message.EmitUntargeted(initialBus);
+            Assert.AreEqual(
+                2,
+                component.Received,
+                "Existing registrations should continue to observe the original bus."
+            );
+
+            component.Token.Disable();
+            component.Token.Enable();
+
+            message.EmitUntargeted(newBus);
+            Assert.AreEqual(
+                3,
+                component.Received,
+                "Re-enabling the token should rebind handlers to the new bus."
+            );
+        }
+
+        private sealed class BusAwareComponent : MessageAwareComponent
+        {
+            internal int Received { get; private set; }
+
+            protected override bool RegisterForStringMessages => false;
+
+            protected override void RegisterMessageHandlers()
+            {
+                base.RegisterMessageHandlers();
+                _ = Token.RegisterUntargeted<SimpleUntargetedMessage>(_ => ++Received);
+            }
+        }
+    }
+}

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

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