crossmate

JournalReplayTests.swift (11005B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 /// Cross-device replay reconstruction (`ReplayTimeline`) and the strict
 /// completeness gate (`ReplayAssembler`). Both are pure value types, so these
 /// tests build `JournalValue`s directly — no Core Data, no CloudKit.
 @Suite("Journal replay")
 struct JournalReplayTests {
 
     private func entry(
         seq: Int64,
         at seconds: TimeInterval,
         row: Int,
         col: Int,
         letter: String,
         mark: CellMark = .none,
         author: String = "author",
         kind: JournalKind = .input,
         batchID: UUID? = nil,
         direction: Puzzle.Direction? = nil
     ) -> JournalValue {
         JournalValue(
             seq: seq,
             timestamp: Date(timeIntervalSince1970: seconds),
             position: GridPosition(row: row, col: col),
             state: JournalCellState(letter: letter, mark: mark, cellAuthorID: author),
             actingAuthorID: author,
             kind: kind,
             targetSeq: nil,
             batchID: batchID,
             prevSeqAtCell: nil,
             direction: direction
         )
     }
 
     private func pos(_ row: Int, _ col: Int) -> GridPosition {
         GridPosition(row: row, col: col)
     }
 
     // MARK: - Merge ordering
 
     @Test("merge orders every device's entries by timestamp")
     func mergeOrdersByTimestamp() {
         let a = entry(seq: 0, at: 10, row: 0, col: 0, letter: "A")
         let b = entry(seq: 1, at: 30, row: 0, col: 1, letter: "B")
         let c = entry(seq: 0, at: 20, row: 1, col: 0, letter: "C", author: "other")
 
         let timeline = ReplayTimeline(merging: [[a, b], [c]])
 
         #expect(timeline.entries.map(\.state.letter) == ["A", "C", "B"])
     }
 
     @Test("same-timestamp ties break deterministically regardless of fetch order")
     func tiesAreDeterministic() {
         // Same instant, different acting authors: the tiebreak orders on
         // author then seq, so fetch order can't change the result.
         let x = entry(seq: 5, at: 10, row: 0, col: 0, letter: "X", author: "zzz")
         let y = entry(seq: 0, at: 10, row: 0, col: 1, letter: "Y", author: "aaa")
 
         let forward = ReplayTimeline(merging: [[x], [y]])
         let reversed = ReplayTimeline(merging: [[y], [x]])
 
         #expect(forward.entries.map(\.state.letter) == ["Y", "X"])
         #expect(forward == reversed)
     }
 
     // MARK: - State reconstruction
 
     @Test("state(through:) replays last-write-per-cell across devices")
     func stateReconstructsGrid() {
         let a = entry(seq: 0, at: 10, row: 0, col: 0, letter: "A", author: "d1")
         let c = entry(seq: 0, at: 20, row: 0, col: 1, letter: "C", author: "d2")
         let b = entry(seq: 1, at: 30, row: 0, col: 0, letter: "B", author: "d1") // overwrites A
 
         let timeline = ReplayTimeline(merging: [[a, b], [c]])
         #expect(timeline.count == 3)
 
         #expect(timeline.state(through: 0).isEmpty)
 
         let afterFirst = timeline.state(through: 1)
         #expect(afterFirst[pos(0, 0)]?.letter == "A")
         #expect(afterFirst[pos(0, 1)] == nil)
 
         let afterSecond = timeline.state(through: 2)
         #expect(afterSecond[pos(0, 0)]?.letter == "A")
         #expect(afterSecond[pos(0, 1)]?.letter == "C")
 
         let afterThird = timeline.state(through: 3)
         #expect(afterThird[pos(0, 0)]?.letter == "B")
         #expect(afterThird[pos(0, 1)]?.letter == "C")
 
         // count clamps to the available range.
         #expect(timeline.state(through: 99) == afterThird)
         #expect(timeline.state(through: -5).isEmpty)
     }
 
     @Test("undo rows replay as a normal timestamped restore")
     func undoReplaysAsRestore() {
         let typed = entry(seq: 0, at: 10, row: 0, col: 0, letter: "A", kind: .input)
         // An undo carries the restored after-state (empty here) and its own time.
         let undone = entry(seq: 1, at: 20, row: 0, col: 0, letter: "", kind: .undo)
 
         let timeline = ReplayTimeline(merging: [[typed, undone]])
 
         #expect(timeline.state(through: 1)[pos(0, 0)]?.letter == "A")
         #expect(timeline.state(through: 2)[pos(0, 0)]?.letter == "")
     }
 
     @Test("check/reveal marks surface during replay")
     func marksSurface() {
         let typed = entry(seq: 0, at: 10, row: 0, col: 0, letter: "A",
                           mark: .pen(checked: nil), kind: .input)
         let checked = entry(seq: 1, at: 20, row: 0, col: 0, letter: "A",
                             mark: .pen(checked: .wrong), kind: .check)
 
         let timeline = ReplayTimeline(merging: [[typed, checked]])
 
         #expect(timeline.state(through: 1)[pos(0, 0)]?.mark == .pen(checked: nil))
         #expect(timeline.state(through: 2)[pos(0, 0)]?.mark == .pen(checked: .wrong))
     }
 
     @Test("a batched gesture (e.g. reveal puzzle) is a single replay step")
     func batchedGestureIsOneStep() {
         let batch = UUID()
         let reveals = [
             entry(seq: 0, at: 10, row: 0, col: 0, letter: "A", kind: .reveal, batchID: batch),
             entry(seq: 1, at: 10, row: 0, col: 1, letter: "B", kind: .reveal, batchID: batch),
             entry(seq: 2, at: 10, row: 1, col: 0, letter: "C", kind: .reveal, batchID: batch),
         ]
         // A single letter typed earlier is its own step; the reveal is one more.
         let typed = entry(seq: 0, at: 5, row: 2, col: 2, letter: "Z")
         let timeline = ReplayTimeline(merging: [[typed], reveals])
 
         #expect(timeline.count == 2)                 // typed, then the whole reveal
         #expect(timeline.state(through: 1).count == 1)
         #expect(timeline.state(through: 2).count == 4) // reveal lands all three at once
         #expect(timeline.focus(ofStep: 0) == pos(2, 2)) // single cell has a playhead
         #expect(timeline.focus(ofStep: 1) == nil)       // batch has none
     }
 
     @Test("single-cell replay steps expose their recorded cursor direction")
     func singleCellStepExposesDirection() {
         let typed = entry(seq: 0, at: 10, row: 0, col: 0, letter: "A", direction: .down)
         let batch = UUID()
         let clear = [
             entry(seq: 1, at: 20, row: 0, col: 0, letter: "", kind: .clear, batchID: batch, direction: .down),
             entry(seq: 2, at: 20, row: 0, col: 1, letter: "", kind: .clear, batchID: batch, direction: .down),
         ]
 
         let timeline = ReplayTimeline(merging: [[typed] + clear])
 
         #expect(timeline.direction(ofStep: 0) == .down)
         #expect(timeline.direction(ofStep: 1) == nil)
     }
 
     // MARK: - Completeness gate
 
     private let d1 = JournalDeviceKey(authorID: "a1", deviceID: "dev1")
     private let d2 = JournalDeviceKey(authorID: "a1", deviceID: "dev2")
     private let d3 = JournalDeviceKey(authorID: "a2", deviceID: "dev3")
 
     @Test("ready once a journal is present for every expected device")
     func readyWhenComplete() {
         let peer = entry(seq: 0, at: 20, row: 0, col: 1, letter: "B", author: "a1")
         let mine = entry(seq: 0, at: 10, row: 0, col: 0, letter: "A", author: "a1")
 
         // d2's journal arrives over the network; d1 (local) supplies its own.
         let fetch = JournalReplayFetch(
             journals: [DeviceJournal(key: d2, entries: [peer])],
             expectedDevices: [d1, d2]
         )
         let result = ReplayAssembler.assemble(fetch: fetch, localKey: d1, localEntries: [mine])
 
         guard case .ready(let timeline) = result else {
             Issue.record("expected .ready, got \(result)")
             return
         }
         #expect(timeline.count == 2)
         #expect(timeline.entries.map(\.state.letter) == ["A", "B"])
     }
 
     @Test("waiting reports how many expected devices haven't uploaded")
     func waitingWhenIncomplete() {
         let peer = entry(seq: 0, at: 20, row: 0, col: 1, letter: "B", author: "a1")
         let mine = entry(seq: 0, at: 10, row: 0, col: 0, letter: "A", author: "a1")
 
         // d3 contributed (in expected) but its journal is absent.
         let fetch = JournalReplayFetch(
             journals: [DeviceJournal(key: d2, entries: [peer])],
             expectedDevices: [d1, d2, d3]
         )
         let result = ReplayAssembler.assemble(fetch: fetch, localKey: d1, localEntries: [mine])
 
         #expect(result == .waiting(missing: 1))
     }
 
     @Test("local live log overrides a stale uploaded copy of itself")
     func localOverlayWins() {
         let stale = entry(seq: 0, at: 10, row: 0, col: 0, letter: "A", author: "a1")
         let fresh1 = entry(seq: 0, at: 10, row: 0, col: 0, letter: "A", author: "a1")
         let fresh2 = entry(seq: 1, at: 15, row: 0, col: 1, letter: "B", author: "a1")
 
         // The fetch already contains d1's own (stale, 1-entry) upload.
         let fetch = JournalReplayFetch(
             journals: [DeviceJournal(key: d1, entries: [stale])],
             expectedDevices: [d1]
         )
         let result = ReplayAssembler.assemble(
             fetch: fetch,
             localKey: d1,
             localEntries: [fresh1, fresh2]
         )
 
         guard case .ready(let timeline) = result else {
             Issue.record("expected .ready, got \(result)")
             return
         }
         #expect(timeline.count == 2) // live two-entry log, not the stale one
     }
 
     // MARK: - Per-game memo
 
     @Test("a cached timeline short-circuits without re-assembling")
     func memoServesCache() async {
         let cached = ReplayTimeline(merging: [[entry(seq: 0, at: 10, row: 0, col: 0, letter: "A")]])
         var assembleCalls = 0
         var hits = 0
 
         let result = await ReplayAssembler.memoised(
             cached: cached,
             onHit: { _ in hits += 1 },
             store: { _ in Issue.record("must not cache on a hit") }
         ) {
             assembleCalls += 1
             return .unavailable
         }
 
         #expect(result == .ready(cached))
         #expect(assembleCalls == 0) // never re-ran the merge
         #expect(hits == 1)
     }
 
     @Test("a ready assembly is cached; waiting/unavailable are not")
     func memoCachesOnlyReady() async {
         // Ready → stored.
         var storedReady: ReplayTimeline?
         let ready = ReplayTimeline(merging: [[entry(seq: 0, at: 10, row: 0, col: 0, letter: "A")]])
         _ = await ReplayAssembler.memoised(cached: nil, store: { storedReady = $0 }) { .ready(ready) }
         #expect(storedReady == ready)
 
         // Waiting → never stored, stays retryable.
         var storedWaiting = false
         let waiting = await ReplayAssembler.memoised(
             cached: nil,
             store: { _ in storedWaiting = true }
         ) { .waiting(missing: 2) }
         #expect(waiting == .waiting(missing: 2))
         #expect(!storedWaiting)
 
         // Unavailable → never stored.
         var storedUnavailable = false
         let unavailable = await ReplayAssembler.memoised(
             cached: nil,
             store: { _ in storedUnavailable = true }
         ) { .unavailable }
         #expect(unavailable == .unavailable)
         #expect(!storedUnavailable)
     }
 }