com.wallstop-studios.dxmessaging 2.1.0 → 2.1.2

package/Tests/Editor/MessagingComponentSerializationTests.cs

@@ -0,0 +1,129 @@
+#if UNITY_EDITOR && UNITY_2021_3_OR_NEWER
+namespace DxMessaging.Tests.Editor
+{
+    using System.Collections.Generic;
+    using DxMessaging.Core.MessageBus;
+    using DxMessaging.Unity;
+    using NUnit.Framework;
+    using UnityEditor;
+    using UnityEngine;
+    using Object = UnityEngine.Object;
+
+    [TestFixture]
+    public sealed class MessagingComponentSerializationTests
+    {
+        private readonly List<Object> _createdObjects = new();
+        private readonly List<string> _createdAssetPaths = new();
+
+        [TearDown]
+        public void TearDown()
+        {
+            foreach (Object instance in _createdObjects)
+            {
+                if (instance != null && !EditorUtility.IsPersistent(instance))
+                {
+                    Object.DestroyImmediate(instance);
+                }
+            }
+            _createdObjects.Clear();
+
+            foreach (string assetPath in _createdAssetPaths)
+            {
+                if (!string.IsNullOrEmpty(assetPath))
+                {
+                    AssetDatabase.DeleteAsset(assetPath);
+                }
+            }
+            _createdAssetPaths.Clear();
+            AssetDatabase.Refresh();
+        }
+
+        [Test]
+        public void SerializedProviderHandleSurvivesJsonRoundtrip()
+        {
+            MessageBus messageBus = new();
+            TestScriptableMessageBusProvider provider =
+                ScriptableObject.CreateInstance<TestScriptableMessageBusProvider>();
+            provider.Configure(messageBus);
+            string assetPath = AssetDatabase.GenerateUniqueAssetPath(
+                "Assets/__TempTestProvider.asset"
+            );
+            AssetDatabase.CreateAsset(provider, assetPath);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.ImportAsset(assetPath);
+            _createdAssetPaths.Add(assetPath);
+
+            GameObject owner = Track(new GameObject("OriginalComponentOwner"));
+            MessagingComponent original = owner.AddComponent<MessagingComponent>();
+            original.Configure(
+                new MessageBusProviderHandle(provider),
+                MessageBusRebindMode.RebindActive
+            );
+
+            SerializedObject originalSerialized = new(original);
+            SerializedProperty autoConfigureProperty = originalSerialized.FindProperty(
+                "autoConfigureSerializedProviderOnAwake"
+            );
+            Assert.IsNotNull(autoConfigureProperty, "Expected auto configure property to exist.");
+            autoConfigureProperty.boolValue = true;
+            originalSerialized.ApplyModifiedPropertiesWithoutUndo();
+
+            string serializedJson = EditorJsonUtility.ToJson(original);
+            Assert.IsFalse(
+                string.IsNullOrEmpty(serializedJson),
+                "JSON serialization should produce content."
+            );
+
+            GameObject cloneOwner = Track(new GameObject("ClonedComponentOwner"));
+            MessagingComponent clone = cloneOwner.AddComponent<MessagingComponent>();
+            EditorJsonUtility.FromJsonOverwrite(serializedJson, clone);
+
+            Assert.IsTrue(
+                clone.SerializedProviderHandle.TryGetProvider(
+                    out IMessageBusProvider resolvedProvider
+                ),
+                "Serialized provider handle should still resolve after JSON roundtrip."
+            );
+            Assert.AreSame(provider, resolvedProvider, "Provider reference should be preserved.");
+            Assert.AreSame(
+                provider,
+                clone.SerializedProviderHandle.SerializedProvider,
+                "Provider asset reference should be preserved."
+            );
+
+            IMessageBus resolvedBus = clone.SerializedProviderHandle.ResolveBus();
+            Assert.AreSame(
+                messageBus,
+                resolvedBus,
+                "Resolved bus should match the original provider configuration."
+            );
+        }
+
+        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/Editor/MessagingComponentSerializationTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: add9131c704f47c39fbef33dbf71faa0
+timeCreated: 1761880591

package/Tests/Editor/WallstopStudios.DxMessaging.Tests.Editor.asmdef

@@ -0,0 +1,19 @@
+{
+  "name": "WallstopStudios.DxMessaging.Tests.Editor",
+  "rootNamespace": "DxMessaging.Tests.Editor",
+  "references": [
+    "UnityEditor.TestRunner",
+    "UnityEngine.TestRunner",
+    "WallstopStudios.DxMessaging",
+    "WallstopStudios.DxMessaging.Editor"
+  ],
+  "includePlatforms": ["Editor"],
+  "excludePlatforms": [],
+  "allowUnsafeCode": false,
+  "overrideReferences": true,
+  "precompiledReferences": ["nunit.framework.dll"],
+  "autoReferenced": true,
+  "defineConstraints": ["UNITY_INCLUDE_TESTS"],
+  "versionDefines": [],
+  "noEngineReferences": false
+}

package/Tests/Editor/WallstopStudios.DxMessaging.Tests.Editor.asmdef.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 824502f38a4d40908d0cc74ba7eda5cb
+timeCreated: 1761880591

package/Tests/Editor.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3dfad12af65044df8412cc4a1c7ebc7b
+timeCreated: 1761880591

package/Tests/Runtime/Benchmarks/BenchmarkSession.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Benchmarks
 {
     using System;
@@ -442,3 +443,5 @@ namespace DxMessaging.Tests.Runtime.Benchmarks
         }
     }
 }
