crossmate

GridStateMergerTests.swift (12154B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("GridStateMerger.merge")
 struct GridStateMergerTests {
 
     private let gameID = UUID(uuidString: "11111111-2222-3333-4444-555555555555")!
 
     private func view(
         author: String,
         device: String,
         cells: [(row: Int, col: Int, letter: String, updatedAt: Date)],
         cellAuthor: String? = nil
     ) -> MovesValue {
         let resolvedCellAuthor = cellAuthor ?? author
         var dict: [GridPosition: TimestampedCell] = [:]
         for entry in cells {
             dict[GridPosition(row: entry.row, col: entry.col)] = TimestampedCell(
                 letter: entry.letter,
                 mark: .none,
                 updatedAt: entry.updatedAt,
                 authorID: resolvedCellAuthor
             )
         }
         return MovesValue(
             gameID: gameID,
             authorID: author,
             deviceID: device,
             cells: dict,
             updatedAt: cells.map(\.updatedAt).max() ?? .distantPast
         )
     }
 
     @Test("Empty input produces an empty grid")
     func emptyInputs() {
         #expect(GridStateMerger.merge([]).isEmpty)
     }
 
     @Test("Single MovesValue is reproduced cell-for-cell")
     func singleViewPassesThrough() {
         let v = view(
             author: "alice",
             device: "d1",
             cells: [
                 (0, 0, "A", Date(timeIntervalSince1970: 1)),
                 (1, 2, "B", Date(timeIntervalSince1970: 2)),
             ]
         )
         let grid = GridStateMerger.merge([v])
         #expect(grid[GridPosition(row: 0, col: 0)]?.letter == "A")
         #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "alice")
         #expect(grid[GridPosition(row: 1, col: 2)]?.letter == "B")
     }
 
     @Test("Later updatedAt wins for the same cell across devices")
     func laterTimestampWins() {
         let earlier = view(
             author: "alice",
             device: "d1",
             cells: [(0, 0, "A", Date(timeIntervalSince1970: 1))]
         )
         let later = view(
             author: "bob",
             device: "d2",
             cells: [(0, 0, "B", Date(timeIntervalSince1970: 2))]
         )
         let grid = GridStateMerger.merge([earlier, later])
         #expect(grid[GridPosition(row: 0, col: 0)]?.letter == "B")
         #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "bob")
     }
 
     @Test("A higher logical tick wins despite an older wall clock")
     func logicalTickWinsAcrossClockSkew() {
         let position = GridPosition(row: 0, col: 0)
         let legacyDate = Date(timeIntervalSince1970: 2_000)
         let legacy = MovesValue(
             gameID: gameID,
             authorID: "alice",
             deviceID: "legacy",
             cells: [position: TimestampedCell(
                 letter: "N",
                 mark: .none,
                 updatedAt: legacyDate,
                 authorID: "alice"
             )],
             updatedAt: legacyDate
         )
         let modern = MovesValue(
             gameID: gameID,
             authorID: "bob",
             deviceID: "modern",
             cells: [position: TimestampedCell(
                 letter: "M",
                 mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 1),
                 authorID: "bob",
                 tick: 2_000_001
             )],
             updatedAt: Date(timeIntervalSince1970: 1)
         )
 
         #expect(GridStateMerger.merge([legacy, modern])[position]?.letter == "M")
     }
 
     @Test("Logical ticks, not wall time, order modern cells")
     func logicalTicksIgnoreModernWallClock() {
         let position = GridPosition(row: 0, col: 0)
         let lowerTick = MovesValue(
             gameID: gameID,
             authorID: "alice",
             deviceID: "fast-clock",
             cells: [position: TimestampedCell(
                 letter: "N",
                 mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 9_999),
                 authorID: "alice",
                 tick: 40
             )],
             updatedAt: Date(timeIntervalSince1970: 9_999)
         )
         let higherTick = MovesValue(
             gameID: gameID,
             authorID: "bob",
             deviceID: "slow-clock",
             cells: [position: TimestampedCell(
                 letter: "M",
                 mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 1),
                 authorID: "bob",
                 tick: 41
             )],
             updatedAt: Date(timeIntervalSince1970: 1)
         )
 
         #expect(GridStateMerger.merge([lowerTick, higherTick])[position]?.letter == "M")
     }
 
     @Test("Input order does not affect the merged result")
     func inputOrderIndependent() {
         let earlier = view(
             author: "alice",
             device: "d1",
             cells: [(0, 0, "A", Date(timeIntervalSince1970: 1))]
         )
         let later = view(
             author: "bob",
             device: "d2",
             cells: [(0, 0, "B", Date(timeIntervalSince1970: 2))]
         )
         let forward = GridStateMerger.merge([earlier, later])
         let reversed = GridStateMerger.merge([later, earlier])
         #expect(forward == reversed)
     }
 
     @Test("Equal updatedAt: lexicographically smaller authorID wins")
     func authorTieBreak() {
         let same = Date(timeIntervalSince1970: 5)
         let bob = view(
             author: "bob",
             device: "d1",
             cells: [(0, 0, "B", same)]
         )
         let alice = view(
             author: "alice",
             device: "d2",
             cells: [(0, 0, "A", same)]
         )
         let grid = GridStateMerger.merge([bob, alice])
         #expect(grid[GridPosition(row: 0, col: 0)]?.letter == "A")
         #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "alice")
     }
 
     @Test("Equal updatedAt and author: smaller deviceID wins")
     func deviceTieBreak() {
         let same = Date(timeIntervalSince1970: 5)
         let onPhone = view(
             author: "alice",
             device: "phone",
             cells: [(0, 0, "P", same)]
         )
         let onIpad = view(
             author: "alice",
             device: "ipad",
             cells: [(0, 0, "I", same)]
         )
         let grid = GridStateMerger.merge([onPhone, onIpad])
         #expect(grid[GridPosition(row: 0, col: 0)]?.letter == "I")
     }
 
     @Test("Cells touched by only one device are all present in the merged grid")
     func disjointCellsCoexist() {
         let alice = view(
             author: "alice",
             device: "d1",
             cells: [(0, 0, "A", Date(timeIntervalSince1970: 1))]
         )
         let bob = view(
             author: "bob",
             device: "d2",
             cells: [(1, 1, "B", Date(timeIntervalSince1970: 1))]
         )
         let grid = GridStateMerger.merge([alice, bob])
         #expect(grid.count == 2)
         #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "alice")
         #expect(grid[GridPosition(row: 1, col: 1)]?.authorID == "bob")
     }
 
     @Test("Cell-level authorID is preserved when the winning entry's parent writer differs")
     func cellLevelAuthorWins() {
         // Bob's device (writer) writes a cell whose preserved authorID is alice
         // — mirrors the "reveal-of-correct" / "same-letter rewrite" behaviors
         // where bob's mutation hands authorship back to alice.
         let preserved = view(
             author: "bob",
             device: "d1",
             cells: [(0, 0, "A", Date(timeIntervalSince1970: 2))],
             cellAuthor: "alice"
         )
         let grid = GridStateMerger.merge([preserved])
         #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "alice")
     }
 
     @Test("Cleared letter (empty string) still wins if its updatedAt is latest")
     func clearingMoveWins() {
         let written = view(
             author: "alice",
             device: "d1",
             cells: [(0, 0, "A", Date(timeIntervalSince1970: 1))]
         )
         let cleared = view(
             author: "alice",
             device: "d2",
             cells: [(0, 0, "", Date(timeIntervalSince1970: 2))]
         )
         let grid = GridStateMerger.merge([written, cleared])
         let cell = grid[GridPosition(row: 0, col: 0)]
         #expect(cell?.letter == "")
         #expect(cell != nil)
     }
 
     @Test("notAfter keeps the latest write at or before the cutoff")
     func cutoffKeepsPreLatchWinner() {
         let cutoff = Date(timeIntervalSince1970: 100)
         let preLatch = view(
             author: "alice",
             device: "d1",
             cells: [(0, 0, "A", Date(timeIntervalSince1970: 100))]
         )
         let postLatch = view(
             author: "bob",
             device: "d2",
             cells: [(0, 0, "B", Date(timeIntervalSince1970: 101))]
         )
         let grid = GridStateMerger.merge([preLatch, postLatch], notAfter: cutoff)
         // Bob's later write would win an unbounded LWW, but it is stamped
         // after the cutoff, so Alice's at-cutoff write survives.
         #expect(grid[GridPosition(row: 0, col: 0)]?.letter == "A")
         #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "alice")
     }
 
     @Test("notAfter drops a cell whose only write is after the cutoff")
     func cutoffDropsPostLatchOnlyCell() {
         let cutoff = Date(timeIntervalSince1970: 100)
         let postLatch = view(
             author: "bob",
             device: "d2",
             cells: [(3, 4, "Z", Date(timeIntervalSince1970: 200))]
         )
         let grid = GridStateMerger.merge([postLatch], notAfter: cutoff)
         #expect(grid[GridPosition(row: 3, col: 4)] == nil)
     }
 
     @Test("A nil cutoff merges every write")
     func nilCutoffIsUnbounded() {
         let v = view(
             author: "alice",
             device: "d1",
             cells: [(0, 0, "A", Date(timeIntervalSince1970: 9_999))]
         )
         #expect(GridStateMerger.merge([v], notAfter: nil) == GridStateMerger.merge([v]))
     }
 }
 
 @Suite("MovesCodec round-trip")
 struct MovesCodecTests {
 
     @Test("Round-trip preserves all cell fields including per-cell authorID")
     func roundTrip() throws {
         let cells: [GridPosition: TimestampedCell] = [
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "A",
                 mark: .pencil(checked: .wrong),
                 updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
                 authorID: "alice",
                 tick: 42
             ),
             GridPosition(row: 4, col: 7): TimestampedCell(
                 letter: "",
                 mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 1_700_000_500),
                 authorID: nil
             ),
         ]
         let data = try MovesCodec.encode(cells)
         let decoded = try MovesCodec.decode(data)
         #expect(decoded == cells)
     }
 
     @Test("Encoded entries are sorted in row-major, col-minor order")
     func encodingIsDeterministic() throws {
         let cells: [GridPosition: TimestampedCell] = [
             GridPosition(row: 2, col: 1): TimestampedCell(
                 letter: "X", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 1),
                 authorID: "alice"
             ),
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "A", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 2),
                 authorID: "bob"
             ),
         ]
         let payload = try JSONDecoder().decode(
             MovesCodec.Payload.self,
             from: MovesCodec.encode(cells)
         )
         #expect(payload.entries.map { GridPosition(row: $0.row, col: $0.col) } == [
             GridPosition(row: 0, col: 0),
             GridPosition(row: 2, col: 1),
         ])
         #expect(payload.entries.map(\.authorID) == ["bob", "alice"])
     }
 
     @Test("Legacy payloads decode without a logical tick")
     func legacyPayloadHasNoTick() throws {
         let data = Data(#"{"entries":[{"row":0,"col":0,"letter":"N","markCode":0,"updatedAt":0}]}"#.utf8)
         let decoded = try MovesCodec.decode(data)
         #expect(decoded[GridPosition(row: 0, col: 0)]?.tick == nil)
     }
 }