Files
archie/ui/test/workflow-yaml.test.ts

142 lines
4.2 KiB
TypeScript

import assert from "node:assert/strict";
import test from "node:test";
const { parseWorkflowYaml, yamlLines } =
await import("../src/workflows/workflow-yaml.ts");
/** A definition in the shape the server writes: id, then typed steps. */
const DEFINITION = `id: bootstrap
steps:
- type: bootstrap.prepare
- type: bootstrap.apply
settings:
mode: fast
`;
test("a definition parses into its id and its steps, in order", () => {
const parsed = parseWorkflowYaml(DEFINITION);
assert.equal(parsed.ok, true);
if (!parsed.ok) return;
assert.equal(parsed.id, "bootstrap");
assert.deepEqual(
parsed.steps.map((step) => [step.index, step.type]),
[
[1, "bootstrap.prepare"],
[2, "bootstrap.apply"],
],
);
});
test("the preview reads the YAML as typed, not a regex over it", () => {
const parsed = parseWorkflowYaml(`id: x
steps:
- type: a
settings:
nested:
- type: not-a-step
- type: b
`);
assert.equal(parsed.ok, true);
if (!parsed.ok) return;
assert.deepEqual(
parsed.steps.map((step) => step.type),
["a", "b"],
);
});
test("invalid workflow structures identify the field that prevents saving", () => {
for (const [source, message] of [
["steps:\n - type: a\n", /id/],
["id: x\n", /steps/],
["id: x\nsteps:\n - type: a\n - settings: {}\n", /type/],
["- a\n- b\n", /mapping/],
['"just a string"\n', /mapping/],
["id: x\nsteps: 3\n", /steps/],
["id: x\nsteps:\n - type: a\n when: what\n", /when/],
["id: x\nsteps:\n - type: a\n retry: {attempts: 2, backoff: yes}\n", /backoff/],
["id: x\nsteps:\n - type: a\n retry: {attempts: 2, backoff: -1s}\n", /backoff/],
] as const) {
const parsed = parseWorkflowYaml(source);
assert.equal(parsed.ok, false, source);
if (!parsed.ok) assert.match(parsed.message, message, source);
}
});
test("a YAML syntax error is reported with the line it is on", () => {
const parsed = parseWorkflowYaml("id: x\nsteps: [unclosed\n");
assert.equal(parsed.ok, false);
if (parsed.ok) return;
assert.ok(parsed.message.length > 0, "an error with no words says nothing");
assert.ok(
typeof parsed.line === "number" && parsed.line >= 1,
"an error that cannot be pointed at cannot be fixed",
);
});
test("every character of the source survives highlighting", () => {
const sources = [
DEFINITION,
"id: x\n\n# a comment\nsteps:\n - type: a\n",
"id: x\nsteps: []\n",
"",
"no trailing newline",
];
for (const source of sources) {
const lines = yamlLines(source);
assert.equal(
lines.map((line) => line.text).join("\n"),
source,
"highlighting rewrote the text it was given",
);
for (const line of lines) {
assert.equal(
line.tokens.map((token) => token.text).join(""),
line.text,
"a line's tokens do not add back up to the line",
);
}
}
});
test("lines are numbered from one, and an empty editor still has a first line", () => {
assert.deepEqual(
yamlLines("a\nb").map((line) => line.number),
[1, 2],
);
assert.deepEqual(
yamlLines("").map((line) => [line.number, line.text]),
[[1, ""]],
);
});
test("keys and comments take their own colour, and a # inside a value does not", () => {
const [keyLine, commentLine, valueLine] = yamlLines(
'id: bootstrap\n# a note\nmessage: "a # b"\n',
);
assert.equal(keyLine.tokens[0]?.kind, "key");
assert.equal(keyLine.tokens[0]?.text, "id");
assert.deepEqual(
commentLine.tokens.filter((token) => token.kind === "comment").map((t) => t.text),
["# a note"],
);
assert.equal(
valueLine.tokens.some((token) => token.kind === "comment"),
false,
"a # inside a quoted value was read as a comment",
);
assert.equal(
valueLine.tokens.some((token) => token.kind === "string"),
true,
"a quoted value was not coloured",
);
});
test("a list marker and a key are not the same thing", () => {
const [line] = yamlLines(" - type: a\n");
assert.equal(line.tokens[0]?.text, " ");
assert.equal(line.tokens[1]?.text, "- ");
assert.equal(line.tokens[1]?.kind, "punct");
assert.equal(line.tokens[2]?.text, "type");
assert.equal(line.tokens[2]?.kind, "key");
});