Initial commit: ssessesse ki battle
This commit is contained in:
@@ -0,0 +1,120 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createPeer } from '../src/client/peer.js';
|
||||
import { PROTOCOL_VERSION } from '../constants/webrtc.js';
|
||||
import { RULES_VERSION } from '../constants/gameplay.js';
|
||||
|
||||
class Signal {
|
||||
handlers = new Map<string, Function[]>(); peer?: Signal; connected = false; disconnected = false;
|
||||
on(name: string, fn: Function) { this.handlers.set(name, [...this.handlers.get(name) ?? [], fn]); return this; }
|
||||
once(name: string, fn: Function) { return this.on(name, fn); }
|
||||
fire(name: string, data?: any) { for (const fn of this.handlers.get(name) ?? []) fn(data); }
|
||||
connect() { this.connected = true; queueMicrotask(() => { this.fire('connect'); if (this.peer?.connected) { this.fire('signal:peers', { count: 2 }); this.peer.fire('signal:peers', { count: 2 }); } }); }
|
||||
disconnect() { this.disconnected = true; this.connected = false; return this; }
|
||||
timeout() { return this; }
|
||||
async emitWithAck(_event: string, packet: any) { queueMicrotask(() => this.peer?.fire('signal', packet)); return { ok: true }; }
|
||||
removeAllListeners() { this.handlers.clear(); return this; }
|
||||
}
|
||||
class Channel {
|
||||
readyState = 'connecting'; onopen?: () => void; onmessage?: (event: { data: string }) => void; onclose?: () => void;
|
||||
peer?: Channel;
|
||||
send(data: string) { queueMicrotask(() => this.peer?.onmessage?.({ data })); }
|
||||
close() { this.readyState = 'closed'; this.onclose?.(); }
|
||||
}
|
||||
class PC {
|
||||
connectionState = 'new'; localDescription: any; remoteDescription: any; channel?: Channel; peer?: PC;
|
||||
ondatachannel?: (event: any) => void; onicecandidate?: (event: any) => void; onconnectionstatechange?: () => void;
|
||||
createDataChannel(_label: string, options: any) { assert.equal(options.ordered, true); assert.equal(options.maxRetransmits, undefined); return this.channel = new Channel(); }
|
||||
async createOffer() { return { type: 'offer', sdp: 'offer' }; }
|
||||
async createAnswer() { return { type: 'answer', sdp: 'answer' }; }
|
||||
async setLocalDescription(value: any) { this.localDescription = value; }
|
||||
async setRemoteDescription(value: any) {
|
||||
this.remoteDescription = value;
|
||||
if (value.type === 'answer') {
|
||||
const remote = new Channel(); this.channel!.peer = remote; remote.peer = this.channel;
|
||||
this.peer!.channel = remote; this.peer!.ondatachannel?.({ channel: remote });
|
||||
this.connectionState = this.peer!.connectionState = 'connected';
|
||||
this.channel!.readyState = remote.readyState = 'open'; this.channel!.onopen?.(); remote.onopen?.();
|
||||
}
|
||||
}
|
||||
async addIceCandidate() {} restartIce() {} close() { this.connectionState = 'closed'; }
|
||||
async getStats() { return new Map(); }
|
||||
getConfiguration() { return { iceServers: [], bundlePolicy: 'max-bundle', rtcpMuxPolicy: 'require' }; }
|
||||
setConfiguration(value: any) { if (value.bundlePolicy !== 'max-bundle' || value.rtcpMuxPolicy !== 'require') throw new Error('INVALID_MODIFICATION'); }
|
||||
}
|
||||
test('peer connects reliable channel, closes signaling after mutual ready and keeps delivering data', async () => {
|
||||
const sa = new Signal(), sb = new Signal(); sa.peer = sb; sb.peer = sa;
|
||||
const pa = new PC(), pb = new PC(); pa.peer = pb; pb.peer = pa;
|
||||
const config = { matchId: 'm1', roomId: 'r1', epoch: 0, iceServers: [] };
|
||||
const a = createPeer({ ...config, slot: 0, createSignaling: () => sa as any, createConnection: () => pa as any });
|
||||
const b = createPeer({ ...config, slot: 1, createSignaling: () => sb as any, createConnection: () => pb as any });
|
||||
try {
|
||||
const messages: any[] = []; b.onMessage(m => messages.push(m));
|
||||
await Promise.all([a.connect(), b.connect()]);
|
||||
assert.equal(sa.disconnected, true); assert.equal(sb.disconnected, true);
|
||||
const message = { protocolVersion: PROTOCOL_VERSION, rulesVersion: RULES_VERSION, matchId: 'm1', connectionEpoch: 0, turnId: 1, type: 'turn:start' as const, startsAt: 1000 };
|
||||
a.send(message); await new Promise(r => setImmediate(r)); assert.deepEqual(messages, [message]);
|
||||
assert.equal(pa.connectionState, 'connected');
|
||||
} finally { a.close(); b.close(); }
|
||||
});
|
||||
|
||||
test('late ICE rejection after mutual ready does not invalidate a working data channel', async () => {
|
||||
const sa = new Signal(), sb = new Signal(); sa.peer = sb; sb.peer = sa;
|
||||
const pa = new PC(), pb = new PC(); pa.peer = pb; pb.peer = pa;
|
||||
const normal = sa.emitWithAck.bind(sa); let rejectIce!: (error: Error) => void;
|
||||
sa.emitWithAck = (event, packet) => packet.type === 'ice' ? new Promise((_resolve, reject) => { rejectIce = reject; }) : normal(event, packet);
|
||||
const a = createPeer({ matchId: 'late', roomId: 'r', slot: 0, iceServers: [], createSignaling: () => sa as any, createConnection: () => pa as any });
|
||||
const b = createPeer({ matchId: 'late', roomId: 'r', slot: 1, iceServers: [], createSignaling: () => sb as any, createConnection: () => pb as any });
|
||||
try {
|
||||
const connecting = a.connect(); pa.onicecandidate?.({ candidate: { toJSON: () => ({ candidate: 'test' }) } });
|
||||
await Promise.all([connecting, b.connect()]);
|
||||
rejectIce(new Error('PEER_NOT_READY')); await new Promise(r => setImmediate(r));
|
||||
assert.equal(a.connected, true); assert.equal(b.connected, true);
|
||||
} finally { a.close(); b.close(); }
|
||||
});
|
||||
|
||||
test('an ICE failure from the previous epoch cannot reject the new connection attempt', async () => {
|
||||
const sa = new Signal(), sb = new Signal(); sa.peer = sb; sb.peer = sa;
|
||||
const pa = new PC(), pb = new PC(); pa.peer = pb; pb.peer = pa;
|
||||
const normal = sa.emitWithAck.bind(sa); let rejectIce!: (error: Error) => void;
|
||||
sa.emitWithAck = (event, packet) => packet.type === 'ice' ? new Promise((_resolve, reject) => { rejectIce = reject; }) : normal(event, packet);
|
||||
const a = createPeer({ matchId: 'generation', roomId: 'r', slot: 0, iceServers: [], createSignaling: () => sa as any, createConnection: () => pa as any });
|
||||
const b = createPeer({ matchId: 'generation', roomId: 'r', slot: 1, iceServers: [], createSignaling: () => sb as any, createConnection: () => pb as any });
|
||||
try {
|
||||
const first = a.connect(); pa.onicecandidate?.({ candidate: { toJSON: () => ({ candidate: 'old' }) } });
|
||||
await Promise.all([first, b.connect()]);
|
||||
const recovery = a.restart(); let failed = false; void recovery.catch(() => { failed = true; });
|
||||
rejectIce(new Error('OLD_ICE')); await new Promise(r => setImmediate(r));
|
||||
assert.equal(failed, false); assert.equal(sa.connected, true);
|
||||
await Promise.all([recovery, b.restart()]); assert.equal(a.connected, true);
|
||||
} finally { a.close(); b.close(); }
|
||||
});
|
||||
|
||||
test('ICE restart refreshes servers without changing immutable connection configuration', async () => {
|
||||
const sa = new Signal(), sb = new Signal(); sa.peer = sb; sb.peer = sa;
|
||||
const pa = new PC(), pb = new PC(); pa.peer = pb; pb.peer = pa;
|
||||
const a = createPeer({ matchId: 'restart', roomId: 'r', slot: 0, iceServers: [], refreshIce: async () => [{ urls: 'stun:example.test' }], createSignaling: () => sa as any, createConnection: () => pa as any });
|
||||
const b = createPeer({ matchId: 'restart', roomId: 'r', slot: 1, iceServers: [], refreshIce: async () => [], createSignaling: () => sb as any, createConnection: () => pb as any });
|
||||
try {
|
||||
await Promise.all([a.connect(), b.connect()]);
|
||||
await Promise.all([a.restart(), b.restart()]);
|
||||
assert.equal(a.connected, true); assert.equal(b.connected, true); assert.equal(a.epoch, 1);
|
||||
} finally { a.close(); b.close(); }
|
||||
});
|
||||
|
||||
test('recovery replaces a closed data channel and can replace a connection that rejects ICE reconfiguration', async () => {
|
||||
const sa = new Signal(), sb = new Signal(); sa.peer = sb; sb.peer = sa;
|
||||
const pairs = Array.from({ length: 2 }, () => { const a = new PC(), b = new PC(); a.peer = b; b.peer = a; return [a, b]; });
|
||||
let ai = 0, bi = 0;
|
||||
pairs[0][0].setConfiguration = () => { throw new Error('InvalidModificationError'); };
|
||||
const a = createPeer({ matchId: 'fallback', roomId: 'r', slot: 0, iceServers: [], refreshIce: async () => [], createSignaling: () => sa as any, createConnection: () => pairs[ai++][0] as any });
|
||||
const b = createPeer({ matchId: 'fallback', roomId: 'r', slot: 1, iceServers: [], refreshIce: async () => [], createSignaling: () => sb as any, createConnection: () => pairs[bi++][1] as any });
|
||||
try {
|
||||
await Promise.all([a.connect(), b.connect()]);
|
||||
pairs[0][1].channel!.close();
|
||||
await Promise.all([a.restart(), b.restart()]);
|
||||
assert.equal(a.connected, true); assert.equal(b.connected, true);
|
||||
assert.equal(pairs[0][0].connectionState, 'closed'); assert.equal(pairs[0][1].connectionState, 'closed');
|
||||
assert.equal(ai, 2); assert.equal(bi, 2);
|
||||
} finally { a.close(); b.close(); }
|
||||
});
|
||||
Reference in New Issue
Block a user