Upstream/test/client-world.test.js
jvanvik 931f59e11e Phase 3: trade/end-game client, bot simulator, first balance pass
Built:
- Client: trade screen, world/end-game screen (landing sites, shipping, node build, final ranking), report sharing + alliance reports tab, alert describers for all notification types, error-code strings (en+nb) for every server CODE.
- tools/bot.js (+ tools/bot/): 50 headless bots against the real server in-process with a fake clock; resource/unit conservation ledger, exit 1 on broken invariants. docs/BALANCE.md has method and every run behind a number.
- Balance changes (evidence in docs/BALANCE.md): secondQueueCoreLevel 10 -> 3, TRANSPORT.capacityPerLink 500 -> 1000 (end game was shipping-limited in bot runs).
- Server fixes: POST /reports/:id/share 500 without a pending reportCleanup; bounced link shipments were silent about cargo overflow.

Tested: npm test 207/207 (new: bot determinism + invariants, client alerts/world/i18n over CODES, two regression tests that failed before their fix); openapi check up to date. Real-browser scratch runs (not in repo): WebSocket push shows an incoming-attack banner ~214 ms after launch, polling fallback ~52 s, 15 scripted flows, 71 screenshots.

NOT tested: Playwright suite (e2e/ still empty), real devices/Safari, nginx proxy websockets, throttled networks, HTTP-level bot load. NOT claimed: balance. Bots are not humans; open balance items (loot waste, escrow refund clipping, no garrisons at landing sites, end game not scaling with world speed) are listed in docs/BALANCE.md.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Q2MJaQ5LXAHzGnTDgceT14
2026-10-11 20:24:41 +02:00

159 lines
12 KiB
JavaScript

