audit, advisories and doctors/setup work

src/__Libraries/__Tests/StellaOps.Policy.Tools.Tests/PolicySimulationSmokeRunnerTests.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using StellaOps.TestKit;
+using Xunit;
+
+namespace StellaOps.Policy.Tools.Tests;
+
+public sealed class PolicySimulationSmokeRunnerTests
+{
+    private const string PolicyJson = "{\n  \"version\": \"1.0\",\n  \"rules\": [\n    {\n      \"name\": \"block-low\",\n      \"action\": \"block\",\n      \"severity\": [\"low\"]\n    }\n  ]\n}\n";
+
+    [Trait("Category", TestCategories.Unit)]
+    [Fact]
+    public async Task RunAsync_ReportsInvalidSeverity()
+    {
+        using var temp = new TempDirectory("policy-sim-invalid-severity");
+        WritePolicy(temp.RootPath);
+
+        var scenario = new PolicySimulationScenario
+        {
+            Name = "invalid-severity",
+            PolicyPath = "policy.json",
+            Findings = new List<ScenarioFinding>
+            {
+                new() { FindingId = "F-1", Severity = "NotASeverity" }
+            },
+            ExpectedDiffs = new List<ScenarioExpectedDiff>()
+        };
+
+        var scenarioRoot = WriteScenario(temp.RootPath, scenario);
+        var outputRoot = Path.Combine(temp.RootPath, "out");
+        var options = BuildOptions(scenarioRoot, outputRoot, temp.RootPath);
+
+        var runner = new PolicySimulationSmokeRunner();
+        var exitCode = await runner.RunAsync(options, CancellationToken.None);
+
+        Assert.Equal(1, exitCode);
+
+        var summaryPath = Path.Combine(outputRoot, "policy-simulation-summary.json");
+        using var document = JsonDocument.Parse(await File.ReadAllTextAsync(summaryPath, CancellationToken.None));
+        var entry = document.RootElement.EnumerateArray().Single();
+
+        Assert.False(entry.GetProperty("Success").GetBoolean());
+
+        var failures = entry.GetProperty("Failures")
+            .EnumerateArray()
+            .Select(value => value.GetString())
+            .ToArray();
+
+        Assert.Contains("Scenario 'invalid-severity' finding 'F-1' has invalid severity 'NotASeverity'.", failures);
+    }
+
+    [Trait("Category", TestCategories.Unit)]
+    [Fact]
+    public async Task RunAsync_ReportsInvalidBaselineStatus()
+    {
+        using var temp = new TempDirectory("policy-sim-invalid-status");
+        WritePolicy(temp.RootPath);
+
+        var scenario = new PolicySimulationScenario
+        {
+            Name = "invalid-status",
+            PolicyPath = "policy.json",
+            Findings = new List<ScenarioFinding>
+            {
+                new() { FindingId = "F-1", Severity = "Low" }
+            },
+            ExpectedDiffs = new List<ScenarioExpectedDiff>(),
+            Baseline = new List<ScenarioBaseline>
+            {
+                new() { FindingId = "F-1", Status = "BadStatus" }
+            }
+        };
+
+        var scenarioRoot = WriteScenario(temp.RootPath, scenario);
+        var outputRoot = Path.Combine(temp.RootPath, "out");
+        var options = BuildOptions(scenarioRoot, outputRoot, temp.RootPath);
+
+        var runner = new PolicySimulationSmokeRunner();
+        var exitCode = await runner.RunAsync(options, CancellationToken.None);
+
+        Assert.Equal(1, exitCode);
+
+        var summaryPath = Path.Combine(outputRoot, "policy-simulation-summary.json");
+        using var document = JsonDocument.Parse(await File.ReadAllTextAsync(summaryPath, CancellationToken.None));
+        var entry = document.RootElement.EnumerateArray().Single();
+
+        Assert.False(entry.GetProperty("Success").GetBoolean());
+
+        var failures = entry.GetProperty("Failures")
+            .EnumerateArray()
+            .Select(value => value.GetString())
+            .ToArray();
+
+        Assert.Contains("Scenario 'invalid-status' baseline 'F-1' has invalid status 'BadStatus'.", failures);
+    }
+
+    [Trait("Category", TestCategories.Unit)]
+    [Fact]
+    public async Task RunAsync_SortsActualStatusesInSummary()
+    {
+        using var temp = new TempDirectory("policy-sim-ordering");
+        WritePolicy(temp.RootPath);
+
+        var scenario = new PolicySimulationScenario
+        {
+            Name = "ordering",
+            PolicyPath = "policy.json",
+            Findings = new List<ScenarioFinding>
+            {
+                new() { FindingId = "b", Severity = "Low" },
+                new() { FindingId = "a", Severity = "Low" }
+            },
+            ExpectedDiffs = new List<ScenarioExpectedDiff>
+            {
+                new() { FindingId = "b", Status = "Blocked" },
+                new() { FindingId = "a", Status = "Blocked" }
+            }
+        };
+
+        var scenarioRoot = WriteScenario(temp.RootPath, scenario);
+        var outputRoot = Path.Combine(temp.RootPath, "out");
+        var options = BuildOptions(scenarioRoot, outputRoot, temp.RootPath);
+
+        var runner = new PolicySimulationSmokeRunner();
+        var exitCode = await runner.RunAsync(options, CancellationToken.None);
+
+        Assert.Equal(0, exitCode);
+
+        var summaryPath = Path.Combine(outputRoot, "policy-simulation-summary.json");
+        using var document = JsonDocument.Parse(await File.ReadAllTextAsync(summaryPath, CancellationToken.None));
+        var entry = document.RootElement.EnumerateArray().Single();
+
+        var actualStatuses = entry.GetProperty("ActualStatuses").EnumerateObject().Select(pair => pair.Name).ToArray();
+
+        Assert.Equal(new[] { "a", "b" }, actualStatuses);
+    }
+
+    [Trait("Category", TestCategories.Unit)]
+    [Fact]
+    public void ResolveFixedTime_UsesDefaultWhenMissing()
+    {
+        var resolved = PolicySimulationSmokeDefaults.ResolveFixedTime(null);
+
+        Assert.Equal(PolicySimulationSmokeDefaults.DefaultFixedTime, resolved);
+    }
+
+    private static PolicySimulationSmokeOptions BuildOptions(string scenarioRoot, string outputRoot, string repoRoot)
+        => new()
+        {
+            ScenarioRoot = scenarioRoot,
+            OutputDirectory = outputRoot,
+            RepoRoot = repoRoot,
+            FixedTime = new DateTimeOffset(2025, 1, 1, 0, 0, 0, TimeSpan.Zero)
+        };
+
+    private static void WritePolicy(string rootPath)
+    {
+        var policyPath = Path.Combine(rootPath, "policy.json");
+        File.WriteAllText(policyPath, PolicyJson);
+    }
+
+    private static string WriteScenario(string rootPath, PolicySimulationScenario scenario)
+    {
+        var scenarioRoot = Path.Combine(rootPath, "scenarios");
+        Directory.CreateDirectory(scenarioRoot);
+
+        var scenarioPath = Path.Combine(scenarioRoot, "scenario.json");
+        var scenarioJson = JsonSerializer.Serialize(
+            scenario,
+            new JsonSerializerOptions(JsonSerializerDefaults.Web) { WriteIndented = true });
+        File.WriteAllText(scenarioPath, scenarioJson);
+
+        return scenarioRoot;
+    }
+}