fix(cli): resolve CLI-014..016 — re-triage update-command contract, doc-surface drift, table-column union

tests/ScadaLink.CLI.Tests/CommandTreeTests.cs

@@ -68,6 +68,22 @@ public class CommandTreeTests
             Assert.True(leaf.Action != null, $"Leaf command '{leaf.Name}' has no action."));
     }
 
+    [Fact]
+    public void TemplateCompositionDelete_IsKeyedByIdOnly()
+    {
+        // CLI-015: the in-repo README documented `template composition delete` with
+        // --template-id / --instance-name, but the implementation keys deletion by the
+        // composition's own integer ID via a single --id option. Pin the real surface.
+        var template = TemplateCommands.Build(Url, Format, Username, Password);
+        var composition = template.Subcommands.Single(c => c.Name == "composition");
+        var delete = composition.Subcommands.Single(c => c.Name == "delete");
+
+        var optionNames = delete.Options.Select(o => o.Name).ToList();
+        Assert.Contains("--id", optionNames);
+        Assert.DoesNotContain("--template-id", optionNames);
+        Assert.DoesNotContain("--instance-name", optionNames);
+    }
+
     [Theory]
     [InlineData(typeof(GetInstanceCommand))]
     [InlineData(typeof(ListSitesCommand))]

tests/ScadaLink.CLI.Tests/TableHeaderUnionTests.cs

@@ -0,0 +1,91 @@
+using ScadaLink.CLI;
+using ScadaLink.CLI.Commands;
+
+namespace ScadaLink.CLI.Tests;
+
+/// <summary>
+/// Regression tests for CLI-016 — <c>WriteAsTable</c> previously derived the table
+/// header set from the first array element only, so any property unique to a later
+/// element was silently dropped from the rendered table.
+/// </summary>
+[Collection("Console")]
+public class TableHeaderUnionTests
+{
+    [Fact]
+    public void HandleResponse_TableFormat_HeterogeneousArray_IncludesAllColumns()
+    {
+        // The second element has a "Status" property the first lacks. The pre-fix code
+        // derived headers from items[0] only, so "Status" (and its value "Faulted")
+        // were dropped from the table entirely.
+        var writer = new StringWriter();
+        Console.SetOut(writer);
+
+        try
+        {
+            var json = "[{\"Id\":1,\"Name\":\"Alpha\"},{\"Id\":2,\"Name\":\"Beta\",\"Status\":\"Faulted\"}]";
+            var response = new ManagementResponse(200, json, null, null);
+            var exitCode = CommandHelpers.HandleResponse(response, "table");
+
+            Assert.Equal(0, exitCode);
+            var output = writer.ToString();
+            Assert.Contains("Status", output);
+            Assert.Contains("Faulted", output);
+        }
+        finally
+        {
+            Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true });
+        }
+    }
+
+    [Fact]
+    public void HandleResponse_TableFormat_HeterogeneousArray_PreservesFirstSeenColumnOrder()
+    {
+        // Column order must be the first-seen order across all elements: the first
+        // element contributes Id, Name; the second contributes Status after them.
+        var writer = new StringWriter();
+        Console.SetOut(writer);
+
+        try
+        {
+            var json = "[{\"Id\":1,\"Name\":\"Alpha\"},{\"Status\":\"Faulted\",\"Id\":2,\"Name\":\"Beta\"}]";
+            var response = new ManagementResponse(200, json, null, null);
+            var exitCode = CommandHelpers.HandleResponse(response, "table");
+
+            Assert.Equal(0, exitCode);
+            var output = writer.ToString();
+            var headerLine = output.Split('\n')[0];
+            Assert.True(headerLine.IndexOf("Id") < headerLine.IndexOf("Name"));
+            Assert.True(headerLine.IndexOf("Name") < headerLine.IndexOf("Status"));
+        }
+        finally
+        {
+            Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true });
+        }
+    }
+
+    [Fact]
+    public void HandleResponse_TableFormat_FirstElementHasExtraColumn_StillRendersAllRows()
+    {
+        // The reverse case: the first element has a property a later element lacks.
+        // The later row must still render (with an empty cell), and all columns kept.
+        var writer = new StringWriter();
+        Console.SetOut(writer);
+
+        try
+        {
+            var json = "[{\"Id\":1,\"Name\":\"Alpha\",\"Note\":\"first\"},{\"Id\":2,\"Name\":\"Beta\"}]";
+            var response = new ManagementResponse(200, json, null, null);
+            var exitCode = CommandHelpers.HandleResponse(response, "table");
+
+            Assert.Equal(0, exitCode);
+            var output = writer.ToString();
+            Assert.Contains("Note", output);
+            Assert.Contains("first", output);
+            Assert.Contains("Beta", output);
+        }
+        finally
+        {
+            Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true });
+        }
+    }
+}

