@bongos/core 1.19.659 → 1.19.661

package/tests/hall_board_world.mjs

@@ -471,3 +471,106 @@ test('the tab strip is left alone — it scrolls in its own row and never moved
   assert.ok(strip, 'the tab strip rule is present');
   assert.match(strip[1], /overflow-x:\s*auto/, 'it scrolls itself, which is why it is not the overflow cause');
 });
+
+// ---- the board's filters drive BOTH queue tabs (task 1003828) ---------------
+//
+// The owner reported an auto-filed artist review as "going into uncategorized
+// BONGOS-V2 backlog tasks" and asked for tasks to be "filterable by role type".
+// The review was never uncategorised — cascade.js inherits its parent's goal —
+// but the Backlog tab it lands on could not say so and could not be narrowed:
+//
+//   * renderBacklog() applied the SEARCH BOX ONLY. Version, Goal, Kind,
+//     Discipline, Newcomer and Run mode were read inside renderClaimable and
+//     nowhere else, so six controls were silently inert over the tab holding the
+//     most rows. Nothing errored; the list simply did not change.
+//   * The filter bar was INSIDE #claim-scroll, which makeTabs hides. So on the
+//     Backlog tab those controls were not merely inert — they were off-screen.
+//   * A backlog row rendered id + title + version + rank + kind. No goal, no
+//     discipline. A correctly-goaled task genuinely read as uncategorised.
+//
+// Each is invisible in a browser the way this file's other entries are: the page
+// renders, it just renders a control that does nothing.
+
+const workJs = read('work.js');
+
+test('the filter bar is above the panels, not inside the Ready one that gets hidden', () => {
+  const filters = workHtml.indexOf('id="work-filters"');
+  const tabs = workHtml.indexOf('id="work-tabs"');
+  const claim = workHtml.indexOf('id="claim-scroll"');
+  assert.ok(filters > 0 && tabs > 0 && claim > 0, 'all three mounts present');
+  assert.ok(filters > tabs, 'the bar follows the tab strip it belongs to');
+  assert.ok(filters < claim,
+    'and precedes the Ready panel — inside it, makeTabs hides the filters with the tab');
+});
+
+test('the bar shows on the two QUEUE tabs and hides on the two that it cannot narrow', () => {
+  assert.match(workJs, /const FILTERED_TABS = new Set\(\['ready', 'backlog'\]\)/,
+    'Ready and Backlog are task feeds; In Progress and Completed render other objects');
+  assert.match(workJs, /function syncFilterBarVisibility/);
+  // Wired BOTH ways: on a tab change, and once at boot — makeTabs restores a
+  // deep-linked tab (/work#completed) before the bar is built, and fires
+  // onChange only on a CHANGE, so opening state has to be set explicitly.
+  assert.match(workJs, /onChange: \(id\) => \{[\s\S]{0,160}syncFilterBarVisibility\(id\)/,
+    'a tab change re-syncs the bar');
+  assert.match(workJs, /syncFilterBarVisibility\(workTabs && workTabs\.active \? workTabs\.active\(\) : 'ready'\)/,
+    'and the opening tab decides the opening state');
+});
+
+test('both queue tabs narrow through ONE predicate, so a filter cannot reach only one', () => {
+  assert.match(workJs, /function matchesBoardFilters\(t, f\)/,
+    'the predicate is shared, not copied per tab');
+  // Both renderers must consult it. This is the whole defect: before, only the
+  // claimable one did.
+  const claimable = workJs.slice(workJs.indexOf('function renderClaimable'), workJs.indexOf('async function populateCreatorFilter'));
+  const backlog = workJs.slice(workJs.indexOf('function renderBacklog'), workJs.indexOf('async function refreshLive'));
+  for (const [name, body] of [['renderClaimable', claimable], ['renderBacklog', backlog]]) {
+    assert.ok(body.length, `${name} body located`);
+    assert.match(body, /matchesBoardFilters\(t, filters\)/, `${name} narrows through the shared predicate`);
+    assert.match(body, /applyRunMode\(list, \$\('#f-fit'\)/, `${name} applies the set-relative run-mode lens too`);
+  }
+});
+
+test('a backlog row names its craft and its goal', () => {
+  const backlog = workJs.slice(workJs.indexOf('function renderBacklog'));
+  // The same vocabulary the Ready card has carried since 1755 — a second spelling
+  // would let the two tabs describe one task differently.
+  assert.match(backlog, /const discipline = t\.discipline \|\| 'unclassified'/);
+  assert.match(backlog, /disciplineTag/, 'the row renders the discipline tag');
+  assert.match(backlog, /taskState\.goalTitles \|\| \{\}/, 'the goal is named by TITLE, not by bare id');
+  assert.match(backlog, /'No goal'/, 'and a goal-less row says so rather than rendering a gap');
+  assert.ok(rule(workCss, '.history__goal'), '.history__goal has a rule — an unstyled sub-line inherits the title size');
+});
+
+test('the backlog asks the SERVER the narrow question, because its read is capped', () => {
+  // A client-side-only narrow of a capped read LIES: filtering the 500 fetched
+  // rows to the artist ones hides the artist tasks that sat at row 501.
+  assert.match(workJs, /function backlogFilterQuery/);
+  const q = workJs.slice(workJs.indexOf('function backlogFilterQuery'), workJs.indexOf('BACKLOG_LIMIT ='));
+  for (const param of ['version=', 'kind=', 'discipline=', 'goal_id=']) {
+    assert.ok(q.includes(param), `the backlog read sends ${param} — GET /tasks answers it`);
+  }
+  // '__none__' (ungoaled) has no server predicate, so it must not be sent.
+  assert.match(q, /f\.goal && f\.goal !== '__none__'/,
+    "the client-only 'No goal' lens is never sent to the route");
+  // It reads through boardFilterValues rather than re-querying the DOM, so the
+  // query and the client predicate can never disagree about a control's value.
+  assert.match(q, /const f = boardFilterValues\(\);/);
+  // And it stays SEPARATE from the claimable query: GET /tasks/claimable answers
+  // only version + discipline, so kind/goal_id there would be a silent no-op.
+  const claimQ = workJs.slice(workJs.indexOf('function serverFilterQuery'), workJs.indexOf('task 1003828 — the BACKLOG'));
+  assert.ok(!claimQ.includes('goal_id='), 'the claimable feed is not sent goal_id');
+  assert.ok(!claimQ.includes('kind='), 'nor kind');
+});
+
+test('each feed decides its own re-fetch, so a server change cannot strand the other tab', () => {
+  // The old shape compared ONE query and returned early, which left the other
+  // tab's client-side lenses unapplied until the next poll happened to repaint.
+  assert.match(workJs, /if \(q !== lastServerFilterQuery\) \{ lastServerFilterQuery = q; refreshLive\(\); \} else \{ renderClaimable\(\); \}/);
+  assert.match(workJs, /if \(bq !== lastBacklogQuery\) \{ lastBacklogQuery = bq; loadBacklog\(\); \} else \{ renderBacklog\(\); \}/);
+});
+
+test('the Goal filter offers goals that only have BACKLOG work', () => {
+  const populate = workJs.slice(workJs.indexOf('function populateGoalFilter'), workJs.indexOf('async function copyPromptForTask'));
+  assert.match(populate, /\[\.\.\.taskState\.all, \.\.\.\(taskState\.backlog \|\| \[\]\)\]/,
+    'built from the claimable feed alone, a backlog-only goal was unofferable');
+});