fix(management): FlowDebugRunner — transport faults still write the root row; write-kind completion is script-specific; standby/unreadable-trigger tests

Claude-Session: https://claude.ai/code/session_01NcMG6xXdsJbmD2wYAgkK29
2026-09-08 01:42:17 -04:00
parent a2bfc79e3a
commit ca9be68d91
2 changed files with 151 additions and 18 deletions
@@ -519,6 +519,39 @@ public class FlowDebugRunnerTests
        await _router.DidNotReceiveWithAnyArgs().RouteToCallAsync(default!, default!, default);
    }

+    [Fact]
+    public async Task RunScript_OnStandby_RefusesWithStandbyCode_BeforeTouchingTheInstance()
+    {
+        var (templates, _, _, pipeline) = WireScript(CallScript("Manual"));
+        _gate.IsActiveNode.Returns(false);
+
+        var ex = await Assert.ThrowsAsync<ManagementCommandException>(() => Runner().RunScriptAsync(
+            _services.BuildServiceProvider(), new FlowDebugRunScriptCommand(5, "Manual", null, null), Deployer, CancellationToken.None));
+
+        Assert.Equal(FlowDebugRunner.StandbyNodeCode, ex.Code);
+        Assert.Contains("ACTIVE central node", ex.Message);
+        await templates.DidNotReceiveWithAnyArgs().GetInstanceByIdAsync(default, default);
+        await pipeline.DidNotReceiveWithAnyArgs().FlattenAndValidateAsync(default, default, default, default);
+    }
+
+    [Fact]
+    public async Task RunScript_WriteKind_UnreadableTriggerConfig_FailsValidation()
+    {
+        // A write-kind trigger whose configuration names no attribute: there is nothing to write,
+        // so the run is refused rather than guessing an attribute.
+        WireScript(new ResolvedScript
+        {
+            CanonicalName = "OnLevel", Code = "return 1;", TriggerType = "ValueChange", TriggerConfiguration = "{}",
+        });
+
+        var ex = await Assert.ThrowsAsync<ManagementCommandException>(() => Runner().RunScriptAsync(
+            _services.BuildServiceProvider(), new FlowDebugRunScriptCommand(5, "OnLevel", null, "7"), Deployer, CancellationToken.None));
+
+        Assert.Equal(FlowDebugRunner.ValidationFailedCode, ex.Code);
+        Assert.Contains("trigger configuration", ex.Message);
+        await _router.DidNotReceiveWithAnyArgs().RouteToSetAttributesAsync(default!, default!, default);
+    }
+
    [Fact]
    public async Task RunScript_WriteKind_WithoutValue_FailsValidation_BeforeAnyWrite()
    {
@@ -529,6 +562,28 @@ public class FlowDebugRunnerTests
        await _router.DidNotReceiveWithAnyArgs().RouteToSetAttributesAsync(default!, default!, default);
    }

+    [Fact]
+    public async Task RunScript_WriteKind_SiblingScriptRun_DoesNotCountAsCompletion()
+    {
+        // The write may fire several scripts. A sibling's run is still COLLECTED (the graph draws
+        // it) but must not report the script the operator chose as having run.
+        var (_, _, puller, _) = WireScript(WriteScript("OnLevel", "ValueChange", "Level"));
+        puller.PullAsync("site-a", Arg.Any<IReadOnlyCollection<Guid>>(), Arg.Any<DateTime>(), Arg.Any<int>(), Arg.Any<CancellationToken>())
+            .Returns(ci => (IReadOnlyList<AuditEvent>)[ScadaBridgeAuditEventFactory.Create(AuditChannel.ScriptTrace, AuditKind.ScriptRun, AuditStatus.Delivered,
+                eventId: Guid.Parse("cccccccc-0000-0000-0000-000000000001"),
+                executionId: Guid.NewGuid(), parentExecutionId: ((IReadOnlyCollection<Guid>)ci[1]).First(), target: "OtherScript")]);
+
+        var result = await Runner().RunScriptAsync(_services.BuildServiceProvider(),
+            new FlowDebugRunScriptCommand(5, "OnLevel", null, "7", WaitSeconds: 3), Deployer, CancellationToken.None);
+
+        Assert.False(result.Completed);
+        Assert.Equal(FlowDebugRunner.NoTriggerCode, result.ErrorCode);
+        Assert.Contains("OnLevel", result.Error);
+        // ...but the sibling is in the events, so the operator can see what DID run.
+        Assert.Equal(2, result.Events.Count);
+        Assert.Equal("OtherScript", result.Events[1].Target);
+    }
+
    [Fact]
    public async Task RunScript_CallKind_RoutesATracedCall_AndReturnsRootRouteCallRow_ThenSiteRows()
    {
@@ -636,6 +691,49 @@ public class FlowDebugRunnerTests
        Assert.Equal(AuditKind.RouteCall, written.AsRow().Kind);
    }

+    [Fact]
+    public async Task RunScript_CallKind_TransportFault_StillWritesTheRootRow_AsCallFailed()
+    {
+        // A throwing Ask is NOT proof the script did not run — the site may have executed it and
+        // the reply been lost. The root row must still be written against the operator's name.
+        WireScript(CallScript("Manual"));
+        _router.RouteToCallAsync("site-a", Arg.Any<RouteToCallRequest>(), Arg.Any<CancellationToken>())
+            .Returns(_ => Task.FromException<RouteToCallResponse>(new InvalidOperationException("channel is broken")));
+
+        var result = await Runner().RunScriptAsync(_services.BuildServiceProvider(),
+            new FlowDebugRunScriptCommand(5, "Manual", null, null), Deployer, CancellationToken.None);
+
+        Assert.False(result.Completed);
+        Assert.Equal(FlowDebugRunner.CallFailedCode, result.ErrorCode);
+        Assert.Contains("channel is broken", result.Error);
+        var root = Assert.Single(result.Events).AsRow();
+        Assert.Equal(AuditKind.RouteCall, root.Kind);
+        Assert.Equal(AuditStatus.Failed, root.Status);
+        Assert.Equal("ops", result.Events[0].Actor);
+        var written = Assert.Single(_central);
+        Assert.Equal(AuditKind.RouteCall, written.AsRow().Kind);
+    }
+
+    [Fact]
+    public async Task RunScript_CallKind_AskTimeout_ReportsTimeoutCode()
+    {
+        // The communication layer's own signal that the site never answered — an AskTimeoutException,
+        // NOT an OperationCanceledException, so it needs its own classification.
+        WireScript(CallScript("Manual"));
+        _router.RouteToCallAsync("site-a", Arg.Any<RouteToCallRequest>(), Arg.Any<CancellationToken>())
+            .Returns(_ => Task.FromException<RouteToCallResponse>(
+                new Akka.Actor.AskTimeoutException("no response from site-a")));
+
+        var result = await Runner().RunScriptAsync(_services.BuildServiceProvider(),
+            new FlowDebugRunScriptCommand(5, "Manual", null, null), Deployer, CancellationToken.None);
+
+        Assert.False(result.Completed);
+        Assert.Equal(FlowDebugRunner.TimeoutCode, result.ErrorCode);
+        var root = Assert.Single(result.Events).AsRow();
+        Assert.Equal(AuditStatus.Failed, root.Status);
+        Assert.Single(_central);
+    }
+
    /// <summary>A routed call that never answers until its token is cancelled — the timeout path.</summary>
    private static async Task<RouteToCallResponse> NeverAnswersAsync(CancellationToken ct)
    {