// 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}]); // snap is the realm's half (t, epoch, v, now, S, r, keep): engine.snapWith(snap, {clock, // roster, since}) makes the stream event // 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); // engine.close() → stops it (every pending call rejects) // // 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'); const { snapWith } = require('../../scripts/lib/mp-sim-engine'); 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 }); }; // The realm's half of a snapshot: the host adds clock, roster and since with snapWith(). 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({ t: 'snap', epoch: r.epoch, v: r.v, now: Date.now(), S, r: F.snap.r, 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: `
What if…
`, 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 }; }, close() { engine.exit(); return Promise.resolve(); }, snapWith, // 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 };