com.wallstop-studios.dxmessaging 2.1.1 → 2.1.3

package/Tests/Runtime/Unity/MessagingComponentInstallerSceneTests.cs

@@ -0,0 +1,109 @@
+#if UNITY_2021_3_OR_NEWER
+namespace DxMessaging.Tests.Runtime.Unity
+{
+    using System.Collections;
+    using System.Collections.Generic;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Unity;
+    using NUnit.Framework;
+    using UnityEditor;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+
+    public sealed class MessagingComponentInstallerSceneTests
+    {
+        private readonly List<Object> _createdObjects = new();
+
+        [TearDown]
+        public void TearDown()
+        {
+            foreach (Object instance in _createdObjects)
+            {
+                if (instance != null)
+                {
+                    Object.DestroyImmediate(instance);
+                }
+            }
+            _createdObjects.Clear();
+        }
+
+        [UnityTest]
+        public IEnumerator InstallerAppliesSerializedProviderToChildren()
+        {
+            MessageBus messageBus = new();
+            TestScriptableMessageBusProvider provider = Track(
+                ScriptableObject.CreateInstance<TestScriptableMessageBusProvider>()
+            );
+            provider.Configure(messageBus);
+
+            GameObject root = Track(new GameObject("InstallerRoot"));
+            MessagingComponentInstaller installer =
+                root.AddComponent<MessagingComponentInstaller>();
+            installer.SetProvider(new MessageBusProviderHandle(provider));
+
+            GameObject child = Track(new GameObject("InstallerChild"));
+            child.transform.SetParent(root.transform);
+            MessagingComponent component = child.AddComponent<MessagingComponent>();
+
+            SerializedObject serializedComponent = new(component);
+            SerializedProperty autoConfigureProperty = serializedComponent.FindProperty(
+                "autoConfigureSerializedProviderOnAwake"
+            );
+            Assert.That(autoConfigureProperty, Is.Not.Null, "Expected auto configure property.");
+            autoConfigureProperty.boolValue = true;
+            serializedComponent.ApplyModifiedPropertiesWithoutUndo();
+
+            installer.ApplyConfiguration();
+
+            yield return null;
+
+            Assert.That(
+                component.SerializedProviderHandle.SerializedProvider,
+                Is.EqualTo(provider),
+                "Serialized provider handle should reference the installer provider."
+            );
+            Assert.That(
+                component.SerializedProviderHandle.ResolveBus(),
+                Is.EqualTo(messageBus),
+                "Serialized provider should resolve to the configured bus."
+            );
+
+            component.enabled = false;
+            yield return null;
+            component.enabled = true;
+            yield return null;
+
+            Assert.That(
+                component.SerializedProviderHandle.ResolveBus(),
+                Is.EqualTo(messageBus),
+                "Provider resolution should persist after enable/disable cycles."
+            );
+        }
+
+        private T Track<T>(T unityObject)
+            where T : Object
+        {
+            if (unityObject != null)
+            {
+                _createdObjects.Add(unityObject);
+            }
+            return unityObject;
+        }
+
+        private sealed class TestScriptableMessageBusProvider : ScriptableMessageBusProvider
+        {
+            private IMessageBus _bus;
+
+            internal void Configure(IMessageBus bus)
+            {
+                _bus = bus;
+            }
+
+            public override IMessageBus Resolve()
+            {
+                return _bus;
+            }
+        }
+    }
+}
+#endif

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

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

package/Tests/Runtime/Unity/MessagingComponentProviderIntegrationTests.cs