tests/ScadaLink.CLI.Tests/UpdateCommandContractTests.cs

@@ -0,0 +1,90 @@
+using System.CommandLine;
+using ScadaLink.CLI.Commands;
+
+namespace ScadaLink.CLI.Tests;
+
+/// <summary>
+/// Regression tests for CLI-014. The <c>Update*Command</c> records in Commons carry
+/// non-nullable "core" fields (e.g. <c>string Name</c>, <c>string Protocol</c>,
+/// <c>string Script</c>) — an update is a <em>whole-entity replace</em>, not a sparse
+/// patch. The CLI must therefore mark those core flags as <c>Required</c>: making them
+/// optional would let an omitted flag send <c>null</c>/empty and silently blank the
+/// field server-side. These tests pin that contract so the documented surface and the
+/// implemented surface stay aligned.
+/// </summary>
+public class UpdateCommandContractTests
+{
+    private static readonly Option<string> Url = new("--url") { Recursive = true };
+    private static readonly Option<string> Username = new("--username") { Recursive = true };
+    private static readonly Option<string> Password = new("--password") { Recursive = true };
+    private static readonly Option<string> Format = CliOptions.CreateFormatOption();
+
+    private static Command UpdateCommand(Command group, params string[] path)
+    {
+        var current = group;
+        foreach (var segment in path)
+            current = current.Subcommands.Single(c => c.Name == segment);
+        return current;
+    }
+
+    private static void AssertRequired(Command command, params string[] requiredOptionNames)
+    {
+        foreach (var name in requiredOptionNames)
+        {
+            var option = command.Options.SingleOrDefault(o => o.Name == name);
+            Assert.True(option != null, $"'{command.Name}' is missing expected option '{name}'.");
+            Assert.True(option!.Required, $"'{command.Name}' option '{name}' must be Required (whole-replace contract).");
+        }
+    }
+
+    [Fact]
+    public void TemplateUpdate_CoreFieldsRequired()
+        => AssertRequired(UpdateCommand(TemplateCommands.Build(Url, Format, Username, Password), "update"), "--name");
+
+    [Fact]
+    public void TemplateAttributeUpdate_CoreFieldsRequired()
+        => AssertRequired(UpdateCommand(TemplateCommands.Build(Url, Format, Username, Password), "attribute", "update"), "--name", "--data-type");
+
+    [Fact]
+    public void TemplateAlarmUpdate_CoreFieldsRequired()
+        => AssertRequired(UpdateCommand(TemplateCommands.Build(Url, Format, Username, Password), "alarm", "update"), "--name", "--trigger-type", "--priority");
+
+    [Fact]
+    public void TemplateScriptUpdate_CoreFieldsRequired()
+        => AssertRequired(UpdateCommand(TemplateCommands.Build(Url, Format, Username, Password), "script", "update"), "--name", "--code");
+
+    [Fact]
+    public void SiteUpdate_CoreFieldsRequired()
+        => AssertRequired(UpdateCommand(SiteCommands.Build(Url, Format, Username, Password), "update"), "--name");
+
+    [Fact]
+    public void DataConnectionUpdate_CoreFieldsRequired()
+        => AssertRequired(UpdateCommand(DataConnectionCommands.Build(Url, Format, Username, Password), "update"), "--name", "--protocol");
+
+    [Fact]
+    public void ExternalSystemUpdate_CoreFieldsRequired()
+        => AssertRequired(UpdateCommand(ExternalSystemCommands.Build(Url, Format, Username, Password), "update"), "--name", "--endpoint-url", "--auth-type");
+
+    [Fact]
+    public void NotificationUpdate_CoreFieldsRequired()
+        => AssertRequired(UpdateCommand(NotificationCommands.Build(Url, Format, Username, Password), "update"), "--name", "--emails");
+
+    [Fact]
+    public void ApiMethodUpdate_CoreFieldsRequired()
+        => AssertRequired(UpdateCommand(ApiMethodCommands.Build(Url, Format, Username, Password), "update"), "--script");
+
+    [Fact]
+    public void ExternalSystemMethodUpdate_IsGenuinelySparse_CoreFieldsOptional()
+    {
+        // UpdateExternalSystemMethodCommand is the one update record whose fields are
+        // genuinely all-nullable, so its flags are correctly optional. Pin that too so
+        // it is not mistakenly forced to Required.
+        var update = UpdateCommand(ExternalSystemCommands.Build(Url, Format, Username, Password), "method", "update");
+        foreach (var name in new[] { "--name", "--http-method", "--path" })
+        {
+            var option = update.Options.SingleOrDefault(o => o.Name == name);
+            Assert.True(option != null, $"method update is missing option '{name}'.");
+            Assert.False(option!.Required, $"method update option '{name}' should be optional (sparse-patch record).");
+        }
+    }
+}