616 lines
20 KiB
TypeScript
616 lines
20 KiB
TypeScript
import { readFileSync } from 'node:fs';
|
|
import assert from 'node:assert/strict';
|
|
import { test } from 'node:test';
|
|
import type { RuntimeConfig } from '../../YouleNexus/assets/framework/config/runtime-config.ts';
|
|
import type { OutboundEnvelope } from '../../YouleNexus/assets/framework/core/types/envelope.ts';
|
|
import type { Clock } from '../../YouleNexus/assets/framework/net/heartbeat.ts';
|
|
import type { WireEvent } from '../../YouleNexus/assets/framework/net/wire-client.ts';
|
|
import type {
|
|
GameEntry,
|
|
GameHost,
|
|
GameModule,
|
|
PlatformToGameEvent,
|
|
} from '../../YouleNexus/assets/framework/sdk/contracts/index.ts';
|
|
import {
|
|
PlatformRuntime,
|
|
type PlatformWireClient,
|
|
} from '../../YouleNexus/assets/framework/platform/runtime.ts';
|
|
import type { ScenePort } from '../../YouleNexus/assets/framework/platform/scene-port.ts';
|
|
|
|
function fixture(name: string): Record<string, unknown> {
|
|
return JSON.parse(
|
|
readFileSync(new URL(`../fixtures/contracts/${name}`, import.meta.url), 'utf8'),
|
|
).data;
|
|
}
|
|
|
|
const ACCOUNT = Object.freeze({
|
|
openid: 'o1',
|
|
nickname: '测试号',
|
|
avatar: 'http://a',
|
|
sex: 0,
|
|
province: '江西',
|
|
city: '南昌',
|
|
unionid: 'test_unionid',
|
|
});
|
|
|
|
const DEVICE = Object.freeze({
|
|
ip: '127.0.0.1',
|
|
location: Object.freeze({ latitude: 1, longitude: 2 }),
|
|
machineid: 'machine-1',
|
|
machineroom: 'room-install-1',
|
|
deviceLogin: Object.freeze({ enabled: false as const }),
|
|
loginPlayerId: Object.freeze({ enabled: false as const }),
|
|
});
|
|
|
|
function runtimeConfig(gameid: string | number = '41'): RuntimeConfig {
|
|
return Object.freeze({
|
|
mode: 'debug',
|
|
isDebugger: true,
|
|
identity: Object.freeze({
|
|
agentid: 'veRa0qrBf',
|
|
channelid: 'FtJf073aa',
|
|
gameid,
|
|
marketid: 4,
|
|
version: 10000,
|
|
}),
|
|
servers: Object.freeze(['ws://agent']),
|
|
source: 'direct',
|
|
gameserver: null,
|
|
rawConfig: null,
|
|
}) as RuntimeConfig;
|
|
}
|
|
|
|
class ManualClock implements Clock {
|
|
private nextHandle = 1;
|
|
readonly timers = new Map<number, { readonly fn: () => void; readonly ms: number }>();
|
|
|
|
setTimeout(fn: () => void, ms: number): unknown {
|
|
const handle = this.nextHandle;
|
|
this.nextHandle += 1;
|
|
this.timers.set(handle, { fn, ms });
|
|
return handle;
|
|
}
|
|
|
|
clearTimeout(handle: unknown): void {
|
|
this.timers.delete(handle as number);
|
|
}
|
|
|
|
runOnlyTimer(): void {
|
|
assert.equal(this.timers.size, 1);
|
|
const [handle, timer] = [...this.timers.entries()][0]!;
|
|
this.timers.delete(handle);
|
|
timer.fn();
|
|
}
|
|
}
|
|
|
|
class RecordingWireClient implements PlatformWireClient {
|
|
readonly sent: OutboundEnvelope[] = [];
|
|
readonly switchCalls: string[] = [];
|
|
readonly lifecycle: string[] = [];
|
|
reconnectCalls = 0;
|
|
stopCalls = 0;
|
|
onAction: (name: string) => void = () => {};
|
|
private readonly listeners = new Set<(event: WireEvent) => void>();
|
|
|
|
subscribe(listener: (event: WireEvent) => void): () => void {
|
|
this.lifecycle.push('subscribe');
|
|
this.onAction('subscribe');
|
|
this.listeners.add(listener);
|
|
return () => {
|
|
this.lifecycle.push('unsubscribe');
|
|
this.onAction('unsubscribe');
|
|
this.listeners.delete(listener);
|
|
};
|
|
}
|
|
|
|
start(): void {
|
|
this.lifecycle.push('start');
|
|
this.onAction('start');
|
|
}
|
|
|
|
send(envelope: OutboundEnvelope): void {
|
|
this.sent.push(envelope);
|
|
}
|
|
|
|
switchServer(target: string): void {
|
|
this.switchCalls.push(target);
|
|
}
|
|
|
|
reconnectCurrent(): void {
|
|
this.reconnectCalls += 1;
|
|
}
|
|
|
|
stop(): void {
|
|
this.stopCalls += 1;
|
|
this.lifecycle.push('stop');
|
|
this.onAction('stop');
|
|
}
|
|
|
|
emit(event: WireEvent): void {
|
|
for (const listener of [...this.listeners]) listener(event);
|
|
}
|
|
}
|
|
|
|
class RecordingScene implements ScenePort {
|
|
readonly calls: Array<{ readonly name: string; readonly value?: unknown }> = [];
|
|
onCall: (name: string, value?: unknown) => void = () => {};
|
|
private record(name: string, value?: unknown): void {
|
|
this.calls.push(value === undefined ? { name } : { name, value });
|
|
this.onCall(name, value);
|
|
}
|
|
showLoading(): void { this.record('loading'); }
|
|
showLogin(): void { this.record('login'); }
|
|
showLobby(): void { this.record('lobby'); }
|
|
showRoom(): void { this.record('room'); }
|
|
showReconnect(): void { this.record('reconnect'); }
|
|
showKicked(data: unknown): void { this.record('kicked', data); }
|
|
showFatal(error: Error): void { this.record('fatal', error); }
|
|
}
|
|
|
|
function makeGameEntry(overrides: Partial<GameEntry> = {}): GameEntry {
|
|
return {
|
|
key: 'fixture',
|
|
gameId: '41',
|
|
route: 'fixture-game',
|
|
resolveSeatCount: () => 4,
|
|
createModule: (): GameModule => ({
|
|
attach() {},
|
|
handlePlatformEvent() {},
|
|
handleGameMessage() {},
|
|
restore() {},
|
|
dispose() {},
|
|
}),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeRuntime(config: RuntimeConfig = runtimeConfig(), entry = makeGameEntry()) {
|
|
const wire = new RecordingWireClient();
|
|
const scene = new RecordingScene();
|
|
const clock = new ManualClock();
|
|
const factoryConfigs: RuntimeConfig[] = [];
|
|
const runtime = new PlatformRuntime({
|
|
gameEntry: entry,
|
|
resolveRuntimeConfig: async () => config,
|
|
createWireClient(resolved) {
|
|
factoryConfigs.push(resolved);
|
|
return wire;
|
|
},
|
|
scene,
|
|
loadResources: async () => {},
|
|
waitForMinimumDisplay: async () => {},
|
|
getLoginDeviceSnapshot: () => DEVICE,
|
|
clock,
|
|
});
|
|
return { runtime, wire, scene, clock, factoryConfigs, config };
|
|
}
|
|
|
|
function makeLoggingEntry(log: string[], restored: unknown[], attached: GameHost[]): GameEntry {
|
|
let recording = false;
|
|
const entry = makeGameEntry({
|
|
createModule: (): GameModule => {
|
|
let host: GameHost | null = null;
|
|
return {
|
|
attach(value) {
|
|
host = value;
|
|
if (!recording) return;
|
|
attached.push(value);
|
|
log.push(`attach:${value.getSnapshot().room.roomcode}`);
|
|
},
|
|
handlePlatformEvent(event: PlatformToGameEvent) {
|
|
if (recording) log.push(`event:${event.type}`);
|
|
},
|
|
handleGameMessage() {},
|
|
restore(deskinfo) {
|
|
if (!recording) return;
|
|
assert.ok(host);
|
|
restored.push(deskinfo);
|
|
log.push('restore');
|
|
},
|
|
dispose() {
|
|
if (!recording) return;
|
|
assert.ok(host);
|
|
host.getSnapshot();
|
|
log.push('dispose');
|
|
},
|
|
};
|
|
},
|
|
});
|
|
Object.defineProperty(entry, 'beginRecording', {
|
|
value: () => { recording = true; },
|
|
});
|
|
return entry;
|
|
}
|
|
|
|
function beginEntryRecording(entry: GameEntry): void {
|
|
(entry as GameEntry & { beginRecording(): void }).beginRecording();
|
|
}
|
|
|
|
test('start resolves config, subscribes before connect, and never logs in without an account', async () => {
|
|
const setup = makeRuntime();
|
|
|
|
await setup.runtime.start();
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
|
|
assert.equal(setup.factoryConfigs.length, 1);
|
|
assert.equal(setup.factoryConfigs[0], setup.config);
|
|
assert.deepEqual(setup.wire.lifecycle, ['subscribe', 'start']);
|
|
assert.deepEqual(setup.wire.sent, []);
|
|
assert.equal(setup.runtime.ready, true);
|
|
assert.deepEqual(setup.scene.calls.map((call) => call.name), ['loading', 'login']);
|
|
});
|
|
|
|
test('login sends one exact request and an ordinary reopen resends the same data with a four-second guard', async () => {
|
|
const setup = makeRuntime();
|
|
await setup.runtime.start();
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
|
|
setup.runtime.login(ACCOUNT);
|
|
|
|
assert.deepEqual(setup.wire.sent[0], {
|
|
app: 'youle',
|
|
route: 'agent',
|
|
rpc: 'player_login',
|
|
data: {
|
|
agentid: 'veRa0qrBf', gameid: '41', openid: 'o1', nickname: '测试号',
|
|
avatar: 'http://a', sex: 0, province: '江西', city: '南昌',
|
|
unionid: 'test_unionid', version: 10000, channelid: 'FtJf073aa',
|
|
marketid: 4, ip: '127.0.0.1', location: DEVICE.location,
|
|
machineid: 'machine-1', machineroom: 'room-install-1',
|
|
},
|
|
});
|
|
assert.deepEqual([...setup.clock.timers.values()].map((timer) => timer.ms), [4000]);
|
|
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
|
|
});
|
|
assert.equal(setup.clock.timers.size, 0);
|
|
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
|
|
assert.equal(setup.wire.sent.length, 2);
|
|
assert.equal(setup.wire.sent[1]?.rpc, 'player_login');
|
|
assert.equal(setup.wire.sent[1]?.data, setup.wire.sent[0]?.data);
|
|
assert.deepEqual([...setup.clock.timers.values()].map((timer) => timer.ms), [4000]);
|
|
setup.clock.runOnlyTimer();
|
|
assert.equal(setup.wire.reconnectCalls, 1);
|
|
});
|
|
|
|
for (const mismatch of [
|
|
{ label: 'different value', configGameId: '42', entryGameId: '41' },
|
|
{ label: 'different type', configGameId: '41', entryGameId: 41 },
|
|
] as const) {
|
|
test(`gameid ${mismatch.label} fails fatally before WireClient creation`, async () => {
|
|
const setup = makeRuntime(
|
|
runtimeConfig(mismatch.configGameId),
|
|
makeGameEntry({ gameId: mismatch.entryGameId }),
|
|
);
|
|
|
|
await assert.rejects(() => setup.runtime.start(), /gameid/i);
|
|
await assert.rejects(() => setup.runtime.start(), /fatal/i);
|
|
|
|
assert.equal(setup.factoryConfigs.length, 0);
|
|
assert.deepEqual(setup.wire.lifecycle, []);
|
|
const fatalCalls = setup.scene.calls.filter((call) => call.name === 'fatal');
|
|
assert.equal(fatalCalls.length, 1);
|
|
assert.ok(fatalCalls[0]?.value instanceof Error);
|
|
});
|
|
}
|
|
|
|
for (const switchCase of [
|
|
{
|
|
label: 'room',
|
|
route: 'room',
|
|
rpc: 'connect_roomserver',
|
|
target: 'ws://room.example:3088',
|
|
data: { roomserver: 'ws://room.example:3088', epoch: 7, nested: { trace: 'r' } },
|
|
},
|
|
{
|
|
label: 'agent',
|
|
route: 'agent',
|
|
rpc: 'connect_agentserver',
|
|
target: 'wss://agent.example/socket',
|
|
data: {
|
|
agentserver: 'wss://agent.example/socket',
|
|
opt: 'free_room',
|
|
nested: { trace: 'a' },
|
|
},
|
|
},
|
|
] as const) {
|
|
test(`${switchCase.label} switch resends the exact switch envelope before returning to steady login`, async () => {
|
|
const setup = makeRuntime();
|
|
await setup.runtime.start();
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
setup.runtime.login(ACCOUNT);
|
|
const loginEnvelope = setup.wire.sent[0]!;
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
|
|
});
|
|
setup.wire.sent.length = 0;
|
|
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: switchCase.route, rpc: switchCase.rpc, data: switchCase.data },
|
|
});
|
|
|
|
assert.deepEqual(setup.wire.switchCalls, [switchCase.target]);
|
|
assert.equal(setup.wire.sent.length, 0);
|
|
|
|
setup.wire.emit({ type: 'open', server: switchCase.target });
|
|
|
|
assert.equal(setup.wire.sent.length, 1);
|
|
assert.equal(setup.wire.sent[0]?.rpc, switchCase.rpc);
|
|
assert.deepEqual(setup.wire.sent[0], {
|
|
app: 'youle',
|
|
route: switchCase.route,
|
|
rpc: switchCase.rpc,
|
|
data: switchCase.data,
|
|
});
|
|
assert.equal(setup.wire.sent[0]?.data, switchCase.data);
|
|
assert.equal(setup.clock.timers.size, 0, 'switch resend must not start the login guard');
|
|
|
|
setup.wire.emit({ type: 'open', server: switchCase.target });
|
|
|
|
assert.equal(setup.wire.sent.length, 2);
|
|
assert.equal(setup.wire.sent[1]?.rpc, 'player_login');
|
|
assert.equal(setup.wire.sent[1]?.data, loginEnvelope.data);
|
|
assert.deepEqual([...setup.clock.timers.values()].map((timer) => timer.ms), [4000]);
|
|
});
|
|
}
|
|
|
|
test('successful login without a room shows the lobby', async () => {
|
|
const setup = makeRuntime();
|
|
await setup.runtime.start();
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
setup.runtime.login(ACCOUNT);
|
|
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
|
|
});
|
|
|
|
assert.equal(setup.runtime.state.room.kind, 'outside');
|
|
assert.equal(setup.scene.calls[setup.scene.calls.length - 1]?.name, 'lobby');
|
|
});
|
|
|
|
test('room login commits and opens before showRoom, then restores the exact deskinfo', async () => {
|
|
const log: string[] = [];
|
|
const restored: unknown[] = [];
|
|
const attached: GameHost[] = [];
|
|
const entry = makeLoggingEntry(log, restored, attached);
|
|
const setup = makeRuntime(runtimeConfig(), entry);
|
|
setup.scene.onCall = (name) => { if (name === 'room') log.push('scene:room'); };
|
|
await setup.runtime.start();
|
|
beginEntryRecording(entry);
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
setup.runtime.login(ACCOUNT);
|
|
const roomLogin = fixture('player-login-room.json');
|
|
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'player_login', data: roomLogin },
|
|
});
|
|
|
|
assert.equal(setup.runtime.state.room.kind, 'inside');
|
|
assert.deepEqual(log, [
|
|
'attach:100001',
|
|
'event:room.entered',
|
|
'scene:room',
|
|
'restore',
|
|
]);
|
|
assert.deepEqual(restored, [roomLogin.deskinfo]);
|
|
assert.equal(restored[0], roomLogin.deskinfo);
|
|
assert.equal(attached.length, 1);
|
|
});
|
|
|
|
for (const withDeskinfo of [false, true]) {
|
|
test(`self join opens and shows the room ${withDeskinfo ? 'before restoring deskinfo' : 'without restoring absent deskinfo'}`, async () => {
|
|
const log: string[] = [];
|
|
const restored: unknown[] = [];
|
|
const attached: GameHost[] = [];
|
|
const entry = makeLoggingEntry(log, restored, attached);
|
|
const setup = makeRuntime(runtimeConfig(), entry);
|
|
setup.scene.onCall = (name) => { if (name === 'room') log.push('scene:room'); };
|
|
await setup.runtime.start();
|
|
beginEntryRecording(entry);
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
setup.runtime.login(ACCOUNT);
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
|
|
});
|
|
log.length = 0;
|
|
const join = fixture('self-join-room.json');
|
|
const deskinfo = join.deskinfo;
|
|
if (!withDeskinfo) delete join.deskinfo;
|
|
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'self_join_room', data: join },
|
|
});
|
|
|
|
assert.deepEqual(log, withDeskinfo
|
|
? ['attach:100001', 'event:room.entered', 'scene:room', 'restore']
|
|
: ['attach:100001', 'event:room.entered', 'scene:room']);
|
|
assert.deepEqual(restored, withDeskinfo ? [deskinfo] : []);
|
|
if (withDeskinfo) assert.equal(restored[0], deskinfo);
|
|
});
|
|
}
|
|
|
|
test('slow and reconnecting show reconnect without clearing or replacing room state', async () => {
|
|
const setup = makeRuntime();
|
|
await setup.runtime.start();
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
setup.runtime.login(ACCOUNT);
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') },
|
|
});
|
|
const roomState = setup.runtime.state;
|
|
const callsBefore = setup.scene.calls.length;
|
|
|
|
setup.wire.emit({ type: 'slow' });
|
|
setup.wire.emit({ type: 'reconnecting', server: 'ws://agent' });
|
|
|
|
assert.equal(setup.runtime.state, roomState);
|
|
assert.equal(setup.runtime.state.room.kind, 'inside');
|
|
assert.deepEqual(
|
|
setup.scene.calls.slice(callsBefore).map((call) => call.name),
|
|
['reconnect', 'reconnect'],
|
|
);
|
|
});
|
|
|
|
test('kick closes the game before showing kicked and stopping the wire', async () => {
|
|
const log: string[] = [];
|
|
const restored: unknown[] = [];
|
|
const attached: GameHost[] = [];
|
|
const entry = makeLoggingEntry(log, restored, attached);
|
|
const setup = makeRuntime(runtimeConfig(), entry);
|
|
setup.scene.onCall = (name) => { if (name === 'kicked') log.push('scene:kicked'); };
|
|
setup.wire.onAction = (name) => { if (name === 'stop') log.push('wire:stop'); };
|
|
await setup.runtime.start();
|
|
beginEntryRecording(entry);
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
setup.runtime.login(ACCOUNT);
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') },
|
|
});
|
|
log.length = 0;
|
|
const kick = { msg: '检查到新版本', code: 1 };
|
|
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'kick_server', data: kick },
|
|
});
|
|
|
|
assert.deepEqual(log, ['dispose', 'scene:kicked', 'wire:stop']);
|
|
assert.equal(setup.wire.stopCalls, 1);
|
|
assert.equal(setup.scene.calls[setup.scene.calls.length - 1]?.value, kick);
|
|
|
|
const sceneCalls = setup.scene.calls.length;
|
|
setup.wire.emit({ type: 'reconnecting', server: 'ws://agent' });
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
assert.equal(setup.scene.calls.length, sceneCalls, 'late wire events stay silent after kick');
|
|
assert.equal(setup.wire.sent.length, 1, 'late open never revives login after kick');
|
|
});
|
|
|
|
test('a game rpc named like a platform rpc cannot drive platform scenes', async () => {
|
|
const setup = makeRuntime();
|
|
await setup.runtime.start();
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
setup.runtime.login(ACCOUNT);
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') },
|
|
});
|
|
const sceneCalls = setup.scene.calls.length;
|
|
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'fixture-game', rpc: 'self_exit_room', data: { reason: 'game-owned' } },
|
|
});
|
|
|
|
assert.equal(setup.runtime.state.room.kind, 'inside');
|
|
assert.equal(setup.scene.calls.length, sceneCalls);
|
|
});
|
|
|
|
test('joinRoom, prepare, and exitRoom delegate through the authoritative platform commands', async () => {
|
|
const setup = makeRuntime();
|
|
await setup.runtime.start();
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
setup.runtime.login(ACCOUNT);
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-success.json') },
|
|
});
|
|
setup.wire.sent.length = 0;
|
|
const location = { latitude: 28.7, longitude: 115.8 };
|
|
|
|
setup.runtime.joinRoom({
|
|
roomcode: '100001',
|
|
location,
|
|
ip: '203.0.113.7',
|
|
vipMatch: 1,
|
|
match_id: 'match-9',
|
|
});
|
|
|
|
assert.deepEqual(setup.wire.sent, [{
|
|
app: 'youle',
|
|
route: 'agent',
|
|
rpc: 'self_join_room',
|
|
data: {
|
|
agentid: 'veRa0qrBf',
|
|
playerid: 430511,
|
|
gameid: '41',
|
|
roomcode: '100001',
|
|
location,
|
|
ip: '203.0.113.7',
|
|
vipMatch: 1,
|
|
match_id: 'match-9',
|
|
},
|
|
}]);
|
|
assert.equal((setup.wire.sent[0]!.data as { location: unknown }).location, location);
|
|
|
|
const joinedRoom = fixture('self-join-room.json');
|
|
delete joinedRoom.deskinfo;
|
|
joinedRoom.deskwar = 0;
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'self_join_room', data: joinedRoom },
|
|
});
|
|
setup.wire.sent.length = 0;
|
|
setup.runtime.prepare();
|
|
setup.runtime.exitRoom();
|
|
|
|
assert.deepEqual(setup.wire.sent, [
|
|
{
|
|
app: 'youle',
|
|
route: 'room',
|
|
rpc: 'player_prepare',
|
|
data: {
|
|
agentid: 'veRa0qrBf', playerid: 430511, gameid: '41', roomcode: '100001',
|
|
},
|
|
},
|
|
{
|
|
app: 'youle',
|
|
route: 'room',
|
|
rpc: 'self_exit_room',
|
|
data: {
|
|
agentid: 'veRa0qrBf', playerid: 430511, gameid: '41', roomcode: '100001',
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
test('stop unsubscribes, disposes while the host is live, invalidates it, then stops the wire', async () => {
|
|
const log: string[] = [];
|
|
const restored: unknown[] = [];
|
|
const attached: GameHost[] = [];
|
|
const entry = makeLoggingEntry(log, restored, attached);
|
|
const setup = makeRuntime(runtimeConfig(), entry);
|
|
setup.wire.onAction = (name) => {
|
|
if (name === 'unsubscribe' || name === 'stop') log.push(`wire:${name}`);
|
|
};
|
|
await setup.runtime.start();
|
|
beginEntryRecording(entry);
|
|
setup.wire.emit({ type: 'open', server: 'ws://agent' });
|
|
setup.runtime.login(ACCOUNT);
|
|
setup.wire.emit({
|
|
type: 'message',
|
|
message: { route: 'agent', rpc: 'player_login', data: fixture('player-login-room.json') },
|
|
});
|
|
const activeHost = attached[0]!;
|
|
log.length = 0;
|
|
|
|
setup.runtime.stop();
|
|
|
|
assert.deepEqual(log, ['wire:unsubscribe', 'dispose', 'wire:stop']);
|
|
assert.throws(() => activeHost.getSnapshot(), /disposed/i);
|
|
setup.runtime.stop();
|
|
assert.deepEqual(log, ['wire:unsubscribe', 'dispose', 'wire:stop']);
|
|
assert.equal(setup.wire.stopCalls, 1);
|
|
});
|