Files
archie/ui/test/task-logs.test.js
T
sam 7414713d61 feat(webui): add the per-run task detail page
A per-task page at #/tasks/{id} with tabs for the attempt's stages and log, changed
files, configuration and a raw debug view. Reachable from the task list, deep
linkable via ?tab= and ?attempt=, and reload safe. Existing URLs (#/tasks?task=N
and #/tasks?status=...) are unchanged.

- A stage rail per attempt: name, duration, terminal status and error text, with
  unattributed events surfaced and the agent's own verdict shown separately.
- No pass/fail badge and no exit code anywhere: the backend has neither, and a stage
  that returned nil after producing a poor diff is a success. Status word, duration
  and error text are shown instead.
- The log pane filters by attempt, stage and level, states the coverage caveat for
  stage filters (agent and tool output records no stage), and keeps the three read
  outcomes distinct: no log reader in this deployment, no file for this attempt, and
  no entries matching the filter.
- Retry is labelled as a new run and its confirm says the previous attempt's commits
  are discarded, because it hard-resets the branch onto the base.
- An absent capture reads "not captured for this run" rather than implying nothing
  changed, and no elapsed-run figure is shown since only per-stage durations exist.
- The events cache is invalidated on retry (it previously kept the ended attempt's
  events) and the log cache is keyed by attempt, so two attempts cannot be conflated.
- ui/dist is rebuilt and committed: the gate runs the node tests but never rebuilds
  the bundle, so a stale one would otherwise ship behind a green gate.
- docs/prds/task-run-detail.md records the surface and its limits, and
  docs/architecture/observability.md describes it alongside the read endpoints.

Both new vocabularies are pinned by tests on each side (config schema, change
statuses) so a one-sided rename fails a test instead of silently degrading the page.
2026-09-18 18:33:03 +10:00

249 lines
11 KiB
JavaScript

import { test } from "node:test";
import assert from "node:assert/strict";
import { render, cleanup, fireEvent } from "@testing-library/preact";
import { TaskLogPanel, logCacheKey, taskLogDownloadURL } from "../src/tasks/task-logs.jsx";
function renderPanel(state, opts = {}) {
const { container, unmount } = render(
<TaskLogPanel
state={state}
onRetry={opts.onRetry}
taskId={opts.taskId}
attempt={opts.attempt}
filters={opts.filters}
onFilterChange={opts.onFilterChange}
stages={opts.stages}
/>,
);
return { root: container, unmount };
}
test("loading state renders a loading placeholder", () => {
const { root, unmount } = renderPanel(undefined);
assert.match(root.querySelector(".task-log-loading")?.className || "", /task-log-loading/);
assert.match(root.textContent, /Loading/);
unmount();
});
test("fetch failure renders a retry control", () => {
const { root, unmount } = renderPanel(null, { onRetry: () => {} });
assert.match(root.querySelector(".task-log-error")?.className || "", /task-log-error/);
const btn = root.querySelector("button");
assert.ok(btn, "a retry button should render");
assert.equal(btn.textContent, "Retry");
unmount();
});
// The panel used to answer every failed read with "Task logging is optional
// and was not enabled for this run", which was false in a deployment where
// logging is unconditional: the dashboard simply could not read the log. The
// two conditions are now stated differently, and this pins that they stay so.
test("a reader that is absent says the dashboard cannot read logs, not that logging is off", () => {
const { root, unmount } = renderPanel({ disabled: true, entries: [] });
assert.match(root.textContent, /No persisted log/);
assert.doesNotMatch(
root.textContent,
/not enabled for this run/,
"this text blames a configuration setting for a process that simply cannot read logs",
);
unmount();
});
test("an attempt with a reader but no log file is not reported as disabled", () => {
const { root, unmount } = renderPanel({ found: false, entries: [], attempt: 0 });
assert.match(root.textContent, /No log recorded for this attempt/);
assert.doesNotMatch(root.textContent, /was not enabled for this run/);
unmount();
});
test("empty entries render a placeholder distinct from the disabled state", () => {
const { root, unmount } = renderPanel({ disabled: false, found: true, entries: [], attempt: 0 });
assert.match(root.textContent, /Nothing recorded/);
unmount();
});
test("entries render one row per entry with fields visible, surfacing stage/token detail", () => {
const { root, unmount } = renderPanel({
found: true,
entries: [
{
time: "2026-01-01T00:00:00Z",
level: "info",
msg: "stage complete",
fields: { stage: "implement", tokens: 1234, model: "sonnet" },
},
{
time: "2026-01-01T00:01:00Z",
level: "error",
msg: "agent failed",
fields: { iteration: 3 },
},
],
});
const list = root.querySelector(".log-list");
assert.ok(list, "the log list wrapper should render");
assert.equal(list.children.length, 2, "one .log-row per entry");
assert.match(root.textContent, /stage complete/);
assert.match(root.textContent, /implement/);
assert.match(root.textContent, /1234/);
assert.match(root.textContent, /sonnet/);
assert.match(root.textContent, /agent failed/);
assert.match(root.textContent, /iteration/);
unmount();
});
// The download is the feature the panel was missing: an operator who wants the
// log in their own tooling had no way to get it.
test("the download link points at the attempt being shown", () => {
assert.equal(taskLogDownloadURL(42, 3), "/api/tasks/42/logs/download?attempt=3");
// No attempt yet resolved: let the server pick the task's current one.
assert.equal(taskLogDownloadURL(42, null), "/api/tasks/42/logs/download");
});
test("a panel with entries offers the download for that attempt", () => {
const { root, unmount } = renderPanel({ found: true, attempt: 3, entries: [{ level: "info", msg: "hi" }] }, { taskId: 42 });
const link = root.querySelector(".task-log-download");
assert.ok(link, "a download control should render when the attempt has a log");
assert.equal(link.getAttribute("href"), "/api/tasks/42/logs/download?attempt=3");
unmount();
});
test("a panel for an attempt with no log offers no download", () => {
const { root, unmount } = renderPanel({ found: false, attempt: 0, entries: [] }, { taskId: 42 });
assert.equal(root.querySelector(".task-log-download"), null, "there is nothing to download");
unmount();
});
// W7: the filter controls must sit ABOVE the three read outcomes. Below the
// disabled early return they would replace the deployment-level message with an
// empty filtered pane in exactly the deployment that cannot read logs.
const FILTER_OPTS = { filters: { level: "", stage: "" }, onFilterChange: () => {}, stages: ["prepare"] };
test("the three read outcomes survive with the filter bar rendered above them", () => {
const disabled = renderPanel({ disabled: true, entries: [] }, FILTER_OPTS);
assert.ok(disabled.root.querySelector(".task-log-filters"), "the filter bar renders first");
assert.match(disabled.root.textContent, /No persisted log for this attempt/);
assert.match(disabled.root.textContent, /cannot read task logs/);
disabled.unmount();
const absent = renderPanel({ found: false, entries: [], attempt: 0 }, FILTER_OPTS);
assert.match(absent.root.textContent, /No log recorded for this attempt/);
assert.doesNotMatch(absent.root.textContent, /cannot read task logs/);
absent.unmount();
const filtered = renderPanel({ disabled: false, found: true, entries: [], attempt: 0 }, FILTER_OPTS);
assert.equal(filtered.root.querySelector(".empty-title").textContent, "Nothing recorded");
filtered.unmount();
});
// W6: one cache entry per task could not represent two attempts, so a retry
// served the previous run's log under the new run's id.
test("the log cache key is keyed by task, attempt and filters", () => {
assert.equal(logCacheKey(7, 1), "7|1||");
assert.notEqual(logCacheKey(7, 1), logCacheKey(7, 2), "two attempts must not share a cache entry");
assert.notEqual(logCacheKey(7, 1), logCacheKey(71, 1), "two tasks must not share a cache entry");
assert.notEqual(
logCacheKey(7, 1, { level: "ERROR", stage: "" }),
logCacheKey(7, 1, { level: "", stage: "" }),
"a filtered read is a different response and needs its own entry",
);
});
// F2: a stage filter narrows to lines a stage tagged and nothing more. Agent and
// tool output has no stage, so a sparse result must be explained next to the
// control rather than left to look broken.
test("a stage filter states its coverage limit beside the control", () => {
const { root, unmount } = renderPanel(
{ found: true, entries: [], attempt: 1 },
{ ...FILTER_OPTS, filters: { level: "", stage: "prepare" }, stages: ["prepare", "implement"] },
);
assert.match(root.textContent, /A stage filter matches only log lines that record a stage/);
assert.match(root.textContent, /Agent and tool output carries none/);
unmount();
});
test("an attempt with no recorded stage names says the stage filter has nothing to match", () => {
const { root, unmount } = renderPanel(
{ found: true, entries: [], attempt: 1 },
{ ...FILTER_OPTS, stages: [] },
);
assert.match(root.textContent, /recorded no stage names/);
unmount();
});
test("changing a filter reports the whole filter set to the page", () => {
const seen = [];
const { root, unmount } = renderPanel(
{ found: true, entries: [], attempt: 1 },
{ ...FILTER_OPTS, onFilterChange: (next) => seen.push(next) },
);
const level = root.querySelectorAll("select")[0];
const stage = root.querySelectorAll("select")[1];
fireEvent.change(level, { target: { value: "ERROR" } });
fireEvent.change(stage, { target: { value: "prepare" } });
assert.deepEqual(seen, [
{ level: "ERROR", stage: "" },
{ level: "", stage: "prepare" },
]);
unmount();
});
// The pane names the attempt it is showing so it can never present attempt 1's
// log as attempt 2's.
test("the pane names the attempt it is showing", () => {
const explicit = renderPanel({ found: true, attempt: 1, entries: [] }, { attempt: 1 });
assert.match(explicit.root.textContent, /Attempt 1/);
explicit.unmount();
const resolved = renderPanel({ found: true, attempt: 4, entries: [] }, { attempt: null, taskId: 42 });
assert.match(resolved.root.textContent, /Attempt 4/);
assert.equal(
resolved.root.querySelector(".task-log-download").getAttribute("href"),
"/api/tasks/42/logs/download?attempt=4",
"a download follows the attempt the pane is showing, not whatever is current",
);
resolved.unmount();
});
test("a panel without a page to act on a filter renders no filter controls", () => {
const { root, unmount } = renderPanel({ found: true, entries: [], attempt: 1 });
assert.equal(root.querySelector("select"), null, "a control that filters nothing is worse than none");
assert.match(root.textContent, /Attempt 1/);
unmount();
});
// R9: the pane carries one live region announcing its STATE, never a line at a
// time. A per-line live region would read the whole log aloud on every load,
// and a pane that loads 500 entries would be unusable with a screen reader.
test("the pane announces its state once, not every log line", () => {
const { root, unmount } = renderPanel({
found: true,
attempt: 2,
entries: [
{ level: "info", msg: "one" },
{ level: "info", msg: "two" },
],
});
const live = root.querySelector("[aria-live]");
assert.ok(live, "the pane should carry a live region");
assert.equal(live.getAttribute("role"), "status");
assert.equal(live.getAttribute("aria-atomic"), "true");
assert.match(live.textContent, /2 log entries/);
assert.ok(live.className.includes("visually-hidden"), "the live text is for assistive technology only");
assert.equal(root.querySelector(".log-list").contains(live), false, "the live region is not the list itself");
unmount();
});
test("the live region says which of the log-unavailable cases applies", () => {
const disabled = renderPanel({ disabled: true, entries: [] });
assert.match(disabled.root.querySelector("[aria-live]").textContent, /cannot read task logs/);
disabled.unmount();
const absent = renderPanel({ found: false, entries: [], attempt: 0 });
assert.match(absent.root.querySelector("[aria-live]").textContent, /No log recorded for this attempt/);
assert.doesNotMatch(absent.root.querySelector("[aria-live]").textContent, /cannot read task logs/);
absent.unmount();
});
test.after(() => cleanup());