com.wallstop-studios.dxmessaging 2.1.1 → 2.1.2

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests/DxAutoConstructorGeneratorDiagnosticsTests.cs

@@ -0,0 +1,69 @@
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using NUnit.Framework;
+
+namespace WallstopStudios.DxMessaging.SourceGenerators.Tests;
+
+[TestFixture]
+public sealed class DxAutoConstructorGeneratorDiagnosticsTests
+{
+    [Test]
+    public void ReportsNonPartialContainingType()
+    {
+        string source = """
+using DxMessaging.Core.Attributes;
+
+namespace Sample;
+
+public class Container
+{
+    [DxAutoConstructor]
+    public readonly struct NestedMessage
+    {
+        public readonly int value;
+    }
+}
+""";
+
+        GeneratorDriverRunResult result = GeneratorTestUtilities.RunDxAutoConstructor(source);
+        Diagnostic[] diagnostics = result.Results[0].Diagnostics.ToArray();
+
+        Assert.That(
+            diagnostics,
+            Has.Some.Matches<Diagnostic>(d => d.Id == "DXMSG003"),
+            "DXMSG003 should be reported when nested types are not declared inside partial containers."
+        );
+        Assert.That(
+            diagnostics,
+            Has.Some.Matches<Diagnostic>(d => d.Id == "DXMSG004"),
+            "DXMSG004 should suggest adding the partial keyword for the containing type."
+        );
+    }
+
+    [Test]
+    public void ReportsInvalidOptionalDefaultExpression()
+    {
+        string source = """
+using DxMessaging.Core.Attributes;
+
+namespace Sample;
+
+[DxTargetedMessage]
+[DxAutoConstructor]
+public readonly partial struct InvalidOptional
+{
+    [DxOptionalParameter(Expression = "value > 0")]
+    public readonly int value;
+}
+""";
+
+        GeneratorDriverRunResult result = GeneratorTestUtilities.RunDxAutoConstructor(source);
+        Diagnostic[] diagnostics = result.Results[0].Diagnostics.ToArray();
+
+        Assert.That(
+            diagnostics,
+            Has.Some.Matches<Diagnostic>(d => d.Id == "DXMSG005"),
+            "DXMSG005 should be reported for optional defaults that cannot be parsed."
+        );
+    }
+}

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests/DxAutoConstructorGeneratorDiagnosticsTests.cs.meta

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

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests/DxMessageIdGeneratorDiagnosticsTests.cs

@@ -0,0 +1,66 @@
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using NUnit.Framework;
+
+namespace WallstopStudios.DxMessaging.SourceGenerators.Tests;
+
+[TestFixture]
+public sealed class DxMessageIdGeneratorDiagnosticsTests
+{
+    [Test]
+    public void ReportsMultipleMessageAttributes()
+    {
+        string source = """
+using DxMessaging.Core.Attributes;
+using DxMessaging.Core.Messages;
+
+namespace Sample;
+
+[DxUntargetedMessage]
+public readonly partial struct ConflictingMessage : IUntargetedMessage { }
+
+[DxBroadcastMessage]
+public readonly partial struct ConflictingMessage : IBroadcastMessage { }
+""";
+
+        GeneratorDriverRunResult result = GeneratorTestUtilities.RunDxMessageId(source);
+        Diagnostic[] diagnostics = result.Results[0].Diagnostics.ToArray();
+
+        Assert.That(
+            diagnostics,
+            Has.Some.Matches<Diagnostic>(d => d.Id == "DXMSG002"),
+            "DXMSG002 should be reported when a message type has multiple Dx message attributes."
+        );
+    }
+
+    [Test]
+    public void ReportsNonPartialContainerForMessageIds()
+    {
+        string source = """
+using DxMessaging.Core.Attributes;
+using DxMessaging.Core.Messages;
+
+namespace Sample;
+
+public class Container
+{
+    [DxTargetedMessage]
+    public readonly struct NestedMessage : ITargetedMessage { }
+}
+""";
+
+        GeneratorDriverRunResult result = GeneratorTestUtilities.RunDxMessageId(source);
+        Diagnostic[] diagnostics = result.Results[0].Diagnostics.ToArray();
+
+        Assert.That(
+            diagnostics,
+            Has.Some.Matches<Diagnostic>(d => d.Id == "DXMSG003"),
+            "DXMSG003 should be reported when a nested message type lives inside a non-partial container."
+        );
+        Assert.That(
+            diagnostics,
+            Has.Some.Matches<Diagnostic>(d => d.Id == "DXMSG004"),
+            "DXMSG004 should suggest adding the partial keyword for the containing type."
+        );
+    }
+}

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests/DxMessageIdGeneratorDiagnosticsTests.cs.meta

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

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests/GeneratorTestUtilities.cs

