@bongos/core 1.21.58 → 1.21.60

package/tests/filter_views.mjs

@@ -0,0 +1,144 @@
+// tests/filter_views.mjs — saved filter views (task 1004553): the pure storage rules
+// in modules/builder-settings/filter-views.js and the own-scoped /me/filter-views
+// routes, run against a fake prefs store keyed by builder. No DB needed.
+//
+// Run:  node --test tests/filter_views.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const fv = require('../modules/builder-settings/filter-views.js');
+
+// One behavior_prefs blob per builder — the column the routes really write.
+const rows = new Map();
+const db = require('../modules/builder-settings/db.js');
+db.getBuilderBehaviorPrefs = async (id) => rows.get(id) || {};
+db.setBuilderBehaviorPrefs = async (id, prefs) => { rows.set(id, prefs); return prefs; };
+const router = require('../modules/builder-settings/routes/settings.js')();
+
+const src = (rel) => readFileSync(new URL('../' + rel, import.meta.url), 'utf8');
+
+function handler(method, path) {
+  const layer = router.stack.find((l) => l.route && l.route.path === path && l.route.methods[method]);
+  assert.ok(layer, `${method} ${path} is registered`);
+  return layer.route.stack[layer.route.stack.length - 1].handle;
+}
+async function call(method, path, { builder, body, query = {}, params = {} }) {
+  const out = { status: 200, body: null };
+  const res = {
+    status(s) { out.status = s; return this; },
+    json(b) { out.body = b; return this; },
+    fail(code, opts) { out.status = (opts && opts.status) || 400; out.body = { error: { code, message: opts && opts.message } }; return this; },
+  };
+  await handler(method, path)({ builder, body, query, params }, res);
+  return out;
+}
+const ALICE = { id: 1, rank: 'thetes' };
+const BOB = { id: 2, rank: 'metic' };
+
+test('saving a view keeps sibling prefs and only what was sent', () => {
+  const r = fv.saveView({ wandering: 'low' }, 'goals', { name: '  My  open goals ', values: { 'f-goal-status': 'open' } });
+  assert.equal(r.ok, true);
+  assert.equal(r.prefs.wandering, 'low', 'sibling knobs survive');
+  assert.deepEqual(r.view, { id: 1, name: 'My open goals', values: { 'f-goal-status': 'open' }, is_default: false });
+});
+
+test('saving under an existing name updates that view instead of adding a second', () => {
+  let p = fv.saveView({}, 'goals', { name: 'Mine', values: { a: '1' } }).prefs;
+  p = fv.saveView(p, 'goals', { name: 'mine', values: { a: '2' } }).prefs;
+  const list = fv.listViews(p, 'goals');
+  assert.equal(list.length, 1);
+  assert.deepEqual(list[0].values, { a: '2' });
+});
+
+test('only one view per page is the default', () => {
+  let p = fv.saveView({}, 'goals', { name: 'A', values: {}, is_default: true }).prefs;
+  p = fv.saveView(p, 'goals', { name: 'B', values: {}, is_default: true }).prefs;
+  assert.deepEqual(fv.listViews(p, 'goals').map((v) => [v.name, v.is_default]), [['A', false], ['B', true]]);
+  p = fv.updateView(p, 'goals', 1, { is_default: true }).prefs;
+  assert.deepEqual(fv.listViews(p, 'goals').map((v) => v.is_default), [true, false]);
+  p = fv.updateView(p, 'goals', 1, { is_default: false }).prefs;
+  assert.deepEqual(fv.listViews(p, 'goals').map((v) => v.is_default), [false, false]);
+});
+
+test('pages keep separate lists, and deleting the last view leaves no empty key behind', () => {
+  let p = fv.saveView({}, 'goals', { name: 'G', values: {} }).prefs;
+  p = fv.saveView(p, 'work', { name: 'W', values: {} }).prefs;
+  assert.deepEqual(fv.listViews(p, 'work').map((v) => v.name), ['W']);
+  p = fv.deleteView(p, 'goals', 1).prefs;
+  p = fv.deleteView(p, 'work', 1).prefs;
+  assert.equal(fv.RESERVED_KEY in p, false);
+});
+
+test('bad input is refused with a readable reason', () => {
+  assert.equal(fv.saveView({}, 'Goals!', { name: 'x', values: {} }).ok, false);
+  assert.equal(fv.saveView({}, 'goals', { name: '   ', values: {} }).ok, false);
+  assert.equal(fv.saveView({}, 'goals', { name: 'x'.repeat(61), values: {} }).ok, false);
+  assert.equal(fv.saveView({}, 'goals', { name: 'x', values: [] }).ok, false);
+  assert.equal(fv.saveView({}, 'goals', { name: 'x', values: { 'f-a': 3 } }).ok, false);
+  let p = {};
+  for (let i = 0; i < fv.MAX_VIEWS_PER_PAGE; i++) p = fv.saveView(p, 'goals', { name: `v${i}`, values: {} }).prefs;
+  assert.match(fv.saveView(p, 'goals', { name: 'one more', values: {} }).errors[0], /at most/);
+  let q = fv.saveView({}, 'goals', { name: 'A', values: {} }).prefs;
+  q = fv.saveView(q, 'goals', { name: 'B', values: {} }).prefs;
+  assert.match(fv.updateView(q, 'goals', 2, { name: 'a' }).errors[0], /already have/);
+});
+
+test('a builder saves a view and reads it back from a fresh request (another device)', async () => {
+  rows.clear();
+  const saved = await call('post', '/me/filter-views', { builder: ALICE, body: { page: 'goals', name: 'Open', values: { 'f-goal-status': 'open' }, is_default: true } });
+  assert.equal(saved.status, 201);
+  const got = await call('get', '/me/filter-views', { builder: ALICE, query: { page: 'goals' } });
+  assert.deepEqual(got.body.views, [{ id: 1, name: 'Open', values: { 'f-goal-status': 'open' }, is_default: true }]);
+});
+
+test('another builder cannot see, rename, default or delete it', async () => {
+  const seen = await call('get', '/me/filter-views', { builder: BOB, query: { page: 'goals' } });
+  assert.deepEqual(seen.body.views, []);
+  const patch = await call('patch', '/me/filter-views/:id', { builder: BOB, params: { id: '1' }, body: { page: 'goals', name: 'Hijacked' } });
+  assert.equal(patch.status, 404);
+  const del = await call('delete', '/me/filter-views/:id', { builder: BOB, params: { id: '1' }, query: { page: 'goals' } });
+  assert.equal(del.status, 404);
+  const still = await call('get', '/me/filter-views', { builder: ALICE, query: { page: 'goals' } });
+  assert.equal(still.body.views[0].name, 'Open', 'Alice\'s view is untouched');
+});
+
+test('the owner renames and deletes their own view', async () => {
+  const ren = await call('patch', '/me/filter-views/:id', { builder: ALICE, params: { id: '1' }, body: { page: 'goals', name: 'Open goals' } });
+  assert.equal(ren.body.view.name, 'Open goals');
+  const del = await call('delete', '/me/filter-views/:id', { builder: ALICE, params: { id: '1' }, query: { page: 'goals' } });
+  assert.deepEqual(del.body.views, []);
+});
+
+test('a missing page is a 400; a wrong-shaped body is refused before it is stored; a bad value is a 422', async () => {
+  rows.clear();
+  assert.equal((await call('get', '/me/filter-views', { builder: ALICE, query: {} })).status, 400);
+  assert.equal((await call('post', '/me/filter-views', { builder: ALICE, body: { page: 'goals', name: 'x' } })).status, 400, 'values missing');
+  assert.equal((await call('post', '/me/filter-views', { builder: ALICE, body: { page: 'goals', name: 'x', values: {}, owner: 2 } })).status, 400, 'unknown field');
+  assert.equal((await call('post', '/me/filter-views', { builder: ALICE, body: { page: 'goals', name: '   ', values: {} } })).status, 422);
+  assert.equal(rows.size, 0, 'nothing was written');
+});
+
+test('every route is own-scoped: requireBuilder, and no id from the request picks the builder', () => {
+  const routes = src('modules/builder-settings/routes/settings.js');
+  for (const m of ['get', 'post', 'patch', 'delete']) {
+    assert.match(routes, new RegExp(`router\\.${m}\\('/me/filter-views[^']*', api\\.requireBuilder,`));
+  }
+  const block = routes.slice(routes.indexOf("'/me/filter-views'"), routes.indexOf('Per-builder DISPLAY NAME'));
+  assert.doesNotMatch(block, /BehaviorPrefs\((?!req\.builder\.id)/, 'prefs are only ever read/written for req.builder.id');
+});
+
+test('both pages opt in, and apply my default view before the focus version', () => {
+  const work = src('modules/hall-ui/public/work.js');
+  assert.match(work, /views: \{ page: 'work', client: api, base: `\$\{API\}\/me\/filter-views` \}/);
+  assert.match(work, /applyDefault\(\{ fire: true \}\)[\s\S]{0,160}!applied && applyFocusVersion\(focusResp\)/);
+  const goals = src('modules/hall-ui/public/goals-page.js');
+  assert.match(goals, /views: \{ page: 'goals', client: api, base: `\$\{API\}\/me\/filter-views` \}/);
+  assert.match(goals, /if \(!\(views && await views\.applyDefault\(\{ fire: false \}\)\)\) applyFocusVersion\(focusResp\);/);
+  const kit = src('modules/hall-ui/public/hall-kit.js');
+  assert.match(kit, /if \(!\(await ready\) \|\| urlHasFilter\) return false;/, 'a URL filter beats my default view');
+});

package/tests/focus_version_filter_default.mjs

@@ -0,0 +1,48 @@
+// tests/focus_version_filter_default.mjs — the Goals page and Tasks board open their
+// Version filter on the project's focus version (task 1004552). The decision is the
+// pure task-lib helper; the two pages are pinned to calling it after their options fill.
+//
+// Run:  node --test tests/focus_version_filter_default.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { focusVersionDefault } = require('../modules/hall-ui/public/task-lib.js');
+const src = (rel) => readFileSync(new URL('../' + rel, import.meta.url), 'utf8');
+const opts = ['', 'BONGOS-V1', 'BONGOS-V2'];
+
+test('a starred version is the default the filter opens on', () => {
+  assert.equal(focusVersionDefault({ focusId: 'BONGOS-V2', optionValues: opts, current: '' }), 'BONGOS-V2');
+});
+
+test('no focus leaves the filter on any — nothing is guessed', () => {
+  for (const focusId of [null, undefined, '']) {
+    assert.equal(focusVersionDefault({ focusId, optionValues: opts, current: '' }), null);
+  }
+});
+
+test('a URL filter wins over the focus default', () => {
+  assert.equal(focusVersionDefault({ focusId: 'BONGOS-V2', optionValues: opts, current: '', urlValue: 'BONGOS-V1' }), null);
+});
+
+test('a choice the builder already made wins over the focus default', () => {
+  assert.equal(focusVersionDefault({ focusId: 'BONGOS-V2', optionValues: opts, current: 'BONGOS-V1' }), null);
+});
+
+test('a focus the select has no option for is left alone, not selected as a blank', () => {
+  assert.equal(focusVersionDefault({ focusId: 'BONGOS-V9', optionValues: opts, current: '' }), null);
+});
+
+test('both pages read the focus and apply it after their version options fill', () => {
+  const work = src('modules/hall-ui/public/work.js');
+  assert.match(work, /\/versions\/focus/);
+  // task 1004553 moved the call after the Goal options fill, behind the builder's default view.
+  assert.match(work, /restoreUrlFilter\('f-goal'\)[\s\S]{0,600}!applied && applyFocusVersion\(focusResp\)/);
+  const goals = src('modules/hall-ui/public/goals-page.js');
+  assert.match(goals, /\/versions\/focus/);
+  assert.match(goals, /populateVersionFilter\(\);[\s\S]{0,400}applyFocusVersion\(focusResp\);/);
+  for (const page of [work, goals]) assert.match(page, /OTBTaskLib\.focusVersionDefault\(/);
+});

package/tests/hall_mine_lens.mjs

@@ -166,6 +166,7 @@ function bootWorkBoard({ signedIn = true, goalsFail = false } = {}) {
       priorityRank: () => 0, touchesConflict: () => false, conflictPeers: () => [], conflictChipHtml: () => '', rankTagHtml: () => '',
       creditsPerMinute: () => 0, buildPromptForTask: () => '', friendlyBatchReason: () => '',
       taskActivityMs: () => 0, STALE_CHOICES: [{ value: '', label: '— any —' }], isStale: () => false,
+      focusVersionDefault: () => null,
     },
     OTB: {
       escapeHtml,