997901847b
* fix(#3280): read frontmatter current_phase in w011 and de-force w027 worktree advice * chore(#3280): add changeset * chore(#3280): reference pr 3452 in changeset --------- Co-authored-by: sim <sim@local>
532 lines
21 KiB
JavaScript
532 lines
21 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* Tests for `src/health-diagnostic-rules/state-consistency.cts` (Phase 11,
|
|
* #3309, ADR-3180 §8.2/§8.3/§8.5) — group "STATE.md consistency": W024,
|
|
* W002, W011, W021, W026.
|
|
*
|
|
* Design: .gsd/phase/refactor-3309-health-diagnostic-rule-table/40-design.md
|
|
*
|
|
* Fixture provenance (§8.5 + CONTRIBUTING "Fixture provenance (#2371)"):
|
|
* every fixture below is a MECHANICAL MUTATION of a realistic multi-phase
|
|
* ROADMAP/STATE/config.json shape (the shipped `templates/state.md` /
|
|
* `templates/roadmap.md` field layout, filled in with real values) with
|
|
* exactly ONE targeted field flipped per rule under test (an extra phase
|
|
* reference, a checkbox left `[x]` while status stays `In progress`, a
|
|
* `phase_id_convention` + a milestone-prefixed phase heading placed under
|
|
* the wrong version section, a `milestone complete` status left with an
|
|
* unstarted phase) — never a fixture invented purely to trip the rule with
|
|
* no other realistic content. Every case drives the REAL
|
|
* `buildPlanningSnapshot(cwd)` (`src/planning-snapshot.cts`) against a REAL
|
|
* temp `.planning/` tree — no hand-built in-memory `PlanningSnapshot` mock.
|
|
*
|
|
* W024 is a deliberate exception: its `check` is documented dead code (see
|
|
* `src/health-diagnostic-rules/state-consistency.cts`'s `RULE_W024`
|
|
* comment) — its tests assert the INERT `[] `contract directly rather than
|
|
* a trigger fixture, since no snapshot field can drive it to fire.
|
|
*/
|
|
|
|
const { test, describe } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
|
|
const { createTempDir, cleanup } = require('../helpers.cjs');
|
|
|
|
const stateConsistency = require('../../gsd-core/bin/lib/health-diagnostic-rules/state-consistency.cjs');
|
|
const { RULES } = stateConsistency;
|
|
|
|
const { buildPlanningSnapshot } = require('../../gsd-core/bin/lib/planning-snapshot.cjs');
|
|
const { SEVERITY, REMEDY_ACTION, REMEDY_RISK } = require('../../gsd-core/bin/lib/health-diagnostic.cjs');
|
|
|
|
function planningDirOf(cwd) {
|
|
return path.join(cwd, '.planning');
|
|
}
|
|
|
|
function writeState(cwd, content) {
|
|
fs.mkdirSync(planningDirOf(cwd), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDirOf(cwd), 'STATE.md'), content);
|
|
}
|
|
|
|
function writeRoadmap(cwd, content) {
|
|
fs.mkdirSync(planningDirOf(cwd), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDirOf(cwd), 'ROADMAP.md'), content);
|
|
}
|
|
|
|
function writeFile(cwd, relPath, content) {
|
|
const full = path.join(cwd, relPath);
|
|
fs.mkdirSync(path.dirname(full), { recursive: true });
|
|
fs.writeFileSync(full, content);
|
|
}
|
|
|
|
function writeConfig(cwd, obj) {
|
|
fs.mkdirSync(planningDirOf(cwd), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDirOf(cwd), 'config.json'), JSON.stringify(obj, null, 2));
|
|
}
|
|
|
|
function makePhaseDir(cwd, dirName) {
|
|
writeFile(cwd, `.planning/phases/${dirName}/01-01-PLAN.md`, '# Plan\n');
|
|
writeFile(cwd, `.planning/phases/${dirName}/01-01-SUMMARY.md`, '# Summary\n');
|
|
writeFile(cwd, `.planning/phases/${dirName}/01-VERIFICATION.md`, '---\nstatus: passed\n---\n');
|
|
}
|
|
|
|
function ruleFor(code) {
|
|
const rule = RULES.find((r) => r.code === code);
|
|
assert.ok(rule, `rule ${code} not found in RULES`);
|
|
return rule;
|
|
}
|
|
|
|
// ─── RULES shape ────────────────────────────────────────────────────────────
|
|
|
|
describe('RULES (state-consistency group)', () => {
|
|
test('exports exactly 5 rules: W024, W002, W011, W021, W026', () => {
|
|
assert.deepEqual(
|
|
RULES.map((r) => r.code).sort(),
|
|
['W002', 'W011', 'W021', 'W024', 'W026'],
|
|
);
|
|
});
|
|
|
|
test('every rule is severity WARNING', () => {
|
|
for (const code of ['W024', 'W002', 'W011', 'W021', 'W026']) {
|
|
assert.equal(ruleFor(code).severity, SEVERITY.WARNING);
|
|
}
|
|
});
|
|
});
|
|
|
|
// ─── W024 — STATE.md commit-age freshness (DELIBERATELY INERT) ─────────────
|
|
|
|
describe('W024 — deliberately inert (no snapshot field backs git-log freshness)', () => {
|
|
test('always returns [] on an empty snapshot', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w024-1-');
|
|
t.after(() => cleanup(cwd));
|
|
fs.mkdirSync(planningDirOf(cwd), { recursive: true });
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W024').check(snapshot), []);
|
|
});
|
|
|
|
test('always returns [] even with a state_head-carrying STATE.md and full roadmap/config', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w024-2-');
|
|
t.after(() => cleanup(cwd));
|
|
writeState(
|
|
cwd,
|
|
['---', 'state_head: deadbeefdeadbeefdeadbeefdeadbeefdeadbeef', 'status: In progress', '---', '', '## Current Position', '', 'Phase: 1 of 2', ''].join('\n'),
|
|
);
|
|
writeRoadmap(cwd, '## v1.0 Current 🚧\n\n### Phase 1: Foo\n\n### Phase 2: Bar\n');
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W024').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W002 — STATE.md references an undeclared phase token ──────────────────
|
|
|
|
describe('W002 — STATE.md references a phase not declared on disk or ROADMAP', () => {
|
|
test('fires when STATE.md mentions a phase not on disk and not in ROADMAP', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w002-1-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, '## v1.0 Current 🚧\n\n### Phase 1: Foo\n\n### Phase 2: Bar\n');
|
|
makePhaseDir(cwd, '01-foo');
|
|
makePhaseDir(cwd, '02-bar');
|
|
writeState(
|
|
cwd,
|
|
[
|
|
'---',
|
|
'status: In progress',
|
|
'---',
|
|
'',
|
|
'## Current Position',
|
|
'',
|
|
'Phase: 1 of 2',
|
|
'',
|
|
'### Decisions',
|
|
'',
|
|
'- Phase 9: referenced a phase that does not exist',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W002').check(snapshot);
|
|
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.equal(diagnostics[0].code, 'W002');
|
|
assert.equal(diagnostics[0].severity, SEVERITY.WARNING);
|
|
assert.match(diagnostics[0].message, /STATE\.md references phase 9, but only phases .* are declared/);
|
|
assert.deepEqual(diagnostics[0].remedy, {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: {
|
|
command:
|
|
'Review STATE.md manually before changing it; /gsd-health --repair will not overwrite an existing STATE.md for phase mismatches',
|
|
},
|
|
});
|
|
});
|
|
|
|
test('does not fire when every STATE.md phase reference is declared (disk or ROADMAP)', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w002-2-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, '## v1.0 Current 🚧\n\n### Phase 1: Foo\n\n### Phase 2: Bar\n');
|
|
makePhaseDir(cwd, '01-foo');
|
|
makePhaseDir(cwd, '02-bar');
|
|
writeState(
|
|
cwd,
|
|
[
|
|
'---',
|
|
'status: In progress',
|
|
'---',
|
|
'',
|
|
'## Current Position',
|
|
'',
|
|
'Phase: 1 of 2',
|
|
'',
|
|
'### Decisions',
|
|
'',
|
|
'- Phase 2: fine, this is declared',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W002').check(snapshot), []);
|
|
});
|
|
|
|
// Boundary: `validPhases.size === 0` guard — mirrors `verify.cts:1765`'s
|
|
// `if (normalizedValid.size > 0)` exactly, so a project with no declared
|
|
// phases at all never reports every STATE.md phase mention as invalid.
|
|
test('does not fire when the valid-phase set is empty (no ROADMAP, no disk phases)', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w002-3-');
|
|
t.after(() => cleanup(cwd));
|
|
writeState(
|
|
cwd,
|
|
['---', 'status: In progress', '---', '', '### Decisions', '', '- Phase 3: referenced with nothing declared anywhere', ''].join(
|
|
'\n',
|
|
),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W002').check(snapshot), []);
|
|
});
|
|
|
|
// `snapshot.archivedPhaseTokens` (#3652) now covers archived-milestone
|
|
// phase-dir tokens, so `buildValidPhaseSet` includes them — a STATE.md
|
|
// reference to a phase whose only home is an archived milestone is
|
|
// correctly treated as declared and does NOT fire.
|
|
test('does not fire on a phase reference whose only home is an archived milestone', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w002-4-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, '## v2.0 Current 🚧\n\n### Phase 3: Baz\n');
|
|
makePhaseDir(cwd, '03-baz');
|
|
writeFile(cwd, '.planning/milestones/v1.0-phases/01-archived-foo/01-VERIFICATION.md', '---\nstatus: passed\n---\n');
|
|
writeState(
|
|
cwd,
|
|
[
|
|
'---',
|
|
'status: In progress',
|
|
'---',
|
|
'',
|
|
'## Current Position',
|
|
'',
|
|
'Phase: 3 of 3',
|
|
'',
|
|
'### Decisions',
|
|
'',
|
|
'- Phase 1: this phase is archived, covered by snapshot.archivedPhaseTokens',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W002').check(snapshot);
|
|
assert.deepEqual(diagnostics, []);
|
|
});
|
|
});
|
|
|
|
// ─── W011 — STATE current-phase status vs. ROADMAP checkbox disagree ───────
|
|
|
|
describe('W011 — STATE current-phase status disagrees with ROADMAP [x] checkbox', () => {
|
|
test('fires when ROADMAP checkbox says the current phase is [x] complete but STATE status is not complete/done', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w011-1-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(
|
|
cwd,
|
|
['## v1.0 Current 🚧', '', '- [x] Phase 3: Auth', '- [ ] Phase 4: Billing', ''].join('\n'),
|
|
);
|
|
writeState(
|
|
cwd,
|
|
['---', 'status: In progress', '---', '', '## Current Position', '', 'Phase: 3 of 4 (Auth)', 'Status: In progress', ''].join(
|
|
'\n',
|
|
),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W011').check(snapshot);
|
|
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.deepEqual(diagnostics[0], {
|
|
code: 'W011',
|
|
severity: SEVERITY.WARNING,
|
|
message:
|
|
'STATE.md says current phase is 3 (status: in progress) but ROADMAP.md shows it as [x] complete — state files may be out of sync',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: { command: 'Run /gsd-progress to re-derive current position, or manually update STATE.md' },
|
|
},
|
|
});
|
|
});
|
|
|
|
test('does not fire when STATE status is already "complete"', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w011-2-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '- [x] Phase 3: Auth', ''].join('\n'));
|
|
writeState(
|
|
cwd,
|
|
['---', 'status: complete', '---', '', '## Current Position', '', 'Phase: 3 of 4 (Auth)', 'Status: complete', ''].join('\n'),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W011').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when the ROADMAP checkbox for the current phase is [ ] (not checked)', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w011-3-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '- [ ] Phase 3: Auth', ''].join('\n'));
|
|
writeState(
|
|
cwd,
|
|
['---', 'status: In progress', '---', '', '## Current Position', '', 'Phase: 3 of 4 (Auth)', 'Status: In progress', ''].join(
|
|
'\n',
|
|
),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W011').check(snapshot), []);
|
|
});
|
|
|
|
// ─── #3280 — the machine-readable frontmatter format gsd-tools itself
|
|
// writes (`state update` / `state begin-phase` persist `current_phase` +
|
|
// `status` via syncStateFrontmatter). W011's phase extraction previously
|
|
// never consulted frontmatter, so the exact staleness class it exists to
|
|
// catch went undetected on the PRIMARY written format. Fixtures added
|
|
// alongside the legacy-prose cases above (not by retrofitting them), so the
|
|
// legacy path real user repos still carry keeps its coverage.
|
|
|
|
test('#3280 AC1: fires when the current phase is recorded in frontmatter (the format gsd-tools writes), even when a body Phase field would shadow it', (t) => {
|
|
const cwd = createTempDir('gsd-3280-w011-fm-1-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '- [x] Phase 2: Auth', '- [ ] Phase 3: Billing', ''].join('\n'));
|
|
// The shape `state.cts`'s syncStateFrontmatter persists: frontmatter owns
|
|
// current_phase/status; the body's `Phase:` line is a stale remnant the
|
|
// frontmatter must override (resolveStatePhase's own ladder order).
|
|
writeState(
|
|
cwd,
|
|
[
|
|
'---',
|
|
'gsd_state_version: \'1.0\'',
|
|
'milestone: v1.0',
|
|
'current_phase: 2',
|
|
'status: executing',
|
|
'---',
|
|
'',
|
|
'## Current Position',
|
|
'',
|
|
'Phase: 5 of 5 (Legacy remnant)',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.equal(snapshot.currentPhaseLabel.value, '2', 'frontmatter current_phase must win over the body Phase field');
|
|
const diagnostics = ruleFor('W011').check(snapshot);
|
|
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.equal(diagnostics[0].code, 'W011');
|
|
assert.equal(diagnostics[0].severity, SEVERITY.WARNING);
|
|
assert.match(diagnostics[0].message, /STATE\.md says current phase is 2 \(status: executing\) but ROADMAP\.md shows it as \[x\] complete/);
|
|
});
|
|
|
|
test('#3280 AC1: fires when frontmatter carries current_phase and the body has no Phase field at all', (t) => {
|
|
const cwd = createTempDir('gsd-3280-w011-fm-2-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '- [x] Phase 2: Auth', ''].join('\n'));
|
|
writeState(
|
|
cwd,
|
|
['---', 'current_phase: 2', 'status: planning', '---', '', '## Session', '', 'Last activity: 2026-08-01', ''].join('\n'),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.equal(snapshot.currentPhaseLabel.value, '2');
|
|
const diagnostics = ruleFor('W011').check(snapshot);
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.equal(diagnostics[0].code, 'W011');
|
|
});
|
|
|
|
test('#3280 AC3: does not fire when frontmatter status reports completion in the state writer\'s own vocabulary (status: completed)', (t) => {
|
|
const cwd = createTempDir('gsd-3280-w011-fm-3-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '- [x] Phase 2: Auth', ''].join('\n'));
|
|
// `normalizeStateStatus` — the vocabulary `syncStateFrontmatter` persists —
|
|
// emits `completed` (not `complete`/`done`), so an exact-token comparison
|
|
// here would turn every legitimately completed frontmatter STATE.md into a
|
|
// false positive the moment the phase read is fixed.
|
|
writeState(
|
|
cwd,
|
|
['---', 'current_phase: 2', 'status: completed', '---', '', '## Current Position', '', 'Phase: 5 of 5', ''].join('\n'),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.equal(snapshot.currentPhaseLabel.value, '2');
|
|
assert.deepEqual(ruleFor('W011').check(snapshot), []);
|
|
});
|
|
|
|
test('#3280 AC3: does not fire when frontmatter status is "done" either', (t) => {
|
|
const cwd = createTempDir('gsd-3280-w011-fm-4-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '- [x] Phase 2: Auth', ''].join('\n'));
|
|
writeState(cwd, ['---', 'current_phase: 2', 'status: done', '---', ''].join('\n'));
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W011').check(snapshot), []);
|
|
});
|
|
|
|
test('#3280 AC2 (locked): fires when the current phase is recorded in a pipe table under ## Current Position', (t) => {
|
|
const cwd = createTempDir('gsd-3280-w011-pipe-1-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '- [x] Phase 2: Auth', ''].join('\n'));
|
|
writeState(
|
|
cwd,
|
|
[
|
|
'---',
|
|
'status: discussing',
|
|
'---',
|
|
'',
|
|
'## Current Position',
|
|
'',
|
|
'| Phase | 2 of 5 |',
|
|
'| --- | --- |',
|
|
'| Status | discussing |',
|
|
'',
|
|
].join('\n'),
|
|
);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.equal(snapshot.currentPhaseLabel.value, '2 of 5');
|
|
const diagnostics = ruleFor('W011').check(snapshot);
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.equal(diagnostics[0].code, 'W011');
|
|
});
|
|
});
|
|
|
|
// ─── W021 — phase_id_convention integer-prefix/milestone mismatch ──────────
|
|
|
|
describe('W021 — milestone-prefixed phase integer-prefix implies a different milestone', () => {
|
|
test('fires when a milestone-prefixed phase heading is listed under the wrong version section', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w021-1-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, { phase_id_convention: 'milestone-prefixed' });
|
|
writeRoadmap(cwd, ['## v2.0 Current 🚧', '', '### Phase 1-1: Misplaced', ''].join('\n'));
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W021').check(snapshot);
|
|
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.deepEqual(diagnostics[0], {
|
|
code: 'W021',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'Phase 1-1: integer prefix implies v1.0 but listed under v2.0',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: { command: 'gsd-tools roadmap upgrade --convention milestone-prefixed' },
|
|
},
|
|
});
|
|
});
|
|
|
|
test('does not fire when the milestone-prefixed phase is listed under its implied version', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w021-2-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, { phase_id_convention: 'milestone-prefixed' });
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '### Phase 1-1: Correctly Placed', ''].join('\n'));
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W021').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when phase_id_convention is not "milestone-prefixed"', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w021-3-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, { phase_id_convention: 'flat' });
|
|
writeRoadmap(cwd, ['## v2.0 Current 🚧', '', '### Phase 1-1: Misplaced', ''].join('\n'));
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W021').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W026 — STATE says milestone complete but ROADMAP lists unstarted phase ─
|
|
|
|
describe('W026 — STATE milestone-complete/archived but ROADMAP lists a phase with no disk directory', () => {
|
|
test('fires when STATE says "milestone complete" and the current milestone still lists an unstarted phase', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w026-1-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '### Phase 1: Foo', '', '### Phase 2: Bar', ''].join('\n'));
|
|
makePhaseDir(cwd, '01-foo');
|
|
// Phase 2 deliberately has NO disk directory.
|
|
writeState(cwd, ['---', 'status: milestone complete', 'milestone: v1.0', '---', ''].join('\n'));
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W026').check(snapshot);
|
|
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.deepEqual(diagnostics[0], {
|
|
code: 'W026',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'STATE says milestone complete but ROADMAP lists 1 unstarted phase(s) (e.g. Phase 2)',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: {
|
|
command: 'Run validate consistency or re-run complete-milestone after verifying all phases are done',
|
|
},
|
|
},
|
|
});
|
|
});
|
|
|
|
test('does not fire when every phase in the current milestone has a disk directory', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w026-2-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '### Phase 1: Foo', '', '### Phase 2: Bar', ''].join('\n'));
|
|
makePhaseDir(cwd, '01-foo');
|
|
makePhaseDir(cwd, '02-bar');
|
|
writeState(cwd, ['---', 'status: milestone complete', 'milestone: v1.0', '---', ''].join('\n'));
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W026').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when STATE status is not "milestone complete"/"archived"', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w026-3-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '### Phase 1: Foo', '', '### Phase 2: Bar', ''].join('\n'));
|
|
makePhaseDir(cwd, '01-foo');
|
|
writeState(cwd, ['---', 'status: In progress', 'milestone: v1.0', '---', ''].join('\n'));
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W026').check(snapshot), []);
|
|
});
|
|
|
|
test('fires when STATE status is "archived" (the other trigger token)', (t) => {
|
|
const cwd = createTempDir('gsd-3309-w026-4-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRoadmap(cwd, ['## v1.0 Current 🚧', '', '### Phase 1: Foo', '', '### Phase 2: Bar', ''].join('\n'));
|
|
makePhaseDir(cwd, '01-foo');
|
|
writeState(cwd, ['---', 'status: archived', 'milestone: v1.0', '---', ''].join('\n'));
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W026').check(snapshot);
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.equal(diagnostics[0].code, 'W026');
|
|
});
|
|
});
|