test(transitions,approvals): seeded fuzz — graph-confinement, reducer totality, policy-denial terminality

2026-06-12 19:11:12 +04:00
parent 7558d32ad9
commit 3dd9c52df0
2 changed files with 326 additions and 0 deletions
@@ -0,0 +1,124 @@
+import com.correx.core.events.types.SessionId
+import com.correx.core.events.types.StageId
+import com.correx.core.events.types.TransitionId
+import com.correx.core.transitions.evaluation.EvaluationContext
+import com.correx.core.transitions.evaluation.TransitionConditionEvaluator
+import com.correx.core.transitions.graph.StageConfig
+import com.correx.core.transitions.graph.TransitionCondition
+import com.correx.core.transitions.graph.TransitionEdge
+import com.correx.core.transitions.graph.WorkflowGraph
+import com.correx.core.transitions.resolution.DefaultTransitionResolver
+import com.correx.core.transitions.resolution.TransitionDecision
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.fail
+
+class TransitionFuzzTest {
+
+    private companion object {
+        const val FUZZ_ITERATIONS = 500
+        const val MAX_STEPS = 100
+        val SEED: Long = System.getProperty("fuzz.seed")?.toLong() ?: System.currentTimeMillis()
+    }
+
+    private val evaluator = TransitionConditionEvaluator { condition, context -> condition.evaluate(context) }
+    private val resolver = DefaultTransitionResolver(evaluator)
+
+    @Test
+    fun `graph-walk stays within declared edges and terminates`() {
+        val rng = kotlin.random.Random(SEED)
+        repeat(FUZZ_ITERATIONS) { iteration ->
+            val iterSeed = rng.nextLong()
+            val graph = randomGraph(kotlin.random.Random(iterSeed))
+            val path1 = walk(graph, kotlin.random.Random(iterSeed))
+            val path2 = walk(graph, kotlin.random.Random(iterSeed))
+            val declaredEdgeIds = graph.transitions.map { it.id }.toSet()
+
+            path1.forEach { transitionId ->
+                if (transitionId !in declaredEdgeIds) {
+                    fail(
+                        "Invariant 1 violated: transition $transitionId not in declared graph. " +
+                            "seed=$SEED iterSeed=$iterSeed iteration=$iteration"
+                    )
+                }
+            }
+
+            if (path1.size >= MAX_STEPS) {
+                fail(
+                    "Invariant 2 violated: walk did not terminate within $MAX_STEPS steps. " +
+                        "seed=$SEED iterSeed=$iterSeed iteration=$iteration"
+                )
+            }
+
+            if (path1 != path2) {
+                fail(
+                    "Invariant 3 violated: same seed produced different paths. " +
+                        "path1=$path1 path2=$path2 seed=$SEED iterSeed=$iterSeed iteration=$iteration"
+                )
+            }
+        }
+    }
+
+    private fun walk(graph: WorkflowGraph, rng: kotlin.random.Random): List<TransitionId> {
+        val path = mutableListOf<TransitionId>()
+        var currentStage = graph.start
+        repeat(MAX_STEPS) {
+            val context = randomContext(currentStage, rng)
+            val graphWithConditions = randomizeConditions(graph, rng)
+            val decision = resolver.resolve(graphWithConditions, context)
+            if (decision is TransitionDecision.Move) {
+                path.add(decision.transitionId)
+                currentStage = decision.to
+            } else {
+                return path
+            }
+        }
+        return path
+    }
+
+    private fun randomGraph(rng: kotlin.random.Random): WorkflowGraph {
+        val stageCount = rng.nextInt(3, 9)
+        val stageIds = (0 until stageCount).map { StageId("stage-$it") }
+        val stages = stageIds.associateWith { StageConfig() }
+        val start = stageIds.first()
+
+        val edgeCount = rng.nextInt(stageCount, stageCount * 2 + 1)
+        val edges = mutableSetOf<TransitionEdge>()
+        repeat(edgeCount) { idx ->
+            val from = stageIds[rng.nextInt(stageIds.size)]
+            val to = stageIds[rng.nextInt(stageIds.size)]
+            edges.add(
+                TransitionEdge(
+                    id = TransitionId("t-$idx"),
+                    from = from,
+                    to = to,
+                    condition = TransitionCondition { true },
+                )
+            )
+        }
+
+        return WorkflowGraph(
+            id = "fuzz-graph",
+            start = start,
+            stages = stages,
+            transitions = edges,
+        )
+    }
+
+    private fun randomizeConditions(graph: WorkflowGraph, rng: kotlin.random.Random): WorkflowGraph {
+        val newEdges = graph.transitions.map { edge ->
+            val outcome = rng.nextBoolean()
+            edge.copy(condition = TransitionCondition { outcome })
+        }.toSet()
+        return graph.copy(transitions = newEdges)
+    }
+
+    private fun randomContext(currentStage: StageId, rng: kotlin.random.Random): EvaluationContext {
+        val varCount = rng.nextInt(0, 4)
+        val variables = (0 until varCount).associate { "var$it" to rng.nextInt(100).toString() }
+        return EvaluationContext(
+            sessionId = SessionId("fuzz-session"),
+            currentStage = currentStage,
+            variables = variables,
+        )
+    }
+}