@bongos/core 1.19.298 → 1.19.300

package/tests/idea_detail_page.mjs

@@ -0,0 +1,271 @@
+// 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 } = {}) {
+  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; }, addEventListener() {},
+    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 } };
+      },
+    },
+  };
+
+  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 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();
+  assert.deepEqual(r.calls.map((c) => c[0]), ['idea'], 'no template fetch for a quick idea');
+});
+
+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/);
+});
+
+console.log(`\nidea_detail_page: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/idea_hall_composer.mjs

@@ -0,0 +1,246 @@
+// tests/idea_hall_composer.mjs
+//
+// task 1002928 (BV1.R152, goal 1000062) — the hall's Full Idea composer.
+//
+// The done-when this file exists to make mechanical: "the meter reflects the REAL
+// scorer, not a second copy of the rules". The cheap way to violate that is not a
+// re-implemented formula — it is five hand-written <textarea> elements in the
+// page, which fork the R141 template one step before any scoring happens. So the
+// central assertion here is a NEGATIVE one over the page source: no field key and
+// no field label may appear in it, at all. If someone hard-codes the form, this
+// fails, and the failure names the field they hard-coded.
+//
+// Also covered: the two routes the composer is built from (template projection,
+// score delegation), and the declaration-order trap that would 400 the template
+// read (`GET /inbox/:id` capturing the literal "template" — the third time this
+// shape has come up in this goal, after /inbox/sparks and /inbox/awaiting-nod).
+//
+// Route halves are DB-free the idea_full_capture.mjs way; the page halves are a
+// pure file read.
+//
+// Run:  node tests/idea_hall_composer.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+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 api = require('../src/module-api.js');
+api.pool.query = async () => ({ rows: [] });
+
+const { BASE_TEMPLATE, fieldOrder } = require('../modules/ideas/templates.js');
+const { scoreFieldValues } = require('../modules/ideas/completeness.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];
+}
+
+function call(handler, { query = {}, body = {} } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = { params: {}, query, body, builder: { id: '9', rank: 'xenos' } };
+    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, details: extra } });
+      },
+    };
+    Promise.resolve(handler(req, res, (e) => reject(e || new Error('next()')))).catch(reject);
+  });
+}
+
+const getTemplate = handlerFor('/inbox/template', 'get');
+const postScore = handlerFor('/inbox/score', 'post');
+
+const IDEAS_JS = fs.readFileSync(path.join(HALL, 'ideas.js'), 'utf8');
+const IDEAS_HTML = fs.readFileSync(path.join(HALL, 'ideas.html'), 'utf8');
+
+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 done-when: the page carries no copy of the rules ----------------
+
+await test('the PAGE names no field key — a hard-coded form is a forked template', () => {
+  for (const f of BASE_TEMPLATE.fields) {
+    assert.ok(!IDEAS_JS.includes(f.key), `ideas.js hard-codes the field key "${f.key}"`);
+    assert.ok(!IDEAS_HTML.includes(f.key), `ideas.html hard-codes the field key "${f.key}"`);
+  }
+});
+
+await test('the PAGE names no field label either', () => {
+  for (const f of BASE_TEMPLATE.fields) {
+    assert.ok(!IDEAS_JS.includes(f.label), `ideas.js hard-codes the label "${f.label}"`);
+    assert.ok(!IDEAS_HTML.includes(f.label), `ideas.html hard-codes the label "${f.label}"`);
+  }
+});
+
+await test('the page does NOT restate the substance floor', () => {
+  // A floor has to be attached to a field to mean anything, and the two
+  // assertions above already forbid naming one — this pins the scorer's own
+  // vocabulary out of the page as well, so "substanceMin: 40" cannot creep in
+  // under a different field name.
+  // camelCase `substanceMin` is the SCORER's own internal property name — a
+  // re-implementation would carry it. The published snake_case `substance_min` is
+  // deliberately NOT forbidden: it is a field of the template response the page
+  // legitimately receives, and naming it in a comment that documents that shape
+  // is documentation, not a forked rule.
+  assert.ok(!IDEAS_JS.includes('substanceMin'), 'ideas.js restates the scorer\'s floor');
+});
+
+await test('the page gets both the FORM and the METER from the server', () => {
+  // The positive half: it is not rule-free because it renders nothing — it is
+  // rule-free because it asks. Both calls must actually be there.
+  assert.match(IDEAS_JS, /getInboxTemplate/, 'the form is rendered from GET /inbox/template');
+  assert.match(IDEAS_JS, /postInboxScore/, 'the meter is filled from POST /inbox/score');
+  assert.match(IDEAS_JS, /postInbox\b/, 'and it files through POST /inbox');
+});
+
+await test('the page does not print a pass bar — that rule lives in economy', () => {
+  // The ideas scorer is documented bar-AGNOSTIC; the pass bar sits with the credit
+  // it gates. A threshold printed here would be a second copy of a DIFFERENT rule.
+  const { IDEA_FULL_PASS_BAR } = require('../modules/economy/credits.js');
+  assert.ok(Number.isInteger(IDEA_FULL_PASS_BAR), 'the bar is a number in economy');
+  assert.ok(!new RegExp(`\\b${IDEA_FULL_PASS_BAR}\\b`).test(IDEAS_JS), 'ideas.js names the economy pass bar');
+});
+
+// --- drafts survive navigation ------------------------------------------
+
+await test('every localStorage touch is guarded — storage that throws must not down the page', () => {
+  // A private window, cleared site data, or a browser set to block storage all
+  // THROW on access. Count the accesses and the guards rather than trusting a
+  // reading of the code.
+  const accesses = (IDEAS_JS.match(/localStorage\./g) || []).length;
+  assert.ok(accesses >= 3, 'the draft feature reads, writes and clears');
+  const tries = (IDEAS_JS.match(/try\s*\{/g) || []).length;
+  assert.ok(tries >= 3, `each localStorage access sits in its own try (found ${tries} for ${accesses} accesses)`);
+});
+
+await test('the draft is cleared only AFTER a successful file, never before', () => {
+  // A failed POST must not cost the text. Assert the ordering in the source: the
+  // clearDraft() call inside file() comes after the !r.ok early return.
+  const body = IDEAS_JS.slice(IDEAS_JS.indexOf('async function file('));
+  const bail = body.indexOf('if (!r.ok)');
+  const clear = body.indexOf('clearDraft()');
+  assert.ok(bail > 0 && clear > 0, 'both the failure bail and the clear are present');
+  assert.ok(clear > bail, 'clearDraft() must come after the failure path returns');
+});
+
+await test('a draft written against another template is dropped, not half-restored', () => {
+  assert.match(IDEAS_JS, /template_key/, 'the draft records which template it was written for');
+});
+
+// --- GET /inbox/template ------------------------------------------------
+
+await test('GET /inbox/template is declared BEFORE GET /inbox/:id', () => {
+  const iT = mounted.indexOf('GET /inbox/template');
+  const iId = mounted.indexOf('GET /inbox/:id');
+  assert.ok(iT >= 0 && iId >= 0);
+  assert.ok(iT < iId, `with :id first, "/inbox/template" binds id="template" and parseId 400s it (template@${iT}, :id@${iId})`);
+});
+
+await test('the template read returns the R141 declaration, in fieldOrder order', async () => {
+  const r = await call(getTemplate);
+  assert.equal(r.status, 200);
+  const t = r.payload.template;
+  assert.equal(t.key, BASE_TEMPLATE.key);
+  assert.equal(t.label, BASE_TEMPLATE.label);
+  // fieldOrder returns KEYS, not field objects. Comparing two lists derived the
+  // same WRONG way proves nothing — the first run of this test passed while the
+  // endpoint was emitting five {key: undefined} descriptors, because both sides
+  // were [undefined × 5]. So assert against the declaration AND that the keys are
+  // real strings.
+  assert.deepEqual(t.fields.map((f) => f.key), fieldOrder(BASE_TEMPLATE),
+    'display order comes from fieldOrder, never jsonb key order');
+  assert.ok(t.fields.length >= 1);
+  for (const f of t.fields) {
+    assert.equal(typeof f.key, 'string', 'a field descriptor carries a real key');
+    assert.ok(f.key.length > 0);
+    assert.equal(typeof f.label, 'string');
+    assert.ok(f.label.length > 0, 'and a real label — five unlabeled boxes is the bug this catches');
+  }
+  for (const f of t.fields) {
+    const src = BASE_TEMPLATE.fields.find((x) => x.key === f.key);
+    assert.equal(f.label, src.label);
+    assert.equal(f.required, !!src.required);
+    assert.equal(f.substance_min, src.substanceMin || 0, 'the floor is published so the form can say how much more is wanted');
+  }
+});
+
+await test('an unknown template is a 404, not an empty form', async () => {
+  const r = await call(getTemplate, { query: { template_key: 'no-such-template' } });
+  assert.equal(r.status, 404);
+  assert.equal(r.payload.error, 'unknown_template');
+});
+
+// --- POST /inbox/score --------------------------------------------------
+
+await test('the score endpoint IS the scorer — identical output, not a reimplementation', async () => {
+  const cases = [
+    Object.fromEntries(BASE_TEMPLATE.fields.map((f) => [f.key, 'x'.repeat(80)])),      // full
+    Object.fromEntries(BASE_TEMPLATE.fields.map((f) => [f.key, 'tiny'])),              // thin
+    { [BASE_TEMPLATE.fields[0].key]: 'y'.repeat(200) },                                // one field only
+    {},                                                                                // empty
+  ];
+  for (const field_values of cases) {
+    const r = await call(postScore, { body: { field_values } });
+    assert.equal(r.status, 200);
+    const direct = scoreFieldValues(field_values);
+    assert.equal(r.payload.score, direct.score, 'same score as calling the scorer directly');
+    assert.deepEqual(r.payload.fields, direct.fields, 'same per-field breakdown, same order');
+  }
+});
+
+await test('whitespace scores as the nothing it is, through the endpoint too', async () => {
+  const padded = Object.fromEntries(BASE_TEMPLATE.fields.map((f) => [f.key, '   \n\n\t  ']));
+  const r = await call(postScore, { body: { field_values: padded } });
+  assert.equal(r.payload.score, 0);
+});
+
+await test('a half-written draft scores rather than 400ing', async () => {
+  // The composer scores on every keystroke, so most calls carry an incomplete set.
+  const r = await call(postScore, { body: { field_values: { [BASE_TEMPLATE.fields[0].key]: 'half a thought' } } });
+  assert.equal(r.status, 200);
+  assert.ok(Number.isInteger(r.payload.score));
+});
+
+await test('unscorable input is a null score, never an exception or a 400', async () => {
+  const r = await call(postScore, { body: { field_values: {}, template_key: 'no-such-template' } });
+  assert.equal(r.status, 200, 'R142 never throws into the caller; "cannot score" is a legal answer');
+  assert.equal(r.payload.score, null);
+  assert.deepEqual(r.payload.fields, []);
+});
+
+await test('field_values is required — scoring nothing is a client bug, not a 0', async () => {
+  const r = await call(postScore, { body: {} });
+  assert.equal(r.status, 400);
+});
+
+await test('neither read touches the database', async () => {
+  let touched = 0;
+  api.pool.query = async () => { touched += 1; return { rows: [] }; };
+  await call(getTemplate);
+  await call(postScore, { body: { field_values: { [BASE_TEMPLATE.fields[0].key]: 'a' } } });
+  assert.equal(touched, 0, 'both are pure — which is what makes a call per keystroke reasonable');
+});
+
+console.log(`\nidea_hall_composer: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);