Files
wikideck/tests/host-pvp-binding.test.ts

186 lines
11 KiB
TypeScript

// host-pvp (#56) part 2: the duel binding, ChainCard → DuelCard, the ownership adapter and
// built-in duel modes. Uses docs/game/card-sample.json only: zero network calls.
import test from 'node:test';
import assert from 'node:assert/strict';
import { readFileSync } from 'node:fs';
import express from 'express';
import { derive } from '../shared/duel/derive.ts';
import { sampleInputs, type SampleCard } from '../shared/duel/sample.ts';
import * as duelApi from '../shared/duel/index.ts';
import { buildIdentity, toProfile } from '../server/game/identity.ts';
import { toDuelCard, duelBinding } from '../server/game/duel-binding.ts';
import { gameRouter, ownershipPortFrom } from '../server/game/index.ts';
import { ModeHost } from '../server/game/host.ts';
import { MatchStore } from '../server/game/store.ts';
import { parseMode, MODE_SCHEMA_VERSION } from '../shared/game/modes.ts';
import { loadModes } from '../server/game/config.ts';
import type { ChainCard, EnginePort, OwnershipPort } from '../server/game/engine-port.ts';
const SAMPLE = (JSON.parse(readFileSync(new URL('../docs/game/card-sample.json', import.meta.url), 'utf8')) as { cards: SampleCard[] }).cards;
/** A ChainCard as ownership.ts builds it from a block, here from a sample card. */
function chainCard(s: SampleCard, owner = 'wallet'): ChainCard {
const { chain } = sampleInputs(s);
return { tokenId: chain.tokenId, owner, confirmations: 5, pageId: s.pageId, title: s.title, revisionId: s.revisionId,
article: { ...chain.article, url: `https://en.wikipedia.org/?curid=${s.pageId}` },
statsSnapshot: { ...chain.statsSnapshot, revisionId: s.revisionId } };
}
test('host-pvp binding: toDuelCard uses the frozen identity, deterministically', () => {
const s = SAMPLE[0]!;
const card = chainCard(s);
const ident = buildIdentity({ tokenId: card.tokenId, pageId: s.pageId, title: s.title, revisionId: s.revisionId },
{ description: s.description, wikidataId: s.wikidataId, categories: s.categories, instanceOf: s.instanceOf } as any,
'cache', new Date('2026-11-17T00:00:00Z'));
const identity = { get: (t: string) => (t === card.tokenId ? ident : undefined) };
const a = toDuelCard(card, { identity });
assert.deepEqual(a, derive(sampleInputs(s).chain, toProfile(ident) as any), 'same as derive(chain, frozen profile)');
assert.deepEqual(toDuelCard(card, { identity }), a, 'deterministic');
// A miss falls back to what the chain carries: still a legal card, no fetch.
const fallback = toDuelCard(card, {});
assert.equal(fallback.pageId, s.pageId);
assert.ok(fallback.cost >= 1 && fallback.cost <= 6);
assert.throws(() => toDuelCard({ ...card, article: undefined }), /no on-chain article/);
});
test('host-pvp binding: the ownership adapter passes the account and options through', async () => {
const seen: unknown[] = [];
const deps = {
ledger: { nft: () => undefined, deck: () => ({ tip: 't', total: 0, next: null, nfts: [] }), summary: () => ({ tip: 't', height: 1 }) },
accounts: { wallets: (sub: string) => { seen.push(sub); return []; } },
verifyIdToken: async (t: string) => { if (t !== 'a.b.c') throw Object.assign(new Error('Token expired'), { status: 401 });
return { sub: 'alice', issuer: 'https://dex.test', name: 'Alice', username: 'alice' }; },
};
const port: OwnershipPort = ownershipPortFrom(deps as any);
const acct = await port.verifyAccount('a.b.c');
assert.equal(acct.sub, 'alice');
await assert.rejects(port.verifyAccount('x.y.z'), (e: any) => e.status === 401);
assert.deepEqual(await port.collection(acct), []);
await assert.rejects(port.resolveDeck(acct, ['a'.repeat(64)], { deckSize: 40, maxCopiesPerPage: 4, minConfirmations: 1 }),
(e: any) => e.status >= 400 && e.status < 500);
assert.ok(seen.includes('alice'));
});
test('host-pvp binding: built-in duel modes parse; Edit War ids moved to edit-war*', () => {
const modes = loadModes({});
assert.deepEqual(modes.map(m => [m.id, m.engine]), [['classic', 'duel'], ['draft', 'duel'], ['trending', 'duel'], ['edit-war', 'editwar']]);
const classic = modes[0]!;
assert.equal(classic.limits.rated, true);
assert.equal(classic.decks.kind, 'constructed');
const draft = modes[1]!;
assert.ok(draft.decks.kind === 'draft' && draft.decks.source === 'collections' && draft.decks.poolSize >= 80);
});
test('host-pvp binding: duel modes are skipped (not fatal) when the build has no duel engine', async () => {
const hasEngine = typeof (duelApi as Record<string, any>).duelEnginePort?.createMatch === 'function';
const app = express();
app.use('/api/game', await gameRouter({ dataDir: null, warmTrends: false, handleSignals: false,
env: { WIKIDECK_MODES: 'classic,edit-war', PUBLIC_ORIGIN: 'http://127.0.0.1:3101', WIKIDECK_GAME_PEERS: '' } }));
const server = app.listen(0);
try {
const list = await (await fetch(`http://127.0.0.1:${(server.address() as any).port}/api/game/modes`)).json();
assert.deepEqual(list.modes.map((m: any) => m.mode.id), hasEngine ? ['classic', 'edit-war'] : ['edit-war']);
} finally { server.close(); }
});
const realPort = (duelApi as Record<string, any>).duelEnginePort as EnginePort<any, any, any, any> | undefined;
test('host-pvp binding: two scripted players finish a hosted 40-card duel on the real engine', { skip: !realPort && 'duel engine alpha not merged yet' }, async () => {
const engine = duelBinding(realPort!);
const alice = SAMPLE.slice(0, 40).map(s => chainCard(s, 'wallet-alice'));
const bob = SAMPLE.slice(40, 80).map(s => chainCard(s, 'wallet-bob'));
const owned: Record<string, ChainCard[]> = { alice, bob };
const ownership: OwnershipPort = {
verifyAccount: async t => ({ sub: String(t), issuer: 'https://dex.test', name: String(t) }),
resolveDeck: async (a, ids) => (ids as string[]).map(id => { const c = owned[a.sub]!.find(x => x.tokenId === id);
if (!c) throw Object.assign(new Error('not yours'), { status: 403 }); return c; }),
collection: async a => owned[a.sub] ?? [],
};
const mode = parseMode({ schema: MODE_SCHEMA_VERSION, engine: 'duel', id: 'classic', version: 1, name: 'Classic', description: 'x',
decks: { kind: 'constructed', minConfirmations: 1 }, limits: { rated: true } });
const host = new ModeHost({ identity: { origin: 'http://node.test', operator: 'T' }, modes: [mode], engines: { duel: engine },
ownership, store: new MatchStore(null) });
const a = await host.createLobby('classic', { idToken: 'alice', deck: alice.map(c => c.tokenId) });
const b = await host.join(a.lobbyId, { idToken: 'bob', deck: bob.map(c => c.tokenId) });
await assert.rejects(host.join(a.lobbyId, { idToken: 'bob', deck: bob.map(c => c.tokenId) }), /no longer open/);
const tokens = [a.token, b.token];
for (let i = 0; i < 4000; i++) {
const v = host.view(a.lobbyId, a.token) as any;
if (v.phase !== 'playing') break;
let moved = false;
for (const t of tokens) {
const sv = host.view(a.lobbyId, t) as any;
if (sv.legalActions?.length) { await host.act(a.lobbyId, t, sv.legalActions[i % sv.legalActions.length]); moved = true; break; }
}
assert.ok(moved, 'someone can always act');
}
const end = host.view(a.lobbyId, a.token) as any;
assert.equal(end.phase, 'finished');
const rec = host.matchRecord(end.matchId);
assert.equal(rec.decks[0]!.length, 40);
assert.equal(rec.engine, 'duel');
// Anyone can audit: replaying the record reproduces the result.
const api = duelApi as Record<string, any>;
if (typeof api.replay === 'function') {
const replayed = api.replay(rec.rules, rec.decks, rec.seed, rec.actions);
assert.equal(api.result(replayed)?.winner ?? null, rec.winner);
}
});
test('host-pvp binding: gameRouter mounts GET /collection when ownership deps are given', async () => {
const deps = {
ledger: { nft: () => undefined, deck: () => ({ tip: 't', total: 0, next: null, nfts: [] }), summary: () => ({ tip: 't', height: 1 }) },
accounts: { wallets: () => [] },
verifyIdToken: async (t: string) => { if (t !== 'a.b.c') throw Object.assign(new Error('Token expired'), { status: 401 });
return { sub: 'alice', issuer: 'https://dex.test', name: 'Alice', username: 'alice' }; },
};
const app = express();
app.use('/api/game', await gameRouter({ dataDir: null, warmTrends: false, handleSignals: false, ownership: deps as any,
env: { WIKIDECK_MODES: 'edit-war', PUBLIC_ORIGIN: 'http://127.0.0.1:3101', WIKIDECK_GAME_PEERS: '' } }));
const server = app.listen(0);
try {
const base = `http://127.0.0.1:${(server.address() as any).port}/api/game`;
assert.equal((await fetch(`${base}/collection`)).status, 401);
const ok = await fetch(`${base}/collection`, { headers: { authorization: 'Bearer a.b.c' } });
assert.equal(ok.status, 200);
assert.deepEqual((await ok.json()).cards, []);
assert.equal((await fetch(`${base}/modes`)).status, 200, 'the game routes still answer');
} finally { server.close(); }
});
/** server/wiki.ts's mint-time category(), reproduced for the sample (it is not exported). */
function mintCategory(title: string, categories: string[]): string {
const text = `${title} ${categories.join(' ')}`.toLowerCase();
if (/astronom|planet|space|galax|moon|star\b/.test(text)) return 'Space';
if (/animal|plant|species|ocean|biolog|mollusc/.test(text)) return 'Nature';
if (/births|deaths|people|scientist/.test(text)) return 'People';
if (/physic|chem|math|science|technolog/.test(text)) return 'Science';
if (/histor|ancient|archaeolog|empire/.test(text)) return 'History';
return 'Culture';
}
test('host-pvp binding: without a frozen identity, cards are typed from on-chain data, not all Doctrine (night-review P1)', () => {
const types: Record<string, number> = {};
for (const s of SAMPLE) {
const c = chainCard(s);
(c.article as any).category = mintCategory(s.title, s.categories);
const d = toDuelCard(c, {});
types[d.type] = (types[d.type] ?? 0) + 1;
assert.equal(d.typedBy, 'fallback');
assert.equal(d.description, undefined, 'no fabricated short description');
assert.ok(!d.connect.p31.includes(''), 'hints never become Connected keys');
}
assert.ok((types.Doctrine ?? 0) < SAMPLE.length / 2, JSON.stringify(types));
assert.ok((types.Figure ?? 0) >= 40, JSON.stringify(types));
// The extract's first sentence wins over the category hint.
const s = SAMPLE[0]!;
const battle = chainCard(s);
(battle.article as any).extract = 'The Battle of Somewhere was a battle fought in 1548. It was long.';
(battle.article as any).category = 'People';
assert.equal(toDuelCard(battle, {}).type, 'Event');
const pol = chainCard(s);
(pol.article as any).extract = 'Jane Doe is an American politician.';
(pol.article as any).category = 'Culture';
assert.equal(toDuelCard(pol, {}).type, 'Figure');
});