seriesoftubes/tests/game.test.js
Frederic Jung c3b99df788
Shape DDoS attacks and add a mitigation toolbox (1.17.0)
DDoS was one flat random event. Now each attack has a vector (DNS, NTP,
CLDAP, SYN, HTTP), a size from a few Gbps to a multi-terabit monster, a
target POP, a duration and an entry point among that city's uplinks.

The NOC grows a live attack panel and a toolbox: RTBH (free, instant, but
the victim goes dark too), a one-time Flowspec licence that drops known UDP
floods at the edge but cannot touch an HTTP flood, the existing scrubbing
center, and HackBack 3000, which sometimes ends the attack and often
flattens an innocent for a fine. New Vigilante and Collateral Damage badges,
Italian translations, and tests for the attack, each tool and old saves.
2026-10-25 06:18:51 +00:00

220 lines
12 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

const test = require('node:test');
const assert = require('node:assert/strict');
const { load, seed } = require('./harness');
test('page boots to the title screen without errors', () => {
const { ev, errors } = load();
assert.equal(ev("document.getElementById('modal').hidden"), false);
assert.match(ev("document.getElementById('modalCard').textContent"), /Series\s*of\s*Tubes/);
assert.deepEqual(errors, []);
});
test('every city sits on its landmass', () => {
const { ev } = load();
const off = ev("CITIES.filter(c=>!inPoly(c.x,c.y,LANDS.find(l=>l.id===c.land).pts)).map(c=>c.id).join()");
assert.equal(off, '');
});
test('every cable lands at two known cities and has a length', () => {
const { ev } = load();
const bad = ev("CABLE_PAIRS.filter(c=>!CITY[c.a]||!CITY[c.b]||!(c.km>0)).map(c=>c.cid).join()");
assert.equal(bad, '');
});
test('a year of scripted play stays healthy', () => {
const { ev, errors } = load();
seed(ev, 7);
ev("ACT.start({})");
ev("ACT.launchBB({city:'fra'});ACT.buyTransit({city:'fra',net:'cog',tier:1});ACT.buyIx({city:'fra',tier:1,signed:true});ACT.rs({city:'fra'})");
ev("UI.pending={a:'fra',b:'ams'};ACT.buildLink({tier:1});ACT.launchBB({city:'ams'})");
for (let d = 0; d < 360; d++) {
ev('dayTick()');
if (d % 30 === 0) ev("for(const o of S.offers.slice())if(S.pops[o.city]&&(!o.city2||S.pops[o.city2]))ACT.accept({id:o.id})");
}
assert.ok(ev('S.day') >= 360);
assert.ok(Number.isFinite(ev('S.cash')), 'cash is a number');
assert.ok(ev('R.served') > 0, 'traffic is flowing');
assert.equal(ev("JSON.stringify(R).includes('NaN')||JSON.stringify(S).includes('null,null')"), false);
assert.deepEqual(errors, []);
});
test('every incident and event type fires and clears cleanly', () => {
const { ev, errors } = load();
seed(ev, 3);
ev("ACT.start({});S.cash=1e8;S.lvl=4;S.day=100");
ev("for(const c of ['ams','lon','nyc','mos','mnl'])ACT.buildPop({city:c})");
ev("ACT.launchBB({city:'fra'});ACT.buyTransit({city:'fra',net:'cog',tier:1});ACT.buyIx({city:'fra',tier:1,signed:true});ACT.rs({city:'fra'})");
ev("UI.pending={a:'fra',b:'ams'};ACT.buildLink({tier:1});UI.via='grace';openLinkModal('nyc','lon');ACT.buildLink({tier:1});closeModal()");
ev("UI.pending={a:'fra',b:'ams'};UI.lmode='df';UI.dfSys='roadm';ACT.orderDf();UI.lmode='wave';S.pops.fra.rgen=2;S.pops.ams.rgen=2");
ev("const df=S.links.find(l=>l.kind==='df');ACT.addCh({id:df.id,o:'zr4'});df.ready=S.day");
const failSrc = ev('fireFailure.toString()');
const types = ['harmless','fatwave','label','mtu','oops','cleaner','maxpfx','prepend','rpki','amp','roadmff','optic','ac','cut','crash','power','transit','ixloop','leak','ddos'];
for (const t of types) {
const funny = ['harmless','fatwave','label','mtu','oops','cleaner','maxpfx','prepend','rpki','roadmff','ac'].includes(t);
const patched = failSrc
.replace(/^function fireFailure/, 'function')
.replace('let tot=opts.reduce', `if(!opts.some(o=>o[0]==='${funny ? 'funny' : t}'))return;opts.splice(0,opts.length,['${funny ? 'funny' : t}',1]);let tot=opts.reduce`)
.replace('type=pick(f);}', `type=f.includes('${t}')?'${t}':pick(f);}`);
ev('window.__ff=' + patched);
ev('S.links.forEach(l=>{l.cut=0;l.eqDown=0;l.chFail=null});S.transit.forEach(t=>t.down=0);for(const c in S.pops)S.pops[c].down=0;compute()');
ev('__ff()');
ev('dayTick()');
}
const evSrc = ev('fireEvent.toString()');
for (const e of ['viral','price','grant','sanction','tariff','hijack','landban','shutdown','redsea','baltic','runet','typhoon','golden','gfw']) {
ev('window.__fe=' + evSrc.replace(/^function fireEvent/, 'function').replace('const e=pick(opts);', `const e='${e}';`));
ev('__fe()');
ev('dayTick()');
}
for (let d = 0; d < 60; d++) ev('dayTick()');
assert.equal(ev('S.inc.filter(i=>i.until<=S.day).length'), 0, 'expired incidents are cleared');
assert.deepEqual(errors, []);
});
test('every panel, tab and the dashboard render', () => {
const { ev, errors } = load();
ev("ACT.start({});S.cash=1e7;ACT.launchBB({city:'fra'});ACT.buyTransit({city:'fra',net:'cog',tier:1})");
for (let d = 0; d < 20; d++) ev('dayTick()');
for (const t of ['cust', 'up', 'peer', 'links']) {
ev(`selectCity('fra');ACT.tab({t:'${t}'})`);
assert.ok(ev("document.getElementById('panelBody').textContent.length") > 50);
}
ev("selectCity('sha')");
for (const t of ['goals', 'deals', 'noc', 'nets']) ev(`ACT.leftTab({t:'${t}'})`);
ev('ACT.dash({})');
assert.ok(ev("document.querySelectorAll('#dashCard svg').length") >= 1);
ev('showHelp()');
assert.deepEqual(errors, []);
});
test('saves never resurrect a bankrupt game', () => {
const { ev } = load();
ev("ACT.start({});S.day=9;S.cash=-2e5;dayTick()");
assert.equal(ev('S.lost'), true);
assert.equal(ev('loadSave()'), null);
});
test('LAGs add members, capacity and cost to transit, IX ports and PNIs', () => {
const { ev, errors } = load();
ev("ACT.start({});S.cash=1e7;S.lvl=4;S.pops.fra.rgen=2;for(const g of GOALS)S.done[g.id]=0");
ev("ACT.buyTransit({city:'fra',net:'cog',tier:1});ACT.buyIx({city:'fra',tier:1,signed:true})");
ev("const t=S.transit[0];window.__c0=S.cash;ACT.lagT({id:t.id,d:1});ACT.lagT({id:t.id,d:1});ACT.lagIx({city:'fra',d:1});compute()");
assert.equal(ev('S.transit[0].n'), 3);
assert.equal(ev("S.ixn.fra"), 2);
assert.equal(ev("__c0-S.cash"), 1500 * 2 + ev("ixPortMo('fra',1)"), 'two transit members and one IX member were charged');
assert.equal(ev("ixCap('fra')"), 190);
assert.equal(ev("R.cost.transit>0"), true);
ev("ACT.buyTransit({city:'fra',net:'cog',tier:2})");
assert.equal(ev('S.transit[0].tier'), 2, 'upgrading a LAG upgrades every member');
ev("ACT.lagT({id:S.transit[0].id,d:-1})");
assert.equal(ev('S.transit[0].n'), 2);
ev("for(let i=0;i<10;i++)ACT.lagT({id:S.transit[0].id,d:1})");
assert.equal(ev('S.transit[0].n'), 8, 'capped at 8 members');
ev("selectCity('fra');ACT.tab({t:'up'})");
assert.match(ev("document.getElementById('panelBody').textContent"), /8×400G LAG/);
assert.deepEqual(errors, []);
});
test('goal rewards are paid once, even for goals finished on day 0', () => {
const { ev } = load();
ev("ACT.start({})");
const c0 = ev('S.cash');
ev("ACT.launchBB({city:'fra'})");
const c1 = ev('S.cash');
for (let i = 0; i < 5; i++) ev('after()');
assert.equal(ev('S.cash'), c1, 'no repeated reward');
assert.equal(c1 - c0, ev("GOALS.find(g=>g.id==='bb').r") - ev("bbCost('fra')"));
});
test('Stuttgart has only the Spätzle-IX: no transit, no PNIs', () => {
const { ev } = load();
assert.equal(ev("CITY.stg.ix"), 'Spätzle-IX');
assert.equal(ev("NETS.filter(n=>n.pops.includes('stg')).length"), 0);
ev('ACT.start({})');
assert.ok(ev("ixMembers('stg').length") > 0, 'networks still peer at the exchange');
});
test('bank: offers arrive, loans pay out, cost money monthly and get paid off', () => {
const { ev, errors } = load();
seed(ev, 5);
ev("ACT.start({});ACT.launchBB({city:'fra'});ACT.buyTransit({city:'fra',net:'cog',tier:1})");
ev("S.loanOffers=[];spawnLoanOffer(false)");
assert.equal(ev('S.loanOffers.length'), 1);
ev("S.loanOffers[0]={id:'x1',bank:'db',amount:100000,exp:S.day+20,covs:['fax'],apr:0.12,term:6,pay:Math.round(annuity(100000,0.12,6))}");
const c0 = ev('S.cash');
ev("ACT.takeLoan({id:'x1'})");
assert.equal(ev('S.cash') - c0 >= 100000 - 1, true, 'cash paid out');
assert.ok(ev('R.cost.loans') > 17000, 'monthly payment shows up in costs');
for (let d = 0; d < 200; d++) ev('dayTick()');
assert.equal(ev("S.loans.filter(l=>l.id==='x1').length"), 0, 'six-month loan is paid off');
ev('ACT.bank({})');
assert.match(ev("document.getElementById('bankCard').textContent"), /Credit rating/);
assert.deepEqual(errors, []);
});
test('bank: broke players get emergency offers, broken conditions cost a penalty', () => {
const { ev } = load();
seed(ev, 9);
ev("ACT.start({});S.cash=-20000");
for (let d = 0; d < 20; d++) ev('loanTick(S.day)');
assert.ok(ev('S.loanOffers.length') >= 1, 'someone offers money when you are broke');
ev("S.cash=500000;S.loans.push({id:'c1',bank:'db',start:S.day-40,amount:100000,bal:100000,apr:0.1,pay:5000,left:24,term:24,share:0,covs:['gen'],base:{sub:0}})");
for (let d = 0; d < 10; d++) ev('S.day++;loanTick(S.day)');
assert.ok(ev("S.loans.find(l=>l.id==='c1').bal") > 100000, 'penalty added after 10 days of breach');
});
test('bank: the venture vultures take a share of revenue instead of payments', () => {
const { ev } = load();
ev("ACT.start({});ACT.launchBB({city:'fra'});ACT.buyTransit({city:'fra',net:'cog',tier:1});for(let i=0;i<30;i++)dayTick()");
ev("S.loanOffers.push({id:'v1',bank:'vult',amount:500000,exp:S.day+20,covs:['blitz'],share:0.1});ACT.takeLoan({id:'v1'})");
assert.equal(ev('R.cost.loans'), 0);
assert.ok(Math.abs(ev('R.cost.revshare') - ev('R.revMo') * 0.1) < 1);
});
test('a shaped DDoS eats capacity, and each tool answers it differently', () => {
const { ev, errors } = load();
ev("ACT.start({});S.cash=1e8;ACT.launchBB({city:'fra'});S.pops.fra.bb.d=200;ACT.buyTransit({city:'fra',net:'cog',tier:1});compute()");
const clean = ev('R.served');
assert.ok(clean > 20, 'traffic flows before the attack');
// A 300 Gbps DNS flood on fra, no mitigation: junk starves the exit and node.
ev("S.ev.ddos={city:'fra',vec:'dns',gbps:300,until:S.day+3,entry:{k:'t',lab:'x'},bh:false,start:S.day};compute()");
const attacked = ev('R.served');
assert.ok(attacked < clean, 'the flood displaces real traffic');
// Flowspec is a standing licence: it drops the known UDP vector at the edge.
ev("ACT.buyFs();compute()");
assert.equal(ev('S.ddosFs'), true);
assert.ok(ev('R.served') > attacked, 'flowspec recovers a DNS flood');
// It cannot touch an application-layer HTTP flood.
const withFs = ev("S.ev.ddos.vec='http';compute();R.served");
ev("S.ddosFs=false;compute()");
assert.ok(Math.abs(withFs - ev('R.served')) < 1, 'flowspec is useless against HTTP');
// Scrubbing cleans any vector network-wide.
ev("S.ev.ddos.vec='dns';S.scrubAt='fra';compute()");
assert.ok(ev('R.served') > attacked, 'scrubbing recovers real traffic');
assert.deepEqual(errors, []);
});
test('RTBH blackholes the victim, and HackBack 3000 is a gamble', () => {
const { ev } = load();
ev("ACT.start({});S.cash=1e8;ACT.launchBB({city:'fra'});S.pops.fra.bb.d=120;ACT.buyTransit({city:'fra',net:'cog',tier:1});compute()");
ev("S.ev.ddos={city:'fra',vec:'syn',gbps:200,until:S.day+3,entry:{k:'edge',lab:''},bh:false,start:S.day};ACT.rtbh();compute()");
assert.equal(ev('S.ev.ddos.bh'), true);
assert.equal(ev('S.stats.rtbh'), 1);
assert.ok(ev("R.citySrv.fra") < 1, 'the blackholed city serves nothing');
// HackBack: a forced win ends the attack early.
ev("S.ev.ddos.bh=false;S.ev.ddos.until=S.day+3;const _r=Math.random;Math.random=()=>0.1;ACT.hackback();Math.random=_r");
assert.ok(ev('S.ev.ddos.until') <= ev('S.day'), 'a lucky hack-back ends it');
// A forced miss fines you and marks you a vigilante.
ev("S.ev.ddos={city:'fra',vec:'dns',gbps:50,until:S.day+3,entry:{k:'edge',lab:''},bh:false,start:S.day};const c=S.cash;const _r=Math.random;Math.random=()=>0.9;ACT.hackback();Math.random=_r;window.__fined=c-S.cash");
assert.ok(ev('window.__fined') > 20000, 'a bad hack-back costs the fee plus a fine');
assert.equal(ev('S.stats.vigilante'), 1);
});
test('old saves without DDoS fields load, and a junk attack object is repaired', () => {
const { ev } = load();
ev("ACT.start({})");
// An old save: no ddosFs, and a stale flat attack with no vector.
const loaded = ev("const s=JSON.parse(JSON.stringify(S));delete s.ddosFs;s.ev={ddos:{city:'fra',until:9}};sanitize(s);JSON.stringify([s.ddosFs, s.ev.ddos===undefined])");
assert.equal(JSON.parse(loaded)[0], false, 'ddosFs defaults to false');
assert.equal(JSON.parse(loaded)[1], true, 'a vectorless attack is dropped');
});