@bongos/core 1.19.934 → 1.19.936

package/tests/idea_full_capture.mjs

@@ -61,8 +61,14 @@ function call(bodyIn) {
   });
 }
 
+// Since task 1004091 (BV2.R12) the floors differ per field, so one fixed
+// sentence no longer clears every one of them — this suite wants a payload that
+// scores 100, so each answer is padded to the field's OWN declared floor.
 const FULL = Object.fromEntries(
-  BASE_TEMPLATE.fields.map((f) => [f.key, `A substantive answer for ${f.key}, long enough to clear the floor.`]),
+  BASE_TEMPLATE.fields.map((f) => [
+    f.key,
+    `A substantive answer for ${f.key}, long enough to clear the floor.`.padEnd(f.substanceMin, '.'),
+  ]),
 );
 
 let passed = 0;

package/tests/idea_recommendation.mjs

@@ -0,0 +1,381 @@
+// tests/idea_recommendation.mjs
+//
+// task 1004092 (BV2.R13, spec R22, goal 1000095) — A Full Idea carries a
+// RECOMMENDATION: goal or criterion, carried from filing through to the board
+// item and shown to voters.
+//
+// The done-when names a CHAIN, so this suite walks it in order rather than
+// testing three features that happen to share a word:
+//
+//   1. filing      — POST /inbox, POST /:id/develop, POST /:id/resubmit each
+//                    take it, refuse anything outside the vocabulary, and write
+//                    it on the grade row.
+//   2. the board item — government's subject projection carries it out of the
+//                    same row the sections come from.
+//   3. the voter   — the Board Room renders it as a recommendation, in front of
+//                    the ballot.
+//
+// THE THREE THINGS MOST LIKELY TO BE WRONG, each with a test that fails loudly:
+//
+//   • A RESUBMISSION SILENTLY WITHDRAWING THE RECOMMENDATION. setIdeaGrade
+//     writes the WHOLE grade row by contract, so a resubmit that does not
+//     restate the recommendation stores NULL — and the request that did it
+//     never mentioned the field. That is the defect this file exists for.
+//   • ABSENCE RENDERED AS A VALUE. Every Full Idea filed before this shipped
+//     carries NULL and there is no backfill, so "the author did not say" has to
+//     survive the projection and reach the voter as itself.
+//   • A SECOND COPY OF THE VOCABULARY. The two values are a database CHECK; the
+//     route, the doorway re-export and the composer must all read the one
+//     declaration in projection.js.
+//
+// DB-free the idea_full_capture.mjs way: pool.query is patched on the doorway
+// before the modules load, and the REAL route handlers are driven through a
+// stub req/res. The Board Room half runs the REAL board-room.js in a vm, the
+// way tests/government_board_vote_ui.mjs does.
+//
+// Run:  node tests/idea_recommendation.mjs
+
+import { strict as assert } from 'node:assert';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import vm from 'node:vm';
+
+const require = createRequire(import.meta.url);
+const api = require('../src/module-api.js');
+
+// ---------------------------------------------------------------------------
+// the stub pool — every write echoes its own parameters back, so a test can
+// assert what was actually BOUND rather than what the handler said it sent.
+// ---------------------------------------------------------------------------
+
+let queries = [];
+// What getIdea sees. Reassigned per test — a resubmit reads the stored row to
+// decide what to carry forward, which is the whole point of half of this file.
+let storedIdea = null;
+
+api.pool.query = async (sql, params = []) => {
+  queries.push({ sql, params });
+  if (/INSERT INTO ideas_grades/i.test(sql)) {
+    return { rows: [{
+      idea_id: params[0], grade: params[1], template_key: params[2],
+      field_values: JSON.parse(params[3]), completeness_score: params[4],
+      recommendation: params[5],
+    }] };
+  }
+  if (/UPDATE ideas_grades/i.test(sql)) {
+    return { rows: [{
+      idea_id: params[0], grade: 'full', template_key: params[1],
+      field_values: JSON.parse(params[2]), completeness_score: params[3],
+      developed_by: params[4], developed_at: 'T', recommendation: params[5],
+    }] };
+  }
+  if (/INSERT INTO idea_inbox/i.test(sql)) return { rows: [{ id: '77', title: params[0], status: 'open' }] };
+  // COUNT before the bare table match: countOpenIdeas also reads FROM
+  // idea_inbox, and answering it with a row list is a TypeError three frames
+  // down that surfaces as a 500 on a route that worked.
+  if (/SELECT COUNT/i.test(sql)) return { rows: [{ n: 3, count: 3 }] };
+  if (/FROM idea_inbox/i.test(sql)) return { rows: storedIdea ? [storedIdea] : [] };
+  return { rows: [] };
+};
+// No credit lane, no board port: this suite is about one column's journey.
+api.resolveOptional = () => undefined;
+
+const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+const projection = require('../modules/ideas/projection.js');
+const inbox = require('../modules/ideas/inbox.js');
+const routesFactory = require('../modules/ideas/routes/inbox.js');
+
+const router = routesFactory({});
+function handlerFor(path, method) {
+  const layer = router.stack.find((l) => l.route && l.route.path === path && l.route.methods[method]);
+  assert.ok(layer, `route ${method.toUpperCase()} ${path} exists`);
+  const stack = layer.route.stack.map((s) => s.handle);
+  return stack[stack.length - 1];
+}
+const postInbox = handlerFor('/inbox', 'post');
+const getTemplate = handlerFor('/inbox/template', 'get');
+const postDevelop = handlerFor('/inbox/:id/develop', 'post');
+const postResubmit = handlerFor('/inbox/:id/resubmit', 'post');
+
+function drive(handler, { body = {}, params = {}, builderId = '9' } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = { body, params, query: {}, builder: { id: builderId, rank: 'metic' } };
+    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(handler(req, res)).catch(reject);
+  });
+}
+
+// Each answer padded to its OWN field's floor — since task 1004091 the floors
+// differ per field, so one fixed sentence no longer clears every one of them.
+const FULL = Object.fromEntries(
+  BASE_TEMPLATE.fields.map((f) => [
+    f.key,
+    `A substantive answer for ${f.key}, long enough to clear the floor.`.padEnd(f.substanceMin, '.'),
+  ]),
+);
+
+const gradeInsert = () => queries.find((q) => /INSERT INTO ideas_grades/i.test(q.sql));
+const gradeUpdate = () => queries.find((q) => /UPDATE ideas_grades/i.test(q.sql));
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  queries = [];
+  storedIdea = null;
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// ---------------------------------------------------------------------------
+// 0. the vocabulary is declared ONCE
+// ---------------------------------------------------------------------------
+
+await test('the vocabulary is exactly goal and criterion, declared in one place', async () => {
+  assert.deepEqual(projection.VALID_RECOMMENDATIONS, ['goal', 'criterion']);
+  // Re-exported through the module facade, so the routes and the template read
+  // do not each name their own pair.
+  assert.equal(inbox.VALID_RECOMMENDATIONS, projection.VALID_RECOMMENDATIONS);
+});
+
+await test('absence is legal at every layer; anything else is not', async () => {
+  for (const ok of [undefined, null, 'goal', 'criterion']) {
+    assert.equal(projection.isValidRecommendation(ok), true, `${String(ok)} is accepted`);
+  }
+  for (const bad of ['Goal', 'version', '', 'criterion ', 0, true, {}]) {
+    assert.equal(projection.isValidRecommendation(bad), false, `${JSON.stringify(bad)} is refused`);
+  }
+  // '' is how an unpicked radio reaches the wire; it normalises to "not given"
+  // rather than being sent on as a value the CHECK constraint would reject.
+  assert.equal(projection.normalizeRecommendation(''), null);
+  assert.equal(projection.normalizeRecommendation(undefined), null);
+  assert.equal(projection.normalizeRecommendation('goal'), 'goal');
+});
+
+// ---------------------------------------------------------------------------
+// 1. filing
+// ---------------------------------------------------------------------------
+
+await test('a Full Idea files WITH its recommendation, and it reaches the grade row', async () => {
+  const r = await drive(postInbox, { body: { title: 'a full idea', grade: 'full', field_values: FULL, recommendation: 'goal' } });
+  assert.equal(r.status, 201);
+  assert.equal(r.payload.idea.recommendation, 'goal', 'the response states what was stored');
+  assert.equal(gradeInsert().params[5], 'goal', 'bound on the write, not just echoed');
+});
+
+await test('a Full Idea files WITHOUT one, and the absence is stored as absence', async () => {
+  const r = await drive(postInbox, { body: { title: 'a full idea', grade: 'full', field_values: FULL } });
+  assert.equal(r.status, 201);
+  assert.equal(r.payload.idea.recommendation, null);
+  assert.equal(gradeInsert().params[5], null, 'NULL, never the string "undefined" and never a default');
+});
+
+await test('a value outside the vocabulary is a named 400, before any write', async () => {
+  const r = await drive(postInbox, { body: { title: 'x', grade: 'full', field_values: FULL, recommendation: 'version' } });
+  assert.equal(r.status, 400);
+  assert.equal(r.payload.error, 'bad_recommendation');
+  assert.deepEqual(r.payload.allowed, ['goal', 'criterion']);
+  assert.equal(queries.length, 0, 'refused before any write — no orphan idea');
+});
+
+await test('a recommendation on a QUICK capture is refused, not silently dropped', async () => {
+  // A quick idea writes no grade row, so accepting one would answer 201 for a
+  // recommendation that was never stored anywhere — the worst of the three
+  // possible behaviours, because the caller is told it worked.
+  const r = await drive(postInbox, { body: { title: 'quick', recommendation: 'goal' } });
+  assert.equal(r.status, 400);
+  assert.equal(r.payload.error, 'recommendation_needs_full_grade');
+  assert.equal(queries.length, 0);
+});
+
+await test('the quick path is untouched when no recommendation is sent', async () => {
+  const r = await drive(postInbox, { body: { title: 'quick' } });
+  assert.equal(r.status, 201);
+  assert.ok(!queries.some((q) => /ideas_grades/i.test(q.sql)), 'still no grade row');
+});
+
+await test('developing a spark carries the developer’s recommendation', async () => {
+  storedIdea = { id: '77', grade: 'spark', status: 'open', captured_by: '9', template_key: 'base-v2', field_values: {} };
+  const r = await drive(postDevelop, { params: { id: '77' }, body: { field_values: FULL, recommendation: 'criterion' }, builderId: '42' });
+  assert.equal(r.status, 200);
+  assert.equal(r.payload.idea.recommendation, 'criterion');
+  assert.equal(gradeUpdate().params[5], 'criterion');
+});
+
+await test('developing refuses a value outside the vocabulary too', async () => {
+  storedIdea = { id: '77', grade: 'spark', status: 'open', captured_by: '9', template_key: 'base-v2', field_values: {} };
+  const r = await drive(postDevelop, { params: { id: '77' }, body: { field_values: FULL, recommendation: 'epic' } });
+  assert.equal(r.status, 400);
+  assert.equal(r.payload.error, 'bad_recommendation');
+  assert.equal(queries.length, 0, 'refused before the idea is even read');
+});
+
+// --- the defect this file exists for --------------------------------------
+
+await test('A RESUBMISSION THAT SAYS NOTHING KEEPS THE STORED RECOMMENDATION', async () => {
+  // setIdeaGrade writes the WHOLE row by contract. Without an explicit carry
+  // forward, answering a board objection would store NULL — silently
+  // withdrawing the scope the board was shown, on a request that never
+  // mentioned it.
+  storedIdea = {
+    id: '77', grade: 'full', status: 'open', captured_by: '9',
+    template_key: 'base-v2', field_values: FULL, recommendation: 'goal',
+  };
+  const r = await drive(postResubmit, { params: { id: '77' }, body: { field_values: FULL } });
+  assert.equal(r.status, 200);
+  assert.equal(gradeInsert().params[5], 'goal', 'carried forward from the stored row');
+  assert.equal(r.payload.idea.recommendation, 'goal');
+});
+
+await test('a resubmission MAY change it — the author revised their own reading', async () => {
+  storedIdea = {
+    id: '77', grade: 'full', status: 'open', captured_by: '9',
+    template_key: 'base-v2', field_values: FULL, recommendation: 'goal',
+  };
+  const r = await drive(postResubmit, { params: { id: '77' }, body: { field_values: FULL, recommendation: 'criterion' } });
+  assert.equal(r.status, 200);
+  assert.equal(gradeInsert().params[5], 'criterion', 'the body wins over the stored value');
+});
+
+await test('resubmitting an idea that never had one still stores none', async () => {
+  storedIdea = {
+    id: '77', grade: 'full', status: 'open', captured_by: '9',
+    template_key: 'base-v2', field_values: FULL, recommendation: null,
+  };
+  const r = await drive(postResubmit, { params: { id: '77' }, body: { field_values: FULL } });
+  assert.equal(r.status, 200);
+  assert.equal(gradeInsert().params[5], null, 'null carried forward is still null — never invented');
+});
+
+// ---------------------------------------------------------------------------
+// the composer's question comes from the server
+// ---------------------------------------------------------------------------
+
+await test('GET /inbox/template serves the choice beside the fields, not inside them', async () => {
+  const r = await drive(getTemplate);
+  assert.equal(r.status, 200);
+  const spec = r.payload.template.recommendation;
+  assert.ok(spec, 'the composer renders the question from here, not from a hard-coded pair');
+  assert.deepEqual(spec.options.map((o) => o.value), ['goal', 'criterion']);
+  assert.ok(spec.options.every((o) => o.label && o.label !== o.value), 'each option carries words a person reads');
+  // NOT a sixth field: it is not prose, nothing scores it, and adding it to
+  // `fields` would change what a Full Idea costs to file.
+  assert.ok(!r.payload.template.fields.some((f) => f.key === 'recommendation'));
+});
+
+await test('the hall composer reads the options rather than restating them', async () => {
+  const src = readFileSync(new URL('../modules/hall-ui/public/ideas.js', import.meta.url), 'utf8');
+  assert.ok(/template\.recommendation/.test(src), 'the spec comes from the template read');
+  // The one place the page may name a value is nowhere: a hard-coded pair here
+  // is the same forked-declaration defect as a hard-coded field list.
+  assert.ok(!/['"]criterion['"]/.test(src), 'the page does not name a vocabulary member');
+});
+
+// ---------------------------------------------------------------------------
+// 2 + 3. the board item, and the voter
+// ---------------------------------------------------------------------------
+
+// board-room.js is a self-contained IIFE over the DOM with an `init()` at the
+// bottom, so it cannot be imported and booting the whole page to read one line
+// would be a harness larger than the feature. Its own suites
+// (government_board_vote_ui.mjs, government_board_room_copy.mjs) slice the file
+// by FUNCTION-NAME LANDMARKS — the file's header calls that out and asks that
+// the function order be left alone for exactly this reason — so this does the
+// same, and then RUNS what it sliced. A source pin could show the words are in
+// the file; only running it shows which of the three branches produces them.
+const BOARD_ROOM = readFileSync(new URL('../modules/hall-ui/public/board-room.js', import.meta.url), 'utf8');
+
+function bootBoardRoom() {
+  const from = BOARD_ROOM.indexOf('const RECOMMENDATION_WORDS');
+  const to = BOARD_ROOM.indexOf("// ---- the sitting's rules");
+  assert.ok(from > 0 && to > from, 'the recommendation renderer is where its landmarks say it is');
+  const escapeHtml = (s) => String(s ?? '').replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+  const sandbox = { escapeHtml, out: null };
+  vm.createContext(sandbox);
+  vm.runInContext(`${BOARD_ROOM.slice(from, to)}\nout = recommendationHtml;`, sandbox);
+  return { recommendationHtml: sandbox.out };
+}
+
+const openItem = (subject) => ({
+  id: '41',
+  subject_type: 'full_idea',
+  subject_id: '1000412',
+  subject,
+  opened_by: '1',
+  opened_at: 'T0',
+  closes_at: null,
+  remaining_seconds: null,
+  expired: false,
+  closed_at: null,
+  outcome: null,
+  constitution: { membership: 'rank:metic+', pass_rule: 'consent', window_minutes: null, close_early_on_full_turnout: false },
+  votes: [],
+});
+
+await test('the board SUBJECT carries the recommendation out of the same row as the sections', async () => {
+  // The projection is government's, over the row modules/government/db.js reads.
+  const boardSrc = readFileSync(new URL('../modules/government/board.js', import.meta.url), 'utf8');
+  const dbSrc = readFileSync(new URL('../modules/government/db.js', import.meta.url), 'utf8');
+  assert.ok(/g\.recommendation/.test(dbSrc), 'getIdeaSubjects selects it');
+  assert.ok(/recommendation: r\.recommendation \?\? null/.test(boardSrc), 'and the subject projects it, absence included');
+});
+
+await test('a voter sees the recommendation, in words, above the ballot', async () => {
+  const T = bootBoardRoom();
+  const html = T.recommendationHtml(openItem({ title: 'x', author_id: '9', template_key: 'base-v2', completeness_score: 100, field_values: { why_had: 'w' }, recommendation: 'goal' }));
+  assert.match(html, /a goal of its own/, 'the value is rendered as words, not as a raw key');
+  assert.match(html, /recommends/i, 'framed as a recommendation');
+  assert.match(html, /board decides/i, 'and the decision is named as the board’s — spec decision 9');
+  assert.ok(!/\bcriterion\b/.test(html), 'only the recommended one is shown');
+});
+
+await test('the criterion reading renders its own words', async () => {
+  const T = bootBoardRoom();
+  const html = T.recommendationHtml(openItem({ title: 'x', author_id: '9', template_key: 'base-v2', field_values: {}, recommendation: 'criterion' }));
+  assert.match(html, /a criterion inside an existing goal/);
+});
+
+await test('AN ABSENT RECOMMENDATION IS STATED, NOT HIDDEN', async () => {
+  // The alternative — rendering nothing — leaves a voter unable to tell
+  // "recommended as a criterion" from "never asked", which is exactly the
+  // confusion every pre-BV2 idea would cause.
+  const T = bootBoardRoom();
+  const html = T.recommendationHtml(openItem({ title: 'x', author_id: '9', template_key: 'base-v1', field_values: { purpose: 'p' }, recommendation: null }));
+  assert.match(html, /no scope recommendation/i);
+  assert.ok(!/a goal of its own|a criterion inside/.test(html), 'and no value is invented for it');
+});
+
+await test('an amendment has no author recommendation and renders no line', async () => {
+  const T = bootBoardRoom();
+  const item = { ...openItem({ proposed: {}, rationale_md: 'r', author_id: '1' }), subject_type: 'constitutional_amendment' };
+  assert.equal(T.recommendationHtml(item), '');
+  assert.equal(T.recommendationHtml({ ...openItem(null) }), '', 'nor does a deleted subject');
+});
+
+await test('a vocabulary member this page has never heard of is printed, not dropped', async () => {
+  // The CHECK constraint can widen in a later migration while this page is
+  // still cached. Printing the raw key is ugly and honest; dropping it hides a
+  // recommendation from the board being asked to rule on it.
+  const T = bootBoardRoom();
+  const html = T.recommendationHtml(openItem({ title: 'x', author_id: '9', template_key: 'base-v2', field_values: {}, recommendation: 'version' }));
+  assert.match(html, /version/);
+  assert.match(html, /recommends/i);
+});
+
+await test('the line sits ON the card, ABOVE the idea’s own words', async () => {
+  const card = BOARD_ROOM.slice(BOARD_ROOM.indexOf('function itemCard'), BOARD_ROOM.indexOf('async function loadBoard'));
+  const rec = card.indexOf('recommendationHtml(item)');
+  const sections = card.indexOf('ideaSectionsHtml(item)');
+  assert.ok(rec > 0, 'the card renders it');
+  assert.ok(rec < sections, 'a voter reads what was proposed before they read the case for it');
+});
+
+console.log(`\nidea_recommendation: ${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/idea_templates.mjs

@@ -74,6 +74,40 @@ test('base-v2 declares the owner\'s new five, in order, and IS the store default
   }
 });
 
+// ── the substance floors (task 1004091, BV2.R12, spec R21) ──────────────────
+//
+// The floors are a PRICE, not a style note: `completeness_score` is the mean of
+// per-field ratios, and that number gates the ideator credit (economy's
+// IDEA_FULL_PASS_BAR) and whether a Full Idea reaches the board at all. So the
+// two claims worth pinning are the two that would be silently reverted: that the
+// floors actually differ per question, and that redistributing them did not
+// change what filing a Full Idea costs in total.
+
+test('BV2.R12: v2\'s floors differ per question, and total exactly what v1 cost', () => {
+  const total = (t) => t.fields.reduce((sum, f) => sum + f.substanceMin, 0);
+  assert.equal(total(T.BASE_V2_TEMPLATE), total(T.BASE_V1_TEMPLATE),
+    're-pricing what a thought costs to file is the owner\'s call, not this template\'s — '
+    + 'R12 distributes v1\'s total across questions that are not interchangeable, it does not move it');
+
+  const floors = T.BASE_V2_TEMPLATE.fields.map((f) => f.substanceMin);
+  assert.ok(new Set(floors).size > 1,
+    'flat floors are the placeholder BV2.R12 replaced — the questions are not interchangeable');
+
+  // Named by key, because the REASONING is what a future edit would undo: the
+  // field that invites the longest answer carries the highest floor, and the
+  // anti-ghost-writing field — the one nobody but the filer can answer — carries
+  // the lowest, so no floor ever pushes an agent to pad it (the Ideator pack).
+  const floorOf = (key) => T.BASE_V2_TEMPLATE.fields.find((f) => f.key === key).substanceMin;
+  assert.equal(Math.max(...floors), floorOf('scope'), '"scope it as best as you can" asks for the most');
+  assert.equal(Math.min(...floors), floorOf('why_had'), '"what made you have the idea" asks for the least');
+
+  // ADR 0186's interim karma-eligibility guard, restated here so a later
+  // reshuffle cannot drop the template below its own economics.
+  assert.ok(T.BASE_V2_TEMPLATE.fields.filter((f) => f.required).length >= 3
+    && total(T.BASE_V2_TEMPLATE) >= 120,
+  'ADR 0186 T5: ≥3 required fields and ≥120 total substanceMin to stay karma-eligible');
+});
+
 test('the declaration is frozen — a consumer cannot fork it in place', () => {
   assert.throws(() => { T.BASE_TEMPLATE.fields.push({ key: 'rogue' }); });
   assert.throws(() => { T.BASE_V1_TEMPLATE.fields.push({ key: 'rogue' }); });