@bongos/core 1.20.74 → 1.20.76

package/tests/wizard_physics.mjs

@@ -0,0 +1,264 @@
+// tests/wizard_physics.mjs — planet physics, questions 1 to 4, in the create wizard
+// (task 1004418 / BV2.PS07, goal 1000121).
+//
+// Done-when: the four questions and their branches work end to end (state incl. the
+// existing-project branch and the stop screen; geography; ages with the guardian
+// tiers; entity, intent when new and legal type when it exists), the planet states
+// match the canvas, answers save through the create's `detail`, and the options the
+// soft-limit table hides or greys show their reason (spec D6).
+//
+// Three layers, all RUN: the server's pre-create check over a mounted router; the
+// page's vocabularies against planet-physics.js (a page cannot require a module, so
+// its copies are held equal here); and the page's own physics controller sliced out
+// of projects.html and driven in a vm under a DOM stub. The kit walk
+// (projects.probes.json) is the rendered half.
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const LANDING = path.join(ROOT, 'modules', 'public-landing', 'public');
+const HUB = fs.readFileSync(path.join(LANDING, 'projects.html'), 'utf8').replace(/\r\n/g, '\n');
+const physics = require('../modules/provisioning/planet-physics.js');
+const { STOP_MESSAGE } = require('../modules/provisioning/screening.js');
+
+// ── the server: POST /provisioning/physics-check ─────────────────────────────
+const api = require('../src/module-api.js');
+const provisioning = require('../modules/provisioning/provisioning.js');
+let writes = 0;
+provisioning.createInstance = async () => { writes += 1; return {}; };
+let builderId = 7;
+api.requireBuilder = (req, _res, next) => { req.builder = { id: builderId, github_login: 'owner' }; next(); };
+const express = require('express');
+const app = express();
+app.use(express.json());
+app.use((_req, res, next) => {
+  res.fail = (code, opts, details) => {
+    const status = typeof opts === 'number' ? opts : (opts && opts.status) || 400;
+    res.status(status).json({ error: { code, ...(details || (typeof opts === 'object' ? opts : {})) } });
+  };
+  next();
+});
+app.use('/api/bongos', require('../modules/provisioning/routes/provisioning.js')());
+const server = app.listen(0);
+after(() => server.close());
+const check = async (body) => {
+  await new Promise((r) => (server.listening ? r() : server.once('listening', r)));
+  const res = await fetch(`http://127.0.0.1:${server.address().port}/api/bongos/provisioning/physics-check`, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+  });
+  return { status: res.status, body: await res.json() };
+};
+
+test('the check answers the soft-limit table for the answers so far, and creates nothing', async () => {
+  const r = await check({ description: 'A co-op farming game.', detail: { project_state: 'new' } });
+  assert.equal(r.status, 200);
+  assert.equal(r.body.stop, false);
+  assert.equal(r.body.soft_limits.enforced, false, 'advice, and says so');
+  const hidden = r.body.soft_limits.limits.filter((l) => l.effect === 'hide').map((l) => l.option).sort();
+  assert.deepEqual(hidden, ['existing_work', 'main_work'], 'a new planet has nothing built to describe');
+  assert.equal(writes, 0);
+});
+
+test('a description the screen stops answers the stop screen in the create\'s own words', async () => {
+  const r = await check({ description: 'We will build ransomware for sale.', detail: {} });
+  assert.equal(r.status, 200);
+  assert.equal(r.body.stop, true);
+  assert.equal(r.body.message, STOP_MESSAGE);
+  assert.equal(writes, 0, 'nothing exists to undo');
+});
+
+test('an answer off the vocabulary, or a field the check does not read, is refused', async () => {
+  assert.equal((await check({ detail: { project_state: 'ancient' } })).status, 400);
+  assert.equal((await check({ detail: { home_country: 'US', home_region: 'CA-ON' } })).status, 400, 'a region outside its country');
+  assert.equal((await check({ slug: 'sneaky' })).status, 400, 'the body is validated strictly');
+});
+
+test('a builder who loops the check is slowed down, and another builder is not', async () => {
+  builderId = 901;
+  try {
+    for (let i = 0; i < 60; i += 1) assert.equal((await check({ detail: {} })).status, 200, `call ${i + 1} is within the minute`);
+    const over = await check({ detail: {} });
+    assert.equal(over.status, 429);
+    assert.equal(over.body.error, 'rate_limited');
+    builderId = 902;
+    assert.equal((await check({ detail: {} })).status, 200, 'the bucket is per builder');
+  } finally { builderId = 7; }
+});
+
+// ── the page's vocabularies are the server's ─────────────────────────────────
+const SCRIPT = HUB.slice(HUB.indexOf('/* ── planet physics, questions 1 to 4 (task 1004418, BV2.PS07) ──'),
+  HUB.indexOf('    /* per-panel validation on Next */'));
+
+test('the page carries the server\'s countries, regions and entity forms, exactly', () => {
+  assert.ok(SCRIPT.length > 1000, 'the physics controller was found');
+  const box = {};
+  vm.createContext(box);
+  vm.runInContext(SCRIPT.slice(0, SCRIPT.indexOf('    var PHYS_LAST')).replace(/\bvar /g, 'this.'), box);
+  const plain = (v) => JSON.parse(JSON.stringify(v)); // values born in the vm
+  assert.deepEqual(plain(box.PHYS_COUNTRIES), [...physics.COUNTRY_CODES]);
+  assert.deepEqual(Object.keys(box.PHYS_REGIONS).sort(), [...physics.REGION_CODES].sort());
+  assert.deepEqual(plain(box.PHYS_ENTITY_FORMS), [...physics.ENTITY_FORMS]);
+  for (const k of Object.keys(box.PHYS_MATERIAL)) {
+    assert.notEqual(physics.canonicalAnswer(physics.PLANET_PHYSICS_QUESTIONS.entity, k), undefined, `${k} is an entity answer`);
+  }
+});
+
+test('every choice the questions offer is an answer the server accepts', () => {
+  const panel = HUB.slice(HUB.indexOf('id="panel-physics"'), HUB.indexOf('<!-- step 4 · name'));
+  const seen = [...panel.matchAll(/data-phys="([a-z_]+)" data-val="([^"]+)"/g)];
+  assert.ok(seen.length >= 20, 'the four questions\' choices');
+  for (const [, key, raw] of seen) {
+    const value = raw === 'true' ? true : raw === 'false' ? false : raw;
+    assert.notEqual(physics.canonicalAnswer(physics.PLANET_PHYSICS_QUESTIONS[key], value), undefined, `${key}=${raw}`);
+  }
+  for (const [, work] of panel.matchAll(/data-work="([^"]+)"/g)) {
+    assert.ok(physics.PLANET_PHYSICS_QUESTIONS.existing_work, 'existing_work is a question');
+    assert.notEqual(physics.canonicalAnswer(physics.PLANET_PHYSICS_QUESTIONS.existing_work, [work]), undefined, work);
+  }
+});
+
+test('the age tiers are described, never claimed as enforced (spec D6)', () => {
+  const ages = HUB.slice(HUB.indexOf('id="physAges"'), HUB.indexOf('<div class="physQ" data-q="4"'));
+  assert.match(ages, /13 to 15<\/dt><dd>Non-monetary tracks only/);
+  assert.match(ages, /the platform does not check ages for you yet/);
+  assert.doesNotMatch(ages, /apply automatically|enforced/i);
+});
+
+// ── the controller, RUN ──────────────────────────────────────────────────────
+class El {
+  constructor(id) {
+    this.id = id; this.hidden = false; this.disabled = false; this.value = ''; this.textContent = ''; this.className = '';
+    this.attrs = {}; this.listeners = {}; this.options = [{}]; this.children = [];
+    const self = this;
+    this.classList = { toggle(c, on) { self.attrs['class:' + c] = !!on; } };
+  }
+  setAttribute(k, v) { this.attrs[k] = String(v); }
+  getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; }
+  removeAttribute(k) { delete this.attrs[k]; }
+  addEventListener(t, fn) { this.listeners[t] = fn; }
+  appendChild(c) { this.options.push(c); return c; }
+  removeChild() { this.options.pop(); }
+  get lastChild() { return this.options[this.options.length - 1]; }
+  focus() {}
+}
+
+function boot({ checkAnswer = { stop: false, soft_limits: { limits: [] } } } = {}) {
+  const els = {};
+  const $ = (id) => (els[id] = els[id] || new El(id));
+  const shown = [];
+  const fetched = [];
+  const state = { description: '', teamShape: null, physics: null };
+  const sandbox = {
+    $, state, API: '/api/bongos', document: { createElement: () => new El('opt') },
+    root: { querySelectorAll: () => [], querySelector: () => null },
+    saveDraft() {}, show(n) { shown.push(n); }, Intl,
+    fetch: async (url, opts) => { fetched.push({ url, body: opts && opts.body && JSON.parse(opts.body) }); return { ok: true, json: async () => (url.includes('physics-check') ? checkAnswer : []) }; },
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(SCRIPT, sandbox, { filename: 'projects.html#physics' });
+  return { sandbox, state, $, shown, fetched, run: (code) => vm.runInContext(code, sandbox) };
+}
+const tick = () => new Promise((r) => setTimeout(r, 0));
+
+test('Continue walks the questions and moves the wizard on only after the last', async () => {
+  const w = boot();
+  const a = () => w.state.physics.answers;
+  assert.equal(w.run('physAdvance()'), false, 'the step never says yes itself');
+  assert.equal(w.state.physics.q, 1, 'from the start screen to question 1');
+  w.run('physAdvance()');
+  assert.equal(w.state.physics.q, 1, 'question 1 unanswered: it stays');
+  assert.match(w.$('h-phys').textContent, /new or existing/);
+  a().project_state = 'existing';
+  w.run('physAdvance()');
+  assert.match(w.$('h-phys').textContent, /what already exists/i, 'an existing planet must say what exists');
+  a().existing_work = ['code', 'digital-files']; a().main_work = 'code';
+  w.state.description = 'A co-op farming game.';
+  w.run('physAdvance()');
+  await tick(); await tick();
+  assert.equal(w.state.physics.q, 2, 'the screen passed it, on to geography');
+  assert.deepEqual(w.fetched.at(-1).body, { description: 'A co-op farming game.', detail: { project_state: 'existing', existing_work: ['code', 'digital-files'], main_work: 'code' } });
+  w.run('physAdvance()');
+  assert.equal(w.state.physics.q, 2, 'no country: it stays');
+  a().home_country = 'US'; a().home_region = 'US-CA'; a().builder_geography = 'us-eu';
+  w.run('physAdvance()');
+  assert.equal(w.state.physics.q, 3);
+  a().minors_on_board = true;
+  w.run('physAdvance()');
+  assert.equal(w.state.physics.q, 4);
+  w.run('physAdvance()');
+  assert.deepEqual(w.shown, [], 'no entity: still here');
+  a().entity = 'for-profit';
+  w.run('physAdvance()');
+  assert.deepEqual(w.shown, [4], 'and only now on to the name step');
+});
+
+test('a stopped description lands on the stop screen with the server\'s words', async () => {
+  const w = boot({ checkAnswer: { stop: true, message: STOP_MESSAGE, soft_limits: { limits: [] } } });
+  w.run('physAdvance()');
+  w.state.physics.answers.project_state = 'new';
+  w.state.description = 'ransomware';
+  w.run('physAdvance()');
+  await tick(); await tick();
+  assert.equal(w.state.physics.q, 'stop');
+  assert.equal(w.$('physStopMsg').textContent, STOP_MESSAGE);
+});
+
+test('the create sends the answers as detail: existing work only for an existing planet, the team shape beside them', () => {
+  const w = boot();
+  w.run('phys()');
+  Object.assign(w.state.physics.answers, { project_state: 'new', existing_work: ['code'], main_work: 'code', home_country: 'NL', builder_geography: 'global', minors_on_board: false, entity: 'intent-solo' });
+  w.state.teamShape = 'solo';
+  assert.deepEqual(JSON.parse(JSON.stringify(w.run('createDetail()'))), {
+    project_state: 'new', home_country: 'NL', builder_geography: 'global', minors_on_board: false, entity: 'intent-solo', team_shape: 'solo',
+  });
+  w.state.physics.answers = {}; w.state.teamShape = null;
+  assert.equal(w.run('createDetail()'), undefined, 'nothing answered: the detail is omitted, as before');
+});
+
+test('the planet forms from the answers: a seed, a formed planet, the protective ring, the core material', () => {
+  const w = boot();
+  w.run('phys()');
+  const src = () => w.$('physPlanet').getAttribute('src');
+  w.state.physics.q = 1; w.state.physics.answers.project_state = 'new';
+  w.run('physPaintStage()');
+  assert.equal(src(), '/assets/world/r2-chrome-blob-one-cut.webp', 'a seed');
+  w.state.physics.answers.project_state = 'existing';
+  w.run('physPaintStage()');
+  assert.equal(src(), '/assets/world/r2-chrome-blobs-set-cut.webp', 'terrain already formed');
+  assert.equal(w.$('physGuard').hidden, true);
+  w.state.physics.q = 3; w.state.physics.answers.minors_on_board = true;
+  w.run('physPaintStage()');
+  assert.equal(w.$('physGuard').hidden, false, 'the protective ring');
+  w.state.physics.q = 4;
+  for (const [entity, plate] of [['intent-solo', 'r3-frost-blob-cut'], ['for-profit', 'r3-gold-blob-cut'], ['nonprofit', 'r3-obsidian-blob-cut']]) {
+    w.state.physics.answers.entity = entity;
+    w.run('physPaintStage()');
+    assert.equal(src(), `/assets/world/${plate}.webp`, entity);
+  }
+  for (const plate of ['r3-frost-blob-cut', 'r3-gold-blob-cut', 'r3-obsidian-blob-cut', 'r2-chrome-blob-one-cut', 'r2-chrome-blobs-set-cut']) {
+    assert.ok(fs.existsSync(path.join(LANDING, 'assets', 'world', `${plate}.webp`)), `${plate} is a world plate`);
+  }
+});
+
+test('a limit the table puts on an option shows its reason beside it, and a grey one is disabled', () => {
+  const w = boot();
+  const why = new El('why');
+  const btn = new El('btn');
+  w.sandbox.root.querySelector = (sel) => (sel.includes('data-why="existing_work"') ? why : null);
+  w.sandbox.root.querySelectorAll = (sel) => (sel.includes('data-phys="entity"][data-val="intent-solo"') ? [btn] : []);
+  w.run(`physLimits = [
+    { option: 'existing_work', effect: 'hide', reason: 'Your planet is new, so there is nothing built yet to describe.' },
+    { option: 'entity:intent-solo', effect: 'grey', reason: 'Because.' }
+  ]; physApplyLimits();`);
+  assert.equal(why.hidden, false);
+  assert.match(why.textContent, /nothing built yet/);
+  assert.equal(btn.disabled, true);
+  assert.equal(btn.title, 'Because.');
+});