@bongos/core 1.19.322 → 1.19.324

package/tests/version_literals.mjs

@@ -0,0 +1,201 @@
+// tests/version_literals.mjs — no ops script hardcodes a version id
+// (task 1003166 / G02, goal 1000077, criterion guards-no-hardcoded-version).
+//
+// THE INCIDENT: smoke-write.sh named 'PMS-V1'. That version shipped, so
+// version_closed refused every create and the write-path smoke could not pass —
+// while /merge-mode Step 5 still said "4/4 expected". FOUR of the versions the
+// nine offending scripts named had already shipped when this was written.
+//
+// The tests care as much about what the guard must NOT flag as what it must: a
+// scan that fires on a comment mentioning an old version would be the over-broad
+// source assertion this repo keeps relearning (learning 1000196).
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const g = require(path.join(ROOT, 'scripts', 'gds', 'version-literal-guard.js'));
+const { pickDefaultVersion } = require(path.join(ROOT, 'scripts', 'gds', 'version-select.js'));
+const read = (...p) => fs.readFileSync(path.join(ROOT, ...p), 'utf8');
+const scan = (files) => g.scanScripts(Object.keys(files), (f) => files[f]);
+
+// ---- the selection rule ---------------------------------------------------
+test('the newest BUILDING version wins; shipped ones are never chosen', () => {
+  const vs = [
+    { id: 'PMS-V1', status: 'shipped', started_at: '2026-05-09' },
+    { id: 'GDS-V4', status: 'shipped', started_at: '2026-05-30' },
+    { id: 'BONGOS-V1', status: 'building', started_at: '2026-06-20' },
+    { id: 'CB-V1', status: 'building', started_at: '2026-06-21' },
+  ];
+  assert.equal(pickDefaultVersion(vs), 'CB-V1');
+});
+
+test('no building version yields NULL, never a guess', () => {
+  // The caller must stop and say so; interpolating '' into a create is worse.
+  assert.equal(pickDefaultVersion([{ id: 'X', status: 'shipped', started_at: '2026-01-01' }]), null);
+  assert.equal(pickDefaultVersion([]), null);
+  assert.equal(pickDefaultVersion(null), null);
+});
+
+test('a null started_at cannot decide the answer', () => {
+  const vs = [
+    { id: 'OLD', status: 'building', started_at: null },
+    { id: 'NEW', status: 'building', started_at: '2026-06-21' },
+  ];
+  assert.equal(pickDefaultVersion(vs), 'NEW', 'a half-filled row sorts last, it does not win');
+});
+
+// ---- what the guard MUST catch -------------------------------------------
+test('THE INCIDENT: a version field assigned a literal is caught', () => {
+  const r = scan({ 'scripts/gds/smoke.sh': "  'version_id': 'PMS-V1'," });
+  assert.equal(r.violations.length, 1);
+  assert.match(r.violations[0], /RESOLVED/);
+  assert.match(r.violations[0], /version-select/, 'and it names the remedy');
+});
+
+test('a --version default is caught', () => {
+  const r = scan({ 'scripts/gds/a.js': "  const v = arg('--version', args) || 'GDS-V3';" });
+  assert.equal(r.violations.length, 1);
+});
+
+test('a DEFAULT_VERSION constant is caught', () => {
+  const r = scan({ 'scripts/gds/b.js': "const DEFAULT_VERSION = process.env.X || 'BONGOS-V1';" });
+  assert.equal(r.violations.length, 1);
+});
+
+test('an unknown future prefix is caught too', () => {
+  // Enumerating PMS/GDS/BONGOS/CB would let the next scheme through.
+  const r = scan({ 'scripts/gds/c.js': "  version_id: 'ACME-V7'," });
+  assert.equal(r.violations.length, 1, 'the shape is matched, not a fixed list');
+});
+
+// ---- what the guard must NOT catch ---------------------------------------
+test('a COMMENT naming an old version is not a violation', () => {
+  // smoke-claim-consistency.sh legitimately says "PMS-V2 P6 not live yet".
+  const r = scan({
+    'scripts/gds/d.sh': '# TODO: once PMS-V2 P6 ships, drop this',
+    'scripts/gds/e.js': "// version_id: 'GDS-V3' used to live here",
+  });
+  assert.deepEqual(r.violations, []);
+});
+
+test('prose printed to the operator is not a violation', () => {
+  const r = scan({ 'scripts/gds/f.sh': '  echo "SKIP — PMS-V2 P6 not live yet"' });
+  assert.deepEqual(r.violations, []);
+});
+
+test('a RESOLVED assignment is not a violation', () => {
+  const r = scan({ 'scripts/gds/g.js': '  version_id: await resolveDefaultVersion(),' });
+  assert.deepEqual(r.violations, []);
+});
+
+test('seeders and tests are exempt BY PATH, not by allowlist', () => {
+  // A seeder's whole subject IS a historical version; asking it to resolve one
+  // at runtime would break it.
+  for (const p of ['scripts/gds/seed-v3-tasks.js', 'scripts/gds/newcomer-floor.test.js', 'scripts/hall-preview/fixtures/x.js']) {
+    assert.equal(g.isExempt(p), true, `${p} must be exempt`);
+  }
+  assert.equal(g.isExempt('scripts/gds/smoke-write.sh'), false, 'an ops script is not exempt');
+});
+
+// ---- the live tree --------------------------------------------------------
+test('the live tree passes', () => {
+  const r = g.checkNoVersionLiterals();
+  assert.equal(r.hardFail, false, `unexpected:\n  ${r.violations.join('\n  ')}`);
+});
+
+test('an empty enumeration FAILS rather than reporting all-clear', () => {
+  const r = g.checkNoVersionLiterals({ files: [] });
+  assert.equal(r.hardFail, true);
+  assert.match(r.violations[0], /scan defect/);
+});
+
+test('every allowlist entry carries a real justification', () => {
+  assert.ok(g.VERSION_LITERAL_ALLOW.size > 0);
+  for (const [k, why] of g.VERSION_LITERAL_ALLOW) {
+    assert.match(k, /^scripts\//, `${k} is a script path`);
+    assert.ok(String(why).length > 60, `${k} needs a reason, not a label`);
+  }
+});
+
+// ---- the reported bug is actually fixed ----------------------------------
+test('smoke-write.sh resolves its version instead of naming one', () => {
+  const sh = read('scripts', 'gds', 'smoke-write.sh');
+  assert.ok(!/'version_id': '[A-Z]/.test(sh), 'no literal remains');
+  // The invocation is `$(node "$(dirname "$0")/version-select.js")`, so the
+  // closing paren is preceded by a quote AND the inner $(dirname "$0") contains
+  // its own ')', so neither `.js)` nor [^)]* matches. Match to end-of-line.
+  assert.match(sh, /VERSION_ID=\$\(node[^\n]*version-select\.js/, 'it resolves at runtime');
+  assert.match(sh, /exit 1/, 'and stops if it cannot');
+});
+
+test('all four bash smokes resolve, and none names a version', () => {
+  for (const f of ['smoke-write.sh', 'smoke-claim-consistency.sh', 'smoke-batch-release.sh', 'smoke-batch-claim.sh']) {
+    const sh = read('scripts', 'gds', f);
+    assert.match(sh, /version-select\.js/, `${f} resolves`);
+    assert.match(sh, /'version_id': '\$\{VERSION_ID\}'/, `${f} uses the resolved id`);
+  }
+});
+
+test('capture.js no longer keeps its own copy of the rule', () => {
+  // It was the precedent; now it is a caller, so there is ONE implementation.
+  const src = read('scripts', 'gds', 'capture.js');
+  assert.match(src, /require\('\.\/version-select\.js'\)/);
+  assert.ok(!/async function resolveDefaultVersion/.test(src), 'the private copy is gone');
+});
+
+// ---- the four grader findings from the first pass -------------------------
+test('an unsafe version id is REFUSED, not printed', () => {
+  // Bash callers splice this into a quoted Python string, so the one place that
+  // can guarantee safety is the source. Ids with a quote or backslash could
+  // otherwise break out of the literal (the grader's defense-in-depth finding).
+  const { SAFE_ID } = require(path.join(ROOT, 'scripts', 'gds', 'version-select.js'));
+  for (const bad of ["CB-V1'; import os", 'CB\\V1', "'", '', '1-V1', 'a b']) {
+    assert.equal(SAFE_ID.test(bad), false, `${JSON.stringify(bad)} must be refused`);
+  }
+  for (const good of ['CB-V1', 'BONGOS-V1', 'GDS-V3', 'v2.1_beta']) {
+    assert.equal(SAFE_ID.test(good), true, `${good} must be accepted`);
+  }
+});
+
+test('session-eval resolves the version ONCE, not per finding', () => {
+  // It was called inside `for (const s of systemic)` — a network round trip per
+  // finding, for a value invariant across the run.
+  const src = read('scripts', 'gds', 'session-eval.js');
+  // Anchored on the CALL COUNT rather than on a loop position: the file has TWO
+  // `for (const s of systemic)` loops, so an indexOf-based test picked the wrong
+  // one and passed vacuously. Exactly one call site is the real invariant.
+  const calls = src.match(/await resolveDefaultVersion\(\)/g) || [];
+  assert.equal(calls.length, 1, `resolved once per run, not per finding (found ${calls.length})`);
+  assert.match(src, /const suggestedVersion = await resolveDefaultVersion\(\)/, 'hoisted to a const');
+  assert.match(src, /suggested_version: suggestedVersion,/, 'and the filing uses it');
+});
+
+test('version-select exits through cliExit, not process.exit', () => {
+  // CLAUDE.md: cliExit is the always-correct move for handle closure.
+  const src = read('scripts', 'gds', 'version-select.js');
+  assert.match(src, /require\('\.\/cli-lib'\)/);
+  assert.ok(!/process\.exit\(/.test(src), 'no raw process.exit remains');
+});
+
+test('ship-flow.js imports every cross-module function it calls', () => {
+  // task 1003205's carve left pushVia() called in regradeMain but never imported,
+  // so EVERY resume of a task at 'completed' died with ReferenceError before the
+  // claim resolved — found by hitting it while shipping this task. Guarding the
+  // one name is not enough; assert the import exists for anything it calls from
+  // its sibling deploy-target module.
+  const src = read('scripts', 'gds', 'ship-flow.js');
+  const deployTargetExports = ['pushVia', 'resolveDeployMode', 'mainIsProtected', 'resolveDeployTarget'];
+  const imported = /require\('\.\/ship-deploy-target\.js'\)/.test(src)
+    ? (src.match(/const \{([^}]*)\} = require\('\.\/ship-deploy-target\.js'\)/) || [, ''])[1]
+    : '';
+  for (const name of deployTargetExports) {
+    if (new RegExp(`(?<![\\w.])${name}\\(`).test(src)) {
+      assert.ok(imported.includes(name), `ship-flow.js calls ${name}() but does not import it`);
+    }
+  }
+});