Tests/Unit/NotificationStateTests.swift (11700B)
1import Foundation
2import Testing
3
4@testable import Crossmate
5
6@Suite("Notification state", .isolatedNotificationState)
7struct NotificationStateTests {
8 @Test("Active puzzle stays suppressed through the leave grace, then clears")
9 func activePuzzleSuppressionClears() {
10 let gameID = UUID()
11 let base = Date(timeIntervalSince1970: 3_000_000)
12 NotificationState.setActivePuzzleID(nil)
13
14 NotificationState.setActivePuzzleID(gameID)
15 #expect(NotificationState.isActive(gameID: gameID, now: base))
16
17 NotificationState.clearActivePuzzleID(if: gameID, now: base)
18
19
20 #expect(NotificationState.isActive(gameID: gameID, now: base))
21 #expect(NotificationState.isActive(
22 gameID: gameID,
23 now: base.addingTimeInterval(NotificationState.leaveGraceWindow - 1)
24 ))
25
26 #expect(!NotificationState.isActive(
27 gameID: gameID,
28 now: base.addingTimeInterval(NotificationState.leaveGraceWindow)
29 ))
30 NotificationState.setActivePuzzleID(nil)
31 }
32
33 @Test("Clearing one puzzle does not clear another active puzzle")
34 func clearActivePuzzleRequiresMatchingID() {
35 let gameID = UUID()
36 let otherID = UUID()
37 NotificationState.setActivePuzzleID(nil)
38
39 NotificationState.setActivePuzzleID(gameID)
40 NotificationState.clearActivePuzzleID(if: otherID)
41
42 #expect(NotificationState.activePuzzleID() == gameID)
43 NotificationState.setActivePuzzleID(nil)
44 }
45
46 @Test("isSuppressed tracks the local active puzzle (and its grace tail)")
47 func suppressedTracksLocalActive() {
48 let gameID = UUID()
49 let base = Date(timeIntervalSince1970: 7_000_000)
50 NotificationState.setActivePuzzleID(nil)
51 #expect(!NotificationState.isSuppressed(gameID: gameID, now: base))
52
53 NotificationState.setActivePuzzleID(gameID)
54 #expect(NotificationState.isSuppressed(gameID: gameID, now: base))
55
56
57
58 NotificationState.clearActivePuzzleID(if: gameID, now: base)
59 #expect(NotificationState.isSuppressed(gameID: gameID, now: base))
60 #expect(!NotificationState.isSuppressed(
61 gameID: gameID,
62 now: base.addingTimeInterval(NotificationState.leaveGraceWindow)
63 ))
64 NotificationState.setActivePuzzleID(nil)
65 }
66
67 @Test("Badge ledger marks unread then seen by horizon")
68 func badgeLedgerMarksUnreadThenSeen() {
69 let gameID = UUID()
70 let unreadAt = Date(timeIntervalSince1970: 10_000)
71 let seenAt = unreadAt.addingTimeInterval(1)
72
73 #expect(BadgeState.markUnread(gameID: gameID, at: unreadAt) == 1)
74 #expect(BadgeState.unreadGameIDs() == Set([gameID]))
75
76 #expect(BadgeState.markSeen(gameID: gameID, at: seenAt) == 0)
77 #expect(BadgeState.unreadGameIDs().isEmpty)
78 }
79
80 @Test("Older unread events do not beat newer seen horizon")
81 func olderUnreadDoesNotBeatSeen() {
82 let gameID = UUID()
83 let seenAt = Date(timeIntervalSince1970: 20_000)
84 let staleUnread = seenAt.addingTimeInterval(-10)
85 let freshUnread = seenAt.addingTimeInterval(10)
86
87 #expect(BadgeState.markSeen(gameID: gameID, at: seenAt) == 0)
88 #expect(BadgeState.markUnread(gameID: gameID, at: staleUnread) == 0)
89 #expect(BadgeState.unreadGameIDs().isEmpty)
90
91 #expect(BadgeState.markUnread(gameID: gameID, at: freshUnread) == 1)
92 #expect(BadgeState.unreadGameIDs() == Set([gameID]))
93 }
94
95 @Test("A delayed completion event does not resurrect a badge after it was seen")
96 func delayedCompletionDoesNotBeatSeen() {
97 let gameID = UUID()
98 let completedAt = Date(timeIntervalSince1970: 25_000)
99 let reviewedAt = completedAt.addingTimeInterval(30)
100
101 BadgeState.markSeen(gameID: gameID, at: reviewedAt)
102
103
104
105 #expect(BadgeState.markUnread(gameID: gameID, at: completedAt) == 0)
106 #expect(BadgeState.unreadGameIDs().isEmpty)
107 }
108
109 @Test("Seeding Core Data unread surfaces games but never resurrects a seen one")
110 func seedUnreadRespectsSeenHorizon() {
111 let fresh = UUID()
112 let alreadySeen = UUID()
113 let base = Date(timeIntervalSince1970: 30_000)
114
115
116
117 BadgeState.markSeen(gameID: alreadySeen, at: base.addingTimeInterval(10))
118
119 BadgeState.seedUnread([
120 fresh: base,
121 alreadySeen: base
122 ])
123
124 #expect(BadgeState.unreadGameIDs() == Set([fresh]))
125 }
126
127 @Test("Forgetting a game drops its ledger entry so a deleted game can't badge")
128 func forgetRemovesLedgerEntry() {
129 let gameID = UUID()
130 let at = Date(timeIntervalSince1970: 40_000)
131
132 #expect(BadgeState.markUnread(gameID: gameID, at: at) == 1)
133 #expect(BadgeState.unreadGameIDs() == Set([gameID]))
134
135
136
137 BadgeState.forget(gameID: gameID)
138 #expect(BadgeState.unreadGameIDs().isEmpty)
139
140
141 #expect(BadgeState.markUnread(gameID: gameID, at: at) == 1)
142 }
143
144 @Test("A push during the suppression horizon badges once the leave collapse lands")
145 func suppressionCollapseResurrectsPostLeavePush() {
146 let gameID = UUID()
147 let open = Date(timeIntervalSince1970: 60_000)
148 let lease = open.addingTimeInterval(600)
149 let leave = open.addingTimeInterval(120)
150 let push = open.addingTimeInterval(300)
151
152
153
154 BadgeState.adoptReadHorizon(gameID: gameID, horizon: lease, now: open)
155
156
157 #expect(BadgeState.markUnread(gameID: gameID, at: push) == 0)
158 #expect(BadgeState.unreadGameIDs().isEmpty)
159
160
161
162
163
164 BadgeState.markSeen(gameID: gameID, at: leave)
165 BadgeState.collapseSuppression(gameID: gameID, to: leave)
166 #expect(BadgeState.unreadGameIDs() == Set([gameID]))
167 }
168
169 @Test("A push the user actually watched stays cleared after the collapse")
170 func suppressionCollapseKeepsWatchedPushCleared() {
171 let gameID = UUID()
172 let open = Date(timeIntervalSince1970: 70_000)
173 let lease = open.addingTimeInterval(600)
174 let push = open.addingTimeInterval(60)
175 let leave = open.addingTimeInterval(120)
176
177 BadgeState.adoptReadHorizon(gameID: gameID, horizon: lease, now: open)
178 #expect(BadgeState.markUnread(gameID: gameID, at: push) == 0)
179
180
181
182 BadgeState.markSeen(gameID: gameID, at: leave)
183 BadgeState.collapseSuppression(gameID: gameID, to: leave)
184 #expect(BadgeState.unreadGameIDs().isEmpty)
185 }
186
187 @Test("adoptReadHorizon never forward-dates the seen watermark")
188 func adoptReadHorizonClampsWatermark() {
189 let gameID = UUID()
190 let now = Date(timeIntervalSince1970: 80_000)
191 let lease = now.addingTimeInterval(600)
192
193 BadgeState.adoptReadHorizon(gameID: gameID, horizon: lease, now: now)
194
195
196
197
198 BadgeState.collapseSuppression(gameID: gameID, to: now)
199 #expect(BadgeState.markUnread(gameID: gameID, at: now.addingTimeInterval(10)) == 1)
200 #expect(BadgeState.unreadGameIDs() == Set([gameID]))
201 }
202
203 @Test("A stale lease arriving late cannot shorten an extended suppression")
204 func extendSuppressionIsMonotonic() {
205 let gameID = UUID()
206 let base = Date(timeIntervalSince1970: 90_000)
207
208 BadgeState.extendSuppression(gameID: gameID, until: base.addingTimeInterval(600))
209
210
211 BadgeState.extendSuppression(gameID: gameID, until: base.addingTimeInterval(300))
212
213 #expect(BadgeState.markUnread(gameID: gameID, at: base.addingTimeInterval(400)) == 0)
214 #expect(BadgeState.unreadGameIDs().isEmpty)
215
216 BadgeState.collapseSuppression(gameID: gameID, to: base.addingTimeInterval(300))
217 #expect(BadgeState.unreadGameIDs() == Set([gameID]))
218 }
219
220 @Test("Collapsing suppression for an unknown game leaves the ledger clean")
221 func collapseSuppressionWithoutEntryIsNoOp() {
222 let gameID = UUID()
223 BadgeState.collapseSuppression(gameID: gameID, to: Date(timeIntervalSince1970: 95_000))
224 #expect(BadgeState.unreadGameIDs().isEmpty)
225
226
227 #expect(BadgeState.markUnread(gameID: gameID, at: Date(timeIntervalSince1970: 95_100)) == 1)
228 }
229
230 @Test("Pending invites round-trip and overwrite wholesale")
231 func pendingInvitesOverwrite() {
232 let first = UUID()
233 let second = UUID()
234
235 BadgeState.setPendingInvites([first])
236 #expect(BadgeState.pendingInviteGameIDs() == Set([first]))
237
238
239
240 BadgeState.setPendingInvites([second])
241 #expect(BadgeState.pendingInviteGameIDs() == Set([second]))
242
243
244 BadgeState.setPendingInvites([])
245 #expect(BadgeState.pendingInviteGameIDs().isEmpty)
246 }
247
248 @Test("Pending invites are independent of the unread-moves ledger")
249 func pendingInvitesIndependentOfLedger() {
250 let move = UUID()
251 let invite = UUID()
252 let at = Date(timeIntervalSince1970: 50_000)
253
254 BadgeState.markUnread(gameID: move, at: at)
255 BadgeState.setPendingInvites([invite])
256
257
258 #expect(BadgeState.unreadGameIDs().union(BadgeState.pendingInviteGameIDs())
259 == Set([move, invite]))
260
261
262 BadgeState.setPendingInvites([])
263 #expect(BadgeState.unreadGameIDs() == Set([move]))
264 }
265
266 @Test("Reset clears pending invites alongside the ledger")
267 func resetClearsPendingInvites() {
268 BadgeState.markUnread(gameID: UUID())
269 BadgeState.setPendingInvites([UUID()])
270
271 BadgeState.reset()
272 #expect(BadgeState.unreadGameIDs().isEmpty)
273 #expect(BadgeState.pendingInviteGameIDs().isEmpty)
274 }
275}