com.wallstop-studios.dxmessaging 2.1.0 → 2.1.2

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/Tests/Runtime/WallstopStudios.DxMessaging.Tests.Runtime.csproj

@@ -1,7 +1,20 @@
-<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"
-/>
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>disable</Nullable>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+    <EnableDefaultNoneItems>false</EnableDefaultNoneItems>
+    <IsPackable>false</IsPackable>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <NoWarn>1701;1702</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+    <None Include="Benchmarks\**\*.cs" LinkBase="Benchmarks" />
+    <None Include="Core\**\*.cs" LinkBase="Core" />
+    <None Include="Integrations\**\*.cs" LinkBase="Integrations" />
+    <None Include="Scripts\**\*.cs" LinkBase="Scripts" />
+    <None Include="TestUtilities\**\*.cs" LinkBase="TestUtilities" />
+    <None Include="Unity\**\*.cs" LinkBase="Unity" />
+  </ItemGroup>
+</Project>

package/package.json

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