The review of track T2 found these; each has a test in tests/mp-sim-*.
- Built-ins: an arg, array entry or draft that is '__proto__', 'constructor'
or 'prototype' is refused by the envelope check and again by the realm
(free text may still say them). After every realm call the trampoline
checks the realm's built-ins against what they were at load; a realm
whose built-ins changed answers {srvErr, polluted} and is replaced from
the worker's mark like one that timed out. S as one JSON per key is a
null-prototype object, so the epilogue's for…in never reads a prototype.
- A realm that cannot be built again is never used again: rebuild() tries
once more without the packed R, and when that fails too the network is
dropped (NO_REALM), and the engine tells the host (opts.onLost).
- A mark that fails or runs out of time changes nothing: it clears the old
mark first, the realm is built again from its own save, never from an
older mark, and the reply names the mark. A day rebuilds only from its
own attempt's mark.
- A day whose alone or nets is not a list is refused whole (ERR); a throw
in a load or day step answers that call, never ends the worker.
- An exit counts against the session the worker was running (the worker
says so before each job and step), else as before. Workers of their own
are capped (opts.maxOwn, 4): past that a session is given up.
- A worker that exits before it is ready is started again after a pause
that doubles; after 5 in a row every call answers SIM_DOWN.
- The game text is read and compiled once, in createEngine: a src/ that
does not compile throws there, and every worker, also one started after
an exit, runs the game engine.simId names.
- A damaged route memory never breaks a save that loads (routed from
nothing, logged), and only a server network loads (S.mp.sim, Normal).
- Routing memory (UI.rk, UI.rkR) is kept by the in-place restore and
carried in rt (rk), so a reloaded or rolled-back network skips the same
routings as the one that kept going.
- A fresh realm takes over the fx of the one it replaces (the mark's after
a failed call, all of them after a read): badges, windows and toasts
waiting for a page are not lost to a timeout.
- Windows: the stand-in elements answer querySelector from what was
written (a [data-x] marker) and have a working classList, never the
inert proxy that said every window is open. A request's ctx may name the
open window, ctx.win = {k, ui} (mp-sim-acts.js WINDOWS: bstd, routing,
charter, ops, pie), with the view state only the page holds (the
intern's POP, the pie window's tab and POP), checked in the realm. This
is an addition to the contract of design 5.8 that the page (T4) sends.
The stand-in is hidden again after an act.
- xpBuild's via is a TEXT arg (256): a six-span express fits.
- actDone, askDone and pulled carry ms, the worker time of the call;
engine.mem() and engine.has(code, nid) are public; prefs() passes a
realm's err through; after close() every call rejects CLOSED.
- The fake engine fails as the engine does (NO_REALM, ERR, a load without
a save, a day of an unknown session or naming an unloaded network,
GAVE_UP, SIM_DOWN, CLOSED, onLost), its greet says its one-shots once and
never 'told'; a test runs the same edge calls on both.
- SIM_DRAFT is built from DRAFT_TYPES.
382 lines
27 KiB
JavaScript
382 lines
27 KiB
JavaScript
// The server's realm plays a network exactly as the page does (the server-sim design, sections 4.1-4.3, 4.7, 11).
|
|
// - Realm vs jsdom: the big network with its L2 customers on scenic routes, 60 days with actions in between, the
|
|
// page's arm clicking as a player does (each click ending in after()) and rendering the HUD after every day: S and R
|
|
// byte for byte the same.
|
|
// - Restore: a checkpoint after any day, loaded into a fresh realm, plays on byte for byte as the network that kept
|
|
// going, the scenic big network and the same one busy (intern, sales desk, failures, events, an attack).
|
|
// - Retry: a day that fails once (a throw, and a timeout, both after the day's DDoS step with an attack on, the networks
|
|
// busy) leaves the same network as no failure.
|
|
// - Order: three networks of a session, in two different realm orders, each the same.
|
|
// - Routing memory: a checkpoint taken between an act and the next day, and an act rolled back, keep what the game
|
|
// remembers of its last routing (UI.rk, UI.rkR): the next click that changes nothing routing reads routes in neither,
|
|
// as in the network that kept going (compute() is not always a fixed point, so a routing there could change R).
|
|
// - Market and moved customers (3.2.0, 3.3.0): the market's settings and a customer moved to another fiber or pinned
|
|
// to a path, then days of sales, against the page and under the strict gate; a checkpoint of it plays on the same.
|
|
// - Timer audit and gate: days with failures, events, the intern on every order and the sales desk on auto, then every
|
|
// sent button a rich crawl finds: no timer is ever scheduled on these paths, nothing changes after them, and no
|
|
// action is rolled back by the sanitize gate (which also runs after every day here, SIM_STRICT).
|
|
// SIM_LONG=1 plays the audit for a year, as section 11 asks, and checkpoints after every day to 30 (a few minutes); by
|
|
// default the audit plays 60 days.
|
|
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const { createEngine } = require('../scripts/lib/mp-sim-engine');
|
|
const { crawl } = require('./lib/mp-sim-crawl');
|
|
const A = require('../scripts/lib/mp-sim-acts');
|
|
const { load } = require('./harness');
|
|
const { CODE, MP, TEST, ROOMY, page, bigScenic, msg, ctxOf, begin, RSIG, checked, differs } = require('./lib/mp-sim-play');
|
|
|
|
const LONG = process.env.SIM_LONG === '1';
|
|
const E = createEngine({ workers: 2, test: TEST, timeouts: ROOMY });
|
|
test.after(() => E.close());
|
|
// The big network with everything that keeps state between days on: the intern on every order, the sales desk (rep)
|
|
// signing on its own, a failure and an event due.
|
|
const busy = (rep) => `S.lvl=Math.max(S.lvl,6);S.rules=makeRules('bgp');ACT.opsHire({id:'kevin'});for(const k in S.ops.on)S.ops.on[k]=true;S.ops.floor=0;closeModal();
|
|
ACT.salesHire({id:'${rep}'});ACT.salesAuto();closeModal();S.nextFail=S.day+2;S.nextEvent=S.day+3;compute();`;
|
|
const on = (X) => ({
|
|
day: (code, d, nets, o = {}) => X.day(code, { d, speed: 1, last: 1, alone: [], nets, ...o }).then(checked),
|
|
realmS: async (code, nid) => (await X.eval(code, nid, 'return JSON.stringify(S)')).value,
|
|
realmR: async (code, nid) => (await X.eval(code, nid, `return ${RSIG}`)).value,
|
|
});
|
|
const { day, realmS, realmR } = on(E);
|
|
const loadBig = async (code, nid) => checked((await E.load(code, [{ nid, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'en', prefs: {} }]))[0]);
|
|
|
|
test('realm vs jsdom: 60 days of the scenic big network with actions in between, S and R byte for byte', async (t) => {
|
|
const P = page({ save: bigScenic() });
|
|
t.after(() => P.close());
|
|
const code = 'D3T3RM', nid = 'detr0001';
|
|
await loadBig(code, nid);
|
|
const ev = P.ev;
|
|
const near = ev("Object.keys(CITY).filter(c=>!S.pops[c]&&homeOk(c)).sort((a,b)=>kmBetween('fra',a)-kmBetween('fra',b))[0]");
|
|
const net = ev(`NETS.filter(n=>sellsAt(n,${JSON.stringify(near)}))[0].id`);
|
|
const script = ev('TE_EXAMPLE');
|
|
const gone = ev("S.links.find(l=>l.kind==='wave'&&l.a==='fra').id");
|
|
// On a day: what the player clicks, the page's way, and the request the same click sends the server.
|
|
const PLAN = {
|
|
5: () => ({ act: 'buildPop', args: { city: near }, page: () => ev(`ACT.buildPop({city:${JSON.stringify(near)}})`) }),
|
|
6: () => { ev(`openLinkModal('fra',${JSON.stringify(near)})`);
|
|
const ui = JSON.parse(ev("JSON.stringify(Object.fromEntries(['pending','route','via','cnPrem'].filter(k=>UI[k]!==undefined&&UI[k]!==null||k==='pending').map(k=>[k,UI[k]])))"));
|
|
return { act: 'buildLink', args: { tier: 1 }, ui, page: () => ev('ACT.buildLink({tier:1})') }; },
|
|
8: () => ({ act: 'buyTransit', args: { city: near, net, tier: 1 }, page: () => ev(`ACT.buyTransit({city:${JSON.stringify(near)},net:'${net}',tier:1})`) }),
|
|
12: () => { ev(`UI.sel={type:'link',id:'${gone}'};`); return { act: 'rmLink', args: { id: gone }, confirmed: true, page: () => ev(`ACT.rmLink({id:'${gone}'});ACT.rmLink({id:'${gone}'})`) }; },
|
|
15: () => ({ act: 'renameGo', args: { name: 'Tubular Bells' }, page: () => ev("ACT.renameGo({name:'Tubular Bells'})") }),
|
|
18: () => ({ act: 'coreUp', args: {}, page: () => ev('ACT.coreUp()') }),
|
|
19: () => ({ act: 'coreUp', args: {}, page: () => ev('ACT.coreUp()') }),
|
|
21: () => ({ act: 'buyTE', args: {}, page: () => ev('ACT.buyTE()') }),
|
|
22: () => ({ act: 'teDeploy', args: { script }, ui: { slop: false }, page: () => ev(`ACT.teDeploy({script:${JSON.stringify(script)}})`) }),
|
|
};
|
|
const outcomes = {};
|
|
for (let d = 1; d <= 60; d++) {
|
|
if (PLAN[d] && PLAN[d]().setup) { const x = PLAN[d]().setup; ev(x); await E.eval(code, nid, x + 'return 1;'); }
|
|
else if (PLAN[d]) {
|
|
const p = PLAN[d]();
|
|
const ctx = ctxOf(ev);
|
|
p.page();
|
|
const r = checked(await E.act(code, nid, msg(p.act, p.args, { ...(p.ui ? { ui: p.ui } : {}), ...(p.confirmed ? { confirmed: true } : {}), ctx })));
|
|
outcomes[p.act + '@' + d] = r.outcome + (r.why ? ': ' + r.why : '');
|
|
const a = ev('JSON.stringify(S)'), b = await realmS(code, nid);
|
|
assert.ok(a === b, `after ${p.act} on day ${d}:\n${a === b ? '' : differs(a, b)}`);
|
|
}
|
|
P.day();
|
|
const D = await day(code, d, [nid]);
|
|
assert.equal(D.nets[nid].err, undefined, `day ${d}`);
|
|
if (d % 20 === 0) {
|
|
const a = ev('JSON.stringify(S)'), b = await realmS(code, nid);
|
|
assert.ok(a === b, `S on day ${d}:\n${a === b ? '' : differs(a, b)}`);
|
|
assert.ok(ev(RSIG) === await realmR(code, nid), `R on day ${d}`);
|
|
}
|
|
}
|
|
// The plan really played: the network grew, a link went, the script is live.
|
|
for (const k of ['buildPop@5', 'buildLink@6', 'buyTransit@8', 'rmLink@12', 'renameGo@15', 'buyTE@21', 'teDeploy@22']) assert.equal(outcomes[k], 'applied', k);
|
|
assert.equal(ev('S.name'), 'Tubular Bells');
|
|
assert.equal(ev('!!(S.te&&S.te.on&&S.te.script)'), true, 'RouteScript is deployed');
|
|
assert.equal(ev('S.biz.filter(b=>b.route===\'scenic\').length') > 0, true, 'scenic circuits played');
|
|
assert.deepEqual(P.errors, []);
|
|
});
|
|
|
|
/* A restart or an idle unload is invisible (4.6, 4.7, 11): a network checkpointed after any day and loaded into a fresh
|
|
realm is at once, and stays, the network that kept going, S and R byte for byte. Two of them: the scenic big network,
|
|
and the same busy (busy(), and an attack on). They need everything rt carries besides the save: R's routing point (R
|
|
after a day is the R of the day's last routing, made before the day's end changed S, so the saved S routes to another
|
|
R, which the next day reads; a checkpoint after day 10 passed by luck: a failure or event routed at that day's end), the
|
|
sales desk's tried offers, and the live order of keys a reload reorders (the intern's weekly report lists its tally
|
|
in it). Checkpoints after days 1, 2, 5 and 10 of each (2 and 10 right after an action), each played 10 days on;
|
|
SIM_LONG: after every day up to 30. Compared as text: a deep-equal of two big networks that differ builds a diff of
|
|
gigabytes. */
|
|
test('restore: a checkpoint after any day, in a fresh realm, plays on byte for byte as the network that kept going', { timeout: LONG ? 1800e3 : 300e3 }, async (t) => {
|
|
const X = createEngine({ workers: 1, test: TEST, timeouts: ROOMY, heapMb: LONG ? 4096 : 1536 });
|
|
t.after(() => X.close());
|
|
const { day, realmS, realmR } = on(X);
|
|
const code = 'R3ST0R', H = 10, KS = LONG ? Array.from({ length: 30 }, (_, i) => i + 1) : [1, 2, 5, 10], N = Math.max(...KS) + H;
|
|
const bases = ['busy0000', 'scen0000'];
|
|
for (const nid of bases) checked((await X.load(code, [{ nid, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'en', prefs: {} }]))[0]);
|
|
assert.equal((await X.eval(code, bases[0], busy('eng') + 'const a=ddosAttack(true);a.until=S.day+6;return slP();')).value, 'eng');
|
|
const same = async (what, a, b) => {
|
|
const sa = await realmS(code, a), sb = await realmS(code, b);
|
|
assert.ok(sa === sb, `${what}: S\n${sa === sb ? '' : differs(sa, sb)}`);
|
|
const ra = await realmR(code, a), rb = await realmR(code, b);
|
|
assert.ok(ra === rb, `${what}: R\n${ra === rb ? '' : differs(ra, rb)}`);
|
|
};
|
|
let copies = [];
|
|
const carried = { point: 0, desk: 0, order: 0 };
|
|
for (let d = 1; d <= N; d++) {
|
|
await day(code, d, [...bases, ...copies.map((c) => c.nid)]);
|
|
for (const c of copies.filter((x) => x.k + H === d)) { await same(`${c.nid}, ${H} days after its checkpoint`, c.base, c.nid); await X.unload(code, c.nid); }
|
|
copies = copies.filter((x) => x.k + H > d);
|
|
if (!KS.includes(d)) continue;
|
|
// Every other one right after an action and a what-if (a server also checkpoints a network after an action), sent
|
|
// to the network and to its copies alike.
|
|
if (d % 2 === 0) for (const b of bases) {
|
|
const city = (await X.eval(code, b, "return Object.keys(CITY).filter(c=>!S.pops[c]&&homeOk(c)).sort((x,y)=>kmBetween('fra',x)-kmBetween('fra',y))[0]")).value;
|
|
const lid = (await X.eval(code, b, 'return S.links[0].id')).value;
|
|
for (const nid of [b, ...copies.filter((c) => c.base === b).map((c) => c.nid)]) {
|
|
assert.equal(checked(await X.act(code, nid, msg('buildPop', { city }))).outcome, 'applied', `${nid}: a POP in ${city}`);
|
|
assert.ok(checked(await X.ask(code, nid, msg('linkCheck', { id: lid }))).modal, `${nid}: the what-if`);
|
|
}
|
|
}
|
|
for (const b of bases) {
|
|
// The envelope a server writes (4.6), through text, into a fresh realm; the network's clock goes on.
|
|
const sv = checked(await X.save(code, b)), nid = b.slice(0, 4) + String(d).padStart(4, '0');
|
|
const env = JSON.parse(JSON.stringify({ s: sv.txt, uidN: sv.uidN, rt: sv.rt, last: d, day: sv.day }));
|
|
checked((await X.load(code, [{ nid, env, lang: 'en', prefs: {} }]))[0]);
|
|
await X.eval(code, nid, `__srvClock(${(await X.eval(code, b, 'return __srvClock()')).value});return 1;`);
|
|
await same(`${nid}, loaded from its checkpoint after day ${d}`, b, nid);
|
|
copies.push({ nid, base: b, k: d });
|
|
const rt = env.rt;
|
|
if (rt.pt && rt.pt.at.biz) carried.point++;
|
|
if (rt.sl.length) carried.desk++;
|
|
if (rt.ord && rt.ord.ops) carried.order++;
|
|
}
|
|
}
|
|
// What it played: scenic circuits, and checkpoints that needed each part of rt.
|
|
assert.ok(JSON.parse(await realmS(code, bases[1])).biz.some((x) => x.route === 'scenic'), 'with scenic circuits');
|
|
assert.ok(carried.point && carried.desk && carried.order, `rt carried each part: ${JSON.stringify(carried)}`);
|
|
await X.unload(code);
|
|
});
|
|
|
|
test('retry: a day that throws, or times out, once after the DDoS step with an attack on, leaves the same network', async (t) => {
|
|
// An engine with the server's own time limits: the injected endless loop is stopped by them.
|
|
const E = createEngine({ workers: 1, test: TEST });
|
|
t.after(() => E.close());
|
|
const { day, realmS, realmR } = on(E);
|
|
const code = 'R3TRYX', clean = 'rtya0001', thrown = 'rtyb0002', slow = 'rtyc0003', nets = [clean, thrown, slow];
|
|
const L = await E.load(code, nets.map((nid) => ({ nid, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'en', prefs: {} })));
|
|
L.forEach(checked);
|
|
// Busy: what keeps state between days goes back to the mark too (the sales desk's tried offers live outside S).
|
|
for (const nid of nets) await E.eval(code, nid, busy('eng') + 'return 1;');
|
|
for (let d = 1; d <= 3; d++) await day(code, d, nets);
|
|
// An attack that is still on during day 4 (the same one in each).
|
|
for (const nid of nets) assert.ok((await E.eval(code, nid, 'const a=ddosAttack(true);a.until=S.day+3;return ddosAll().length')).value > 0, 'an attack is on');
|
|
const epoch = async (nid) => checked(await E.pull(code, nid, {})).epoch;
|
|
const e0 = { thrown: await epoch(thrown), slow: await epoch(slow) };
|
|
// Day 4 fails once in two of them, right after the DDoS step, while the attack is on.
|
|
const fault = (what) => `{const f=ddosTick;let once=true;ddosTick=function(){f();if(once&&ddosAll().length){once=false;${what}}};}return 1;`;
|
|
await E.eval(code, thrown, fault("throw new Error('injected failure')"));
|
|
await E.eval(code, slow, fault('for(;;){}'));
|
|
const D = await day(code, 4, nets);
|
|
assert.deepEqual([D.nets[clean].retried, D.nets[thrown].retried, D.nets[slow].retried], [undefined, true, true]);
|
|
for (const nid of nets) assert.equal(D.nets[nid].err, undefined, `${nid} played day 4`);
|
|
assert.equal(await epoch(thrown), e0.thrown, 'a throw is put back in place: the same realm');
|
|
assert.notEqual(await epoch(slow), e0.slow, 'a timeout gets a fresh realm: a new epoch');
|
|
for (let d = 5; d <= 8; d++) await day(code, d, nets);
|
|
const s0 = await realmS(code, clean), r0 = await realmR(code, clean);
|
|
for (const nid of [thrown, slow]) {
|
|
const s = await realmS(code, nid);
|
|
assert.ok(s === s0, `${nid}:\n${s === s0 ? '' : differs(s0, s)}`);
|
|
assert.ok(await realmR(code, nid) === r0, `${nid}: R`);
|
|
}
|
|
// A day that fails twice: broken at its state before the day; it gets no more days, its actions stop.
|
|
await E.eval(code, thrown, "{const f=ddosTick;ddosTick=function(){f();throw new Error('broken for good');};}return 1;");
|
|
const before = JSON.parse(await realmS(code, thrown)).day;
|
|
const D2 = await day(code, 9, nets);
|
|
assert.equal(D2.nets[thrown].retried, true);
|
|
assert.match(D2.nets[thrown].err, /broken for good/);
|
|
assert.equal(D2.nets[thrown].day, before, 'at its state before the day');
|
|
assert.equal(JSON.parse(await realmS(code, thrown)).day, before);
|
|
const D3 = await day(code, 10, nets);
|
|
assert.equal(D3.nets[thrown], undefined, 'no more days');
|
|
assert.equal(checked(await E.act(code, thrown, msg('buildPop', { city: 'dus' }))).outcome, 'stopped');
|
|
await E.unload(code);
|
|
});
|
|
|
|
test('routing memory: after a checkpoint between an act and the next day, or an act rolled back, a click that changes nothing routing reads routes in neither network', async () => {
|
|
const code = 'RKMEM0', base = 'rkbs0001', copy = 'rkcp0002';
|
|
const ev = async (nid, src) => (await E.eval(code, nid, src)).value;
|
|
checked((await E.load(code, [begin(base)]))[0]);
|
|
await day(code, 1, [base]);
|
|
assert.equal(checked(await E.act(code, base, msg('launchBB', { city: 'fra' }))).outcome, 'applied');
|
|
// The checkpoint, right after an act that routed, in a fresh realm.
|
|
const sv = checked(await E.save(code, base));
|
|
assert.equal(sv.rt.rk, true, 'the checkpoint says R is the routing of S as it is');
|
|
checked((await E.load(code, [{ nid: copy, env: { s: sv.txt, uidN: sv.uidN, rt: sv.rt }, lang: 'en', prefs: {} }]))[0]);
|
|
await ev(copy, `__srvClock(${await ev(base, 'return __srvClock()')});return 1;`);
|
|
const COUNT = '{const c=compute;compute=function(){__cc++;return c.apply(this,arguments);};}window.__cc=0;return 1;';
|
|
for (const n of [base, copy]) await ev(n, COUNT);
|
|
for (const n of [base, copy]) assert.equal(checked(await E.act(code, n, msg('renameGo', { name: 'Tubular Bells' }))).outcome, 'applied');
|
|
assert.deepEqual([await ev(base, 'return __cc'), await ev(copy, 'return __cc')], [0, 0], 'a click that changes nothing routing reads');
|
|
{ const x = await realmS(code, base), y = await realmS(code, copy); assert.ok(x === y, differs(x, y)); }
|
|
// An act that routes, then throws: back in place, what the game remembers of its routing with it.
|
|
const net = await ev(base, "return NETS.filter(n=>sellsAt(n,'fra')&&!S.transit.some(t=>t.city==='fra'&&t.net===n.id))[0].id");
|
|
await ev(base, "{const f=ACT.buyTransit;ACT.buyTransit=a=>{f(a);throw new Error('after its routing');};}return 1;");
|
|
const r = checked(await E.act(code, base, msg('buyTransit', { city: 'fra', net, tier: 1 })));
|
|
assert.equal(r.outcome, 'error');
|
|
assert.ok(await ev(base, 'return __cc') > 0, 'the act that failed had routed');
|
|
for (const n of [base, copy]) await ev(n, '__cc=0;return 1;');
|
|
for (const n of [base, copy]) checked(await E.act(code, n, msg('renameGo', { name: 'Packet Pals' })));
|
|
assert.deepEqual([await ev(base, 'return __cc'), await ev(copy, 'return __cc')], [0, 0], 'nor after an act rolled back');
|
|
{ const x = await realmS(code, base), y = await realmS(code, copy); assert.ok(x === y, differs(x, y)); }
|
|
await E.unload(code);
|
|
});
|
|
|
|
test('order: three networks of a session play the same in either realm order', async () => {
|
|
// The same three networks under ids that sort the other way round: X, Y, Z here are Z, Y, X there.
|
|
const X = { home: 'fra' }, Y = { home: 'nyc', preset: 'bgp' }, Z = { home: 'sin', preset: 'freeze' };
|
|
const one = { aaaa0001: X, mmmm0002: Y, zzzz0003: Z }, two = { zzzz0001: X, mmmm0002: Y, aaaa0003: Z };
|
|
const play = async (code, ids) => {
|
|
const nids = Object.keys(ids);
|
|
(await E.load(code, nids.map((nid, i) => ({ ...begin(nid, ids[nid]), begin: { ...begin(nid, ids[nid]).begin, mp: { code: 'S4M3C0', pid: 'same000' + i, asn: 201234, seed: 777, preset: ids[nid].preset || 'oncall', color: '#3a86ff', title: 'Order' } } })))).forEach(checked);
|
|
for (const nid of nids) {
|
|
const c = ids[nid].home;
|
|
for (const [act, args] of [['launchBB', { city: c }], ['buyTransit', { city: c, net: (await E.eval(code, nid, `return NETS.filter(n=>sellsAt(n,'${c}'))[0].id`)).value, tier: 1 }]]) checked(await E.act(code, nid, msg(act, args)));
|
|
}
|
|
for (let d = 1; d <= 40; d++) await day(code, d, nids.slice().reverse());
|
|
const out = {};
|
|
for (const nid of nids) out[ids[nid].home] = await realmS(code, nid);
|
|
await E.unload(code);
|
|
return out;
|
|
};
|
|
const a = await play('0RDER1', one), b = await play('0RDER2', two);
|
|
for (const k of Object.keys(a)) assert.ok(a[k] === b[k], `${k}:\n${a[k] === b[k] ? '' : differs(a[k], b[k])}`);
|
|
assert.notEqual(a.fra, a.nyc);
|
|
});
|
|
|
|
// The capacity market and moving customers came after the engine (3.2.0, 3.3.0): their acts and the market's days, on a
|
|
// network with fiber to sell (the big fixture has none), against the page, under the strict gate, then from a checkpoint.
|
|
test('market and moved customers: realm and page the same, the strict gate passes, a checkpoint plays on the same', async (t) => {
|
|
// New York to Ashburn three times (two fibers in one trench), the way round through Boston, Chicago; a wave, a managed
|
|
// wave and a circuit to move.
|
|
const fib = (id, a, z, km, tr, n = 8) => `S.links.push({id:'${id}',a:'${a}',b:'${z}',kind:'df',own:true,sys:'roadm',pairs:2,ch:Array(${n}).fill('zr4'),km:${km},sub:false,cable:null,mo:1,trench:'${tr}',cut:0,day:0,ready:0,spares:false});`;
|
|
const cust = (id, type, more) => `S.biz.push({id:'${id}',type:'${type}',name:'Customer ${id}',city:'nyc',city2:'ash',bw:1,rate:9000,reqs:[],mood:80,since:0,day:0,route:'normal'${more}});`;
|
|
const h = load({ seed: TEST.seed });
|
|
h.ev("ACT.start({});S.cash=1e9;for(const g of GOALS)S.done[g.id]=0;S.lvl=13;UI.speed=0;" +
|
|
"for(const c of ['nyc','ash','bos','chi'])if(!S.pops[c])S.pops[c]={day:0,bb:null,boost:0,down:0,routers:4,gen:false,rgen:RG.length-3};" +
|
|
fib('a', 'nyc', 'ash', 350, 'ta') + fib('b', 'nyc', 'ash', 350, 'ta') + fib('c', 'ash', 'nyc', 420, 'tc') + fib('d', 'nyc', 'bos', 130, 'td') +
|
|
fib('e', 'bos', 'ash', 220, 'te') + fib('f', 'chi', 'nyc', 1200, 'tf', 16) +
|
|
cust('w', 'wwave', ",link:'a',slots:2,what:'x'") + cust('m', 'mwave', ",link:'b',slots:1,g:100,what:'x'") + cust('k', 'l2vpn', '') +
|
|
`S.rng=${MP.seed};S.mp={...${JSON.stringify(MP)},seq:0,sim:1};compute();`);
|
|
const save = h.ev('JSON.stringify(migrate(JSON.parse(JSON.stringify(S))))');
|
|
h.dom.window.close();
|
|
const P = page({ save }), ev = P.ev;
|
|
t.after(() => P.close());
|
|
const S2 = createEngine({ workers: 1, test: TEST, strict: true, timeouts: ROOMY });
|
|
t.after(() => S2.close());
|
|
const code = 'MKTPTH', nid = 'mktp0001', nid2 = 'mktp0002';
|
|
checked((await S2.load(code, [{ nid, env: { s: save, uidN: 1000, rt: null }, lang: 'en', prefs: {} }]))[0]);
|
|
const realm = async (n, src) => (await S2.eval(code, n, src)).value;
|
|
const same = async (what) => {
|
|
const x = ev('JSON.stringify(S)'), y = await realm(nid, 'return JSON.stringify(S)');
|
|
assert.ok(x === y, `${what}:\n${x === y ? '' : differs(x, y)}`);
|
|
};
|
|
const outcomes = [];
|
|
const act = async (a, args) => {
|
|
const ctx = ctxOf(ev);
|
|
ev(`ACT.${a}(${JSON.stringify(args)})`);
|
|
outcomes.push(a + ' ' + checked(await S2.act(code, nid, msg(a, args, { ctx }))).outcome);
|
|
await same(`after ${a}`);
|
|
};
|
|
let d = 0;
|
|
const days = async (n, nets, pg = true) => {
|
|
for (let i = 0; i < n; i++) {
|
|
if (pg) P.day();
|
|
const D = checked(await S2.day(code, { d: ++d, speed: 1, last: 1, alone: [], nets }));
|
|
for (const x of nets) assert.equal(D.nets[x].err, undefined, `${x} day ${d}: ${D.nets[x].err}`);
|
|
}
|
|
};
|
|
await act('mktHold', { v: 0 });
|
|
for (const p of ev('CM_P.join()').split(',')) { await act('mktCfg', { p, k: 'on', v: true }); await act('mktCfg', { p, k: 'floor', v: 60 }); }
|
|
await act('mktCfg', { p: 'w100', k: 'min', v: 1 });
|
|
await act('mktRoute', { k: 'ash|nyc' });
|
|
await act('mktRoute', { k: 'ash|nyc' });
|
|
const to = (id) => ev(`fiberTargets(S.biz.find(b=>b.id==='${id}')).filter(x=>!x.no).map(x=>x.l.id)[0]`);
|
|
await act('pathMove', { id: 'w', link: to('w') });
|
|
await act('pathMove', { id: 'm', link: to('m') });
|
|
const via = ev("circuitTargets(S.biz.find(b=>b.id==='k')).alts[0].p.join()");
|
|
await act('pathPin', { id: 'k', via });
|
|
await days(1, [nid]);
|
|
await act('pathAuto', { id: 'k' });
|
|
await act('pathPin', { id: 'k', via });
|
|
assert.deepEqual(outcomes.filter((o) => !o.endsWith(' applied')), [], 'every one applied');
|
|
for (let k = 0; k < 2; k++) {
|
|
await days(20, [nid]);
|
|
await same(`S on day ${d}`);
|
|
assert.ok(ev(RSIG) === await realm(nid, `return ${RSIG}`), `R on day ${d}`);
|
|
}
|
|
// What the days said (sales, news) reaches a page as fx of the next update, in the contract's shapes.
|
|
const U = JSON.parse(checked(await S2.pull(code, nid, {})).upd);
|
|
assert.ok(U.fx.some(([k, p]) => k === 'toast' && p.k === 'good'), 'the sales were told');
|
|
const sold = ev('S.stats.cmSold');
|
|
assert.ok(sold > 20 && ev("S.biz.find(b=>b.id==='k').pin.join()") === via, `the market sold (${sold}) and the circuit stayed pinned`);
|
|
// A checkpoint into a fresh realm (its rt, no route cache) plays on byte for byte as the realm that kept going.
|
|
const sv = checked(await S2.save(code, nid));
|
|
checked((await S2.load(code, [{ nid: nid2, env: { s: sv.txt, uidN: sv.uidN, rt: sv.rt }, lang: 'en', prefs: {} }]))[0]);
|
|
await realm(nid2, `__srvClock(${await realm(nid, 'return __srvClock()')});return 1;`);
|
|
await days(15, [nid, nid2], false);
|
|
const s1 = await realm(nid, 'return JSON.stringify(S)'), s2 = await realm(nid2, 'return JSON.stringify(S)');
|
|
assert.ok(s1 === s2, `S after the checkpoint:\n${s1 === s2 ? '' : differs(s1, s2)}`);
|
|
assert.ok(await realm(nid, `return ${RSIG}`) === await realm(nid2, `return ${RSIG}`), 'R after the checkpoint');
|
|
assert.ok(JSON.parse(s1).stats.cmSold > sold, 'it went on selling');
|
|
assert.deepEqual(await realm(nid, 'return [__SRV_T.n,__SRV_T.at]'), [0, []], 'no timer');
|
|
assert.deepEqual(P.errors, []);
|
|
});
|
|
|
|
test(`timer audit and gate: ${LONG ? 365 : 60} days with everything on, then every sent button a crawl finds`, { timeout: LONG ? 1800e3 : 300e3 }, async (t) => {
|
|
const S2 = createEngine({ workers: 1, test: TEST, strict: true, timeouts: ROOMY });
|
|
t.after(() => S2.close());
|
|
const code = 'AVD1T5', nid = 'audt0001';
|
|
const SETUP = busy('shark');
|
|
checked((await S2.load(code, [{ nid, env: { s: bigScenic(), uidN: 1000, rt: null }, lang: 'en', prefs: {} }]))[0]);
|
|
await S2.eval(code, nid, SETUP + 'return 1;');
|
|
const timers = async () => (await S2.eval(code, nid, 'return [__SRV_T.n,__SRV_T.at]')).value;
|
|
const N = LONG ? 365 : 60;
|
|
let fails = 0;
|
|
for (let d = 1; d <= N; d++) {
|
|
const D = checked(await S2.day(code, { d, speed: 8, last: 8, alone: [], nets: [nid] }));
|
|
assert.equal(D.nets[nid].err, undefined, `day ${d}: ${D.nets[nid].err}`);
|
|
if (D.nets[nid].lost) break;
|
|
if (d % 30 === 0) checked(await S2.pull(code, nid, { snap: d === 30 }));
|
|
}
|
|
const after = (await S2.eval(code, nid, 'return [S.inc.length+S.stats.incidents,S.ops.log.length,S.biz.length,S.day]')).value;
|
|
assert.ok(after[0] > 0 && after[1] > 0, `failures happened and the intern worked: ${after}`);
|
|
let [n, at] = await timers();
|
|
assert.equal(n, 0, `no timer on a day: ${(at || []).join('\n')}`);
|
|
// Every sent button of the same network, found by a page.
|
|
const P = page({ save: (await S2.eval(code, nid, 'return JSON.stringify(S)')).value });
|
|
t.after(() => P.close());
|
|
const btns = crawl(P.ev).filter(([act]) => A.SEND.includes(act));
|
|
assert.ok(btns.length > 150, `a real sweep: ${btns.length} buttons`);
|
|
for (const q of ['mktCfg', 'mktHold', 'pathPin']) assert.ok(btns.some(([a]) => a === q), `the crawl found ${q}`);
|
|
// By default the first three different buttons of each act (about 250); SIM_LONG every one (about 3,000).
|
|
const seen = new Set(), per = {}, outs = {};
|
|
for (const [act, args] of btns) {
|
|
const k = act + JSON.stringify(args);
|
|
if (seen.has(k) || (!LONG && (per[act] || 0) >= 3)) continue;
|
|
seen.add(k); per[act] = (per[act] || 0) + 1;
|
|
let body;
|
|
try { body = msg(act, args, { ...(A.CONFIRM[act] ? { confirmed: true } : {}), ctx: { sel: { type: 'city', id: 'fra' }, tab: 'cust', left: 'noc', modal: false, w: 1024, h: 768 } }); } catch (e) { continue; }
|
|
const r = checked(await S2.act(code, nid, body));
|
|
if (r.t === 'err') { fails++; continue; }
|
|
outs[r.outcome] = (outs[r.outcome] || 0) + 1;
|
|
assert.ok(!/^sanitize would repair/.test(r.why || ''), `the gate rolled back ${act} ${JSON.stringify(args)}: ${r.why}`);
|
|
if (r.outcome === 'error') assert.fail(`${act} ${JSON.stringify(args)}: ${r.why}`);
|
|
}
|
|
assert.equal(fails, 0, 'no action timed out or broke its pipeline');
|
|
assert.ok(outs.applied > 20, `actions applied: ${JSON.stringify(outs)}`);
|
|
[n, at] = await timers();
|
|
assert.equal(n, 0, `no timer in an action: ${(at || []).join('\n')}`);
|
|
// Nothing waits to run later: S stays as it is after the worker's next turns.
|
|
const s1 = (await S2.eval(code, nid, 'return JSON.stringify(S)')).value;
|
|
await new Promise((r) => setTimeout(r, 50));
|
|
assert.ok((await S2.eval(code, nid, 'return JSON.stringify(S)')).value === s1, 'S changed after the call was over');
|
|
// A day after all of it still passes the strict gate.
|
|
const D = checked(await S2.day(code, { d: N + 1, speed: 1, last: 1, alone: [], nets: [nid] }));
|
|
assert.equal(D.nets[nid].err, undefined);
|
|
});
|