@bongos/core 1.19.971 → 1.19.973

package/tests/goal_mine_lens.mjs

@@ -0,0 +1,233 @@
+// tests/goal_mine_lens.mjs — the goal board's half of the hall's "mine" lens:
+// the goals you are added on, and inside one goal, the tasks you are holding.
+//
+// Two things are pinned here, and both are the kind that render fine while being
+// wrong:
+//
+//   * "My goals" NOW READS THE ROW. The lens used to answer membership out of the
+//     per-goal DETAIL prefetch — a best-effort fan-out. When that fan-out had not
+//     landed, or had failed, every goal answered "not a member" and the lens
+//     returned an empty board: an assertion about the READER, manufactured out of
+//     a failed fetch. GET /goals now carries `viewer_is_member`, so the lens has
+//     evidence that arrives with the list it is filtering.
+//   * A GOAL'S TO-DO LIST CAN BE NARROWED TO YOUR OWN CLAIMS, which is the board's
+//     "Only mine" question scoped to one goal.
+//
+// Executes the REAL goals-page.js + goals-render.js in a vm against the stub DOM
+// this repo uses in place of jsdom — the tests/goal_criterion_confirm_ui.mjs
+// precedent, and for its stated reason: it is the only way a renderer bug is
+// caught rather than a source string.
+//
+// Run:  node --test tests/goal_mine_lens.mjs
+
+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';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const hall = (f) => fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public', f), 'utf8');
+const TASK_LIB_SRC = hall('task-lib.js');
+const GOALS_LIB_SRC = hall('goals-lib.js');
+// goal-forest-lib.js is loaded so the detail view's dependency forest does not
+// throw on the #/goal/N tests; nothing here asserts on it. It is a UMD module
+// that attaches to the sandbox global rather than to `window`, so it is bridged
+// across by hand after it runs.
+const GOAL_FOREST_LIB_SRC = hall('goal-forest-lib.js');
+const GOAL_FOREST_RENDER_SRC = hall('goal-forest-render.js');
+const GOALS_RENDER_SRC = hall('goals-render.js');
+const GOALS_PAGE_SRC = hall('goals-page.js');
+
+const ME_ID = 1;
+
+// Boot goals-page.js.
+//   `filters`  — control values seeded BEFORE boot, so the first render already
+//                runs under the lens (the stub filter bar fires no onChange).
+//   `detailsFail` — the per-goal detail prefetch rejects, which is the exact
+//                state that used to empty the "My goals" board.
+async function boot({
+  hash = '',
+  goals = [],
+  tasks = [],
+  activeClaims = [],
+  filters = {},
+  detailsFail = false,
+} = {}) {
+  const requests = [];
+  const els = new Map();
+  const makeEl = (key) => ({
+    _key: key, dataset: {}, style: {}, title: '', textContent: '', hidden: false,
+    disabled: false, value: '', innerHTML: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; }, removeAttribute() {},
+    appendChild() {}, focus() {}, click() {}, querySelectorAll() { return []; },
+    addEventListener() {},
+  });
+  const $ = (sel) => {
+    if (!sel) return null;
+    if (!els.has(sel)) els.set(sel, makeEl(sel));
+    return els.get(sel);
+  };
+  // Seed the lens controls before anything reads them.
+  for (const [id, value] of Object.entries(filters)) $(`#${id}`).value = value;
+
+  const api = {
+    request(method, p) {
+      requests.push([method, p]);
+      const reply = (data, status = 200) => Promise.resolve({ status, ok: true, data });
+      if (method === 'GET' && /\/me$/.test(p)) return reply({ builder: { id: ME_ID, rank: 'metic' }, active_claims: [] });
+      if (method === 'GET' && /\/goals$/.test(p)) return reply({ goals });
+      if (method === 'GET' && /\/goals\/\d+$/.test(p)) {
+        if (detailsFail) return Promise.resolve({ status: 500, ok: false, data: null });
+        const id = Number(p.match(/\/goals\/(\d+)$/)[1]);
+        const goal = goals.find((g) => Number(g.id) === id) || goals[0];
+        return reply({ goal, members: [], criteria: [], dependencies: [] });
+      }
+      if (method === 'GET' && /\/tasks\/claimable/.test(p)) return reply({ claimable: [], active_claims: activeClaims });
+      if (method === 'GET' && /\/tasks\?/.test(p)) return reply({ tasks });
+      if (method === 'GET' && /\/conflicts$/.test(p)) return reply({ pairs: [] });
+      if (method === 'GET' && /\/requests$/.test(p)) return reply({ requests: [] });
+      return reply({});
+    },
+  };
+
+  const windowObj = {
+    OTB: {
+      roleAxisLabel: () => 'Role',
+      roleLabel: (d) => String(d || ''),
+      roleOptions: () => [{ value: '', label: '— any —' }],
+      roleIsUnset: () => true,
+      ROLE_UNSET: 'unclassified',
+      KIND_UNSET: 'unclassified',
+      kindIsUnset: () => true,
+      escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[ch])),
+      $, fmtNum: (n) => String(n), fmtDate: () => '', rankLabel: (r) => r,
+      toast() {}, categoryChip: () => '', fillKindFilter() {},
+    },
+    OTBKit: {
+      makePager: (prefix) => ({ prefix, page: 1, perPage: 50 }),
+      paginate: (rows) => rows,
+      wirePager() {}, pagerBarHtml: () => '',
+      makeTabs: () => ({ setCount() {}, select() {}, activate() {} }),
+      makeFilterBar() {},
+      emptyStateHtml: (m) => `<div class="kit-empty">${m}</div>`,
+      skeletonRows: () => '',
+      ageChipHtml: () => '',
+    },
+    OTBBranding: { currencyLabel: () => 'credits', taskSettled: () => false, taskCreditValue: () => 0 },
+    OTBTaskDetail: { href: (id) => `/task/${id}`, open() {} },
+    BongosClient: { createClient: () => api },
+    location: { hash, pathname: '/builders/goals', search: '', assign() {} },
+    addEventListener() {},
+    scrollTo() {},
+    matchMedia: () => ({ matches: false, addEventListener() {} }),
+    localStorage: { getItem() { return null; }, setItem() {} },
+  };
+  const documentObj = {
+    body: { dataset: {} },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } } },
+    getElementById: (id) => $(`#${id}`),
+    querySelector: (sel) => $(sel),
+    querySelectorAll: () => [],
+    createElement: () => makeEl('created'),
+    addEventListener() {},
+  };
+
+  const sandbox = {
+    window: windowObj, document: documentObj, location: windowObj.location,
+    console, setTimeout, clearTimeout, Set, Map, Number, String, Array, Object,
+    JSON, Math, encodeURIComponent, Promise, Date, URLSearchParams,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(TASK_LIB_SRC, sandbox, { filename: 'task-lib.js' });
+  vm.runInContext(GOALS_LIB_SRC, sandbox, { filename: 'goals-lib.js' });
+  vm.runInContext(GOAL_FOREST_LIB_SRC, sandbox, { filename: 'goal-forest-lib.js' });
+  windowObj.OTBGoalForestLib = sandbox.OTBGoalForestLib;
+  vm.runInContext(GOAL_FOREST_RENDER_SRC, sandbox, { filename: 'goal-forest-render.js' });
+  vm.runInContext(GOALS_RENDER_SRC, sandbox, { filename: 'goals-render.js' });
+  vm.runInContext(GOALS_PAGE_SRC, sandbox, { filename: 'goals-page.js' });
+  for (let i = 0; i < 30; i += 1) await new Promise((r) => setTimeout(r, 0));
+
+  return { requests, el: (sel) => $(sel) };
+}
+
+const GOALS = [
+  { id: 11, version_id: 'V1', title: 'Goal I am on', status: 'open', visibility: 'public', created_by: 999, scope_modules: [], viewer_is_member: true },
+  { id: 12, version_id: 'V1', title: 'Goal I am not on', status: 'open', visibility: 'public', created_by: 999, scope_modules: [], viewer_is_member: false },
+];
+
+// ---------------------------------------------------------------------------
+// 1. "My goals" — the goals you are added on
+// ---------------------------------------------------------------------------
+
+test('the goal board shows both goals with the lens off', async () => {
+  const { el } = await boot({ goals: GOALS });
+  const grid = el('#goal-grid').innerHTML;
+  assert.match(grid, /Goal I am on/);
+  assert.match(grid, /Goal I am not on/);
+});
+
+test('"My goals" keeps the goals the viewer is a member of and drops the rest', async () => {
+  const { el } = await boot({ goals: GOALS, filters: { 'f-goal-mine': 'mine' } });
+  const grid = el('#goal-grid').innerHTML;
+  assert.match(grid, /Goal I am on/);
+  assert.doesNotMatch(grid, /Goal I am not on/);
+});
+
+// The regression this change exists for. Before `viewer_is_member`, membership
+// was read from the per-goal detail — so a failed prefetch answered "you are on
+// none of them" and the lens rendered an empty board.
+test('"My goals" still answers when the per-goal detail prefetch FAILS', async () => {
+  const { el } = await boot({ goals: GOALS, filters: { 'f-goal-mine': 'mine' }, detailsFail: true });
+  const grid = el('#goal-grid').innerHTML;
+  assert.match(grid, /Goal I am on/,
+    'the row carries the membership, so a dead detail read cannot empty the lens');
+  assert.doesNotMatch(grid, /Goal I am not on/);
+});
+
+// A deploy whose server has not yet grown the flag must fall back rather than
+// answer "no" — the boolean check is what makes the fallback reachable.
+test('a goal row WITHOUT the flag falls back to the detail instead of reading as "not mine"', async () => {
+  const legacy = GOALS.map(({ viewer_is_member, ...g }) => g); // eslint-disable-line no-unused-vars
+  const { el } = await boot({ goals: legacy, filters: { 'f-goal-mine': 'mine' } });
+  // The stub's detail returns members: [], so nothing matches — the point is that
+  // the page consulted the detail at all rather than short-circuiting on a
+  // missing field, and that it did not crash.
+  assert.ok(el('#goal-grid').innerHTML.length > 0, 'the board still renders');
+});
+
+// ---------------------------------------------------------------------------
+// 2. Inside one goal — the tasks you have claimed
+// ---------------------------------------------------------------------------
+
+const GOAL_TASKS = [
+  { id: 301, title: 'held by me', status: 'active', goal_id: 11, touches: [] },
+  { id: 302, title: 'held by someone else', status: 'active', goal_id: 11, touches: [] },
+  { id: 303, title: 'nobody has claimed this', status: 'ready', goal_id: 11, touches: [] },
+];
+const GOAL_CLAIMS = [
+  { claim_id: 1, task_id: 301, builder_id: ME_ID, github_login: 'me', display_name: 'Me' },
+  { claim_id: 2, task_id: 302, builder_id: 999, github_login: 'them', display_name: 'Them' },
+];
+
+test("a goal's To-do list shows every open task with the lens off", async () => {
+  const { el } = await boot({ hash: '#/goal/11', goals: GOALS, tasks: GOAL_TASKS, activeClaims: GOAL_CLAIMS });
+  const list = el('#goal-todo-list').innerHTML;
+  for (const title of ['held by me', 'held by someone else', 'nobody has claimed this']) {
+    assert.match(list, new RegExp(title), `${title} is there unfiltered`);
+  }
+});
+
+test('"claimed by me" narrows a goal\'s To-do list to the viewer\'s own claims', async () => {
+  const { el } = await boot({
+    hash: '#/goal/11', goals: GOALS, tasks: GOAL_TASKS, activeClaims: GOAL_CLAIMS,
+    filters: { 'f-goal-claimed': 'mine' },
+  });
+  const list = el('#goal-todo-list').innerHTML;
+  assert.match(list, /held by me/);
+  assert.doesNotMatch(list, /held by someone else/, "another builder's claim is not mine");
+  assert.doesNotMatch(list, /nobody has claimed this/, 'an unclaimed task is nobody\'s');
+});

