@bongos/core 1.20.64 → 1.20.66

package/tests/goal_move.mjs

@@ -0,0 +1,285 @@
+// tests/goal_move.mjs — POST /goals/:id/move re-homes a goal, whole, on another
+// version (task 1004485).
+//
+// Three layers, the goal_archive_disposition / goal_archive_route_e2e split in one
+// file: the pure gate's truth table, the writer's transaction shape against a fake
+// pool (every write inside ONE transaction, tasks moved by version_id AND goal,
+// the cross-goal criterion refusal BEFORE any write), and the real router over a
+// real socket with the db layer stubbed at the module boundary.
+//
+// Run:  node --test tests/goal_move.mjs
+
+import assert from 'node:assert/strict';
+import { test, after } 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 { authorizeGoalMove, moveGoalToVersion } = require('../modules/lifecycle/goal-move.js');
+
+const OPEN_GOAL = { id: '7', version_id: 'V2', status: 'open', is_maintenance: false };
+const V2 = { id: 'V2', status: 'building' };
+const V3 = { id: 'V3', status: 'planning' };
+
+// ---- the pure gate ----------------------------------------------------------
+
+test('an open goal moves to the planning version', () => {
+  const d = authorizeGoalMove({ goal: OPEN_GOAL, source: V2, target: V3 });
+  assert.deepEqual(d, { ok: true, overrideApplied: false });
+});
+
+test('refusals, each by name', () => {
+  const cases = [
+    [{ goal: null, source: null, target: V3 }, 404, 'goal_not_found'],
+    [{ goal: { ...OPEN_GOAL, is_maintenance: true }, source: V2, target: V3 }, 409, 'maintenance_goal'],
+    [{ goal: { ...OPEN_GOAL, status: 'achieved' }, source: V2, target: V3 }, 409, 'goal_not_open'],
+    [{ goal: { ...OPEN_GOAL, status: 'archived' }, source: V2, target: V3 }, 409, 'goal_not_open'],
+    [{ goal: OPEN_GOAL, source: { id: 'V2', status: 'shipped' }, target: V3 }, 409, 'source_version_shipped'],
+    [{ goal: OPEN_GOAL, source: V2, target: V2 }, 409, 'same_version'],
+    [{ goal: OPEN_GOAL, source: V2, target: null }, 404, 'version_not_found'],
+    [{ goal: OPEN_GOAL, source: V2, target: { id: 'V1', status: 'shipped' } }, 409, 'version_closed'],
+    [{ goal: { ...OPEN_GOAL, version_id: 'V3' }, source: V3, target: V2 }, 409, 'version_not_planning'],
+  ];
+  for (const [input, status, error] of cases) {
+    const d = authorizeGoalMove(input);
+    assert.equal(d.ok, false, error);
+    assert.equal(d.status, status, error);
+    assert.equal(d.body.error, error);
+  }
+});
+
+test('a building target opens only with the admit_reason override, and says so', () => {
+  const goal = { ...OPEN_GOAL, version_id: 'V3' };
+  assert.deepEqual(authorizeGoalMove({ goal, source: V3, target: V2, admitReason: 'owner pulled it back' }),
+    { ok: true, overrideApplied: true });
+  // On a planning target the reason changes nothing — so nothing is recorded.
+  assert.deepEqual(authorizeGoalMove({ goal: OPEN_GOAL, source: V2, target: V3, admitReason: 'x' }),
+    { ok: true, overrideApplied: false });
+});
+
+// ---- the writer ---------------------------------------------------------------
+
+const flat = (q) => String(q.sql).replace(/\s+/g, ' ').trim();
+function txPool(handler) {
+  const c = makeSqlAwareClient(handler);
+  return { connect: c.connect, query: (sql, params) => c._client.query(sql, params), queries: c._client.queries };
+}
+function happyPool(over = {}) {
+  return txPool((q) => {
+    for (const [re, rows] of Object.entries(over)) if (new RegExp(re).test(q)) return { rows };
+    if (/FROM goals WHERE id = \$1 FOR UPDATE/.test(q)) return { rows: [{ id: '7', version_id: 'V2', status: 'open' }] };
+    if (/FROM versions WHERE id = \$1 FOR SHARE/.test(q)) return { rows: [{ status: 'planning' }] };
+    if (/FROM task_criteria/.test(q)) return { rows: [] };
+    if (/UPDATE done_when_criteria/.test(q)) return { rows: [{ id: '51' }] };
+    if (/UPDATE tasks/.test(q)) return { rows: [{ id: '12' }, { id: '3' }] };
+    return { rows: [] };
+  });
+}
+const ARGS = { goalId: 7, fromVersionId: 'V2', toVersionId: 'V3', targetStatus: 'planning' };
+
+test('goal, criteria and every task move inside ONE transaction', async () => {
+  const pool = happyPool();
+  const out = await moveGoalToVersion(ARGS, { pool });
+  assert.deepEqual(out, { fromVersionId: 'V2', toVersionId: 'V3', taskIds: ['3', '12'], criterionIds: ['51'] });
+  const sqls = pool.queries.map(flat);
+  const at = (re) => sqls.findIndex((s) => re.test(s));
+  assert.equal(sqls.filter((s) => s === 'BEGIN').length, 1);
+  assert.equal(sqls.filter((s) => s === 'COMMIT').length, 1);
+  for (const re of [/^UPDATE goals SET version_id = \$2/, /^UPDATE done_when_criteria SET version_id = \$2 WHERE goal_id = \$1/, /^UPDATE tasks SET version_id = \$2/]) {
+    const i = at(re);
+    assert.ok(i > at(/^BEGIN$/) && i < at(/^COMMIT$/), `${re} is inside the transaction`);
+  }
+  // Every task in the goal — not only the open ones — or a shipped task would be
+  // left in a goal of another version.
+  const taskWrite = sqls[at(/^UPDATE tasks/)];
+  assert.match(taskWrite, /WHERE goal_id = \$1 RETURNING/);
+  assert.doesNotMatch(taskWrite, /status/);
+  // The goal is locked before anything is read or written.
+  assert.ok(at(/FROM goals WHERE id = \$1 FOR UPDATE/) < at(/^UPDATE/));
+});
+
+test('a criterion link crossing the goal edge refuses BEFORE any write, and names the pair', async () => {
+  const pool = happyPool({ 'FROM task_criteria': [{ task_id: '12', criterion_id: '900' }] });
+  await assert.rejects(moveGoalToVersion(ARGS, { pool }), (e) => {
+    assert.equal(e.code, 'CRITERION_LINKS_CROSS_GOAL');
+    assert.deepEqual(e.links, [{ task_id: '12', criterion_id: '900' }]);
+    return true;
+  });
+  const sqls = pool.queries.map(flat);
+  assert.equal(sqls.filter((s) => /^UPDATE|^INSERT/.test(s)).length, 0, 'nothing written');
+  assert.ok(sqls.includes('ROLLBACK'));
+});
+
+test('the crossing test asks "exactly one side inside the goal"', async () => {
+  const pool = happyPool();
+  await moveGoalToVersion(ARGS, { pool });
+  const q = pool.queries.map(flat).find((s) => /FROM task_criteria/.test(s));
+  assert.match(q, /\(t\.goal_id IS NOT DISTINCT FROM \$1\) <> \(c\.goal_id IS NOT DISTINCT FROM \$1\)/);
+});
+
+test('a goal or target that changed since the route checked rolls back', async () => {
+  for (const [over, code] of [
+    [{ 'FROM goals WHERE id = \\$1 FOR UPDATE': [{ id: '7', version_id: 'V9', status: 'open' }] }, 'GOAL_CHANGED'],
+    [{ 'FROM goals WHERE id = \\$1 FOR UPDATE': [{ id: '7', version_id: 'V2', status: 'archived' }] }, 'GOAL_CHANGED'],
+    [{ 'FROM versions WHERE id = \\$1 FOR SHARE': [{ status: 'building' }] }, 'TARGET_CHANGED'],
+    [{ 'FROM goals WHERE id = \\$1 FOR UPDATE': [] }, 'GOAL_NOT_FOUND'],
+  ]) {
+    const pool = happyPool(over);
+    await assert.rejects(moveGoalToVersion(ARGS, { pool }), (e) => e.code === code);
+    assert.equal(pool.queries.map(flat).filter((s) => /^UPDATE/.test(s)).length, 0, code);
+  }
+});
+
+test('a criterion slug the target already uses becomes CRITERION_ID_COLLISION', async () => {
+  const pool = txPool((q) => {
+    if (/FROM goals WHERE id = \$1 FOR UPDATE/.test(q)) return { rows: [{ id: '7', version_id: 'V2', status: 'open' }] };
+    if (/FROM versions WHERE id = \$1 FOR SHARE/.test(q)) return { rows: [{ status: 'planning' }] };
+    if (/UPDATE done_when_criteria/.test(q)) throw Object.assign(new Error('dup'), { code: '23505' });
+    return { rows: [] };
+  });
+  await assert.rejects(moveGoalToVersion(ARGS, { pool }), (e) => e.code === 'CRITERION_ID_COLLISION');
+});
+
+test('the admission is written only when the override opened a building target', async () => {
+  const plain = happyPool();
+  await moveGoalToVersion(ARGS, { pool: plain });
+  assert.equal(plain.queries.map(flat).filter((s) => /lifecycle_goal_version_admissions/.test(s)).length, 0);
+
+  const admitted = happyPool({ 'FROM versions WHERE id = \\$1 FOR SHARE': [{ status: 'building' }] });
+  await moveGoalToVersion({ ...ARGS, targetStatus: 'building', admission: { admittedBy: '3', reason: 'r' } }, { pool: admitted });
+  const ins = admitted.queries.find((q) => /lifecycle_goal_version_admissions/.test(flat(q)));
+  assert.ok(ins, 'admission recorded');
+  assert.deepEqual(ins.params, [7, 'V3', '3', 'r']);
+});
+
+// ---- the route, over a real socket ---------------------------------------------
+
+const express = require('express');
+const api = require('../src/module-api.js');
+const db = require('../modules/lifecycle/db.js');
+const goalMove = require('../modules/lifecycle/goal-move.js');
+
+let permSeen = null;
+api.requireBuilder = (req, _res, next) => { req.builder = { id: '3', rank: 'archon' }; next(); };
+api.requirePermission = (...p) => { permSeen = p; return (_req, _res, next) => next(); };
+
+const GOALS = { 7: { ...OPEN_GOAL }, 8: { id: '8', version_id: 'V2', status: 'open', is_maintenance: true } };
+const VERSIONS = { V2, V3 };
+let writes = [];
+db.getGoal = async (id) => GOALS[Number(id)] ?? null;
+db.getVersion = async (id) => VERSIONS[id] ?? null;
+goalMove.moveGoalToVersion = async (args) => {
+  writes.push(args);
+  GOALS[args.goalId] = { ...GOALS[args.goalId], version_id: args.toVersionId };
+  return { fromVersionId: args.fromVersionId, toVersionId: args.toVersionId, taskIds: ['3', '12'], criterionIds: [] };
+};
+
+const app = express();
+app.use(express.json());
+app.use((req, res, next) => {
+  res.fail = (code, statusOrOpts, details) => {
+    const o = typeof statusOrOpts === 'number' ? { status: statusOrOpts } : (statusOrOpts || {});
+    return res.status(o.status || 400).json({ error: code, message: o.message, details: o.details ?? details });
+  };
+  next();
+});
+app.use('/api/gds', require('../modules/lifecycle/routes/goal-move.js')());
+const server = app.listen(0);
+await new Promise((r) => server.once('listening', r));
+after(() => server.close());
+const base = `http://127.0.0.1:${server.address().port}/api/gds`;
+const post = async (p, body) => {
+  const r = await fetch(base + p, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body ?? {}) });
+  return { status: r.status, body: await r.json().catch(() => null) };
+};
+
+test('the route is gated on the version-authoring atom', () => {
+  assert.deepEqual(permSeen, ['version.create']);
+  const pins = readFileSync(new URL('../src/bongos/route-rank-check.js', import.meta.url), 'utf8');
+  assert.match(pins, /'POST \/goals\/:id\/move': 'perm:version\.create'/);
+});
+
+test('a move returns the goal on its new version and the tasks that went with it', async () => {
+  writes = [];
+  const r = await post('/goals/7/move', { version_id: 'V3' });
+  assert.equal(r.status, 200, JSON.stringify(r.body));
+  assert.equal(r.body.goal.version_id, 'V3');
+  assert.equal(r.body.from_version_id, 'V2');
+  assert.deepEqual(r.body.moved_task_ids, ['3', '12']);
+  assert.equal(r.body.admitted, false);
+  assert.deepEqual(writes, [{ goalId: 7, fromVersionId: 'V2', toVersionId: 'V3', targetStatus: 'planning', admission: null }]);
+});
+
+test('a refused move writes nothing and renders the gate verbatim', async () => {
+  writes = [];
+  let r = await post('/goals/8/move', { version_id: 'V3' });
+  assert.equal(r.status, 409); assert.equal(r.body.error, 'maintenance_goal');
+  r = await post('/goals/404/move', { version_id: 'V3' });
+  assert.equal(r.status, 404); assert.equal(r.body.error, 'goal_not_found');
+  r = await post('/goals/8/move', {});
+  assert.equal(r.status, 400);
+  r = await post('/goals/8/move', { version_id: 'V3', versionid: 'typo' });
+  assert.equal(r.status, 400, 'an unknown field is rejected, not ignored');
+  assert.equal(writes.length, 0);
+});
+
+test('a crossing criterion link surfaces as 409 with the pairs', async () => {
+  GOALS[9] = { id: '9', version_id: 'V2', status: 'open', is_maintenance: false };
+  const real = goalMove.moveGoalToVersion;
+  goalMove.moveGoalToVersion = async () => { throw Object.assign(new Error('x'), { code: 'CRITERION_LINKS_CROSS_GOAL', links: [{ task_id: '1', criterion_id: '2' }] }); };
+  const r = await post('/goals/9/move', { version_id: 'V3' });
+  goalMove.moveGoalToVersion = real;
+  assert.equal(r.status, 409);
+  assert.equal(r.body.error, 'criterion_links_cross_goal');
+  assert.deepEqual(r.body.details.links, [{ task_id: '1', criterion_id: '2' }]);
+});
+
+// ---- the CLI wrapper ----------------------------------------------------------
+
+test('goal.js move parses a real goal id and version id, and refuses junk', () => {
+  const { parseMoveArgs } = require('../scripts/gds/goal.js');
+  assert.deepEqual(parseMoveArgs(['1000122', '--to', 'BONGOS-V3']), { id: 1000122, body: { version_id: 'BONGOS-V3' } });
+  assert.deepEqual(parseMoveArgs(['7', '--to=V3.1', '--admit-reason', 'owner call']),
+    { id: 7, body: { version_id: 'V3.1', admit_reason: 'owner call' } });
+  for (const bad of [[], ['abc', '--to', 'V3'], ['7'], ['7', '--to'], ['7', '--to', 'V 3'], ['7', '--to', 'V3;rm']]) {
+    assert.equal(parseMoveArgs(bad), null, JSON.stringify(bad));
+  }
+});
+
+// ---- version progress follows the move --------------------------------------
+//
+// The live view counts a version's tasks by tasks.version_id — so the counts move
+// with the goal exactly when the writer re-points every task's version_id, which
+// the transaction test above pins. Both halves are asserted here together: if the
+// view ever counted through goals instead, or the writer stopped touching
+// tasks.version_id, V2's progress would keep counting moved work.
+
+test('version_progress counts by tasks.version_id, and the move rewrites it for every task in the goal', async () => {
+  const { readdirSync } = await import('node:fs');
+  const files = readdirSync(new URL('../migrations/', import.meta.url)).filter((f) => f.endsWith('.sql')).sort();
+  const latest = files.filter((f) => /VIEW version_progress/.test(readFileSync(new URL('../migrations/' + f, import.meta.url), 'utf8'))).pop();
+  assert.ok(latest, 'version_progress view found');
+  const view = readFileSync(new URL('../migrations/' + latest, import.meta.url), 'utf8');
+  assert.match(view, /LEFT JOIN tasks t ON t\.version_id = v\.id/);
+
+  // Before/after against the writer's own statements: a goal holding tasks 3 and
+  // 12 on V2 — after the move both carry V3, so V2 counts 0 of them and V3 counts 2.
+  const tasks = [{ id: '3', goal_id: 7, version_id: 'V2' }, { id: '12', goal_id: 7, version_id: 'V2' }, { id: '99', goal_id: 8, version_id: 'V2' }];
+  const count = (v) => tasks.filter((t) => t.version_id === v).length;
+  assert.equal(count('V2'), 3); assert.equal(count('V3'), 0);
+  const pool = txPool((q, params) => {
+    if (/FROM goals WHERE id = \$1 FOR UPDATE/.test(q)) return { rows: [{ id: '7', version_id: 'V2', status: 'open' }] };
+    if (/FROM versions WHERE id = \$1 FOR SHARE/.test(q)) return { rows: [{ status: 'planning' }] };
+    if (/^UPDATE tasks SET version_id = \$2/.test(q)) {
+      const hit = tasks.filter((t) => t.goal_id === params[0]);
+      for (const t of hit) t.version_id = params[1];
+      return { rows: hit.map((t) => ({ id: t.id })) };
+    }
+    return { rows: [] };
+  });
+  await moveGoalToVersion(ARGS, { pool });
+  assert.equal(count('V2'), 1, 'only the other goal\'s task still counts on V2');
+  assert.equal(count('V3'), 2);
+});