+
+#endif

package/Tests/Runtime/Benchmarks/BenchmarkTestBase.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Benchmarks
 {
     using System;
@@ -92,3 +93,5 @@ namespace DxMessaging.Tests.Runtime.Benchmarks
         }
     }
 }
+
+#endif

package/Tests/Runtime/Benchmarks/ComparisonPerformanceTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Benchmarks
 {
     using System;
@@ -393,3 +394,5 @@ namespace DxMessaging.Tests.Runtime.Benchmarks
 #endif
     }
 }
+
+#endif

package/Tests/Runtime/Benchmarks/PerformanceTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Benchmarks
 {
     using System;
@@ -65,6 +66,12 @@ namespace DxMessaging.Tests.Runtime.Benchmarks
                     RunWithComponent(component =>
                         NoCopyUntargeted(timer, timeout, component, untargetedMessage)
                     );
+                    RunWithComponent(component =>
+                        InterceptorHeavyUntargeted(timer, timeout, component, untargetedMessage)
+                    );
+                    RunWithComponent(component =>
+                        PostProcessorHeavyUntargeted(timer, timeout, component, untargetedMessage)
+                    );
                     RunWithComponent(component =>
                         ReflexiveOneArgument(timer, timeout, component.gameObject, reflexiveMessage)
                     );
@@ -482,5 +489,135 @@ namespace DxMessaging.Tests.Runtime.Benchmarks
                 ++count;
             }
         }
