test(redis): split keyspace scenarios

Author: rian-be

Tests/ModularityKit.Mutator.Governance.Redis.Tests/Keys/RedisMutationRequestKeyspaceEnumerationTests.cs

@@ -0,0 +1,39 @@
+using ModularityKit.Mutator.Governance.Abstractions.Lifecycle.Model;
+using ModularityKit.Mutator.Governance.Abstractions.Requests.Model;
+using ModularityKit.Mutator.Governance.Redis.Tests.TestSupport.Keys;
+using Xunit;
+
+namespace ModularityKit.Mutator.Governance.Redis.Tests.Keys;
+
+public sealed partial class RedisMutationRequestKeyspaceTests
+{
+    [Fact]
+    public void Enumerate_indexes_includes_pending_indexes_only_for_pending_requests()
+    {
+        var keyspace = RedisMutationRequestKeyspaceTestSupport.CreateKeyspace();
+
+        var request = new MutationRequest
+        {
+            RequestId = "req-42",
+            Scope = new MutationRequestScopeDetails
+            {
+                StateId = "tenant-42",
+                StateType = "IamRoleState",
+                MutationType = "GrantRoleMutation"
+            },
+            Lifecycle = new MutationRequestLifecycleDetails
+            {
+                Status = MutationRequestStatus.Pending,
+                PendingReason = PendingMutationReason.Approval
+            }
+        };
+
+        var keys = keyspace.EnumerateIndexes(request).Select(key => key.ToString()).ToArray();
+
+        Assert.Contains("mk:gov:requests:ids", keys);
+        Assert.Contains("mk:gov:states:tenant-42:requests", keys);
+        Assert.Contains("mk:gov:status:pending:requests", keys);
+        Assert.Contains("mk:gov:pending:requests", keys);
+        Assert.Contains("mk:gov:pending:approval:requests", keys);
+    }
+}

Tests/ModularityKit.Mutator.Governance.Redis.Tests/Keys/RedisMutationRequestKeyspaceIndexKeysTests.cs

@@ -0,0 +1,22 @@
+using ModularityKit.Mutator.Governance.Abstractions.Lifecycle.Model;
+using ModularityKit.Mutator.Governance.Abstractions.Requests.Model;
+using ModularityKit.Mutator.Governance.Redis.Tests.TestSupport.Keys;
+using Xunit;
+
+namespace ModularityKit.Mutator.Governance.Redis.Tests.Keys;
+
+public sealed partial class RedisMutationRequestKeyspaceTests
+{
+    [Fact]
+    public void Builds_expected_index_keys_for_state_status_and_pending_reason()
+    {
+        var keyspace = RedisMutationRequestKeyspaceTestSupport.CreateKeyspace();
+
+        Assert.Equal("mk:gov:states:tenant-42:requests", keyspace.RequestsByStateId("tenant-42").ToString());
+        Assert.Equal("mk:gov:status:pending:requests", keyspace.RequestsByStatus(MutationRequestStatus.Pending).ToString());
+        Assert.Equal("mk:gov:pending:requests", keyspace.PendingRequestIds().ToString());
+        Assert.Equal(
+            "mk:gov:pending:approval:requests",
+            keyspace.PendingRequestIds(PendingMutationReason.Approval).ToString());
+    }
+}

Tests/ModularityKit.Mutator.Governance.Redis.Tests/Keys/RedisMutationRequestKeyspaceRequestKeysTests.cs

@@ -0,0 +1,27 @@
+using ModularityKit.Mutator.Governance.Abstractions.Lifecycle.Model;
+using ModularityKit.Mutator.Governance.Abstractions.Requests.Model;
+using ModularityKit.Mutator.Governance.Redis;
+using ModularityKit.Mutator.Governance.Redis.Keys;
+using ModularityKit.Mutator.Governance.Redis.Tests.TestSupport.Keys;
+using Xunit;
+
+namespace ModularityKit.Mutator.Governance.Redis.Tests.Keys;
+
+/// <summary>
+/// Verifies Redis mutation request key construction for provider scenarios.
+/// </summary>
+public sealed partial class RedisMutationRequestKeyspaceTests
+{
+    /// <summary>
+    /// Verifies request data and identity keys derived from the configured prefix.
+    /// </summary>
+    [Fact]
+    public void Builds_expected_request_keys_from_prefix()
+    {
+        var keyspace = RedisMutationRequestKeyspaceTestSupport.CreateKeyspace();
+
+        Assert.Equal("mk:gov:requests:ids", keyspace.RequestIds().ToString());
+        Assert.Equal("mk:gov:requests:req-42:data", keyspace.RequestData("req-42").ToString());
+        Assert.Equal("mk:gov:requests:req-42:revision", keyspace.RequestRevision("req-42").ToString());
+    }
+}

