com.wallstop-studios.dxmessaging 2.1.4 → 2.1.6

package/.llm/skills/testing/test-coverage-data-driven.md

@@ -0,0 +1,172 @@
+---
+title: "Data-Driven Coverage Patterns"
+id: "test-coverage-data-driven"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-22"
+updated: "2026-01-22"
+
+source:
+  repository: "wallstop/DxMessaging"
+  files:
+    - path: "Tests/Runtime/"
+  url: "https://github.com/wallstop/DxMessaging"
+
+tags:
+  - "testing"
+  - "data-driven"
+  - "nunit"
+  - "coverage"
+
+complexity:
+  level: "intermediate"
+  reasoning: "Requires structuring reusable data sets for tests"
+
+impact:
+  performance:
+    rating: "none"
+    details: "Testing pattern only"
+  maintainability:
+    rating: "high"
+    details: "Reduces duplication while increasing coverage"
+  testability:
+    rating: "high"
+    details: "Encourages broad coverage with fewer tests"
+
+prerequisites:
+  - "Understanding of NUnit TestCase/TestCaseSource"
+
+dependencies:
+  packages: []
+  skills:
+    - "comprehensive-test-coverage"
+    - "data-driven-tests"
+
+applies_to:
+  languages:
+    - "C#"
+  frameworks:
+    - "Unity"
+    - ".NET"
+    - "NUnit"
+
+aliases:
+  - "Parameterized coverage"
+
+related:
+  - "comprehensive-test-coverage"
+  - "data-driven-tests"
+
+status: "stable"
+---
+
+# Data-Driven Coverage Patterns
+
+> **One-line summary**: Use `[TestCase]` and `[TestCaseSource]` to cover many scenarios without duplicating test code.
+
+## Overview
+
+Data-driven tests are the fastest way to expand coverage while keeping test code maintainable.
+
+## Problem Statement
+
+Duplicated tests increase maintenance cost and still miss edge cases. Parameterized tests keep coverage broad and readable.
+
+## Solution
+
+### Using TestCase for Inline Data
+
+```csharp
+[TestFixture]
+public sealed class MessageParsingTests
+{
+    [Test]
+    [TestCase("valid", true)]
+    [TestCase("", false)]
+    [TestCase(null, false)]
+    [TestCase("   ", false)]
+    [TestCase("valid-with-dashes", true)]
+    [TestCase("123numeric", true)]
+    public void IsValidMessageIdReturnsExpectedResult(string messageId, bool expected)
+    {
+        bool result = MessageValidator.IsValidMessageId(messageId);
+
+        Assert.That(
+            result,
+            Is.EqualTo(expected),
+            $"MessageId '{messageId ?? "null"}' should be {(expected ? "valid" : "invalid")}");
+    }
+}
+```
+
+### Using TestCaseSource for Complex Data
+
+```csharp
+[TestFixture]
+public sealed class TargetResolutionTests
+{
+    private static IEnumerable<TestCaseData> GameObjectTargetingTestCases
+    {
+        get
+        {
+            yield return new TestCaseData(new Vector3(0, 0, 0), "Origin", true)
+                .SetName("OriginPositionIsValidTarget");
+            yield return new TestCaseData(new Vector3(float.NaN, 0, 0), "Invalid", false)
+                .SetName("NaNPositionIsInvalidTarget");
+        }
+    }
+
+    [Test]
+    [TestCaseSource(nameof(GameObjectTargetingTestCases))]
+    public void ValidateTargetPositionReturnsExpectedResult(
+        Vector3 position,
+        string objectName,
+        bool expectedValidity)
+    {
+        bool result = TargetValidator.IsValidTargetPosition(position);
+
+        Assert.That(
+            result,
+            Is.EqualTo(expectedValidity),
+            $"Position {position} for '{objectName}' should be {(expectedValidity ? "valid" : "invalid")}");
+    }
+}
+```
+
+### Consolidating Test Logic
+
+```csharp
+[TestFixture]
+public sealed class MessageSerializationTests
+{
+    private static readonly Type[] SupportedMessageTypes =
+    {
+        typeof(SimpleMessage),
+        typeof(ComplexMessage),
+        typeof(NestedMessage),
+        typeof(CollectionMessage)
+    };
+
+    [Test]
+    [TestCaseSource(nameof(SupportedMessageTypes))]
+    public void MessageTypeRoundTripsCorrectly(Type messageType)
+    {
+        object original = Activator.CreateInstance(messageType);
+        string serialized = MessageSerializer.Serialize(original);
+        object deserialized = MessageSerializer.Deserialize(serialized, messageType);
+
+        Assert.That(deserialized, Is.EqualTo(original));
+    }
+}
+```
+
+## See Also
+
+- [Comprehensive Test Coverage](comprehensive-test-coverage.md)
+- [Data-Driven Tests](data-driven-tests.md)
+
+## Changelog
+
+| Version | Date       | Changes         |
+| ------- | ---------- | --------------- |
+| 1.0.0   | 2026-01-22 | Initial version |

