92 lines
6.9 KiB
TypeScript
92 lines
6.9 KiB
TypeScript
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { randomBytes, randomUUID } from 'node:crypto';
|
|
import { MongoClient } from 'mongodb';
|
|
import { io } from 'socket.io-client';
|
|
import { createGameServer } from '../src/server/create-server.js';
|
|
import { ManualClock } from './helpers.js';
|
|
const uri = process.env.TEST_MONGODB_URI;
|
|
test('server cleanup releases a closed browser while an authenticated presence connection protects another tab', { skip: !uri }, async () => {
|
|
const databaseName = 'dragon_ball_test_cleanup_' + randomUUID().replaceAll('-', ''), clock = new ManualClock();
|
|
const app = await createGameServer({ mongoUri: uri!, databaseName, clientDirectory: 'dist/client', clock });
|
|
const client = await new MongoClient(uri!).connect();
|
|
let socket: ReturnType<typeof io> | undefined;
|
|
try {
|
|
const url = await app.listen({ host: '127.0.0.1', port: 0 });
|
|
const create = async (guestToken?: string) => (await app.inject({ method: 'POST', url: '/api/game-sessions',
|
|
payload: { createRequestId: randomBytes(32).toString('base64url'), guestToken } })).json().data;
|
|
const old = await create(), live = await create(old.guestToken), otherBrowser = await create();
|
|
assert.equal(old.playerId, live.playerId);
|
|
assert.notEqual(old.playerId, otherBrowser.playerId);
|
|
const headers = (s: typeof old) => ({ authorization: 'Bearer ' + s.token, 'x-game-session': s.gameSessionId });
|
|
for (const session of [old, live]) {
|
|
assert.equal((await app.inject({ method: 'POST', url: '/api/game-session/matches', headers: headers(session),
|
|
payload: { requestId: 'bot', matchId: session.gameSessionId, mode: 'bot', expectedPreviousSeq: 0 } })).statusCode, 200);
|
|
}
|
|
assert.equal((await app.inject({ method: 'POST', url: '/api/ranked/queue', headers: headers(otherBrowser), payload: {} })).statusCode, 200);
|
|
await clock.advance(90000);
|
|
socket = io(url + '/presence', { autoConnect: false, reconnection: false, auth: { gameSessionId: live.gameSessionId, token: live.token } });
|
|
const connected = new Promise<void>((resolve, reject) => { socket!.once('connect', resolve); socket!.once('connect_error', reject); });
|
|
socket.connect(); await connected;
|
|
await clock.advance(60000);
|
|
const get = async (s: typeof old) => (await app.inject({ url: '/api/game-session', headers: headers(s) })).json().data;
|
|
assert.equal((await get(old)).activeMatch, undefined);
|
|
assert.equal((await get(old)).stats.bot.losses, 0);
|
|
assert.equal((await get(live)).activeMatch.matchId, live.gameSessionId);
|
|
assert.equal((await app.inject({ method: 'POST', url: '/api/ranked/queue', headers: headers(old), payload: {} })).json().code, 'MATCH_PENDING');
|
|
socket.disconnect();
|
|
await clock.advance(90000);
|
|
assert.equal((await get(live)).activeMatch, undefined);
|
|
assert.equal((await app.inject({ method: 'POST', url: '/api/ranked/queue', headers: headers(old), payload: {} })).statusCode, 200);
|
|
} finally { socket?.disconnect(); await app.close(); await client.db(databaseName).dropDatabase(); await client.close(); }
|
|
});
|
|
|
|
test('HTTP game registration survives server restart without game timers and old gameplay sockets are rejected', { skip: !uri }, async () => {
|
|
const databaseName = 'dragon_ball_test_server_' + randomUUID().replaceAll('-', ''), clock = new ManualClock();
|
|
const options = { mongoUri: uri!, databaseName, clientDirectory: 'dist/client', clock };
|
|
let app = await createGameServer(options);
|
|
const client = await new MongoClient(uri!).connect();
|
|
let socket: ReturnType<typeof io> | undefined;
|
|
try {
|
|
const url = await app.listen({ host: '127.0.0.1', port: 0 });
|
|
assert.equal((await app.inject('/health')).statusCode, 200);
|
|
assert.equal((await app.inject('/ready')).statusCode, 200);
|
|
const session = (await app.inject({ method: 'POST', url: '/api/game-sessions', payload: { createRequestId: randomBytes(32).toString('base64url') } })).json().data;
|
|
const headers = { authorization: 'Bearer ' + session.token, 'x-game-session': session.gameSessionId };
|
|
const input = { requestId: 'register', matchId: 'bot-match', mode: 'bot', expectedPreviousSeq: 0 };
|
|
const match = (await app.inject({ method: 'POST', url: '/api/game-session/matches', headers, payload: input })).json().data;
|
|
assert.equal(match.seq, 1);
|
|
await clock.advance(12000);
|
|
assert.equal((await app.inject({ url: '/api/game-session', headers })).json().data.activeMatch.matchId, 'bot-match');
|
|
assert.equal(await client.db(databaseName).collection('matches').countDocuments(), 0);
|
|
socket = io(url, { autoConnect: false, reconnection: false, transports: ['websocket'] });
|
|
const status = new Promise<string>(resolve => { socket!.once('connect_error', () => resolve('rejected')); socket!.once('connect', () => resolve('accepted')); });
|
|
socket.connect(); assert.equal(await status, 'rejected'); socket.disconnect();
|
|
await app.close(); app = await createGameServer(options);
|
|
assert.equal((await app.inject({ url: '/api/game-session', headers })).json().data.activeMatch.matchId, 'bot-match');
|
|
const payload = { ...match, outcome: 'loss', reason: 'timeout' };
|
|
assert.equal((await app.inject({ method: 'POST', url: '/api/game-session/results', headers, payload })).json().data.stats.bot.losses, 1);
|
|
assert.equal((await app.inject({ method: 'POST', url: '/api/game-session/results', headers, payload })).json().data.status, 'duplicate');
|
|
assert.equal((await app.inject({ method: 'POST', url: '/api/game-session/results', payload })).statusCode, 401);
|
|
const state = (await app.inject({ url: '/api/game-session', headers })).json().data;
|
|
assert.equal(state.activeMatch, undefined); assert.equal(state.stats.bot.losses, 1);
|
|
} finally { socket?.disconnect(); await app.close(); try { await client.db(databaseName).dropDatabase(); } finally { await client.close(); } }
|
|
});
|
|
|
|
test('production server enforces session limits before database creation', { skip: !uri }, async () => {
|
|
const databaseName = 'dragon_ball_test_limits_' + randomUUID().replaceAll('-', '');
|
|
const app = await createGameServer({ mongoUri: uri!, databaseName, clientDirectory: 'dist/client', environment: 'test' });
|
|
const client = await new MongoClient(uri!).connect();
|
|
try {
|
|
for (let i = 0; i < 30; i++) {
|
|
assert.equal((await app.inject({ method: 'POST', url: '/api/game-sessions', payload: {} })).statusCode, 400);
|
|
}
|
|
const response = await app.inject({ method: 'POST', url: '/api/game-sessions',
|
|
payload: { createRequestId: randomBytes(32).toString('base64url') } });
|
|
assert.equal(response.statusCode, 429);
|
|
assert.ok(Number(response.headers['retry-after']) > 0);
|
|
assert.equal(await client.db(databaseName).collection('players').countDocuments(), 0);
|
|
assert.equal(await client.db(databaseName).collection('game_sessions').countDocuments(), 0);
|
|
} finally { await app.close(); try { await client.db(databaseName).dropDatabase(); } finally { await client.close(); } }
|
|
});
|