833 lines
40 KiB
TypeScript
833 lines
40 KiB
TypeScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { spawnSync } from 'node:child_process';
|
|
import {
|
|
existsSync,
|
|
mkdtempSync,
|
|
readFileSync,
|
|
readdirSync,
|
|
rmSync,
|
|
statSync,
|
|
writeFileSync,
|
|
} from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
|
|
import type { Game } from '../game/engine';
|
|
import { isAuditorLeader, treacheryDeck } from '../game/cards';
|
|
import { richeseCards } from '../game/richese-cards';
|
|
import { STRONGHOLD_CARDS } from '../game/stronghold-cards';
|
|
import { sampleInventory, verifySampleCustody } from '../tools/sample-custody';
|
|
import { createTechTokens } from '../game/tech-tokens';
|
|
const root = new URL('../', import.meta.url).pathname;
|
|
const cli = new URL('../tools/faction-games.ts', import.meta.url).pathname;
|
|
type CliResult = {
|
|
name: string;
|
|
seed: number;
|
|
resumed: boolean;
|
|
outcome: string;
|
|
error?: string;
|
|
actions: number;
|
|
attempts: number;
|
|
};
|
|
type CliReport = {
|
|
status: string;
|
|
sourceUnchanged: boolean;
|
|
before: { commit: string; tree: string };
|
|
after: { commit: string; tree: string };
|
|
options: {
|
|
seed: number;
|
|
profile: string;
|
|
rules: string;
|
|
maxActions: number;
|
|
players: number | 'all';
|
|
resume?: { path: string; sha256: string };
|
|
};
|
|
results: CliResult[];
|
|
};
|
|
|
|
function run(out: string, ...args: string[]) {
|
|
const env = { ...process.env };
|
|
delete env.NODE_TEST_CONTEXT;
|
|
const result = spawnSync(
|
|
process.execPath,
|
|
['--import', import.meta.resolve('tsx'), cli, '--out', out, ...args],
|
|
{ cwd: root, env, encoding: 'utf8', timeout: 30_000 },
|
|
);
|
|
assert.ifError(result.error);
|
|
return result;
|
|
}
|
|
|
|
function temporary(t: test.TestContext) {
|
|
const directory = mkdtempSync(join(tmpdir(), 'dune-faction-games-cli-'));
|
|
t.after(() => rmSync(directory, { recursive: true, force: true }));
|
|
return directory;
|
|
}
|
|
|
|
function json<T>(path: string): T {
|
|
return JSON.parse(readFileSync(path, 'utf8')) as T;
|
|
}
|
|
|
|
function assertFailedEvidence(
|
|
out: string,
|
|
name: string,
|
|
expectedSeed: number,
|
|
resumed: boolean,
|
|
expectedCount = 1,
|
|
) {
|
|
const report = json<CliReport>(join(out, 'report.json'));
|
|
const results = json<{ results: CliResult[] }>(join(out, 'results.json'));
|
|
assert.equal(report.status, 'failed');
|
|
assert.equal(report.sourceUnchanged, true);
|
|
assert.equal(report.before.commit, report.after.commit);
|
|
assert.equal(report.before.tree, report.after.tree);
|
|
assert.match(report.before.commit, /\S/);
|
|
assert.match(report.before.tree, /^[a-f\d]{64}$/);
|
|
assert.equal(report.results.length, expectedCount);
|
|
assert.equal(results.results.length, expectedCount);
|
|
for (const result of [report.results.find(row => row.name === name), results.results.find(row => row.name === name)]) {
|
|
assert.ok(result);
|
|
assert.equal(result.name, name);
|
|
assert.equal(result.seed, expectedSeed);
|
|
assert.equal(result.resumed, resumed);
|
|
assert.equal(result.outcome, 'failure');
|
|
assert.ok(result.actions > 0);
|
|
assert.ok(result.attempts > 0);
|
|
}
|
|
const trace = json<unknown[]>(join(out, `trace-${name}.json`));
|
|
assert.ok(Array.isArray(trace) && trace.length > 0);
|
|
assert.ok(existsSync(join(out, `failed-${name}.json`)));
|
|
for (const file of readdirSync(out))
|
|
assert.equal(statSync(join(out, file)).mode & 0o777, 0o600);
|
|
return report;
|
|
}
|
|
|
|
void test('native Stronghold samples admit every two-to-six-seat roster and preserve canonical physical inventories', (t) => {
|
|
const area = temporary(t);
|
|
const out = join(area, 'native');
|
|
assert.equal(run(out, '--profile', 'stronghold-factions',
|
|
'--players', 'all', '--seed', '1000', '--max-actions', '1').status, 1);
|
|
const results = json<{ results: CliResult[] }>(join(out, 'results.json')).results;
|
|
const families = [
|
|
{ native: 'ixians-choam', expansions: ['ix', 'choam'],
|
|
roster: ['ixians', 'choam', 'emperor', 'fremen', 'harkonnen', 'beneGesserit'], counts: [2, 3, 4, 5, 6], ordinal: 151 },
|
|
{ native: 'ixians-tleilaxu', expansions: ['ix'],
|
|
roster: ['ixians', 'tleilaxu', 'emperor', 'fremen', 'harkonnen', 'beneGesserit'], counts: [2, 3, 4, 5, 6], ordinal: 156 },
|
|
{ native: 'choam-richese', expansions: ['choam'],
|
|
roster: ['choam', 'richese', 'emperor', 'fremen', 'harkonnen', 'beneGesserit'], counts: [2, 3, 4, 5, 6], ordinal: 161 },
|
|
{ native: 'ixians-tleilaxu-choam-richese', expansions: ['ix', 'choam'],
|
|
roster: ['ixians', 'tleilaxu', 'choam', 'richese', 'emperor', 'fremen'], counts: [4, 5, 6], ordinal: 166 },
|
|
];
|
|
const scenarios = families.flatMap(family => family.counts.map((count, index) => ({
|
|
...family, count, seed: 1000 + family.ordinal + index,
|
|
name: `stronghold-factions-${family.native}-${count}-advanced`,
|
|
})));
|
|
assert.deepEqual(results.map(result => result.name), scenarios.map(scenario => scenario.name));
|
|
for (const [index, result] of results.entries()) {
|
|
const scenario = scenarios[index];
|
|
assert.equal(result.seed, scenario.seed);
|
|
assert.equal(result.error, 'Error: Action limit');
|
|
assert.equal(result.actions, 1);
|
|
const game = json<Game>(join(out, `failed-${result.name}.json`));
|
|
assert.equal(game.advanced, true);
|
|
assert.deepEqual(game.expansions, scenario.expansions);
|
|
assert.deepEqual(game.players.map(player => player.faction), scenario.roster.slice(0, scenario.count));
|
|
assert.deepEqual(game.players.map(player => player.bot),
|
|
['Easy', 'Medium', 'Hard', 'Brutal', 'Easy', 'Medium'].slice(0, scenario.count));
|
|
const deck = treacheryDeck(scenario.expansions).map(card => card.id).sort();
|
|
assert.equal(deck.length, scenario.expansions.includes('ix') ? 47 : 35);
|
|
const cache = scenario.roster.includes('richese') ? richeseCards().map(card => card.id).sort() : [];
|
|
const inventory = sampleInventory(game);
|
|
assert.deepEqual(inventory.cards, [...deck, ...cache].sort());
|
|
assert.deepEqual((game.richeseCache ?? []).map(card => card.id).sort(), cache);
|
|
verifySampleCustody(game, inventory);
|
|
assert.deepEqual(Object.keys(game.strongholdCards!.owners).sort(),
|
|
STRONGHOLD_CARDS.map(card => card.id).sort());
|
|
assert.ok(Object.values(game.strongholdCards!.owners).every(owner => owner === null));
|
|
assert.equal(game.strongholdCards!.claimedTurn, 0);
|
|
const choam = game.players.find(player => player.faction === 'choam');
|
|
if (choam) assert.equal(choam.leaders.filter(isAuditorLeader).length, 1);
|
|
}
|
|
for (const scenario of scenarios.filter(candidate => candidate.count === 6)) {
|
|
const snapshot = join(out, `failed-${scenario.name}.json`);
|
|
const original = readFileSync(snapshot, 'utf8');
|
|
const continued = join(area, `continued-${scenario.native}`);
|
|
assert.equal(run(continued, '--resume', snapshot, '--seed', '1000',
|
|
'--max-actions', '1').status, 1);
|
|
const report = assertFailedEvidence(continued, scenario.name, scenario.seed, true);
|
|
assert.equal(report.options.resume?.path, snapshot);
|
|
verifySampleCustody(json<Game>(join(continued, `failed-${scenario.name}.json`)),
|
|
sampleInventory(json<Game>(snapshot)), json<Game>(snapshot));
|
|
assert.equal(readFileSync(snapshot, 'utf8'), original);
|
|
}
|
|
});
|
|
|
|
void test('native Stronghold admission and resume reject foreign profiles and corrupted custody before gameplay', (t) => {
|
|
const area = temporary(t);
|
|
const basic = join(area, 'basic');
|
|
assert.equal(run(basic, '--profile', 'stronghold-factions', '--rules', 'basic').status, 1);
|
|
assert.equal(existsSync(basic), false);
|
|
const out = join(area, 'native');
|
|
assert.equal(run(out, '--profile', 'stronghold-factions', '--players', '2',
|
|
'--max-actions', '1').status, 1);
|
|
const source = json<Game>(join(out, 'failed-stronghold-factions-ixians-choam-2-advanced.json'));
|
|
const corruptions: [string, (game: Game) => void][] = [
|
|
['basic', game => { game.advanced = false; }],
|
|
['wrong-deck', game => { game.expansions = ['ix']; }],
|
|
['foreign-faction', game => { game.players[1].faction = 'ecaz'; }],
|
|
['missing-module', game => { delete game.strongholdCards; }],
|
|
['nexus', game => { game.nexusCards = { cards: null, phase: null }; }],
|
|
['tech', game => { game.techTokens = createTechTokens(); }],
|
|
['missing-stronghold', game => { Reflect.deleteProperty(game.strongholdCards!.owners, 'arrakeen'); }],
|
|
['foreign-owner', game => { game.strongholdCards!.owners.arrakeen = 'foreign-seat'; }],
|
|
['future-custody', game => { game.strongholdCards!.claimedTurn = game.turn + 1; }],
|
|
['missing-treachery', game => { game.deck.pop(); }],
|
|
];
|
|
for (const [label, corrupt] of corruptions) {
|
|
const game = structuredClone(source);
|
|
corrupt(game);
|
|
const snapshot = join(area, `${label}.json`);
|
|
writeFileSync(snapshot, JSON.stringify(game), { mode: 0o600 });
|
|
const before = readFileSync(snapshot, 'utf8');
|
|
const rejected = join(area, `${label}-resume`);
|
|
assert.equal(run(rejected, '--resume', snapshot, '--max-actions', '1').status, 1, label);
|
|
assert.equal(existsSync(rejected), false, label);
|
|
assert.equal(readFileSync(snapshot, 'utf8'), before, label);
|
|
}
|
|
});
|
|
|
|
void test('Ecaz card samples keep all three physical identities through saved resume', (t) => {
|
|
const area = temporary(t);
|
|
const out = join(area, 'ecaz-cards');
|
|
const result = run(out, '--profile', 'ecaz-treachery', '--players', '2',
|
|
'--rules', 'advanced', '--seed', '1000', '--max-actions', '1');
|
|
assert.equal(result.status, 1);
|
|
assertFailedEvidence(out, 'ecaz-treachery-2-advanced', 1137, false);
|
|
const snapshot = join(out, 'failed-ecaz-treachery-2-advanced.json');
|
|
const game = json<{
|
|
ecazTreachery: boolean;
|
|
deck: { id: string }[];
|
|
discard: { id: string }[];
|
|
players: { hand: { id: string }[] }[];
|
|
}>(snapshot);
|
|
assert.equal(game.ecazTreachery, true);
|
|
assert.deepEqual(
|
|
[...game.deck, ...game.discard, ...game.players.flatMap(player => player.hand)]
|
|
.map(card => card.id).filter(id => id.startsWith('ecaz-')).sort(),
|
|
['ecaz-harass-withdraw', 'ecaz-recruits', 'ecaz-reinforcements'],
|
|
);
|
|
const resumed = join(area, 'resumed');
|
|
assert.equal(run(resumed, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(resumed, 'ecaz-treachery-2-advanced', 1137, true);
|
|
});
|
|
|
|
void test('Advanced Moritani assassination samples retain their preview and physical Traitor pool on resume', (t) => {
|
|
const area = temporary(t);
|
|
const out = join(area, 'assassinate');
|
|
assert.equal(run(out, '--profile', 'moritani-assassinate', '--players', '3',
|
|
'--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(out, 'moritani-assassinate-3-advanced', 1147, false);
|
|
const snapshot = join(out, 'failed-moritani-assassinate-3-advanced.json');
|
|
const game = json<{ advanced: boolean; moritaniAssassinatePreview: boolean;
|
|
moritaniAssassinate: { owner: string; opportunities: unknown[] };
|
|
players: { id: string; faction: string }[] }>(snapshot);
|
|
assert.equal(game.advanced, true);
|
|
assert.equal(game.moritaniAssassinatePreview, true);
|
|
assert.equal(game.moritaniAssassinate.owner, game.players.find(p => p.faction === 'moritani')?.id);
|
|
const resumed = join(area, 'resumed');
|
|
assert.equal(run(resumed, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(resumed, 'moritani-assassinate-3-advanced', 1147, true);
|
|
const unsupported = join(area, 'basic');
|
|
assert.equal(run(unsupported, '--profile', 'moritani-assassinate', '--rules', 'basic').status, 1);
|
|
assert.equal(existsSync(unsupported), false);
|
|
});
|
|
|
|
void test('Moritani Skills samples preserve full Basic and Advanced native decks through saved continuation', (t) => {
|
|
const area = temporary(t);
|
|
const out = join(area, 'skills');
|
|
const result = run(out, '--profile', 'moritani-skills', '--rules', 'basic', '--players', '2', '--seed', '1000', '--max-actions', '1');
|
|
assert.equal(result.status, 1);
|
|
assertFailedEvidence(out, 'moritani-skills-2-basic', 1016, false);
|
|
const snapshot = join(out, 'failed-moritani-skills-2-basic.json');
|
|
const game = json<{ advanced: boolean; leaderSkills: { deck: string[]; offers: Record<string, { cards: string[] }>; assignments: { skill: string }[] } }>(snapshot);
|
|
assert.equal(game.advanced, false);
|
|
const physical = [...game.leaderSkills.deck, ...Object.values(game.leaderSkills.offers).flatMap(o => o.cards), ...game.leaderSkills.assignments.map(a => a.skill)];
|
|
assert.equal(physical.length, 14); assert.equal(new Set(physical).size, 14);
|
|
const resumed = join(area, 'skills-resumed');
|
|
assert.equal(run(resumed, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(resumed, 'moritani-skills-2-basic', 1016, true);
|
|
const advanced = join(area, 'advanced');
|
|
assert.equal(run(advanced, '--profile', 'moritani-skills', '--rules', 'advanced', '--players', '2', '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(advanced, 'moritani-skills-2-advanced', 1249, false);
|
|
const state = json<typeof game>(join(advanced, 'failed-moritani-skills-2-advanced.json'));
|
|
assert.equal(state.advanced, true);
|
|
const cards = [...state.leaderSkills.deck, ...Object.values(state.leaderSkills.offers).flatMap(o => o.cards), ...state.leaderSkills.assignments.map(a => a.skill)];
|
|
assert.equal(new Set(cards).size, 14);
|
|
assert.equal(cards.length, 14);
|
|
const advancedResumed = join(area, 'advanced-resumed');
|
|
assert.equal(run(advancedResumed, '--resume', join(advanced, 'failed-moritani-skills-2-advanced.json'), '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(advancedResumed, 'moritani-skills-2-advanced', 1249, true);
|
|
});
|
|
|
|
void test('Tleilaxu Skills samples preserve full Basic and Advanced native decks through saved continuation', (t) => {
|
|
const area = temporary(t);
|
|
const out = join(area, 'skills');
|
|
const result = run(out, '--profile', 'tleilaxu-skills', '--rules', 'basic', '--players', '2', '--seed', '1000', '--max-actions', '1');
|
|
assert.equal(result.status, 1);
|
|
assertFailedEvidence(out, 'tleilaxu-skills-2-basic', 1021, false);
|
|
const snapshot = join(out, 'failed-tleilaxu-skills-2-basic.json');
|
|
const game = json<{ advanced: boolean; leaderSkills: { deck: string[]; offers: Record<string, { cards: string[] }>; assignments: { skill: string }[] } }>(snapshot);
|
|
assert.equal(game.advanced, false);
|
|
const physical = [...game.leaderSkills.deck, ...Object.values(game.leaderSkills.offers).flatMap(o => o.cards), ...game.leaderSkills.assignments.map(a => a.skill)];
|
|
assert.equal(physical.length, 14); assert.equal(new Set(physical).size, 14);
|
|
const resumed = join(area, 'skills-resumed');
|
|
assert.equal(run(resumed, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(resumed, 'tleilaxu-skills-2-basic', 1021, true);
|
|
const advanced = join(area, 'advanced');
|
|
assert.equal(run(advanced, '--profile', 'tleilaxu-skills', '--rules', 'advanced', '--players', '2', '--seed', '1000', '--max-actions', '1').status, 1);
|
|
for (const [name, seed] of [['tleilaxu-skills-2-advanced', 1235], ['tleilaxu-skills-tleilaxu-ixians-2-advanced', 1240]] as const) {
|
|
assertFailedEvidence(advanced, name, seed, false, 2);
|
|
const state = json<typeof game>(join(advanced, `failed-${name}.json`));
|
|
assert.equal(state.advanced, true);
|
|
const cards = [...state.leaderSkills.deck, ...Object.values(state.leaderSkills.offers).flatMap(o => o.cards), ...state.leaderSkills.assignments.map(a => a.skill)];
|
|
assert.equal(new Set(cards).size, 14);
|
|
assert.equal(cards.length, 14);
|
|
const continued = join(area, `advanced-resumed-${name}`);
|
|
assert.equal(run(continued, '--resume', join(advanced, `failed-${name}.json`), '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(continued, name, seed, true);
|
|
}
|
|
});
|
|
|
|
void test('Ixian Skills samples preserve full Basic and Advanced native decks through saved continuation', (t) => {
|
|
const area = temporary(t);
|
|
const out = join(area, 'skills');
|
|
const result = run(out, '--profile', 'ix-skills', '--rules', 'basic', '--players', '2', '--seed', '1000', '--max-actions', '1');
|
|
assert.equal(result.status, 1);
|
|
assertFailedEvidence(out, 'ix-skills-2-basic', 1026, false);
|
|
const snapshot = join(out, 'failed-ix-skills-2-basic.json');
|
|
const game = json<{ advanced: boolean; leaderSkills: { deck: string[]; offers: Record<string, { cards: string[] }>; assignments: { skill: string }[] } }>(snapshot);
|
|
assert.equal(game.advanced, false);
|
|
const physical = [...game.leaderSkills.deck, ...Object.values(game.leaderSkills.offers).flatMap(o => o.cards), ...game.leaderSkills.assignments.map(a => a.skill)];
|
|
assert.equal(physical.length, 14); assert.equal(new Set(physical).size, 14);
|
|
const resumed = join(area, 'skills-resumed');
|
|
assert.equal(run(resumed, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(resumed, 'ix-skills-2-basic', 1026, true);
|
|
const advanced = join(area, 'advanced');
|
|
assert.equal(run(advanced, '--profile', 'ix-skills', '--rules', 'advanced', '--players', '2', '--seed', '1000', '--max-actions', '1').status, 1);
|
|
for (const [name, seed] of [['ix-skills-2-advanced', 1220], ['ix-skills-ixians-choam-2-advanced', 1230]] as const) {
|
|
assertFailedEvidence(advanced, name, seed, false, 2);
|
|
const state = json<typeof game>(join(advanced, `failed-${name}.json`));
|
|
assert.equal(state.advanced, true);
|
|
const cards = [...state.leaderSkills.deck, ...Object.values(state.leaderSkills.offers).flatMap(o => o.cards), ...state.leaderSkills.assignments.map(a => a.skill)];
|
|
assert.equal(new Set(cards).size, 14);
|
|
assert.equal(cards.length, 14);
|
|
const continued = join(area, `advanced-resumed-${name}`);
|
|
assert.equal(run(continued, '--resume', join(advanced, `failed-${name}.json`), '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(continued, name, seed, true);
|
|
}
|
|
});
|
|
|
|
void test('CHOAM Skills samples preserve full Basic and Advanced native decks through saved continuation', (t) => {
|
|
const area = temporary(t);
|
|
const out = join(area, 'skills');
|
|
const result = run(out, '--profile', 'choam-skills', '--rules', 'basic', '--players', '2', '--seed', '1000', '--max-actions', '1');
|
|
assert.equal(result.status, 1);
|
|
assertFailedEvidence(out, 'choam-skills-2-basic', 1031, false);
|
|
const snapshot = join(out, 'failed-choam-skills-2-basic.json');
|
|
const game = json<{ advanced: boolean; leaderSkills: { deck: string[]; offers: Record<string, { cards: string[] }>; assignments: { skill: string }[] } }>(snapshot);
|
|
assert.equal(game.advanced, false);
|
|
const physical = [...game.leaderSkills.deck, ...Object.values(game.leaderSkills.offers).flatMap(o => o.cards), ...game.leaderSkills.assignments.map(a => a.skill)];
|
|
assert.equal(physical.length, 14); assert.equal(new Set(physical).size, 14);
|
|
const resumed = join(area, 'skills-resumed');
|
|
assert.equal(run(resumed, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(resumed, 'choam-skills-2-basic', 1031, true);
|
|
const advanced = join(area, 'advanced');
|
|
assert.equal(run(advanced, '--profile', 'choam-skills', '--rules', 'advanced', '--players', '2', '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(advanced, 'choam-skills-2-advanced', 1225, false);
|
|
const state = json<typeof game>(join(advanced, 'failed-choam-skills-2-advanced.json'));
|
|
assert.equal(state.advanced, true);
|
|
const cards = [...state.leaderSkills.deck, ...Object.values(state.leaderSkills.offers).flatMap(o => o.cards), ...state.leaderSkills.assignments.map(a => a.skill)];
|
|
assert.equal(new Set(cards).size, 14);
|
|
assert.equal(cards.length, 14);
|
|
const advancedResumed = join(area, 'advanced-resumed');
|
|
assert.equal(run(advancedResumed, '--resume', join(advanced, 'failed-choam-skills-2-advanced.json'), '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(advancedResumed, 'choam-skills-2-advanced', 1225, true);
|
|
});
|
|
|
|
void test('native Richese skill captures retain all fourteen skills, ten cache cards and original Basic or Advanced CLI continuation', (t) => {
|
|
const area = temporary(t);
|
|
for (const rules of ['basic', 'advanced'] as const) {
|
|
const out = join(area, rules);
|
|
assert.equal(run(out, '--profile', 'richese-skills', '--rules', rules, '--players', '2', '--seed', '1000', '--max-actions', '1').status, 1);
|
|
const samples = rules === 'basic'
|
|
? [['richese-skills-2-basic', 1254], ['richese-skills-richese-choam-2-basic', 1264]] as const
|
|
: [['richese-skills-2-advanced', 1259], ['richese-skills-richese-choam-2-advanced', 1269], ['richese-skills-ix-deck-2-advanced', 1278]] as const;
|
|
for (const [name, seed] of samples) {
|
|
assertFailedEvidence(out, name, seed, false, samples.length);
|
|
const snapshot = join(out, `failed-${name}.json`);
|
|
const state = json<{richeseCache:{id:string}[];leaderSkills:{deck:string[];offers:Record<string,{cards:string[]}>;assignments:{skill:string}[]}}>(snapshot);
|
|
const skills = [...state.leaderSkills.deck, ...Object.values(state.leaderSkills.offers).flatMap(o => o.cards), ...state.leaderSkills.assignments.map(a => a.skill)];
|
|
assert.equal(new Set(skills).size, 14);
|
|
assert.equal(skills.length, 14);
|
|
assert.equal(new Set(state.richeseCache.map(c => c.id)).size, 10);
|
|
const continued = join(area, `resumed-${name}`);
|
|
assert.equal(run(continued, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(continued, name, seed, true);
|
|
}
|
|
}
|
|
});
|
|
void test('Homeworld and Nexus sample snapshots resume only their matching module and roster', (t) => {
|
|
const area = temporary(t);
|
|
for (const [profile, ordinal, module, other] of [
|
|
['homeworld', 37, 'homeworlds', 'nexusCards'],
|
|
['nexus', 39, 'nexusCards', 'homeworlds'],
|
|
] as const) {
|
|
const out = join(area, profile);
|
|
const name = profile === 'nexus' ? 'nexus-6-advanced' : 'homeworld-4-advanced';
|
|
const playerFilter = ['--players', profile === 'nexus' ? '6' : '4'];
|
|
assert.equal(run(out, '--profile', profile, '--rules', 'advanced', ...playerFilter, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(out, name, 1000 + ordinal, false);
|
|
const snapshot = join(out, `failed-${name}.json`);
|
|
const game = json<Record<string, unknown>>(snapshot);
|
|
assert.ok(game[module], `${profile} module remains in the snapshot`);
|
|
assert.equal(Boolean(game[other]), false);
|
|
const resumed = join(area, `${profile}-resumed`);
|
|
assert.equal(run(resumed, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(resumed, name, 1000 + ordinal, true);
|
|
const unsupported = join(area, `${profile}-combined.json`);
|
|
writeFileSync(unsupported, JSON.stringify({ ...game, [other]: game[module] }), { mode: 0o600 });
|
|
const refused = join(area, `${profile}-refused`);
|
|
const result = run(refused, '--resume', unsupported);
|
|
assert.equal(result.status, 1);
|
|
assert.equal(existsSync(refused), false);
|
|
}
|
|
});
|
|
|
|
void test('Homeworld samples cover each two-to-six-seat roster under both rules and resume the two-seat configuration', (t) => {
|
|
const area = temporary(t);
|
|
const out = join(area, 'homeworld');
|
|
assert.equal(run(out, '--profile', 'homeworld', '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assert.deepEqual(json<{ results: CliResult[] }>(join(out, 'results.json')).results.map(({ name, seed }) => [name, seed]), [
|
|
['homeworld-2-basic', 1048], ['homeworld-2-advanced', 1049],
|
|
['homeworld-3-basic', 1050], ['homeworld-3-advanced', 1051],
|
|
['homeworld-4-basic', 1036], ['homeworld-4-advanced', 1037],
|
|
['homeworld-5-basic', 1054], ['homeworld-5-advanced', 1055],
|
|
['homeworld-6-basic', 1056], ['homeworld-6-advanced', 1057],
|
|
]);
|
|
const snapshot = join(out, 'failed-homeworld-2-advanced.json');
|
|
const game = json<{ players: unknown[]; homeworlds: unknown }>(snapshot);
|
|
assert.equal(game.players.length, 2);
|
|
assert.ok(game.homeworlds);
|
|
const resumed = join(area, 'resumed');
|
|
assert.equal(run(resumed, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(resumed, 'homeworld-2-advanced', 1049, true);
|
|
});
|
|
|
|
void test('combined Homeworld and Nexus snapshots keep both physical modules across saved continuation', (t) => {
|
|
const area = temporary(t);
|
|
const out = join(area, 'combined');
|
|
assert.equal(run(out, '--profile', 'homeworld-nexus', '--players', '3', '--rules', 'advanced', '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(out, 'homeworld-nexus-3-advanced', 1061, false);
|
|
const snapshot = join(out, 'failed-homeworld-nexus-3-advanced.json');
|
|
const game = json<Record<string, unknown>>(snapshot);
|
|
assert.equal((game.players as unknown[]).length, 3);
|
|
assert.ok(game.homeworlds);
|
|
assert.ok(game.nexusCards);
|
|
const resumed = join(area, 'resumed');
|
|
assert.equal(run(resumed, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(resumed, 'homeworld-nexus-3-advanced', 1061, true);
|
|
});
|
|
|
|
void test('combined modules reach saved Nexus draws and actual Homeworld shipment in one complete game', (t) => {
|
|
const out = join(temporary(t), 'complete');
|
|
const result = run(out, '--profile', 'homeworld-nexus', '--players', '5', '--rules', 'advanced', '--seed', '20260927');
|
|
assert.equal(result.status, 0, result.stderr);
|
|
const report = json<CliReport>(join(out, 'report.json'));
|
|
const evidence = json<{ results: (CliResult & {
|
|
used: Record<string, number>;
|
|
rejected: Record<string, number>;
|
|
restores: number;
|
|
})[] }>(join(out, 'results.json')).results[0];
|
|
assert.equal(report.status, 'passed');
|
|
assert.equal(evidence.outcome, 'complete');
|
|
assert.ok(evidence.used.nexusCardChoice > 0);
|
|
assert.ok(evidence.used.homeworldShip > 0);
|
|
assert.deepEqual(evidence.rejected, {});
|
|
assert.ok(evidence.restores > 0);
|
|
});
|
|
|
|
void test('expansion-roster snapshots resume their own Advanced games rather than the fixed four-seat sample', (t) => {
|
|
const area = temporary(t);
|
|
for (const [profile, seed] of [['choam-roster', '20260928'], ['ecaz-roster', '20260927'], ['ix-roster', '20260927'], ['choam-nexus', '20260928'], ['ecaz-nexus', '20260927'], ['ix-nexus', '20260927']] as const) {
|
|
const name = `${profile}-4-advanced`;
|
|
const initial = join(area, `${profile}-initial`);
|
|
assert.equal(run(initial, '--profile', profile, '--players', '4', '--rules', 'advanced', '--seed', seed, '--max-actions', '1').status, 1);
|
|
const snapshot = join(initial, `failed-${name}.json`);
|
|
const continued = join(area, `${profile}-continued`);
|
|
const resumed = run(continued, '--resume', snapshot, '--seed', seed);
|
|
assert.equal(resumed.status, 0, resumed.stderr);
|
|
const report = json<CliReport>(join(continued, 'report.json'));
|
|
const result = json<{ results: (CliResult & { restores: number; rejected: Record<string, number> })[] }>(join(continued, 'results.json')).results[0];
|
|
assert.equal(report.status, 'passed');
|
|
assert.equal(result.name, name);
|
|
assert.equal(result.outcome, 'complete');
|
|
assert.equal(result.resumed, true);
|
|
assert.deepEqual(result.rejected, {});
|
|
assert.ok(result.restores > 0);
|
|
}
|
|
});
|
|
|
|
void test('six-seat Advanced Ixian/Tleilaxu game resolves Technology and Face Dancers through JSON restores', (t) => {
|
|
const out = join(temporary(t), 'ix-complete');
|
|
const runResult = run(out, '--profile', 'ix-roster', '--players', '6', '--rules', 'advanced', '--seed', '20260927');
|
|
assert.equal(runResult.status, 0, runResult.stderr);
|
|
const evidence = json<{ results: (CliResult & {
|
|
used: Record<string, number>;
|
|
rejected: Record<string, number>;
|
|
restores: number;
|
|
})[] }>(join(out, 'results.json')).results[0];
|
|
assert.equal(evidence.name, 'ix-roster-6-advanced');
|
|
assert.equal(evidence.outcome, 'complete');
|
|
assert.ok(evidence.used['decision:ixTechnology'] > 0);
|
|
assert.ok(evidence.used['decision:faceDance'] > 0);
|
|
assert.deepEqual(evidence.rejected, {});
|
|
assert.ok(evidence.restores > 0);
|
|
});
|
|
|
|
void test('combined-expansion Advanced sample completes with Richese Technology declines and saved continuation', (t) => {
|
|
const out = join(temporary(t), 'combined-complete');
|
|
const result = run(out, '--profile', 'combined', '--rules', 'advanced', '--seed', '20260927');
|
|
assert.equal(result.status, 0, result.stderr);
|
|
const report = json<CliReport>(join(out, 'report.json'));
|
|
const game = json<{ results: (CliResult & {
|
|
used: Record<string, number>;
|
|
rejected: Record<string, number>;
|
|
restores: number;
|
|
})[] }>(join(out, 'results.json')).results[0];
|
|
assert.equal(report.status, 'passed');
|
|
assert.equal(report.sourceUnchanged, true);
|
|
assert.equal(game.name, 'combined-advanced');
|
|
assert.equal(game.outcome, 'complete');
|
|
assert.ok(game.used['decision:ixRicheseTechnology'] > 0);
|
|
assert.ok(game.used['decision:ecazAmbassador'] > 0);
|
|
assert.ok(game.used['decision:faceDance'] > 0);
|
|
assert.deepEqual(game.rejected, {});
|
|
assert.ok(game.restores > 0);
|
|
});
|
|
|
|
void test('CHOAM/Richese Nexus game reaches an unallied card choice and restores across phases', (t) => {
|
|
const out = join(temporary(t), 'choam-nexus-complete');
|
|
const result = run(out, '--profile', 'choam-nexus', '--players', '3', '--rules', 'advanced', '--seed', '20260927');
|
|
assert.equal(result.status, 0, result.stderr);
|
|
const report = json<CliReport>(join(out, 'report.json'));
|
|
const game = json<{ results: (CliResult & {
|
|
used: Record<string, number>;
|
|
rejected: Record<string, number>;
|
|
restores: number;
|
|
})[] }>(join(out, 'results.json')).results[0];
|
|
assert.equal(report.status, 'passed');
|
|
assert.equal(report.sourceUnchanged, true);
|
|
assert.equal(game.name, 'choam-nexus-3-advanced');
|
|
assert.equal(game.outcome, 'complete');
|
|
assert.ok(game.used.nexusCardChoice > 0);
|
|
assert.deepEqual(game.rejected, {});
|
|
assert.ok(game.restores > 0);
|
|
});
|
|
|
|
void test('Ecaz/Moritani Nexus game draws cards and resolves Ambassador battles through JSON restores', (t) => {
|
|
const out = join(temporary(t), 'ecaz-nexus-complete');
|
|
const result = run(out, '--profile', 'ecaz-nexus', '--players', '3', '--rules', 'basic', '--seed', '20260927');
|
|
assert.equal(result.status, 0, result.stderr);
|
|
const report = json<CliReport>(join(out, 'report.json'));
|
|
const game = json<{ results: (CliResult & {
|
|
used: Record<string, number>;
|
|
rejected: Record<string, number>;
|
|
restores: number;
|
|
})[] }>(join(out, 'results.json')).results[0];
|
|
assert.equal(report.status, 'passed');
|
|
assert.equal(report.sourceUnchanged, true);
|
|
assert.equal(game.name, 'ecaz-nexus-3-basic');
|
|
assert.equal(game.outcome, 'complete');
|
|
assert.ok(game.used.nexusCardChoice > 0);
|
|
assert.ok(game.used['decision:ecazAmbassador'] > 0);
|
|
assert.deepEqual(game.rejected, {});
|
|
assert.ok(game.restores > 0);
|
|
});
|
|
|
|
void test('Ixian/Tleilaxu Nexus games reach unallied card choices, Technology and Face Dancers across saves', (t) => {
|
|
const area = temporary(t);
|
|
for (const rules of ['basic', 'advanced'] as const) {
|
|
const out = join(area, rules);
|
|
const result = run(out, '--profile', 'ix-nexus', '--players', '3', '--rules', rules, '--seed', '20260927');
|
|
assert.equal(result.status, 0, result.stderr);
|
|
const report = json<CliReport>(join(out, 'report.json'));
|
|
const game = json<{ results: (CliResult & {
|
|
used: Record<string, number>;
|
|
rejected: Record<string, number>;
|
|
restores: number;
|
|
})[] }>(join(out, 'results.json')).results[0];
|
|
assert.equal(report.status, 'passed');
|
|
assert.equal(report.sourceUnchanged, true);
|
|
assert.equal(game.name, `ix-nexus-3-${rules}`);
|
|
assert.equal(game.outcome, 'complete');
|
|
assert.ok(game.used.nexusCardChoice > 0);
|
|
assert.ok(game.used['decision:ixAuction'] > 0);
|
|
assert.ok(game.used[rules === 'advanced' ? 'decision:ixTechnology' : 'decision:faceDance'] > 0);
|
|
assert.deepEqual(game.rejected, {});
|
|
assert.ok(game.restores > 0);
|
|
}
|
|
});
|
|
|
|
void test('three-seat Nexus samples preserve their module and roster across saved continuation', (t) => {
|
|
const area = temporary(t);
|
|
for (const [rules, ordinal] of [['basic', 42], ['advanced', 43]] as const) {
|
|
const out = join(area, rules);
|
|
const initial = run(out, '--profile', 'nexus', '--players', '3', '--rules', rules, '--seed', '1000', '--max-actions', '1');
|
|
assert.equal(initial.status, 1);
|
|
assertFailedEvidence(out, `nexus-3-${rules}`, 1000 + ordinal, false);
|
|
const snapshot = join(out, `failed-nexus-3-${rules}.json`);
|
|
const game = json<{ players: unknown[]; nexusCards: unknown }>(snapshot);
|
|
assert.equal(game.players.length, 3);
|
|
assert.ok(game.nexusCards);
|
|
const resumed = join(area, `${rules}-resumed`);
|
|
assert.equal(run(resumed, '--resume', snapshot, '--seed', '1000', '--max-actions', '1').status, 1);
|
|
assertFailedEvidence(resumed, `nexus-3-${rules}`, 1000 + ordinal, true);
|
|
}
|
|
});
|
|
|
|
void test('a genuine three-seat Advanced Nexus game reaches unallied card choice and completes without illegal bot actions', (t) => {
|
|
const out = join(temporary(t), 'card-draw');
|
|
const result = run(out, '--profile', 'nexus', '--players', '3', '--rules', 'advanced', '--seed', '20260927');
|
|
assert.equal(result.status, 0, result.stderr);
|
|
const report = json<CliReport>(join(out, 'report.json'));
|
|
const evidence = json<{ results: (CliResult & {
|
|
used: Record<string, number>;
|
|
rejected: Record<string, number>;
|
|
restores: number;
|
|
})[] }>(join(out, 'results.json')).results[0];
|
|
assert.equal(report.status, 'passed');
|
|
assert.equal(evidence.outcome, 'complete');
|
|
assert.ok(evidence.used.nexusCardChoice > 0);
|
|
assert.deepEqual(evidence.rejected, {});
|
|
assert.ok(evidence.restores > 0);
|
|
});
|
|
|
|
void test('selected genuine three-player Advanced base sample fails honestly, resumes its fixed snapshot and keeps source-bound private evidence', (t) => {
|
|
const area = temporary(t);
|
|
const first = join(area, 'first');
|
|
const initial = run(
|
|
first,
|
|
'--profile',
|
|
'base',
|
|
'--players',
|
|
'3',
|
|
'--rules',
|
|
'advanced',
|
|
'--seed',
|
|
'1000',
|
|
'--max-actions',
|
|
'1',
|
|
);
|
|
assert.equal(initial.status, 1);
|
|
const firstReport = assertFailedEvidence(
|
|
first,
|
|
'base-3-advanced',
|
|
1009,
|
|
false,
|
|
);
|
|
assert.deepEqual(firstReport.options, {
|
|
seed: 1000,
|
|
profile: 'base',
|
|
rules: 'advanced',
|
|
maxActions: 1,
|
|
players: 3,
|
|
});
|
|
|
|
const snapshot = join(first, 'failed-base-3-advanced.json');
|
|
for (const field of [
|
|
'ecazTreachery',
|
|
'mentatQuestionPreview',
|
|
'moritaniAssassinatePreview',
|
|
'moritaniAssassinate',
|
|
'moritaniAssassinateResume',
|
|
'moritaniAssassinateCallEvents',
|
|
]) {
|
|
const optionalSnapshot = join(area, `optional-${field}.json`);
|
|
const optional = json<Record<string, unknown>>(snapshot);
|
|
optional[field] = true;
|
|
writeFileSync(optionalSnapshot, JSON.stringify(optional), { mode: 0o600 });
|
|
const optionalOut = join(area, `optional-${field}-resume`);
|
|
const optionalResult = run(
|
|
optionalOut,
|
|
'--resume',
|
|
optionalSnapshot,
|
|
'--max-actions',
|
|
'1',
|
|
);
|
|
assert.equal(optionalResult.status, 1);
|
|
assert.equal(existsSync(optionalOut), false);
|
|
}
|
|
|
|
const resumedOut = join(area, 'resumed');
|
|
const resumed = run(
|
|
resumedOut,
|
|
'--resume',
|
|
snapshot,
|
|
'--seed',
|
|
'1000',
|
|
'--max-actions',
|
|
'1',
|
|
);
|
|
assert.equal(resumed.status, 1);
|
|
const resumedReport = assertFailedEvidence(
|
|
resumedOut,
|
|
'base-3-advanced',
|
|
1009,
|
|
true,
|
|
);
|
|
assert.equal(resumedReport.options.profile, 'base');
|
|
assert.equal(resumedReport.options.rules, 'advanced');
|
|
assert.equal(resumedReport.options.players, 3);
|
|
assert.ok(resumedReport.options.resume);
|
|
assert.equal(resumedReport.options.resume.path, snapshot);
|
|
assert.match(resumedReport.options.resume.sha256, /^[a-f\d]{64}$/);
|
|
|
|
const custodyOut = join(area, 'custody-source');
|
|
const custodyRun = run(
|
|
custodyOut,
|
|
'--profile',
|
|
'base',
|
|
'--players',
|
|
'3',
|
|
'--rules',
|
|
'advanced',
|
|
'--max-actions',
|
|
'20',
|
|
);
|
|
assert.equal(custodyRun.status, 1);
|
|
const corruptPath = join(area, 'paired-missing-leader-and-traitor.json');
|
|
const corrupt = json<{
|
|
status: string;
|
|
players: { leaders: { id: string }[]; traitors: string[] }[];
|
|
traitorReserve?: string[];
|
|
}>(join(custodyOut, 'failed-base-3-advanced.json'));
|
|
assert.equal(corrupt.status, 'playing');
|
|
const dealt = new Set([
|
|
...(corrupt.traitorReserve ?? []),
|
|
...corrupt.players.flatMap((player) => player.traitors),
|
|
]);
|
|
const owner = corrupt.players.find((player) =>
|
|
player.leaders.some((leader) => dealt.has(leader.id)),
|
|
);
|
|
assert.ok(owner, 'fixture has a leader represented in the Traitor inventory');
|
|
const missing = owner.leaders.find((leader) => dealt.has(leader.id))!.id;
|
|
owner.leaders = owner.leaders.filter((leader) => leader.id !== missing);
|
|
let removed = false;
|
|
corrupt.traitorReserve = corrupt.traitorReserve?.filter((id) => {
|
|
if (id !== missing) return true;
|
|
removed = true;
|
|
return false;
|
|
});
|
|
for (const player of corrupt.players)
|
|
player.traitors = player.traitors.filter((id) => {
|
|
if (id !== missing) return true;
|
|
removed = true;
|
|
return false;
|
|
});
|
|
assert.equal(removed, true, 'fixture leader has one physical Traitor card');
|
|
writeFileSync(corruptPath, JSON.stringify(corrupt), { mode: 0o600 });
|
|
const corruptOut = join(area, 'corrupt-resume');
|
|
const corrupted = run(
|
|
corruptOut,
|
|
'--resume',
|
|
corruptPath,
|
|
'--max-actions',
|
|
'1',
|
|
);
|
|
assert.equal(corrupted.status, 1);
|
|
const corruptResult = json<{ results: CliResult[] }>(
|
|
join(corruptOut, 'results.json'),
|
|
).results[0];
|
|
assert.equal(corruptResult.actions, 0);
|
|
|
|
for (const [label, args] of [
|
|
['profile', ['--profile', 'base']],
|
|
['rules', ['--rules', 'advanced']],
|
|
['players', ['--players', '3']],
|
|
] as const) {
|
|
const out = join(area, `invalid-resume-${label}`);
|
|
const invalid = run(out, '--resume', snapshot, ...args);
|
|
assert.equal(invalid.status, 1);
|
|
assert.equal(existsSync(out), false);
|
|
}
|
|
});
|
|
|
|
void test('default expansion samples retain their six names and seed ordinals while base defaults cover every two-to-six-player roster', (t) => {
|
|
const area = temporary(t);
|
|
const expansionOut = join(area, 'expansion-default');
|
|
const expansion = run(expansionOut, '--seed', '2000', '--max-actions', '1');
|
|
assert.equal(expansion.status, 1);
|
|
const expansionResults = json<{ results: CliResult[] }>(
|
|
join(expansionOut, 'results.json'),
|
|
).results;
|
|
assert.deepEqual(
|
|
expansionResults.map((result) => [result.name, result.seed]),
|
|
[
|
|
['choam-basic', 2000],
|
|
['choam-advanced', 2001],
|
|
['ecaz-basic', 2002],
|
|
['ecaz-advanced', 2003],
|
|
['combined-basic', 2004],
|
|
['combined-advanced', 2005],
|
|
],
|
|
);
|
|
for (const result of expansionResults) {
|
|
assert.equal(result.actions, 1, `${result.name} reached the action limit`);
|
|
}
|
|
|
|
const baseOut = join(area, 'base-default');
|
|
const base = run(
|
|
baseOut,
|
|
'--profile',
|
|
'base',
|
|
'--seed',
|
|
'2000',
|
|
'--max-actions',
|
|
'1',
|
|
);
|
|
assert.equal(base.status, 1);
|
|
const baseReport = json<CliReport>(join(baseOut, 'report.json'));
|
|
assert.equal(baseReport.options.players, 'all');
|
|
assert.deepEqual(
|
|
json<{ results: CliResult[] }>(join(baseOut, 'results.json')).results.map(
|
|
(result) => [result.name, result.seed],
|
|
),
|
|
[
|
|
['base-2-basic', 2006],
|
|
['base-2-advanced', 2007],
|
|
['base-3-basic', 2008],
|
|
['base-3-advanced', 2009],
|
|
['base-4-basic', 2010],
|
|
['base-4-advanced', 2011],
|
|
['base-5-basic', 2012],
|
|
['base-5-advanced', 2013],
|
|
['base-6-basic', 2014],
|
|
['base-6-advanced', 2015],
|
|
],
|
|
);
|
|
});
|
|
|
|
void test('invalid player filters fail before creating a private output directory', (t) => {
|
|
const area = temporary(t);
|
|
for (const [label, args] of [
|
|
['without-base', ['--players', '3']],
|
|
['expansion-profile', ['--profile', 'choam', '--players', '3']],
|
|
['invalid-count', ['--profile', 'base', '--players', '7']],
|
|
] as const) {
|
|
const out = join(area, label);
|
|
const result = run(out, ...args);
|
|
assert.equal(result.status, 1);
|
|
assert.equal(existsSync(out), false);
|
|
}
|
|
});
|