@bongos/core 1.20.65 → 1.20.67

package/tests/goal_sort_staleness.mjs

@@ -171,9 +171,14 @@ await test('the SQL rollup buckets MIRROR goals-lib readinessOf exactly', () =>
   assert.match(lib, /DONE_STATUSES = new Set\(\['completed', 'confirmed', 'shipped'\]\)/);
   assert.match(vocab, /const CUT_STATUSES = \['abandoned', 'dropped'\]/);
   assert.match(lib, /CUT_STATUSES = new Set\(\['abandoned', 'dropped'\]\)/);
-  // blocked = backlog with >=1 unshipped dependency, both sides
-  assert.match(rollup, /WHEN s\.status = 'backlog' AND s\.has_unshipped_dep THEN 'blocked'/);
-  assert.match(lib, /s === 'backlog' && \(t\.blocked_by \|\| \[\]\)\.some\(\(d\) => !d\.satisfied\)/);
+  // blocked = >=1 unshipped dependency on an unclaimed task, both sides — and
+  // on BOTH sides the arm sits AHEAD of 'ready' (task 1004487), because a dep
+  // added after promotion leaves the row at 'ready' and a status-first
+  // bucketing would then count un-claimable work as ready. The ORDER is the
+  // assertion, not just the presence of the clause.
+  assert.match(rollup, /WHEN s\.has_unshipped_dep\s+THEN 'blocked'\s*\n\s*WHEN s\.status = 'ready'\s+THEN 'ready'/);
+  assert.match(lib, /const hasUnmetDeps = \(t\) => \(\(t && t\.blocked_by\) \|\| \[\]\)\.some\(\(d\) => !d\.satisfied\);/);
+  assert.match(lib, /if \(hasUnmetDeps\(t\)\) return 'blocked';\s*\n\s*if \(s === 'ready'\) return 'ready';/);
   // cut is excluded from the total on both sides (migration 017's rule)
   assert.match(rollup, /FILTER \(WHERE b\.bucket <> 'cut'\)::int\s+AS total/);
   assert.match(read('modules/hall-ui/public/goals-page.js'), /total: row\.total \|\| 0/);

package/tests/goals_lib.mjs

@@ -25,7 +25,16 @@ const SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/goals-lib.js
 const TASK_LIB_SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/task-lib.js'), 'utf8');
 const { test, summary } = makeRunner();
 
-const windowObj = {};
+// window.OTB.escapeHtml is the ONE sibling the lib reaches for that is not a
+// loadable file (it lives in the hall's shared dom-utils). The real one, copied
+// to its behaviour, so a tag that forgets to escape a dependency title fails
+// here rather than passing against a pass-through fake.
+const windowObj = {
+  OTB: {
+    escapeHtml: (s) => String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;'),
+  },
+};
 const sandbox = { window: windowObj, Set, Map, Math, Number, String, Array, Object, Date, JSON };
 sandbox.globalThis = sandbox;
 vm.createContext(sandbox);
@@ -39,7 +48,8 @@ await test('loads standalone in a bare window (no page-state dependency) and exp
   assert.ok(lib, 'window.OTBGoalsLib must be set');
   assert.equal('state' in sandbox, false, 'the lib must not reach for page state');
   for (const k of ['DONE_STATUSES', 'CUT_STATUSES', 'isTodoStatus', 'ring', 'memberName',
-    'readinessOf', 'EMPTY_ROLLUP', 'goalRollLine', 'matchesTodoSearch', 'msOf', 'taskActivityMs']) {
+    'hasUnmetDeps', 'taskStatusTagHtml', 'readinessOf', 'EMPTY_ROLLUP', 'goalRollLine',
+    'matchesTodoSearch', 'msOf', 'taskActivityMs']) {
     assert.ok(k in lib, `missing export: ${k}`);
   }
 });
@@ -53,6 +63,52 @@ await test('readinessOf buckets match the task-1002439 rules', () => {
   assert.equal(lib.readinessOf({ status: 'backlog' }), 'backlog');
 });
 
+// Task 1004487 — the case the backlog-only condition missed. ADR 0015 rules
+// that a dependency added AFTER promotion leaves the row at `ready` and that
+// the readers are what change (core_264 did it for the claimable feed), so a
+// `ready` row with an unshipped dependency must bucket as blocked here too —
+// otherwise the Goals page counts work POST /claims refuses as claimable.
+await test('a READY task with an unshipped dependency is blocked, not ready', () => {
+  assert.equal(lib.readinessOf({ status: 'ready', blocked_by: [{ satisfied: false }] }), 'blocked');
+  // …and a satisfied edge does not demote a genuinely claimable row.
+  assert.equal(lib.readinessOf({ status: 'ready', blocked_by: [{ satisfied: true }] }), 'ready');
+  assert.equal(lib.readinessOf({ status: 'ready', blocked_by: [] }), 'ready');
+  // A live claim still outranks the dependency question: the task is being
+  // worked, so "in progress" is the true answer whatever its edges say.
+  assert.equal(lib.readinessOf({ status: 'active', blocked_by: [{ satisfied: false }] }), 'active');
+  // Settled work is never re-bucketed by a stale edge either.
+  assert.equal(lib.readinessOf({ status: 'shipped', blocked_by: [{ satisfied: false }] }), 'done');
+  assert.equal(lib.readinessOf({ status: 'abandoned', blocked_by: [{ satisfied: false }] }), 'cut');
+});
+
+await test('hasUnmetDeps mirrors the DEPS_NOT_SHIPPED rule and tolerates a missing array', () => {
+  assert.equal(lib.hasUnmetDeps({ blocked_by: [{ satisfied: true }, { satisfied: false }] }), true);
+  assert.equal(lib.hasUnmetDeps({ blocked_by: [{ satisfied: true }] }), false);
+  // A caller that never asked for ?include=deps gets no array at all; the page
+  // must render rather than throw, and must not invent a block it cannot see.
+  assert.equal(lib.hasUnmetDeps({ status: 'ready' }), false);
+  assert.equal(lib.hasUnmetDeps(null), false);
+});
+
+await test("taskStatusTagHtml says blocked on a dep-blocked ready row, and the real status otherwise", () => {
+  const blocked = lib.taskStatusTagHtml({
+    status: 'ready',
+    blocked_by: [{ id: 640, title: 'Palette overhaul', satisfied: false },
+      { id: 587, title: 'Already landed', satisfied: true }],
+  });
+  assert.match(blocked, />blocked<\/span>$/, 'the word the claim gate would use, not the status column');
+  assert.match(blocked, /title="Waiting on #640 Palette overhaul"/, 'it names the unmet edge');
+  assert.doesNotMatch(blocked, /587/, 'and not the one that already shipped');
+  // Every other row is untouched — this must not become a second status vocabulary.
+  assert.equal(lib.taskStatusTagHtml({ status: 'active' }),
+    '<span class="task__tag" title="Task status">active</span>');
+  assert.equal(lib.taskStatusTagHtml({ status: 'ready', blocked_by: [{ satisfied: true }] }),
+    '<span class="task__tag" title="Task status">ready</span>');
+  // A dependency title is ledger prose on a title attribute — escape it.
+  const nasty = lib.taskStatusTagHtml({ status: 'ready', blocked_by: [{ id: 1, title: '"><b>x', satisfied: false }] });
+  assert.doesNotMatch(nasty, /<b>/);
+});
+
 await test('matchesTodoSearch: bare number, #N and title fragments all match (task 1003135 search semantics)', () => {
   const t = { id: 1002163, title: 'Show the goal id on the row' };
   assert.ok(lib.matchesTodoSearch(t, ''));