@bongos/core 1.20.53 → 1.20.54

package/tests/government_recommendations.mjs

@@ -0,0 +1,119 @@
+// tests/government_recommendations.mjs — recommended governments and base-rank
+// sets by project TYPE and SIZE (task 1004400, criterion wa7-government).
+//
+// The rules held here, each because the live site once broke it:
+//   • a recommendation only ever names a charter that can be ADOPTED — the
+//     ladder used to recommend Presidential (~9) and Federation (150+), and the
+//     live project, at 10 builders, was told to adopt one nobody can;
+//   • the type really changes the answer, not just the wording;
+//   • every grant a recommended rank carries is one a custom rank can hold;
+//   • a Foundation is always recommended together with the council rank it is
+//     governed through, and that rank makes a valid charter proposal.
+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 reco = require(path.join(ROOT, 'modules', 'government', 'recommendations.js'));
+const charter = require(path.join(ROOT, 'modules', 'government', 'charter.js'));
+const catalog = require(path.join(ROOT, 'modules', 'government', 'catalog.js'));
+const provisioning = require(path.join(ROOT, 'modules', 'provisioning', 'provisioning.js'));
+
+const TYPES = reco.PROJECT_TYPES.map((t) => t.key);
+// Every band edge, plus nonsense — the edges are where a ladder goes wrong.
+const HEADCOUNTS = [0, 1, 2, 3, 8, 9, 10, 49, 50, 149, 150, 151, 1000, -4, 'nonsense', null];
+const CUSTOM_RANK = { is_system: false, seeded_rank: null };
+
+// The hall's charter library says which charters are selectable; read it from
+// the client source, since browser code cannot be required.
+function hallSelectableKeys() {
+  const client = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'government.js'), 'utf8');
+  const lib = client.slice(client.indexOf('const CHARTERS'), client.indexOf('const TRAJECTORIES'));
+  return [...lib.matchAll(/key: '([a-z-]+)', name: '[^']+', selectable: true/g)].map((m) => m[1]);
+}
+
+test('the project types are exactly the ones a project declares at creation', () => {
+  assert.deepEqual(TYPES, provisioning.PROJECT_TYPES);
+});
+
+test('every type and size recommends a charter that can be adopted today', () => {
+  const available = charter.FORMS.filter((f) => f.available).map((f) => f.key);
+  const selectable = hallSelectableKeys();
+  assert.ok(selectable.length >= 4, 'the hall library parse found its selectable charters');
+  for (const type of [...TYPES, undefined, 'spaceship']) {
+    for (const n of HEADCOUNTS) {
+      const c = reco.recommendedCharter(n, type);
+      assert.ok(available.includes(c.key), `${type}@${n} recommends "${c.key}", which charter.js cannot adopt`);
+      assert.ok(selectable.includes(c.key), `${type}@${n} recommends "${c.key}", which the hall marks not selectable`);
+      if (c.later) assert.ok(!available.includes(c.later.key), 'a `later` shape is one that cannot be adopted yet');
+    }
+  }
+});
+
+test('the live case: a project of 10 is no longer told to adopt Presidential', () => {
+  const c = reco.recommendedCharter(10, 'not-sure');
+  assert.equal(c.key, 'timocratic-republic');
+  assert.equal(c.later.key, 'presidential', 'what the ladder would name is still said, as coming later');
+});
+
+test('the project type changes the answer, not just the words', () => {
+  assert.equal(reco.recommendedCharter(20, 'game').key, 'timocratic-republic');
+  assert.equal(reco.recommendedCharter(20, 'non-profit').key, 'foundation', 'a non-profit is governed by trustees early');
+  assert.equal(reco.recommendedRankSet('game', 5).ranks[0].rank_key, 'playtester');
+  assert.equal(reco.recommendedRankSet('research', 5).ranks[0].rank_key, 'peer-reviewer');
+  assert.equal(reco.recommendedCharter(20, 'spaceship').type, 'not-sure', 'an unknown type reads as not sure');
+});
+
+test('the rank set grows with size', () => {
+  const sizes = [1, 5, 20, 80, 200].map((n) => reco.recommendedRankSet('business', n).ranks.length);
+  assert.deepEqual(sizes, [0, 1, 2, 3, 3]);
+});
+
+test('every recommended rank is creatable and every grant is one a custom rank can hold', () => {
+  for (const type of TYPES) {
+    for (const n of HEADCOUNTS) {
+      for (const r of reco.recommendedRankSet(type, n).ranks) {
+        assert.match(r.rank_key, /^[a-z][a-z0-9-]*$/, `${r.rank_key} must be a slug the rank API accepts`);
+        assert.ok(r.rank_key.length >= 2 && r.rank_key.length <= 64);
+        assert.ok(!catalog.RANK_ORDER.includes(r.rank_key), `${r.rank_key} must not collide with a standard rank`);
+        assert.ok(r.label && r.description);
+        assert.ok(r.permissions.length > 0);
+        for (const key of r.permissions) {
+          assert.ok(catalog.byKey(key), `${r.rank_key}: ${key} is not in the catalog`);
+          assert.ok(catalog.isGrantableTo(key, CUSTOM_RANK), `${r.rank_key}: ${key} cannot be granted to a custom rank`);
+        }
+      }
+    }
+  }
+});
+
+test('a recommended Foundation always comes with its council rank, and that rank makes a valid charter', () => {
+  const live = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+  let foundations = 0;
+  for (const type of TYPES) {
+    for (const n of HEADCOUNTS) {
+      const c = reco.recommendedCharter(n, type);
+      if (c.key !== 'foundation') { assert.equal(c.council_rank, null); continue; }
+      foundations += 1;
+      const set = reco.recommendedRankSet(type, n).ranks.map((r) => r.rank_key);
+      assert.ok(set.includes(c.council_rank), `${type}@${n}: the rank set must carry ${c.council_rank}`);
+      const built = charter.buildCharterProposal(live, { form: 'foundation', councilRank: c.council_rank });
+      assert.ok(built.ok, `${type}@${n}: ${c.council_rank} must make a valid Foundation (${built.reason})`);
+    }
+  }
+  assert.ok(foundations > 0, 'the walk reached a Foundation');
+});
+
+test('recommendationsFor carries both answers and the vocabulary to ask about another', () => {
+  const r = reco.recommendationsFor({ type: 'research', headcount: 60 });
+  assert.equal(r.type, 'research');
+  assert.equal(r.size, 'organisation');
+  assert.equal(r.charter.key, 'foundation');
+  assert.equal(r.rank_set.ranks.length, 3);
+  assert.equal(r.project_types.length, TYPES.length);
+  for (const b of r.size_bands) assert.equal(reco.sizeBandFor(b.example).key, b.key, 'each size option lands in its own band');
+});

