@bongos/core 1.19.295 → 1.19.297

package/tests/idea_spark_queue.mjs

@@ -0,0 +1,233 @@
+// tests/idea_spark_queue.mjs
+//
+// task 1002921 (BV1.R145, goal 1000062) — the spark queue.
+//
+// The done-when, as assertions: the GET returns OPEN sparks NOT YET DEVELOPED,
+// newest first; a DEVELOPED spark leaves the queue; and the queue is readable by
+// ANY builder (a Xenos included — it is a pickup surface, and the author's R144
+// mark is the consent).
+//
+// It also pins two things that are load-bearing but invisible in a passing app:
+// the DECLARATION ORDER against `GET /inbox/:id` (which would otherwise capture
+// the literal "sparks" and 400 the whole queue), and the fact that the count and
+// the list share one predicate — a pill that disagrees with its rows is the
+// classic version of this bug.
+//
+// DB-free the idea_full_capture.mjs way: pool.query patched on the doorway before
+// the modules load, so the REAL SQL is captured and the REAL handler runs.
+//
+// Run:  node tests/idea_spark_queue.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const api = require('../src/module-api.js');
+
+let queries = [];
+let listRows = [];
+let countN = 0;
+
+api.pool.query = async (sql, params = []) => {
+  queries.push({ sql, params });
+  if (/COUNT\(\*\)/i.test(sql)) return { rows: [{ n: countN }] };
+  return { rows: listRows };
+};
+
+const inbox = require('../modules/ideas/inbox.js');
+const routesFactory = require('../modules/ideas/routes/inbox.js');
+const router = routesFactory({});
+
+const mounted = router.stack.filter((l) => l.route)
+  .map((l) => `${Object.keys(l.route.methods)[0].toUpperCase()} ${l.route.path}`);
+
+function handlerFor(pathStr, method) {
+  const layer = router.stack.find((l) => l.route && l.route.path === pathStr && l.route.methods[method]);
+  assert.ok(layer, `route ${method.toUpperCase()} ${pathStr} is not mounted`);
+  const stack = layer.route.stack.map((s) => s.handle);
+  return stack[stack.length - 1];
+}
+const getSparks = handlerFor('/inbox/sparks', 'get');
+
+function call({ query = {}, rank = 'metic' } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = { params: {}, body: {}, query, builder: { id: '9', rank } };
+    const res = {
+      statusCode: 200,
+      status(c) { this.statusCode = c; return this; },
+      json(payload) { resolve({ status: this.statusCode, payload }); },
+      fail(code, status, extra) {
+        const s = typeof status === 'number' ? status : (status && status.status) || 500;
+        resolve({ status: s, payload: { error: code, ...(extra || {}) } });
+      },
+    };
+    Promise.resolve(getSparks(req, res, (err) => reject(err || new Error('next() called')))).catch(reject);
+  });
+}
+
+const listSql = () => queries.find((q) => !/COUNT\(\*\)/i.test(q.sql));
+const countSql = () => queries.find((q) => /COUNT\(\*\)/i.test(q.sql));
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  queries = [];
+  listRows = [];
+  countN = 0;
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- declaration order: the bug that would 400 the whole queue -----------
+
+await test('GET /inbox/sparks is declared BEFORE GET /inbox/:id', () => {
+  const iSparks = mounted.indexOf('GET /inbox/sparks');
+  const iId = mounted.indexOf('GET /inbox/:id');
+  assert.ok(iSparks >= 0, 'the spark queue route is mounted');
+  assert.ok(iId >= 0, 'the by-id read is mounted');
+  assert.ok(
+    iSparks < iId,
+    `declaration order is load-bearing: with :id first, "/inbox/sparks" binds id="sparks" and parseId 400s the queue (sparks@${iSparks}, :id@${iId})`,
+  );
+});
+
+// --- the predicate: open, undeveloped sparks, newest first ---------------
+
+await test('the queue asks for grade=spark AND status=open — nothing else', async () => {
+  const r = await call();
+  assert.equal(r.status, 200);
+  const sql = listSql().sql;
+  assert.match(sql, /g\.grade = 'spark'/, 'only sparks');
+  assert.match(sql, /i\.status = 'open'/, 'only open ideas');
+});
+
+await test('a DEVELOPED spark leaves the queue by GRADE, not by a `developed` filter', async () => {
+  await call();
+  const sql = listSql().sql;
+  // R146 develops in place and flips the grade spark→full, so grade='spark' IS
+  // "not yet developed". A second source of truth could disagree with the grade.
+  //
+  // The invariant is about the PREDICATE, so only the predicate is asserted.
+  // R146 later added developed_by/developed_at to the SELECT list (attribution
+  // rides along on every idea read) — that is not a filter and must not trip this.
+  const predicate = sql.slice(sql.search(/\bWHERE\b/i));
+  assert.doesNotMatch(predicate, /developed/i, 'nothing in the WHERE keys off a developed flag');
+  assert.doesNotMatch(predicate, /promoted_to_task_id\s*IS\s*NULL/i, 'exit is the grade flip, not a promote link');
+  // And the positive half, so the two tasks' expectations are explicit rather
+  // than merely non-conflicting: the attribution IS returned.
+  assert.match(sql, /g\.developed_by/, 'who developed it rides along on the read (R146)');
+});
+
+await test('newest first, with a stable tiebreak', async () => {
+  await call();
+  assert.match(listSql().sql, /ORDER BY i\.captured_at DESC, i\.id DESC/);
+});
+
+await test('an INNER join from ideas_grades — a spark is never implicit', async () => {
+  await call();
+  const sql = listSql().sql;
+  // Inverted from every other idea read on purpose: absence of a grade row means
+  // 'quick', so a spark ALWAYS has a real row, and starting from ideas_grades
+  // lets ideas_grades_grade_score_idx drive the scan.
+  assert.match(sql, /FROM ideas_grades g/, 'driven by the graded table');
+  assert.match(sql, /JOIN idea_inbox i ON i\.id = g\.idea_id/);
+  assert.doesNotMatch(sql, /LEFT JOIN ideas_grades/, 'not the COALESCE-to-quick read shape');
+});
+
+await test('the author is named — attribution is the point of a pickup surface', async () => {
+  listRows = [{ id: '5', title: 'a spark', captured_by: '3', grade: 'spark', filed_by_login: 'someone' }];
+  const r = await call();
+  assert.match(listSql().sql, /github_login/);
+  assert.equal(r.payload.sparks[0].filed_by_login, 'someone');
+});
+
+// --- the count cannot disagree with the list ----------------------------
+
+await test('count and list share ONE predicate', async () => {
+  countN = 7;
+  const r = await call();
+  assert.equal(r.payload.count, 7);
+  const l = listSql().sql;
+  const c = countSql().sql;
+  for (const clause of [/g\.grade = 'spark'/, /i\.status = 'open'/]) {
+    assert.match(l, clause);
+    assert.match(c, clause, 'the pill must not claim sparks the list will not show');
+  }
+});
+
+// --- readable by ANY builder -------------------------------------------
+
+await test('a XENOS can read the queue — the R144 mark is the consent', async () => {
+  listRows = [{ id: '5', title: 'a spark', grade: 'spark' }];
+  const r = await call({ rank: 'xenos' });
+  assert.equal(r.status, 200, 'no rank gate on a pickup surface');
+  assert.equal(r.payload.sparks.length, 1);
+});
+
+await test('but the skill-friction visibility gate still applies, to BOTH halves', async () => {
+  await call({ rank: 'xenos' });
+  const l = listSql();
+  const c = countSql();
+  assert.match(l.sql, /i\.title NOT LIKE/, 'a Xenos does not see routine-filed friction rows');
+  assert.match(c.sql, /i\.title NOT LIKE/, 'nor are they counted for them');
+  assert.ok(l.params.some((p) => typeof p === 'string' && p.endsWith('%')));
+
+  queries = [];
+  await call({ rank: 'archon' });
+  assert.doesNotMatch(listSql().sql, /i\.title NOT LIKE/, 'a trusted rank sees everything');
+});
+
+// --- limit -------------------------------------------------------------
+
+await test('limit defaults to 50 and is clamped to 1..100', async () => {
+  await call();
+  assert.equal(listSql().params.at(-1), 50, 'default');
+
+  for (const [given, want] of [['10', 10], ['0', 50], ['-5', 50], ['1000', 50], ['abc', 50], ['100', 100]]) {
+    queries = [];
+    await call({ query: { limit: given } });
+    assert.equal(listSql().params.at(-1), want, `limit=${given}`);
+  }
+});
+
+await test('the count query takes no limit — it counts the whole queue', async () => {
+  await call({ query: { limit: '5' } });
+  assert.equal(countSql().params.length, 0, 'a trusted viewer adds no filter param, and the count never takes the limit');
+});
+
+// --- the CLI's rendering of the queue ------------------------------------
+
+const { renderQueue } = require('../scripts/gds/spark.js');
+
+await test('the empty queue reads as an ANSWER, not a blank screen', () => {
+  const out = renderQueue({ sparks: [], count: 0 });
+  assert.match(out, /No sparks are awaiting development/);
+  assert.match(out, /mark one of your own/, 'it says what to do next');
+});
+
+await test('each row links to the HALL, never a bare #NNN', () => {
+  const out = renderQueue({
+    sparks: [{ id: '812', title: 'a thought', filed_by_login: 'someone', captured_at: '2026-08-20T10:11:12Z' }],
+    count: 1,
+  });
+  // A bare "#NNN" autolinks to a GitHub issue and 404s — our ids are not
+  // GitHub's. The hall deep-link resolver form is /builders/#/idea/N.
+  assert.match(out, /\/builders\/#\/idea\/812/);
+  assert.doesNotMatch(out, /(^|[^/])#812\b/, 'no bare ref');
+  assert.match(out, /@someone/, 'the author is named');
+  assert.match(out, /2026-08-20/);
+});
+
+await test('a missing author degrades to prose, not "@undefined"', () => {
+  const out = renderQueue({ sparks: [{ id: '1', title: 't', filed_by_login: null }], count: 1 });
+  assert.match(out, /an unnamed builder/);
+  assert.doesNotMatch(out, /undefined|null/);
+});
+
+await test('the header distinguishes "showing N" from the true total', () => {
+  assert.match(renderQueue({ sparks: [{ id: '1', title: 't' }], count: 5 }), /5 sparks awaiting development \(showing 1\)/);
+  assert.match(renderQueue({ sparks: [{ id: '1', title: 't' }], count: 1 }), /^1 spark awaiting development:/m, 'singular, no "showing"');
+});
+
+console.log(`\nidea_spark_queue: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);