Files

560 lines
31 KiB
TypeScript

import { test } from 'node:test';
import { strict as assert } from 'node:assert';
import { BETS, PAYLINES, PAYTABLE, SYMBOLS, evaluate, spin } from '../assets/orchard/scripts/SlotsMath';
import type { SpinResult, SymbolId } from '../assets/orchard/scripts/SlotsMath';
import { GameSession, initialState } from '../assets/orchard/scripts/GameSession';
import type { GameState } from '../assets/orchard/scripts/GameSession';
import { GameRepository } from '../assets/orchard/scripts/GameRepository';
// 独立规则夹具,避免用被测常量证明自身。 / Independent fixtures, not production-derived expectations.
const ORDINARY = ['seven', 'bell', 'bar', 'strawberry', 'blueberry', 'plum', 'cherry', 'watermelon'] as const;
const SYMBOL_IDS: SymbolId[] = [...ORDINARY, 'wild', 'scatter'];
const WEIGHTS = [3, 5, 7, 10, 11, 13, 15, 30, 2, 4];
const ODDS: Record<typeof ORDINARY[number], [number, number, number]> = {
seven: [45, 158, 675], bell: [36, 113, 450], bar: [27, 90, 360],
strawberry: [18, 54, 203], blueberry: [14, 45, 158], plum: [9, 27, 90],
cherry: [5, 18, 68], watermelon: [5, 14, 45],
};
const LINES = ['MMMMM', 'TTTTT', 'BBBBB', 'TMBMT', 'BMTMB', 'MTTTM', 'MBBBM', 'MTBTM', 'MBTBM',
'TMMMT', 'BMMMB', 'TTMMB', 'BBMMT', 'TMMBB', 'BMMTT', 'MTMMM', 'MBMMM', 'MMMTM', 'MMMBM', 'MTMBM']
.map(line => [...line].map(row => ({ T: 0, M: 1, B: 2 })[row as 'T' | 'M' | 'B']));
const SCOPE = 'https://example.test/FruitFixture/guest-a';
const DAY = 86_400_000;
const NOW = Date.parse('2026-11-20T12:00:00Z');
const copy = <T>(value: T): T => JSON.parse(JSON.stringify(value)) as T;
function board(symbol: SymbolId = 'scatter'): SymbolId[][] {
return Array.from({ length: 5 }, () => Array<SymbolId>(3).fill(symbol));
}
function sample(symbol: SymbolId): number {
const index = SYMBOL_IDS.indexOf(symbol);
return (WEIGHTS.slice(0, index).reduce((sum, weight) => sum + weight, 0) + WEIGHTS[index] / 2) / 100;
}
function draws(values: number[]): () => number {
let index = 0;
return () => {
assert.ok(index < values.length, 'unexpected random draw');
return values[index++];
};
}
function randomFor(value: SymbolId[][], extra: number[] = []): () => number {
return draws([...value.flat().map(sample), ...extra]);
}
// 全部候选按最长前缀算奖后取最大;与实现共享的只有公开类型。 / Independent line-award oracle.
function expectedWins(value: SymbolId[][], bet: number) {
return LINES.flatMap((rows, line) => {
const candidates = ORDINARY.map(symbol => {
let count = 0;
while (count < 5 && (value[count][rows[count]] === symbol || value[count][rows[count]] === 'wild')) count++;
return { line, symbol, count, amount: count < 3 ? 0 : bet / 20 * ODDS[symbol][count - 3] };
}).sort((a, b) => b.amount - a.amount);
return candidates[0].amount === 0 ? [] : [candidates[0]];
});
}
function verifyEvaluation(value: SymbolId[][], bet: number): SpinResult {
const before = copy(value);
const result = evaluate(value, bet);
const expected = expectedWins(value, bet);
assert.deepEqual(result.board, before);
assert.deepEqual(value, before, 'evaluation must not mutate the caller board');
assert.deepEqual(result.wins.map(win => ({ line: win.line, symbol: win.symbol, count: win.count, amount: win.amount })), expected);
assert.equal(result.win, expected.reduce((sum, win) => sum + win.amount, 0));
assert.equal(new Set(result.wins.map(win => win.line)).size, result.wins.length, 'at most one award per line');
assert.equal(result.wildColumn, null);
return result;
}
function memory() {
const values = new Map<string, string>();
return {
values, reads: 0, writes: 0, failRead: 0, failWrite: false, silent: false, corrupt: false,
beforeWrite: null as (() => void) | null,
afterWrite: null as (() => void) | null,
getItem(key: string): string | null {
this.reads++;
if (this.failRead > 0) { this.failRead--; throw new Error('fixture read failure'); }
return values.get(key) ?? null;
},
setItem(key: string, value: string): void {
this.writes++;
this.beforeWrite?.();
if (this.failWrite) throw new Error('fixture quota failure');
if (!this.silent) values.set(key, this.corrupt ? '{broken write' : value);
this.afterWrite?.();
},
};
}
type Memory = ReturnType<typeof memory>;
function session(random: () => number = () => sample('scatter'), now: () => number = () => NOW, storage = memory()) {
const game = new GameSession(new GameRepository(storage, SCOPE), random, now);
return { game, storage };
}
function persisted(storage: Memory): GameState {
const saved = new GameRepository(storage, SCOPE).load();
assert.ok(saved);
return saved;
}
function assertUnchanged(game: GameSession, storage: Memory, action: () => unknown): void {
const before = game.state;
const raw = [...storage.values];
assert.throws(action);
assert.deepEqual(game.state, before, 'rejected operation mutated memory');
assert.deepEqual([...storage.values], raw, 'rejected operation overwrote storage');
}
function freeReady(random: () => number = () => sample('scatter')) {
let triggered = false;
let normalDraws = 0;
const fixture = session(() => {
if (!triggered) {
normalDraws++;
if (normalDraws === 15) triggered = true;
return sample('scatter');
}
return random();
});
const trigger = fixture.game.beginSpin();
assert.equal(trigger.awarded, 16);
fixture.game.completeSpin();
assert.equal(fixture.game.state.phase, 'free-trigger');
fixture.game.startFree();
assert.equal(fixture.game.state.phase, 'free-ready');
return fixture;
}
test('gameplay constants exactly match the approved weights, 20 ordered paylines and paytable', () => {
assert.deepEqual(SYMBOLS, SYMBOL_IDS);
assert.deepEqual(BETS, [1000, 2000, 5000, 10000, 20000, 50000]);
assert.deepEqual(PAYLINES, LINES);
assert.equal(new Set(PAYLINES.map(line => line.join(''))).size, 20);
assert.deepEqual(PAYTABLE, ODDS);
});
test('every payline pays all eight symbols at 3/4/5 from the left and sums overlapping lines', () => {
for (let line = 0; line < LINES.length; line++) {
for (const symbol of ORDINARY) {
for (const count of [3, 4, 5]) {
const value = board();
for (let col = 0; col < count; col++) value[col][LINES[line][col]] = symbol;
const result = verifyEvaluation(value, 2000);
const target = result.wins.find(win => win.line === line);
assert.ok(target, `missing line=${line}, symbol=${symbol}, count=${count}`);
assert.deepEqual({ symbol: target.symbol, count: target.count, amount: target.amount },
{ symbol, count, amount: 100 * ODDS[symbol][count - 3] });
}
}
}
});
test('all legal bet levels scale line awards from total bet divided by twenty', () => {
for (const bet of [1000, 2000, 5000, 10000, 20000, 50000]) {
const result = verifyEvaluation(board('cherry'), bet);
assert.equal(result.win, bet * 68);
assert.equal(result.wins.length, 20);
}
});
test('WILD substitution pays the highest candidate, including a shorter seven and all-WILD', () => {
for (const [symbols, symbol, count, multiplier] of [
[['wild', 'wild', 'wild', 'bell', 'bell'], 'bell', 5, 450],
[['wild', 'wild', 'wild', 'watermelon', 'bell'], 'seven', 3, 45],
[['wild', 'wild', 'wild', 'wild', 'wild'], 'seven', 5, 675],
[['wild', 'wild', 'watermelon', 'watermelon', 'bell'], 'watermelon', 4, 14],
[['cherry', 'wild', 'cherry', 'scatter', 'cherry'], 'cherry', 3, 5],
] as const) {
const value = symbols.map(value => Array<SymbolId>(3).fill(value));
const result = verifyEvaluation(value, 2000);
assert.equal(result.wins.length, 20);
for (const win of result.wins) {
assert.equal(win.symbol, symbol); assert.equal(win.count, count); assert.equal(win.amount, multiplier * 100);
}
}
});
test('SCATTER interrupts ordinary lines, has no line award and cannot be substituted by WILD', () => {
for (const symbols of [
['scatter', 'cherry', 'cherry', 'cherry', 'cherry'],
['cherry', 'scatter', 'cherry', 'cherry', 'cherry'],
['wild', 'wild', 'scatter', 'wild', 'wild'],
['watermelon', 'bell', 'watermelon', 'watermelon', 'watermelon'],
] as SymbolId[][]) {
assert.equal(verifyEvaluation(symbols.map(symbol => Array<SymbolId>(3).fill(symbol)), 2000).win, 0);
}
const scatter = verifyEvaluation(board(), 2000);
assert.deepEqual(scatter.wins, []); assert.equal(scatter.scatters, 15);
});
test('SCATTER anywhere awards exactly 8/12/16 normal spins at 3/4/5 through 15', () => {
const positions = [14, 0, 7, 4, 11, 2, 9, 6, 13, 1, 8, 5, 12, 3, 10];
for (let count = 0; count <= 15; count++) {
const value = board('cherry');
for (const position of positions.slice(0, count)) value[Math.floor(position / 3)][position % 3] = 'scatter';
const result = evaluate(value, 2000);
assert.equal(result.scatters, count);
assert.equal(result.awarded, count < 3 ? 0 : count === 3 ? 8 : count === 4 ? 12 : 16);
}
});
test('normal draws independently use all exact weight intervals, with fifteen draws per spin', () => {
let lower = 0;
for (let symbol = 0; symbol < SYMBOL_IDS.length; symbol++) {
for (const value of [lower / 100, (lower + WEIGHTS[symbol] - 0.000001) / 100]) {
let calls = 0;
const result = spin(2000, false, () => { calls++; return value; });
assert.deepEqual(result.board, board(SYMBOL_IDS[symbol]));
assert.equal(calls, 15);
assert.equal(result.wildColumn, null);
}
lower += WEIGHTS[symbol];
}
const value: SymbolId[][] = [
['seven', 'bell', 'bar'], ['strawberry', 'blueberry', 'plum'], ['cherry', 'watermelon', 'wild'],
['scatter', 'seven', 'bell'], ['bar', 'cherry', 'plum'],
];
assert.deepEqual(spin(2000, false, randomFor(value)), evaluate(value, 2000));
});
test('free spins uniformly select exactly one column, preserve SCATTER, evaluate after conversion and never retrigger', () => {
const original = board('cherry');
for (let column = 0; column < 5; column++) original[column][1] = 'scatter';
const before = copy(original);
for (let column = 0; column < 5; column++) {
for (const selector of [column / 5, (column + 1) / 5 - 0.00000001]) {
const result = spin(2000, true, randomFor(original, [selector]));
const expected = copy(original);
expected[column][0] = 'wild'; expected[column][2] = 'wild';
assert.equal(result.wildColumn, column);
assert.deepEqual(result.board, expected);
assert.deepEqual(result.wins, evaluate(expected, 2000).wins);
assert.equal(result.win, evaluate(expected, 2000).win);
assert.equal(result.scatters, 5);
assert.equal(result.awarded, 0);
}
}
assert.deepEqual(original, before);
const firstColumnWild = spin(2000, true, draws([...Array<number>(15).fill(sample('bell')), 0]));
assert.equal(firstColumnWild.win, 2000 * 450);
});
test('invalid random samples are rejected at every draw, including the free column selection', () => {
for (const invalid of [-1, -Number.EPSILON, 1, 1.1, NaN, Infinity, -Infinity]) {
for (const index of [0, 7, 14]) {
const values = Array<number>(15).fill(sample('cherry')); values[index] = invalid;
assert.throws(() => spin(2000, false, draws(values)));
}
assert.throws(() => spin(2000, true, draws([...Array<number>(15).fill(sample('cherry')), invalid])));
}
assert.throws(() => spin(2000, false, () => { throw Error('entropy unavailable'); }));
});
test('malformed boards and unsupported bets fail before they can be settled', () => {
const malformed: unknown[] = [null, [], board().slice(0, 4), [...board(), ['cherry']], board().map(col => col.slice(0, 2)),
[['unknown', 'cherry', 'cherry'], ...board().slice(1)]];
for (const value of malformed) assert.throws(() => evaluate(value as SymbolId[][], 2000));
for (const bet of [0, -2000, 1500, NaN, Infinity, Number.MAX_SAFE_INTEGER]) {
assert.throws(() => evaluate(board(), bet));
assert.throws(() => spin(bet, false, () => sample('cherry')));
}
});
test('initial state grants once and returns fresh board, settings and snapshots', () => {
const first = initialState(); const second = initialState();
assert.equal(first.version, 1); assert.equal(first.balance, 100000); assert.equal(first.bet, 2000);
assert.equal(first.lastWin, 0); assert.equal(first.phase, 'idle'); assert.equal(first.sequence, 0);
assert.equal(first.free, null); assert.equal(first.pending, null); assert.equal(first.lastClaimDay, null);
assert.deepEqual(Object.keys(first.settings).sort(), ['music', 'sound', 'vibration']);
for (const value of Object.values(first.settings)) assert.equal(typeof value, 'boolean');
first.board[0][0] = first.board[0][0] === 'seven' ? 'bell' : 'seven'; first.settings.music = !first.settings.music;
assert.notDeepEqual(first, second); assert.deepEqual(initialState(), second);
const { game, storage } = session(); const writes = storage.writes;
assert.equal(storage.values.size, 1, 'one JSON snapshot per scope');
const restored = new GameSession(new GameRepository(storage, SCOPE), () => { throw Error('restore must not draw'); });
assert.deepEqual(restored.state, game.state); assert.equal(storage.writes, writes);
});
test('beginSpin atomically commits the paid bet, winnings and pending animation exactly once', () => {
const { game, storage } = session(() => sample('cherry'));
const writes = storage.writes;
const result = game.beginSpin(); const committed = game.state;
assert.equal(result.win, 136000);
assert.equal(committed.balance, 100000 - 2000 + 136000);
assert.equal(committed.lastWin, result.win); assert.equal(committed.phase, 'spinning');
assert.equal(committed.sequence, 1); assert.equal(committed.pending?.id, 1);
assert.equal(committed.pending?.free, false); assert.deepEqual(committed.pending?.result, result);
assert.deepEqual(committed.board, result.board); assert.equal(committed.free, null);
assert.equal(storage.writes, writes + 1, 'money and pending result require one write');
assert.deepEqual(persisted(storage), committed);
assertUnchanged(game, storage, () => game.beginSpin());
game.completeSpin();
assert.equal(game.state.phase, 'idle'); assert.equal(game.state.pending, null);
assert.equal(game.state.balance, committed.balance); assert.equal(game.state.lastWin, result.win);
const after = game.state; const afterWrites = storage.writes;
try { game.completeSpin(); } catch { /* Duplicate completion may reject or no-op; it cannot commit. */ }
assert.deepEqual(game.state, after); assert.equal(storage.writes, afterWrites);
});
test('pending refresh replays without RNG, charging, awarding or any restoration write', () => {
const { game, storage } = session(() => sample('cherry'));
game.beginSpin(); const before = persisted(storage); const writes = storage.writes;
const restored = new GameSession(new GameRepository(storage, SCOPE), () => { throw Error('pending replay drew again'); });
assert.equal(restored.state.phase, 'spinning'); assert.deepEqual(restored.state.pending, before.pending);
assert.deepEqual(restored.state, before); assert.equal(storage.writes, writes);
restored.completeSpin();
assert.equal(restored.state.balance, before.balance); assert.equal(restored.state.lastWin, before.lastWin);
assert.equal(restored.state.sequence, before.sequence); assert.equal(restored.state.pending, null);
assertUnchanged(game, storage, () => game.completeSpin());
});
test('bet changes are restricted to idle supported bets; insufficient balance never draws or commits', () => {
let calls = 0;
const { game, storage } = session(() => { calls++; return sample('scatter'); });
for (const bet of [1000, 2000, 5000, 10000, 20000, 50000]) {
game.setBet(bet); assert.equal(game.state.bet, bet); assert.equal(game.state.balance, 100000);
}
for (const bet of [0, 1500, NaN, Infinity]) assertUnchanged(game, storage, () => game.setBet(bet));
const repo = new GameRepository(storage, SCOPE); const seed = repo.load()!; seed.balance = 49999; repo.save(seed);
const poor = new GameSession(new GameRepository(storage, SCOPE), () => { calls++; return sample('cherry'); });
const beforeCalls = calls;
assertUnchanged(poor, storage, () => poor.beginSpin()); assert.equal(calls, beforeCalls);
const active = session().game; active.beginSpin(); assert.throws(() => active.setBet(1000));
});
test('normal award is separate from free total, free bets stay locked and scatter never retriggers', () => {
// 3 scatter + 12 cherries still pays ordinary lines on the trigger. / Trigger payout is not free-spin total.
const triggerBoard = board('cherry'); triggerBoard[4] = ['scatter', 'scatter', 'scatter'];
let paid = false; let draw = 0;
const triggerRandom = randomFor(triggerBoard);
const { game, storage } = session(() => {
if (!paid) { const result = triggerRandom(); if (++draw === 15) paid = true; return result; }
return sample('bell');
});
const trigger = game.beginSpin(); const afterTrigger = game.state.balance;
assert.equal(trigger.awarded, 8); assert.ok(trigger.win > 0);
assert.deepEqual(game.state.free, { remaining: 8, awarded: 8, total: 0, bet: 2000 });
assert.equal(game.state.lastWin, trigger.win);
game.completeSpin(); assert.equal(game.state.phase, 'free-trigger');
assertUnchanged(game, storage, () => game.beginSpin());
assertUnchanged(game, storage, () => game.setBet(1000));
game.startFree(); assert.equal(game.state.phase, 'free-ready');
assertUnchanged(game, storage, () => game.setBet(5000));
let total = 0;
for (let index = 0; index < 8; index++) {
const writes = storage.writes;
const result = game.beginSpin(); total += result.win;
assert.equal(result.awarded, 0); assert.equal(game.state.pending?.free, true);
assert.equal(game.state.free?.remaining, 7 - index); assert.equal(game.state.free?.awarded, 8);
assert.equal(game.state.free?.total, total); assert.equal(game.state.free?.bet, 2000);
assert.equal(game.state.balance, afterTrigger + total); assert.equal(game.state.lastWin, result.win);
assert.equal(storage.writes, writes + 1, 'free win, remaining count and pending must commit together');
game.completeSpin();
assert.equal(game.state.phase, index === 7 ? 'free-result' : 'free-ready');
}
assert.ok(total > 0); assert.equal(game.state.free?.total, total);
assertUnchanged(game, storage, () => game.beginSpin());
game.closeFreeResult();
assert.equal(game.state.phase, 'idle'); assert.equal(game.state.free, null);
assert.equal(game.state.balance, afterTrigger + total); game.setBet(5000);
});
test('free SCATTER preserves all cells, consumes exactly the awarded spins and cannot add spins', () => {
const { game } = freeReady(); const balance = game.state.balance;
for (let index = 0; index < 16; index++) {
const result = game.beginSpin();
assert.deepEqual(result.board, board()); assert.equal(result.scatters, 15); assert.equal(result.awarded, 0);
assert.equal(result.win, 0); assert.equal(game.state.free?.remaining, 15 - index);
game.completeSpin(); assert.equal(game.state.balance, balance);
}
assert.equal(game.state.phase, 'free-result'); assert.equal(game.state.free?.total, 0);
});
test('refresh preserves trigger, ready, intermediate pending, final pending and result without grants', () => {
const { game, storage } = freeReady();
const restore = () => new GameSession(new GameRepository(storage, SCOPE), () => sample('scatter'));
assert.deepEqual(restore().state, game.state);
let current = restore();
for (let index = 0; index < 16; index++) {
current.beginSpin(); const before = current.state; const writes = storage.writes;
current = restore();
assert.equal(current.state.phase, 'spinning'); assert.deepEqual(current.state, before);
assert.equal(storage.writes, writes);
current.completeSpin();
}
assert.equal(current.state.phase, 'free-result'); assert.deepEqual(restore().state, current.state);
const triggerFixture = session(); triggerFixture.game.beginSpin(); triggerFixture.game.completeSpin();
const trigger = new GameSession(new GameRepository(triggerFixture.storage, SCOPE), () => { throw Error('trigger restore draw'); });
assert.equal(trigger.state.phase, 'free-trigger'); assert.deepEqual(trigger.state.free, triggerFixture.game.state.free);
});
test('daily gift is once per UTC day and reset countdown crosses midnight and leap day', () => {
let time = Date.parse('2028-02-28T23:59:59.000Z');
const { game, storage } = session(undefined, () => time);
assert.equal(game.canClaimDaily(), true); assert.equal(game.nextResetMs(), 1000);
assert.equal(game.claimDaily(), true); assert.equal(game.state.balance, 120000);
assert.equal(game.state.lastClaimDay, '2028-02-28'); assert.equal(game.canClaimDaily(), false);
const writes = storage.writes;
assert.equal(game.claimDaily(), false); assert.equal(storage.writes, writes);
const restored = new GameSession(new GameRepository(storage, SCOPE), undefined, () => time);
assert.equal(restored.canClaimDaily(), false); assert.equal(restored.claimDaily(), false);
time += 1000;
assert.equal(restored.nextResetMs(), DAY); assert.equal(restored.canClaimDaily(), true);
assert.equal(restored.claimDaily(), true); assert.equal(restored.state.balance, 140000);
assert.equal(restored.state.lastClaimDay, '2028-02-29');
time = Date.parse('2028-03-01T00:00:00Z');
assert.equal(restored.claimDaily(), true); assert.equal(restored.state.lastClaimDay, '2028-03-01');
assert.equal(restored.state.balance, 160000);
});
test('preferences persist independently and exposed state/results cannot mutate a saved snapshot', () => {
const { game, storage } = session(() => sample('cherry'));
for (const key of ['music', 'sound', 'vibration'] as const) game.setPreference(key, false);
assert.deepEqual(game.state.settings, { music: false, sound: false, vibration: false });
const result = game.beginSpin(); const committed = copy(game.state);
result.board[0][0] = 'scatter'; result.wins[0].amount = 0; result.win = 0;
const exposed = game.state; exposed.balance = 0; exposed.board[0][0] = 'scatter'; exposed.settings.music = true;
exposed.pending!.result.board[1][0] = 'scatter'; exposed.pending!.result.wins[0].amount = 0;
assert.deepEqual(game.state, committed); assert.deepEqual(persisted(storage), committed);
game.completeSpin(); const restored = new GameSession(new GameRepository(storage, SCOPE));
assert.deepEqual(restored.state.settings, { music: false, sound: false, vibration: false });
});
test('repository snapshots and initial grants are isolated by caller-provided service/product/guest scope', () => {
const storage = memory(); const first = new GameRepository(storage, SCOPE);
assert.equal(first.load(), null);
const state = initialState(); first.save(state); state.balance = 1; state.settings.music = false;
const loaded = first.load()!; assert.equal(loaded.balance, 100000);
loaded.balance = 2; loaded.board[0][0] = 'scatter';
assert.equal(first.load()!.balance, 100000);
for (const scope of ['https://other.test/FruitFixture/guest-a', 'https://example.test/OtherProduct/guest-a',
'https://example.test/FruitFixture/guest-b']) {
const another = new GameRepository(storage, scope); assert.equal(another.load(), null);
const other = new GameSession(another); assert.equal(other.state.balance, 100000);
other.claimDaily(); assert.equal(other.state.balance, 120000);
assert.equal(first.load()!.balance, 100000);
}
assert.equal(storage.values.size, 4);
});
test('repository rejects invalid state invariants before writing', () => {
const { storage } = session();
const mutations: ((value: GameState) => void)[] = [
state => { state.version = 2 as 1; }, state => { state.balance = -1; }, state => { state.balance = 1.5; },
state => { state.balance = Number.MAX_SAFE_INTEGER + 1; }, state => { state.bet = 1500; },
state => { state.lastWin = -1; }, state => { state.sequence = -1; },
state => { state.board.pop(); }, state => { state.board[0][0] = 'invalid' as SymbolId; },
state => { state.lastClaimDay = '2026-02-30'; }, state => { state.phase = 'spinning'; },
state => { state.phase = 'free-trigger'; }, state => { state.settings.music = 1 as unknown as boolean; },
state => { state.free = { remaining: 9, awarded: 8, total: 0, bet: 2000 }; state.phase = 'free-ready'; },
];
for (const mutate of mutations) {
const repository = new GameRepository(storage, SCOPE); const invalid = repository.load()!; mutate(invalid);
const before = [...storage.values]; const writes = storage.writes;
assert.throws(() => repository.save(invalid));
assert.deepEqual([...storage.values], before); assert.equal(storage.writes, writes);
}
});
test('corrupt or incompatible existing JSON is rejected without overwriting or giving a new balance', () => {
for (const corrupt of ['{invalid', 'null', '[]', '{}', '42', '"invalid"', '{"version":2}']) {
const { storage } = session(); const key = [...storage.values.keys()][0]; storage.values.set(key, corrupt);
const writes = storage.writes;
assert.throws(() => new GameSession(new GameRepository(storage, SCOPE)));
assert.equal(storage.values.get(key), corrupt); assert.equal(storage.writes, writes);
}
});
test('unavailable initial storage never silently creates an in-memory grant', () => {
for (const mode of ['read', 'write', 'silent'] as const) {
const storage = memory();
if (mode === 'read') storage.failRead = 1;
if (mode === 'write') storage.failWrite = true;
if (mode === 'silent') storage.silent = true;
assert.throws(() => new GameSession(new GameRepository(storage, SCOPE)));
assert.equal(storage.values.size, 0);
}
});
test('failed and silent writes keep spin, bet, daily and preferences unchanged in memory', () => {
for (const mode of ['failWrite', 'silent'] as const) {
for (const action of [
(game: GameSession) => game.beginSpin(), (game: GameSession) => game.setBet(5000),
(game: GameSession) => game.claimDaily(), (game: GameSession) => game.setPreference('sound', false),
]) {
const { game, storage } = session(() => sample('cherry'));
storage[mode] = true;
assertUnchanged(game, storage, () => action(game));
}
}
});
test('failed complete/start/close writes keep the current pending or free state replayable', () => {
const { game, storage } = session(); game.beginSpin();
storage.failWrite = true; assertUnchanged(game, storage, () => game.completeSpin());
storage.failWrite = false; game.completeSpin();
storage.failWrite = true; assertUnchanged(game, storage, () => game.startFree());
storage.failWrite = false; game.startFree();
for (let index = 0; index < 16; index++) { game.beginSpin(); game.completeSpin(); }
assert.equal(game.state.phase, 'free-result');
storage.failWrite = true; assertUnchanged(game, storage, () => game.closeFreeResult());
storage.failWrite = false; game.closeFreeResult(); assert.equal(game.state.phase, 'idle');
});
test('readback verification detects a corrupt write without publishing the new in-memory state', () => {
const { game, storage } = session(() => sample('cherry')); const before = game.state;
storage.corrupt = true;
assert.throws(() => game.beginSpin()); assert.deepEqual(game.state, before);
storage.corrupt = false;
assert.throws(() => new GameSession(new GameRepository(storage, SCOPE)));
});
test('an uncertain commit with failing readback recovers saved pending and cannot be charged twice', () => {
const { game, storage } = session(() => sample('cherry')); const before = game.state;
storage.afterWrite = () => { storage.failRead = 1; };
assert.throws(() => game.beginSpin()); assert.deepEqual(game.state, before);
storage.afterWrite = null;
const committed = new GameSession(new GameRepository(storage, SCOPE), () => { throw Error('uncertain commit redraw'); });
assert.equal(committed.state.phase, 'spinning'); assert.equal(committed.state.balance, 234000);
assertUnchanged(game, storage, () => game.beginSpin());
committed.completeSpin(); assert.equal(committed.state.balance, 234000);
});
test('stale sessions cannot overwrite a concurrent spin or daily claim in the same guest scope', () => {
for (const action of [(game: GameSession) => game.beginSpin(), (game: GameSession) => game.claimDaily()]) {
const { game, storage } = session(() => sample('cherry'));
const stale = new GameSession(new GameRepository(storage, SCOPE), () => sample('cherry'), () => NOW);
action(game); const committed = persisted(storage); const writes = storage.writes;
assertUnchanged(stale, storage, () => action(stale));
assert.deepEqual(persisted(storage), committed); assert.equal(storage.writes, writes);
}
});
test('same-page reentrant storage writes cannot allow two sessions to settle the same revision', () => {
const { game, storage } = session(() => sample('cherry'));
const competitor = new GameSession(new GameRepository(storage, SCOPE), () => sample('cherry'));
const competingBefore = competitor.state; let attempted = false;
storage.beforeWrite = () => {
storage.beforeWrite = null; attempted = true;
assert.throws(() => competitor.beginSpin());
};
game.beginSpin();
assert.equal(attempted, true); assert.deepEqual(competitor.state, competingBefore);
assert.equal(game.state.balance, 234000); assert.deepEqual(persisted(storage), game.state);
});
test('entropy failure aborts a spin before balance, sequence or persisted pending can change', () => {
for (const invalidAt of [0, 14]) {
let calls = 0;
const { game, storage } = session(() => ++calls > invalidAt ? NaN : sample('cherry'));
assertUnchanged(game, storage, () => game.beginSpin());
}
const { game, storage } = freeReady(draws([...Array<number>(15).fill(sample('bell')), 1]));
assertUnchanged(game, storage, () => game.beginSpin());
});