a9a7a328e6
Mechanical rename produced by scripts/msd-rename.cjs: gsd/Gsd/GSD -> msd/Msd/MSD across contents and paths, upstream package/repo coordinates -> @golem15/msd-core and golem15com/msd-core. Deep links into upstream history, sibling upstream packages, the GSD-2 import feature, CHANGELOG.md and .changeset/ are kept as-is. Hand edits on top: MSD block-letter banner and logos, LICENSE copyright line, package/plugin identity, regenerated lockfile, install-tree fixtures, derived registries and benchmark baseline; migration checksum baseline re-locked (MSD keeps its own install state, so no install had applied the old sums); sort-order and regex-escaped expectations in tests adjusted.
860 lines
32 KiB
JavaScript
860 lines
32 KiB
JavaScript
'use strict';
|
|
|
|
/**
|
|
* Tests for `src/health-diagnostic-rules/config-validation.cts` (Phase 11,
|
|
* #3309, ADR-3180 §8.2/§8.3/§8.5) — group "config.json validation": W003,
|
|
* E005, W004, W008, W016, W012, W013, W014, W015, W022.
|
|
*
|
|
* Design: .msd/phase/refactor-3309-health-diagnostic-rule-table/40-design.md
|
|
* Test matrix: .msd/phase/refactor-3309-health-diagnostic-rule-table/50-test-matrix.md
|
|
*
|
|
* Fixture provenance (§8.5 + CONTRIBUTING "Fixture provenance (#2371)"):
|
|
*
|
|
* - W003, W008, W016 are STRUCTURAL ABSENCE (a file, or a key, is missing) —
|
|
* exempt from external-citation provenance, mirrors
|
|
* tests/health-diagnostic-rules/root-existence.test.cjs's own framing.
|
|
* - E005, W004, W012, W013, W014, W015, W022 are MECHANICAL MUTATION: each
|
|
* fixture starts from `msd-core/templates/config.json` (the real shipped
|
|
* shape, parsed once as `BASE_CONFIG`) with exactly ONE field changed to
|
|
* the invalid value under test, per the design doc's Fixture provenance
|
|
* §4. `w022`'s `models` key and `branching_strategy`/`context_window`/
|
|
* `phase_branch_template`/`milestone_branch_template` are not present in
|
|
* the shipped default at all (they are optional, additive keys) — for
|
|
* those the "one field changed" mutation is adding exactly that one key
|
|
* with its invalid value, the generic-mutation equivalent when there is no
|
|
* existing value to corrupt.
|
|
*
|
|
* Every fixture is driven through the REAL `buildPlanningSnapshot(cwd)`
|
|
* against a REAL temp `.planning/` directory with a REAL config.json file
|
|
* written to disk — mirrors tests/planning-snapshot.test.cjs's own
|
|
* `writeConfig` helper exactly (same shape, same call site convention).
|
|
*
|
|
* TDD RED: `src/health-diagnostic-rules/config-validation.cts` does not
|
|
* exist yet at the start of this batch — this file's
|
|
* `require('../../msd-core/bin/lib/health-diagnostic-rules/config-validation.cjs')`
|
|
* throws MODULE_NOT_FOUND until this batch's implementation lands.
|
|
*/
|
|
|
|
const { test, describe } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const childProcess = require('node:child_process');
|
|
|
|
const { createTempDir, createTempGitProject, cleanup } = require('../helpers.cjs');
|
|
const { gitOrThrow } = require('../helpers/git-fixture.cjs');
|
|
|
|
const configValidation = require('../../msd-core/bin/lib/health-diagnostic-rules/config-validation.cjs');
|
|
const { RULES } = configValidation;
|
|
|
|
const { buildPlanningSnapshot } = require('../../msd-core/bin/lib/planning-snapshot.cjs');
|
|
const { SEVERITY, REMEDY_ACTION, REMEDY_RISK, applyRepairs } = require('../../msd-core/bin/lib/health-diagnostic.cjs');
|
|
const { SCOPE } = require('../../msd-core/bin/lib/planning-scope.cjs');
|
|
|
|
// Real shipped default, parsed once — the mutation base for every
|
|
// MECHANICAL MUTATION fixture below (design doc Fixture provenance §4).
|
|
const TEMPLATE_CONFIG_PATH = path.join(__dirname, '..', '..', 'msd-core', 'templates', 'config.json');
|
|
const BASE_CONFIG = JSON.parse(fs.readFileSync(TEMPLATE_CONFIG_PATH, 'utf-8'));
|
|
|
|
function planningDirOf(cwd) {
|
|
return path.join(cwd, '.planning');
|
|
}
|
|
|
|
function writeConfig(cwd, obj) {
|
|
fs.mkdirSync(planningDirOf(cwd), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDirOf(cwd), 'config.json'), JSON.stringify(obj));
|
|
}
|
|
|
|
function writeRawConfig(cwd, rawText) {
|
|
fs.mkdirSync(planningDirOf(cwd), { recursive: true });
|
|
fs.writeFileSync(path.join(planningDirOf(cwd), 'config.json'), rawText);
|
|
}
|
|
|
|
// Deep-clones BASE_CONFIG and applies exactly one mutation, mirroring the
|
|
// design doc's "mechanical, rule-blind mutation of the real shipped
|
|
// template" fixture class.
|
|
function mutatedConfig(mutate) {
|
|
const clone = JSON.parse(JSON.stringify(BASE_CONFIG));
|
|
mutate(clone);
|
|
return clone;
|
|
}
|
|
|
|
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 (config-validation group)', () => {
|
|
test('exports exactly 11 rules: W003, E005, W004, W008, W016, W012, W013, W014, W015, W022, W029', () => {
|
|
assert.deepEqual(
|
|
RULES.map((r) => r.code).sort(),
|
|
['E005', 'W003', 'W004', 'W008', 'W012', 'W013', 'W014', 'W015', 'W016', 'W022', 'W029'].sort(),
|
|
);
|
|
});
|
|
|
|
test('E005 is severity ERROR; the rest are severity WARNING', () => {
|
|
assert.equal(ruleFor('E005').severity, SEVERITY.ERROR);
|
|
for (const code of ['W003', 'W004', 'W008', 'W012', 'W013', 'W014', 'W015', 'W016', 'W022', 'W029']) {
|
|
assert.equal(ruleFor(code).severity, SEVERITY.WARNING, `${code} should be WARNING`);
|
|
}
|
|
});
|
|
});
|
|
|
|
// ─── W003 — config.json not found ───────────────────────────────────────────
|
|
|
|
describe('W003 — config.json not found', () => {
|
|
test('fires when config.json is absent (structural absence)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w003-1-');
|
|
t.after(() => cleanup(cwd));
|
|
fs.mkdirSync(planningDirOf(cwd), { recursive: true });
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W003').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W003',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'config.json not found',
|
|
remedy: { action: REMEDY_ACTION.CREATE_CONFIG, risk: REMEDY_RISK.NONE, args: {} },
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('does not fire when config.json exists', (t) => {
|
|
const cwd = createTempDir('msd-3309-w003-2-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, BASE_CONFIG);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W003').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── E005 — config.json JSON parse error ────────────────────────────────────
|
|
|
|
describe('E005 — config.json invalid JSON', () => {
|
|
test('fires when config.json exists but is unparseable', (t) => {
|
|
const cwd = createTempDir('msd-3309-e005-1-');
|
|
t.after(() => cleanup(cwd));
|
|
writeRawConfig(cwd, '{ not valid json');
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('E005').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'E005',
|
|
severity: SEVERITY.ERROR,
|
|
message: 'config.json: JSON parse error',
|
|
remedy: { action: REMEDY_ACTION.RESET_CONFIG, risk: REMEDY_RISK.DESTRUCTIVE, args: {} },
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('does not fire when config.json is absent (that is W003s job)', (t) => {
|
|
const cwd = createTempDir('msd-3309-e005-2-');
|
|
t.after(() => cleanup(cwd));
|
|
fs.mkdirSync(planningDirOf(cwd), { recursive: true });
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('E005').check(snapshot), []);
|
|
assert.equal(ruleFor('W003').check(snapshot).length, 1);
|
|
});
|
|
|
|
test('does not fire when config.json is well-formed', (t) => {
|
|
const cwd = createTempDir('msd-3309-e005-3-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, BASE_CONFIG);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('E005').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W004 — invalid model_profile ───────────────────────────────────────────
|
|
|
|
describe('W004 — invalid model_profile', () => {
|
|
test('fires on an invalid model_profile value (mutated shipped config)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w004-1-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.model_profile = 'not-a-real-profile';
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W004').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W004',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'config.json: invalid model_profile "not-a-real-profile"',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: { command: 'Valid values: quality, balanced, budget, adaptive, inherit' },
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('does not fire on a valid model_profile', (t) => {
|
|
const cwd = createTempDir('msd-3309-w004-2-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.model_profile = 'balanced';
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W004').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when model_profile is absent', (t) => {
|
|
const cwd = createTempDir('msd-3309-w004-3-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, BASE_CONFIG);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W004').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W008 — workflow.nyquist_validation absent ──────────────────────────────
|
|
|
|
describe('W008 — workflow.nyquist_validation absent', () => {
|
|
test('fires when workflow is present but nyquist_validation key is deleted', (t) => {
|
|
const cwd = createTempDir('msd-3309-w008-1-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
delete c.workflow.nyquist_validation;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W008').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W008',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'config.json: workflow.nyquist_validation absent (defaults to enabled but agents may skip)',
|
|
remedy: { action: REMEDY_ACTION.ADD_NYQUIST_KEY, risk: REMEDY_RISK.NONE, args: {} },
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('does not fire when nyquist_validation is present (shipped default)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w008-2-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, BASE_CONFIG);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W008').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when workflow itself is absent (guard mirrors original)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w008-3-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
delete c.workflow;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W008').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W016 — workflow.ai_integration_phase absent ────────────────────────────
|
|
|
|
describe('W016 — workflow.ai_integration_phase absent', () => {
|
|
test('fires on the unmodified shipped default — ai_integration_phase is not in the template at all (structural absence)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w016-1-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, BASE_CONFIG);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W016').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W016',
|
|
severity: SEVERITY.WARNING,
|
|
message:
|
|
'config.json: workflow.ai_integration_phase absent (defaults to enabled — run /msd-ai-integration-phase before planning AI system phases)',
|
|
remedy: { action: REMEDY_ACTION.ADD_AI_INTEGRATION_PHASE_KEY, risk: REMEDY_RISK.NONE, args: {} },
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('does not fire when ai_integration_phase key is present', (t) => {
|
|
const cwd = createTempDir('msd-3309-w016-2-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.workflow.ai_integration_phase = true;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W016').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when workflow itself is absent (guard mirrors original)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w016-3-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
delete c.workflow;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W016').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W012 — invalid branching_strategy ──────────────────────────────────────
|
|
|
|
describe('W012 — invalid branching_strategy', () => {
|
|
test('fires on an invalid branching_strategy value', (t) => {
|
|
const cwd = createTempDir('msd-3309-w012-1-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.branching_strategy = 'bogus-strategy';
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W012').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W012',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'config.json: invalid branching_strategy "bogus-strategy"',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: { command: 'Valid values: none, phase, milestone' },
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
for (const valid of ['none', 'phase', 'milestone']) {
|
|
test(`does not fire on valid branching_strategy "${valid}"`, (t) => {
|
|
const cwd = createTempDir('msd-3309-w012-valid-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.branching_strategy = valid;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W012').check(snapshot), []);
|
|
});
|
|
}
|
|
|
|
test('does not fire when branching_strategy is absent', (t) => {
|
|
const cwd = createTempDir('msd-3309-w012-2-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, BASE_CONFIG);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W012').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W013 — context_window not a positive integer ───────────────────────────
|
|
|
|
describe('W013 — context_window not a positive integer', () => {
|
|
test('fires on a non-integer context_window', (t) => {
|
|
const cwd = createTempDir('msd-3309-w013-1-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.context_window = 3.5;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W013').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W013',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'config.json: context_window should be a positive integer, got "3.5"',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: { command: 'Set to 200000 (default) or 1000000 (for 1M models)' },
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('fires on a non-positive context_window (boundary: 0)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w013-2-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.context_window = 0;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.equal(ruleFor('W013').check(snapshot).length, 1);
|
|
});
|
|
|
|
test('fires on a negative context_window', (t) => {
|
|
const cwd = createTempDir('msd-3309-w013-3-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.context_window = -1;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.equal(ruleFor('W013').check(snapshot).length, 1);
|
|
});
|
|
|
|
test('does not fire on a valid positive integer (boundary: 1)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w013-4-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.context_window = 1;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W013').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire on the conventional default (200000)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w013-5-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.context_window = 200000;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W013').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when context_window is absent', (t) => {
|
|
const cwd = createTempDir('msd-3309-w013-6-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, BASE_CONFIG);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W013').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W014 — phase_branch_template missing {phase} ───────────────────────────
|
|
|
|
describe('W014 — phase_branch_template missing {phase} placeholder', () => {
|
|
test('fires when the placeholder is stripped', (t) => {
|
|
const cwd = createTempDir('msd-3309-w014-1-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.phase_branch_template = 'phase/no-placeholder-here';
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W014').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W014',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'config.json: phase_branch_template missing {phase} placeholder',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: { command: 'Template must include {phase} for phase number substitution' },
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('does not fire when the placeholder is present', (t) => {
|
|
const cwd = createTempDir('msd-3309-w014-2-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.phase_branch_template = 'phase/{phase}';
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W014').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when phase_branch_template is absent', (t) => {
|
|
const cwd = createTempDir('msd-3309-w014-3-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, BASE_CONFIG);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W014').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W015 — milestone_branch_template missing {milestone} ──────────────────
|
|
|
|
describe('W015 — milestone_branch_template missing {milestone} placeholder', () => {
|
|
test('fires when the placeholder is stripped', (t) => {
|
|
const cwd = createTempDir('msd-3309-w015-1-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.milestone_branch_template = 'milestone/no-placeholder-here';
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W015').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W015',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'config.json: milestone_branch_template missing {milestone} placeholder',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: { command: 'Template must include {milestone} for version substitution' },
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('does not fire when the placeholder is present', (t) => {
|
|
const cwd = createTempDir('msd-3309-w015-2-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.milestone_branch_template = 'milestone/{milestone}';
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W015').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when milestone_branch_template is absent', (t) => {
|
|
const cwd = createTempDir('msd-3309-w015-3-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, BASE_CONFIG);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W015').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W022 — models malformed (3 internal conditions, 1 code) ───────────────
|
|
|
|
describe('W022 — config.json models malformed', () => {
|
|
test('(a) unknown phase type key fires', (t) => {
|
|
const cwd = createTempDir('msd-3309-w022a-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.models = { not_a_real_phase_type: 'sonnet' };
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W022').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W022',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'config.json: models has an unknown phase type "not_a_real_phase_type" which will be ignored',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: {
|
|
command: 'Valid phase types: planning, discuss, research, execution, verification, completion',
|
|
},
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('(b) known phase type with an invalid tier value fires', (t) => {
|
|
const cwd = createTempDir('msd-3309-w022b-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.models = { planning: 'not-a-real-tier' };
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W022').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W022',
|
|
severity: SEVERITY.WARNING,
|
|
message: 'config.json: models.planning has an invalid tier value "not-a-real-tier" which will be ignored',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: { command: 'Valid tiers: opus, sonnet, haiku, inherit' },
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('(c) models present but not an object fires, and does NOT also run (a)/(b)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w022c-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.models = 'not-an-object';
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W022').check(snapshot);
|
|
|
|
assert.deepEqual(diagnostics, [
|
|
{
|
|
code: 'W022',
|
|
severity: SEVERITY.WARNING,
|
|
message:
|
|
'config.json: models is set to "not-an-object", but must be an object mapping phase types to tiers — this value will be ignored',
|
|
remedy: {
|
|
action: REMEDY_ACTION.ADVISE,
|
|
risk: REMEDY_RISK.NONE,
|
|
args: {
|
|
command: 'Set models to an object like {"planning": "sonnet"}, or remove the key to use profile defaults',
|
|
},
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('(c) an array also counts as "not an object" (Array.isArray guard)', (t) => {
|
|
const cwd = createTempDir('msd-3309-w022c-array-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.models = ['sonnet'];
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W022').check(snapshot);
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.equal(diagnostics[0].code, 'W022');
|
|
});
|
|
|
|
test('multiple malformed entries in one models object each produce their own diagnostic', (t) => {
|
|
const cwd = createTempDir('msd-3309-w022-multi-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.models = { planning: 'bogus-tier', not_a_real_phase_type: 'sonnet' };
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W022').check(snapshot);
|
|
assert.equal(diagnostics.length, 2);
|
|
for (const d of diagnostics) assert.equal(d.code, 'W022');
|
|
});
|
|
|
|
test('does not fire when models is a well-formed object', (t) => {
|
|
const cwd = createTempDir('msd-3309-w022-ok-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.models = { planning: 'sonnet', research: 'inherit' };
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W022').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when models is absent', (t) => {
|
|
const cwd = createTempDir('msd-3309-w022-absent-');
|
|
t.after(() => cleanup(cwd));
|
|
writeConfig(cwd, BASE_CONFIG);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W022').check(snapshot), []);
|
|
});
|
|
|
|
test('does not fire when models is null', (t) => {
|
|
const cwd = createTempDir('msd-3309-w022-null-');
|
|
t.after(() => cleanup(cwd));
|
|
const cfg = mutatedConfig((c) => {
|
|
c.models = null;
|
|
});
|
|
writeConfig(cwd, cfg);
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W022').check(snapshot), []);
|
|
});
|
|
});
|
|
|
|
// ─── W029 — .planning/ ignored but still tracked (#3586, epic #2292) ──────
|
|
//
|
|
// Group B of the test matrix (.msd/phase/fix-3586-tracked-gitignored-planning/
|
|
// 50-test-matrix.md): the rule is a pure predicate over
|
|
// `snapshot.planningTracked` — every fixture here is driven through the REAL
|
|
// `buildPlanningSnapshot(cwd)` against a REAL temp git repo, mirroring
|
|
// tests/planning-snapshot.test.cjs's own A1-A12 fixtures (same helpers:
|
|
// createTempGitProject / gitOrThrow, no hand-built partial snapshots except
|
|
// B4, which specifically tests the field-absent-entirely case).
|
|
|
|
function writeGitignore(cwd, content) {
|
|
fs.writeFileSync(path.join(cwd, '.gitignore'), content);
|
|
}
|
|
|
|
function commitAll(cwd, message) {
|
|
gitOrThrow(['add', '-A'], { cwd });
|
|
gitOrThrow(['commit', '-m', message], { cwd });
|
|
}
|
|
|
|
describe('W029 — .planning/ ignored but still tracked', () => {
|
|
test('B1: fires when ignored AND tracked, carrying the git rm -r --cached remedy', (t) => {
|
|
const cwd = createTempGitProject('msd-3586-w029-b1-');
|
|
t.after(() => cleanup(cwd));
|
|
writeGitignore(cwd, '.planning/\n');
|
|
commitAll(cwd, 'add gitignore');
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W029').check(snapshot);
|
|
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.equal(diagnostics[0].code, 'W029');
|
|
assert.equal(diagnostics[0].severity, SEVERITY.WARNING);
|
|
assert.deepEqual(diagnostics[0].remedy.action, REMEDY_ACTION.ADVISE);
|
|
assert.deepEqual(diagnostics[0].remedy.risk, REMEDY_RISK.NONE);
|
|
assert.match(diagnostics[0].remedy.args.command, /git rm -r --cached \.planning\//);
|
|
});
|
|
|
|
test('B2a: tracked + NOT ignored (the default project) is silent', (t) => {
|
|
const cwd = createTempGitProject('msd-3586-w029-b2a-');
|
|
t.after(() => cleanup(cwd));
|
|
// No .gitignore at all.
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W029').check(snapshot), []);
|
|
});
|
|
|
|
test('B2b: ignored + untracked (the healthy ignored state) is silent', (t) => {
|
|
const cwd = createTempDir('msd-3586-w029-b2b-');
|
|
t.after(() => cleanup(cwd));
|
|
gitOrThrow(['init'], { cwd });
|
|
gitOrThrow(['config', 'user.email', 'test@test.com'], { cwd });
|
|
gitOrThrow(['config', 'user.name', 'Test'], { cwd });
|
|
gitOrThrow(['config', 'commit.gpgsign', 'false'], { cwd });
|
|
writeGitignore(cwd, '.planning/\n');
|
|
commitAll(cwd, 'initial (gitignore only)');
|
|
fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
|
|
fs.writeFileSync(path.join(cwd, '.planning', 'PROJECT.md'), '# Project\n');
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W029').check(snapshot), []);
|
|
});
|
|
|
|
test('B2c: neither tracked nor ignored (fresh project) is silent', (t) => {
|
|
const cwd = createTempDir('msd-3586-w029-b2c-');
|
|
t.after(() => cleanup(cwd));
|
|
gitOrThrow(['init'], { cwd });
|
|
gitOrThrow(['config', 'user.email', 'test@test.com'], { cwd });
|
|
gitOrThrow(['config', 'user.name', 'Test'], { cwd });
|
|
gitOrThrow(['config', 'commit.gpgsign', 'false'], { cwd });
|
|
gitOrThrow(['commit', '--allow-empty', '-m', 'initial'], { cwd });
|
|
fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
|
|
fs.writeFileSync(path.join(cwd, '.planning', 'PROJECT.md'), '# Project\n');
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.deepEqual(ruleFor('W029').check(snapshot), []);
|
|
});
|
|
|
|
test('B3: a degraded (UNREADABLE) probe produces zero findings — never a finding from a failed probe', (t) => {
|
|
const cwd = createTempDir('msd-3586-w029-b3-');
|
|
t.after(() => cleanup(cwd));
|
|
fs.mkdirSync(path.join(cwd, '.planning'), { recursive: true });
|
|
// No `git init` at all — the probe degrades to UNREADABLE/not_a_git_repo.
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.notEqual(snapshot.planningTracked.scope, 'complete');
|
|
assert.deepEqual(ruleFor('W029').check(snapshot), []);
|
|
});
|
|
|
|
test('B4: field absent from the snapshot entirely is silent, no throw (forward/backward compat)', () => {
|
|
const fakeSnapshot = {}; // deliberately missing `planningTracked`
|
|
assert.doesNotThrow(() => {
|
|
assert.deepEqual(ruleFor('W029').check(fakeSnapshot), []);
|
|
});
|
|
});
|
|
|
|
test('B5: the RULES entry marks W029 non-repairable — ADVISE never auto-untracks', () => {
|
|
assert.equal(ruleFor('W029').repairable, false);
|
|
});
|
|
|
|
// ─── ENOBUFS overflow (#3586 review F2) — the field reads COMPLETE/tracked
|
|
// via the overflow-as-proof-of-tracking path, so the rule must still fire.
|
|
// Discriminates by argv (mirrors tests/planning-snapshot.test.cjs's own
|
|
// `mockGitSpawnEnobufs`) so `isGitIgnored`'s `check-ignore` call still runs
|
|
// against the real fixture `.gitignore`.
|
|
|
|
test('B1-enobufs: an ENOBUFS-overflowed ls-files still fires W029 (tracked is proof, not a failure)', (t) => {
|
|
const cwd = createTempGitProject('msd-3586-w029-b1-enobufs-');
|
|
t.after(() => cleanup(cwd));
|
|
writeGitignore(cwd, '.planning/\n');
|
|
commitAll(cwd, 'add gitignore');
|
|
|
|
const originalSpawnSync = childProcess.spawnSync;
|
|
t.mock.method(childProcess, 'spawnSync', (cmd, args, opts) => {
|
|
if (Array.isArray(args) && args.includes('ls-files')) {
|
|
return {
|
|
status: null,
|
|
stdout: '',
|
|
stderr: '',
|
|
signal: null,
|
|
error: Object.assign(new Error('spawnSync git ENOBUFS'), { code: 'ENOBUFS' }),
|
|
};
|
|
}
|
|
return originalSpawnSync.call(childProcess, cmd, args, opts);
|
|
});
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
assert.strictEqual(snapshot.planningTracked.value.tracked, true);
|
|
assert.strictEqual(snapshot.planningTracked.scope, SCOPE.COMPLETE);
|
|
|
|
const diagnostics = ruleFor('W029').check(snapshot);
|
|
assert.equal(diagnostics.length, 1);
|
|
assert.equal(diagnostics[0].code, 'W029');
|
|
});
|
|
|
|
// ─── C3 — negative-proof: --repair must NOT untrack anything ─────────────
|
|
|
|
test('C3: applyRepairs never applies the W029 remedy, and .planning/ stays tracked afterward', (t) => {
|
|
const cwd = createTempGitProject('msd-3586-w029-c3-');
|
|
t.after(() => cleanup(cwd));
|
|
writeGitignore(cwd, '.planning/\n');
|
|
commitAll(cwd, 'add gitignore');
|
|
|
|
const snapshot = buildPlanningSnapshot(cwd);
|
|
const diagnostics = ruleFor('W029').check(snapshot);
|
|
assert.equal(diagnostics.length, 1);
|
|
|
|
const result = applyRepairs(cwd, diagnostics, /* repair */ true, /* backfill */ false);
|
|
assert.deepEqual(result.applied, []);
|
|
assert.deepEqual(result.refused, []);
|
|
assert.deepEqual(result.details, []);
|
|
|
|
// The tracked file must still be in the index — nothing was untracked.
|
|
const trackedAfter = gitOrThrow(['ls-files', '--', '.planning'], { cwd }).trim();
|
|
assert.ok(trackedAfter.length > 0, '.planning/ must still be tracked after a --repair run');
|
|
});
|
|
});
|