105 lines
2.9 KiB
TypeScript
105 lines
2.9 KiB
TypeScript
import assert from 'node:assert/strict';
|
|
import { test } from 'node:test';
|
|
import type {
|
|
GameEntry,
|
|
GameHost,
|
|
GameModule,
|
|
PlatformGameSnapshot,
|
|
} from '../../YouleNexus/assets/framework/sdk/contracts/index.ts';
|
|
import {
|
|
assertGameContract,
|
|
type GameContractHost,
|
|
} from '../../YouleNexus/assets/framework/sdk/testing/game-contract-harness.ts';
|
|
|
|
test('assertGameContract runs the reusable isolated session conformance suite', () => {
|
|
let invalidations = 0;
|
|
let nextModuleId = 0;
|
|
const restoredDeskinfo: unknown[] = [];
|
|
const entry: GameEntry = {
|
|
key: 'fixture',
|
|
gameId: 41,
|
|
route: 'fixture-route',
|
|
resolveSeatCount: (roomtype) => {
|
|
const seats = roomtype[0];
|
|
if (seats === 2 || seats === 4 || seats === 10) return seats;
|
|
return 4;
|
|
},
|
|
createModule: () => makeModule(++nextModuleId, (deskinfo) => { restoredDeskinfo.push(deskinfo); }),
|
|
};
|
|
|
|
assert.doesNotThrow(() => assertGameContract(
|
|
entry,
|
|
makeConformanceHost(() => { invalidations++; }, restoredDeskinfo),
|
|
));
|
|
assert.equal(invalidations, 2);
|
|
assert.equal(restoredDeskinfo.length, 0);
|
|
assert.ok(nextModuleId >= 2);
|
|
});
|
|
|
|
function makeModule(id: number, onRestore: (deskinfo: unknown) => void): GameModule {
|
|
let host: GameHost | undefined;
|
|
let restored: unknown;
|
|
let eventCount = 0;
|
|
let messageCycle: number | undefined;
|
|
return {
|
|
attach(value) { host = value; },
|
|
handlePlatformEvent(event) {
|
|
eventCount++;
|
|
if (event.type === 'room.entered') {
|
|
assert.equal(event.roomtype[0], 4);
|
|
}
|
|
},
|
|
handleGameMessage(message) {
|
|
assert.equal(message.rpc, 'conformance.message');
|
|
const data = message.data as { cycle: number };
|
|
assert.equal(typeof data.cycle, 'number');
|
|
messageCycle = data.cycle;
|
|
},
|
|
restore(deskinfo) {
|
|
restored = deskinfo;
|
|
onRestore(deskinfo);
|
|
},
|
|
dispose() {
|
|
if (!host) {
|
|
assert.equal(eventCount, 0);
|
|
assert.equal(restored, undefined);
|
|
return;
|
|
}
|
|
assert.ok(host);
|
|
assert.equal(eventCount, 1);
|
|
assert.deepEqual(restored, deskinfoFor(messageCycle!));
|
|
},
|
|
};
|
|
}
|
|
|
|
function deskinfoFor(cycle: number): { readonly cycle: number } {
|
|
return { cycle };
|
|
}
|
|
|
|
function makeConformanceHost(
|
|
onInvalidate: () => void,
|
|
restoredDeskinfo: unknown[],
|
|
): () => GameContractHost {
|
|
return () => {
|
|
const snapshot: PlatformGameSnapshot = {
|
|
connection: { phase: 'connected' },
|
|
self: { playerId: 1, seat: 0 },
|
|
room: { roomcode: 'fixture', roomtype: [], stage: 0, needprepare: 0, infinite: 0 },
|
|
seats: [],
|
|
};
|
|
return {
|
|
host: {
|
|
seat: { toView: (seat) => seat, toServer: (seat) => seat },
|
|
getSnapshot: () => snapshot,
|
|
subscribe: () => () => {},
|
|
sendGameMessage: () => {},
|
|
execute: () => {},
|
|
},
|
|
invalidate: onInvalidate,
|
|
assertRestored(deskinfo) {
|
|
assert.equal(restoredDeskinfo.shift(), deskinfo);
|
|
},
|
|
};
|
|
};
|
|
}
|