crossmate

GameStoreCompletionLockTests.swift (8859B)

---

 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 /// Completion makes a game terminal. Opening it seals the displayed grid to the
 /// puzzle solution — so post-completion merge drift (a late clear, clock skew,
 /// or an edit that reached a peer over engagement but never synced) can't leave
 /// a hole or stray letter in a "finished" puzzle — and the returned mutator is
 /// locked against further input.
 @Suite("GameStore completion lock", .isolatedNotificationState)
 @MainActor
 struct GameStoreCompletionLockTests {
 
     private static let authorID = "alice"
     private static let puzzleSource = """
     Title: Test Puzzle
     Author: Test
 
 
     AB
     CD
 
 
     A1. Across 1 ~ AB
     A3. Across 3 ~ CD
     D1. Down 1 ~ AC
     D2. Down 2 ~ BD
     """
 
     private func makeGame(
         completed: Bool,
         in ctx: NSManagedObjectContext
     ) throws -> (GameEntity, UUID) {
         let xd = try XD.parse(Self.puzzleSource)
         let puzzle = Puzzle(xd: xd)
         let gameID = UUID()
         let entity = GameEntity(context: ctx)
         entity.id = gameID
         entity.title = "Test"
         entity.puzzleSource = Self.puzzleSource
         entity.createdAt = Date()
         entity.updatedAt = Date()
         if completed { entity.completedAt = Date() }
         entity.ckRecordName = "game-\(gameID.uuidString)"
         entity.populateCachedSummaryFields(from: puzzle)
         try ctx.save()
         return (entity, gameID)
     }
 
     /// Writes a single local-device Moves row carrying `cells` (position → letter).
     private func writeMoves(
         for entity: GameEntity,
         gameID: UUID,
         cells: [GridPosition: String],
         in ctx: NSManagedObjectContext
     ) throws {
         let row = MovesEntity(context: ctx)
         row.game = entity
         row.authorID = Self.authorID
         row.deviceID = "device-a"
         row.ckRecordName = RecordSerializer.recordName(
             forMovesInGame: gameID,
             authorID: Self.authorID,
             deviceID: "device-a"
         )
         let now = Date()
         var encoded: [GridPosition: TimestampedCell] = [:]
         for (pos, letter) in cells {
             encoded[pos] = TimestampedCell(
                 letter: letter, mark: .none, updatedAt: now, authorID: Self.authorID
             )
         }
         row.cells = try MovesCodec.encode(encoded)
         row.updatedAt = now
         try ctx.save()
     }
 
     @Test("A completed game seals a hole and a stray wrong letter to the solution")
     func sealsToSolution() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ctx = persistence.viewContext
         let (entity, gameID) = try makeGame(completed: true, in: ctx)
 
         // (0,0) correct, (0,1) a stray wrong letter, (1,0) correct, (1,1) a
         // hole — the post-completion drift the seal has to repair.
         try writeMoves(
             for: entity, gameID: gameID,
             cells: [
                 GridPosition(row: 0, col: 0): "A",
                 GridPosition(row: 0, col: 1): "Z",
                 GridPosition(row: 1, col: 0): "C"
             ],
             in: ctx
         )
 
         let (game, _) = try store.loadGame(id: gameID)
 
         #expect(game.squares[0][0].entry == "A")   // correct — kept
         #expect(game.squares[0][1].entry == "B")   // stray — overwritten
         #expect(game.squares[1][0].entry == "C")   // correct — kept
         #expect(game.squares[1][1].entry == "D")   // hole — filled
         #expect(game.completionState == .solved)
     }
 
     @Test("Loading a completed game returns a locked mutator that rejects input")
     func loadedMutatorIsLocked() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ctx = persistence.viewContext
         let (entity, gameID) = try makeGame(completed: true, in: ctx)
         try writeMoves(
             for: entity, gameID: gameID,
             cells: [GridPosition(row: 0, col: 0): "A"],
             in: ctx
         )
 
         let (game, mutator) = try store.loadGame(id: gameID)
         #expect(mutator.isCompleted)
 
         mutator.setLetter("Z", atRow: 1, atCol: 1, pencil: false)
         #expect(game.squares[1][1].entry == "D")   // seal stands; input rejected
     }
 
     @Test("An incomplete game is not sealed — an untouched hole stays empty")
     func incompleteGameNotSealed() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ctx = persistence.viewContext
         let (entity, gameID) = try makeGame(completed: false, in: ctx)
         try writeMoves(
             for: entity, gameID: gameID,
             cells: [GridPosition(row: 0, col: 0): "A"],
             in: ctx
         )
 
         let (game, mutator) = try store.loadGame(id: gameID)
 
         #expect(game.squares[0][0].entry == "A")
         #expect(game.squares[1][1].entry == "")    // untouched hole stays empty
         #expect(mutator.isCompleted == false)
         #expect(game.completionState != .solved)
     }
 
     @Test("Opening an owned legacy game upgrades it to the current sync version")
     func ownerOpenUpgradesSyncVersion() throws {
         let persistence = makeTestPersistence()
         var enqueuedRecordNames: [String] = []
         let store = makeTestStore(
             persistence: persistence,
             onGameUpdated: { enqueuedRecordNames.append($0) }
         )
         let ctx = persistence.viewContext
         let (entity, gameID) = try makeGame(completed: false, in: ctx)
         entity.databaseScope = DatabaseScope.private.rawValue
         entity.syncVersion = GameSyncVersion.legacy
         try ctx.save()
 
         _ = try store.loadGame(id: gameID)
 
         #expect(entity.syncVersion == GameSyncVersion.current)
         #expect(entity.hasPendingSave)
         #expect(enqueuedRecordNames == ["game-\(gameID.uuidString)"])
     }
 
     @Test("Opening a participant legacy game waits for the owner's upgrade")
     func participantOpenDoesNotUpgradeSyncVersion() throws {
         let persistence = makeTestPersistence()
         var enqueuedRecordNames: [String] = []
         let store = makeTestStore(
             persistence: persistence,
             onGameUpdated: { enqueuedRecordNames.append($0) }
         )
         let ctx = persistence.viewContext
         let (entity, gameID) = try makeGame(completed: false, in: ctx)
         entity.databaseScope = DatabaseScope.shared.rawValue
         entity.syncVersion = GameSyncVersion.legacy
         try ctx.save()
 
         _ = try store.loadGame(id: gameID)
 
         #expect(entity.syncVersion == GameSyncVersion.legacy)
         #expect(!entity.hasPendingSave)
         #expect(enqueuedRecordNames.isEmpty)
     }
 
     @Test("Completion delivery waits for both Game and Moves, then journal")
     func completionDeliveryGates() {
         var progress = CompletionDeliveryProgress(resigned: false)
         #expect(!progress.canDeliverCompletion)
 
         progress.durableRecords.insert(.game)
         #expect(!progress.canDeliverCompletion)
         progress.durableRecords.insert(.journal)
         #expect(!progress.canDeliverCompletion)
 
         progress.durableRecords.insert(.moves)
         #expect(progress.canDeliverCompletion)
         #expect(!progress.canDeliverReplay)
 
         progress.completionDelivered = true
         #expect(progress.canDeliverReplay)
         progress.replayDelivered = true
         #expect(!progress.canDeliverReplay)
     }
 
     @Test("A pre-completion Moves acknowledgement cannot open the gate")
     func completionDeliveryOrdering() {
         var progress = CompletionDeliveryProgress(resigned: false)
         progress.acknowledge([.moves, .journal])
         #expect(progress.durableRecords.isEmpty)
         progress.acknowledge([.game])
         #expect(!progress.canDeliverCompletion)
         progress.acknowledge([.moves, .journal])
         #expect(progress.canDeliverCompletion)
         #expect(progress.durableRecords.contains(.journal))
     }
 
     @Test("Only the device that initiates completion stages a peer notification")
     func completionCallbackDistinguishesObservedSolve() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(
             persistence: persistence,
             authorIDProvider: { Self.authorID }
         )
         let (_, gameID) = try makeGame(completed: false, in: persistence.viewContext)
         var callback: (resigned: Bool, notifyPeers: Bool)?
         store.onJournalComplete = { _, _, resigned, notifyPeers in
             callback = (resigned, notifyPeers)
         }
 
         #expect(try store.markCompletedFromObservedSolvedState(id: gameID))
         #expect(callback?.resigned == false)
         #expect(callback?.notifyPeers == false)
     }
 }