396 lines
16 KiB
JavaScript
396 lines
16 KiB
JavaScript
// The live-updates fold, exercised as a pure delta sequence so the client's
|
|
// correctness is pinned without a device or a socket: a created run, a step
|
|
// started, a step finished, a run finished, a delta for a run the list does not
|
|
// hold, an out-of-order/duplicate delta, and a reconnect resync.
|
|
//
|
|
// A direct port of android/.../ui/RunEventsTest.kt, so the browser fold and the
|
|
// app fold are proven against the same shape.
|
|
import { test } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
import {
|
|
TERMINAL_RUN_STATUSES,
|
|
executingFor,
|
|
foldRunEvent,
|
|
foldRunEventDetail,
|
|
isTerminalRunStatus,
|
|
isWaitingRunStatus,
|
|
newRunSummaryFromFrame,
|
|
runDetailNeedsFullSync,
|
|
runLifecycleRank,
|
|
stepLifecycleRank,
|
|
} from "../src/runEvents.js";
|
|
|
|
function summary(id, { status = "running", executing = true, currentStage = "", completedSteps = 0, finishedAt = "" } = {}) {
|
|
return {
|
|
id,
|
|
pipeline_id: 4,
|
|
name: "pipeline",
|
|
status,
|
|
executing,
|
|
current_stage: currentStage,
|
|
completed_steps: completedSteps,
|
|
created_at: "2026-10-17T09:00:00Z",
|
|
finished_at: finishedAt,
|
|
};
|
|
}
|
|
|
|
function detail({ id = 1, status = "queued", executing = true, currentStage = "", completedSteps = 0, finishedAt = "", steps = [] } = {}) {
|
|
return {
|
|
id,
|
|
pipeline_id: 4,
|
|
name: "pipeline",
|
|
status,
|
|
executing,
|
|
current_stage: currentStage,
|
|
completed_steps: completedSteps,
|
|
created_at: "2026-10-17T09:00:00Z",
|
|
finished_at: finishedAt,
|
|
steps,
|
|
};
|
|
}
|
|
|
|
function step({ sequence = 1, stage = "build", status = "running", outcome = "", target = "" } = {}) {
|
|
return { sequence, stage, status, outcome, target };
|
|
}
|
|
|
|
function frame({
|
|
runId = 1,
|
|
status = "",
|
|
currentStage = "",
|
|
outcome = "",
|
|
completedSteps = 0,
|
|
finishedAt = "",
|
|
step: stepDelta = null,
|
|
pipelineId = 0,
|
|
name = "",
|
|
title = "",
|
|
version = 0,
|
|
createdAt = "",
|
|
} = {}) {
|
|
return {
|
|
run_id: runId,
|
|
workspace: "/work",
|
|
pipeline_id: pipelineId,
|
|
name,
|
|
title,
|
|
version,
|
|
status,
|
|
outcome,
|
|
current_stage: currentStage,
|
|
completed_steps: completedSteps,
|
|
created_at: createdAt,
|
|
finished_at: finishedAt,
|
|
step: stepDelta,
|
|
};
|
|
}
|
|
|
|
// --- lifecycle vocabulary ----------------------------------------------------
|
|
|
|
test("the lifecycle ladders mirror RunEvents.kt", () => {
|
|
assert.deepEqual(TERMINAL_RUN_STATUSES, ["succeeded", "failed", "canceled", "interrupted"]);
|
|
assert.equal(runLifecycleRank("queued"), 0);
|
|
assert.equal(runLifecycleRank("running"), 1);
|
|
assert.equal(runLifecycleRank("waiting"), 1);
|
|
assert.equal(runLifecycleRank("succeeded"), 2);
|
|
assert.equal(runLifecycleRank("nonsense"), -1);
|
|
assert.equal(stepLifecycleRank("running"), 1);
|
|
assert.equal(stepLifecycleRank("completed"), 2);
|
|
assert.equal(stepLifecycleRank(""), -1);
|
|
assert.equal(isWaitingRunStatus(" waiting "), true);
|
|
assert.equal(isTerminalRunStatus("SUCCEEDED"), true);
|
|
assert.equal(isTerminalRunStatus("waiting"), false);
|
|
assert.equal(executingFor("queued", false), true);
|
|
assert.equal(executingFor("waiting", true), false);
|
|
assert.equal(executingFor("", true), true);
|
|
assert.equal(executingFor("", false), false);
|
|
});
|
|
|
|
// --- runs list ---------------------------------------------------------------
|
|
|
|
test("a delta updates a matching row in place without reordering", () => {
|
|
const runs = [summary(3, { status: "succeeded", executing: false }), summary(1)];
|
|
const fold = foldRunEvent(runs, frame({ runId: 1, status: "running", currentStage: "build", completedSteps: 1 }));
|
|
assert.equal(fold.needsResync, false);
|
|
assert.deepEqual(fold.runs.map((run) => run.id), [3, 1]);
|
|
const updated = fold.runs.find((run) => run.id === 1);
|
|
assert.equal(updated.status, "running");
|
|
assert.equal(updated.current_stage, "build");
|
|
assert.equal(updated.completed_steps, 1);
|
|
assert.equal(updated.executing, true);
|
|
assert.equal(fold.runs[0], runs[0], "the other row is shared, not copied");
|
|
});
|
|
|
|
test("a new run appears from its frame without a fetch", () => {
|
|
const runs = [summary(1, { status: "succeeded", executing: false })];
|
|
const fold = foldRunEvent(
|
|
runs,
|
|
frame({
|
|
runId: 9,
|
|
status: "queued",
|
|
pipelineId: 4,
|
|
name: "pipeline",
|
|
title: "a fresh run",
|
|
version: 3,
|
|
createdAt: "2026-10-17T09:30:00Z",
|
|
}),
|
|
);
|
|
assert.equal(fold.needsResync, false);
|
|
assert.deepEqual(fold.runs.map((run) => run.id), [9, 1]);
|
|
const added = fold.runs[0];
|
|
assert.equal(added.pipeline_id, 4);
|
|
assert.equal(added.name, "pipeline");
|
|
assert.equal(added.title, "a fresh run");
|
|
assert.equal(added.version, 3);
|
|
assert.equal(added.status, "queued");
|
|
assert.equal(added.executing, true);
|
|
assert.equal(added.created_at, "2026-10-17T09:30:00Z");
|
|
});
|
|
|
|
test("a frame for an unknown run without identity still asks for a resync", () => {
|
|
const runs = [summary(1)];
|
|
const fold = foldRunEvent(runs, frame({ runId: 9, status: "queued" }));
|
|
assert.equal(fold.needsResync, true);
|
|
assert.equal(fold.runs, runs);
|
|
});
|
|
|
|
test("an inserted run then advances in place", () => {
|
|
const created = foldRunEvent(
|
|
[],
|
|
frame({ runId: 9, status: "queued", pipelineId: 4, name: "pipeline", version: 1, createdAt: "2026-10-17T09:30:00Z" }),
|
|
).runs;
|
|
const running = foldRunEvent(created, frame({ runId: 9, status: "running", currentStage: "build", completedSteps: 1 }));
|
|
assert.equal(running.needsResync, false);
|
|
assert.equal(running.runs.length, 1);
|
|
assert.equal(running.runs[0].status, "running");
|
|
assert.equal(running.runs[0].current_stage, "build");
|
|
const done = foldRunEvent(
|
|
running.runs,
|
|
frame({ runId: 9, status: "succeeded", outcome: "success", completedSteps: 1, finishedAt: "2026-10-17T09:31:00Z" }),
|
|
);
|
|
assert.equal(done.runs.length, 1);
|
|
assert.equal(done.runs[0].status, "succeeded");
|
|
assert.equal(done.runs[0].executing, false);
|
|
});
|
|
|
|
test("a delta for an unknown run also asks for a resync", () => {
|
|
const runs = [summary(1, { status: "succeeded", executing: false })];
|
|
const fold = foldRunEvent(runs, frame({ runId: 42, status: "running", currentStage: "x" }));
|
|
assert.equal(fold.needsResync, true);
|
|
assert.deepEqual(fold.runs.map((run) => run.id), [1]);
|
|
});
|
|
|
|
test("a duplicate or out-of-order list delta never regresses a run", () => {
|
|
const settled = [summary(1, { status: "succeeded", executing: false, finishedAt: "2026-10-17T09:05:00Z" })];
|
|
const fold = foldRunEvent(settled, frame({ runId: 1, status: "running", currentStage: "build" }));
|
|
assert.equal(fold.needsResync, false);
|
|
assert.equal(fold.runs[0].status, "succeeded");
|
|
assert.equal(fold.runs[0].executing, false);
|
|
assert.equal(fold.runs, settled, "an unchanged fold keeps the original list");
|
|
});
|
|
|
|
test("a terminal run delta settles the row and stops executing", () => {
|
|
const fold = foldRunEvent(
|
|
[summary(1, { status: "running" })],
|
|
frame({ runId: 1, status: "failed", outcome: "error", finishedAt: "2026-10-17T09:06:00Z" }),
|
|
);
|
|
const run = fold.runs[0];
|
|
assert.equal(run.status, "failed");
|
|
assert.equal(run.outcome, "error");
|
|
assert.equal(run.executing, false);
|
|
assert.equal(run.finished_at, "2026-10-17T09:06:00Z");
|
|
});
|
|
|
|
test("a stale running frame after terminal leaves the list unchanged whole", () => {
|
|
const terminal = [summary(1, { status: "succeeded", executing: false, finishedAt: "2026-10-17T09:06:00Z" })];
|
|
const fold = foldRunEvent(terminal, frame({ runId: 1, status: "running", currentStage: "build", completedSteps: 3 }));
|
|
assert.equal(fold.runs, terminal, "the whole frame is dropped, not just its status");
|
|
assert.equal(fold.runs[0].current_stage, "");
|
|
assert.equal(fold.runs[0].completed_steps, 0);
|
|
});
|
|
|
|
test("a second, different terminal word is dropped", () => {
|
|
const failed = [summary(1, { status: "failed", executing: false })];
|
|
const fold = foldRunEvent(failed, frame({ runId: 1, status: "canceled" }));
|
|
assert.equal(fold.runs, failed);
|
|
assert.equal(fold.runs[0].status, "failed");
|
|
});
|
|
|
|
// --- run detail --------------------------------------------------------------
|
|
|
|
test("a step started delta adds the visit and runs the run", () => {
|
|
const folded = foldRunEventDetail(
|
|
detail(),
|
|
frame({ runId: 1, status: "running", currentStage: "build", step: { sequence: 1, stage: "build", status: "running" } }),
|
|
);
|
|
assert.equal(folded.status, "running");
|
|
assert.equal(folded.executing, true);
|
|
assert.equal(folded.current_stage, "build");
|
|
assert.equal(folded.steps.length, 1);
|
|
assert.equal(folded.steps[0].sequence, 1);
|
|
assert.equal(folded.steps[0].status, "running");
|
|
});
|
|
|
|
test("a step finished delta settles the visit and counts it", () => {
|
|
const started = detail({ status: "running", currentStage: "build", steps: [step()] });
|
|
const folded = foldRunEventDetail(
|
|
started,
|
|
frame({
|
|
runId: 1,
|
|
status: "running",
|
|
currentStage: "build",
|
|
completedSteps: 1,
|
|
step: { sequence: 1, stage: "build", status: "completed", outcome: "success", target: "#success" },
|
|
}),
|
|
);
|
|
assert.equal(folded.steps.length, 1);
|
|
assert.equal(folded.steps[0].status, "completed");
|
|
assert.equal(folded.steps[0].outcome, "success");
|
|
assert.equal(folded.steps[0].target, "#success");
|
|
assert.equal(folded.completed_steps, 1);
|
|
assert.equal(folded.executing, true, "the run is still going until the terminal frame");
|
|
});
|
|
|
|
test("a run finished delta settles the run with its terminal fields", () => {
|
|
const folded = foldRunEventDetail(
|
|
detail({ status: "running", executing: true, currentStage: "build" }),
|
|
frame({ runId: 1, status: "succeeded", outcome: "success", finishedAt: "2026-10-17T09:07:00Z", completedSteps: 2 }),
|
|
);
|
|
assert.equal(folded.status, "succeeded");
|
|
assert.equal(folded.outcome, "success");
|
|
assert.equal(folded.executing, false);
|
|
assert.equal(folded.finished_at, "2026-10-17T09:07:00Z");
|
|
assert.equal(folded.completed_steps, 2);
|
|
});
|
|
|
|
test("a duplicate step delta is idempotent", () => {
|
|
const started = foldRunEventDetail(
|
|
detail(),
|
|
frame({ runId: 1, status: "running", step: { sequence: 1, stage: "build", status: "running" } }),
|
|
);
|
|
const again = foldRunEventDetail(
|
|
started,
|
|
frame({ runId: 1, status: "running", step: { sequence: 1, stage: "build", status: "running" } }),
|
|
);
|
|
assert.equal(again.steps.length, 1);
|
|
assert.equal(again, started, "a duplicate changes nothing");
|
|
});
|
|
|
|
test("an out-of-order step delta never reopens a settled visit", () => {
|
|
const settled = detail({
|
|
status: "running",
|
|
steps: [step({ status: "completed", outcome: "success", target: "#success" })],
|
|
});
|
|
const folded = foldRunEventDetail(
|
|
settled,
|
|
frame({ runId: 1, status: "running", step: { sequence: 1, stage: "build", status: "running" } }),
|
|
);
|
|
assert.equal(folded.steps[0].status, "completed");
|
|
assert.equal(folded.steps[0].outcome, "success");
|
|
assert.equal(folded, settled);
|
|
});
|
|
|
|
test("a settled step keeps its word against another terminal delta", () => {
|
|
const settled = detail({
|
|
status: "running",
|
|
steps: [step({ status: "completed", outcome: "success", target: "#success" })],
|
|
});
|
|
const folded = foldRunEventDetail(
|
|
settled,
|
|
frame({ runId: 1, status: "running", step: { sequence: 1, stage: "build", status: "failed", outcome: "error" } }),
|
|
);
|
|
assert.equal(folded.steps[0].status, "completed");
|
|
assert.equal(folded.steps[0].outcome, "success");
|
|
assert.equal(folded, settled);
|
|
});
|
|
|
|
test("a later visit is inserted in sequence order", () => {
|
|
const started = detail({
|
|
status: "running",
|
|
steps: [step({ sequence: 1, status: "completed", outcome: "success", target: "#success" })],
|
|
});
|
|
const folded = foldRunEventDetail(
|
|
started,
|
|
frame({ runId: 1, status: "running", step: { sequence: 2, stage: "review", status: "running" } }),
|
|
);
|
|
assert.deepEqual(folded.steps.map((s) => s.sequence), [1, 2]);
|
|
const lower = foldRunEventDetail(
|
|
folded,
|
|
frame({ runId: 1, status: "running", step: { sequence: 0, stage: "plan", status: "running" } }),
|
|
);
|
|
assert.deepEqual(lower.steps.map((s) => s.sequence), [0, 1, 2]);
|
|
});
|
|
|
|
test("a frame for another run leaves the detail untouched", () => {
|
|
const mine = detail({ id: 1, status: "running" });
|
|
const folded = foldRunEventDetail(mine, frame({ runId: 2, status: "succeeded" }));
|
|
assert.equal(folded, mine);
|
|
});
|
|
|
|
test("resource_wait_set sets and clears the wait explicitly", () => {
|
|
const waiting = foldRunEventDetail(
|
|
detail({ status: "running" }),
|
|
{ ...frame({ runId: 1, status: "waiting" }), resource_wait_set: true, resource_wait: { resource: "gpu", stage: "build", sequence: 1, queued_since: "2026-10-17T09:00:00Z" } },
|
|
);
|
|
assert.deepEqual(waiting.resource_wait, { resource: "gpu", stage: "build", sequence: 1, queued_since: "2026-10-17T09:00:00Z" });
|
|
const cleared = foldRunEventDetail(waiting, { ...frame({ runId: 1 }), resource_wait_set: true });
|
|
assert.equal(cleared.resource_wait, null);
|
|
// A terminal status always clears it.
|
|
const terminal = foldRunEventDetail(waiting, frame({ runId: 1, status: "succeeded" }));
|
|
assert.equal(terminal.resource_wait, null);
|
|
});
|
|
|
|
// --- resync ------------------------------------------------------------------
|
|
|
|
test("a reconnect resync takes the server snapshot then ignores a late older delta", () => {
|
|
const stale = detail({ status: "running", currentStage: "build" });
|
|
const snapshot = foldRunEventDetail(
|
|
stale,
|
|
frame({
|
|
runId: 1,
|
|
status: "succeeded",
|
|
outcome: "success",
|
|
completedSteps: 1,
|
|
finishedAt: "2026-10-17T09:07:00Z",
|
|
step: { sequence: 1, stage: "build", status: "completed", outcome: "success", target: "#success" },
|
|
}),
|
|
);
|
|
const after = foldRunEventDetail(snapshot, frame({ runId: 1, status: "running", currentStage: "build" }));
|
|
assert.equal(after.status, "succeeded");
|
|
assert.equal(after.outcome, "success");
|
|
assert.equal(after.executing, false);
|
|
assert.equal(after.completed_steps, 1);
|
|
assert.equal(after.steps.length, 1);
|
|
assert.equal(after.steps[0].status, "completed");
|
|
});
|
|
|
|
// --- sync heuristic ----------------------------------------------------------
|
|
|
|
test("settled visits, terminal runs and pending decisions need a full detail sync", () => {
|
|
assert.equal(runDetailNeedsFullSync(frame({ runId: 1, step: { sequence: 1, status: "completed" } })), true);
|
|
assert.equal(runDetailNeedsFullSync(frame({ runId: 1, step: { sequence: 1, status: "failed" } })), true);
|
|
assert.equal(runDetailNeedsFullSync(frame({ runId: 1, status: "succeeded" })), true);
|
|
assert.equal(runDetailNeedsFullSync(frame({ runId: 1, status: "canceled" })), true);
|
|
assert.equal(runDetailNeedsFullSync(frame({ runId: 1, status: "waiting" })), true);
|
|
assert.equal(runDetailNeedsFullSync(frame({ runId: 1, step: { sequence: 1, status: "waiting" } })), true);
|
|
assert.equal(runDetailNeedsFullSync(frame({ runId: 1, status: "running", step: { sequence: 1, status: "running" } })), false);
|
|
assert.equal(runDetailNeedsFullSync(frame({ runId: 1, status: "queued" })), false);
|
|
assert.equal(runDetailNeedsFullSync(frame({ runId: 1, status: "running" })), false);
|
|
});
|
|
|
|
test("a waiting human stage is not executing", () => {
|
|
assert.equal(isTerminalRunStatus("waiting"), false);
|
|
const fold = foldRunEvent([summary(1, { status: "running" })], frame({ runId: 1, status: "waiting", currentStage: "gate" }));
|
|
assert.equal(fold.runs[0].status, "waiting");
|
|
assert.equal(fold.runs[0].executing, false, "a parked human stage shows no spinner");
|
|
});
|
|
|
|
test("newRunSummaryFromFrame requires a pipeline identity and a name", () => {
|
|
assert.equal(newRunSummaryFromFrame(frame({ runId: 9, status: "queued" })), null);
|
|
assert.equal(newRunSummaryFromFrame(frame({ runId: 9, status: "queued", pipelineId: 4, name: " " })), null);
|
|
const built = newRunSummaryFromFrame(frame({ runId: 9, status: "queued", pipelineId: 4, name: "p", version: 2 }));
|
|
assert.equal(built.id, 9);
|
|
assert.equal(built.pipeline_id, 4);
|
|
assert.equal(built.title, null);
|
|
});
|