package/.llm/skills/testing/test-coverage-organization-assertions.md

@@ -0,0 +1,171 @@
+---
+title: "Test Organization and Assertions"
+id: "test-coverage-organization-assertions"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-22"
+updated: "2026-01-22"
+
+source:
+  repository: "wallstop/DxMessaging"
+  files:
+    - path: "Tests/Runtime/"
+  url: "https://github.com/wallstop/DxMessaging"
+
+tags:
+  - "testing"
+  - "assertions"
+  - "naming"
+  - "organization"
+
+complexity:
+  level: "basic"
+  reasoning: "Establishes consistent structure and assertion clarity"
+
+impact:
+  performance:
+    rating: "none"
+    details: "Testing guidance only"
+  maintainability:
+    rating: "high"
+    details: "Consistent structure improves readability and review"
+  testability:
+    rating: "high"
+    details: "Clear assertions improve diagnostics"
+
+prerequisites:
+  - "Understanding of NUnit"
+
+dependencies:
+  packages: []
+  skills:
+    - "comprehensive-test-coverage"
+
+applies_to:
+  languages:
+    - "C#"
+  frameworks:
+    - "Unity"
+    - ".NET"
+    - "NUnit"
+
+aliases:
+  - "Test naming"
+  - "Assertion best practices"
+
+related:
+  - "comprehensive-test-coverage"
+
+status: "stable"
+---
+
+# Test Organization and Assertions
+
+> **One-line summary**: Use clear naming, structured test classes, and expressive assertions with failure messages.
+
+## Overview
+
+Well-structured tests are easier to review and debug. Names should read like sentences and assertions should explain failures.
+
+## Problem Statement
+
+Poor naming and weak assertions make failures hard to interpret and increase maintenance cost.
+
+## Solution
+
+### Test Class Naming
+
+```csharp
+// Pattern: {ClassUnderTest}Tests or {Feature}Tests
+public sealed class MessageBusTests { }
+public sealed class TargetedMessageDeliveryTests { }
+public sealed class RegistrationLifecycleTests { }
+```
+
+### Test Method Naming
+
+```csharp
+// GOOD: Descriptive, reads naturally
+[Test]
+public void EmitUntargetedMessageInvokesAllRegisteredHandlers() { }
+
+// BAD: Underscores, unclear
+[Test]
+public void Test_Emit_Works() { }
+```
+
+### Test Class Organization
+
+```csharp
+[TestFixture]
+public sealed class MessageBusTests
+{
+    private MessageBus _messageBus;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _messageBus = new MessageBus();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        _messageBus?.Dispose();
+    }
+
+    [Test]
+    public void RegisterHandlerSucceeds() { }
+
+    [Test]
+    public void RegisterNullHandlerThrows() { }
+}
+```
+
+### Expressive Assertions
+
+```csharp
+Assert.That(
+    actualCount,
+    Is.EqualTo(expectedCount),
+    $"Handler should be invoked {expectedCount} times, but was {actualCount}");
+
+Assert.That(result, Is.Not.Null.And.Not.Empty);
+Assert.That(values, Has.Count.EqualTo(5).And.All.GreaterThan(0));
+```
+
+### Assert One Concept Per Test
+
+```csharp
+[Test]
+public void HandlerReceivesCorrectMessagePayload()
+{
+    TestMessage received = default;
+    _messageBus.RegisterUntargetedHandler<TestMessage>(msg => received = msg);
+
+    TestMessage sent = new TestMessage { Value = 42 };
+    sent.EmitUntargeted(_messageBus);
+
+    Assert.That(received.Value, Is.EqualTo(42));
+}
+```
+
+### Use CollectionAssert for Collections
+
+```csharp
+CollectionAssert.AreEquivalent(
+    new[] { typeof(MessageA), typeof(MessageB), typeof(MessageC) },
+    types,
+    "Should return all registered message types");
+```
+
+## See Also
+
+- [Comprehensive Test Coverage](comprehensive-test-coverage.md)
+- [Unity Considerations and Anti-Patterns](test-coverage-unity-anti-patterns.md)
+
+## Changelog
+
+| Version | Date       | Changes         |
+| ------- | ---------- | --------------- |
+| 1.0.0   | 2026-01-22 | Initial version |

