[tests] feat: cover closure graph and verb output

Author: FeathBow

tests/e2e/ClosureTests.cs

@@ -0,0 +1,105 @@
+using System.Text.Json;
+
+namespace PeFix.Tests;
+
+[Trait("Category", "E2E")]
+public sealed class ClosureE2E : IDisposable
+{
+    private readonly TempDir _temp = new();
+
+    [Fact]
+    public void TextOutput()
+    {
+        _temp.CopyAll(
+            "F20_closure_entry.dll",
+            "F21_closure_mid.dll",
+            "F22_closure_deep.dll",
+            "F23_closure_cycle_a.dll",
+            "F24_closure_cycle_b.dll");
+
+        CliResult result = CliRunner.Run("closure", _temp.DirPath);
+
+        Assert.Equal(0, result.ExitCode);
+        Assert.Contains("UNRESOLVED", result.Stdout);
+        Assert.Contains("ClosureMissing", result.Stdout);
+        Assert.Contains("MISSING", result.Stdout);
+        Assert.Contains("Cycle chains:", result.Stdout);
+        Assert.Contains("ClosureCycleA", result.Stdout);
+        Assert.Contains("ClosureCycleB", result.Stdout);
+        Assert.Contains("CYCLE", result.Stdout);
+        Assert.Contains("entry assemblies", result.Stdout);
+        Assert.Contains("transitive references", result.Stdout);
+        Assert.Contains("→ ClosureMid.dll v1.0.0.0", result.Stdout);
+        Assert.Contains("→ ClosureDeep.dll v1.0.0.0", result.Stdout);
+        Assert.Contains("→ ClosureMissing.dll v1.0.0.0  [MISSING]", result.Stdout);
+        Assert.Contains("[resolved]", result.Stdout);
+    }
+
+    [Fact]
+    public void JsonContract()
+    {
+        _temp.CopyAll(
+            "F20_closure_entry.dll",
+            "F21_closure_mid.dll",
+            "F22_closure_deep.dll");
+
+        CliResult result = CliRunner.Run("closure", _temp.DirPath, "--json");
+
+        Assert.Equal(0, result.ExitCode);
+        Assert.DoesNotContain("\r", result.Stdout);
+        Assert.EndsWith("\n", result.Stdout);
+
+        using JsonDocument doc = JsonDocument.Parse(result.Stdout);
+        JsonElement root = doc.RootElement;
+
+        Assert.Equal(1, root.GetProperty("schema_version").GetInt32());
+        Assert.True(root.TryGetProperty("directory", out _));
+        Assert.True(root.TryGetProperty("entry_assemblies", out _));
+        Assert.True(root.TryGetProperty("unresolved_chains", out _));
+        Assert.True(root.TryGetProperty("cycle_chains", out _));
+        Assert.True(root.TryGetProperty("total_refs_walked", out _));
+        Assert.True(root.TryGetProperty("framework_leaves", out _));
+
+        JsonElement unresolved = root.GetProperty("unresolved_chains");
+        JsonElement chain = Assert.Single(
+            unresolved.EnumerateArray(),
+            item => item.GetProperty("entry").GetString() == "ClosureEntry");
+        JsonElement segments = chain.GetProperty("segments");
+        Assert.Equal(3, segments.GetArrayLength());
+        AssertSeg(segments[0], "ClosureMid", "resolved");
+        AssertSeg(segments[1], "ClosureDeep", "resolved");
+        AssertSeg(segments[2], "ClosureMissing", "unresolved");
+    }
+
+    [Fact]
+    public void FailOnFlag()
+    {
+        _temp.CopyAll(
+            "F20_closure_entry.dll",
+            "F21_closure_mid.dll",
+            "F22_closure_deep.dll");
+
+        CliResult result = CliRunner.Run("closure", _temp.DirPath, "--fail-on-unresolved");
+
+        Assert.Equal(1, result.ExitCode);
+    }
+
+    [Fact]
+    public void FailOnFlag_AllResolved()
+    {
+        _temp.CopyAll("F01_compatible_anycpu.dll");
+
+        CliResult result = CliRunner.Run("closure", _temp.DirPath, "--fail-on-unresolved");
+
+        Assert.Equal(0, result.ExitCode);
+    }
+
+    private static void AssertSeg(JsonElement segment, string name, string kind)
+    {
+        Assert.Equal(name, segment.GetProperty("name").GetString());
+        Assert.Equal("1.0.0.0", segment.GetProperty("version").GetString());
+        Assert.Equal(kind, segment.GetProperty("kind").GetString());
+    }
+
+    public void Dispose() => _temp.Dispose();
+}

