@bongos/core 1.19.971 → 1.19.972

package/tests/hall_mine_lens.mjs

@@ -0,0 +1,381 @@
+// tests/hall_mine_lens.mjs — the hall's "Only mine" lens: goals you are added
+// on, and tasks you have claimed.
+//
+// The lens is ONE checkbox that four tabs answer differently — Ready and Backlog
+// by goal membership, In Progress by who holds the claim, Completed by who
+// shipped it. That is exactly the shape a source-grep test cannot prove: a regex
+// can see that `mineOn()` is called and still miss that a renderer filters the
+// wrong list, or counts the unfiltered one, or silently empties every tab when
+// the membership read fails. So work.js is BOOTED here, against the stub DOM
+// tests/helpers.mjs already uses for the profile and idea pages, and the
+// assertions read the HTML the page actually wrote.
+//
+// Each test below was verified by deleting the line it guards and watching it go
+// red — the vacuous-guard check this suite has been bitten by before.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+import { settle } from './helpers.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const WORK_JS = fs.readFileSync(path.join(HALL, 'work.js'), 'utf8');
+// The two files work.js was carved into. Run the REAL ones rather than stubbing
+// them: mine-lens.js IS the subject here, and work-summary.js is the piece that
+// left work.js to make room for it — a stub of either would let the carve rot.
+const MINE_LENS_JS = fs.readFileSync(path.join(HALL, 'mine-lens.js'), 'utf8');
+const WORK_SUMMARY_JS = fs.readFileSync(path.join(HALL, 'work-summary.js'), 'utf8');
+
+// ---------------------------------------------------------------------------
+// The fixture. Two goals, and the viewer (builder 7, @percy) is on ONE of them.
+// Every list below is built so that "mine" and "not mine" are both non-empty —
+// a lens that returned everything and a lens that returned nothing would both
+// pass against a one-sided fixture.
+// ---------------------------------------------------------------------------
+const MINE_GOAL = 1000101;
+const THEIRS_GOAL = 1000102;
+
+const GOALS = [
+  { id: MINE_GOAL, title: 'A goal I am on', viewer_is_member: true },
+  { id: THEIRS_GOAL, title: 'A goal I am not on', viewer_is_member: false },
+];
+
+const CLAIMABLE = [
+  { id: 501, title: 'ready in my goal', goal_id: MINE_GOAL, status: 'ready', version_id: 'V1' },
+  { id: 502, title: 'ready in their goal', goal_id: THEIRS_GOAL, status: 'ready', version_id: 'V1' },
+  // A task with NO goal at all. It is nobody's by membership, and it exists in
+  // the fixture to pin that the lens excludes it rather than letting the
+  // ungoaled backlog ride along under the word "mine".
+  { id: 503, title: 'ready with no goal', goal_id: null, status: 'ready', version_id: 'V1' },
+];
+
+const BACKLOG = [
+  { id: 601, title: 'backlog in my goal', goal_id: MINE_GOAL, status: 'backlog', version_id: 'V1' },
+  { id: 602, title: 'backlog in their goal', goal_id: THEIRS_GOAL, status: 'backlog', version_id: 'V1' },
+];
+
+const ACTIVE_CLAIMS = [
+  { claim_id: 9001, task_id: 701, title: 'a claim of mine', builder_id: 7, github_login: 'percy', display_name: 'Percy', claimed_at: '2026-09-20T00:00:00Z' },
+  { claim_id: 9002, task_id: 702, title: 'someone else holds this', builder_id: 8, github_login: 'annabeth', display_name: 'Annabeth', claimed_at: '2026-09-20T00:00:00Z' },
+];
+
+const SHIPPED = [
+  { id: 801, title: 'I shipped this', github_login: 'percy', shipped_at: '2026-09-21T00:00:00Z' },
+  { id: 802, title: 'they shipped this', github_login: 'annabeth', shipped_at: '2026-09-21T00:00:00Z' },
+];
+
+// ---------------------------------------------------------------------------
+// bootWorkBoard — run the REAL work.js in a vm.
+//
+// `goalsFail: true` makes GET /goals reject, which is the failure mode the lens
+// has to survive honestly: with no membership evidence it must switch itself off
+// rather than narrow both queue tabs to nothing.
+// ---------------------------------------------------------------------------
+function bootWorkBoard({ signedIn = true, goalsFail = false } = {}) {
+  const els = new Map();
+  const makeEl = (id = '') => ({
+    id,
+    dataset: {}, style: {}, textContent: '', hidden: false, disabled: false,
+    checked: false, value: '', title: '',
+    _html: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; },
+    listeners: {},
+    addEventListener(type, fn) { (this.listeners[type] ||= []).push(fn); },
+    fire(type, ev = {}) { (this.listeners[type] || []).forEach((fn) => fn(ev)); },
+    querySelector() { return null; }, querySelectorAll() { return []; },
+    appendChild() {}, remove() {}, closest() { return null; },
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+  // Keyed by the selector text with the leading '#' stripped, so a compound
+  // selector like '#wip-table tbody' gets its own stable element — which is
+  // what work.js reads the in-flight rows out of.
+  const el = (key) => { if (!els.has(key)) els.set(key, makeEl(key)); return els.get(key); };
+  const documentObj = {
+    getElementById: (id) => el(id),
+    querySelector: (sel) => el(String(sel).replace(/^#/, '')),
+    querySelectorAll: () => [],
+    createElement: () => makeEl(),
+    addEventListener(type, fn) { (this.listeners[type] ||= []).push(fn); },
+    listeners: {},
+    body: { dataset: {} }, documentElement: { dataset: {} },
+    hidden: false,
+  };
+
+  const requests = [];
+  const client = {
+    request: async (method, url) => {
+      requests.push(`${method} ${url}`);
+      const ok = (data) => ({ status: 200, ok: true, data });
+      if (url.endsWith('/me')) {
+        // `signedIn: false` is a 200 that carries NO builder, not a 401: a 401
+        // bounces this page to sign-in before anything renders (and the server
+        // page gate bars an unauthenticated visitor from /work outright), so the
+        // identity-less state the lens actually has to survive is this one.
+        return signedIn
+          ? ok({ builder: { id: 7, display_name: 'Percy', github_login: 'percy', rank: 'metic' }, task_kinds: ['build'] })
+          : ok({ builder: null });
+      }
+      if (url.endsWith('/goals')) {
+        return goalsFail ? { status: 500, ok: false, data: null } : ok({ goals: GOALS });
+      }
+      if (url.includes('/tasks/claimable')) return ok({ claimable: CLAIMABLE, active_claims: ACTIVE_CLAIMS });
+      if (url.includes('/tasks?status=backlog')) return ok({ tasks: BACKLOG });
+      if (url.includes('/public/recent-shipped')) return ok({ tasks: SHIPPED });
+      if (url.includes('/versions')) return ok({ versions: [{ version_id: 'V1' }] });
+      if (url.includes('/public/progress')) return ok({ progress: [{ version_id: 'V1', lifecycle_shipped_count: 42 }] });
+      if (url.includes('/public/cost-summary')) return ok({ total_value_credits: 1234 });
+      return ok({});
+    },
+  };
+
+  const escapeHtml = (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+
+  let tabsOnChange = null;
+  const kit = {
+    makePager: (prefix) => ({ prefix, page: 1, perPage: 100 }),
+    paginate: (rows) => rows,
+    wirePager() {},
+    pagerBarHtml: () => '',
+    makeTabs: ({ tabs, onChange }) => {
+      let current = tabs[0].id;
+      tabsOnChange = onChange;
+      return { active: () => current, setCount() {}, activate(id) { current = id; onChange(id); } };
+    },
+    // The real bar is hall-kit's; here it only has to MAKE the controls readable,
+    // because what this suite asserts is what the renderers do with their values.
+    makeFilterBar: ({ search, primary = [], overflow = [] }) => {
+      [search, ...primary, ...overflow].filter(Boolean).forEach((c) => {
+        el(c.id).value = c.value ?? c.default ?? '';
+      });
+      return { values: () => ({}), get: () => '', set() {} };
+    },
+    ageChipHtml: () => '',
+  };
+
+  const windowObj = {
+    __BRANDING__: { currency: { label: 'credits' } },
+    BongosClient: { createClient: () => client },
+    OTBKit: kit,
+    OTBTaskDetail: { href: (id) => `/task/${id}`, open() {} },
+    OTBTaskLib: {
+      priorityRank: () => 0, touchesConflict: () => false, rankTagHtml: () => '',
+      creditsPerMinute: () => 0, buildPromptForTask: () => '', friendlyBatchReason: () => '',
+      taskActivityMs: () => 0, STALE_CHOICES: [{ value: '', label: '— any —' }], isStale: () => false,
+    },
+    OTB: {
+      escapeHtml,
+      $: (sel) => documentObj.querySelector(sel),
+      fmtNum: (n) => String(n ?? 0),
+      fmtDate: (d) => String(d ?? '').slice(0, 10),
+      errCode: () => null, errDetails: () => ({}),
+      toast() {},
+      categoryChip: () => '',
+      fillKindFilter() {},
+      kindIsUnset: () => true, KIND_UNSET: 'unclassified',
+      roleAxisLabel: () => 'Role',
+      roleOptions: () => [{ value: '', label: '— any —' }],
+      roleIsUnset: () => true, roleLabel: () => '', ROLE_UNSET: 'unclassified',
+    },
+    location: { hostname: 'builders.example.com', pathname: '/work', search: '', hash: '', href: 'https://builders.example.com/work' },
+    localStorage: { getItem: () => null, setItem() {}, removeItem() {} },
+    confirm: () => true,
+    addEventListener() {},
+  };
+
+  const sandbox = {
+    window: windowObj, document: documentObj, location: windowObj.location,
+    localStorage: windowObj.localStorage, console, setTimeout, clearTimeout,
+    setInterval: () => 0, clearInterval() {}, Date, URL, URLSearchParams, navigator: {},
+    history: { replaceState() {} },
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  // Both are UMD modules that attach to the sandbox global rather than to
+  // `window` (there is no `module` here), so they are bridged across by hand.
+  vm.runInContext(MINE_LENS_JS, sandbox, { filename: 'mine-lens.js' });
+  vm.runInContext(WORK_SUMMARY_JS, sandbox, { filename: 'work-summary.js' });
+  windowObj.OTBMineLens = sandbox.OTBMineLens;
+  windowObj.OTBWorkSummary = sandbox.OTBWorkSummary;
+  vm.runInContext(WORK_JS, sandbox, { filename: 'work.js' });
+  (documentObj.listeners.DOMContentLoaded || []).forEach((fn) => fn());
+
+  return {
+    el,
+    requests,
+    // Flip the lens the way a click does: set the box, then fire its listener.
+    setMine: (on) => { el('f-mine').checked = on; el('f-mine').fire('change'); },
+    switchTab: (id) => { if (tabsOnChange) tabsOnChange(id); },
+  };
+}
+
+// settle() twice: loadAll awaits /me, then the goals read, then the claimable
+// read, and the history feed lands on its own promise chain.
+const ready = async (board) => { for (let i = 0; i < 6; i += 1) await settle(); return board; };
+
+// ---------------------------------------------------------------------------
+// 1. The queue tabs: "mine" is GOAL MEMBERSHIP
+// ---------------------------------------------------------------------------
+
+test('Ready narrows to tasks in a goal the viewer is a member of', async () => {
+  const b = await ready(bootWorkBoard());
+  const before = b.el('task-list').innerHTML;
+  assert.match(before, /ready in my goal/, 'the unfiltered board shows both goals');
+  assert.match(before, /ready in their goal/);
+
+  b.setMine(true);
+  const after = b.el('task-list').innerHTML;
+  assert.match(after, /ready in my goal/, 'the task in my goal survives');
+  assert.doesNotMatch(after, /ready in their goal/, 'the task in a goal I am not on is gone');
+});
+
+test('a task with NO goal is not "mine" — the lens is membership, not leftovers', async () => {
+  const b = await ready(bootWorkBoard());
+  assert.match(b.el('task-list').innerHTML, /ready with no goal/, 'it is there unfiltered');
+  b.setMine(true);
+  assert.doesNotMatch(b.el('task-list').innerHTML, /ready with no goal/,
+    'an ungoaled task belongs to nobody, so it cannot arrive under "only mine"');
+});
+
+test('Backlog narrows through the SAME predicate, so the lens cannot reach one tab only', async () => {
+  const b = await ready(bootWorkBoard());
+  assert.match(b.el('backlog-list').innerHTML, /backlog in their goal/);
+  b.setMine(true);
+  assert.match(b.el('backlog-list').innerHTML, /backlog in my goal/);
+  assert.doesNotMatch(b.el('backlog-list').innerHTML, /backlog in their goal/);
+});
+
+// ---------------------------------------------------------------------------
+// 2. In Progress: "mine" is THE CLAIM
+// ---------------------------------------------------------------------------
+
+test('In Progress narrows to the claims the viewer is holding', async () => {
+  const b = await ready(bootWorkBoard());
+  const tbody = b.el('wip-table tbody');
+  assert.match(tbody.innerHTML, /someone else holds this/, 'unfiltered, the whole board is in flight');
+
+  b.setMine(true);
+  assert.match(tbody.innerHTML, /a claim of mine/);
+  assert.doesNotMatch(tbody.innerHTML, /someone else holds this/,
+    "another builder's live claim is not mine");
+});
+
+test('the in-flight SECTION pill counts what is shown; the TAB pill keeps the whole board', async () => {
+  // The distinction is the point: narrowing to my own claims must not make the
+  // board look idle. The tab pill is the project's in-flight count either way.
+  const b = await ready(bootWorkBoard());
+  assert.equal(b.el('wip-count').textContent, '2');
+  b.setMine(true);
+  assert.equal(b.el('wip-count').textContent, '1', 'the section pill follows the narrowed list');
+});
+
+test('holding nothing says so, instead of reading as a quiet board', async () => {
+  const b = await ready(bootWorkBoard());
+  // Hand the page an in-flight list with none of the viewer's own claims by
+  // flipping the lens on a fixture where builder 7 holds one — then assert the
+  // OTHER direction: a viewer who holds nothing gets the specific sentence.
+  ACTIVE_CLAIMS[0].builder_id = 8;
+  try {
+    b.setMine(true);
+    assert.match(b.el('wip-table tbody').innerHTML, /You are not holding any claims right now/,
+      'the empty state names the lens, not the project');
+  } finally {
+    ACTIVE_CLAIMS[0].builder_id = 7;
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 3. Completed: "mine" is WHO SHIPPED IT
+// ---------------------------------------------------------------------------
+
+test('Completed narrows to the viewer\'s own ships, matched on the login the public feed carries', async () => {
+  const b = await ready(bootWorkBoard());
+  assert.match(b.el('history-list').innerHTML, /they shipped this/);
+  b.setMine(true);
+  assert.match(b.el('history-list').innerHTML, /I shipped this/);
+  assert.doesNotMatch(b.el('history-list').innerHTML, /they shipped this/);
+});
+
+// ---------------------------------------------------------------------------
+// 4. The two ways the lens must refuse rather than lie
+// ---------------------------------------------------------------------------
+
+test('with no identity the lens is disabled — never a checkbox that empties every tab', async () => {
+  const b = await ready(bootWorkBoard({ signedIn: false }));
+  assert.equal(b.el('f-mine').disabled, true);
+  assert.equal(b.el('f-mine').checked, false);
+  assert.match(b.el('f-mine').title, /Sign in/);
+});
+
+test('a failed membership read disarms the lens instead of answering "you are on no goals"', async () => {
+  const b = await ready(bootWorkBoard({ goalsFail: true }));
+  assert.equal(b.el('f-mine').disabled, true,
+    'with no evidence the lens is off the table');
+  assert.match(b.el('f-mine').title, /could not be loaded/,
+    'and it says the read failed rather than implying an answer');
+  // The board itself is untouched — losing the lens must not lose the queue.
+  assert.match(b.el('task-list').innerHTML, /ready in their goal/);
+});
+
+// ---------------------------------------------------------------------------
+// 5. The word means something different on each tab, so the hint is rewritten
+// ---------------------------------------------------------------------------
+
+test('the hint beside the checkbox is re-read from the tab, not left generic', async () => {
+  const b = await ready(bootWorkBoard());
+  const hint = b.el('work-mine-hint');
+  assert.equal(hint.textContent, 'tasks in goals you are on', 'Ready opens the board');
+  b.switchTab('in-progress');
+  assert.equal(hint.textContent, 'claims you are holding');
+  b.switchTab('completed');
+  assert.equal(hint.textContent, 'tasks you shipped');
+  b.switchTab('backlog');
+  assert.equal(hint.textContent, 'tasks in goals you are on');
+});
+
+// ---------------------------------------------------------------------------
+// 6. It costs nothing to ask
+// ---------------------------------------------------------------------------
+
+test('the lens is answered from data the board already fetched — no read per goal', async () => {
+  const b = await ready(bootWorkBoard());
+  const before = b.requests.length;
+  b.setMine(true);
+  assert.equal(b.requests.length, before,
+    'flipping the lens makes no request: viewer_is_member rides the goal list');
+  assert.ok(b.requests.some((r) => r.endsWith('/goals')),
+    'and the goal list is the one read it depends on');
+  assert.ok(!b.requests.some((r) => /\/goals\/\d+\/members/.test(r)),
+    'never a membership read per goal');
+});
+
+// ---------------------------------------------------------------------------
+// 7. The carve: work-summary.js
+//
+// The momentum card left work.js so the lens could fit under the size ceiling.
+// Two things have to stay true across that move — it still paints, and it still
+// reports the PROJECT, not the viewer. The second is the risk the carve created:
+// the card sits directly above a list the lens narrows, and a card that quietly
+// restated one builder's output as the project's totals would look right.
+// ---------------------------------------------------------------------------
+
+test('the momentum card still renders the project-wide figures after the carve', async () => {
+  const b = await ready(bootWorkBoard());
+  const card = b.el('works-summary');
+  assert.equal(card.hidden, false, 'the card is shown once the shipped counts land');
+  assert.match(card.innerHTML, /Works shipped/);
+  assert.match(card.innerHTML, /42/, 'the all-time shipped count');
+  assert.match(card.innerHTML, /1234/, 'and the credits awarded');
+});
+
+test('"Only mine" does NOT narrow the project totals above the list it narrows', async () => {
+  const b = await ready(bootWorkBoard());
+  const before = b.el('works-summary').innerHTML;
+  b.setMine(true);
+  assert.equal(b.el('works-summary').innerHTML, before,
+    'the card reports the project; the lens reports the reader');
+});