@bongos/core 1.19.827 → 1.19.829

package/tests/blockers_lib.mjs

@@ -0,0 +1,102 @@
+// tests/blockers_lib.mjs — the shared blocker-row renderer (blockers-lib.js,
+// task 1003455, goal 1000089).
+//
+// Pins that the lib is genuinely pure (no window.OTB, no DOM) so it loads
+// standalone via require() the way goals-lib.js loads standalone in a vm — and
+// that its output is what both callers (goal-inbox.js's attention-inbox slice,
+// blockers.js's full-queue page) actually depend on: a title link into the
+// EXISTING #/blocker/N overlay (task-detail.js), a quoted note, and a `·`-joined
+// facts line naming which tasks a blocker holds up.
+//
+// Run:  node tests/blockers_lib.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const lib = require('../modules/hall-ui/public/blockers-lib.js');
+
+test('loads standalone via require() — no window, no DOM (Node-require-safe like hall-kit.js)', () => {
+  assert.ok(lib, 'module.exports must be set');
+  for (const k of ['esc', 'fmtDate', 'blockingLine', 'blockerFacts']) {
+    assert.ok(k in lib, `missing export: ${k}`);
+  }
+});
+
+test('blockerFacts: title links into the SAME #/blocker/N overlay task-detail.js renders', () => {
+  const b = { id: 42, title: 'Need the owner’s AWS card on file', created_at: '2026-08-30T00:00:00.000Z', blocking_task_ids: [] };
+  const { titleHtml } = lib.blockerFacts(b, { blockerHref: (id) => `#/blocker/${id}` });
+  assert.match(titleHtml, /href="#\/blocker\/42"/);
+  assert.match(titleHtml, /Need the owner/);
+});
+
+test('blockerFacts: with no blockerHref, the title renders as plain text, not a dead link', () => {
+  const b = { id: 42, title: 'Something stuck', created_at: null, blocking_task_ids: [] };
+  const { titleHtml } = lib.blockerFacts(b);
+  assert.doesNotMatch(titleHtml, /<a /);
+  assert.match(titleHtml, /<span/);
+});
+
+test('blockerFacts: the caller-supplied classes land on the right fragments', () => {
+  const b = { id: 1, title: 'x', body_md: 'a reason', created_at: '2026-08-30T00:00:00.000Z', blocking_task_ids: [] };
+  const { titleHtml, noteHtml, factsHtml } = lib.blockerFacts(b, {
+    titleClass: 'ginbox__goal', noteClass: 'ginbox__note', whenClass: 'ginbox__sub',
+  });
+  assert.match(titleHtml, /class="ginbox__goal"/);
+  assert.match(noteHtml, /class="ginbox__note"/);
+  assert.match(factsHtml, /class="ginbox__sub"/);
+});
+
+test('blockingLine: no linked tasks reads honestly, not as a false "0 tasks"', () => {
+  assert.equal(lib.blockingLine({ blocking_task_ids: [] }, null), 'Blocking nothing yet');
+  assert.equal(lib.blockingLine({}, null), 'Blocking nothing yet');
+});
+
+test('blockingLine: singular/plural noun agreement, and every id becomes a link when taskHref is given', () => {
+  const one = lib.blockingLine({ blocking_task_ids: [5] }, (id) => `/task/${id}`);
+  assert.equal(one, 'Blocking 1 task: <a href="/task/5">#5</a>');
+  const many = lib.blockingLine({ blocking_task_ids: [5, 6] }, (id) => `/task/${id}`);
+  assert.equal(many, 'Blocking 2 tasks: <a href="/task/5">#5</a>, <a href="/task/6">#6</a>');
+});
+
+test('blockingLine: with no taskHref the ids still render, as plain text — never a dead link', () => {
+  const line = lib.blockingLine({ blocking_task_ids: [5] }, null);
+  assert.equal(line, 'Blocking 1 task: #5');
+  assert.doesNotMatch(line, /<a /);
+});
+
+test('blockerFacts: the facts line is ONE `·`-joined span, not several ungapped siblings', () => {
+  // The bug this shape avoids: two adjacent .ginbox__sub spans have no flex gap
+  // between them (unlike .ov-row__facts, which is a flex container) and would
+  // render Filed-date and Blocking-line running together with no separator.
+  const b = { id: 1, title: 'x', created_at: '2026-08-30T00:00:00.000Z', blocking_task_ids: [7] };
+  const { factsHtml } = lib.blockerFacts(b, { taskHref: (id) => `/task/${id}` });
+  assert.equal((factsHtml.match(/<span/g) || []).length, 1, 'exactly one wrapping span');
+  assert.match(factsHtml, /Filed .* · Blocking 1 task/);
+});
+
+test('blockerFacts: body_md becomes a quoted note; an empty one renders nothing', () => {
+  const withNote = lib.blockerFacts({ id: 1, title: 'x', body_md: 'reason', blocking_task_ids: [] });
+  assert.match(withNote.noteHtml, /<p class="ov-row__sub">“reason”<\/p>/);
+  const noNote = lib.blockerFacts({ id: 1, title: 'x', body_md: '   ', blocking_task_ids: [] });
+  assert.equal(noNote.noteHtml, '');
+});
+
+test('blockerFacts: a very long body_md is clipped, so one enormous blocker cannot blow up the row', () => {
+  const long = 'x'.repeat(500);
+  const { noteHtml } = lib.blockerFacts({ id: 1, title: 't', body_md: long, blocking_task_ids: [] });
+  assert.ok(noteHtml.length < 500, 'clipped well below the source length');
+  assert.match(noteHtml, /…”<\/p>$/);
+});
+
+test('blockerFacts: HTML in a title/body/task id is escaped, not injected', () => {
+  const b = {
+    id: 1, title: '<script>alert(1)</script>', body_md: '<img onerror=alert(1)>',
+    created_at: '2026-08-30T00:00:00.000Z', blocking_task_ids: [1],
+  };
+  const { titleHtml, noteHtml, factsHtml } = lib.blockerFacts(b, { taskHref: (id) => `/task/"><script>${id}` });
+  assert.doesNotMatch(titleHtml, /<script>/);
+  assert.doesNotMatch(noteHtml, /<img /);
+  assert.doesNotMatch(factsHtml, /<script>/);
+});

