559 lines
24 KiB
JavaScript
559 lines
24 KiB
JavaScript
import { describe, it, expect } from 'vitest'
|
||
import { readFileSync, readdirSync, statSync } from 'node:fs'
|
||
import { fileURLToPath } from 'node:url'
|
||
import { dirname, join } from 'node:path'
|
||
|
||
import {
|
||
Grid, eightWay, orthogonal,
|
||
GameSession, replay, mulberry32,
|
||
MinesweeperRules, generateBoard, validateLayout, levels
|
||
} from '../core/index.js'
|
||
import { placeMines, excludeAround } from '../core/minesweeper/board.js'
|
||
|
||
const beginner = levels.beginner
|
||
|
||
// Reveal every non-mine cell of a session's board, reading the (already-placed)
|
||
// state — a deterministic way to drive a game to a win without hardcoding the
|
||
// layout. Returns the events for assertions.
|
||
function playToWin(session, clock) {
|
||
// First reveal seeds the board (first-click safe); pick a corner.
|
||
session.applyMove({ type: 'reveal', r: 0, c: 0 })
|
||
const { grid, config } = session.state
|
||
for (let r = 0; r < config.rows; r++) {
|
||
for (let c = 0; c < config.cols; c++) {
|
||
if (!grid.at(r, c).mine && grid.at(r, c).status !== 'revealed') {
|
||
if (clock) clock.tick()
|
||
session.applyMove({ type: 'reveal', r, c })
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
describe('grid + neighbors (Layer 0)', () => {
|
||
it('addresses cells and reports bounds', () => {
|
||
const g = new Grid(3, 4, (r, c) => `${r},${c}`)
|
||
expect(g.rows).toBe(3)
|
||
expect(g.cols).toBe(4)
|
||
expect(g.at(2, 3)).toBe('2,3')
|
||
expect(g.inBounds(2, 3)).toBe(true)
|
||
expect(g.inBounds(3, 0)).toBe(false)
|
||
expect(g.inBounds(-1, 0)).toBe(false)
|
||
})
|
||
|
||
it('eightWay yields 8 neighbors interior, 3 in a corner', () => {
|
||
const g = new Grid(5, 5)
|
||
expect(eightWay(g, 2, 2)).toHaveLength(8)
|
||
expect(eightWay(g, 0, 0)).toHaveLength(3)
|
||
expect(orthogonal(g, 2, 2)).toHaveLength(4)
|
||
expect(orthogonal(g, 0, 0)).toHaveLength(2)
|
||
})
|
||
})
|
||
|
||
describe('rng (Layer 1)', () => {
|
||
it('is deterministic for a given seed', () => {
|
||
const a = mulberry32(12345)
|
||
const b = mulberry32(12345)
|
||
const seqA = [a(), a(), a()]
|
||
const seqB = [b(), b(), b()]
|
||
expect(seqA).toEqual(seqB)
|
||
expect(mulberry32(1)()).not.toBe(mulberry32(2)())
|
||
})
|
||
})
|
||
|
||
describe('board generation (Layer 2)', () => {
|
||
it('places exactly `mines` mines, deterministically from the seed', () => {
|
||
const mk = () => {
|
||
const g = new Grid(beginner.rows, beginner.cols, () => ({ mine: false, adjacent: 0, status: 'hidden' }))
|
||
const placed = placeMines(42, beginner, excludeAround(beginner, 0, 0), g)
|
||
return { g, placed }
|
||
}
|
||
const one = mk()
|
||
const two = mk()
|
||
expect(one.placed.size).toBe(beginner.mines)
|
||
expect([...one.placed].sort()).toEqual([...two.placed].sort())
|
||
})
|
||
|
||
it('keeps the first-click 3x3 neighborhood mine-free', () => {
|
||
const g = new Grid(beginner.rows, beginner.cols, () => ({ mine: false, adjacent: 0, status: 'hidden' }))
|
||
placeMines(7, beginner, excludeAround(beginner, 4, 4), g)
|
||
for (let dr = -1; dr <= 1; dr++) {
|
||
for (let dc = -1; dc <= 1; dc++) {
|
||
expect(g.at(4 + dr, 4 + dc).mine).toBe(false)
|
||
}
|
||
}
|
||
})
|
||
|
||
it('computes adjacency as the 8-way mine count', () => {
|
||
const g = new Grid(beginner.rows, beginner.cols, () => ({ mine: false, adjacent: 0, status: 'hidden' }))
|
||
placeMines(99, beginner, excludeAround(beginner, 0, 0), g)
|
||
g.forEach((cell, r, c) => {
|
||
if (cell.mine) return
|
||
let n = 0
|
||
for (const [nr, nc] of eightWay(g, r, c)) if (g.at(nr, nc).mine) n++
|
||
expect(cell.adjacent).toBe(n)
|
||
})
|
||
})
|
||
})
|
||
|
||
describe('generateBoard (Layer 2, pure)', () => {
|
||
it('is callable in plain Node and returns a plain layout object', () => {
|
||
// Non-square (rows ≠ cols) pins the rows-first orientation.
|
||
const layout = generateBoard(4, 7, 5, { seed: 42 })
|
||
expect(layout.rows).toBe(4)
|
||
expect(layout.cols).toBe(7)
|
||
expect(layout.mines).toBe(5)
|
||
expect(layout.cells).toHaveLength(4)
|
||
expect(layout.cells.every(row => row.length === 7)).toBe(true)
|
||
// plain data only — no Grid instance, no class methods leaking out
|
||
expect(layout.cells[0][0]).toEqual({ mine: expect.any(Boolean), adjacent: expect.any(Number) })
|
||
expect(layout).toEqual(JSON.parse(JSON.stringify(layout)))
|
||
// places exactly `mines` mines
|
||
expect(layout.mineLocations).toHaveLength(5)
|
||
let mineCount = 0
|
||
for (const row of layout.cells) for (const cell of row) if (cell.mine) mineCount++
|
||
expect(mineCount).toBe(5)
|
||
})
|
||
|
||
it('same injected RNG (seed) → identical layout', () => {
|
||
const a = generateBoard(16, 16, 40, { rng: mulberry32(123) })
|
||
const b = generateBoard(16, 16, 40, { rng: mulberry32(123) })
|
||
expect(a).toEqual(b)
|
||
// and the seed convenience wrapper matches an explicitly injected mulberry32
|
||
expect(generateBoard(16, 16, 40, { seed: 123 })).toEqual(a)
|
||
// a different seed diverges
|
||
expect(generateBoard(16, 16, 40, { seed: 124 })).not.toEqual(a)
|
||
})
|
||
|
||
it('computes adjacency as the 8-way mine count', () => {
|
||
const layout = generateBoard(9, 9, 10, { seed: 99 })
|
||
const g = new Grid(9, 9, (r, c) => layout.cells[r][c])
|
||
layout.cells.forEach((row, r) => row.forEach((cell, c) => {
|
||
if (cell.mine) return
|
||
let n = 0
|
||
for (const [nr, nc] of eightWay(g, r, c)) if (g.at(nr, nc).mine) n++
|
||
expect(cell.adjacent).toBe(n)
|
||
}))
|
||
})
|
||
|
||
it('honors an exclude set (e.g. first-click safety)', () => {
|
||
const exclude = new Set([0]) // key 0 == cell (0,0)
|
||
const layout = generateBoard(9, 9, 10, { seed: 7, exclude })
|
||
expect(layout.cells[0][0].mine).toBe(false)
|
||
})
|
||
|
||
it('rejects impossible dimensions and mine counts', () => {
|
||
expect(() => generateBoard(0, 9, 1)).toThrow(RangeError)
|
||
expect(() => generateBoard(3, 3, 10)).toThrow(RangeError) // more mines than cells
|
||
expect(() => generateBoard(3, 3, -1)).toThrow(RangeError)
|
||
})
|
||
})
|
||
|
||
describe('generateBoard first-move-safe (safeCell)', () => {
|
||
it('never mines the safe cell across randomized runs (property-style)', () => {
|
||
// Dense board so the safe cell is a demanding constraint, swept over many
|
||
// injected-RNG streams — the guarantee must hold for every seed, not one.
|
||
for (let seed = 0; seed < 200; seed++) {
|
||
const layout = generateBoard(9, 9, 70, { rng: mulberry32(seed), safeCell: { r: 4, c: 5 } })
|
||
expect(layout.cells[4][5].mine).toBe(false)
|
||
// and it's a genuine constraint on top of a correct board: exact mine count
|
||
expect(layout.mineLocations).toHaveLength(70)
|
||
}
|
||
})
|
||
|
||
it('holds at edge coordinates — every corner and a border cell', () => {
|
||
const corners = [{ r: 0, c: 0 }, { r: 0, c: 8 }, { r: 8, c: 0 }, { r: 8, c: 8 }]
|
||
const borders = [{ r: 0, c: 4 }, { r: 4, c: 0 }, { r: 8, c: 4 }, { r: 4, c: 8 }]
|
||
for (const safeCell of [...corners, ...borders]) {
|
||
const layout = generateBoard(9, 9, 70, { seed: 123, safeCell })
|
||
expect(layout.cells[safeCell.r][safeCell.c].mine).toBe(false)
|
||
}
|
||
})
|
||
|
||
it('generates a max-density board (mines = cells − 1) with the one safe cell blank', () => {
|
||
// 3x3 with 8 mines: every cell except the safe one must be a mine.
|
||
const layout = generateBoard(3, 3, 8, { seed: 5, safeCell: { r: 1, c: 1 } })
|
||
expect(layout.mineLocations).toHaveLength(8)
|
||
expect(layout.cells[1][1].mine).toBe(false)
|
||
let mines = 0
|
||
for (const row of layout.cells) for (const cell of row) if (cell.mine) mines++
|
||
expect(mines).toBe(8)
|
||
})
|
||
|
||
it('merges with an existing exclude set rather than replacing it', () => {
|
||
const exclude = new Set([0]) // key 0 == cell (0,0)
|
||
const layout = generateBoard(5, 5, 23, { seed: 9, exclude, safeCell: { r: 4, c: 4 } })
|
||
expect(layout.cells[0][0].mine).toBe(false) // from exclude
|
||
expect(layout.cells[4][4].mine).toBe(false) // from safeCell
|
||
expect(layout.mineLocations).toHaveLength(23) // 25 − 2 excluded
|
||
})
|
||
|
||
it('rejects configurations where the mines cannot fit with the safe cell excluded', () => {
|
||
// 3x3 = 9 cells, one reserved for safety ⇒ capacity 8; 9 mines can't fit.
|
||
expect(() => generateBoard(3, 3, 9, { safeCell: { r: 0, c: 0 } })).toThrow(RangeError)
|
||
})
|
||
|
||
it('rejects an out-of-bounds or non-integer safe cell', () => {
|
||
expect(() => generateBoard(9, 9, 10, { safeCell: { r: 9, c: 0 } })).toThrow(RangeError)
|
||
expect(() => generateBoard(9, 9, 10, { safeCell: { r: -1, c: 0 } })).toThrow(RangeError)
|
||
expect(() => generateBoard(9, 9, 10, { safeCell: { r: 0, c: 1.5 } })).toThrow(RangeError)
|
||
})
|
||
})
|
||
|
||
describe('rules (Layer 2)', () => {
|
||
it('first reveal is never a mine and opens a region', () => {
|
||
const s = MinesweeperRules.init(3, beginner)
|
||
const { state, events } = MinesweeperRules.apply(s, { type: 'reveal', r: 0, c: 0 })
|
||
expect(state.phase).toBe('active')
|
||
expect(state.grid.at(0, 0).mine).toBe(false)
|
||
expect(events[0].type).toBe('reveal')
|
||
// first click is inside a mine-free 3x3, so it's blank and floods
|
||
expect(events[0].cells.length).toBeGreaterThan(1)
|
||
})
|
||
|
||
it('revealing a mine loses and emits explode with all mines', () => {
|
||
const s = MinesweeperRules.init(5, beginner)
|
||
MinesweeperRules.apply(s, { type: 'reveal', r: 0, c: 0 })
|
||
const mine = firstMine(s.grid)
|
||
const { state, events } = MinesweeperRules.apply(s, { type: 'reveal', r: mine.r, c: mine.c })
|
||
expect(state.phase).toBe('lost')
|
||
expect(events[0].type).toBe('explode')
|
||
expect(events[0].mines.length).toBe(beginner.mines)
|
||
})
|
||
|
||
it('toggles flags and blocks revealing a flagged cell', () => {
|
||
let s = MinesweeperRules.init(1, beginner)
|
||
s = MinesweeperRules.apply(s, { type: 'reveal', r: 0, c: 0 }).state
|
||
const hidden = firstHidden(s.grid)
|
||
let r = MinesweeperRules.apply(s, { type: 'flag', r: hidden.r, c: hidden.c })
|
||
expect(r.events[0]).toMatchObject({ type: 'flag', flagged: true })
|
||
// revealing a flagged cell is a no-op
|
||
r = MinesweeperRules.apply(r.state, { type: 'reveal', r: hidden.r, c: hidden.c })
|
||
expect(r.events).toHaveLength(0)
|
||
expect(r.state.grid.at(hidden.r, hidden.c).status).toBe('flagged')
|
||
})
|
||
|
||
it('project never leaks an unrevealed mine mid-game, but reveals mines when over', () => {
|
||
const s = MinesweeperRules.init(8, beginner)
|
||
const active = MinesweeperRules.apply(s, { type: 'reveal', r: 0, c: 0 }).state
|
||
const view = MinesweeperRules.project(active)
|
||
for (const cell of view.cells) {
|
||
if (cell.status !== 'revealed') expect(cell.mine).not.toBe(true)
|
||
}
|
||
// now lose and re-project
|
||
const mine = firstMine(active.grid)
|
||
const lost = MinesweeperRules.apply(active, { type: 'reveal', r: mine.r, c: mine.c }).state
|
||
const overView = MinesweeperRules.project(lost)
|
||
expect(overView.cells.some(c => c.status === 'hidden' && c.mine === true)).toBe(true)
|
||
})
|
||
})
|
||
|
||
describe('board injection (fromLayout, Layer 2)', () => {
|
||
// A hand-built 3x3 with a single mine at (0,0). Adjacency: the mine's three
|
||
// neighbors (0,1),(1,0),(1,1) are 1; everything else is 0.
|
||
const knownLayout = () => ({
|
||
rows: 3,
|
||
cols: 3,
|
||
mines: 1,
|
||
cells: [
|
||
[{ mine: true, adjacent: 0 }, { mine: false, adjacent: 1 }, { mine: false, adjacent: 0 }],
|
||
[{ mine: false, adjacent: 1 }, { mine: false, adjacent: 1 }, { mine: false, adjacent: 0 }],
|
||
[{ mine: false, adjacent: 0 }, { mine: false, adjacent: 0 }, { mine: false, adjacent: 0 }]
|
||
],
|
||
mineLocations: [[0, 0]]
|
||
})
|
||
|
||
it('creates a game instance from an injected layout and scripts moves to known states', () => {
|
||
const session = new GameSession(MinesweeperRules, { state: MinesweeperRules.fromLayout(knownLayout()) })
|
||
expect(session.status()).toBe('fresh')
|
||
|
||
// Reveal a numbered (non-zero) cell: it activates the game and reveals just
|
||
// itself, carrying the layout's adjacency — proof the injected board is live.
|
||
const first = session.applyMove({ type: 'reveal', r: 0, c: 1 })
|
||
expect(session.status()).toBe('active')
|
||
expect(first.events[0].cells).toEqual([{ r: 0, c: 1, adjacent: 1 }])
|
||
|
||
// Stepping on the injected mine loses and reports it (before any flood wins).
|
||
const boom = session.applyMove({ type: 'reveal', r: 0, c: 0 })
|
||
expect(session.status()).toBe('lost')
|
||
expect(boom.events[0]).toMatchObject({ type: 'explode', r: 0, c: 0 })
|
||
expect(boom.events[0].mines).toEqual([{ r: 0, c: 0 }])
|
||
})
|
||
|
||
it('a zero cell floods the connected safe region on an injected board', () => {
|
||
const session = new GameSession(MinesweeperRules, { state: MinesweeperRules.fromLayout(knownLayout()) })
|
||
// (2,2) is a zero far from the mine; flood opens all 8 safe cells → win.
|
||
const flood = session.applyMove({ type: 'reveal', r: 2, c: 2 })
|
||
expect(flood.events[0].cells.length).toBe(8)
|
||
expect(session.status()).toBe('won')
|
||
})
|
||
|
||
it('an injected board can be played to a win, every safe cell revealed', () => {
|
||
const session = new GameSession(MinesweeperRules, { state: MinesweeperRules.fromLayout(knownLayout()) })
|
||
// Reveal all 8 non-mine cells; avoid (0,0).
|
||
for (let r = 0; r < 3; r++) {
|
||
for (let c = 0; c < 3; c++) {
|
||
if (r === 0 && c === 0) continue
|
||
session.applyMove({ type: 'reveal', r, c })
|
||
}
|
||
}
|
||
expect(session.status()).toBe('won')
|
||
})
|
||
|
||
it('plays identically to a generated board: injecting a generated layout reproduces its play', () => {
|
||
// Generate a board, then inject that exact layout. Revealing any cell must
|
||
// report the layout's own adjacency, and mines must sit where the layout says.
|
||
const layout = generateBoard(9, 9, 10, { seed: 42, safeCell: { r: 4, c: 4 } })
|
||
const state = MinesweeperRules.fromLayout(layout)
|
||
const { events } = MinesweeperRules.apply(state, { type: 'reveal', r: 4, c: 4 })
|
||
expect(state.phase).toBe('active')
|
||
// (4,4) was forced safe; its revealed adjacency matches the layout.
|
||
const seen = events[0].cells.find(cell => cell.r === 4 && cell.c === 4)
|
||
expect(seen.adjacent).toBe(layout.cells[4][4].adjacent)
|
||
// The mines are exactly the layout's mines.
|
||
const mines = []
|
||
state.grid.forEach((cell, r, c) => { if (cell.mine) mines.push([r, c]) })
|
||
expect(mines.sort()).toEqual([...layout.mineLocations].sort())
|
||
})
|
||
|
||
it('two sessions from the same layout with the same script transition identically', () => {
|
||
const script = [{ type: 'reveal', r: 2, c: 2 }, { type: 'flag', r: 0, c: 0 }, { type: 'reveal', r: 0, c: 1 }]
|
||
const run = () => {
|
||
const s = new GameSession(MinesweeperRules, { state: MinesweeperRules.fromLayout(knownLayout()) })
|
||
return script.map(m => s.applyMove(m).view)
|
||
}
|
||
expect(run()).toEqual(run())
|
||
})
|
||
|
||
it('rejects malformed layouts with a clear error', () => {
|
||
expect(() => MinesweeperRules.fromLayout(null)).toThrow(TypeError)
|
||
expect(() => MinesweeperRules.fromLayout('nope')).toThrow(TypeError)
|
||
// dimensions don't match the cells grid
|
||
expect(() => MinesweeperRules.fromLayout({ ...knownLayout(), rows: 4 })).toThrow(RangeError)
|
||
// mine count disagrees with the actual mined cells
|
||
expect(() => MinesweeperRules.fromLayout({ ...knownLayout(), mines: 2 })).toThrow(RangeError)
|
||
// a cell missing its shape
|
||
const badCells = knownLayout()
|
||
badCells.cells[1][1] = { mine: false } // no `adjacent`
|
||
expect(() => MinesweeperRules.fromLayout(badCells)).toThrow(TypeError)
|
||
// mineLocations pointing at a non-mined cell
|
||
const badLocs = knownLayout()
|
||
badLocs.mineLocations = [[2, 2]]
|
||
expect(() => MinesweeperRules.fromLayout(badLocs)).toThrow(RangeError)
|
||
})
|
||
|
||
it('validateLayout accepts a freshly generated board', () => {
|
||
expect(() => validateLayout(generateBoard(16, 16, 40, { seed: 3 }))).not.toThrow()
|
||
})
|
||
|
||
it('leaves existing seed-based construction unaffected', () => {
|
||
// No `state` supplied ⇒ the session still generates from seed/config as before.
|
||
const session = new GameSession(MinesweeperRules, { seed: 3, config: beginner })
|
||
const { events } = session.applyMove({ type: 'reveal', r: 0, c: 0 })
|
||
expect(session.status()).toBe('active')
|
||
expect(session.state.grid.at(0, 0).mine).toBe(false) // first-click safety intact
|
||
expect(events[0].cells.length).toBeGreaterThan(1)
|
||
})
|
||
})
|
||
|
||
describe('state serialization (serialize / deserialize)', () => {
|
||
// Drive a fresh session to a genuine MID-GAME state: opening flood + a flag on
|
||
// a mine (which stays flagged and never needs revealing to win). Returns the
|
||
// session, its clock, and the flagged mine's coordinates.
|
||
function midGame(seed = 21) {
|
||
const clock = makeClock()
|
||
const session = new GameSession(MinesweeperRules, { seed, config: beginner, clock })
|
||
clock.tick()
|
||
session.applyMove({ type: 'reveal', r: 0, c: 0 }) // opening flood → active
|
||
const mine = firstMine(session.state.grid)
|
||
clock.tick()
|
||
session.applyMove({ type: 'flag', r: mine.r, c: mine.c })
|
||
return { session, clock, mine }
|
||
}
|
||
|
||
it('round-trips a mid-game snapshot through JSON without loss', () => {
|
||
const { session } = midGame()
|
||
expect(session.status()).toBe('active') // genuinely mid-game, not fresh/finished
|
||
|
||
const snap = session.serialize()
|
||
const roundTripped = JSON.parse(JSON.stringify(snap))
|
||
expect(roundTripped).toEqual(snap) // JSON-safe: stringify → parse is lossless
|
||
|
||
// deserialize → re-serialize reproduces the exact snapshot
|
||
const revived = GameSession.deserialize(MinesweeperRules, roundTripped, { clock: makeClock() })
|
||
expect(revived.serialize()).toEqual(snap)
|
||
})
|
||
|
||
it('snapshot covers layout, revealed + flagged cells, and session/clock state', () => {
|
||
const { session, mine } = midGame()
|
||
const snap = session.serialize()
|
||
|
||
// board layout
|
||
expect(snap.state.grid.rows).toBe(beginner.rows)
|
||
expect(snap.state.grid.cols).toBe(beginner.cols)
|
||
expect(snap.state.grid.cells).toHaveLength(beginner.rows * beginner.cols)
|
||
expect(snap.state.grid.cells[0]).toEqual({ mine: expect.any(Boolean), adjacent: expect.any(Number), status: expect.any(String) })
|
||
|
||
// per-cell state: the flood left revealed cells, and our flagged mine is flagged
|
||
expect(snap.state.grid.cells.some(c => c.status === 'revealed')).toBe(true)
|
||
expect(snap.state.grid.cells[mine.r * beginner.cols + mine.c].status).toBe('flagged')
|
||
|
||
// session / clock state: timer started (t0 set), still running (tEnd null), log intact
|
||
expect(snap.t0).not.toBeNull()
|
||
expect(snap.tEnd).toBeNull()
|
||
expect(snap.log).toHaveLength(2)
|
||
expect(snap.log[0]).toEqual({ move: { type: 'reveal', r: 0, c: 0 }, t: expect.any(Number) })
|
||
})
|
||
|
||
it('a deserialized session resumes and plays identically to the original', () => {
|
||
const playToWin = (session, clock) => {
|
||
const { grid, config } = session.state
|
||
for (let r = 0; r < config.rows; r++) {
|
||
for (let c = 0; c < config.cols; c++) {
|
||
if (!grid.at(r, c).mine && grid.at(r, c).status !== 'revealed') {
|
||
clock.tick()
|
||
session.applyMove({ type: 'reveal', r, c })
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
const { session, clock } = midGame(33)
|
||
const snap = session.serialize()
|
||
// Revive on a clock continuing from the same instant, so timing stays aligned.
|
||
const reviveClock = makeClock(clock())
|
||
const revived = GameSession.deserialize(MinesweeperRules, JSON.parse(JSON.stringify(snap)), { clock: reviveClock })
|
||
|
||
playToWin(session, clock)
|
||
playToWin(revived, reviveClock)
|
||
|
||
expect(revived.status()).toBe(session.status())
|
||
expect(revived.status()).toBe('won')
|
||
expect(revived.view()).toEqual(session.view())
|
||
expect(revived.elapsed()).toBe(session.elapsed())
|
||
expect(revived.result()).toEqual(session.result())
|
||
})
|
||
|
||
it('rules.serialize / deserialize round-trips a state and revives a real Grid', () => {
|
||
const state = MinesweeperRules.init(7, beginner)
|
||
MinesweeperRules.apply(state, { type: 'reveal', r: 0, c: 0 })
|
||
const snap = MinesweeperRules.serialize(state)
|
||
const revived = MinesweeperRules.deserialize(JSON.parse(JSON.stringify(snap)))
|
||
expect(revived.grid).toBeInstanceOf(Grid) // not a plain object — a live Grid
|
||
expect(revived.grid.at(0, 0)).toEqual(state.grid.at(0, 0))
|
||
expect(MinesweeperRules.serialize(revived)).toEqual(snap)
|
||
})
|
||
|
||
it('serialize throws clearly when the rules lack a serializer', () => {
|
||
const bareRules = { init: () => ({}), apply: s => ({ state: s, events: [] }), status: () => 'fresh', project: s => s }
|
||
const session = new GameSession(bareRules, { state: {} })
|
||
expect(() => session.serialize()).toThrow(TypeError)
|
||
})
|
||
})
|
||
|
||
describe('session + timing (Layer 1)', () => {
|
||
it('reports authoritative elapsed time from the injected clock', () => {
|
||
const clock = makeClock()
|
||
const session = new GameSession(MinesweeperRules, { seed: 21, config: beginner, clock })
|
||
expect(session.elapsed()).toBe(0) // no move yet
|
||
playToWin(session, clock)
|
||
expect(session.status()).toBe('won')
|
||
// time is (terminal tick − first tick), owned by the clock, not the client
|
||
expect(session.elapsed()).toBeGreaterThan(0)
|
||
const result = session.result()
|
||
expect(result.status).toBe('won')
|
||
expect(result.seed).toBe(21)
|
||
})
|
||
})
|
||
|
||
describe('replay verification (Layer 1)', () => {
|
||
it('accepts a genuine winning log and recomputes the same time', () => {
|
||
const clock = makeClock()
|
||
const session = new GameSession(MinesweeperRules, { seed: 33, config: beginner, clock })
|
||
playToWin(session, clock)
|
||
const submission = session.result()
|
||
const verdict = replay(MinesweeperRules, submission)
|
||
expect(verdict.valid).toBe(true)
|
||
expect(verdict.status).toBe('won')
|
||
expect(verdict.time).toBe(submission.time)
|
||
})
|
||
|
||
it('rejects a truncated (non-terminal) log', () => {
|
||
const clock = makeClock()
|
||
const session = new GameSession(MinesweeperRules, { seed: 33, config: beginner, clock })
|
||
playToWin(session, clock)
|
||
const submission = session.result()
|
||
const truncated = { ...submission, log: submission.log.slice(0, 2) }
|
||
const verdict = replay(MinesweeperRules, truncated)
|
||
expect(verdict.valid).toBe(false)
|
||
expect(verdict.reason).toMatch(/terminal/)
|
||
})
|
||
|
||
it('rejects non-monotonic timestamps', () => {
|
||
const clock = makeClock()
|
||
const session = new GameSession(MinesweeperRules, { seed: 33, config: beginner, clock })
|
||
playToWin(session, clock)
|
||
const submission = session.result()
|
||
const tampered = { ...submission, log: submission.log.map((e, i) => ({ ...e, t: i === 1 ? -5 : e.t })) }
|
||
const verdict = replay(MinesweeperRules, tampered)
|
||
expect(verdict.valid).toBe(false)
|
||
expect(verdict.reason).toMatch(/monotonic/)
|
||
})
|
||
|
||
it('is deterministic: same seed + same log ⇒ same board', () => {
|
||
const a = MinesweeperRules.init(777, beginner)
|
||
const b = MinesweeperRules.init(777, beginner)
|
||
MinesweeperRules.apply(a, { type: 'reveal', r: 2, c: 2 })
|
||
MinesweeperRules.apply(b, { type: 'reveal', r: 2, c: 2 })
|
||
const minesA = []
|
||
const minesB = []
|
||
a.grid.forEach((cell, r, c) => { if (cell.mine) minesA.push(r * beginner.cols + c) })
|
||
b.grid.forEach((cell, r, c) => { if (cell.mine) minesB.push(r * beginner.cols + c) })
|
||
expect(minesA).toEqual(minesB)
|
||
})
|
||
})
|
||
|
||
describe('determinism guard (invariant #4)', () => {
|
||
it('no Date/Math.random in core/ outside the rng seam', () => {
|
||
const coreDir = join(dirname(fileURLToPath(import.meta.url)), '..', 'core')
|
||
const offenders = []
|
||
walk(coreDir, file => {
|
||
if (!file.endsWith('.js')) return
|
||
// Scan code only — strip comments so prose that *names* these APIs
|
||
// (e.g. "uses Math.imul, not Math.random") isn't a false positive.
|
||
const code = readFileSync(file, 'utf8')
|
||
.replace(/\/\*[\s\S]*?\*\//g, '')
|
||
.replace(/\/\/.*$/gm, '')
|
||
if (/\bMath\.random\b/.test(code) || /\bDate\.now\b/.test(code) || /\bnew Date\b/.test(code)) {
|
||
offenders.push(file)
|
||
}
|
||
})
|
||
expect(offenders).toEqual([])
|
||
})
|
||
})
|
||
|
||
// ---- helpers ----
|
||
|
||
function makeClock(start = 1000) {
|
||
let t = start
|
||
return Object.assign(() => t, { tick() { t += 50 } })
|
||
}
|
||
|
||
function firstMine(grid) {
|
||
let found = null
|
||
grid.forEach((cell, r, c) => { if (!found && cell.mine) found = { r, c } })
|
||
return found
|
||
}
|
||
|
||
function firstHidden(grid) {
|
||
let found = null
|
||
grid.forEach((cell, r, c) => { if (!found && cell.status === 'hidden' && !cell.mine) found = { r, c } })
|
||
return found
|
||
}
|
||
|
||
function walk(dir, fn) {
|
||
for (const name of readdirSync(dir)) {
|
||
const p = join(dir, name)
|
||
if (statSync(p).isDirectory()) walk(p, fn)
|
||
else fn(p)
|
||
}
|
||
}
|