@bongos/core 1.25.3 → 1.25.5

package/tests/provisioning_update_subscription_route.mjs

@@ -0,0 +1,141 @@
+// tests/provisioning_update_subscription_route.mjs
+//
+// Task 1004150 (ADR 0325 decision 5): POST /provisioning/instances/:id/update-subscription — the
+// operator's switch for "does the nightly sweep move this instance on its own".
+//
+// The load-bearing assertions:
+//   • the fleet permission gate is what stands in front of it (an ungated route could arm any
+//     instance for unattended upgrades)
+//   • the body is strict and boolean: a string, a missing field or an extra field is a 400 and
+//     nothing is written
+//   • a real change writes the column and one audit event; a no-op writes and records nothing
+//   • an unknown id is a 404
+//
+// DB-free: the pool and data access are stubbed on the cached module objects over a real mounted
+// router (the provisioning_repo_private_route.mjs pattern).
+//
+// Run:  node tests/provisioning_update_subscription_route.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import http from 'node:http';
+
+const require = createRequire(import.meta.url);
+const provisioning = require('../modules/provisioning/provisioning.js');
+const api = require('../src/module-api.js');
+
+let passed = 0, failed = 0;
+async function ta(name, fn) {
+  try { await fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+let instance = null;
+let writes = [];
+let events = [];
+let permissionAsked = null;
+let allowed = true;
+provisioning.getInstanceById = async (_db, id) => (instance ? { ...instance, id } : null);
+provisioning.recordEvent = async (_db, e) => { events.push(e); };
+api.pool.query = async (sql, params) => { writes.push({ sql, params }); return { rows: [] }; };
+api.requireBuilder = (req, _res, next) => { req.builder = { id: 5, github_login: 'op', rank: 'metic' }; next(); };
+api.requirePermission = (atom) => {
+  permissionAsked = atom;
+  return (req, res, next) => (allowed ? next() : res.status(403).json({ error: { code: 'forbidden' } }));
+};
+api.logger = () => ({ error() {}, warn() {}, info() {}, debug() {} });
+
+const express = require('express');
+const buildRouter = require('../modules/provisioning/routes/update-subscription.js');
+const app = express();
+app.use(express.json());
+app.use((_req, res, next) => {
+  res.fail = (code, opts) => {
+    const status = typeof opts === 'number' ? opts : (opts && opts.status) || 400;
+    res.status(status).json({ error: { code, ...(typeof opts === 'object' ? opts : {}) } });
+  };
+  next();
+});
+app.use('/api/bongos', buildRouter());
+
+const server = app.listen(0);
+await new Promise((r) => server.once('listening', r));
+const base = `http://127.0.0.1:${server.address().port}/api/bongos`;
+
+function post(path, body) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify(body);
+    const req = http.request(`${base}${path}`, { method: 'POST', headers: { 'Content-Type': 'application/json' } }, (res) => {
+      let d = '';
+      res.on('data', (c) => { d += c; });
+      res.on('end', () => { let j = null; try { j = JSON.parse(d); } catch { /* non-JSON */ } resolve({ status: res.statusCode, body: j, raw: d }); });
+    });
+    req.on('error', reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+function reset(patch = {}) {
+  instance = { owner_builder_id: 7, slug: 'spike', update_subscribed: false, ...patch };
+  writes = []; events = []; allowed = true;
+}
+const URL_18 = '/provisioning/instances/18/update-subscription';
+
+console.log('POST /provisioning/instances/:id/update-subscription:');
+
+await ta('is gated on the fleet permission, and a caller without it writes nothing', async () => {
+  reset(); allowed = false;
+  const r = await post(URL_18, { subscribed: true });
+  assert.equal(permissionAsked, 'provisioning.fleet.manage');
+  assert.equal(r.status, 403, r.raw);
+  assert.equal(writes.length, 0);
+});
+
+await ta('arming writes the column once and records one audit event', async () => {
+  reset();
+  const r = await post(URL_18, { subscribed: true });
+  assert.equal(r.status, 200, r.raw);
+  assert.deepEqual(r.body, { ok: true, update_subscribed: true, previous: false, changed: true });
+  assert.equal(writes.length, 1);
+  assert.match(writes[0].sql, /SET update_subscribed = \$2/);
+  assert.deepEqual(writes[0].params, [18, true]);
+  assert.equal(events.length, 1);
+  assert.equal(events[0].event, 'update-subscription-changed');
+});
+
+await ta('a no-op (already in that state) writes nothing and records nothing', async () => {
+  reset({ update_subscribed: true });
+  const r = await post(URL_18, { subscribed: true });
+  assert.equal(r.status, 200, r.raw);
+  assert.equal(r.body.changed, false);
+  assert.equal(writes.length, 0);
+  assert.equal(events.length, 0);
+});
+
+await ta('disarming is symmetric', async () => {
+  reset({ update_subscribed: true });
+  const r = await post(URL_18, { subscribed: false });
+  assert.equal(r.body.update_subscribed, false);
+  assert.deepEqual(writes[0].params, [18, false]);
+});
+
+await ta('a non-boolean, a missing field and an extra field are all 400 with nothing written', async () => {
+  for (const body of [{ subscribed: 'yes' }, {}, { subscribed: true, channel: 'minor' }]) {
+    reset();
+    const r = await post(URL_18, body);
+    assert.equal(r.status, 400, `${JSON.stringify(body)} → ${r.raw}`);
+    assert.equal(writes.length, 0);
+  }
+});
+
+await ta('an unknown id is 404', async () => {
+  reset(); instance = null;
+  const r = await post(URL_18, { subscribed: true });
+  assert.equal(r.status, 404, r.raw);
+  assert.equal(r.body.error.code, 'instance_not_found');
+});
+
+server.close();
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/tests/update_channel_db.mjs

@@ -129,3 +129,27 @@ test('update-sweep.js reads the DB from its own env, never an entry env (which n
   // A core too old to carry the reader must keep the roster rather than crash the sweep.
   assert.match(src, /typeof channel\.readDbChannels === 'function'/);
 });
+
+// ---- task 1004150: the subscription roster lives on the project row too ----
+
+const subDb = (subs) => ({ ok: true, channels: new Map(), subscribed: new Map(Object.entries(subs)) });
+
+test('subscribed on the row: reported as deploy-sourced; a file-only entry is kept as an override', () => {
+  const { instances, unreachable } = uc.applyDbSubscriptions([entry(), entry({ slug: 'charter' })], subDb({ cloudbongos: true, charter: false }));
+  assert.equal(instances[0].subscribedSource, uc.CHANNEL_SOURCE_DEPLOY);
+  assert.equal(instances[1].subscribedSource, uc.CHANNEL_SOURCE_ROSTER);
+  assert.match(instances[1].subscribedNote, /roster file only/);
+  assert.deepEqual(unreachable, []);
+});
+
+test('subscribed on the row with no roster entry: surfaced as unreachable, never dropped', () => {
+  const { instances, unreachable } = uc.applyDbSubscriptions([], subDb({ mercury: true, venus: false }));
+  assert.equal(instances.length, 0);
+  assert.deepEqual(unreachable, ['mercury']);
+});
+
+test('database unreachable: the roster alone decides and nothing is reported unreachable', () => {
+  const { instances, unreachable } = uc.applyDbSubscriptions([entry()], { ok: false, reason: 'psql not found' });
+  assert.equal(instances.length, 1);
+  assert.deepEqual(unreachable, []);
+});