@bongos/core 1.19.990 → 1.19.992

package/tests/provisioning_error_note_scope.mjs

@@ -0,0 +1,147 @@
+// tests/provisioning_error_note_scope.mjs — the "we stopped trying" note belongs to the
+// action that wrote it (task 1004197; the F19 latch, task 1002720).
+//
+// What is pinned:
+//   1. both retire paths record the retiring intent's action beside the note, through the
+//      setInstanceStatus whitelist, and provisioning_026 adds that column idempotently;
+//   2. clearErrorNote releases only its own action's note (or one with no recorded
+//      action), in one narrow statement; ownsErrorNote answers the same question for the
+//      owner's re-kick doors;
+//   3. every success leg names its own action — no unscoped clear is left.
+// The re-kick doors themselves are pinned in tests/provisioning_settings_apply.mjs and
+// tests/provisioning_domain_attach.mjs.
+//
+// DB-free: CI has no Postgres, so the SQL is exercised through a recording fake.
+//
+// Run:  node tests/provisioning_error_note_scope.mjs
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const P = require('../scripts/gds/provision.js');
+const { clearErrorNote, ownsErrorNote } = require('../modules/provisioning/error-note.js');
+const provisioning = require('../modules/provisioning/provisioning.js');
+
+const { test, summary } = makeRunner();
+
+const activeStandalone = {
+  id: 18, slug: 'spike', hosting_shape: 'standalone', status: 'active', owner_builder_id: 7,
+  port: 3010, db_name: 'spike', domain: null, target_ref: 'jaxri/spike-harbor',
+};
+
+function recordingDb(rows = [{ id: 18 }]) {
+  const calls = [];
+  return { calls, query: async (sql, params) => { calls.push({ sql, params }); return { rows }; } };
+}
+
+// ---- 1. the author is recorded ------------------------------------------------------
+
+function retireDeps(getInstanceById) {
+  let claims = 0;
+  const patches = [];
+  const deps = {
+    apply: true, log: () => {},
+    db: { query: async () => ({ rows: [] }) },
+    provisioning: {
+      claimNextIntent: async () => (claims++ === 0
+        ? { id: 9, instance_id: 18, action: 'domain-attach', attempts: P.MAX_INTENT_ATTEMPTS } : null),
+      getInstanceById,
+      resolveIntent: async () => {},
+      setInstanceStatus: async (_db, _id, _s, patch) => { patches.push(patch); },
+      recordEvent: async () => {},
+      claimNextOAuthManifest: async () => null, resolveOAuthManifest: async () => {},
+    },
+    exec: () => ({ ok: true }), writeFile: () => ({ ok: true }), doApi: null,
+    checkDnsTokenScope: async () => ({ reachable: true, zone: 'z' }),
+    checkCaddyWiring: () => null,
+  };
+  return { deps, patches };
+}
+
+await test('a retire that returned ok:false records its action beside the note', async () => {
+  // Arrange: an active instance with no domain makes the attach leg fail on its last attempt.
+  const r = retireDeps(async () => ({ ...activeStandalone }));
+  // Act
+  await P.cmdRunIntents(r.deps);
+  // Assert
+  assert.equal(r.patches.length, 1);
+  assert.ok(r.patches[0].error_note, 'the reason reaches the card');
+  assert.equal(r.patches[0].error_note_action, 'domain-attach');
+});
+
+await test('a retire by a throw records its action beside the note', async () => {
+  const r = retireDeps(async () => { throw new Error('box unreachable'); });
+  await P.cmdRunIntents(r.deps);
+  assert.deepEqual(r.patches[0], { error_note: 'box unreachable', error_note_action: 'domain-attach' });
+});
+
+await test('setInstanceStatus writes error_note_action (it is on the whitelist)', async () => {
+  const db = recordingDb();
+  await provisioning.setInstanceStatus(db, 18, 'active', { error_note: 'x', error_note_action: 'restart' });
+  assert.match(db.calls[0].sql, /error_note_action = \$\d/);
+  assert.ok(db.calls[0].params.includes('restart'));
+});
+
+await test('provisioning_026 adds the column idempotently, and nothing else', () => {
+  const sql = readFileSync(path.join(ROOT, 'modules/provisioning/migrations/provisioning_026_error_note_action.sql'), 'utf8')
+    .replace(/--.*$/gm, '');
+  assert.match(sql, /ALTER TABLE provisioning_instances ADD COLUMN IF NOT EXISTS error_note_action text;/);
+  assert.doesNotMatch(sql, /DROP|UPDATE|DELETE/i, 'additive only (ADR 0083)');
+});
+
+// ---- 2. who may release the note ------------------------------------------------------
+
+await test('ownsErrorNote: own action, or no recorded action, owns the note; another action does not', () => {
+  assert.equal(ownsErrorNote({ error_note: 'x', error_note_action: 'restart' }, 'restart'), true);
+  assert.equal(ownsErrorNote({ error_note: 'x', error_note_action: null }, 'restart'), true, 'a note from before the column is anyone\'s, as before');
+  assert.equal(ownsErrorNote({ error_note: 'x' }, 'restart'), true);
+  assert.equal(ownsErrorNote({ error_note: 'x', error_note_action: 'domain-attach' }, 'restart'), false);
+  assert.equal(ownsErrorNote({ error_note: null, error_note_action: 'restart' }, 'restart'), false, 'no note, nothing to own');
+  assert.equal(ownsErrorNote(null, 'restart'), false);
+});
+
+await test('clearErrorNote releases only its own action\'s note, in one narrow statement', async () => {
+  const db = recordingDb();
+  const out = await clearErrorNote(db, 18, 'repo-private');
+  assert.deepEqual(out, { id: 18 });
+  assert.equal(db.calls.length, 1, 'one statement — no read-then-write window');
+  const { sql, params } = db.calls[0];
+  assert.match(sql, /SET error_note = NULL, error_note_action = NULL/);
+  assert.match(sql, /error_note IS NOT NULL AND \(error_note_action IS NULL OR error_note_action = \$2\)/,
+    'another action\'s note does not match, so it stays');
+  assert.deepEqual(params, [18, 'repo-private']);
+  assert.doesNotMatch(sql, /status\s*=|updated_at/, 'releasing the latch never touches the lifecycle');
+});
+
+await test('an unscoped clear passes null, which releases only a note with no recorded action', async () => {
+  const db = recordingDb([]);
+  assert.equal(await clearErrorNote(db, 18), null);
+  assert.deepEqual(db.calls[0].params, [18, null]);
+});
+
+await test('provisioning.js re-exports both from error-note.js', () => {
+  assert.equal(provisioning.clearErrorNote, clearErrorNote);
+  assert.equal(provisioning.ownsErrorNote, ownsErrorNote);
+});
+
+// ---- 3. every success leg names its own action -------------------------------------
+
+await test('each success leg clears with its OWN action, and no unscoped clear is left', () => {
+  const want = {
+    'scripts/gds/provision.js': ['domain-attach', 'settings-apply', 'restart'],
+    'scripts/gds/provision-core-upgrade.js': ['core-upgrade'],
+    'scripts/gds/provision-repo-private.js': ['repo-private'],
+  };
+  for (const [file, actions] of Object.entries(want)) {
+    const src = readFileSync(path.join(ROOT, file), 'utf8');
+    const calls = [...src.matchAll(/clearErrorNote\(db, inst\.id(?:, '([a-z-]+)')?\)/g)].map((m) => m[1] || '(none)');
+    assert.deepEqual(calls.sort(), [...actions].sort(), `${file}: ${calls.join(', ')}`);
+  }
+});
+
+summary();

