@bongos/core 1.19.592 → 1.19.594

package/tests/version_override_visibility.mjs

@@ -0,0 +1,176 @@
+// tests/version_override_visibility.mjs — an override nobody can count is
+// indistinguishable from no gate at all (BV1.R15, task 1003602, goal 1000086,
+// ADR 0250 §3).
+//
+// THE RULE R03 CREATED, AND THE HOLE R15 CLOSES. A goal may only be added to a
+// version still in `planning`; an Archon may override that and admit one into a
+// version already building, recording a reason. R07 (task 1003594) built the
+// record and put the count on `GET /versions/:id/progress`. That route is not a
+// surface anyone opens — the roadmap reads the ROLLUP, the board reads
+// `listGoals`, and neither carried a single bit about admissions. So the
+// override existed, was recorded, and was invisible everywhere a person looks,
+// which is the same accountability as not recording it.
+//
+// WHAT THIS FILE PINS: the count rides the rollup the hall actually reads; the
+// board can tell an admitted goal from a normal one; the detail names WHO and
+// WHY; and the zero case renders nothing, so the line is a signal rather than
+// chrome.
+//
+// Run:  node --test tests/version_override_visibility.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { makeSqlAwareClient } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const { listGoals, listVersionAdmissions, versionProgress } = require('../modules/lifecycle/db.js');
+
+const src = (rel) => readFileSync(new URL('../' + rel, import.meta.url), 'utf8');
+const GOALS_RENDER = src('modules/hall-ui/public/goals-render.js');
+const ROADMAP = src('modules/hall-ui/public/roadmap.js');
+
+function fakePool(handler) {
+  const c = makeSqlAwareClient(handler);
+  return { query: (sql, params) => c._client.query(sql, params), connect: c.connect, queries: c._client.queries };
+}
+
+// ---------------------------------------------------------------------------
+// The rollup — the surface the roadmap reads
+// ---------------------------------------------------------------------------
+
+test('versionProgress asks for the admission count', async () => {
+  let seen = null;
+  const pool = fakePool((s) => { seen = s; return { rows: [] }; });
+  await versionProgress({ pool });
+  assert.match(seen, /lifecycle_goal_version_admissions/,
+    'the rollup must carry the override count — R07 put it only on /versions/:id/progress, which the roadmap never calls');
+  assert.match(seen, /COALESCE\(adm\.admission_count, 0\)/,
+    'a version nobody widened has no row in the aggregate, so the zero comes from COALESCE, not from a manufactured join row');
+});
+
+test('versionProgress returns admission_count as a number, defaulting to 0', async () => {
+  const pool = fakePool(() => ({
+    rows: [{
+      version_id: 'BONGOS-V1', name: 'platform', status: 'building',
+      shipped_count: 1, total_count: 2, shipped_weight: 1, total_weight: 2,
+      done_when: null, criteria_count: 3,
+      lifecycle_completed_count: 0, lifecycle_confirmed_count: 0, lifecycle_shipped_count: 1,
+      admission_count: 2,
+    }],
+  }));
+  const [row] = await versionProgress({ pool });
+  assert.equal(row.admission_count, 2);
+  assert.equal(typeof row.admission_count, 'number',
+    'the client compares it to 0; a string "2" from the pg driver would render but never equal 0');
+});
+
+// ---------------------------------------------------------------------------
+// The board — which goals were admitted
+// ---------------------------------------------------------------------------
+
+test('listGoals carries an `admitted` flag', async () => {
+  let seen = null;
+  const pool = fakePool((s) => { seen = s; return { rows: [] }; });
+  await listGoals({ versionId: 'BONGOS-V1' }, { pool });
+  assert.match(seen, /EXISTS \(SELECT 1 FROM lifecycle_goal_version_admissions/);
+  assert.match(seen, /AS admitted/);
+});
+
+test('the board flag is EXISTS, not a join that could duplicate a goal', async () => {
+  // A LEFT JOIN would return one row per admission. There is one today, but the
+  // table has no unique constraint on goal_id, so a second admission row would
+  // silently make the goal appear twice in the board's list.
+  let seen = null;
+  const pool = fakePool((s) => { seen = s; return { rows: [] }; });
+  await listGoals({}, { pool });
+  assert.equal(/LEFT JOIN lifecycle_goal_version_admissions/.test(seen), false);
+});
+
+test('listGoals still filters and orders as before', async () => {
+  let seen = null;
+  const pool = fakePool((s) => { seen = s; return { rows: [] }; });
+  await listGoals({ versionId: 'X', status: 'open', limit: 5 }, { pool });
+  assert.match(seen, /version_id = \$1/);
+  assert.match(seen, /status = \$2/);
+  // Unqualified, exactly as before: the admissions EXISTS names `goals.id` in
+  // full so no other line of this query had to change. tests/goal_tier.mjs pins
+  // this literal ordering text.
+  assert.match(seen, /ORDER BY version_id, sort_order, created_at, id/);
+});
+
+// ---------------------------------------------------------------------------
+// The detail — by whom, and why
+// ---------------------------------------------------------------------------
+
+test('listVersionAdmissions resolves the admitter to a NAME', async () => {
+  let seen = null;
+  const pool = fakePool((s) => { seen = s; return { rows: [] }; });
+  await listVersionAdmissions('BONGOS-V1', { pool });
+  // ADR 0250 §3 asks "by whom". A numeric builder id does not answer it, and
+  // making every caller issue a second lookup per row is how a counter stops
+  // being read.
+  assert.match(seen, /admitted_by_login/);
+  assert.match(seen, /admitted_by_name/);
+});
+
+test('an admission whose admitter was offboarded still appears', async () => {
+  // The one failure mode that matters: an inner JOIN would DROP the row, hiding
+  // exactly the history someone with an interest in hiding it would target.
+  let seen = null;
+  const pool = fakePool((s) => { seen = s; return { rows: [] }; });
+  await listVersionAdmissions('BONGOS-V1', { pool });
+  assert.match(seen, /LEFT JOIN builders b ON b\.id = a\.admitted_by/);
+});
+
+// ---------------------------------------------------------------------------
+// The hall
+// ---------------------------------------------------------------------------
+
+test('the goal detail renders WHO admitted it', () => {
+  assert.match(GOALS_RENDER, /goal-badge--admitted/);
+  assert.match(GOALS_RENDER, /admitted_by_name \|\| adm\.admitted_by_login \|\| \('builder ' \+ adm\.admitted_by\)/,
+    'falls back through name → login → id so an offboarded admitter still renders as someone');
+});
+
+test('the REASON is rendered, not hidden in a title attribute', () => {
+  // A tooltip is invisible on touch and to anyone not already suspicious. An
+  // override you have to hover to justify is the same unaccountable override.
+  assert.match(GOALS_RENDER, /why\.className = 'goal-admission';/);
+  assert.match(GOALS_RENDER, /adm\.reason \? ` — \$\{escapeHtml\(String\(adm\.reason\)\)\}`/);
+});
+
+test('an admission with no recorded reason says so rather than rendering blank', () => {
+  assert.match(GOALS_RENDER, /no reason recorded/);
+});
+
+test('a normally-created goal renders nothing at all', () => {
+  // `admitted` is null for every goal that went through the gate — the positive
+  // fact "this did not skip it", not missing data.
+  assert.match(GOALS_RENDER, /const adm = d\.admitted;/);
+  assert.match(GOALS_RENDER, /const admittedSpan = adm\s*\n?\s*\?/);
+  assert.match(GOALS_RENDER, /if \(adm\) \{/);
+});
+
+test('the board renders one chip, and does not leak the reason onto every row', () => {
+  assert.match(GOALS_RENDER, /fact-chip--admitted/);
+  assert.match(GOALS_RENDER, /g\.admitted\s*\n?\s*\?/);
+  // The chip's own markup must not interpolate a reason: listGoals deliberately
+  // returns a boolean, and an Archon's free text does not belong on a list row.
+  const chip = GOALS_RENDER.slice(GOALS_RENDER.indexOf('const admittedChip'), GOALS_RENDER.indexOf('const factsHtml'));
+  assert.equal(/reason/.test(chip), false);
+});
+
+test('the roadmap renders the count only when it is above zero', () => {
+  assert.match(ROADMAP, /function admissionNote\(v\)/);
+  assert.match(ROADMAP, /if \(n === 0\) return '';/,
+    'a permanent "0 overrides" line is chrome a reader learns to skip — and would go on skipping when it became 2');
+  assert.match(ROADMAP, /admissions: Number\(p\.admission_count\) \|\| 0/);
+  assert.match(ROADMAP, /\$\{admissionNote\(v\)\}/, 'the helper must actually be called from the goals block');
+});
+
+test('the roadmap note pluralises, so "1 goals" never ships', () => {
+  assert.match(ROADMAP, /n === 1 \? '' : 's'/);
+});