@bongos/core 1.25.5 → 1.25.6

package/tests/test_project.mjs

@@ -0,0 +1,122 @@
+// tests/test_project.mjs — A TEST PROJECT: one made to try features that are not live yet
+// (task 1005036, idea 1001299; owner, 2026-11-01).
+//
+// Done-when: only an archon can ask for one; it is stamped once on the row just made; it is
+// kept off the public map; it reaches the instance as project.test; and the not-yet-live
+// genesis switch opens on a test project and nowhere else. The free-place count is pinned in
+// tests/provisioning_paid_shape_gate.mjs and the create route in tests/wizard_demo.mjs.
+//
+// Run:  node --test tests/test_project.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import { execFileSync } from 'node:child_process';
+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 tp = require('../modules/provisioning/test-project.js');
+const provisioning = require('../modules/provisioning/provisioning.js');
+const bridge = require('../modules/provisioning/catalog-bridge.js');
+const gh = require('../modules/onboarding/genesis-home.js');
+const fm = require('../modules/onboarding/founding-mode.js');
+
+const ARCHON = { id: 1, rank: 'archon' };
+const METIC = { id: 2, rank: 'metic' };
+const ROW = (settings) => ({ id: 41, slug: 'sandbox', domain: 'sandbox.example.test', status: 'active', hosting_shape: 'cloud-host', settings });
+
+test('only an archon can ask for a test project, and genesis means nothing without one', () => {
+  assert.deepEqual(tp.parseTestAsk({ test: true }, ARCHON), { ok: true, test: true, genesis: false });
+  assert.deepEqual(tp.parseTestAsk({ test: true, genesis: true }, ARCHON), { ok: true, test: true, genesis: true });
+  assert.deepEqual(tp.parseTestAsk({}, METIC), { ok: true, test: false, genesis: false }, 'a request that asks for nothing is fine for anyone');
+  const refused = tp.parseTestAsk({ test: true }, METIC);
+  assert.equal(refused.ok, false);
+  assert.equal(refused.status, 403);
+  assert.equal(refused.code, 'test_project_forbidden');
+  assert.equal(tp.parseTestAsk({ test: true }, undefined).ok, false, 'no builder, no test project');
+  assert.equal(tp.parseTestAsk({ test: 'yes' }, METIC).ok, true, 'only a real boolean true asks');
+  const alone = tp.parseTestAsk({ genesis: true }, ARCHON);
+  assert.equal(alone.ok, false);
+  assert.equal(alone.code, 'genesis_needs_test');
+  assert.equal(alone.status, 400);
+});
+
+test('the mark: stamped on the row it is given, once; read only when it says on', async () => {
+  const seen = [];
+  await tp.stampTestProject({ query: async (sql, params) => { seen.push({ sql, params }); return { rows: [] }; } }, 41);
+  assert.equal(seen.length, 1);
+  assert.match(seen[0].sql, /WHERE id = \$1 AND NOT \(COALESCE\(settings, '\{\}'::jsonb\) \? \$2::text\)/, 'write-once');
+  assert.deepEqual(seen[0].params, [41, 'test_project']);
+  assert.equal(tp.isTestProject(ROW({ test_project: 'on' })), true);
+  for (const bad of [undefined, null, {}, { test_project: 'yes' }, { test_project: true }, 'on']) {
+    assert.equal(tp.isTestProject(ROW(bad)), false, JSON.stringify(bad));
+  }
+  assert.equal(tp.isTestProject(null), false);
+});
+
+test('the owner view says it, and it reaches web.env as TEST_PROJECT, empty on every other project', () => {
+  assert.equal(provisioning.publicInstance(ROW({ test_project: 'on' })).is_test, true);
+  assert.equal(provisioning.publicInstance(ROW({})).is_test, false);
+  assert.equal(provisioning.settingsEnvVars(ROW({ test_project: 'on' }), 'X').X_TEST_PROJECT, 'on');
+  assert.equal(provisioning.settingsEnvVars(ROW({}), 'X').X_TEST_PROJECT, '', 'a line that came and went would leave a stale one behind');
+  assert.equal(provisioning.settingsEnvVars(ROW({ test_project: 'maybe' }), 'X').X_TEST_PROJECT, '');
+});
+
+test('a test project is never on the public map; the same row without the mark is', () => {
+  assert.equal(bridge.catalogEntryForInstance(ROW({ test_project: 'on' }), { ownerGithubId: 99 }), null);
+  const plain = bridge.catalogEntryForInstance(ROW({}), { ownerGithubId: 99 });
+  assert.ok(plain && plain.clientId === 'sandbox', 'an ordinary project still projects');
+});
+
+test('the instance reads TEST_PROJECT into project.test, and publishes it as a boolean beside project, not in it', () => {
+  const read = (env) => JSON.parse(execFileSync(process.execPath, ['-e',
+    "const b=require('./src/branding.js');const r=(b.branding||b)();console.log(JSON.stringify({p:r.project&&r.project.test,c:b.clientBranding(r).testProject}))"],
+    { cwd: ROOT, encoding: 'utf8', env: { ...process.env, ...env } }));
+  assert.deepEqual(read({}), { c: false }, 'no env, not a test project');
+  assert.deepEqual(read({ CLOUDBONGOS_TEST_PROJECT: 'on' }), { p: 'on', c: true });
+  assert.deepEqual(read({ CLOUDBONGOS_TEST_PROJECT: '' }), { c: false }, 'the empty line every other project carries');
+});
+
+// ── the genesis switch, on the instance ────────────────────────────────────────
+
+function world({ test = true, settings = {} } = {}) {
+  const store = new Map(Object.entries(settings));
+  const deps = {
+    branding: { project: { test: test ? 'on' : '' } },
+    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: 0 }), genesisTasks: async () => ({}) },
+    government: null,
+    now: new Date('2026-11-02T09:00:00Z'),
+  };
+  return { store, deps };
+}
+
+test('genesis cannot be switched on from a project that is not a test project', async () => {
+  const w = world({ test: false });
+  assert.deepEqual(await gh.setEnabled(true, 1, w.deps), { ok: false, reason: 'not_a_test_project' });
+  assert.deepEqual(await gh.ownerStart(1, w.deps), { ok: false, reason: 'not_a_test_project' });
+  assert.equal(w.store.size, 0, 'nothing is written');
+});
+
+test('on a test project the switch starts genesis, pauses it, and brings it back', async () => {
+  const w = world();
+  const on = await gh.setEnabled(true, 1, w.deps);
+  assert.equal(on.ok, true);
+  assert.equal(on.mode.active, true);
+  assert.equal(w.store.get(fm.KEYS.ENABLED), 'true');
+  const off = await gh.setEnabled(false, 1, w.deps);
+  assert.equal(off.ok, true);
+  assert.equal(off.mode, null, 'paused: the hall opens full');
+  assert.equal(w.store.get(fm.KEYS.ACTIVE), 'true', 'the founding record is kept');
+  const again = await gh.setEnabled(true, 1, w.deps);
+  assert.equal(again.mode.active, true, 'it comes back where it was');
+  assert.equal((await gh.ownerStart(1, world().deps)).ok, true, 'the owner\'s own start works on a test project');
+});
+
+test('a genesis that came alive cannot be switched back on', async () => {
+  const w = world({ settings: { [fm.KEYS.STARTED_AT]: '2026-11-01T00:00:00Z', [fm.KEYS.ENDED_AT]: '2026-11-01T05:00:00Z' } });
+  assert.deepEqual(await gh.setEnabled(true, 1, w.deps), { ok: false, reason: 'already_alive' });
+});