package/tests/goal_tier.mjs

@@ -116,14 +116,15 @@ await test('getGoal: unknown id returns null (not undefined)', async () => {
 // =========================================================================
 // listGoals
 // =========================================================================
-await test('listGoals: no args binds [null, null, null] (all three filters off)', async () => {
+await test('listGoals: no args binds [null, null, null, null] (every filter off, no viewer)', async () => {
   const pool = fakePool((s) => (/FROM goals/.test(s) ? { rows: [GOAL_ROW] } : null));
   const out = await listGoals(undefined, { pool });
   assert.deepEqual(out, [GOAL_ROW]);
   const sel = find(pool.queries, /FROM goals/);
   // task 1002539 added an OPTIONAL limit. Postgres treats `LIMIT NULL` as unbounded,
   // so the goal board's read is byte-for-byte unchanged in behaviour.
-  assert.deepEqual(sel.params, [null, null, null]);
+  // $4 is the viewer whose membership `viewer_is_member` answers; null = nobody.
+  assert.deepEqual(sel.params, [null, null, null, null]);
   assert.match(sel.sql, /ORDER BY version_id, sort_order, created_at, id/, 'priority-first, then stable ordering');
   assert.match(sel.sql, /LIMIT \$3::int/, 'the limit is bound, never interpolated');
 });
@@ -131,13 +132,38 @@ await test('listGoals: no args binds [null, null, null] (all three filters off)'
 await test('listGoals: versionId + status flow through to the bound params', async () => {
   const pool = fakePool((s) => (/FROM goals/.test(s) ? { rows: [] } : null));
   await listGoals({ versionId: 'BONGOS-V1', status: 'open' }, { pool });
-  assert.deepEqual(find(pool.queries, /FROM goals/).params, ['BONGOS-V1', 'open', null]);
+  assert.deepEqual(find(pool.queries, /FROM goals/).params, ['BONGOS-V1', 'open', null, null]);
 });
 
 await test('listGoals: an explicit limit is bound so Postgres truncates, not JS', async () => {
   const pool = fakePool((s) => (/FROM goals/.test(s) ? { rows: [] } : null));
   await listGoals({ versionId: 'BONGOS-V1', status: 'open', limit: 6 }, { pool });
-  assert.deepEqual(find(pool.queries, /FROM goals/).params, ['BONGOS-V1', 'open', 6]);
+  assert.deepEqual(find(pool.queries, /FROM goals/).params, ['BONGOS-V1', 'open', 6, null]);
+});
+
+// The "goals I am added on" half of the hall's Only-mine lens. The board asks this
+// of a list it already fetches, so the answer has to ride the row rather than cost
+// a membership read per goal.
+await test('listGoals: a viewer binds as $4 and the row carries viewer_is_member', async () => {
+  const pool = fakePool((s) => (/FROM goals/.test(s) ? { rows: [] } : null));
+  await listGoals({ viewerId: 77 }, { pool });
+  const sel = find(pool.queries, /FROM goals/);
+  assert.deepEqual(sel.params, [null, null, null, 77]);
+  assert.match(sel.sql, /AS viewer_is_member/, 'the flag is named on the wire');
+  assert.match(sel.sql, /EXISTS \(SELECT 1 FROM goal_members gm[\s\S]*?gm\.builder_id = \$4::bigint\)/,
+    'and it is an EXISTS over goal_members for THAT builder');
+});
+
+// A NULL viewer must yield false, never NULL: the client branches on
+// `typeof g.viewer_is_member === 'boolean'` to decide whether the server answered
+// at all, so a three-valued column would make "nobody is reading" indistinguishable
+// from "this deploy does not send the flag" and silently re-arm the empty-lens bug.
+await test('listGoals: a viewer-less read still answers the flag with a BOOLEAN false', async () => {
+  const pool = fakePool((s) => (/FROM goals/.test(s) ? { rows: [] } : null));
+  await listGoals({}, { pool });
+  const sel = find(pool.queries, /FROM goals/);
+  assert.match(sel.sql, /\(\$4::bigint IS NOT NULL\s*\n?\s*AND EXISTS/,
+    'the NULL case is short-circuited to false before the EXISTS is consulted');
 });
 
 // =========================================================================