crossmate

PlayerNamePublisherTests.swift (5780B)

---

 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("PlayerNamePublisher", .serialized)
 @MainActor
 struct PlayerNamePublisherTests {
 
     // MARK: - Helpers
 
     /// Creates a persistence store with one game that qualifies for fan-out
     /// (it has a `ckShareRecordName`, so `upsertPlayerRecords` will visit it).
     private func makeSharedGame() throws -> (PersistenceController, UUID) {
         let p = makeTestPersistence()
         let ctx = p.viewContext
         let gameID = UUID()
         let entity = GameEntity(context: ctx)
         entity.id = gameID
         entity.title = "Shared Test"
         entity.puzzleSource = ""
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.ckRecordName = RecordSerializer.recordName(forGameID: gameID)
         entity.ckShareRecordName = "share-\(UUID().uuidString)"
         try ctx.save()
         return (p, gameID)
     }
 
     private func makeNonSharedGame() throws -> (PersistenceController, UUID) {
         let p = makeTestPersistence()
         let ctx = p.viewContext
         let gameID = UUID()
         let entity = GameEntity(context: ctx)
         entity.id = gameID
         entity.title = "Solo Test"
         entity.puzzleSource = ""
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.ckRecordName = RecordSerializer.recordName(forGameID: gameID)
         // No ckShareRecordName and databaseScope == 0 → not picked up by fan-out.
         try ctx.save()
         return (p, gameID)
     }
 
     private func fetchPlayerName(authorID: String, in persistence: PersistenceController) -> String? {
         let ctx = persistence.container.newBackgroundContext()
         return ctx.performAndWait {
             let req = NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity")
             req.predicate = NSPredicate(format: "authorID == %@", authorID)
             req.fetchLimit = 1
             return (try? ctx.fetch(req).first)?.name
         }
     }
 
     private func makeBroadcaster(
         preferences: PlayerPreferences,
         persistence: PersistenceController,
         authorID: String
     ) -> PlayerNamePublisher {
         PlayerNamePublisher(
             preferences: preferences,
             persistence: persistence,
             authorIdentity: AuthorIdentity(testing: authorID),
             enqueuePlayerRecord: { _, _ in }
         )
     }
 
     // MARK: - Tests
 
     @Test("broadcastName writes a PlayerEntity for shared/joined games")
     func broadcastNameWritesPlayerEntityForSharedGame() async throws {
         let (persistence, _) = try makeSharedGame()
         let prefs = PlayerPreferences(
             local: UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         )
         prefs.name = "Alice"
         let broadcaster = makeBroadcaster(
             preferences: prefs,
             persistence: persistence,
             authorID: "_local"
         )
 
         await broadcaster.broadcastName()
 
         #expect(fetchPlayerName(authorID: "_local", in: persistence) == "Alice")
     }
 
     @Test("broadcastName is a no-op for non-shared games")
     func broadcastNameSkipsNonSharedGames() async throws {
         let (persistence, _) = try makeNonSharedGame()
         let prefs = PlayerPreferences(
             local: UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         )
         prefs.name = "Alice"
         let broadcaster = makeBroadcaster(
             preferences: prefs,
             persistence: persistence,
             authorID: "_local"
         )
 
         await broadcaster.broadcastName()
 
         #expect(fetchPlayerName(authorID: "_local", in: persistence) == nil)
     }
 
     @Test("Debounce coalesces two rapid name changes into one fan-out with the final name")
     func debounceCoalescesPair() async throws {
         let (persistence, _) = try makeSharedGame()
         let prefs = PlayerPreferences(
             local: UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         )
         let broadcaster = makeBroadcaster(
             preferences: prefs,
             persistence: persistence,
             authorID: "_local"
         )
 
         let spy = FanOutSpy()
         broadcaster.onFanOutForTesting = { name in spy.record(name) }
 
         // Allow the observation task to make its first withObservationTracking
         // registration before we mutate any values.
         await Task.yield()
 
         // First change — debounce timer #1 starts.
         prefs.name = "Alice"
         await Task.yield() // observation task → scheduleDebounce
 
         // Second change before timer fires — must cancel #1, start #2.
         prefs.name = "Bob"
         await Task.yield() // observation task → cancel #1, start #2
 
         // Poll until the (single, hopefully) fan-out fires. Loose deadline so
         // CI scheduler jitter doesn't fail the test.
         let deadline = Date().addingTimeInterval(2.0)
         while spy.count == 0 && Date() < deadline {
             try await Task.sleep(for: .milliseconds(20))
         }
 
         // Grace period to catch a stray second fan-out from an uncancelled
         // timer — the bug we're guarding against would surface here as count==2.
         try await Task.sleep(for: .milliseconds(150))
 
         #expect(spy.count == 1, "two rapid changes should debounce into one fan-out")
         #expect(spy.names.last == "Bob", "the final name should win")
         #expect(fetchPlayerName(authorID: "_local", in: persistence) == "Bob")
 
         // Keep broadcaster alive until assertions are done.
         withExtendedLifetime(broadcaster) {}
     }
 }
 
 @MainActor
 private final class FanOutSpy {
     private(set) var names: [String] = []
     var count: Int { names.count }
     func record(_ name: String) { names.append(name) }
 }