@bongos/core 1.19.299 → 1.19.301

package/tests/idea_detail_page.mjs

@@ -0,0 +1,397 @@
+// tests/idea_detail_page.mjs
+//
+// task 1002929 (BV1.R153, goal 1000062) — the idea-detail page (/idea/:id).
+//
+// The done-when, as assertions:
+//   1. a Full Idea is legible end to end — every question and every answer, in
+//      TEMPLATE order, plus the score;
+//   2. a QUICK idea renders on the same page with NO empty five-field skeleton —
+//      five headings over five dashes is not an empty state, it is a page telling
+//      a builder they were wrong to file a quick idea;
+//   3. spark AND developer attribution are both visible — R146's whole point is
+//      that the author survives being developed by someone else, so a developed
+//      idea must name two people.
+//
+// The page renders by string-building into #idea-body, so this executes the real
+// render path in a minimal DOM stub (the hall_nav.mjs / hall_signout.mjs pattern)
+// and asserts over the HTML a viewer would actually get. Pure vm + file read.
+//
+// Run:  node tests/idea_detail_page.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const SRC = fs.readFileSync(path.join(HALL, 'idea.js'), 'utf8');
+
+const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+
+// The template as GET /inbox/template projects it (R152's shape).
+const TEMPLATE = {
+  key: BASE_TEMPLATE.key,
+  label: BASE_TEMPLATE.label,
+  fields: BASE_TEMPLATE.fields.map((f) => ({ key: f.key, label: f.label, required: !!f.required, substance_min: f.substanceMin || 0 })),
+};
+
+// Boot idea.js against a stub DOM + a stub client that answers with `idea`, and
+// return the HTML it wrote into #idea-body.
+function render(idea, { template = TEMPLATE, templateFails = false, ideaStatus = 200, viewer = null, sparkResult = null } = {}) {
+  const els = new Map();
+  const makeEl = () => ({
+    dataset: {}, style: {}, textContent: '', hidden: false, _html: '',
+    classList: { add() {}, remove() {}, toggle() { return false; }, contains() { return false; } },
+    setAttribute() {}, getAttribute() { return null; },
+    _handlers: {},
+    addEventListener(type, fn) { this._handlers[type] = fn; },
+    querySelector() { return makeEl(); }, querySelectorAll() { return []; }, appendChild() {},
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+  });
+
+  const documentObj = {
+    title: '',
+    body: { dataset: { page: 'idea' } },
+    documentElement: { dataset: {}, style: {}, classList: { add() {}, remove() {} } },
+    getElementById(id) { if (!els.has(id)) els.set(id, makeEl()); return els.get(id); },
+    querySelector(sel) { return this.getElementById(String(sel).replace(/^#/, '')); },
+    querySelectorAll() { return []; },
+    createElement() { return makeEl(); },
+    addEventListener() {},
+  };
+
+  const calls = [];
+  const client = {
+    inbox: {
+      getInboxId: async (args) => { calls.push(['idea', args]); return { status: ideaStatus, ok: ideaStatus === 200, data: { idea } }; },
+      getInboxTemplate: async (args) => {
+        calls.push(['template', args]);
+        if (templateFails) return { status: 500, ok: false, data: null };
+        return { status: 200, ok: true, data: { template } };
+      },
+      // R154's mark control. `sparkResult` lets a test drive the failure path.
+      postInboxIdSpark: async (args) => {
+        calls.push(['spark', args]);
+        return sparkResult || { status: 200, ok: true, data: { idea: { ...idea, grade: 'spark' }, sparked: true } };
+      },
+      deleteInboxIdSpark: async (args) => {
+        calls.push(['unspark', args]);
+        return sparkResult || { status: 200, ok: true, data: { idea: { ...idea, grade: 'quick' }, sparked: false } };
+      },
+    },
+    // The page reads /me for the author-only control (R154).
+    me: { getMe: async () => { calls.push(['me', null]); return { status: 200, ok: true, data: { builder: viewer } }; } },
+  };
+
+  const windowObj = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => client },
+    OTB: {
+      escapeHtml: (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c])),
+      $: (sel) => documentObj.querySelector(sel),
+      fmtDate: (iso) => String(iso).slice(0, 10),
+      toast() {},
+    },
+    location: { hostname: 'builders.cloudbongos.com', pathname: `/idea/${idea && idea.id ? idea.id : '1'}`, assign() {} },
+    addEventListener() {},
+  };
+
+  const sandbox = { window: windowObj, document: documentObj, location: windowObj.location, console, setTimeout, clearTimeout };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SRC, sandbox, { filename: 'idea.js' });
+
+  return {
+    html: () => documentObj.getElementById('idea-body').innerHTML,
+    calls,
+    documentObj,
+    // The mark button is written via innerHTML, so the stub DOM has no real
+    // element for it — idea.js looks it up with $('#ig-mark-btn'), which resolves
+    // to the memoised stub, so its captured click handler is the click.
+    clickMark: () => {
+      const btn = documentObj.getElementById('ig-mark-btn');
+      return btn._handlers.click ? btn._handlers.click() : null;
+    },
+    markBtn: () => documentObj.getElementById('ig-mark-btn'),
+  };
+}
+
+// The render is async (two awaits at most), so let the microtask queue drain.
+const settle = () => new Promise((r) => setTimeout(r, 0));
+
+const FULL_VALUES = Object.fromEntries(BASE_TEMPLATE.fields.map((f, i) => [f.key, `Answer number ${i + 1}, with enough words in it to read like a real answer.`]));
+
+const fullIdea = {
+  id: '812', title: 'A shared changelog', status: 'open', kind: 'feature',
+  body_md: 'the original quick thought', captured_by: '9', captured_at: '2026-08-01T00:00:00Z',
+  grade: 'full', template_key: 'base-v1', field_values: FULL_VALUES, completeness_score: 88,
+  filed_by_login: 'thinker', developed_by: '42', developed_at: '2026-08-20T00:00:00Z', developed_by_login: 'someone',
+};
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- done-when 1: a Full Idea is legible end to end ---------------------
+
+await test('a Full Idea shows every question and every answer, in template order', async () => {
+  const r = render(fullIdea);
+  await settle();
+  const html = r.html();
+  let cursor = -1;
+  for (const f of TEMPLATE.fields) {
+    const qAt = html.indexOf(f.label);
+    assert.ok(qAt > -1, `the question "${f.label}" is on the page`);
+    assert.ok(qAt > cursor, 'questions appear in TEMPLATE order, not jsonb key order');
+    cursor = qAt;
+    assert.ok(html.includes(FULL_VALUES[f.key]), `the answer for ${f.key} is on the page`);
+  }
+});
+
+await test('the score is shown as a number and a bar', async () => {
+  const r = render(fullIdea);
+  await settle();
+  assert.match(r.html(), /88\/100 complete/);
+  assert.match(r.html(), /width:88%/);
+});
+
+await test('a Full Idea with no score says so instead of drawing a zero', async () => {
+  const r = render({ ...fullIdea, completeness_score: null });
+  await settle();
+  assert.match(r.html(), /Not scored/);
+  assert.doesNotMatch(r.html(), /0\/100/);
+});
+
+await test('a blank answer on a Full Idea is marked, not hidden', async () => {
+  const { fit, ...four } = FULL_VALUES;
+  const r = render({ ...fullIdea, field_values: four });
+  await settle();
+  // It is information: it is WHY the score is what it is.
+  assert.ok(r.html().includes('Not answered'));
+  const label = TEMPLATE.fields.find((f) => f.key === 'fit').label;
+  assert.ok(r.html().includes(label), 'the unanswered question is still shown');
+});
+
+// --- done-when 2: a quick idea gets NO five-field skeleton --------------
+
+await test('a QUICK idea shows its body and NOT one of the five questions', async () => {
+  const r = render({
+    id: '5', title: 'a quick thought', status: 'open', body_md: 'just the thought',
+    captured_by: '9', captured_at: '2026-08-01T00:00:00Z', grade: 'quick',
+    template_key: null, field_values: null, completeness_score: null,
+    filed_by_login: 'thinker', developed_by: null, developed_at: null, developed_by_login: null,
+  });
+  await settle();
+  const html = r.html();
+  assert.ok(html.includes('just the thought'));
+  for (const f of TEMPLATE.fields) {
+    assert.ok(!html.includes(f.label), `a quick idea must not show the question "${f.label}"`);
+  }
+  assert.doesNotMatch(html, /Not answered/, 'and no empty answer rows either');
+  assert.doesNotMatch(html, /\/100 complete/, 'nor a completeness bar it has no score for');
+});
+
+await test('a quick idea costs ONE request — the labels are only needed for a full one', async () => {
+  const r = render({ id: '5', title: 't', status: 'open', body_md: 'b', grade: 'quick', captured_by: '9' });
+  await settle();
+  // Asserted as "no TEMPLATE call", not "exactly one call": R154 added a /me read
+  // for the author-only mark control, which is a legitimate second request. The
+  // invariant was always about the template — the expensive one a quick idea has
+  // no use for — so it is asserted directly rather than via a total count.
+  const kinds = r.calls.map((c) => c[0]);
+  assert.ok(!kinds.includes('template'), 'no template fetch for a quick idea');
+  assert.ok(kinds.includes('idea'), 'the idea itself is read');
+});
+
+await test('a SPARK shows its body, no skeleton, and says it is open for development', async () => {
+  const r = render({
+    id: '7', title: 'a spark', status: 'open', body_md: 'the seed', grade: 'spark',
+    captured_by: '9', captured_at: '2026-08-01T00:00:00Z', filed_by_login: 'thinker',
+  });
+  await settle();
+  const html = r.html();
+  assert.ok(html.includes('the seed'));
+  assert.match(html, /Big Idea Spark/);
+  assert.match(html, /needing development/);
+  for (const f of TEMPLATE.fields) assert.ok(!html.includes(f.label), 'a spark has no five-field skeleton either');
+});
+
+// --- done-when 3: both attributions visible ----------------------------
+
+await test('a developed idea names TWO people, in their two roles', async () => {
+  const r = render(fullIdea);
+  await settle();
+  const html = r.html();
+  assert.match(html, /@thinker/);
+  assert.match(html, /had the thought/);
+  assert.match(html, /@someone/);
+  assert.match(html, /developed it into a Full Idea/);
+  // The author must come first: the thought precedes the development, and R146
+  // exists so being developed does not displace the person who had it.
+  assert.ok(html.indexOf('@thinker') < html.indexOf('@someone'));
+});
+
+await test('an UNdeveloped idea names one person and invents no developer', async () => {
+  const r = render({ ...fullIdea, developed_by: null, developed_at: null, developed_by_login: null });
+  await settle();
+  const html = r.html();
+  assert.match(html, /had the thought/);
+  assert.doesNotMatch(html, /developed it/);
+});
+
+await test('self-development reads as one person doing both, not a handoff', async () => {
+  const r = render({ ...fullIdea, developed_by: '9', developed_by_login: 'thinker' });
+  await settle();
+  assert.match(r.html(), /developed it themselves/);
+});
+
+await test('a missing login degrades to the builder id, never "@undefined"', async () => {
+  const r = render({ ...fullIdea, filed_by_login: null, developed_by_login: null });
+  await settle();
+  const html = r.html();
+  assert.match(html, /builder 9/);
+  assert.match(html, /builder 42/);
+  assert.doesNotMatch(html, /@undefined|@null|undefined/);
+});
+
+// --- grade badge + plumbing --------------------------------------------
+
+await test('the grade is named in WORDS, not only in colour', async () => {
+  for (const [grade, word] of [['full', 'Full Idea'], ['spark', 'Big Idea Spark'], ['quick', 'Quick idea']]) {
+    const r = render({ ...fullIdea, grade, ...(grade === 'full' ? {} : { field_values: null }) });
+    await settle();
+    assert.ok(r.html().includes(word), `${grade} is spelled "${word}"`);
+  }
+});
+
+await test('an unknown grade falls back to quick rather than rendering nothing', async () => {
+  const r = render({ id: '1', title: 't', body_md: 'b', grade: 'something-new', captured_by: '9' });
+  await settle();
+  assert.match(r.html(), /Quick idea/);
+  assert.ok(r.html().includes('b'));
+});
+
+await test('a template outage still renders the answers, without inventing an order', async () => {
+  const r = render(fullIdea, { templateFails: true });
+  await settle();
+  const html = r.html();
+  assert.match(html, /Could not load the question labels/);
+  for (const v of Object.values(FULL_VALUES)) assert.ok(html.includes(v), 'the answers are still readable');
+});
+
+await test('a promoted idea links to the task it became', async () => {
+  const r = render({ ...fullIdea, status: 'promoted', promoted_to_task_id: '1234' });
+  await settle();
+  assert.match(r.html(), /\/task\/1234/);
+});
+
+await test('a 404 says which idea is missing rather than failing blank', async () => {
+  const r = render({ id: '99' }, { ideaStatus: 404 });
+  await settle();
+  assert.match(r.html(), /No idea 99/);
+});
+
+// --- R154: the mark control is AUTHOR-ONLY ------------------------------
+
+const AUTHOR = { id: '9', github_login: 'thinker' };
+const OTHER = { id: '77', github_login: 'someone-else' };
+const quick = {
+  id: '5', title: 'a quick thought', status: 'open', body_md: 'just the thought',
+  captured_by: '9', captured_at: '2026-08-01T00:00:00Z', grade: 'quick',
+  filed_by_login: 'thinker',
+};
+
+await test('the AUTHOR of an open quick idea is offered the mark', async () => {
+  const r = render(quick, { viewer: AUTHOR });
+  await settle();
+  assert.match(r.html(), /Mark as a Big Idea Spark/);
+});
+
+await test('a NON-author is not — the wall is the route, this is the cosmetic half', async () => {
+  const r = render(quick, { viewer: OTHER });
+  await settle();
+  assert.doesNotMatch(r.html(), /Mark as a Big Idea Spark/);
+  assert.doesNotMatch(r.html(), /Withdraw the spark/);
+});
+
+await test('a signed-out or unknown viewer is offered nothing', async () => {
+  const r = render(quick, { viewer: null });
+  await settle();
+  assert.doesNotMatch(r.html(), /Mark as a Big Idea Spark/);
+});
+
+await test('an author looking at their own SPARK is offered the withdrawal', async () => {
+  const r = render({ ...quick, grade: 'spark' }, { viewer: AUTHOR });
+  await settle();
+  assert.match(r.html(), /Withdraw the spark mark/);
+  assert.doesNotMatch(r.html(), /Mark as a Big Idea Spark/);
+});
+
+await test('no control on a FULL idea — R144 refuses it, so offering it teaches the rule wrong', async () => {
+  const r = render({ ...fullIdea, captured_by: '9' }, { viewer: AUTHOR });
+  await settle();
+  assert.doesNotMatch(r.html(), /Big Idea Spark<\/button>|Mark as a Big Idea Spark/);
+});
+
+await test('no control on a CLOSED idea — marking requires status=open', async () => {
+  for (const status of ['promoted', 'discarded', 'merged']) {
+    const r = render({ ...quick, status }, { viewer: AUTHOR });
+    await settle();
+    assert.doesNotMatch(r.html(), /Mark as a Big Idea Spark/, `status=${status}`);
+  }
+});
+
+await test('marking calls the spark route and re-renders from the SERVER response', async () => {
+  const r = render(quick, { viewer: AUTHOR });
+  await settle();
+  await r.clickMark();
+  await settle();
+  assert.ok(r.calls.some((c) => c[0] === 'spark'), 'POST /inbox/:id/spark was called');
+  // Re-rendered from what came back, not from a locally flipped flag.
+  assert.match(r.html(), /Big Idea Spark/);
+  assert.match(r.html(), /Withdraw the spark mark/);
+});
+
+await test('withdrawing calls the DELETE side', async () => {
+  const r = render({ ...quick, grade: 'spark' }, { viewer: AUTHOR });
+  await settle();
+  await r.clickMark();
+  await settle();
+  assert.ok(r.calls.some((c) => c[0] === 'unspark'));
+  assert.match(r.html(), /Quick idea/);
+});
+
+await test('a refusal shows the server\'s reason, in the author\'s terms', async () => {
+  const { envelope } = require('../src/bongos/api-errors.js');
+  const cases = [
+    ['not_your_idea', /Only the builder who filed this idea/],
+    ['not_a_quick_idea', /already a Full Idea/],
+    ['idea_not_open', /no longer open/],
+  ];
+  for (const [code, expect] of cases) {
+    const r = render(quick, { viewer: AUTHOR, sparkResult: { status: 409, ok: false, data: envelope(code) } });
+    await settle();
+    await r.clickMark();
+    await settle();
+    assert.match(r.documentObj.getElementById('ig-mark-err').textContent, expect, code);
+  }
+});
+
+await test('a failed mark re-enables the button rather than dead-ending', async () => {
+  const { envelope } = require('../src/bongos/api-errors.js');
+  const r = render(quick, { viewer: AUTHOR, sparkResult: { status: 500, ok: false, data: envelope('boom') } });
+  await settle();
+  await r.clickMark();
+  await settle();
+  assert.equal(r.markBtn().disabled, false);
+});
+
+console.log(`\nidea_detail_page: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/idea_hall_composer.mjs

@@ -242,5 +242,56 @@ await test('neither read touches the database', async () => {
   assert.equal(touched, 0, 'both are pure — which is what makes a call per keystroke reasonable');
 });
 
+// --- R154: the spark queue + develop mode, as source invariants ----------
+//
+// The composer's runtime is exercised through the page's own DOM in
+// tests/idea_spark_hall.mjs; these are the invariants that are cheapest and most
+// durable to assert over the source, because each one is a rule about WHICH
+// endpoint gets called and a mistake in it silently does the wrong write.
+
+await test('develop mode files through the DEVELOP route, not a new capture', () => {
+  assert.match(IDEAS_JS, /postInboxIdDevelop/, 'developing calls POST /inbox/:id/develop');
+  assert.match(IDEAS_JS, /postInbox\b/, 'and filing a new idea still calls POST /inbox');
+  // The fork must be on the develop id, not on anything guessable from the form.
+  assert.match(IDEAS_JS, /DEVELOP_ID\s*\n?\s*\?\s*await api\.inbox\.postInboxIdDevelop/, 'the fork keys off the develop id');
+});
+
+await test('a develop POST carries no title and no grade', () => {
+  // The row already has both, and R146 preserves them along with its author —
+  // sending either would be this surface asserting authority over someone else's
+  // idea. Scoped to the develop branch so the new-capture body is unaffected.
+  const from = IDEAS_JS.indexOf('postInboxIdDevelop');
+  const body = IDEAS_JS.slice(from, IDEAS_JS.indexOf('})', from));
+  assert.ok(!/title:/.test(body), 'no title in the develop body');
+  assert.ok(!/grade:/.test(body), 'no grade in the develop body');
+  assert.match(body, /field_values/);
+});
+
+await test('the develop draft is keyed per idea, so it cannot collide with a new one', () => {
+  // Sharing one key would let a half-written new idea overwrite development work.
+  assert.match(IDEAS_JS, /develop:\$\{DEVELOP_ID\}/);
+});
+
+await test('the queue is read from the R145 endpoint, not rebuilt from the inbox', () => {
+  assert.match(IDEAS_JS, /getInboxSparks/);
+  // And it links each row at the R153 page rather than the overlay.
+  assert.match(IDEAS_JS, /\/idea\/\$\{encodeURIComponent\(sp\.id\)\}/);
+});
+
+await test('the develop block ships HIDDEN — plain mode must not flash it', () => {
+  // The runtime test cannot see this (its stub DOM does not parse markup), so the
+  // attribute is pinned here, over the HTML itself.
+  assert.match(IDEAS_HTML, /id="fi-develop"[^>]*\shidden/, '#fi-develop carries the hidden attribute');
+});
+
+await test('the queue never blocks the composer', () => {
+  // The composer is the page's job; the queue is context. An outage in the
+  // secondary read must not take the primary surface down with it.
+  const from = IDEAS_JS.indexOf('async function loadQueue');
+  const fn = IDEAS_JS.slice(from, IDEAS_JS.indexOf('\n  }', from));
+  assert.match(fn, /if \(!r\.ok/, 'it handles its own failure');
+  assert.ok(!/throw/.test(fn), 'and never throws into boot');
+});
+
 console.log(`\nidea_hall_composer: ${passed} passed, ${failed} failed`);
 if (failed > 0) process.exit(1);