crossmate

MoveBufferTests.swift (13612B)

---

 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("MoveBuffer", .serialized)
 @MainActor
 struct MoveBufferTests {
 
     /// Thread-safe collector for moves emitted by the buffer under test.
     actor Capture {
         private(set) var flushes: [[Move]] = []
         var allMoves: [Move] { flushes.flatMap { $0 } }
         var flushCount: Int { flushes.count }
         func append(_ moves: [Move]) { flushes.append(moves) }
     }
 
     /// Builds a `PersistenceController` backed by an in-memory store and
     /// seeds a single `GameEntity`, returning its id so tests can target it.
     private func makePersistenceWithGame(
         lamportHighWater: Int64 = 0
     ) throws -> (PersistenceController, UUID) {
         let persistence = makeTestPersistence()
         let context = persistence.viewContext
         let gameID = UUID()
         let entity = GameEntity(context: context)
         entity.id = gameID
         entity.title = "Test"
         entity.puzzleSource = ""
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.ckRecordName = "game-\(gameID.uuidString)"
         entity.lamportHighWater = lamportHighWater
         try context.save()
         return (persistence, gameID)
     }
 
     @Test("Same-cell enqueues coalesce to one move carrying the latest value")
     func coalescesSameCell() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let buffer = MoveBuffer(
             debounceInterval: .seconds(10),
             persistence: persistence,
             sink: { await capture.append($0) }
         )
 
         await buffer.enqueue(gameID: gameID, row: 0, col: 0, letter: "A", markKind: 0, checkedWrong: false, authorID: nil)
         await buffer.enqueue(gameID: gameID, row: 0, col: 0, letter: "B", markKind: 0, checkedWrong: false, authorID: nil)
         await buffer.enqueue(gameID: gameID, row: 0, col: 0, letter: "C", markKind: 0, checkedWrong: false, authorID: nil)
         await buffer.flush()
 
         let moves = await capture.allMoves
         #expect(moves.count == 1)
         #expect(moves.first?.letter == "C")
         #expect(moves.first?.lamport == 1)
     }
 
     @Test("Enqueuing a different cell persists and enqueues the previous cell")
     func cellChangeFlushesPrevious() async throws {
         // A long debounce makes this test insensitive to timer jitter:
         // only the cell-change trigger (and the final explicit flush) can
         // fire.
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let buffer = MoveBuffer(
             debounceInterval: .seconds(10),
             persistence: persistence,
             sink: { await capture.append($0) }
         )
 
         await buffer.enqueue(gameID: gameID, row: 0, col: 0, letter: "A", markKind: 0, checkedWrong: false, authorID: nil)
         await buffer.enqueue(gameID: gameID, row: 0, col: 1, letter: "B", markKind: 0, checkedWrong: false, authorID: nil)
 
         // The cell-change flush allocates Lamport 1, writes the prior cell
         // durably, and immediately hands it to the sink.
         #expect(await capture.flushCount == 1)
         let persistedBeforeFinalFlush = fetchMoveValues(gameID: gameID, persistence: persistence)
         #expect(persistedBeforeFinalFlush.count == 1)
         #expect(persistedBeforeFinalFlush.first?.letter == "A")
         #expect(persistedBeforeFinalFlush.first?.lamport == 1)
 
         await buffer.flush()
 
         let flushes = await capture.flushes
         #expect(flushes.count == 2)
         #expect(flushes.map { $0.map(\.letter) } == [["A"], ["B"]])
         #expect(flushes.map { $0.map(\.lamport) } == [[1], [2]])
     }
 
     @Test("Lamports are allocated from GameEntity.lamportHighWater and bump it")
     func lamportsUseGameHighWater() async throws {
         let (persistence, gameID) = try makePersistenceWithGame(lamportHighWater: 10)
         let capture = Capture()
         let buffer = MoveBuffer(
             debounceInterval: .seconds(10),
             persistence: persistence,
             sink: { await capture.append($0) }
         )
 
         await buffer.enqueue(gameID: gameID, row: 0, col: 0, letter: "X", markKind: 0, checkedWrong: false, authorID: nil)
         await buffer.flush()
 
         let moves = await capture.allMoves
         #expect(moves.first?.lamport == 11)
 
         // Verify the bump landed in Core Data by reading the game back from
         // a fresh context — the writer used a background context, so we
         // need to read from the same underlying store.
         let highWater = fetchHighWater(gameID: gameID, persistence: persistence)
         #expect(highWater == 11)
     }
 
     @Test("Flushed moves bump the parent game's updatedAt timestamp")
     func flushedMovesUpdateGameTimestamp() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let before = try #require(fetchUpdatedAt(gameID: gameID, persistence: persistence))
         let buffer = MoveBuffer(
             debounceInterval: .seconds(10),
             persistence: persistence,
             sink: { _ in }
         )
 
         try await Task.sleep(for: .milliseconds(10))
         await buffer.enqueue(gameID: gameID, row: 0, col: 0, letter: "X", markKind: 0, checkedWrong: false, authorID: nil)
         await buffer.flush()
 
         let after = try #require(fetchUpdatedAt(gameID: gameID, persistence: persistence))
         #expect(after > before)
     }
 
     @Test("Debounce coalesces rapid same-cell enqueues into one flush")
     func debounceCoalescesRapidEnqueues() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let buffer = MoveBuffer(
             debounceInterval: .milliseconds(80),
             persistence: persistence,
             sink: { await capture.append($0) }
         )
 
         for letter in ["A", "B", "C", "D", "E"] {
             await buffer.enqueue(gameID: gameID, row: 0, col: 0, letter: letter, markKind: 0, checkedWrong: false, authorID: nil)
             try await Task.sleep(for: .milliseconds(20))
         }
         try await Task.sleep(for: .milliseconds(250))
 
         let count = await capture.flushCount
         #expect(count == 1)
         let moves = await capture.allMoves
         #expect(moves.first?.letter == "E")
     }
 
     @Test("Explicit flush fires immediately and cancels any pending debounce")
     func flushCancelsDebounce() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let buffer = MoveBuffer(
             debounceInterval: .seconds(5),
             persistence: persistence,
             sink: { await capture.append($0) }
         )
 
         await buffer.enqueue(gameID: gameID, row: 0, col: 0, letter: "A", markKind: 0, checkedWrong: false, authorID: nil)
         await buffer.flush()
         let afterFlush = await capture.flushCount
         #expect(afterFlush == 1)
 
         // The debounce should have been cancelled by flush, so waiting past
         // the original interval must not add a second call.
         try await Task.sleep(for: .milliseconds(200))
         let later = await capture.flushCount
         #expect(later == 1)
     }
 
     @Test("Flush on an empty buffer does not invoke the sink")
     func emptyFlushDoesNothing() async throws {
         let (persistence, _) = try makePersistenceWithGame()
         let capture = Capture()
         let buffer = MoveBuffer(
             debounceInterval: .milliseconds(50),
             persistence: persistence,
             sink: { await capture.append($0) }
         )
 
         await buffer.flush()
 
         let count = await capture.flushCount
         #expect(count == 0)
     }
 
     @Test("MoveEntity rows are written with the enqueued fields")
     func persistsMoveEntity() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let buffer = MoveBuffer(
             debounceInterval: .seconds(10),
             persistence: persistence,
             sink: { _ in }
         )
 
         await buffer.enqueue(
             gameID: gameID, row: 2, col: 3,
             letter: "Q", markKind: 1, checkedWrong: true, authorID: "alice"
         )
         await buffer.flush()
 
         let moves = fetchMoveValues(gameID: gameID, persistence: persistence)
         #expect(moves.count == 1)
         let m = moves.first
         #expect(m?.letter == "Q")
         #expect(m?.row == 2)
         #expect(m?.col == 3)
         #expect(m?.markKind == 1)
         #expect(m?.checkedWrong == true)
         #expect(m?.authorID == "alice")
         #expect(m?.lamport == 1)
         #expect(m?.ckRecordName == "move-\(gameID.uuidString)-1-\(RecordSerializer.localDeviceID)")
     }
 
     @Test("Flush updates cell cache with the latest local cell values")
     func flushUpdatesCellCache() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let buffer = MoveBuffer(
             debounceInterval: .seconds(10),
             persistence: persistence,
             sink: { _ in }
         )
 
         await buffer.enqueue(
             gameID: gameID,
             row: 2,
             col: 3,
             letter: "Q",
             markKind: 1,
             checkedWrong: true,
             authorID: "alice"
         )
         await buffer.enqueue(
             gameID: gameID,
             row: 2,
             col: 3,
             letter: "R",
             markKind: 2,
             checkedWrong: false,
             authorID: "bob"
         )
         await buffer.flush()
 
         let cells = fetchCellValues(gameID: gameID, persistence: persistence)
         #expect(cells.count == 1)
         let cell = cells.first
         #expect(cell?.row == 2)
         #expect(cell?.col == 3)
         #expect(cell?.letter == "R")
         #expect(cell?.markKind == 2)
         #expect(cell?.checkedWrong == false)
         #expect(cell?.authorID == "bob")
     }
 
     // MARK: - Helpers
 
     /// Reads the game's lamport high-water from a fresh background context.
     private func fetchHighWater(gameID: UUID, persistence: PersistenceController) -> Int64 {
         let context = persistence.container.newBackgroundContext()
         return context.performAndWait {
             let request = NSFetchRequest<GameEntity>(entityName: "GameEntity")
             request.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
             request.fetchLimit = 1
             return (try? context.fetch(request).first?.lamportHighWater) ?? 0
         }
     }
 
     private func fetchUpdatedAt(gameID: UUID, persistence: PersistenceController) -> Date? {
         let context = persistence.container.newBackgroundContext()
         return context.performAndWait {
             let request = NSFetchRequest<GameEntity>(entityName: "GameEntity")
             request.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
             request.fetchLimit = 1
             return try? context.fetch(request).first?.updatedAt
         }
     }
 
     /// Extracts `MoveEntity` field values inside the background context so
     /// no `NSManagedObject` escapes its owning context.
     struct MoveValues {
         let letter: String
         let row: Int16
         let col: Int16
         let markKind: Int16
         let checkedWrong: Bool
         let authorID: String?
         let lamport: Int64
         let ckRecordName: String?
     }
 
     struct CellValues {
         let letter: String
         let row: Int16
         let col: Int16
         let markKind: Int16
         let checkedWrong: Bool
         let authorID: String?
     }
 
     private func fetchMoveValues(gameID: UUID, persistence: PersistenceController) -> [MoveValues] {
         let context = persistence.container.newBackgroundContext()
         return context.performAndWait {
             let request = NSFetchRequest<MoveEntity>(entityName: "MoveEntity")
             request.predicate = NSPredicate(format: "game.id == %@", gameID as CVarArg)
             request.sortDescriptors = [NSSortDescriptor(key: "lamport", ascending: true)]
             guard let entities = try? context.fetch(request) else { return [] }
             return entities.map {
                 MoveValues(
                     letter: $0.letter ?? "",
                     row: $0.row,
                     col: $0.col,
                     markKind: $0.markKind,
                     checkedWrong: $0.checkedWrong,
                     authorID: $0.authorID,
                     lamport: $0.lamport,
                     ckRecordName: $0.ckRecordName
                 )
             }
         }
     }
 
     private func fetchCellValues(gameID: UUID, persistence: PersistenceController) -> [CellValues] {
         let context = persistence.container.newBackgroundContext()
         return context.performAndWait {
             let request = NSFetchRequest<CellEntity>(entityName: "CellEntity")
             request.predicate = NSPredicate(format: "game.id == %@", gameID as CVarArg)
             request.sortDescriptors = [
                 NSSortDescriptor(key: "row", ascending: true),
                 NSSortDescriptor(key: "col", ascending: true)
             ]
             guard let entities = try? context.fetch(request) else { return [] }
             return entities.map {
                 CellValues(
                     letter: $0.letter ?? "",
                     row: $0.row,
                     col: $0.col,
                     markKind: $0.markKind,
                     checkedWrong: $0.checkedWrong,
                     authorID: $0.letterAuthorID
                 )
             }
         }
     }
 }