Merge branch 'main' into web-attention
# Conflicts: # web/PARITY.md # web/src/app.js # web/styles.css
This commit is contained in:
@@ -0,0 +1,260 @@
|
||||
// Pure unit tests for the run-level action helpers (R11–R14): the pending human
|
||||
// decision extracted from a waiting step (with the pinned-graph fallback), the
|
||||
// option/target wording, the cancel/retry eligibility, the deliberate-confirm
|
||||
// draft rule and the verbatim Android copy. No server, no DOM.
|
||||
import { test } from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
|
||||
import {
|
||||
ACTION_FAILED_OK,
|
||||
ACTION_FAILED_TITLE,
|
||||
CANCEL_CONFIRM,
|
||||
CANCEL_DIALOG_MESSAGE,
|
||||
DECISION_ACTION,
|
||||
DECISION_CANCEL,
|
||||
DECISION_CARD_TITLE,
|
||||
DECISION_CONFIRM,
|
||||
DECISION_SENDING,
|
||||
DISMISS_KEEP,
|
||||
DecisionDraft,
|
||||
FEEDBACK_LABEL,
|
||||
RESTART_CONFIRM,
|
||||
RESTART_DIALOG_MESSAGE,
|
||||
RETRY_CONFIRM,
|
||||
RETRY_DIALOG_MESSAGE,
|
||||
canCancel,
|
||||
canRetry,
|
||||
cancelDialogTitle,
|
||||
decisionCardMeta,
|
||||
decisionSheetMeta,
|
||||
decisionSheetTitle,
|
||||
decisionTargetLabel,
|
||||
humanOptions,
|
||||
lastWaitingStep,
|
||||
optionTargetText,
|
||||
pendingDecision,
|
||||
retryDialogTitle,
|
||||
retryModes,
|
||||
retryRequestKey,
|
||||
restartDialogTitle,
|
||||
waitingOptions,
|
||||
waitingPrompt,
|
||||
} from "../src/actions.js";
|
||||
|
||||
/** A run with the fields pendingDecision reads; overridable per test. */
|
||||
function run(overrides = {}) {
|
||||
return {
|
||||
id: 42,
|
||||
title: "",
|
||||
name: "Pipe",
|
||||
status: "waiting",
|
||||
current_stage: "review",
|
||||
executing: false,
|
||||
steps: [],
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
test("lastWaitingStep finds the last waiting step, null when none is waiting", () => {
|
||||
const steps = [
|
||||
{ stage: "plan", status: "completed" },
|
||||
{ stage: "review", status: "waiting" },
|
||||
{ stage: "review", status: "waiting" },
|
||||
];
|
||||
assert.equal(lastWaitingStep(steps)?.stage, "review");
|
||||
assert.equal(lastWaitingStep(steps), steps[2]);
|
||||
assert.equal(lastWaitingStep([{ stage: "plan", status: "completed" }]), null);
|
||||
assert.equal(lastWaitingStep([]), null);
|
||||
assert.equal(lastWaitingStep(undefined), null);
|
||||
});
|
||||
|
||||
test("waitingPrompt returns the recorded instructions, else empty", () => {
|
||||
assert.equal(waitingPrompt({ prompt: "Choose a path." }), "Choose a path.");
|
||||
assert.equal(waitingPrompt({ prompt: 7 }), "");
|
||||
assert.equal(waitingPrompt({}), "");
|
||||
assert.equal(waitingPrompt(null), "");
|
||||
});
|
||||
|
||||
test("waitingOptions keeps string entries in recorded order, dropping malformed and blank", () => {
|
||||
assert.deepEqual(waitingOptions({ options: ["approve", "reject"] }), ["approve", "reject"]);
|
||||
assert.deepEqual(waitingOptions({ options: ["a", 3, null, " ", "b"] }), ["a", "b"]);
|
||||
assert.deepEqual(waitingOptions({ options: "approve" }), []);
|
||||
assert.deepEqual(waitingOptions({}), []);
|
||||
});
|
||||
|
||||
test("humanOptions are a stage's non-error edges, sorted", () => {
|
||||
assert.deepEqual(humanOptions({ publish: "#success", error: "#failure", revise: "review" }), [
|
||||
"publish",
|
||||
"revise",
|
||||
]);
|
||||
assert.deepEqual(humanOptions({}), []);
|
||||
assert.deepEqual(humanOptions(undefined), []);
|
||||
});
|
||||
|
||||
test("decisionTargetLabel resolves declared edges and is blank otherwise", () => {
|
||||
assert.equal(decisionTargetLabel("publish", "publish"), "publish");
|
||||
assert.equal(decisionTargetLabel("publish", "#"), "SUCCESS");
|
||||
assert.equal(decisionTargetLabel("error", "#"), "FAILURE");
|
||||
assert.equal(decisionTargetLabel("approve", ""), "");
|
||||
assert.equal(decisionTargetLabel("approve", null), "");
|
||||
assert.equal(decisionTargetLabel("approve", undefined), "");
|
||||
assert.equal(optionTargetText("publish"), "→ publish");
|
||||
assert.equal(optionTargetText(""), "");
|
||||
assert.equal(optionTargetText(null), "");
|
||||
});
|
||||
|
||||
test("pendingDecision returns null unless the run is waiting", () => {
|
||||
assert.equal(pendingDecision(null), null);
|
||||
assert.equal(pendingDecision(run({ status: "failed" })), null);
|
||||
assert.equal(pendingDecision(run({ status: "running", executing: true })), null);
|
||||
assert.equal(pendingDecision(run({ status: "succeeded" })), null);
|
||||
});
|
||||
|
||||
test("pendingDecision yields the recorded options in author order and the verbatim prompt", () => {
|
||||
const decision = pendingDecision(
|
||||
run({
|
||||
title: "Review the plan",
|
||||
current_stage: "review",
|
||||
steps: [
|
||||
{ stage: "plan", status: "completed" },
|
||||
{
|
||||
stage: "review",
|
||||
status: "waiting",
|
||||
output: { prompt: "Ship it or revise it?", options: ["revise", "approve"] },
|
||||
},
|
||||
],
|
||||
graph: {
|
||||
stages: [
|
||||
{
|
||||
key: "review",
|
||||
prompt: "graph prompt",
|
||||
edges: { approve: "publish", revise: "review", error: "#failure" },
|
||||
},
|
||||
],
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert.deepEqual(decision.options.map((o) => o.key), ["revise", "approve"]);
|
||||
assert.equal(decision.instructions, "Ship it or revise it?");
|
||||
assert.equal(decision.stageKey, "review");
|
||||
assert.equal(decision.runId, 42);
|
||||
assert.equal(decision.runLabel, "Review the plan");
|
||||
assert.deepEqual(decision.options, [
|
||||
{ key: "revise", target: "review" },
|
||||
{ key: "approve", target: "publish" },
|
||||
]);
|
||||
});
|
||||
|
||||
test("pendingDecision falls back to the pinned graph's sorted non-error edges", () => {
|
||||
const decision = pendingDecision(
|
||||
run({
|
||||
current_stage: "review",
|
||||
steps: [{ stage: "", status: "waiting", output: {} }],
|
||||
graph: {
|
||||
stages: [
|
||||
{ key: "review", prompt: "Graph instructions.", edges: { publish: "#success", error: "#failure", revise: "review" } },
|
||||
],
|
||||
},
|
||||
}),
|
||||
);
|
||||
assert.deepEqual(decision.options.map((o) => o.key), ["publish", "revise"]);
|
||||
assert.equal(decision.instructions, "Graph instructions.");
|
||||
assert.equal(decision.stageKey, "review");
|
||||
});
|
||||
|
||||
test("pendingDecision keeps a recorded option whose edge is not declared, with a blank target", () => {
|
||||
const decision = pendingDecision(
|
||||
run({
|
||||
steps: [{ stage: "review", status: "waiting", output: { options: ["approve", "legacy"] } }],
|
||||
graph: { stages: [{ key: "review", edges: { approve: "publish" } }] },
|
||||
}),
|
||||
);
|
||||
assert.deepEqual(decision.options, [
|
||||
{ key: "approve", target: "publish" },
|
||||
{ key: "legacy", target: "" },
|
||||
]);
|
||||
});
|
||||
|
||||
test("pendingDecision is null when no option can be derived", () => {
|
||||
assert.equal(
|
||||
pendingDecision(run({ steps: [{ stage: "review", status: "waiting", output: {} }], graph: { stages: [] } })),
|
||||
null,
|
||||
);
|
||||
});
|
||||
|
||||
test("DecisionDraft: a blank selection cannot submit and selecting never sends", () => {
|
||||
const blank = new DecisionDraft();
|
||||
assert.equal(blank.canSubmit, false);
|
||||
const selected = blank.select("approve");
|
||||
assert.equal(selected.canSubmit, true);
|
||||
assert.equal(selected.selected, "approve");
|
||||
// Selecting is pure: the original draft is untouched and no side effect fires.
|
||||
assert.equal(blank.selected, null);
|
||||
assert.equal(blank.canSubmit, false);
|
||||
// Feedback is carried verbatim and never changes the submit rule.
|
||||
const withFeedback = selected.withFeedback(" looks good ");
|
||||
assert.equal(withFeedback.feedback, " looks good ");
|
||||
assert.equal(withFeedback.canSubmit, true);
|
||||
assert.equal(new DecisionDraft(" ").canSubmit, false);
|
||||
});
|
||||
|
||||
test("canCancel is true only while executing; canRetry only for a failed, idle run", () => {
|
||||
assert.equal(canCancel(run({ executing: true })), true);
|
||||
assert.equal(canCancel(run({ executing: false })), false);
|
||||
assert.equal(canCancel(null), false);
|
||||
|
||||
assert.equal(canRetry(run({ status: "failed", executing: false })), true);
|
||||
assert.equal(canRetry(run({ status: "failed", executing: true })), false);
|
||||
assert.equal(canRetry(run({ status: "succeeded", executing: false })), false);
|
||||
assert.equal(canRetry(run({ status: "waiting", executing: false })), false);
|
||||
assert.equal(canRetry(null), false);
|
||||
assert.equal(canRetry(undefined), false);
|
||||
});
|
||||
|
||||
test("retryModes offers resume and restart for a retryable run, nothing otherwise", () => {
|
||||
assert.deepEqual(retryModes(run({ status: "failed" })), ["resume", "restart"]);
|
||||
assert.deepEqual(retryModes(run({ status: "succeeded" })), []);
|
||||
assert.deepEqual(retryModes(run({ status: "failed", executing: true })), []);
|
||||
});
|
||||
|
||||
test("retryRequestKey is unique, prefixed and within the server's 128-character bound", () => {
|
||||
const key = retryRequestKey(440, 1_700_000_000_000, () => 0.5);
|
||||
assert.match(key, /^web-retry-440-1700000000000-/);
|
||||
assert.ok(key.length <= 128, `key too long: ${key.length}`);
|
||||
assert.notEqual(
|
||||
retryRequestKey(440, 1, () => 0.1),
|
||||
retryRequestKey(440, 1, () => 0.2),
|
||||
);
|
||||
});
|
||||
|
||||
test("the decision/action copy matches the Android sources verbatim", () => {
|
||||
assert.equal(DECISION_CARD_TITLE, "Waiting for your decision");
|
||||
assert.equal(DECISION_ACTION, "Decide");
|
||||
assert.equal(FEEDBACK_LABEL, "Feedback (optional)");
|
||||
assert.equal(DECISION_CANCEL, "Cancel");
|
||||
assert.equal(DECISION_CONFIRM, "Confirm decision");
|
||||
assert.equal(DECISION_SENDING, "Sending…");
|
||||
assert.equal(cancelDialogTitle(440), "Cancel run 440?");
|
||||
assert.equal(CANCEL_DIALOG_MESSAGE, "This asks the server to stop the active run.");
|
||||
assert.equal(CANCEL_CONFIRM, "Cancel run");
|
||||
assert.equal(retryDialogTitle(440), "Retry run 440?");
|
||||
assert.equal(
|
||||
RETRY_DIALOG_MESSAGE,
|
||||
"Only failed runs can be retried. The server starts a new run from the same input.",
|
||||
);
|
||||
assert.equal(RETRY_CONFIRM, "Retry");
|
||||
assert.equal(DISMISS_KEEP, "Keep");
|
||||
assert.equal(RESTART_CONFIRM, "Restart from start");
|
||||
assert.ok(RESTART_DIALOG_MESSAGE.includes("replays the whole pipeline"));
|
||||
assert.ok(RESTART_DIALOG_MESSAGE.includes("instead of resuming the failed stage"));
|
||||
assert.equal(restartDialogTitle(440), "Restart run 440?");
|
||||
assert.equal(ACTION_FAILED_TITLE, "Action failed");
|
||||
assert.equal(ACTION_FAILED_OK, "OK");
|
||||
});
|
||||
|
||||
test("the decision card and sheet meta/title render the app's exact shapes", () => {
|
||||
const decision = { runId: 12, runLabel: "Ship it", stageKey: "review" };
|
||||
assert.equal(decisionCardMeta(decision), "review · run 12 · Ship it");
|
||||
assert.equal(decisionSheetTitle(decision.stageKey), "Decide review");
|
||||
assert.equal(decisionSheetMeta(decision), "run 12 · Ship it");
|
||||
});
|
||||
@@ -104,3 +104,130 @@ test("validate throws when the reply has no graph", async () => {
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "validated" });
|
||||
await assert.rejects(() => repo.validate("empty"), ProtocolError);
|
||||
});
|
||||
|
||||
test("search sends exactly {type:'search',search:{query,kind:'',limit:0}} and returns search_results", async () => {
|
||||
const { repo, ws } = connected();
|
||||
const payload = { query: "release", results: [{ kind: "run" }], cap: 50, scanned_steps: 3 };
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "search_results", search_results: payload });
|
||||
|
||||
const reply = await repo.search("release");
|
||||
assert.deepEqual(lastFrame(ws), {
|
||||
type: "search",
|
||||
search: { query: "release", kind: "", limit: 0 },
|
||||
});
|
||||
assert.deepEqual(reply, payload);
|
||||
});
|
||||
|
||||
test("search sends the selected kind verbatim and never a limit above the cap", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "search_results", search_results: { results: [] } });
|
||||
|
||||
await repo.search("release", "run");
|
||||
const { search } = lastFrame(ws);
|
||||
assert.deepEqual(search, { query: "release", kind: "run", limit: 0 });
|
||||
// limit 0 asks for the server's own default (SearchDefaultLimit 50); the client
|
||||
// never asks for more than SearchMaxLimit (200), let alone sends a larger value.
|
||||
assert.ok(search.limit <= 200);
|
||||
});
|
||||
|
||||
test("search returns null when an older server replies without search_results", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "pong" });
|
||||
assert.equal(await repo.search("release"), null);
|
||||
});
|
||||
|
||||
test("search surfaces an explicit server error with the server's own text", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "error", error: "unknown command: search" });
|
||||
await assert.rejects(() => repo.search("release"), {
|
||||
name: "ProtocolError",
|
||||
message: "unknown command: search",
|
||||
});
|
||||
});
|
||||
/** The run detail a run.action reply carries in these tests. */
|
||||
const RUN_DETAIL = { id: 440, status: "failed" };
|
||||
|
||||
test("decideRun sends exactly {type:'decide_run',run_id,option,feedback} and returns the run detail", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "run", run_detail: RUN_DETAIL });
|
||||
|
||||
const detail = await repo.decideRun(440, { stage: "review", option: "approve", feedback: " yes " });
|
||||
assert.deepEqual(lastFrame(ws), {
|
||||
type: "decide_run",
|
||||
run_id: 440,
|
||||
stage: "review",
|
||||
option: "approve",
|
||||
feedback: "yes",
|
||||
});
|
||||
assert.deepEqual(detail, RUN_DETAIL);
|
||||
});
|
||||
|
||||
test("decideRun omits a blank stage and blank feedback", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "run", run_detail: RUN_DETAIL });
|
||||
|
||||
await repo.decideRun(12, { stage: " ", option: "publish", feedback: " " });
|
||||
assert.deepEqual(lastFrame(ws), { type: "decide_run", run_id: 12, option: "publish" });
|
||||
});
|
||||
|
||||
test("cancelRun sends exactly {type:'cancel_run',run_id} and returns the run detail", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "run", run_detail: RUN_DETAIL });
|
||||
|
||||
const detail = await repo.cancelRun(440);
|
||||
assert.deepEqual(lastFrame(ws), { type: "cancel_run", run_id: 440 });
|
||||
assert.deepEqual(detail, RUN_DETAIL);
|
||||
});
|
||||
|
||||
test("retryRun always sends request_key and omits retry_mode for the default resume", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "run_started", run_detail: RUN_DETAIL });
|
||||
|
||||
await repo.retryRun(440, { requestKey: "key-1" });
|
||||
assert.deepEqual(lastFrame(ws), { type: "retry_run", run_id: 440, request_key: "key-1" });
|
||||
});
|
||||
|
||||
test("retryRun sends retry_mode only for an explicit restart", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "run_started", run_detail: RUN_DETAIL });
|
||||
|
||||
await repo.retryRun(440, { mode: "restart", requestKey: "key-2" });
|
||||
assert.deepEqual(lastFrame(ws), {
|
||||
type: "retry_run",
|
||||
run_id: 440,
|
||||
request_key: "key-2",
|
||||
retry_mode: "restart",
|
||||
});
|
||||
});
|
||||
|
||||
test("setRunTitle sends exactly {type:'set_run_title',run_id,title} and returns the run detail", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "run", run_detail: RUN_DETAIL });
|
||||
|
||||
const detail = await repo.setRunTitle(440, "New title");
|
||||
assert.deepEqual(lastFrame(ws), { type: "set_run_title", run_id: 440, title: "New title" });
|
||||
assert.deepEqual(detail, RUN_DETAIL);
|
||||
});
|
||||
|
||||
test("each run action rejects a server error envelope instead of returning a detail", async () => {
|
||||
const calls = [
|
||||
(repo) => () => repo.decideRun(440, { option: "approve" }),
|
||||
(repo) => () => repo.cancelRun(440),
|
||||
(repo) => () => repo.retryRun(440, { requestKey: "key-3" }),
|
||||
(repo) => () => repo.setRunTitle(440, ""),
|
||||
];
|
||||
for (const makeCall of calls) {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "error", error: "a title with usable text is required" });
|
||||
await assert.rejects(makeCall(repo), {
|
||||
name: "ProtocolError",
|
||||
message: "a title with usable text is required",
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
test("a run action throws when the reply has no run detail", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "run" });
|
||||
await assert.rejects(() => repo.cancelRun(7), ProtocolError);
|
||||
});
|
||||
|
||||
@@ -0,0 +1,519 @@
|
||||
// Pure omni-search tests: the per-kind row text, the in-hand narrowing and
|
||||
// ordering, the routing target/tab resolution, the debounce/stale-token sequencer
|
||||
// and the failure copy. Everything here is DOM-free and needs no server, mirroring
|
||||
// android/.../ui/OmniSearchResultsTest.kt and OmniSearchTest.kt.
|
||||
import { test } from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
|
||||
import {
|
||||
DEFAULT_SEARCH_KIND,
|
||||
DEFAULT_SEARCH_SORT,
|
||||
SEARCH_KINDS,
|
||||
SEARCH_SORTS,
|
||||
SEARCH_UNSUPPORTED,
|
||||
SearchSequencer,
|
||||
filterSearchResults,
|
||||
resolveRunTarget,
|
||||
searchControlsSummary,
|
||||
searchFailureText,
|
||||
searchFieldTab,
|
||||
searchKindLabel,
|
||||
searchPanelBody,
|
||||
searchPanelEmptyMessage,
|
||||
searchPanelProgress,
|
||||
searchQuerySendable,
|
||||
searchResultKindLabel,
|
||||
searchRow,
|
||||
searchTarget,
|
||||
snippetSpans,
|
||||
sortSearchResults,
|
||||
} from "../src/search.js";
|
||||
|
||||
const UTC = { timeZone: "UTC" };
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Fixtures — the same shapes the Android test uses
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
function pipelineHit(overrides = {}) {
|
||||
return {
|
||||
kind: "pipeline",
|
||||
target: "pipeline:7",
|
||||
pipeline: { id: 7, name: "release", version: 3, stages: 4, ...overrides },
|
||||
};
|
||||
}
|
||||
|
||||
function versionHit(overrides = {}) {
|
||||
return {
|
||||
kind: "version",
|
||||
target: "pipeline:9:v2",
|
||||
version: {
|
||||
pipeline_id: 9,
|
||||
version: 2,
|
||||
content_hash: "abc",
|
||||
created_at: "2026-01-01T00:00:00Z",
|
||||
...overrides,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function runHit(overrides = {}) {
|
||||
return {
|
||||
kind: "run",
|
||||
target: "run:11",
|
||||
run: {
|
||||
id: 11,
|
||||
pipeline_name: "release",
|
||||
status: "succeeded",
|
||||
created_at: "2026-01-01T00:00:00Z",
|
||||
...overrides,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function stepHit(overrides = {}) {
|
||||
return {
|
||||
kind: "step",
|
||||
target: "run:11:4",
|
||||
step: { run_id: 11, sequence: 4, stage: "builder", visit: 2, outcome: "success", ...overrides },
|
||||
};
|
||||
}
|
||||
|
||||
function fieldHit(overrides = {}, matchedField = "output") {
|
||||
return {
|
||||
kind: "field",
|
||||
target: "run:11:4:output",
|
||||
matched_field: matchedField,
|
||||
field: {
|
||||
run_id: 11,
|
||||
sequence: 4,
|
||||
field: "output",
|
||||
snippet: "the release is ready",
|
||||
...overrides,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function artifactHit(overrides = {}) {
|
||||
return {
|
||||
kind: "artifact",
|
||||
target: "/artifacts/11/4/notes.md",
|
||||
artifact: {
|
||||
run_id: 11,
|
||||
sequence: 4,
|
||||
name: "notes.md",
|
||||
content_type: "text/markdown",
|
||||
size_bytes: 2048,
|
||||
url: "/artifacts/11/4/notes.md",
|
||||
...overrides,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Kind/sort vocabulary
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("the kind options are exactly the server vocabulary, All kinds first", () => {
|
||||
assert.deepEqual(
|
||||
SEARCH_KINDS.map((option) => [option.value, option.label]),
|
||||
[
|
||||
["", "All kinds"],
|
||||
["pipeline", "Pipelines"],
|
||||
["run", "Runs"],
|
||||
["step", "Steps"],
|
||||
["field", "Fields"],
|
||||
["artifact", "Artifacts"],
|
||||
["version", "Versions"],
|
||||
],
|
||||
);
|
||||
assert.equal(DEFAULT_SEARCH_KIND, "");
|
||||
assert.deepEqual(
|
||||
SEARCH_SORTS.map((option) => [option.value, option.label]),
|
||||
[
|
||||
["relevance", "Relevance"],
|
||||
["newest", "Newest first"],
|
||||
["name", "Name"],
|
||||
],
|
||||
);
|
||||
assert.equal(DEFAULT_SEARCH_SORT, "relevance");
|
||||
// A stale/unknown value falls back rather than inventing an option.
|
||||
assert.equal(searchKindLabel("prompts"), "All kinds");
|
||||
assert.equal(searchKindLabel("run"), "Runs");
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Row text
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("pipeline rows carry the name (or the id fallback) and the version/stage line", () => {
|
||||
assert.deepEqual(searchRow(pipelineHit(), "release", UTC), {
|
||||
title: "release",
|
||||
secondary: "pipeline 7 · v3 · 4 stages",
|
||||
snippet: null,
|
||||
});
|
||||
const blank = searchRow(pipelineHit({ name: " " }), "release", UTC);
|
||||
assert.equal(blank.title, "pipeline 7");
|
||||
// The stage count keeps the app's singular form.
|
||||
assert.equal(searchRow(pipelineHit({ stages: 1 }), "", UTC).secondary, "pipeline 7 · v3 · 1 stage");
|
||||
});
|
||||
|
||||
test("version rows name the pipeline/version and omit blank content parts", () => {
|
||||
assert.deepEqual(searchRow(versionHit(), "release", UTC), {
|
||||
title: "pipeline 9 · v2",
|
||||
secondary: "content abc · 1 Jan 00:00",
|
||||
snippet: null,
|
||||
});
|
||||
const blankHash = searchRow(versionHit({ content_hash: " " }), "release", UTC);
|
||||
assert.equal(blankHash.secondary, "1 Jan 00:00");
|
||||
});
|
||||
|
||||
test("run rows join the non-blank status, workspace and timestamp", () => {
|
||||
assert.deepEqual(searchRow(runHit(), "release", UTC), {
|
||||
title: "run #11 · release",
|
||||
secondary: "succeeded · 1 Jan 00:00",
|
||||
snippet: null,
|
||||
});
|
||||
const withWorkspace = searchRow(runHit({ workspace: "/tmp/ws" }), "", UTC);
|
||||
assert.equal(withWorkspace.secondary, "succeeded · /tmp/ws · 1 Jan 00:00");
|
||||
const unnamed = searchRow(runHit({ pipeline_name: "" }), "", UTC);
|
||||
assert.equal(unnamed.title, "run #11");
|
||||
});
|
||||
|
||||
test("step rows carry outcome, route and the first non-blank diagnostic line", () => {
|
||||
const withTarget = searchRow(stepHit({ target: "#success" }), "", UTC);
|
||||
assert.deepEqual(withTarget, {
|
||||
title: "run #11 · builder visit 2",
|
||||
secondary: "success · → #success",
|
||||
snippet: null,
|
||||
});
|
||||
const withDiagnostic = searchRow(
|
||||
stepHit({ diagnostic: "\n the first line\nsecond line" }),
|
||||
"",
|
||||
UTC,
|
||||
);
|
||||
assert.equal(withDiagnostic.secondary, "success · the first line");
|
||||
// Every part blank: the sequence is the honest fallback.
|
||||
const allBlank = searchRow(stepHit({ outcome: "", target: "", diagnostic: "" }), "", UTC);
|
||||
assert.equal(allBlank.secondary, "step 4");
|
||||
// A blank stage falls back to the word "step".
|
||||
assert.equal(searchRow(stepHit({ stage: "" }), "", UTC).title, "run #11 · step visit 2");
|
||||
});
|
||||
|
||||
test("field rows carry the server snippet with the matched query span", () => {
|
||||
const row = searchRow(fieldHit(), "release", UTC);
|
||||
assert.equal(row.title, "run #11 · step 4 · output");
|
||||
assert.equal(row.secondary, "the release is ready");
|
||||
assert.deepEqual(row.snippet, [
|
||||
{ text: "the ", matched: false },
|
||||
{ text: "release", matched: true },
|
||||
{ text: " is ready", matched: false },
|
||||
]);
|
||||
// No occurrence: one unmatched run, never dropped text.
|
||||
assert.deepEqual(searchRow(fieldHit(), "absent", UTC).snippet, [
|
||||
{ text: "the release is ready", matched: false },
|
||||
]);
|
||||
// A blank field falls back to the word "field".
|
||||
assert.equal(searchRow(fieldHit({ field: " " }), "release", UTC).title, "run #11 · step 4 · field");
|
||||
});
|
||||
|
||||
test("artifact rows join name, run, step, content type and human size", () => {
|
||||
assert.deepEqual(searchRow(artifactHit(), "notes", UTC), {
|
||||
title: "notes.md",
|
||||
secondary: "run #11 · step 4 · text/markdown · 2.0 KiB",
|
||||
snippet: null,
|
||||
});
|
||||
assert.equal(searchRow(artifactHit({ name: "", content_type: "" }), "", UTC).title, "artifact");
|
||||
});
|
||||
|
||||
test("an unknown row is read-only and never dropped", () => {
|
||||
const named = searchRow({ kind: "future_kind", target: "widget:7" }, "x", UTC);
|
||||
assert.deepEqual(named, {
|
||||
title: "widget:7",
|
||||
secondary: 'kind "future_kind" · read-only',
|
||||
snippet: null,
|
||||
});
|
||||
const anonymous = searchRow({ kind: "", target: "" }, "x", UTC);
|
||||
assert.deepEqual(anonymous, { title: "Unrecognised result", secondary: "read-only", snippet: null });
|
||||
});
|
||||
|
||||
test("snippetSpans splits only the first occurrence, case-insensitively", () => {
|
||||
assert.deepEqual(snippetSpans("the Release notes mention it", "release"), [
|
||||
{ text: "the ", matched: false },
|
||||
{ text: "Release", matched: true },
|
||||
{ text: " notes mention it", matched: false },
|
||||
]);
|
||||
// The FIRST occurrence is the emphasised one; a later one is left in the tail.
|
||||
assert.deepEqual(snippetSpans("aXbXc", "x"), [
|
||||
{ text: "a", matched: false },
|
||||
{ text: "X", matched: true },
|
||||
{ text: "bXc", matched: false },
|
||||
]);
|
||||
// A match at the very start/end needs no empty leading/trailing run.
|
||||
assert.deepEqual(snippetSpans("release", "release"), [{ text: "release", matched: true }]);
|
||||
assert.deepEqual(snippetSpans("nothing here", "release"), [{ text: "nothing here", matched: false }]);
|
||||
assert.deepEqual(snippetSpans("nothing here", " "), [{ text: "nothing here", matched: false }]);
|
||||
assert.deepEqual(snippetSpans("", "release"), []);
|
||||
});
|
||||
|
||||
test("searchResultKindLabel names the kind in words, artifact by its content type", () => {
|
||||
assert.equal(searchResultKindLabel(pipelineHit()), "Pipeline");
|
||||
assert.equal(searchResultKindLabel(versionHit()), "Pipeline version");
|
||||
assert.equal(searchResultKindLabel(runHit()), "Run");
|
||||
assert.equal(searchResultKindLabel(stepHit()), "Step");
|
||||
assert.equal(searchResultKindLabel(fieldHit()), "Field");
|
||||
assert.equal(searchResultKindLabel(artifactHit({ content_type: "text/markdown" })), "Document artifact");
|
||||
assert.equal(
|
||||
searchResultKindLabel(artifactHit({ name: "shot.png", content_type: "image/png" })),
|
||||
"Image artifact",
|
||||
);
|
||||
assert.equal(searchResultKindLabel({ kind: "future_kind", target: "x" }), "Unrecognised result");
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Kind filtering + in-hand sorting
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("the kind filter narrows the list, and All kinds keeps it whole", () => {
|
||||
const mixed = [pipelineHit(), runHit(), stepHit(), fieldHit(), artifactHit(), versionHit()];
|
||||
assert.deepEqual(filterSearchResults(mixed, ""), mixed);
|
||||
assert.deepEqual(filterSearchResults(mixed, "run"), [mixed[1]]);
|
||||
assert.deepEqual(filterSearchResults(mixed, "version"), [mixed[5]]);
|
||||
assert.deepEqual(filterSearchResults(mixed, "nothing"), []);
|
||||
});
|
||||
|
||||
function hitWithRecency(kind, recency) {
|
||||
return { kind, target: `${kind}:1`, recency };
|
||||
}
|
||||
|
||||
test("Relevance keeps the server's ranking untouched", () => {
|
||||
const ordered = [
|
||||
hitWithRecency("run", "2026-01-01T00:00:00Z"),
|
||||
hitWithRecency("pipeline", "2026-03-01T00:00:00Z"),
|
||||
];
|
||||
assert.deepEqual(sortSearchResults(ordered, "relevance"), ordered);
|
||||
assert.deepEqual(sortSearchResults(ordered, "stale-sort-value"), ordered);
|
||||
});
|
||||
|
||||
test("Newest first orders by parsed recency, descending", () => {
|
||||
const older = hitWithRecency("run", "2026-01-01T00:00:00Z");
|
||||
const newer = hitWithRecency("pipeline", "2026-03-01T00:00:00Z");
|
||||
assert.deepEqual(sortSearchResults([older, newer], "newest"), [newer, older]);
|
||||
});
|
||||
|
||||
test("Newest first keeps ties stable, and puts a missing/invalid recency last", () => {
|
||||
const first = hitWithRecency("run", "2026-01-01T00:00:00Z");
|
||||
const second = hitWithRecency("pipeline", "2026-01-01T00:00:00Z");
|
||||
assert.deepEqual(sortSearchResults([first, second], "newest"), [first, second]);
|
||||
|
||||
const dated = hitWithRecency("run", "2026-01-01T00:00:00Z");
|
||||
const undated = hitWithRecency("run", null);
|
||||
const invalid = hitWithRecency("run", "not-a-date");
|
||||
assert.deepEqual(sortSearchResults([undated, invalid, dated], "newest"), [dated, undated, invalid]);
|
||||
});
|
||||
|
||||
test("Name orders by the displayed title, case-insensitively, with ties stable", () => {
|
||||
const alpha1 = pipelineHit({ id: 1, name: "alpha" });
|
||||
const beta = pipelineHit({ id: 2, name: "Beta" });
|
||||
const alpha2 = pipelineHit({ id: 3, name: "ALPHA" });
|
||||
assert.deepEqual(sortSearchResults([beta, alpha1, alpha2], "name"), [alpha1, alpha2, beta]);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Summary + empty state
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("the controls summary is exactly {Kind} · {Sort}, with no (in hand) suffix", () => {
|
||||
assert.equal(searchControlsSummary("", "relevance"), "All kinds · Relevance");
|
||||
assert.equal(searchControlsSummary("run", "newest"), "Runs · Newest first");
|
||||
assert.equal(searchControlsSummary("field", "name"), "Fields · Name");
|
||||
assert.equal(searchControlsSummary("bogus", "bogus"), "All kinds · Relevance");
|
||||
});
|
||||
|
||||
test("the empty state names the query and the active filter, or nothing", () => {
|
||||
const empty = { query: "release", loading: false, error: "" };
|
||||
assert.equal(searchPanelEmptyMessage(empty, [], ""), 'No matches for "release".');
|
||||
assert.equal(searchPanelEmptyMessage(empty, [], "run"), 'No runs match "release".');
|
||||
assert.equal(searchPanelEmptyMessage(empty, [], "version"), 'No versions match "release".');
|
||||
// Rows shown, still loading, a blank query or an error: no message at all.
|
||||
assert.equal(searchPanelEmptyMessage(empty, [runHit()], ""), null);
|
||||
assert.equal(searchPanelEmptyMessage({ ...empty, loading: true }, [], ""), null);
|
||||
assert.equal(searchPanelEmptyMessage({ query: " " }, [], ""), null);
|
||||
assert.equal(searchPanelEmptyMessage({ ...empty, error: "boom" }, [], ""), null);
|
||||
});
|
||||
|
||||
test("a blank or whitespace query is never sent to the server", () => {
|
||||
assert.equal(searchQuerySendable(""), false);
|
||||
assert.equal(searchQuerySendable(" "), false);
|
||||
assert.equal(searchQuerySendable(undefined), false);
|
||||
assert.equal(searchQuerySendable("plan"), true);
|
||||
assert.equal(searchQuerySendable(" plan "), true);
|
||||
});
|
||||
|
||||
test("the refresh bar shows only when results are retained while a newer query loads", () => {
|
||||
assert.equal(searchPanelProgress({ loading: true, results: [runHit()] }), true);
|
||||
assert.equal(searchPanelProgress({ loading: true, results: [] }), false);
|
||||
assert.equal(searchPanelProgress({ loading: false, results: [runHit()] }), false);
|
||||
assert.equal(searchPanelProgress({}), false);
|
||||
});
|
||||
|
||||
test("the panel body reports an error first, then rows, Searching…, the empty line or nothing", () => {
|
||||
const loading = { query: "plan", loading: true, results: [], error: "" };
|
||||
// The first load, nothing yet: the searching row.
|
||||
assert.deepEqual(searchPanelBody(loading, [], ""), { kind: "searching", message: "" });
|
||||
// A retained result set is still shown while a refresh is in flight.
|
||||
const refresh = { query: "plan", loading: true, results: [runHit()], error: "" };
|
||||
assert.deepEqual(searchPanelBody(refresh, [runHit()], ""), { kind: "results", message: "" });
|
||||
// An error takes precedence over results.
|
||||
assert.deepEqual(searchPanelBody({ ...refresh, error: "boom" }, [runHit()], ""), {
|
||||
kind: "error",
|
||||
message: "boom",
|
||||
});
|
||||
// A landed, empty reply: the empty-state sentence, naming the kind when set.
|
||||
const landed = { query: "plan", loading: false, results: [], error: "" };
|
||||
assert.deepEqual(searchPanelBody(landed, [], ""), { kind: "empty", message: 'No matches for "plan".' });
|
||||
assert.deepEqual(searchPanelBody(landed, [], "run"), {
|
||||
kind: "empty",
|
||||
message: 'No runs match "plan".',
|
||||
});
|
||||
// A blank query, or a filter that emptied a list while a refresh is in flight:
|
||||
// nothing at all.
|
||||
assert.deepEqual(searchPanelBody({ query: " ", loading: false }, [], ""), { kind: "idle", message: "" });
|
||||
assert.deepEqual(searchPanelBody(refresh, [], "run"), { kind: "idle", message: "" });
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Routing target + tab resolution
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("pipeline and version hits open the pipeline detail (version 0 = latest)", () => {
|
||||
assert.deepEqual(searchTarget(pipelineHit()), { kind: "pipeline", pipelineId: 7, version: 3 });
|
||||
assert.deepEqual(searchTarget(pipelineHit({ version: 0 })), {
|
||||
kind: "pipeline",
|
||||
pipelineId: 7,
|
||||
version: 0,
|
||||
});
|
||||
assert.deepEqual(searchTarget(versionHit()), { kind: "pipeline", pipelineId: 9, version: 2 });
|
||||
});
|
||||
|
||||
test("run, step, field and artifact hits open runs", () => {
|
||||
assert.deepEqual(searchTarget(runHit()), { kind: "run", runId: 11, sequence: 0, matchedField: "" });
|
||||
assert.deepEqual(searchTarget(stepHit()), { kind: "run", runId: 11, sequence: 4, matchedField: "" });
|
||||
assert.deepEqual(searchTarget(fieldHit({}, "output")), {
|
||||
kind: "run",
|
||||
runId: 11,
|
||||
sequence: 4,
|
||||
matchedField: "output",
|
||||
});
|
||||
assert.deepEqual(searchTarget(artifactHit()), { kind: "run", runId: 11, sequence: 4, matchedField: "" });
|
||||
});
|
||||
|
||||
test("an unknown result has no target and is never navigated", () => {
|
||||
assert.equal(searchTarget({ kind: "future_kind", target: "widget:7" }), null);
|
||||
});
|
||||
|
||||
test("the matched field resolves the run-detail tab, everything else Summary", () => {
|
||||
assert.equal(searchFieldTab("input"), "input");
|
||||
assert.equal(searchFieldTab("output"), "output");
|
||||
assert.equal(searchFieldTab("transcript"), "summary");
|
||||
assert.equal(searchFieldTab("evidence"), "summary");
|
||||
assert.equal(searchFieldTab("other"), "summary");
|
||||
assert.equal(searchFieldTab(""), "summary");
|
||||
assert.equal(searchFieldTab(undefined), "summary");
|
||||
});
|
||||
|
||||
const STEPS = [
|
||||
{ sequence: 1, stage: "planner" },
|
||||
{ sequence: 2, stage: "builder" },
|
||||
{ sequence: 3, stage: "builder" },
|
||||
];
|
||||
|
||||
test("a text-match target resolves to the run-detail tab holding it", () => {
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, matchedField: "input" }, 11, STEPS), {
|
||||
tab: "input",
|
||||
});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, matchedField: "output" }, 11, STEPS), {
|
||||
tab: "output",
|
||||
});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, matchedField: "transcript" }, 11, STEPS), {
|
||||
tab: "summary",
|
||||
});
|
||||
});
|
||||
|
||||
test("a step/artifact target resolves the visit index within its stage, not the visit number", () => {
|
||||
// "builder" recorded two visits; sequence 3 is its second, index 1.
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 3 }, 11, STEPS), {
|
||||
stageKey: "builder",
|
||||
visitIndex: 1,
|
||||
});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 2 }, 11, STEPS), {
|
||||
stageKey: "builder",
|
||||
visitIndex: 0,
|
||||
});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 1 }, 11, STEPS), {
|
||||
stageKey: "planner",
|
||||
visitIndex: 0,
|
||||
});
|
||||
});
|
||||
|
||||
test("a bare run target or a visit that cannot be located falls back to the run detail", () => {
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 0 }, 11, STEPS), {});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 99 }, 11, STEPS), {});
|
||||
assert.deepEqual(resolveRunTarget(null, 11, STEPS), {});
|
||||
assert.deepEqual(resolveRunTarget({ kind: "run", runId: 11, sequence: 1 }, 11, []), {});
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Debounce + stale-reply sequencing
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("a burst of keystrokes collapses to one request for the last query", () => {
|
||||
const sequencer = new SearchSequencer();
|
||||
const first = sequencer.edit("r");
|
||||
const second = sequencer.edit("re");
|
||||
const third = sequencer.edit("rel");
|
||||
assert.equal(sequencer.begin(first), null);
|
||||
assert.equal(sequencer.begin(second), null);
|
||||
assert.deepEqual(sequencer.begin(third), { token: third.token, query: "rel" });
|
||||
});
|
||||
|
||||
test("only the newest recorded edit is accepted, so a stale reply can never land", () => {
|
||||
const sequencer = new SearchSequencer();
|
||||
const sentOld = sequencer.begin(sequencer.edit("old"));
|
||||
// A keystroke while the old reply is in flight invalidates it immediately.
|
||||
const next = sequencer.edit("new");
|
||||
assert.equal(sequencer.accepts(sentOld.token), false);
|
||||
const sentNew = sequencer.begin(next);
|
||||
assert.equal(sequencer.accepts(sentNew.token), true);
|
||||
// A token that was never recorded is not accepted either.
|
||||
assert.equal(sequencer.accepts(sentNew.token + 100), false);
|
||||
// Closing records an empty edit, which invalidates the in-flight reply too.
|
||||
sequencer.edit("");
|
||||
assert.equal(sequencer.accepts(sentNew.token), false);
|
||||
});
|
||||
|
||||
test("Enter sends the current query at once, skipping the debounce", () => {
|
||||
const sequencer = new SearchSequencer();
|
||||
sequencer.edit("release");
|
||||
const sent = sequencer.begin(sequencer.edit("release"));
|
||||
assert.deepEqual(sent, { token: sent.token, query: "release" });
|
||||
assert.equal(sequencer.accepts(sent.token), true);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Failure copy
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
test("a missing payload or an unknown command reports the unsupported sentence", () => {
|
||||
assert.equal(searchFailureText(null), SEARCH_UNSUPPORTED);
|
||||
assert.equal(searchFailureText(undefined), SEARCH_UNSUPPORTED);
|
||||
assert.equal(searchFailureText(new Error("")), SEARCH_UNSUPPORTED);
|
||||
assert.equal(searchFailureText(new Error("unknown command: search")), SEARCH_UNSUPPORTED);
|
||||
assert.equal(searchFailureText(new Error("unsupported command")), SEARCH_UNSUPPORTED);
|
||||
});
|
||||
|
||||
test("any other failure carries the server's own text", () => {
|
||||
assert.equal(searchFailureText(new Error("boom")), "boom");
|
||||
assert.equal(searchFailureText(new Error("request timed out after 30000ms")), "request timed out after 30000ms");
|
||||
assert.equal(searchFailureText("plain string"), "plain string");
|
||||
});
|
||||
@@ -90,6 +90,17 @@ async function openRunDetail(runId) {
|
||||
await page.waitForSelector(row, { timeout: 20000 });
|
||||
await page.click(row);
|
||||
await page.waitForSelector(".detail .detail-tabs", { timeout: 20000 });
|
||||
// The tabstrip already exists from the previously opened run, so it is not
|
||||
// proof this run's detail loaded. Wait for this run's own identity line
|
||||
// (`run {id} · …`) before returning, or the next assertion can read the
|
||||
// previous run's actions.
|
||||
await eventually(
|
||||
() =>
|
||||
page.evaluate(
|
||||
`document.querySelector(".run-detail .run-identity")?.textContent?.startsWith("run ${runId} ") ?? false`,
|
||||
),
|
||||
{ timeout: 20000, what: `run ${runId}'s detail to load` },
|
||||
);
|
||||
return;
|
||||
} catch (error) {
|
||||
if (attempt === 1) throw error;
|
||||
@@ -98,6 +109,74 @@ async function openRunDetail(runId) {
|
||||
}
|
||||
}
|
||||
|
||||
// --- Omni-search (S1/S2) ---------------------------------------------------
|
||||
// The page's own search UI drives every one of the helpers below; nothing is
|
||||
// stubbed. `searchTargets` opens the panel (if it is not already open), types the
|
||||
// query, applies the kind filter and returns the `data-target` of every row of
|
||||
// that kind once one has rendered.
|
||||
|
||||
async function searchTargets(query, kind) {
|
||||
await ensureConnected();
|
||||
if (!(await page.evaluate(`!!document.querySelector("#searchInput")`))) {
|
||||
await page.click("#searchToggle");
|
||||
await page.waitForSelector("#searchInput", { timeout: 15000 });
|
||||
}
|
||||
await page.fill("#searchInput", query);
|
||||
await page.evaluate(`(() => {
|
||||
const select = document.querySelector("#searchKind");
|
||||
select.value = ${JSON.stringify(kind)};
|
||||
select.dispatchEvent(new Event("change", { bubbles: true }));
|
||||
})()`);
|
||||
await eventually(
|
||||
() =>
|
||||
page.evaluate(
|
||||
`[...document.querySelectorAll("#searchResults .search-row")].some((r) => r.dataset.kind === ${JSON.stringify(kind)})`,
|
||||
),
|
||||
{ timeout: 25000, what: `a ${kind} search result` },
|
||||
);
|
||||
return page.evaluate(
|
||||
`[...document.querySelectorAll("#searchResults .search-row")]
|
||||
.filter((r) => r.dataset.kind === ${JSON.stringify(kind)})
|
||||
.map((r) => r.dataset.target ?? "")`,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Click one search row by its exact data-target; routing closes the panel. The
|
||||
* lookup and the click happen in one evaluate so a reply landing between them
|
||||
* cannot replace the row first. This drives the row's own click handler, exactly
|
||||
* as a mouse click would.
|
||||
*/
|
||||
async function clickSearchTarget(target) {
|
||||
return page.evaluate(`(() => {
|
||||
const row = [...document.querySelectorAll("#searchResults .search-row")]
|
||||
.find((r) => (r.dataset.target ?? "") === ${JSON.stringify(target)});
|
||||
if (!row) return false;
|
||||
row.click();
|
||||
return true;
|
||||
})()`);
|
||||
}
|
||||
|
||||
/**
|
||||
* Route candidate rows of `kind` until the expected destination renders (routing
|
||||
* always closes the panel, so each attempt reopens and re-queries). Live data can
|
||||
* change between runs, so up to `attempts` rows are tried before giving up;
|
||||
* returns the target that landed or null.
|
||||
*/
|
||||
async function routeSearchKind(query, kind, landed, attempts = 4) {
|
||||
const targets = await searchTargets(query, kind);
|
||||
for (const target of targets.slice(0, attempts)) {
|
||||
await searchTargets(query, kind);
|
||||
if (!(await clickSearchTarget(target))) continue;
|
||||
if (await landed()) return target;
|
||||
await page.evaluate(`document.querySelector(".stage-pane-back")?.click()`);
|
||||
await eventually(() => page.evaluate(`!document.querySelector(".stage-pane")`), {
|
||||
timeout: 5000,
|
||||
}).catch(() => {});
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// The mounted graph's current transform, read back so the pan/zoom clamp checks
|
||||
// assert the real rendered state rather than a claim.
|
||||
const graphState = () =>
|
||||
@@ -1545,6 +1624,526 @@ try {
|
||||
shots.push(await page.screenshot(`${out}/34-run-${pendingRunId}-changes-pending.png`));
|
||||
}
|
||||
|
||||
// S1/S2: omni-search over the real server. The panel is opened from the top
|
||||
// bar; the query is typed through the page's own field, the flat result list
|
||||
// and its controls are asserted, a kind filter is applied and captured, and one
|
||||
// result of each kind is routed to its real destination. Every capture below is
|
||||
// a real screenshot of the rendered page.
|
||||
step("opening omni-search from the top bar (S1)");
|
||||
await ensureConnected();
|
||||
await page.clickText("nav.tabs button.tab", "Runs");
|
||||
await page.waitForSelector(".list.runs .run-row", { timeout: 25000 });
|
||||
const viewSnapshot = () =>
|
||||
page.evaluate(`(() => ({
|
||||
tab: document.querySelector("nav.tabs button.tab.active")?.textContent ?? "",
|
||||
detail: document.querySelector("#content .detail h2")?.textContent ?? "",
|
||||
}))()`);
|
||||
const beforeOpen = await viewSnapshot();
|
||||
await page.click("#searchToggle");
|
||||
await page.waitForSelector("#searchInput", { timeout: 15000 });
|
||||
const chrome = await page.evaluate(`(() => {
|
||||
const input = document.querySelector("#searchInput");
|
||||
return {
|
||||
placeholder: input?.getAttribute("placeholder") ?? "",
|
||||
autofocused: document.activeElement === input,
|
||||
close: document.querySelector("#searchClose")?.textContent ?? "",
|
||||
};
|
||||
})()`);
|
||||
if (chrome.placeholder !== "Search pipelines, runs and artifacts") {
|
||||
throw new Error(`search placeholder is wrong: ${chrome.placeholder}`);
|
||||
}
|
||||
if (!chrome.autofocused) throw new Error("the search field was not autofocused on open");
|
||||
if (chrome.close !== "Close search") throw new Error(`the close control is wrong: ${chrome.close}`);
|
||||
const afterOpen = await viewSnapshot();
|
||||
if (afterOpen.tab !== beforeOpen.tab || afterOpen.detail !== beforeOpen.detail) {
|
||||
throw new Error(`opening search changed the view: ${JSON.stringify({ beforeOpen, afterOpen })}`);
|
||||
}
|
||||
console.log(
|
||||
` field autofocused, placeholder "${chrome.placeholder}", "${chrome.close}" present; view stayed ${afterOpen.tab}`,
|
||||
);
|
||||
|
||||
const SEARCH_QUERY = "plan";
|
||||
step(`running a real query ("${SEARCH_QUERY}") and capturing the flat result list (S1)`);
|
||||
await page.fill("#searchInput", SEARCH_QUERY);
|
||||
await page.waitForSelector("#searchResults .search-row", { timeout: 25000 });
|
||||
const list = await page.evaluate(`(() => ({
|
||||
kinds: [...document.querySelectorAll("#searchKind option")].map((o) => o.textContent),
|
||||
sorts: [...document.querySelectorAll("#searchSort option")].map((o) => o.textContent),
|
||||
kindValue: document.querySelector("#searchKind")?.value ?? "",
|
||||
sortValue: document.querySelector("#searchSort")?.value ?? "",
|
||||
summary: document.querySelector("#searchSummary")?.textContent ?? "",
|
||||
clear: document.querySelector("#searchClearFilter")?.textContent ?? "",
|
||||
rows: document.querySelectorAll("#searchResults .search-row").length,
|
||||
headers: document.querySelectorAll("#searchResults h1, #searchResults h2, #searchResults h3").length,
|
||||
kindsPresent: [...new Set([...document.querySelectorAll("#searchResults .search-row")].map((r) => r.dataset.kind))],
|
||||
matchedSpans: document.querySelectorAll("#searchResults .search-match").length,
|
||||
}))()`);
|
||||
if (
|
||||
JSON.stringify(list.kinds) !==
|
||||
JSON.stringify(["All kinds", "Pipelines", "Runs", "Steps", "Fields", "Artifacts", "Versions"])
|
||||
) {
|
||||
throw new Error(`kind options are wrong: ${list.kinds.join(",")}`);
|
||||
}
|
||||
if (JSON.stringify(list.sorts) !== JSON.stringify(["Relevance", "Newest first", "Name"])) {
|
||||
throw new Error(`sort options are wrong: ${list.sorts.join(",")}`);
|
||||
}
|
||||
if (list.kindValue !== "" || list.sortValue !== "relevance") {
|
||||
throw new Error(`the default controls are wrong: kind=${list.kindValue} sort=${list.sortValue}`);
|
||||
}
|
||||
if (list.summary !== "All kinds · Relevance") throw new Error(`the summary line is wrong: ${list.summary}`);
|
||||
if (list.clear !== "Clear filter") throw new Error(`the reset control is wrong: ${list.clear}`);
|
||||
if (!list.rows) throw new Error("the query rendered no result rows");
|
||||
if (list.headers !== 0) throw new Error("the result list carries grouping headers, not a flat list");
|
||||
if (list.kindsPresent.length < 2) {
|
||||
throw new Error(`the query returned only ${list.kindsPresent.join(",")}, expected a mixed list`);
|
||||
}
|
||||
console.log(
|
||||
` ${list.rows} flat rows across ${list.kindsPresent.join(",")}; summary "${list.summary}"; ` +
|
||||
`${list.matchedSpans} emphasised snippet span(s)`,
|
||||
);
|
||||
await page.rect("#searchPanel");
|
||||
await shot("01-search-results.png");
|
||||
|
||||
step("applying a kind filter and capturing it (S1)");
|
||||
await page.evaluate(`(() => {
|
||||
const select = document.querySelector("#searchKind");
|
||||
select.value = "pipeline";
|
||||
select.dispatchEvent(new Event("change", { bubbles: true }));
|
||||
})()`);
|
||||
await eventually(
|
||||
() =>
|
||||
page.evaluate(`(() => {
|
||||
const rows = [...document.querySelectorAll("#searchResults .search-row")];
|
||||
return rows.length > 0 && rows.every((r) => r.dataset.kind === "pipeline");
|
||||
})()`),
|
||||
{ timeout: 25000, what: "the kind filter to narrow the list to pipelines" },
|
||||
);
|
||||
const filteredSummary = await text("#searchSummary");
|
||||
if (filteredSummary !== "Pipelines · Relevance") {
|
||||
throw new Error(`the filtered summary is wrong: ${filteredSummary}`);
|
||||
}
|
||||
const filteredRows = await page.evaluate(`document.querySelectorAll("#searchResults .search-row").length`);
|
||||
console.log(` Pipelines filter: ${filteredRows} row(s), summary "${filteredSummary}"`);
|
||||
await page.rect("#searchPanel");
|
||||
await shot("02-search-kind-filter.png");
|
||||
|
||||
step("Clear filter returns the kind to All kinds");
|
||||
await page.click("#searchClearFilter");
|
||||
await eventually(async () => (await text("#searchSummary")) === "All kinds · Relevance", {
|
||||
timeout: 15000,
|
||||
what: "Clear filter to reset the kind",
|
||||
});
|
||||
console.log(' Clear filter reset the kind to "All kinds"');
|
||||
|
||||
step("a Fields filter emphasises the matched snippet in the page, never as markup (S1)");
|
||||
await page.evaluate(`(() => {
|
||||
const select = document.querySelector("#searchKind");
|
||||
select.value = "field";
|
||||
select.dispatchEvent(new Event("change", { bubbles: true }));
|
||||
})()`);
|
||||
await eventually(
|
||||
() => page.evaluate(`!!document.querySelector("#searchResults .search-row .search-match")`),
|
||||
{ timeout: 25000, what: "an emphasised snippet span" },
|
||||
);
|
||||
const emphasis = await page.evaluate(`(() => {
|
||||
const node = document.querySelector("#searchResults .search-row .search-match");
|
||||
return {
|
||||
tag: node?.tagName ?? "",
|
||||
inner: node?.firstElementChild?.tagName ?? "",
|
||||
text: node?.textContent ?? "",
|
||||
kind: node?.closest(".search-row")?.dataset.kind ?? "",
|
||||
};
|
||||
})()`);
|
||||
if (emphasis.tag !== "STRONG" || emphasis.inner !== "U") {
|
||||
throw new Error(`the matched span is not <strong><u>: ${JSON.stringify(emphasis)}`);
|
||||
}
|
||||
if (!emphasis.text) throw new Error("the emphasised span carries no text");
|
||||
if (emphasis.kind !== "field") throw new Error(`the emphasis is not on a field hit: ${emphasis.kind}`);
|
||||
console.log(` matched snippet emphasised as <${emphasis.tag}><${emphasis.inner}>: "${emphasis.text}"`);
|
||||
// Back to every kind for the routing steps.
|
||||
await page.evaluate(`(() => {
|
||||
const select = document.querySelector("#searchKind");
|
||||
select.value = "";
|
||||
select.dispatchEvent(new Event("change", { bubbles: true }));
|
||||
})()`);
|
||||
await eventually(() => page.evaluate(`!!document.querySelector("#searchResults .search-row")`), {
|
||||
timeout: 25000,
|
||||
what: "the unfiltered list",
|
||||
});
|
||||
|
||||
step("routing a pipeline hit to its detail (S2)");
|
||||
const pipelineTarget = await routeSearchKind(SEARCH_QUERY, "pipeline", async () => {
|
||||
await page.waitForSelector("#content .detail h2", { timeout: 25000 });
|
||||
await page.waitForSelector("#content .detail .monospace", { timeout: 25000 });
|
||||
return true;
|
||||
});
|
||||
if (!pipelineTarget) throw new Error("no pipeline result routed to a pipeline detail");
|
||||
const pipelineView = await page.evaluate(`(() => ({
|
||||
active: document.querySelector("nav.tabs button.tab.active")?.textContent ?? "",
|
||||
title: document.querySelector("#content .detail h2")?.textContent ?? "",
|
||||
searchOpen: !!document.querySelector("#searchInput"),
|
||||
}))()`);
|
||||
if (!pipelineView.active.startsWith("Pipelines")) {
|
||||
throw new Error(`a pipeline hit landed on ${pipelineView.active}`);
|
||||
}
|
||||
if (!pipelineView.title) throw new Error("the routed pipeline detail has no heading");
|
||||
if (pipelineView.searchOpen) throw new Error("selecting a result did not close the search panel");
|
||||
console.log(` ${pipelineTarget} -> Pipelines detail "${pipelineView.title}"`);
|
||||
await page.rect("#content .detail");
|
||||
await shot("03-search-route-pipeline.png");
|
||||
|
||||
step("routing a run hit to its detail (S2)");
|
||||
const runTarget = await routeSearchKind(SEARCH_QUERY, "run", async () => {
|
||||
await eventually(
|
||||
() =>
|
||||
page.evaluate(`(() => {
|
||||
const tab = document.querySelector("nav.tabs button.tab.active")?.textContent ?? "";
|
||||
return tab.startsWith("Runs") && !!document.querySelector("#content .detail .detail-tabs");
|
||||
})()`),
|
||||
{ timeout: 25000, what: "the routed run detail" },
|
||||
);
|
||||
return true;
|
||||
});
|
||||
if (!runTarget) throw new Error("no run result routed to a run detail");
|
||||
const runView = await page.evaluate(`(() => ({
|
||||
active: document.querySelector("nav.tabs button.tab.active")?.textContent ?? "",
|
||||
title: document.querySelector("#content .detail h2")?.textContent ?? "",
|
||||
tabs: [...document.querySelectorAll("#content .detail .detail-tabs .detail-tab")].map((n) => n.textContent),
|
||||
}))()`);
|
||||
if (!runView.active.startsWith("Runs")) throw new Error(`a run hit landed on ${runView.active}`);
|
||||
if (!runView.tabs.includes("Summary")) throw new Error(`the routed run detail has no tabs: ${runView.tabs}`);
|
||||
console.log(` ${runTarget} -> Runs detail "${runView.title}" (${runView.tabs.join("/")})`);
|
||||
await page.rect("#content .detail");
|
||||
await shot("04-search-route-run.png");
|
||||
|
||||
step("routing a field hit to the run-detail tab holding the match (S2)");
|
||||
const fieldTargets = await searchTargets(SEARCH_QUERY, "field");
|
||||
let fieldRoute = null;
|
||||
for (const target of fieldTargets.slice(0, 4)) {
|
||||
// data-target is run:{id}:{sequence}:{matchedField}.
|
||||
const matchedField = target.split(":")[3] ?? "";
|
||||
const expectedTab = matchedField === "input" ? "Input" : matchedField === "output" ? "Output" : "Summary";
|
||||
await searchTargets(SEARCH_QUERY, "field");
|
||||
if (!(await clickSearchTarget(target))) continue;
|
||||
const landed = await eventually(
|
||||
() =>
|
||||
page.evaluate(`(() => {
|
||||
const tab = document.querySelector("nav.tabs button.tab.active")?.textContent ?? "";
|
||||
const active = document.querySelector("#content .detail .detail-tabs .detail-tab.active")?.textContent ?? "";
|
||||
return tab.startsWith("Runs") && active === ${JSON.stringify(expectedTab)};
|
||||
})()`),
|
||||
{ timeout: 25000, what: `the ${expectedTab} run-detail tab` },
|
||||
)
|
||||
.then(() => true)
|
||||
.catch(() => false);
|
||||
if (landed) {
|
||||
fieldRoute = { target, matchedField, expectedTab };
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!fieldRoute) throw new Error("no field result opened the run-detail tab holding its match");
|
||||
console.log(` ${fieldRoute.target} (matched_field ${fieldRoute.matchedField}) -> ${fieldRoute.expectedTab} tab`);
|
||||
await page.rect("#content .detail");
|
||||
await shot("05-search-route-field.png");
|
||||
|
||||
step("routing a step hit to the visit's stage pane (S2)");
|
||||
const stepTarget = await routeSearchKind(SEARCH_QUERY, "step", async () => {
|
||||
await eventually(() => page.evaluate(`!!document.querySelector(".stage-pane")`), {
|
||||
timeout: 20000,
|
||||
what: "the routed visit stage pane",
|
||||
});
|
||||
return true;
|
||||
});
|
||||
if (!stepTarget) throw new Error("no step result opened a visit stage pane");
|
||||
const stepPane = await page.evaluate(`(() => ({
|
||||
title: document.querySelector(".stage-pane-title")?.textContent ?? "",
|
||||
tab: document.querySelector("nav.tabs button.tab.active")?.textContent ?? "",
|
||||
}))()`);
|
||||
if (!stepPane.title) throw new Error("the routed stage pane named no stage");
|
||||
if (!stepPane.tab.startsWith("Runs")) throw new Error(`the step route landed on ${stepPane.tab}`);
|
||||
console.log(` ${stepTarget} -> run stage pane "${stepPane.title}"`);
|
||||
await page.rect(".stage-pane-sheet");
|
||||
await shot("06-search-route-step.png");
|
||||
await page.click(".stage-pane-back");
|
||||
await eventually(() => page.evaluate(`!document.querySelector(".stage-pane")`), {
|
||||
timeout: 5000,
|
||||
what: "the step stage pane to close",
|
||||
});
|
||||
|
||||
step("routing an artifact hit to the same visit pane (S2)");
|
||||
const artifactTarget = await routeSearchKind(SEARCH_QUERY, "artifact", async () => {
|
||||
await eventually(() => page.evaluate(`!!document.querySelector(".stage-pane")`), {
|
||||
timeout: 20000,
|
||||
what: "the routed artifact visit pane",
|
||||
});
|
||||
return true;
|
||||
});
|
||||
if (artifactTarget) {
|
||||
const artifactPane = await page.evaluate(
|
||||
`document.querySelector(".stage-pane-title")?.textContent ?? ""`,
|
||||
);
|
||||
console.log(` ${artifactTarget} -> run stage pane "${artifactPane}"`);
|
||||
await page.rect(".stage-pane-sheet");
|
||||
await shot("07-search-route-artifact.png");
|
||||
await page.click(".stage-pane-back");
|
||||
await eventually(() => page.evaluate(`!document.querySelector(".stage-pane")`), {
|
||||
timeout: 5000,
|
||||
what: "the artifact stage pane to close",
|
||||
});
|
||||
} else {
|
||||
console.log(" -- no artifact hit routed to a visit pane; skipped the artifact capture");
|
||||
}
|
||||
|
||||
step("routing a version hit to its pipeline detail (S2)");
|
||||
const versionTarget = await routeSearchKind(SEARCH_QUERY, "version", async () => {
|
||||
await eventually(
|
||||
() =>
|
||||
page.evaluate(`(() => {
|
||||
const tab = document.querySelector("nav.tabs button.tab.active")?.textContent ?? "";
|
||||
return tab.startsWith("Pipelines") && !!document.querySelector("#content .detail h2");
|
||||
})()`),
|
||||
{ timeout: 25000, what: "the pipeline detail for the version" },
|
||||
);
|
||||
return true;
|
||||
});
|
||||
if (versionTarget) {
|
||||
const versionTitle = await text("#content .detail h2");
|
||||
console.log(` ${versionTarget} -> Pipelines detail "${versionTitle}"`);
|
||||
await page.rect("#content .detail");
|
||||
await shot("08-search-route-version.png");
|
||||
} else {
|
||||
console.log(" -- no version hit routed; skipped the version capture");
|
||||
}
|
||||
|
||||
step("Closing search clears the query and leaves the view intact (S1)");
|
||||
await searchTargets("release", "field");
|
||||
const beforeClose = await viewSnapshot();
|
||||
await page.click("#searchClose");
|
||||
await eventually(() => page.evaluate(`!document.querySelector("#searchInput")`), {
|
||||
timeout: 10000,
|
||||
what: "the search panel to close",
|
||||
});
|
||||
const afterClose = await viewSnapshot();
|
||||
if (afterClose.tab !== beforeClose.tab || afterClose.detail !== beforeClose.detail) {
|
||||
throw new Error(`closing search changed the view: ${JSON.stringify({ beforeClose, afterClose })}`);
|
||||
}
|
||||
await page.click("#searchToggle");
|
||||
await page.waitForSelector("#searchInput", { timeout: 15000 });
|
||||
const reopenedQuery = await page.evaluate(`document.querySelector("#searchInput")?.value ?? ""`);
|
||||
if (reopenedQuery !== "") throw new Error(`closing search did not clear the query: "${reopenedQuery}"`);
|
||||
await page.evaluate(
|
||||
`document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", bubbles: true }))`,
|
||||
);
|
||||
await eventually(() => page.evaluate(`!document.querySelector("#searchInput")`), {
|
||||
timeout: 10000,
|
||||
what: "Escape to close the search",
|
||||
});
|
||||
console.log(" Close search cleared the query and kept the view; Escape also closed the field");
|
||||
|
||||
// R13/R14: the run-level actions on run 440 (failed, not executing). The
|
||||
// Retry action is offered; Cancel is not. The Retry confirm and its secondary
|
||||
// Restart-from-start confirm are captured and dismissed with Keep — no run is
|
||||
// started here. The rename field is captured pre-filled, then a blank rename is
|
||||
// actually sent: the live server refuses it without mutating anything, so the
|
||||
// shared Action-failed dialog shows the server's own reason.
|
||||
step("R13/R14: run 440 (failed) — Retry eligibility, restart confirm and the rename field");
|
||||
// The search block above leaves the routed detail (a Pipelines detail) on
|
||||
// screen; R13/R14 needs the Runs list rendered before it can open run 440.
|
||||
await page.clickText("nav.tabs button.tab", "Runs");
|
||||
await page.waitForSelector(".list.runs .run-row", { timeout: 25000 });
|
||||
await openRunDetail(440);
|
||||
const actions440 = await page.evaluate(`(() => ({
|
||||
retry: !!document.querySelector(".run-detail .run-actions .retry-run"),
|
||||
cancel: !!document.querySelector(".run-detail .run-actions .cancel-run"),
|
||||
}))()`);
|
||||
if (!actions440.retry) throw new Error("run 440 (failed, not executing) offered no Retry action");
|
||||
if (actions440.cancel) throw new Error("run 440 (not executing) must not offer a Cancel action");
|
||||
shots.push(await page.screenshot(`${out}/35-run-440-run-actions.png`));
|
||||
|
||||
step("R13: the Retry confirm — resume is the default, Restart from start is secondary");
|
||||
await page.click(".run-detail .run-actions .retry-run");
|
||||
await page.waitForSelector(".confirm-dialog.confirm-retry", { timeout: 15000 });
|
||||
const retryDialog = await page.evaluate(`(() => ({
|
||||
title: document.querySelector(".confirm-retry .confirm-title")?.textContent ?? "",
|
||||
message: document.querySelector(".confirm-retry .confirm-message")?.textContent ?? "",
|
||||
confirm: document.querySelector(".confirm-retry .confirm-accept")?.textContent ?? "",
|
||||
dismiss: document.querySelector(".confirm-retry .confirm-dismiss")?.textContent ?? "",
|
||||
secondary: document.querySelector(".confirm-retry .confirm-secondary")?.textContent ?? "",
|
||||
}))()`);
|
||||
if (retryDialog.title !== "Retry run 440?") throw new Error(`retry title: ${retryDialog.title}`);
|
||||
if (retryDialog.message !== "Only failed runs can be retried. The server starts a new run from the same input.") {
|
||||
throw new Error(`retry message: ${retryDialog.message}`);
|
||||
}
|
||||
if (retryDialog.confirm !== "Retry") throw new Error(`retry confirm: ${retryDialog.confirm}`);
|
||||
if (retryDialog.dismiss !== "Keep") throw new Error(`retry dismiss: ${retryDialog.dismiss}`);
|
||||
if (retryDialog.secondary !== "Restart from start") {
|
||||
throw new Error(`retry secondary: ${retryDialog.secondary}`);
|
||||
}
|
||||
console.log(` retry dialog: "${retryDialog.title}" — ${retryDialog.message}`);
|
||||
shots.push(await page.screenshot(`${out}/36-run-440-retry-confirm.png`));
|
||||
|
||||
step("R13: the Restart-from-start confirm states the whole-pipeline replay");
|
||||
await page.click(".confirm-retry .confirm-secondary");
|
||||
await page.waitForSelector(".confirm-dialog.confirm-restart", { timeout: 15000 });
|
||||
const restartDialog = await page.evaluate(`(() => ({
|
||||
title: document.querySelector(".confirm-restart .confirm-title")?.textContent ?? "",
|
||||
message: document.querySelector(".confirm-restart .confirm-message")?.textContent ?? "",
|
||||
confirm: document.querySelector(".confirm-restart .confirm-accept")?.textContent ?? "",
|
||||
dismiss: document.querySelector(".confirm-restart .confirm-dismiss")?.textContent ?? "",
|
||||
}))()`);
|
||||
if (restartDialog.title !== "Restart run 440?") throw new Error(`restart title: ${restartDialog.title}`);
|
||||
if (!restartDialog.message.includes("replays the whole pipeline")) {
|
||||
throw new Error(`restart message does not state the whole-pipeline replay: ${restartDialog.message}`);
|
||||
}
|
||||
if (!restartDialog.message.includes("instead of resuming the failed stage")) {
|
||||
throw new Error(`restart message does not contrast with resume: ${restartDialog.message}`);
|
||||
}
|
||||
if (restartDialog.confirm !== "Restart from start") {
|
||||
throw new Error(`restart confirm: ${restartDialog.confirm}`);
|
||||
}
|
||||
if (restartDialog.dismiss !== "Keep") throw new Error(`restart dismiss: ${restartDialog.dismiss}`);
|
||||
console.log(` restart dialog: "${restartDialog.title}" — ${restartDialog.message}`);
|
||||
shots.push(await page.screenshot(`${out}/37-run-440-restart-confirm.png`));
|
||||
|
||||
step("R13: dismissing the dialog with Keep sends nothing");
|
||||
await page.click(".confirm-restart .confirm-dismiss");
|
||||
await eventually(() => page.evaluate(`!document.querySelector(".confirm-dialog")`), {
|
||||
timeout: 5000,
|
||||
what: "the confirm dialog to close",
|
||||
});
|
||||
|
||||
step("R14: the rename field is pre-filled with the current title");
|
||||
await page.click(".run-detail .rename-open");
|
||||
await page.waitForSelector(".run-detail .rename-input", { timeout: 15000 });
|
||||
const renameValue = await page.evaluate(
|
||||
`document.querySelector(".run-detail .rename-input")?.value ?? ""`,
|
||||
);
|
||||
if (!renameValue) throw new Error("the rename field was not pre-filled with the current title");
|
||||
console.log(` rename field pre-filled with: ${JSON.stringify(renameValue)}`);
|
||||
shots.push(await page.screenshot(`${out}/38-run-440-rename-field.png`));
|
||||
|
||||
step("Action failed: a refused rename shows the server's exact reason");
|
||||
await page.fill(".run-detail .rename-input", "");
|
||||
await page.click(".run-detail .rename-save");
|
||||
await page.waitForSelector(".action-failed", { timeout: 15000 });
|
||||
const actionFailed = await page.evaluate(`(() => ({
|
||||
title: document.querySelector(".action-failed .action-failed-title")?.textContent ?? "",
|
||||
message: document.querySelector(".action-failed .action-failed-message")?.textContent ?? "",
|
||||
ok: document.querySelector(".action-failed .action-failed-ok")?.textContent ?? "",
|
||||
}))()`);
|
||||
if (actionFailed.title !== "Action failed") throw new Error(`action-failed title: ${actionFailed.title}`);
|
||||
if (actionFailed.ok !== "OK") throw new Error(`action-failed ok: ${actionFailed.ok}`);
|
||||
if (actionFailed.message !== "a title with usable text is required") {
|
||||
throw new Error(`action-failed message is not the server's own reason: ${actionFailed.message}`);
|
||||
}
|
||||
console.log(` action failed: "${actionFailed.title}" — ${actionFailed.message}`);
|
||||
shots.push(await page.screenshot(`${out}/39-run-440-action-failed.png`));
|
||||
await page.click(".action-failed .action-failed-ok");
|
||||
await eventually(() => page.evaluate(`!document.querySelector(".action-failed")`), {
|
||||
timeout: 5000,
|
||||
what: "the Action-failed dialog to close",
|
||||
});
|
||||
// Leave the rename field without changing anything.
|
||||
await page.click(".run-detail .rename-cancel");
|
||||
|
||||
// R12: the Cancel confirm on an executing run. Shown and dismissed with Keep —
|
||||
// no cancel_run is sent (a real cancel is unsafe against a shared live run).
|
||||
step("R12: the Cancel confirm on an executing run (shown, not executed)");
|
||||
const cancelRunId = await page.evaluate(`(() => {
|
||||
const row = [...document.querySelectorAll(".list.runs .run-row")].find((n) => n.querySelector(".chip-running"));
|
||||
const meta = row?.querySelector(".run-row-meta[data-run-id]");
|
||||
return meta ? Number(meta.getAttribute("data-run-id")) : null;
|
||||
})()`);
|
||||
if (cancelRunId == null) {
|
||||
console.log(" -- no executing run available; skipped the Cancel confirm capture");
|
||||
} else {
|
||||
await openRunDetail(cancelRunId);
|
||||
const cancelOffered = await page.evaluate(
|
||||
`!!document.querySelector(".run-detail .run-actions .cancel-run")`,
|
||||
);
|
||||
if (!cancelOffered) {
|
||||
console.log(` -- run ${cancelRunId} stopped before the Cancel action could be shown`);
|
||||
} else {
|
||||
await page.click(".run-detail .run-actions .cancel-run");
|
||||
await page.waitForSelector(".confirm-dialog.confirm-cancel", { timeout: 15000 });
|
||||
const cancelDialog = await page.evaluate(`(() => ({
|
||||
title: document.querySelector(".confirm-cancel .confirm-title")?.textContent ?? "",
|
||||
message: document.querySelector(".confirm-cancel .confirm-message")?.textContent ?? "",
|
||||
confirm: document.querySelector(".confirm-cancel .confirm-accept")?.textContent ?? "",
|
||||
dismiss: document.querySelector(".confirm-cancel .confirm-dismiss")?.textContent ?? "",
|
||||
}))()`);
|
||||
if (cancelDialog.title !== `Cancel run ${cancelRunId}?`) {
|
||||
throw new Error(`cancel title: ${cancelDialog.title}`);
|
||||
}
|
||||
if (cancelDialog.message !== "This asks the server to stop the active run.") {
|
||||
throw new Error(`cancel message: ${cancelDialog.message}`);
|
||||
}
|
||||
if (cancelDialog.confirm !== "Cancel run") throw new Error(`cancel confirm: ${cancelDialog.confirm}`);
|
||||
if (cancelDialog.dismiss !== "Keep") throw new Error(`cancel dismiss: ${cancelDialog.dismiss}`);
|
||||
console.log(` cancel dialog (run ${cancelRunId}, not executed): "${cancelDialog.title}" — ${cancelDialog.message}`);
|
||||
shots.push(await page.screenshot(`${out}/40-run-${cancelRunId}-cancel-confirm.png`));
|
||||
await page.click(".confirm-cancel .confirm-dismiss");
|
||||
await eventually(() => page.evaluate(`!document.querySelector(".confirm-dialog")`), {
|
||||
timeout: 5000,
|
||||
what: "the Cancel dialog to close",
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// R11: the decision card/sheet, only when the live server actually has a run
|
||||
// waiting on a person with recorded options. There is normally none (a human
|
||||
// stage blocks a run until a person answers), so this stays a best-effort
|
||||
// capture rather than a failure; the model is unit-tested in actions.test.mjs.
|
||||
step("R11: the human-decision card/sheet (only when a waiting run is present)");
|
||||
const waitingRunId = await page.evaluate(`(() => {
|
||||
const row = [...document.querySelectorAll(".list.runs .run-row")].find((n) => n.querySelector(".chip-waiting"));
|
||||
const meta = row?.querySelector(".run-row-meta[data-run-id]");
|
||||
return meta ? Number(meta.getAttribute("data-run-id")) : null;
|
||||
})()`);
|
||||
if (waitingRunId == null) {
|
||||
console.log(" -- no waiting run available; skipped the decision card/sheet capture (R11 stays partial)");
|
||||
} else {
|
||||
await openRunDetail(waitingRunId);
|
||||
await page.waitForSelector(".run-detail .decision-card", { timeout: 15000 });
|
||||
const cardText = await page.evaluate(`(() => ({
|
||||
title: document.querySelector(".decision-card .decision-card-title")?.textContent ?? "",
|
||||
meta: document.querySelector(".decision-card .decision-card-meta")?.textContent ?? "",
|
||||
action: document.querySelector(".decision-card .decision-open")?.textContent ?? "",
|
||||
}))()`);
|
||||
if (cardText.title !== "Waiting for your decision") throw new Error(`card title: ${cardText.title}`);
|
||||
if (cardText.action !== "Decide") throw new Error(`card action: ${cardText.action}`);
|
||||
console.log(` decision card (run ${waitingRunId}): ${cardText.title} — ${cardText.meta}`);
|
||||
shots.push(await page.screenshot(`${out}/41-run-${waitingRunId}-decision-card.png`));
|
||||
await page.click(".decision-card .decision-open");
|
||||
await page.waitForSelector(".decision-sheet .decision-option", { timeout: 15000 });
|
||||
const sheet = await page.evaluate(`(() => ({
|
||||
title: document.querySelector(".decision-sheet-title")?.textContent ?? "",
|
||||
meta: document.querySelector(".decision-sheet-meta")?.textContent ?? "",
|
||||
label: document.querySelector(".decision-field-label")?.textContent ?? "",
|
||||
options: [...document.querySelectorAll(".decision-sheet .decision-option-key")].map((n) => n.textContent),
|
||||
confirmDisabled: document.querySelector(".decision-confirm")?.disabled ?? null,
|
||||
}))()`);
|
||||
if (sheet.label !== "Feedback (optional)") throw new Error(`sheet feedback label: ${sheet.label}`);
|
||||
if (sheet.confirmDisabled !== true) {
|
||||
throw new Error("Confirm decision must be disabled until an option is selected");
|
||||
}
|
||||
console.log(` decision sheet (run ${waitingRunId}): ${sheet.title} — ${sheet.meta}; options ${sheet.options.join(", ")}`);
|
||||
shots.push(await page.screenshot(`${out}/42-run-${waitingRunId}-decision-sheet.png`));
|
||||
// Selecting an option enables the confirm but sends nothing.
|
||||
await page.click(".decision-sheet .decision-option");
|
||||
await eventually(
|
||||
() => page.evaluate(`document.querySelector(".decision-confirm")?.disabled === false`),
|
||||
{ timeout: 5000, what: "the confirm to enable after selecting an option" },
|
||||
);
|
||||
shots.push(await page.screenshot(`${out}/43-run-${waitingRunId}-decision-selected.png`));
|
||||
// Dismiss with Cancel: no decide_run is sent for a real waiting run here.
|
||||
await page.click(".decision-sheet .decision-cancel");
|
||||
await eventually(() => page.evaluate(`!document.querySelector(".decision-sheet")`), {
|
||||
timeout: 5000,
|
||||
what: "the decision sheet to close",
|
||||
});
|
||||
}
|
||||
|
||||
console.log("\nUI SMOKE PASS");
|
||||
for (const shot of shots) console.log(` ${shot}`);
|
||||
} catch (error) {
|
||||
|
||||
Reference in New Issue
Block a user