audit, advisories and doctors/setup work

src/Cli/__Tests/StellaOps.Cli.Tests/Commands/BinaryDiffCommandTests.cs

@@ -0,0 +1,129 @@
+using System.CommandLine;
+using Microsoft.Extensions.DependencyInjection;
+using StellaOps.Cli.Commands.Scan;
+using Xunit;
+
+namespace StellaOps.Cli.Tests.Commands;
+
+public sealed class BinaryDiffCommandTests
+{
+    private readonly IServiceProvider _services;
+    private readonly Option<bool> _verboseOption;
+    private readonly CancellationToken _cancellationToken;
+
+    public BinaryDiffCommandTests()
+    {
+        _services = new ServiceCollection().BuildServiceProvider();
+        _verboseOption = new Option<bool>("--verbose", new[] { "-v" })
+        {
+            Description = "Enable verbose output"
+        };
+        _cancellationToken = CancellationToken.None;
+    }
+
+    [Fact]
+    public void BuildDiffCommand_HasRequiredOptions()
+    {
+        var command = BuildDiffCommand();
+
+        Assert.Contains(command.Options, option => HasAlias(option, "--base", "-b"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--target", "-t"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--mode", "-m"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--emit-dsse", "-d"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--signing-key"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--format", "-f"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--platform", "-p"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--include-unchanged"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--sections"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--registry-auth"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--timeout"));
+        Assert.Contains(command.Options, option => HasAlias(option, "--verbose", "-v"));
+    }
+
+    [Fact]
+    public void BuildDiffCommand_RequiresBaseAndTarget()
+    {
+        var command = BuildDiffCommand();
+        var baseOption = FindOption(command, "--base");
+        var targetOption = FindOption(command, "--target");
+
+        Assert.NotNull(baseOption);
+        Assert.NotNull(targetOption);
+        Assert.Equal(1, baseOption!.Arity.MinimumNumberOfValues);
+        Assert.Equal(1, targetOption!.Arity.MinimumNumberOfValues);
+    }
+
+    [Fact]
+    public void DiffCommand_ParsesMinimalArgs()
+    {
+        var root = BuildRoot(out _);
+
+        var result = root.Parse("scan diff --base registry.example.com/app:1 --target registry.example.com/app:2");
+
+        Assert.Empty(result.Errors);
+    }
+
+    [Fact]
+    public void DiffCommand_FailsWhenBaseMissing()
+    {
+        var root = BuildRoot(out _);
+
+        var result = root.Parse("scan diff --target registry.example.com/app:2");
+
+        Assert.NotEmpty(result.Errors);
+    }
+
+    [Fact]
+    public void DiffCommand_AcceptsSectionsTokens()
+    {
+        var root = BuildRoot(out var diffCommand);
+
+        var result = root.Parse("scan diff --base registry.example.com/app:1 --target registry.example.com/app:2 --sections .text,.rodata --sections .data");
+
+        Assert.Empty(result.Errors);
+
+        var sectionsOption = diffCommand.Options
+            .OfType<Option<string[]>>()
+            .Single(option => HasAlias(option, "--sections"));
+
+        Assert.True(sectionsOption.AllowMultipleArgumentsPerToken);
+    }
+
+    private Command BuildDiffCommand()
+    {
+        return BinaryDiffCommandGroup.BuildDiffCommand(_services, _verboseOption, _cancellationToken);
+    }
+
+    private RootCommand BuildRoot(out Command diffCommand)
+    {
+        diffCommand = BuildDiffCommand();
+        var scan = new Command("scan", "Scanner operations")
+        {
+            diffCommand
+        };
+        return new RootCommand { scan };
+    }
+
+    private static Option? FindOption(Command command, string alias)
+    {
+        return command.Options.FirstOrDefault(option =>
+            option.Name.Equals(alias, StringComparison.OrdinalIgnoreCase) ||
+            option.Name.Equals(alias.TrimStart('-'), StringComparison.OrdinalIgnoreCase) ||
+            option.Aliases.Contains(alias));
+    }
+
+    private static bool HasAlias(Option option, params string[] aliases)
+    {
+        foreach (var alias in aliases)
+        {
+            if (option.Name.Equals(alias, StringComparison.OrdinalIgnoreCase) ||
+                option.Name.Equals(alias.TrimStart('-'), StringComparison.OrdinalIgnoreCase) ||
+                option.Aliases.Contains(alias))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}