package/tests/government_routes.mjs

@@ -60,6 +60,7 @@ test('the routes file declares the full R110 surface', () => {
     'POST /government/ranks/:rankKey/reset',
     'POST /government/assignments',
     'DELETE /government/assignments/:builderId/:rankKey',
+    'POST /government/rank-sets/apply',
   ];
   for (const key of wanted) assert.ok(declared.has(key), `missing route ${key}`);
 });
@@ -203,6 +204,7 @@ test('without government.manage EVERY route 403s (reads included)', async () =>
     ['DELETE', '/government/ranks/r/permissions/task.create'],
     ['POST', '/government/assignments'],
     ['DELETE', '/government/assignments/7/r'],
+    ['POST', '/government/rank-sets/apply'],
   ]) {
     const r = await call(method, p, method === 'GET' ? undefined : {});
     assert.equal(r.status, 403, `${method} ${p} must deny`);
@@ -243,6 +245,39 @@ test('GET /government/assignments returns builder↔role rows', async () => {
   assert.equal(r.json.assignments[0].rank_key, 'metic');
 });
 
+// --- recommended rank sets (task 1004400) -------------------------------------
+
+test('POST /government/rank-sets/apply creates the missing ranks with their grants and leaves existing ones alone', async () => {
+  const realGet = stub.getRankByKey;
+  // 'design-lead' already exists: it must be skipped, never re-granted.
+  stub.getRankByKey = async (k) => (k === 'design-lead' ? { rank_key: k, label: 'Mine', is_system: false, seeded_rank: null } : null);
+  try {
+    const r = await call('POST', '/government/rank-sets/apply', { type: 'game', headcount: 20 });
+    assert.equal(r.status, 200);
+    assert.deepEqual(r.json.skipped, ['design-lead']);
+    assert.deepEqual(r.json.created.map((c) => c.rank_key), ['playtester']);
+    const creates = calls.filter(([k]) => k === 'createRank');
+    assert.equal(creates.length, 1);
+    assert.equal(creates[0][1].createdBy, 42, 'created_by is the session builder');
+    const grants = calls.filter(([k]) => k === 'grantRankPermission').map(([, a]) => a);
+    assert.ok(grants.length > 0 && grants.every((g) => g.rankKey === 'playtester'), 'an existing rank is never re-granted');
+    assert.ok(grants.every((g) => catalog.isGrantableTo(g.permissionKey, { is_system: false, seeded_rank: null })));
+  } finally { stub.getRankByKey = realGet; }
+});
+
+test('POST /government/rank-sets/apply needs a headcount and does nothing at founding size', async () => {
+  const bad = await call('POST', '/government/rank-sets/apply', { type: 'game' });
+  assert.equal(bad.status, 400);
+  const realGet = stub.getRankByKey;
+  stub.getRankByKey = async () => null;
+  try {
+    const solo = await call('POST', '/government/rank-sets/apply', { type: 'game', headcount: 1 });
+    assert.equal(solo.status, 200);
+    assert.deepEqual(solo.json.created, []);
+    assert.equal(calls.filter(([k]) => k === 'createRank').length, 0);
+  } finally { stub.getRankByKey = realGet; }
+});
+
 // --- create role -------------------------------------------------------------
 
 test('POST /government/ranks creates a custom role, created_by = the session builder', async () => {