crossmate

GameCursorStoreTests.swift (5276B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("GameCursorStore")
 @MainActor
 struct GameCursorStoreTests {
 
     private func makeStore() -> GameCursorStore {
         // Use a fresh UserDefaults suite per test to avoid cross-test pollution.
         let suiteName = "test-\(UUID().uuidString)"
         let defaults = UserDefaults(suiteName: suiteName)!
         return GameCursorStore(defaults: defaults)
     }
 
     /// 3×3 grid with a block at (1, 1):
     ///   row 0: A B C   (A1 across, D1/D2/… downs start here)
     ///   row 1: D # E
     ///   row 2: F G H
     /// (1, 0) = 'D' is part of the D1 down answer only — it has no across word.
     private func makeGame() throws -> Game {
         let source = """
         Title: Cursor Test
         Author: Test
 
 
         ABC
         D#E
         FGH
 
 
         A1. First across ~ ABC
         A3. Final across ~ FGH
         D1. First down ~ ADF
         D2. Final down ~ CEH
         """
         let puzzle = Puzzle(xd: try XD.parse(source))
         return Game(puzzle: puzzle)
     }
 
     private func makeSession(
         game: Game,
         gameID: UUID,
         store: GameCursorStore?
     ) -> PlayerSession {
         let mutator = GameMutator(game: game, gameID: gameID, movesUpdater: nil)
         return PlayerSession(game: game, mutator: mutator, cursorStore: store)
     }
 
     // MARK: - Store round-trip
 
     @Test("Cursor round-trips through the store")
     func cursorRoundTrips() {
         let store = makeStore()
         let gameID = UUID()
         #expect(store.cursor(forGame: gameID) == nil)
 
         store.setCursor(.init(row: 2, col: 1, direction: .down), forGame: gameID)
         #expect(store.cursor(forGame: gameID) == .init(row: 2, col: 1, direction: .down))
 
         store.clearCursor(forGame: gameID)
         #expect(store.cursor(forGame: gameID) == nil)
     }
 
     @Test("Cursors are isolated per game")
     func cursorsIsolatedPerGame() {
         let store = makeStore()
         let a = UUID()
         let b = UUID()
         store.setCursor(.init(row: 0, col: 1, direction: .across), forGame: a)
         store.setCursor(.init(row: 2, col: 2, direction: .down), forGame: b)
         #expect(store.cursor(forGame: a) == .init(row: 0, col: 1, direction: .across))
         #expect(store.cursor(forGame: b) == .init(row: 2, col: 2, direction: .down))
     }
 
     // MARK: - PlayerSession persistence + restore
 
     @Test("Moving the cursor persists it to the store")
     func movingCursorPersists() throws {
         let store = makeStore()
         let gameID = UUID()
         let session = makeSession(game: try makeGame(), gameID: gameID, store: store)
 
         session.select(row: 2, col: 2)
 
         let saved = try #require(store.cursor(forGame: gameID))
         #expect(saved.row == 2)
         #expect(saved.col == 2)
     }
 
     @Test("A new session restores the persisted cursor")
     func sessionRestoresPersistedCursor() throws {
         let store = makeStore()
         let gameID = UUID()
 
         let first = makeSession(game: try makeGame(), gameID: gameID, store: store)
         first.select(row: 2, col: 0)
         first.setDirection(.down)
 
         let reopened = makeSession(game: try makeGame(), gameID: gameID, store: store)
         #expect(reopened.selectedRow == 2)
         #expect(reopened.selectedCol == 0)
         #expect(reopened.direction == .down)
     }
 
     @Test("Without a store the session uses the default start position")
     func defaultsWithoutStore() throws {
         let session = makeSession(game: try makeGame(), gameID: UUID(), store: nil)
         #expect(session.selectedRow == 0)
         #expect(session.selectedCol == 0)
         #expect(session.direction == .across)
     }
 
     @Test("An out-of-bounds saved cursor falls back to the default start")
     func invalidSavedCursorFallsBack() throws {
         let store = makeStore()
         let gameID = UUID()
         store.setCursor(.init(row: 9, col: 9, direction: .across), forGame: gameID)
 
         let session = makeSession(game: try makeGame(), gameID: gameID, store: store)
         #expect(session.selectedRow == 0)
         #expect(session.selectedCol == 0)
         #expect(session.direction == .across)
     }
 
     @Test("A saved cursor on a block cell falls back to the default start")
     func blockSavedCursorFallsBack() throws {
         let store = makeStore()
         let gameID = UUID()
         store.setCursor(.init(row: 1, col: 1, direction: .across), forGame: gameID)
 
         let session = makeSession(game: try makeGame(), gameID: gameID, store: store)
         #expect(session.selectedRow == 0)
         #expect(session.selectedCol == 0)
     }
 
     @Test("Restore flips direction when the saved one has no word")
     func restoreFlipsDirectionWithoutWord() throws {
         let store = makeStore()
         let gameID = UUID()
         // (1, 0) = 'D' belongs only to the D1 down answer; there is no across
         // word through it, so a saved `.across` must flip to `.down`.
         store.setCursor(.init(row: 1, col: 0, direction: .across), forGame: gameID)
 
         let session = makeSession(game: try makeGame(), gameID: gameID, store: store)
         #expect(session.selectedRow == 1)
         #expect(session.selectedCol == 0)
         #expect(session.direction == .down)
     }
 }