354 lines
20 KiB
TypeScript
354 lines
20 KiB
TypeScript
import { DEFAULT_GLOBAL_SETTINGS } from '../constants/global-settings.js';
|
|
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createMatchController } from '../src/client/match-controller.js';
|
|
import { emptyPlayerStats, type PeerMessage, type ResultSubmission } from '../src/shared/p2p-types.js';
|
|
import { ManualClock } from './helpers.js';
|
|
import type { PeerState } from '../src/client/peer.js';
|
|
|
|
test('failed rematch request remains retryable', async () => {
|
|
let attempts = 0;
|
|
const h = setup(async () => { if (++attempts === 1) throw new Error('offline'); }); const [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await a.leave(); await h.clock.advance(1);
|
|
assert.equal(a.view().finished?.reason, 'forfeit'); assert.equal(b.view().finished?.winnerIndex, 1);
|
|
await assert.rejects(a.rematch(), /offline/); assert.equal(a.view().rematch[0], false);
|
|
await a.rematch(); assert.equal(attempts, 2);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
class Wire {
|
|
epoch = 0; connected = false; remote?: Wire; drop = false;
|
|
intercept?: (message: PeerMessage) => boolean;
|
|
messages = new Set<(m: PeerMessage) => void>(); states = new Set<(s: PeerState) => void>();
|
|
async connect() { this.connected = true; }
|
|
send(message: PeerMessage) {
|
|
if (!this.connected) throw new Error('DISCONNECTED');
|
|
if (this.intercept?.(message)) return;
|
|
if (!this.drop) queueMicrotask(() => { if (this.remote?.connected) for (const h of this.remote.messages) h(structuredClone(message)); });
|
|
}
|
|
onMessage(h: (m: PeerMessage) => void) { this.messages.add(h); return () => { this.messages.delete(h); }; }
|
|
onState(h: (s: PeerState) => void) { this.states.add(h); return () => { this.states.delete(h); }; }
|
|
async restart(epoch = this.epoch + 1) { this.epoch = epoch; this.connected = true; }
|
|
close() { this.connected = false; }
|
|
disconnect() { this.connected = false; for (const h of this.states) h('disconnected'); }
|
|
}
|
|
test('peer emotes reach the correct slot without exposing choices or changing the turn', async () => {
|
|
const h = setup(), [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
await a.submitAction('charge'); await h.clock.advance(1);
|
|
const before = b.view();
|
|
assert.equal(a.sendEmote('greet'), true);
|
|
assert.equal(a.sendEmote('mistake'), false);
|
|
await h.clock.advance(1);
|
|
assert.equal(b.view().emotes?.[0]?.id, 'greet');
|
|
assert.equal(b.view().emotes?.[0]?.variant, a.view().emotes?.[0]?.variant);
|
|
assert.equal(b.view().ownAction, null);
|
|
assert.equal(b.view().turnId, before.turnId);
|
|
assert.deepEqual(b.view().energy, before.energy);
|
|
assert.equal(b.view().phase, 'selecting');
|
|
await b.leave();
|
|
assert.equal(b.sendEmote('threaten'), false);
|
|
} finally { h.close(); }
|
|
});
|
|
function setup(onRematch?: () => Promise<void>, guestClockOffset = 0, guestStartDelay = 0, turnDurationMs = DEFAULT_GLOBAL_SETTINGS.turnDurationMs) {
|
|
const clock = new ManualClock(); clock.time = 1000;
|
|
const a = new Wire(), b = new Wire(); a.remote = b; b.remote = a;
|
|
const records: ResultSubmission[][] = [[], []];
|
|
const storages: any[] = [];
|
|
const controllers = [a, b].map((peer, slot) => {
|
|
const memory = new Map<string, string>();
|
|
const storage = { getItem: (k: string) => memory.get(k) ?? null, setItem: (k: string, v: string) => { memory.set(k, v); }, removeItem: (k: string) => { memory.delete(k); } }; storages.push(storage);
|
|
const localClock = slot === 1 ? { now: () => clock.now() + guestClockOffset,
|
|
setTimeout: (fn: () => void, ms: number) => clock.setTimeout(fn, ms + (ms === 4000 || ms === 0 ? guestStartDelay : 0)), clearTimeout: clock.clearTimeout } : clock;
|
|
return createMatchController({ activeMatch: { matchId: 'friend-match', seq: 1, mode: 'friend', roomId: 'r', settings: { ...DEFAULT_GLOBAL_SETTINGS, turnDurationMs } }, gameSessionId: `session-${slot}`, selfIndex: slot as 0 | 1, clock: localClock, peer, onRematch,
|
|
reporter: { submit: async data => { records[slot].push(data); return { status: 'applied', stats: emptyPlayerStats() }; } },
|
|
storage,
|
|
});
|
|
});
|
|
return { clock, a, b, controllers, records, storages, close: () => controllers.forEach(c => c.destroy()) };
|
|
}
|
|
test('two peers agree turns and record complementary results without server turn events', async () => {
|
|
const h = setup(); const [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
assert.equal(a.view().phase, 'selecting'); assert.equal(b.view().phase, 'selecting');
|
|
await a.submitAction('charge'); await h.clock.advance(1);
|
|
assert.equal(a.view().phase, 'selecting');
|
|
await b.submitAction('charge'); await h.clock.advance(1);
|
|
assert.equal(a.view().phase, 'revealing'); assert.equal(b.view().phase, 'revealing');
|
|
assert.deepEqual(a.view().energy, [1, 1]); assert.deepEqual(b.view().energy, [1, 1]);
|
|
await h.clock.advance(1200); await a.submitAction('blast'); await b.submitAction('charge'); await h.clock.advance(4000);
|
|
assert.equal(h.records[0][0]?.outcome, 'win'); assert.equal(h.records[1][0]?.outcome, 'loss');
|
|
assert.equal(h.records[0].length, 1); assert.equal(h.records[1].length, 1);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('an immediate choice survives the other browser starting the announced turn late', async () => {
|
|
const h = setup(undefined, 0, 100), [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(0); await h.clock.advance(4000);
|
|
assert.equal(a.view().phase, 'selecting'); assert.equal(b.view().phase, 'countdown');
|
|
await a.submitAction('charge'); await h.clock.advance(0); await h.clock.advance(100);
|
|
await b.submitAction('charge'); await h.clock.advance(1);
|
|
assert.equal(a.view().phase, 'revealing'); assert.equal(b.view().phase, 'revealing');
|
|
assert.deepEqual(a.view().energy, [1, 1]); assert.deepEqual(b.view().energy, [1, 1]);
|
|
await h.clock.advance(1200);
|
|
assert.equal(a.view().phase, 'selecting'); assert.equal(b.view().phase, 'revealing');
|
|
await a.submitAction('blast'); await h.clock.advance(0); await h.clock.advance(100);
|
|
await b.submitAction('charge'); await h.clock.advance(1);
|
|
assert.equal(a.view().finished?.reason, 'hit'); assert.equal(b.view().finished?.reason, 'hit');
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('loss of final presentation after digest acknowledgements preserves both agreed results', async () => {
|
|
const h = setup(); const [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
await a.submitAction('charge'); await b.submitAction('charge'); await h.clock.advance(1); await h.clock.advance(1200);
|
|
await a.submitAction('blast'); await b.submitAction('charge');
|
|
h.a.intercept = m => { if (m.type !== 'turn:present') return false; queueMicrotask(() => { h.a.drop = h.b.drop = true; h.a.disconnect(); h.b.disconnect(); }); return true; };
|
|
await h.clock.advance(14000);
|
|
assert.deepEqual(h.records.map(r => r.map(x => x.outcome)), [['win'], ['loss']]);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
for (const leavingSlot of [0, 1] as const) test(`leaving a finished match as slot ${leavingSlot} never restarts the other player's final reveal`, async () => {
|
|
const h = setup(), [a, b] = h.controllers;
|
|
const remainingSlot = leavingSlot === 0 ? 1 : 0;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
await a.submitAction('charge'); await b.submitAction('charge'); await h.clock.advance(1); await h.clock.advance(1200);
|
|
await a.submitAction('blast'); await b.submitAction('charge'); await h.clock.advance(4000);
|
|
const remaining = h.controllers[remainingSlot], before = remaining.view();
|
|
assert.equal(before.finished?.reason, 'hit'); assert.equal(before.finished?.saved, true);
|
|
assert.ok(before.reveal!.revealEndsAt < h.clock.now());
|
|
h.controllers[leavingSlot].destroy();
|
|
const wire = remainingSlot === 0 ? h.a : h.b;
|
|
wire.disconnect(); await h.clock.advance(1);
|
|
assert.equal(remaining.view().opponentPresent, false);
|
|
assert.deepEqual(remaining.view().reveal, before.reveal);
|
|
assert.deepEqual(remaining.view().finished, before.finished);
|
|
wire.disconnect(); await h.clock.advance(1);
|
|
assert.deepEqual(remaining.view().reveal, before.reveal);
|
|
assert.deepEqual(h.records.map(records => records.length), [1, 1]);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('crossed explicit leave requests produce one draw per player instead of two wins', async () => {
|
|
const h = setup();
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start()));
|
|
await Promise.all(h.controllers.map(c => c.leave())); await h.clock.advance(1);
|
|
assert.deepEqual(h.records.map(r => r.map(x => x.outcome)), [['draw'], ['draw']]);
|
|
} finally { h.close(); }
|
|
});
|
|
test('recovery starts a fresh epoch and ignores messages from the previous connection', async () => {
|
|
const h = setup(); const [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000); await a.submitAction('charge');
|
|
h.a.disconnect(); h.b.disconnect(); await h.clock.advance(100);
|
|
assert.equal(h.a.epoch, 1); assert.equal(h.b.epoch, 1);
|
|
assert.equal(a.view().ownAction, null); assert.equal(b.view().ownAction, null);
|
|
assert.equal(h.records[0].length, 0);
|
|
h.a.send({ protocolVersion: 1, rulesVersion: '1', matchId: 'friend-match', connectionEpoch: 0, turnId: 1, type: 'turn:commit', digest: '0'.repeat(64), slot: 0 });
|
|
await h.clock.advance(1); assert.equal(b.view().phase, 'selecting');
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('peers whose wall clocks differ by five seconds agree on deadline and timeout result', async () => {
|
|
const h = setup(undefined, 5000); const [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
assert.equal(a.view().deadline, b.view().deadline); assert.equal(a.view().clockNow, b.view().clockNow);
|
|
await a.submitAction('charge'); await h.clock.advance(9000);
|
|
assert.equal(h.records[0][0]?.outcome, 'win'); assert.equal(h.records[1][0]?.outcome, 'loss');
|
|
assert.equal(a.view().finished?.reason, 'timeout'); assert.equal(b.view().finished?.reason, 'timeout');
|
|
} finally { h.close(); }
|
|
});
|
|
test('unrecoverable transport interruption aborts rather than inventing two wins', async () => {
|
|
const h = setup();
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
h.a.drop = h.b.drop = true; h.a.disconnect(); h.b.disconnect();
|
|
await new Promise(r => setImmediate(r)); // drain already-delivered messages before advancing the recovery clock
|
|
await h.clock.advance(10000);
|
|
assert.equal(h.records[0][0]?.outcome, 'aborted'); assert.equal(h.records[1][0]?.outcome, 'aborted');
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('refresh of a mutually confirmed final result saves without reconnecting to the opponent', async () => {
|
|
const h = setup();
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(13000);
|
|
const { GAME_CHECKPOINT_KEY } = await import('../constants/recording.js');
|
|
const saved = JSON.parse(h.storages[0].getItem(GAME_CHECKPOINT_KEY));
|
|
saved.checkpoint.state.finished.saved = false; saved.checkpoint.state.saveStatus = 'pending';
|
|
h.storages[0].setItem(GAME_CHECKPOINT_KEY, JSON.stringify(saved));
|
|
h.close(); let recorded = 0;
|
|
const restored = createMatchController({ activeMatch: saved.activeMatch, gameSessionId: 'session-0', selfIndex: 0, clock: h.clock, storage: h.storages[0],
|
|
reporter: { submit: async data => { recorded++; assert.equal(data.outcome, 'draw'); return { status: 'duplicate', stats: emptyPlayerStats() }; } } });
|
|
try { await restored.start(); assert.equal(recorded, 1); assert.equal(restored.view().saveStatus, 'saved'); }
|
|
finally { restored.destroy(); }
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('silent packet loss near a deadline enters recovery before declaring a protocol error', async () => {
|
|
const h = setup();
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
await Promise.all(h.controllers.map(c => c.submitAction('charge'))); await h.clock.advance(1); await h.clock.advance(1200);
|
|
// Last heartbeat was just delivered; no RTC state event arrives when packets stop.
|
|
h.a.drop = h.b.drop = true;
|
|
await h.clock.advance(17000);
|
|
assert.ok(h.a.epoch > 0 && h.b.epoch > 0);
|
|
assert.deepEqual(h.records.map(r => r.map(x => [x.outcome, x.reason])), [[['aborted', 'connection_failed']], [['aborted', 'connection_failed']]]);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('transport send failure at selection deadline attempts recovery', async () => {
|
|
const h = setup();
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
await h.clock.advance(2900);
|
|
h.a.connected = h.b.connected = false;
|
|
h.a.restart = h.b.restart = async () => { throw new Error('offline'); };
|
|
await h.clock.advance(100);
|
|
assert.deepEqual(h.records.map(r => r.map(x => x.reason)), [['connection_failed'], ['connection_failed']]);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('recovery blocks actions, ignores repeated disconnects and records interruption only once', async () => {
|
|
const h = setup();
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
h.a.drop = h.b.drop = true; h.a.disconnect(); h.b.disconnect();
|
|
await h.clock.advance(1);
|
|
assert.equal(await h.controllers[0].submitAction('charge'), false);
|
|
h.a.disconnect(); h.b.disconnect(); await h.clock.advance(1);
|
|
assert.equal(h.a.epoch, 1); assert.equal(h.b.epoch, 1);
|
|
await h.clock.advance(10000);
|
|
assert.deepEqual(h.records.map(r => r.length), [1, 1]);
|
|
assert.deepEqual(h.records.map(r => r[0].outcome), ['aborted', 'aborted']);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('leaving during unavailable recovery settles and records once', async () => {
|
|
const h = setup();
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
h.a.drop = h.b.drop = true; h.a.disconnect(); h.b.disconnect(); await h.clock.advance(1);
|
|
const leaving = h.controllers[0].leave(); await h.clock.advance(3000); await leaving;
|
|
await h.clock.advance(10000);
|
|
assert.deepEqual(h.records.map(r => r.map(x => x.outcome)), [['aborted'], ['aborted']]);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('loss of result agreement cannot display or save a speculative winner during recovery', async () => {
|
|
const h = setup(); const [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
await a.submitAction('charge'); await b.submitAction('charge'); await h.clock.advance(1); await h.clock.advance(1200);
|
|
await a.submitAction('blast'); await b.submitAction('charge');
|
|
h.a.intercept = h.b.intercept = message => message.type === 'turn:resolved';
|
|
h.a.restart = h.b.restart = () => new Promise<void>(() => {});
|
|
await h.clock.advance(7000);
|
|
assert.deepEqual(h.controllers.map(c => c.view().finished), [undefined, undefined]);
|
|
assert.deepEqual(h.controllers.map(c => c.view().opponentPresent), [false, false]);
|
|
await Promise.all(h.controllers.map(c => c.retrySave()));
|
|
assert.deepEqual(h.records.map(r => r.length), [0, 0]);
|
|
await h.clock.advance(10000);
|
|
assert.deepEqual(h.records.map(r => r.map(x => x.outcome)), [['aborted'], ['aborted']]);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('peer timeout extensions preserve hidden choices and cumulative chances across turns', async () => {
|
|
const h = setup(), [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
await a.submitAction('charge');
|
|
await h.clock.advance(a.view().deadline - h.clock.now() + 1);
|
|
assert.deepEqual(a.view().timeouts, [0, 1]);
|
|
assert.deepEqual(b.view().timeouts, [0, 1]);
|
|
assert.equal(a.view().ownAction, 'charge');
|
|
assert.equal(b.view().reveal, undefined);
|
|
assert.equal(await b.submitAction('guard'), true); await h.clock.advance(1);
|
|
assert.equal(a.view().phase, 'revealing');
|
|
await h.clock.advance(1200);
|
|
await a.submitAction('guard');
|
|
await h.clock.advance(a.view().deadline - h.clock.now() + 1);
|
|
assert.deepEqual(b.view().timeouts, [0, 2]);
|
|
assert.equal(b.view().phase, 'selecting');
|
|
await h.clock.advance(a.view().deadline - h.clock.now() + 1);
|
|
assert.equal(a.view().finished?.winnerIndex, 0);
|
|
assert.equal(b.view().finished?.winnerIndex, 0);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('a guest commitment arriving after the deadline keeps a valid last-moment choice', async () => {
|
|
const h = setup(), [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
await a.submitAction('charge'); await h.clock.advance(1);
|
|
const held: PeerMessage[] = [];
|
|
h.b.intercept = message => { if (['turn:commit', 'turn:reveal', 'turn:timeout'].includes(message.type)) { held.push(message); return true; } return false; };
|
|
await h.clock.advance(b.view().deadline - h.clock.now() - 1);
|
|
await b.submitAction('guard'); await h.clock.advance(2);
|
|
assert.equal(a.view().phase, 'selecting');
|
|
h.b.intercept = undefined; for (const message of held) h.b.send(message);
|
|
await h.clock.advance(1);
|
|
assert.equal(a.view().phase, 'revealing'); assert.equal(b.view().phase, 'revealing');
|
|
assert.deepEqual(a.view().timeouts, [0, 0]); assert.deepEqual(b.view().timeouts, [0, 0]);
|
|
assert.deepEqual(a.view().reveal?.actions, ['charge', 'guard']);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('recovery reconciles a timeout report lost before the other peer receives it', async () => {
|
|
const h = setup(), [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
h.a.intercept = message => message.type === 'turn:timeout';
|
|
await h.clock.advance(a.view().deadline - h.clock.now() + 1);
|
|
assert.deepEqual(a.view().timeouts, [1, 1]); assert.deepEqual(b.view().timeouts, [0, 0]);
|
|
h.a.intercept = undefined; h.a.disconnect(); h.b.disconnect();
|
|
await h.clock.advance(1000);
|
|
assert.equal(a.view().phase, 'selecting'); assert.equal(b.view().phase, 'selecting');
|
|
assert.deepEqual(a.view().timeouts, [1, 1]); assert.deepEqual(b.view().timeouts, [1, 1]);
|
|
assert.equal(a.view().aborted, false); assert.equal(b.view().aborted, false);
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('selecting during a ten-second extension does not start the protocol timeout early', async () => {
|
|
const h = setup(undefined, 0, 0, 10000), [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
await h.clock.advance(a.view().deadline - h.clock.now() + 1000);
|
|
assert.deepEqual(a.view().timeouts, [1, 1]);
|
|
await a.submitAction('guard'); await h.clock.advance(4000);
|
|
assert.equal(h.a.epoch, 0); assert.equal(h.b.epoch, 0);
|
|
assert.equal(a.view().ownAction, 'guard');
|
|
assert.equal(await b.submitAction('charge'), true); await h.clock.advance(1);
|
|
assert.equal(a.view().phase, 'revealing');
|
|
} finally { h.close(); }
|
|
});
|
|
|
|
test('disconnect before terminal timeout agreement cannot refund the third chance', async () => {
|
|
const h = setup(), [a, b] = h.controllers;
|
|
try {
|
|
await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(4000);
|
|
await a.submitAction('guard');
|
|
const holdAgreement = (message: PeerMessage) => ['turn:resolved', 'turn:ack', 'turn:present'].includes(message.type);
|
|
h.a.intercept = h.b.intercept = holdAgreement;
|
|
await h.clock.advance(a.view().deadline - h.clock.now() + 6001);
|
|
assert.deepEqual(a.view().timeouts, [0, 3]); assert.deepEqual(b.view().timeouts, [0, 3]);
|
|
assert.deepEqual(h.records.map(records => records.length), [0, 0]);
|
|
h.a.intercept = h.b.intercept = undefined; h.a.disconnect(); h.b.disconnect();
|
|
await h.clock.advance(1000);
|
|
assert.equal(a.view().finished?.reason, 'timeout'); assert.equal(b.view().finished?.reason, 'timeout');
|
|
assert.equal(a.view().finished?.winnerIndex, 0); assert.equal(b.view().finished?.winnerIndex, 0);
|
|
assert.deepEqual(a.view().timeouts, [0, 3]);
|
|
assert.equal(h.records[0][0]?.outcome, 'win'); assert.equal(h.records[1][0]?.outcome, 'loss');
|
|
} finally { h.close(); }
|
|
});
|