crossmate

GamePlayerColorStoreTests.swift (8173B)

---

 import CloudKit
 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("GamePlayerColorStore")
 @MainActor
 struct GamePlayerColorStoreTests {
 
     private func makeStore() -> GamePlayerColorStore {
         // Use a fresh UserDefaults suite per test to avoid cross-test pollution.
         let suiteName = "test-\(UUID().uuidString)"
         let defaults = UserDefaults(suiteName: suiteName)!
         return GamePlayerColorStore(defaults: defaults)
     }
 
     // MARK: - ensureColor
 
     @Test("ensureColor on empty store picks a palette entry and persists it")
     func ensureColorPersists() {
         let store = makeStore()
         let gameID = UUID()
         let color = store.ensureColor(forGame: gameID, authorID: "_A", reservedColorIDs: [])
         #expect(PlayerColor.palette.contains(color))
         // Second call returns the same colour.
         let again = store.ensureColor(forGame: gameID, authorID: "_A", reservedColorIDs: [])
         #expect(again.id == color.id)
     }
 
     @Test("ensureColor never returns a reserved colour when alternatives exist")
     func ensureColorRespectsReserved() {
         let store = makeStore()
         let gameID = UUID()
         // Reserve all colours except the last one.
         let reserved = Set(PlayerColor.palette.dropLast().map { $0.id })
         let color = store.ensureColor(forGame: gameID, authorID: "_A", reservedColorIDs: reserved)
         #expect(!reserved.contains(color.id))
         #expect(color.id == PlayerColor.palette.last!.id)
     }
 
     @Test("ensureColor with seeded RNG is deterministic")
     func ensureColorSeededRNG() {
         let store = makeStore()
         let gameID = UUID()
         var rng = SeededRNG(seed: 42)
         let c1 = store.ensureColor(forGame: gameID, authorID: "_A", reservedColorIDs: [], using: &rng)
 
         let store2 = makeStore()
         var rng2 = SeededRNG(seed: 42)
         let c2 = store2.ensureColor(forGame: gameID, authorID: "_A", reservedColorIDs: [], using: &rng2)
 
         #expect(c1.id == c2.id)
     }
 
     @Test("ensureColor with palette fully saturated falls back to a palette entry")
     func ensureColorFallback() {
         let store = makeStore()
         let gameID = UUID()
         // Assign all palette colours to other authors for this game.
         for (i, color) in PlayerColor.palette.enumerated() {
             store.setColor(color, forGame: gameID, authorID: "_other\(i)")
         }
         // All colours are assigned; ensureColor should still return something.
         let reserved = Set(PlayerColor.palette.map { $0.id })
         var rng = SeededRNG(seed: 99)
         let fallback = store.ensureColor(
             forGame: gameID,
             authorID: "_new",
             reservedColorIDs: reserved,
             using: &rng
         )
         #expect(PlayerColor.palette.contains(fallback))
     }
 
     @Test("ensureColor persists without posting a change notification")
     func ensureColorDoesNotPostChangeNotification() {
         let store = makeStore()
         let gameID = UUID()
         var notificationCount = 0
         let observer = NotificationCenter.default.addObserver(
             forName: .gamePlayerColorsChanged,
             object: nil,
             queue: nil
         ) { note in
             guard let id = note.userInfo?["gameID"] as? UUID, id == gameID else { return }
             notificationCount += 1
         }
         defer { NotificationCenter.default.removeObserver(observer) }
 
         _ = store.ensureColor(forGame: gameID, authorID: "_A", reservedColorIDs: [])
 
         #expect(notificationCount == 0)
     }
 
     // MARK: - setColor / color round-trip
 
     @Test("setColor and color round-trip correctly")
     func setColorRoundTrip() {
         let store = makeStore()
         let gameID = UUID()
         store.setColor(.red, forGame: gameID, authorID: "_A")
         #expect(store.color(forGame: gameID, authorID: "_A")?.id == PlayerColor.red.id)
     }
 
     @Test("color returns nil for unknown authorID")
     func colorNilForUnknown() {
         let store = makeStore()
         #expect(store.color(forGame: UUID(), authorID: "_unknown") == nil)
     }
 
     // MARK: - clearColors / clearColor
 
     @Test("clearColors removes all entries for a game")
     func clearColorsRemovesAll() {
         let store = makeStore()
         let gameID = UUID()
         store.setColor(.red, forGame: gameID, authorID: "_A")
         store.setColor(.blue, forGame: gameID, authorID: "_B")
         store.clearColors(forGame: gameID)
         #expect(store.color(forGame: gameID, authorID: "_A") == nil)
         #expect(store.color(forGame: gameID, authorID: "_B") == nil)
     }
 
     @Test("clearColor removes only the targeted author")
     func clearColorScopedToAuthor() {
         let store = makeStore()
         let gameID = UUID()
         store.setColor(.red, forGame: gameID, authorID: "_A")
         store.setColor(.blue, forGame: gameID, authorID: "_B")
         store.clearColor(forGame: gameID, authorID: "_A")
         #expect(store.color(forGame: gameID, authorID: "_A") == nil)
         #expect(store.color(forGame: gameID, authorID: "_B")?.id == PlayerColor.blue.id)
     }
 
     @Test("clearColors for one game does not affect another game")
     func clearColorsGameScoped() {
         let store = makeStore()
         let g1 = UUID()
         let g2 = UUID()
         store.setColor(.red, forGame: g1, authorID: "_A")
         store.setColor(.blue, forGame: g2, authorID: "_A")
         store.clearColors(forGame: g1)
         #expect(store.color(forGame: g2, authorID: "_A")?.id == PlayerColor.blue.id)
     }
 
     // MARK: - assignedColorIDs
 
     @Test("assignedColorIDs returns IDs of all assigned colours for a game")
     func assignedColorIDsAll() {
         let store = makeStore()
         let gameID = UUID()
         store.setColor(.red, forGame: gameID, authorID: "_A")
         store.setColor(.blue, forGame: gameID, authorID: "_B")
         let ids = store.assignedColorIDs(forGame: gameID, excludingAuthorID: nil)
         #expect(ids == ["red", "blue"])
     }
 
     @Test("assignedColorIDs excludes the specified authorID")
     func assignedColorIDsExcludes() {
         let store = makeStore()
         let gameID = UUID()
         store.setColor(.red, forGame: gameID, authorID: "_A")
         store.setColor(.blue, forGame: gameID, authorID: "_B")
         let ids = store.assignedColorIDs(forGame: gameID, excludingAuthorID: "_A")
         #expect(ids == ["blue"])
         #expect(!ids.contains("red"))
     }
 
     // MARK: - Color cleanup on game deletion
 
     @Test("Color store is cleared when a game is deleted via onGameDeleted")
     func colorStoreCleanupOnGameDelete() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.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 = "game-\(gameID.uuidString)"
         try ctx.save()
 
         let colorStore = makeStore()
         colorStore.setColor(.red, forGame: gameID, authorID: "_A")
         colorStore.setColor(.blue, forGame: gameID, authorID: "_B")
 
         // Use the production factory so this test fails if the real wiring
         // ever drops the colour-cleanup branch.
         let container = CKContainer(identifier: "iCloud.net.inqk.crossmate.v3")
         let syncEngine = SyncEngine(container: container, persistence: persistence)
         let store = makeTestStore(
             persistence: persistence,
             onGameDeleted: AppServices.makeOnGameDeleted(
                 syncEngine: syncEngine,
                 colorStore: colorStore
             )
         )
 
         try store.deleteGame(id: gameID)
 
         #expect(colorStore.storedAuthorIDs(forGame: gameID).isEmpty)
     }
 }
 
 // Minimal seeded RNG for deterministic tests.
 private struct SeededRNG: RandomNumberGenerator {
     private var state: UInt64
 
     init(seed: UInt64) { state = seed }
 
     mutating func next() -> UInt64 {
         state = state &* 6364136223846793005 &+ 1442695040888963407
         return state
     }
 }