@bongos/core 1.21.167 → 1.21.169

package/tests/module_promotion.mjs

@@ -0,0 +1,290 @@
+// tests/module_promotion.mjs — the promotion gate: tester to general, and what
+// earns it (task 1003804, ADR 0344 D3; owner decisions 2026-10-23). The rule
+// (decidePromotion) is driven directly; the sweep, the author's standing, the
+// person's release and both routes run against an in-memory stand-in for the
+// four tables they read and the one they write.
+//
+// Run:  node tests/module_promotion.mjs
+
+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 DAY = 24 * 60 * 60 * 1000;
+const NOW = new Date('2026-10-23T12:00:00Z');
+const ago = (days) => new Date(NOW.getTime() - days * DAY).toISOString();
+
+// ---- an in-memory store ---------------------------------------------------
+let state;
+function fresh() {
+  state = {
+    modules: { weather: { module_key: 'weather', title: 'Weather', author_id: 42, status: 'listed' } },
+    versions: [{ id: 7, module_key: 'weather', version: '1.3.0', tarball_sha256: 'x', artifact_path: 'a', published_at: ago(3) }],
+    channels: [{ id: 1, version_id: 7, channel: 'tester', reason: 'new_version', set_by: 9, set_at: ago(3) }],
+    installs: [],
+    errors: [],
+    signals: [
+      { id: 1, version_id: 7, part: 'security', outcome: 'passed', score: null, measured_at: ago(3) },
+      { id: 2, version_id: 7, part: 'tests', outcome: 'scored', score: 100, measured_at: ago(3) },
+    ],
+  };
+  return state;
+}
+fresh();
+
+const newestRow = (vid) => state.channels.filter((c) => String(c.version_id) === String(vid))
+  .sort((a, b) => (b.set_at.localeCompare(a.set_at)) || (b.id - a.id))[0];
+
+const query = async (sql, params = []) => {
+  if (/CROSS JOIN LATERAL/.test(sql)) {
+    const [vid, limit] = params;
+    const ids = [...new Set(state.channels.map((c) => c.version_id))]
+      .filter((id) => vid == null || String(id) === String(vid)).sort((a, b) => a - b);
+    const rows = [];
+    for (const id of ids) {
+      const cur = newestRow(id);
+      if (cur.channel !== 'tester') continue;
+      const v = state.versions.find((x) => x.id === id);
+      const mine = (l) => l.filter((r) => r.version_id === id);
+      rows.push({
+        version_id: id, module_key: v.module_key, version: v.version, current_reason: cur.reason,
+        on_tester_since: mine(state.channels).filter((c) => c.channel === 'tester').map((c) => c.set_at).sort()[0],
+        clean_installs: mine(state.installs).filter((r) => r.ok).length,
+        failed_installs: mine(state.installs).filter((r) => !r.ok).length,
+        runtime_errors: mine(state.errors).reduce((n, e) => n + e.error_count, 0),
+      });
+    }
+    return { rows: rows.slice(0, limit) };
+  }
+  if (/FROM module_assessment_signals/.test(sql)) {
+    const out = new Map();
+    for (const s of [...state.signals].sort((a, b) => b.measured_at.localeCompare(a.measured_at) || b.id - a.id)) {
+      if (!params[0].includes(s.version_id)) continue;
+      const k = `${s.version_id}:${s.part}`;
+      if (!out.has(k)) out.set(k, s);
+    }
+    return { rows: [...out.values()] };
+  }
+  if (/^\s*INSERT INTO store_module_version_channels/.test(sql)) {
+    const [vid, channel, reason, setBy, fromReason] = params;
+    const cur = newestRow(vid);
+    if (!cur || cur.reason !== fromReason) return { rows: [], rowCount: 0 };
+    const id = Math.max(...state.channels.map((c) => c.id)) + 1;
+    // A later set_at than anything already there, so this row is the newest.
+    state.channels.push({ id, version_id: vid, channel, reason, set_by: setBy, set_at: new Date(NOW.getTime() + id).toISOString() });
+    return { rows: [], rowCount: 1 };
+  }
+  if (/SELECT channel, reason, set_by, set_at FROM store_module_version_channels/.test(sql)) {
+    const cur = newestRow(params[0]); return { rows: cur ? [cur] : [] };
+  }
+  if (/FROM store_modules WHERE module_key = \$1/.test(sql)) {
+    const m = state.modules[params[0]]; return { rows: m ? [m] : [] };
+  }
+  if (/FROM store_module_versions WHERE module_key = \$1 AND version = \$2/.test(sql)) {
+    return { rows: state.versions.filter((v) => v.module_key === params[0] && v.version === params[1]) };
+  }
+  return { rows: [] };
+};
+const pool = { connect: async () => ({ query, release() {} }), query };
+const poolPath = require.resolve('../src/bongos/pool.js');
+require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool } };
+
+const {
+  PROMOTE_AFTER_DAYS, EARLY_AFTER_DAYS, EARLY_CLEAN_INSTALLS, decidePromotion, sweepPromotions, readStanding, releaseHeld, start,
+} = require('../src/bongos/module-promotion.js');
+const promo = { PROMOTE_AFTER_DAYS, EARLY_AFTER_DAYS, EARLY_CLEAN_INSTALLS, decidePromotion, sweepPromotions, readStanding, releaseHeld, start };
+const buildModulesRouter = require('../src/bongos/routes/modules.js');
+
+const clean = (n) => { for (let i = 0; i < n; i++) state.installs.push({ version_id: 7, holder_ref: `p${i}`, ok: true }); };
+const current = () => newestRow(7);
+
+// ---- the rule -------------------------------------------------------------
+const ev = (over = {}) => ({
+  onTesterSince: ago(3), held: false, cleanInstalls: 0, failedInstalls: 0, runtimeErrors: 0,
+  security: { outcome: 'passed' }, tests: { outcome: 'scored', score: 100 }, ...over,
+});
+
+test('the owner numbers: 7 days, early from day 2 with 5 clean installs', () => {
+  assert.equal(promo.PROMOTE_AFTER_DAYS, 7);
+  assert.equal(promo.EARLY_AFTER_DAYS, 2);
+  assert.equal(promo.EARLY_CLEAN_INSTALLS, 5);
+});
+
+test('seven days on tester promotes, even with no tester at all', () => {
+  const d = promo.decidePromotion(ev({ onTesterSince: ago(7) }), NOW);
+  assert.equal(d.action, 'promote');
+  assert.equal(d.reason, 'promoted_after_7_days');
+  assert.equal(promo.decidePromotion(ev({ onTesterSince: ago(6.9) }), NOW).action, 'wait');
+});
+
+test('early: day 2 and 5 clean installs; not before day 2, not with 4', () => {
+  assert.equal(promo.decidePromotion(ev({ onTesterSince: ago(2), cleanInstalls: 5 }), NOW).reason, 'promoted_early_clean_installs');
+  assert.equal(promo.decidePromotion(ev({ onTesterSince: ago(1.9), cleanInstalls: 50 }), NOW).action, 'wait');
+  assert.equal(promo.decidePromotion(ev({ onTesterSince: ago(5), cleanInstalls: 4 }), NOW).action, 'wait');
+});
+
+test('any failed tester install or runtime error holds, whatever the age', () => {
+  for (const over of [{ failedInstalls: 1 }, { runtimeErrors: 1 }, { failedInstalls: 1, onTesterSince: ago(30), cleanInstalls: 99 }]) {
+    const d = promo.decidePromotion(ev(over), NOW);
+    assert.equal(d.action, 'hold');
+    assert.equal(d.reason, 'held_tester_errors');
+  }
+});
+
+test('a held version never moves on its own, even at day 30', () => {
+  const d = promo.decidePromotion(ev({ held: true, onTesterSince: ago(30) }), NOW);
+  assert.equal(d.action, 'wait');
+  assert.equal(d.reason, 'held_until_released');
+});
+
+test('security and tests (ADR 0343): moves only when both pass; never held for them', () => {
+  const old = { onTesterSince: ago(10) };
+  assert.equal(promo.decidePromotion(ev({ ...old, security: { outcome: 'failed' } }), NOW).reason, 'checks_not_passed');
+  assert.equal(promo.decidePromotion(ev({ ...old, security: null }), NOW).reason, 'checks_not_passed');
+  assert.equal(promo.decidePromotion(ev({ ...old, tests: { outcome: 'scored', score: 80 } }), NOW).reason, 'checks_not_passed');
+  assert.equal(promo.decidePromotion(ev({ ...old, tests: { outcome: 'pending' } }), NOW).reason, 'checks_not_passed');
+  assert.equal(promo.decidePromotion(ev({ ...old, tests: { outcome: 'no_data' } }), NOW).action, 'promote', 'no tests is not a fail');
+});
+
+// ---- the sweep ------------------------------------------------------------
+test('the sweep promotes early on clean installs, with a new system row', async () => {
+  fresh(); clean(5);
+  const out = await promo.sweepPromotions({ db: pool, now: NOW });
+  assert.deepEqual(out.promoted.map((p) => p.reason), ['promoted_early_clean_installs']);
+  assert.equal(current().channel, 'general');
+  assert.equal(current().set_by, null, 'the system moved it');
+  assert.equal(state.channels.length, 2, 'a move is a new row; the tester row stays');
+  const again = await promo.sweepPromotions({ db: pool, now: NOW });
+  assert.equal(again.promoted.length + again.held.length, 0, 'a general version is not swept again');
+});
+
+test('the sweep holds on an error, once, and the hold outlives day 7', async () => {
+  fresh(); clean(9);
+  state.errors.push({ version_id: 7, error_count: 2 });
+  const out = await promo.sweepPromotions({ db: pool, now: NOW });
+  assert.equal(out.held.length, 1);
+  assert.equal(current().channel, 'tester');
+  assert.equal(current().reason, 'held_tester_errors');
+  assert.equal(current().set_by, null);
+  const later = await promo.sweepPromotions({ db: pool, now: new Date(NOW.getTime() + 30 * DAY) });
+  assert.equal(later.held.length + later.promoted.length, 0, 'no second hold row, no promotion');
+  assert.equal(state.channels.length, 2);
+});
+
+test('the sweep moves an untested version at day 7 and leaves a young one', async () => {
+  fresh();
+  assert.equal((await promo.sweepPromotions({ db: pool, now: NOW })).promoted.length, 0);
+  const out = await promo.sweepPromotions({ db: pool, now: new Date(NOW.getTime() + 4 * DAY) });
+  assert.deepEqual(out.promoted.map((p) => p.reason), ['promoted_after_7_days']);
+});
+
+// ---- the author's standing ------------------------------------------------
+test('an author reads the rule and where their version stands', async () => {
+  fresh(); clean(2);
+  const s = await promo.readStanding(7, { db: pool, now: NOW });
+  assert.equal(s.channel, 'tester');
+  assert.equal(s.moved_by, '9');
+  assert.match(s.rule, /7 days/);
+  assert.match(s.rule, /2 days once 5 or more testers/);
+  assert.equal(s.next.action, 'wait');
+  assert.equal(s.next.clean_installs, 2);
+  assert.equal(s.next.days_on_tester, 3);
+  assert.equal(s.next.general_on, new Date(new Date(ago(3)).getTime() + 7 * DAY).toISOString());
+});
+
+// ---- the person's release -------------------------------------------------
+test('only a held version can be released, and the person is recorded', async () => {
+  fresh();
+  const early = await promo.releaseHeld(7, 3, { db: pool });
+  assert.equal(early.ok, false);
+  assert.equal(early.code, 'not_held');
+  state.installs.push({ version_id: 7, holder_ref: 'p', ok: false });
+  await promo.sweepPromotions({ db: pool, now: NOW });
+  const r = await promo.releaseHeld(7, 3, { db: pool });
+  assert.equal(r.ok, true);
+  assert.equal(current().channel, 'general');
+  assert.equal(current().reason, 'released_by_person');
+  assert.equal(current().set_by, 3);
+  assert.equal((await promo.releaseHeld(7, 3, { db: pool })).code, 'not_held', 'a second release is refused');
+});
+
+// ---- the routes -----------------------------------------------------------
+function handlerFor(router, method, p) {
+  const layer = router.stack.find((l) => l.route && l.route.path === p && l.route.methods[method]);
+  assert.ok(layer, `no ${method.toUpperCase()} ${p} on the router`);
+  const stack = layer.route.stack;
+  return { handle: stack[stack.length - 1].handle, depth: stack.length };
+}
+async function invoke(handle, { key = 'weather', version = '1.3.0', body = {} } = {}) {
+  const res = {
+    statusCode: 200, body: undefined,
+    json(b) { this.body = b; return this; },
+    status(c) { this.statusCode = c; return this; },
+    set() { return this; },
+    fail(code, opts, details) { const o = typeof opts === 'number' ? { status: opts, details } : (opts || {}); this.statusCode = o.status; this.body = { error: code, ...o }; return this; },
+  };
+  let nextErr = null;
+  await handle({ params: { key, version }, body, builder: { id: 3 } }, res, (err) => { nextErr = err; });
+  if (nextErr) throw nextErr;
+  return res;
+}
+const router = buildModulesRouter();
+const release = handlerFor(router, 'post', '/store/modules/:key/versions/:version/release');
+const channel = handlerFor(router, 'get', '/store/modules/:key/versions/:version/channel');
+
+test('release is gated on module.delist (owner, no new permission) and pinned', () => {
+  assert.ok(release.depth >= 3, 'requireBuilder + requirePermission sit in front of the handler');
+  const src = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/modules.js'), 'utf8');
+  assert.match(src, /router\.post\('\/store\/modules\/:key\/versions\/:version\/release', auth\.requireBuilder, auth\.requirePermission\('module\.delist'\)/);
+  const pins = fs.readFileSync(path.join(ROOT, 'src/bongos/route-rank-check.js'), 'utf8');
+  assert.match(pins, /'POST \/store\/modules\/:key\/versions\/:version\/release': 'perm:module\.delist'/);
+  const { byKey } = require('../modules/government/catalog.js');
+  assert.match(byKey('module.delist').guards, /POST \/store\/modules\/:key\/versions\/:version\/release/);
+});
+
+test('release needs a reason, refuses a version not held, and releases a held one', async () => {
+  fresh();
+  for (const body of [{}, { reason: '  ' }]) assert.equal((await invoke(release.handle, { body })).body.error, 'reason_required');
+  assert.equal((await invoke(release.handle, { body: { reason: 'r', channel: 'general' } })).statusCode, 400, 'unknown fields are refused');
+  assert.equal((await invoke(release.handle, { version: '9.9.9', body: { reason: 'r' } })).statusCode, 404);
+  const notHeld = await invoke(release.handle, { body: { reason: 'r' } });
+  assert.equal(notHeld.statusCode, 409);
+  assert.equal(notHeld.body.error, 'not_held');
+  state.errors.push({ version_id: 7, error_count: 1 });
+  await promo.sweepPromotions({ db: pool, now: NOW });
+  const ok = await invoke(release.handle, { body: { reason: 'the error was the tester\'s own config' } });
+  assert.equal(ok.statusCode, 200);
+  assert.equal(ok.body.channel, 'general');
+});
+
+test('the channel read: any signed-in builder, the standing, 404 for no version', async () => {
+  fresh();
+  assert.equal(channel.depth, 2, 'requireBuilder only — the author must be able to read it');
+  const res = await invoke(channel.handle);
+  assert.equal(res.statusCode, 200);
+  assert.equal(res.body.channel, 'tester');
+  assert.equal(res.body.module_key, 'weather');
+  assert.ok(res.body.next);
+  assert.equal((await invoke(channel.handle, { version: '2.0.0' })).statusCode, 404);
+  state.channels = [];
+  const none = await invoke(channel.handle);
+  assert.equal(none.statusCode, 404);
+  assert.equal(none.body.error, 'version_has_no_channel', 'a version with no channel row says so');
+  fresh();
+  assert.equal((await invoke(channel.handle, { key: 'Bad_Key' })).statusCode, 400);
+});
+
+test('the sweep is started by the server after listen, never by a test, and can be switched off', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'src/platform-server.js'), 'utf8');
+  assert.match(src, /require\('\.\/bongos\/module-promotion'\); startPromotionSweep\(\)/);
+  const start = src.indexOf('function startBackgroundServices');
+  const body = src.slice(start, src.indexOf('}', start));
+  assert.doesNotMatch(body, /module-promotion/);
+  assert.equal(promo.start({ env: { MODULE_PROMOTION_DISABLED: '1' } }), false);
+});

