dohertj2/ScadaBridge
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

test(rig): flow debugger script entry — Playwright direct-call run + verify-delmia-notifier step H2

Browse Source 
Claude-Session: https://claude.ai/code/session_01NcMG6xXdsJbmD2wYAgkK29
This commit is contained in:
Joseph Doherty
2026-09-08 01:29:10 -04:00
parent 24026b25e2
commit 0887c69500
2 changed files with 207 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/ZB.MOM.WW.ScadaBridge.CentralUI.PlaywrightTests/Deployment/FlowDebuggerTests.cs
+176
View File
@@ -12,6 +12,13 @@ namespace ZB.MOM.WW.ScadaBridge.CentralUI.PlaywrightTests.Deployment;
/// prediction path that used to deadlock the circuit (see <see cref="FlowDebuggerFixture"/>) —
/// under that bug the state chip never reached <c>Predicted</c> and every later click was lost,
/// so these tests are the browser-level guard for that fix as well.
///
/// <para>
/// The script entry (design 2026-09-08, Task 11) adds two more: a Live direct call of the rig's
/// <c>OutboundDemo</c> Call script on <c>DelmiaSim01</c>, and the write-kind Inputs card naming the
/// trigger's own attribute. Unlike the method tests those drive RIG-SEEDED objects the fixture does
/// not provision, so each picker step skips with a "run docker/seed-…" message when it is absent.
/// </para>
/// </summary>
[Collection("Playwright")]
public class FlowDebuggerTests : IClassFixture<FlowDebuggerFixture>
@@ -91,6 +98,175 @@ public class FlowDebuggerTests : IClassFixture<FlowDebuggerFixture>
Assert.DoesNotContain(consoleErrors, e => e.Contains("JSInterop", StringComparison.OrdinalIgnoreCase));
}
[SkippableFact]
public async Task ScriptEntry_LiveRunOfACallScript_InBrowser_Completes()
{
// Flow Debugger script entry (design 2026-09-08 §5). Rig objects: DelmiaSim01 (SimMachine, site-a)
// carries the OutboundDemo Call script seeded by docker/seed-flow-outbound-demo.sh; skip when absent.
// A Call script is invoked DIRECTLY through the traced RouteToCall path, so this is the browser-level
// proof of the call-kind branch: picker -> prediction -> Inputs card -> real run -> graph.
Skip.IfNot(_flow.Available, ClusterAvailability.SkipReason);
var page = await _pw.NewAuthenticatedPageAsync();
var consoleErrors = CaptureConsoleErrors(page);
await page.GotoAsync(PlaywrightFixture.BaseUrl + FlowDebuggerUrl);
await page.ClickAsync("button[data-test='flow-entry-script']");
var scriptSelect = await SelectRigScriptAsync(page, RigCallScript);
// The prediction ran server-side (a RouteCall root + the site script's predicted steps).
await Assertions.Expect(page.Locator("[data-test='flow-state']")).ToHaveTextAsync("Predicted", new() { Timeout = 15_000 });
// Call kinds render the shared ParameterValueForm, or the no-parameters note when the script
// declares none — OutboundDemo declares none today (the seed passes no --parameters), but it
// reads an optional WorkOrder, so fill the field if a later seed starts declaring it.
var paramsCard = page.Locator("[data-test='flow-script-params']");
var noParamsNote = page.Locator("[data-test='flow-script-no-params']");
await Assertions.Expect(paramsCard.Or(noParamsNote)).ToBeVisibleAsync(new() { Timeout = 15_000 });
if (await paramsCard.IsVisibleAsync())
{
var workOrder = page.Locator("#param-WorkOrder");
if (await workOrder.CountAsync() > 0)
{
await workOrder.FillAsync("WO-PW");
await workOrder.BlurAsync();
await page.WaitForTimeoutAsync(300);
}
}
await page.ClickAsync("button[data-test='flow-run']");
await Assertions.Expect(page.Locator("[data-test='flow-state']")).ToHaveTextAsync("Completed", new() { Timeout = 60_000 });
var stepCountText = await page.Locator("[data-test='flow-step-count']").InnerTextAsync();
var stepCount = int.Parse(stepCountText.Trim(), CultureInfo.InvariantCulture);
Assert.True(stepCount >= 2, $"expected at least the RouteCall root + the site's ScriptRun, got {stepCount}");
// The picker kept the choice, and selecting a node fills the detail panel.
await Assertions.Expect(scriptSelect).ToHaveValueAsync(RigCallScript);
await page.Locator("g[data-test='flow-node']").Last.ClickAsync();
await Assertions.Expect(page.Locator("[data-test='flow-step-title']")).ToBeVisibleAsync();
Assert.DoesNotContain(consoleErrors, e => e.Contains("JSInterop", StringComparison.OrdinalIgnoreCase));
}
[SkippableFact]
public async Task ScriptEntry_WriteKindScript_ShowsTheValueFieldForTheTriggerAttribute()
{
// The write-kind branch of the same picker (design 2026-09-08 §5): a ValueChange/Conditional
// script is fired by writing ITS OWN trigger attribute, so the Inputs card offers one value
// field naming that attribute instead of a parameter form. DelmiaReceiverSimulator (ValueChange
// on DelmiaReceiver.RecipeDownloadFlag) is seeded by docker/seed-delmia-sim.sh. No run: the
// simulator has real side effects and the call-kind test above already covers execution.
Skip.IfNot(_flow.Available, ClusterAvailability.SkipReason);
var page = await _pw.NewAuthenticatedPageAsync();
var consoleErrors = CaptureConsoleErrors(page);
await page.GotoAsync(PlaywrightFixture.BaseUrl + FlowDebuggerUrl);
await page.ClickAsync("button[data-test='flow-entry-script']");
await SelectRigScriptAsync(page, RigValueChangeScript);
var valueField = page.Locator("input[data-test='flow-input-value']");
await Assertions.Expect(valueField).ToBeVisibleAsync(new() { Timeout = 15_000 });
await Assertions.Expect(page.Locator("[data-test='flow-script-params']")).ToHaveCountAsync(0);
// The card names the attribute the debugger would write — that is what makes the derived
// attribute (rather than an operator-picked one) visible to the operator.
var inputsCard = valueField.Locator("xpath=ancestor::div[contains(@class,'card-body')][1]");
await Assertions.Expect(inputsCard).ToContainTextAsync(RigValueChangeAttribute);
Assert.DoesNotContain(consoleErrors, e => e.Contains("JSInterop", StringComparison.OrdinalIgnoreCase));
}
/// <summary>Rig instance the script-entry tests drive (<c>docker/seed-delmia-sim.sh</c>).</summary>
private const string RigInstanceName = "DelmiaSim01";
/// <summary>Call script on that instance (<c>docker/seed-flow-outbound-demo.sh</c>).</summary>
private const string RigCallScript = "OutboundDemo";
/// <summary>ValueChange script on that instance, and the attribute its trigger names.</summary>
private const string RigValueChangeScript = "DelmiaReceiverSimulator";
private const string RigValueChangeAttribute = "DelmiaReceiver.RecipeDownloadFlag";
/// <summary>
/// Walks the script entry's three pickers (site → instance → script) to the named script on the
/// rig's <see cref="RigInstanceName"/>, skipping the test with a rig-shaped message whenever an
/// option is missing — none of these objects is provisioned by the fixture. Site is matched by
/// LABEL because its id differs per rig (the seed names it "Test Plant A", identifier
/// <c>site-a</c>); the script is matched by option VALUE, which is its canonical name.
/// </summary>
private static async Task<ILocator> SelectRigScriptAsync(IPage page, string scriptName)
{
var sites = page.Locator("select[data-test='flow-site-select']");
await Assertions.Expect(sites).ToBeVisibleAsync(new() { Timeout = 15_000 });
var siteLabel = await WaitForOptionLabelAsync(page, sites, l =>
l.Contains("Plant A", StringComparison.OrdinalIgnoreCase)
|| l.Contains("Site A", StringComparison.OrdinalIgnoreCase)
|| l.Contains("site-a", StringComparison.OrdinalIgnoreCase));
Skip.If(siteLabel is null, "The rig's site-a ('Test Plant A') is not in the Flow Debugger site list — run docker/seed-sites.sh.");
await sites.SelectOptionAsync(new SelectOptionValue { Label = siteLabel! });
var instances = page.Locator("select[data-test='flow-instance-select']");
var instanceLabel = await WaitForOptionLabelAsync(
page, instances, l => string.Equals(l, RigInstanceName, StringComparison.Ordinal));
Skip.If(instanceLabel is null, $"Instance {RigInstanceName} is not on the rig's site-a — run docker/seed-delmia-sim.sh.");
await instances.SelectOptionAsync(new SelectOptionValue { Label = instanceLabel! });
var scripts = page.Locator("select[data-test='flow-script-select']");
var option = scripts.Locator($"option[value='{scriptName}']");
Skip.IfNot(
await WaitForCountAsync(page, option),
$"Script {scriptName} is not on {RigInstanceName} — run docker/seed-delmia-sim.sh and docker/seed-flow-outbound-demo.sh.");
await scripts.SelectOptionAsync(scriptName);
return scripts;
}
/// <summary>
/// Polls a <c>&lt;select&gt;</c>'s option labels until one matches, returning it (or null on
/// timeout). The instance and script lists are filled by a server round-trip after the previous
/// picker changes, so the options do not exist at first render.
/// </summary>
private static async Task<string?> WaitForOptionLabelAsync(
IPage page, ILocator select, Func<string, bool> match, int timeoutMs = 15_000)
{
var deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);
while (true)
{
foreach (var text in await select.Locator("option").AllTextContentsAsync())
{
var label = text.Trim();
if (label.Length > 0 && match(label))
{
return label;
}
}
if (DateTime.UtcNow >= deadline)
{
return null;
}
await page.WaitForTimeoutAsync(250);
}
}
/// <summary>Polls until <paramref name="locator"/> matches at least one element, or the timeout expires.</summary>
private static async Task<bool> WaitForCountAsync(IPage page, ILocator locator, int timeoutMs = 15_000)
{
var deadline = DateTime.UtcNow.AddMilliseconds(timeoutMs);
while (await locator.CountAsync() == 0)
{
if (DateTime.UtcNow >= deadline)
{
return false;
}
await page.WaitForTimeoutAsync(250);
}
return true;
}
private string MethodIdText => _flow.MethodId.ToString(CultureInfo.InvariantCulture);
private async Task SelectMethodAsync(IPage page)