@bongos/core 1.21.89 → 1.21.91

package/tests/government_board_routes.mjs

@@ -0,0 +1,361 @@
+// tests/government_board_routes.mjs — route-level tests for three Board Room
+// routes that had none (task 1004655):
+//
+//   POST /government/board/charter               (the genesis charter pick)
+//   POST /government/board/items/:itemId/withdraw (a proposer takes back a sitting)
+//   GET  /government/board/genesis-stages        (who each founding stage waits on)
+//
+// The module/SQL walls are pinned elsewhere (government_charter_forms.mjs,
+// government_board_withdraw.mjs, government_board_genesis_stage.mjs). What those
+// cannot see is the HTTP mapping: which atom gates each route, which status and
+// error code each refusal becomes, and that the SESSION builder (never the body)
+// is the proposer. So this drives a real express app through the real router
+// and the real board / board-withdraw logic, with the REAL requirePermission
+// gate resolving a STUB government port on the seam and the db slice
+// monkeypatched by property — the tests/government_routes.mjs pattern.
+//
+// The live constitution is this checkout's neutral monarchy (rank:archon,
+// first_ratifier) — a guard test below pins that, because the charter cases
+// depend on it.
+//
+// Run:  node --test tests/government_board_routes.mjs
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import http from 'node:http';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const GOV = path.join(ROOT, 'modules', 'government');
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const govDb = require(path.join(GOV, 'db.js'));
+const config = require(path.join(GOV, 'config.js'));
+const { readCharter } = require(path.join(GOV, 'charter.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+const express = require('express');
+
+const SESSION_ID = 42;
+const MONARCHY = Object.freeze({
+  membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true,
+});
+
+// ── harness ─────────────────────────────────────────────────────────────────
+
+// Every db function a test stubs is recorded, then restored after the test.
+const calls = [];
+async function withDb(stubs, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(stubs)) {
+    originals[k] = govDb[k];
+    govDb[k] = (...args) => { calls.push([k, ...args]); return v(...args); };
+  }
+  try { return await fn(); } finally { for (const [k, v] of Object.entries(originals)) govDb[k] = v; }
+}
+const called = (name) => calls.filter(([k]) => k === name);
+
+// Fake the session (requireBuilder is captured at router build time); keep the
+// REAL requirePermission gate, which resolves the government port per request.
+const realRequireBuilder = api.requireBuilder;
+api.requireBuilder = (req, res, next) => { req.builder = { id: SESSION_ID, rank: 'archon' }; next(); };
+
+function grant(keys) {
+  seams._reset();
+  seams.registerProvider('government', { resolveBuilderPermissions: async () => keys });
+}
+const ALL = ['board.item.open', 'board.vote.cast'];
+grant(ALL);
+
+const buildGovernmentRouter = require(path.join(GOV, 'routes', 'government.js'));
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(buildGovernmentRouter());
+const server = http.createServer(app);
+await new Promise((r) => server.listen(0, '127.0.0.1', r));
+const BASE = `http://127.0.0.1:${server.address().port}`;
+
+after(() => {
+  server.close();
+  api.requireBuilder = realRequireBuilder;
+  seams._reset();
+});
+
+async function call(method, p, body) {
+  calls.length = 0;
+  const res = await fetch(`${BASE}${p}`, {
+    method,
+    headers: body === undefined ? {} : { 'content-type': 'application/json' },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  let json = null;
+  try { json = await res.json(); } catch { /* no body */ }
+  return { status: res.status, json };
+}
+
+// The db a successful charter filing walks through: the amendment row, then
+// its sitting under the constitution IN FORCE.
+const filingDb = (over = {}) => ({
+  builderHoldsRankActive: async () => true,
+  getRankByKey: async () => null,
+  createAmendment: async (a) => ({ id: '5', proposed: a.proposed, proposed_by: a.proposedBy }),
+  openBoardItem: async (a) => ({
+    id: '21', subject_type: a.subjectType, subject_id: '5', opened_by: a.openedBy,
+    constitution: a.constitution, closes_at: null, closed_at: null,
+  }),
+  getActiveBuildersWithRank: async () => [],
+  ...over,
+});
+
+test('this checkout runs the neutral monarchy (the charter cases below depend on it)', () => {
+  assert.equal(readCharter(config.loadGovernmentConfig().board).form, 'monarchy');
+});
+
+// ── the rank wall ───────────────────────────────────────────────────────────
+
+// Holding the OTHER board atom is not enough: charter and withdraw need
+// board.item.open, the stage read needs board.vote.cast. One test per route, so
+// a broken gate names its route.
+const unreachable = {
+  listLatestGenesisStageItems: async () => { throw new Error('must not be reached'); },
+  getBoardItemForVote: async () => { throw new Error('must not be reached'); },
+  createAmendment: async () => { throw new Error('must not be reached'); },
+};
+for (const [method, p, body, held, missing] of [
+  ['POST', '/government/board/charter', { form: 'direct-democracy' }, 'board.vote.cast', 'board.item.open'],
+  ['POST', '/government/board/items/21/withdraw', {}, 'board.vote.cast', 'board.item.open'],
+  ['GET', '/government/board/genesis-stages', undefined, 'board.item.open', 'board.vote.cast'],
+]) {
+  test(`${method} ${p} refuses a builder without ${missing} (403 permission_forbidden), before the db`, async () => {
+    grant([held]);
+    try {
+      await withDb(unreachable, async () => {
+        const r = await call(method, p, body);
+        assert.equal(r.status, 403, `${method} ${p} must deny without ${missing}`);
+        assert.equal(r.json.error.code, 'permission_forbidden');
+        assert.equal(calls.length, 0, 'the refusal is before the db');
+      });
+    } finally { grant(ALL); }
+  });
+}
+
+// ── POST /government/board/charter ──────────────────────────────────────────
+
+test('charter: a new form is filed as an amendment by the SESSION builder, 201 with what it reads as', async () => {
+  await withDb(filingDb(), async () => {
+    // A body cannot name the proposer: the strict schema refuses the field outright.
+    const spoof = await call('POST', '/government/board/charter', { form: 'direct-democracy', proposed_by: 999 });
+    assert.equal(spoof.status, 400);
+    assert.equal(spoof.json.error.code, 'validation_failed');
+    assert.equal(called('createAmendment').length, 0);
+
+    const r = await call('POST', '/government/board/charter', { form: 'direct-democracy' });
+    assert.equal(r.status, 201);
+    assert.equal(r.json.ok, true);
+    assert.equal(r.json.reads_as.form, 'direct-democracy');
+    assert.equal(r.json.item.id, '21');
+    const [filed] = called('createAmendment');
+    assert.ok(filed, 'an amendment was filed');
+    assert.equal(filed[1].proposed.membership, 'rank:xenos+');
+    assert.equal(filed[1].proposedBy, SESSION_ID, 'the proposer is the session, never the body');
+    const [opened] = called('openBoardItem');
+    assert.equal(opened[1].openedBy, SESSION_ID);
+    assert.deepEqual(opened[1].constitution, config.loadGovernmentConfig().board,
+      'the sitting runs under the constitution IN FORCE, not the one proposed');
+  });
+});
+
+test('charter: picking the form already in force is no_change 409 and files nothing', async () => {
+  await withDb(filingDb(), async () => {
+    const r = await call('POST', '/government/board/charter', { form: 'monarchy' });
+    assert.equal(r.status, 409);
+    assert.equal(r.json.error.code, 'no_change');
+    assert.equal(called('createAmendment').length, 0);
+  });
+});
+
+test('charter: an unreadable choice is invalid_charter 400 naming the reason, and files nothing', async () => {
+  await withDb(filingDb(), async () => {
+    for (const [body, reason] of [
+      [{ form: 'no-such-form' }, 'unknown_form'],
+      [{}, 'nothing_chosen'],
+      [{ franchise: 'nobody-knows' }, 'unknown_franchise'],
+      [{ pass_rule: 'coin_toss' }, 'unknown_pass_rule'],
+      [{ franchise: 'council' }, 'council_needs_a_rank'],
+    ]) {
+      const r = await call('POST', '/government/board/charter', body);
+      assert.equal(r.status, 400, JSON.stringify(body));
+      assert.equal(r.json.error.code, 'invalid_charter', JSON.stringify(body));
+      assert.equal(r.json.error.details.reason, reason, JSON.stringify(body));
+    }
+    // A council must be a rank that exists; the refusal names the key.
+    const ghost = await call('POST', '/government/board/charter', { franchise: 'council', council_rank: 'ghosts' });
+    assert.equal(ghost.status, 400);
+    assert.equal(ghost.json.error.code, 'invalid_charter');
+    assert.equal(ghost.json.error.details.reason, 'unknown_council_rank');
+    assert.equal(ghost.json.error.details.rank_key, 'ghosts');
+    assert.equal(called('createAmendment').length, 0);
+  });
+});
+
+test('charter: a malformed body is refused before the board is asked', async () => {
+  await withDb(filingDb(), async () => {
+    const typed = await call('POST', '/government/board/charter', { form: 7 });
+    assert.equal(typed.status, 400);
+    assert.equal(typed.json.error.code, 'validation_failed');
+    const clock = await call('POST', '/government/board/charter', { form: 'direct-democracy', window_minutes: 1.5 });
+    assert.equal(clock.status, 400);
+    assert.equal(clock.json.error.code, 'invalid_proposal');
+    assert.equal(clock.json.error.details.reason, 'bad_window_minutes');
+    assert.equal(called('createAmendment').length, 0);
+  });
+});
+
+test('charter: a clock (window_minutes) is accepted and filed with the proposal', async () => {
+  // The handler reads window_minutes and the charter builder files it, so the
+  // strict schema must declare it — otherwise every request carrying a clock
+  // is refused as an unknown field and the clock can never be chosen here.
+  await withDb(filingDb(), async () => {
+    const r = await call('POST', '/government/board/charter', { pass_rule: 'consent', window_minutes: 90 });
+    assert.equal(r.status, 201, JSON.stringify(r.json));
+    const [filed] = called('createAmendment');
+    assert.equal(filed[1].proposed.window_minutes, 90);
+    assert.equal(filed[1].proposed.pass_rule, 'consent');
+  });
+});
+
+test('charter: a pick that unseats the proposer is 409 proposer_would_lose_their_seat until acknowledged', async () => {
+  await withDb(filingDb({ builderHoldsRankActive: async () => false }), async () => {
+    const r = await call('POST', '/government/board/charter', { form: 'direct-democracy' });
+    assert.equal(r.status, 409);
+    assert.equal(r.json.error.code, 'proposer_would_lose_their_seat');
+    assert.equal(r.json.error.details.membership, 'rank:xenos+');
+    assert.deepEqual(r.json.error.details.retry_with, { acknowledge_self_removal: true });
+    assert.ok(r.json.error.details.what_this_means, 'the refusal carries the words the hall shows');
+    assert.equal(called('createAmendment').length, 0, 'nothing is filed on the refusal');
+
+    const ack = await call('POST', '/government/board/charter', { form: 'direct-democracy', acknowledge_self_removal: true });
+    assert.equal(ack.status, 201, 'the acknowledged pick files');
+    assert.equal(called('createAmendment').length, 1);
+  });
+});
+
+test('charter: a db failure is a plain 500 charter_failed', async () => {
+  await withDb(filingDb({ createAmendment: async () => { throw new Error('boom'); } }), async () => {
+    const r = await call('POST', '/government/board/charter', { form: 'direct-democracy' });
+    assert.equal(r.status, 500);
+    assert.equal(r.json.error.code, 'charter_failed');
+  });
+});
+
+// ── POST /government/board/items/:itemId/withdraw ───────────────────────────
+
+const openItem = (over = {}) => ({
+  id: '21', subject_type: 'constitutional_amendment', subject_id: '5', opened_by: String(SESSION_ID),
+  constitution: MONARCHY, closed_at: null, expired: false, ...over,
+});
+const withdrawDb = (over = {}) => ({
+  getBoardItemForVote: async () => openItem(),
+  getVotesForItem: async () => [],
+  withdrawBoardItem: async ({ itemId }) => ({ ...openItem(), id: String(itemId), closed_at: 'T', outcome: 'withdrawn' }),
+  ...over,
+});
+
+test('withdraw: the proposer takes back their own unvoted sitting — 200, closed as withdrawn', async () => {
+  await withDb(withdrawDb(), async () => {
+    const r = await call('POST', '/government/board/items/21/withdraw', {});
+    assert.equal(r.status, 200);
+    assert.equal(r.json.ok, true);
+    assert.equal(r.json.item_closed, true);
+    assert.equal(r.json.outcome, 'withdrawn');
+    const [w] = called('withdrawBoardItem');
+    assert.ok(w, 'the write ran');
+    assert.equal(w[1].itemId, '21');
+    assert.equal(w[1].builderId, SESSION_ID, 'the withdrawer is the session builder');
+  });
+});
+
+test('withdraw: someone who did not open the sitting is refused 403 not_proposer', async () => {
+  for (const openedBy of ['99', null]) {
+    await withDb(withdrawDb({ getBoardItemForVote: async () => openItem({ opened_by: openedBy }) }), async () => {
+      const r = await call('POST', '/government/board/items/21/withdraw', {});
+      assert.equal(r.status, 403, `opened_by ${openedBy}`);
+      assert.equal(r.json.error.code, 'not_proposer');
+      assert.equal(r.json.error.details.item_id, 21);
+      assert.equal(called('withdrawBoardItem').length, 0, 'nothing is written');
+    });
+  }
+});
+
+test('withdraw: once anyone has voted it is refused 409 votes_cast', async () => {
+  const votes = [{ voter_id: '43', direction: 'no' }];
+  await withDb(withdrawDb({ getVotesForItem: async () => votes }), async () => {
+    const r = await call('POST', '/government/board/items/21/withdraw', {});
+    assert.equal(r.status, 409);
+    assert.equal(r.json.error.code, 'votes_cast');
+    assert.equal(called('withdrawBoardItem').length, 0, 'the voters keep their say');
+  });
+});
+
+test('withdraw: missing, closed, expired and raced sittings each get their own refusal', async () => {
+  for (const [over, status, code] of [
+    [{ getBoardItemForVote: async () => null }, 404, 'item_not_found'],
+    [{ getBoardItemForVote: async () => openItem({ closed_at: 'T', outcome: 'passed' }) }, 409, 'item_closed'],
+    [{ getBoardItemForVote: async () => openItem({ expired: true }) }, 409, 'vote_window_expired'],
+    // A vote landing between the reads and the write: the guarded write finds no row.
+    [{ withdrawBoardItem: async () => null }, 409, 'item_changed'],
+  ]) {
+    await withDb(withdrawDb(over), async () => {
+      const r = await call('POST', '/government/board/items/21/withdraw', {});
+      assert.equal(r.status, status, code);
+      assert.equal(r.json.error.code, code);
+    });
+  }
+});
+
+test('withdraw: a non-numeric item id is 400 before the db', async () => {
+  await withDb(withdrawDb(), async () => {
+    const r = await call('POST', '/government/board/items/abc/withdraw', {});
+    assert.equal(r.status, 400);
+    assert.equal(r.json.error.code, 'bad_item_id');
+    assert.equal(calls.length, 0);
+  });
+});
+
+// ── GET /government/board/genesis-stages ────────────────────────────────────
+
+test('genesis-stages: five stages, and an open sitting names who it is still waiting on', async () => {
+  const sitting = {
+    id: '90', subject_type: 'genesis_stage', subject_id: '3', opened_by: String(SESSION_ID),
+    opened_at: 'T0', closes_at: null, closed_at: null, outcome: null, remaining_seconds: null, constitution: MONARCHY,
+  };
+  const passed = { ...sitting, id: '80', subject_id: '1', closed_at: 'T1', outcome: 'passed' };
+  await withDb({
+    listLatestGenesisStageItems: async () => [passed, sitting],
+    getVotesForItems: async () => [],
+    getActiveBuildersWithRank: async () => [{ builder_id: '42', github_login: 'founder', display_name: 'Founder' }],
+  }, async () => {
+    const r = await call('GET', '/government/board/genesis-stages');
+    assert.equal(r.status, 200);
+    const stages = r.json.stages;
+    assert.deepEqual(stages.map((s) => s.key), ['scope', 'strategize', 'charter', 'legalize', 'legislation']);
+    assert.equal(stages[0].state, 'passed');
+    assert.equal(stages[1].state, 'not_put');
+    assert.equal(stages[2].state, 'sitting');
+    assert.equal(stages[2].item_id, '90');
+    assert.equal(stages[2].one_vote_decides, true);
+    assert.deepEqual(stages[2].waiting_on.map((m) => m.builder_id), ['42']);
+    assert.deepEqual(called('getVotesForItems')[0][1], ['90'], 'only the open sitting is asked for votes');
+  });
+});
+
+test('genesis-stages: a db failure is a plain 500 genesis_stage_read_failed', async () => {
+  await withDb({ listLatestGenesisStageItems: async () => { throw new Error('boom'); } }, async () => {
+    const r = await call('GET', '/government/board/genesis-stages');
+    assert.equal(r.status, 500);
+    assert.equal(r.json.error.code, 'genesis_stage_read_failed');
+  });
+});