@bongos/core 1.19.251 → 1.19.252

package/tests/government_board_membership_db.mjs

@@ -0,0 +1,150 @@
+// tests/government_board_membership_db.mjs — the board franchise against a REAL
+// Postgres (task 1003094).
+//
+// WHY THIS EXISTS BESIDE THE DB-FREE government_board_membership.mjs. That file
+// covers the pure parser and the resolvers against a stubbed db, which is where
+// the grammar lives. It cannot cover the half this task actually changed: the
+// SQL. `WHERE rank_key = $1` became `WHERE rank_key = ANY($1)` plus a DISTINCT,
+// and a FRANCHISE bug is precisely the kind a stub agrees with and the database
+// does not — the stub returns whatever the test author imagined the query means.
+//
+// What only real SQL can answer:
+//   * does `rank:metic+` genuinely seat the Archon (the regression that cost an
+//     owner their seat on their own constitution);
+//   * do the two STRUCTURAL filters survive the rewrite — a deactivated builder
+//     and a machine principal must still never govern, because a widened
+//     franchise that also admits a bot is a worse bug than the one being fixed;
+//   * does DISTINCT actually hold when a builder matches through two keys — a
+//     double-counted member silently raises the bar a consent vote must clear.
+//
+// It SELF-SKIPS (exit 0) with no reachable Postgres, and is listed in
+// run-unit-tests.js's INTEGRATION set so the DB-free lane never runs it.
+//
+// Run:  DATABASE_URL=postgres://... node tests/government_board_membership_db.mjs
+//
+// It creates its own throwaway `builders` / `government_builder_ranks` rows at
+// ids far above any real row, and deletes them at the end.
+
+import pg from 'pg';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+
+const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL || undefined });
+
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`government_board_membership_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}). Set DATABASE_URL to run.`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+let passed = 0, failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL ${name}\n     ${e.message}`); }
+}
+const assert = (await import('node:assert')).strict;
+
+// Minimal stand-ins ONLY when the real tables are absent (throwaway container);
+// against a migrated database these are no-ops and the real tables are used.
+await pool.query(`
+  CREATE TABLE IF NOT EXISTS builders (
+    id bigserial PRIMARY KEY, github_login text, display_name text,
+    status text DEFAULT 'active', system_role text);
+  CREATE TABLE IF NOT EXISTS government_builder_ranks (
+    builder_id bigint, rank_key text);
+`);
+
+// Ids far above any real row, and every login prefixed, so cleanup is exact and
+// this can never touch a real builder or a real rank assignment.
+const B = 990000000;
+const ID = { xenos: B + 1, thetes: B + 2, metic: B + 3, archon: B + 4, gone: B + 5, bot: B + 6, ops: B + 7 };
+const cleanup = async () => {
+  await pool.query('DELETE FROM government_builder_ranks WHERE builder_id >= $1', [B]);
+  await pool.query('DELETE FROM builders WHERE id >= $1', [B]);
+};
+await cleanup();
+await pool.query(`INSERT INTO builders (id, github_login, display_name, status, system_role) VALUES
+  ($1,'gbmdb-x','Xenos','active',NULL),($2,'gbmdb-t','Thetes','active',NULL),
+  ($3,'gbmdb-m','Metic','active',NULL),($4,'gbmdb-a','Archon','active',NULL),
+  ($5,'gbmdb-gone','Deactivated Archon','inactive',NULL),
+  ($6,'gbmdb-bot','A Machine','active','bfg'),
+  ($7,'gbmdb-ops','Custom Ops','active',NULL)`,
+[ID.xenos, ID.thetes, ID.metic, ID.archon, ID.gone, ID.bot, ID.ops]);
+await pool.query(`INSERT INTO government_builder_ranks (builder_id, rank_key) VALUES
+  ($1,'xenos'),($2,'thetes'),($3,'metic'),($4,'archon'),($5,'archon'),($6,'archon'),($7,'gbmdb-ops-rank')`,
+[ID.xenos, ID.thetes, ID.metic, ID.archon, ID.gone, ID.bot, ID.ops]);
+
+const api = require(process.cwd() + '/src/module-api.js');
+api.pool.query = (...a) => pool.query(...a);
+const { resolveBoardMembers, isBoardMember } = require(process.cwd() + '/modules/government/board-membership.js');
+
+const board = (membership) => ({ membership, pass_rule: 'consent', window_minutes: null, close_early_on_full_turnout: true });
+const logins = async (m) => (await resolveBoardMembers(board(m)))
+  .filter((r) => Number(r.builder_id) >= B)          // ignore any real rows on a migrated db
+  .map((r) => r.github_login.replace('gbmdb-', ''));
+
+console.log('the predicate against real SQL');
+
+await t('bare rank:archon is unchanged — exactly archons', async () => {
+  assert.deepEqual(await logins('rank:archon'), ['a']);
+});
+
+await t('THE BUG: bare rank:metic seats metics ONLY (still true, deliberately)', async () => {
+  assert.deepEqual(await logins('rank:metic'), ['m']);
+});
+
+await t('THE FIX: rank:metic+ seats metic AND archon', async () => {
+  assert.deepEqual(await logins('rank:metic+'), ['m', 'a']);
+});
+
+await t('rank:xenos+ is how you say everyone', async () => {
+  assert.deepEqual(await logins('rank:xenos+'), ['x', 't', 'm', 'a']);
+});
+
+await t('bare rank:xenos really does seat NEWCOMERS ONLY — the library\'s lie', async () => {
+  assert.deepEqual(await logins('rank:xenos'), ['x']);
+});
+
+await t('a comma union works, and composes with the ladder', async () => {
+  assert.deepEqual(await logins('rank:metic,archon'), ['m', 'a']);
+  assert.deepEqual(await logins('rank:metic+,gbmdb-ops-rank'), ['m', 'a', 'ops']);
+});
+
+await t('the deactivated and the machine are STILL excluded under the widened form', async () => {
+  // The two structural filters must survive the ANY() rewrite — a widened
+  // franchise that also admits a bot or a departed builder is a worse bug.
+  const l = await logins('rank:xenos+');
+  assert.ok(!l.includes('gone'), 'a deactivated builder never governs');
+  assert.ok(!l.includes('bot'), 'a machine principal never governs');
+});
+
+await t('no duplicate rows when a builder matches through two keys', async () => {
+  await pool.query('INSERT INTO government_builder_ranks (builder_id, rank_key) VALUES ($1, $2)', [ID.archon, 'gbmdb-ops-rank']);
+  try {
+    const l = await logins('rank:archon,gbmdb-ops-rank');
+    assert.deepEqual(l.filter((x) => x === 'a').length, 1,
+      'DISTINCT holds — a double-counted member silently raises the consent bar');
+  } finally {
+    await pool.query("DELETE FROM government_builder_ranks WHERE builder_id=$1 AND rank_key='gbmdb-ops-rank'", [ID.archon]);
+  }
+});
+
+await t('isBoardMember agrees with resolveBoardMembers on every form', async () => {
+  assert.equal(await isBoardMember(ID.archon, board('rank:metic+')), true, 'THE REGRESSION: the Archon keeps their seat');
+  assert.equal(await isBoardMember(ID.archon, board('rank:metic')), false, 'and the bare form still excludes them');
+  assert.equal(await isBoardMember(ID.metic, board('rank:metic+')), true);
+  assert.equal(await isBoardMember(ID.xenos, board('rank:xenos+')), true);
+  assert.equal(await isBoardMember(ID.gone, board('rank:xenos+')), false, 'deactivated');
+  assert.equal(await isBoardMember(ID.bot, board('rank:xenos+')), false, 'machine');
+});
+
+await t('an unparseable predicate still seats nobody against a real db', async () => {
+  assert.deepEqual(await logins('rank:ops+'), [], '+ on a non-ladder rank fails closed');
+  assert.deepEqual(await logins('nonsense'), []);
+});
+
+await cleanup();
+console.log(`\n${passed} passed, ${failed} failed`);
+await pool.end();
+process.exit(failed ? 1 : 0);

package/tests/government_board_vote.mjs

@@ -84,8 +84,10 @@ test('the happy path: a member yes is recorded fresh, with its +1 karma', async
   let insertArgs = null;
   await withDb({
     getBoardItemForVote: async () => openItem(),
-    builderHoldsRankActive: async (builderId, rankKey) =>
-      builderId === '42' && rankKey === 'archon', // the REAL membership parse chose 'archon' from the snapshot
+    builderHoldsRankActive: async (builderId, rankKeys) =>
+      // The db read takes a SET since task 1003094; the REAL membership parse
+      // resolved 'rank:archon' from the snapshot to the one-element set ['archon'].
+      builderId === '42' && rankKeys.includes('archon'),
     getBoardItemAuthor: async () => '7',          // someone else authored the idea
     insertBoardVote: async (args) => { insertArgs = args; return { id: '1', ...args }; },
     insertVoteKarma: async (args) => { karma.push(args); },
@@ -105,7 +107,7 @@ test('membership is the SNAPSHOT\'s rule: a rank the snapshot does not name is r
   // they hold A rank — just not the snapshotted one.
   await withDb({
     getBoardItemForVote: async () => openItem(),
-    builderHoldsRankActive: async (builderId, rankKey) => rankKey === 'metic', // holds metic, not archon
+    builderHoldsRankActive: async (builderId, rankKeys) => rankKeys.includes('metic'), // holds metic, not archon
     getBoardItemAuthor: async () => { throw new Error('must not be reached'); },
     insertBoardVote: async () => { throw new Error('must not be reached'); },
   }, async () => {

package/tests/government_constitution_view.mjs

@@ -86,3 +86,56 @@ test('the read rides the vote atom, and the client renders the SERVER value (sou
   assert.ok(!/'first_ratifier'[^]*hardcod/i.test(client), 'sanity');
   assert.match(client, /loadConstitution\(\)/, 'the panel loads for everyone the page admits');
 });
+
+// ── the hall's membership prose mirrors the server parser (task 1003094) ─────
+//
+// Browser code cannot import the server module (the established pattern here —
+// the five Full Idea section labels are mirrored the same way), so the hall
+// re-implements the predicate grammar to render it in plain language. Two copies
+// of a grammar is exactly the drift that produced the bug this task fixes, so
+// they are held equal here over every form.
+//
+// This matters more than a normal mirror: the Constitution panel is where an
+// owner READS who governs before deciding whether to change it. A panel that
+// misdescribes the franchise is the same failure as a resolver that mis-seats
+// it, one layer up.
+test('the hall renders every predicate form the server actually resolves', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/government.js'), 'utf8');
+
+  // Lift the browser mirror out of the IIFE and run it.
+  const ladder = /const STANDARD_LADDER = (\[[^\]]*\]);/.exec(src);
+  assert.ok(ladder, 'the hall must declare the standard ladder it expands `+` against');
+  const fn = /function membershipRankKeys\(predicate\) \{[\s\S]*?\n  \}/.exec(src);
+  assert.ok(fn, 'membershipRankKeys must be findable — this test lifts it');
+  // eslint-disable-next-line no-new-func
+  const browserKeys = new Function(`const STANDARD_LADDER = ${ladder[1]}; ${fn[0]}; return membershipRankKeys;`)();
+
+  const { parseMembershipPredicate } = require(path.join(ROOT, 'modules/government/membership-predicate.js'));
+
+  const forms = [
+    'rank:archon', 'rank:metic', 'rank:xenos', 'rank:custom-rank',
+    'rank:metic+', 'rank:xenos+', 'rank:archon+',
+    'rank:metic,archon', 'rank:metic+,ops', 'rank:archon,archon',
+    'rank:custom+', 'rank:', 'rank:metic++', 'rank:+metic', 'nonsense', '',
+    'rank:archon,', 'rank:,archon', 'rank:archon,,metic',
+  ];
+  for (const f of forms) {
+    const server = parseMembershipPredicate(f);
+    const browser = browserKeys(f);
+    assert.deepEqual(
+      browser === null ? null : browser,
+      server === null ? null : [...server.rankKeys],
+      `the hall and the server disagree about ${JSON.stringify(f)}`,
+    );
+  }
+});
+
+test('the ladder the hall expands against IS the government ladder', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/government.js'), 'utf8');
+  const { RANK_ORDER } = require(path.join(ROOT, 'modules/government/catalog.js'));
+  const m = /const STANDARD_LADDER = \[([^\]]*)\]/.exec(src);
+  assert.ok(m);
+  const hall = m[1].split(',').map((x) => x.trim().replace(/['"]/g, '')).filter(Boolean);
+  assert.deepEqual(hall, [...RANK_ORDER],
+    'a hall ladder that drifts from catalog.RANK_ORDER renders a franchise nobody has');
+});

package/tests/rank_tier_single_source.mjs

@@ -107,6 +107,15 @@ const STATIC_LADDER_FILES = [
   'modules/hall-ui/public/ranks.js',
   'modules/hall-ui/public/profile.js',
   'modules/hall-ui/public/watch.js',
+  // task 1003094: the Constitution panel expands the `rank:<key>+` membership
+  // form ("that rank and above") to render who governs in plain language, so it
+  // needs the ladder to expand against. Browser code cannot require the server
+  // module — the established mirror pattern here — and listing it in this array
+  // is what makes the copy provable rather than merely allowed. A second,
+  // government-specific pin lives in tests/government_constitution_view.mjs,
+  // which holds it against catalog.RANK_ORDER and holds the whole browser parser
+  // equal to the server one.
+  'modules/hall-ui/public/government.js',
 ];
 test('static ladder copies carry the exact canonical ladder', () => {
   for (const rel of STATIC_LADDER_FILES) {