@bongos/core 1.20.69 → 1.20.71

package/tests/module_cli.mjs

@@ -156,14 +156,14 @@ test('gatherUpgrade: a satisfied enabled module passes; the same module disabled
   loader._reset();
 });
 
-test('cmdUpgrade: exit 0 with no modules, exit 1 when an enabled module is incompatible', () => {
+test('cmdUpgrade: exit 0 with no modules, exit 1 when an enabled module is incompatible', async () => {
   const lines = [];
   const sink = { log: (s) => lines.push(String(s)), errlog: (s) => lines.push(String(s)) };
 
-  const empty = mod.cmdUpgrade([], { ...sink, gather: () => ({ rows: [], errors: [], core: '1.0.0' }) });
+  const empty = await mod.cmdUpgrade([], { checkUpdates: async () => ({ checked: true, latest: {} }), ...sink, gather: () => ({ rows: [], errors: [], core: '1.0.0' }) });
   assert.equal(empty, 0);
 
-  const bad = mod.cmdUpgrade([], {
+  const bad = await mod.cmdUpgrade([], { checkUpdates: async () => ({ checked: true, latest: {} }),
     ...sink,
     gather: () => ({ core: '1.0.0', errors: [], rows: [{ key: 'future', version: '1.0.0', coreVersion: '^2.0.0', enabled: true, satisfied: false }] }),
   });
@@ -474,13 +474,13 @@ test('gatherUpgrade: carries each module\'s maintenance posture onto its row', (
   loader._reset();
 });
 
-test('cmdUpgrade: a DISABLED incompatible module is reported with its owner, not silently dropped', () => {
+test('cmdUpgrade: a DISABLED incompatible module is reported with its owner, not silently dropped', async () => {
   // The catalog-rot case: an accepted module ships default:false (ADR 0107 §6), so
   // every rotted catalog entry is disabled by construction. Exit stays 0 — it breaks
   // nothing at boot — but it must be visible and attributed.
   const lines = [];
   const sink = { log: (s) => lines.push(String(s)), errlog: (s) => lines.push(String(s)) };
-  const code = mod.cmdUpgrade([], {
+  const code = await mod.cmdUpgrade([], { checkUpdates: async () => ({ checked: true, latest: {} }),
     ...sink,
     gather: () => ({
       core: '2.0.0',
@@ -498,10 +498,10 @@ test('cmdUpgrade: a DISABLED incompatible module is reported with its owner, not
   assert.match(out, /maintainer Ada <ada@example\.com>/, 'the owner is named so someone can be told');
 });
 
-test('cmdUpgrade: reports an expired deprecation and modules with no declared upkeep', () => {
+test('cmdUpgrade: reports an expired deprecation and modules with no declared upkeep', async () => {
   const lines = [];
   const sink = { log: (s) => lines.push(String(s)), errlog: (s) => lines.push(String(s)) };
-  const code = mod.cmdUpgrade([], {
+  const code = await mod.cmdUpgrade([], { checkUpdates: async () => ({ checked: true, latest: {} }),
     ...sink,
     gather: () => ({
       core: '1.13.0',

package/tests/module_upgrade_updates.mjs

@@ -0,0 +1,256 @@
+// tests/module_upgrade_updates.mjs — `bongos upgrade` reports available module
+// updates beside coreVersion drift (task 1003787, ADR 0338 D1, criterion
+// wa5-module-economy). Two halves, no port and no real DB:
+//   - the CLI: cmdUpgrade against injected rows and a fake store, so one command
+//     answers "what is stale here" — and the exit code is still decided by the
+//     compatibility check alone (an incompatible ENABLED module blocks, a disabled
+//     one never does, an update never does);
+//   - the server: the real GET /store/modules/latest handler off the real router,
+//     with pool.js replaced in the require cache (the module_store_howto.mjs harness).
+//
+// Run:  node tests/module_upgrade_updates.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+// ---- the fake registry the route reads ----
+const state = { modules: {}, versions: [] };
+const pool = {
+  async query(sql, params = []) {
+    if (/FROM store_module_versions v JOIN store_modules m/.test(sql)) {
+      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 })),
+      };
+    }
+    return { rows: [] };
+  },
+};
+const poolPath = require.resolve('../src/bongos/pool.js');
+require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool: { connect: async () => ({ ...pool, release() {} }), query: pool.query } } };
+
+const buildModulesRouter = require('../src/bongos/routes/modules.js');
+const mod = require('../scripts/gds/module.js');
+
+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, names: stack.map((s) => s.name) };
+}
+
+async function invoke(handle, req) {
+  const res = {
+    statusCode: 200, body: undefined, headers: {},
+    json(b) { this.body = b; return this; },
+    status(c) { this.statusCode = c; return this; },
+    set(k, v) { this.headers[k] = v; return this; },
+    fail(code, opts) { this.statusCode = opts.status; this.body = { error: code, ...opts }; return this; },
+  };
+  let nextErr = null;
+  await handle(req, res, (err) => { nextErr = err; });
+  if (nextErr) throw nextErr;
+  return res;
+}
+
+const row = (key, version, extra = {}) => ({ key, version, coreVersion: '^1.0.0', enabled: true, satisfied: true, maintenance: { status: 'maintained' }, maintainer: 'Ada', ...extra });
+const sink = () => { const out = []; const err = []; return { out, err, log: (s) => out.push(String(s)), errlog: (s) => err.push(String(s)) }; };
+
+// ---------------------------------------------------------------------------
+// the decision (pure)
+// ---------------------------------------------------------------------------
+
+test('evaluateUpdates: only a NEWER store version is an update; equal, older and unknown are not', () => {
+  const rows = [row('weather', '1.0.0'), row('clock', '2.0.0'), row('dice', '1.5.0'), row('built-here', '0.1.0')];
+  const latest = {
+    weather: { version: '1.2.0', core_version: '^1.0.0', status: 'listed' },
+    clock: { version: '2.0.0', core_version: '^1.0.0', status: 'listed' },
+    dice: { version: '1.4.0', core_version: '^1.0.0', status: 'listed' },
+  };
+  const { updates, delisted } = mod.evaluateUpdates(rows, latest, '1.19.0');
+  assert.deepEqual(updates.map((u) => [u.key, u.installed, u.latest, u.fits]), [['weather', '1.0.0', '1.2.0', true]]);
+  assert.deepEqual(delisted, []);
+});
+
+test('evaluateUpdates: semver order, not text — 1.10.0 is newer than 1.9.0', () => {
+  const { updates } = mod.evaluateUpdates([row('weather', '1.9.0')], { weather: { version: '1.10.0', core_version: '^1.0.0', status: 'listed' } }, '1.19.0');
+  assert.equal(updates.length, 1);
+});
+
+test('evaluateUpdates: an update that needs a newer core is reported as waiting, not as runnable', () => {
+  const { updates } = mod.evaluateUpdates([row('weather', '1.0.0')], { weather: { version: '2.0.0', core_version: '^2.0.0', status: 'listed' } }, '1.19.0');
+  assert.equal(updates.length, 1);
+  assert.equal(updates[0].fits, false);
+});
+
+test('evaluateUpdates: a delisted module is reported apart, never offered as an update', () => {
+  const { updates, delisted } = mod.evaluateUpdates([row('weather', '1.0.0', { enabled: false })], { weather: { version: '1.2.0', core_version: '^1.0.0', status: 'delisted' } }, '1.19.0');
+  assert.deepEqual(updates, []);
+  assert.deepEqual(delisted.map((d) => d.key), ['weather']);
+});
+
+test('evaluateUpdates: a row with no exact version has nothing to compare against', () => {
+  const { updates } = mod.evaluateUpdates([row('weather', null)], { weather: { version: '1.2.0', core_version: '^1.0.0', status: 'listed' } }, '1.19.0');
+  assert.deepEqual(updates, []);
+});
+
+// ---------------------------------------------------------------------------
+// gatherUpdates (the store read)
+// ---------------------------------------------------------------------------
+
+test('gatherUpdates: one read for every versioned module, keys in the query string', async () => {
+  const calls = [];
+  const request = async (method, urlPath) => { calls.push([method, urlPath]); return { ok: true, status: 200, data: { latest: { weather: { version: '1.2.0' } } } }; };
+  const got = await mod.gatherUpdates([row('weather', '1.0.0'), row('clock', '2.0.0'), row('loose', null)], { request });
+  assert.deepEqual(calls, [['GET', '/store/modules/latest?keys=weather,clock']]);
+  assert.equal(got.checked, true);
+  assert.equal(got.latest.weather.version, '1.2.0');
+});
+
+test('gatherUpdates: it never acquires — no POST, so asking takes no entitlement', async () => {
+  const methods = [];
+  await mod.gatherUpdates([row('weather', '1.0.0')], { request: async (m) => { methods.push(m); return { ok: true, status: 200, data: { latest: {} } }; } });
+  assert.deepEqual(methods, ['GET']);
+});
+
+test('gatherUpdates: an unreachable store or a refusal is "not checked", never a throw', async () => {
+  const down = await mod.gatherUpdates([row('weather', '1.0.0')], { request: async () => { throw new Error('ECONNREFUSED'); } });
+  assert.equal(down.checked, false);
+  assert.match(down.reason, /could not be reached/);
+  const refused = await mod.gatherUpdates([row('weather', '1.0.0')], { request: async () => ({ ok: false, status: 401, data: { error: { message: 'session expired' } } }) });
+  assert.equal(refused.checked, false);
+  assert.match(refused.reason, /session expired/);
+});
+
+test('gatherUpdates: nothing versioned means nothing to ask — no store call at all', async () => {
+  const got = await mod.gatherUpdates([row('loose', null)], { request: async () => { throw new Error('must not be called'); } });
+  assert.deepEqual(got, { checked: true, latest: {} });
+});
+
+// ---------------------------------------------------------------------------
+// cmdUpgrade — one report, the old exit-code asymmetry intact
+// ---------------------------------------------------------------------------
+
+const storeSays = (latest) => async () => ({ checked: true, latest });
+
+test('cmdUpgrade: lists an available update beside the compatibility rows, and still exits 0', async () => {
+  const s = sink();
+  const code = await mod.cmdUpgrade([], {
+    ...s,
+    gather: () => ({ core: '1.19.0', errors: [], rows: [row('weather', '1.0.0')] }),
+    checkUpdates: storeSays({ weather: { version: '1.2.0', core_version: '^1.0.0', status: 'listed' } }),
+  });
+  assert.equal(code, 0, 'an update is news, never a refusal');
+  const out = s.out.join('\n');
+  assert.match(out, /✓ weather/, 'the compatibility row is still there');
+  assert.match(out, /Module updates \(from the store\)/);
+  assert.match(out, /weather\s+1\.0\.0 → 1\.2\.0\s+— run `bongos module update weather`/);
+});
+
+test('cmdUpgrade: an incompatible ENABLED module still refuses, with the updates reported too', async () => {
+  const s = sink();
+  const code = await mod.cmdUpgrade([], {
+    ...s,
+    gather: () => ({ core: '2.0.0', errors: [], rows: [row('weather', '1.0.0', { coreVersion: '^1.0.0', satisfied: false })] }),
+    checkUpdates: storeSays({ weather: { version: '2.0.0', core_version: '^2.0.0', status: 'listed' } }),
+  });
+  assert.equal(code, 1, 'the block is unchanged');
+  assert.match(s.err.join('\n'), /REFUSING: 1 enabled module/);
+  assert.match(s.out.join('\n'), /weather\s+1\.0\.0 → 2\.0\.0\s+— run `bongos module update weather`/, 'and the way out is named: the newer version fits this core');
+});
+
+test('cmdUpgrade: an incompatible DISABLED module never blocks, update or not', async () => {
+  const s = sink();
+  const code = await mod.cmdUpgrade([], {
+    ...s,
+    gather: () => ({ core: '2.0.0', errors: [], rows: [row('weather', '1.0.0', { enabled: false, satisfied: false })] }),
+    checkUpdates: storeSays({ weather: { version: '1.5.0', core_version: '^1.0.0', status: 'listed' } }),
+  });
+  assert.equal(code, 0);
+  assert.match(s.out.join('\n'), /needs core \^1\.0\.0; this core is 2\.0\.0, so it waits until the core moves/);
+});
+
+test('cmdUpgrade: nothing newer says so in one line', async () => {
+  const s = sink();
+  await mod.cmdUpgrade([], { ...s, gather: () => ({ core: '1.19.0', errors: [], rows: [row('weather', '1.2.0')] }), checkUpdates: storeSays({ weather: { version: '1.2.0', core_version: '^1.0.0', status: 'listed' } }) });
+  assert.match(s.out.join('\n'), /every installed store module is on its newest version/);
+});
+
+test('cmdUpgrade: a delisted installed module is flagged', async () => {
+  const s = sink();
+  await mod.cmdUpgrade([], { ...s, gather: () => ({ core: '1.19.0', errors: [], rows: [row('weather', '1.2.0')] }), checkUpdates: storeSays({ weather: { version: '1.2.0', core_version: '^1.0.0', status: 'delisted' } }) });
+  assert.match(s.err.join('\n'), /weather.*delisted in the store: it keeps working, but no further versions will come/);
+});
+
+test('cmdUpgrade: an unreachable store costs the update list, never the pre-check or its exit code', async () => {
+  const s = sink();
+  const code = await mod.cmdUpgrade([], { ...s, gather: () => ({ core: '1.19.0', errors: [], rows: [row('weather', '1.0.0')] }), checkUpdates: async () => ({ checked: false, reason: 'no Bongos session — run `bongos setup` first' }) });
+  assert.equal(code, 0);
+  const out = s.out.join('\n');
+  assert.match(out, /not checked — no Bongos session/);
+  assert.match(out, /OK — every enabled module satisfies core 1\.19\.0/);
+});
+
+test('cmdUpgrade --no-store: the store is not asked at all', async () => {
+  const s = sink();
+  const code = await mod.cmdUpgrade(['--no-store'], { ...s, gather: () => ({ core: '1.19.0', errors: [], rows: [row('weather', '1.0.0')] }), checkUpdates: async () => { throw new Error('must not be called'); } });
+  assert.equal(code, 0);
+  assert.doesNotMatch(s.out.join('\n'), /Module updates/);
+});
+
+test('gatherUpgrade rows carry the installed version, so the store can be compared against', () => {
+  const data = mod.gatherUpgrade({ env: {}, neutral: {}, instance: {} });
+  const versioned = data.rows.filter((r) => r.version);
+  assert.ok(versioned.length > 0, 'the core modules declare a version');
+  for (const r of versioned) assert.equal(typeof r.version, 'string');
+});
+
+// ---------------------------------------------------------------------------
+// GET /store/modules/latest — the server half
+// ---------------------------------------------------------------------------
+
+const router = buildModulesRouter();
+const latestRoute = handlerFor(router, 'get', '/store/modules/latest');
+const ask = (keys) => invoke(latestRoute.handle, { query: keys == null ? {} : { keys }, builder: { id: 7 } });
+
+state.modules = {
+  weather: { module_key: 'weather', status: 'listed' },
+  gone: { module_key: 'gone', status: 'delisted' },
+};
+state.versions = [
+  { module_key: 'weather', version: '1.9.0', core_version: '^1.0.0' },
+  { module_key: 'weather', version: '1.10.0', core_version: '^1.2.0' },
+  { module_key: 'weather', version: '1.2.0', core_version: '^1.0.0' },
+  { module_key: 'gone', version: '0.3.0', core_version: '^1.0.0' },
+];
+
+test('the route is open to any signed-in builder: requireBuilder and no permission gate', () => {
+  assert.deepEqual(latestRoute.names.slice(0, 1), ['requireBuilder']);
+  assert.equal(latestRoute.names.length, 2, 'builder gate, then the handler');
+});
+
+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.equal(r.headers['Cache-Control'], 'no-store');
+});
+
+test('the route still answers a delisted module, with its status; an unknown key is absent', async () => {
+  const r = await ask('weather,gone,nope');
+  assert.equal(r.body.latest.gone.status, 'delisted');
+  assert.equal('nope' in r.body.latest, false);
+});
+
+test('the route refuses a missing, malformed or oversized key list', async () => {
+  assert.equal((await ask(null)).statusCode, 400);
+  assert.equal((await ask('')).statusCode, 400);
+  assert.equal((await ask('Not_A_Key')).statusCode, 400);
+  assert.equal((await ask('../etc')).statusCode, 400);
+  const many = Array.from({ length: 201 }, (_, i) => `m-${i}`).join(',');
+  assert.equal((await ask(many)).statusCode, 400);
+});