77 lines
6.2 KiB
TypeScript
77 lines
6.2 KiB
TypeScript
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
import vm from 'node:vm';
|
|
import ts from 'typescript';
|
|
import { GAME_CHECKPOINT_KEY, GAME_ROOM_KEY } from '../constants/recording.js';
|
|
import { HOME_TELEPORT_APPEARANCE } from '../constants/home.js';
|
|
import { createGameApi, ApiClientError } from '../src/client/api.js';
|
|
import { createGlobalSettingsCache } from '../src/client/global-settings.js';
|
|
import { emptyPlayerStats } from '../src/shared/p2p-types.js';
|
|
|
|
const source = readFileSync('src/client/main.ts', 'utf8').replace(/^import .*;\r?\n/gm, '');
|
|
const compiled = ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.None } }).outputText;
|
|
const flush = async () => { for (let i = 0; i < 8; i++) await new Promise(r => setImmediate(r)); };
|
|
async function setup(kind: 'expired' | 'orphan' | 'rematch-wait' | 'result') {
|
|
const mem = new Map<string, string>(), calls: string[] = [], polls = new Map<number, () => void>(), launched: string[] = [];
|
|
const active = { matchId: 'm', seq: 1, mode: 'friend', roomId: 'r' };
|
|
const session: any = { gameSessionId: 's', token: 't'.repeat(43), stats: emptyPlayerStats(), lastAppliedSeq: kind === 'orphan' ? 0 : 1, ...(kind === 'orphan' ? { activeMatch: active } : {}) };
|
|
const room: any = { id: 'r', code: 'ABCDEF', currentMatchId: 'm', round: 1, selfIndex: 0, status: 'paired', count: 2, expiresAt: Date.now() + 60000, rematch: [kind === 'rematch-wait', false] };
|
|
let open = true, pollId = 0;
|
|
mem.set(GAME_ROOM_KEY, JSON.stringify({ gameSessionId: 's', room }));
|
|
if (kind !== 'orphan') mem.set(GAME_CHECKPOINT_KEY, JSON.stringify({ gameSessionId: 's', activeMatch: active, checkpoint: { state: {
|
|
matchId: 'm', mode: 'friend', phase: 'finished', selfIndex: 0, version: 1, finished: { saved: true, stats: session.stats, reason: 'hit' }, rematch: room.rematch, saveStatus: 'saved',
|
|
} } }));
|
|
const send: typeof fetch = async (input, init) => {
|
|
const path = String(input); calls.push(path); let data: any = session;
|
|
if (path === '/api/rooms/r' || path.endsWith('/leave')) {
|
|
if (kind === 'expired') return new Response(JSON.stringify({ ok: false, code: 'ROOM_EXPIRED', message: 'expired' }), { status: 410 });
|
|
if (path.endsWith('/leave')) open = false;
|
|
data = room;
|
|
} else if (path === '/api/game-session/results') { delete session.activeMatch; session.lastAppliedSeq = 1; data = { status: 'applied', stats: session.stats }; }
|
|
else if (path === '/api/game-session/matches') { const body = JSON.parse(String(init?.body)); data = { ...body, seq: 2 }; }
|
|
else if (path.startsWith('/api/rtc-config')) data = { iceServers: [] };
|
|
return new Response(JSON.stringify({ ok: true, data }));
|
|
};
|
|
const storage = { getItem: (k: string) => mem.get(k) ?? null, setItem: (k: string, v: string) => { mem.set(k,v); }, removeItem: (k: string) => { mem.delete(k); } };
|
|
const nodes = new Map<string, any>();
|
|
const el = (id: string) => { if (!nodes.has(id)) nodes.set(id, { classList: { toggle() {}, add() {}, remove() {} }, addEventListener() {}, focus() {} }); return nodes.get(id); };
|
|
const ctx: any = { Map, Date, Promise, JSON, URL, URLSearchParams, Number, crypto, ApiClientError, GAME_CHECKPOINT_KEY, GAME_ROOM_KEY, GUEST_TOKEN_KEY: 'guest', ROOM_POLL_MS: 1000, ACTIONS: {}, ACTION_IDS: [],
|
|
window: { addEventListener() {} }, document: { addEventListener() {}, getElementById: el, body: { dataset: {} }, querySelectorAll: () => [] }, location: { origin: 'http://local', search: '' }, sessionStorage: storage, localStorage: { getItem: () => null, setItem() {} }, navigator: {}, fighterArt: () => '',
|
|
GAME_NAME: '쎄쎄쎄:기공대전', HOME_TELEPORT_APPEARANCE, createGameApi: () => createGameApi(storage, send),
|
|
createGlobalSettingsCache: () => createGlobalSettingsCache(storage, send),
|
|
createAppFooter: () => ({ setConnection() {}, openRules() {} }),
|
|
createClientAnalytics: () => ({ ready() {}, screen() {}, gameFinished() {}, gameStarted() {}, error() {}, click() {} }),
|
|
createResultReporter: (api: any) => ({ destroy() {}, resumePending: async () => {}, submit: api.record }),
|
|
createMatchView: () => ({ update() {}, destroy() {} }), createPeer: () => ({}),
|
|
createLobbyFeatures: () => ({ initialize: async () => false, setReady() {}, active: false }),
|
|
createMatchController: (config: any) => { launched.push(config.activeMatch.matchId); return { subscribe() {}, start: async () => {}, view: () => ({ matchId: config.activeMatch.matchId }), destroy() {} }; },
|
|
setTimeout(fn: () => void) { polls.set(++pollId, fn); return pollId; }, clearTimeout(id: number) { polls.delete(id); },
|
|
};
|
|
vm.createContext(ctx); vm.runInContext(compiled + '\nglobalThis.review={leave,boot,inspect:()=>({ready,currentScreen,currentRoom,currentMatch})};', ctx); await flush();
|
|
return { ctx, calls, polls, room, mem, launched, open: () => open };
|
|
}
|
|
test('already-expired room does not trap a restored result on exit', async () => {
|
|
const h = await setup('expired'); await h.ctx.review.leave();
|
|
assert.equal(h.ctx.review.inspect().currentScreen, 'home'); assert.equal(h.mem.has(GAME_ROOM_KEY), false);
|
|
});
|
|
test('orphan registration recovery closes the persisted room membership before forgetting it', async () => {
|
|
const h = await setup('orphan'); assert.equal(h.open(), false);
|
|
assert.ok(h.calls.includes('/api/rooms/r/leave')); assert.equal(h.ctx.review.inspect().currentScreen, 'home');
|
|
});
|
|
test('refresh restores HTTP rematch consent polling and starts an advanced round', async () => {
|
|
const h = await setup('rematch-wait'); assert.ok(h.calls.includes('/api/rooms/r')); assert.equal(h.polls.size, 1);
|
|
h.room.round = 2; h.room.currentMatchId = 'new-match'; h.room.rematch = [false, false];
|
|
[...h.polls.values()][0](); await flush(); assert.deepEqual(h.launched, ['new-match']);
|
|
});
|
|
|
|
test('a result monitors opponent departure without requesting a rematch', async () => {
|
|
const h = await setup('result');
|
|
assert.equal(h.polls.size, 1);
|
|
assert.equal(h.ctx.review.inspect().currentMatch.opponentLeft, false);
|
|
h.room.status = 'closed';
|
|
[...h.polls.values()][0](); await flush();
|
|
assert.equal(h.ctx.review.inspect().currentMatch.opponentLeft, true);
|
|
assert.equal(h.calls.some(path => path.endsWith('/rematch')), false);
|
|
});
|