Tests/ModularityKit.Mutator.Governance.Redis.Tests/Keys/RedisMutationRequestKeyspaceTests.cs

@@ -5,6 +5,8 @@
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <IsPackable>false</IsPackable>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <NoWarn>$(NoWarn);1591</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>

Tests/ModularityKit.Mutator.Governance.Redis.Tests/ModularityKit.Mutator.Governance.Redis.Tests.csproj

@@ -1,11 +1,8 @@
-using ModularityKit.Mutator.Abstractions.Context;
-using ModularityKit.Mutator.Abstractions.Effects;
 using ModularityKit.Mutator.Abstractions.Intent;
-using ModularityKit.Mutator.Abstractions.Policies;
-using ModularityKit.Mutator.Governance.Abstractions.Lifecycle.Model;
-using ModularityKit.Mutator.Governance.Abstractions.Requests.Factory;
 using ModularityKit.Mutator.Governance.Abstractions.Requests.Model;
 using ModularityKit.Mutator.Governance.Redis.Serialization;
+using ModularityKit.Mutator.Governance.Redis.Tests.TestSupport.Serialization;
+using ModularityKit.Mutator.Governance.Redis.Tests.TestSupport.Serialization.Models;
 using Xunit;
 
 namespace ModularityKit.Mutator.Governance.Redis.Tests.Serialization;
@@ -15,71 +12,7 @@ public sealed class RedisMutationRequestSerializerTests
     [Fact]
     public void Roundtrip_preserves_request_shape_needed_by_governance_runtime()
     {
-        var request = MutationRequestFactory.PendingApproval(
-            stateId: "tenant-42:roles",
-            stateType: "IamRoleState",
-            mutationType: "GrantRoleMutation",
-            intent: new MutationIntent
-            {
-                OperationName = "GrantRole",
-                Category = "Security",
-                Description = "Grant elevated access",
-                Tags = new HashSet<string> { "security", "urgent" },
-                EstimatedBlastRadius = BlastRadius.Module,
-                Metadata = new Dictionary<string, object>
-                {
-                    ["risk-owner"] = "platform"
-                }
-            },
-            context: MutationContext.User("requester-1", "Requester One", "Need emergency access") with
-            {
-                StateId = "tenant-42:roles",
-                Metadata = new Dictionary<string, object>
-                {
-                    ["source"] = "tests"
-                }
-            },
-            requirements:
-            [
-                new PolicyRequirement
-                {
-                    Type = "Approval",
-                    Description = "Requires security approval",
-                    Data = new Dictionary<string, object>
-                    {
-                        ["Approver"] = "security-lead",
-                        ["Reason"] = "Elevated role",
-                        ["StepOrder"] = 1L,
-                        ["RequiredApprovals"] = 1L
-                    }
-                }
-            ],
-            expectedStateVersion: "v10",
-            metadata: new Dictionary<string, object>
-            {
-                ["team"] = "security",
-                ["priority"] = "high"
-            })
-        with
-        {
-            Lifecycle = new MutationRequestLifecycleDetails
-            {
-                Status = MutationRequestStatus.Pending,
-                PendingReason = PendingMutationReason.Approval,
-                CreatedAt = new DateTimeOffset(2026, 6, 25, 9, 0, 0, TimeSpan.Zero),
-                UpdatedAt = new DateTimeOffset(2026, 6, 25, 9, 5, 0, TimeSpan.Zero)
-            },
-            SideEffects =
-            [
-                SideEffect.Critical(
-                    type: "WorkflowRejected",
-                    description: "Workflow rejection requires action",
-                    data: new RedisGovernanceSideEffectData
-                    {
-                        Ticket = "INC-42"
-                    })
-            ]
-        };
+        var request = RedisMutationRequestSerializerRequestFactory.CreateRoundtripRequest();
 
         var json = RedisMutationRequestSerializer.Serialize(request);
         var roundtrip = RedisMutationRequestSerializer.Deserialize(json);
@@ -104,10 +37,4 @@ public void Roundtrip_preserves_request_shape_needed_by_governance_runtime()
         Assert.Equal(request.Lifecycle.CreatedAt, roundtrip.Lifecycle.CreatedAt);
         Assert.Equal(request.Lifecycle.UpdatedAt, roundtrip.Lifecycle.UpdatedAt);
     }
-
-    [SideEffectDataContract("redis.governance.side-effect", 1)]
-    private sealed record RedisGovernanceSideEffectData
-    {
-        public required string Ticket { get; init; }
-    }
 }

Tests/ModularityKit.Mutator.Governance.Redis.Tests/Serialization/Converters/RedisMutationRequestSerializerTests.cs

