Update tests for refactored MutationRequest model

Author: rian-be

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

@@ -49,11 +49,17 @@ public void Enumerate_indexes_includes_pending_indexes_only_for_pending_requests
         var request = new MutationRequest
         {
             RequestId = "req-42",
-            StateId = "tenant-42",
-            StateType = "IamRoleState",
-            MutationType = "GrantRoleMutation",
-            Status = MutationRequestStatus.Pending,
-            PendingReason = PendingMutationReason.Approval
+            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();

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

@@ -4,6 +4,7 @@
 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 Xunit;
 
@@ -61,8 +62,13 @@ public void Roundtrip_preserves_request_shape_needed_by_governance_runtime()
             })
         with
         {
-            CreatedAt = new DateTimeOffset(2026, 6, 25, 9, 0, 0, TimeSpan.Zero),
-            UpdatedAt = new DateTimeOffset(2026, 6, 25, 9, 5, 0, TimeSpan.Zero),
+            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(
@@ -95,6 +101,8 @@ public void Roundtrip_preserves_request_shape_needed_by_governance_runtime()
         Assert.Single(roundtrip.ApprovalRequirements);
         Assert.Equal("security-lead", roundtrip.ApprovalRequirements[0].ApproverId);
         Assert.Equal(3, roundtrip.Decisions.Count);
+        Assert.Equal(request.Lifecycle.CreatedAt, roundtrip.Lifecycle.CreatedAt);
+        Assert.Equal(request.Lifecycle.UpdatedAt, roundtrip.Lifecycle.UpdatedAt);
     }
 
     [SideEffectDataContract("redis.governance.side-effect", 1)]

Tests/ModularityKit.Mutator.Governance.Tests/Execution/GovernanceExecutionManagerTests.cs

@@ -10,6 +10,8 @@
 using ModularityKit.Mutator.Abstractions.Results;
 using ModularityKit.Mutator.Governance.Abstractions.Execution.Contracts;
 using ModularityKit.Mutator.Governance.Abstractions.Execution.Model;
+using ModularityKit.Mutator.Governance.Abstractions.Execution.Model.Compensation;
+using ModularityKit.Mutator.Governance.Abstractions.Execution.Model.Links;
 using ModularityKit.Mutator.Governance.Abstractions.Lifecycle.Model;
 using ModularityKit.Mutator.Governance.Abstractions.Requests.Factory;
 using ModularityKit.Mutator.Governance.Abstractions.Requests.Decisions;
@@ -75,9 +77,9 @@ public async Task ExecuteApproved_executes_request_persists_resulting_version_an
         Assert.NotNull(result.MutationResult);
         Assert.Equal("v11", result.ResultingStateVersion);
         Assert.Equal(MutationRequestStatus.Executed, result.Request.Status);
-        Assert.Equal("v11", result.Request.ResultingStateVersion);
-        Assert.Equal("v11", result.Request.ExpectedStateVersion);
-        Assert.NotNull(result.Request.ExecutedAt);
+        Assert.Equal("v11", result.Request.Versioning.ResultingStateVersion);
+        Assert.Equal("v11", result.Request.Versioning.ExpectedStateVersion);
+        Assert.NotNull(result.Request.Versioning.ExecutedAt);
         Assert.Single(result.Request.SideEffects);
         Assert.Equal("RoleElevated", result.Request.SideEffects[0].Type);
         Assert.Equal("governance.execution-effect", result.Request.SideEffects[0].DataContractType);
@@ -180,7 +182,7 @@ public async Task ExecuteApproved_requires_renewed_approval_before_execution_whe
         Assert.Null(result.MutationResult);
         Assert.Equal(MutationRequestStatus.Pending, result.Request.Status);
         Assert.Equal(PendingMutationReason.Approval, result.Request.PendingReason);
-        Assert.Equal("v15", result.Request.ExpectedStateVersion);
+        Assert.Equal("v15", result.Request.Versioning.ExpectedStateVersion);
         Assert.Equal(MutationRequestVersionResolutionOutcome.RequiresRenewedApproval, result.Resolution.Outcome);
     }
 
@@ -223,8 +225,8 @@ public async Task ExecuteApproved_revalidates_and_executes_against_latest_state_
         Assert.Equal(MutationRequestVersionResolutionOutcome.RevalidateOnLatestState, result.Resolution.Outcome);
         Assert.Equal(MutationRequestStatus.Executed, result.Request.Status);
         Assert.Equal("v16", result.ResultingStateVersion);