@@ -1,6 +1,8 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Unity
 {
     using System.Collections;
+    using System.Collections.Generic;
     using System.Text.RegularExpressions;
     using DxMessaging.Core;
     using DxMessaging.Core.MessageBus;
@@ -12,6 +14,29 @@ namespace DxMessaging.Tests.Runtime.Unity
 
     public sealed class MessagingComponentProviderIntegrationTests
     {
+        private readonly List<Object> _objectsToDestroy = new();
+
+        [SetUp]
+        public void SetUp()
+        {
+            _objectsToDestroy.Clear();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            for (int i = 0; i < _objectsToDestroy.Count; ++i)
+            {
+                Object obj = _objectsToDestroy[i];
+                if (obj != null)
+                {
+                    Object.DestroyImmediate(obj);
+                }
+            }
+
+            _objectsToDestroy.Clear();
+        }
+
         [UnityTest]
         public IEnumerator ConfigureWithProviderHandleRoutesThroughProviderBus()
         {
@@ -19,9 +44,10 @@ namespace DxMessaging.Tests.Runtime.Unity
             TestScriptableMessageBusProvider provider =
                 ScriptableObject.CreateInstance<TestScriptableMessageBusProvider>();
             provider.Configure(messageBus);
+            Track(provider);
             MessageBusProviderHandle handle = new(provider);
 
-            GameObject owner = new("MessagingComponentOwner");
+            GameObject owner = Track(new GameObject("MessagingComponentOwner"));
             MessagingComponent messagingComponent = owner.AddComponent<MessagingComponent>();
             messagingComponent.Configure(handle, MessageBusRebindMode.RebindActive);
 
@@ -34,9 +60,6 @@ namespace DxMessaging.Tests.Runtime.Unity
             messageBus.UntargetedBroadcast(ref message);
 
             Assert.AreEqual(1, listener.ReceivedCount);
-
-            Object.DestroyImmediate(owner);
-            Object.DestroyImmediate(provider);
         }
 
         [UnityTest]
@@ -46,14 +69,15 @@ namespace DxMessaging.Tests.Runtime.Unity
             TestScriptableMessageBusProvider provider =
                 ScriptableObject.CreateInstance<TestScriptableMessageBusProvider>();
             provider.Configure(messageBus);
+            Track(provider);
             MessageBusProviderHandle handle = new(provider);
 
-            GameObject root = new("InstallerRoot");
+            GameObject root = Track(new GameObject("InstallerRoot"));
             MessagingComponentInstaller installer =
                 root.AddComponent<MessagingComponentInstaller>();
             installer.SetProvider(handle);
 
-            GameObject child = new("InstallerListener");
+            GameObject child = Track(new GameObject("InstallerListener"));
             child.transform.SetParent(root.transform);
             MessagingComponent messagingComponent = child.AddComponent<MessagingComponent>();
 
@@ -68,9 +92,6 @@ namespace DxMessaging.Tests.Runtime.Unity
             messageBus.UntargetedBroadcast(ref message);
 
             Assert.AreEqual(1, listener.ReceivedCount);
-
-            Object.DestroyImmediate(root);
-            Object.DestroyImmediate(provider);
         }
 
         [UnityTest]
@@ -79,7 +100,7 @@ namespace DxMessaging.Tests.Runtime.Unity
             MessageBus messageBus = new();
             TestProvider provider = new(messageBus);
 
-            GameObject owner = new("BuilderOwner");
+            GameObject owner = Track(new GameObject("BuilderOwner"));
             MessagingComponent messagingComponent = owner.AddComponent<MessagingComponent>();
             messagingComponent.Configure(provider, MessageBusRebindMode.RebindActive);
 
@@ -93,8 +114,6 @@ namespace DxMessaging.Tests.Runtime.Unity
                 Assert.AreSame(messageBus, lease.MessageBus);
                 Assert.IsFalse(lease.Token.Enabled);
             }
-
-            Object.DestroyImmediate(owner);
             yield break;
         }
 
