205 lines
11 KiB
JavaScript
205 lines
11 KiB
JavaScript
// tests/lib/fix-round-4-5b2-a-prose.test.mjs
|
|
// Prose pins for fix round 4.5b2, part A (plan
|
|
// .claude/projects/2026-10-31-guard-4-5b2-part-a, decisions 91, 107, 122 and
|
|
// 123): the fixes that are text a session reads. The tag in brackets is the
|
|
// part-A id from the round's plan; each tagged test fails on an assertion at
|
|
// e2d6bec, part 4's end point. The keep-behaviour checks sit inside the tagged
|
|
// test as "Control:" assertions.
|
|
// KIA the CHANGELOG lists part A's fixes (RXT, CNT, SFX, ESR, EVL, SIS, HDR)
|
|
// under ### Fixed, brings part 4's CSG, SLT and ESC bullets in line,
|
|
// lists the two MAJOR findings decision 122 keeps, the four MINOR and
|
|
// what part A leaves open under ### Known issues, and its door under
|
|
// ### Doors.
|
|
// HDR tests/hooks/bash-guard-false-stops.test.mjs names its red base
|
|
// 591f3c4. In the red clone this test passes at e2d6bec, because the
|
|
// working tree's tests/ is copied in; its red is shown under a named
|
|
// mutation that writes the old header back.
|
|
// No static import of a new export: the file must load at e2d6bec.
|
|
// Fix the SOURCE a pin guards, not the pin.
|
|
|
|
import { test } from 'node:test';
|
|
import { strict as assert } from 'node:assert';
|
|
import { existsSync, readFileSync } from 'node:fs';
|
|
import { dirname, join } from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
|
|
const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
|
|
|
|
const readCache = new Map();
|
|
|
|
/** A repo file's text; the file must exist. Read from disk once per run. */
|
|
function read(rel) {
|
|
if (!readCache.has(rel)) {
|
|
assert.ok(existsSync(join(ROOT, rel)), `missing file ${rel}`);
|
|
readCache.set(rel, readFileSync(join(ROOT, rel), 'utf8'));
|
|
}
|
|
return readCache.get(rel);
|
|
}
|
|
|
|
/** Whitespace (line breaks too) collapsed to one space. */
|
|
const flat = (s) => s.replace(/\s+/g, ' ').trim();
|
|
|
|
// --- KIA: the round's CHANGELOG entry ----------------------------------------------
|
|
// Part A stands in the same Unreleased section as parts 1 to 4. The section is
|
|
// found by its title, by the rule tests/lib/fix-round-4-5b-part-4-prose.test.mjs
|
|
// uses (copied, not imported): `## Unreleased — <title>` before the release,
|
|
// `## vX.Y.Z — <date> — <title>` after it, exactly once, up to the next `## `.
|
|
|
|
const CHANGELOG_TITLE = "The annotating skill, the run coupling and P10's model-free part";
|
|
const CHANGELOG_HEADING = new RegExp(`^## (?:Unreleased|v\\d+\\.\\d+\\.\\d+ — \\d{4}-\\d{2}-\\d{2}) — ${CHANGELOG_TITLE.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`);
|
|
|
|
/** The lines of the round's CHANGELOG section, heading excluded. */
|
|
function changelogSection() {
|
|
const lines = read('CHANGELOG.md').split('\n');
|
|
const at = [];
|
|
lines.forEach((l, i) => { if (CHANGELOG_HEADING.test(l.replace(/\s+$/, ''))) at.push(i); });
|
|
assert.equal(at.length, 1, `CHANGELOG.md must hold the "${CHANGELOG_TITLE}" section exactly once (found ${at.length})`);
|
|
let end = lines.length;
|
|
for (let i = at[0] + 1; i < lines.length; i++) if (/^## /.test(lines[i])) { end = i; break; }
|
|
return lines.slice(at[0] + 1, end);
|
|
}
|
|
|
|
/** The bullets of one `### ` subsection of the round's CHANGELOG section, each flattened to one line. */
|
|
function changelogBullets(heading) {
|
|
const lines = changelogSection();
|
|
const s = lines.findIndex((l) => l.replace(/\s+$/, '') === heading);
|
|
assert.ok(s !== -1, `the "${CHANGELOG_TITLE}" section of CHANGELOG.md must have "${heading}"`);
|
|
const out = [];
|
|
for (const l of lines.slice(s + 1)) {
|
|
if (/^### /.test(l)) break;
|
|
if (/^- /.test(l)) out.push(l);
|
|
else if (out.length && l.trim() !== '' && /^\s/.test(l)) out[out.length - 1] += ` ${l}`;
|
|
else if (l.trim() !== '') out.push('');
|
|
}
|
|
return out.filter((b) => b !== '').map(flat);
|
|
}
|
|
|
|
// Part A's seven Fixed bullets, each with the ref it must name: the four review
|
|
// findings of part 4's review it fixes, the two operator decisions and the
|
|
// false test header. The ids are the review's, written out here.
|
|
const FIXED = [
|
|
['(RXT)', '5f1cc34c'], ['(CNT)', '97d1f547'], ['(SFX)', '27b0b46a'], ['(ESR)', 'ed40abdb'],
|
|
['(EVL)', 'decision 107'], ['(SIS)', 'decision 123'], ['(HDR)', '86488cd6'],
|
|
];
|
|
const FIXED_IDS = ['5f1cc34c', '97d1f547', '27b0b46a', 'ed40abdb'];
|
|
const NEW_TAGS = FIXED.map(([tag]) => tag);
|
|
// The two MAJOR findings decision 122 keeps open.
|
|
const KEPT_IDS = ['943f9841', 'a6735ef9'];
|
|
// The review's four MINOR findings, listed as open under decision 91.
|
|
const MINOR_IDS = ['03df3b0b', '78040bd7', '49873813', '79402171'];
|
|
|
|
const DELIM = 'VOYAGE_ARGS_EOF_7F3C9E';
|
|
const TWO_ESCAPED = 'two escaped `<` in a row';
|
|
|
|
test('[KIA] the CHANGELOG lists part A\'s seven fixes under ### Fixed, each with its ref', () => {
|
|
const fixed = changelogBullets('### Fixed');
|
|
|
|
// Red: one ### Fixed bullet per part-A tag, each naming its ref.
|
|
for (const [tag, ref] of FIXED) {
|
|
const hits = fixed.filter((b) => b.includes(tag) && b.includes(ref));
|
|
assert.equal(hits.length, 1, `### Fixed must hold exactly one bullet marked ${tag} naming ${ref}; found ${hits.length}`);
|
|
}
|
|
|
|
// Control: no fixed finding is listed as open.
|
|
const known = changelogBullets('### Known issues');
|
|
for (const id of FIXED_IDS) {
|
|
assert.deepEqual(known.filter((b) => b.includes(id)), [], `Control: the fixed finding ${id} must not stand under ### Known issues`);
|
|
}
|
|
});
|
|
|
|
test('[KIA] the two MAJOR findings decision 122 keeps stand under ### Known issues, one bullet each', () => {
|
|
const known = changelogBullets('### Known issues');
|
|
|
|
// Red: each kept finding has exactly one Known-issues bullet, and that bullet names decision 122.
|
|
const bullets = [];
|
|
for (const id of KEPT_IDS) {
|
|
const hits = known.filter((b) => b.includes(id));
|
|
assert.equal(hits.length, 1, `### Known issues must hold exactly one bullet naming ${id}; found ${hits.length}`);
|
|
assert.ok(hits[0].includes('decision 122'), `the Known-issues bullet naming ${id} does not say decision 122: ${hits[0]}`);
|
|
bullets.push(hits[0]);
|
|
}
|
|
assert.notEqual(bullets[0], bullets[1], `${KEPT_IDS[0]} and ${KEPT_IDS[1]} must stand in two different Known-issues bullets`);
|
|
|
|
// Control: neither kept finding stands in a Fixed bullet marked with one of part A's tags.
|
|
const fixed = changelogBullets('### Fixed');
|
|
for (const id of KEPT_IDS) {
|
|
const hits = fixed.filter((b) => b.includes(id) && NEW_TAGS.some((tag) => b.includes(tag)));
|
|
assert.deepEqual(hits, [], `Control: ${id} must not stand in a ### Fixed bullet marked with one of ${NEW_TAGS.join(' ')}`);
|
|
}
|
|
});
|
|
|
|
test('[KIA] part 4\'s SLT bullet no longer promises a pass the guard refuses, and names the SIS exception', () => {
|
|
const slt = changelogBullets('### Fixed').filter((b) => b.includes('(SLT)'));
|
|
assert.equal(slt.length, 1, `### Fixed must hold exactly one bullet marked (SLT); found ${slt.length}`);
|
|
|
|
// Red: the old promise is gone.
|
|
assert.ok(!slt[0].includes('pass again'), `the (SLT) bullet must not hold "pass again": ${slt[0]}`);
|
|
|
|
// It names the gaps of part 4's review, what is refused as before, and the SIS exception.
|
|
for (const part of [...KEPT_IDS, 'refused as before', 'unless a backslash-newline splits']) {
|
|
assert.ok(slt[0].includes(part), `the (SLT) bullet must hold ${JSON.stringify(part)}: ${slt[0]}`);
|
|
}
|
|
assert.ok(!slt[0].includes('is text and passes, so'), `the (SLT) bullet must not hold "is text and passes, so": ${slt[0]}`);
|
|
});
|
|
|
|
test('[KIA] part 4\'s CSG and ESC bullets name the gaps part A fixes, ESC with the EVL exception', () => {
|
|
const fixed = changelogBullets('### Fixed');
|
|
|
|
// Red: the CSG bullet names the split-delimiter gap.
|
|
const csg = fixed.filter((b) => b.includes('(CSG)'));
|
|
assert.equal(csg.length, 1, `### Fixed must hold exactly one bullet marked (CSG); found ${csg.length}`);
|
|
assert.ok(csg[0].includes('27b0b46a'), `the (CSG) bullet must name review finding 27b0b46a: ${csg[0]}`);
|
|
|
|
// The ESC bullet names the whole-command limits gap and the EVL exception.
|
|
const esc = fixed.filter((b) => b.includes('(ESC)'));
|
|
assert.equal(esc.length, 1, `### Fixed must hold exactly one bullet marked (ESC); found ${esc.length}`);
|
|
for (const part of ['ed40abdb', 'still open before the run', TWO_ESCAPED]) {
|
|
assert.ok(esc[0].includes(part), `the (ESC) bullet must hold ${JSON.stringify(part)}: ${esc[0]}`);
|
|
}
|
|
for (const gone of ['no quote or heredoc operator before it', 'stands before the run']) {
|
|
assert.ok(!esc[0].includes(gone), `the (ESC) bullet must not hold ${JSON.stringify(gone)}: ${esc[0]}`);
|
|
}
|
|
});
|
|
|
|
test('[KIA] ### Known issues lists the four MINOR, decisions 107, 123 and 124, and part 2\'s bullet with its exceptions', () => {
|
|
const known = changelogBullets('### Known issues');
|
|
|
|
// Red: each MINOR finding has exactly one Known-issues bullet, and that bullet names decision 91.
|
|
for (const id of MINOR_IDS) {
|
|
const hits = known.filter((b) => b.includes(id));
|
|
assert.equal(hits.length, 1, `### Known issues must hold exactly one bullet naming ${id}; found ${hits.length}`);
|
|
assert.ok(hits[0].includes('decision 91'), `the Known-issues bullet naming ${id} does not say decision 91: ${hits[0]}`);
|
|
}
|
|
|
|
// What part A leaves open: one bullet per decision.
|
|
const d107 = known.filter((b) => b.includes('decision 107'));
|
|
assert.equal(d107.length, 1, `### Known issues must hold exactly one bullet naming decision 107; found ${d107.length}`);
|
|
const d124 = known.filter((b) => b.includes('decision 124'));
|
|
assert.equal(d124.length, 1, `### Known issues must hold exactly one bullet naming decision 124; found ${d124.length}`);
|
|
for (const part of ['setopt', 'emulate', 'set -o', 'shopt', 'alias']) {
|
|
assert.ok(d124[0].includes(part), `the decision 124 Known-issues bullet must hold ${JSON.stringify(part)}: ${d124[0]}`);
|
|
}
|
|
const d123 = known.filter((b) => b.includes('decision 123'));
|
|
assert.equal(d123.length, 1, `### Known issues must hold exactly one bullet naming decision 123; found ${d123.length}`);
|
|
|
|
// Part 2's bullet keeps its pair and names the exceptions part A widens.
|
|
const followed = known.filter((b) => b.includes(DELIM) && b.includes('stays blocked'));
|
|
assert.equal(followed.length, 1, `### Known issues must hold one bullet holding ${DELIM} and "stays blocked"; found ${followed.length}`);
|
|
for (const part of ['fix round 4.5b2 part A', TWO_ESCAPED]) {
|
|
assert.ok(followed[0].includes(part), `part 2's Known-issues bullet must hold ${JSON.stringify(part)}: ${followed[0]}`);
|
|
}
|
|
});
|
|
|
|
test('[KIA] ### Doors holds one line for decision 91', () => {
|
|
const doors = changelogBullets('### Doors').filter((b) => b.includes('decision 91'));
|
|
assert.equal(doors.length, 1, `### Doors must hold exactly one bullet naming decision 91; found ${doors.length}`);
|
|
});
|
|
|
|
// --- HDR: the false-stops test header -----------------------------------------------
|
|
|
|
test('[HDR] tests/hooks/bash-guard-false-stops.test.mjs names its red base 591f3c4', () => {
|
|
const text = read('tests/hooks/bash-guard-false-stops.test.mjs');
|
|
assert.ok(!text.includes('loads at 12bca8b'), 'tests/hooks/bash-guard-false-stops.test.mjs must not hold "loads at 12bca8b"');
|
|
const hits = text.split('loads at 591f3c4').length - 1;
|
|
assert.equal(hits, 1, `tests/hooks/bash-guard-false-stops.test.mjs must hold "loads at 591f3c4" exactly once; found ${hits}`);
|
|
});
|