Files
archie/ui/test/workflow-edit.test.ts
sam f2b8681611 refactor(workflow): stop assuming a human decides
An approval, ask or park can be resolved by an operator, a rule, a
classifier or automatically, so the vocabulary stops naming a person:

- step type human.approve -> workflow.approve
- park class needs_human -> needs_decision (ParkNeedsDecision)
- event kinds human_* -> operator_*
- alert kind task.needs_human -> task.needs_decision
- status grouping "needs you" -> "needs attention"

0061 rewrites the stored values, including the approval step type in the
workflow-definitions resource and each task's pinned definition, with the
digest recomputed so resumed tasks still match.
2026-10-25 17:31:16 +11:00

127 lines
6.9 KiB
TypeScript

import assert from "node:assert/strict";
import test from "node:test";
import { parse } from "yaml";
const { addBranch, deleteBranch, deleteStep, insertStep, renameBranch } = await import("../src/workflows/workflow-edit.ts");
const { workflowGraph } = await import("../src/workflows/workflow-graph.ts");
const source = `id: w
steps:
- id: research
parallel:
# Keep the branch comment.
code: [{id: read, type: agent.run, settings: {mission: Read code, read_only: true}}]
docs: [{type: agent.run, settings: {mission: Read docs, read_only: true}}]
- {id: finish, type: workflow.finish}
`;
const path = ["steps", 0];
test("parallel authoring preserves branches and their YAML while guarding destructive edits", () => {
const cases: [string, () => void][] = [
["rename preserves order, comments and steps", () => {
const renamed = renameBranch(source, path, "code", "review-code");
assert.match(renamed, /Keep the branch comment/);
const before = parse(source), after = parse(renamed);
assert.deepEqual(Object.keys(after.steps[0].parallel), ["review-code", "docs"]);
assert.deepEqual(after.steps[0].parallel["review-code"], before.steps[0].parallel.code);
assert.deepEqual(after.steps[1], before.steps[1]);
}],
["rename cannot overwrite a sibling", () => assert.throws(() => renameBranch(source, path, "code", "docs"), /already exists/)],
["branch names follow the engine grammar", () => {
for (const name of ["Bad", "with space", "a..b", "", "__proto__"]) assert.throws(() => addBranch(source, path, name), /lowercase branch name/);
}],
["add and remove a branch leaves its siblings unchanged", () => {
const added = addBranch(source, path, "checks");
assert.deepEqual(parse(added).steps[0].parallel.checks, []);
assert.deepEqual(parse(deleteBranch(added, path, "checks")), parse(source));
assert.throws(() => deleteBranch(source, path, "docs"), /at least two branches/);
}],
["last step removal leaves a reachable empty branch", () => {
const empty = deleteStep(source, ["steps", 0, "parallel", "code", 0]);
assert.deepEqual(parse(empty).steps[0].parallel.code, []);
assert.ok(workflowGraph(empty).nodes.some((node) => node.type === "add" && node.data.branch === "code"));
}],
["branch insertion defaults agents to read-only and refuses unsafe steps", () => {
const inserted = insertStep(source, ["steps", 0, "parallel", "code", -1], "agent.run");
assert.equal(parse(inserted.source).steps[0].parallel.code[0].settings.read_only, true);
assert.equal(parse(inserted.source).steps[0].parallel.code[1].id, "read");
for (const type of ["parallel", "repo.commit", "command.run"]) assert.throws(() => insertStep(source, ["steps", 0, "parallel", "code", 0], type), /Branches allow only/);
}],
["every branch and the workflow end has the correct insertion path", () => {
const graph = workflowGraph(source);
assert.deepEqual(graph.nodes.find((node) => node.type === "add" && !node.data.branch)?.data.insertAfter, ["steps", 1]);
for (const branch of ["code", "docs"]) {
assert.ok(graph.edges.some((edge) => JSON.stringify(edge.insertAfter) === JSON.stringify(["steps", 0, "parallel", branch, -1])));
assert.deepEqual(graph.nodes.find((node) => node.type === "add" && node.data.branch === branch)?.data.insertAfter, ["steps", 0, "parallel", branch, 0]);
}
const inserted = insertStep(source, graph.nodes.find((node) => node.type === "add" && !node.data.branch)!.data.insertAfter!, "parallel");
assert.deepEqual(parse(inserted.source).steps.slice(0, 2), parse(source).steps);
const branches = Object.values(parse(inserted.source).steps[2].parallel);
assert.equal(branches.length, 2);
assert.ok(branches.every((steps) => Array.isArray(steps) && steps.length === 0));
}],
];
for (const [name, check] of cases) {
try { check(); } catch (error) { throw new Error(name, { cause: error }); }
}
});
test("existing invalid step ids become reference-safe without losing references", async () => {
const { normalizeStepIDs, earlierStepIDs } = await import("../src/workflows/workflow-edit.ts");
const { parseWorkflowYaml } = await import("../src/workflows/workflow-yaml.ts");
const original = `id: review
# Keep this comment.
steps:
- {id: write-a-prd, type: agent.run}
- id: Write a PRD
type: agent.run
- switch:
on: steps.Write a PRD.result.ready
cases:
default:
- {id: "123 title", type: agent.run}
- id: approve
type: workflow.approve
when: steps.Write a PRD.result.ready
settings:
message: "{{ steps.Write a PRD.summary }} and {{ steps.123 title.summary }}"
`;
assert.equal(parseWorkflowYaml(original).ok, false);
const normalized = normalizeStepIDs(original);
assert.match(normalized, /Keep this comment/);
const data = parse(normalized);
assert.equal(data.steps[0].id, "write-a-prd");
assert.equal(data.steps[1].id, "write-a-prd-2");
assert.equal(data.steps[2].switch.cases.default[0].id, "step-123-title");
assert.equal(data.steps[2].switch.on, "steps.write-a-prd-2.result.ready");
assert.equal(data.steps[3].when, "steps.write-a-prd-2.result.ready");
assert.equal(data.steps[3].settings.message, "{{ steps.write-a-prd-2.summary }} and {{ steps.step-123-title.summary }}");
assert.deepEqual(earlierStepIDs(normalized, ["steps", 3]), ["write-a-prd", "write-a-prd-2", "step-123-title"]);
assert.equal(parseWorkflowYaml(normalized).ok, true);
for (const [id, expected] of [
["UPPER", "upper"], ["under_score", "under-score"], ["123", "step-123"],
["trailing-", "trailing"], ["double--dash", "double-dash"],
["dotted.id", "dotted-id"], ["punct+(id)", "punct-id"], ["!!!", "step"],
]) {
const input = `id: test\nsteps:\n - {id: ${JSON.stringify(expected)}, type: agent.run}\n - {id: ${JSON.stringify(id)}, type: agent.run}\n - type: workflow.approve\n settings: {message: ${JSON.stringify(`{{ steps.${id}.summary }}`)}}\n`;
const output = parse(normalizeStepIDs(input));
assert.equal(output.steps[0].id, expected);
assert.equal(output.steps[1].id, `${expected}-2`, id);
assert.equal(output.steps[2].settings.message, `{{ steps.${id.includes(".") ? id : `${expected}-2`}.summary }}`, id);
assert.match(output.steps[1].id, /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/);
}
const ambiguous = `id: test
steps:
- {id: produce, type: agent.run}
- {id: produce.result, type: agent.run}
- type: workflow.approve
when: steps.produce.result.ready
settings: {message: "{{ steps.produce.result.ready }}"}
`;
const preserved = parse(normalizeStepIDs(ambiguous));
assert.equal(preserved.steps[1].id, "produce-result");
assert.equal(preserved.steps[2].when, "steps.produce.result.ready");
assert.equal(preserved.steps[2].settings.message, "{{ steps.produce.result.ready }}");
assert.equal(normalizeStepIDs(normalized), normalized);
assert.equal(normalizeStepIDs("steps: [broken"), "steps: [broken");
});