@bongos/core 1.21.82 → 1.21.84

package/tests/wizard_ship_mode.mjs

@@ -0,0 +1,187 @@
+// tests/wizard_ship_mode.mjs — the project-creation wizard asks how finished work ships,
+// and the new project is born with that answer (task 1004629, ADR 0369).
+//
+// Pinned here, end to end:
+//   1. the wizard's review has a Shipping row: Auto first and checked, one plain sentence
+//      each, "you can change it later", and the create request carries ship_mode;
+//   2. the create route accepts only auto|manual and stamps it, write-once, on the row it
+//      just made (modules/provisioning/birth.js);
+//   3. the stamp rides the new instance's web.env as <PREFIX>_SHIP_MODE, which
+//      src/branding.js maps onto the server-only founding.shipMode;
+//   4. the instance's resolveShipMode reads it as a CHOSEN mode while no project_settings
+//      row exists, and a row (the settings page, the CLI) always wins.
+//
+// Run:  node --test tests/wizard_ship_mode.mjs
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HUB = fs.readFileSync(path.join(ROOT, 'modules', 'public-landing', 'public', 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+
+// Destructured from literal relative paths, so the dead-code scan (knip) can trace them.
+const { SHIP_MODE_KEY, stampShipMode, BIRTH_COMPANION_ENV } = require('../modules/provisioning/birth.js');
+const { resolveShipMode } = require('../src/bongos/project-settings.js');
+const provisioning = require('../modules/provisioning/provisioning.js');
+const poolMod = require('../src/bongos/pool.js');
+
+function slice(start, end, what) {
+  const a = HUB.indexOf(start), b = HUB.indexOf(end, a);
+  assert.ok(a > 0 && b > a, `slice for ${what} not found — a rename moved it`);
+  return HUB.slice(a, b);
+}
+
+// ── 1. the wizard ──────────────────────────────────────────────────────────
+
+test('the review asks how finished work ships: Auto (recommended) first and checked, Manual second', () => {
+  const row = slice('<div class="setRow" data-row="ship">', '<div class="hint" id="h-review">', 'the ship row');
+  const auto = row.indexOf('value="auto"'), manual = row.indexOf('value="manual"');
+  assert.ok(auto > 0 && manual > auto, 'Auto comes first');
+  assert.match(row, /<input type="radio" name="shipMode" value="auto" checked>/, 'and is the pick until the founder says otherwise');
+  assert.match(row, /<b>Auto \(recommended\)<\/b>/);
+  assert.match(row, /<b>Manual<\/b>/);
+  assert.match(row, /ships finished work on its own/, 'one plain sentence for Auto');
+  assert.match(row, /waits for you to approve it/, 'and one for Manual');
+});
+
+test('the row says what was picked and that it can be changed later; an older draft reads Auto', () => {
+  const fns = slice('    /* the ship row (task 1004629)', '    var ROWS = [', 'the ship choice');
+  const ctx = { state: {} };
+  vm.runInNewContext(`${fns}; this.choice = shipModeChoice;`, ctx);
+  assert.equal(ctx.choice(), 'auto', 'a draft with no shipMode is Auto');
+  ctx.state.shipMode = 'manual';
+  assert.equal(ctx.choice(), 'manual');
+  ctx.state.shipMode = 'yolo';
+  assert.equal(ctx.choice(), 'auto', 'anything but manual is Auto');
+  const say = slice("      if (key === 'ship') {", "      return { v: '', s: '' };", "the ship row's words");
+  assert.match(say, /v: 'Auto \(recommended\)'/);
+  assert.match(say, /v: 'Manual'/);
+  assert.equal((say.match(/You can change this later in your project’s settings\./g) || []).length, 2, 'both say it can be changed later');
+});
+
+test('the draft remembers the pick, and Create sends it as ship_mode', () => {
+  assert.match(HUB, /appPlatform: 'later', shipMode: 'auto', physics: null/, 'the initial state starts on Auto');
+  assert.equal((HUB.match(/shipMode: 'auto'/g) || []).length, 2, 'and so does the reset (the two literals stay equal)');
+  assert.match(HUB, /if \(type === 'change' && ev\.target\.name === 'shipMode'\) \{ state\.shipMode = ev\.target\.value; saveDraft\(\); \}/);
+  assert.match(HUB, /ship_mode: shipModeChoice\(\)\n {10}\}\)/, 'the create request carries it');
+});
+
+// ── 2. the stamp ───────────────────────────────────────────────────────────
+
+test('stampShipMode writes a valid answer once, and writes nothing for none or junk', async () => {
+  const seen = [];
+  const db = { query: async (sql, params) => { seen.push({ sql, params }); return { rows: [] }; } };
+  assert.equal(await stampShipMode(db, 41, 'manual'), true);
+  assert.equal(seen.length, 1);
+  assert.match(seen[0].sql, /UPDATE provisioning_instances/);
+  assert.match(seen[0].sql, /WHERE id = \$1 AND NOT \(COALESCE\(settings, '\{\}'::jsonb\) \? \$2::text\)/, 'write-once');
+  assert.deepEqual(seen[0].params, [41, SHIP_MODE_KEY, 'manual']);
+  assert.equal(await stampShipMode(db, 41, undefined), false, 'no answer: the project asks at its first ship instead');
+  assert.equal(await stampShipMode(db, 41, 'yolo'), false);
+  assert.equal(seen.length, 1, 'nothing written for either');
+});
+
+test('the stamp is not a setting: no client patch can write it and it never projects as one', () => {
+  assert.ok(!(SHIP_MODE_KEY in provisioning.SETTINGS_VOCAB));
+  assert.ok(!(SHIP_MODE_KEY in provisioning.PLANET_VOCAB));
+  assert.ok(!(SHIP_MODE_KEY in provisioning.effectiveSettings({ settings: { [SHIP_MODE_KEY]: 'manual' } })));
+});
+
+// ── 3. the transport ───────────────────────────────────────────────────────
+
+test('the stamped mode rides web.env as SHIP_MODE; an unstamped or mangled row sends empty', () => {
+  assert.equal(typeof BIRTH_COMPANION_ENV.SHIP_MODE, 'function');
+  assert.equal(provisioning.settingsEnvVars({ settings: { ship_mode: 'manual' } }, 'X').X_SHIP_MODE, 'manual');
+  assert.equal(provisioning.settingsEnvVars({ settings: { ship_mode: 'auto' } }, 'X').X_SHIP_MODE, 'auto');
+  assert.equal(provisioning.settingsEnvVars({ settings: {} }, 'X').X_SHIP_MODE, '');
+  assert.equal(provisioning.settingsEnvVars({ settings: { ship_mode: 'sometimes' } }, 'X').X_SHIP_MODE, '');
+});
+
+test('the instance reads it into founding.shipMode, and never publishes it to the client', () => {
+  const read = (env) => JSON.parse(execFileSync(process.execPath, ['-e',
+    "const b=require('./src/branding.js');const r=(b.branding||b)();console.log(JSON.stringify({m:(r.founding||{}).shipMode||null,c:'founding' in b.clientBranding(r)}))"],
+    { cwd: ROOT, encoding: 'utf8', env: { ...process.env, ...env } }));
+  assert.deepEqual(read({ CLOUDBONGOS_SHIP_MODE: 'manual' }), { m: 'manual', c: false });
+  assert.deepEqual(read({ CLOUDBONGOS_SHIP_MODE: '' }), { m: null, c: false }, 'the empty line every other instance carries is nothing');
+});
+
+// ── 4. the instance's own resolver ─────────────────────────────────────────
+
+async function withRow(value, fn) {
+  const pool = poolMod.pool;
+  const saved = pool.query;
+  pool.query = async () => ({ rows: value == null ? [] : [{ key: 'ship.mode', value, updated_at: null, updated_by: 1 }] });
+  try { return await fn(); } finally { pool.query = saved; }
+}
+const packWith = (shipMode) => () => ({ founding: { shipMode } });
+
+test('a wizard pick counts as chosen while no setting row exists', async () => {
+  const r = await withRow(null, () => resolveShipMode({ branding: packWith('manual') }));
+  assert.deepEqual(r, { mode: 'manual', source: 'wizard', chosen: true, invalid: null });
+  const auto = await withRow(null, () => resolveShipMode({ branding: packWith('auto') }));
+  assert.equal(auto.chosen, true, 'picking Auto in the wizard is a choice, so the first ship does not ask again');
+});
+
+test('the settings page (a row) always wins over the wizard; junk or no pick is the default, unchosen', async () => {
+  const r = await withRow('auto', () => resolveShipMode({ branding: packWith('manual') }));
+  assert.equal(r.mode, 'auto');
+  assert.equal(r.source, 'project_settings');
+  assert.deepEqual(await withRow(null, () => resolveShipMode({ branding: packWith('') })), { mode: 'auto', source: 'default', chosen: false, invalid: null });
+  assert.deepEqual(await withRow(null, () => resolveShipMode({ branding: packWith('maybe') })), { mode: 'auto', source: 'default', chosen: false, invalid: null });
+  assert.equal((await withRow(null, () => resolveShipMode({ branding: () => { throw new Error('no pack'); } }))).source, 'default', 'a pack that cannot be read is no pick');
+});
+
+// ── 2b. the create route ───────────────────────────────────────────────────
+
+const api = require('../src/module-api.js');
+const birth = require('../modules/provisioning/birth.js');
+provisioning.getInstanceBySlug = async () => null;
+provisioning.getInstanceByDomain = async () => null;
+birth.stampBirth = async () => {};
+provisioning.createInstance = async (_db, args) => ({
+  instance: { id: 41, owner_builder_id: 7, slug: args.slug, status: 'requested', hosting_shape: 'byo-host', detail: {} }, created: true,
+});
+provisioning.enqueueIntent = async (_db, _id, action) => ({ intent: { id: 9, action, state: 'pending' }, created: true });
+provisioning.getOpenIntent = async () => null;
+provisioning.recordEvent = async () => {};
+api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner' }; next(); };
+const stamped = [];
+api.pool.query = async (sql, params) => { if (/jsonb_build_object/.test(sql) && params[1] === SHIP_MODE_KEY) stamped.push(params[2]); return { rows: [] }; };
+
+const express = require('express');
+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, message: opts && opts.message } });
+  };
+  next();
+});
+app.use('/api/bongos', require('../modules/provisioning/routes/provisioning.js')());
+const server = app.listen(0);
+after(() => server.close());
+async function create(body) {
+  await new Promise((r) => (server.listening ? r() : server.once('listening', r)));
+  const res = await fetch(`http://127.0.0.1:${server.address().port}/api/bongos/provisioning/instances`, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+  });
+  return { status: res.status, body: await res.json() };
+}
+
+test('the create route stamps the pick on the new row, and refuses anything but auto|manual', async () => {
+  stamped.length = 0;
+  const r = await create({ slug: 'ships-by-hand', hosting_shape: 'byo-host', ship_mode: 'manual' });
+  assert.equal(r.status, 201, JSON.stringify(r.body));
+  assert.deepEqual(stamped, ['manual']);
+  stamped.length = 0;
+  assert.equal((await create({ slug: 'no-pick', hosting_shape: 'byo-host' })).status, 201, 'the answer is optional (an API caller)');
+  assert.deepEqual(stamped, [], 'and none is stamped when none is given');
+  assert.equal((await create({ slug: 'bad-pick', hosting_shape: 'byo-host', ship_mode: 'sometimes' })).status, 400);
+});

