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 = { 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 = (value: T): T => JSON.parse(JSON.stringify(value)) as T; function board(symbol: SymbolId = 'scatter'): SymbolId[][] { return Array.from({ length: 5 }, () => Array(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(); 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; 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(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(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(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(15).fill(sample('cherry')); values[index] = invalid; assert.throws(() => spin(2000, false, draws(values))); } assert.throws(() => spin(2000, true, draws([...Array(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(15).fill(sample('bell')), 1])); assertUnchanged(game, storage, () => game.beginSpin()); });