@bongos/core 1.19.300 → 1.19.301

package/tests/idea_spark_hall.mjs

@@ -0,0 +1,263 @@
+// tests/idea_spark_hall.mjs
+//
+// task 1002930 (BV1.R154, goal 1000062) — the spark handoff in the hall,
+// exercised at RUNTIME rather than over the source.
+//
+// The done-when this file owns: "starting development from the queue leads into
+// the R152 authoring surface pre-filled with the spark". So it boots ideas.js
+// twice against a stub DOM — once plainly, once as ?develop=<id> — and asserts
+// what a builder would actually get: the queue rows and where they point, the
+// spark's own words carried into the composer, a title that is shown but NOT
+// editable, and the file going to the develop route with no title or grade on it.
+//
+// (The author-only mark control is the other half of R154 and lives with the page
+// it renders on — tests/idea_detail_page.mjs.)
+//
+// Pure vm + file read.
+//
+// Run:  node tests/idea_spark_hall.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, 'ideas.js'), 'utf8');
+
+const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+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 })),
+};
+
+const SPARK = {
+  id: '77', title: 'Let a builder mute one channel', status: 'open', grade: 'spark',
+  body_md: 'I muted the whole server and then missed a ship.',
+  captured_by: '9', captured_at: '2026-08-01T00:00:00Z', filed_by_login: 'thinker',
+  field_values: null, completeness_score: null, template_key: null,
+};
+
+const QUEUE = [
+  SPARK,
+  { id: '78', title: 'A shared changelog', status: 'open', grade: 'spark', captured_at: '2026-07-30T00:00:00Z', filed_by_login: null },
+];
+
+function boot({ search = '', sparks = QUEUE, count = null, idea = SPARK, ideaOk = true, store = {} } = {}) {
+  const els = new Map();
+  const makeEl = () => ({
+    dataset: {}, style: {}, textContent: '', value: '', hidden: false, disabled: false,
+    readOnly: false, tabIndex: 0, _html: '', _handlers: {},
+    classList: { add() {}, remove() {} },
+    setAttribute() {}, getAttribute() { return null; },
+    addEventListener(t, fn) { this._handlers[t] = 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: 'ideas' } },
+    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: {
+      getInboxTemplate: async () => ({ status: 200, ok: true, data: { template: TEMPLATE } }),
+      getInboxSparks: async () => { calls.push(['sparks', null]); return { status: 200, ok: true, data: { sparks, count: count == null ? sparks.length : count } }; },
+      getInboxId: async (a) => { calls.push(['idea', a]); return { status: ideaOk ? 200 : 404, ok: ideaOk, data: ideaOk ? { idea } : null }; },
+      postInboxScore: async (a) => { calls.push(['score', a]); return { status: 200, ok: true, data: { score: 60, fields: TEMPLATE.fields.map((f) => ({ key: f.key, substance: 24, floor: 40, ratio: 0.6 })) } }; },
+      postInbox: async (a) => { calls.push(['capture', a]); return { status: 201, ok: true, data: { idea: { id: '900', grade: 'full', completeness_score: 80 } } }; },
+      postInboxIdDevelop: async (a) => { calls.push(['develop', a]); return { status: 200, ok: true, data: { idea: { ...idea, grade: 'full', completeness_score: 80, ideator_credit: 5 } } }; },
+    },
+  };
+
+  const toasts = [];
+  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),
+      toast: (m) => toasts.push(m),
+    },
+    localStorage: {
+      getItem: (k) => (Object.prototype.hasOwnProperty.call(store, k) ? store[k] : null),
+      setItem: (k, v) => { store[k] = String(v); },
+      removeItem: (k) => { delete store[k]; },
+    },
+    location: { hostname: 'builders.cloudbongos.com', pathname: '/ideas', search, assign() {} },
+    addEventListener() {},
+  };
+
+  const sandbox = { window: windowObj, document: documentObj, location: windowObj.location, console, setTimeout, clearTimeout, Date };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SRC, sandbox, { filename: 'ideas.js' });
+
+  const el = (id) => documentObj.getElementById(id);
+  return {
+    calls, toasts, store, el,
+    queueHtml: () => el('fi-queue').innerHTML,
+    fill: () => { for (const f of TEMPLATE.fields) el(`fi-f-${f.key}`).value = `an answer for ${f.key} long enough to count`; },
+    submit: () => el('fi-form')._handlers.submit({ preventDefault() {} }),
+  };
+}
+
+const settle = () => new Promise((r) => setTimeout(r, 0));
+
+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}`); }
+}
+
+// --- the queue -----------------------------------------------------------
+
+await test('the queue lists each waiting spark, naming who had the thought', async () => {
+  const r = boot();
+  await settle(); await settle();
+  const html = r.queueHtml();
+  assert.ok(html.includes('Let a builder mute one channel'));
+  assert.ok(html.includes('A shared changelog'));
+  assert.match(html, /@thinker/);
+  assert.match(html, /an unnamed builder/, 'a missing login degrades, it does not print @null');
+  assert.doesNotMatch(html, /undefined|null</);
+});
+
+await test('each row links to the idea PAGE and offers a develop link', async () => {
+  const r = boot();
+  await settle(); await settle();
+  const html = r.queueHtml();
+  assert.match(html, /href="\/idea\/77"/, 'the title links at the R153 page');
+  assert.match(html, /href="\?develop=77"/, 'and the action enters develop mode');
+});
+
+await test('an empty queue says how one gets filled', async () => {
+  const r = boot({ sparks: [] });
+  await settle(); await settle();
+  assert.match(r.queueHtml(), /Nothing is waiting/);
+  assert.match(r.queueHtml(), /author offers a quick idea up/);
+});
+
+await test('a truncated queue says so', async () => {
+  const r = boot({ count: 9 });
+  await settle(); await settle();
+  assert.match(r.queueHtml(), /Showing 2 of 9/);
+});
+
+// --- develop mode: pre-filled with the spark -----------------------------
+
+await test('develop mode carries the spark\'s own words into the composer', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  assert.equal(r.el('fi-develop').hidden, false);
+  assert.equal(r.el('fi-develop-title').textContent, SPARK.title);
+  assert.equal(r.el('fi-develop-body').textContent, SPARK.body_md);
+  assert.match(r.el('fi-develop-who').textContent, /@thinker/);
+  assert.match(r.el('fi-develop-who').textContent, /keep the credit/);
+});
+
+await test('the title is carried but NOT editable — developing must not rename it', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  assert.equal(r.el('fi-title').value, SPARK.title, 'the title is present');
+  assert.equal(r.el('fi-title').readOnly, true);
+  assert.equal(r.el('fi-title').hidden, true, 'and shown as a fact in the block above, not as a field');
+  assert.equal(r.el('fi-title-label').hidden, true);
+});
+
+await test('the action says what it does', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  assert.equal(r.el('fi-submit').textContent, 'Develop this idea');
+});
+
+await test('filing in develop mode calls the DEVELOP route with no title and no grade', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  r.fill();
+  await r.submit();
+  await settle();
+  const call = r.calls.find((c) => c[0] === 'develop');
+  assert.ok(call, 'POST /inbox/:id/develop was called');
+  assert.equal(call[1].id, '77');
+  assert.ok(call[1].body.field_values, 'it carries the five answers');
+  assert.ok(!('title' in call[1].body), 'and no title');
+  assert.ok(!('grade' in call[1].body), 'and no grade');
+  assert.ok(!r.calls.some((c) => c[0] === 'capture'), 'and never files a second idea');
+});
+
+await test('the developer is told about the split', async () => {
+  const r = boot({ search: '?develop=77' });
+  await settle(); await settle(); await settle();
+  r.fill();
+  await r.submit();
+  await settle();
+  assert.ok(r.toasts.some((t) => /split with its author/.test(t)), `toasts: ${JSON.stringify(r.toasts)}`);
+});
+
+await test('the develop draft is stored under its OWN key', async () => {
+  const store = {};
+  const r = boot({ search: '?develop=77', store });
+  await settle(); await settle(); await settle();
+  r.fill();
+  // The draft write is debounced behind an input event; call the saver's trigger.
+  r.el('fi-f-purpose')._handlers.input();
+  await new Promise((res) => setTimeout(res, 600));
+  const keys = Object.keys(store);
+  assert.ok(keys.length >= 1, `something was stored (${JSON.stringify(keys)})`);
+  assert.ok(keys.every((k) => k.includes('develop:77')), `keyed per idea: ${JSON.stringify(keys)}`);
+});
+
+// --- develop mode refuses what the server would refuse -------------------
+
+await test('a non-spark cannot be developed from this surface', async () => {
+  for (const [grade, expect] of [['full', /already been developed/], ['quick', /not a Big Idea Spark/]]) {
+    const r = boot({ search: '?develop=77', idea: { ...SPARK, grade } });
+    await settle(); await settle(); await settle();
+    assert.match(r.el('fi-sub').textContent, expect, grade);
+    assert.equal(r.el('fi-form').hidden, true, 'and the form is not offered');
+  }
+});
+
+await test('an unloadable idea says so instead of showing an empty form', async () => {
+  const r = boot({ search: '?develop=77', ideaOk: false });
+  await settle(); await settle(); await settle();
+  assert.match(r.el('fi-sub').textContent, /Could not load idea 77/);
+  assert.equal(r.el('fi-form').hidden, true);
+});
+
+await test('the plain composer is unaffected — develop mode is never entered', async () => {
+  const r = boot();
+  await settle(); await settle();
+  // Asserted as "develop mode never ran" rather than "#fi-develop is hidden":
+  // the stub DOM does not parse the markup, so the element's `hidden` default is
+  // false here regardless. The block ships with the `hidden` attribute, which
+  // tests/idea_hall_composer.mjs pins over the HTML source; what matters at
+  // runtime is that nothing reveals it, and the tell is that no idea was fetched.
+  assert.ok(!r.calls.some((c) => c[0] === 'idea'), 'no idea is loaded without ?develop=');
+  assert.equal(r.el('fi-title').readOnly, false, 'the title stays editable');
+  r.el('fi-title').value = 'a new idea';
+  r.fill();
+  await r.submit();
+  await settle();
+  const call = r.calls.find((c) => c[0] === 'capture');
+  assert.ok(call, 'it still files through POST /inbox');
+  assert.equal(call[1].body.grade, 'full');
+  assert.equal(call[1].body.title, 'a new idea');
+});
+
+console.log(`\nidea_spark_hall: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);