package/tests/wizard_six_screens.mjs

@@ -81,10 +81,10 @@ test('planet words survive only as the light touch: the fork and the alive momen
   assert.match(SCRIPT, /if \(inst\.last_verified_up\) \{\n\s*\/\*[^*]*\*\/\n\s*\$\('done-h'\)\.textContent =/, 'said only once the project has answered (Live is a verified claim)');
 });
 
-test('the review cannot be skipped: seven rows, one Edit each, and one Continue that confirms them all (task 1004550)', () => {
+test('the review cannot be skipped: eight rows, one Edit each, and one Continue that confirms them all (task 1004550)', () => {
   const p = panel('panel-review');
   const rows = [...p.matchAll(/<div class="setRow" data-row="([a-z]+)">/g)].map((m) => m[1]);
-  assert.deepEqual(rows, ['code', 'address', 'app', 'extras', 'team', 'rewards', 'run']);
+  assert.deepEqual(rows, ['code', 'address', 'app', 'extras', 'team', 'rewards', 'run', 'ship']);
   for (const key of rows) {
     const r = (p.match(new RegExp(`<div class="setRow" data-row="${key}">[\\s\\S]*?<span class="acts">[^\\n]*\\n`)) || [''])[0];
     assert.match(r, /<span class="acts"><button type="button" class="rowChg" data-row-chg aria-expanded="false">Edit<\/button><\/span>/, `${key}: one Edit, nothing else`);
@@ -110,6 +110,7 @@ test('nothing the old steps could do is lost: their controls are moved whole int
   has('extras', ['modQ', 'modCards', 'modWhy', 'modCoreNote']);
   has('team', ['physTeam', 'physStartN', 'physExpected', 'teamCards']);
   has('run', ['physSuite']);
+  has('ship', ['shipOpts']);
   for (const id of ['physCountry', 'physRegion', 'physAges', 'physIntent', 'physForms', 'physHaveEntity', 'checksStop', 'physStopMsg', 'physFromAccount']) {
     assert.match(panel('panel-checks'), new RegExp(`id="${id}"`), `the quick checks host #${id}`);
   }