sprints work

src/__Libraries/StellaOps.Resolver.Tests/DeterministicResolverTests.cs

@@ -0,0 +1,138 @@
+/**
+ * Resolver Tests
+ * Sprint: SPRINT_9100_0001_0001 (Core Resolver Package)
+ * Tasks: RESOLVER-9100-019 through RESOLVER-9100-024
+ */
+
+using System.Text.Json;
+using Xunit;
+
+namespace StellaOps.Resolver.Tests;
+
+public class DeterministicResolverTests
+{
+    private readonly Policy _policy = Policy.Empty;
+    private readonly IGraphOrderer _orderer = new TopologicalGraphOrderer();
+    private readonly ITrustLatticeEvaluator _evaluator = new DefaultTrustLatticeEvaluator();
+
+    [Fact]
+    public void Run_SameInputTwice_IdenticalFinalDigest()
+    {
+        // RESOLVER-9100-020: Replay test
+        var graph = CreateTestGraph();
+        var resolver = new DeterministicResolver(_policy, _orderer, _evaluator);
+        var fixedTime = DateTimeOffset.Parse("2025-12-24T00:00:00Z");
+
+        var result1 = resolver.Run(graph, fixedTime);
+        var result2 = resolver.Run(graph, fixedTime);
+
+        Assert.Equal(result1.FinalDigest, result2.FinalDigest);
+        Assert.Equal(result1.GraphDigest, result2.GraphDigest);
+        Assert.Equal(result1.TraversalSequence.Length, result2.TraversalSequence.Length);
+    }
+
+    [Fact]
+    public void Run_ShuffledNodesAndEdges_IdenticalFinalDigest()
+    {
+        // RESOLVER-9100-021: Permutation test
+        var node1 = Node.Create("package", "pkg:npm/a@1.0.0");
+        var node2 = Node.Create("package", "pkg:npm/b@1.0.0");
+        var node3 = Node.Create("package", "pkg:npm/c@1.0.0");
+
+        var edge1 = Edge.Create(node1.Id, "depends_on", node2.Id);
+        var edge2 = Edge.Create(node2.Id, "depends_on", node3.Id);
+
+        // Create graphs with different input orders
+        var graph1 = EvidenceGraph.Create(
+            new[] { node1, node2, node3 },
+            new[] { edge1, edge2 });
+
+        var graph2 = EvidenceGraph.Create(
+            new[] { node3, node1, node2 }, // shuffled
+            new[] { edge2, edge1 }); // shuffled
+
+        var resolver = new DeterministicResolver(_policy, _orderer, _evaluator);
+        var fixedTime = DateTimeOffset.Parse("2025-12-24T00:00:00Z");
+
+        var result1 = resolver.Run(graph1, fixedTime);
+        var result2 = resolver.Run(graph2, fixedTime);
+
+        Assert.Equal(result1.FinalDigest, result2.FinalDigest);
+    }
+
+    [Fact]
+    public void Run_IsIdempotent()
+    {
+        // RESOLVER-9100-022: Idempotency property test
+        var graph = CreateTestGraph();
+        var resolver = new DeterministicResolver(_policy, _orderer, _evaluator);
+        var fixedTime = DateTimeOffset.Parse("2025-12-24T00:00:00Z");
+
+        var result1 = resolver.Run(graph, fixedTime);
+        var result2 = resolver.Run(graph, fixedTime);
+        var result3 = resolver.Run(graph, fixedTime);
+
+        Assert.Equal(result1.FinalDigest, result2.FinalDigest);
+        Assert.Equal(result2.FinalDigest, result3.FinalDigest);
+    }
+
+    [Fact]
+    public void Run_TraversalSequence_MatchesTopologicalOrder()
+    {
+        // RESOLVER-9100-023: Traversal order test
+        var root = Node.Create("package", "root");
+        var child1 = Node.Create("package", "child1");
+        var child2 = Node.Create("package", "child2");
+
+        var edge1 = Edge.Create(root.Id, "depends_on", child1.Id);
+        var edge2 = Edge.Create(root.Id, "depends_on", child2.Id);
+
+        var graph = EvidenceGraph.Create(
+            new[] { root, child1, child2 },
+            new[] { edge1, edge2 });
+
+        var resolver = new DeterministicResolver(_policy, _orderer, _evaluator);
+        var result = resolver.Run(graph);
+
+        // Children should come before root in topological order (reverse dependency order)
+        var rootIndex = result.TraversalSequence.ToList().IndexOf(root.Id);
+        var child1Index = result.TraversalSequence.ToList().IndexOf(child1.Id);
+        var child2Index = result.TraversalSequence.ToList().IndexOf(child2.Id);
+
+        // Root depends on children, so root should come after children in topological order
+        // Wait - our edges go root -> child, so root has no incoming edges
+        // Root should actually be first since it has no dependencies
+        Assert.True(rootIndex < child1Index || rootIndex < child2Index,
+            "Root should appear before at least one child in traversal");
+    }
+
+    [Fact]
+    public void ResolutionResult_CanonicalJsonStructure()
+    {
+        // RESOLVER-9100-024: Snapshot test for canonical JSON
+        var graph = CreateTestGraph();
+        var resolver = new DeterministicResolver(_policy, _orderer, _evaluator);
+        var fixedTime = DateTimeOffset.Parse("2025-12-24T00:00:00Z");
+
+        var result = resolver.Run(graph, fixedTime);
+
+        // Verify result structure
+        Assert.NotNull(result.FinalDigest);
+        Assert.NotNull(result.GraphDigest);
+        Assert.NotNull(result.PolicyDigest);
+        Assert.Equal(64, result.FinalDigest.Length); // SHA256 hex
+        Assert.Equal(64, result.GraphDigest.Length);
+        Assert.Equal(64, result.PolicyDigest.Length);
+        Assert.Equal(fixedTime, result.ResolvedAt);
+    }
+
+    private static EvidenceGraph CreateTestGraph()
+    {
+        var node1 = Node.Create("package", "pkg:npm/test@1.0.0");
+        var node2 = Node.Create("vulnerability", "CVE-2024-1234");
+
+        var edge = Edge.Create(node2.Id, "affects", node1.Id);
+
+        return EvidenceGraph.Create(new[] { node1, node2 }, new[] { edge });
+    }
+}