com.wallstop-studios.dxmessaging 2.1.3 → 2.1.5

package/.llm/skills/testing/test-categories-execution.md

@@ -0,0 +1,142 @@
+---
+title: "Test Category Execution"
+id: "test-categories-execution"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-22"
+updated: "2026-01-22"
+
+source:
+  repository: "wallstop/unity-helpers"
+  files:
+    - path: "Tests/Runtime/"
+  url: "https://github.com/wallstop/unity-helpers"
+
+tags:
+  - "testing"
+  - "organization"
+  - "categories"
+  - "ci"
+
+complexity:
+  level: "basic"
+  reasoning: "Focuses on executing categories in runners and CI"
+
+impact:
+  performance:
+    rating: "none"
+    details: "Execution guidance only"
+  maintainability:
+    rating: "high"
+    details: "Helps keep test suites organized"
+  testability:
+    rating: "high"
+    details: "Ensures correct selection of tests"
+
+prerequisites:
+  - "Understanding of NUnit categories"
+
+dependencies:
+  packages: []
+  skills:
+    - "test-categories"
+
+applies_to:
+  languages:
+    - "C#"
+  frameworks:
+    - "Unity"
+    - ".NET"
+    - "NUnit"
+
+aliases:
+  - "Test category execution"
+
+related:
+  - "test-categories"
+
+status: "stable"
+---
+
+# Test Category Execution
+
+> **One-line summary**: How to run test categories locally, in the Unity Test Runner, and in CI.
+
+## Overview
+
+This skill shows how to execute tests by category in different runners.
+
+## Solution
+
+Use the commands below to run targeted test subsets.
+
+## Usage
+
+### Unity Test Runner
+
+In Unity's Test Runner window:
+
+1. Click the filter dropdown
+1. Select "Category"
+1. Choose categories to include/exclude
+
+### Command Line
+
+```bash
+# Run only fast tests
+Unity -batchmode -runTests -testFilter "cat==Fast"
+
+# Exclude slow tests
+Unity -batchmode -runTests -testFilter "cat!=Slow"
+
+# Run integration tests only
+Unity -batchmode -runTests -testFilter "cat==Integration"
+
+# Combine filters
+Unity -batchmode -runTests -testFilter "cat==Fast && cat!=Flaky"
+```
+
+### CI/CD Pipeline
+
+```yaml
+# .github/workflows/test.yml
+jobs:
+  fast-tests:
+    name: Fast Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Run fast tests
+        run: |
+          Unity -batchmode -nographics -runTests \
+            -testFilter "cat==Fast" \
+            -testResults fast-results.xml
+
+  integration-tests:
+    name: Integration Tests
+    runs-on: ubuntu-latest
+    needs: fast-tests # Only run if fast tests pass
+    steps:
+      - name: Run integration tests
+        run: |
+          Unity -batchmode -nographics -runTests \
+            -testFilter "cat==Integration" \
+            -testResults integration-results.xml
+```
+
+### Local Development Workflow
+
+```csharp
+// Create a menu item for quick fast test runs
+#if UNITY_EDITOR
+public static class TestMenus
+{
+    [MenuItem("Tests/Run Fast Tests")]
+    public static void RunFastTests()
+    {
+        var filter = new Filter { categoryNames = new[] { "Fast" } };
+        var testRunnerApi = ScriptableObject.CreateInstance<TestRunnerApi>();
+        testRunnerApi.Execute(new ExecutionSettings(filter));
+    }
+}
+#endif
+```

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