'use strict';
/* Client side of the end game and trade: pure helpers (endcore.js), the send-dialog options for landing sites and transports (milcore.js),
* string coverage of the new screens, and no HTML injection sinks. Browser behaviour was looked at in headless Chromium, not here. */
const test = require('node:test');
const assert = require('node:assert');
const fs = require('fs');
const path = require('path');
const I = require('../public/js/i18n.js');
const D = require('../public/js/data.js');
const E = require('../public/js/endcore.js');
const M = require('../public/js/milcore.js');
for (const f of fs.readdirSync(path.join(__dirname, '..', 'public', 'js', 'strings')).sort()) if (f.endsWith('.js')) require('../public/js/strings/' + f);
const ROOT = path.join(__dirname, '..', 'public', 'js');
const site = (o) => Object.assign({ id: 1, index: 0, x: 1, y: 2, holder: null, takenBy: null, takenAt: null, level: 0, maxLevel: 100, progress: 0, pool: { fiber: 0, hardware: 0, capital: 0 }, build: null, next: { toLevel: 1, cost: { fiber: 100, hardware: 100, capital: 100 }, durationMs: 1000 } }, o || {});
const holder = (id, tag) => ({ allianceId: id, tag, name: 'Alliance ' + tag });
test('leading: highest node level, then more sites, then the earlier takeover', () => {
assert.strictEqual(E.leading([]), null);
assert.strictEqual(E.leading([site(), site({ index: 1 })]), null, 'nobody holds a site');
const a = site({ index: 0, holder: holder(1, 'AAA'), level: 10, takenAt: 500 });
const b = site({ index: 1, holder: holder(2, 'BBB'), level: 12, takenAt: 900 });
assert.strictEqual(E.leading([a, b]).tag, 'BBB');
assert.strictEqual(E.leading([a, b]).siteIndex, 1);
const a2 = site({ index: 2, holder: holder(1, 'AAA'), level: 12, takenAt: 700 });
assert.strictEqual(E.leading([a, b, a2]).tag, 'AAA', 'same level: two sites beat one');
assert.strictEqual(E.leading([a, b, a2]).sites, 2);
const c = site({ index: 3, holder: holder(3, 'CCC'), level: 12, takenAt: 100 });
assert.strictEqual(E.leading([b, c]).tag, 'CCC', 'same level and sites: the earlier takeover');
});
test('buildProgress, missing and holderKind', () => {
assert.strictEqual(E.buildProgress(site(), 5), null);
const s = site({ build: { toLevel: 2, startedAt: 1000, dueAt: 3000 } });
assert.strictEqual(E.buildProgress(s, 2000), 0.5);
assert.strictEqual(E.buildProgress(s, 9000), 1);
assert.strictEqual(E.buildProgress(s, 0), 0);
assert.deepStrictEqual(E.missing({ fiber: 100, hardware: 50, capital: 0 }, { fiber: 40, hardware: 50, capital: 9 }), { fiber: 60 });
assert.deepStrictEqual(E.missing({ fiber: 1 }, null), { fiber: 1 });
assert.strictEqual(E.holderKind(site(), 5), 'incumbent');
assert.strictEqual(E.holderKind(site({ holder: holder(5, 'X') }), 5), 'mine');
assert.strictEqual(E.holderKind(site({ holder: holder(6, 'Y') }), 5), 'rival');
assert.strictEqual(E.holderKind(site({ holder: holder(5, 'X') }), null), 'rival');
});
test('buildCheck explains why the node cannot be built, in the order the server checks it', () => {
const rich = { fiber: 1e6, hardware: 1e6, capital: 1e6 };
const ok = site({ pool: rich });
const you = { holder: true, canBuild: true, canShip: true, canAttack: false };
assert.deepStrictEqual(E.buildCheck(ok, you, false), { ok: true, reason: null });
assert.strictEqual(E.buildCheck(ok, you, true).reason, 'ended');
assert.strictEqual(E.buildCheck(ok, { holder: true, canBuild: false }, false).reason, 'forbidden');
assert.strictEqual(E.buildCheck(ok, { holder: false, canBuild: false }, false).reason, 'forbidden');
assert.strictEqual(E.buildCheck(site({ pool: rich, next: null, level: 100 }), you, false).reason, 'max_level');
assert.strictEqual(E.buildCheck(site({ pool: rich, build: { toLevel: 2, startedAt: 0, dueAt: 9 } }), you, false).reason, 'already_queued');
assert.strictEqual(E.buildCheck(site(), you, false).reason, 'not_enough_resources');
});
test('phaseNow flips to backbone_open at opensAt even before the status is refetched; ended wins', () => {
const st = { phase: 'running', opensAt: 1000, ageDays: 40, openDay: 100 };
assert.strictEqual(E.phaseNow(st, 999), 'running');
assert.strictEqual(E.phaseNow(st, 1000), 'backbone_open');
assert.strictEqual(E.phaseNow({ phase: 'ended', opensAt: 1 }, 0), 'ended');
assert.strictEqual(E.phaseNow(null, 0), 'running');
assert.strictEqual(E.openProgress(st), 0.4);
assert.strictEqual(E.openProgress({ ageDays: 500, openDay: 100 }), 1);
assert.strictEqual(E.sumCargo({ fiber: 3, capital: 4 }), 7);
assert.strictEqual(E.topRows([1, 2, 3], 2).length, 2);
});
test('moveOptions on a landing site: scan, attack (needs an alliance, not your own site)', () => {
const tile = (b) => ({ type: 'backbone', backbone: Object.assign({ siteId: 1, index: 0, mine: false, canAttack: true }, b) });
const home = { port_scanner: 2, script_crew: 10 };
const types = (o) => o.map((x) => x.type + (x.ok ? '' : '!'));
assert.deepStrictEqual(types(M.moveOptions({ tile: tile(), home, allianceId: 5 })), ['scan', 'attack']);
const noAll = M.moveOptions({ tile: tile(), home, allianceId: null });
assert.deepStrictEqual(types(noAll), ['scan', 'attack!']);
assert.strictEqual(noAll[1].reason, 'no_alliance');
const own = M.moveOptions({ tile: tile({ mine: true }), home, allianceId: 5 });
assert.strictEqual(own[1].reason, 'own_site');
assert.deepStrictEqual(types(M.moveOptions({ tile: tile(), home: {}, allianceId: 5 })), ['scan!', 'attack!']);
assert.ok(!M.moveOptions({ tile: tile(), home, allianceId: 5 }).some((o) => ['raid', 'takeover', 'settle', 'reinforce', 'transport'].includes(o.type)));
});
test('moveOptions transportOnly: any POP takes a transport (a rival\'s too), nothing else is offered, links decide ok', () => {
const rival = { type: 'pop', town: { id: 9, mine: false, owner: { id: 2, protected: true } } };
const mine = { type: 'pop', town: { id: 3, mine: true, owner: { id: 1 } } };
const home = { script_crew: 10, port_scanner: 3 };
const o = M.moveOptions({ tile: rival, home, transport: { links: 2, active: 1 }, transportOnly: true });
assert.deepStrictEqual(o, [{ type: 'transport', ok: true, reason: null }]);
assert.strictEqual(M.moveOptions({ tile: rival, home, transport: { links: 2, active: 2 }, transportOnly: true })[0].reason, 'links_busy');
assert.strictEqual(M.moveOptions({ tile: mine, home, transport: { links: 0, active: 0 }, transportOnly: true })[0].reason, 'no_link');
assert.deepStrictEqual(M.moveOptions({ tile: { type: 'land', settle: { possible: true } }, home, transportOnly: true }), [], 'empty land takes no transport');
// without the flag a rival POP still gets the hostile types only
assert.ok(!M.moveOptions({ tile: rival, home, transport: { links: 2, active: 0 } }).some((x) => x.type === 'transport'));
});
// ------------------------------------------------------------------ strings of the new screens
const files = ['screens/trade.js', 'screens/world.js', 'screens/cargo-ui.js', 'screens/reports.js', 'screens/map.js', 'screens/send.js', 'screens/movements.js', 'alertkinds.js'];
const SRC = files.map((f) => fs.readFileSync(path.join(ROOT, f), 'utf8')).join('\n');
test('every static string key the trade / world / report / map / send screens use exists in en and nb', () => {
const used = new Set();
for (const m of SRC.matchAll(/\b(?:App\.)?t\('([a-zA-Z0-9_.]+)'/g)) if (!m[1].endsWith('.')) used.add(m[1]);
for (const m of SRC.matchAll(/\bt\([^()']*\? '([a-z0-9_]+\.[a-zA-Z0-9_.]+)' : '([a-z0-9_]+\.[a-zA-Z0-9_.]+)'/g)) { used.add(m[1]); used.add(m[2]); }
assert.ok(used.size > 150, 'found the keys (' + used.size + ')');
const missing = [];
for (const l of I.LANGS) for (const k of used) if (!I.strings[l][k]) missing.push(l + ' ' + k);
assert.deepStrictEqual(missing, []);
});
test('dynamic string keys: tabs, statuses, roles, validation codes, ranking tabs, build refusals, send reasons', () => {
const want = ['trd.tab.offers', 'trd.tab.new', 'trd.tab.mine', 'trd.tab.send', 'trd.role.poster', 'trd.role.acceptor', 'wld.rank.operators', 'wld.rank.alliances', 'wld.rank.attackers', 'wld.rank.defenders',
'wld.build.why.ended', 'wld.build.why.forbidden', 'send.reason.no_alliance', 'send.reason.own_site', 'send.invalid.no_alliance', 'send.invalid.own_site', 'send.invalid.landing_scan_or_attack_only',
'tile.backbone', 'report.type.landing', 'rep.attackerWon', 'rep.defenderWon', 'rep.tab.mine', 'rep.tab.alliance', 'rep.folder.empty', 'rep.share.done', 'rep.share.already', 'nav.trade', 'nav.world', 'screen.trade', 'screen.world']
.concat(['all', 'open', 'accepted', 'completed', 'cancelled', 'expired', 'void'].map((s) => 'trd.status.' + s))
.concat(['giveRes', 'wantRes', 'giveAmount', 'wantAmount', 'maxDistance', 'terms'].map((s) => 'trd.v.' + s));
for (const l of I.LANGS) for (const k of want) assert.ok(I.strings[l][k], l + ' ' + k);
// trade_terms paths the rules can report all have a message
const R = require('../public/js/rules.js');
for (const bad of [{ giveRes: 'x' }, { wantRes: 'x' }, { wantRes: 'fiber' }, { giveAmount: 0 }, { wantAmount: 0 }, { maxDistance: 0 }]) {
const r = R.tradeTermsCheck(Object.assign({ giveRes: 'fiber', giveAmount: 100, wantRes: 'hardware', wantAmount: 100, maxDistance: 30 }, bad));
assert.ok(!r.ok);
assert.ok(I.strings.en['trd.v.' + r.errors[0].path], 'message for ' + r.errors[0].path);
}
});
test('the new screens put no player-controlled text through HTML sinks', () => {
const code = SRC.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
assert.ok(!/innerHTML|insertAdjacentHTML|outerHTML|document\.write/.test(code), 'no HTML injection sinks');
});
test('every screen file of the new screens is loaded by index.html, strings before screens', () => {
const html = fs.readFileSync(path.join(__dirname, '..', 'public', 'index.html'), 'utf8');
const order = (f) => html.indexOf('js/' + f + '"');
for (const f of ['strings/alerts.js', 'strings/trade.js', 'strings/world.js', 'endcore.js', 'alertkinds.js', 'screens/cargo-ui.js', 'screens/trade.js', 'screens/world.js']) assert.ok(order(f) > 0, f + ' is in index.html');
assert.ok(order('strings/world.js') < order('main.js'), 'strings before the shell');
assert.ok(order('endcore.js') < order('screens/world.js'));
assert.ok(order('milstate.js') < order('alertkinds.js') && order('main.js') < order('alertkinds.js'), 'alert kinds need App and App.mil');
assert.ok(order('screens/cargo-ui.js') < order('screens/trade.js') && order('screens/cargo-ui.js') < order('screens/world.js'));
});
test('icons used by the new screens exist in the sprite', () => {
const sprite = fs.readFileSync(path.join(__dirname, '..', 'public', 'icons', 'sprite.svg'), 'utf8');
const have = new Set((sprite.match(/id="i-([a-z_-]+)"/g) || []).map((s) => s.slice(6, -1)));
const used = new Set();
for (const f of ['screens/trade.js', 'screens/world.js']) for (const m of fs.readFileSync(path.join(ROOT, f), 'utf8').matchAll(/\bicon\('([a-z_-]+)'/g)) used.add(m[1]);
used.delete('b-'); // icon('b-' + building): the building icons
used.add('b-' + D.TRANSPORT.building);
for (const i of used) assert.ok(have.has(i), 'icon ' + i);
});
test('every browser script under public/js parses (a syntax error in one file kills every screen after it)', () => {
const vm = require('vm');
const walk = (dir) => fs.readdirSync(dir, { withFileTypes: true }).flatMap((e) => (e.isDirectory() ? walk(path.join(dir, e.name)) : e.name.endsWith('.js') ? [path.join(dir, e.name)] : []));
const files = walk(ROOT);
assert.ok(files.length > 30, 'found the scripts (' + files.length + ')');
for (const f of files) assert.doesNotThrow(() => new vm.Script(fs.readFileSync(f, 'utf8'), { filename: f }), f);
});