+
+        private void InterceptorHeavyUntargeted(
+            Stopwatch timer,
+            TimeSpan timeout,
+            EmptyMessageAwareComponent component,
+            SimpleUntargetedMessage message
+        )
+        {
+            int handlerInvocationCount = 0;
+            int interceptorInvocationCount = 0;
+            MessageRegistrationToken token = GetToken(component);
+
+            const int InterceptorCount = 8;
+            for (int i = 0; i < InterceptorCount; ++i)
+            {
+                token.RegisterUntargetedInterceptor<SimpleUntargetedMessage>(
+                    (ref SimpleUntargetedMessage _) =>
+                    {
+                        ++interceptorInvocationCount;
+                        return true;
+                    }
+                );
+            }
+
+            token.RegisterUntargeted<SimpleUntargetedMessage>(Handle);
+            message.EmitUntargeted();
+
+            timer.Restart();
+            do
+            {
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    message.EmitUntargeted();
+                }
+            } while (timer.Elapsed < timeout);
+
+            bool allocating;
+            try
+            {
+                Assert.That(() => message.EmitUntargeted(), Is.Not.AllocatingGCMemory());
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
+
+            Assert.Greater(
+                interceptorInvocationCount,
+                0,
+                "Interceptor-heavy benchmark should invoke registered interceptors."
+            );
+
+            DisplayCount(
+                "DxMessaging (Untargeted) - Interceptors",
+                handlerInvocationCount,
+                timeout,
+                allocating
+            );
+            return;
+
+            void Handle(ref SimpleUntargetedMessage _)
+            {
+                ++handlerInvocationCount;
+            }
+        }
+
+        private void PostProcessorHeavyUntargeted(
+            Stopwatch timer,
+            TimeSpan timeout,
+            EmptyMessageAwareComponent component,
+            SimpleUntargetedMessage message
+        )
+        {
+            int handlerInvocationCount = 0;
+            int postProcessorInvocationCount = 0;
+            MessageRegistrationToken token = GetToken(component);
+
+            const int PostProcessorCount = 8;
+            for (int i = 0; i < PostProcessorCount; ++i)
+            {
+                token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(
+                    (ref SimpleUntargetedMessage _) => ++postProcessorInvocationCount
+                );
+            }
+
+            token.RegisterUntargeted<SimpleUntargetedMessage>(Handle);
+            message.EmitUntargeted();
+
+            timer.Restart();
+            do
+            {
+                for (int i = 0; i < NumInvocationsPerIteration; ++i)
+                {
+                    message.EmitUntargeted();
+                }
+            } while (timer.Elapsed < timeout);
+
+            bool allocating;
+            try
+            {
+                Assert.That(() => message.EmitUntargeted(), Is.Not.AllocatingGCMemory());
+                allocating = false;
+            }
+            catch
+            {
+                allocating = true;
+            }
+
+            Assert.Greater(
+                postProcessorInvocationCount,
+                0,
+                "Post-processor benchmark should invoke registered post-processors."
+            );
+
+            DisplayCount(
+                "DxMessaging (Untargeted) - Post-Processors",
+                handlerInvocationCount,
+                timeout,
+                allocating
+            );
+            return;
+
+            void Handle(ref SimpleUntargetedMessage _)
+            {
+                ++handlerInvocationCount;
+            }
+        }
     }
 }
+
+#endif

