Files
pipelines/web/test/routes.test.mjs
T

300 lines
12 KiB
JavaScript

// Unit tests for the pure URL route model (web/src/routes.js). No DOM and no
// server: every case here is a claim the live UI smoke relies on.
import test from "node:test";
import assert from "node:assert/strict";
import {
DEFAULT_ROUTE,
parseRoute,
sameRoute,
serializeRoute,
} from "../src/routes.js";
const defaultRoute = () => ({ ...DEFAULT_ROUTE });
test("pipeline-specific Runs links survive reload and ignore invalid filter ids", () => {
assert.deepEqual(parseRoute("/runs?pipeline=27"), { kind: "runs", pipelineId: 27 });
assert.equal(serializeRoute({ kind: "runs", pipelineId: 27 }), "/runs?pipeline=27");
assert.deepEqual(parseRoute("/runs?pipeline=bad"), { kind: "runs" });
assert.equal(serializeRoute({ kind: "runs", pipelineId: -1 }), "/runs");
});
test("default destination: empty, root, unknown and malformed paths", () => {
for (const path of [
undefined,
null,
"",
"/",
"///",
"/nope",
"/pipelinesx",
"/runs/abc",
"/runs/0",
"/runs/-1",
"/runs/1x",
"/pipelines/x",
"/pipelines/24/-1",
"/pipelines/24/1x",
"/pipelines/24/5/nope",
"/pipelines/24/5/stage",
"/runs/440/stage",
// A trailing segment on a versionless stage branch is malformed, not a
// dropped visit or an ignored extra: both stage branches require exactly
// four segments (the versioned pipeline branch already rejected extras).
"/runs/440/stage/planner/extra",
"/runs/440/stage/planner/2",
"/pipelines/24/stage/planner/extra",
"/pipelines/24/stage/planner/2",
"/runs/%E0%A4%A",
"/pipelines/%E0%A4%A",
"/templates/%E0%A4%A",
"/runs/440/stage/%E0%A4%A",
]) {
assert.deepEqual(parseRoute(path), defaultRoute(), `path ${JSON.stringify(path)}`);
}
});
test("top-level destinations", () => {
assert.deepEqual(parseRoute("/pipelines"), { kind: "pipelines" });
assert.deepEqual(parseRoute("/runs"), { kind: "runs" });
assert.deepEqual(parseRoute("/chat"), { kind: "chat" });
assert.deepEqual(parseRoute("/chat/ses_abc123"), { kind: "chatSession", id: "ses_abc123" });
assert.deepEqual(parseRoute("/chat/ses_a/b"), { kind: "pipelines" });
assert.deepEqual(parseRoute("/chat/"), { kind: "chat" });
assert.deepEqual(parseRoute("/settings"), { kind: "settings" });
assert.deepEqual(parseRoute("/templates"), { kind: "templates" });
});
test("trailing slashes are normalised and location-style strings accepted", () => {
assert.deepEqual(parseRoute("/runs/"), { kind: "runs" });
assert.deepEqual(parseRoute("/runs/440/"), { kind: "run", id: 440 });
assert.deepEqual(parseRoute("http://127.0.0.1:8090/runs/440?visit=2"), {
kind: "run",
id: 440,
});
assert.deepEqual(parseRoute("http://127.0.0.1:8090/runs/440"), { kind: "run", id: 440 });
assert.deepEqual(parseRoute("/runs/440?action=decide"), { kind: "run", id: 440, action: "decide" });
});
test("pipeline detail: absent and zero versions are the same latest route", () => {
const latest = { kind: "pipeline", id: 24, version: 0 };
assert.deepEqual(parseRoute("/pipelines/24"), latest);
assert.deepEqual(parseRoute("/pipelines/24/0"), latest);
assert.deepEqual(parseRoute("/pipelines/24/5"), { kind: "pipeline", id: 24, version: 5 });
assert.equal(serializeRoute(parseRoute("/pipelines/24")), "/pipelines/24");
assert.equal(serializeRoute(parseRoute("/pipelines/24/0")), "/pipelines/24");
assert.equal(serializeRoute(parseRoute("/pipelines/24/5")), "/pipelines/24/5");
});
test("run detail and the optional decide action", () => {
assert.deepEqual(parseRoute("/runs/440"), { kind: "run", id: 440 });
assert.deepEqual(parseRoute("/runs/440?action=decide"), { kind: "run", id: 440, action: "decide" });
assert.equal(serializeRoute({ kind: "run", id: 440 }), "/runs/440");
assert.equal(serializeRoute({ kind: "run", id: 440, action: "decide" }), "/runs/440?action=decide");
});
test("run stage: optional zero-based visit, invalid visit dropped", () => {
assert.deepEqual(parseRoute("/runs/440/stage/planner"), {
kind: "runStage",
id: 440,
stageKey: "planner",
});
assert.deepEqual(parseRoute("/runs/440/stage/planner", "?visit=2"), {
kind: "runStage",
id: 440,
stageKey: "planner",
visit: 2,
});
assert.deepEqual(parseRoute("/runs/440/stage/planner?visit=0"), {
kind: "runStage",
id: 440,
stageKey: "planner",
visit: 0,
});
// An invalid visit is dropped while the stage route is kept.
for (const query of ["?visit=-1", "?visit=x", "?visit=", "?visit=1.5"]) {
assert.deepEqual(parseRoute("/runs/440/stage/planner", query), {
kind: "runStage",
id: 440,
stageKey: "planner",
});
}
assert.equal(
serializeRoute({ kind: "runStage", id: 440, stageKey: "planner" }),
"/runs/440/stage/planner",
);
assert.equal(
serializeRoute({ kind: "runStage", id: 440, stageKey: "planner", visit: 0 }),
"/runs/440/stage/planner?visit=0",
);
assert.equal(
serializeRoute({ kind: "runStage", id: 440, stageKey: "planner", visit: -1 }),
"/runs/440/stage/planner",
);
});
test("pipeline stage routes, with and without an explicit version", () => {
assert.deepEqual(parseRoute("/pipelines/24/5/stage/planner"), {
kind: "pipelineStage",
id: 24,
version: 5,
stageKey: "planner",
});
assert.deepEqual(parseRoute("/pipelines/24/stage/planner"), {
kind: "pipelineStage",
id: 24,
version: 0,
stageKey: "planner",
});
assert.deepEqual(parseRoute("/pipelines/24/0/stage/planner"), {
kind: "pipelineStage",
id: 24,
version: 0,
stageKey: "planner",
});
assert.equal(
serializeRoute({ kind: "pipelineStage", id: 24, version: 5, stageKey: "planner" }),
"/pipelines/24/5/stage/planner",
);
assert.equal(
serializeRoute({ kind: "pipelineStage", id: 24, version: 0, stageKey: "planner" }),
"/pipelines/24/stage/planner",
);
});
test("templates gallery and detail, including the /settings aliases", () => {
assert.deepEqual(parseRoute("/templates"), { kind: "templates" });
assert.deepEqual(parseRoute("/settings/templates"), { kind: "templates" });
assert.deepEqual(parseRoute("/templates/plan"), { kind: "template", key: "plan" });
assert.deepEqual(parseRoute("/settings/templates/plan"), { kind: "template", key: "plan" });
assert.equal(serializeRoute({ kind: "template", key: "plan" }), "/templates/plan");
assert.equal(
serializeRoute(parseRoute("/settings/templates/plan")),
"/templates/plan",
);
});
test("unknown query state is ignored; only action and visit are read", () => {
assert.deepEqual(parseRoute("/runs/440", "?q=plan&kind=runs&sort=name"), {
kind: "run",
id: 440,
});
assert.deepEqual(parseRoute("/runs", "?q=plan&kind=pipelines&sort=newest"), { kind: "runs" });
assert.deepEqual(parseRoute("/runs/440?visit=2"), { kind: "run", id: 440 });
assert.deepEqual(parseRoute("/runs/440/stage/planner?visit=2&q=x"), {
kind: "runStage",
id: 440,
stageKey: "planner",
visit: 2,
});
});
test("stage and template keys are percent-encoded and round-trip", () => {
const stageKey = "plan/land & go";
const templateKey = "a b/c?d#e";
// A dotted key stays one path segment; serve.mjs must not mistake it for an
// asset when the shell is requested for a hard navigation.
assert.deepEqual(parseRoute(serializeRoute({ kind: "pipelineStage", id: 7, version: 2, stageKey: "plan.v2" })), {
kind: "pipelineStage",
id: 7,
version: 2,
stageKey: "plan.v2",
});
const stage = parseRoute(serializeRoute({ kind: "runStage", id: 7, stageKey, visit: 3 }));
assert.deepEqual(stage, { kind: "runStage", id: 7, stageKey, visit: 3 });
assert.equal(
serializeRoute({ kind: "pipelineStage", id: 7, version: 2, stageKey }),
"/pipelines/7/2/stage/plan%2Fland%20%26%20go",
);
assert.deepEqual(parseRoute(serializeRoute({ kind: "template", key: templateKey })), {
kind: "template",
key: templateKey,
});
assert.equal(serializeRoute({ kind: "template", key: templateKey }), "/templates/a%20b%2Fc%3Fd%23e");
});
test("serialisation is idempotent and parse(serialize(route)) preserves every route", () => {
const routes = [
{ kind: "pipelines" },
{ kind: "runs" },
{ kind: "chat" },
{ kind: "chatSession", id: "ses_abc123" },
{ kind: "settings" },
{ kind: "templates" },
{ kind: "template", key: "plan" },
{ kind: "pipeline", id: 24, version: 0 },
{ kind: "pipeline", id: 24, version: 5 },
{ kind: "pipelineStage", id: 24, version: 0, stageKey: "planner" },
{ kind: "pipelineStage", id: 24, version: 5, stageKey: "plan/land" },
{ kind: "run", id: 440 },
{ kind: "run", id: 440, action: "decide" },
{ kind: "runStage", id: 440, stageKey: "planner" },
{ kind: "runStage", id: 440, stageKey: "plan/land", visit: 0 },
];
for (const route of routes) {
const url = serializeRoute(route);
const parsed = parseRoute(url);
assert.equal(serializeRoute(parsed), url, `route ${JSON.stringify(route)}`);
assert.ok(sameRoute(parsed, route), `sameRoute ${JSON.stringify(route)}`);
}
});
test("sameRoute compares the canonical serialised form", () => {
assert.ok(sameRoute({ kind: "pipeline", id: 24 }, { kind: "pipeline", id: 24, version: 0 }));
assert.ok(
sameRoute(
parseRoute("/settings/templates/plan"),
{ kind: "template", key: "plan" },
),
);
assert.ok(!sameRoute({ kind: "run", id: 440 }, { kind: "run", id: 440, action: "decide" }));
assert.ok(!sameRoute({ kind: "runs" }, { kind: "pipelines" }));
});
test("a bad route object serialises to the default, never throws", () => {
assert.equal(serializeRoute(null), "/pipelines");
assert.equal(serializeRoute({}), "/pipelines");
assert.equal(serializeRoute({ kind: "unknown" }), "/pipelines");
assert.equal(serializeRoute({ kind: "pipeline" }), "/pipelines");
assert.equal(serializeRoute({ kind: "runStage", id: 1 }), "/runs");
});
test("the serialiser rejects ids/versions the parser would not accept", () => {
// An invalid id cannot name an entity; the nearest canonical route is the list.
for (const id of [0, -1, 1.5, NaN, Infinity, "abc", "", null]) {
assert.equal(serializeRoute({ kind: "pipeline", id }), "/pipelines", `pipeline id ${String(id)}`);
assert.equal(serializeRoute({ kind: "run", id }), "/runs", `run id ${String(id)}`);
assert.equal(
serializeRoute({ kind: "runStage", id, stageKey: "planner" }),
"/runs",
`runStage id ${String(id)}`,
);
}
// An invalid or negative version falls back to the latest form, which parses
// back to the same route instead of emitting a path the parser rejects.
for (const version of [-1, 1.5, NaN, "abc", ""]) {
assert.equal(
serializeRoute({ kind: "pipeline", id: 24, version }),
"/pipelines/24",
`pipeline version ${String(version)}`,
);
assert.equal(
serializeRoute({ kind: "pipelineStage", id: 24, version, stageKey: "planner" }),
"/pipelines/24/stage/planner",
`pipelineStage version ${String(version)}`,
);
assert.deepEqual(parseRoute(serializeRoute({ kind: "pipelineStage", id: 24, version, stageKey: "planner" })), {
kind: "pipelineStage",
id: 24,
version: 0,
stageKey: "planner",
});
}
// A blank or non-string key cannot describe a stage/template.
assert.equal(serializeRoute({ kind: "pipelineStage", id: 24, stageKey: "" }), "/pipelines");
assert.equal(serializeRoute({ kind: "runStage", id: 440, stageKey: "" }), "/runs");
assert.equal(serializeRoute({ kind: "template", key: "" }), "/templates");
// A canonical numeric string is emitted as the number the parser reads back.
assert.equal(serializeRoute({ kind: "run", id: "440" }), "/runs/440");
assert.equal(serializeRoute({ kind: "pipeline", id: "24", version: "5" }), "/pipelines/24/5");
});