crossmate

PlayerRosterTests.swift (7541B)

---

 import CloudKit
 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("PlayerRoster")
 @MainActor
 struct PlayerRosterTests {
 
     // MARK: - Helpers
 
     private func makePersistenceWithGame() throws -> (PersistenceController, UUID) {
         let p = makeTestPersistence()
         let ctx = p.viewContext
         let gameID = UUID()
         let entity = GameEntity(context: ctx)
         entity.id = gameID
         entity.title = "Test"
         entity.puzzleSource = ""
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.ckRecordName = RecordSerializer.recordName(forGameID: gameID)
         // No ckZoneName — prevents the roster from attempting a CloudKit share fetch.
         try ctx.save()
         return (p, gameID)
     }
 
     private func addMoves(
         authorIDs: [String],
         gameID: UUID,
         persistence: PersistenceController
     ) {
         let ctx = persistence.viewContext
         let req = NSFetchRequest<GameEntity>(entityName: "GameEntity")
         req.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
         guard let game = try? ctx.fetch(req).first else { return }
         for (i, authorID) in authorIDs.enumerated() {
             // Each MovesEntity row is per-(game, author, device); for the
             // roster's purposes the per-cell content is irrelevant — only the
             // `authorID` matters. Synthesise a unique deviceID per row.
             let deviceID = "test-device-\(i)"
             let entity = MovesEntity(context: ctx)
             entity.game = game
             entity.authorID = authorID
             entity.deviceID = deviceID
             entity.cells = Data()
             entity.updatedAt = Date()
             entity.ckRecordName = RecordSerializer.recordName(
                 forMovesInGame: gameID,
                 authorID: authorID,
                 deviceID: deviceID
             )
         }
         try? ctx.save()
     }
 
     private func addPlayerEntity(
         authorID: String,
         name: String,
         gameID: UUID,
         persistence: PersistenceController
     ) {
         let ctx = persistence.viewContext
         let req = NSFetchRequest<GameEntity>(entityName: "GameEntity")
         req.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
         guard let game = try? ctx.fetch(req).first else { return }
         let player = PlayerEntity(context: ctx)
         player.game = game
         player.authorID = authorID
         player.name = name
         player.ckRecordName = RecordSerializer.recordName(forPlayerInGame: gameID, authorID: authorID)
         player.updatedAt = Date()
         try? ctx.save()
     }
 
     private func makeRoster(
         gameID: UUID,
         persistence: PersistenceController,
         colorStore: GamePlayerColorStore? = nil,
         preferences: PlayerPreferences? = nil
     ) -> PlayerRoster {
         let store = colorStore ?? GamePlayerColorStore(
             defaults: UserDefaults(suiteName: "test-cs-\(UUID().uuidString)")!
         )
         let prefs = preferences ?? PlayerPreferences(
             local: UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         )
         let container = CKContainer(identifier: "iCloud.net.inqk.crossmate.v3")
         return PlayerRoster(
             gameID: gameID,
             colorStore: store,
             authorIdentity: AuthorIdentity(testing: "_Local"),
             preferences: prefs,
             persistence: persistence,
             container: container
         )
     }
 
     // MARK: - Tests
 
     @Test("Three remote participants are assigned distinct colors, none matching local")
     func threeParticipantsGetDistinctColors() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         addMoves(authorIDs: ["_B", "_C", "_D"], gameID: gameID, persistence: persistence)
 
         let colorStore = GamePlayerColorStore(
             defaults: UserDefaults(suiteName: "test-cs-\(UUID().uuidString)")!
         )
         let prefsDefaults = UserDefaults(suiteName: "test-pref-\(UUID().uuidString)")!
         let prefs = PlayerPreferences(local: prefsDefaults)
 
         let roster = makeRoster(
             gameID: gameID,
             persistence: persistence,
             colorStore: colorStore,
             preferences: prefs
         )
         await roster.refresh()
 
         #expect(roster.entries.count == 4) // 1 local + 3 remote
         let allColorIDs = roster.entries.map { $0.color.id }
         #expect(Set(allColorIDs).count == 4, "all four participants should have distinct colors")
         let remoteColorIDs = roster.entries.filter { !$0.isLocal }.map { $0.color.id }
         #expect(!remoteColorIDs.contains(prefs.color.id), "remote colors should not collide with local")
     }
 
     @Test("Stale color entries are GC'd after refresh")
     func staleColorEntriesAreGCd() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         addMoves(authorIDs: ["_B"], gameID: gameID, persistence: persistence)
 
         let colorStore = GamePlayerColorStore(
             defaults: UserDefaults(suiteName: "test-cs-\(UUID().uuidString)")!
         )
         colorStore.setColor(.red, forGame: gameID, authorID: "_B")
         colorStore.setColor(.green, forGame: gameID, authorID: "_Stale")
 
         let roster = makeRoster(gameID: gameID, persistence: persistence, colorStore: colorStore)
         await roster.refresh()
 
         #expect(colorStore.color(forGame: gameID, authorID: "_B") != nil, "_B should be kept")
         #expect(colorStore.color(forGame: gameID, authorID: "_Stale") == nil, "_Stale should be GC'd")
     }
 
     @Test("Entry name comes from PlayerEntity when available")
     func entryNameFromPlayerEntity() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         addMoves(authorIDs: ["_B"], gameID: gameID, persistence: persistence)
         addPlayerEntity(authorID: "_B", name: "Alice", gameID: gameID, persistence: persistence)
 
         let roster = makeRoster(gameID: gameID, persistence: persistence)
         await roster.refresh()
 
         let remote = roster.entries.first { !$0.isLocal }
         #expect(remote?.name == "Alice")
     }
 
     @Test("Entry name waits for PlayerEntity when no game-specific name has arrived")
     func entryNameWaitsForPlayerEntity() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         addMoves(authorIDs: ["_B"], gameID: gameID, persistence: persistence)
         // No PlayerEntity for "_B".
 
         let roster = makeRoster(gameID: gameID, persistence: persistence)
         await roster.refresh()
 
         let remote = roster.entries.first { !$0.isLocal }
         #expect(remote?.name == "Waiting for player...")
     }
 
     @Test("Current user placeholder is not shown as a remote player")
     func currentUserPlaceholderIsHidden() async throws {
         let (persistence, gameID) = try makePersistenceWithGame()
         addMoves(
             authorIDs: [CKCurrentUserDefaultName, "_B"],
             gameID: gameID,
             persistence: persistence
         )
         addPlayerEntity(
             authorID: CKCurrentUserDefaultName,
             name: "Ghost",
             gameID: gameID,
             persistence: persistence
         )
 
         let roster = makeRoster(gameID: gameID, persistence: persistence)
         await roster.refresh()
 
         #expect(!roster.entries.contains { $0.authorID == CKCurrentUserDefaultName })
         #expect(roster.entries.map(\.authorID).contains("_B"))
     }
 }