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
+5
View File
@@ -23,6 +23,11 @@ android/.kotlin/
android/local.properties
android/**/build/
android/captures/
# Web client: review captures (`ui-smoke.mjs --out captures`) are evidence, not
# tracked source. They live beside the checkout, so the whole name is ignored to
# keep the delivery checkout clean for landing.
captures/
android/.idea/
android/*.iml
android/**/*.apk
+3 -3
View File
@@ -21,9 +21,9 @@ Status legend: `todo` · `partial` (some of it works) · `done` (working + captu
## Pipelines
| # | Feature | Protocol | Status |
| --- | --- | --- | --- |
| P1 | Pipeline list | `list_pipelines` | partial (list + count only) |
| P2 | Filter + sort (status/name/updated) | client-side | todo |
| P3 | Pipeline detail: stages, graph, versions, last run, content hash | `get_pipeline` | todo |
| P1 | Pipeline list | `list_pipelines` | done — row: name; `id {id} · v{version} · {N stages}`; `updated d MMM HH:mm`; last-run line joined from `list_runs` (status chip + `{ago} · {duration} · run {id}`, or `no runs recorded`) |
| P2 | Filter + sort (status/name/updated) | client-side | done — Filter menu (name contains, Runs Any/Has runs/No runs, Last run status over the 7 server states, Clear filters) + Sort menu (Server order default, Name A–Z/Z–A, Most recent run, Fewest/Most stages, Reset); server order preserved |
| P3 | Pipeline detail: stages, graph, versions, last run, content hash | `get_pipeline` | done — Summary/Graph/Source tabs; Summary shows content hash (monospace), latest version (`v{n}` or blank), created/updated, and a collapsed-by-default Versions section. Graph tab shows the browser guidance note only; the rendered graph is P6 |
| P4 | Templates gallery + template detail | `list_templates` | todo |
| P5 | Create pipeline from a template (validate then submit) | `validate`, `submit` | todo |
| P6 | Workflow graph rendering (nodes, edges, stage panes) | `get_pipeline` | todo |
+336 -39
View File
@@ -4,6 +4,25 @@
import { PipelinesClient } from "./client.js";
import { PipelinesRepository } from "./repository.js";
import { validateServerUrl, resolveArtifactUrl } from "./serverUrl.js";
import {
PIPELINE_SORTS,
PIPELINE_DETAIL_TABS,
RUN_PRESENCES,
RUN_STATUS_FILTERS,
EMPTY_PIPELINE_FILTERS,
filterPipelines,
graphNote,
latestRunByPipeline,
pipelineFilterCount,
pipelineListEmptyState,
pipelineSubtitle,
pipelineUpdatedLine,
runBadge,
runBadgeMetaLine,
sortPipelines,
summaryFields,
versionRow,
} from "./pipelines.js";
import {
RUN_STATES,
RUN_TIME_RANGES,
@@ -63,6 +82,16 @@ const state = {
runDetail: null,
selectedPipelineId: null,
selectedRunId: null,
// Pipelines view: client-side filter/sort/detail-tab state. The run history is
// fetched alongside the pipelines so the list can show each pipeline's last
// run; runsLoaded tells a genuinely empty history apart from one not in hand.
pipelineFilters: { ...EMPTY_PIPELINE_FILTERS },
pipelineSort: "server_order",
pipelineMenu: null,
pipelineTab: "summary",
versionsExpanded: false,
pipelinesLoaded: false,
runsLoaded: false,
loading: false,
error: "",
runFilters: defaultRunFilters(),
@@ -231,28 +260,234 @@ function tabButton(view, label) {
function renderPipelineList() {
const list = h("div", { class: "list" });
if (state.loading && !state.pipelines.length) {
list.append(h("div", { class: "muted pad", text: "Loading…" }));
return list;
}
if (!state.pipelines.length) {
list.append(h("div", { class: "muted pad", text: "No pipelines." }));
return list;
}
for (const p of state.pipelines) {
list.append(
list.append(renderPipelineControls());
const rows = h("div", { id: "pipelineRows" });
fillPipelineRows(rows);
list.append(rows);
return list;
}
/**
* The list's filter + sort toolbar and (when open) the matching menu panel. The
* rows themselves live in the separate `#pipelineRows` container so a keystroke
* in the name filter can refresh just the rows without rebuilding (and so
* blurring) the input the operator is typing in.
*/
function renderPipelineControls() {
const filters = state.pipelineFilters;
const count = pipelineFilterCount(filters);
const panel = state.pipelineMenu;
const controls = h(
"div",
{ class: "list-controls" },
h(
"div",
{ class: "list-toolbar" },
h(
"button",
{
class: `row${state.selectedPipelineId === p.id ? " selected" : ""}`,
onclick: () => selectPipeline(p),
id: "filterToggle",
class: `control${panel === "filter" ? " active" : ""}`,
onclick: () => {
state.pipelineMenu = panel === "filter" ? null : "filter";
renderContent();
},
},
h("span", { class: "row-title", text: p.name || `pipeline ${p.id}` }),
h("span", { class: "row-meta", text: `#${p.id} · v${p.version} · ${p.stages} stage${p.stages === 1 ? "" : "s"}` }),
h("span", { text: "Filter" }),
h("span", { id: "filterCount", class: "count", text: count ? ` (${count})` : "" }),
),
h("button", {
id: "sortToggle",
class: `control${panel === "sort" ? " active" : ""}`,
text: `Sort: ${pipelineSortLabel(state.pipelineSort)}`,
onclick: () => {
state.pipelineMenu = panel === "sort" ? null : "sort";
renderContent();
},
}),
h("button", {
id: "clearFilters",
class: "ghost clear",
text: "Clear filters",
hidden: count === 0,
onclick: clearPipelineFilters,
}),
),
);
if (panel === "filter") controls.append(renderFilterPanel());
if (panel === "sort") controls.append(renderSortPanel());
return controls;
}
function renderFilterPanel() {
const filters = state.pipelineFilters;
const panel = h("div", { class: "menu-panel filter-panel" });
panel.append(h("div", { class: "filter-section", text: "Name" }));
panel.append(
h(
"label",
{ class: "filter-field" },
h("span", { class: "filter-field-label", text: "Pipeline name contains" }),
h("input", {
id: "pipelineNameFilter",
type: "text",
value: filters.name,
spellcheck: "false",
oninput: (e) => {
state.pipelineFilters = { ...state.pipelineFilters, name: e.target.value };
// Targeted refresh: the input keeps focus and its value while the
// list narrows behind it.
refreshPipelineRows();
},
}),
),
);
panel.append(h("div", { class: "filter-section", text: "Runs" }));
for (const presence of RUN_PRESENCES) {
panel.append(
h(
"label",
{ class: "filter-item" },
h("input", {
type: "radio",
name: "runPresence",
checked: filters.presence === presence.key,
onchange: () => {
state.pipelineFilters = { ...state.pipelineFilters, presence: presence.key };
renderContent();
},
}),
h("span", { text: presence.label }),
),
);
}
return list;
panel.append(h("div", { class: "filter-section", text: "Last run status" }));
for (const status of RUN_STATUS_FILTERS) {
panel.append(
h(
"label",
{ class: "filter-item" },
h("input", {
id: `status-${status}`,
type: "checkbox",
checked: filters.lastRunStatuses.includes(status),
onchange: (e) => {
const next = e.target.checked
? [...state.pipelineFilters.lastRunStatuses, status]
: state.pipelineFilters.lastRunStatuses.filter((s) => s !== status);
state.pipelineFilters = { ...state.pipelineFilters, lastRunStatuses: next };
renderContent();
},
}),
h("span", { text: status }),
),
);
}
panel.append(
h("div", { class: "filter-actions" }, h("button", { class: "ghost", text: "Clear filters", onclick: clearPipelineFilters })),
);
return panel;
}
function renderSortPanel() {
const panel = h("div", { class: "menu-panel sort-panel" });
for (const option of PIPELINE_SORTS) {
panel.append(
h("button", {
class: `sort-option${state.pipelineSort === option.key ? " active" : ""}`,
text: option.label,
onclick: () => {
state.pipelineSort = option.key;
state.pipelineMenu = null;
renderContent();
},
}),
);
}
panel.append(
h(
"div",
{ class: "filter-actions" },
h("button", {
class: "ghost",
text: "Reset",
onclick: () => {
state.pipelineSort = "server_order";
state.pipelineMenu = null;
renderContent();
},
}),
),
);
return panel;
}
/** Re-renders the rows and the toolbar's active-filter badge after a filter change. */
function refreshPipelineRows() {
const rows = document.getElementById("pipelineRows");
if (rows) fillPipelineRows(rows);
const count = pipelineFilterCount(state.pipelineFilters);
const badge = document.getElementById("filterCount");
if (badge) badge.textContent = count ? ` (${count})` : "";
const clear = document.getElementById("clearFilters");
if (clear) clear.hidden = count === 0;
}
/** Sorts, filters and renders the pipeline rows (or the matching empty state) into `rowsEl`. */
function fillPipelineRows(rowsEl) {
const latestRuns = latestRunByPipeline(state.runs);
const runsKnown = state.runsLoaded;
const now = Date.now();
const nodes = [];
if (state.loading && !state.pipelines.length) {
nodes.push(h("div", { class: "muted pad", text: "Loading pipelines…" }));
} else if (!state.pipelinesLoaded) {
nodes.push(h("div", { class: "muted pad", text: "Connect to the server to load pipelines." }));
} else {
const sorted = sortPipelines(state.pipelines, state.pipelineSort, latestRuns);
const items = filterPipelines(sorted, state.pipelineFilters, latestRuns, runsKnown);
if (items.length) {
for (const pipeline of items) nodes.push(renderPipelineRow(pipeline, latestRuns, runsKnown, now));
} else {
const empty = pipelineListEmptyState(state.pipelines, items, state.pipelineFilters);
const box = h("div", { class: "empty pad" }, h("div", { class: "muted", text: empty.message }));
if (empty.clearAction) {
box.append(h("button", { class: "ghost", text: empty.clearAction, onclick: clearPipelineFilters }));
}
nodes.push(box);
}
}
rowsEl.replaceChildren(...nodes);
}
function renderPipelineRow(pipeline, latestRuns, runsKnown, now) {
const children = [
h("span", { class: "row-title", text: pipeline.name || `pipeline ${pipeline.id}` }),
h("span", { class: "row-meta", text: pipelineSubtitle(pipeline) }),
];
const updated = pipelineUpdatedLine(pipeline);
if (updated) children.push(h("span", { class: "row-meta", text: updated }));
if (runsKnown) {
const run = latestRuns.get(pipeline.id);
if (!run) {
children.push(h("span", { class: "row-meta muted", text: "no runs recorded" }));
} else {
const badge = runBadge(run, now);
children.push(
h(
"span",
{ class: "row-run" },
h("span", { class: `chip chip-${badge.state}`, text: badge.state }),
h("span", { class: "row-meta", text: runBadgeMetaLine(badge) }),
),
);
}
}
return h(
"button",
{ class: `row${state.selectedPipelineId === pipeline.id ? " selected" : ""}`, onclick: () => selectPipeline(pipeline) },
...children,
);
}
function renderPipelineDetail() {
@@ -262,40 +497,91 @@ function renderPipelineDetail() {
pane.append(h("div", { class: "muted pad", text: "Select a pipeline." }));
return pane;
}
pane.append(h("h2", { text: d.name || `pipeline ${d.id}` }));
pane.append(
h("h2", { text: d.name || `pipeline ${d.id}` }),
h(
"div",
{ class: "kv" },
kv("ID / version", `#${d.id} · v${d.version}`),
kv("Stages", String(d.stages ?? (d.graph?.stages?.length ?? 0))),
kv("Content hash", d.content_hash || "—"),
kv("Created", fmtTime(d.created_at)),
kv("Updated", fmtTime(d.updated_at)),
kv("Latest version", d.latest_version ? String(d.latest_version) : "—"),
{ class: "detail-tabs" },
...PIPELINE_DETAIL_TABS.map((tab) =>
h("button", {
class: `detail-tab${state.pipelineTab === tab.key ? " active" : ""}`,
text: tab.label,
onclick: () => {
state.pipelineTab = tab.key;
renderContent();
},
}),
),
),
);
const stages = d.graph?.stages ?? [];
if (stages.length) {
pane.append(h("h3", { text: "Stages" }));
const ul = h("ul", { class: "stages" });
for (const s of stages) {
const outcomes = Object.keys(s.edges ?? {}).join(", ");
ul.append(
h(
"li",
{},
h("code", { text: s.key }),
s.type ? h("span", { class: "chip", text: s.type }) : null,
outcomes ? h("span", { class: "muted", text: `→ ${outcomes}` }) : null,
),
);
if (state.pipelineTab === "graph") {
pane.append(h("p", { class: "graph-note muted", text: graphNote() }));
return pane;
}
if (state.pipelineTab === "source") {
pane.append(h("pre", { class: "source-code" }, h("code", { text: d.source || "" })));
return pane;
}
pane.append(h("div", { class: "detail-subtitle muted", text: pipelineSubtitle({ ...d, stages: d.graph?.stages?.length ?? d.stages }) }));
const rows = h("div", { class: "kv" });
for (const field of summaryFields(d)) {
rows.append(
h(
"div",
{ class: "kv-row" },
h("span", { class: "kv-key", text: field.key }),
h("span", { class: `kv-val${field.monospace ? " monospace" : ""}`, text: field.value }),
),
);
}
pane.append(rows);
pane.append(
h(
"button",
{
class: "section-toggle",
onclick: () => {
state.versionsExpanded = !state.versionsExpanded;
renderContent();
},
},
h("span", { class: "chevron", text: state.versionsExpanded ? "\u25be" : "\u25b8" }),
h("span", { text: "Versions" }),
),
);
if (state.versionsExpanded) {
const versions = d.versions ?? [];
const body = h("div", { class: "section-body versions-list" });
if (!versions.length) {
body.append(h("div", { class: "muted", text: "No versions recorded." }));
} else {
for (const version of versions) {
const row = versionRow(version);
body.append(
h(
"div",
{ class: "version-row" },
h("span", { class: "version-title", text: row.versionLabel }),
h("span", { class: "muted", text: row.stagesText }),
row.createdText ? h("span", { class: "muted", text: row.createdText }) : null,
),
);
}
}
pane.append(ul);
pane.append(body);
}
return pane;
}
function pipelineSortLabel(key) {
return (PIPELINE_SORTS.find((option) => option.key === key) ?? PIPELINE_SORTS[0]).label;
}
function clearPipelineFilters() {
state.pipelineFilters = { ...EMPTY_PIPELINE_FILTERS };
renderContent();
}
function renderRunList() {
const pane = h("div", { class: "list runs" });
pane.append(renderRunToolbar());
@@ -725,10 +1011,19 @@ async function loadCurrentView(force = false) {
try {
if (state.view === "pipelines") {
state.pipelines = await repo.listPipelines();
state.pipelinesLoaded = true;
// The last-run line joins list_runs onto the pipelines, so the history is
// fetched alongside them; runsLoaded distinguishes a genuinely empty
// history from one that has not arrived yet.
const { runs, usage } = await repo.listRuns();
state.runs = runs;
if (usage) state.usage = usage;
state.runsLoaded = true;
} else {
const { runs, usage } = await repo.listRuns();
state.runs = runs;
state.usage = usage;
state.runsLoaded = true;
}
state.loading = false;
renderContent();
@@ -744,6 +1039,8 @@ async function loadCurrentView(force = false) {
async function selectPipeline(summary) {
state.selectedPipelineId = summary.id;
state.pipelineDetail = null;
state.pipelineTab = "summary";
state.versionsExpanded = false;
renderContent();
try {
state.pipelineDetail = await repo.getPipeline(summary.id, summary.version);
+493
View File
@@ -0,0 +1,493 @@
// Pure pipeline-list/detail logic for the web client. Deliberately DOM-free:
// every helper here is a plain function a `node --test` can exercise without a
// browser, exactly like `client.js`. The DOM wiring lives in `app.js`.
//
// The wording and behaviour mirror the Android app one-for-one — the same
// singular/plural spelling, the same status vocabulary, the same comparator
// tie-breaks and the same empty-state sentences — because the web client's goal
// is feature parity, not a re-invention:
// ui/Format.kt, ui/screens/ListSort.kt, ui/screens/ListFilter.kt,
// ui/screens/PipelineLastRun.kt, ui/screens/PipelineDetailScreen.kt,
// ui/components/RunStatus.kt.
// ---------------------------------------------------------------------------
// Timestamps and durations (ui/Format.kt)
// ---------------------------------------------------------------------------
/**
* Parses an RFC3339 timestamp to epoch millis, or null when blank or
* unparseable. The single parser every time-reading helper shares, so a bad
* timestamp is handled the same way everywhere.
*/
export function parseInstant(text) {
if (typeof text !== "string" || text.trim() === "") return null;
const ms = Date.parse(text);
return Number.isNaN(ms) ? null : ms;
}
/**
* An RFC3339 timestamp as the app's one human, local rendering (`d MMM HH:mm`,
* e.g. `17 Oct 21:26`), or null when blank/unparseable so the caller omits the
* value rather than printing a blank. The day/month/hour/minute parts are
* assembled from `Intl.DateTimeFormat.formatToParts`, so no locale's list comma
* leaks into the string and the shape is the same everywhere. `timeZone` is
* accepted for deterministic tests; `locale` defaults to a fixed English so the
* month abbreviation matches the app's `d MMM` wording rather than drifting with
* the host locale.
*/
export function formatLocalTimestamp(instant, options = {}) {
const ms = parseInstant(instant);
if (ms === null) return null;
const { timeZone, locale = "en-GB" } = options;
const parts = new Intl.DateTimeFormat(locale, {
day: "numeric",
month: "short",
hour: "2-digit",
minute: "2-digit",
hourCycle: "h23",
...(timeZone ? { timeZone } : {}),
}).formatToParts(new Date(ms));
const get = (type) => parts.find((part) => part.type === type)?.value ?? "";
return `${get("day")} ${get("month")} ${get("hour")}:${get("minute")}`;
}
/**
* Human duration for a whole number of seconds: `45s`, `2m 5s`, `1h 2m`. The
* single duration rule every surface shares. A negative total renders as `0s`
* so a clamped value never prints a negative.
*/
export function formatDuration(totalSeconds) {
const seconds = Math.max(0, Math.trunc(totalSeconds));
if (seconds < 60) return `${seconds}s`;
if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
}
/**
* Non-negative whole seconds between two RFC3339 timestamps, or null when either
* is blank/unparseable or the end precedes the start.
*/
export function durationSeconds(start, end) {
const from = parseInstant(start);
const to = parseInstant(end);
if (from === null || to === null) return null;
const seconds = Math.floor((to - from) / 1000);
return seconds >= 0 ? seconds : null;
}
/**
* Non-negative whole seconds from a `start` timestamp to `nowMillis`, or null
* when `start` is blank/unparseable. Clamps a future/unparseable elapsed to 0 so
* a live timer never prints a negative.
*/
export function secondsSince(start, nowMillis) {
const from = parseInstant(start);
if (from === null) return null;
return Math.max(0, Math.floor((nowMillis - from) / 1000));
}
/**
* The time a run has taken so far: while it is still executing, its live elapsed
* from its start to `nowMs`; once finished, its stored total duration. Null when
* the needed timestamps are unusable, so the caller omits the value.
*/
export function runDurationText(run, nowMs) {
if (run && run.executing) {
const elapsed = secondsSince(run.created_at, nowMs);
return elapsed === null ? null : formatDuration(elapsed);
}
const total = durationSeconds(run?.created_at, run?.finished_at);
return total === null ? null : formatDuration(total);
}
/**
* A compact "how long ago" for a run's start: `just now` under a minute, then
* `Nm ago`/`Nh ago`/`Nd ago`. Null when the timestamp is blank/unparseable so
* the caller omits the fragment instead of printing a blank. A future start
* (clock skew) reads as `just now`, never a negative age.
*/
export function formatRanAgo(createdAt, nowMs) {
const start = parseInstant(createdAt);
if (start === null) return null;
const seconds = Math.max(0, Math.floor((nowMs - start) / 1000));
if (seconds < 60) return "just now";
if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
return `${Math.floor(seconds / 86400)}d ago`;
}
/**
* A stage count in the app's one singular/plural spelling (`1 stage` /
* `n stages`), shared by the list and the detail so a single-stage pipeline
* never reads "1 stages".
*/
export function stageCountText(count) {
const n = Number(count) || 0;
return `${n} ${n === 1 ? "stage" : "stages"}`;
}
// ---------------------------------------------------------------------------
// Run states (ui/components/RunStatus.kt)
// ---------------------------------------------------------------------------
const RUN_STATE_ALIASES = {
running: "running",
queued: "queued",
waiting: "waiting",
active: "active",
succeeded: "succeeded",
success: "succeeded",
completed: "succeeded",
done: "succeeded",
failed: "failed",
error: "failed",
canceled: "canceled",
cancelled: "canceled",
interrupted: "interrupted",
blocked: "blocked",
skipped: "skipped",
};
/**
* Maps a server status or outcome word to the app's run-state word, accepting
* the server's own vocabulary only. A blank or unrecognised value falls back to
* `unknown` so a bad value never crashes the UI.
*/
export function runStateOf(status) {
const key = String(status ?? "").trim().toLowerCase();
return RUN_STATE_ALIASES[key] ?? "unknown";
}
// ---------------------------------------------------------------------------
// Last-run join and badge (ui/screens/PipelineLastRun.kt)
// ---------------------------------------------------------------------------
/** Shown for a pipeline that has recorded no run. */
export const NO_RUNS_RECORDED = "no runs recorded";
/**
* Timestamps decide recency; the higher run id breaks an exact tie (or a bad
* timestamp). The one recency rule, shared by the per-pipeline last-run join
* and the "most recent run" ordering.
*/
export function isMoreRecent(candidate, current) {
const a = parseInstant(candidate.created_at);
const b = parseInstant(current.created_at);
if (a !== null && b !== null && a !== b) return a > b;
return candidate.id > current.id;
}
/**
* Joins the whole run history onto pipelines by pipeline id: the most recent
* run per pipeline. The input order never matters — recency is decided from the
* timestamps, with the higher run id breaking an exact tie — so a pipeline with
* no runs is simply absent from the result (the caller renders
* [NO_RUNS_RECORDED] for it).
*/
export function latestRunByPipeline(runs) {
const latest = new Map();
for (const run of runs ?? []) {
const current = latest.get(run.pipeline_id);
if (current === undefined || isMoreRecent(run, current)) latest.set(run.pipeline_id, run);
}
return latest;
}
/** The display facts one pipeline row shows for `run`, anchored to `nowMs`. */
export function runBadge(run, nowMs) {
return {
runId: run.id,
state: runStateOf(run.status),
ranAgo: formatRanAgo(run.created_at, nowMs),
duration: runDurationText(run, nowMs),
};
}
/**
* The last-run secondary line, e.g. `2h ago · 1m 5s · run 42`. Missing
* fragments (an unparseable start, a run still executing) are omitted so no
* blank separator is ever printed; the run id is always present.
*/
export function runBadgeMetaLine(badge) {
const fragments = [badge.ranAgo, badge.duration, `run ${badge.runId}`];
return fragments.filter((fragment) => fragment != null && fragment !== "").join(" · ");
}
// ---------------------------------------------------------------------------
// Sorting (ui/screens/ListSort.kt)
// ---------------------------------------------------------------------------
/** The pipeline-list orderings offered by the sort control; Server order is the default. */
export const PIPELINE_SORTS = [
{ key: "server_order", label: "Server order" },
{ key: "name_asc", label: "Name A\u2013Z" },
{ key: "name_desc", label: "Name Z\u2013A" },
{ key: "recent_run", label: "Most recent run" },
{ key: "fewest_stages", label: "Fewest stages" },
{ key: "most_stages", label: "Most stages" },
];
/** Case-insensitive string comparison, matching String.CASE_INSENSITIVE_ORDER for ASCII. */
function compareInsensitive(a, b) {
const x = String(a ?? "").toUpperCase();
const y = String(b ?? "").toUpperCase();
if (x < y) return -1;
if (x > y) return 1;
return 0;
}
/** Plain (case-sensitive) string comparison for the comparator's second key. */
function compareSensitive(a, b) {
const x = String(a ?? "");
const y = String(b ?? "");
if (x < y) return -1;
if (x > y) return 1;
return 0;
}
/**
* The pure pipeline comparator for `sort`. Every case ends in an explicit
* tie-break (`id` is unique), so pipelines that compare equal on the primary
* key always order the same way rather than depending on the input order.
*
* `latestRuns` maps a pipeline id to that pipeline's most recent run (see
* [latestRunByPipeline]); only "Most recent run" uses it but it is passed in
* once so the fold is never repeated per comparison.
*/
export function pipelineComparator(sort, latestRuns = new Map()) {
const runFor = (pipeline) =>
latestRuns instanceof Map ? latestRuns.get(pipeline.id) : latestRuns[pipeline.id];
switch (sort) {
case "name_asc":
return (a, b) =>
compareInsensitive(a.name, b.name) ||
compareSensitive(a.name, b.name) ||
a.id - b.id;
case "name_desc":
return (a, b) =>
-compareInsensitive(a.name, b.name) ||
compareSensitive(a.name, b.name) ||
a.id - b.id;
case "recent_run":
return (a, b) => {
const ra = runFor(a);
const rb = runFor(b);
const noRunA = ra == null ? 1 : 0;
const noRunB = rb == null ? 1 : 0;
if (noRunA !== noRunB) return noRunA - noRunB;
const ta = ra ? parseInstant(ra.created_at) : null;
const tb = rb ? parseInstant(rb.created_at) : null;
const na = ta == null ? -Infinity : ta;
const nb = tb == null ? -Infinity : tb;
if (na !== nb) return na > nb ? -1 : 1;
const ia = ra ? ra.id : -Infinity;
const ib = rb ? rb.id : -Infinity;
if (ia !== ib) return ia > ib ? -1 : 1;
return a.id - b.id;
};
case "fewest_stages":
return (a, b) =>
(Number(a.stages) || 0) - (Number(b.stages) || 0) ||
compareInsensitive(a.name, b.name) ||
a.id - b.id;
case "most_stages":
return (a, b) =>
(Number(b.stages) || 0) - (Number(a.stages) || 0) ||
compareInsensitive(a.name, b.name) ||
a.id - b.id;
// Server order (and any unknown stored value): the identity comparator, so
// a stable sort preserves the server's own ordering exactly.
case "server_order":
default:
return () => 0;
}
}
/** Orders `pipelines` by `sort` without mutating the input, folding the run history once. */
export function sortPipelines(pipelines, sort, latestRuns = new Map()) {
return [...(pipelines ?? [])].sort(pipelineComparator(sort, latestRuns));
}
// ---------------------------------------------------------------------------
// Filtering (ui/screens/ListFilter.kt)
// ---------------------------------------------------------------------------
/**
* The statuses a filter can select: the server's own run vocabulary. The
* app-only `active` bucket, the stage-outcome words (`blocked`/`skipped`) and
* the `unknown` fallback are deliberately not offered, so a status filter
* always names a real run state.
*/
export const RUN_STATUS_FILTERS = [
"queued",
"running",
"waiting",
"succeeded",
"failed",
"canceled",
"interrupted",
];
/** The has/no-runs narrowing offered by the filter's Runs section. */
export const RUN_PRESENCES = [
{ key: "any", label: "Any" },
{ key: "has_runs", label: "Has runs" },
{ key: "no_runs", label: "No runs" },
];
/** The default, no-narrowing pipeline filter. */
export const EMPTY_PIPELINE_FILTERS = { presence: "any", lastRunStatuses: [], name: "" };
/** Whether a run-history facet (presence or last-run status) is set. */
export function hasRunFacets(filters) {
return (filters?.presence ?? "any") !== "any" || (filters?.lastRunStatuses ?? []).length > 0;
}
/** True when the filters actually narrow anything. */
export function pipelineFiltersActive(filters) {
return hasRunFacets(filters) || String(filters?.name ?? "").trim() !== "";
}
/** The number of active facets, used for the control's badge. */
export function pipelineFilterCount(filters) {
return (
((filters?.presence ?? "any") !== "any" ? 1 : 0) +
((filters?.lastRunStatuses ?? []).length > 0 ? 1 : 0) +
(String(filters?.name ?? "").trim() !== "" ? 1 : 0)
);
}
/** True when `name` is blank, or when `pipelineName` contains it, ignoring case. */
export function pipelineMatchesName(name, pipelineName) {
const needle = String(name ?? "").trim();
return needle === "" || String(pipelineName ?? "").toLowerCase().includes(needle.toLowerCase());
}
/** True when `presence` is satisfied by whether the pipeline has a run. */
export function pipelineMatchesPresence(presence, hasRun) {
switch (presence) {
case "has_runs":
return hasRun;
case "no_runs":
return !hasRun;
case "any":
default:
return true;
}
}
/**
* True when `latestRun`'s status is in `statuses`; an empty set means "any
* status" and a pipeline with no run never matches a selected status, so the
* filter genuinely narrows.
*/
export function pipelineMatchesLastRunStatus(latestRun, statuses) {
const wanted = statuses ?? [];
if (wanted.length === 0) return true;
return latestRun != null && wanted.includes(runStateOf(latestRun.status));
}
/**
* Narrows `pipelines` by `filters`: the name narrowing and both run facets
* combined with AND. The name facet never depends on the run history, so it
* applies immediately; the run facets do, so while that history is still
* unknown (`runsKnown == false`) they are skipped rather than briefly hiding
* every pipeline.
*/
export function filterPipelines(pipelines, filters, latestRuns = new Map(), runsKnown = true) {
const all = pipelines ?? [];
if (!pipelineFiltersActive(filters)) return all;
const runFacets = hasRunFacets(filters);
const getRun = (pipeline) =>
latestRuns instanceof Map ? latestRuns.get(pipeline.id) : latestRuns[pipeline.id];
return all.filter((pipeline) => {
if (!pipelineMatchesName(filters?.name, pipeline.name)) return false;
if (runFacets && runsKnown) {
const latestRun = getRun(pipeline) ?? null;
if (!pipelineMatchesPresence(filters.presence, latestRun != null)) return false;
if (!pipelineMatchesLastRunStatus(latestRun, filters.lastRunStatuses)) return false;
}
return true;
});
}
/**
* The empty-state sentence for the pipeline list plus its optional reset action.
* Returns null when there is something to show. `Clear filters` is only offered
* when pipelines exist (nothing exists to reveal otherwise).
*/
export function pipelineListEmptyState(all, items, filters) {
if ((items ?? []).length > 0) return null;
const every = all ?? [];
if (every.length === 0) {
return { message: "No pipelines are defined on this server.", clearAction: null };
}
const name = String(filters?.name ?? "");
const message =
name.trim() !== "" && !hasRunFacets(filters)
? `No pipelines match "${name}".`
: "No pipelines match the current filters.";
return { message, clearAction: "Clear filters" };
}
// ---------------------------------------------------------------------------
// List row and detail text
// ---------------------------------------------------------------------------
/** The pipeline row's secondary line: `id {id} · v{version} · {N stages}`. */
export function pipelineSubtitle(pipeline) {
const stages = pipeline.stages ?? pipeline.graph?.stages?.length ?? 0;
return `id ${pipeline.id} · v${pipeline.version} · ${stageCountText(stages)}`;
}
/** The row's `updated …` line, or null when the timestamp is unparseable. */
export function pipelineUpdatedLine(pipeline) {
const formatted = formatLocalTimestamp(pipeline.updated_at);
return formatted ? `updated ${formatted}` : null;
}
/** The pipeline-detail tabs, Summary first (the version list lives inside it). */
export const PIPELINE_DETAIL_TABS = [
{ key: "summary", label: "Summary" },
{ key: "graph", label: "Graph" },
{ key: "source", label: "Source" },
];
/**
* The Summary tab's key/value rows, in the app's order: Content hash
* (monospace), Latest version (`v{n}` or blank — never a dash), Version created,
* Pipeline created, Pipeline updated.
*/
export function summaryFields(detail) {
const latest = Number(detail?.latest_version) || 0;
return [
{ key: "Content hash", value: detail?.content_hash ?? "", monospace: true },
{ key: "Latest version", value: latest > 0 ? `v${latest}` : "" },
{ key: "Version created", value: formatLocalTimestamp(detail?.version_created_at) ?? "" },
{ key: "Pipeline created", value: formatLocalTimestamp(detail?.created_at) ?? "" },
{ key: "Pipeline updated", value: formatLocalTimestamp(detail?.updated_at) ?? "" },
];
}
/** One Version row: `v{n}` plus its stage count and (parseable) created time. */
export function versionRow(version) {
return {
versionLabel: `v${version?.version}`,
stagesText: stageCountText(version?.stages),
createdText: formatLocalTimestamp(version?.created_at),
};
}
/**
* The Graph tab's guidance note, adapted for a browser: mouse-wheel zoom and
* click replace the app's pinch and tap. The graph itself is the separate P6
* item.
*/
export const GRAPH_NOTE =
"Mouse wheel to zoom, drag to pan, click a stage for details. " +
"Edges are labelled with their outcome; error* is the implicit fallback.";
/** The guidance note string (a function so callers need no constant import). */
export function graphNote() {
return GRAPH_NOTE;
}
+49
View File
@@ -319,3 +319,52 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font-
color: var(--muted);
}
.run-list-error { padding: 12px 16px; color: var(--bad); }
/* Pipeline list: filter + sort controls. */
.list-controls { border-bottom: 1px solid var(--border); }
.list-toolbar { display: flex; gap: 6px; align-items: center; flex-wrap: wrap; padding: 8px 12px; }
.control { font-size: 12px; padding: 4px 10px; }
.control.active { border-color: var(--accent); color: var(--accent); }
.control .count { color: var(--accent); }
.clear { font-size: 12px; padding: 4px 10px; }
.menu-panel { border-top: 1px solid var(--border); padding: 8px 12px 12px; background: var(--surface); }
.filter-section { color: var(--muted); font-size: 11px; text-transform: uppercase; letter-spacing: 0.04em; margin: 10px 0 4px; }
.filter-field { display: block; }
.filter-field-label { display: block; color: var(--muted); font-size: 12px; margin-bottom: 4px; }
.filter-field input[type="text"] { flex: none; width: 100%; min-width: 0; }
.filter-item { display: flex; gap: 8px; align-items: center; padding: 3px 0; font-size: 13px; cursor: pointer; }
.filter-item input { accent-color: var(--accent); }
.filter-actions { margin-top: 10px; display: flex; gap: 8px; }
.sort-option { display: block; width: 100%; text-align: left; border: 1px solid transparent; background: transparent; padding: 5px 8px; border-radius: 6px; font-size: 13px; }
.sort-option:hover { background: var(--surface-2); }
.sort-option.active { border-color: var(--accent); color: var(--accent); }
.row-run { display: flex; gap: 8px; align-items: center; margin-top: 3px; }
.row-run .row-meta { margin-top: 0; }
.empty { display: grid; gap: 10px; justify-items: start; }
/* Pipeline detail: tab strip, collapsible sections, source block. */
.detail-tabs { display: flex; gap: 4px; margin: 10px 0 12px; border-bottom: 1px solid var(--border); }
.detail-tab { border: 0; border-bottom: 2px solid transparent; border-radius: 0; background: transparent; color: var(--muted); padding: 6px 10px; }
.detail-tab:hover { border-color: transparent; color: var(--text); }
.detail-tab.active { color: var(--accent); border-bottom-color: var(--accent); }
.detail-subtitle { font-size: 12px; margin-bottom: 10px; }
.monospace { font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace; font-size: 12px; }
.section-toggle { display: flex; gap: 8px; align-items: center; width: 100%; text-align: left; margin-top: 16px; border: 0; border-radius: 8px; background: var(--surface-2); padding: 8px 10px; font-weight: 600; }
.section-toggle .chevron { color: var(--muted); }
.section-body { padding: 8px 4px 0; display: grid; gap: 6px; }
.version-row { display: flex; gap: 12px; align-items: baseline; border: 1px solid var(--border); border-radius: 8px; padding: 6px 10px; }
.version-title { font-weight: 600; }
.source-code { margin: 0; background: var(--surface-2); border: 1px solid var(--border); border-radius: 10px; padding: 12px; overflow: auto; max-height: 60vh; }
.source-code code { background: transparent; padding: 0; font-family: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace; font-size: 12px; white-space: pre-wrap; word-break: break-word; }
.graph-note { margin: 0; max-width: 60ch; }
/* The waiting / canceled / interrupted hues are set once above, next to the
other status chips, so RunStatusPalette stays the single source of truth for
every status word. */
.chip-unknown { color: #bec9c5; border-color: #bec9c5; }
+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}`);