-        Assert.Equal("v16", result.Request.ResultingStateVersion);
-        Assert.Equal("v16", result.Request.ExpectedStateVersion);
+        Assert.Equal("v16", result.Request.Versioning.ResultingStateVersion);
+        Assert.Equal("v16", result.Request.Versioning.ExpectedStateVersion);
         Assert.Equal(
             MutationRequestDecisionType.Lifecycle(MutationRequestLifecycleDecisionType.Executed),
             result.Request.Decisions[^1].Type);
@@ -233,6 +235,110 @@ public async Task ExecuteApproved_revalidates_and_executes_against_latest_state_
             decision => decision.Type == MutationRequestDecisionType.VersionResolution(MutationRequestVersionResolutionDecisionType.RevalidationRequired));
     }
 
+    [Fact]
+    public async Task ExecuteApproved_executes_operator_rollback_compensation_and_links_execution_history()
+    {
+        var services = new ServiceCollection();
+        services.AddMutators(MutationEngineOptions.Strict);
+        await using var provider = services.BuildServiceProvider();
+
+        var engine = provider.GetRequiredService<IMutationEngine>();
+        var auditor = provider.GetRequiredService<IMutationAuditor>();
+        var historyStore = provider.GetRequiredService<IMutationHistoryStore>();
+        var requestStore = new InMemoryMutationRequestStore();
+        var resolutionManager = new MutationRequestVersionResolutionManager(requestStore, new MutationRequestVersionResolver());
+        var executionManager = new GovernanceExecutionManager(requestStore, resolutionManager, engine);
+
+        var originalRequest = await requestStore.Create(MutationRequestFactory.Approved<RoleState, PromoteRoleMutation>(
+            stateId: "tenant-42:roles",
+            intent: new MutationIntent
+            {
+                OperationName = "GrantRole",
+                Category = "Security",
+                Description = "Grant elevated access",
+                IsReversible = true
+            },
+            context: MutationContext.User("requester", "Requester", "Need access"),
+            expectedStateVersion: "v10"));
+
+        var originalState = RoleState.Create("tenant-42:roles", role: "Reader", version: "v10");
+        var originalMutation = new PromoteRoleMutation(
+            MutationContext.User("operator-1", "Operator One", "Execute approved role promotion"),
+            nextVersion: "v11");
+
+        var originalResult = await executionManager.ExecuteApproved(
+            originalRequest.RequestId,
+            originalMutation,
+            originalState,
+            governanceContext: MutationContext.Service("governance-runtime", "Execute approved request"),
+            strategy: VersionedRequestResolutionStrategy.RejectStale);
+
+        var compensationPlan = new GovernedCompensationPlan
+        {
+            OriginalRequestId = originalRequest.RequestId,
+            Kind = GovernedCompensationKind.Rollback,
+            Trigger = GovernedCompensationTrigger.OperatorRollback,
+            Reason = "Operator reverted the elevated role after incident review."
+        };
+
+        var compensationRequest = await requestStore.Create(CompensationMutationRequestFactory.Approved<RoleState, RollbackRoleMutation>(
+            stateId: "tenant-42:roles",
+            intent: new MutationIntent
+            {
+                OperationName = "RollbackRole",
+                Category = "Security",
+                Description = "Restore the previous tenant role"
+            },
+            context: MutationContext.User("operator-2", "Operator Two", "Rollback approved role mutation"),
+            compensation: compensationPlan,
+            expectedStateVersion: "v11"));
+
+        var compensationMutation = new RollbackRoleMutation(
+            MutationContext.User("operator-2", "Operator Two", "Rollback approved role mutation"),
+            nextVersion: "v12");
+
+        var compensationResult = await executionManager.ExecuteApproved(
+            compensationRequest.RequestId,
+            compensationMutation,
+            originalResult.MutationResult!.NewState!,
+            governanceContext: MutationContext.Service("governance-runtime", "Execute operator rollback"),
+            strategy: VersionedRequestResolutionStrategy.RejectStale);
+
+        Assert.True(compensationResult.WasExecuted);
+        Assert.Equal(GovernedExecutionKind.Compensation, compensationResult.ExecutionKind);
+        Assert.NotNull(compensationResult.Compensation);
+        Assert.Equal(originalRequest.RequestId, compensationResult.Compensation!.OriginalRequestId);
+        Assert.Equal(GovernedCompensationKind.Rollback, compensationResult.Compensation.Kind);
+        Assert.Contains(
+            compensationResult.Request.Execution.RelatedExecutions,
+            link => link.RequestId == originalRequest.RequestId &&
+                    link.Type == GovernedExecutionLinkType.Compensates);
+
+        var compensatedOriginalRequest = await requestStore.Get(originalRequest.RequestId);
+        Assert.NotNull(compensatedOriginalRequest);
+        Assert.Contains(
+            compensatedOriginalRequest!.Execution.RelatedExecutions,
+            link => link.RequestId == compensationRequest.RequestId &&
+                    link.Type == GovernedExecutionLinkType.CompensatedBy &&
+                    link.ExecutionKind == GovernedExecutionKind.Compensation);
+        Assert.Contains(
+            compensatedOriginalRequest.Decisions,
+            decision => decision.Type == MutationRequestDecisionType.Lifecycle(MutationRequestLifecycleDecisionType.Compensated));
+
+        var auditEntries = await auditor.GetAuditLogAsync(originalRequest.StateId);
+        var history = await historyStore.GetHistoryAsync(originalRequest.StateId);
+
+        Assert.Equal(2, auditEntries.Count);
+        Assert.Equal(2, history.Entries.Count);
+        Assert.Equal("Compensation", auditEntries[1].Context.Metadata["GovernanceExecutionKind"]);
+        Assert.Equal("Compensation", history.Entries[1].Context.Metadata["GovernanceExecutionKind"]);
+
+        var auditCompensation = Assert.IsAssignableFrom<IReadOnlyDictionary<string, object>>(
+            auditEntries[1].Context.Metadata["GovernanceCompensation"]);
+        Assert.Equal(originalRequest.RequestId, auditCompensation["OriginalRequestId"]);
+        Assert.Equal("Rollback", auditCompensation["Kind"]);
+    }
+
     private sealed record RoleState(string StateId, string Role, string Version) : IVersionedState
     {
         public static RoleState Create(string stateId, string role, string version) => new(stateId, role, version);
@@ -282,6 +388,51 @@ public ValidationResult Validate(RoleState state)
         public MutationResult<RoleState> Simulate(RoleState state) => Apply(state);
     }
 
