crossmate

GameStoreUnreadMovesTests.swift (21496B)

---

 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 /// Pins down the Date-based unread-badge heuristic on `GameStore`. A shared
 /// game gains an unread badge when another author's `MovesEntity` row has a
 /// later `updatedAt` than the local user's last open.
 @Suite("GameStore unread badge", .isolatedNotificationState)
 @MainActor
 struct GameStoreUnreadMovesTests {
 
     private static let localAuthorID = "local-author"
     private static let otherAuthorID = "other-author"
 
     private static let sharedPuzzleSource = """
     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 func makeSharedGame(
         in ctx: NSManagedObjectContext
     ) throws -> (GameEntity, UUID) {
         let gameID = UUID()
         let xd = try XD.parse(Self.sharedPuzzleSource)
         let puzzle = Puzzle(xd: xd)
 
         let entity = GameEntity(context: ctx)
         entity.id = gameID
         entity.title = "Shared"
         entity.puzzleSource = Self.sharedPuzzleSource
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.ckRecordName = "game-\(gameID.uuidString)"
         entity.ckZoneName = "game-\(gameID.uuidString)"
         entity.ckZoneOwnerName = "_someOtherUser"
         entity.databaseScope = 1
         // Pre-populate the cached summary fields so `GameSummary.init?` takes
         // the fast path and doesn't have to re-parse XD.
         entity.populateCachedSummaryFields(from: puzzle)
         try ctx.save()
         return (entity, gameID)
     }
 
     private func addMovesRow(
         for entity: GameEntity,
         gameID: UUID,
         authorID: String,
         updatedAt: Date,
         in ctx: NSManagedObjectContext
     ) throws {
         let row = MovesEntity(context: ctx)
         row.game = entity
         row.authorID = authorID
         row.deviceID = "test-\(authorID)"
         row.cells = Data()
         row.updatedAt = updatedAt
         row.ckRecordName = RecordSerializer.recordName(
             forMovesInGame: gameID,
             authorID: authorID,
             deviceID: "test-\(authorID)"
         )
         try ctx.save()
     }
 
     @Test("Other-author Moves update marks the shared game unread")
     func otherAuthorMoveMarksSharedGameUnread() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let (entity, gameID) = try makeSharedGame(in: persistence.viewContext)
         let updatedAt = Date(timeIntervalSinceNow: -10)
         try addMovesRow(
             for: entity,
             gameID: gameID,
             authorID: Self.otherAuthorID,
             updatedAt: updatedAt,
             in: persistence.viewContext
         )
 
         store.noteIncomingMovesUpdate(
             gameIDs: [gameID],
             currentAuthorID: Self.localAuthorID
         )
 
         let summary = try #require(GameSummary(entity: entity))
         #expect(entity.latestOtherMoveAt == updatedAt)
         #expect(entity.lastReadOtherMoveAt == nil)
         #expect(summary.hasUnreadOtherMoves)
     }
 
     @Test("Own Moves update does not mark the shared game unread")
     func ownMoveDoesNotMarkSharedGameUnread() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let (entity, gameID) = try makeSharedGame(in: persistence.viewContext)
         try addMovesRow(
             for: entity,
             gameID: gameID,
             authorID: Self.localAuthorID,
             updatedAt: Date(),
             in: persistence.viewContext
         )
 
         store.noteIncomingMovesUpdate(
             gameIDs: [gameID],
             currentAuthorID: Self.localAuthorID
         )
 
         let summary = try #require(GameSummary(entity: entity))
         #expect(entity.latestOtherMoveAt == nil)
         #expect(!summary.hasUnreadOtherMoves)
     }
 
     @Test("Opening a game advances readThroughAt to latestOtherMoveAt")
     func openingGameMarksOtherMovesSeen() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ctx = persistence.viewContext
         let (entity, _) = try makeSharedGame(in: ctx)
         let latest = Date(timeIntervalSinceNow: -10)
         entity.latestOtherMoveAt = latest
         try ctx.save()
 
         _ = try store.loadGame(id: entity.id!)
 
         #expect(entity.readThroughAt == latest)
         let summary = try #require(GameSummary(entity: entity))
         #expect(!summary.hasUnreadOtherMoves)
     }
 
     @Test("unreadOtherMovesGameCount tallies shared games with pending other-author moves")
     func unreadOtherMovesGameCountAcrossGames() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ctx = persistence.viewContext
 
         // Unseen: shared game with other-author moves and no lastSeen.
         let (gameA, gameAID) = try makeSharedGame(in: ctx)
         try addMovesRow(
             for: gameA,
             gameID: gameAID,
             authorID: Self.otherAuthorID,
             updatedAt: Date(timeIntervalSinceNow: -20),
             in: ctx
         )
         store.noteIncomingMovesUpdate(
             gameIDs: [gameAID],
             currentAuthorID: Self.localAuthorID
         )
 
         // Seen: shared game whose watermark catches up to latest.
         let (gameB, _) = try makeSharedGame(in: ctx)
         let seenLatest = Date(timeIntervalSinceNow: -30)
         gameB.latestOtherMoveAt = seenLatest
         gameB.readThroughAt = seenLatest
         try ctx.save()
 
         #expect(store.unreadOtherMovesGameCount() == 1)
 
         // Opening the unseen game advances lastSeen and clears the badge tally.
         _ = try store.loadGame(id: gameAID)
         #expect(store.unreadOtherMovesGameCount() == 0)
     }
 
     @Test("Inbound moves while the puzzle is visible advance readThroughAt")
     func inboundMovesWhilePuzzleVisibleMarkSeen() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let (entity, gameID) = try makeSharedGame(in: persistence.viewContext)
         let updatedAt = Date(timeIntervalSinceNow: -10)
         try addMovesRow(
             for: entity,
             gameID: gameID,
             authorID: Self.otherAuthorID,
             updatedAt: updatedAt,
             in: persistence.viewContext
         )
 
         NotificationState.setActivePuzzleID(gameID)
         defer { NotificationState.setActivePuzzleID(nil) }
 
         store.noteIncomingMovesUpdate(
             gameIDs: [gameID],
             currentAuthorID: Self.localAuthorID
         )
 
         #expect(entity.readThroughAt == updatedAt)
         let summary = try #require(GameSummary(entity: entity))
         #expect(!summary.hasUnreadOtherMoves)
     }
 
     @Test("Inbound moves while visible do not shorten an active read lease")
     func inboundMovesWhileVisiblePreserveFutureLease() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let (entity, gameID) = try makeSharedGame(in: persistence.viewContext)
         let lease = Date(timeIntervalSinceNow: 10 * 60)
         entity.lastReadOtherMoveAt = lease
         try persistence.viewContext.save()
 
         let updatedAt = Date(timeIntervalSinceNow: -10)
         try addMovesRow(
             for: entity,
             gameID: gameID,
             authorID: Self.otherAuthorID,
             updatedAt: updatedAt,
             in: persistence.viewContext
         )
 
         NotificationState.setActivePuzzleID(gameID)
         defer { NotificationState.setActivePuzzleID(nil) }
 
         store.noteIncomingMovesUpdate(
             gameIDs: [gameID],
             currentAuthorID: Self.localAuthorID
         )
 
         #expect(entity.latestOtherMoveAt == updatedAt)
         #expect(entity.lastReadOtherMoveAt == lease)
         let summary = try #require(GameSummary(entity: entity))
         #expect(!summary.hasUnreadOtherMoves)
     }
 
     @Test("Inbound moves after backing out of a puzzle still mark it unseen")
     func inboundMovesAfterBackOutMarkUnseen() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let (entity, gameID) = try makeSharedGame(in: persistence.viewContext)
         // Simulate a prior open: `currentEntity` is set inside the store and
         // `lastReadOtherMoveAt` is up-to-date with no pending moves. The user
         // then backs out — `NotificationState.activePuzzleID` clears, but the
         // store's `currentEntity` deliberately stays put.
         _ = try store.loadGame(id: gameID)
         NotificationState.setActivePuzzleID(nil)
 
         let updatedAt = Date()
         try addMovesRow(
             for: entity,
             gameID: gameID,
             authorID: Self.otherAuthorID,
             updatedAt: updatedAt,
             in: persistence.viewContext
         )
 
         store.noteIncomingMovesUpdate(
             gameIDs: [gameID],
             currentAuthorID: Self.localAuthorID
         )
 
         #expect(entity.latestOtherMoveAt == updatedAt)
         #expect(entity.lastReadOtherMoveAt == nil)
         let summary = try #require(GameSummary(entity: entity))
         #expect(summary.hasUnreadOtherMoves)
     }
 
     @Test("Inbound moves within the leave grace after backing out stay seen")
     func inboundMovesWithinLeaveGraceStaySeen() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let (entity, gameID) = try makeSharedGame(in: persistence.viewContext)
         _ = try store.loadGame(id: gameID)
 
         // Simulate the real open → back-out path: the view sets the active
         // puzzle on appear and clears it on `.onDisappear`, which now opens a
         // short grace window rather than dropping the active state instantly.
         NotificationState.setActivePuzzleID(gameID)
         NotificationState.clearActivePuzzleID(if: gameID)
         defer { NotificationState.setActivePuzzleID(nil) }
 
         let updatedAt = Date()
         try addMovesRow(
             for: entity,
             gameID: gameID,
             authorID: Self.otherAuthorID,
             updatedAt: updatedAt,
             in: persistence.viewContext
         )
 
         // An inbound batch (or back-out catch-up) that finishes processing a
         // beat after the view disappeared is still treated as seen — the user
         // watched these moves arrive while the grid was on screen.
         store.noteIncomingMovesUpdate(
             gameIDs: [gameID],
             currentAuthorID: Self.localAuthorID
         )
 
         #expect(entity.readThroughAt == updatedAt)
         let summary = try #require(GameSummary(entity: entity))
         #expect(!summary.hasUnreadOtherMoves)
     }
 
     @Test("A sibling's presenceUntil presence lease is adopted last-writer-wins")
     func incomingReadCursorSetsBadgeHorizon() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(
             persistence: persistence,
             authorIDProvider: { Self.localAuthorID }
         )
         let ctx = persistence.viewContext
         let (entity, gameID) = try makeSharedGame(in: ctx)
 
         let earlier = Date(timeIntervalSinceNow: -30)
         let later = Date(timeIntervalSinceNow: -10)
         let future = Date(timeIntervalSinceNow: 10 * 60)
 
         // All of an account's devices share one Player record, so the inbound
         // `presenceUntil` is the account's resolved *presence lease*: adopt it verbatim
         // under last-writer-wins. This is the presence horizon only; the unread
         // badge is driven by the read watermark (see the watermark test below).
         store.noteIncomingReadCursor(gameID: gameID, presenceUntil: earlier)
         #expect(entity.lastReadOtherMoveAt == earlier)
 
         store.noteIncomingReadCursor(gameID: gameID, presenceUntil: later)
         #expect(entity.lastReadOtherMoveAt == later)
 
         // A sibling opens an active session and leases the horizon into the
         // future; the lease is adopted verbatim.
         store.noteIncomingReadCursor(gameID: gameID, presenceUntil: future)
         #expect(entity.lastReadOtherMoveAt == future)
 
         // That sibling leaves and publishes the current time. Under
         // last-writer-wins the single shared scalar simply moves back to the
         // close value — there is no per-device lease here to protect it.
         store.noteIncomingReadCursor(gameID: gameID, presenceUntil: later)
         #expect(entity.lastReadOtherMoveAt == later)
     }
 
     @Test("The unread badge tracks the read watermark, not the presence lease")
     func badgeTracksWatermarkNotLease() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(
             persistence: persistence,
             authorIDProvider: { Self.localAuthorID }
         )
         let ctx = persistence.viewContext
         let (entity, gameID) = try makeSharedGame(in: ctx)
 
         let earlier = Date(timeIntervalSinceNow: -30)
         let latest = Date(timeIntervalSinceNow: -10)
         let future = Date(timeIntervalSinceNow: 10 * 60)
         try addMovesRow(
             for: entity,
             gameID: gameID,
             authorID: Self.otherAuthorID,
             updatedAt: latest,
             in: ctx
         )
         store.noteIncomingMovesUpdate(gameIDs: [gameID], currentAuthorID: Self.localAuthorID)
         #expect(entity.readThroughAt == nil)
         #expect(store.unreadOtherMovesGameCount() == 1)
         #expect(store.hasUnreadOtherMoves(gameID: gameID))
 
         // A future presence lease must NOT clear the badge — this is the bug:
         // a leased-but-backgrounded reader had moves silently swallowed.
         #expect(store.setReadCursor(gameID: gameID, presenceUntil: future))
         #expect(entity.lastReadOtherMoveAt == future)
         #expect(store.unreadOtherMovesGameCount() == 1)
         #expect(store.hasUnreadOtherMoves(gameID: gameID))
 
         // The watermark, older than the latest move, still leaves it unread.
         #expect(store.advanceReadThrough(gameID: gameID, through: earlier))
         #expect(store.unreadOtherMovesGameCount() == 1)
         #expect(store.hasUnreadOtherMoves(gameID: gameID))
 
         // The watermark catching the latest move is what clears the badge.
         #expect(store.advanceReadThrough(gameID: gameID, through: latest))
         #expect(entity.readThroughAt == latest)
         #expect(store.unreadOtherMovesGameCount() == 0)
         #expect(!store.hasUnreadOtherMoves(gameID: gameID))
     }
 
     /// Checks the summary and the store predicate agree: both must key off the
     /// watermark alone, so a forward-dated presence lease cannot clear unread.
     @Test("Read watermark overrides a newer presence lease")
     func readWatermarkOverridesNewerPresenceLease() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ctx = persistence.viewContext
         let (entity, gameID) = try makeSharedGame(in: ctx)
 
         let readThrough = Date(timeIntervalSinceNow: -120)
         let latest = Date(timeIntervalSinceNow: -60)
         entity.latestOtherMoveAt = latest
         entity.readThroughAt = readThrough
         entity.lastReadOtherMoveAt = Date(timeIntervalSinceNow: 10 * 60)
         try ctx.save()
 
         let summary = try #require(GameSummary(entity: entity))
         #expect(summary.hasUnreadOtherMoves)
         #expect(store.unreadOtherMovesGameCount() == 1)
         #expect(store.hasUnreadOtherMoves(gameID: gameID))
     }
 
     @Test("Active read leases refresh only when the horizon is below the floor")
     func activeReadLeaseRefreshesAtFloor() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let (entity, gameID) = try makeSharedGame(in: persistence.viewContext)
 
         let now = Date()
         let farEnough = now.addingTimeInterval(6 * 60)
         let floor = now.addingTimeInterval(5 * 60)
         let refreshed = now.addingTimeInterval(10 * 60)
 
         #expect(store.setReadCursor(gameID: gameID, presenceUntil: farEnough))
         #expect(!store.setReadCursor(
             gameID: gameID,
             presenceUntil: refreshed,
             minimumExistingPresenceUntil: floor
         ))
         #expect(entity.lastReadOtherMoveAt == farEnough)
 
         let tooClose = now.addingTimeInterval(4 * 60)
         #expect(store.setReadCursor(gameID: gameID, presenceUntil: tooClose))
         #expect(store.setReadCursor(
             gameID: gameID,
             presenceUntil: refreshed,
             minimumExistingPresenceUntil: floor
         ))
         #expect(entity.lastReadOtherMoveAt == refreshed)
     }
 
     @Test("Completed shared games show as unseen when a peer finished or resigned unseen")
     func completedSharedGameSurfacesUnseen() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ctx = persistence.viewContext
 
         // A peer's win or resignation is itself an unseen event: the move that
         // finished the game lands as a later other-author move, so the finished
         // game should flag as unread until the user opens it to review.
         let (entity, gameID) = try makeSharedGame(in: ctx)
         entity.completedAt = Date(timeIntervalSinceNow: -100)
         try ctx.save()
 
         try addMovesRow(
             for: entity,
             gameID: gameID,
             authorID: Self.otherAuthorID,
             updatedAt: Date(),
             in: ctx
         )
 
         store.noteIncomingMovesUpdate(
             gameIDs: [gameID],
             currentAuthorID: Self.localAuthorID
         )
 
         let summary = try #require(GameSummary(entity: entity))
         #expect(summary.hasUnreadOtherMoves)
         #expect(store.unreadOtherMovesGameCount() == 1)
 
         // Reviewing the finished game advances the read watermark and clears it.
         store.advanceReadThrough(gameID: gameID, through: Date())
         let reviewed = try #require(GameSummary(entity: entity))
         #expect(!reviewed.hasUnreadOtherMoves)
         #expect(store.unreadOtherMovesGameCount() == 0)
     }
 
     @Test("Realtime cell edit updates the open game through the move merger")
     func realtimeCellEditUpdatesOpenGame() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(
             persistence: persistence,
             authorIDProvider: { Self.localAuthorID }
         )
         let (_, gameID) = try makeSharedGame(in: persistence.viewContext)
         let (game, _) = try store.loadGame(id: gameID)
         let updatedAt = Date()
 
         let applied = store.applyRealtimeCellEdit(RealtimeCellEdit(
             gameID: gameID,
             authorID: Self.localAuthorID,
             deviceID: "remote-device",
             row: 0,
             col: 0,
             letter: "Q",
             mark: .none,
             updatedAt: updatedAt,
             cellAuthorID: Self.localAuthorID
         ))
 
         #expect(applied)
         #expect(game.squares[0][0].entry == "Q")
         #expect(game.squares[0][0].letterAuthorID == Self.localAuthorID)
     }
 
     @Test("Older realtime cell edit from the same device is ignored")
     func olderRealtimeCellEditIsIgnored() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(
             persistence: persistence,
             authorIDProvider: { Self.localAuthorID }
         )
         let (_, gameID) = try makeSharedGame(in: persistence.viewContext)
         let (game, _) = try store.loadGame(id: gameID)
         let later = Date(timeIntervalSince1970: 200)
         let earlier = Date(timeIntervalSince1970: 100)
 
         #expect(store.applyRealtimeCellEdit(RealtimeCellEdit(
             gameID: gameID,
             authorID: Self.localAuthorID,
             deviceID: "remote-device",
             row: 0,
             col: 0,
             letter: "Q",
             mark: .none,
             updatedAt: later,
             cellAuthorID: Self.localAuthorID
         )))
         #expect(!store.applyRealtimeCellEdit(RealtimeCellEdit(
             gameID: gameID,
             authorID: Self.localAuthorID,
             deviceID: "remote-device",
             row: 0,
             col: 0,
             letter: "R",
             mark: .none,
             updatedAt: earlier,
             cellAuthorID: Self.localAuthorID
         )))
 
         #expect(game.squares[0][0].entry == "Q")
     }
 
     @Test("Opening a stale parser-version game reparses source and records current version")
     func openingStaleParserVersionGameReparsesSource() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ctx = persistence.viewContext
         let (entity, _) = try makeSharedGame(in: ctx)
         entity.puzzleParserVersion = 0
         entity.gridWidth = 0
         entity.gridHeight = 0
         entity.blockMask = nil
         try ctx.save()
 
         _ = try store.loadGame(id: entity.id!)
 
         #expect(entity.puzzleParserVersion == Int64(XD.currentParserVersion))
         #expect(entity.gridWidth == 3)
         #expect(entity.gridHeight == 3)
         #expect(entity.blockMask?.count == 9)
     }
 }