@@ -0,0 +1,155 @@
+using System.Collections.Immutable;
+using System.Reflection;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using WallstopStudios.DxMessaging.SourceGenerators;
+
+namespace WallstopStudios.DxMessaging.SourceGenerators.Tests;
+
+internal static class GeneratorTestUtilities
+{
+    private static readonly CSharpParseOptions ParseOptions = new(
+        languageVersion: LanguageVersion.Latest,
+        documentationMode: DocumentationMode.Diagnose
+    );
+
+    private static readonly ImmutableArray<MetadataReference> CoreReferences =
+        BuildCoreReferences();
+
+    internal static GeneratorDriverRunResult RunDxAutoConstructor(string userSource)
+    {
+        SyntaxTree attributeTree = CSharpSyntaxTree.ParseText(SharedStubs, ParseOptions);
+        SyntaxTree userTree = CSharpSyntaxTree.ParseText(userSource, ParseOptions);
+
+        CSharpCompilation compilation = CSharpCompilation.Create(
+            assemblyName: "GeneratorTests",
+            syntaxTrees: new[] { attributeTree, userTree },
+            references: CoreReferences,
+            options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+        );
+
+        DxAutoConstructorGenerator generator = new();
+        GeneratorDriver driver = CSharpGeneratorDriver.Create(generator);
+        driver = driver.RunGenerators(compilation);
+
+        return driver.GetRunResult();
+    }
+
+    internal static GeneratorDriverRunResult RunDxMessageId(string userSource)
+    {
+        SyntaxTree stubs = CSharpSyntaxTree.ParseText(SharedStubs, ParseOptions);
+        SyntaxTree userTree = CSharpSyntaxTree.ParseText(userSource, ParseOptions);
+
+        CSharpCompilation compilation = CSharpCompilation.Create(
+            assemblyName: "GeneratorTests",
+            syntaxTrees: new[] { stubs, userTree },
+            references: CoreReferences,
+            options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+        );
+
+        DxMessageIdGenerator generator = new();
+        GeneratorDriver driver = CSharpGeneratorDriver.Create(generator);
+        driver = driver.RunGenerators(compilation);
+
+        return driver.GetRunResult();
+    }
+
+    internal static ImmutableArray<Diagnostic> CompileSnippet(string userSource)
+    {
+        SyntaxTree stubs = CSharpSyntaxTree.ParseText(SharedStubs, ParseOptions);
+        SyntaxTree userTree = CSharpSyntaxTree.ParseText(
+            userSource,
+            ParseOptions.WithKind(SourceCodeKind.Script)
+        );
+
+        CSharpCompilation compilation = CSharpCompilation.Create(
+            assemblyName: "SnippetCompilation",
+            syntaxTrees: new[] { stubs, userTree },
+            references: CoreReferences,
+            options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+        );
+
+        return compilation.GetDiagnostics();
+    }
+
+    internal static ImmutableArray<Diagnostic> ParseSnippet(string userSource)
+    {
+        SyntaxTree userTree = CSharpSyntaxTree.ParseText(userSource, ParseOptions);
+        return userTree.GetDiagnostics().ToImmutableArray();
+    }
+
+    private static ImmutableArray<MetadataReference> BuildCoreReferences()
+    {
+        List<MetadataReference> references = new();
+
+        void AddAssembly(Assembly assembly)
+        {
+            string location = assembly.Location;
+            if (!string.IsNullOrEmpty(location))
+            {
+                references.Add(MetadataReference.CreateFromFile(location));
+            }
+        }
+
+        AddAssembly(typeof(object).Assembly);
+        AddAssembly(typeof(Attribute).Assembly);
+        AddAssembly(typeof(Enumerable).Assembly);
+        AddAssembly(typeof(List<>).Assembly);
+
+        return references.ToImmutableArray();
+    }
+
+    private const string SharedStubs = """
+namespace DxMessaging.Core.Attributes
+{
+    using System;
+
+    [AttributeUsage(AttributeTargets.Struct | AttributeTargets.Class)]
+    public sealed class DxAutoConstructorAttribute : Attribute { }
+
+    [AttributeUsage(AttributeTargets.Field)]
+    public sealed class DxOptionalParameterAttribute : Attribute
+    {
+        public DxOptionalParameterAttribute() { }
+
+        public DxOptionalParameterAttribute(object _) { }
+
+        public string Expression { get; set; }
+    }
+
+    [AttributeUsage(AttributeTargets.Struct)]
+    public sealed class DxTargetedMessageAttribute : Attribute { }
+
+    [AttributeUsage(AttributeTargets.Struct)]
+    public sealed class DxUntargetedMessageAttribute : Attribute { }
+
+    [AttributeUsage(AttributeTargets.Struct)]
+    public sealed class DxBroadcastMessageAttribute : Attribute { }
+}
+
+namespace DxMessaging.Core
+{
+    using System;
+
+    public interface IMessage
+    {
+        Type MessageType => GetType();
+    }
+}
+
+namespace DxMessaging.Core.Messages
+{
+    public interface IUntargetedMessage { }
+    public interface ITargetedMessage { }
+    public interface IBroadcastMessage { }
+}
+
+namespace UnityEngine
+{
+    public struct Color
+    {
+        public static readonly Color green = default;
+    }
+}
+""";
+}

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests/GeneratorTestUtilities.cs.meta

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

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests/WallstopStudios.DxMessaging.SourceGenerators.Tests.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+    <PackageReference Include="NUnit" Version="4.4.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="5.2.0" />
+    <PackageReference Include="coverlet.collector" Version="6.0.4">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\WallstopStudios.DxMessaging.SourceGenerators\WallstopStudios.DxMessaging.SourceGenerators.csproj" />
+  </ItemGroup>
+</Project>

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests/WallstopStudios.DxMessaging.SourceGenerators.Tests.csproj.meta

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