@@ -103,7 +122,7 @@ namespace DxMessaging.Tests.Runtime.Unity
         {
             MessageBus messageBus = new();
 
-            GameObject owner = new("OverrideOwner");
+            GameObject owner = Track(new GameObject("OverrideOwner"));
             MessagingComponent messagingComponent = owner.AddComponent<MessagingComponent>();
             messagingComponent.Configure(messageBus, MessageBusRebindMode.RebindActive);
 
@@ -116,18 +135,17 @@ namespace DxMessaging.Tests.Runtime.Unity
             {
                 Assert.AreSame(messageBus, lease.MessageBus);
             }
-            Object.DestroyImmediate(owner);
             yield break;
         }
 
         [UnityTest]
         public IEnumerator InstallerWithoutConfigurationLogsWarning()
         {
-            GameObject root = new("InstallerWarningRoot");
+            GameObject root = Track(new GameObject("InstallerWarningRoot"));
             MessagingComponentInstaller installer =
                 root.AddComponent<MessagingComponentInstaller>();
 
-            GameObject child = new("InstallerWarningChild");
+            GameObject child = Track(new GameObject("InstallerWarningChild"));
             child.transform.SetParent(root.transform);
             _ = child.AddComponent<MessagingComponent>();
 
@@ -141,7 +159,129 @@ namespace DxMessaging.Tests.Runtime.Unity
             installer.ApplyConfiguration();
             yield return null;
 
-            Object.DestroyImmediate(root);
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator PreserveRegistrationsKeepsExistingHandlersOnOriginalBus()
+        {
+            MessageBus originalBus = new();
+            MessageBus newBus = new();
+
+            GameObject owner = Track(new GameObject("PreserveOwner"));
+            MessagingComponent messagingComponent = owner.AddComponent<MessagingComponent>();
+            messagingComponent.Configure(originalBus, MessageBusRebindMode.RebindActive);
+
+            TestListener originalListener = owner.AddComponent<TestListener>();
+            originalListener.Initialize(messagingComponent);
+
+            yield return null;
+
+            TestUntargetedMessage message = new(1);
+            originalBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(
+                1,
+                originalListener.ReceivedCount,
+                "Original listener should observe messages on the initial bus."
+            );
+
+            messagingComponent.Configure(newBus, MessageBusRebindMode.PreserveRegistrations);
+
+            message = new TestUntargetedMessage(2);
+            originalBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(
+                2,
+                originalListener.ReceivedCount,
+                "Existing listener should remain bound to the original bus when preserving registrations."
+            );
+
+            message = new TestUntargetedMessage(3);
+            newBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(
+                2,
+                originalListener.ReceivedCount,
+                "Existing listener should not observe messages on the new bus when preserving registrations."
+            );
+
+            TestListener newListener = owner.AddComponent<TestListener>();
+            newListener.Initialize(messagingComponent);
+
+            yield return null;
+
+            message = new TestUntargetedMessage(4);
+            newBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(
+                1,
+                newListener.ReceivedCount,
+                "New listener should bind to the new bus after preservation."
+            );
+            Assert.AreEqual(2, originalListener.ReceivedCount);
+
+            message = new TestUntargetedMessage(5);
+            originalBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(
+                1,
+                newListener.ReceivedCount,
+                "New listener should not observe messages sent on the original bus."
+            );
+            Assert.AreEqual(3, originalListener.ReceivedCount);
+
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator RebindActiveMovesExistingHandlersToNewBus()
+        {
+            MessageBus originalBus = new();
+            MessageBus newBus = new();
+
+            GameObject owner = Track(new GameObject("RebindOwner"));
+            MessagingComponent messagingComponent = owner.AddComponent<MessagingComponent>();
+            messagingComponent.Configure(originalBus, MessageBusRebindMode.RebindActive);
+
+            TestListener listener = owner.AddComponent<TestListener>();
+            listener.Initialize(messagingComponent);
+
+            yield return null;
+
+            TestUntargetedMessage message = new(1);
+            originalBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(
+                1,
+                listener.ReceivedCount,
+                "Listener should observe messages on the initial bus prior to rebind."
+            );
+
+            messagingComponent.Configure(newBus, MessageBusRebindMode.RebindActive);
+
+            message = new TestUntargetedMessage(2);
+            originalBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(
+                1,
+                listener.ReceivedCount,
+                "Listener should no longer receive messages on the original bus after rebinding."
+            );
+
+            message = new TestUntargetedMessage(3);
+            newBus.UntargetedBroadcast(ref message);
+            Assert.AreEqual(
+                2,
+                listener.ReceivedCount,
+                "Listener should observe messages on the new bus after rebinding."
+            );
+
+            yield break;
+        }
+
+        private T Track<T>(T unityObject)
+            where T : Object
+        {
+            if (unityObject != null)
+            {
+                _objectsToDestroy.Add(unityObject);
+            }
+
+            return unityObject;
         }
 
         private sealed class TestListener : MonoBehaviour
@@ -208,3 +348,5 @@ namespace DxMessaging.Tests.Runtime.Unity
         }
     }
 }
+
+#endif

package/package.json

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

package/Tests/Runtime/WallstopStudios.DxMessaging.Tests.Runtime.csproj

@@ -1,7 +0,0 @@
-<wpf:ResourceDictionary
-  xml:space="preserve"
-  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-  xmlns:s="clr-namespace:System;assembly=mscorlib"
-  xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml"
-  xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-/>