package/tests/hall_nav.mjs

@@ -255,7 +255,10 @@ test('sidebar groups read by audience, in order', () => {
   // (2026-09-09) was to move it: a sitting is work the project does, beside Goals
   // and Tasks, not one of Government's monitoring surfaces. The item is invisible
   // to anyone without the atom, so most builders never see it here.
-  assert.deepEqual(nav[0].items.map((i) => i.id), ['home', 'roadmap', 'goals', 'work', 'board-room', 'ideas', 'copy-desk', 'studio'],
+  // task 1003455 (goal 1000089): 'blockers' joins the same group, after Tasks —
+  // its subject is the project (what's stuck on the owner), not a person or a
+  // craft, and its one data source (GET /blockers) is public like Roadmap's.
+  assert.deepEqual(nav[0].items.map((i) => i.id), ['home', 'roadmap', 'goals', 'work', 'blockers', 'board-room', 'ideas', 'copy-desk', 'studio'],
     'the unlabeled group is the project itself (task 1002425 order)');
   assert.deepEqual(nav[1].items.map((i) => i.id), ['standing', 'profile'], 'You = your own numbers');
   // People (task 1002577): the /scouting directory graduated into the hall.

package/tests/hall_page_gate_map.mjs

@@ -129,6 +129,14 @@ const ORACLE = {
   '/builders/drachmae': null,
   '/builders/profile': null,
 
+  // task 1003455: the blocker queue. GET /blockers is deliberately public (the
+  // status dashboard is meant to read it too — "anyone landing on /builders or
+  // the status dashboard can see what's stuck on the owner", the route's own
+  // handler comment), so the page must not be gated tighter than the API it
+  // fronts — the same rule that puts /roster and /drachmae here. The nav link
+  // is still cosmetically 'signed', same as those two.
+  '/builders/blockers': null,
+
   // The bare detail slugs, gated by task 1003629 — the decision idea 1000907
   // (task 1003448) asked for. They resolve to the same task.html / idea.html
   // shells their /:id forms do, so they now sit on the same tier: the id-less

package/tests/unit_runner_teardown_abort.mjs

@@ -0,0 +1,67 @@
+// tests/unit_runner_teardown_abort.mjs
+//
+// The unit runner tells a libuv TEARDOWN abort apart from a failing suite (task 1003845).
+//
+// On Windows + Node 24 a suite that hard-exits after serving HTTP can print a clean
+// verdict and THEN die natively:
+//
+//   Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), file src\win\async.c, line 76
+//
+// exit 127 or 0xC0000409, nondeterministically. tests/provisioning_github_app_routes.mjs
+// did it 5 runs of 6 on origin/main, and 51 suites share that shape. Counted as FAILED,
+// these swap in and out of a Windows baseline with timing, so a genuinely new failure
+// can take a vanished one's place without the count moving.
+//
+// The runner recognises the class by its stderr signature AND the suite's own clean
+// verdict, never by a curated list of names. The cases below are the ways that pairing
+// must refuse: a real failure is never allowed to read as teardown noise.
+//
+// Run:  node --test tests/unit_runner_teardown_abort.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { isCleanTeardownAbort } from '../scripts/gds/run-unit-tests.js';
+
+// Captured from a real aborted run of tests/provisioning_github_app_routes.mjs.
+const ABORT_76 = 'Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), file src\\win\\async.c, line 76\r\n';
+const ABORT_94 = 'Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), file src\\win\\async.c, line 94\r\n';
+const CLEAN = '  PASS  non-numeric :id → 400 bad_id (never a 500)\n\nprovisioning github-app routes: 23 passed, 0 failed\n';
+
+test('a clean verdict followed by the libuv abort is teardown noise', () => {
+  assert.equal(isCleanTeardownAbort(CLEAN, ABORT_76), true);
+  assert.equal(isCleanTeardownAbort('  PASS  a\n\n9 passed, 0 failed\n', ABORT_94), true);
+});
+
+test('the abort does not excuse a verdict that reports failures', () => {
+  assert.equal(isCleanTeardownAbort('  PASS  a\n  FAIL  b\n\n22 passed, 1 failed\n', ABORT_76), false);
+});
+
+test('a FAIL line outranks a summary that claims zero failures', () => {
+  assert.equal(isCleanTeardownAbort('  FAIL  b\n\n23 passed, 0 failed\n', ABORT_76), false);
+});
+
+test('FAIL inside a passing case title is not a FAIL line', () => {
+  // tests/search_isolation.mjs prints exactly this and passes.
+  const stdout = '  ok  rank helper is FAIL-CLOSED: unknown/missing rank → least privilege only\n\n5 passed, 0 failed\n';
+  assert.equal(isCleanTeardownAbort(stdout, ABORT_76), true);
+});
+
+test('an ordinary non-zero exit with no abort signature stays a failure', () => {
+  assert.equal(isCleanTeardownAbort(CLEAN, ''), false);
+  assert.equal(isCleanTeardownAbort(CLEAN, 'Error: listen EADDRINUSE\n'), false);
+});
+
+test('an abort with no verdict at all is a crash, not noise', () => {
+  assert.equal(isCleanTeardownAbort('  PASS  a\n', ABORT_76), false);
+  assert.equal(isCleanTeardownAbort('', ABORT_76), false);
+});
+
+test('the verdict must be the LAST thing the suite printed', () => {
+  // A mid-file section summary does not vouch for whatever ran after it.
+  const midFile = 'section one: 4 passed, 0 failed\n  PASS  c\nnext section starting\n';
+  assert.equal(isCleanTeardownAbort(midFile, ABORT_76), false);
+});
+
+test('a suite that asserted nothing is not vouched for', () => {
+  assert.equal(isCleanTeardownAbort('\n0 passed, 0 failed\n', ABORT_76), false);
+});