+    private sealed class RollbackRoleMutation(MutationContext context, string nextVersion) : IMutation<RoleState>
+    {
+        public MutationIntent Intent { get; } = new()
+        {
+            OperationName = "RollbackRole",
+            Category = "Security",
+            Description = "Rollback tenant role to Reader",
+            IsReversible = false
+        };
+
+        public MutationContext Context { get; } = context;
+
+        public MutationResult<RoleState> Apply(RoleState state)
+        {
+            var newState = state with
+            {
+                Role = "Reader",
+                Version = nextVersion
+            };
+
+            return MutationResult<RoleState>.Success(
+                newState,
+                ChangeSet.Single(StateChange.Modified("Role", state.Role, newState.Role)),
+                [
+                    SideEffect.Create(
+                        type: "RoleRollback",
+                        description: "Governed compensation restored the previous role",
+                        data: new GovernanceExecutionSideEffectData
+                        {
+                            RequestStateId = state.StateId,
+                            NewRole = newState.Role
+                        })
+                ]);
+        }
+
+        public ValidationResult Validate(RoleState state)
+        {
+            return state.Role == "Reader"
+                ? ValidationResult.WithError("Role", "Role is already Reader.")
+                : ValidationResult.Success();
+        }
+
+        public MutationResult<RoleState> Simulate(RoleState state) => Apply(state);
+    }
+
     [SideEffectDataContract("governance.execution-effect", 1)]
     private sealed record GovernanceExecutionSideEffectData
     {

Tests/ModularityKit.Mutator.Governance.Tests/Lifecycle/MutationRequestStoreContractTests.cs

@@ -34,8 +34,11 @@ public async Task TryStore_rejects_stale_revision_and_preserves_current_state()
 
         var firstUpdate = created with
         {
-            Status = MutationRequestStatus.Approved,
-            PendingReason = null,
+            Lifecycle = created.Lifecycle with
+            {
+                Status = MutationRequestStatus.Approved,
+                PendingReason = null
+            },
             Decisions =
             [
                 .. created.Decisions,
@@ -50,8 +53,11 @@ public async Task TryStore_rejects_stale_revision_and_preserves_current_state()
 
         var staleUpdate = created with
         {
-            Status = MutationRequestStatus.Canceled,
-            PendingReason = null,
+            Lifecycle = created.Lifecycle with
+            {
+                Status = MutationRequestStatus.Canceled,
+                PendingReason = null
+            },
             Decisions =
             [
                 .. created.Decisions,

Tests/ModularityKit.Mutator.Governance.Tests/Queries/MutationRequestQueryStoreTests.cs

@@ -393,10 +393,13 @@ private static MutationRequest CreateSimpleRequest(
         with
         {
             RequestId = requestId,
-            Status = status,
-            PendingReason = pendingReason,
-            CreatedAt = createdAt,
-            UpdatedAt = createdAt
+            Lifecycle = new MutationRequestLifecycleDetails
+            {
+                Status = status,
+                PendingReason = pendingReason,
+                CreatedAt = createdAt,
+                UpdatedAt = createdAt
+            }
         };
 
     private static MutationRequest CreateApprovedRequest(
@@ -423,10 +426,13 @@ private static MutationRequest CreateApprovedRequest(
         with
         {
             RequestId = requestId,
-            Status = MutationRequestStatus.Approved,
-            PendingReason = null,
-            CreatedAt = createdAt,
-            UpdatedAt = updatedAt,
+            Lifecycle = new MutationRequestLifecycleDetails
+            {
+                Status = MutationRequestStatus.Approved,
+                PendingReason = null,
+                CreatedAt = createdAt,
+                UpdatedAt = updatedAt
+            },
             Decisions =
             [
                 MutationRequestDecision.Create(
@@ -495,8 +501,11 @@ private static MutationRequest CreateApprovalViewRequest(
         with
         {
             RequestId = requestId,
-            Status = MutationRequestStatus.Pending,
-            PendingReason = PendingMutationReason.Approval,
+            Lifecycle = new MutationRequestLifecycleDetails
+            {
+                Status = MutationRequestStatus.Pending,
+                PendingReason = PendingMutationReason.Approval
+            },
             ApprovalRequirements =
             [
                 new MutationApprovalRequirement
@@ -528,7 +537,12 @@ private static MutationRequest CreateDecisionViewRequest(
         {
             RequestId = requestId,
             Decisions = decisions,
-            UpdatedAt = decisions.Max(decision => decision.Timestamp)
+            Lifecycle = new MutationRequestLifecycleDetails
+            {
+                Status = MutationRequestStatus.Pending,
+                PendingReason = PendingMutationReason.ExternalCheck,
+                UpdatedAt = decisions.Max(decision => decision.Timestamp)
+            }
         };
 
     private static MutationRequest CreateGovernedRequest(
@@ -552,22 +566,31 @@ private static MutationRequest CreateGovernedRequest(
         => new MutationRequest
         {
             RequestId = requestId,
-            StateId = stateId,
-            StateType = stateType,
-            MutationType = mutationType,
-            Intent = new MutationIntent
+            Scope = new MutationRequestScopeDetails
             {
-                OperationName = mutationType,
-                Category = category,
-                Tags = tags,
-                Metadata = intentMetadata,
-                EstimatedBlastRadius = blastRadius
+                StateId = stateId,
+                StateType = stateType,
+                MutationType = mutationType
+            },
+            Payload = new MutationRequestPayloadDetails
+            {
+                Intent = new MutationIntent
+                {
+                    OperationName = mutationType,
+                    Category = category,
+                    Tags = tags,
+                    Metadata = intentMetadata,
+                    EstimatedBlastRadius = blastRadius
+                },
+                Context = MutationContext.User(actorId, actorName, "Query test")
+            },
+            Lifecycle = new MutationRequestLifecycleDetails
+            {
+                Status = status,
+                PendingReason = pendingReason,
+                CreatedAt = createdAt,
+                UpdatedAt = updatedAt
             },
-            Context = MutationContext.User(actorId, actorName, "Query test"),
-            Status = status,
-            PendingReason = pendingReason,
-            CreatedAt = createdAt,
-            UpdatedAt = updatedAt,
             Decisions = decisions,
             Metadata = requestMetadata,
             SideEffects = sideEffects ?? []