Kevin/lifegame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Extend tests for the real board and add tileEffects unit tests

Browse Source 
game.test.js: rewritten for the new {type, rolls} action shape and 5-stat
player model. The full-playthrough test now walks the real 212-space board
turn by turn (deterministic dummy rolls — always the low end of each die's
range) until finish, asserting every stat stays numeric and every one of
the 9 real tile types actually gets resolved along the way. board-shape
assertions updated to match (212 spaces, no `choices` populated yet).

tileEffects.test.js (new): unit tests per tile type in isolation, including
exact deterministic assertions against real placeholder-table content (roll
a known value, assert the exact banded effect) and a multi-table
roll_table_ref cross-check computed independently from the raw table data —
no seeded-rng machinery anywhere, same explicit-action-value pattern the
reducer tests already used. Also a sweep resolving every real tile across
the full range of its die to catch any type/die combination that throws.

package.json: test script now runs shared/*.test.js instead of naming one
file.
This commit is contained in:
Kevin
2026-07-28 10:08:37 -07:00
parent db82b531e0
commit 6749777b45
3 changed files with 172 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
shared/game.test.js
+61 -31
View File
@@ -2,21 +2,28 @@ import { test } from 'node:test';
import assert from 'node:assert/strict';
import { createInitialState, reduce, getLegalIntents, isPlayersTurn } from './game.js';
import { board } from './board.js';
import { rollsNeededFor } from './tileEffects.js';
function join(state, playerId, name, seat) {
return reduce(state, { type: 'JOIN', playerId, name, seat, color: '#000' });
}
/** Drives `playerId` forward by always resolving any pending choice with its
* first option and otherwise rolling the max die value — walkForward stops
* early at the next choice/finish regardless of pips, so this reliably makes
* progress without the test needing to know the board's shape or size. */
// Deterministic dummy rolls — always the low end of each die's range, so
// these tests exercise the reducer's mechanics without depending on real
// (or synthesized-placeholder) table content. shared/tileEffects.test.js
// covers the actual banding/effect math.
function rollsFor(space) {
return rollsNeededFor(space).map(() => 1);
}
function takeTurn(state, playerId) {
const player = state.players[playerId];
if (player.pendingChoice) {
return reduce(state, { type: 'CHOOSE', playerId, spaceId: player.pendingChoice.options[0] });
const spaceId = player.pendingChoice.options[0];
return reduce(state, { type: 'CHOOSE', playerId, spaceId, rolls: rollsFor(board.spaces[spaceId]) });
}
return reduce(state, { type: 'ROLL', playerId, value: state.config.diceSides });
const nextSpaceId = board.spaces[player.position].next;
return reduce(state, { type: 'ROLL', playerId, rolls: rollsFor(board.spaces[nextSpaceId]) });
}
test('lobby: join validation', () => {
@@ -27,6 +34,16 @@ test('lobby: join validation', () => {
assert.throws(() => reduce(state, { type: 'START_GAME' }), /Not enough players/);
});
test('join gives every player the five starting stats', () => {
let state = createInitialState();
state = join(state, 'p1', 'Alice', 1);
const p1 = state.players.p1;
assert.deepEqual(
{ cash: p1.cash, love: p1.love, education: p1.education, wealth: p1.wealth, age: p1.age },
state.config.startingStats
);
});
test('turn order and illegal actions', () => {
let state = createInitialState();
state = join(state, 'p1', 'Alice', 1);
@@ -41,59 +58,72 @@ test('turn order and illegal actions', () => {
assert.deepEqual(getLegalIntents(state, 'p1'), ['REQUEST_ROLL']);
assert.deepEqual(getLegalIntents(state, 'p2'), []);
assert.throws(() => reduce(state, { type: 'ROLL', playerId: 'p2', value: 3 }), /Not your turn/);
assert.throws(() => reduce(state, { type: 'ROLL', playerId: 'p2', rolls: [] }), /Not your turn/);
assert.throws(() => reduce(state, { type: 'CHOOSE', playerId: 'p1', spaceId: 'anything' }), /No pending choice/);
});
test('full game: every player reaches every fork, race to finish', () => {
test('a single roll advances exactly one tile and applies its effect', () => {
let state = createInitialState();
state = join(state, 'p1', 'Alice', 1);
state = join(state, 'p2', 'Bob', 2);
state = reduce(state, { type: 'START_GAME' });
const seenChoiceSpaces = new Set();
const expectedNext = board.spaces[board.startSpaceId].next;
state = takeTurn(state, 'p1');
assert.equal(state.players.p1.position, expectedNext);
assert.equal(state.currentTurn, 'p2', 'turn advances since no choice is pending yet');
assert.equal(state.log.at(-1).landedOn, expectedNext);
});
test('full board: walking every tile to the temporary finish never crashes and always terminates', () => {
let state = createInitialState();
state = join(state, 'p1', 'Alice', 1);
state = join(state, 'p2', 'Bob', 2);
state = reduce(state, { type: 'START_GAME' });
const seenTypes = new Set();
let guard = 0;
while (state.status === 'active') {
if (++guard > 500) throw new Error('game did not finish in a reasonable number of turns');
if (++guard > 1000) throw new Error('game did not finish in a reasonable number of turns');
const turnPlayerId = state.currentTurn;
const before = state.players[turnPlayerId];
if (before.pendingChoice) seenChoiceSpaces.add(before.position);
state = takeTurn(state, turnPlayerId);
const after = state.players[turnPlayerId];
assert.equal(typeof after.cash, 'number');
seenTypes.add(board.spaces[after.position].type);
for (const stat of ['cash', 'love', 'education', 'wealth', 'age']) {
assert.equal(typeof after[stat], 'number', `${stat} stays numeric`);
}
assert.ok(board.spaces[after.position], 'player is always on a real space');
}
assert.equal(state.status, 'finished');
assert.ok(state.winnerId, 'a winner is recorded');
assert.ok(state.winnerId);
assert.equal(state.currentTurn, null);
assert.equal(state.players[state.winnerId].position, 'finish');
assert.deepEqual(getLegalIntents(state, 'p1'), []);
assert.deepEqual(getLegalIntents(state, 'p2'), []);
assert.throws(() => reduce(state, { type: 'ROLL', playerId: 'p1', value: 1 }), /not active/);
// Always picking the first option at every fork should have visited all
// three choice points at least once between two full playthroughs' worth
// of turns (the loser doesn't necessarily finish, so this just checks the
// race itself exercised real fork logic, not that both players finished).
assert.ok(seenChoiceSpaces.size >= 1, 'at least one fork was actually resolved');
// Every distinct tile type in the real board actually got resolved along the way.
for (const type of [
'payday', 'action_space', 'dice_space', 'roll_table_ref',
'inline_table', 'cash_bonus', 'event', 'choice', 'stop',
]) {
assert.ok(seenTypes.has(type), `expected to land on a "${type}" tile during a full playthrough`);
}
assert.throws(() => reduce(state, { type: 'ROLL', playerId: 'p1', rolls: [] }), /not active/);
});
test('board graph is well-formed', () => {
const ids = Object.keys(board.spaces);
assert.ok(ids.length > 100, 'the full board should be a substantial expansion of the Phase 1 subset');
assert.equal(ids.length, 212, '211 real tiles + 1 synthetic finish');
let nonFinishCount = 0;
for (const id of ids) {
const space = board.spaces[id];
if (space.type === 'choice') {
assert.ok(Array.isArray(space.choices) && space.choices.length >= 2, `${id} needs 2+ choices`);
for (const target of space.choices) assert.ok(board.spaces[target], `${id} -> missing ${target}`);
} else if (space.type === 'finish') {
if (space.type === 'finish') {
assert.equal(space.next, undefined);
} else {
assert.ok(board.spaces[space.next], `${id} -> missing ${space.next}`);
continue;
}
nonFinishCount++;
assert.ok(board.spaces[space.next], `${id} -> missing ${space.next}`);
}
assert.equal(nonFinishCount, 211);
});