crossmate

ReplayCacheTests.swift (5656B)

---

 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 /// `GameStore`'s on-device replay cache: once a finished game's remote journals
 /// are fetched in full they are stored as `JournalEntity` rows carrying a source
 /// device key, so re-opening the game replays from Core Data without a CloudKit
 /// round-trip. These rows must round-trip faithfully *and* stay out of this
 /// device's own log (undo/redo and the journal upload read the same table).
 @Suite("Replay cache", .serialized)
 @MainActor
 struct ReplayCacheTests {
 
     private func makeGame(in persistence: PersistenceController) -> UUID {
         let context = persistence.viewContext
         let gameID = UUID()
         let entity = GameEntity(context: context)
         entity.id = gameID
         entity.title = "Cached Game"
         entity.puzzleSource = "Title: Cached\n\n\nAB\n\n\nA1. _ ~ AB"
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.ckRecordName = "game-\(gameID.uuidString)"
         try? context.save()
         return gameID
     }
 
     private func remoteJournal(
         author: String,
         device: String,
         letters: [(Int64, String)]
     ) -> DeviceJournal {
         let entries = letters.map { seq, letter in
             JournalValue(
                 seq: seq,
                 timestamp: Date(timeIntervalSince1970: TimeInterval(seq)),
                 position: GridPosition(row: 0, col: Int(seq)),
                 state: JournalCellState(letter: letter, mark: .none, cellAuthorID: author),
                 actingAuthorID: author,
                 kind: .input,
                 targetSeq: nil,
                 batchID: nil,
                 prevSeqAtCell: nil,
                 direction: nil
             )
         }
         return DeviceJournal(
             key: JournalDeviceKey(authorID: author, deviceID: device),
             entries: entries
         )
     }
 
     @Test("cache is nil until a complete fetch is stored")
     func cacheEmptyBeforeStore() async {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let gameID = makeGame(in: persistence)
 
         #expect(await store.cachedRemoteJournals(forGameID: gameID) == nil)
     }
 
     @Test("stored remote journals round-trip, grouped by source device")
     func storedJournalsRoundTrip() async {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let gameID = makeGame(in: persistence)
 
         let a = remoteJournal(author: "alice", device: "dev-a", letters: [(0, "A"), (1, "B")])
         let b = remoteJournal(author: "bob", device: "dev-b", letters: [(0, "C")])
         await store.cacheRemoteJournals([a, b], forGameID: gameID)
 
         let cached = await store.cachedRemoteJournals(forGameID: gameID)
         let byKey = Dictionary(
             uniqueKeysWithValues: (cached ?? []).map { ($0.key, $0.entries) }
         )
         #expect(cached?.count == 2)
         #expect(byKey[a.key]?.map(\.state.letter) == ["A", "B"])
         #expect(byKey[b.key]?.map(\.state.letter) == ["C"])
     }
 
     @Test("solo game with no remote contributors still caches as complete")
     func soloGameCachesAsComplete() async {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let gameID = makeGame(in: persistence)
 
         await store.cacheRemoteJournals([], forGameID: gameID)
 
         // Non-nil (complete), but empty — distinct from the un-cached nil.
         let cached = await store.cachedRemoteJournals(forGameID: gameID)
         #expect(cached != nil)
         #expect(cached?.isEmpty == true)
     }
 
     @Test("re-caching replaces prior remote rows")
     func reCacheReplaces() async {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let gameID = makeGame(in: persistence)
 
         await store.cacheRemoteJournals(
             [remoteJournal(author: "alice", device: "dev-a", letters: [(0, "A")])],
             forGameID: gameID
         )
         await store.cacheRemoteJournals(
             [remoteJournal(author: "bob", device: "dev-b", letters: [(0, "C")])],
             forGameID: gameID
         )
 
         let cached = await store.cachedRemoteJournals(forGameID: gameID)
         #expect(cached?.count == 1)
         #expect(cached?.first?.key.authorID == "bob")
     }
 
     @Test("cached remote rows stay out of this device's own journal")
     func remoteRowsExcludedFromLocalLog() async {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let gameID = makeGame(in: persistence)
 
         // Seed one *local* entry (no source key) through the real write path.
         let localJournal = MovesJournal(persistence: persistence)
         _ = localJournal.record(
             gameID: gameID,
             position: GridPosition(row: 0, col: 0),
             state: JournalCellState(letter: "L", mark: .none, cellAuthorID: "me"),
             actingAuthorID: "me",
             kind: .input,
             targetSeq: nil,
             batchID: nil
         )
         await localJournal.flush()
 
         // Cache a remote device's journal into the same table.
         await store.cacheRemoteJournals(
             [remoteJournal(author: "alice", device: "dev-a", letters: [(0, "A"), (1, "B")])],
             forGameID: gameID
         )
 
         // The local-log reader sees only the local row, never the cached remotes.
         let local = store.localJournalEntries(for: gameID)
         #expect(local.map(\.state.letter) == ["L"])
     }
 }