@bongos/core 1.19.515 → 1.19.516

package/tests/provisioning_module_selection.mjs

@@ -0,0 +1,286 @@
+// tests/provisioning_module_selection.mjs
+//
+// Where the creation picker's chosen module set LANDS (BV1.R20, task 1002339;
+// goal 1000046 criterion `proj-module-select`, migration provisioning_014).
+//
+// R19 declared the bundles and served them; this is the half that stores an
+// answer. The whole contract is three-valued and every test below exists to keep
+// one of the three legible:
+//
+//   absent  the owner skipped the picker  → the column stores NULL and the READ
+//           resolves the declared type's starter bundle, so a skip yields exactly
+//           the set the panel preselected.
+//   []      the owner said "none of them" → stored as an empty array, and it
+//           stays empty. A NOT NULL DEFAULT '[]' column could never have said this.
+//   [...]   what they picked.
+//
+// Three layers, mirroring tests/provisioning_onboard_mode.mjs beside it:
+//   • createInstance  — what actually reaches the INSERT params
+//   • POST /instances — validation (loud, never a silent drop) + threading
+//   • publicInstance  — what a reader gets back, resolved rather than raw
+//
+// DB-free: the pool is a recording fake and the data-access fns the route needs
+// are stubbed on the cached module object. No network beyond a loopback listener.
+//
+// Run:  node --test --test-reporter=tap tests/provisioning_module_selection.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import http from 'node:http';
+// ESM named imports off the CJS module on purpose — knip cannot trace a
+// createRequire() import, so these would read as dead exports (the repo's knip
+// learning; tests/provisioning_starter_bundles.mjs does the same).
+import { ALWAYS_ON_CORE, bundleForProjectType } from '../modules/provisioning/starter-bundles.js';
+
+const require = createRequire(import.meta.url);
+const provisioning = require('../modules/provisioning/provisioning.js');
+
+let passed = 0, failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+async function ta(name, fn) {
+  try { await fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+// ── createInstance: what reaches the column ─────────────────────────────────
+// A recording pool: assert the STORED value, not just the returned row. A
+// normalization bug that only shows up in the column is the one that would
+// mislabel a project's modules forever.
+function recordingDb(returnRow = {}) {
+  const calls = [];
+  return {
+    calls,
+    query: async (text, params) => {
+      calls.push({ text, params });
+      return { rows: [{ id: 1, owner_builder_id: 7, slug: 'demo', ...returnRow }] };
+    },
+  };
+}
+
+function insertParams(db) {
+  const insert = db.calls.find((c) => /INSERT INTO provisioning_instances/i.test(c.text));
+  assert.ok(insert, 'issued an INSERT');
+  assert.match(insert.text, /modules/, 'the modules column is in the INSERT');
+  return insert.params;
+}
+
+await ta('createInstance: a chosen set is stored as a jsonb array, in catalog order', async () => {
+  // Arrange
+  const db = recordingDb();
+
+  // Act
+  await provisioning.createInstance(db, {
+    ownerBuilderId: 7, slug: 'demo', hostingShape: 'standalone', type: 'game',
+    modules: ['discord', 'agents'],
+  });
+
+  // Assert
+  const params = insertParams(db);
+  assert.ok(params.includes(JSON.stringify(['agents', 'discord'])),
+    `the normalized selection reached the INSERT (got ${JSON.stringify(params)})`);
+});
+
+await ta('createInstance: NO answer stores NULL — the skip has to stay readable as a skip', async () => {
+  // If this stored '[]' the row would claim the owner turned every module off,
+  // and the read-time bundle fallback could never fire again.
+  for (const modules of [undefined, null, 'discord', 42]) {
+    const db = recordingDb();
+    await provisioning.createInstance(db, {
+      ownerBuilderId: 7, slug: 'demo', hostingShape: 'standalone', type: 'game', modules,
+    });
+    const params = insertParams(db);
+    assert.equal(params[13], null, `modules=${JSON.stringify(modules)} stores NULL, not an empty list`);
+  }
+});
+
+await ta('createInstance: an explicit empty answer is stored, and is NOT the same as absent', async () => {
+  const db = recordingDb();
+  await provisioning.createInstance(db, {
+    ownerBuilderId: 7, slug: 'demo', hostingShape: 'standalone', type: 'game', modules: [],
+  });
+  assert.equal(insertParams(db)[13], '[]', 'the owner said none of them, and the row says so');
+});
+
+await ta('createInstance: the always-on core is never written into the selection', async () => {
+  // The core is the floor every project gets, not a pick. Storing it would make
+  // the column disagree with ALWAYS_ON_CORE the day a manifest flips its default.
+  const db = recordingDb();
+  await provisioning.createInstance(db, {
+    ownerBuilderId: 7, slug: 'demo', hostingShape: 'standalone', modules: ['memory', 'discord', 'provisioning'],
+  });
+  assert.equal(insertParams(db)[13], JSON.stringify(['discord']));
+});
+
+// ── publicInstance: what a reader gets back ────────────────────────────────
+
+t('publicInstance: a skipped picker reads as the declared type\'s bundle', () => {
+  // Arrange — the row a skip writes
+  const row = { id: 1, slug: 'demo', status: 'requested', type: 'game', modules: null, detail: {} };
+
+  // Act
+  const out = provisioning.publicInstance(row);
+
+  // Assert — resolved, never raw: no caller should have to re-derive the rule,
+  // which is the one way two surfaces come to name different modules.
+  assert.deepEqual(out.modules.selected, bundleForProjectType('game').bundle);
+  assert.deepEqual(out.modules.core, [...ALWAYS_ON_CORE]);
+  assert.equal(out.modules.source, 'bundle');
+});
+
+t('publicInstance: a chosen set reads back as chosen, empty included', () => {
+  const chosen = provisioning.publicInstance({ id: 1, type: 'game', modules: ['agents'], detail: {} });
+  assert.deepEqual(chosen.modules.selected, ['agents']);
+  assert.equal(chosen.modules.source, 'chosen');
+
+  const none = provisioning.publicInstance({ id: 1, type: 'game', modules: [], detail: {} });
+  assert.deepEqual(none.modules.selected, []);
+  assert.equal(none.modules.source, 'chosen', 'a project that switched the bundle off does not get it back');
+});
+
+t('publicInstance: a row written before provisioning_014 reads as the bundle, not as an error', () => {
+  // Every existing row has no `modules` key at all. Nullable + read-time
+  // resolution is what makes the migration a no-op for them.
+  const out = provisioning.publicInstance({ id: 1, slug: 'old', status: 'active', type: 'research', detail: {} });
+  assert.deepEqual(out.modules.selected, ['agents']);
+  assert.equal(out.modules.source, 'bundle');
+});
+
+// ── POST /instances, over a real mounted router ────────────────────────────
+
+let lastCreateArgs = null;
+let existingRow = null;
+provisioning.getInstanceBySlug = async () => existingRow;
+provisioning.getInstanceByDomain = async () => null;
+provisioning.getInstanceById = async () => null;
+provisioning.createInstance = async (_db, args) => {
+  lastCreateArgs = args;
+  return existingRow
+    ? { instance: existingRow, created: false }
+    : { instance: { id: 41, owner_builder_id: 7, slug: args.slug, status: 'requested', hosting_shape: 'standalone', type: args.type || null, detail: {} }, created: true };
+};
+provisioning.enqueueIntent = async (_db, id, action) => ({ intent: { id: 9, action, state: 'pending' }, created: true });
+provisioning.getOpenIntent = async () => null;
+provisioning.recordEvent = async () => {};
+
+const api = require('../src/module-api.js');
+api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner' }; next(); };
+
+const express = require('express');
+const provisioningRoutes = require('../modules/provisioning/routes/provisioning.js');
+const app = express();
+app.use(express.json());
+app.use((_req, res, next) => {
+  res.fail = (code, opts, details) => {
+    const status = typeof opts === 'number' ? opts : (opts && opts.status) || 400;
+    res.status(status).json({ error: { code, ...(details || (typeof opts === 'object' ? opts : {})) } });
+  };
+  next();
+});
+app.use('/api/bongos', provisioningRoutes());
+
+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', 'Content-Length': Buffer.byteLength(payload) },
+    }, (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.end(payload);
+  });
+}
+
+await ta('POST /instances: the picker\'s ids ride the create request through to storage', async () => {
+  // Arrange
+  lastCreateArgs = null; existingRow = null;
+
+  // Act — the body the wizard files
+  const res = await post('/provisioning/instances', {
+    slug: 'mercury', hosting_shape: 'standalone', type: 'game', modules: ['dev-box', 'discord'],
+  });
+
+  // Assert
+  assert.equal(res.status, 201, `expected 201, got ${res.status} ${res.raw}`);
+  assert.deepEqual(lastCreateArgs && lastCreateArgs.modules, ['dev-box', 'discord']);
+});
+
+await ta('POST /instances: an omitted modules key is still a valid create — skipping is supported, not an error', async () => {
+  lastCreateArgs = null; existingRow = null;
+  const res = await post('/provisioning/instances', { slug: 'mercury', hosting_shape: 'standalone', type: 'game' });
+  assert.equal(res.status, 201, `expected 201, got ${res.status} ${res.raw}`);
+  assert.equal(lastCreateArgs.modules, undefined, 'nothing is invented on the owner\'s behalf');
+  // …and the receipt already carries the set they will actually get.
+  assert.deepEqual(res.body.instance.modules.selected, bundleForProjectType('game').bundle);
+  assert.equal(res.body.instance.modules.source, 'bundle');
+});
+
+await ta('POST /instances: an explicit empty selection is accepted as an answer', async () => {
+  lastCreateArgs = null; existingRow = null;
+  const res = await post('/provisioning/instances', { slug: 'mercury', hosting_shape: 'standalone', type: 'game', modules: [] });
+  assert.equal(res.status, 201, `expected 201, got ${res.status} ${res.raw}`);
+  assert.deepEqual(lastCreateArgs.modules, []);
+});
+
+await ta('POST /instances: an unknown module is REFUSED and named, never silently dropped', async () => {
+  // The normalizer would drop it on the way to storage and the caller would be
+  // told nothing — the exact silent-drop failure the strict validator exists to
+  // prevent, and the reason badProjectDetail was written beside this.
+  existingRow = null;
+  const res = await post('/provisioning/instances', {
+    slug: 'mercury', hosting_shape: 'standalone', modules: ['discrod'],
+  });
+  assert.equal(res.status, 400, res.raw);
+  assert.equal(res.body.error.code, 'bad_modules');
+  assert.match(res.body.error.message, /discrod/, 'the message names what was wrong');
+  assert.match(res.body.error.message, /agents/, 'and what the choices are');
+});
+
+await ta('POST /instances: naming an always-on module is refused with the reason, not the generic miss', async () => {
+  existingRow = null;
+  const res = await post('/provisioning/instances', {
+    slug: 'mercury', hosting_shape: 'standalone', modules: ['memory'],
+  });
+  assert.equal(res.status, 400, res.raw);
+  assert.equal(res.body.error.code, 'bad_modules');
+  assert.match(res.body.error.message, /always on/i, '"memory" exists — it just was never a choice');
+});
+
+await ta('POST /instances: modules must be an array of strings', async () => {
+  existingRow = null;
+  const notArray = await post('/provisioning/instances', { slug: 'mercury', hosting_shape: 'standalone', modules: 'discord' });
+  assert.equal(notArray.status, 400, notArray.raw);
+  assert.equal(notArray.body.error.code, 'validation_failed');
+
+  const notStrings = await post('/provisioning/instances', { slug: 'mercury', hosting_shape: 'standalone', modules: [7] });
+  assert.equal(notStrings.status, 400, notStrings.raw);
+  assert.equal(notStrings.body.error.code, 'validation_failed');
+});
+
+await ta('POST /instances: a re-request never changes an existing project\'s modules — and SAYS so', async () => {
+  // Same honesty as type_ignored (task 1002772). There is no mutation route yet
+  // (R23, task 1002342 is "add modules later"), so the receipt does not name one.
+  existingRow = { id: 41, owner_builder_id: 7, slug: 'mercury', status: 'active', type: 'game', modules: ['agents'], detail: {} };
+  const res = await post('/provisioning/instances', {
+    slug: 'mercury', hosting_shape: 'standalone', modules: ['discord'],
+  });
+  assert.equal(res.status, 200, res.raw);
+  assert.ok(res.body.modules_ignored, 'the dropped answer is reported, not swallowed');
+  assert.match(res.body.modules_ignored.hint, /never changes/);
+  assert.deepEqual(res.body.instance.modules.selected, ['agents'], 'and the stored answer is what reads back');
+  existingRow = null;
+});
+
+server.close();
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/provisioning_starter_bundles.mjs