package/.llm/skills/testing/test-coverage-scenario-categories.md

@@ -0,0 +1,223 @@
+---
+title: "Test Coverage Scenario Categories"
+id: "test-coverage-scenario-categories"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-22"
+updated: "2026-01-22"
+
+source:
+  repository: "wallstop/DxMessaging"
+  files:
+    - path: "Tests/Runtime/Core/NominalTests.cs"
+  url: "https://github.com/wallstop/DxMessaging"
+
+tags:
+  - "testing"
+  - "coverage"
+  - "edge-cases"
+  - "negative-tests"
+
+complexity:
+  level: "intermediate"
+  reasoning: "Requires designing tests across multiple scenario classes"
+
+impact:
+  performance:
+    rating: "none"
+    details: "Testing pattern only"
+  maintainability:
+    rating: "high"
+    details: "Comprehensive scenarios prevent regressions"
+  testability:
+    rating: "critical"
+    details: "Defines the breadth of coverage expected"
+
+prerequisites:
+  - "Understanding of NUnit testing framework"
+
+dependencies:
+  packages: []
+  skills:
+    - "comprehensive-test-coverage"
+
+applies_to:
+  languages:
+    - "C#"
+  frameworks:
+    - "Unity"
+    - ".NET"
+    - "NUnit"
+
+aliases:
+  - "Scenario coverage"
+
+related:
+  - "comprehensive-test-coverage"
+  - "test-coverage-data-driven"
+
+status: "stable"
+---
+
+# Test Coverage Scenario Categories
+
+> **One-line summary**: Cover normal, negative, edge, unexpected, and "impossible" scenarios for every change.
+
+## Overview
+
+Coverage is incomplete if it only exercises the happy path. Use these scenario categories for every feature or fix.
+
+## Problem Statement
+
+Tests that only cover expected usage miss boundary behavior, error handling, and defensive code paths.
+
+## Solution
+
+### 1. Normal / Happy Path Scenarios
+
+```csharp
+[TestFixture]
+public sealed class MessageBusHappyPathTests
+{
+    [Test]
+    public void RegisterHandlerSucceedsWithValidInput()
+    {
+        MessageBus messageBus = new MessageBus();
+        bool handlerCalled = false;
+
+        MessageRegistrationToken token = messageBus.RegisterUntargetedHandler<TestMessage>(
+            _ => handlerCalled = true);
+
+        Assert.That(token, Is.Not.Null, "Registration should return a valid token");
+        Assert.That(token.IsActive, Is.True, "Token should be active after registration");
+        Assert.That(handlerCalled, Is.False, "Handler should not be called yet");
+    }
+}
+```
+
+### 2. Negative Scenarios (Error Conditions)
+
+```csharp
+[TestFixture]
+public sealed class MessageBusNegativeTests
+{
+    [Test]
+    public void RegisterHandlerThrowsOnNullHandler()
+    {
+        MessageBus messageBus = new MessageBus();
+
+        ArgumentNullException exception = Assert.Throws<ArgumentNullException>(
+            () => messageBus.RegisterUntargetedHandler<TestMessage>(null));
+
+        Assert.That(
+            exception.ParamName,
+            Does.Contain("handler").IgnoreCase,
+            "Exception should identify the null parameter");
+    }
+}
+```
+
+### 3. Edge Cases (Boundary Conditions)
+
+```csharp
+[TestFixture]
+public sealed class MessageBusEdgeCaseTests
+{
+    [Test]
+    public void EmitWithNoHandlersDoesNotThrow()
+    {
+        MessageBus messageBus = new MessageBus();
+        TestMessage message = new TestMessage { Value = 1 };
+
+        Assert.DoesNotThrow(
+            () => message.EmitUntargeted(messageBus),
+            "Emitting with no registered handlers should be safe");
+    }
+
+    [TestCase(0)]
+    [TestCase(int.MaxValue)]
+    [TestCase(int.MinValue)]
+    public void MessageWithExtremeIntValuesHandledCorrectly(int extremeValue)
+    {
+        MessageBus messageBus = new MessageBus();
+        int receivedValue = -999;
+
+        messageBus.RegisterUntargetedHandler<TestMessage>(msg => receivedValue = msg.Value);
+
+        TestMessage message = new TestMessage { Value = extremeValue };
+        message.EmitUntargeted(messageBus);
+
+        Assert.That(receivedValue, Is.EqualTo(extremeValue));
+    }
+}
+```
+
+### 4. Unexpected Situations
+
+```csharp
+[TestFixture]
+public sealed class MessageBusUnexpectedUsageTests
+{
+    [Test]
+    public void DuplicateRegistrationCreatesDistinctTokens()
+    {
+        MessageBus messageBus = new MessageBus();
+        int invokeCount = 0;
+        Action<TestMessage> handler = _ => invokeCount++;
+
+        MessageRegistrationToken token1 = messageBus.RegisterUntargetedHandler(handler);
+        MessageRegistrationToken token2 = messageBus.RegisterUntargetedHandler(handler);
+
+        TestMessage message = new TestMessage();
+        message.EmitUntargeted(messageBus);
+
+        Assert.That(invokeCount, Is.EqualTo(2));
+        Assert.That(token1, Is.Not.SameAs(token2));
+    }
+}
+```
+
+### 5. "The Impossible" Scenarios
+
+```csharp
+[TestFixture]
+public sealed class MessageBusDefensiveTests
+{
+    [Test]
+    public void HandlerThrowingExceptionDoesNotPreventOtherHandlers()
+    {
+        MessageBus messageBus = new MessageBus();
+        bool handler1Called = false;
+        bool handler3Called = false;
+
+        messageBus.RegisterUntargetedHandler<TestMessage>(_ => handler1Called = true);
+        messageBus.RegisterUntargetedHandler<TestMessage>(
+            _ => throw new InvalidOperationException("Simulated failure"));
+        messageBus.RegisterUntargetedHandler<TestMessage>(_ => handler3Called = true);
+
+        TestMessage message = new TestMessage();
+
+        try
+        {
+            message.EmitUntargeted(messageBus);
+        }
+        catch (InvalidOperationException)
+        {
+        }
+
+        Assert.That(handler1Called, Is.True, "Handler before exception should be called");
+        // Behavior of handler3 depends on implementation choice
+    }
+}
+```
+
+## See Also
+
+- [Comprehensive Test Coverage](comprehensive-test-coverage.md)
+- [Data-Driven Coverage Patterns](test-coverage-data-driven.md)
+
+## Changelog
+
+| Version | Date       | Changes         |
+| ------- | ---------- | --------------- |
+| 1.0.0   | 2026-01-22 | Initial version |