towerdef/test/server.test.js
Claude faf0cfa603 Add co-op server, deploy docs, e2e suite and wire in the music tracks
- server/: Node (ws) static server + authoritative co-op rooms; dual-stack
  listen, proxy-aware client IP and Origin check, keep-alive pings, per-socket
  rate limits, graceful shutdown; 59 node:test tests
- docs/DEPLOY.md + deploy/netwall.service: Debian 13 LXC, systemd, nginx
  Proxy Manager walk-through, path prefix, troubleshooting
- e2e/: Playwright suite (smoke, touch, end flow, two-browser co-op incl.
  reconnect, 14-size layout matrix); npm run e2e
- Music: tracks.json now points at the uploaded theme/battle/boss/win/lose
  files; stingers fade out when a new game starts
- PAUSED indicator, refreshed icon

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Tb8pW2KAN4oFkh1aK1BfD8
2026-10-09 19:57:27 +00:00

1472 lines
73 KiB
JavaScript
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
/*
* Multiplayer server tests: a real server on port 0 and real ws clients. Everything (helpers included) lives
* in this one file because `node --test` runs every file under test/.
* Needs only Node 18+ and the ws package: no fetch, no mock timers.
*/
const test = require('node:test');
const assert = require('node:assert/strict');
const http = require('http');
const net = require('net');
const fs = require('fs');
const os = require('os');
const path = require('path');
const EventEmitter = require('events');
const WebSocket = require('ws');
const { createServer } = require('../server');
const netx = require('../server/net');
const TD = require('../public/js/sim.js');
const noop = () => {};
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
let pidCounter = 0;
const newPid = () => 'testpid' + String(++pidCounter).padStart(5, '0');
async function until(fn, ms = 3000, label = 'condition') {
const end = Date.now() + ms;
for (;;) {
const v = fn();
if (v) return v;
if (Date.now() > end) throw new Error('timed out waiting for ' + label);
await sleep(4);
}
}
// ---------------------------------------------------------------- ws client wrapper
class Client {
constructor(url, opts) {
this.msgs = []; this.rx = []; this.pos = 0;
this.closeInfo = null; this.status = null; this.error = null; this.opened = false; this.pings = 0;
const ws = this.ws = new WebSocket(url, opts);
ws.on('open', () => { this.opened = true; });
ws.on('message', (data) => {
let m;
try { m = JSON.parse(data.toString()); } catch (e) { m = { t: '?bad-json', raw: String(data) }; }
this.msgs.push(m); this.rx.push(Date.now());
});
ws.on('ping', () => { this.pings++; });
ws.on('close', (code, reason) => { this.closeInfo = { code, reason: reason.toString() }; });
ws.on('error', (err) => { this.error = err; });
ws.on('unexpected-response', (req, res) => { this.status = res.statusCode; res.resume(); });
}
async open(ms = 3000) {
await until(() => this.opened || this.error || this.status || this.closeInfo, ms, 'websocket open');
if (!this.opened) throw new Error('websocket did not open: ' + (this.status || (this.error && this.error.message) || JSON.stringify(this.closeInfo)));
return this;
}
send(obj) { this.ws.send(JSON.stringify(obj)); }
raw(s) { this.ws.send(s); }
// First not-yet-consumed message matching pred (skipped messages are dropped from consideration).
next(pred, ms = 3000, label = 'message') {
return until(() => {
for (let i = this.pos; i < this.msgs.length; i++) {
if (pred(this.msgs[i])) { this.pos = i + 1; return this.msgs[i]; }
}
return null;
}, ms, label + ' (have: ' + this.msgs.slice(-6).map((m) => m.t).join(',') + (this.closeInfo ? '; closed ' + this.closeInfo.code : '') + ')');
}
type(t, ms) { return this.next((m) => m.t === t, ms, t); }
snap(pred, ms) { return this.next((m) => m.t === 'snap' && (!pred || pred(m)), ms, 'snap'); }
closed(ms = 3000) { return until(() => this.closeInfo, ms, 'close'); }
of(t, from) { return this.msgs.slice(from || 0).filter((m) => m.t === t); }
// Round trip: when the echo is back, everything the server sent before it has been seen.
async barrier() {
const ts = Math.random();
this.send({ t: 'rtt', ts });
await this.next((m) => m.t === 'rtt' && m.ts === ts, 3000, 'barrier');
}
}
async function withServer(opts, fn) {
const srv = await createServer(Object.assign({ port: 0, host: '127.0.0.1', log: noop, graceMs: 400, pingMs: 0 }, opts));
const clients = [];
const S = {
srv,
url: 'ws://127.0.0.1:' + srv.port + '/ws',
port: srv.port,
client(wsOpts) { const c = new Client(S.url, wsOpts); clients.push(c); return c; },
// connect + join; returns { c, pid, r } where r is the first 'joined' or 'error' message
async join({ name = 'Alice', map, pid = newPid(), room, wsOpts } = {}) {
const c = S.client(wsOpts);
await c.open();
const m = { t: 'join', pid, name };
if (room !== undefined) m.room = room;
if (map !== undefined) m.map = map;
c.send(m);
const r = await c.next((x) => x.t === 'joined' || x.t === 'error', 3000, 'joined');
return { c, pid, r };
},
// host creates a room, guest joins it
async pair(o) {
const a = await S.join(Object.assign({ name: 'Alice' }, o));
const b = await S.join({ name: 'Bob', room: a.r.room });
await a.c.next((m) => m.t === 'players' && m.players.length === 2, 3000, 'players(2)');
return { a, b, room: a.r.room };
},
};
try { return await fn(S); } finally {
for (const c of clients) { try { c.ws.terminate(); } catch (e) { /* ignore */ } }
await srv.close();
}
}
// ---------------------------------------------------------------- http helpers
function request(port, rawPath, { method = 'GET', headers = {}, host = '127.0.0.1' } = {}) {
return new Promise((resolve, reject) => {
const req = http.request({ host, port, method, path: rawPath, headers, agent: false }, (res) => {
const chunks = [];
res.on('data', (c) => chunks.push(c));
res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: Buffer.concat(chunks) }));
});
req.on('error', reject);
req.end();
});
}
function rawHttp(port, text) {
return new Promise((resolve, reject) => {
const s = net.connect(port, '127.0.0.1');
let out = '';
s.on('data', (d) => { out += d.toString('latin1'); });
s.on('close', () => resolve(out));
s.on('error', reject);
s.write(text);
});
}
// Open a websocket and report what the server said to the upgrade request.
function probe(url, opts) {
return new Promise((resolve) => {
const ws = new WebSocket(url, opts);
ws.on('open', () => { ws.terminate(); resolve({ ok: true, status: 101 }); });
ws.on('unexpected-response', (req, res) => { res.resume(); ws.terminate(); resolve({ ok: false, status: res.statusCode }); });
ws.on('error', (e) => resolve({ ok: false, error: e.message }));
});
}
const curOf = (snap, slot) => snap.cur.find((c) => c[0] === slot);
// ================================================================ handshake
test('create + join flow: joined payload', async () => {
await withServer({}, async (S) => {
const { c, pid, r } = await S.join({ name: 'Alice', map: 'twin' });
assert.equal(r.t, 'joined');
assert.match(r.room, /^[ABCDEFGHJKLMNPQRSTUVWXYZ23456789]{4}$/);
assert.equal(r.resumed, false);
assert.deepEqual(r.you, { pid, slot: 0, host: true });
assert.deepEqual(r.players, [{ pid, slot: 0, name: 'Alice', host: true, online: true }]);
assert.equal(r.state.map, 'twin');
assert.equal(r.state.rev, 0);
assert.deepEqual(r.state.towers, []);
assert.equal(r.state.maxLives, TD.START_LIVES);
assert.equal(r.snap.s, 'playing');
assert.equal(r.snap.g, TD.START_GOLD);
assert.equal(r.snap.l, TD.START_LIVES);
assert.equal(r.snap.rev, 0);
assert.equal(r.speed, 1);
assert.equal(r.paused, false);
assert.ok(S.srv.rooms.has(r.room));
assert.equal(S.srv.rooms.get(r.room).sim.mapId, 'twin');
// the default map is 'open'
const d = await S.join({});
assert.equal(d.r.state.map, 'open');
assert.notEqual(d.r.room, r.room);
assert.equal(c.closeInfo, null);
});
});
test('names are trimmed, stripped of control chars, capped at 16 and default to Player', async () => {
await withServer({}, async (S) => {
const a = await S.join({ name: ' \u0007‮Bob\n the builder of towers ' });
assert.equal(a.r.players[0].name, 'Bob the builde'); // control chars removed, then 16 chars
assert.ok(a.r.players[0].name.length <= 16);
const b = await S.join({ name: '\u0001\u0002 ' });
assert.equal(b.r.players[0].name, 'Player');
const c = await S.join({ name: 12345 });
assert.equal(c.r.players[0].name, 'Player');
const d = await S.join({ name: '\u{1F600}'.repeat(20) });
assert.equal(Array.from(d.r.players[0].name).length, 16);
});
});
test('second player joins (case-insensitive code) and the first gets players; third gets full', async () => {
await withServer({}, async (S) => {
const a = await S.join({ name: 'Alice' });
const b = await S.join({ name: 'Bob', room: a.r.room.toLowerCase() });
assert.equal(b.r.t, 'joined');
assert.equal(b.r.room, a.r.room);
assert.equal(b.r.resumed, false);
assert.deepEqual(b.r.you, { pid: b.pid, slot: 1, host: false });
assert.equal(b.r.players.length, 2);
assert.deepEqual(b.r.players.map((p) => [p.slot, p.name, p.host, p.online]), [[0, 'Alice', true, true], [1, 'Bob', false, true]]);
const pl = await a.c.type('players');
assert.deepEqual(pl.players.map((p) => [p.slot, p.name, p.host, p.online]),
[[0, 'Alice', true, true], [1, 'Bob', false, true]]);
assert.equal(pl.players[0].pid, a.pid, 'a player sees their own pid');
assert.notEqual(pl.players[1].pid, b.pid, 'but never the other player\'s: the pid is the reconnect secret (see the pid test)');
// the joiner does not get a 'players' echo of its own join (only the *other* players do)
await b.c.barrier();
assert.equal(b.c.of('players').length, 0);
const c = await S.join({ name: 'Carol', room: a.r.room });
assert.equal(c.r.t, 'error');
assert.equal(c.r.code, 'full');
assert.equal(typeof c.r.msg, 'string');
const cl = await c.c.closed();
assert.ok(cl.code >= 4000 && cl.code < 5000);
// the two real players are unaffected
await a.c.barrier();
assert.equal(a.c.closeInfo, null);
assert.equal(S.srv.rooms.get(a.r.room).players.filter(Boolean).length, 2);
});
});
test('a full room still admits the pid that owns a slot (no full error)', async () => {
await withServer({}, async (S) => {
const { a, b, room } = await S.pair();
const again = await S.join({ pid: b.pid, name: 'Bob', room });
assert.equal(again.r.t, 'joined');
assert.equal(again.r.resumed, true);
assert.equal(again.r.you.slot, 1);
});
});
test('the reconnect secret (pid) never reaches the other player; an alias cannot take a slot over', async () => {
await withServer({ graceMs: 5000 }, async (S) => {
const { a, b, room } = await S.pair();
const seenByA = a.c.of('players').pop().players;
const seenByB = b.r.players;
assert.equal(seenByA.find((p) => p.slot === 0).pid, a.pid, 'own entry carries the own pid');
assert.equal(seenByB.find((p) => p.slot === 1).pid, b.pid);
const hostAlias = seenByB.find((p) => p.slot === 0).pid;
const guestAlias = seenByA.find((p) => p.slot === 1).pid;
for (const al of [hostAlias, guestAlias]) assert.match(al, /^[A-Za-z0-9_-]{22}$/);
assert.notEqual(hostAlias, a.pid);
assert.notEqual(guestAlias, b.pid);
assert.notEqual(hostAlias, guestAlias);
// the host's pid is not anywhere in what the guest was sent (and the other way round)
await a.c.barrier(); await b.c.barrier();
assert.ok(!JSON.stringify(b.c.msgs).includes(a.pid), 'host pid leaked to the guest');
assert.ok(!JSON.stringify(a.c.msgs).includes(b.pid), 'guest pid leaked to the host');
// aliases are stable across 'players' updates and reconnects
b.c.ws.terminate();
const off = await a.c.next((m) => m.t === 'players' && !m.players[1].online);
assert.equal(off.players[1].pid, guestAlias);
assert.equal(off.players[0].pid, a.pid);
const b2 = await S.join({ pid: b.pid, room });
assert.equal(b2.r.resumed, true);
assert.equal(b2.r.players.find((p) => p.slot === 0).pid, hostAlias);
assert.equal(b2.r.players.find((p) => p.slot === 1).pid, b.pid);
const on = await a.c.next((m) => m.t === 'players' && m.players[1].online);
assert.equal(on.players[1].pid, guestAlias);
// presenting the alias as a pid takes nothing over: it is just a third (refused) player, the host stays connected
const evil = await S.join({ pid: hostAlias, room, name: 'Mallory' });
assert.equal(evil.r.code, 'full');
await a.c.barrier();
assert.equal(a.c.closeInfo, null, 'the host was not kicked');
assert.equal(S.srv.rooms.get(room).players[0].conn.ws.readyState, 1);
assert.equal(S.srv.rooms.get(room).players[0].name, 'Alice');
});
});
test('join failures: unknown room, bad pid / room / map, room limit', async () => {
await withServer({ maxRooms: 2 }, async (S) => {
const cases = [
[{ room: 'ZZZZ' }, 'no_room'],
[{ pid: 'short' }, 'bad_request'],
[{ pid: 'has spaces in it!' }, 'bad_request'],
[{ pid: 'x'.repeat(41) }, 'bad_request'],
[{ pid: 12345678 }, 'bad_request'],
[{ room: 'abc' }, 'bad_request'],
[{ room: 'abcde' }, 'bad_request'],
[{ room: 'ab-d' }, 'bad_request'],
[{ room: 1234 }, 'bad_request'],
[{ map: 'nope' }, 'bad_map'],
[{ map: 42 }, 'bad_map'],
[{ map: 'toString' }, 'bad_map'],
[{ map: '__proto__' }, 'bad_map'],
];
for (const [over, code] of cases) {
const c = S.client();
await c.open();
c.send(Object.assign({ t: 'join', pid: newPid(), name: 'X' }, over));
const e = await c.type('error');
assert.equal(e.code, code, JSON.stringify(over));
assert.equal(typeof e.msg, 'string');
const cl = await c.closed();
assert.ok(cl.code >= 4000, 'close code is 4000+ for ' + JSON.stringify(over) + ' (got ' + cl.code + ')');
}
assert.equal(S.srv.rooms.size, 0, 'failed joins must not leave rooms behind');
await S.join({}); await S.join({});
const third = await S.join({});
assert.equal(third.r.code, 'too_many_rooms');
assert.equal(S.srv.rooms.size, 2);
});
});
test('a full server evicts the room nobody is online in (longest abandoned first) instead of refusing a newcomer', async () => {
await withServer({ maxRooms: 2, graceMs: 30000 }, async (S) => {
const r1 = await S.join({ name: 'one' });
const r2 = await S.join({ name: 'two' });
const dropped = async (r) => {
r.c.ws.terminate();
await until(() => S.srv.rooms.get(r.r.room).players[0].conn === null, 2000, 'server to notice the disconnect');
};
await dropped(r1);
await sleep(15);
await dropped(r2);
// full, but nobody is online in either room: the one abandoned first makes way
const n1 = await S.join({ name: 'new1' });
assert.equal(n1.r.t, 'joined');
assert.equal(S.srv.rooms.size, 2);
assert.ok(!S.srv.rooms.has(r1.r.room), 'longest-abandoned room evicted');
assert.ok(S.srv.rooms.has(r2.r.room));
assert.equal((await S.join({ pid: r1.pid, room: r1.r.room })).r.code, 'no_room');
const back2 = await S.join({ pid: r2.pid, room: r2.r.room });
assert.equal(back2.r.resumed, true, 'the other abandoned room was still held for its owner');
// somebody is online in both rooms now: nothing may be evicted, the newcomer is refused
const n2 = await S.join({ name: 'new2' });
assert.equal(n2.r.code, 'too_many_rooms');
assert.equal(S.srv.rooms.size, 2);
await n1.c.barrier(); await back2.c.barrier();
assert.equal(n1.c.closeInfo, null);
assert.equal(back2.c.closeInfo, null);
});
});
test('creating rooms and dropping the sockets cannot lock everybody else out of the room table', async () => {
await withServer({ maxRooms: 5, graceMs: 30000 }, async (S) => {
for (let i = 0; i < 12; i++) { // more than twice the table size
const f = await S.join({ name: 'flood' + i });
assert.equal(f.r.t, 'joined', 'room creation ' + i);
f.c.ws.terminate();
await until(() => S.srv.rooms.get(f.r.room).players[0].conn === null, 2000, 'disconnect ' + i);
}
assert.ok(S.srv.rooms.size <= 5);
const innocent = await S.join({ name: 'innocent' });
assert.equal(innocent.r.t, 'joined');
await innocent.c.snap();
});
});
test('first message that is not a valid join is answered with bad_request and the socket is closed', async () => {
await withServer({}, async (S) => {
for (const first of ['garbage', '{', '[]', '{"t":"rtt","ts":1}', '{"t":"join"}', '{"t":"cmd","c":"wave"}']) {
const c = S.client();
await c.open();
c.raw(first);
const e = await c.type('error');
assert.equal(e.code, 'bad_request', first);
assert.equal((await c.closed()).code, 4400);
}
assert.equal(S.srv.rooms.size, 0);
});
});
test('a socket that never joins is closed with 4408', async () => {
await withServer({ joinTimeoutMs: 150 }, async (S) => {
const c = S.client();
await c.open();
const t0 = Date.now();
const cl = await c.closed();
assert.equal(cl.code, 4408);
assert.ok(Date.now() - t0 >= 100);
// a joined socket is not affected by the timer
const a = await S.join({});
await sleep(300);
assert.equal(a.c.closeInfo, null);
});
});
// ================================================================ commands
test('cmd place: accepted -> next snap carries tw + event; "by" forged by the client is ignored', async () => {
await withServer({}, async (S) => {
const { a, b } = await S.pair();
a.c.send({ t: 'cmd', c: 'place', type: 'filter', x: 5, y: 5, by: 1 }); // forged: claims slot 1
const s1 = await a.c.snap((m) => m.tw);
assert.equal(s1.tw.length, 1);
assert.deepEqual(s1.tw[0].slice(0, 5), [1, 'filter', 5, 5, 1]);
assert.equal(s1.tw[0][7], 0, 'owner is the sender\'s slot (0), not the forged 1');
assert.equal(s1.g, TD.START_GOLD - TD.TOWERS.filter.levels[0].cost);
assert.equal(s1.rev, 1);
const place = s1.ev.find((e) => e.e === 'place');
assert.deepEqual(place, { e: 'place', id: 1, type: 'filter', x: 5, y: 5, by: 0 });
// the other player sees the very same snap content
const s1b = await b.c.snap((m) => m.tw);
assert.equal(s1b.seq, s1.seq);
assert.deepEqual(s1b.tw, s1.tw);
assert.deepEqual(s1b.ev, s1.ev);
b.c.send({ t: 'cmd', c: 'place', type: 'wall', x: 6, y: 6, by: 0 }); // forged the other way round
const s2 = await b.c.snap((m) => m.tw && m.tw.length === 2);
assert.equal(s2.tw.find((t) => t[2] === 6)[7], 1);
assert.equal(s2.ev.find((e) => e.e === 'place').by, 1);
assert.equal(a.c.of('reject').length + b.c.of('reject').length, 0, 'accepted commands send no reject');
});
});
test('cmd rejected -> reject goes to the sender only, echoing x/y/id', async () => {
await withServer({}, async (S) => {
const { a, b } = await S.pair();
a.c.send({ t: 'cmd', c: 'place', type: 'wall', x: 3, y: 3 });
await a.c.snap((m) => m.tw);
b.c.send({ t: 'cmd', c: 'place', type: 'wall', x: 3, y: 3 });
const rj = await b.c.type('reject');
assert.deepEqual(rj, { t: 'reject', c: 'place', reason: 'occupied', x: 3, y: 3 });
b.c.send({ t: 'cmd', c: 'place', type: 'wall', x: 99, y: 1 });
assert.deepEqual(await b.c.type('reject'), { t: 'reject', c: 'place', reason: 'bounds', x: 99, y: 1 });
b.c.send({ t: 'cmd', c: 'place', type: 'nope', x: 1, y: 1 });
assert.equal((await b.c.type('reject')).reason, 'bad_type');
b.c.send({ t: 'cmd', c: 'sell', id: 999 });
assert.deepEqual(await b.c.type('reject'), { t: 'reject', c: 'sell', reason: 'no_tower', id: 999 });
b.c.send({ t: 'cmd', c: 'upgrade', id: 999 });
assert.equal((await b.c.type('reject')).c, 'upgrade');
b.c.send({ t: 'cmd', c: 'target', id: 1, mode: 'bogus' });
assert.equal((await b.c.type('reject')).reason, 'bad_mode');
// run the gold down: 140 - 5 (wall) = 135 -> two IDS (60) fit, the third does not
b.c.send({ t: 'cmd', c: 'place', type: 'ids', x: 10, y: 10 });
b.c.send({ t: 'cmd', c: 'place', type: 'ids', x: 11, y: 10 });
b.c.send({ t: 'cmd', c: 'place', type: 'ids', x: 12, y: 10 });
assert.equal((await b.c.type('reject')).reason, 'gold');
// the sender got every reject; the other player none
await a.c.barrier();
assert.equal(a.c.of('reject').length, 0);
assert.equal(b.c.closeInfo, null, 'rejected commands are not "malformed"');
});
});
test('upgrade / target / sell / auto / continue go through the same path', async () => {
await withServer({}, async (S) => {
const { a } = await S.pair();
a.c.send({ t: 'cmd', c: 'place', type: 'filter', x: 4, y: 4 });
await a.c.snap((m) => m.tw && m.tw.length === 1);
a.c.send({ t: 'cmd', c: 'upgrade', id: 1 });
const up = await a.c.snap((m) => m.tw && m.tw[0][4] === 2);
assert.ok(up.ev.some((e) => e.e === 'up' && e.level === 2));
a.c.send({ t: 'cmd', c: 'target', id: 1, mode: 'strong' });
const tg = await a.c.snap((m) => m.tw && m.tw[0][5] === 'strong');
assert.equal(tg.tw[0][5], 'strong');
a.c.send({ t: 'cmd', c: 'auto', v: true });
const au = await a.c.snap((m) => m.au === 1);
assert.ok(au.nw > 0);
a.c.send({ t: 'cmd', c: 'sell', id: 1 });
const sold = await a.c.snap((m) => m.tw && m.tw.length === 0);
assert.ok(sold.ev.some((e) => e.e === 'sell'));
a.c.send({ t: 'cmd', c: 'continue' });
assert.equal((await a.c.type('reject')).reason, 'not_won');
});
});
test('wave command spawns monsters that appear in snapshots; refused beyond the load cap', async () => {
await withServer({}, async (S) => {
const { a, room } = await S.pair();
a.c.send({ t: 'ctl', c: 'speed', v: 3 });
a.c.send({ t: 'cmd', c: 'wave' });
const w = await a.c.snap((m) => m.ev.some((e) => e.e === 'wave'));
assert.deepEqual(w.ev.find((e) => e.e === 'wave'), { e: 'wave', n: 1, boss: false });
const withMo = await a.c.snap((m) => m.mo.length > 0, 4000);
const mo = withMo.mo[0];
assert.equal(mo.length, 7);
assert.equal(TD.ENEMY_ORDER[mo[1]], 'ping');
assert.ok(withMo.w === 1 && withMo.q >= 0);
// load cap (CPU / bandwidth guard against `wave` spam)
const sim = S.srv.rooms.get(room).sim;
for (let i = 0; i < 1600; i++) sim.spawnQ.push({ t: 1e9, k: 'ping', wave: 1 });
a.c.send({ t: 'cmd', c: 'wave' });
assert.equal((await a.c.type('reject')).reason, 'busy');
assert.equal(sim.wave, 1);
});
});
// ================================================================ snapshots
test('snapshots arrive at ~20 Hz with consecutive seq and the documented fields', async () => {
await withServer({}, async (S) => {
const { a, b } = await S.pair();
await a.c.snap();
const from = a.c.msgs.length;
const t0 = Date.now();
await sleep(1000);
const secs = (Date.now() - t0) / 1000;
const snaps = a.c.of('snap', from);
const hz = snaps.length / secs;
assert.ok(hz > 15 && hz < 25, 'snapshot rate was ' + hz.toFixed(1) + ' Hz');
for (let i = 1; i < snaps.length; i++) assert.equal(snaps[i].seq, snaps[i - 1].seq + 1);
const s = snaps[snaps.length - 1];
for (const k of ['t', 'seq', 'time', 'g', 'l', 'w', 's', 'au', 'nw', 'k', 'rev', 'mo', 'bu', 'tt', 'q', 'ev', 'cur', 'pa', 'sp']) {
assert.ok(k in s, 'snap has ' + k);
}
assert.equal(s.pa, 0);
assert.equal(s.sp, 1);
assert.equal(s.s, 'playing');
assert.ok(!('tw' in s));
// serialised once: both players get identical bytes' worth of content for the same seq
const same = b.c.msgs.find((m) => m.t === 'snap' && m.seq === s.seq);
if (same) assert.deepEqual(same, s);
});
});
test('slow clock check: snapshot rate follows snapshotHz', async () => {
await withServer({ snapshotHz: 10 }, async (S) => {
const { a } = await S.pair();
await a.c.snap();
const from = a.c.msgs.length;
await sleep(1000);
const n = a.c.of('snap', from).length;
assert.ok(n >= 6 && n <= 13, 'got ' + n + ' snaps in 1 s at 10 Hz');
});
});
test('"tw" is attached only when the tower rev changed', async () => {
await withServer({}, async (S) => {
const { a } = await S.pair();
const quiet = async (ms) => {
const from = a.c.msgs.length;
await sleep(ms);
const s = a.c.of('snap', from);
assert.ok(s.length >= 2);
assert.ok(s.every((x) => !('tw' in x)), 'no tw while rev is unchanged');
};
await quiet(300); // from the first snap on: no tw
a.c.send({ t: 'cmd', c: 'place', type: 'filter', x: 2, y: 2 });
await a.c.snap((m) => m.tw);
await quiet(300); // exactly one snap carried it
a.c.send({ t: 'cmd', c: 'place', type: 'filter', x: 2, y: 2 }); // refused: occupied
await a.c.type('reject');
await quiet(200); // a refused command does not bump rev
a.c.send({ t: 'cmd', c: 'target', id: 1, mode: 'last' });
const t = await a.c.snap((m) => m.tw);
assert.equal(t.tw[0][5], 'last');
assert.equal(t.rev, 2);
await quiet(200);
});
});
test('pause stops sim time and speed 2 doubles it (pa / sp reflect the room state)', async () => {
await withServer({}, async (S) => {
const { a, b, room } = await S.pair();
const sim = () => S.srv.rooms.get(room).sim;
const rate = async (c) => { // game seconds per wall second, from snapshot arrival times
await c.snap();
const from = c.msgs.length;
await sleep(900);
const idx = c.msgs.map((m, i) => (i >= from && m.t === 'snap' ? i : -1)).filter((i) => i >= 0);
const f = idx[0], l = idx[idx.length - 1];
return (c.msgs[l].time - c.msgs[f].time) / ((c.rx[l] - c.rx[f]) / 1000);
};
const r1 = await rate(a.c);
assert.ok(r1 > 0.8 && r1 < 1.2, 'speed 1 ran at ' + r1.toFixed(2) + 'x');
b.c.send({ t: 'ctl', c: 'speed', v: 2 }); // either player may change the room speed
const s2 = await a.c.snap((m) => m.sp === 2);
assert.equal(s2.sp, 2);
const r2 = await rate(a.c);
assert.ok(r2 > 1.6 && r2 < 2.4, 'speed 2 ran at ' + r2.toFixed(2) + 'x');
a.c.send({ t: 'ctl', c: 'pause', v: true });
const p = await a.c.snap((m) => m.pa === 1);
assert.equal(p.sp, 2);
const frozen = sim().time;
await sleep(350);
const later = a.c.msgs[a.c.msgs.length - 1];
assert.equal(later.t, 'snap', 'paused rooms keep sending snapshots');
assert.equal(later.pa, 1);
assert.equal(later.time, p.time);
assert.equal(sim().time, frozen);
// building while paused still works
a.c.send({ t: 'cmd', c: 'place', type: 'wall', x: 8, y: 8 });
assert.ok((await a.c.snap((m) => m.tw)).tw.length === 1);
a.c.send({ t: 'ctl', c: 'pause', v: false });
await a.c.snap((m) => m.pa === 0);
await sleep(300);
assert.ok(sim().time > frozen + 0.3, 'time advances again after unpausing');
// a late joiner / sync sees the current values
a.c.send({ t: 'sync' });
const st = await a.c.type('state');
assert.equal(st.speed, 2);
assert.equal(st.paused, false);
});
});
test('the sim only ticks while somebody is online; nothing is fast-forwarded on return', async () => {
await withServer({ graceMs: 1500 }, async (S) => {
const a = await S.join({});
const room = S.srv.rooms.get(a.r.room);
await sleep(200);
assert.ok(room.sim.time > 0.1);
a.c.ws.terminate();
await until(() => room.players[0].conn === null, 2000, 'server to notice the disconnect');
const t0 = room.sim.time;
await sleep(400);
assert.equal(room.sim.time, t0);
const back = await S.join({ pid: a.pid, room: a.r.room });
assert.equal(back.r.resumed, true);
assert.ok(back.r.snap.time - t0 < 0.1, 'no catch-up for the time spent offline');
await sleep(300);
assert.ok(room.sim.time > t0 + 0.2);
});
});
test('rooms are independent and several run at once', async () => {
await withServer({}, async (S) => {
const a = await S.join({ name: 'A' });
const b = await S.join({ name: 'B', map: 'hub' });
assert.notEqual(a.r.room, b.r.room);
a.c.send({ t: 'cmd', c: 'place', type: 'wall', x: 1, y: 1 });
await a.c.snap((m) => m.tw);
await b.c.snap();
await sleep(150);
assert.ok(b.c.of('snap').every((s) => !s.tw && s.g === TD.START_GOLD), 'room B is untouched by room A');
assert.equal(S.srv.rooms.get(b.r.room).sim.mapId, 'hub');
assert.ok(S.srv.rooms.get(a.r.room).sim.time > 0 && S.srv.rooms.get(b.r.room).sim.time > 0);
});
});
// ================================================================ cursor / mark / rtt / sync
test('cursor relay: clamped, rounded to 2 dp, cleared by x:null; included for all players', async () => {
await withServer({}, async (S) => {
const { a, b } = await S.pair();
a.c.send({ t: 'cursor', x: 3.14159, y: 2.5 });
const s = await b.c.snap((m) => curOf(m, 0));
assert.deepEqual(curOf(s, 0), [0, 3.14, 2.5]);
const own = await a.c.snap((m) => curOf(m, 0)); // the sender sees it too (one payload per room)
assert.deepEqual(curOf(own, 0), [0, 3.14, 2.5]);
b.c.send({ t: 'cursor', x: 7.777, y: 1 });
const both = await a.c.snap((m) => curOf(m, 0) && curOf(m, 1));
assert.deepEqual(curOf(both, 1), [1, 7.78, 1]);
const cols = TD.MAPS.open.rows[0].length, rows = TD.MAPS.open.rows.length;
a.c.send({ t: 'cursor', x: 999, y: -4 });
const cl = await b.c.snap((m) => { const c = curOf(m, 0); return c && c[1] === cols; });
assert.deepEqual(curOf(cl, 0), [0, cols, 0]);
a.c.send({ t: 'cursor', x: -1, y: 1e9 });
const cl2 = await b.c.snap((m) => { const c = curOf(m, 0); return c && c[2] === rows; });
assert.deepEqual(curOf(cl2, 0), [0, 0, rows]);
a.c.send({ t: 'cursor', x: null });
const hidden = await b.c.snap((m) => !curOf(m, 0));
assert.deepEqual(hidden.cur, [[1, 7.78, 1]]);
// a cursor disappears when its owner goes offline
b.c.ws.terminate();
const gone = await a.c.snap((m) => m.cur.length === 0);
assert.deepEqual(gone.cur, []);
});
});
test('mark relay goes to everyone incl. the sender, at most 1 per 400 ms per player', async () => {
await withServer({}, async (S) => {
const { a, b } = await S.pair();
a.c.send({ t: 'mark', x: 4.5, y: 6.25 });
const ma = await a.c.type('mark');
const mb = await b.c.type('mark');
assert.deepEqual(ma, { t: 'mark', slot: 0, x: 4.5, y: 6.25 });
assert.deepEqual(mb, ma);
for (let i = 0; i < 6; i++) a.c.send({ t: 'mark', x: i, y: i }); // all inside the window: dropped
b.c.send({ t: 'mark', x: 1, y: 1 }); // the other player has their own budget
const mb2 = await a.c.type('mark');
assert.equal(mb2.slot, 1);
await a.c.barrier();
await b.c.barrier();
assert.equal(a.c.of('mark').length, 2, 'one mark from each player, the burst was dropped');
assert.equal(a.c.closeInfo, null, 'dropped marks are rate limiting, not malformed input');
await sleep(450);
a.c.send({ t: 'mark', x: 9, y: 9 });
const late = await a.c.next((m) => m.t === 'mark' && m.slot === 0 && m.x === 9);
assert.equal(late.y, 9);
});
});
test('rtt echoes ts immediately; sync returns the full state', async () => {
await withServer({}, async (S) => {
const { a } = await S.pair();
a.c.send({ t: 'rtt', ts: 12345.678 });
assert.deepEqual(await a.c.type('rtt'), { t: 'rtt', ts: 12345.678 });
a.c.send({ t: 'cmd', c: 'place', type: 'wall', x: 7, y: 7 });
await a.c.snap((m) => m.tw);
a.c.send({ t: 'sync' });
const st = await a.c.type('state');
assert.equal(st.state.map, 'open');
assert.equal(st.state.rev, 1);
assert.equal(st.state.towers.length, 1);
assert.equal(st.snap.rev, 1);
assert.equal(st.speed, 1);
assert.equal(st.paused, false);
assert.ok(!('newgame' in st));
});
});
// ================================================================ newgame / host / leave / reconnect
test('newgame is host-only; host migrates when the host leaves', async () => {
await withServer({}, async (S) => {
const { a, b, room } = await S.pair();
a.c.send({ t: 'cmd', c: 'place', type: 'wall', x: 2, y: 2 });
a.c.send({ t: 'ctl', c: 'speed', v: 3 });
a.c.send({ t: 'ctl', c: 'pause', v: true });
await a.c.snap((m) => m.rev === 1 && m.pa === 1 && m.sp === 3);
b.c.send({ t: 'newgame', map: 'twin' });
assert.deepEqual(await b.c.type('reject'), { t: 'reject', c: 'newgame', reason: 'not_host' });
await a.c.barrier();
assert.equal(a.c.of('reject').length, 0);
assert.equal(S.srv.rooms.get(room).sim.mapId, 'open');
a.c.send({ t: 'newgame', map: 'nope' });
assert.deepEqual(await a.c.type('reject'), { t: 'reject', c: 'newgame', reason: 'bad_map' });
a.c.send({ t: 'newgame', map: 'twin' });
for (const c of [a.c, b.c]) {
const st = await c.type('state');
assert.equal(st.newgame, true);
assert.equal(st.state.map, 'twin');
assert.deepEqual(st.state.towers, []);
assert.equal(st.snap.g, TD.START_GOLD);
assert.equal(st.snap.time, 0);
assert.equal(st.speed, 1);
assert.equal(st.paused, false);
}
const after = await b.c.snap((m) => m.pa === 0 && m.sp === 1);
assert.equal(after.rev, 0);
assert.ok(!('tw' in after));
a.c.send({ t: 'newgame' }); // no map: restart the current one
assert.equal((await b.c.type('state')).state.map, 'twin');
// host leaves for good -> the other player becomes host and may now start games
a.c.send({ t: 'leave' });
assert.equal((await a.c.closed()).code, 1000);
const pl = await b.c.next((m) => m.t === 'players' && m.players.length === 1);
assert.deepEqual(pl.players.map((p) => [p.slot, p.host, p.online]), [[1, true, true]]);
b.c.send({ t: 'newgame', map: 'hub' });
assert.equal((await b.c.type('state')).state.map, 'hub');
assert.equal(b.c.of('reject').filter((r) => r.reason === 'not_host').length, 1);
// slots are reused: a newcomer takes the lowest free one (0) and is not host
const c = await S.join({ name: 'Carol', room });
assert.deepEqual(c.r.you, { pid: c.pid, slot: 0, host: false });
});
});
test('host migration also happens when the host\'s grace period expires', async () => {
await withServer({ graceMs: 250 }, async (S) => {
const { a, b } = await S.pair();
a.c.ws.terminate();
const off = await b.c.next((m) => m.t === 'players' && m.players.some((p) => !p.online));
assert.deepEqual(off.players.map((p) => [p.slot, p.host, p.online]), [[0, true, false], [1, false, true]]);
const gone = await b.c.next((m) => m.t === 'players' && m.players.length === 1, 2000);
assert.deepEqual(gone.players.map((p) => [p.slot, p.host, p.online]), [[1, true, true]]);
});
});
test('reconnect with the same pid resumes within grace; the old socket is closed with 4001', async () => {
await withServer({ graceMs: 5000 }, async (S) => {
const { a, b, room } = await S.pair();
a.c.send({ t: 'cmd', c: 'place', type: 'wall', x: 2, y: 2 });
await a.c.snap((m) => m.tw);
// (1) a second connection while the first is still open
const a2 = await S.join({ pid: a.pid, room, name: 'Alice2' });
assert.equal(a2.r.t, 'joined');
assert.equal(a2.r.resumed, true);
assert.deepEqual(a2.r.you, { pid: a.pid, slot: 0, host: true });
assert.equal(a2.r.state.towers.length, 1, 'the resumed player gets the current state');
assert.equal((await a.c.closed()).code, 4001);
const pl = await b.c.next((m) => m.t === 'players' && m.players[0].name === 'Alice2');
assert.ok(pl.players.every((p) => p.online));
await a2.c.snap();
// (2) the socket dies, the player is held offline, then comes back
a2.c.ws.terminate();
const off = await b.c.next((m) => m.t === 'players' && !m.players[0].online);
assert.equal(off.players[0].pid, b.r.players[0].pid, 'the host keeps the same alias in b\'s lists');
assert.notEqual(off.players[0].pid, a.pid);
assert.equal(off.players.length, 2);
const a3 = await S.join({ pid: a.pid, room });
assert.equal(a3.r.resumed, true);
assert.equal(a3.r.you.slot, 0);
assert.equal(a3.r.you.host, true);
const on = await b.c.next((m) => m.t === 'players' && m.players[0].online);
assert.equal(on.players.length, 2);
// the offline period never freed the slot: a stranger still gets 'full'
const c = await S.join({ room });
assert.equal(c.r.code, 'full');
});
});
test('a pid that is offline for longer than graceMs loses its slot; an empty room is deleted', async () => {
await withServer({ graceMs: 250 }, async (S) => {
const { a, b, room } = await S.pair();
b.c.ws.terminate();
const off = await a.c.next((m) => m.t === 'players' && m.players.some((p) => !p.online));
assert.equal(off.players.length, 2);
await sleep(120);
assert.equal(S.srv.rooms.get(room).players.filter(Boolean).length, 2, 'still held inside the grace period');
const gone = await a.c.next((m) => m.t === 'players' && m.players.length === 1, 2000);
assert.equal(gone.players[0].pid, a.pid);
// coming back after the grace period is a fresh join into the lowest free slot
const b2 = await S.join({ pid: b.pid, room });
assert.equal(b2.r.resumed, false);
assert.equal(b2.r.you.slot, 1);
assert.equal(b2.r.you.host, false);
// everyone leaves: room deleted at once for 'leave', after the grace period for a dropped socket
a.c.send({ t: 'leave' });
await a.c.closed();
assert.ok(S.srv.rooms.has(room));
b2.c.ws.terminate();
await sleep(100);
assert.ok(S.srv.rooms.has(room), 'room survives while its last player is within the grace period');
await until(() => !S.srv.rooms.has(room), 2000, 'room deletion after grace');
const lost = await S.join({ room });
assert.equal(lost.r.code, 'no_room');
});
});
test('leave deletes the room at once when the last player goes', async () => {
await withServer({}, async (S) => {
const a = await S.join({});
assert.equal(S.srv.rooms.size, 1);
a.c.send({ t: 'leave' });
assert.equal((await a.c.closed()).code, 1000);
await until(() => S.srv.rooms.size === 0, 1000, 'room deletion');
// and the loop is idle again: creating a room works from a clean slate
const b = await S.join({});
assert.equal(b.r.t, 'joined');
await b.c.snap();
});
});
// ================================================================ malformed input / limits
test('malformed messages are counted: the 20th is tolerated, the 21st closes with 4400', async () => {
await withServer({}, async (S) => {
const { a } = await S.pair();
const junk = [
() => a.c.raw('not json'),
() => a.c.raw('[]'),
() => a.c.raw('"str"'),
() => a.c.raw('{}'),
() => a.c.send({ t: 'bogus' }),
() => a.c.send({ t: 'cmd', c: 'nope' }),
() => a.c.send({ t: 'cmd' }),
() => a.c.send({ t: 'ctl', c: 'speed', v: 9 }),
() => a.c.send({ t: 'cursor', x: 'a', y: 1 }),
() => a.c.ws.send(Buffer.from([1, 2, 3])), // binary frame
];
for (let round = 0; round < 2; round++) for (const f of junk) f(); // 20 in total
await a.c.barrier(); // still alive: the 20th is tolerated
assert.equal(a.c.closeInfo, null);
a.c.raw('x'); // the 21st
assert.equal((await a.c.closed()).code, 4400);
// a second join on an already joined socket is malformed too
const b = await S.join({});
for (let i = 0; i < 20; i++) b.c.send({ t: 'join', pid: newPid() });
await b.c.barrier();
assert.equal(b.c.closeInfo, null);
b.c.send({ t: 'join', pid: newPid() });
assert.equal((await b.c.closed()).code, 4400);
});
});
test('oversize frames (> 2048 bytes) close the socket with 1009; exactly 2048 bytes is fine', async () => {
await withServer({}, async (S) => {
const { a } = await S.pair();
const base = JSON.stringify({ t: 'rtt', ts: 1, pad: '' });
const exact = JSON.stringify({ t: 'rtt', ts: 1, pad: 'x'.repeat(2048 - Buffer.byteLength(base)) });
assert.equal(Buffer.byteLength(exact), 2048);
a.c.raw(exact);
assert.equal((await a.c.type('rtt')).ts, 1);
a.c.raw('x'.repeat(3000));
assert.equal((await a.c.closed()).code, 1009);
// the server and the room survived
const b = await S.join({});
assert.equal(b.r.t, 'joined');
});
});
test('per-socket rate limit: a burst well over 120 messages closes with 4429, normal traffic does not', async () => {
await withServer({}, async (S) => {
const ok = await S.join({});
for (let i = 0; i < 100; i++) ok.c.send({ t: 'rtt', ts: i });
await until(() => ok.c.of('rtt').length === 100, 3000, '100 echoes');
assert.equal(ok.c.closeInfo, null);
const bad = await S.join({});
for (let i = 0; i < 400; i++) bad.c.send({ t: 'rtt', ts: i });
assert.equal((await bad.c.closed()).code, 4429);
assert.ok(bad.c.of('rtt').length < 400, 'the server stopped answering');
// another player is not affected
await ok.c.barrier();
// the room of the offender remains (grace), the offender is just offline
const room = S.srv.rooms.get(bad.r.room);
await until(() => room.players[0].conn === null, 1000, 'offender offline');
});
});
test('a crash inside one room (or one message handler) does not take the server or other rooms down', async () => {
await withServer({}, async (S) => {
const good = await S.join({ name: 'good' });
const bad = await S.join({ name: 'bad' });
const bad2 = await S.join({ name: 'bad2' });
// (1) the sim of one room throws while stepping
S.srv.rooms.get(bad.r.room).sim.tick = () => { throw new Error('boom (test)'); };
const e = await bad.c.type('error');
assert.equal(e.code, 'server_error');
assert.equal((await bad.c.closed()).code, 1011);
await until(() => !S.srv.rooms.has(bad.r.room), 1000, 'crashed room removed');
// (2) a handler throws for one socket
S.srv.rooms.get(bad2.r.room).handleMessage = () => { throw new Error('boom 2 (test)'); };
bad2.c.send({ t: 'rtt', ts: 1 });
assert.equal((await bad2.c.closed()).code, 1011);
// everybody else is fine
await good.c.snap();
const t0 = good.c.msgs.length;
await sleep(200);
assert.ok(good.c.of('snap', t0).length >= 2, 'the other room keeps getting snapshots');
const again = await S.join({});
assert.equal(again.r.t, 'joined');
});
});
test('a client that falls hopelessly behind (huge send backlog) is dropped and can resume', async () => {
await withServer({ graceMs: 3000 }, async (S) => {
const { a, b, room } = await S.pair();
const slow = S.srv.rooms.get(room).players[1].conn.ws;
Object.defineProperty(slow, 'bufferedAmount', { get: () => 10 * 1024 * 1024 }); // pretend the socket is backed up
assert.equal((await b.c.closed()).code, 1006, 'terminated rather than silently losing tw/ev data');
const off = await a.c.next((m) => m.t === 'players' && !m.players[1].online);
assert.equal(off.players[1].name, 'Bob');
assert.notEqual(off.players[1].pid, b.pid);
const b2 = await S.join({ pid: b.pid, room });
assert.equal(b2.r.resumed, true);
await b2.c.snap();
assert.equal(a.c.closeInfo, null);
});
});
// ================================================================ keep-alive
test('keep-alive: a socket that never pongs is terminated, one that does stays', async () => {
await withServer({ pingMs: 100, graceMs: 3000 }, async (S) => {
const good = await S.join({ name: 'good' });
const dead = await S.join({ name: 'dead', room: good.r.room, wsOpts: { autoPong: false } });
await good.c.next((m) => m.t === 'players' && m.players.length === 2);
const t0 = Date.now();
const cl = await dead.c.closed(2000);
assert.equal(cl.code, 1006, 'terminated without a close frame');
assert.ok(dead.c.pings >= 1, 'it did receive a protocol ping first');
assert.ok(Date.now() - t0 < 1200);
const off = await good.c.next((m) => m.t === 'players' && m.players.some((p) => !p.online));
assert.equal(off.players.find((p) => !p.online).name, 'dead');
await sleep(350); // several more rounds
assert.equal(good.c.closeInfo, null);
assert.ok(good.c.pings >= 3, 'got ' + good.c.pings + ' pings');
await good.c.barrier();
});
});
// ================================================================ origin / proxy
test('Origin check: same host ok, no Origin ok, foreign origin 403, "null" 403, wrong path 404', async () => {
await withServer({}, async (S) => {
const host = '127.0.0.1:' + S.port;
assert.equal((await probe(S.url)).ok, true, 'no Origin');
assert.equal((await probe(S.url, { origin: 'http://' + host })).ok, true, 'same host');
assert.equal((await probe(S.url + '?x=1', { origin: 'http://' + host })).ok, true, 'query string is ignored');
assert.equal((await probe(S.url, { origin: 'http://evil.example' })).status, 403);
assert.equal((await probe(S.url, { origin: 'http://127.0.0.1:' + (S.port === 65535 ? 1 : S.port + 1) })).status, 403, 'different port');
assert.equal((await probe(S.url, { origin: 'null' })).status, 403);
assert.equal((await probe(S.url, { origin: 'garbage' })).status, 403);
assert.equal((await probe('ws://127.0.0.1:' + S.port + '/nope')).status, 404);
assert.equal((await probe('ws://127.0.0.1:' + S.port + '/ws/')).status, 404);
assert.equal((await probe('ws://127.0.0.1:' + S.port + '/')).status, 404);
});
});
test('refused upgrades are plain HTTP responses with the security headers', async () => {
await withServer({}, async (S) => {
const send = (extra) => rawHttp(S.port, 'GET /ws HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n' +
'Sec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n' + extra + '\r\n');
const r = await send('Origin: http://evil.example\r\n');
assert.match(r, /^HTTP\/1\.1 403 Forbidden\r\n/);
assert.match(r, /X-Content-Type-Options: nosniff/i);
assert.match(r, /Referrer-Policy: no-referrer/i);
assert.match(r, /Content-Security-Policy: default-src 'self'; connect-src 'self' ws: wss:/i);
const nf = await rawHttp(S.port, 'GET /elsewhere HTTP/1.1\r\nHost: x\r\nConnection: Upgrade\r\nUpgrade: websocket\r\nSec-WebSocket-Version: 13\r\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n');
assert.match(nf, /^HTTP\/1\.1 404 Not Found\r\n/);
assert.match(nf, /X-Content-Type-Options: nosniff/i);
});
});
test('Origin check behind a proxy: Host/Origin default ports, X-Forwarded-Host (trusted proxy only), allowedOrigins', async () => {
// Host header rewritten by a proxy: https://game.example.com -> Host: game.example.com
await withServer({}, async (S) => {
assert.equal((await probe(S.url, { headers: { Host: 'game.example.com' }, origin: 'https://game.example.com' })).ok, true);
assert.equal((await probe(S.url, { headers: { Host: 'game.example.com' }, origin: 'https://GAME.Example.com:443' })).ok, true);
assert.equal((await probe(S.url, { headers: { Host: 'game.example.com:80' }, origin: 'http://game.example.com' })).ok, true);
assert.equal((await probe(S.url, { headers: { Host: 'game.example.com' }, origin: 'https://other.example.com' })).status, 403);
// proxy kept the upstream Host but sends X-Forwarded-Host: the peer is loopback -> trusted under 'auto'
const xfh = { 'X-Forwarded-Host': 'game.example.com', 'X-Forwarded-Proto': 'https' };
assert.equal((await probe(S.url, { headers: xfh, origin: 'https://game.example.com' })).ok, true);
assert.equal((await probe(S.url, { headers: { 'X-Forwarded-Host': 'game.example.com, inner.local' }, origin: 'https://game.example.com' })).ok, true, 'first entry');
assert.equal((await probe(S.url, { headers: { 'X-Forwarded-Host': 'inner.local, game.example.com' }, origin: 'https://game.example.com' })).status, 403, 'only the first entry counts');
assert.equal((await probe(S.url, { headers: xfh, origin: 'https://evil.example' })).status, 403);
});
await withServer({ trustProxy: false }, async (S) => {
assert.equal((await probe(S.url, { headers: { 'X-Forwarded-Host': 'game.example.com' }, origin: 'https://game.example.com' })).status, 403,
'X-Forwarded-Host is ignored when the proxy is not trusted');
});
await withServer({ trustProxy: true }, async (S) => {
assert.equal((await probe(S.url, { headers: { 'X-Forwarded-Host': 'game.example.com' }, origin: 'https://game.example.com' })).ok, true);
});
await withServer({ allowedOrigins: ['https://game.example.com', 'play.example.org:8443'], trustProxy: false }, async (S) => {
assert.equal((await probe(S.url, { origin: 'https://game.example.com' })).ok, true);
assert.equal((await probe(S.url, { origin: 'https://GAME.example.com' })).ok, true);
assert.equal((await probe(S.url, { origin: 'https://play.example.org:8443' })).ok, true);
assert.equal((await probe(S.url, { origin: 'https://play.example.org' })).status, 403);
assert.equal((await probe(S.url, { origin: 'https://evil.example' })).status, 403);
});
});
test('net helpers: normalizeHost / originAllowed / isPrivateIp / forwarded ip', () => {
assert.equal(netx.normalizeHost('Example.COM:443'), 'example.com');
assert.equal(netx.normalizeHost('example.com:80'), 'example.com');
assert.equal(netx.normalizeHost('https://example.com:443'), 'example.com');
assert.equal(netx.normalizeHost('http://example.com:8080'), 'example.com:8080');
assert.equal(netx.normalizeHost('[::1]:8080'), '[::1]:8080');
assert.equal(netx.normalizeHost('[::1]'), '[::1]');
assert.equal(netx.normalizeHost('a b'), null);
assert.equal(netx.normalizeHost('a/b'), null);
assert.equal(netx.normalizeHost(''), null);
assert.equal(netx.normalizeHost(undefined), null);
const req = (h, peer) => ({ headers: h, socket: { remoteAddress: peer || '::ffff:127.0.0.1' } });
const o = { trustProxy: 'auto', allowedOrigins: [] };
assert.equal(netx.originAllowed(req({ host: 'a.b' }), o), true);
assert.equal(netx.originAllowed(req({ host: 'a.b', origin: 'https://a.b' }), o), true);
assert.equal(netx.originAllowed(req({ host: 'a.b', origin: 'https://c.d' }), o), false);
assert.equal(netx.originAllowed(req({ host: 'a.b', origin: '' }), o), false);
// X-Forwarded-Host from a public peer is not believed under 'auto'
assert.equal(netx.originAllowed(req({ host: 'x', origin: 'https://c.d', 'x-forwarded-host': 'c.d' }, '203.0.113.9'), o), false);
assert.equal(netx.originAllowed(req({ host: 'x', origin: 'https://c.d', 'x-forwarded-host': 'c.d' }, '10.1.2.3'), o), true);
for (const ip of ['127.0.0.1', '::ffff:127.0.0.1', '10.0.0.5', '172.16.0.1', '172.31.255.1', '192.168.1.1', '169.254.1.1',
'::1', 'fc00::1', 'fd12:3456::1', 'fe80::1', 'fe80::1%eth0', '::ffff:192.168.0.9']) assert.equal(netx.isPrivateIp(ip), true, ip);
for (const ip of ['8.8.8.8', '172.32.0.1', '172.15.0.1', '192.169.0.1', '203.0.113.9', '2001:db8::1', '2a0a:3e40::1', 'fec0::1', '::ffff:8.8.8.8', 'not an ip', '']) {
assert.equal(netx.isPrivateIp(ip), false, ip);
}
assert.equal(netx.normalizeIp('::ffff:1.2.3.4'), '1.2.3.4');
assert.equal(netx.normalizeIp('FE80::1%eth0'), 'fe80::1');
assert.equal(netx.firstForwardedIp('203.0.113.9, 10.0.0.2'), '203.0.113.9');
assert.equal(netx.firstForwardedIp(' [2001:db8::5]:1234 , x'), '2001:db8::5');
assert.equal(netx.firstForwardedIp('203.0.113.9:5555'), '203.0.113.9');
assert.equal(netx.firstForwardedIp('::ffff:203.0.113.9'), '203.0.113.9');
assert.equal(netx.firstForwardedIp('unknown'), null);
assert.equal(netx.firstForwardedIp(undefined), null);
assert.equal(netx.parseTrustProxy(undefined), 'auto');
assert.equal(netx.parseTrustProxy('1'), true);
assert.equal(netx.parseTrustProxy('0'), false);
assert.equal(netx.parseTrustProxy('AUTO'), 'auto');
assert.throws(() => netx.parseTrustProxy('maybe'));
});
test('client ip: X-Forwarded-For / X-Real-IP are used only when the peer is a private/loopback proxy (or forced)', () => {
const req = (peer, h) => ({ headers: h || {}, socket: { remoteAddress: peer } });
const xff = { 'x-forwarded-for': '198.51.100.7, 10.0.0.2' };
assert.equal(netx.clientIp(req('::ffff:127.0.0.1', xff), 'auto'), '198.51.100.7');
assert.equal(netx.clientIp(req('192.168.1.10', xff), 'auto'), '198.51.100.7');
assert.equal(netx.clientIp(req('fd00::10', xff), 'auto'), '198.51.100.7');
assert.equal(netx.clientIp(req('::1', { 'x-real-ip': '198.51.100.8' }), 'auto'), '198.51.100.8');
assert.equal(netx.clientIp(req('::1', { 'x-forwarded-for': 'junk', 'x-real-ip': '198.51.100.8' }), 'auto'), '198.51.100.8');
assert.equal(netx.clientIp(req('::1', { 'x-forwarded-for': 'junk' }), 'auto'), '::1');
assert.equal(netx.clientIp(req('203.0.113.5', xff), 'auto'), '203.0.113.5', 'public peer: headers ignored');
assert.equal(netx.clientIp(req('::ffff:203.0.113.5', xff), 'auto'), '203.0.113.5');
assert.equal(netx.clientIp(req('203.0.113.5', xff), true), '198.51.100.7', 'forced on');
assert.equal(netx.clientIp(req('127.0.0.1', xff), false), '127.0.0.1', 'forced off');
assert.equal(netx.clientIp(req('127.0.0.1', {}), 'auto'), '127.0.0.1');
});
test('client ip: proxies append to X-Forwarded-For, so the left part is the client\'s own claim and is not believed', () => {
const req = (peer, h) => ({ headers: h || {}, socket: { remoteAddress: peer } });
const ip = (xff, peer, mode) => netx.clientIp(req(peer || '127.0.0.1', { 'x-forwarded-for': xff }), mode || 'auto');
// nginx proxy manager: the client sent "203.0.113.50"; the proxy appended the address it really saw
assert.equal(ip('203.0.113.50, 198.51.100.66'), '198.51.100.66');
assert.equal(ip('203.0.113.50, 198.51.100.66', '203.0.113.9', true), '198.51.100.66', 'also when forced on');
assert.equal(ip('203.0.113.50, 198.51.100.66, 10.0.0.2'), '198.51.100.66', 'own (private) hops are skipped');
assert.equal(ip('203.0.113.50, 198.51.100.66, 172.17.0.1, fd00::2'), '198.51.100.66');
assert.equal(ip('2001:db8::1, [2001:db8::99]:4000'), '2001:db8::99');
assert.equal(ip('198.51.100.7'), '198.51.100.7');
// LAN clients: private all the way -> what the nearest proxy saw, never the (forgeable) left end
assert.equal(ip('10.9.9.9, 192.168.1.5'), '192.168.1.5');
assert.equal(ip('192.168.1.5'), '192.168.1.5');
assert.equal(ip('junk, 10.0.0.2'), '10.0.0.2');
// junk where the proxy's entry should be: believe nothing from the header
assert.equal(ip('203.0.113.50, junk'), '127.0.0.1');
assert.equal(ip('unknown'), '127.0.0.1');
assert.equal(netx.forwardedClientIp('1.2.3.4, 5.6.7.8'), '5.6.7.8');
assert.equal(netx.forwardedClientIp(undefined), null);
assert.equal(netx.forwardedClientIp(''), null);
});
test('per-IP cap: a forged left part of X-Forwarded-For can neither dodge the cap nor use up somebody else\'s', async () => {
await withServer({ maxConnPerIp: 2 }, async (S) => {
// what nginx proxy manager forwards when a client itself sent "X-Forwarded-For: <claim>": "<claim>, <real address>"
const via = (claim) => ({ headers: { 'X-Forwarded-For': claim + ', 198.51.100.66' } });
const mallory1 = S.client(via('203.0.113.50')); await mallory1.open();
const mallory2 = S.client(via('203.0.113.50')); await mallory2.open();
assert.equal((await probe(S.url, via('192.0.2.1'))).status, 429, 'forging another address does not escape the cap');
assert.equal((await probe(S.url, via('192.0.2.2'))).status, 429);
// the address Mallory claimed was never charged: its real owner (the proxy sends just their address) connects fine
const victim = S.client({ headers: { 'X-Forwarded-For': '203.0.113.50' } });
await victim.open();
assert.equal(victim.opened, true);
});
});
test('start-up banner: os.networkInterfaces() throwing (restricted sandbox) does not matter', () => {
const real = os.networkInterfaces;
os.networkInterfaces = () => { throw new Error('A system error occurred: uv_interface_addresses returned Unknown system error 13'); };
try {
assert.deepEqual(netx.listUrls('::', 8080), ['http://localhost:8080/']);
assert.deepEqual(netx.listUrls('0.0.0.0', 8080), ['http://localhost:8080/']);
} finally { os.networkInterfaces = real; }
});
test('per-IP socket cap uses X-Forwarded-For behind a private/loopback peer; 429 on upgrade', async () => {
await withServer({ maxConnPerIp: 2 }, async (S) => {
const h = (ip) => ({ headers: { 'X-Forwarded-For': ip + ', 10.9.9.9' } });
const a1 = S.client(h('198.51.100.1')); await a1.open();
const a2 = S.client(h('198.51.100.1')); await a2.open();
assert.equal((await probe(S.url, h('198.51.100.1'))).status, 429, 'third socket for the same client ip');
assert.equal((await probe(S.url, h('198.51.100.2'))).ok, true, 'another client ip behind the same proxy is fine');
assert.equal((await probe(S.url, h('2001:db8::1'))).ok, true);
// closing frees the budget again
a1.ws.terminate();
let freed = false;
for (let i = 0; i < 100 && !freed; i++) { freed = (await probe(S.url, h('198.51.100.1'))).ok; if (!freed) await sleep(10); }
assert.ok(freed, 'cap released after a socket closed');
});
await withServer({ maxConnPerIp: 2, trustProxy: false }, async (S) => {
const h = (ip) => ({ headers: { 'X-Forwarded-For': ip } });
const [c1, c2] = [S.client(h('198.51.100.3')), S.client(h('198.51.100.4'))];
await c1.open(); await c2.open();
assert.equal((await probe(S.url, h('198.51.100.5'))).status, 429, 'spoofed headers are ignored: all sockets are 127.0.0.1');
});
await withServer({ maxConnPerIp: 0 }, async (S) => {
const cs = [];
for (let i = 0; i < 6; i++) { const c = S.client(); await c.open(); cs.push(c); }
assert.equal(cs.length, 6, 'cap disabled');
});
});
// ================================================================ dual stack
test('listenDual: IPv6 fallback logic (stub server)', async () => {
const stub = (failWith) => {
const s = new EventEmitter();
s.calls = [];
s.listen = (opts) => {
s.calls.push(opts);
setImmediate(() => {
if (failWith && opts.host === '::') s.emit('error', Object.assign(new Error(failWith), { code: failWith }));
else s.emit('listening');
});
};
return s;
};
for (const code of ['EAFNOSUPPORT', 'EADDRNOTAVAIL', 'EPROTONOSUPPORT']) {
const s = stub(code); const logs = [];
assert.equal(await netx.listenDual(s, 1234, '::', (m) => logs.push(m)), '0.0.0.0');
assert.deepEqual(s.calls, [{ port: 1234, host: '::', ipv6Only: false }, { port: 1234, host: '0.0.0.0' }]);
assert.match(logs.join('\n'), /IPv6.*0\.0\.0\.0/);
assert.equal(s.listenerCount('error'), 0, 'no listener leaks');
assert.equal(s.listenerCount('listening'), 0);
}
const ok = stub(null);
assert.equal(await netx.listenDual(ok, 1, '::', noop), '::');
assert.deepEqual(ok.calls, [{ port: 1, host: '::', ipv6Only: false }], 'dual stack requested with ipv6Only:false');
// an address already in use is an error, not a reason to fall back
const busy = stub('EADDRINUSE');
await assert.rejects(() => netx.listenDual(busy, 1, '::', noop), { code: 'EADDRINUSE' });
assert.equal(busy.calls.length, 1);
// explicit hosts are honoured as given, never replaced
const explicit = stub('EAFNOSUPPORT');
assert.equal(await netx.listenDual(explicit, 5, '127.0.0.1', noop), '127.0.0.1');
assert.deepEqual(explicit.calls, [{ port: 5, host: '127.0.0.1' }]);
const v4 = stub(null);
assert.equal(await netx.listenDual(v4, 5, '0.0.0.0', noop), '0.0.0.0');
});
test('EADDRINUSE on a real port rejects createServer', async () => {
const blocker = net.createServer();
await new Promise((r) => blocker.listen(0, '127.0.0.1', r));
try {
await assert.rejects(() => createServer({ port: blocker.address().port, host: '127.0.0.1', log: noop }), { code: 'EADDRINUSE' });
} finally { await new Promise((r) => blocker.close(r)); }
});
test('dual stack: a "::" server answers on 127.0.0.1 and ::1 (skipped without IPv6)', async (t) => {
const v6 = await new Promise((res) => { const s = net.createServer(); s.once('error', () => res(false)); s.listen(0, '::1', () => s.close(() => res(true))); });
const dflt = await createServer({ port: 0, log: noop, pingMs: 0 }); // default host
try {
assert.ok(['::', '0.0.0.0'].includes(dflt.addresses[0]), 'default host is :: (or the logged IPv4 fallback)');
if (v6) assert.deepEqual(dflt.addresses, ['::']);
} finally { await dflt.close(); }
if (!v6) { t.skip('IPv6 loopback is not available in this environment'); return; }
await withServer({ host: '::' }, async (S) => {
assert.deepEqual(S.srv.addresses, ['::']);
for (const [host, wsHost] of [['127.0.0.1', '127.0.0.1'], ['::1', '[::1]']]) {
const hz = await request(S.port, '/healthz', { host });
assert.equal(hz.status, 200, host);
assert.equal(hz.body.toString(), 'ok');
const c = new Client('ws://' + wsHost + ':' + S.port + '/ws', { origin: 'http://' + wsHost + ':' + S.port });
try {
await c.open();
c.send({ t: 'join', pid: newPid(), name: 'v' + host });
const j = await c.type('joined');
assert.equal(j.you.slot, 0);
await c.snap();
} finally { c.ws.terminate(); }
}
// an IPv4 client is logged as IPv4, not ::ffff:a.b.c.d
assert.equal(netx.normalizeIp('::ffff:127.0.0.1'), '127.0.0.1');
});
});
// ================================================================ shutdown
test('close(): closes sockets with 1001, is idempotent, releases the port, leaves nothing running', async () => {
const srv = await createServer({ port: 0, host: '127.0.0.1', log: noop, pingMs: 50, graceMs: 100000 });
const url = 'ws://127.0.0.1:' + srv.port + '/ws';
const cs = [new Client(url), new Client(url)];
await cs[0].open(); await cs[1].open();
cs[0].send({ t: 'join', pid: newPid(), name: 'a' });
const j = await cs[0].type('joined');
cs[1].send({ t: 'join', pid: newPid(), name: 'b', room: j.room });
await cs[1].type('joined');
const idle = new Client(url); await idle.open(); // never joined
const t0 = Date.now();
await srv.close();
assert.ok(Date.now() - t0 < 1500, 'close took ' + (Date.now() - t0) + ' ms');
assert.equal((await cs[0].closed()).code, 1001);
assert.equal((await cs[1].closed()).code, 1001);
assert.equal((await idle.closed()).code, 1001);
assert.equal(srv.rooms.size, 0);
await srv.close(); // second call is fine
await assert.rejects(() => request(srv.port, '/healthz'), { code: 'ECONNREFUSED' });
});
// ================================================================ HTTP: static files and /healthz
test('/healthz and security headers', async () => {
await withServer({}, async (S) => {
const g = await request(S.port, '/healthz');
assert.equal(g.status, 200);
assert.equal(g.body.toString(), 'ok');
const h = await request(S.port, '/healthz', { method: 'HEAD' });
assert.equal(h.status, 200);
assert.equal(h.body.length, 0);
assert.equal((await request(S.port, '/healthz', { method: 'POST' })).status, 405);
assert.equal((await request(S.port, '/healthz?probe=1')).status, 200);
const ws = await request(S.port, '/ws');
assert.equal(ws.status, 426, 'plain GET of the socket endpoint');
for (const res of [g, h, ws, await request(S.port, '/definitely-missing'), await request(S.port, '/js/sim.js')]) {
assert.equal(res.headers['x-content-type-options'], 'nosniff');
assert.equal(res.headers['referrer-policy'], 'no-referrer');
assert.equal(res.headers['content-security-policy'],
"default-src 'self'; connect-src 'self' ws: wss:; img-src 'self' data:; style-src 'self' 'unsafe-inline'; media-src 'self' data:; base-uri 'none'; frame-ancestors 'none'");
}
});
});
test('default publicDir is the repo\'s public/ (sim.js is served byte for byte)', async () => {
await withServer({}, async (S) => {
const r = await request(S.port, '/js/sim.js');
assert.equal(r.status, 200);
assert.equal(r.headers['content-type'], 'text/javascript; charset=utf-8');
assert.equal(r.headers['cache-control'], 'no-cache');
assert.ok(r.body.equals(fs.readFileSync(path.join(__dirname, '..', 'public', 'js', 'sim.js'))));
assert.equal(S.srv.options.publicDir, path.join(__dirname, '..', 'public'));
});
});
test('static server: files, MIME types, conditional + range requests, methods', async (t) => {
const root = fs.mkdtempSync(path.join(os.tmpdir(), 'netwall-static-'));
const pub = path.join(root, 'public');
for (const d of ['js', 'css', 'sub', '.git', 'assets']) fs.mkdirSync(path.join(pub, d), { recursive: true });
const audio = Buffer.alloc(1000); for (let i = 0; i < audio.length; i++) audio[i] = i % 251;
const files = {
'index.html': '<!doctype html><title>root</title>',
'sub/index.html': '<!doctype html><title>sub</title>',
'js/app.js': 'console.log(1)', 'js/.secret.js': 'SECRET', 'css/style.css': 'body{}',
'data.json': '{"a":1}', 'icon.svg': '<svg xmlns="http://www.w3.org/2000/svg"/>', 'logo.png': 'PNG', 'photo.jpg': 'JPG',
'favicon.ico': 'ICO', 'font.woff2': 'WOFF2', 'notes.txt': 'hello', 'a b.txt': 'space', 'noext': 'x', 'app.webmanifest': '{}',
'.hidden': 'SECRET', '.git/config': 'SECRET', 'empty.txt': '',
};
for (const [name, body] of Object.entries(files)) fs.writeFileSync(path.join(pub, name), body);
for (const n of ['s.mp3', 's.ogg', 's.wav']) fs.writeFileSync(path.join(pub, 'assets', n), audio);
fs.writeFileSync(path.join(root, 'secret.txt'), 'TOP SECRET');
let symlinks = true;
try { fs.symlinkSync(path.join(root, 'secret.txt'), path.join(pub, 'link-out')); fs.symlinkSync(root, path.join(pub, 'dir-out')); } catch (e) { symlinks = false; }
const srv = await createServer({ port: 0, host: '127.0.0.1', publicDir: pub, log: noop, pingMs: 0 });
t.after(async () => { await srv.close(); fs.rmSync(root, { recursive: true, force: true }); });
const get = (p, o) => request(srv.port, p, o);
await t.test('/ serves index.html; directories serve their index.html; /dir redirects relatively', async () => {
const r = await get('/');
assert.equal(r.status, 200);
assert.equal(r.headers['content-type'], 'text/html; charset=utf-8');
assert.equal(r.body.toString(), files['index.html']);
assert.equal((await get('/index.html')).body.toString(), files['index.html']);
assert.equal((await get('/index.html?cache=bust&x=%2e%2e')).status, 200);
assert.equal((await get('/sub/')).body.toString(), files['sub/index.html']);
const red = await get('/sub');
assert.equal(red.status, 301);
assert.equal(red.headers.location, 'sub/', 'relative redirect, so it also works under a path prefix');
assert.equal((await get('/js/')).status, 404, 'no index.html in js/: no directory listing');
assert.equal((await get('/a%20b.txt')).body.toString(), 'space');
assert.equal((await get('//index.html')).status, 200, 'duplicate slashes collapse');
});
await t.test('MIME types', async () => {
const want = {
'/index.html': 'text/html; charset=utf-8', '/js/app.js': 'text/javascript; charset=utf-8', '/css/style.css': 'text/css; charset=utf-8',
'/data.json': 'application/json; charset=utf-8', '/icon.svg': 'image/svg+xml', '/logo.png': 'image/png', '/photo.jpg': 'image/jpeg',
'/favicon.ico': 'image/x-icon', '/font.woff2': 'font/woff2', '/assets/s.mp3': 'audio/mpeg', '/assets/s.ogg': 'audio/ogg',
'/assets/s.wav': 'audio/wav', '/notes.txt': 'text/plain; charset=utf-8', '/noext': 'application/octet-stream',
'/app.webmanifest': 'application/manifest+json; charset=utf-8',
};
for (const [p, type] of Object.entries(want)) {
const r = await get(p);
assert.equal(r.status, 200, p);
assert.equal(r.headers['content-type'], type, p);
assert.equal(r.headers['cache-control'], 'no-cache', p);
assert.equal(r.headers['x-content-type-options'], 'nosniff');
}
assert.equal((await get('/empty.txt')).status, 200);
});
await t.test('HEAD, ETag/304, ranges', async () => {
const head = await get('/assets/s.mp3', { method: 'HEAD' });
assert.equal(head.status, 200);
assert.equal(head.headers['content-length'], '1000');
assert.equal(head.headers['accept-ranges'], 'bytes');
assert.equal(head.body.length, 0);
const full = await get('/assets/s.mp3');
assert.ok(full.body.equals(audio));
const etag = full.headers.etag;
assert.ok(etag);
const nm = await get('/assets/s.mp3', { headers: { 'If-None-Match': etag } });
assert.equal(nm.status, 304);
assert.equal(nm.body.length, 0);
assert.equal((await get('/assets/s.mp3', { headers: { 'If-None-Match': '"other"' } })).status, 200);
assert.equal((await get('/assets/s.mp3', { headers: { 'If-Modified-Since': full.headers['last-modified'] } })).status, 304);
const r1 = await get('/assets/s.mp3', { headers: { Range: 'bytes=0-9' } });
assert.equal(r1.status, 206);
assert.equal(r1.headers['content-range'], 'bytes 0-9/1000');
assert.ok(r1.body.equals(audio.subarray(0, 10)));
const r2 = await get('/assets/s.mp3', { headers: { Range: 'bytes=990-' } });
assert.equal(r2.status, 206);
assert.ok(r2.body.equals(audio.subarray(990)));
const r3 = await get('/assets/s.mp3', { headers: { Range: 'bytes=-5' } });
assert.equal(r3.status, 206);
assert.ok(r3.body.equals(audio.subarray(995)));
const r4 = await get('/assets/s.mp3', { headers: { Range: 'bytes=0-99999' } });
assert.equal(r4.status, 206);
assert.equal(r4.headers['content-range'], 'bytes 0-999/1000');
const r5 = await get('/assets/s.mp3', { headers: { Range: 'bytes=5000-' } });
assert.equal(r5.status, 416);
assert.equal(r5.headers['content-range'], 'bytes */1000');
assert.equal((await get('/assets/s.mp3', { headers: { Range: 'bytes=0-1,5-6' } })).status, 200, 'multi-range is ignored');
assert.equal((await get('/assets/s.mp3', { headers: { Range: 'nonsense' } })).status, 200);
assert.equal((await get('/assets/s.mp3', { headers: { Range: 'bytes=0-9', 'If-Range': '"stale"' } })).status, 200);
assert.equal((await get('/assets/s.mp3', { headers: { Range: 'bytes=0-9', 'If-Range': etag } })).status, 206);
});
await t.test('other methods get 405 with Allow', async () => {
for (const method of ['POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS']) {
for (const p of ['/', '/index.html', '/nothing-here']) {
const r = await get(p, { method });
assert.equal(r.status, 405, method + ' ' + p);
assert.equal(r.headers.allow, 'GET, HEAD');
}
}
});
await t.test('404 for missing files', async () => {
for (const p of ['/nope', '/js/nope.js', '/nope/deeper/still', '/index.html/extra', '/sub/nope.html']) assert.equal((await get(p)).status, 404, p);
assert.equal((await get('/nope')).headers['cache-control'], 'no-cache');
});
await t.test('path traversal, encoded tricks, dotfiles, absolute paths never leak anything', async () => {
const expect400 = [
'/../secret.txt', '/../../secret.txt', '/js/../../secret.txt', '/%2e%2e/secret.txt', '/%2E%2E/secret.txt', '/.%2e/secret.txt',
'/js/%2e%2e/%2e%2e/secret.txt', '/..%2fsecret.txt', '/..%2Fsecret.txt', '/%2e%2e%2fsecret.txt', '/js%2f..%2f..%2fsecret.txt',
'/..\\secret.txt', '/..%5csecret.txt', '/%5c..%5csecret.txt', '/js\\..\\..\\secret.txt', '/%2fetc%2fpasswd',
'/index.html%00.png', '/%00', '/%00/../secret.txt', '/index.html%0d%0aX-Evil:1', '/%c0%ae%c0%ae/secret.txt', '/%',
'/%zz', '/./index.html',
];
for (const p of expect400) {
const r = await get(p);
assert.equal(r.status, 400, p);
assert.ok(!r.body.toString().includes('SECRET'), p);
}
const expect404 = ['/.hidden', '/js/.secret.js', '/.git/config', '/.git', '/%2ehidden', '/%2egit/config', '/etc/passwd', '//etc/passwd', '/secret.txt'];
for (const p of expect404) {
const r = await get(p);
assert.equal(r.status, 404, p);
assert.ok(!r.body.toString().includes('SECRET'), p);
}
if (symlinks) {
assert.equal((await get('/link-out')).status, 404, 'symlink pointing out of public/');
assert.equal((await get('/dir-out/secret.txt')).status, 404, 'symlinked directory pointing out of public/');
}
// absolute-form request target and a raw NUL byte straight on the wire
const abs = await rawHttp(srv.port, 'GET http://evil.example/index.html HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n');
assert.match(abs, /^HTTP\/1\.1 400 /);
const nul = await rawHttp(srv.port, 'GET /index.html\u0000 HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n');
assert.match(nul, /^HTTP\/1\.1 (400|404) /);
assert.ok(!nul.includes('SECRET') && !nul.includes('<title>'));
const star = await rawHttp(srv.port, 'OPTIONS * HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n');
assert.match(star, /^HTTP\/1\.1 (400|405) /);
});
await t.test('static parser unit cases', () => {
const { parseTarget } = require('../server/static');
assert.deepEqual(parseTarget('/a/b.js?x=1#y'), { segs: ['a', 'b.js'], trailingSlash: false });
assert.deepEqual(parseTarget('/'), { segs: [], trailingSlash: true });
assert.deepEqual(parseTarget('/a%20b/'), { segs: ['a b'], trailingSlash: true });
assert.equal(parseTarget('/a/../b').status, 400);
assert.equal(parseTarget('a/b').status, 400);
assert.equal(parseTarget('/.env').status, 404);
});
});
test('rate limiting uses a monotonic clock: a wall-clock step backwards must not stop the refill', async () => {
const realNow = Date.now;
await withServer({}, async (S) => {
const { a } = await S.pair();
a.c.send({ t: 'mark', x: 1, y: 1 });
await a.c.type('mark');
const b = new netx.TokenBucket(60, 120);
while (b.take()) { /* drain the burst */ }
Date.now = () => realNow() - 3600 * 1000; // NTP / VM resume: the clock jumps back an hour
try {
await sleep(450);
assert.equal(b.take(), true, 'the bucket refills with real elapsed time');
a.c.send({ t: 'mark', x: 2, y: 2 });
const m = await a.c.next((x) => x.t === 'mark' && x.x === 2, 1500, 'mark after the clock step');
assert.equal(m.y, 2);
} finally { Date.now = realNow; }
});
});
test('TokenBucket: burst then steady rate', () => {
const b = new netx.TokenBucket(60, 120);
b.last = 1000; // drive it with a fake clock
let n = 0;
while (b.take(1000)) n++;
assert.equal(n, 120);
assert.equal(b.take(1000 + 15), false, 'a quarter of a token is not enough');
assert.equal(b.take(1000 + 20), true, 'one token after ~16.7 ms');
assert.equal(b.take(1000 + 20), false);
b.take(60000);
let m = 1;
while (b.take(60000)) m++;
assert.equal(m, 120, 'refill is capped at the burst size');
});