@bongos/core 1.21.113 → 1.21.114

package/tests/government_counts.mjs

@@ -0,0 +1,143 @@
+// tests/government_counts.mjs — GET /government/counts, the government's counts in
+// one server read (task 1004716, goal 1000111).
+//
+// What it pins:
+//   1. the server's rule IS the docket's route: on you = route.yours (the docket's
+//      own counts.yours), on others = needs that are not yours and that somebody can
+//      still answer, an unrouted docket puts every need on you, an unread figure is
+//      null, never 0;
+//   2. it agrees with the deck: the hall's one count rule (gov-living.js countsOf)
+//      over the docket alone and over the server's counts gives the same numbers,
+//      with and without answers, so no surface can drift from the server;
+//   3. countsFor reads the viewer's own docket and the traffic port; the route is
+//      gated like the docket; the agents count is the open claims GET
+//      /tasks/claimable lists, and lifecycle hands both counts over its port;
+//   4. the harness fixture is the rule run over the harness's own docket.
+//
+// Run:  node --test --test-reporter=tap tests/government_counts.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const require = createRequire(import.meta.url);
+const C = require(path.join(ROOT, 'modules/government/counts.js'));
+const L = require(path.join(ROOT, 'modules/hall-ui/public/gov-living.js'));
+const FX = path.join(ROOT, 'scripts/hall-preview/fixtures');
+const fx = (n) => JSON.parse(fs.readFileSync(path.join(FX, n + '.json'), 'utf8'));
+const read = (f) => fs.readFileSync(path.join(ROOT, f), 'utf8');
+const NOW = Date.parse('2026-10-09T15:00:00.000Z');
+const TRAFFIC = { moving: 6, agents_at_work: 5 };
+
+// the harness docket, with one ask on somebody else, one nobody can answer any
+// more and one moving: every way a matter can leave "to do"
+function mixedDocket() {
+  const d = fx('government__docket');
+  const needs = d.matters.filter((m) => m.state === 'needs');
+  needs[0].route = Object.assign({}, needs[0].route, { yours: false });
+  needs[1].route = Object.assign({}, needs[1].route, { yours: false, nobody: { why: 'lapsed', outcome: null } });
+  needs[2].state = 'moving';
+  needs[2].route = Object.assign({}, needs[2].route, { yours: false });
+  return d;
+}
+
+// ── 1. the rule ──────────────────────────────────────────────────────────────
+
+test('on you is the docket\'s own route; on others is what somebody else can still answer', () => {
+  const d = fx('government__docket');
+  const c = C.countsOf(d, TRAFFIC);
+  assert.equal(c.on_you, d.counts.yours, 'the docket\'s own counts.yours');
+  assert.equal(c.on_you, d.matters.filter((m) => m.route && m.route.yours).length);
+  assert.deepEqual(c.yours, d.matters.filter((m) => m.route && m.route.yours).map((m) => m.id));
+  const x = C.countsOf(mixedDocket(), TRAFFIC);
+  assert.equal(x.on_you, c.on_you - 3);
+  assert.equal(x.on_others, 1, 'the lapsed ask and the moving matter are on nobody\'s list');
+  assert.equal(x.open, x.on_you + x.on_others);
+  assert.deepEqual([x.agents_at_work, x.moving], [5, 6]);
+});
+
+test('an unrouted docket puts every need on you; an unread figure is null, never 0', () => {
+  const d = mixedDocket();
+  d.routed = false;
+  const c = C.countsOf(d, {});
+  assert.equal(c.on_you, d.matters.filter((m) => m.state === 'needs').length);
+  assert.equal(c.on_others, 0);
+  assert.deepEqual([c.agents_at_work, c.moving], [null, null], 'no traffic read');
+  const none = C.countsOf(null, TRAFFIC);
+  assert.deepEqual([none.on_you, none.on_others, none.open, none.yours], [null, null, null, null]);
+  assert.deepEqual(C.countsOf({ matters: [], routed: true }, { moving: 0, agents_at_work: 0 }).on_you, 0, 'read and empty is a real zero');
+});
+
+// ── 2. it agrees with the deck ───────────────────────────────────────────────
+
+test('the hall\'s count rule over the docket and over the server\'s counts give the same numbers', () => {
+  for (const d of [fx('government__docket'), mixedDocket()]) {
+    const srv = C.countsOf(d, TRAFFIC);
+    const claims = { active_claims: Array.from({ length: 5 }, (_, i) => ({ claim_id: String(i), task_id: String(i) })) };
+    const fromDocket = L.livingModel({ docket: d, claims, moving: { moving: 6 }, me: fx('me'), now: NOW });
+    const fromServer = L.livingModel({ counts: srv, me: fx('me'), now: NOW });
+    const strip = (c) => { const o = { ...c }; delete o._sources; return o; };
+    assert.deepEqual(strip(L.countsOf(fromServer)), strip(L.countsOf(fromDocket)));
+    assert.deepEqual(strip(L.countsOf(fromServer)), { on_you: srv.on_you, on_others: srv.on_others, open: srv.open, agents_at_work: 5, moving: 6 });
+    // an answer on the page leaves both the same way
+    const answered = [srv.yours[0], srv.yours[1]].concat(srv.others.slice(0, 1));
+    assert.deepEqual(strip(L.countsOf(fromServer, { answered })), strip(L.countsOf(fromDocket, { answered })));
+  }
+});
+
+test('the deck holds what the server counts', () => {
+  const K = (() => {
+    for (const f of ['street-draw.js', 'street-inside.js', 'street-depth.js', 'street-card.js', 'street-desk.js']) require(path.join(ROOT, 'modules/hall-ui/public', f));
+    return require(path.join(ROOT, 'modules/hall-ui/public/street-deck.js'));
+  })();
+  const d = mixedDocket();
+  const srv = C.countsOf(d, TRAFFIC);
+  const living = L.livingModel({ docket: d, counts: srv, me: fx('me'), now: NOW });
+  const dm = K.deckModel({
+    living, docket: d, goals: [], now: NOW, viewerId: String(d.viewer.id), scope: null,
+    session: { done: {}, delegated: {}, skipped: [], extra: [], batch: null, noBatch: {} },
+  });
+  assert.equal(dm.lead.n, srv.on_you);
+  assert.equal(dm.remaining, srv.open);
+});
+
+// ── 3. the read ──────────────────────────────────────────────────────────────
+
+test('countsFor reads the viewer\'s own docket and the traffic', async () => {
+  const seen = [];
+  const docket = { docketFor: async (b) => { seen.push(b.id); return fx('government__docket'); } };
+  const c = await C.countsFor({ id: '1000025' }, { docket, readTraffic: async () => TRAFFIC });
+  assert.deepEqual(seen, ['1000025']);
+  assert.equal(c.viewer.id, '1000025');
+  assert.equal(c.on_you, fx('government__docket').counts.yours);
+  assert.deepEqual([c.agents_at_work, c.moving], [5, 6]);
+});
+
+test('the route is gated like the docket, and lifecycle hands both traffic counts over its port', async () => {
+  const route = read('modules/government/routes/government.js');
+  assert.match(route, /router\.get\('\/government\/counts', api\.requireBuilder, api\.requirePermission\('board\.vote\.cast'\)/);
+  assert.match(read('modules/lifecycle/routes/moving.js'), /registerProvider\('lifecycle\.traffic', \{ countMoving: moving\.countMoving, countAgentsAtWork: moving\.countAgentsAtWork \}\)/);
+  assert.ok(JSON.parse(read('modules/lifecycle/module.json')).provides.includes('lifecycle.traffic'));
+  const prev = process.env.NODE_ENV;
+  process.env.NODE_ENV = 'test';
+  try {
+    const moving = require(path.join(ROOT, 'modules/lifecycle/moving.js'));
+    let sql = '';
+    const n = await moving.countAgentsAtWork({ pool: { query: async (q) => { sql = q; return { rows: [{ n: 4 }] }; } } });
+    assert.equal(n, 4);
+    assert.match(sql, /FROM claims c/);
+    assert.match(sql, /released_at IS NULL/, 'one agent per open claim, as GET /tasks/claimable lists them');
+  } finally { process.env.NODE_ENV = prev; }
+});
+
+// ── 4. the harness fixture ──────────────────────────────────────────────────
+
+test('the harness serves the rule run over its own docket', () => {
+  const d = fx('government__docket');
+  const want = Object.assign({ viewer: d.viewer, generated_at: d.generated_at }, C.countsOf(d, { moving: fx('moving').moving, agents_at_work: fx('tasks__claimable').active_claims.length }));
+  assert.deepEqual(fx('government__counts'), want);
+});

package/tests/government_decision_rules.mjs

@@ -315,7 +315,10 @@ test('a PASSED decision-rules amendment writes the rows inside the closing trans
   const log = [];
   let written = null;
   const origApply = config.applyBoardAmendment;
-  config.applyBoardAmendment = () => { throw new Error('a rules amendment must not rewrite the board block'); };
+  // closeItem catches an apply failure and only logs it, so a throwing stub would
+  // pass silently: count the calls instead (the government_laws.mjs pattern).
+  let boardWrites = 0;
+  config.applyBoardAmendment = () => { boardWrites += 1; return {}; };
   try {
     await withDb({
       getVotesForItem: async () => [{ voter_id: '42', direction: 'yes' }],
@@ -331,6 +334,7 @@ test('a PASSED decision-rules amendment writes the rows inside the closing trans
       assert.equal(out.applied_constitution, undefined);
     });
   } finally { config.applyBoardAmendment = origApply; }
+  assert.equal(boardWrites, 0, 'the board block was not rewritten');
   assert.deepEqual(log, ['committed']);
   assert.equal(String(written.itemId), '21');
   assert.deepEqual(written.rules.map((r) => [r.area, r.decided_by, r.rule]), [['people', 'rank:council', 'consent']]);