seriesoftubes/tests/lib/mp-sim-fake-engine.js
jvanvik d1e127da67 Server-run play, part 1: game prerequisites and shared contracts
Groundwork for running multiplayer games on the session server; nothing
of it is switched on yet, and the plain build is unchanged.

- A new network in two halves (beginState/beginShow), the coach split into
  tutAdvance/coachDom, toastPop split out of toast, bootNotes() for the
  once-per-load toasts, the five text actions take their text as an
  argument, and srvOn() with its two checks in the loop.
- Live state is what a reload makes of it (migrate() is a no-op on it):
  new POPs, ports, PNIs, customers, attacks, dark fiber and the intern's
  notes are written in their saved shape; a 365-day test proves it.
- pniAll and bstdApply check the quote the sheet showed (bstdApply by its
  plan, within 1% for the daily hardware drift; utilityKit too).
- assemble({mp}) leaves src/game/98-server-play/ and its CSS out of every
  page but a multiplayer build's, which also gets a SIM_ID build id.
- Contracts for the server, protocol and browser parts: the action tables
  and envelope check (scripts/lib/mp-sim-acts.js), event fixtures, a shape
  checker, a fake engine, and load({mp:true}) in the test harness.
- route-fuzz judges both pages with one migrate(), so reload repairs of
  the base no longer count as divergences.
2026-11-07 10:26:06 +01:00

187 lines
12 KiB
JavaScript

