From 849a18456106adcecc46ab2aa6c0c2de2174ea79 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Mon, 19 Oct 2026 02:50:51 +0100 Subject: [PATCH] web: run history list, filter and sort (R1/R2) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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). --- web/PARITY.md | 4 +- web/src/app.js | 382 ++++++++++++++++++++++++++---- web/src/runs.js | 512 +++++++++++++++++++++++++++++++++++++++++ web/styles.css | 185 ++++++++++++++- web/test/runs.test.mjs | 393 +++++++++++++++++++++++++++++++ web/test/ui-smoke.mjs | 173 +++++++++++++- 6 files changed, 1601 insertions(+), 48 deletions(-) create mode 100644 web/src/runs.js create mode 100644 web/test/runs.test.mjs diff --git a/web/PARITY.md b/web/PARITY.md index 5df4f4e4..af754d46 100644 --- a/web/PARITY.md +++ b/web/PARITY.md @@ -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 | diff --git a/web/src/app.js b/web/src/app.js index 1af401e1..b612314f 100644 --- a/web/src/app.js +++ b/web/src/app.js @@ -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(); }); diff --git a/web/src/runs.js b/web/src/runs.js new file mode 100644 index 00000000..7737f6b5 --- /dev/null +++ b/web/src/runs.js @@ -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; + } +} diff --git a/web/styles.css b/web/styles.css index f753f440..bf3e21d3 100644 --- a/web/styles.css +++ b/web/styles.css @@ -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); } diff --git a/web/test/runs.test.mjs b/web/test/runs.test.mjs new file mode 100644 index 00000000..ee7bce32 --- /dev/null +++ b/web/test/runs.test.mjs @@ -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], + ); +}); diff --git a/web/test/ui-smoke.mjs b/web/test/ui-smoke.mjs index c39dfc6e..74ff5095 100644 --- a/web/test/ui-smoke.mjs +++ b/web/test/ui-smoke.mjs @@ -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`));