@@ -0,0 +1,287 @@
+---
+title: "Test Categories for Selective Execution"
+id: "test-categories"
+category: "testing"
+version: "1.0.0"
+created: "2026-01-21"
+updated: "2026-01-21"
+
+source:
+  repository: "wallstop/unity-helpers"
+  files:
+    - path: "Tests/Runtime/SpriteSettingsTests.cs"
+    - path: "Tests/Runtime/ParabolaTests.cs"
+  url: "https://github.com/wallstop/unity-helpers"
+
+tags:
+  - "testing"
+  - "organization"
+  - "categories"
+  - "nunit"
+  - "ci"
+
+complexity:
+  level: "basic"
+  reasoning: "Simple NUnit attribute usage"
+
+impact:
+  performance:
+    rating: "high"
+    details: "Enables fast feedback by running only fast tests locally"
+  maintainability:
+    rating: "high"
+    details: "Clear test organization"
+  testability:
+    rating: "high"
+    details: "Selective test runs improve workflow"
+
+prerequisites:
+  - "Understanding of NUnit attributes"
+
+dependencies:
+  packages: []
+  skills: []
+
+applies_to:
+  languages:
+    - "C#"
+  frameworks:
+    - "Unity"
+    - ".NET"
+  versions:
+    unity: ">=2021.3"
+
+aliases:
+  - "NUnit categories"
+  - "Test filtering"
+  - "Test organization"
+
+related:
+  - "test-base-class-cleanup"
+  - "data-driven-tests"
+  - "test-categories-execution"
+
+status: "stable"
+---
+
+# Test Categories for Selective Execution
+
+> **One-line summary**: Use NUnit `[Category]` attributes to organize tests by speed, type, and purpose, enabling selective test runs for faster development feedback.
+
+## Overview
+
+Not all tests should run all the time:
+
+- **Fast unit tests** (~100ms): Run constantly during development
+- **Slow integration tests** (~5s): Run before commits
+- **Flaky tests**: Quarantine and fix separately
+
+This pattern uses NUnit's `[Category]` attribute to enable selective execution.
+
+## Problem Statement
+
+```csharp
+// BAD: All tests look the same
+[Test]
+public void QuickCalculation() { } // 1ms
+
+[Test]
+public void LoadAssetBundle() { } // 3000ms
+
+[Test]
+public void NetworkCall() { } // Sometimes fails
+
+// Running all tests takes forever
+// Developer skips testing because it's slow
+// Flaky test breaks CI randomly
+```
+
+## Solution
+
+### Core Categories
+
+```csharp
+// Category definitions (can be constants or a static class)
+public static class TestCategories
+{
+    public const string Fast = "Fast";           // <100ms, no I/O
+    public const string Slow = "Slow";           // >100ms or I/O
+    public const string Integration = "Integration"; // External dependencies
+    public const string Flaky = "Flaky";         // Known intermittent failures
+    public const string EditorOnly = "EditorOnly"; // Requires Editor mode
+    public const string PlayMode = "PlayMode";   // Requires Play mode
+}
+```
+
+### Implementation
+
+```csharp
+namespace WallstopStudios.UnityHelpers.Tests
+{
+    using NUnit.Framework;
+
+    // Fast unit tests - pure logic, no Unity APIs
+    [TestFixture]
+    [Category(TestCategories.Fast)]
+    public sealed class MathUtilsTests
+    {
+        [Test]
+        public void ClampReturnsValueInRange()
+        {
+            Assert.AreEqual(5, MathUtils.Clamp(5, 0, 10));
+        }
+
+        [Test]
+        public void ClampReturnsMinWhenBelowRange()
+        {
+            Assert.AreEqual(0, MathUtils.Clamp(-5, 0, 10));
+        }
+    }
+
+    // Slow tests - creates Unity objects
+    [TestFixture]
+    [Category(TestCategories.Slow)]
+    public sealed class TextureProcessingTests : CommonTestBase
+    {
+        [Test]
+        public void ProcessLargeTexture()
+        {
+            Texture2D texture = CreateTexture(2048, 2048);
+            Track(texture);
+
+            processor.Process(texture);
+
+            Assert.IsTrue(processor.IsComplete);
+        }
+    }
+
+    // Integration tests - requires external resources
+    [TestFixture]
+    [Category(TestCategories.Slow)]
+    [Category(TestCategories.Integration)]
+    public sealed class AssetBundleTests : CommonTestBase
+    {
+        [Test]
+        public void LoadBundleFromDisk()
+        {
+            // Requires asset bundle on disk
+            AssetBundle bundle = AssetBundle.LoadFromFile(bundlePath);
+            Track(bundle);
+
+            Assert.IsNotNull(bundle);
+        }
+    }
+
+    // Mixed fixture - some fast, some slow
+    [TestFixture]
+    public sealed class CacheTests
+    {
+        [Test]
+        [Category(TestCategories.Fast)]
+        public void GetReturnsStoredValue()
+        {
+            // Pure logic test
+        }
+
+        [Test]
+        [Category(TestCategories.Slow)]
+        public void CacheEvictsUnderMemoryPressure()
+        {
+            // Allocates lots of memory, takes time
+        }
+    }
+
+    // Flaky tests - quarantine until fixed
+    [TestFixture]
+    [Category(TestCategories.Flaky)]
+    [Explicit("Network timing issues - see issue #123")]
+    public sealed class NetworkTests
+    {
+        [Test]
+        public void ServerRespondsWithinTimeout()
+        {
+            // Sometimes fails due to network latency
+        }
+    }
+}
+```
+
+### Per-Test Category Override
+
+```csharp
+[TestFixture]
+[Category(TestCategories.Fast)] // Default for fixture
+public sealed class StringExtensionTests
+{
+    [Test]
+    public void TrimRemovesWhitespace()
+    {
+        // Fast test
+    }
+
+    [Test]
+    [Category(TestCategories.Slow)] // Override for this test
+    public void FormatLargeString()
+    {
+        // Slow test in otherwise fast fixture
+    }
+}
+```
+
+## Performance Notes
+
+### Recommended Time Budgets
+
+| Category    | Max Time | Description                 |
+| ----------- | -------- | --------------------------- |
+| Fast        | <100ms   | No I/O, no Unity lifecycle  |
+| Slow        | <5s      | Unity objects, moderate I/O |
+| Integration | <30s     | External resources, network |
+
+### Execution Strategy
+
+| Context              | Categories to Run   |
+| -------------------- | ------------------- |
+| On save (IDE plugin) | Fast only           |
+| Pre-commit hook      | Fast                |
+| PR checks            | Fast + Slow         |
+| Nightly build        | All including Flaky |
+
+## Best Practices
+
+### Do
+
+- Mark all tests with at least one category
+- Use `[Explicit]` with reason for quarantined tests
+- Run Fast tests constantly during development
+- Keep Fast tests under 100ms total per file
+- Document why tests are categorized as Slow/Flaky
+
+### Don't
+
+- Don't leave tests uncategorized (defaults vary)
+- Don't mark slow tests as Fast (hurts feedback loop)
+- Don't leave Flaky tests in main categories (breaks CI)
+- Don't use too many categories (hard to manage)
+
+### Category Hygiene
+
+```csharp
+// Good: Clear reason for Slow category
+[Test]
+[Category(TestCategories.Slow)]
+// This test creates 1000 GameObjects
+public void StressTestSpawning() { }
+
+// Good: Explicit with reason for quarantine
+[Test]
+[Category(TestCategories.Flaky)]
+[Explicit("Race condition on first frame - issue #456")]
+public void InitializationOrder() { }
+```
+
+## Related Patterns
+
+- [Test Base Class Cleanup](./test-base-class-cleanup.md) - Test infrastructure
+- [Data-Driven Tests](./data-driven-tests.md) - Parameterized testing
+- [Test Category Execution](./test-categories-execution.md) - Running categories

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 |