crossmate

GameStoreUnseenMovesTests.swift (13028B)

---

 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", .serialized)
 @MainActor
 struct GameStoreUnseenMovesTests {
 
     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.lastSeenOtherMoveAt == nil)
         #expect(summary.hasUnseenOtherMoves)
     }
 
     @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.hasUnseenOtherMoves)
     }
 
     @Test("Opening a game advances lastSeenOtherMoveAt 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.lastSeenOtherMoveAt == latest)
         let summary = try #require(GameSummary(entity: entity))
         #expect(!summary.hasUnseenOtherMoves)
     }
 
     @Test("unseenOtherMovesGameCount tallies shared games with pending other-author moves")
     func unseenOtherMovesGameCountAcrossGames() 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 lastSeen catches up to latest.
         let (gameB, gameBID) = try makeSharedGame(in: ctx)
         let seenLatest = Date(timeIntervalSinceNow: -30)
         gameB.latestOtherMoveAt = seenLatest
         gameB.lastSeenOtherMoveAt = seenLatest
         try ctx.save()
 
         #expect(store.unseenOtherMovesGameCount() == 1)
 
         // Opening the unseen game advances lastSeen and clears the badge tally.
         _ = try store.loadGame(id: gameAID)
         #expect(store.unseenOtherMovesGameCount() == 0)
     }
 
     @Test("Inbound moves while the puzzle is visible advance lastSeenOtherMoveAt")
     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.lastSeenOtherMoveAt == updatedAt)
         let summary = try #require(GameSummary(entity: entity))
         #expect(!summary.hasUnseenOtherMoves)
     }
 
     @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
         // `lastSeenOtherMoveAt` 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.lastSeenOtherMoveAt == nil)
         let summary = try #require(GameSummary(entity: entity))
         #expect(summary.hasUnseenOtherMoves)
     }
 
     @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.lastSeenOtherMoveAt == updatedAt)
         let summary = try #require(GameSummary(entity: entity))
         #expect(!summary.hasUnseenOtherMoves)
     }
 
     @Test("A sibling device's open lease keeps inbound moves seen here")
     func remoteLeaseKeepsInboundMovesSeen() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let (entity, gameID) = try makeSharedGame(in: persistence.viewContext)
         _ = try store.loadGame(id: gameID)
 
         // Not viewing here, but a sibling device of the same user holds an
         // open lease — the user has eyes on the puzzle there.
         NotificationState.setActivePuzzleID(nil)
         let sentMs = Int64(Date().timeIntervalSince1970 * 1000)
         NotificationState.noteRemoteLease(
             gameID: gameID,
             until: Date().addingTimeInterval(NotificationState.openLeaseDuration),
             sentAtMs: sentMs
         )
         defer {
             NotificationState.noteRemoteLease(
                 gameID: gameID,
                 until: Date().addingTimeInterval(-1),
                 sentAtMs: sentMs + 1
             )
         }
 
         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.lastSeenOtherMoveAt == updatedAt)
         let summary = try #require(GameSummary(entity: entity))
         #expect(!summary.hasUnseenOtherMoves)
     }
 
     @Test("Completed shared games do not show as unseen even with later other-author moves")
     func completedSharedGameSuppressesUnseen() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ctx = persistence.viewContext
 
         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.hasUnseenOtherMoves)
         #expect(store.unseenOtherMovesGameCount() == 0)
     }
 
     @Test("Opening a stale CmVer game reparses source and records current CmVer")
     func openingStaleCmVerGameReparsesSource() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ctx = persistence.viewContext
         let (entity, _) = try makeSharedGame(in: ctx)
         entity.puzzleCmVersion = 0
         entity.gridWidth = 0
         entity.gridHeight = 0
         entity.blockMask = nil
         try ctx.save()
 
         _ = try store.loadGame(id: entity.id!)
 
         #expect(entity.puzzleCmVersion == Int64(XD.currentCmVersion))
         #expect(entity.gridWidth == 3)
         #expect(entity.gridHeight == 3)
         #expect(entity.blockMask?.count == 9)
     }
 }