tests/fixtures/ClosureTests.cs

@@ -0,0 +1,114 @@
+using PeFix.Meta;
+
+namespace PeFix.Tests;
+
+[Trait("Category", "Unit")]
+public sealed class ClosureTests
+{
+    [Fact]
+    public void All_Resolved()
+    {
+        Inspection a = Make("A", "1.0", [Asm("B", "1.0")]);
+        Inspection b = Make("B", "1.0", [Asm("C", "1.0")]);
+        Inspection c = Make("C", "1.0", []);
+
+        ClosureReport report = ClosureGraph.Build([a, b, c], "/test");
+
+        Assert.Equal(3, report.Entries.Length);
+        Assert.Empty(report.Unresolved);
+        Assert.Empty(report.CycleChains);
+        Assert.Equal(0, report.HostLeaves);
+    }
+
+    [Fact]
+    public void Direct_Missing()
+    {
+        Inspection a = Make("A", "1.0", [Asm("Missing", "2.0")]);
+
+        ClosureReport report = ClosureGraph.Build([a], "/test");
+
+        Assert.Single(report.Unresolved);
+        ClosureChain chain = report.Unresolved[0];
+        Assert.Equal("A", chain.Entry.AssemblyName);
+        Assert.Single(chain.Segments);
+        Assert.Equal("Missing", chain.Segments[0].AssemblyName);
+        Assert.Equal(ChainKind.Unresolved, chain.Segments[0].Kind);
+        Assert.Equal(1, report.RefsWalked);
+    }
+
+    [Fact]
+    public void Transitive_Missing()
+    {
+        Inspection a = Make("A", "1.0", [Asm("B", "1.0")]);
+        Inspection b = Make("B", "1.0", [Asm("C", "1.0")]);
+        Inspection c = Make("C", "1.0", [Asm("Missing", "1.0")]);
+
+        ClosureReport report = ClosureGraph.Build([a, b, c], "/test");
+
+        Assert.Equal(3, report.Entries.Length);
+        Assert.Single(report.Unresolved, ch => ch.Entry.AssemblyName == "A");
+
+        ClosureChain chain = report.Unresolved.First(ch => ch.Entry.AssemblyName == "A");
+        Assert.Equal(3, chain.Segments.Length);
+        Assert.Equal("B", chain.Segments[0].AssemblyName);
+        Assert.Equal(ChainKind.Resolved, chain.Segments[0].Kind);
+        Assert.Equal("C", chain.Segments[1].AssemblyName);
+        Assert.Equal("Missing", chain.Segments[2].AssemblyName);
+        Assert.Equal(ChainKind.Unresolved, chain.Segments[2].Kind);
+    }
+
+    [Fact]
+    public void Cycle_Handled()
+    {
+        Inspection a = Make("A", "1.0", [Asm("B", "1.0")]);
+        Inspection b = Make("B", "1.0", [Asm("A", "1.0")]);
+
+        ClosureReport report = ClosureGraph.Build([a, b], "/test");
+
+        Assert.NotEmpty(report.CycleChains);
+        Assert.Empty(report.Unresolved);
+        Assert.Equal(2, report.CycleChains.Length);
+        Assert.Contains(report.CycleChains, ch => ch.Entry.AssemblyName == "A");
+        Assert.Contains(report.CycleChains, ch => ch.Entry.AssemblyName == "B");
+    }
+
+    [Fact]
+    public void Framework_NotReported()
+    {
+        Inspection a = Make("A", "1.0", [Asm("System", "4.0")]);
+
+        ClosureReport report = ClosureGraph.Build([a], "/test");
+
+        Assert.Empty(report.Unresolved);
+        Assert.Equal(1, report.RefsWalked);
+        Assert.Equal(1, report.HostLeaves);
+    }
+
+    private static Inspection Make(string name, string ver, AsmRef[] refs)
+    {
+        return new Inspection(
+            $"{name}.dll",
+            true,
+            true,
+            null,
+            null,
+            default,
+            default,
+            null,
+            Status.Compatible,
+            "test",
+            "cause",
+            [],
+            [],
+            [],
+            null,
+            null,
+            null,
+            null,
+            null,
+            refs,
+            Asm(name, ver));
+    }
+
+    private static AsmRef Asm(string name, string version) => new(name, version);
+}