package/Tests/Runtime/Core/AlternateBusTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -80,3 +81,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/BroadcastTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -895,3 +896,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/CyclicBufferTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -68,3 +69,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/DefaultBusFallbackTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -20,9 +21,9 @@ namespace DxMessaging.Tests.Runtime.Core
         [TearDown]
         public void TearDown()
         {
-            foreach (var token in _tokens)
+            foreach (MessageRegistrationToken token in _tokens)
             {
-                foreach (var handle in _handles)
+                foreach (MessageRegistrationHandle handle in _handles)
                 {
                     token.RemoveRegistration(handle);
                 }
@@ -331,3 +332,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/DiagnosticsTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -116,3 +117,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/EdgeCaseTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 // ReSharper disable AccessToModifiedClosure
 namespace DxMessaging.Tests.Runtime.Core
 {
@@ -577,3 +578,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/EnablementTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -67,3 +68,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/Extensions/MessageExtensionsProviderTests.cs

@@ -204,7 +204,7 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
 
             MessageHandler handler = new(new InstanceId(601), providerBus) { active = true };
             MessageRegistrationToken token = MessageRegistrationToken.Create(handler, providerBus);
-            string? received = null;
+            string received = null;
             _ = token.RegisterTargeted(target, (ref StringMessage m) => received = m.message);
             token.Enable();
 
@@ -213,7 +213,7 @@ namespace DxMessaging.Tests.Runtime.Core.Extensions
                 globalHandler,
                 MessageHandler.MessageBus
             );
-            string? globalReceived = null;
+            string globalReceived = null;
             _ = globalToken.RegisterTargeted(
                 target,
                 (ref StringMessage m) => globalReceived = m.message

package/Tests/Runtime/Core/GenericMessageTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using DxMessaging.Core;
@@ -45,3 +46,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/GlobalAcceptAllTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System;
@@ -188,3 +189,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/InterceptorCancellationTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -168,3 +169,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/LifecycleTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -70,3 +71,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/MessageEmissionDataTests.cs

@@ -0,0 +1,70 @@
+namespace DxMessaging.Tests.Runtime.Core
+{
+    using System;
+    using System.Linq;
+    using DxMessaging.Core;
+    using DxMessaging.Core.Diagnostics;
+    using DxMessaging.Core.Messages;
+    using NUnit.Framework;
+
+    public sealed class MessageEmissionDataTests
+    {
+        [Test]
+        public void StackTraceOmitsDxMessagingFrames()
+        {
+            MessageEmissionData data = CaptureMessageEmission();
+
+            Assert.IsFalse(
+                string.IsNullOrWhiteSpace(data.stackTrace),
+                "Stack trace should capture emission site."
+            );
+
+            string[] lines = data.stackTrace.Split(
+                new[] { "\r\n", "\n" },
+                StringSplitOptions.RemoveEmptyEntries
+            );
+
+            bool containsInternalFrame = lines.Any(line =>
+                line.Contains("DxMessaging.Core.", StringComparison.Ordinal)
+                || line.Contains("DxMessaging.Unity.", StringComparison.Ordinal)
+            );
+            if (containsInternalFrame)
+            {
+                Assert.Fail(
+                    $"Stack trace should omit DxMessaging internal frames.{Environment.NewLine}{data.stackTrace}"
+                );
+            }
+
+            bool containsTestMethod = lines.Any(line =>
+                line.Contains(nameof(StackTraceOmitsDxMessagingFrames), StringComparison.Ordinal)
+            );
+            if (!containsTestMethod)
+            {
+                Assert.Fail(
+                    $"Stack trace should include calling test method for debugging context.{Environment.NewLine}{data.stackTrace}"
+                );
+            }
+        }
+
+        [Test]
+        public void ContextIsCapturedWhenProvided()
+        {
+            InstanceId expectedContext = new(12345);
+            MessageEmissionData data = new(new TestUntargetedMessage(), expectedContext);
+
+            Assert.That(
+                data.context.HasValue,
+                Is.True,
+                "Context should be captured when supplied."
+            );
+            Assert.That(data.context.Value, Is.EqualTo(expectedContext));
+        }
+
+        private static MessageEmissionData CaptureMessageEmission()
+        {
+            return new MessageEmissionData(new TestUntargetedMessage());
+        }
+
+        private readonly struct TestUntargetedMessage : IUntargetedMessage { }
+    }
+}

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

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

package/Tests/Runtime/Core/MessagingComponentLifecycleTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -87,3 +88,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/MessagingTestBase.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System;
@@ -206,3 +207,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/MutationDedupeTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -96,3 +97,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/MutationDestructionTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -432,3 +433,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/MutationDuringEmissionTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -2019,3 +2020,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/MutationGlobalAddTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -97,3 +98,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/MutationInterceptorTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -185,3 +186,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif

package/Tests/Runtime/Core/MutationPostProcessorAcrossHandlersTests.cs

@@ -1,3 +1,4 @@
+#if UNITY_2021_3_OR_NEWER
 namespace DxMessaging.Tests.Runtime.Core
 {
     using System.Collections;
@@ -104,3 +105,5 @@ namespace DxMessaging.Tests.Runtime.Core
         }
     }
 }
+
+#endif