// A stand-in for the server-run engine (scripts/lib/mp-sim-engine.js, track T2), for testing the session host without
// worker threads or a game: the same API, every method a promise of the worker reply that section 4.2 of the
// server-sim design names, made from the canned stream in tests/fixtures/mp-sim/. Each reply passes
// tests/lib/mp-sim-shape.js checkWorker(); an upd or snap inside one passes checkEvent().
//
// const engine = createFakeEngine();
// engine.load(code, nets:[{nid, env?, begin?, lang, prefs}]) → [{t:'loaded', nid, epoch, day, lost, saved?}], one per
// net; a network that did not load is {t:'loaded', nid, err} (broken, 4.7)
// engine.day(code, {d, speed, last, alone:[nid], nets:[nid], mute}) → {t:'dayDone', code, d, nets:{[nid]:{day, lost,
// pause?, err?, retried?, ms}}}
// engine.act(code, nid, msg) → {t:'actDone', nid, epoch, rid, outcome, why?, v, upd} (msg: the request body, 5.8)
// engine.ask(code, nid, msg) → {t:'askDone', nid, rid, modal:{h, c}, ui?}
// engine.pull(code, nid, {snap, views}) → {t:'pulled', nid, epoch, v, upd?, snap?, subs?} (views: [{link} | {peer}])
// engine.sub(code, nid, {views}) → {t:'subbed', nid, epoch, v, subs}
// engine.prefs(code, nid, {prefs}) → undefined; engine.greet(code, nid) → a pulled
// engine.save(code, nid) → {t:'saved', nid, txt, uidN, rt, day, lost}; engine.card(code, nid) → {t:'card', nid, card}
// engine.unload(code, nid?) → {t:'unloaded', code, nid?}; engine.stats() → {workers, realms, sessions} (not a promise)
//
// For the tests of the host: engine.calls (every call, [method, ...args]); engine.outcome = (msg) => outcome to answer
// acts with ('applied' unless set); engine.lose(code, nid) / engine.pause(code, nid) (the next day ends bankrupt / asks
// for a pause); engine.hold(method) keeps that method's answers back until engine.release(method); engine.exit() is a worker
// that died: every pending call rejects and every realm is gone.
// Failures, in the shapes the real engine answers them (4.2, 4.3, 4.7): engine.failNext(method, what, nid?) with what
// 'timeout' or 'throw' (or 'exit': the call rejects, as when the worker died):
// load → that network (every network of the call without nid) answers {t:'loaded', nid, err} and has no realm;
// day → the day failed twice: nets[nid] = {day (unchanged), lost, err, retried:true, ms} and the network is broken
// (left out of later days; acts answer 'stopped'); without nid, the first network of the day;
// other → {t:'err', code, nid, what, msg}.
// A timeout leaves a fresh realm behind (4.2): a new epoch, v from 0. engine.breakNext(code, nid): the next load of that
// network fails (a save that does not migrate). engine.flaky(code, nid): its next day fails once and passes on the retry
// (retried:true, no err).
'use strict';
const { fixture } = require('./mp-sim-shape');
function createFakeEngine(opts = {}) {
const F = { snap: fixture('snap'), day: fixture('upd-day'), act: fixture('upd-act'), sub: fixture('sub'), roster: fixture('roster') };
const realms = new Map(), held = new Map(), fails = new Map(), pending = new Set(), breaks = new Set(), flaky = new Set();
const key = (code, nid) => code + '/' + nid;
let epochN = 0;
const newEpoch = () => 'e' + (++epochN).toString(36);
const realm = (code, nid) => { const r = realms.get(key(code, nid)); if (!r) throw new Error(`no realm ${key(code, nid)}`); return r; };
// A realm the worker had to build again after a timeout: a new epoch, versions from 0.
const rebuilt = (r) => { if (r) { r.epoch = newEpoch(); r.v = 0; r.dirty = false; } };
// Every answer goes through here: held back, failed, or rejected when the worker exits meanwhile. failed(f): the reply
// for an injected failure, when the method has its own shape for one (load, day); else {t:'err'}.
function answer(method, make, code = 'K7Q2XD', nid = 'abcd1234', failed = null) {
return new Promise((ok, no) => {
const job = { ok, no };
const run = () => {
pending.delete(job);
const f = fails.get(method);
if (f) {
fails.delete(method);
if (f.what === 'exit') return no(Object.assign(new Error('worker exited'), { code: 'EXIT' }));
if (failed) { try { return ok(failed(f)); } catch (e) { return no(e); } }
if (f.what === 'timeout') rebuilt(realms.get(key(code, f.nid || nid)));
return ok({ t: 'err', code, nid: f.nid || nid, what: f.what, msg: `injected ${f.what}` });
}
try { ok(make()); } catch (e) { no(e); }
};
job.run = run;
pending.add(job);
const h = held.get(method);
if (h) h.push(job); else if (opts.sync) run(); else setImmediate(run);
});
}
const upd = (r, base, extra = {}) => {
const from = r.v, v = ++r.v;
const s = { ...base.s, day: r.day };
return JSON.stringify({ ...base, from, v, now: Date.now(), day: r.day, s, ...extra });
};
const snapOf = (code, nid, r) => {
const S = { ...F.snap.S, day: r.day, lost: r.lost, mp: { ...F.snap.S.mp, code, pid: nid } };
return JSON.stringify({ ...F.snap, epoch: r.epoch, v: r.v, now: Date.now(), S, keep: r.keep.splice(0) });
};
const subsOf = (views = []) => {
const o = {};
for (const w of views) {
if (w && typeof w.link === 'string') o['link:' + w.link] = { ef: F.sub.ef, egd: F.sub.egd };
if (w && typeof w.peer === 'string') o['peer:' + w.peer] = { pf: { [w.peer]: Object.values(F.sub.pf)[0] || {} } };
}
return o;
};
const savedOf = (code, nid, r) => ({ t: 'saved', nid, txt: JSON.stringify({ ...F.snap.S, day: r.day, lost: r.lost, mp: { ...F.snap.S.mp, code, pid: nid } }), uidN: 100 + r.day, rt: { load: {}, l2route: {}, efg: {} }, day: r.day, lost: r.lost });
const engine = {
calls: [],
outcome: () => 'applied',
load(code, nets) {
engine.calls.push(['load', code, nets]);
const one = (n, err) => {
if (err) { realms.delete(key(code, n.nid)); return { t: 'loaded', nid: n.nid, err }; }
const day = n.begin ? 0 : (n.env && Number.isInteger(n.env.day) ? n.env.day : F.snap.S.day);
const r = { epoch: newEpoch(), v: 0, day, lost: false, broken: false, dirty: false, pause: false, loseNext: false, keep: [], lang: n.lang || 'en' };
realms.set(key(code, n.nid), r);
return { t: 'loaded', nid: n.nid, epoch: r.epoch, day, lost: false, ...(n.begin ? { saved: savedOf(code, n.nid, r) } : {}) };
};
const bad = (n) => { const k = key(code, n.nid); if (!breaks.has(k)) return null; breaks.delete(k); return 'migrate threw: injected'; };
return answer('load', () => nets.map((n) => one(n, bad(n))), code, nets[0] && nets[0].nid,
(f) => nets.map((n) => one(n, f.nid === undefined || f.nid === n.nid ? `injected ${f.what}` : bad(n))));
},
day(code, { d, nets = [] } = {}) {
engine.calls.push(['day', code, { d, nets }]);
const ids = [...nets].sort();
const run = (f) => {
const out = {};
for (const nid of ids) {
const r = realm(code, nid);
if (r.lost || r.broken) continue;
// Failed twice (f names it): back to the mark, broken at its pre-day state.
if (f && (f.nid || ids.find((x) => !realm(code, x).lost && !realm(code, x).broken)) === nid) {
r.broken = true; if (f.what === 'timeout') rebuilt(r);
out[nid] = { day: r.day, lost: r.lost, err: `injected ${f.what}`, retried: true, ms: 2000 };
continue;
}
const again = flaky.delete(key(code, nid));
r.day++; r.dirty = true;
if (r.loseNext) { r.lost = true; r.loseNext = false; r.keep.push(['modal', 'lose']); }
out[nid] = { day: r.day, lost: r.lost, ms: 1, ...(r.pause ? { pause: true } : {}), ...(again ? { retried: true } : {}) };
r.pause = false;
}
return { t: 'dayDone', code, d, nets: out };
};
return answer('day', () => run(null), code, ids[0], run);
},
act(code, nid, msg) {
engine.calls.push(['act', code, nid, msg]);
return answer('act', () => {
const r = realm(code, nid);
if (r.lost || r.broken) return { t: 'actDone', nid, epoch: r.epoch, rid: msg.rid, outcome: 'stopped', v: r.v, upd: null };
const outcome = engine.outcome(msg);
r.dirty = false;
const u = upd(r, F.act, { acts: [{ rid: msg.rid, dev: msg.dev, ui: {} }] });
return { t: 'actDone', nid, epoch: r.epoch, rid: msg.rid, outcome, ...(outcome === 'error' ? { why: 'the game threw' } : {}), v: r.v, upd: u };
}, code, nid);
},
ask(code, nid, msg) {
engine.calls.push(['ask', code, nid, msg]);
return answer('ask', () => { realm(code, nid); return { t: 'askDone', nid, rid: msg.rid, modal: { h: `<h2>${msg.act}</h2><p>What if…</p>`, c: '' } }; }, code, nid);
},
pull(code, nid, { snap = false, views } = {}) {
engine.calls.push(['pull', code, nid, { snap, views }]);
return answer('pull', () => {
const r = realm(code, nid), o = { t: 'pulled', nid, epoch: r.epoch };
if (r.dirty) { o.upd = upd(r, F.day); r.dirty = false; }
o.v = r.v;
if (snap) o.snap = snapOf(code, nid, r);
if (views) o.subs = subsOf(views);
return o;
}, code, nid);
},
sub(code, nid, { views = [] } = {}) {
engine.calls.push(['sub', code, nid, { views }]);
return answer('sub', () => { const r = realm(code, nid); return { t: 'subbed', nid, epoch: r.epoch, v: r.v, subs: subsOf(views) }; }, code, nid);
},
prefs(code, nid, { prefs } = {}) { engine.calls.push(['prefs', code, nid, { prefs }]); return answer('prefs', () => { realm(code, nid); return undefined; }, code, nid); },
greet(code, nid) {
engine.calls.push(['greet', code, nid]);
return answer('greet', () => { const r = realm(code, nid); r.dirty = true; const o = { t: 'pulled', nid, epoch: r.epoch, upd: upd(r, F.day, { fx: [['told', 'grace']] }) }; r.dirty = false; o.v = r.v; return o; }, code, nid);
},
save(code, nid) { engine.calls.push(['save', code, nid]); return answer('save', () => savedOf(code, nid, realm(code, nid)), code, nid); },
card(code, nid) { engine.calls.push(['card', code, nid]); return answer('card', () => { realm(code, nid); return { t: 'card', nid, card: F.roster.players[0].card }; }, code, nid); },
unload(code, nid) {
engine.calls.push(['unload', code, nid]);
return answer('unload', () => { for (const k of [...realms.keys()]) if (k.startsWith(code + '/') && (nid === undefined || k === key(code, nid))) realms.delete(k); return { t: 'unloaded', code, ...(nid ? { nid } : {}) }; }, code, nid);
},
stats() { return { workers: 1, realms: realms.size, sessions: new Set([...realms.keys()].map((k) => k.split('/')[0])).size }; },
// Test controls.
lose(code, nid) { realm(code, nid).loseNext = true; },
pause(code, nid) { realm(code, nid).pause = true; },
keep(code, nid, fx) { realm(code, nid).keep.push(fx); },
hold(method) { if (!held.has(method)) held.set(method, []); },
release(method) { const h = held.get(method) || []; held.delete(method); for (const j of h) j.run(); },
failNext(method, what = 'throw', nid) { fails.set(method, { what, nid }); },
breakNext(code, nid) { breaks.add(key(code, nid)); },
flaky(code, nid) { flaky.add(key(code, nid)); },
exit() {
const e = Object.assign(new Error('worker exited'), { code: 'EXIT' });
for (const j of [...pending]) { pending.delete(j); j.no(e); }
held.clear(); realms.clear();
},
realms,
};
return engine;
}
module.exports = { createFakeEngine };