@bongos/core 1.21.87 → 1.21.89

package/tests/genesis_government.mjs

@@ -0,0 +1,220 @@
+// tests/genesis_government.mjs — THE GOVERNMENT PICKED AT GENESIS IS THE ONE IN FORCE
+// (task 1004656, goal 1000111 criterion gov-born-governed).
+//
+// WHAT IT GUARDS. A founder picks a starting government on the genesis decide screen.
+// Before this task the pick was stored in the plan and never read again, so every
+// project left genesis on the default monarchy it never chose. Now saving the plan
+// files the pick as a charter amendment under the constitution in force, and under the
+// monarchy a project is born with, the founder's own yes applies it. What can go wrong:
+//   * the pick saved but nothing filed (the old bug), or filed and never applied;
+//   * a pick that cannot be filed refusing the whole plan (the plan must always save);
+//   * Foundation filed with no council, which would seat nobody;
+//   * the hall's Charter picker filing a constitution the server would not build.
+//
+// The path RUNS end to end over the real code: genesis-home's savePlan with the REAL
+// government port's proposeCharter, castVote and close (db stubbed, the board's own
+// logic real), and the ratified text written through the stubbed apply. The hall
+// picker runs the real street-amend.js over the server's real charter view.
+//
+// Run:  node --test tests/genesis_government.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+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 GOV = path.join(ROOT, 'modules', 'government');
+const gh = require(path.join(ROOT, 'modules', 'onboarding', 'genesis-home.js'));
+const board = require(path.join(GOV, 'board.js'));
+const db = require(path.join(GOV, 'db.js'));
+const config = require(path.join(GOV, 'config.js'));
+const charter = require(path.join(GOV, 'charter.js'));
+const DR = require(path.join(GOV, 'decision-rules.js'));
+const A = require(path.join(ROOT, 'modules', 'hall-ui', 'public', 'street-amend.js'));
+
+const MONARCHY = Object.freeze({ membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true });
+const FOUNDER = '42';
+const j = (v) => JSON.parse(JSON.stringify(v));
+
+// A founding project in its decide stage: an in-memory project_settings store, a fake
+// lifecycle seeder, and the REAL government port surface genesis-home calls.
+function project() {
+  const store = new Map();
+  const deps = {
+    getSetting: async (k) => (store.has(k) ? { key: k, value: store.get(k) } : null),
+    setSetting: async (k, v) => { store.set(k, String(v)); return { key: k, value: String(v) }; },
+    lifecycle: { seedGenesis: async () => ({ seeded: 5 }), genesisTasks: async () => ({}) },
+    government: {
+      proposeCharter: board.proposeCharter,
+      genesisStageStatus: async () => ({ stages: [] }),
+    },
+    now: new Date('2026-10-08T00:00:00Z'),
+  };
+  return { store, deps };
+}
+
+// The board's db, stubbed to one founder under the monarchy a project is born with;
+// everything that decides (validation, the self-removal guard, the tally, the close)
+// is the real board.js. Returns what was filed and what was applied.
+async function underMonarchy(fn) {
+  const seen = { filed: null, applied: [], votes: [] };
+  const originals = {};
+  const stubs = {
+    builderHoldsRankActive: async () => true,
+    getRankByKey: async () => null,
+    createAmendment: async (args) => { seen.filed = args; return { id: '5', proposed: args.proposed, proposed_by: args.proposedBy }; },
+    openBoardItem: async (args) => ({ id: '21', subject_type: args.subjectType, subject_id: '5', opened_by: args.openedBy, constitution: args.constitution, closes_at: null, closed_at: null }),
+    getBoardItemForVote: async () => ({ id: '21', subject_type: 'constitutional_amendment', subject_id: '5', opened_by: FOUNDER, constitution: MONARCHY, closed_at: null, expired: false }),
+    insertBoardVote: async (row) => { const v = { voter_id: row.voterId, direction: row.direction }; seen.votes.push(v); return v; },
+    insertVoteKarma: async () => {},
+    getVotesForItem: async () => seen.votes,
+    getActiveBuildersWithRank: async () => [{ builder_id: FOUNDER, github_login: 'founder', display_name: 'Founder' }],
+    getBoardItemAuthor: async () => FOUNDER,
+    closeBoardItem: async ({ outcome }) => ({ id: '21', subject_type: 'constitutional_amendment', subject_id: '5', opened_by: FOUNDER, closed_at: 'T', outcome }),
+    insertAuthorRatifyKarma: async () => true,
+    getAmendment: async () => ({ id: '5', proposed: seen.filed.proposed }),
+  };
+  for (const [k, v] of Object.entries(stubs)) { originals[k] = db[k]; db[k] = v; }
+  const originalApply = config.applyBoardAmendment;
+  config.applyBoardAmendment = (proposed) => { seen.applied.push(proposed); return proposed; };
+  try { await fn(seen); } finally {
+    for (const [k, v] of Object.entries(originals)) db[k] = v;
+    config.applyBoardAmendment = originalApply;
+  }
+  return seen;
+}
+
+async function decide(plan) {
+  const p = project();
+  assert.equal((await gh.startFounding(FOUNDER, p.deps)).ok, true);
+  const out = await gh.savePlan(plan, FOUNDER, p.deps);
+  return { p, out };
+}
+
+test('this checkout is born a monarchy, the state every genesis starts from', () => {
+  assert.equal(charter.readCharter(config.loadGovernmentConfig().board).form, 'monarchy');
+});
+
+for (const form of ['timocratic-republic', 'direct-democracy']) {
+  test(`picking ${form} at decide files it, the founder's one yes applies it, and the constitution reads as ${form}`, async () => {
+    const seen = await underMonarchy(async () => {
+      const { out } = await decide({ government: form });
+      assert.equal(out.ok, true, 'the plan saves');
+      assert.equal(out.charter.state, 'sitting', 'the pick is filed, not just recorded');
+      assert.equal(out.charter.one_vote_decides, true, 'under the monarchy the founder\'s yes carries it');
+      assert.equal(out.charter.item_id, '21');
+      // what the hall does next: the founder's yes, then the close
+      await board.castVote({ itemId: out.charter.item_id, voterId: FOUNDER, direction: 'yes' });
+      assert.equal((await board.maybeCloseAfterVote(out.charter.item_id)).outcome, 'passed');
+    });
+    assert.equal(seen.applied.length, 1, 'the ratified constitution is applied once');
+    assert.equal(charter.readCharter(seen.applied[0]).form, form, 'the constitution in force is the government the founder picked');
+    assert.match(seen.filed.rationaleMd, /^Charter: /, 'the record says in words what was chosen');
+  });
+}
+
+test('picking Monarchy files nothing: it is already the government in force', async () => {
+  const seen = await underMonarchy(async () => {
+    const { out } = await decide({ government: 'monarchy' });
+    assert.equal(out.ok, true);
+    assert.deepEqual(out.charter, { state: 'in_force', form: 'monarchy' });
+  });
+  assert.equal(seen.filed, null);
+});
+
+test('Foundation needs a council first: the plan saves, nothing is filed, and the reason is named', async () => {
+  const seen = await underMonarchy(async () => {
+    const { p, out } = await decide({ government: 'foundation' });
+    assert.equal(out.ok, true, 'the plan is never refused over the government');
+    assert.deepEqual(out.charter, { state: 'needs_council', form: 'foundation' });
+    assert.equal(JSON.parse(p.store.get(gh.PLAN_KEY)).government, 'foundation', 'the pick is still recorded');
+  });
+  assert.equal(seen.filed, null, 'a council nobody sits on is never filed');
+});
+
+test('no pick, no government module, a refusal, a throw: the plan still saves and says what happened', async () => {
+  let r = await decide({});
+  assert.deepEqual(r.out.charter, { state: 'none' });
+  const p = project();
+  await gh.startFounding(FOUNDER, p.deps);
+  p.deps.government = { genesisStageStatus: async () => ({ stages: [] }) };
+  r = { out: await gh.savePlan({ government: 'direct-democracy' }, FOUNDER, p.deps) };
+  assert.equal(r.out.ok, true);
+  assert.deepEqual(r.out.charter, { state: 'not_filed', form: 'direct-democracy', reason: 'no_government' });
+  for (const [proposeCharter, reason] of [
+    [async () => ({ ok: false, reason: 'unknown_form' }), 'unknown_form'],
+    [async () => { throw new Error('board down'); }, 'charter_failed'],
+  ]) {
+    const q = project();
+    await gh.startFounding(FOUNDER, q.deps);
+    q.deps.government = { proposeCharter, genesisStageStatus: async () => ({ stages: [] }) };
+    const out = await gh.savePlan({ government: 'direct-democracy' }, FOUNDER, q.deps);
+    assert.equal(out.ok, true, `${reason}: the plan saves`);
+    assert.equal(out.charter.state, 'not_filed');
+    assert.equal(out.charter.reason, reason);
+  }
+});
+
+test('a demo stays the monarchy it is born with (owner ruling 2026-10-01): nothing is filed', () => {
+  assert.equal(gh.demoPlan({ people: 3, hours_each: 4 }).government, 'monarchy');
+});
+
+// ── the hall's Charter picker ───────────────────────────────────────────────
+
+function constitutionView(boardBlock = MONARCHY) {
+  return j({
+    board: boardBlock,
+    charter: charter.charterView(boardBlock),
+    decision_rules: {
+      areas: DR.resolveAll([], { board: boardBlock }),
+      rules: DR.DECISION_RULES.map((r) => ({ key: r.key, words: r.words })),
+      changed_by: 'a passed amendment only',
+    },
+  });
+}
+
+test('the Charter offers the forms that can be adopted in one tap; Foundation and the later forms are named, not offered', () => {
+  const d = A.draftFor('charter', constitutionView());
+  assert.deepEqual(d.forms.pick.map((f) => f.words), ['Monarchy / BDFL', 'Timocratic Republic', 'Direct Democracy']);
+  assert.deepEqual(d.forms.council, ['Foundation']);
+  assert.deepEqual(d.forms.later, ['Presidential', 'Cooperative', 'Federation']);
+  assert.equal(A.draftFor('review', constitutionView()).forms.pick.length, 0, 'only the Charter carries forms');
+});
+
+test('a tapped form sets who and how together, files through the charter route, and the server builds the same constitution', () => {
+  for (const key of ['timocratic-republic', 'direct-democracy']) {
+    let d = A.draftFor('charter', constitutionView());
+    d = A.pick(d, 'form', key);
+    assert.equal(A.formOf(d).value, key, 'the lit chip is the form the settings make');
+    d = A.pick(d, 'reason', 'More of us should decide.');
+    const req = A.request(d);
+    assert.equal(req.url, '/api/bongos/government/board/charter');
+    assert.deepEqual(req.body, { form: key, rationale_md: 'More of us should decide.' });
+    // what the server files for that body
+    const built = charter.buildCharterProposal(MONARCHY, { form: key });
+    assert.equal(built.ok, true);
+    assert.equal(built.proposal.membership, d.decided_by, `${key}: the seat the hall showed is the seat the server files`);
+    assert.equal(charter.readCharter(built.proposal).form, key);
+    assert.match(A.answer(d, { item: { id: 7 } }).toast, new RegExp(A.formOf(d).words.replace(/[/]/g, '\\/')));
+  }
+});
+
+test('picking who or how by hand after a form lights no form, and files as a plain amendment', () => {
+  let d = A.pick(A.draftFor('charter', constitutionView()), 'form', 'direct-democracy');
+  d = A.pick(d, 'rule', 'majority');
+  assert.equal(A.formOf(d), null, 'the name follows the settings: a mix is no named form');
+  d = A.pick(d, 'reason', 'A majority, not consent.');
+  assert.equal(A.request(d).url, '/api/bongos/government/board/items');
+  assert.equal(A.pick(d, 'form', 'presidential'), d, 'a form outside the offered set changes nothing');
+});
+
+test('the charter route\'s refusals are said in words', () => {
+  const d = A.draftFor('charter', constitutionView());
+  const say = (reason) => A.refusal(400, { error: { code: 'invalid_charter', details: { reason } } });
+  assert.match(say('council_needs_a_rank'), /council rank/);
+  assert.match(say('form_not_available'), /not available yet/);
+  assert.ok(d.ok);
+});