@bongos/core 1.19.989 → 1.19.991

package/tests/text_fit.mjs

@@ -0,0 +1,91 @@
+// tests/text_fit.mjs — measured-width text fitting, EXECUTED (task 1004200; moved
+// out of goal-forest-lib.js into its own file by task 1004204 so the goal map
+// and the goal forest share one copy).
+//
+// text-fit.js is pure — the caller hands it `measure` — so these run the real
+// code against a proportional fake where no fixed character count can fit.
+//
+// Run:  node tests/text_fit.mjs
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const FILE = path.join(ROOT, 'modules/hall-ui/public/text-fit.js');
+const L = require(FILE);
+
+const { test, summary } = makeRunner();
+
+// ---- fitting a line to its box (task 1004200) ---------------------------------------
+
+// A proportional fake: wide capitals cost three times a narrow letter, so any
+// character budget that fits one title overflows the other.
+const WIDTHS = { W: 12, M: 11, i: 3, '…': 8, '🚀': 14 };
+const measure = (s) => Array.from(s).reduce((w, c) => w + (WIDTHS[c] ?? 6), 0);
+
+await test('fitText leaves a title that fits untouched', () => {
+  assert.equal(L.fitText('#7 Fix', 136, measure), '#7 Fix');
+});
+
+await test('fitText cuts to the MEASURED width, so wide glyphs keep fewer characters than narrow ones', () => {
+  const wide = L.fitText('W'.repeat(40), 136, measure);
+  const narrow = L.fitText('i'.repeat(80), 136, measure);
+  for (const s of [wide, narrow]) {
+    assert.ok(measure(s) <= 136, `${s} measures ${measure(s)}, past the box`);
+    assert.ok(s.endsWith('…'), 'a cut title says it was cut');
+  }
+  assert.ok(Array.from(narrow).length > 3 * Array.from(wide).length, 'no fixed character count could produce both');
+  assert.equal(wide, 'W'.repeat(10) + '…', 'the LONGEST prefix that fits: 10 W + … = 128px, 11 would be 140px');
+});
+
+await test('fitText never ends on a dangling space and never splits an emoji', () => {
+  const spaced = L.fitText('ab cd ef gh ij kl mn op qr', 62, measure);
+  assert.doesNotMatch(spaced, /\s…$/);
+  const emoji = L.fitText('🚀'.repeat(30), 60, measure);
+  assert.equal(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])/.test(emoji), false, 'no lone high surrogate');
+});
+
+await test('fitText returns a bare ellipsis when not even one character fits', () => {
+  assert.equal(L.fitText('WWW', 10, measure), '…');
+});
+
+await test('fitLines keeps a short title on one line, whole', () => {
+  assert.deepEqual(L.fitLines('#7 Fix', 136, 2, measure), ['#7 Fix']);
+});
+
+await test('fitLines wraps at a space, and a second line that fits is left whole', () => {
+  assert.deepEqual(L.fitLines('aaaa bbbb cccc dddd', 60, 2, measure), ['aaaa bbbb', 'cccc dddd']);
+  assert.deepEqual(L.fitLines('a   b\n c', 60, 2, measure), ['a b c'], 'runs of whitespace read as one space');
+});
+
+await test('fitLines ellipsises the LAST line when the title outruns every line, and no line overflows', () => {
+  const lines = L.fitLines('BV1.R26 — Real governance: the constitution becomes enforceable at last', 136, 2, measure);
+  assert.equal(lines.length, 2);
+  for (const l of lines) assert.ok(measure(l) <= 136, `"${l}" measures ${measure(l)}`);
+  assert.ok(lines[1].endsWith('…'));
+  assert.ok(!lines[0].endsWith('…'), 'only the last line is cut');
+});
+
+await test('fitLines breaks a word wider than a whole line instead of overflowing, and always finishes', () => {
+  const lines = L.fitLines('W'.repeat(40), 136, 2, measure);
+  assert.deepEqual(lines, ['W'.repeat(11), 'W'.repeat(10) + '…']);
+  assert.ok(L.fitLines('WWW', 5, 2, measure).length <= 2, 'a box narrower than one glyph still terminates');
+});
+
+await test('fitLines with one line is fitText', () => {
+  const t = 'Move the remaining hall pages onto the kit';
+  assert.deepEqual(L.fitLines(t, 90, 1, measure), [L.fitText(t, 90, measure)]);
+});
+
+// ---- purity -----------------------------------------------------------------------
+
+await test('the helper is pure: no DOM, no fetch — the caller measures', () => {
+  const src = fs.readFileSync(FILE, 'utf8').replace(/^\s*\/\/.*$/gm, '');
+  assert.equal(/\bdocument\b|\bfetch\b|\bwindow\b|getComputedTextLength/.test(src.replace(/root\.OTBTextFit/, '')), false);
+});
+
+summary();

