web: run history list, filter and sort (R1/R2)

Day-grouped run list with sticky day headers (Today / Yesterday / d MMM
yyyy / Unknown date), a usage roll-up block, the app's row hierarchy and
a bounded filter/sort menu — mirroring RunHistoryScreen.kt, ListFilter.kt
and ListSort.kt. New pure helpers live in src/runs.js with focused unit
tests; app.js keeps the wiring and sets server strings with textContent.

R1 done, R2 partial: no per-row "needs you" mark exists in the Android
app; its wording is deferred to R15 (separate attention surface).
This commit is contained in:
2026-10-19 02:50:51 +01:00
parent 4721b8af10
commit 849a184561
6 changed files with 1601 additions and 48 deletions
+2 -2
View File
@@ -31,8 +31,8 @@ Status legend: `todo` · `partial` (some of it works) · `done` (working + captu
## Runs
| # | Feature | Protocol | Status |
| --- | --- | --- | --- |
| R1 | Run history list with status roll-up | `list_runs` | partial (list only) |
| R2 | Filter by status, sort, "needs you" markers | client-side | todo |
| R1 | Run history list with status roll-up | `list_runs` | done |
| R2 | Filter by status, sort, "needs you" markers | client-side | partial (status/pipeline/time filter + sort implemented and captured; the per-row "needs you" mark has no Android counterpart and its wording is deferred to R15, still todo) |
| R3 | Run detail: run fields, steps/visits, targets, sessions | `get_run` | partial (fields + steps) |
| R4 | Summary tab incl. collapsible **Changes** viewer (raw + rendered diff) | `get_run` file changes | todo |
| R5 | Graph tab (per-stage panes, verdicts) | `get_run` | todo |
+343 -39
View File
@@ -4,6 +4,26 @@
import { PipelinesClient } from "./client.js";
import { PipelinesRepository } from "./repository.js";
import { validateServerUrl, resolveArtifactUrl } from "./serverUrl.js";
import {
RUN_STATES,
RUN_TIME_RANGES,
RUN_SORTS,
DEFAULT_RUN_SORT,
runStateOf,
runIdentity,
versionLabel,
progressText,
metaText,
formatDuration,
localDayKey,
filterRuns,
groupRunsByDay,
runComparator,
pipelineFilterOptions,
runListEntries,
defaultRunFilters,
runFiltersActiveCount,
} from "./runs.js";
const STORAGE_KEY = "pipelines.web.serverUrl.v2";
@@ -45,10 +65,20 @@ const state = {
selectedRunId: null,
loading: false,
error: "",
runFilters: defaultRunFilters(),
runSort: DEFAULT_RUN_SORT,
openMenu: null,
};
let runPoll = null;
// One shared live clock for the runs list: it ticks only while a shown run is
// executing, and each running row reads its elapsed from it rather than starting
// a timer of its own. Elapsed is derived from the server's start timestamp, so
// it stays correct after a reconnect; a finished history never ticks.
let listClock = null;
let listNow = Date.now();
// ---------------------------------------------------------------------------
// DOM helpers
// ---------------------------------------------------------------------------
@@ -181,6 +211,8 @@ function renderContent() {
}
nodes.push(split);
content.replaceChildren(...nodes);
if (state.view === "runs") refreshListClock();
else stopListClock();
}
function tabButton(view, label) {
@@ -265,52 +297,294 @@ function renderPipelineDetail() {
}
function renderRunList() {
const list = h("div", { class: "list" });
if (state.usage) {
list.append(
h(
"div",
{ class: "usage" },
h("span", { text: `${state.usage.total} total` }),
h("span", { class: "ok", text: `${state.usage.succeeded} succeeded` }),
h("span", { class: "bad", text: `${state.usage.failed} failed` }),
h("span", { class: "warn", text: `${state.usage.active} active` }),
),
);
}
const pane = h("div", { class: "list runs" });
pane.append(renderRunToolbar());
const scroll = h("div", { class: "run-scroll" });
if (state.loading && !state.runs.length) {
list.append(h("div", { class: "muted pad", text: "Loading…" }));
return list;
scroll.append(h("div", { class: "muted pad", text: "Loading…" }));
pane.append(scroll);
return pane;
}
if (!state.runs.length) {
list.append(h("div", { class: "muted pad", text: "No runs." }));
return list;
const filters = state.runFilters;
const today = localDayKey(new Date());
const filtered = filterRuns(state.runs, filters, today);
const groups = groupRunsByDay(filtered, today, undefined, runComparator(state.runSort));
const entries = runListEntries(
state.usage,
state.runs.length === 0,
filtered.length === 0 && state.runs.length > 0,
groups,
"",
);
for (const entry of entries) {
switch (entry.kind) {
case "usage":
scroll.append(renderUsage(entry.usage));
break;
case "empty":
scroll.append(renderEmptyState(entry));
break;
case "day":
scroll.append(h("div", { class: "day-header", text: entry.label }));
break;
case "run":
scroll.append(renderRunRow(entry.run));
break;
case "error":
scroll.append(h("div", { class: "run-list-error", text: entry.message }));
break;
}
}
for (const r of state.runs) {
list.append(
pane.append(scroll);
return pane;
}
function renderUsage(usage) {
const metrics = h("div", { class: "metrics" });
metrics.append(metric("Total", String(usage.total ?? 0), "total"));
if ((usage.average_seconds ?? 0) > 0) {
metrics.append(metric("Average", formatDuration(usage.average_seconds), "average"));
}
metrics.append(metric("Succeeded", String(usage.succeeded ?? 0), "succeeded"));
metrics.append(metric("Failed", String(usage.failed ?? 0), "failed"));
metrics.append(metric("Canceled", String(usage.canceled ?? 0), "canceled"));
metrics.append(metric("Interrupted", String(usage.interrupted ?? 0), "interrupted"));
metrics.append(metric("Active", String(usage.active ?? 0), "active"));
return metrics;
}
function metric(label, value, cls) {
return h(
"div",
{ class: `metric metric-${cls}` },
h("span", { class: "metric-value", text: value }),
h("span", { class: "metric-label", text: label }),
);
}
function renderEmptyState(entry) {
const wrap = h("div", { class: "empty-state" }, h("span", { text: entry.message }));
if (entry.actionLabel) {
wrap.append(h("button", { class: "ghost", text: entry.actionLabel, onclick: clearRunFilters }));
}
return wrap;
}
/**
* One run row, in the app's exact hierarchy: status chip (+ spinner while
* executing); primary line = stored title else pipeline name, carrying the
* version chip when there is no title; the pipeline name + version chip on a
* second line only when a title exists; the progress line; the meta line; and
* the diagnostic line, in the error colour only on a failure. Every
* server-provided string is set with textContent.
*/
function renderRunRow(run) {
const status = runStateOf(run.status);
const identity = runIdentity(run.title, run.name);
const row = h("button", {
class: `row run-row${state.selectedRunId === run.id ? " selected" : ""}`,
onclick: () => selectRun(run.id),
});
const head = h("span", { class: "run-row-head" });
head.append(h("span", { class: `chip chip-${status}`, text: status }));
if (run.executing) head.append(h("span", { class: "spinner", "aria-hidden": "true" }));
head.append(h("span", { class: "run-row-title", text: identity.label }));
if (identity.pipeline == null) head.append(versionChip(run.version));
row.append(head);
if (identity.pipeline != null) {
row.append(
h(
"button",
{
class: `row${state.selectedRunId === r.id ? " selected" : ""}`,
onclick: () => selectRun(r.id),
},
h(
"span",
{ class: "row-head" },
h("span", { class: "row-title", text: r.title || r.name || `run ${r.id}` }),
h("span", { class: statusClass(r.status), text: r.status || "unknown" }),
),
h(
"span",
{ class: "row-meta" },
`#${r.id} · ${fmtTime(r.created_at)} · `,
isExecuting(r) ? h("em", { text: fmtDuration(r.created_at, "") }) : fmtDuration(r.created_at, r.finished_at),
),
r.diagnostic ? h("span", { class: "row-diag", text: r.diagnostic }) : null,
"span",
{ class: "run-row-pipeline" },
h("span", { class: "run-row-pipeline-name", text: identity.pipeline }),
versionChip(run.version),
),
);
}
return list;
row.append(h("span", { class: "run-row-progress", text: progressText(run) }));
row.append(
h("span", {
class: "run-row-meta",
"data-run-id": String(run.id),
text: metaText(run, listNow),
}),
);
if (String(run.diagnostic ?? "").trim()) {
row.append(
h("span", {
class: `run-row-diag${status === "failed" ? " error" : ""}`,
text: run.diagnostic,
}),
);
}
return row;
}
function versionChip(version) {
return h("span", { class: "version-chip", text: versionLabel(version) });
}
function renderRunToolbar() {
const activeCount = runFiltersActiveCount(state.runFilters);
const filterLabel = activeCount > 0 ? `Filter (${activeCount})` : "Filter";
const sortLabel = (RUN_SORTS.find((s) => s.value === state.runSort) ?? RUN_SORTS[0]).label;
const toolbar = h("div", { class: "run-toolbar" });
toolbar.append(
h(
"div",
{ class: "menu-anchor" },
h("button", {
id: "runFilterBtn",
class: `ghost filter-btn${activeCount > 0 ? " active" : ""}`,
title: activeCount > 0 ? `${activeCount} active filter${activeCount === 1 ? "" : "s"}` : "Filter runs",
text: filterLabel,
"data-active-count": String(activeCount),
onclick: () => toggleMenu("filter"),
}),
state.openMenu === "filter" ? renderFilterMenu() : null,
),
h(
"div",
{ class: "menu-anchor" },
h("button", {
id: "runSortBtn",
class: "ghost sort-btn",
title: "Sort runs",
text: `Sort: ${sortLabel}`,
onclick: () => toggleMenu("sort"),
}),
state.openMenu === "sort" ? renderSortMenu() : null,
),
h("span", { class: "spacer" }),
);
return toolbar;
}
function renderFilterMenu() {
const filters = state.runFilters;
const menu = h("div", { class: "menu filter-menu", id: "runFilterMenu" });
menu.append(h("div", { class: "menu-section", text: "Status" }));
for (const status of RUN_STATES) {
menu.append(
filterCheck(status, filters.statuses.has(status), () => toggleStatusFilter(status), {
"data-status": status,
}),
);
}
menu.append(h("div", { class: "menu-divider" }));
menu.append(h("div", { class: "menu-section", text: "Pipeline" }));
menu.append(
filterCheck("Any pipeline", filters.pipelineId == null, () => setPipelineFilter(null), {
"data-pipeline": "any",
}),
);
for (const option of pipelineFilterOptions(state.runs)) {
menu.append(
filterCheck(option.name, filters.pipelineId === option.id, () => setPipelineFilter(option.id), {
"data-pipeline": String(option.id),
}),
);
}
menu.append(h("div", { class: "menu-divider" }));
menu.append(h("div", { class: "menu-section", text: "Time range" }));
for (const range of RUN_TIME_RANGES) {
menu.append(
filterCheck(range.label, filters.timeRange === range.value, () => setTimeRangeFilter(range.value), {
"data-time": range.value,
}),
);
}
menu.append(
h(
"div",
{ class: "menu-actions" },
h("button", { class: "ghost", text: "Clear filters", onclick: clearRunFilters }),
h("button", { class: "ghost", text: "Done", onclick: closeMenu }),
),
);
return menu;
}
function filterCheck(label, checked, onclick, data = {}) {
return h(
"label",
{ class: "filter-check" },
h("input", {
type: "checkbox",
checked: checked ? "checked" : null,
onchange: onclick,
...data,
}),
h("span", { text: label }),
);
}
function renderSortMenu() {
const menu = h("div", { class: "menu sort-menu", id: "runSortMenu" });
for (const option of RUN_SORTS) {
menu.append(
h("button", {
class: `menu-item${state.runSort === option.value ? " selected" : ""}`,
text: option.label,
onclick: () => {
state.runSort = option.value;
closeMenu();
},
}),
);
}
menu.append(h("div", { class: "menu-divider" }));
menu.append(
h("button", {
class: "menu-item",
text: "Reset",
onclick: () => {
state.runSort = DEFAULT_RUN_SORT;
closeMenu();
},
}),
);
return menu;
}
function toggleStatusFilter(status) {
const next = new Set(state.runFilters.statuses);
if (next.has(status)) next.delete(status);
else next.add(status);
state.runFilters = { ...state.runFilters, statuses: next };
renderContent();
}
function setPipelineFilter(pipelineId) {
state.runFilters = { ...state.runFilters, pipelineId };
closeMenu();
}
function setTimeRangeFilter(timeRange) {
state.runFilters = { ...state.runFilters, timeRange };
closeMenu();
}
function clearRunFilters() {
state.runFilters = defaultRunFilters();
closeMenu();
}
function toggleMenu(name) {
state.openMenu = state.openMenu === name ? null : name;
renderContent();
}
function closeMenu() {
state.openMenu = null;
renderContent();
}
function renderRunDetail() {
@@ -509,6 +783,35 @@ function stopRunPoll() {
}
}
/**
* (Re)start the shared runs-list clock: it ticks once a second only while a
* shown run is executing, updating each running row's meta line in place (never
* a full re-render, so an open filter/sort menu is not torn down). The elapsed
* value is derived from the run's server start timestamp, so it survives a
* reconnect.
*/
function refreshListClock() {
stopListClock();
listNow = Date.now();
if (state.view === "runs" && state.runs.some((run) => run.executing)) {
listClock = setInterval(() => {
listNow = Date.now();
for (const node of document.querySelectorAll(".run-row-meta[data-run-id]")) {
const id = Number(node.getAttribute("data-run-id"));
const run = state.runs.find((candidate) => candidate.id === id);
if (run && run.executing) node.textContent = metaText(run, listNow);
}
}, 1000);
}
}
function stopListClock() {
if (listClock) {
clearInterval(listClock);
listClock = null;
}
}
// ---------------------------------------------------------------------------
// Boot
// ---------------------------------------------------------------------------
@@ -523,6 +826,7 @@ client.addEventListener("state", (event) => {
}
if (next.kind !== "connected" && previousKind === "connected") {
stopRunPoll();
stopListClock();
}
render();
});
+512
View File
@@ -0,0 +1,512 @@
// Pure, DOM-free helpers for the runs history list: the status vocabulary, run
// identity, progress/meta wording, filtering, sorting and day grouping.
//
// This mirrors the Android app exactly — ui/screens/RunHistoryScreen.kt,
// screens/ListFilter.kt, screens/ListSort.kt, ui/RunIdentity.kt and ui/Format.kt
// — so the browser list reads the same words in the same order as the app. It is
// deliberately DOM-free: every rule here is unit-testable under `node --test`
// with no browser and no server. app.js keeps the wiring.
//
// Every server-provided string is only ever compared or rendered, never parsed
// as markup; the caller sets it with textContent.
// ---------------------------------------------------------------------------
// Status vocabulary
// ---------------------------------------------------------------------------
/**
* The server's own run vocabulary, in the filter's display order
* (internal/pipeline/runs.go: queued/running/waiting/succeeded/failed/canceled/
* interrupted). The app-only `active` usage bucket, the stage-outcome words
* (`blocked`/`skipped`) and the `unknown` fallback are deliberately not offered
* as run-status filters, mirroring RUN_STATUS_FILTERS.
*/
export const RUN_STATES = [
"queued",
"running",
"waiting",
"succeeded",
"failed",
"canceled",
"interrupted",
];
/**
* Maps a server status or outcome word to its canonical display state, accepting
* the server's vocabulary only (the steps/outcomes synonyms resolve onto the same
* states so one chip set renders list, detail and timeline). Mirrors
* runStateOf: blank or unrecognised input is the safe `unknown` fallback.
*/
export function runStateOf(status) {
switch (String(status ?? "").trim().toLowerCase()) {
case "running":
return "running";
case "queued":
return "queued";
case "waiting":
return "waiting";
case "active":
return "active";
case "succeeded":
case "success":
case "completed":
case "done":
return "succeeded";
case "failed":
case "error":
return "failed";
case "canceled":
case "cancelled":
return "canceled";
case "interrupted":
return "interrupted";
case "blocked":
return "blocked";
case "skipped":
return "skipped";
default:
return "unknown";
}
}
// ---------------------------------------------------------------------------
// Identity, wording and time formatting
// ---------------------------------------------------------------------------
/**
* The runs list's two identity lines: `label` is the run's primary line and
* `pipeline` is the pipeline the run belongs to, shown as a second line only
* when the label is a stored title. A run with no title falls back to the
* pipeline name as its only line — never a title followed by an empty one.
* Mirrors ui/RunIdentity.kt runIdentity.
*/
export function runIdentity(title, name) {
const stored = String(title ?? "").trim();
return stored
? { label: stored, pipeline: String(name ?? "") }
: { label: String(name ?? ""), pipeline: null };
}
/** The version chip label, e.g. `v5` (mirrors RunHistoryScreen.VersionChip). */
export function versionLabel(version) {
return `v${version}`;
}
/**
* A visit count in the app's one singular/plural spelling (`1 visit` /
* `n visits`), mirroring ui/Format.kt visitCount so the same run is never
* described inconsistently.
*/
export function visitCount(count, adjective) {
const n = Number(count) || 0;
return `${n} ${adjective} ${n === 1 ? "visit" : "visits"}`;
}
/** Parses an RFC3339 timestamp to epoch millis, or null when blank/unparseable. */
export function parseInstant(text) {
if (text == null) return null;
const value = String(text).trim();
if (!value) return null;
const ms = Date.parse(value);
return Number.isNaN(ms) ? null : ms;
}
/**
* Non-negative whole seconds between two RFC3339 timestamps, or null when either
* is blank/unparseable or the end precedes the start. Mirrors Format.durationSeconds
* (truncating toward zero), so a sort key and the printed duration never disagree.
*/
export function durationSeconds(start, end) {
const from = parseInstant(start);
const to = parseInstant(end);
if (from == null || to == null) return null;
const seconds = Math.trunc((to - from) / 1000);
return seconds >= 0 ? seconds : null;
}
/**
* Non-negative whole seconds from a [start] RFC3339 timestamp to [nowMillis], or
* null when [start] is blank/unparseable. A future start (clock skew) reads as 0,
* never a negative. Mirrors Format.secondsSince.
*/
export function secondsSince(start, nowMillis) {
const from = parseInstant(start);
if (from == null) return null;
return Math.max(0, Math.trunc((nowMillis - from) / 1000));
}
/**
* Human duration for a whole number of seconds: `Ns`, `Nm Ss`, `Hh Mm`. Mirrors
* Format.formatDuration (a negative total renders as `0s`).
*/
export function formatDuration(totalSeconds) {
const seconds = Math.max(0, Math.trunc(Number(totalSeconds) || 0));
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`;
}
/**
* 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 a caller omits the
* value rather than printing a blank. [options] may carry a `zone` (IANA name)
* and `locale` for deterministic tests; both default to the runtime's.
*/
export function formatLocalTimestamp(instant, options = {}) {
const ms = parseInstant(instant);
if (ms == null) return null;
return formatInZone(ms, options, (parts) => `${parts.day} ${parts.month} ${parts.hour}:${parts.minute}`);
}
/** The run's calendar day (`YYYY-MM-DD`) in [zone], or null when unparseable. */
export function localDayKey(value, zone) {
const ms = value instanceof Date ? value.getTime() : parseInstant(value);
if (ms == null || !Number.isFinite(ms)) return null;
try {
const fmt = new Intl.DateTimeFormat("en-CA", {
year: "numeric",
month: "2-digit",
day: "2-digit",
timeZone: zone,
});
return fmt.format(new Date(ms));
} catch {
return null;
}
}
/**
* The day header for a run: `Today`, `Yesterday`, `d MMM yyyy`, or `Unknown date`
* for a blank/unparseable timestamp. [today] may be a day-key string or a Date.
* Mirrors RunHistoryScreen.dayLabel.
*/
export function dayLabel(createdAt, today, zone) {
const key = localDayKey(createdAt, zone);
if (key == null) return "Unknown date";
const todayKey = typeof today === "string" ? today : localDayKey(today, zone);
if (todayKey == null) return "Unknown date";
if (key === todayKey) return "Today";
if (key === addDays(todayKey, -1)) return "Yesterday";
return formatDayKey(key);
}
/**
* The runs list's meta line: `run {id} · {local d MMM HH:mm} · {duration}` for a
* finished run, and `run {id} · {live elapsed}` for an executing one (elapsed
* computed from its server start timestamp against [nowMillis]). Mirrors
* RunHistoryScreen.metaText.
*/
export function metaText(run, nowMillis, options = {}) {
const parts = [`run ${run.id}`];
if (run.executing) {
const elapsed = secondsSince(run.created_at, nowMillis);
if (elapsed != null) parts.push(formatDuration(elapsed));
} else {
const stamp = formatLocalTimestamp(run.created_at, options);
if (stamp != null) parts.push(stamp);
const duration = durationSeconds(run.created_at, run.finished_at);
if (duration != null) parts.push(formatDuration(duration));
}
return parts.join(" · ");
}
/**
* Progress from the fields a summary actually has: an optional resource-wait
* line, completed visits, then the current stage. Mirrors
* RunHistoryScreen.progressText.
*/
export function progressText(run) {
const parts = [];
if (run.resource_wait != null) {
parts.push(`Waiting for resource ${String(run.resource_wait.resource ?? "")}`);
}
parts.push(visitCount(run.completed_steps, "completed"));
const stage = String(run.current_stage ?? "").trim();
if (stage) parts.push(`stage ${stage}`);
return parts.join(" · ");
}
// ---------------------------------------------------------------------------
// Filters
// ---------------------------------------------------------------------------
/** The run-list time windows offered by the filter control. */
export const RUN_TIME_RANGES = [
{ value: "any_time", label: "Any time" },
{ value: "today", label: "Today" },
{ value: "last_7_days", label: "Last 7 days" },
{ value: "last_30_days", label: "Last 30 days" },
];
export const DEFAULT_TIME_RANGE = "any_time";
/** The runs-list filters, each defaulting to "no narrowing". */
export function defaultRunFilters() {
return { statuses: new Set(), pipelineId: null, timeRange: DEFAULT_TIME_RANGE };
}
/** The number of active facets (one per status/pipeline/time choice). */
export function runFiltersActiveCount(filters) {
return (
(filters.statuses && filters.statuses.size > 0 ? 1 : 0) +
(filters.pipelineId != null ? 1 : 0) +
(filters.timeRange && filters.timeRange !== DEFAULT_TIME_RANGE ? 1 : 0)
);
}
/** True when [run] is in [statuses]; an empty set means "any status". */
export function runMatchesStatuses(run, statuses) {
if (!statuses || statuses.size === 0) return true;
return statuses.has(runStateOf(run.status));
}
/** True when [run] belongs to [pipelineId]; null means "any pipeline". */
export function runMatchesPipeline(run, pipelineId) {
return pipelineId == null || run.pipeline_id === pipelineId;
}
/**
* True when [run] falls inside [range] relative to [today]. A blank/unparseable
* timestamp and a future-dated run never match a finite window; `any_time`
* matches everything. The window is inclusive calendar days ending today.
*/
export function runMatchesTimeRange(run, range, today, zone) {
if (!range || range === DEFAULT_TIME_RANGE) return true;
const key = localDayKey(run.created_at, zone);
if (key == null) return false;
const todayKey = typeof today === "string" ? today : localDayKey(today, zone);
if (todayKey == null) return false;
if (key > todayKey) return false;
switch (range) {
case "today":
return key === todayKey;
case "last_7_days":
return key >= addDays(todayKey, -6);
case "last_30_days":
return key >= addDays(todayKey, -29);
default:
return true;
}
}
/** Every run facet combined with AND. */
export function runMatchesFilters(run, filters, today, zone) {
return (
runMatchesStatuses(run, filters.statuses) &&
runMatchesPipeline(run, filters.pipelineId) &&
runMatchesTimeRange(run, filters.timeRange, today, zone)
);
}
/** Narrows [runs] by [filters]; the default filters change nothing. */
export function filterRuns(runs, filters, today, zone) {
if (runFiltersActiveCount(filters) === 0) return runs;
return (runs ?? []).filter((run) => runMatchesFilters(run, filters, today, zone));
}
/** One selectable pipeline in the run filter, named from its runs. */
export function pipelineFilterOptions(runs) {
const names = new Map();
for (const run of runs ?? []) {
const current = names.get(run.pipeline_id);
if (current == null || current.trim() === "") names.set(run.pipeline_id, run.name ?? "");
}
return [...names.entries()]
.map(([id, name]) => ({ id, name: name.trim() === "" ? `Pipeline ${id}` : name }))
.sort((a, b) => caseInsensitiveCompare(a.name, b.name) || a.id - b.id);
}
// ---------------------------------------------------------------------------
// Sort
// ---------------------------------------------------------------------------
/** The run-list orderings offered by the sort control. */
export const RUN_SORTS = [
{ value: "newest_first", label: "Newest first" },
{ value: "oldest_first", label: "Oldest first" },
{ value: "longest_duration", label: "Longest duration" },
{ value: "shortest_duration", label: "Shortest duration" },
{ value: "pipeline_name", label: "Pipeline name" },
{ value: "status", label: "Status" },
];
export const DEFAULT_RUN_SORT = "newest_first";
/**
* The pure comparator for [sort]. Every case ends in an explicit id tie-break
* (`id` is unique) so runs that compare equal on the primary key always order
* the same way. A blank/unparseable timestamp and a run with no recorded
* duration (still executing) sort last regardless of direction and never crash.
* Mirrors ListSort.runComparator.
*/
export function runComparator(sort) {
switch (sort) {
case "oldest_first":
return (a, b) =>
ascending(instantOr(a.created_at, Infinity), instantOr(b.created_at, Infinity)) ||
ascending(a.id, b.id);
case "longest_duration":
return (a, b) => {
const da = durationSeconds(a.created_at, a.finished_at);
const db = durationSeconds(b.created_at, b.finished_at);
return (
ascending(da == null ? 1 : 0, db == null ? 1 : 0) ||
descending(da ?? -Infinity, db ?? -Infinity) ||
descending(instantOr(a.created_at, -Infinity), instantOr(b.created_at, -Infinity)) ||
descending(a.id, b.id)
);
};
case "shortest_duration":
return (a, b) => {
const da = durationSeconds(a.created_at, a.finished_at);
const db = durationSeconds(b.created_at, b.finished_at);
return (
ascending(da == null ? 1 : 0, db == null ? 1 : 0) ||
ascending(da ?? Infinity, db ?? Infinity) ||
descending(instantOr(a.created_at, -Infinity), instantOr(b.created_at, -Infinity)) ||
descending(a.id, b.id)
);
};
case "pipeline_name":
return (a, b) =>
caseInsensitiveCompare(a.name, b.name) ||
descending(instantOr(a.created_at, -Infinity), instantOr(b.created_at, -Infinity)) ||
descending(a.id, b.id);
case "status":
return (a, b) =>
caseInsensitiveCompare(a.status, b.status) ||
descending(instantOr(a.created_at, -Infinity), instantOr(b.created_at, -Infinity)) ||
descending(a.id, b.id);
case "newest_first":
default:
return (a, b) =>
descending(instantOr(a.created_at, -Infinity), instantOr(b.created_at, -Infinity)) ||
descending(a.id, b.id);
}
}
/** Orders [runs] by [sort], returning a new array. */
export function sortRuns(runs, sort) {
return [...(runs ?? [])].sort(runComparator(sort));
}
// ---------------------------------------------------------------------------
// Day grouping and the list's slots
// ---------------------------------------------------------------------------
/**
* Groups runs by calendar day in [zone], preserving the order [order] puts them
* in and the order within a day. A blank/unparseable timestamp gets a safe
* "Unknown date" group. Mirrors RunHistoryScreen.groupRunsByDay.
*/
export function groupRunsByDay(runs, today, zone, order = runComparator(DEFAULT_RUN_SORT)) {
const groups = new Map();
for (const run of [...(runs ?? [])].sort(order)) {
const label = dayLabel(run.created_at, today, zone);
if (!groups.has(label)) groups.set(label, []);
groups.get(label).push(run);
}
return [...groups.entries()].map(([label, list]) => ({ label, runs: list }));
}
export const NO_RUNS_MESSAGE = "No runs have been recorded yet.";
export const NO_MATCH_MESSAGE = "No runs match the current filters.";
export const CLEAR_FILTERS_LABEL = "Clear filters";
/**
* The runs list's slots in layout order: the usage block when there is one, then
* either the single empty line (nothing recorded, or nothing matching the
* filters) or the day groups, then the inline error row. Pure and single-sourced
* with the renderer, so its size is exactly the list's entry count. Mirrors
* RunHistoryScreen.runListEntries.
*/
export function runListEntries(usage, nothingRecorded, nothingMatched, groups, error) {
const entries = [];
if (usage != null) entries.push({ kind: "usage", key: "usage", usage });
if (nothingRecorded) {
entries.push({ kind: "empty", key: "runs-empty", message: NO_RUNS_MESSAGE, actionLabel: null });
} else if (nothingMatched) {
entries.push({
kind: "empty",
key: "runs-filtered-empty",
message: NO_MATCH_MESSAGE,
actionLabel: CLEAR_FILTERS_LABEL,
});
} else {
for (const group of groups ?? []) {
entries.push({ kind: "day", key: `day-${group.label}`, label: group.label });
for (const run of group.runs) entries.push({ kind: "run", key: `run-${run.id}`, run });
}
}
if (error) entries.push({ kind: "error", key: "runs-error", message: error });
return entries;
}
// ---------------------------------------------------------------------------
// Internals
// ---------------------------------------------------------------------------
/** Ascending compare of two numbers/strings, safe on the -Infinity sentinels. */
function ascending(x, y) {
if (x < y) return -1;
if (x > y) return 1;
return 0;
}
/** Descending compare: the larger value sorts first. */
function descending(x, y) {
return ascending(y, x);
}
function instantOr(iso, fallback) {
const ms = parseInstant(iso);
return ms == null ? fallback : ms;
}
function caseInsensitiveCompare(a, b) {
const left = String(a ?? "").toLowerCase();
const right = String(b ?? "").toLowerCase();
if (left < right) return -1;
if (left > right) return 1;
return 0;
}
/** `dayKey` shifted by [days] calendar days (keys are `YYYY-MM-DD`). */
function addDays(dayKey, days) {
const [year, month, day] = dayKey.split("-").map(Number);
const shifted = new Date(Date.UTC(year, month - 1, day) + days * 86400000);
return `${shifted.getUTCFullYear()}-${pad2(shifted.getUTCMonth() + 1)}-${pad2(shifted.getUTCDate())}`;
}
function pad2(value) {
return String(value).padStart(2, "0");
}
function formatDayKey(dayKey) {
const [year, month, day] = dayKey.split("-").map(Number);
const parts = zoneParts(Date.UTC(year, month - 1, day), "UTC", "en-GB");
return `${parts.day} ${parts.month} ${parts.year}`;
}
function formatInZone(ms, options, assemble) {
const parts = zoneParts(ms, options.zone, options.locale);
return parts ? assemble(parts) : null;
}
/** The named parts of `ms` in [zone], or null when the zone is unusable. */
function zoneParts(ms, zone, locale) {
try {
const fmt = new Intl.DateTimeFormat(locale ?? "en-GB", {
day: "numeric",
month: "short",
year: "numeric",
hour: "2-digit",
minute: "2-digit",
hourCycle: "h23",
timeZone: zone,
});
return Object.fromEntries(fmt.formatToParts(new Date(ms)).map((part) => [part.type, part.value]));
} catch {
return null;
}
}
+181 -4
View File
@@ -95,9 +95,6 @@ button.ghost { background: transparent; }
.row-head { display: flex; gap: 8px; justify-content: space-between; align-items: center; }
.row-title { font-weight: 600; }
.row-meta { display: block; color: var(--muted); font-size: 12px; margin-top: 2px; }
.row-diag { display: block; color: var(--warn); font-size: 12px; margin-top: 2px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.usage { display: flex; gap: 12px; padding: 8px 12px; border-bottom: 1px solid var(--border); font-size: 12px; }
.detail { padding: 16px; }
.detail h2 { margin: 0 0 12px; display: flex; gap: 10px; align-items: center; }
@@ -120,9 +117,17 @@ button.ghost { background: transparent; }
.artifacts a { color: var(--accent); margin-right: 10px; }
.chip { display: inline-block; padding: 1px 8px; border-radius: 999px; font-size: 11px; border: 1px solid var(--border); color: var(--muted); }
.chip-running, .chip-queued { color: var(--warn); border-color: var(--warn); }
/* The app-owned status hues (RunStatusPalette): status is never colour-only,
every chip still carries its own label. */
.chip-running, .chip-active { color: #7fb2f0; border-color: #7fb2f0; }
.chip-waiting { color: #8edff5; border-color: #8edff5; }
.chip-succeeded { color: var(--ok); border-color: var(--ok); }
.chip-failed { color: var(--bad); border-color: var(--bad); }
.chip-canceled { color: #889391; border-color: #889391; }
.chip-interrupted { color: var(--warn); border-color: var(--warn); }
.chip-queued { color: #9aa6a2; border-color: #9aa6a2; }
.chip-blocked { color: #f0a35e; border-color: #f0a35e; }
.chip-skipped { color: #a8b8c8; border-color: #a8b8c8; }
.dot::before { content: "●"; margin-right: 6px; }
.dot.ok::before { color: var(--ok); }
@@ -142,3 +147,175 @@ button.ghost { background: transparent; }
.banner.error { background: #2c1616; color: var(--bad); }
code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font-size: 12px; }
/* ---------------------------------------------------------------------------
Runs history: toolbar, filter/sort menus, usage roll-up, sticky day headers
and the run rows. Hand-written, dark palette, no framework.
--------------------------------------------------------------------------- */
.list.runs {
display: flex;
flex-direction: column;
/* The filter/sort menus hang below the toolbar; keep them unclipped so their
bounded, scrollable box can be reached over the rows beneath. */
overflow: visible;
}
.run-toolbar {
display: flex;
gap: 8px;
align-items: center;
padding: 8px 12px;
border-bottom: 1px solid var(--border);
}
.run-toolbar .spacer { flex: 1; }
.run-toolbar button.ghost { padding: 4px 10px; font-size: 12px; }
.filter-btn.active { border-color: var(--accent); color: var(--accent); }
.menu-anchor { position: relative; }
.menu {
position: absolute;
top: calc(100% + 4px);
left: 0;
z-index: 6;
min-width: 210px;
/* The filter menu lists every pipeline, so with a busy history it is taller
than the viewport. Bound it to the viewport and scroll it in place: every
section (Status, Pipeline, Time range) and the Clear filters/Done actions
stay reachable instead of being clipped off-screen. */
max-height: min(70vh, 600px);
overflow-y: auto;
overscroll-behavior: contain;
padding: 6px;
background: var(--surface-2);
border: 1px solid var(--border);
border-radius: 10px;
box-shadow: 0 10px 30px rgba(0, 0, 0, 0.45);
display: grid;
gap: 2px;
}
.menu-section {
font-size: 11px;
text-transform: uppercase;
letter-spacing: 0.04em;
color: var(--muted);
padding: 6px 8px 2px;
}
.menu-divider { height: 1px; background: var(--border); margin: 6px 0; }
.menu-actions { display: flex; justify-content: space-between; gap: 8px; margin-top: 6px; }
.menu-actions button { padding: 4px 8px; font-size: 12px; }
.menu-item {
display: block;
width: 100%;
text-align: left;
border: 0;
background: transparent;
padding: 6px 8px;
border-radius: 6px;
font-size: 13px;
}
.menu-item:hover { background: var(--surface); }
.menu-item.selected { color: var(--accent); }
.filter-check {
display: flex;
align-items: center;
gap: 8px;
min-width: 0;
padding: 4px 8px;
border-radius: 6px;
font-size: 13px;
cursor: pointer;
}
/* Pipeline names can be long; keep each option on one line inside the bounded
menu width rather than wrapping to two or three lines. */
.filter-check span { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.filter-check:hover { background: var(--surface); }
.filter-check input { accent-color: var(--accent); }
.filter-menu { min-width: 240px; max-width: 340px; grid-template-columns: minmax(0, 1fr); }
/* The list body is the scroll container so the day headers can stick to its top
without depending on the (wrapping) top bar's height. */
.run-scroll {
max-height: calc(100vh - 210px);
overflow-y: auto;
}
.metrics {
display: flex;
flex-wrap: wrap;
gap: 20px;
padding: 12px 16px;
border-bottom: 1px solid var(--border);
}
.metric { display: flex; flex-direction: column; min-width: 56px; }
.metric-value { font-size: 18px; font-weight: 600; line-height: 1.2; }
.metric-label { font-size: 11px; color: var(--muted); }
.metric-succeeded .metric-value { color: var(--ok); }
.metric-failed .metric-value { color: var(--bad); }
.metric-canceled .metric-value { color: #889391; }
.metric-interrupted .metric-value { color: var(--warn); }
.metric-active .metric-value { color: #7fb2f0; }
.day-header {
position: sticky;
top: 0;
z-index: 1;
padding: 7px 16px;
background: var(--surface);
border-bottom: 1px solid var(--border);
font-size: 11px;
text-transform: uppercase;
letter-spacing: 0.05em;
color: var(--muted);
}
.run-row { display: block; padding: 10px 14px; }
.run-row-head { display: flex; align-items: center; gap: 8px; }
.run-row-title { flex: 1; font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.run-row-pipeline { display: flex; align-items: center; gap: 8px; margin-top: 2px; color: var(--muted); font-size: 12px; }
.run-row-pipeline-name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.run-row-progress,
.run-row-meta,
.run-row-diag {
display: block;
margin-top: 2px;
color: var(--muted);
font-size: 12px;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.run-row-diag.error { color: var(--bad); }
.version-chip {
flex: none;
padding: 0 7px;
border-radius: 999px;
border: 1px solid var(--border);
background: var(--surface-2);
color: var(--muted);
font-size: 11px;
}
.spinner {
flex: none;
width: 12px;
height: 12px;
border: 2px solid var(--border);
border-top-color: #7fb2f0;
border-radius: 50%;
display: inline-block;
animation: spin 0.8s linear infinite;
}
@keyframes spin { to { transform: rotate(360deg); } }
.empty-state {
display: flex;
flex-direction: column;
align-items: flex-start;
gap: 10px;
padding: 16px;
color: var(--muted);
}
.run-list-error { padding: 12px 16px; color: var(--bad); }
+393
View File
@@ -0,0 +1,393 @@
// Pure unit tests for the runs-list helpers: filtering (status/pipeline/time,
// AND-combined), every sort comparator with its id tie-break, day grouping,
// the wording helpers and the list's slot model. No server, no DOM.
import { test } from "node:test";
import assert from "node:assert/strict";
import {
RUN_STATES,
RUN_TIME_RANGES,
RUN_SORTS,
runStateOf,
runIdentity,
versionLabel,
visitCount,
progressText,
metaText,
formatDuration,
secondsSince,
durationSeconds,
localDayKey,
dayLabel,
defaultRunFilters,
runFiltersActiveCount,
runMatchesTimeRange,
filterRuns,
pipelineFilterOptions,
runComparator,
sortRuns,
groupRunsByDay,
runListEntries,
NO_RUNS_MESSAGE,
NO_MATCH_MESSAGE,
} from "../src/runs.js";
/** A finished run on the Today of the tests, with every field the list reads. */
function run(overrides = {}) {
return {
id: 1,
pipeline_id: 1,
name: "Pipe",
title: null,
version: 1,
status: "succeeded",
executing: false,
current_stage: "",
completed_steps: 0,
created_at: "2026-10-19T10:00:00Z",
finished_at: "2026-10-19T10:01:00Z",
diagnostic: "",
resource_wait: null,
...overrides,
};
}
const TODAY = "2026-10-19";
const ZONE = "UTC";
const TIME_OPTS = { zone: ZONE, locale: "en-GB" };
// ---------------------------------------------------------------------------
// Vocabulary and wording
// ---------------------------------------------------------------------------
test("runStateOf maps the server vocabulary and the outcome synonyms", () => {
assert.equal(runStateOf("running"), "running");
assert.equal(runStateOf("succeeded"), "succeeded");
assert.equal(runStateOf("success"), "succeeded");
assert.equal(runStateOf("completed"), "succeeded");
assert.equal(runStateOf("done"), "succeeded");
assert.equal(runStateOf("error"), "failed");
assert.equal(runStateOf("cancelled"), "canceled");
assert.equal(runStateOf(" INTERRUPTED "), "interrupted");
assert.equal(runStateOf(""), "unknown");
assert.equal(runStateOf("nonsense"), "unknown");
});
test("RUN_STATES is exactly the server run vocabulary in display order", () => {
assert.deepEqual(RUN_STATES, [
"queued",
"running",
"waiting",
"succeeded",
"failed",
"canceled",
"interrupted",
]);
});
test("runIdentity falls back to the pipeline name and only splits when titled", () => {
assert.deepEqual(runIdentity(" Fix the thing ", "Plan and land"), {
label: "Fix the thing",
pipeline: "Plan and land",
});
assert.deepEqual(runIdentity(null, "Plan and land"), { label: "Plan and land", pipeline: null });
assert.deepEqual(runIdentity(" ", "Plan and land"), { label: "Plan and land", pipeline: null });
});
test("versionLabel and visitCount use the app's singular/plural spelling", () => {
assert.equal(versionLabel(5), "v5");
assert.equal(visitCount(1, "completed"), "1 completed visit");
assert.equal(visitCount(0, "completed"), "0 completed visits");
assert.equal(visitCount(3, "completed"), "3 completed visits");
});
test("progressText carries resource wait, completed visits and the stage", () => {
assert.equal(
progressText(run({ completed_steps: 2, current_stage: "implementer" })),
"2 completed visits · stage implementer",
);
assert.equal(
progressText(
run({ completed_steps: 1, current_stage: "reviewer", resource_wait: { resource: "pixel-9" } }),
),
"Waiting for resource pixel-9 · 1 completed visit · stage reviewer",
);
assert.equal(progressText(run({ completed_steps: 0 })), "0 completed visits");
});
test("metaText shows a live elapsed while executing and id/start/duration at rest", () => {
const executing = run({
id: 7,
executing: true,
created_at: "2026-10-19T09:30:00Z",
finished_at: "",
});
assert.equal(metaText(executing, Date.parse("2026-10-19T09:31:05Z"), TIME_OPTS), "run 7 · 1m 5s");
// A future start (clock skew) reads as 0s, never a negative.
assert.equal(metaText(executing, Date.parse("2026-10-19T09:00:00Z"), TIME_OPTS), "run 7 · 0s");
const done = run({
id: 7,
created_at: "2026-10-19T09:30:00Z",
finished_at: "2026-10-19T09:32:05Z",
});
assert.equal(metaText(done, 0, TIME_OPTS), "run 7 · 19 Oct 09:30 · 2m 5s");
});
test("formatDuration, secondsSince and durationSeconds mirror Format.kt", () => {
assert.equal(formatDuration(0), "0s");
assert.equal(formatDuration(59), "59s");
assert.equal(formatDuration(60), "1m 0s");
assert.equal(formatDuration(125), "2m 5s");
assert.equal(formatDuration(3725), "1h 2m");
assert.equal(formatDuration(-5), "0s");
assert.equal(secondsSince("2026-10-19T09:30:00Z", Date.parse("2026-10-19T09:31:05Z")), 65);
assert.equal(secondsSince("bad", 0), null);
assert.equal(durationSeconds("2026-10-19T09:30:00Z", "2026-10-19T09:32:05Z"), 125);
assert.equal(durationSeconds("2026-10-19T09:32:05Z", "2026-10-19T09:30:00Z"), null);
assert.equal(durationSeconds("", ""), null);
});
// ---------------------------------------------------------------------------
// Filters
// ---------------------------------------------------------------------------
test("default filters change nothing and count as zero active facets", () => {
const runs = [run({ id: 1 }), run({ id: 2, status: "failed" })];
const filters = defaultRunFilters();
assert.equal(runFiltersActiveCount(filters), 0);
assert.equal(filterRuns(runs, filters, TODAY, ZONE), runs);
});
test("status filter narrows to the selected states; an empty set is any status", () => {
const runs = [
run({ id: 1, status: "succeeded" }),
run({ id: 2, status: "failed" }),
run({ id: 3, status: "canceled" }),
];
const filters = { ...defaultRunFilters(), statuses: new Set(["failed"]) };
assert.deepEqual(
filterRuns(runs, filters, TODAY, ZONE).map((r) => r.id),
[2],
);
// "success" resolves to the succeeded state, so selecting it matches.
const succeeded = { ...defaultRunFilters(), statuses: new Set(["succeeded"]) };
assert.deepEqual(
filterRuns([run({ id: 9, status: "success" })], succeeded, TODAY, ZONE).map((r) => r.id),
[9],
);
assert.equal(runFiltersActiveCount(filters), 1);
});
test("pipeline filter is a single-select; null means any pipeline", () => {
const runs = [run({ id: 1, pipeline_id: 3 }), run({ id: 2, pipeline_id: 4 })];
const filters = { ...defaultRunFilters(), pipelineId: 4 };
assert.deepEqual(
filterRuns(runs, filters, TODAY, ZONE).map((r) => r.id),
[2],
);
assert.equal(runFiltersActiveCount(filters), 1);
});
test("time range is inclusive calendar days ending today and rejects future/blank", () => {
const at = (created_at) => run({ created_at });
assert.equal(runMatchesTimeRange(at("2026-10-19T00:00:00Z"), "today", TODAY, ZONE), true);
assert.equal(runMatchesTimeRange(at("2026-10-18T23:59:59Z"), "today", TODAY, ZONE), false);
// last 7 days covers today and the six days before it (>= 13 Oct).
assert.equal(runMatchesTimeRange(at("2026-10-13T00:00:00Z"), "last_7_days", TODAY, ZONE), true);
assert.equal(runMatchesTimeRange(at("2026-10-12T23:00:00Z"), "last_7_days", TODAY, ZONE), false);
// last 30 days covers >= 20 Sep.
assert.equal(runMatchesTimeRange(at("2026-09-20T00:00:00Z"), "last_30_days", TODAY, ZONE), true);
assert.equal(runMatchesTimeRange(at("2026-09-19T00:00:00Z"), "last_30_days", TODAY, ZONE), false);
// A future-dated run and a blank/unparseable timestamp never match a window.
assert.equal(runMatchesTimeRange(at("2026-10-20T00:00:00Z"), "today", TODAY, ZONE), false);
assert.equal(runMatchesTimeRange(at("not-a-date"), "today", TODAY, ZONE), false);
assert.equal(runMatchesTimeRange(at(""), "last_30_days", TODAY, ZONE), false);
// Any time matches everything, including blank.
assert.equal(runMatchesTimeRange(at(""), "any_time", TODAY, ZONE), true);
});
test("the three facets AND-combine and the count is one per facet", () => {
const runs = [
run({ id: 1, pipeline_id: 3, status: "failed", created_at: "2026-10-19T10:00:00Z" }),
run({ id: 2, pipeline_id: 3, status: "succeeded", created_at: "2026-10-19T10:00:00Z" }),
run({ id: 3, pipeline_id: 4, status: "failed", created_at: "2026-10-19T10:00:00Z" }),
run({ id: 4, pipeline_id: 3, status: "failed", created_at: "2026-08-01T10:00:00Z" }),
];
const filters = {
statuses: new Set(["failed"]),
pipelineId: 3,
timeRange: "last_7_days",
};
assert.equal(runFiltersActiveCount(filters), 3);
assert.deepEqual(
filterRuns(runs, filters, TODAY, ZONE).map((r) => r.id),
[1],
);
});
test("pipelineFilterOptions names each pipeline from its newest non-blank run and sorts by name then id", () => {
const options = pipelineFilterOptions([
run({ pipeline_id: 5, name: "beta" }),
run({ pipeline_id: 5, name: "" }),
run({ pipeline_id: 2, name: "Alpha" }),
run({ pipeline_id: 9, name: "" }),
]);
assert.deepEqual(options, [
{ id: 2, name: "Alpha" },
{ id: 5, name: "beta" },
{ id: 9, name: "Pipeline 9" },
]);
});
// ---------------------------------------------------------------------------
// Sort: every comparator plus an id tie-break
// ---------------------------------------------------------------------------
test("newest first orders by start descending, then id descending", () => {
const a = run({ id: 1, created_at: "2026-10-19T10:00:00Z" });
const b = run({ id: 2, created_at: "2026-10-19T10:00:00Z" });
const c = run({ id: 3, created_at: "2026-10-19T11:00:00Z" });
assert.deepEqual(
sortRuns([a, b, c], "newest_first").map((r) => r.id),
[3, 2, 1],
);
});
test("oldest first orders by start ascending, then id ascending", () => {
const a = run({ id: 1, created_at: "2026-10-19T10:00:00Z" });
const b = run({ id: 2, created_at: "2026-10-19T10:00:00Z" });
const c = run({ id: 3, created_at: "2026-10-19T11:00:00Z" });
assert.deepEqual(
sortRuns([a, b, c], "oldest_first").map((r) => r.id),
[1, 2, 3],
);
});
test("longest duration puts a missing duration last, then duration desc, created desc, id desc", () => {
const a = run({ id: 1, created_at: "2026-10-19T10:00:00Z", finished_at: "2026-10-19T10:05:00Z" }); // 300
const b = run({ id: 2, executing: true, created_at: "2026-10-19T10:00:00Z", finished_at: "" }); // null
const c = run({ id: 3, created_at: "2026-10-19T09:00:00Z", finished_at: "2026-10-19T09:10:00Z" }); // 600
const d = run({ id: 4, created_at: "2026-10-19T08:00:00Z", finished_at: "2026-10-19T08:05:00Z" }); // 300
assert.deepEqual(
sortRuns([a, b, c, d], "longest_duration").map((r) => r.id),
[3, 1, 4, 2],
);
});
test("shortest duration puts a missing duration last, then duration asc, created desc, id desc", () => {
const a = run({ id: 1, created_at: "2026-10-19T10:00:00Z", finished_at: "2026-10-19T10:05:00Z" }); // 300
const b = run({ id: 2, executing: true, created_at: "2026-10-19T10:00:00Z", finished_at: "" }); // null
const c = run({ id: 3, created_at: "2026-10-19T09:00:00Z", finished_at: "2026-10-19T09:10:00Z" }); // 600
const d = run({ id: 4, created_at: "2026-10-19T08:00:00Z", finished_at: "2026-10-19T08:05:00Z" }); // 300
assert.deepEqual(
sortRuns([a, b, c, d], "shortest_duration").map((r) => r.id),
[1, 4, 3, 2],
);
});
test("pipeline name sorts case-insensitively, then created desc, id desc", () => {
const x = run({ id: 1, name: "beta", created_at: "2026-10-19T10:00:00Z" });
const y = run({ id: 2, name: "Alpha", created_at: "2026-10-19T10:00:00Z" });
const z = run({ id: 3, name: "alpha", created_at: "2026-10-19T11:00:00Z" });
assert.deepEqual(
sortRuns([x, y, z], "pipeline_name").map((r) => r.id),
[3, 2, 1],
);
});
test("status sorts case-insensitively, then created desc, id desc", () => {
const p = run({ id: 1, status: "succeeded", created_at: "2026-10-19T10:00:00Z" });
const q = run({ id: 2, status: "failed", created_at: "2026-10-19T10:00:00Z" });
const r = run({ id: 3, status: "failed", created_at: "2026-10-19T11:00:00Z" });
assert.deepEqual(
sortRuns([p, q, r], "status").map((r) => r.id),
[3, 2, 1],
);
});
test("an unknown sort falls back to newest first", () => {
const a = run({ id: 1, created_at: "2026-10-19T10:00:00Z" });
const b = run({ id: 2, created_at: "2026-10-19T11:00:00Z" });
assert.deepEqual(
sortRuns([a, b], "not_a_sort").map((r) => r.id),
[2, 1],
);
});
test("RUN_SORTS and RUN_TIME_RANGES carry the app's exact labels", () => {
assert.deepEqual(
RUN_SORTS.map((s) => s.label),
["Newest first", "Oldest first", "Longest duration", "Shortest duration", "Pipeline name", "Status"],
);
assert.deepEqual(
RUN_TIME_RANGES.map((r) => r.label),
["Any time", "Today", "Last 7 days", "Last 30 days"],
);
});
// ---------------------------------------------------------------------------
// Day grouping
// ---------------------------------------------------------------------------
test("dayLabel renders Today / Yesterday / d MMM yyyy / Unknown date", () => {
assert.equal(dayLabel("2026-10-19T01:00:00Z", TODAY, ZONE), "Today");
assert.equal(dayLabel("2026-10-18T23:00:00Z", TODAY, ZONE), "Yesterday");
assert.equal(dayLabel("2026-10-16T23:00:00Z", TODAY, ZONE), "16 Oct 2026");
assert.equal(dayLabel("", TODAY, ZONE), "Unknown date");
assert.equal(dayLabel("not-a-date", TODAY, ZONE), "Unknown date");
assert.equal(localDayKey("2026-10-19T01:00:00Z", ZONE), "2026-10-19");
assert.equal(localDayKey("", ZONE), null);
});
test("groupRunsByDay follows the sort order and preserves it within a day", () => {
const r1 = run({ id: 1, created_at: "2026-10-19T10:00:00Z" });
const r2 = run({ id: 2, created_at: "2026-10-19T09:00:00Z" });
const r3 = run({ id: 3, created_at: "2026-10-18T12:00:00Z" });
const r4 = run({ id: 4, created_at: "" });
const groups = groupRunsByDay([r2, r1, r4, r3], TODAY, ZONE, runComparator("newest_first"));
assert.deepEqual(
groups.map((g) => g.label),
["Today", "Yesterday", "Unknown date"],
);
assert.deepEqual(
groups[0].runs.map((r) => r.id),
[1, 2],
);
});
// ---------------------------------------------------------------------------
// The list's slots
// ---------------------------------------------------------------------------
test("runListEntries orders usage, the empty state, groups and the inline error", () => {
const usage = { total: 3 };
const recorded = runListEntries(usage, true, true, [], null);
assert.deepEqual(
recorded.map((e) => e.kind),
["usage", "empty"],
);
assert.equal(recorded[1].message, NO_RUNS_MESSAGE);
assert.equal(recorded[1].actionLabel, null);
const matched = runListEntries(null, false, true, [], "boom");
assert.deepEqual(
matched.map((e) => e.kind),
["empty", "error"],
);
assert.equal(matched[0].message, NO_MATCH_MESSAGE);
assert.equal(matched[0].actionLabel, "Clear filters");
const groups = [{ label: "Today", runs: [run({ id: 1 }), run({ id: 2 })] }];
const body = runListEntries(null, false, false, groups, null);
assert.deepEqual(
body.map((e) => e.kind),
["day", "run", "run"],
);
assert.equal(body[0].label, "Today");
assert.deepEqual(
body.filter((e) => e.kind === "run").map((e) => e.run.id),
[1, 2],
);
});
+170 -3
View File
@@ -79,10 +79,177 @@ try {
await page.waitForSelector(".detail h2");
shots.push(await page.screenshot(`${out}/02-pipeline-detail.png`));
step("switching to Runs and opening a run detail");
step("switching to Runs: day-grouped list + usage roll-up");
await page.clickText("nav.tabs button.tab", "Runs");
await page.waitForSelector(".list button.row", { timeout: 25000 });
await page.click(".list button.row");
await page.waitForSelector(".list.runs .day-header", { timeout: 25000 });
await page.waitForSelector(".metrics .metric", { timeout: 25000 });
const usageLabels = await page.evaluate(
`[...document.querySelectorAll(".metrics .metric-label")].map((n) => n.textContent)`,
);
for (const label of ["Total", "Succeeded", "Failed", "Canceled", "Interrupted", "Active"]) {
if (!usageLabels.includes(label)) throw new Error(`usage metric missing: ${label}`);
}
const dayHeaders = await page.evaluate(
`[...document.querySelectorAll(".list.runs .day-header")].map((n) => n.textContent)`,
);
if (!dayHeaders.length) throw new Error("no day header rendered");
if (!dayHeaders.includes("Today")) {
throw new Error(`the list does not start with Today: ${dayHeaders.join(" | ")}`);
}
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`));
console.log(` usage: ${usageLabels.join(", ")}`);
console.log(` day headers: ${dayHeaders.slice(0, 3).join(" | ")}`);
step(`scrolling the list to the older day group (${fullDateHeader})`);
const scrolledTo = await page.evaluate(`(() => {
const scroll = document.querySelector(".run-scroll");
const header = [...document.querySelectorAll(".list.runs .day-header")]
.find((n) => /^\\d{1,2} \\w{3} \\d{4}$/.test(n.textContent));
if (!scroll || !header) return null;
scroll.scrollTop += header.getBoundingClientRect().top - scroll.getBoundingClientRect().top;
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`));
console.log(` scrolled to: ${scrolledTo}`);
step("opening the filter menu: it must stay in the viewport and be reachable");
await page.click("#runFilterBtn");
await page.waitForSelector("#runFilterMenu");
const menuLabels = await page.evaluate(
`[...document.querySelectorAll("#runFilterMenu .filter-check span")].map((n) => n.textContent)`,
);
for (const label of [
"queued",
"running",
"waiting",
"succeeded",
"failed",
"canceled",
"interrupted",
"Any pipeline",
"Any time",
"Today",
"Last 7 days",
"Last 30 days",
]) {
if (!menuLabels.includes(label)) throw new Error(`filter menu missing: ${label}`);
}
const menuActions = await page.evaluate(
`[...document.querySelectorAll("#runFilterMenu .menu-actions button")].map((n) => n.textContent)`,
);
for (const label of ["Clear filters", "Done"]) {
if (!menuActions.includes(label)) throw new Error(`filter menu action missing: ${label}`);
}
// The gate is reachability, not DOM presence: with a busy history the menu is
// taller than the viewport, so it must be bounded and scroll its own box rather
// than being clipped by an ancestor with no way for a user to reach the actions.
const reach = await page.evaluate(`(() => {
const menu = document.querySelector("#runFilterMenu");
const overflowY = getComputedStyle(menu).overflowY;
const rect = menu.getBoundingClientRect();
menu.scrollTop = menu.scrollHeight;
const actions = menu.querySelector(".menu-actions").getBoundingClientRect();
return {
overflowY,
height: Math.round(rect.height),
viewport: window.innerHeight,
fitsViewport: rect.height <= window.innerHeight && rect.bottom <= window.innerHeight + 1,
actionsReachable: actions.bottom <= window.innerHeight + 1 && actions.top >= -1,
};
})()`);
if (reach.overflowY !== "auto" && reach.overflowY !== "scroll") {
throw new Error(`the filter menu does not scroll its own box: overflow-y=${reach.overflowY}`);
}
if (!reach.fitsViewport) {
throw new Error(`the filter menu overflows the viewport: ${JSON.stringify(reach)}`);
}
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`));
console.log(` filter menu ${reach.height}px tall in a ${reach.viewport}px viewport; actions reachable`);
step("applying a status filter");
await page.evaluate(
`document.querySelector('#runFilterMenu input[data-status="failed"]').click()`,
);
const filterLabel = await page.evaluate(`document.querySelector("#runFilterBtn").textContent`);
if (!filterLabel.includes("(1)")) {
throw new Error(`filter control is missing the active count: ${filterLabel}`);
}
await page.click("#runFilterBtn"); // close the menu so the list is unobstructed
const filteredChips = await page.evaluate(
`[...document.querySelectorAll(".list.runs .run-row .run-row-head .chip")].map((n) => n.textContent)`,
);
if (!filteredChips.length) throw new Error("the status filter produced no rows");
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`));
console.log(` filtered rows: ${filteredChips.length}, all failed`);
step("filtering to a state with no runs: the filtered-empty state + Clear filters");
await page.click("#runFilterBtn");
await page.waitForSelector("#runFilterMenu");
await page.evaluate(
`document.querySelector('#runFilterMenu input[data-status="failed"]').click()`,
);
await page.evaluate(
`document.querySelector('#runFilterMenu input[data-status="interrupted"]').click()`,
);
await page.click("#runFilterBtn"); // close the menu to see the list
await page.waitForSelector(".list.runs .empty-state");
const emptyMessage = await page.evaluate(
`document.querySelector(".list.runs .empty-state span")?.textContent ?? ""`,
);
if (emptyMessage !== "No runs match the current filters.") {
throw new Error(`unexpected filtered-empty message: ${emptyMessage}`);
}
const clearAction = await page.evaluate(
`document.querySelector(".list.runs .empty-state button")?.textContent ?? null`,
);
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`));
console.log(` empty state: ${emptyMessage} (+ ${clearAction})`);
step("clearing the filters from the empty state and changing the sort");
await page.click(".list.runs .empty-state button");
await page.waitForSelector(".list.runs .day-header", { timeout: 25000 });
const resetLabel = await page.evaluate(`document.querySelector("#runFilterBtn").textContent`);
if (resetLabel.includes("(")) throw new Error(`Clear filters did not reset the count: ${resetLabel}`);
await page.click("#runSortBtn");
await page.waitForSelector("#runSortMenu");
const sortItems = await page.evaluate(
`[...document.querySelectorAll("#runSortMenu .menu-item")].map((n) => n.textContent)`,
);
for (const label of [
"Newest first",
"Oldest first",
"Longest duration",
"Shortest duration",
"Pipeline name",
"Status",
"Reset",
]) {
if (!sortItems.includes(label)) throw new Error(`sort menu missing: ${label}`);
}
shots.push(await page.screenshot(`${out}/10-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`));
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`));