crossmate

TestHelpers.swift (6807B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 /// Creates a fresh PersistenceController with in-memory storage for isolated testing.
 @MainActor
 func makeTestPersistence() -> PersistenceController {
     PersistenceController(inMemory: true)
 }
 
 /// Builds a `GameStore` wired with no-op collaborators for tests that don't
 /// exercise the sync/identity/updater paths. Override only what the test needs.
 @MainActor
 func makeTestStore(
     persistence: PersistenceController,
     movesUpdater: MovesUpdater? = nil,
     authorIDProvider: @escaping @MainActor () -> String? = { nil },
     onGameCreated: @escaping (String) -> Void = { _ in },
     onGameUpdated: @escaping (String) -> Void = { _ in },
     onGameDeleted: @escaping (GameCloudDeletion) -> Void = { _ in }
 ) -> GameStore {
     let updater = movesUpdater ?? MovesUpdater(
         persistence: persistence,
         writerAuthorIDProvider: { nil },
         sink: { _, _ in }
     )
     return GameStore(
         persistence: persistence,
         movesUpdater: updater,
         authorIDProvider: authorIDProvider,
         onGameCreated: onGameCreated,
         onGameUpdated: onGameUpdated,
         onGameDeleted: onGameDeleted
     )
 }
 
 /// Test-controllable sleep: pending awaits hang until `releaseAll()`. Lets
 /// debounce-based tests verify "rapid inputs coalesce" without depending on
 /// wall-clock timing — Task.sleep on a contended simulator can wake before
 /// the next actor hop lands, racing the cancellation that should have
 /// suppressed the prior debounce task.
 ///
 /// `releaseAll()` is sticky: it opens the gate permanently, so a debounce
 /// task that only reaches its `sleep()` *after* the test called
 /// `releaseAll()` resumes immediately instead of parking forever. Without
 /// this, the live (non-cancelled) debounce task — spawned with no
 /// suspension point before `releaseAll()` — could miss the one-shot
 /// release and strand the flush, failing the test with `count → 0`.
 final class ManualDebounceSleep: @unchecked Sendable {
     private let lock = NSLock()
     private var continuations: [CheckedContinuation<Void, Never>] = []
     private var released = false
     private var sleeperCount = 0
 
     var sleepFn: @Sendable (Duration) async throws -> Void {
         { @Sendable [weak self] _ in
             await withCheckedContinuation { cont in
                 guard let self else { cont.resume(); return }
                 self.lock.lock()
                 self.sleeperCount += 1
                 if self.released {
                     self.lock.unlock()
                     cont.resume()
                     return
                 }
                 self.continuations.append(cont)
                 self.lock.unlock()
             }
         }
     }
 
     func releaseAll() {
         lock.lock()
         released = true
         let toRelease = continuations
         continuations.removeAll()
         lock.unlock()
         toRelease.forEach { $0.resume() }
     }
 
     func waitForSleeperCount(
         _ expected: Int,
         timeout: Duration = .seconds(5)
     ) async throws {
         let deadline = ContinuousClock.now.advanced(by: timeout)
         while lock.withLock({ sleeperCount }) < expected,
               ContinuousClock.now < deadline {
             try await Task.sleep(for: .milliseconds(20))
         }
     }
 }
 
 /// Creates a Game, GameEntity, and GameMutator backed by an in-memory store.
 /// The puzzle is a minimal 3x3 grid with a single block at (1,1).
 /// `movesUpdater` is nil — tests that need emission verify via MovesUpdater's own suite.
 @MainActor
 func makeTestGame() throws -> (Game, GameMutator, GameEntity, PersistenceController) {
     let persistence = makeTestPersistence()
     let context = persistence.viewContext
 
     let source = """
     Title: Test Puzzle
     Author: Test
 
 
     ABC
     D#E
     FGH
 
 
     A1. Across 1 ~ ABC
     A4. Across 4 ~ DE
     A5. Across 5 ~ FGH
     D1. Down 1 ~ ADF
     D2. Down 2 ~ BG
     D3. Down 3 ~ CEH
     """
 
     let xd = try XD.parse(source)
     let puzzle = Puzzle(xd: xd)
     let game = Game(puzzle: puzzle)
 
     let gameID = UUID()
     let entity = GameEntity(context: context)
     entity.id = gameID
     entity.title = puzzle.title
     entity.puzzleSource = source
     entity.createdAt = Date()
     entity.updatedAt = Date()
     entity.ckRecordName = "game-\(gameID.uuidString)"
 
     try context.save()
 
     let mutator = GameMutator(
         game: game,
         gameID: gameID,
         movesUpdater: nil,
         movesJournal: MovesJournal(persistence: persistence)
     )
     return (game, mutator, entity, persistence)
 }
 
 // MARK: - NotificationState test isolation
 
 /// Wraps a test (or whole suite) in an isolated `UserDefaults` suite so any
 /// `NotificationState` writes never leak to the shared App-Group store, and
 /// concurrent test suites that touch `NotificationState` can't contaminate
 /// each other. Applied via the `.isolatedNotificationState` sugar below.
 ///
 /// The trait routes the override through `NotificationState.$testingDefaults`
 /// (a `TaskLocal`), which means the scope flows naturally through actor hops
 /// and `Task` continuations the test body kicks off. Marked recursive so that
 /// applying it to a suite re-invokes `provideScope` per test rather than once
 /// around the whole suite — without that, parallel sibling tests inside one
 /// suite would share a single override and race on global `NotificationState`
 /// keys (e.g. `activePuzzleID`).
 struct IsolatedNotificationStateTrait: TestTrait, SuiteTrait, TestScoping {
     var isRecursive: Bool { true }
 
     func provideScope(
         for test: Test,
         testCase: Test.Case?,
         performing function: @Sendable () async throws -> Void
     ) async throws {
         let suiteName = "test.notif.\(UUID().uuidString)"
         guard let userDefaults = UserDefaults(suiteName: suiteName) else {
             // The standard suite is always constructable in test environments,
             // so reaching this branch indicates broken test infrastructure
             // rather than a recoverable error — run the body unscoped so the
             // failure surfaces in the assertions instead of being masked.
             try await function()
             return
         }
         defer { UserDefaults().removePersistentDomain(forName: suiteName) }
         try await NotificationState.$testingDefaults.withValue(
             NotificationState.TestingDefaults(userDefaults: userDefaults)
         ) {
             try await function()
         }
     }
 }
 
 extension Trait where Self == IsolatedNotificationStateTrait {
     /// Isolates a test or suite's `NotificationState` writes into a per-call
     /// `UserDefaults` suite. See `IsolatedNotificationStateTrait`.
     static var isolatedNotificationState: Self { IsolatedNotificationStateTrait() }
 }