crossmate

PeerChangeLedgerTests.swift (5465B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("PeerChangeLedger.upserts")
 struct PeerChangeLedgerTests {
 
     private func t(_ seconds: TimeInterval) -> Date {
         Date(timeIntervalSinceReferenceDate: seconds)
     }
 
     /// A merged-grid provenance entry: `author` is the preserved cell author
     /// (the letter's writer, `nil` for a clear), `writer` is the iCloud user
     /// whose move won LWW.
     private func prov(
         _ letter: String,
         author: String?,
         writer: String,
         at: Date
     ) -> GridStateMerger.Provenance {
         GridStateMerger.Provenance(
             cell: TimestampedCell(letter: letter, mark: .none, updatedAt: at, authorID: author),
             writerAuthorID: writer
         )
     }
 
     private func apply(_ upserts: [PeerChange], to ledger: inout [GridPosition: PeerChange]) {
         for change in upserts { ledger[change.position] = change }
     }
 
     private let p1 = GridPosition(row: 0, col: 0)
     private let p2 = GridPosition(row: 0, col: 1)
     private let p3 = GridPosition(row: 1, col: 0)
 
     @Test("A first build seeds every non-empty current cell at .distantPast")
     func seedingRecordsDistantPast() {
         let current = [
             p1: prov("A", author: "bob", writer: "bob", at: t(10)),
             p2: prov("B", author: "bob", writer: "bob", at: t(20)),
             p3: prov("", author: nil, writer: "bob", at: t(30)),
         ]
         let upserts = PeerChangeLedger.upserts(current: current, recorded: [:], seeding: true)
         #expect(upserts.count == 2)
         #expect(upserts.allSatisfy { $0.changedAt == .distantPast })
     }
 
     @Test("A first-seen empty cell records nothing")
     func firstSeenEmptyCellIgnored() {
         let current = [p1: prov("", author: nil, writer: "bob", at: t(40))]
         let upserts = PeerChangeLedger.upserts(current: current, recorded: [:], seeding: false)
         #expect(upserts.isEmpty)
     }
 
     @Test("After the seed, a genuine letter change records the move's real timestamp")
     func letterChangeRecordsRealTimestamp() {
         let recorded = [p1: PeerChange(position: p1, letter: "A", authorID: "bob", changedAt: .distantPast)]
         let current = [p1: prov("B", author: "carol", writer: "carol", at: t(40))]
         let upserts = PeerChangeLedger.upserts(current: current, recorded: recorded, seeding: false)
         #expect(upserts == [PeerChange(position: p1, letter: "B", authorID: "carol", changedAt: t(40))])
     }
 
     @Test("A check re-stamp (same letter, newer updatedAt) records nothing")
     func checkReStampIgnored() {
         // The reported bug: a check bumps updatedAt but leaves the letter alone.
         let recorded = [p1: PeerChange(position: p1, letter: "A", authorID: "bob", changedAt: t(10))]
         let current = [p1: prov("A", author: "bob", writer: "bob", at: t(99))]
         let upserts = PeerChangeLedger.upserts(current: current, recorded: recorded, seeding: false)
         #expect(upserts.isEmpty)
     }
 
     @Test("A clear records an empty letter, attributed to whoever cleared it")
     func clearAttributedToClearer() {
         let recorded = [p1: PeerChange(position: p1, letter: "A", authorID: "carol", changedAt: t(10))]
         // The clearing move carries no preserved cell author; the writer is Bob.
         let current = [p1: prov("", author: nil, writer: "bob", at: t(40))]
         let upserts = PeerChangeLedger.upserts(current: current, recorded: recorded, seeding: false)
         #expect(upserts == [PeerChange(position: p1, letter: "", authorID: "bob", changedAt: t(40))])
     }
 
     @Test("An unchanged cell records nothing")
     func unchangedCellIgnored() {
         let recorded = [p1: PeerChange(position: p1, letter: "A", authorID: "bob", changedAt: t(10))]
         let current = [p1: prov("A", author: "bob", writer: "bob", at: t(10))]
         #expect(PeerChangeLedger.upserts(current: current, recorded: recorded, seeding: false).isEmpty)
     }
 
     // MARK: - End-to-end: the reported rejoin bug
 
     @Test("A peer's check sweep after you leave never reads as 'filled while away'")
     func checkSweepNotFlaggedOnReturn() {
         // The game is in progress: bunny's two letters are already in the
         // ledger, recorded at their genuine fill times before you left.
         var ledger: [GridPosition: PeerChange] = [
             p1: PeerChange(position: p1, letter: "A", authorID: "bunny", changedAt: t(10)),
             p2: PeerChange(position: p2, letter: "B", authorID: "bunny", changedAt: t(20)),
         ]
         let viewedAt = t(30)
 
         // bunny runs a check: same letters, fresh updatedAt — and, in the same
         // sync, genuinely fills one new cell.
         let inbound = [
             p1: prov("A", author: "bunny", writer: "bunny", at: t(40)),
             p2: prov("B", author: "bunny", writer: "bunny", at: t(50)),
             p3: prov("C", author: "bunny", writer: "bunny", at: t(60)),
         ]
         apply(
             PeerChangeLedger.upserts(current: inbound, recorded: ledger, seeding: false),
             to: &ledger
         )
 
         let changes = RecentChanges.changes(
             in: Array(ledger.values),
             since: viewedAt,
             excludingAuthor: "alice"
         )
         // Only the genuine new fill counts — not the two re-stamped letters.
         #expect(changes.cells == [p3: "bunny"])
         #expect(changes.counts["bunny"] == RecentChanges.Count(added: 1, cleared: 0))
     }
 }