Merge branch 'main' into web-runs-home

# Conflicts:
#	web/src/app.js
#	web/styles.css
#	web/test/ui-smoke.mjs
This commit is contained in:
2026-10-19 03:00:13 +01:00
7 changed files with 1376 additions and 56 deletions
+397
View File
@@ -0,0 +1,397 @@
// Unit tests for the pure pipeline helpers (src/pipelines.js): timestamp and
// duration formatting, the last-run join, the sort comparators, the filter and
// the empty-state strings. No DOM and no server: `node --test test/` proves the
// module is pure. Wording is asserted against the Android app's own strings.
import { test } from "node:test";
import assert from "node:assert/strict";
import {
PIPELINE_DETAIL_TABS,
PIPELINE_SORTS,
RUN_PRESENCES,
RUN_STATUS_FILTERS,
durationSeconds,
filterPipelines,
formatDuration,
formatLocalTimestamp,
formatRanAgo,
graphNote,
isMoreRecent,
latestRunByPipeline,
parseInstant,
pipelineComparator,
pipelineFilterCount,
pipelineListEmptyState,
pipelineMatchesLastRunStatus,
pipelineMatchesName,
pipelineMatchesPresence,
pipelineSubtitle,
pipelineUpdatedLine,
runBadge,
runBadgeMetaLine,
runDurationText,
runStateOf,
sortPipelines,
stageCountText,
summaryFields,
versionRow,
} from "../src/pipelines.js";
const LOCAL_STAMP = /^\d{1,2} [A-Z][a-z]{2} \d{2}:\d{2}$/;
// ---------------------------------------------------------------------------
// Timestamps, durations and stage counts
// ---------------------------------------------------------------------------
test("stageCountText spells 1 singular and everything else plural", () => {
assert.equal(stageCountText(0), "0 stages");
assert.equal(stageCountText(1), "1 stage");
assert.equal(stageCountText(2), "2 stages");
assert.equal(stageCountText(5), "5 stages");
});
test("parseInstant accepts RFC3339 and rejects blank/unparseable input", () => {
assert.equal(parseInstant("2026-10-17T21:57:31Z"), Date.parse("2026-10-17T21:57:31Z"));
assert.equal(parseInstant(""), null);
assert.equal(parseInstant(" "), null);
assert.equal(parseInstant("not a date"), null);
assert.equal(parseInstant(undefined), null);
});
test("formatLocalTimestamp renders 'd MMM HH:mm' and null on bad input", () => {
assert.equal(formatLocalTimestamp("2026-10-17T21:57:31Z", { timeZone: "UTC" }), "17 Oct 21:57");
assert.equal(formatLocalTimestamp("2026-01-05T00:00:00Z", { timeZone: "UTC" }), "5 Jan 00:00");
assert.equal(formatLocalTimestamp("2026-10-17T21:57:31Z", { timeZone: "Europe/London" }), "17 Oct 22:57");
assert.equal(formatLocalTimestamp("", { timeZone: "UTC" }), null);
assert.equal(formatLocalTimestamp("nope", { timeZone: "UTC" }), null);
});
test("formatDuration matches the app's s / m s / h m rhythm", () => {
assert.equal(formatDuration(0), "0s");
assert.equal(formatDuration(45), "45s");
assert.equal(formatDuration(59), "59s");
assert.equal(formatDuration(60), "1m 0s");
assert.equal(formatDuration(125), "2m 5s");
assert.equal(formatDuration(3599), "59m 59s");
assert.equal(formatDuration(3600), "1h 0m");
assert.equal(formatDuration(3725), "1h 2m");
assert.equal(formatDuration(-5), "0s");
});
test("durationSeconds is null when the end precedes the start or a timestamp is bad", () => {
assert.equal(durationSeconds("2026-10-17T21:00:00Z", "2026-10-17T21:02:05Z"), 125);
assert.equal(durationSeconds("2026-10-17T21:02:05Z", "2026-10-17T21:00:00Z"), null);
assert.equal(durationSeconds("", "2026-10-17T21:00:00Z"), null);
assert.equal(durationSeconds("2026-10-17T21:00:00Z", "nope"), null);
});
test("runDurationText is live while executing and stored once finished", () => {
const start = "2026-10-17T21:00:00Z";
const now = Date.parse(start) + 100_000;
assert.equal(runDurationText({ created_at: start, finished_at: "", executing: true }, now), "1m 40s");
assert.equal(
runDurationText({ created_at: start, finished_at: "2026-10-17T21:02:05Z", executing: false }, now),
"2m 5s",
);
assert.equal(runDurationText({ created_at: "", finished_at: "", executing: true }, now), null);
assert.equal(runDurationText({ created_at: start, finished_at: "", executing: false }, now), null);
});
test("a running run with a future start reads as 0s, never negative", () => {
const start = "2026-10-17T21:00:00Z";
const now = Date.parse(start) - 5_000;
assert.equal(runDurationText({ created_at: start, finished_at: "", executing: true }, now), "0s");
});
test("formatRanAgo buckets by minute/hour/day and nulls a bad start", () => {
const start = Date.parse("2026-10-17T21:00:00Z");
const ago = (seconds) => formatRanAgo("2026-10-17T21:00:00Z", start + seconds * 1000);
assert.equal(ago(0), "just now");
assert.equal(ago(59), "just now");
assert.equal(ago(60), "1m ago");
assert.equal(ago(90), "1m ago");
assert.equal(ago(3600), "1h ago");
assert.equal(ago(7200), "2h ago");
assert.equal(ago(86400), "1d ago");
assert.equal(ago(3 * 86400), "3d ago");
assert.equal(formatRanAgo("2026-10-17T21:00:00Z", start - 10_000), "just now");
assert.equal(formatRanAgo("", start), null);
assert.equal(formatRanAgo("nope", start), null);
});
// ---------------------------------------------------------------------------
// Run states and the last-run join
// ---------------------------------------------------------------------------
test("runStateOf accepts the server vocabulary and falls back to unknown", () => {
assert.equal(runStateOf("succeeded"), "succeeded");
assert.equal(runStateOf("RUNNING"), "running");
assert.equal(runStateOf("success"), "succeeded");
assert.equal(runStateOf("error"), "failed");
assert.equal(runStateOf("cancelled"), "canceled");
assert.equal(runStateOf("interrupted"), "interrupted");
assert.equal(runStateOf(""), "unknown");
assert.equal(runStateOf(undefined), "unknown");
});
test("latestRunByPipeline picks the newest run per pipeline independent of input order", () => {
const runs = [
{ id: 1, pipeline_id: 7, created_at: "2026-10-01T00:00:00Z" },
{ id: 3, pipeline_id: 7, created_at: "2026-10-03T00:00:00Z" },
{ id: 2, pipeline_id: 7, created_at: "2026-10-02T00:00:00Z" },
{ id: 5, pipeline_id: 9, created_at: "2026-10-01T00:00:00Z" },
];
const forward = latestRunByPipeline(runs);
const backward = latestRunByPipeline([...runs].reverse());
assert.equal(forward.get(7).id, 3);
assert.equal(backward.get(7).id, 3);
assert.equal(forward.get(9).id, 5);
assert.equal(forward.size, 2);
});
test("isMoreRecent breaks an exact timestamp tie (and a bad timestamp) with the higher id", () => {
const sameTime = { created_at: "2026-10-01T00:00:00Z" };
assert.equal(isMoreRecent({ id: 7, ...sameTime }, { id: 5, ...sameTime }), true);
assert.equal(isMoreRecent({ id: 5, ...sameTime }, { id: 7, ...sameTime }), false);
assert.equal(isMoreRecent({ id: 8, created_at: "bad" }, { id: 6, created_at: "also bad" }), true);
assert.equal(isMoreRecent({ id: 6, created_at: "bad" }, { id: 8, created_at: "bad" }), false);
});
test("runBadgeMetaLine omits missing fragments but always prints the run id", () => {
assert.equal(runBadgeMetaLine({ ranAgo: "2h ago", duration: "1m 5s", runId: 42 }), "2h ago · 1m 5s · run 42");
assert.equal(runBadgeMetaLine({ ranAgo: null, duration: "1m 5s", runId: 42 }), "1m 5s · run 42");
assert.equal(runBadgeMetaLine({ ranAgo: "2h ago", duration: null, runId: 42 }), "2h ago · run 42");
assert.equal(runBadgeMetaLine({ ranAgo: null, duration: null, runId: 42 }), "run 42");
assert.equal(runBadgeMetaLine({ ranAgo: "", duration: "", runId: 7 }), "run 7");
});
test("runBadge bundles the state, age, duration and run id", () => {
const start = "2026-10-17T21:00:00Z";
const badge = runBadge(
{ id: 12, status: "failed", created_at: start, finished_at: "2026-10-17T21:02:05Z", executing: false },
Date.parse(start) + 3600_000,
);
assert.deepEqual(badge, { runId: 12, state: "failed", ranAgo: "1h ago", duration: "2m 5s" });
});
// ---------------------------------------------------------------------------
// Sorting
// ---------------------------------------------------------------------------
const P = (id, name, stages) => ({ id, name, stages, version: 1 });
function ids(list) {
return list.map((p) => p.id);
}
test("the sort list matches the app's labels with Server order default", () => {
assert.deepEqual(
PIPELINE_SORTS.map((option) => option.label),
["Server order", "Name A\u2013Z", "Name Z\u2013A", "Most recent run", "Fewest stages", "Most stages"],
);
assert.equal(PIPELINE_SORTS[0].key, "server_order");
});
test("server order preserves the server's own ordering (and never mutates the input)", () => {
const pipelines = [P(3, "beta", 2), P(1, "Alpha", 3), P(2, "alpha", 1), P(4, "Gamma", 1)];
assert.deepEqual(ids(sortPipelines(pipelines, "server_order")), [3, 1, 2, 4]);
assert.deepEqual(ids(pipelines), [3, 1, 2, 4], "input list is untouched");
});
test("name comparators ignore case and tie-break on the exact name then the id", () => {
const pipelines = [P(3, "beta", 2), P(1, "Alpha", 3), P(2, "alpha", 1), P(4, "Gamma", 1)];
assert.deepEqual(ids(sortPipelines(pipelines, "name_asc")), [1, 2, 3, 4]);
assert.deepEqual(ids(sortPipelines(pipelines, "name_desc")), [4, 3, 1, 2]);
});
test("stage-count comparators tie-break on the name then the id", () => {
const pipelines = [P(3, "beta", 2), P(1, "Alpha", 3), P(2, "alpha", 1), P(4, "Gamma", 1)];
assert.deepEqual(ids(sortPipelines(pipelines, "fewest_stages")), [2, 4, 3, 1]);
assert.deepEqual(ids(sortPipelines(pipelines, "most_stages")), [1, 3, 2, 4]);
});
test("most-recent-run puts no-run pipelines last and orders by run recency then run id", () => {
const pipelines = [P(1, "One", 1), P(2, "Two", 1), P(3, "Three", 1), P(4, "Four", 1)];
const latestRuns = new Map([
[1, { id: 11, pipeline_id: 1, created_at: "2026-10-03T00:00:00Z" }],
[3, { id: 10, pipeline_id: 3, created_at: "2026-10-01T00:00:00Z" }],
[4, { id: 9, pipeline_id: 4, created_at: "not a date" }],
]);
assert.deepEqual(ids(sortPipelines(pipelines, "recent_run", latestRuns)), [1, 3, 4, 2]);
});
test("most-recent-run breaks an exact timestamp tie with the higher run id", () => {
const pipelines = [P(1, "One", 1), P(2, "Two", 1)];
const at = "2026-10-01T00:00:00Z";
const latestRuns = new Map([
[1, { id: 4, pipeline_id: 1, created_at: at }],
[2, { id: 9, pipeline_id: 2, created_at: at }],
]);
assert.deepEqual(ids(sortPipelines(pipelines, "recent_run", latestRuns)), [2, 1]);
});
test("every comparator ends in a deterministic id tie-break", () => {
// Identical names and stage counts: only the id can decide, whatever the input order.
const pipelines = [P(5, "same", 2), P(2, "same", 2), P(9, "same", 2)];
assert.deepEqual(ids(sortPipelines(pipelines, "name_asc")), [2, 5, 9]);
assert.deepEqual(ids(sortPipelines([...pipelines].reverse(), "name_asc")), [2, 5, 9]);
assert.deepEqual(ids(sortPipelines(pipelines, "fewest_stages")), [2, 5, 9]);
assert.equal(typeof pipelineComparator("server_order"), "function");
});
// ---------------------------------------------------------------------------
// Filtering and empty states
// ---------------------------------------------------------------------------
test("the status filter vocabulary is exactly the server's seven run states", () => {
assert.deepEqual(RUN_STATUS_FILTERS, [
"queued",
"running",
"waiting",
"succeeded",
"failed",
"canceled",
"interrupted",
]);
assert.deepEqual(
RUN_PRESENCES.map((p) => p.label),
["Any", "Has runs", "No runs"],
);
});
const FILTER_PIPELINES = [P(1, "Android", 3), P(2, "Beta", 2), P(3, "Gamma", 1)];
const FILTER_RUNS = new Map([
[1, { id: 1, pipeline_id: 1, status: "succeeded" }],
[2, { id: 2, pipeline_id: 2, status: "failed" }],
]);
const FILTERS = (overrides = {}) => ({ presence: "any", lastRunStatuses: [], name: "", ...overrides });
test("the name facet narrows case-insensitively and needs no run history", () => {
assert.ok(pipelineMatchesName("", "anything"));
assert.ok(pipelineMatchesName("and", "Android"));
assert.ok(!pipelineMatchesName("zzz", "Android"));
assert.deepEqual(
filterPipelines(FILTER_PIPELINES, FILTERS({ name: "and" }), FILTER_RUNS, false).map((p) => p.id),
[1],
);
});
test("run facets AND together and a no-run pipeline never matches a selected status", () => {
assert.ok(pipelineMatchesPresence("any", false));
assert.ok(pipelineMatchesPresence("has_runs", true));
assert.ok(!pipelineMatchesPresence("has_runs", false));
assert.ok(pipelineMatchesPresence("no_runs", false));
assert.ok(pipelineMatchesLastRunStatus(null, []));
assert.ok(!pipelineMatchesLastRunStatus(null, ["failed"]));
assert.deepEqual(
filterPipelines(FILTER_PIPELINES, FILTERS({ presence: "has_runs" }), FILTER_RUNS, true).map((p) => p.id),
[1, 2],
);
assert.deepEqual(
filterPipelines(FILTER_PIPELINES, FILTERS({ presence: "no_runs" }), FILTER_RUNS, true).map((p) => p.id),
[3],
);
assert.deepEqual(
filterPipelines(FILTER_PIPELINES, FILTERS({ lastRunStatuses: ["failed"] }), FILTER_RUNS, true).map((p) => p.id),
[2],
);
});
test("a run facet is skipped while the run history is unknown, and the name still applies", () => {
assert.deepEqual(
filterPipelines(FILTER_PIPELINES, FILTERS({ presence: "has_runs" }), FILTER_RUNS, false).map((p) => p.id),
[1, 2, 3],
);
assert.deepEqual(
filterPipelines(FILTER_PIPELINES, FILTERS({ presence: "has_runs", name: "Beta" }), FILTER_RUNS, false).map((p) => p.id),
[2],
);
});
test("pipelineFilterCount counts one per active facet", () => {
assert.equal(pipelineFilterCount(FILTERS()), 0);
assert.equal(pipelineFilterCount(FILTERS({ name: "a" })), 1);
assert.equal(pipelineFilterCount(FILTERS({ presence: "has_runs", lastRunStatuses: ["failed"], name: "a" })), 3);
});
test("empty states use the app's three exact sentences and only offer a reset when pipelines exist", () => {
assert.deepEqual(pipelineListEmptyState([], [], FILTERS()), {
message: "No pipelines are defined on this server.",
clearAction: null,
});
assert.deepEqual(pipelineListEmptyState(FILTER_PIPELINES, [], FILTERS({ name: "zzz" })), {
message: 'No pipelines match "zzz".',
clearAction: "Clear filters",
});
assert.deepEqual(pipelineListEmptyState(FILTER_PIPELINES, [], FILTERS({ presence: "has_runs" })), {
message: "No pipelines match the current filters.",
clearAction: "Clear filters",
});
// A name narrowing combined with a run facet is no longer name-only.
assert.equal(
pipelineListEmptyState(FILTER_PIPELINES, [], FILTERS({ name: "zzz", presence: "has_runs" })).message,
"No pipelines match the current filters.",
);
assert.equal(pipelineListEmptyState(FILTER_PIPELINES, FILTER_PIPELINES, FILTERS()), null);
});
// ---------------------------------------------------------------------------
// List row and detail text
// ---------------------------------------------------------------------------
test("pipelineSubtitle is 'id {id} · v{version} · {N stages}' with a singular stage", () => {
assert.equal(pipelineSubtitle({ id: 20, version: 10, stages: 5 }), "id 20 · v10 · 5 stages");
assert.equal(pipelineSubtitle({ id: 3, version: 1, stages: 1 }), "id 3 · v1 · 1 stage");
assert.equal(pipelineSubtitle({ id: 4, version: 2, graph: { stages: [{}, {}] } }), "id 4 · v2 · 2 stages");
});
test("pipelineUpdatedLine is 'updated d MMM HH:mm' or null for a bad timestamp", () => {
const line = pipelineUpdatedLine({ updated_at: "2026-10-17T21:57:31Z" });
assert.ok(LOCAL_STAMP.test(line.replace(/^updated /, "")), line);
assert.equal(pipelineUpdatedLine({ updated_at: "" }), null);
assert.equal(pipelineUpdatedLine({ updated_at: "nope" }), null);
});
test("the detail tabs are Summary / Graph / Source in order", () => {
assert.deepEqual(PIPELINE_DETAIL_TABS.map((tab) => tab.label), ["Summary", "Graph", "Source"]);
});
test("summaryFields render the app's rows; latest version is v{n} or blank, never a dash", () => {
const fields = summaryFields({
content_hash: "abc123",
latest_version: 10,
version_created_at: "2026-10-18T23:41:08Z",
created_at: "2026-10-17T21:57:31Z",
updated_at: "2026-10-18T23:41:08Z",
});
assert.deepEqual(fields.map((f) => f.key), [
"Content hash",
"Latest version",
"Version created",
"Pipeline created",
"Pipeline updated",
]);
assert.equal(fields[0].value, "abc123");
assert.equal(fields[0].monospace, true);
assert.equal(fields[1].value, "v10");
for (const field of fields.slice(2)) assert.ok(LOCAL_STAMP.test(field.value), field.value);
const blank = summaryFields({ content_hash: "", latest_version: 0 });
assert.equal(blank[1].value, "");
assert.equal(blank[2].value, "");
});
test("versionRow shows v{n} plus its stage count and created time", () => {
const row = versionRow({ version: 2, stages: 1, created_at: "2026-10-18T19:04:13Z" });
assert.equal(row.versionLabel, "v2");
assert.equal(row.stagesText, "1 stage");
assert.ok(LOCAL_STAMP.test(row.createdText));
assert.equal(versionRow({ version: 3, stages: 4 }).createdText, null);
});
test("the graph note is the browser wording and leaves the graph to P6", () => {
const note = graphNote();
assert.match(note, /Mouse wheel to zoom, drag to pan, click a stage for details/);
assert.match(note, /Edges are labelled with their outcome/);
});
+93 -14
View File
@@ -37,6 +37,16 @@ function step(label) {
console.log(`• ${label}`);
}
async function shot(name) {
const path = `${out}/${name}`;
shots.push(await page.screenshot(path));
console.log(` capture ${path}`);
return path;
}
const text = (selector) =>
page.evaluate(`document.querySelector(${JSON.stringify(selector)})?.textContent ?? ""`);
try {
await mkdir(out, { recursive: true });
@@ -67,17 +77,86 @@ try {
await page.waitForSelector(".row-title", { timeout: 25000 });
await page.waitForText("connected", { timeout: 25000 });
const pipelineCount = await page.evaluate(
`document.querySelectorAll(".list button.row").length`,
`document.querySelectorAll("#pipelineRows button.row").length`,
);
if (!pipelineCount) throw new Error("connected but no pipelines rendered");
shots.push(await page.screenshot(`${out}/01-pipelines.png`));
console.log(` pipelines rendered: ${pipelineCount}`);
step("opening a pipeline detail");
await page.click(".list button.row");
// 1. The list with its filter menu open: the name field, the Runs section, the
// Last run status multi-select and the Clear filters reset (P1 + P2).
step("capturing the pipeline list with the filter menu open");
await page.click("#filterToggle");
await page.waitForSelector(".filter-panel");
await shot("01-pipelines-controls.png");
// 2. The sort menu, and exercising it changes the ordering (P2).
step("capturing and exercising the sort menu");
await page.click("#sortToggle");
await page.waitForSelector(".sort-panel");
await shot("02-pipelines-sort.png");
await page.clickText(".sort-panel .sort-option", "Name A\u2013Z");
const sorted = await text("#sortToggle");
if (!sorted.includes("Name A\u2013Z")) throw new Error(`sort did not apply: ${sorted}`);
await page.click("#sortToggle");
await page.waitForSelector(".sort-panel");
await page.clickText(".sort-panel button", "Reset");
const reset = await text("#sortToggle");
if (!reset.includes("Server order")) throw new Error(`sort reset failed: ${reset}`);
// 3. The name facet narrows live; an unmatched name shows the name-only empty state.
step("narrowing by name and capturing the name-only empty state");
await page.click("#filterToggle");
await page.waitForSelector(".filter-panel");
await page.fill("#pipelineNameFilter", "Android");
const narrowed = await page.evaluate(
`document.querySelectorAll("#pipelineRows button.row").length`,
);
if (!narrowed || narrowed >= pipelineCount) {
throw new Error(`name filter did not narrow (${narrowed} of ${pipelineCount})`);
}
console.log(` name filter narrowed ${pipelineCount} -> ${narrowed}`);
await page.fill("#pipelineNameFilter", "zzz-no-such-pipeline");
await page.waitForText('No pipelines match "zzz-no-such-pipeline".');
await shot("03-pipelines-empty-name.png");
await page.click(".empty button");
await page.waitForSelector("#pipelineRows button.row");
// 4. A run facet with no matches shows the general empty state and a reset.
step("capturing the run-facet empty state");
await page.click("#status-interrupted");
await page.waitForText("No pipelines match the current filters.");
await shot("04-pipelines-empty-filters.png");
await page.click(".empty button");
await page.waitForSelector("#pipelineRows button.row");
await page.click("#filterToggle");
// 5. Pipeline detail: Summary (name, subtitle, content hash, created/updated).
step("opening a pipeline detail (Summary)");
await page.click("#pipelineRows button.row");
await page.waitForSelector(".detail h2");
shots.push(await page.screenshot(`${out}/02-pipeline-detail.png`));
await page.waitForSelector(".monospace");
await page.evaluate(`document.querySelector(".detail")?.scrollIntoView({ block: "start" })`);
await shot("05-pipeline-summary.png");
// 6. The Versions section is collapsed by default; expanding shows its rows.
step("expanding the Versions section");
await page.click(".section-toggle");
await page.waitForSelector(".versions-list");
await page.evaluate(`document.querySelector(".versions-list")?.scrollIntoView({ block: "start" })`);
await shot("06-pipeline-summary-versions.png");
// 7. Source tab: the rendered pipeline source in a monospace block.
step("opening the Source tab");
await page.clickText(".detail-tabs button", "Source");
await page.waitForSelector(".source-code");
await page.evaluate(`document.querySelector(".detail")?.scrollIntoView({ block: "start" })`);
await shot("07-pipeline-source.png");
// 8. Graph tab: the guidance note only; the rendered graph is P6.
step("opening the Graph tab (guidance note only)");
await page.clickText(".detail-tabs button", "Graph");
await page.waitForSelector(".graph-note");
await shot("08-pipeline-graph.png");
step("switching to Runs: day-grouped list + usage roll-up");
await page.clickText("nav.tabs button.tab", "Runs");
@@ -98,7 +177,7 @@ try {
}
const fullDateHeader = dayHeaders.find((label) => /^\d{1,2} \w{3} \d{4}$/.test(label));
if (!fullDateHeader) throw new Error(`no full-date day header: ${dayHeaders.join(" | ")}`);
shots.push(await page.screenshot(`${out}/04-runs-day-groups.png`));
shots.push(await page.screenshot(`${out}/09-runs-day-groups.png`));
console.log(` usage: ${usageLabels.join(", ")}`);
console.log(` day headers: ${dayHeaders.slice(0, 3).join(" | ")}`);
@@ -112,7 +191,7 @@ try {
return header.textContent;
})()`);
if (!scrolledTo) throw new Error("could not scroll to the older day group");
shots.push(await page.screenshot(`${out}/07-runs-older-day-group.png`));
shots.push(await page.screenshot(`${out}/10-runs-older-day-group.png`));
console.log(` scrolled to: ${scrolledTo}`);
step("opening the filter menu: it must stay in the viewport and be reachable");
@@ -169,7 +248,7 @@ try {
if (!reach.actionsReachable) {
throw new Error(`the filter menu actions are unreachable: ${JSON.stringify(reach)}`);
}
shots.push(await page.screenshot(`${out}/08-runs-filter-menu.png`));
shots.push(await page.screenshot(`${out}/11-runs-filter-menu.png`));
console.log(` filter menu ${reach.height}px tall in a ${reach.viewport}px viewport; actions reachable`);
step("applying a status filter");
@@ -188,7 +267,7 @@ try {
if (!filteredChips.every((chip) => chip === "failed")) {
throw new Error(`filtered rows are not all failed: ${filteredChips.join(",")}`);
}
shots.push(await page.screenshot(`${out}/05-runs-filtered.png`));
shots.push(await page.screenshot(`${out}/12-runs-filtered.png`));
console.log(` filtered rows: ${filteredChips.length}, all failed`);
step("filtering to a state with no runs: the filtered-empty state + Clear filters");
@@ -214,7 +293,7 @@ try {
if (clearAction !== "Clear filters") {
throw new Error(`the filtered-empty state should offer Clear filters, got: ${clearAction}`);
}
shots.push(await page.screenshot(`${out}/09-runs-filtered-empty.png`));
shots.push(await page.screenshot(`${out}/13-runs-filtered-empty.png`));
console.log(` empty state: ${emptyMessage} (+ ${clearAction})`);
step("clearing the filters from the empty state and changing the sort");
@@ -238,20 +317,20 @@ try {
]) {
if (!sortItems.includes(label)) throw new Error(`sort menu missing: ${label}`);
}
shots.push(await page.screenshot(`${out}/10-runs-sort-menu.png`));
shots.push(await page.screenshot(`${out}/14-runs-sort-menu.png`));
await page.clickText("#runSortMenu .menu-item", "Pipeline name");
const sortLabel = await page.evaluate(`document.querySelector("#runSortBtn").textContent`);
if (!sortLabel.includes("Pipeline name")) {
throw new Error(`the sort control did not change: ${sortLabel}`);
}
await page.waitForSelector(".list.runs .run-row", { timeout: 25000 });
shots.push(await page.screenshot(`${out}/06-runs-sorted.png`));
shots.push(await page.screenshot(`${out}/15-runs-sorted.png`));
console.log(` sort control now: ${sortLabel}`);
step("opening a run detail");
await page.click(".list.runs .run-row");
await page.waitForSelector(".detail h2", { timeout: 25000 });
shots.push(await page.screenshot(`${out}/03-run-detail.png`));
await shot("16-run-detail.png");
console.log("\nUI SMOKE PASS");
for (const shot of shots) console.log(` ${shot}`);