@bongos/core 1.19.385 → 1.19.387

package/tests/government_board_room_copy.mjs

@@ -0,0 +1,131 @@
+// tests/government_board_room_copy.mjs — the Board Room card reads as one
+// decision (task 1003270, goal 1000068).
+//
+// The owner's report was that the room was "extremely poor and unclear": the
+// idea being voted on was collapsed while raw config keys — `first_ratifier`,
+// `rank:archon`, `why_matters` — were expanded above it, and the Vote button
+// sat under a wall of prose. Copy rots back, so the two rules that came out of
+// that pass are pinned here rather than left to the next reader's judgment:
+//
+//   1. NO RAW CONFIG KEY REACHES A READER. Every pass rule the server can hold
+//      has a plain sentence, checked against the REAL PASS_RULES list — a rule
+//      added server-side with no copy fails here instead of shipping a card
+//      that prints its enum. Rank keys go through OTB.rankLabel.
+//   2. THE ORDER IS title → action → idea → apparatus. That order IS the fix;
+//      an edit that puts prose back between the title and the ballot has undone
+//      the task.
+//
+// Source pins, like tests/government_board_vote_ui.mjs: the hall script is an
+// IIFE over the DOM and cannot be imported into node wholesale.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+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 CLIENT = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'government.js'), 'utf8');
+const HTML = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'government.html'), 'utf8');
+const { PASS_RULES } = require(path.join(ROOT, 'modules', 'government', 'config.js'));
+
+const card = () => CLIENT.slice(CLIENT.indexOf('function itemCard'), CLIENT.indexOf('async function loadBoard'));
+
+// Deleted copy is asserted against the RENDERING source only. The comments in
+// government.js deliberately quote what was removed and why — that history is
+// the point of them, and a test that forbade it would push the record out of
+// the file it explains.
+const CODE = CLIENT.split(/\r?\n/).filter((l) => !/^\s*\/\//.test(l)).join('\n');
+
+test('every pass rule the server can hold has a plain-language sentence', () => {
+  const block = CLIENT.slice(CLIENT.indexOf('const PASS_RULE_PLAIN'), CLIENT.indexOf('function decidedByHtml'));
+  assert.ok(PASS_RULES.length >= 3, `sanity: found the real rule set (${PASS_RULES})`);
+  for (const rule of PASS_RULES) {
+    assert.ok(block.includes(`${rule}:`), `PASS_RULE_PLAIN must explain '${rule}' — a rule with no copy renders its enum key`);
+  }
+  // And the sentence must not simply echo the key back at the reader.
+  for (const rule of PASS_RULES) {
+    const line = block.split('\n').find((l) => l.trim().startsWith(`${rule}:`));
+    assert.ok(!/'[^']*\b(first_ratifier|consent_rule|pass_rule)\b/.test(line), `'${rule}' copy leaks a config key: ${line}`);
+  }
+});
+
+test('the short name map covers the same rule set (the history line)', () => {
+  const block = CLIENT.slice(CLIENT.indexOf('const PASS_RULE_NAME'), CLIENT.indexOf('const PASS_RULE_PLAIN'));
+  for (const rule of PASS_RULES) {
+    assert.ok(block.includes(`${rule}:`), `PASS_RULE_NAME must name '${rule}'`);
+  }
+});
+
+test('a rank reaches the reader as a LABEL, never as the enum key', () => {
+  assert.match(CLIENT, /function rankNames\(keys\)[\s\S]*?window\.OTB\.rankLabel\(k\)/,
+    'the board card resolves rank keys through the branding pack');
+  const membership = CLIENT.slice(CLIENT.indexOf('function membershipSentence'), CLIENT.indexOf('function passRuleSentence'));
+  assert.match(membership, /window\.OTB\.rankLabel\(k\)/,
+    'so does the Constitution sentence — `archon` is an enum, "Owner" is what a person reads');
+});
+
+test('the card order is title → action → the idea → the apparatus', () => {
+  const c = card();
+  const at = (needle) => {
+    const i = c.indexOf(needle);
+    assert.notEqual(i, -1, `itemCard no longer contains ${needle}`);
+    return i;
+  };
+  assert.ok(at('gov-item__title') < at('gov-item__act'),
+    'the action follows the title directly — that adjacency is the whole fix');
+  assert.ok(at('gov-item__act') < at('ideaSectionsHtml(item)'),
+    'nothing may be inserted between the title and the ballot');
+  assert.ok(at('ideaSectionsHtml(item)') < at('decidedByHtml(item)'),
+    'the idea outranks the rules it is decided under');
+  assert.ok(at('decidedByHtml(item)') < at('ballotHtml(item, viewerId)'),
+    'who votes, then who has');
+});
+
+test('the idea renders OPEN — never behind a summary', () => {
+  const sections = CLIENT.slice(CLIENT.indexOf('function ideaSectionsHtml'), CLIENT.indexOf('function rankNames'));
+  assert.ok(!/<details/.test(sections),
+    'the substance of the vote is not a disclosure — that was the reported bug');
+  assert.match(sections, /gov-idea__body/, 'and it is set as prose, not as a config row');
+});
+
+test('the tally stays visible without a click (ADR 0175 §9)', () => {
+  const c = card();
+  assert.match(c, /gov-item__summary">\$\{tally\}/,
+    'a board whose votes are invisible constrains nobody — the count rides the summary');
+});
+
+test('the self-explaining copy is DELETED, not reworded', () => {
+  assert.ok(!/Casting arrives with the vote form/.test(CODE),
+    'the sentence that explained the UI to itself — and the form it promised has shipped');
+  assert.ok(!/tally: \$\{yes\} yes/.test(CLIENT), 'the raw-config tally line is gone');
+  assert.ok(!/The idea, in full/.test(CODE), 'so is the summary that hid the idea');
+});
+
+test('the section a voter faults is shown by NAME, in the ballot and the picker', () => {
+  const ballot = CLIENT.slice(CLIENT.indexOf('function ballotHtml'), CLIENT.indexOf('// ---- the vote form'));
+  assert.match(ballot, /SECTION_LABELS\[v\.section_key\]/,
+    '`why_matters` is a jsonb key; the objector picked a named section and the reader should see that name');
+});
+
+test('the objection still carries a reason AND one section (ADR 0175 §8)', () => {
+  // The requirement simplifying may not weaken: it is why voting lives in the
+  // hall instead of on a chat reaction.
+  const form = CLIENT.slice(CLIENT.indexOf('function voteFormHtml'), CLIENT.indexOf('async function castVoteFromRoom'));
+  assert.match(form, /data-vote-reason/, 'the reason box survives');
+  assert.match(form, /gov-vote__sections/, 'so does the five-way section picker');
+  assert.match(form, /Object\.keys\(SECTION_LABELS\)\.map/, 'with one radio per declared section');
+});
+
+test('the page frames its panels in one line each, not a paragraph', () => {
+  // The two intros used to run ~60 and ~50 words before anything actionable.
+  for (const heading of ['Constitution', 'Board Room']) {
+    const i = HTML.indexOf(`<h2 class="gov-h">${heading}</h2>`);
+    assert.notEqual(i, -1, `${heading} panel heading missing`);
+    const note = /<p class="gov-grid-note">([\s\S]*?)<\/p>/.exec(HTML.slice(i));
+    assert.ok(note, `${heading} has no framing line`);
+    const words = note[1].replace(/<[^>]+>/g, ' ').trim().split(/\s+/).length;
+    assert.ok(words <= 30, `${heading}'s intro is ${words} words — a reader meets it before anything actionable`);
+  }
+});