@bongos/core 1.21.145 → 1.21.147

package/tests/upgrade_hold.mjs

@@ -0,0 +1,207 @@
+// tests/upgrade_hold.mjs — a failed core move is told to the project's OWN owner, in their
+// own hall (task 1004730).
+//
+// The move is `bongos upgrade` run against THIS project's database; its auto-rollback
+// writes `rolled_back: <why> (attempted A → B, restored A)` to this project's own
+// core_upgrades ledger. src/bongos/upgrade-hold.js reads that row back, and GET
+// /software-update (Settings → Software update) and GET /core-update (the banner) carry
+// it as `held`: which version was tried, that it was rolled back, and that the project is
+// still on its old version and working. A newer release clears it.
+//
+// Run:  node tests/upgrade_hold.mjs
+
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { upgradeHold, readUpgradeHold } = require('../src/bongos/upgrade-hold.js');
+
+let passed = 0;
+let failed = 0;
+const t = async (name, fn) => {
+  try { await fn(); passed += 1; console.log(`  PASS  ${name}`); }
+  catch (e) { failed += 1; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+};
+
+// The row upgrade.js rollback() writes, byte for byte in its note.
+const rollbackRow = (why = 'migrate failed', from = '1.21.20', to = '1.21.115') => ({
+  from_version: from, to_version: to, applied_at: '2026-10-14T09:00:00.000Z',
+  note: `rolled_back: ${why} (attempted ${from} → ${to}, restored ${from})`,
+});
+const okRow = { from_version: '1.21.20', to_version: '1.21.69', applied_at: '2026-10-15T09:00:00.000Z', note: null };
+
+console.log('upgrade hold, read by the project itself (task 1004730)');
+
+await t('a rolled-back move is held, in plain words: tried, rolled back, still on the old one and working', () => {
+  const h = upgradeHold({ rows: [rollbackRow()], running: '1.21.20', offered: '1.21.115' });
+  assert.equal(h.version, '1.21.115');
+  assert.equal(h.still_on, '1.21.20');
+  assert.equal(h.reason, 'migrate');
+  assert.equal(h.retry, 'next_release');
+  assert.equal(h.at, '2026-10-14T09:00:00.000Z');
+  assert.match(h.message, /Version 1\.21\.115 was tried on this project/);
+  assert.match(h.message, /rolled back/);
+  assert.match(h.message, /still on 1\.21\.20 and working/);
+  assert.match(h.message, /database changes/, 'the reason, in words an owner reads');
+  assert.doesNotMatch(h.message, /[—–]/, 'voice rule: no dashes in copy');
+});
+
+await t('each step that can fail reads as its own plain reason; an unknown one as the general line', () => {
+  const cases = [['npm install failed', 'npm_install', /downloaded and installed/, 'later'],
+    ['restart failed', 'restart', /did not start/, 'next_release'],
+    ['health check failed after restart', 'health', /did not answer properly/, 'next_release'],
+    ['served core version did not change (still 1.21.20, expected 1.21.115)', 'health', /did not answer properly/, 'next_release'],
+    ['integrity pin mismatch', 'integrity_pin', /did not match/, 'next_release'],
+    ['something nobody wrote down', 'unknown', /did not pass its checks/, 'next_release']];
+  for (const [why, reason, words, retry] of cases) {
+    const h = upgradeHold({ rows: [rollbackRow(why)], running: '1.21.20', offered: '1.21.115' });
+    assert.equal(h.reason, reason, why);
+    assert.match(h.message, words, why);
+    assert.equal(h.retry, retry, why);
+  }
+  assert.match(upgradeHold({ rows: [rollbackRow('npm install failed')], running: '1.21.20', offered: null }).message, /may be tried again later/);
+});
+
+await t('a newer release clears the hold: it may carry the fix', () => {
+  assert.equal(upgradeHold({ rows: [rollbackRow()], running: '1.21.20', offered: '1.21.116' }), null);
+});
+
+await t('the hold stands when nothing, or nothing newer, is offered', () => {
+  assert.ok(upgradeHold({ rows: [rollbackRow()], running: '1.21.20', offered: null }));
+  assert.ok(upgradeHold({ rows: [rollbackRow()], running: '1.21.20', offered: '1.21.100' }));
+});
+
+await t('a later move that landed ends it (only the newest ledger row counts)', () => {
+  assert.equal(upgradeHold({ rows: [okRow, rollbackRow()], running: '1.21.69', offered: null }), null);
+});
+
+await t('"still on it and working" is said only by the version the rollback restored', () => {
+  assert.equal(upgradeHold({ rows: [rollbackRow()], running: '1.21.30', offered: null }), null);
+  assert.equal(upgradeHold({ rows: [rollbackRow()], running: null, offered: null }), null);
+});
+
+await t('rows this file did not write are no hold', () => {
+  for (const rows of [[], null, [okRow], [{ ...rollbackRow(), note: 'rolled_back: whatever' }], [{ ...rollbackRow(), to_version: 'x' }]]) {
+    assert.equal(upgradeHold({ rows, running: '1.21.20', offered: null }), null, JSON.stringify(rows));
+  }
+});
+
+await t('readUpgradeHold reads the newest ledger row, and a failed read is no hold, never a throw', async () => {
+  let sql = '';
+  const pool = { query: async (s) => { sql = s; return { rows: [rollbackRow()] }; } };
+  const h = await readUpgradeHold({ running: '1.21.20', offered: '1.21.115', pool });
+  assert.equal(h.version, '1.21.115');
+  assert.match(sql, /FROM core_upgrades/);
+  assert.match(sql, /ORDER BY applied_at DESC/);
+  assert.equal(await readUpgradeHold({ running: '1.21.20', pool: { query: async () => { throw new Error('no table'); } } }), null);
+});
+
+// ---- the two reads the hall makes ----------------------------------------------------
+
+async function drive(p, deps) {
+  const auth = require('../src/bongos/auth.js');
+  const saved = { b: auth.requireBuilder, p: auth.requirePermission };
+  auth.requireBuilder = (req, _res, next) => { req.builder = { id: '7' }; next(); };
+  auth.requirePermission = () => (_req, _res, next) => next();
+  const build = require('../src/bongos/routes/core-update.js');
+  const express = require('express');
+  const app = express();
+  try {
+    app.use(build({ askDeps: () => ({ hub: null, getSetting: async () => null }), canUpdate: async () => true,
+      doorInputs: () => ({ provisioning: false, idp: null, hubUpgradeUrl: 'https://cloudbongos.com/deploy?project=toast' }), ...deps }));
+  } finally { auth.requireBuilder = saved.b; auth.requirePermission = saved.p; }
+  const server = app.listen(0);
+  await new Promise((r) => server.once('listening', r));
+  try {
+    const res = await fetch(`http://127.0.0.1:${server.address().port}${p}`);
+    return { status: res.status, body: await res.json() };
+  } finally { server.close(); }
+}
+const ledger = { query: async () => ({ rows: [rollbackRow()] }) };
+const realHold = (a) => readUpgradeHold({ ...a, pool: ledger });
+
+await t('GET /software-update carries the hold and its plain reason (Settings → Software update)', async () => {
+  let asked = null;
+  const r = await drive('/software-update', {
+    softwareUpdate: async ({ running }) => ({ reading: 'ok', running, offered: '1.21.115' }),
+    upgradeHold: (a) => { asked = a; return realHold({ ...a, running: '1.21.20' }); },
+  });
+  assert.equal(r.status, 200);
+  assert.equal(asked.offered, '1.21.115', 'the hold is judged against what this project is offered');
+  assert.equal(r.body.held.version, '1.21.115');
+  assert.match(r.body.held.message, /still on 1\.21\.20 and working/);
+});
+
+await t('GET /software-update: a newer offer means no hold, and an unread registry still shows it', async () => {
+  const newer = await drive('/software-update', { softwareUpdate: async () => ({ reading: 'ok', offered: '1.21.116' }),
+    upgradeHold: (a) => realHold({ ...a, running: '1.21.20' }) });
+  assert.equal(newer.body.held, null);
+  const unread = await drive('/software-update', { softwareUpdate: async () => ({ reading: 'no_answer', offered: null }),
+    upgradeHold: (a) => realHold({ ...a, running: '1.21.20' }) });
+  assert.equal(unread.body.held.version, '1.21.115');
+});
+
+await t('GET /core-update carries it too, for the banner', async () => {
+  const r = await drive('/core-update', {
+    coreUpdate: async () => ({ reading: 'ok', running: '1.21.20', latest: '1.21.115', behind: true }),
+    selfChannel: async () => null,
+    upgradeHold: (a) => realHold({ ...a, running: '1.21.20' }),
+  });
+  assert.equal(r.status, 200);
+  assert.equal(r.body.held.version, '1.21.115');
+});
+
+await t('a hold read that throws never fails either read', async () => {
+  const boom = async () => { throw new Error('boom'); };
+  const a = await drive('/software-update', { softwareUpdate: async () => ({ reading: 'ok', offered: null }), upgradeHold: boom });
+  assert.equal(a.status, 200);
+  assert.equal(a.body.held, null);
+  const b = await drive('/core-update', { coreUpdate: async () => ({ reading: 'ok', behind: false }), selfChannel: async () => null, upgradeHold: boom });
+  assert.equal(b.status, 200);
+  assert.equal(b.body.held, null);
+});
+
+// ---- the Software update panel draws it ----------------------------------------------
+
+const PANEL_SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/settings-software-update.js'), 'utf8');
+const escapeHtml = (s) => String(s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+
+async function panel(data) {
+  const el = () => ({ hidden: true, textContent: '', _html: '', dataset: {}, set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; }, querySelectorAll: () => [] });
+  const els = new Map([['software-update-scroll', el()], ['su-body', el()], ['su-note', el()], ['settings-groups', el()]]);
+  els.get('settings-groups').dataset.active = 'update';
+  const windowObj = {
+    BongosClient: { createClient: () => ({ request: async () => ({ ok: true, status: 200, data }) }) },
+    OTB: { escapeHtml }, location: { assign() {} },
+  };
+  const sandbox = { window: windowObj, document: { getElementById: (id) => els.get(id) || null, addEventListener() {} }, console, setTimeout, Date, Math, URL, Promise, String, Number };
+  vm.createContext(sandbox);
+  vm.runInContext(PANEL_SRC, sandbox, { filename: 'settings-software-update.js' });
+  for (let i = 0; i < 10; i++) await new Promise((r) => setTimeout(r, 0));
+  return els.get('su-body').innerHTML;
+}
+
+await t('the panel says it in the owner\'s words, and does not offer the held version as "Update ready"', async () => {
+  const held = upgradeHold({ rows: [rollbackRow()], running: '1.21.20', offered: '1.21.115' });
+  const html = await panel({ ok: true, update: { reading: 'ok', running: '1.21.20', offered: '1.21.115', whats_new: null },
+    door: { kind: 'hub', url: 'https://cloudbongos.com/deploy?project=toast' }, can_update: true, ask: {}, held });
+  assert.ok(html.includes(escapeHtml(held.message)), 'the plain message is drawn');
+  assert.match(html, /On hold/);
+  assert.doesNotMatch(html, /Update ready/);
+  assert.doesNotMatch(html, /id="su-update"/, 'no button to take the version that just failed');
+});
+
+await t('no hold, no change: the panel draws exactly what it did before', async () => {
+  const data = { ok: true, update: { reading: 'ok', running: '1.21.20', offered: '1.21.116', whats_new: null }, door: { kind: 'cli', url: null }, can_update: true, ask: {} };
+  const html = await panel({ ...data, held: null });
+  assert.match(html, /Update ready/);
+  assert.equal(html, await panel(data));
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);