package/tests/wizard_demo.mjs

@@ -117,6 +117,9 @@ provisioning.getInstanceByDomain = async () => null;
 const order = [];
 const birth = require('../modules/provisioning/birth.js');
 birth.stampBirth = async (_db, id) => { order.push(`birth:${id}`); };
+const testProject = require('../modules/provisioning/test-project.js');
+testProject.stampTestProject = async (_db, id) => { order.push(`test:${id}`); };
+let rank = 'metic';   // who is asking: a test project is an archon's alone (task 1005036)
 provisioning.createInstance = async (_db, args) => {
   created = args;
   const fresh = args.slug !== 'old-one';
@@ -126,7 +129,7 @@ provisioning.enqueueIntent = async (_db, _id, action) => { order.push(`enqueue:$
 provisioning.getOpenIntent = async () => null;
 provisioning.recordEvent = async () => {};
 demo.startDemoProject = async (_db, _p, id, d) => { started = { id, d }; order.push(`demo:${id}`); return null; };
-api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner' }; next(); };
+api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner', rank }; next(); };
 let stored = null;
 provisioning.getInstanceById = async (_db, id) => (id === 41 ? { id: 41, owner_builder_id: 7, demo: stored } : null);
 api.pool.query = async (sql, params) => { if (/UPDATE provisioning_instances SET demo/.test(sql)) stored = JSON.parse(params[1]); return { rows: [] }; };
@@ -173,8 +176,26 @@ test('a new project is stamped born, once, before its provision intent; an exist
   assert.equal((await post('/provisioning/instances', { slug: 'born-real', hosting_shape: 'byo-host' })).status, 201);
   assert.deepEqual(order, ['enqueue:provision'], 'a real project opens as the full hall: genesis is off by default (owner, 2026-11-01)');
   order.length = 0;
-  assert.equal((await post('/provisioning/instances', { slug: 'born-test', hosting_shape: 'byo-host', genesis: true })).status, 201);
-  assert.deepEqual(order, ['birth:41', 'enqueue:provision'], 'the genesis toggle still births a test project, with no demo box');
+  // A test project (task 1005036): an archon's alone, marked once on the row, and the only way to be born with genesis.
+  const asked = await post('/provisioning/instances', { slug: 'sneaky', hosting_shape: 'byo-host', test: true });
+  assert.equal(asked.status, 403, 'a non-archon cannot make one');
+  assert.equal(asked.body.error.code, 'test_project_forbidden');
+  assert.deepEqual(order, [], 'and nothing is made, marked or queued');
+  const bare = await post('/provisioning/instances', { slug: 'bare-genesis', hosting_shape: 'byo-host', genesis: true });
+  assert.equal(bare.status, 400, 'genesis alone is no longer a way in');
+  assert.equal(bare.body.error.code, 'genesis_needs_test');
+  assert.deepEqual(order, []);
+  rank = 'archon';
+  try {
+    assert.equal((await post('/provisioning/instances', { slug: 'sandbox-a', hosting_shape: 'byo-host', test: true })).status, 201);
+    assert.deepEqual(order, ['test:41', 'enqueue:provision'], 'a test project is marked, not born into genesis');
+    order.length = 0;
+    assert.equal((await post('/provisioning/instances', { slug: 'sandbox-g', hosting_shape: 'byo-host', test: true, genesis: true })).status, 201);
+    assert.deepEqual(order, ['birth:41', 'test:41', 'enqueue:provision'], 'a test project that asks for genesis is born into it, marked, before the runner can read it');
+    order.length = 0;
+    assert.equal((await post('/provisioning/instances', { slug: 'archon-real', hosting_shape: 'byo-host' })).status, 201);
+    assert.deepEqual(order, ['enqueue:provision'], 'an ordinary project made by an archon is still an ordinary project');
+  } finally { rank = 'metic'; }
   order.length = 0;
   const again = await post('/provisioning/instances', { slug: 'old-one', hosting_shape: 'byo-host' });
   assert.ok(again.status < 300, JSON.stringify(again.body));
@@ -182,7 +203,7 @@ test('a new project is stamped born, once, before its provision intent; an exist
   const keep = birth.stampBirth;
   birth.stampBirth = async () => { throw new Error('db hiccup'); };
   try {
-    assert.equal((await post('/provisioning/instances', { slug: 'unlucky', hosting_shape: 'byo-host', genesis: true })).status, 201,
+    assert.equal((await post('/provisioning/instances', { slug: 'unlucky', hosting_shape: 'byo-host', demo: { people: 2, hours_each: 3 } })).status, 201,
       'a missed marker costs the project its genesis, never its creation');
   } finally { birth.stampBirth = keep; }
 });