up

tests/reachability/StellaOps.Reachability.FixtureTests/CorpusFixtureTests.cs

@@ -1,6 +1,5 @@
 using System.Security.Cryptography;
 using System.Text.Json;
-using System.Text.RegularExpressions;
 using FluentAssertions;
 using Xunit;
 
@@ -55,29 +54,47 @@ public class CorpusFixtureTests
     }
 
     [Fact]
-    public void ExpectFilesContainRequiredFields()
+    public void GroundTruthFilesContainRequiredFields()
     {
         var manifestPath = Path.Combine(CorpusRoot, "manifest.json");
         var manifest = JsonDocument.Parse(File.ReadAllBytes(manifestPath)).RootElement.EnumerateArray().ToArray();
-        var required = new[] { "id", "language", "state", "score" };
-        var idRegex = new Regex(@"^id:\s*(?<id>.+)$", RegexOptions.Multiline);
+        const string expectedSchemaVersion = "reachbench.reachgraph.truth/v1";
+        var allowedVariants = new[] { "reachable", "unreachable" };
 
         foreach (var entry in manifest)
         {
             var id = entry.GetProperty("id").GetString()!;
             var language = entry.GetProperty("language").GetString()!;
-            var expectPath = Path.Combine(CorpusRoot, language, id, "expect.yaml");
-            File.Exists(expectPath).Should().BeTrue($"{id} missing expect.yaml");
-            var text = File.ReadAllText(expectPath);
+            var truthPath = Path.Combine(CorpusRoot, language, id, "ground-truth.json");
+            File.Exists(truthPath).Should().BeTrue($"{id} missing ground-truth.json");
 
-            foreach (var field in required)
+            using var truthDoc = JsonDocument.Parse(File.ReadAllBytes(truthPath));
+            truthDoc.RootElement.GetProperty("schema_version").GetString().Should().Be(expectedSchemaVersion, $"{id} ground-truth schema_version mismatch");
+            truthDoc.RootElement.GetProperty("case_id").GetString().Should().Be(id, $"{id} ground-truth case_id must match manifest id");
+
+            var variant = truthDoc.RootElement.GetProperty("variant").GetString();
+            variant.Should().NotBeNullOrWhiteSpace($"{id} ground-truth must set variant");
+            allowedVariants.Should().Contain(variant!, $"{id} variant must be reachable|unreachable");
+
+            truthDoc.RootElement.TryGetProperty("paths", out var pathsProp).Should().BeTrue($"{id} ground-truth must include paths");
+            pathsProp.ValueKind.Should().Be(JsonValueKind.Array, $"{id} paths must be an array");
+
+            if (string.Equals(variant, "reachable", StringComparison.Ordinal))
             {
-                text.Should().Contain($"{field}:", $"{id} expect.yaml missing '{field}:'");
+                pathsProp.GetArrayLength().Should().BeGreaterThan(0, $"{id} reachable ground-truth should include at least one path");
             }
 
-            var match = idRegex.Match(text);
-            match.Success.Should().BeTrue($"{id} expect.yaml should include matching id");
-            match.Groups["id"].Value.Trim().Should().Be(id, $"{id} expect.yaml id must match manifest id");
+            foreach (var path in pathsProp.EnumerateArray())
+            {
+                path.ValueKind.Should().Be(JsonValueKind.Array, $"{id} each path must be an array");
+                path.GetArrayLength().Should().BeGreaterThan(0, $"{id} each path must contain at least one symbol");
+
+                foreach (var segment in path.EnumerateArray())
+                {
+                    segment.ValueKind.Should().Be(JsonValueKind.String, $"{id} path segments must be strings");
+                    segment.GetString().Should().NotBeNullOrWhiteSpace($"{id} path segments must be non-empty strings");
+                }
+            }
         }
     }
 }