@@ -0,0 +1,19 @@
+using ModularityKit.Mutator.Governance.Redis.Configuration;
+using ModularityKit.Mutator.Governance.Redis.Keys;
+
+namespace ModularityKit.Mutator.Governance.Redis.Tests.TestSupport.Keys;
+
+/// <summary>
+/// Creates Redis mutation request keyspace fixtures for key-centric tests.
+/// </summary>
+internal static class RedisMutationRequestKeyspaceTestSupport
+{
+    /// <summary>
+    /// Creates a keyspace with the default provider prefix used by tests.
+    /// </summary>
+    public static RedisMutationRequestKeyspace CreateKeyspace(string keyPrefix = "mk:gov")
+        => new(new RedisMutationRequestStoreOptions
+        {
+            KeyPrefix = keyPrefix
+        });
+}

Tests/ModularityKit.Mutator.Governance.Redis.Tests/TestSupport/Keys/RedisMutationRequestKeyspaceTestSupport.cs

@@ -0,0 +1,15 @@
+using ModularityKit.Mutator.Abstractions.Effects;
+
+namespace ModularityKit.Mutator.Governance.Redis.Tests.TestSupport.Serialization.Models;
+
+/// <summary>
+/// Side-effect payload used by the serializer roundtrip fixture.
+/// </summary>
+[SideEffectDataContract("redis.governance.side-effect", 1)]
+internal sealed record RedisGovernanceSideEffectData
+{
+    /// <summary>
+    /// Gets the external ticket reference carried by the side effect.
+    /// </summary>
+    public required string Ticket { get; init; }
+}

Tests/ModularityKit.Mutator.Governance.Redis.Tests/TestSupport/Serialization/Models/RedisGovernanceSideEffectData.cs

@@ -0,0 +1,88 @@
+using ModularityKit.Mutator.Abstractions.Context;
+using ModularityKit.Mutator.Abstractions.Effects;
+using ModularityKit.Mutator.Abstractions.Intent;
+using ModularityKit.Mutator.Abstractions.Policies;
+using ModularityKit.Mutator.Governance.Abstractions.Lifecycle.Model;
+using ModularityKit.Mutator.Governance.Abstractions.Requests.Factory;
+using ModularityKit.Mutator.Governance.Abstractions.Requests.Model;
+using ModularityKit.Mutator.Governance.Redis.Tests.TestSupport.Serialization.Models;
+
+namespace ModularityKit.Mutator.Governance.Redis.Tests.TestSupport.Serialization;
+
+/// <summary>
+/// Creates the governed request fixture used by serializer tests.
+/// </summary>
+internal static class RedisMutationRequestSerializerRequestFactory
+{
+    /// <summary>
+    /// Creates a request that exercises the Redis serializer roundtrip path.
+    /// </summary>
+    public static MutationRequest CreateRoundtripRequest()
+    {
+        return MutationRequestFactory.PendingApproval(
+            stateId: "tenant-42:roles",
+            stateType: "IamRoleState",
+            mutationType: "GrantRoleMutation",
+            intent: new MutationIntent
+            {
+                OperationName = "GrantRole",
+                Category = "Security",
+                Description = "Grant elevated access",
+                Tags = new HashSet<string> { "security", "urgent" },
+                EstimatedBlastRadius = BlastRadius.Module,
+                Metadata = new Dictionary<string, object>
+                {
+                    ["risk-owner"] = "platform"
+                }
+            },
+            context: MutationContext.User("requester-1", "Requester One", "Need emergency access") with
+            {
+                StateId = "tenant-42:roles",
+                Metadata = new Dictionary<string, object>
+                {
+                    ["source"] = "tests"
+                }
+            },
+            requirements:
+            [
+                new PolicyRequirement
+                {
+                    Type = "Approval",
+                    Description = "Requires security approval",
+                    Data = new Dictionary<string, object>
+                    {
+                        ["Approver"] = "security-lead",
+                        ["Reason"] = "Elevated role",
+                        ["StepOrder"] = 1L,
+                        ["RequiredApprovals"] = 1L
+                    }
+                }
+            ],
+            expectedStateVersion: "v10",
+            metadata: new Dictionary<string, object>
+            {
+                ["team"] = "security",
+                ["priority"] = "high"
+            })
+        with
+        {
+            Lifecycle = new MutationRequestLifecycleDetails
+            {
+                Status = MutationRequestStatus.Pending,
+                PendingReason = PendingMutationReason.Approval,
+                CreatedAt = new DateTimeOffset(2026, 6, 25, 9, 0, 0, TimeSpan.Zero),
+                UpdatedAt = new DateTimeOffset(2026, 6, 25, 9, 5, 0, TimeSpan.Zero)
+            },
+            SideEffects =
+            [
+                SideEffect.Critical(
+                    type: "WorkflowRejected",
+                    description: "Workflow rejection requires action",
+                    data: new RedisGovernanceSideEffectData
+                    {
+                        Ticket = "INC-42"
+                    })
+            ]
+        };
+    }
+}