package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.Tests.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 89c62acfc9f82784e900a467ff4d3be1
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests/Editor/MessagingComponentEditorHarnessTests.cs

@@ -0,0 +1,243 @@
+#if UNITY_EDITOR && UNITY_2021_3_OR_NEWER
+namespace DxMessaging.Tests.Editor
+{
+    using System.Collections.Generic;
+    using Core;
+    using Core.MessageBus;
+    using Core.Messages;
+    using DxMessaging.Editor.Testing;
+    using DxMessaging.Unity;
+    using NUnit.Framework;
+    using UnityEditor;
+    using UnityEngine;
+    using Object = UnityEngine.Object;
+
+    [TestFixture]
+    public sealed class MessagingComponentEditorHarnessTests
+    {
+        private readonly List<Object> _createdObjects = new();
+
+        [TearDown]
+        public void TearDown()
+        {
+            foreach (Object instance in _createdObjects)
+            {
+                if (instance != null)
+                {
+                    Object.DestroyImmediate(instance);
+                }
+            }
+            _createdObjects.Clear();
+
+            if (MessageHandler.MessageBus is MessageBus messageBus)
+            {
+                messageBus.DiagnosticsMode = false;
+                messageBus._emissionBuffer.Clear();
+            }
+        }
+
+        [Test]
+        public void CaptureReflectsListenerDiagnostics()
+        {
+            GameObject host = CreateTrackedObject("HarnessHost");
+            MessagingComponent messagingComponent = host.AddComponent<MessagingComponent>();
+            TestListener listener = host.AddComponent<TestListener>();
+
+            MessageRegistrationToken token = messagingComponent.Create(listener);
+            token.DiagnosticMode = true;
+            token.RegisterUntargeted<TestHarnessMessage>(listener.OnMessage);
+            token.Enable();
+
+            MessageBus messageBus = MessageHandler.MessageBus as MessageBus;
+            Assert.That(
+                messageBus,
+                Is.Not.Null,
+                "Default message bus should be the DxMessaging MessageBus implementation."
+            );
+            messageBus.DiagnosticsMode = true;
+            messageBus._emissionBuffer.Clear();
+
+            try
+            {
+                TestHarnessMessage message = default;
+                MessageHandler.MessageBus.UntargetedBroadcast(ref message);
+
+                MessagingComponentInspectorState state = MessagingComponentEditorHarness.Capture(
+                    messagingComponent
+                );
+
+                Assert.That(state.GlobalDiagnosticsEnabled, Is.True);
+                Assert.That(
+                    state.GlobalEmissionHistory.Count,
+                    Is.GreaterThan(0),
+                    "Global emission buffer should contain recorded messages."
+                );
+                Assert.That(state.Listeners.Count, Is.EqualTo(1));
+
+                ListenerDiagnosticsView listenerView = state.Listeners[0];
+                Assert.That(listenerView.Listener, Is.EqualTo(listener));
+                Assert.That(listenerView.DiagnosticsEnabled, Is.True);
+                Assert.That(listenerView.TokenEnabled, Is.True);
+                Assert.That(listenerView.Registrations.Count, Is.EqualTo(1));
+                Assert.That(listenerView.Registrations[0].CallCount, Is.EqualTo(1));
+                Assert.That(listenerView.EmissionHistory.Count, Is.GreaterThan(0));
+            }
+            finally
+            {
+                token.Disable();
+                messageBus.DiagnosticsMode = false;
+            }
+        }
+
+        [Test]
+        public void AutoConfigureWithoutSerializedProviderEmitsWarning()
+        {
+            GameObject host = CreateTrackedObject("ProviderWarningHost");
+            MessagingComponent messagingComponent = host.AddComponent<MessagingComponent>();
+
+            SerializedObject serializedObject = new(messagingComponent);
+            SerializedProperty autoConfigureProperty = serializedObject.FindProperty(
+                "autoConfigureSerializedProviderOnAwake"
+            );
+            Assert.That(autoConfigureProperty, Is.Not.Null);
+            autoConfigureProperty.boolValue = true;
+            serializedObject.ApplyModifiedPropertiesWithoutUndo();
+
+            MessagingComponentInspectorState state = MessagingComponentEditorHarness.Capture(
+                messagingComponent
+            );
+
+            Assert.That(
+                state.ProviderDiagnostics.SerializedProviderMissingWarning,
+                Is.True,
+                "Inspector should warn when auto-configure is enabled without a serialized provider."
+            );
+        }
+
+        [Test]
+        public void AssignedSerializedProviderClearsWarning()
+        {
+            MessageBus messageBus = new();
+            TestScriptableMessageBusProvider provider = CreateTrackedObject(
+                ScriptableObject.CreateInstance<TestScriptableMessageBusProvider>()
+            );
+            provider.Configure(messageBus);
+
+            GameObject host = CreateTrackedObject("ProviderAssignedHost");
+            MessagingComponent messagingComponent = host.AddComponent<MessagingComponent>();
+            messagingComponent.Configure(
+                new MessageBusProviderHandle(provider),
+                MessageBusRebindMode.RebindActive
+            );
+
+            SerializedObject serializedObject = new(messagingComponent);
+            SerializedProperty autoConfigureProperty = serializedObject.FindProperty(
+                "autoConfigureSerializedProviderOnAwake"
+            );
+            Assert.That(autoConfigureProperty, Is.Not.Null);
+            autoConfigureProperty.boolValue = true;
+            serializedObject.ApplyModifiedPropertiesWithoutUndo();
+
+            MessagingComponentInspectorState state = MessagingComponentEditorHarness.Capture(
+                messagingComponent
+            );
+
+            Assert.That(
+                state.ProviderDiagnostics.SerializedProviderMissingWarning,
+                Is.False,
+                "Inspector warning should clear when a serialized provider is assigned."
+            );
+            Assert.That(
+                state.ProviderDiagnostics.SerializedProviderNullBusWarning,
+                Is.False,
+                "Provider should resolve a message bus without triggering the null-bus warning."
+            );
+        }
+
+        [Test]
+        public void NullResolvingSerializedProviderEmitsWarning()
+        {
+            GameObject host = CreateTrackedObject("NullProviderHost");
+            MessagingComponent messagingComponent = host.AddComponent<MessagingComponent>();
+
+            NullBusProvider provider = CreateTrackedObject(
+                ScriptableObject.CreateInstance<NullBusProvider>()
+            );
+            messagingComponent.Configure(
+                new MessageBusProviderHandle(provider),
+                MessageBusRebindMode.RebindActive
+            );
+
+            SerializedObject serializedObject = new(messagingComponent);
+            SerializedProperty autoConfigureProperty = serializedObject.FindProperty(
+                "autoConfigureSerializedProviderOnAwake"
+            );
+            Assert.That(autoConfigureProperty, Is.Not.Null);
+            autoConfigureProperty.boolValue = true;
+            serializedObject.ApplyModifiedPropertiesWithoutUndo();
+
+            MessagingComponentInspectorState state = MessagingComponentEditorHarness.Capture(
+                messagingComponent
+            );
+
+            Assert.That(
+                state.ProviderDiagnostics.SerializedProviderMissingWarning,
+                Is.False,
+                "Warning should not claim the provider asset is missing when assigned."
+            );
+            Assert.That(
+                state.ProviderDiagnostics.SerializedProviderNullBusWarning,
+                Is.True,
+                "Inspector should warn when the serialized provider does not resolve a message bus."
+            );
+        }
+
+        private GameObject CreateTrackedObject(string name)
+        {
+            GameObject gameObject = new(name);
+            _createdObjects.Add(gameObject);
+            return gameObject;
+        }
+
+        private T CreateTrackedObject<T>(T unityObject)
+            where T : Object
+        {
+            if (unityObject != null)
+            {
+                _createdObjects.Add(unityObject);
+            }
+            return unityObject;
+        }
+
+        private sealed class TestListener : MonoBehaviour
+        {
+            public void OnMessage(ref TestHarnessMessage message) { }
+        }
+
+        private readonly struct TestHarnessMessage : IUntargetedMessage { }
+
+        private sealed class TestScriptableMessageBusProvider : ScriptableMessageBusProvider
+        {
+            private IMessageBus _bus;
+
+            public void Configure(IMessageBus bus)
+            {
+                _bus = bus;
+            }
+
+            public override IMessageBus Resolve()
+            {
+                return _bus;
+            }
+        }
+
+        private sealed class NullBusProvider : ScriptableMessageBusProvider
+        {
+            public override IMessageBus Resolve()
+            {
+                return null;
+            }
+        }
+    }
+}
+#endif

package/Tests/Editor/MessagingComponentEditorHarnessTests.cs.meta

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