@@ -34,10 +34,13 @@ import { createRequire } from 'node:module';
 // the knip ratchet (see the repo's knip learning).
 import {
   ALWAYS_ON_CORE,
+  OPTIONAL_MODULES,
   STARTER_BUNDLES,
   HUB_ONLY_MODULES,
   bundleForProjectType,
   allStarterBundles,
+  normalizeModuleSelection,
+  effectiveModules,
 } from '../modules/provisioning/starter-bundles.js';
 
 const require = createRequire(import.meta.url);
@@ -266,3 +269,131 @@ test('the route never reaches the database — the bundles are a declaration, no
   const res = await get('/api/bongos/provisioning/starter-bundles');
   assert.equal(res.status, 200);
 });
+
+// ── the opt-in catalog + the selection rules (BV1.R20, task 1002339) ─────────
+
+test('the opt-in catalog declared for the picker IS the on-disk opt-in set', () => {
+  // Arrange — the manifests are the catalog; OPTIONAL_MODULES is the declaration
+  // the picker renders. This is the same link the bundle<->catalog tests above
+  // make, applied to the choices: a new default:false module cannot ship without
+  // owner-facing copy, and a declared choice cannot outlive its module.
+  const onDisk = manifestsOnDisk();
+  const optInOnDisk = [...onDisk.values()]
+    .filter((m) => m.default !== true && !HUB_ONLY_MODULES.includes(m.key))
+    .map((m) => m.key)
+    .sort();
+
+  // Act
+  const declared = OPTIONAL_MODULES.map((m) => m.key).sort();
+
+  // Assert
+  assert.deepEqual(declared, optInOnDisk,
+    'the picker\'s catalog has drifted from the manifests — a module was added, removed, or flipped its default');
+});
+
+test('every opt-in module carries owner-facing copy, and no module jargon rides along', () => {
+  for (const row of OPTIONAL_MODULES) {
+    assert.ok(row.label && row.label.length <= 40, `"${row.key}" needs a short label`);
+    assert.ok(row.summary && row.summary.length > 20, `"${row.key}" needs a real one-line summary`);
+    // The owner choosing here has met none of these modules; a manifest sentence
+    // ("Mirror only, never authority (ADR 0033)") is true and unusable.
+    assert.doesNotMatch(`${row.label} ${row.summary}`, /\bADR\b|\bjsonb\b|\bAPI\b|\bwebhook\b|_/i,
+      `"${row.key}" reads like a manifest, not like a choice`);
+  }
+});
+
+test('every module a bundle preselects is a row the picker can actually render', () => {
+  // A preselect with no catalog row would light up nothing — the panel would
+  // silently ship a choice the owner cannot see or switch off.
+  const offered = OPTIONAL_MODULES.map((m) => m.key);
+  for (const [type, bundle] of Object.entries(STARTER_BUNDLES)) {
+    for (const key of bundle.modules) {
+      assert.ok(offered.includes(key), `bundle "${type}" preselects "${key}", which the picker does not offer`);
+    }
+  }
+});
+
+test('normalizeModuleSelection: absent is null, an empty answer is [], and order is the catalog\'s', () => {
+  // Arrange + Act + Assert — the three-valued contract the nullable column exists for
+  assert.equal(normalizeModuleSelection(undefined), null, 'never answered');
+  assert.equal(normalizeModuleSelection(null), null, 'never answered');
+  assert.equal(normalizeModuleSelection('discord'), null, 'a non-array is not an answer');
+  assert.deepEqual(normalizeModuleSelection([]), [], 'the owner said none — a real answer');
+  // catalog order, not the caller's
+  assert.deepEqual(normalizeModuleSelection(['discord', 'agents']), ['agents', 'discord']);
+  assert.deepEqual(normalizeModuleSelection(['discord', 'discord']), ['discord'], 'deduped');
+});
+
+test('normalizeModuleSelection drops what was never a choice — always-on, hub-only, unknown', () => {
+  assert.deepEqual(normalizeModuleSelection(['discord', 'memory']), ['discord'], 'always-on is the floor, not a pick');
+  assert.deepEqual(normalizeModuleSelection(['provisioning']), [], 'the control plane is not a project module');
+  assert.deepEqual(normalizeModuleSelection(['nope', 42, null]), [], 'nothing is invented from junk');
+});
+
+test('effectiveModules: a skipped picker yields exactly the declared type\'s bundle', () => {
+  // Arrange — the row a skip writes: type declared, modules NULL
+  const row = { type: 'game', modules: null };
+
+  // Act
+  const eff = effectiveModules(row);
+
+  // Assert — the preselect and the fallback are the SAME declaration, which is
+  // what makes "skip = what the panel showed you" true rather than a promise.
+  assert.deepEqual(eff.selected, bundleForProjectType('game').bundle);
+  assert.deepEqual(eff.modules, bundleForProjectType('game').modules);
+  assert.equal(eff.source, 'bundle', 'and a reader can tell nobody answered');
+  assert.deepEqual(eff.core, [...ALWAYS_ON_CORE]);
+});
+
+test('effectiveModules: an answered picker wins over the bundle, including "none of them"', () => {
+  assert.deepEqual(effectiveModules({ type: 'game', modules: ['agents'] }).selected, ['agents']);
+  assert.equal(effectiveModules({ type: 'game', modules: ['agents'] }).source, 'chosen');
+  // the case a NOT NULL DEFAULT '[]' column could never have expressed
+  const none = effectiveModules({ type: 'game', modules: [] });
+  assert.deepEqual(none.selected, [], 'the owner switched the bundle off, and it stays off');
+  assert.deepEqual(none.modules, [...ALWAYS_ON_CORE]);
+  assert.equal(none.source, 'chosen');
+});
+
+test('effectiveModules: an undeclared type resolves to the core, never a guess', () => {
+  for (const row of [{ type: null, modules: null }, { type: 'not-sure', modules: null }, {}]) {
+    const eff = effectiveModules(row);
+    assert.deepEqual(eff.selected, [], `${JSON.stringify(row)} preselects nothing`);
+    assert.deepEqual(eff.modules, [...ALWAYS_ON_CORE]);
+  }
+});
+
+test('GET /provisioning/starter-bundles carries the opt-in catalog the picker renders', async () => {
+  // Act
+  const res = await get('/api/bongos/provisioning/starter-bundles');
+
+  // Assert — one read gives the picker both halves: what is preselected, and
+  // what may be chosen. A second round trip is what lets them disagree.
+  assert.equal(res.status, 200, res.raw);
+  assert.deepEqual(res.body.optional, OPTIONAL_MODULES.map((m) => ({ ...m })));
+  for (const row of res.body.optional) {
+    assert.deepEqual(Object.keys(row).sort(), ['key', 'label', 'summary']);
+  }
+});
+
+test('the design kit\'s stub fixture is the same payload this route serves', () => {
+  // modules/ui-design/kit/serve.js answers the picker's read with a hand-written
+  // fixture (the stub imports no module, by design — see modules/public-landing/
+  // CLAUDE.md's "the kit's stub is not the server" trap). This is the pin that
+  // stops the picture the kit renders from drifting away from the real payload:
+  // task 1003352 shipped a body the real route would have 400'd on, past 47
+  // green probes and a clean render, because nothing compared the two.
+  const stub = fs.readFileSync(path.join(fileURLToPath(new URL('..', import.meta.url)), 'modules/ui-design/kit/serve.js'), 'utf8');
+  const src = (stub.match(/const STARTER_BUNDLES_FIXTURE = (\{[\s\S]*?\n\};)/) || [, ''])[1];
+  assert.ok(src, 'the fixture is extractable');
+  // eslint-disable-next-line no-new-func -- reading a literal out of our own repo file
+  const fixture = new Function(`return ${src.replace(/;$/, '')}`)();
+
+  assert.deepEqual(fixture.core, [...ALWAYS_ON_CORE], 'the core the panel counts');
+  assert.deepEqual(fixture.optional, OPTIONAL_MODULES.map((m) => ({ ...m })), 'the catalog the panel renders');
+  assert.deepEqual(
+    fixture.bundles.map((b) => ({ type: b.type, bundle: b.bundle })),
+    allStarterBundles().map((b) => ({ type: b.type, bundle: b.bundle })),
+    'and what each type preselects',
+  );
+});