@bongos/core 1.19.262 → 1.19.264

package/tests/ship_error_shape.mjs

@@ -0,0 +1,153 @@
+// tests/ship_error_shape.mjs
+//
+// Unit tests for ship.js's API-error rendering (task 1002789).
+//
+// HIT FOR REAL on task 1002485: a fully diagnosable push failure reached the
+// builder as literally "ci-land: server publish failed - [object Object]".
+// The cause is one bug class repeated at several sites — ship.js read the
+// PRE-ADR-0116 flat body `{ error: 'code', …fields }` while the live server
+// emits the nested envelope `{ error: { code, message, details } }`:
+//
+//   * interpolating `data.error` into a template string stringifies the
+//     envelope OBJECT — that is the literal "[object Object]";
+//   * `data.error === 'some_code'` never matches, so the graceful branch
+//     behind it (box_scope re-auth, verify-attestation remedy, the
+//     CLAIM_SESSION_MISMATCH explanation) is DEAD CODE against a live server;
+//   * `data.<field>` reads a top-level field that MOVED into `error.details`.
+//
+// What we prove here (pure helpers only — no git, no network):
+//   1. normalizeApiError now carries `details`, from the envelope when nested
+//      and from the body itself on a legacy flat response.
+//   2. apiErrorLine renders BOTH shapes as one readable line and NEVER emits
+//      "[object Object]" — the regression this task exists to kill.
+//   3. It keeps the scalar detail fields that name what actually failed, and
+//      drops non-scalar blobs (a details payload can carry a whole bundle).
+//   4. It survives missing/odd/hostile bodies without throwing.
+//
+// Run:  node tests/ship_error_shape.mjs
+
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const ship = require('../scripts/gds/ship.js');
+const { normalizeApiError, apiErrorLine } = ship;
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`  ok  ${name}`);
+  } catch (err) {
+    failed++;
+    console.log(`  FAIL ${name}`);
+    console.log(`     ${err.message}`);
+  }
+}
+function eq(actual, expected, msg) {
+  if (actual !== expected) throw new Error(`${msg || 'mismatch'}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+}
+function has(haystack, needle) {
+  if (!String(haystack).includes(needle)) throw new Error(`expected to contain ${JSON.stringify(needle)}, got ${JSON.stringify(haystack)}`);
+}
+function lacks(haystack, needle) {
+  if (String(haystack).includes(needle)) throw new Error(`expected NOT to contain ${JSON.stringify(needle)}, got ${JSON.stringify(haystack)}`);
+}
+
+// ---- 1. normalizeApiError carries details from both shapes ----
+
+test('normalizeApiError takes details from the envelope', () => {
+  const { code, details } = normalizeApiError({
+    error: { code: 'CLAIM_SESSION_MISMATCH', message: 'other session', details: { claimWorktree: 'wt-1002789' } },
+  });
+  eq(code, 'CLAIM_SESSION_MISMATCH');
+  eq(details.claimWorktree, 'wt-1002789');
+});
+
+test('normalizeApiError falls back to the body on the legacy flat shape', () => {
+  // The flat shape put the structured fields at the TOP level, so the body IS
+  // the details. Both server generations resolve through one read.
+  const { code, details } = normalizeApiError({ error: 'CLAIM_SESSION_MISMATCH', claimWorktree: 'wt-legacy' });
+  eq(code, 'CLAIM_SESSION_MISMATCH');
+  eq(details.claimWorktree, 'wt-legacy');
+});
+
+test('normalizeApiError still survives missing/odd bodies', () => {
+  eq(normalizeApiError(null).code, undefined);
+  eq(typeof normalizeApiError(null).details, 'object');
+  eq(normalizeApiError({}).code, undefined);
+});
+
+// ---- 2. apiErrorLine never emits "[object Object]" ----
+
+test('apiErrorLine renders the ADR 0116 envelope, not [object Object]', () => {
+  const line = apiErrorLine({
+    error: { code: 'publish_failed', message: 'push rejected', details: { step: 'push', reason: 'non-fast-forward' } },
+  }, 500);
+  lacks(line, '[object Object]');
+  has(line, 'publish_failed');
+  has(line, 'push rejected');
+  has(line, 'step: push');
+  has(line, 'non-fast-forward');
+  has(line, 'HTTP 500');
+});
+
+test('apiErrorLine renders the legacy flat shape', () => {
+  const line = apiErrorLine({ error: 'publish_failed', step: 'push' }, 500);
+  lacks(line, '[object Object]');
+  has(line, 'publish_failed');
+  has(line, 'step: push');
+});
+
+test('apiErrorLine does not repeat the code when message just echoes it', () => {
+  // envelope() defaults message to the code, so the naive `code: message`
+  // join would print "publish_failed: publish_failed".
+  const line = apiErrorLine({ error: { code: 'publish_failed', message: 'publish_failed' } }, 500);
+  lacks(line, 'publish_failed: publish_failed');
+  has(line, 'publish_failed');
+});
+
+// ---- 3. scalars kept, blobs dropped ----
+
+test('apiErrorLine keeps scalar details and drops blobs', () => {
+  const line = apiErrorLine({
+    error: {
+      code: 'publish_failed',
+      message: 'nope',
+      details: { step: 'push', attempt: 3, armed: false, bundle: { b64: 'x'.repeat(200) }, files: ['a', 'b'] },
+    },
+  }, 500);
+  has(line, 'step: push');
+  has(line, 'attempt: 3');
+  has(line, 'armed: false');
+  lacks(line, 'bundle');
+  lacks(line, 'files');
+  lacks(line, '[object Object]');
+});
+
+test('apiErrorLine flattens multi-line git stderr onto one line', () => {
+  const line = apiErrorLine({
+    error: { code: 'publish_failed', message: 'nope', details: { reason: 'error: failed to push\n hint: fetch first\n' } },
+  }, 500);
+  eq(line.includes('\n'), false, 'must be a single line');
+  has(line, 'fetch first');
+});
+
+// ---- 4. hostile / empty bodies ----
+
+test('apiErrorLine handles a body with no error at all', () => {
+  has(apiErrorLine({}, 503), 'HTTP 503');
+  has(apiErrorLine(null, 503), 'HTTP 503');
+  eq(apiErrorLine(null), 'unknown error');
+});
+
+test('apiErrorLine handles a null error member', () => {
+  const line = apiErrorLine({ error: null }, 500);
+  lacks(line, '[object Object]');
+  has(line, 'HTTP 500');
+});
+
+console.log('');
+console.log(`ship_error_shape: ${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/task_lib.mjs

@@ -0,0 +1,115 @@
+// tests/task_lib.mjs
+//
+// task 1002463 — the shared task-domain helpers extracted out of work.js and
+// goals-page.js into modules/hall-ui/public/task-lib.js.
+//
+// WHY THIS FILE EXISTS. The extraction was verified by an equivalence pass against
+// the pristine pre-refactor sources — and that pass MISSED two real regressions,
+// because every input it fed deHashRefs was a string or null. A grader caught them:
+// the digit bound had been "tidied" from \d{1,5} to \d+, and the null guard from
+// (text == null ? '' : text) to (text || ''). Both are behaviour changes hiding in
+// a refactor. The lesson is that equivalence proofs are only as good as their input
+// domain, so the boundaries now have named, checked-in cases.
+//
+// Run:  node tests/task_lib.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const T = require(join(ROOT, 'modules/hall-ui/public/task-lib.js'));
+
+let passed = 0, failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+// ---- deHashRefs: the two regressions, pinned ------------------------------
+t('deHashRefs rewrites a 1-5 digit ref (GitHub would autolink it to an issue)', () => {
+  assert.equal(T.deHashRefs('see #123'), 'see task 123');
+  assert.equal(T.deHashRefs('#1'), 'task 1');
+  assert.equal(T.deHashRefs('#12345'), 'task 12345');
+});
+
+t('deHashRefs LEAVES a 6+ digit run alone — \\d{1,5} is load-bearing by omission', () => {
+  // \d{1,5} followed by \b cannot match inside a longer digit run: after 5 digits
+  // the next char is still a word char, so there is no boundary and no match at
+  // all. Widening to \d+ silently changed this. Pinned so it cannot drift back.
+  assert.equal(T.deHashRefs('#123456'), '#123456');
+  assert.equal(T.deHashRefs('#1002463'), '#1002463');
+  assert.equal(T.deHashRefs('#12345 and #123456'), 'task 12345 and #123456');
+});
+
+t('deHashRefs keeps falsy-but-real input — (text == null) not (!text)', () => {
+  // `text || ''` would swallow these into the empty string.
+  assert.equal(T.deHashRefs(0), '0');
+  assert.equal(T.deHashRefs(false), 'false');
+  assert.equal(T.deHashRefs(NaN), 'NaN');
+  // ...while genuinely absent input is still the empty string.
+  assert.equal(T.deHashRefs(null), '');
+  assert.equal(T.deHashRefs(undefined), '');
+});
+
+// ---- touchesConflict: the parallel-safety predicate -----------------------
+t('touchesConflict: a path collides with itself, its parents and its children', () => {
+  assert.equal(T.touchesConflict(['src'], ['src']), true);
+  assert.equal(T.touchesConflict(['src'], ['src/gds/db.js']), true);
+  assert.equal(T.touchesConflict(['src/gds/db.js'], ['src']), true);
+  assert.equal(T.touchesConflict(['src'], ['srcery']), false, 'prefix must not count as a parent');
+  assert.equal(T.touchesConflict(['a'], ['b']), false);
+});
+
+t('touchesConflict: trailing slashes normalise, non-arrays are inert', () => {
+  assert.equal(T.touchesConflict(['src/'], ['src']), true);
+  assert.equal(T.touchesConflict(null, ['src']), false);
+  assert.equal(T.touchesConflict('src', ['src']), false, 'a bare string is not a list');
+});
+
+// ---- priorityRank / creditsPerMinute: sort keys ---------------------------
+t('priorityRank: unparseable or absent sorts LAST, not first', () => {
+  assert.equal(T.priorityRank('P1'), 1);
+  assert.equal(T.priorityRank('P5'), 5);
+  assert.equal(T.priorityRank(null), 99);
+  assert.equal(T.priorityRank('nonsense'), 99);
+});
+
+t('creditsPerMinute: unpriced/unestimated sinks below a genuine zero ratio', () => {
+  assert.equal(T.creditsPerMinute({ credits_reward: 10, est_minutes: 5 }), 2);
+  assert.equal(T.creditsPerMinute({ credits_reward: 0, est_minutes: 5 }), -Infinity);
+  assert.equal(T.creditsPerMinute({ credits_reward: 10, est_minutes: 0 }), -Infinity);
+  assert.equal(T.creditsPerMinute({}), -Infinity);
+});
+
+// ---- friendlyBatchReason: the bug this extraction fixed -------------------
+t('friendlyBatchReason explains MODULE_CONFLICT — the case goals-page.js had lost', () => {
+  assert.match(
+    T.friendlyBatchReason({ reason: 'MODULE_CONFLICT', module_key: 'ideas', conflictsWithTaskId: 7 }),
+    /shares module "ideas" with task #7/
+  );
+  assert.match(
+    T.friendlyBatchReason({ reason: 'MODULE_CONFLICT', module_key: 'ideas' }),
+    /shares module "ideas" with an active claim/
+  );
+});
+
+t('friendlyBatchReason falls through to the raw code for an unmapped reason', () => {
+  // The failure mode this guards: a new server-side refusal code degrades to the
+  // machine string in the UI rather than throwing. Loud enough to notice, safe.
+  assert.equal(T.friendlyBatchReason({ reason: 'SOME_NEW_CODE' }), 'SOME_NEW_CODE');
+  assert.equal(T.friendlyBatchReason(null), 'not claimable');
+});
+
+// ---- rankTagHtml: escaping ------------------------------------------------
+t('rankTagHtml escapes its label and treats xenos as "no floor"', () => {
+  assert.match(T.rankTagHtml('xenos'), /Any rank/);
+  assert.match(T.rankTagHtml('metic'), /Metic\+/);
+  assert.match(T.rankTagHtml('archon'), /Archon</, 'archon takes no + suffix');
+  assert.doesNotMatch(T.rankTagHtml('<img src=x onerror=1>'), /<img/);
+});
+
+console.log(`\ntask-lib tests: ${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);