crossmate

SessionMonitorTests.swift (15730B)

---

 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("SessionMonitor", .isolatedNotificationState)
 @MainActor
 struct SessionMonitorTests {
 
     private static let localAuthorID = "local-author"
     private static let alice = "alice"
     private static let bob = "bob"
 
     private static let puzzleSource = """
     Title: Test Puzzle
     Author: Test
 
 
     ABC
     D#E
     FGH
 
 
     A1. Across 1 ~ ABC
     A4. Across 4 ~ DE
     A5. Across 5 ~ FGH
     D1. Down 1 ~ ADF
     D2. Down 2 ~ BG
     D3. Down 3 ~ CEH
     """
 
     private struct Fixture {
         let persistence: PersistenceController
         let store: GameStore
         let monitor: SessionMonitor
         let gameID: UUID
         let game: GameEntity
     }
 
     private func makeFixture(
         localAuthorID: String? = SessionMonitorTests.localAuthorID
     ) throws -> Fixture {
         let persistence = makeTestPersistence()
         let store = makeTestStore(
             persistence: persistence,
             authorIDProvider: { localAuthorID }
         )
         let monitor = SessionMonitor(
             store: store,
             localAuthorIDProvider: { localAuthorID }
         )
         let ctx = persistence.viewContext
         let gameID = UUID()
         let entity = GameEntity(context: ctx)
         entity.id = gameID
         entity.title = "Test Puzzle"
         entity.puzzleSource = Self.puzzleSource
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.ckRecordName = "game-\(gameID.uuidString)"
         let xd = try XD.parse(Self.puzzleSource)
         entity.populateCachedSummaryFields(from: Puzzle(xd: xd))
         try ctx.save()
         return Fixture(
             persistence: persistence,
             store: store,
             monitor: monitor,
             gameID: gameID,
             game: entity
         )
     }
 
     /// Seeds the per-cell letter-change ledger directly — the data `summaries`
     /// reduces. Each cell is the recorded letter (empty = a clear) and when it
     /// last changed. Most reduction tests use this rather than driving the
     /// moves→ledger writer, whose translation is covered separately.
     private func writeLedger(
         in fixture: Fixture,
         authorID: String?,
         cells: [GridPosition: (letter: String, changedAt: Date)]
     ) throws {
         let ctx = fixture.persistence.viewContext
         for (pos, value) in cells {
             let row = PeerChangeEntity(context: ctx)
             row.gameID = fixture.gameID
             row.row = Int16(pos.row)
             row.col = Int16(pos.col)
             row.letter = value.letter
             row.authorID = authorID
             row.changedAt = value.changedAt
             row.game = fixture.game
         }
         try ctx.save()
     }
 
     /// Upserts a device's full `MovesEntity` snapshot (one row per
     /// author/device, as in production). Used by the integration tests that
     /// drive the real moves→ledger writer.
     private func writeMoves(
         in fixture: Fixture,
         authorID: String,
         deviceID: String = "device-1",
         cells: [GridPosition: (letter: String, updatedAt: Date)]
     ) throws {
         let ctx = fixture.persistence.viewContext
         let stamped = cells.mapValues { value in
             TimestampedCell(
                 letter: value.letter,
                 mark: .none,
                 updatedAt: value.updatedAt,
                 authorID: value.letter.isEmpty ? nil : authorID
             )
         }
         let data = try MovesCodec.encode(stamped)
         let recordName = RecordSerializer.recordName(
             forMovesInGame: fixture.gameID,
             authorID: authorID,
             deviceID: deviceID
         )
         let req = NSFetchRequest<MovesEntity>(entityName: "MovesEntity")
         req.predicate = NSPredicate(
             format: "game == %@ AND authorID == %@ AND deviceID == %@",
             fixture.game, authorID, deviceID
         )
         req.fetchLimit = 1
         let row = (try? ctx.fetch(req).first) ?? MovesEntity(context: ctx)
         row.game = fixture.game
         row.authorID = authorID
         row.deviceID = deviceID
         row.cells = data
         row.updatedAt = Date()
         row.ckRecordName = recordName
         try ctx.save()
     }
 
     private func buildLedger(in fixture: Fixture) async {
         await fixture.store.updatePeerChangeLedger(for: [fixture.gameID])
     }
 
     private func addPlayer(
         in fixture: Fixture,
         authorID: String,
         name: String
     ) throws {
         let ctx = fixture.persistence.viewContext
         let player = PlayerEntity(context: ctx)
         player.game = fixture.game
         player.authorID = authorID
         player.name = name
         player.updatedAt = Date()
         player.ckRecordName = "player-\(fixture.gameID.uuidString)-\(authorID)"
         try ctx.save()
     }
 
     private func position(_ row: Int, _ col: Int) -> GridPosition {
         GridPosition(row: row, col: col)
     }
 
     /// The view baseline cutoff, with edits placed before/after it.
     private static let cutoff = Date(timeIntervalSince1970: 1_000)
     private var before: Date { Self.cutoff.addingTimeInterval(-60) }
     private var after: Date { Self.cutoff.addingTimeInterval(60) }
 
     // MARK: - Counts since the view baseline (ledger reduction)
 
     @Test("A peer's fills since the cutoff surface as a named summary")
     func peerFillsSummarised() throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         try writeLedger(
             in: fixture,
             authorID: Self.alice,
             cells: [
                 position(0, 0): ("A", after),
                 position(0, 1): ("B", after),
                 position(2, 2): ("H", after),
             ]
         )
 
         let summaries = fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff)
 
         #expect(summaries.count == 1)
         let summary = try #require(summaries.first)
         #expect(summary.authorID == Self.alice)
         #expect(summary.playerName == "Alice")
         #expect(summary.added == 3)
         #expect(summary.cleared == 0)
     }
 
     @Test("A friend nickname overrides the peer's published name in summaries")
     func nicknameOverridesPlayerName() throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         let ctx = fixture.persistence.viewContext
         let friend = FriendEntity(context: ctx)
         friend.authorID = Self.alice
         friend.pairKey = "pair-alice"
         friend.createdAt = Date()
         friend.nickname = "Mum"
         try ctx.save()
         try writeLedger(
             in: fixture,
             authorID: Self.alice,
             cells: [position(0, 0): ("A", after)]
         )
 
         let summary = try #require(
             fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff).first
         )
         #expect(summary.playerName == "Mum")
     }
 
     @Test("A clear (letter→empty) since the cutoff counts toward the cleared total")
     func clearsCounted() throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         // One cell still holds its (pre-cutoff) letter; another was emptied
         // after the cutoff.
         try writeLedger(
             in: fixture,
             authorID: Self.alice,
             cells: [
                 position(0, 0): ("A", before),
                 position(0, 1): ("", after),
             ]
         )
         let summary = try #require(
             fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff).first
         )
         #expect(summary.added == 0)
         #expect(summary.cleared == 1)
     }
 
     @Test("Nothing newer than the cutoff yields no summary")
     func noActivityReturnsNothing() throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         try writeLedger(
             in: fixture,
             authorID: Self.alice,
             cells: [position(0, 0): ("A", before)]
         )
 
         #expect(fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff).isEmpty)
     }
 
     @Test("summaries is read-only: repeated reads against the same cutoff are stable")
     func readsAreStable() throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         try writeLedger(
             in: fixture,
             authorID: Self.alice,
             cells: [
                 position(0, 0): ("A", after),
                 position(0, 1): ("B", after),
             ]
         )
         #expect(fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff).first?.added == 2)
         #expect(fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff).first?.added == 2)
     }
 
     @Test("The local author's change is excluded from the summaries")
     func localAuthorExcluded() throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         try writeLedger(
             in: fixture,
             authorID: Self.localAuthorID,
             cells: [position(0, 0): ("A", after)]
         )
         try writeLedger(
             in: fixture,
             authorID: Self.alice,
             cells: [position(0, 1): ("B", after)]
         )
 
         let summaries = fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff)
         #expect(summaries.count == 1)
         #expect(summaries.first?.authorID == Self.alice)
     }
 
     @Test("Multiple peers each appear as their own summary, ordered by author")
     func multiplePeers() throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         try addPlayer(in: fixture, authorID: Self.bob, name: "Bob")
         try writeLedger(
             in: fixture,
             authorID: Self.alice,
             cells: [position(0, 0): ("A", after)]
         )
         try writeLedger(
             in: fixture,
             authorID: Self.bob,
             cells: [
                 position(0, 1): ("B", after),
                 position(0, 2): ("C", after),
             ]
         )
 
         let summaries = fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff)
         #expect(summaries.map(\.authorID) == [Self.alice, Self.bob])
         #expect(summaries[0].added == 1)
         #expect(summaries[1].added == 2)
     }
 
     // MARK: - Integration: the moves→ledger writer
 
     @Test("An empty seed preserves the first later peer fill")
     func emptySeedPreservesFirstPeerFill() async throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
 
         // The user leaves before anyone has entered a letter. This first build
         // must still persist that the empty snapshot has been established.
         await buildLedger(in: fixture)
 
         try writeMoves(
             in: fixture,
             authorID: Self.alice,
             cells: [position(0, 0): ("A", after)]
         )
         await buildLedger(in: fixture)
 
         let summary = try #require(
             fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff).first
         )
         #expect(summary.added == 1)
         #expect(summary.cleared == 0)
     }
 
     @Test("Legacy ledger rows preserve a later peer fill during migration")
     func legacyLedgerRowsPreserveLaterPeerFill() async throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         try writeLedger(
             in: fixture,
             authorID: Self.alice,
             cells: [position(2, 2): ("H", before)]
         )
         try writeMoves(
             in: fixture,
             authorID: Self.alice,
             cells: [
                 position(2, 2): ("H", before),
                 position(0, 0): ("A", after),
             ]
         )
 
         await buildLedger(in: fixture)
 
         let summary = try #require(
             fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff).first
         )
         #expect(summary.added == 1)
     }
 
     @Test("A peer's fills drive the ledger and surface as a summary")
     func fillsDriveLedger() async throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         // A baseline build (over a pre-cutoff cell) seeds the ledger, so the
         // later fills are measured against it rather than absorbed by the seed.
         try writeMoves(
             in: fixture,
             authorID: Self.alice,
             cells: [position(2, 2): ("H", before)]
         )
         await buildLedger(in: fixture)
         try writeMoves(
             in: fixture,
             authorID: Self.alice,
             cells: [
                 position(2, 2): ("H", before),
                 position(0, 0): ("A", after),
                 position(0, 1): ("B", after),
             ]
         )
         await buildLedger(in: fixture)
 
         let summary = try #require(
             fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff).first
         )
         #expect(summary.added == 2)
     }
 
     @Test("A peer's check sweep after the cutoff does not inflate the summary")
     func checkSweepDoesNotInflateSummary() async throws {
         // The reported rejoin bug: a check re-stamps every filled cell's
         // updatedAt without changing the letter, and must not read as fresh
         // fills on return.
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         // Alice's two letters arrive and are recorded before you leave.
         try writeMoves(
             in: fixture,
             authorID: Self.alice,
             cells: [
                 position(0, 0): ("A", before),
                 position(0, 1): ("B", before),
             ]
         )
         await buildLedger(in: fixture)
         // After the cutoff she runs a check (re-stamps both letters) and fills
         // one genuinely new cell.
         try writeMoves(
             in: fixture,
             authorID: Self.alice,
             cells: [
                 position(0, 0): ("A", after),
                 position(0, 1): ("B", after),
                 position(2, 2): ("H", after),
             ]
         )
         await buildLedger(in: fixture)
 
         let summary = try #require(
             fixture.monitor.summaries(for: fixture.gameID, since: Self.cutoff).first
         )
         // Only the genuine fill — not the two re-stamped letters.
         #expect(summary.added == 1)
         #expect(summary.cleared == 0)
     }
 
     @Test("Completing a game drops its peer-change ledger")
     func completionClearsLedger() async throws {
         let fixture = try makeFixture()
         try addPlayer(in: fixture, authorID: Self.alice, name: "Alice")
         try writeMoves(
             in: fixture,
             authorID: Self.alice,
             cells: [position(0, 0): ("A", after), position(0, 1): ("B", after)]
         )
         await buildLedger(in: fixture)
 
         let req = NSFetchRequest<PeerChangeEntity>(entityName: "PeerChangeEntity")
         req.predicate = NSPredicate(format: "gameID == %@", fixture.gameID as CVarArg)
         #expect(try fixture.persistence.viewContext.count(for: req) > 0)
 
         // The game finishes; the next build drops the now-useless ledger.
         fixture.game.completedAt = Date()
         try fixture.persistence.viewContext.save()
         await buildLedger(in: fixture)
 
         #expect(try fixture.persistence.viewContext.count(for: req) == 0)
     }
 }