package/tests/provisioning_settings_apply.mjs

@@ -323,6 +323,20 @@ await ta('the owner re-kick: same values re-sent while a retired push left its e
   receiptShape(r.body.push, { queued: true, restart: true, reachable: true });
 });
 
+await ta('another action\'s note is NOT a re-kick: same values re-sent over a retired RESTART\'s note → "No change", nothing queued (task 1004197)', async () => {
+  // A settings push that works cannot release a restart's note, so treating that note as
+  // "the push is owed" would re-queue a push (and a restart) on every unchanged save.
+  reset({ inst: { ...ACTIVE, settings: { platform_visibility: 'gated' }, error_note: 'could not restart spike', error_note_action: 'restart' } });
+  const r = await patch('/provisioning/instances/18/settings', { platform_visibility: 'gated' });
+  assert.equal(r.status, 200, r.raw);
+  assert.equal(enqueueCalls.length, 0, 'no push re-queued');
+  assert.equal(updateCalls.length, 0);
+  reset({ inst: { ...ACTIVE, settings: { platform_visibility: 'gated' }, error_note: 'could not apply the settings on spike', error_note_action: 'settings-apply' } });
+  const own = await patch('/provisioning/instances/18/settings', { platform_visibility: 'gated' });
+  assert.deepEqual(enqueueCalls.map((c) => c.id), [18], 'its OWN retired push still re-kicks');
+  receiptShape(own.body.push, { queued: true, restart: true, reachable: true });
+});
+
 console.log('\nthe state gate — store, queue nothing, say when it takes effect:');
 
 await ta('requested / provisioning: stored, NO intent (standup writes the same values), message says so', async () => {

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();