package/tests/module_upgrade_updates.mjs

@@ -24,7 +24,7 @@ const pool = {
       return {
         rows: state.versions
           .filter((v) => params[0].includes(v.module_key) && state.modules[v.module_key])
-          .map((v) => ({ ...v, status: state.modules[v.module_key].status })),
+          .map((v) => ({ channel: 'general', ...v, status: state.modules[v.module_key].status })),
       };
     }
     return { rows: [] };
@@ -236,7 +236,7 @@ test('the route is open to any signed-in builder: requireBuilder and no permissi
 test('the route answers the newest version per key, in semver order', async () => {
   const r = await ask('weather');
   assert.equal(r.statusCode, 200, JSON.stringify(r.body));
-  assert.deepEqual(r.body.latest.weather, { version: '1.10.0', core_version: '^1.2.0', status: 'listed' });
+  assert.deepEqual(r.body.latest.weather, { version: '1.10.0', core_version: '^1.2.0', status: 'listed', channel: 'general' });
   assert.equal(r.headers['Cache-Control'], 'no-store');
 });
 

package/tests/rebase_gate_set_aside.mjs

@@ -0,0 +1,73 @@
+// tests/rebase_gate_set_aside.mjs — one stuck land must not block every claim
+// (task 1004788). DB-free half: the shared predicate (rebase-gate.js), the 409
+// hint's wording, and that all three claim surfaces call the ONE predicate. The
+// real-DB half (claimTask, claimTasksBatch, validateClaimBatch end to end) is
+// cases 8-10 of tests/claim_gate_rebase.mjs.
+//
+// Run:  node tests/rebase_gate_set_aside.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const gate = require('../modules/lifecycle/rebase-gate.js');
+const { rebaseRequiredHint } = require('../modules/lifecycle/routes/claims.js');
+const { test, summary } = makeRunner();
+
+const row = (id, reason) => ({ id, title: `t${id}`, needs_rebase_reason: reason, needs_rebase_at: null });
+const GUARD = 'strand:branch_modifies_executed_code:.gitattributes,scripts/gds/git-merge-regen.js';
+
+await test('a strand parked on a server-side guard is set aside: it never gates', () => {
+  const s = gate.splitRebaseGate([row(1, GUARD)], { limit: 1 });
+  assert.equal(s.gates, false);
+  assert.deepEqual(s.gating, []);
+  assert.equal(s.waiting.length, 1);
+  assert.match(s.waiting[0].waits_on, /server-side guard/);
+});
+
+await test('an explicit waiting:<what> hold is set aside with what it waits on', () => {
+  assert.equal(gate.waitsOn('waiting:the owner'), 'the owner');
+  assert.equal(gate.waitsOn('strand:unresolvable_conflict:docs/x.json'), null);
+  assert.equal(gate.waitsOn('strand:pr_not_landed'), null);
+  assert.equal(gate.waitsOn(null), null, 'an unknown reason is the builder\'s, never silently waived');
+});
+
+await test('fixable strands gate only at the limit (default 3), not on the first', () => {
+  delete process.env.REBASE_GATE_LIMIT;
+  assert.equal(gate.REBASE_GATE_LIMIT, 3);
+  const one = [row(1, 'strand:pr_not_landed')];
+  const three = [...one, row(2, 'strand:pr_not_landed'), row(3, 'strand:unresolvable_conflict:a')];
+  assert.equal(gate.splitRebaseGate(one).gates, false);
+  assert.equal(gate.splitRebaseGate(three.slice(0, 2)).gates, false);
+  const s = gate.splitRebaseGate([...three, row(9, GUARD)]);
+  assert.equal(s.gates, true);
+  assert.deepEqual(s.gating.map((t) => t.id), [1, 2, 3], 'the waiting one never counts toward the limit');
+  const tasks = gate.rebaseRefusalTasks(s);
+  assert.deepEqual(tasks.map((t) => [t.id, !!t.waiting]), [[1, false], [2, false], [3, false], [9, true]]);
+});
+
+await test('the refusal says which tasks gate and lists the rest as waiting, not on you', () => {
+  const s = gate.splitRebaseGate([row(1, 'strand:pr_not_landed'), row(2, 'strand:pr_not_landed'), row(3, 'strand:pr_not_landed'), row(9, GUARD)]);
+  const h = rebaseRequiredHint(gate.rebaseRefusalTasks(s));
+  assert.match(h, /3 confirmed task\(s\) of yours are waiting to land and need you \(task 1, task 2, task 3\)/);
+  assert.match(h, /Waiting, not on you .*task 9 \(a server-side guard/);
+  assert.match(h, /\/strand-fix N/);
+});
+
+await test('all three claim surfaces call the ONE predicate', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/db-claims.js'), 'utf8');
+  const calls = src.match(/splitRebaseGate\(await gatingRebaseTasksForBuilder\(builderId, (client|pool)\)\)/g) || [];
+  assert.equal(calls.length, 3, 'claimTask, claimTasksBatch and validateClaimBatch');
+  for (const fn of ['async function claimTask(', 'async function claimTasksBatch(', 'async function validateClaimBatch(']) {
+    const start = src.indexOf(fn);
+    const next = src.indexOf('\nasync function ', start + 10);
+    assert.ok(src.slice(start, next < 0 ? undefined : next).includes('splitRebaseGate('), `${fn} uses the shared predicate`);
+  }
+});
+
+summary();