com.wallstop-studios.dxmessaging 2.0.0 → 2.1.1

package/Tests/Runtime/Scripts/Components/EmptyMessageAwareComponent.cs

@@ -1,6 +1,6 @@
 namespace DxMessaging.Tests.Runtime.Scripts.Components
 {
-    using Unity;
+    using DxMessaging.Unity;
 
     public sealed class EmptyMessageAwareComponent : MessageAwareComponent
     {

package/Tests/Runtime/Scripts/Components/GenericMessageAwareComponent.cs

@@ -1,7 +1,7 @@
 namespace DxMessaging.Tests.Runtime.Scripts.Components
 {
+    using DxMessaging.Unity;
     using Messages;
-    using Unity;
     using UnityEngine;
 
     [DisallowMultipleComponent]

package/Tests/Runtime/Scripts/Components/SimpleMessageAwareComponent.cs

@@ -2,8 +2,8 @@ namespace DxMessaging.Tests.Runtime.Scripts.Components
 {
     using System;
     using DxMessaging.Core;
+    using DxMessaging.Unity;
     using Messages;
-    using Unity;
 
     public sealed class SimpleMessageAwareComponent : MessageAwareComponent
     {

package/Tests/Runtime/TestUtilities/UnityFixtureBase.cs

@@ -0,0 +1,64 @@
+namespace DxMessaging.Tests.Runtime
+{
+    using System;
+    using System.Collections.Generic;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Provides cleanup helpers for tests that instantiate Unity objects or disposable resources.
+    /// </summary>
+    public abstract class UnityFixtureBase
+    {
+        private readonly List<IDisposable> _disposables = new();
+        private readonly List<UnityEngine.Object> _unityObjects = new();
+
+        protected T Track<T>(T unityObject)
+            where T : UnityEngine.Object
+        {
+            if (unityObject != null)
+            {
+                _unityObjects.Add(unityObject);
+            }
+
+            return unityObject;
+        }
+
+        protected T TrackDisposable<T>(T disposable)
+            where T : IDisposable
+        {
+            if (disposable != null)
+            {
+                _disposables.Add(disposable);
+            }
+
+            return disposable;
+        }
+
+        [TearDown]
+        public virtual void TearDownManagedResources()
+        {
+            for (int i = _disposables.Count - 1; i >= 0; i--)
+            {
+                try
+                {
+                    _disposables[i]?.Dispose();
+                }
+                catch
+                {
+                    // Ignore teardown exceptions to avoid masking test failures.
+                }
+            }
+            _disposables.Clear();
+
+            for (int i = _unityObjects.Count - 1; i >= 0; i--)
+            {
+                UnityEngine.Object instance = _unityObjects[i];
+                if (instance != null)
+                {
+                    UnityEngine.Object.DestroyImmediate(instance);
+                }
+            }
+            _unityObjects.Clear();
+        }
+    }
+}

package/Tests/Runtime/TestUtilities/UnityFixtureBase.cs.meta

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

package/Tests/Runtime/TestUtilities.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 9e845c7a4bcb4d84b1be9b8fba64a2fc
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

package/Tests/Runtime/Unity/MessageBusProviderAssetTests.cs

@@ -0,0 +1,57 @@
+namespace DxMessaging.Tests.Runtime.Unity
+{
+    using DxMessaging.Core;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Tests.Runtime;
+    using DxMessaging.Unity;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    [TestFixture]
+    public sealed class MessageBusProviderAssetTests : UnityFixtureBase
+    {
+        [Test]
+        public void GlobalProviderRespectsCurrentGlobalBus()
+        {
+            CurrentGlobalMessageBusProvider provider = Track(
+                ScriptableObject.CreateInstance<CurrentGlobalMessageBusProvider>()
+            );
+
+            MessageBus overrideBus = new();
+            using (MessageHandler.OverrideGlobalMessageBus(overrideBus))
+            {
+                IMessageBus resolved = provider.Resolve();
+                Assert.AreSame(
+                    overrideBus,
+                    resolved,
+                    "Global provider should resolve the currently configured global bus."
+                );
+            }
+        }
+
+        [Test]
+        public void InitialProviderAlwaysReturnsStartupBus()
+        {
+            InitialGlobalMessageBusProvider provider = Track(
+                ScriptableObject.CreateInstance<InitialGlobalMessageBusProvider>()
+            );
+
+            IMessageBus startupBus = provider.Resolve();
+            Assert.AreSame(
+                MessageHandler.InitialGlobalMessageBus,
+                startupBus,
+                "Initial provider should resolve the startup global bus."
+            );
+
+            using (MessageHandler.OverrideGlobalMessageBus(new MessageBus()))
+            {
+                IMessageBus resolvedDuringOverride = provider.Resolve();
+                Assert.AreSame(
+                    startupBus,
+                    resolvedDuringOverride,
+                    "Initial provider should ignore overrides and continue returning the startup bus."
+                );
+            }
+        }
+    }
+}

package/Tests/Runtime/Unity/MessageBusProviderAssetTests.cs.meta

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

package/Tests/Runtime/Unity/MessageBusProviderHandleTests.cs

@@ -0,0 +1,107 @@
+namespace DxMessaging.Tests.Runtime.Unity
+{
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Unity;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    [TestFixture]
+    public sealed class MessageBusProviderHandleTests
+    {
+        [Test]
+        public void TryGetProviderReturnsRuntimeProvider()
+        {
+            TestMessageBusProvider runtimeProvider = new(new MessageBus());
+            MessageBusProviderHandle handle = MessageBusProviderHandle.FromProvider(
+                runtimeProvider
+            );
+
+            bool resolved = handle.TryGetProvider(out IMessageBusProvider provider);
+
+            Assert.IsTrue(resolved);
+            Assert.AreSame(runtimeProvider, provider);
+        }
+
+        [Test]
+        public void TryGetProviderReturnsAssetProvider()
+        {
+            TestScriptableMessageBusProvider providerAsset =
+                ScriptableObject.CreateInstance<TestScriptableMessageBusProvider>();
+            providerAsset.Configure(new MessageBus());
+            MessageBusProviderHandle handle = new(providerAsset);
+
+            bool resolved = handle.TryGetProvider(out IMessageBusProvider provider);
+
+            Assert.IsTrue(resolved);
+            Assert.AreSame(providerAsset, provider);
+
+            Object.DestroyImmediate(providerAsset);
+        }
+
+        [Test]
+        public void ResolveBusReturnsNullWhenUnassigned()
+        {
+            MessageBusProviderHandle handle = MessageBusProviderHandle.Empty;
+
+            IMessageBus bus = handle.ResolveBus();
+
+            Assert.IsNull(bus);
+        }
+
+        [Test]
+        public void HandleSurvivesSerializationCycle()
+        {
+            TestScriptableMessageBusProvider providerAsset =
+                ScriptableObject.CreateInstance<TestScriptableMessageBusProvider>();
+            providerAsset.Configure(new MessageBus());
+            MessageBusProviderHandle handle = new(providerAsset);
+
+            HandleWrapper wrapper = new() { Handle = handle };
+            string json = JsonUtility.ToJson(wrapper);
+            HandleWrapper deserialized = JsonUtility.FromJson<HandleWrapper>(json);
+
+            bool resolved = deserialized.Handle.TryGetProvider(out IMessageBusProvider provider);
+
+            Assert.IsTrue(resolved);
+            Assert.AreSame(providerAsset, provider);
+
+            Object.DestroyImmediate(providerAsset);
+        }
+
+        private sealed class TestMessageBusProvider : IMessageBusProvider
+        {
+            private readonly IMessageBus _bus;
+
+            public TestMessageBusProvider(IMessageBus bus)
+            {
+                _bus = bus;
+            }
+
+            public IMessageBus Resolve()
+            {
+                return _bus;
+            }
+        }
+
+        [System.Serializable]
+        private struct HandleWrapper
+        {
+            public MessageBusProviderHandle Handle;
+        }
+
+        private sealed class TestScriptableMessageBusProvider : ScriptableMessageBusProvider
+        {
+            private IMessageBus _bus;
+
+            public void Configure(IMessageBus bus)
+            {
+                _bus = bus;
+            }
+
+            public override IMessageBus Resolve()
+            {
+                return _bus;
+            }
+        }
+    }
+}

package/Tests/Runtime/Unity/MessageBusProviderHandleTests.cs.meta

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

package/Tests/Runtime/Unity/MessagingComponentProviderIntegrationTests.cs

@@ -0,0 +1,210 @@
+namespace DxMessaging.Tests.Runtime.Unity
+{
+    using System.Collections;
+    using System.Text.RegularExpressions;
+    using DxMessaging.Core;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Core.Messages;
+    using DxMessaging.Unity;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+
+    public sealed class MessagingComponentProviderIntegrationTests
+    {
+        [UnityTest]
+        public IEnumerator ConfigureWithProviderHandleRoutesThroughProviderBus()
+        {
+            MessageBus messageBus = new();
+            TestScriptableMessageBusProvider provider =
+                ScriptableObject.CreateInstance<TestScriptableMessageBusProvider>();
+            provider.Configure(messageBus);
+            MessageBusProviderHandle handle = new(provider);
+
+            GameObject owner = new("MessagingComponentOwner");
+            MessagingComponent messagingComponent = owner.AddComponent<MessagingComponent>();
+            messagingComponent.Configure(handle, MessageBusRebindMode.RebindActive);
+
+            TestListener listener = owner.AddComponent<TestListener>();
+            listener.Initialize(messagingComponent);
+
+            yield return null;
+
+            TestUntargetedMessage message = new(42);
+            messageBus.UntargetedBroadcast(ref message);
+
+            Assert.AreEqual(1, listener.ReceivedCount);
+
+            Object.DestroyImmediate(owner);
+            Object.DestroyImmediate(provider);
+        }
+
+        [UnityTest]
+        public IEnumerator InstallerAppliesConfigurationToChildren()
+        {
+            MessageBus messageBus = new();
+            TestScriptableMessageBusProvider provider =
+                ScriptableObject.CreateInstance<TestScriptableMessageBusProvider>();
+            provider.Configure(messageBus);
+            MessageBusProviderHandle handle = new(provider);
+
+            GameObject root = new("InstallerRoot");
+            MessagingComponentInstaller installer =
+                root.AddComponent<MessagingComponentInstaller>();
+            installer.SetProvider(handle);
+
+            GameObject child = new("InstallerListener");
+            child.transform.SetParent(root.transform);
+            MessagingComponent messagingComponent = child.AddComponent<MessagingComponent>();
+
+            installer.ApplyConfiguration();
+
+            TestListener listener = child.AddComponent<TestListener>();
+            listener.Initialize(messagingComponent);
+
+            yield return null;
+
+            TestUntargetedMessage message = new(19);
+            messageBus.UntargetedBroadcast(ref message);
+
+            Assert.AreEqual(1, listener.ReceivedCount);
+
+            Object.DestroyImmediate(root);
+            Object.DestroyImmediate(provider);
+        }
+
+        [UnityTest]
+        public IEnumerator CreateRegistrationBuilderUsesConfiguredProviderBus()
+        {
+            MessageBus messageBus = new();
+            TestProvider provider = new(messageBus);
+
+            GameObject owner = new("BuilderOwner");
+            MessagingComponent messagingComponent = owner.AddComponent<MessagingComponent>();
+            messagingComponent.Configure(provider, MessageBusRebindMode.RebindActive);
+
+            IMessageRegistrationBuilder builder = messagingComponent.CreateRegistrationBuilder();
+            using (
+                MessageRegistrationLease lease = builder.Build(
+                    new MessageRegistrationBuildOptions()
+                )
+            )
+            {
+                Assert.AreSame(messageBus, lease.MessageBus);
+                Assert.IsFalse(lease.Token.Enabled);
+            }
+
+            Object.DestroyImmediate(owner);
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator CreateRegistrationBuilderUsesOverrideBusWhenNoProvider()
+        {
+            MessageBus messageBus = new();
+
+            GameObject owner = new("OverrideOwner");
+            MessagingComponent messagingComponent = owner.AddComponent<MessagingComponent>();
+            messagingComponent.Configure(messageBus, MessageBusRebindMode.RebindActive);
+
+            IMessageRegistrationBuilder builder = messagingComponent.CreateRegistrationBuilder();
+            using (
+                MessageRegistrationLease lease = builder.Build(
+                    new MessageRegistrationBuildOptions()
+                )
+            )
+            {
+                Assert.AreSame(messageBus, lease.MessageBus);
+            }
+            Object.DestroyImmediate(owner);
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator InstallerWithoutConfigurationLogsWarning()
+        {
+            GameObject root = new("InstallerWarningRoot");
+            MessagingComponentInstaller installer =
+                root.AddComponent<MessagingComponentInstaller>();
+
+            GameObject child = new("InstallerWarningChild");
+            child.transform.SetParent(root.transform);
+            _ = child.AddComponent<MessagingComponent>();
+
+            LogAssert.Expect(
+                LogType.Warning,
+                new Regex(
+                    "MessagingComponentInstaller.+has no provider or explicit message bus configured"
+                )
+            );
+
+            installer.ApplyConfiguration();
+            yield return null;
+
+            Object.DestroyImmediate(root);
+        }
+
+        private sealed class TestListener : MonoBehaviour
+        {
+            private MessageRegistrationToken _token;
+            public int ReceivedCount { get; private set; }
+
+            public void Initialize(MessagingComponent messagingComponent)
+            {
+                _token = messagingComponent.Create(this);
+                _ = _token.RegisterUntargeted<TestUntargetedMessage>(OnUntargetedMessage);
+                _token.Enable();
+            }
+
+            private void OnUntargetedMessage(ref TestUntargetedMessage message)
+            {
+                ReceivedCount++;
+            }
+
+            private void OnDestroy()
+            {
+                _token?.Disable();
+            }
+        }
+
+        private sealed class TestScriptableMessageBusProvider : ScriptableMessageBusProvider
+        {
+            private IMessageBus _bus;
+
+            public void Configure(IMessageBus bus)
+            {
+                _bus = bus;
+            }
+
+            public override IMessageBus Resolve()
+            {
+                return _bus;
+            }
+        }
+
+        private sealed class TestProvider : IMessageBusProvider
+        {
+            private readonly IMessageBus _messageBus;
+
+            public TestProvider(IMessageBus messageBus)
+            {
+                _messageBus = messageBus;
+            }
+
+            public IMessageBus Resolve()
+            {
+                return _messageBus;
+            }
+        }
+
+        private readonly struct TestUntargetedMessage : IUntargetedMessage
+        {
+            public TestUntargetedMessage(int value)
+            {
+                Value = value;
+            }
+
+            public int Value { get; }
+        }
+    }
+}

package/Tests/Runtime/Unity/MessagingComponentProviderIntegrationTests.cs.meta

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

package/Tests/Runtime/Unity.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e1576d59050e4b7cbc1b55ce49963cf0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+

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

@@ -5,7 +5,9 @@
     "UnityEngine.TestRunner",
     "UnityEditor.TestRunner",
     "WallstopStudios.DxMessaging",
-    "Unity.PerformanceTesting"
+    "WallstopStudios.DxMessaging.Reflex",
+    "WallstopStudios.DxMessaging.VContainer",
+    "WallstopStudios.DxMessaging.Zenject"
   ],
   "includePlatforms": [],
   "excludePlatforms": [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.dxmessaging",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "displayName": "DxMessaging",
   "description": "Synchronous Event Bus for Unity",
   "unity": "2021.3",