Tests/Unit/PuzzleSessionTests.swift (6304B)
1import Foundation
2import Testing
3import UIKit
4
5@testable import Crossmate
6
7@Suite("PuzzleSession", .serialized)
8@MainActor
9struct PuzzleSessionTests {
10
11
12
13 @MainActor
14 final class EffectLog {
15 private(set) var ends: [Date] = []
16 private(set) var banners = 0
17 private(set) var notes: [String] = []
18 private(set) var assertionNames: [String] = []
19 private(set) var releasedAssertions: [UIBackgroundTaskIdentifier] = []
20 private(set) var expirationHandler: (@MainActor () -> Void)?
21
22 var effects: PuzzleSession.Effects {
23 PuzzleSession.Effects(
24 publishEnd: { self.ends.append($0) },
25 postSummaryBanner: { self.banners += 1 },
26 note: { self.notes.append($0) },
27 beginBackgroundAssertion: { name, onExpiration in
28 self.assertionNames.append(name)
29 self.expirationHandler = onExpiration
30 return UIBackgroundTaskIdentifier(rawValue: self.assertionNames.count)
31 },
32 endBackgroundAssertion: { self.releasedAssertions.append($0) }
33 )
34 }
35 }
36
37 private func waitUntil(
38 timeout: Duration = .seconds(5),
39 _ condition: () -> Bool
40 ) async throws {
41 let deadline = ContinuousClock.now.advanced(by: timeout)
42 while !condition(), ContinuousClock.now < deadline {
43 try await Task.sleep(for: .milliseconds(20))
44 }
45 #expect(condition())
46 }
47
48 @Test("End push fires with the pause start captured at scheduling time")
49 func endPushFiresWithScheduledPauseStart() async throws {
50 let log = EffectLog()
51 let sleeps = ManualDebounceSleep()
52 let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
53
54 let before = Date()
55 session.scheduleEndPush(after: 30)
56 let after = Date()
57 #expect(log.assertionNames.count == 1)
58 try await sleeps.waitForSleeperCount(1)
59
60 sleeps.releaseAll()
61 try await waitUntil { log.ends.count == 1 }
62 let pauseStart = try #require(log.ends.first)
63 #expect(pauseStart >= before && pauseStart <= after)
64
65 try await waitUntil { log.releasedAssertions.count == 1 }
66 #expect(session.isIdle)
67 }
68
69 @Test("Resuming inside the end grace cancels the pause and frees the assertion")
70 func resumeInsideEndGrace() async throws {
71 let log = EffectLog()
72 let sleeps = ManualDebounceSleep()
73 let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
74
75 session.scheduleEndPush(after: 30)
76 try await sleeps.waitForSleeperCount(1)
77 #expect(session.cancelPendingEndPush())
78 #expect(log.releasedAssertions.count == 1)
79
80 sleeps.releaseAll()
81 try await Task.sleep(for: .milliseconds(120))
82 #expect(log.ends.isEmpty)
83 #expect(session.isIdle)
84 }
85
86 @Test("Assertion expiration fires the pause early, exactly once")
87 func expirationFiresEndEarlyExactlyOnce() async throws {
88 let log = EffectLog()
89 let sleeps = ManualDebounceSleep()
90 let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
91
92 session.scheduleEndPush(after: 30)
93 try await sleeps.waitForSleeperCount(1)
94
95
96 log.expirationHandler?()
97 try await waitUntil { log.ends.count == 1 }
98 #expect(log.notes.contains { $0.contains("firing early") })
99
100
101 sleeps.releaseAll()
102 try await Task.sleep(for: .milliseconds(120))
103 #expect(log.ends.count == 1)
104 try await waitUntil { log.releasedAssertions.count == 1 }
105 #expect(session.isIdle)
106 }
107
108 @Test("A direct publish supersedes the pending timer; the latch frees the assertion")
109 func supersedeDropsTimerWithoutPublishing() async throws {
110 let log = EffectLog()
111 let sleeps = ManualDebounceSleep()
112 let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
113
114 session.scheduleEndPush(after: 30)
115 try await sleeps.waitForSleeperCount(1)
116 session.supersedePendingEndPush()
117
118 sleeps.releaseAll()
119 try await Task.sleep(for: .milliseconds(120))
120 #expect(log.ends.isEmpty)
121
122
123
124 #expect(log.releasedAssertions.isEmpty)
125 #expect(!session.isIdle)
126
127
128 log.expirationHandler?()
129 #expect(log.ends.isEmpty)
130 #expect(log.releasedAssertions.count == 1)
131 #expect(session.isIdle)
132 }
133
134 @Test("Catch-up banner fires after the settle delay")
135 func bannerFiresAfterSettle() async throws {
136 let log = EffectLog()
137 let sleeps = ManualDebounceSleep()
138 let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
139
140 session.scheduleSummaryBanner(after: 3)
141 try await sleeps.waitForSleeperCount(1)
142 sleeps.releaseAll()
143 try await waitUntil { log.banners == 1 }
144 #expect(session.isIdle)
145 }
146
147 @Test("Leaving cancels a pending catch-up banner")
148 func leaveCancelsPendingBanner() async throws {
149 let log = EffectLog()
150 let sleeps = ManualDebounceSleep()
151 let session = PuzzleSession(gameID: UUID(), effects: log.effects, sleep: sleeps.sleepFn)
152
153 session.scheduleSummaryBanner(after: 3)
154 try await sleeps.waitForSleeperCount(1)
155 session.cancelPendingSummaryBanner()
156
157 sleeps.releaseAll()
158 try await Task.sleep(for: .milliseconds(120))
159 #expect(log.banners == 0)
160 #expect(session.isIdle)
161 }
162}