crossmate

PuzzleSessionTests.swift (6304B)

---

 import Foundation
 import Testing
 import UIKit
 
 @testable import Crossmate
 
 @Suite("PuzzleSession", .serialized)
 @MainActor
 struct PuzzleSessionTests {
     /// Records every effect firing so tests can assert which pushes a given
     /// interleaving produced, and drive the background-assertion expiration
     /// handler by hand.
     @MainActor
     final class EffectLog {
         private(set) var ends: [Date] = []
         private(set) var banners = 0
         private(set) var notes: [String] = []
         private(set) var assertionNames: [String] = []
         private(set) var releasedAssertions: [UIBackgroundTaskIdentifier] = []
         private(set) var expirationHandler: (@MainActor () -> Void)?
 
         var effects: PuzzleSession.Effects {
             PuzzleSession.Effects(
                 publishEnd: { self.ends.append($0) },
                 postSummaryBanner: { self.banners += 1 },
                 note: { self.notes.append($0) },
                 beginBackgroundAssertion: { name, onExpiration in
                     self.assertionNames.append(name)
                     self.expirationHandler = onExpiration
                     return UIBackgroundTaskIdentifier(rawValue: self.assertionNames.count)
                 },
                 endBackgroundAssertion: { self.releasedAssertions.append($0) }
             )
         }
     }
 
     private func waitUntil(
         timeout: Duration = .seconds(5),
         _ condition: () -> Bool
     ) async throws {
         let deadline = ContinuousClock.now.advanced(by: timeout)
         while !condition(), ContinuousClock.now < deadline {
             try await Task.sleep(for: .milliseconds(20))
         }
         #expect(condition())
     }
 
     @Test("End push fires with the pause start captured at scheduling time")
     func endPushFiresWithScheduledPauseStart() async throws {
         let log = EffectLog()
         let sleeps = ManualDebounceSleep()
         let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
 
         let before = Date()
         session.scheduleEndPush(after: 30)
         let after = Date()
         #expect(log.assertionNames.count == 1)
         try await sleeps.waitForSleeperCount(1)
 
         sleeps.releaseAll()
         try await waitUntil { log.ends.count == 1 }
         let pauseStart = try #require(log.ends.first)
         #expect(pauseStart >= before && pauseStart <= after)
         // The assertion is released only after the publish completes.
         try await waitUntil { log.releasedAssertions.count == 1 }
         #expect(session.isIdle)
     }
 
     @Test("Resuming inside the end grace cancels the pause and frees the assertion")
     func resumeInsideEndGrace() async throws {
         let log = EffectLog()
         let sleeps = ManualDebounceSleep()
         let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
 
         session.scheduleEndPush(after: 30)
         try await sleeps.waitForSleeperCount(1)
         #expect(session.cancelPendingEndPush()) // true: this is a resume
         #expect(log.releasedAssertions.count == 1)
 
         sleeps.releaseAll()
         try await Task.sleep(for: .milliseconds(120))
         #expect(log.ends.isEmpty)
         #expect(session.isIdle)
     }
 
     @Test("Assertion expiration fires the pause early, exactly once")
     func expirationFiresEndEarlyExactlyOnce() async throws {
         let log = EffectLog()
         let sleeps = ManualDebounceSleep()
         let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
 
         session.scheduleEndPush(after: 30)
         try await sleeps.waitForSleeperCount(1)
 
         // iOS reclaims the app before the grace elapses.
         log.expirationHandler?()
         try await waitUntil { log.ends.count == 1 }
         #expect(log.notes.contains { $0.contains("firing early") })
 
         // The grace timer wakes late; the fired latch swallows it.
         sleeps.releaseAll()
         try await Task.sleep(for: .milliseconds(120))
         #expect(log.ends.count == 1)
         try await waitUntil { log.releasedAssertions.count == 1 }
         #expect(session.isIdle)
     }
 
     @Test("A direct publish supersedes the pending timer; the latch frees the assertion")
     func supersedeDropsTimerWithoutPublishing() async throws {
         let log = EffectLog()
         let sleeps = ManualDebounceSleep()
         let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
 
         session.scheduleEndPush(after: 30)
         try await sleeps.waitForSleeperCount(1)
         session.supersedePendingEndPush()
 
         sleeps.releaseAll()
         try await Task.sleep(for: .milliseconds(120))
         #expect(log.ends.isEmpty) // the timer never fires its own pause
         // The assertion is deliberately left for the expiration latch (the
         // direct publish it covers is still in flight at this point in
         // production).
         #expect(log.releasedAssertions.isEmpty)
         #expect(!session.isIdle)
 
         // The expiration latch finds no pending timer and only releases.
         log.expirationHandler?()
         #expect(log.ends.isEmpty)
         #expect(log.releasedAssertions.count == 1)
         #expect(session.isIdle)
     }
 
     @Test("Catch-up banner fires after the settle delay")
     func bannerFiresAfterSettle() async throws {
         let log = EffectLog()
         let sleeps = ManualDebounceSleep()
         let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
 
         session.scheduleSummaryBanner(after: 3)
         try await sleeps.waitForSleeperCount(1)
         sleeps.releaseAll()
         try await waitUntil { log.banners == 1 }
         #expect(session.isIdle)
     }
 
     @Test("Leaving cancels a pending catch-up banner")
     func leaveCancelsPendingBanner() async throws {
         let log = EffectLog()
         let sleeps = ManualDebounceSleep()
         let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
 
         session.scheduleSummaryBanner(after: 3)
         try await sleeps.waitForSleeperCount(1)
         session.cancelPendingSummaryBanner()
 
         sleeps.releaseAll()
         try await Task.sleep(for: .milliseconds(120))
         #expect(log.banners == 0)
         #expect(session.isIdle)
     }
 }