@bongos/core 1.19.514 → 1.19.516

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',
+  );
+});