package/tests/npm_release_preview_diagnosis.mjs

@@ -149,7 +149,7 @@ test('a probe that sees a database failure fails the preview, says why, and clea
   assert.match(s.error, /schemaPending null/);
   assert.ok(events.includes('kill:SIGTERM'), 'the child was stopped');
   assert.deepEqual(calls[calls.length - 1], cmds.dropDbCommand(), 'the copy was dropped');
-  assert.equal(fake.rm.length, 1, 'the scratch directory was removed');
+  assert.equal(fake.rm.filter((p) => !String(p).replace(/\\/g, '/').endsWith('/live.dump')).length, 1, 'the scratch directory was removed');
 });
 
 test('a preview is running only once the probe says it can serve data', async () => {

package/tests/npm_release_preview_env.mjs

@@ -98,3 +98,26 @@ test('a missing port or scratch home is refused rather than guessed', () => {
   assert.throws(() => buildPreviewEnv({ env: LIVE, scratchHome: '/h' }), /port/);
   assert.throws(() => buildPreviewEnv({ env: LIVE, port: 1 }), /scratchHome/);
 });
+
+// THE FIRST REAL RUN ON THE DROPLET (task 1004388). The live hall connects by Unix-socket peer
+// auth with no PGUSER set, so the database driver takes the login name from USER — and an
+// environment built from nothing has no USER. Every query in the preview then failed with
+// "no PostgreSQL user name specified", while the migration (psql, which asks the OS) passed.
+// The login name is therefore stated: the carried PGUSER when there is one, else the OS user
+// this process runs as — the same identity peer auth would have checked.
+test('with no PGUSER to carry, the preview logs in as the OS user it runs as', () => {
+  const { PGUSER, ...noUser } = LIVE;
+  const out = buildPreviewEnv({ env: noUser, port: 3190, scratchHome: '/h', osUser: () => 'lars' });
+  assert.equal(out.PGUSER, 'lars');
+});
+
+test('a carried PGUSER wins over the OS user', () => {
+  const out = buildPreviewEnv({ env: LIVE, port: 3190, scratchHome: '/h', osUser: () => 'lars' });
+  assert.equal(out.PGUSER, 'hall');
+});
+
+test('an OS user that cannot be read leaves PGUSER unset rather than failing the start', () => {
+  const { PGUSER, ...noUser } = LIVE;
+  const out = buildPreviewEnv({ env: noUser, port: 3190, scratchHome: '/h', osUser: () => { throw new Error('no passwd entry'); } });
+  assert.equal('PGUSER' in out, false);
+});

package/tests/npm_release_preview_supervisor.mjs

@@ -46,6 +46,8 @@ function rig({ failOn, probeResults, env } = {}) {
 }
 
 const fwd = (x) => String(x).split(String.fromCharCode(92)).join('/');
+// The scratch directory's own removals; the dump file is removed separately, right after the restore.
+const scratchRms = (r) => r.filter((p) => !fwd(p).endsWith('/live.dump'));
 const DROP = { cmd: 'dropdb', args: ['--if-exists', '--force', PREVIEW_DB] };
 
 test('a start runs install, copy, restore and migrate, in that order, then launches and waits for health', async () => {
@@ -92,7 +94,7 @@ for (const failOn of ['npm', 'dropdb', 'createdb', 'dump', 'pg_restore', 'bash']
     assert.match(s.error, failOn === 'dropdb' ? /could not be dropped/ : /failed [(]exit 3[)]/);
     assert.equal(fake.spawned.length, 0, 'no process was started');
     if (failOn !== 'dropdb') assert.deepEqual(calls[calls.length - 1], DROP, 'the copy is dropped last');
-    assert.equal(rmCalls.length, 1, 'the scratch directory is removed');
+    assert.equal(scratchRms(rmCalls).length, 1, 'the scratch directory is removed');
   });
 }
 
@@ -102,7 +104,7 @@ test('a preview that never answers is stopped and cleaned up', async () => {
   assert.equal(sup.status().state, 'failed');
   assert.match(sup.status().error, /did not answer/);
   assert.equal(fake.killed, 1);
-  assert.equal(rmCalls.length, 1);
+  assert.equal(scratchRms(rmCalls).length, 1);
 });
 
 test('only one preview at a time: a second version is refused, the same version is not restarted', async () => {
@@ -139,7 +141,7 @@ test('stop kills the child, drops the copy, removes scratch and returns to idle'
   await sup.stop();
   assert.equal(fake.killed, 1);
   assert.deepEqual(calls[calls.length - 1], DROP);
-  assert.equal(rmCalls.length, 1);
+  assert.equal(scratchRms(rmCalls).length, 1);
   assert.equal(sup.status().state, 'idle');
   assert.equal(sup.status().version, null);
   assert.equal(sup.start('1.19.1001').ok, true, 'and a new one may start');
@@ -201,3 +203,16 @@ test('when the running version is not in the list the window counts from the new
   assert.equal(previewable('1.19.1029', { published, running: '0.0.1' }).ok, true);
   assert.equal(previewable('1.19.1028', { published, running: '0.0.1' }).ok, false);
 });
+
+// THE DUMP IS A FULL COPY OF THE LIVE DATABASE, sessions included (task 1004388). It is needed
+// only until the restore has read it; leaving it to the stop's cleanup meant a restart of the
+// live service (which cannot finish an async stop) left it in /tmp — found there 11 hours on.
+test('the dump file is deleted as soon as the restore has read it, before the child launches', async () => {
+  const { sup, rmCalls, fake } = rig();
+  const r = sup.start('1.19.1000');
+  await r.done;
+  const dumpRm = rmCalls.findIndex((p) => fwd(p).endsWith('/live.dump'));
+  assert.ok(dumpRm >= 0, 'the dump was never removed: ' + JSON.stringify(rmCalls));
+  assert.equal(sup.status().state, 'running');
+  assert.equal(fake.spawned.length, 1);
+});