package/tests/upgrade_artist_gate.mjs

@@ -0,0 +1,144 @@
+// tests/upgrade_artist_gate.mjs — the artist gate holds the pin on the UPGRADE
+// path too (task 1004205; ADR 0241).
+//
+// go-live.js consulted the gate; the vendored `upgrade.js --from` this instance
+// actually moves its pin with did not, so an open review held nothing. These
+// pin the gate reader against a fake instance, and runUpgrade refusing BEFORE
+// anything moves — with a downgrade (rolling back) never held.
+//
+// Run:  node tests/upgrade_artist_gate.mjs
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { makeRunner } from './helpers.mjs';
+import { checkArtistGate } from '../scripts/gds/upgrade-artist-gate.js';
+
+const require = createRequire(import.meta.url);
+const u = require('../scripts/gds/upgrade.js');
+const { test, summary } = makeRunner();
+
+// A fake instance: answers GET <origin>/api/bongos/artist-gate with `status` + `body`.
+function instance(status, body) {
+  const asked = [];
+  const fetchImpl = async (url, init) => {
+    asked.push({ url, method: init && init.method });
+    return { status, ok: status >= 200 && status < 300, json: async () => { if (body === undefined) throw new Error('not json'); return body; } };
+  };
+  return { asked, fetchImpl };
+}
+const HOLD = {
+  ok: true, mode: 'strict', holds: true, reviews: [{ id: '1004199' }],
+  halt: { code: 'ARTIST_REVIEW_UNRESOLVED', message: '1 unresolved artist review hold this deploy', detail: 'Held by task 1004199. Two ways out.' },
+};
+
+// ---- the reader ---------------------------------------------------------------
+
+await test('it asks the instance being upgraded, at the ORIGIN of --health-url', async () => {
+  const i = instance(200, { ok: true, mode: 'strict', holds: false, reviews: [], halt: null });
+  const r = await checkArtistGate({ healthUrl: 'http://127.0.0.1:3000/api/bongos/healthz' }, { fetchImpl: i.fetchImpl });
+  assert.deepEqual(i.asked, [{ url: 'http://127.0.0.1:3000/api/bongos/artist-gate', method: 'GET' }]);
+  assert.deepEqual(r, { halts: [], notes: [] }, 'strict with nothing open holds nothing');
+});
+
+await test('an open review on a strict project HALTS, naming the review and the way out', async () => {
+  const r = await checkArtistGate({ healthUrl: 'https://cloudbongos.com/api/bongos/healthz' }, { fetchImpl: instance(200, HOLD).fetchImpl });
+  assert.equal(r.halts.length, 1);
+  assert.equal(r.halts[0].code, 'ARTIST_REVIEW_UNRESOLVED');
+  assert.match(r.halts[0].detail, /1004199/);
+});
+
+await test('advisory and off hold nothing', async () => {
+  for (const mode of ['advisory', 'off']) {
+    const r = await checkArtistGate({ healthUrl: 'http://x/h' }, { fetchImpl: instance(200, { mode, holds: false, reviews: [], halt: null }).fetchImpl });
+    assert.deepEqual(r.halts, [], mode);
+  }
+});
+
+await test('a gate that is THERE and broken halts; one that cannot be read at all is a note', async () => {
+  assert.equal((await checkArtistGate({ healthUrl: 'http://x/h' }, { fetchImpl: instance(500, {}).fetchImpl })).halts[0].code, 'ARTIST_GATE_UNREADABLE');
+  for (const [status, body] of [[404, {}], [200, undefined], [200, { hello: 'an SPA page' }]]) {
+    const r = await checkArtistGate({ healthUrl: 'http://x/h' }, { fetchImpl: instance(status, body).fetchImpl });
+    assert.deepEqual(r.halts, [], `${status} → no halt`);
+    assert.equal(r.notes[0].code, 'ARTIST_GATE_UNREAD', `${status} → said out loud, never read as "nothing holds" silently`);
+  }
+  const down = await checkArtistGate({ healthUrl: 'http://x/h' }, { fetchImpl: async () => { throw new Error('ECONNREFUSED'); } });
+  assert.equal(down.notes[0].code, 'ARTIST_GATE_UNREAD');
+});
+
+await test('with no --health-url there is nothing to ask — a note, never a silent pass', async () => {
+  for (const healthUrl of [undefined, 'not a url']) {
+    const r = await checkArtistGate({ healthUrl }, { fetchImpl: async () => { throw new Error('must not be called'); } });
+    assert.deepEqual(r.halts, []);
+    assert.equal(r.notes[0].code, 'ARTIST_GATE_UNREAD');
+  }
+});
+
+// ---- runUpgrade -----------------------------------------------------------------
+
+function consumer(version = '1.14.1') {
+  const dir = mkdtempSync(join(tmpdir(), 'otb-upgrade-gate-'));
+  writeFileSync(join(dir, 'package.json'), JSON.stringify({
+    name: 'c', version: '0.1.0', dependencies: { '@bongos/core': `file:vendor/bongos-core-${version}.tgz` }, scripts: { migrate: 'true', start: 'true' },
+  }, null, 2) + '\n');
+  mkdirSync(join(dir, 'node_modules', '@bongos', 'core'), { recursive: true });
+  writeFileSync(join(dir, 'node_modules', '@bongos', 'core', 'package.json'), JSON.stringify({ name: '@bongos/core', version }) + '\n');
+  return dir;
+}
+function tarball(version) {
+  const src = mkdtempSync(join(tmpdir(), 'src-'));
+  writeFileSync(join(src, `bongos-core-${version}.tgz`), 'TGZ');
+  return join(src, `bongos-core-${version}.tgz`);
+}
+const run = (calls) => (cmd, args) => { calls.push(`${cmd} ${(args || []).join(' ')}`); return cmd === 'git' ? { status: 0, stdout: '' } : { status: 0 }; };
+const holding = async () => ({ halts: [{ code: 'ARTIST_REVIEW_UNRESOLVED', message: '1 unresolved artist review hold this deploy', detail: 'Held by task 1004199.' }], notes: [] });
+
+await test('runUpgrade REFUSES a held pin before anything moves — --force included', async () => {
+  for (const force of [false, true]) {
+    const dir = consumer();
+    const calls = [];
+    const res = await u.runUpgrade({ to: '1.15.0', from: tarball('1.15.0'), instance: dir, force, skipMigrate: true },
+      { log: () => {}, err: () => {}, run: run(calls), checkArtistGate: holding });
+    assert.equal(res.ok, false);
+    assert.equal(res.artistGate, true);
+    assert.match(res.error, /unresolved artist review/);
+    assert.match(res.error, /1004199/, 'names the review');
+    assert.equal(u.readPinnedCoreVersion(dir), '1.14.1', 'the pin never moved');
+    assert.ok(!calls.some((c) => c.startsWith('npm')), 'nothing installed');
+  }
+});
+
+await test('a dry run reports the hold too — that is what a dry run is for', async () => {
+  const res = await u.runUpgrade({ to: '1.15.0', from: tarball('1.15.0'), instance: consumer(), dryRun: true, skipMigrate: true },
+    { log: () => {}, err: () => {}, run: run([]), checkArtistGate: holding });
+  assert.equal(res.ok, false);
+  assert.equal(res.artistGate, true);
+});
+
+await test('nothing open: the upgrade proceeds exactly as before, and a note is printed, not swallowed', async () => {
+  const errs = [];
+  const res = await u.runUpgrade({ to: '1.15.0', from: tarball('1.15.0'), instance: consumer(), dryRun: true, skipMigrate: true },
+    { log: () => {}, err: (m) => errs.push(m), run: run([]), checkArtistGate: async () => ({ halts: [], notes: [{ code: 'ARTIST_GATE_UNREAD', message: 'could not read this instance\'s artist gate (x)' }] }) });
+  assert.equal(res.ok, true);
+  assert.ok(errs.some((m) => /could not read this instance's artist gate/.test(m)));
+});
+
+await test('a DOWNGRADE is never held — rolling back must not wait on a review', async () => {
+  let asked = 0;
+  const res = await u.runUpgrade({ to: '1.14.0', from: tarball('1.14.0'), instance: consumer('1.14.1'), allowDowngrade: true, dryRun: true, skipMigrate: true },
+    { log: () => {}, err: () => {}, run: run([]), checkArtistGate: async () => { asked++; return holding(); } });
+  assert.equal(asked, 0);
+  assert.equal(res.ok, true);
+});
+
+await test('the gate runs from the pre-flight, before the pin step, and the reader is go-live\'s own', () => {
+  const whole = readFileSync(new URL('../scripts/gds/upgrade.js', import.meta.url), 'utf8');
+  const src = whole.slice(whole.indexOf('async function runUpgrade('));
+  const gateAt = src.indexOf('checkArtistGate)(opts, deps)');
+  assert.ok(gateAt > 0 && gateAt < src.indexOf('writePin(instanceDir'), 'checked before the pin is written');
+  const gateSrc = readFileSync(new URL('../scripts/gds/upgrade-artist-gate.js', import.meta.url), 'utf8');
+  assert.match(gateSrc, /require\('\.\/go-live'\)/, 'one reader and one judgement for both deploy paths');
+});
+
+summary();