crossmate

PlayerSelectionPublisherTests.swift (19252B)

---

 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("PlayerSelectionPublisher", .serialized)
 @MainActor
 struct PlayerSelectionPublisherTests {
 
     /// Captures the `(gameID, authorID)` sink fan-outs.
     actor Capture {
         private(set) var notifications: [(UUID, String)] = []
         var count: Int { notifications.count }
         func append(_ gameID: UUID, _ authorID: String) {
             notifications.append((gameID, authorID))
         }
     }
 
     /// Mutable flag for tests that need to toggle the peer-presence
     /// predicate mid-test.
     actor PresenceFlag {
         private(set) var value: Bool = false
         func set(_ newValue: Bool) { value = newValue }
     }
 
     /// Records the durations handed to the injected sleep.
     actor DurationRecorder {
         private(set) var durations: [Duration] = []
         func record(_ duration: Duration) { durations.append(duration) }
     }
 
     /// Records the game IDs the interval provider is consulted for.
     actor GameIDRecorder {
         private(set) var ids: [UUID] = []
         func record(_ id: UUID) { ids.append(id) }
     }
 
     private func makePersistenceWithGame() throws -> (PersistenceController, UUID) {
         let persistence = makeTestPersistence()
         let context = persistence.viewContext
         let gameID = UUID()
         let entity = GameEntity(context: context)
         entity.id = gameID
         entity.title = "Test"
         entity.puzzleSource = ""
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.ckRecordName = "game-\(gameID.uuidString)"
         try context.save()
         return (persistence, gameID)
     }
 
     @Test("Publish + flush writes the PlayerEntity row and notifies the sink")
     func publishWritesEntity() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publish(PlayerSelection(row: 3, col: 4, direction: .down))
         await publisher.flush()
 
         let count = await capture.count
         #expect(count == 1)
         let values = fetchPlayer(gameID: gameID, authorID: "alice", persistence: persistence)
         #expect(values?.selRow == 3)
         #expect(values?.selCol == 4)
         #expect(values?.selDir == Int64(Puzzle.Direction.down.rawValue))
         #expect(values?.ckRecordName == "player-\(gameID.uuidString)-alice")
     }
 
     @Test("Repeated identical selections don't refire the sink")
     func dedupesIdenticalSelections() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .milliseconds(40) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         let selection = PlayerSelection(row: 0, col: 0, direction: .across)
         await publisher.publish(selection)
         try await Task.sleep(for: .milliseconds(120))
         await publisher.publish(selection)
         await publisher.publish(selection)
         try await Task.sleep(for: .milliseconds(120))
 
         let count = await capture.count
         #expect(count == 1)
     }
 
     @Test("Rapid distinct selections coalesce into a single trailing flush")
     func debounceCoalescesRapidPublishes() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let manualSleep = ManualDebounceSleep()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) },
             sleep: manualSleep.sleepFn
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         for col in 0...4 {
             await publisher.publish(PlayerSelection(row: 0, col: col, direction: .across))
         }
         // Each publish cancelled the prior debounce task; only the latest is
         // live. Releasing the manual sleep wakes every captured continuation
         // — the cancelled tasks observe Task.isCancelled and exit without
         // flushing; the live task proceeds to flush with the final value.
         manualSleep.releaseAll()
         try await waitForCount(1, capture: capture)
 
         let count = await capture.count
         #expect(count == 1)
         let values = fetchPlayer(gameID: gameID, authorID: "alice", persistence: persistence)
         #expect(values?.selCol == 4)
     }
 
     @Test("Debounce interval is sourced from the provider, keyed by the active game")
     func debounceIntervalComesFromProvider() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let sleepRecorder = DurationRecorder()
         let providerGames = GameIDRecorder()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { id in
                 await providerGames.record(id)
                 return .milliseconds(1234)
             },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) },
             sleep: { duration in await sleepRecorder.record(duration) }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publish(PlayerSelection(row: 0, col: 1, direction: .across))
         try await waitForCount(1, capture: capture)
 
         // The provider was asked for this game, and its returned interval is
         // exactly what the debounce slept on.
         #expect(await providerGames.ids == [gameID])
         #expect(await sleepRecorder.durations == [.milliseconds(1234)])
     }
 
     private func waitForCount(
         _ expected: Int,
         capture: Capture,
         timeout: Duration = .seconds(5)
     ) async throws {
         let deadline = ContinuousClock.now.advanced(by: timeout)
         while await capture.count != expected,
               ContinuousClock.now < deadline {
             try await Task.sleep(for: .milliseconds(20))
         }
     }
 
     @Test("Clear nils the selection fields and notifies the sink")
     func clearWritesNilSelection() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publish(PlayerSelection(row: 1, col: 2, direction: .down))
         await publisher.flush()
         await publisher.clear()
 
         let count = await capture.count
         #expect(count == 2)
         let values = fetchPlayer(gameID: gameID, authorID: "alice", persistence: persistence)
         #expect(values != nil)
         #expect(values?.selRow == nil)
         #expect(values?.selCol == nil)
         #expect(values?.selDir == nil)
     }
 
     @Test("Clear is a no-op when nothing has been published yet")
     func clearWithoutPriorPublishIsNoOp() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.clear()
 
         let count = await capture.count
         #expect(count == 0)
     }
 
     @Test("Publish without begin is silently ignored")
     func publishBeforeBeginIsDropped() async throws {
         let (persistence, _) = try makePersistenceWithGame()
         let capture = Capture()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .milliseconds(40) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) }
         )
 
         await publisher.publish(PlayerSelection(row: 0, col: 0, direction: .across))
         await publisher.flush()
 
         let count = await capture.count
         #expect(count == 0)
     }
 
     @Test("Updates an existing PlayerEntity rather than creating a duplicate")
     func updatesExistingEntity() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         // Pre-seed a PlayerEntity (e.g. from a name broadcast or remote sync).
         let context = persistence.viewContext
         let gameReq = NSFetchRequest<GameEntity>(entityName: "GameEntity")
         gameReq.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
         let game = try #require(try context.fetch(gameReq).first)
         let preexisting = PlayerEntity(context: context)
         preexisting.game = game
         preexisting.authorID = "alice"
         preexisting.name = "Alice"
         preexisting.updatedAt = Date()
         preexisting.ckRecordName = "player-\(gameID.uuidString)-alice"
         try context.save()
 
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { _, _, _ in }
         )
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publish(PlayerSelection(row: 5, col: 6, direction: .across))
         await publisher.flush()
 
         let rows = fetchAllPlayers(gameID: gameID, persistence: persistence)
         #expect(rows.count == 1)
         #expect(rows.first?.name == "Alice") // pre-existing field preserved
         #expect(rows.first?.selRow == 5)
         #expect(rows.first?.selCol == 6)
     }
 
     @Test("Gate denied: Core Data row still updated but sink is skipped")
     func gateDeniedSkipsSink() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) },
             peerPresent: { _ in false }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publish(PlayerSelection(row: 3, col: 4, direction: .down))
         await publisher.flush()
 
         let count = await capture.count
         #expect(count == 0)
         let values = fetchPlayer(gameID: gameID, authorID: "alice", persistence: persistence)
         #expect(values?.selRow == 3)
         #expect(values?.selCol == 4)
     }
 
     @Test("Gate denied then peerPresenceMayHaveChanged ships the held selection")
     func gateResumeShipsPending() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let presence = PresenceFlag()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) },
             peerPresent: { _ in await presence.value }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publish(PlayerSelection(row: 1, col: 2, direction: .across))
         await publisher.flush()
         #expect(await capture.count == 0)
 
         await presence.set(true)
         await publisher.peerPresenceMayHaveChanged()
         #expect(await capture.count == 1)
 
         // A subsequent publish to the same selection shouldn't refire.
         await publisher.publish(PlayerSelection(row: 1, col: 2, direction: .across))
         await publisher.flush()
         #expect(await capture.count == 1)
     }
 
     @Test("peerPresenceMayHaveChanged does not pre-empt an active debounce")
     func gateResumeRespectsActiveDebounce() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let manualSleep = ManualDebounceSleep()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) },
             peerPresent: { _ in true },
             sleep: manualSleep.sleepFn
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publish(PlayerSelection(row: 0, col: 0, direction: .across))
         // Debounce is now scheduled. A peer-presence nudge here must not
         // pre-empt it — that would let a chatty partner pressure us into
         // one CloudKit write per partner-move.
         await publisher.peerPresenceMayHaveChanged()
         #expect(await capture.count == 0)
 
         // Release the debounce normally and confirm we still ship exactly once.
         manualSleep.releaseAll()
         try await waitForCount(1, capture: capture)
         #expect(await capture.count == 1)
     }
 
     @Test("peerPresenceMayHaveChanged with non-matching gameIDs is a no-op")
     func gateResumeScopedByGameID() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) },
             peerPresent: { _ in true }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publish(PlayerSelection(row: 0, col: 0, direction: .across))
         // Don't flush — keep pending set by skipping the debounce. Force a
         // gated state by swapping the predicate isn't supported, so instead
         // verify scoping: a resume call for a different game shouldn't drain.
         await publisher.peerPresenceMayHaveChanged(gameIDs: [UUID()])
         #expect(await capture.count == 0)
     }
 
     @Test("publishImmediately bypasses the gate")
     func publishImmediatelyBypassesGate() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) },
             peerPresent: { _ in false }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publishImmediately(PlayerSelection(row: 7, col: 8, direction: .across))
 
         let count = await capture.count
         #expect(count == 1)
     }
 
     @Test("clear bypasses the gate")
     func clearBypassesGate() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) },
             peerPresent: { _ in false }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publishImmediately(PlayerSelection(row: 1, col: 1, direction: .down))
         await publisher.clear()
 
         let count = await capture.count
         #expect(count == 2)
     }
 
     @Test("Publishing again after clear writes the new selection")
     func publishAfterClear() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         let capture = Capture()
         let publisher = PlayerSelectionPublisher(
             debounceInterval: { _ in .seconds(10) },
             persistence: persistence,
             sink: { id, author, _ in await capture.append(id, author) }
         )
 
         await publisher.begin(gameID: gameID, authorID: "alice", currentName: "Alice")
         await publisher.publish(PlayerSelection(row: 1, col: 1, direction: .across))
         await publisher.flush()
         await publisher.clear()
         await publisher.publish(PlayerSelection(row: 2, col: 2, direction: .down))
         await publisher.flush()
 
         let count = await capture.count
         #expect(count == 3)
         let values = fetchPlayer(gameID: gameID, authorID: "alice", persistence: persistence)
         #expect(values?.selRow == 2)
         #expect(values?.selCol == 2)
         #expect(values?.selDir == Int64(Puzzle.Direction.down.rawValue))
     }
 
     // MARK: - Helpers
 
     struct PlayerValues {
         let name: String?
         let selRow: Int64?
         let selCol: Int64?
         let selDir: Int64?
         let ckRecordName: String?
     }
 
     private func fetchPlayer(
         gameID: UUID,
         authorID: String,
         persistence: PersistenceController
     ) -> PlayerValues? {
         let context = persistence.container.newBackgroundContext()
         return context.performAndWait {
             let request = NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity")
             request.predicate = NSPredicate(
                 format: "game.id == %@ AND authorID == %@",
                 gameID as CVarArg,
                 authorID
             )
             request.fetchLimit = 1
             guard let entity = try? context.fetch(request).first else { return nil }
             return PlayerValues(
                 name: entity.name,
                 selRow: entity.selRow?.int64Value,
                 selCol: entity.selCol?.int64Value,
                 selDir: entity.selDir?.int64Value,
                 ckRecordName: entity.ckRecordName
             )
         }
     }
 
     private func fetchAllPlayers(
         gameID: UUID,
         persistence: PersistenceController
     ) -> [PlayerValues] {
         let context = persistence.container.newBackgroundContext()
         return context.performAndWait {
             let request = NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity")
             request.predicate = NSPredicate(format: "game.id == %@", gameID as CVarArg)
             guard let entities = try? context.fetch(request) else { return [] }
             return entities.map {
                 PlayerValues(
                     name: $0.name,
                     selRow: $0.selRow?.int64Value,
                     selCol: $0.selCol?.int64Value,
                     selDir: $0.selDir?.int64Value,
                     ckRecordName: $0.ckRecordName
                 )
             }
         }
     }
 }