crossmate

PlayerNamePublisherTests.swift (11409B)

---

 import CloudKit
 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("PlayerNamePublisher", .serialized)
 @MainActor
 struct PlayerNamePublisherTests {
 
     // MARK: - Helpers
 
     /// One enqueued name Decision as seen by the spy closure.
     private struct EnqueuedDecision: Equatable {
         let authorID: String
         let name: String
         let version: Int64
         let zoneID: CKRecordZone.ID
         let scope: DatabaseScope
     }
 
     @MainActor
     private final class DecisionSpy {
         private(set) var decisions: [EnqueuedDecision] = []
         func record(_ d: EnqueuedDecision) { decisions.append(d) }
     }
 
     /// A unique author per test keeps `NameVersionStore`'s UserDefaults state
     /// from leaking between runs — every test starts at generation 0.
     private func freshAuthorID() -> String {
         "_local-\(UUID().uuidString)"
     }
 
     private func addFriend(
         to persistence: PersistenceController,
         authorID: String,
         blocked: Bool = false
     ) throws {
         let ctx = persistence.viewContext
         let friend = FriendEntity(context: ctx)
         friend.authorID = authorID
         friend.pairKey = "pair-\(authorID)"
         friend.isBlocked = blocked
         friend.createdAt = Date()
         try ctx.save()
         if !blocked {
             FriendZone.markOutboxAccepted(pairKey: "pair-\(authorID)")
         }
     }
 
     private func makeBroadcaster(
         preferences: PlayerPreferences,
         persistence: PersistenceController,
         authorID: String,
         spy: DecisionSpy,
         enqueuePlayer: @escaping (UUID, String, String) async -> Void = { _, _, _ in }
     ) -> PlayerNamePublisher {
         PlayerNamePublisher(
             preferences: preferences,
             persistence: persistence,
             authorIdentity: AuthorIdentity(testing: authorID),
             enqueuePlayer: enqueuePlayer,
             enqueueNameDecision: { authorID, name, version, zoneID, scope in
                 await spy.record(EnqueuedDecision(
                     authorID: authorID,
                     name: name,
                     version: version,
                     zoneID: zoneID,
                     scope: scope
                 ))
             }
         )
     }
 
     private func fetchPlayerNames(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)
             let entities = (try? ctx.fetch(req)) ?? []
             return entities.compactMap(\.name)
         }
     }
 
     // MARK: - Decision fan-out
 
     @Test("broadcastName publishes to the account zone and every non-blocked friend zone")
     func broadcastNameFansOutDecisions() async throws {
         let persistence = makeTestPersistence()
         let authorID = freshAuthorID()
         try addFriend(to: persistence, authorID: "_bob")
         try addFriend(to: persistence, authorID: "_carol")
         try addFriend(to: persistence, authorID: "_mallory", blocked: true)
 
         let prefs = PlayerPreferences(
             local: UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         )
         prefs.name = "Alice"
         let spy = DecisionSpy()
         let broadcaster = makeBroadcaster(
             preferences: prefs, persistence: persistence,
             authorID: authorID, spy: spy
         )
 
         await broadcaster.broadcastName()
 
         // Account zone copy plus one per non-blocked friend; blocked zone skipped.
         #expect(spy.decisions.count == 3)
         #expect(spy.decisions.allSatisfy { $0.authorID == authorID })
         #expect(spy.decisions.allSatisfy { $0.name == "Alice" })
         #expect(spy.decisions.allSatisfy { $0.version == 1 })
         // A friend's name is written into their inbox — our outbox: shared
         // scope, owned by the friend, both zones named `friend-<pairKey>`.
         let bobZone = FriendZone.outboxZoneID(pairKey: "pair-_bob", friendAuthorID: "_bob")
         let carolZone = FriendZone.outboxZoneID(pairKey: "pair-_carol", friendAuthorID: "_carol")
         let zoneNames = Set(spy.decisions.map(\.zoneID.zoneName))
         #expect(zoneNames == [
             RecordSerializer.accountZoneID.zoneName, bobZone.zoneName, carolZone.zoneName
         ])
         let carol = spy.decisions.first { $0.zoneID.zoneName == carolZone.zoneName }
         #expect(carol?.scope == .shared)
         #expect(carol?.zoneID.ownerName == "_carol")
         // Fan-out no longer touches per-game Player rows.
         #expect(fetchPlayerNames(authorID: authorID, in: persistence).isEmpty)
 
         withExtendedLifetime(broadcaster) {}
     }
 
     @Test("each broadcast bumps the name generation")
     func broadcastNameBumpsVersion() async throws {
         let persistence = makeTestPersistence()
         let authorID = freshAuthorID()
         let prefs = PlayerPreferences(
             local: UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         )
         prefs.name = "Alice"
         let spy = DecisionSpy()
         let broadcaster = makeBroadcaster(
             preferences: prefs, persistence: persistence,
             authorID: authorID, spy: spy
         )
 
         await broadcaster.broadcastName()
         prefs.name = "Alicia"
         await broadcaster.broadcastName()
 
         #expect(spy.decisions.map(\.version) == [1, 2])
         #expect(spy.decisions.map(\.name) == ["Alice", "Alicia"])
 
         withExtendedLifetime(broadcaster) {}
     }
 
     @Test("broadcastName skips an empty or whitespace-only name")
     func broadcastNameSkipsEmptyName() async throws {
         let persistence = makeTestPersistence()
         let authorID = freshAuthorID()
         let prefs = PlayerPreferences(
             local: UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         )
         prefs.name = "   "
         let spy = DecisionSpy()
         let broadcaster = makeBroadcaster(
             preferences: prefs, persistence: persistence,
             authorID: authorID, spy: spy
         )
 
         await broadcaster.broadcastName()
 
         #expect(spy.decisions.isEmpty)
         // The skipped broadcast must not consume a generation.
         #expect(NameVersionStore.current(authorID: authorID) == 0)
 
         withExtendedLifetime(broadcaster) {}
     }
 
     // MARK: - Per-game snapshot (game open)
 
     @Test("publishName writes only the requested shared game")
     func publishNameWritesOnlyRequestedGame() async throws {
         let p = makeTestPersistence()
         let ctx = p.viewContext
         let firstID = UUID()
         let secondID = UUID()
         for id in [firstID, secondID] {
             let entity = GameEntity(context: ctx)
             entity.id = id
             entity.title = "Shared"
             entity.puzzleSource = "## Metadata\nTitle: Shared\n"
             entity.createdAt = Date()
             entity.updatedAt = Date()
             entity.ckRecordName = RecordSerializer.recordName(forGameID: id)
             entity.ckShareRecordName = "share-\(id.uuidString)"
         }
         try ctx.save()
 
         let authorID = freshAuthorID()
         let prefs = PlayerPreferences(
             local: UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         )
         prefs.name = "Alice"
         let spy = DecisionSpy()
         var enqueued: [UUID] = []
         let broadcaster = makeBroadcaster(
             preferences: prefs, persistence: p,
             authorID: authorID, spy: spy,
             enqueuePlayer: { gameID, _, _ in enqueued.append(gameID) }
         )
 
         await broadcaster.publishName(for: secondID)
 
         #expect(enqueued == [secondID])
         #expect(fetchPlayerNames(authorID: authorID, in: p) == ["Alice"])
         // Opening a game publishes no Decisions.
         #expect(spy.decisions.isEmpty)
 
         withExtendedLifetime(broadcaster) {}
     }
 
     @Test("publishName is a no-op for a non-shared game")
     func publishNameSkipsNonSharedGame() async throws {
         let p = makeTestPersistence()
         let ctx = p.viewContext
         let gameID = UUID()
         let entity = GameEntity(context: ctx)
         entity.id = gameID
         entity.title = "Solo"
         entity.puzzleSource = ""
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.ckRecordName = RecordSerializer.recordName(forGameID: gameID)
         try ctx.save()
 
         let authorID = freshAuthorID()
         let prefs = PlayerPreferences(
             local: UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         )
         prefs.name = "Alice"
         let spy = DecisionSpy()
         let broadcaster = makeBroadcaster(
             preferences: prefs, persistence: p,
             authorID: authorID, spy: spy
         )
 
         await broadcaster.publishName(for: gameID)
 
         #expect(fetchPlayerNames(authorID: authorID, in: p).isEmpty)
 
         withExtendedLifetime(broadcaster) {}
     }
 
     // MARK: - Debounce
 
     @Test("Debounce coalesces two rapid name changes into one fan-out with the final name")
     func debounceCoalescesPair() async throws {
         let persistence = makeTestPersistence()
         let authorID = freshAuthorID()
         let prefs = PlayerPreferences(
             local: UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         )
         let spy = DecisionSpy()
         let broadcaster = makeBroadcaster(
             preferences: prefs, persistence: persistence,
             authorID: authorID, spy: spy
         )
 
         let fanOuts = FanOutSpy()
         broadcaster.onFanOutForTesting = { name in fanOuts.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 fanOuts.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(fanOuts.count == 1, "two rapid changes should debounce into one fan-out")
         #expect(fanOuts.names.last == "Bob", "the final name should win")
         // One coalesced rename → one generation, carrying the final name.
         #expect(spy.decisions.map(\.version) == [1])
         #expect(spy.decisions.first?.name == "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) }
 }