Tests/Unit/GameStorePushAddressTests.swift (13786B)
1import CloudKit
2import CoreData
3import Foundation
4import Testing
5
6@testable import Crossmate
7
8
9
10
11
12
13
14
15@Suite("GameStore push addressing", .isolatedNotificationState)
16@MainActor
17struct GameStorePushAddressTests {
18
19 private static let authorID = "alice"
20 private static let secret = "test-secret-0123456789"
21 private static let puzzleSource = """
22 Title: Test Puzzle
23 Author: Test
24
25
26 AB
27 CD
28
29
30 A1. Top row ~ AB
31 A3. Bottom row ~ CD
32
33 D1. Left column ~ AC
34 D2. Right column ~ BD
35 """
36
37 @discardableResult
38 private func makeGame(
39 scope: Int16,
40 in ctx: NSManagedObjectContext
41 ) throws -> UUID {
42 let gameID = UUID()
43 let entity = GameEntity(context: ctx)
44 entity.id = gameID
45 entity.title = "Test"
46 entity.puzzleSource = Self.puzzleSource
47 entity.createdAt = Date()
48 entity.updatedAt = Date()
49 entity.ckRecordName = "game-\(gameID.uuidString)"
50 entity.ckZoneName = "game-\(gameID.uuidString)"
51 entity.databaseScope = scope
52 try ctx.save()
53 return gameID
54 }
55
56
57
58 private func makeStalePlayerRow(
59 gameID: UUID,
60 address: String,
61 in ctx: NSManagedObjectContext
62 ) throws {
63 let req = NSFetchRequest<GameEntity>(entityName: "GameEntity")
64 req.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
65 req.fetchLimit = 1
66 let game = try #require(try ctx.fetch(req).first)
67 let player = PlayerEntity(context: ctx)
68 player.game = game
69 player.authorID = Self.authorID
70 player.name = "alice"
71 player.ckRecordName = RecordSerializer.recordName(
72 forPlayerInGame: gameID,
73 authorID: Self.authorID
74 )
75 player.pushAddress = address
76 player.updatedAt = Date()
77 try ctx.save()
78 }
79
80 private func playerRowCount(in ctx: NSManagedObjectContext) throws -> Int {
81 try ctx.count(for: NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity"))
82 }
83
84 private func playerRow(gameID: UUID, in ctx: NSManagedObjectContext) throws -> PlayerEntity {
85 let req = NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity")
86 req.predicate = NSPredicate(
87 format: "game.id == %@ AND authorID == %@",
88 gameID as CVarArg,
89 Self.authorID
90 )
91 req.fetchLimit = 1
92 return try #require(try ctx.fetch(req).first)
93 }
94
95
96
97 @Test("deriveGameAddress is deterministic, URL-safe, and per-game/per-secret distinct")
98 func derivationProperties() {
99 let g1 = UUID()
100 let g2 = UUID()
101
102 let a1 = RecordSerializer.deriveGameAddress(secret: Self.secret, gameID: g1)
103 let a1Again = RecordSerializer.deriveGameAddress(secret: Self.secret, gameID: g1)
104 let a2 = RecordSerializer.deriveGameAddress(secret: Self.secret, gameID: g2)
105 let a1OtherSecret = RecordSerializer.deriveGameAddress(secret: "other-secret", gameID: g1)
106
107 #expect(a1 == a1Again)
108 #expect(a1 != a2)
109 #expect(a1 != a1OtherSecret)
110 #expect(!a1.isEmpty)
111
112 let allowed = CharacterSet(charactersIn:
113 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")
114 #expect(a1.unicodeScalars.allSatisfy(allowed.contains))
115 }
116
117
118
119 @Test("setPushAddress stamps the derived address and is stable")
120 func setPushAddressDerivesStably() throws {
121 let persistence = makeTestPersistence()
122 let store = makeTestStore(persistence: persistence)
123 let gameID = try makeGame(scope: 1, in: persistence.viewContext)
124
125 let expected = RecordSerializer.deriveGameAddress(secret: Self.secret, gameID: gameID)
126 let first = try #require(
127 store.setPushAddress(gameID: gameID, authorID: Self.authorID, secret: Self.secret)
128 )
129 #expect(first == expected)
130 let second = try #require(
131 store.setPushAddress(gameID: gameID, authorID: Self.authorID, secret: Self.secret)
132 )
133 #expect(second == first)
134 }
135
136 @Test("setPushAddress returns nil when the game is missing")
137 func setPushAddressMissingGame() {
138 let persistence = makeTestPersistence()
139 let store = makeTestStore(persistence: persistence)
140 #expect(
141 store.setPushAddress(gameID: UUID(), authorID: Self.authorID, secret: Self.secret) == nil
142 )
143 }
144
145
146
147 @Test("reconcile derives shared games only, and never fabricates a Player row")
148 func reconcileDerivesSharedGamesWithoutFabricating() throws {
149 let persistence = makeTestPersistence()
150 let store = makeTestStore(persistence: persistence)
151 let shared1 = try makeGame(scope: 1, in: persistence.viewContext)
152 let shared2 = try makeGame(scope: 1, in: persistence.viewContext)
153 _ = try makeGame(scope: 0, in: persistence.viewContext)
154
155 let result = store.reconcileLocalPushAddresses(authorID: Self.authorID, secret: Self.secret)
156
157
158
159 #expect(Set(result.bindings.map(\.address)) == [
160 RecordSerializer.deriveGameAddress(secret: Self.secret, gameID: shared1),
161 RecordSerializer.deriveGameAddress(secret: Self.secret, gameID: shared2)
162 ])
163
164
165 #expect(result.bindings.allSatisfy { $0.credentials != nil })
166 #expect(GamePushCredentials.decode(store.notification(for: shared1)) != nil)
167
168
169 #expect(result.republishGameIDs.isEmpty)
170 #expect(try playerRowCount(in: persistence.viewContext) == 0)
171 }
172
173 @Test("reconcile mirrors freshly-minted content keys for the notification extension")
174 func reconcileMirrorsMintedContentKeys() async throws {
175 let url = FileManager.default.temporaryDirectory
176 .appendingPathComponent("content-key-directory-\(UUID().uuidString).json")
177 defer { try? FileManager.default.removeItem(at: url) }
178
179 try await ContentKeyDirectory.$testingFileURL.withValue(url) {
180 try await MainActor.run {
181 let persistence = makeTestPersistence()
182 let store = makeTestStore(persistence: persistence)
183 let gameID = try makeGame(scope: 1, in: persistence.viewContext)
184
185 #expect(ContentKeyDirectory.load().isEmpty)
186
187 let result = store.reconcileLocalPushAddresses(
188 authorID: Self.authorID,
189 secret: Self.secret
190 )
191 let credentials = try #require(result.bindings.first?.credentials)
192 let contentKey = try #require(credentials.contentKey)
193
194 #expect(ContentKeyDirectory.load()[gameID.uuidString] == contentKey)
195 }
196 }
197 }
198
199 @Test("reconcile migrates a stale row to the derived address and lists it")
200 func reconcileMigratesStaleRow() throws {
201 let persistence = makeTestPersistence()
202 let store = makeTestStore(persistence: persistence)
203 let gameID = try makeGame(scope: 1, in: persistence.viewContext)
204 try makeStalePlayerRow(
205 gameID: gameID,
206 address: "stale-minted-token",
207 in: persistence.viewContext
208 )
209
210 let derived = RecordSerializer.deriveGameAddress(secret: Self.secret, gameID: gameID)
211 let first = store.reconcileLocalPushAddresses(authorID: Self.authorID, secret: Self.secret)
212 #expect(first.bindings.map(\.address) == [derived])
213 #expect(first.republishGameIDs == [gameID])
214
215 let player = try #require(
216 persistence.viewContext.registeredObjects
217 .compactMap { $0 as? PlayerEntity }
218 .first
219 )
220 #expect(player.pushAddress == derived)
221
222 #expect(player.name == "alice")
223
224
225 let second = store.reconcileLocalPushAddresses(authorID: Self.authorID, secret: Self.secret)
226 #expect(second.bindings.map(\.address) == [derived])
227 #expect(second.republishGameIDs.isEmpty)
228
229 let firstCred = try #require(first.bindings.first?.credentials)
230 let secondCred = try #require(second.bindings.first?.credentials)
231 #expect(firstCred.credID == secondCred.credID)
232 #expect(firstCred.secret == secondCred.secret)
233 }
234
235 @Test("reconcile can refresh bindings without republishing stale Player rows")
236 func reconcileCanSkipPlayerRepublish() throws {
237 let persistence = makeTestPersistence()
238 let store = makeTestStore(persistence: persistence)
239 let gameID = try makeGame(scope: 1, in: persistence.viewContext)
240 try makeStalePlayerRow(
241 gameID: gameID,
242 address: "stale-minted-token",
243 in: persistence.viewContext
244 )
245
246 let derived = RecordSerializer.deriveGameAddress(secret: Self.secret, gameID: gameID)
247 let result = store.reconcileLocalPushAddresses(
248 authorID: Self.authorID,
249 secret: Self.secret,
250 republishPlayerRows: false
251 )
252
253 #expect(result.bindings.map(\.address) == [derived])
254 #expect(result.republishGameIDs.isEmpty)
255 #expect(try playerRow(gameID: gameID, in: persistence.viewContext).pushAddress == "stale-minted-token")
256 #expect(GamePushCredentials.decode(store.notification(for: gameID)) != nil)
257 }
258
259
260
261 @Test("ensurePushCredentials mints once for a shared game and is stable")
262 func ensurePushCredentialsMintsStably() throws {
263 let persistence = makeTestPersistence()
264 let store = makeTestStore(persistence: persistence)
265 let gameID = try makeGame(scope: 1, in: persistence.viewContext)
266
267 let first = try #require(store.ensurePushCredentials(for: gameID))
268 let second = try #require(store.ensurePushCredentials(for: gameID))
269 #expect(first == second)
270
271 #expect(Data(base64URLEncoded: first.secret)?.count == 32)
272 }
273
274 @Test("constructJoinedGame seeds the invite-carried notification credential")
275 func constructJoinedGameSeedsNotificationCredential() async throws {
276 let url = FileManager.default.temporaryDirectory
277 .appendingPathComponent("joined-game-content-key-\(UUID().uuidString).json")
278 defer { try? FileManager.default.removeItem(at: url) }
279
280 try await ContentKeyDirectory.$testingFileURL.withValue(url) {
281 try await MainActor.run {
282 let persistence = makeTestPersistence()
283 let store = makeTestStore(persistence: persistence)
284 let gameID = UUID()
285 let credentials = try GamePushCredentials.fresh()
286 let encoded = try credentials.encoded()
287 let zoneID = CKRecordZone.ID(
288 zoneName: "game-\(gameID.uuidString)",
289 ownerName: "_owner"
290 )
291
292 try store.constructJoinedGame(
293 gameID: gameID,
294 zoneID: zoneID,
295 source: Self.puzzleSource,
296 notification: encoded
297 )
298
299 #expect(store.notification(for: gameID) == encoded)
300 #expect(ContentKeyDirectory.load()[gameID.uuidString] == credentials.contentKey)
301 }
302 }
303 }
304
305 @Test("ensurePushCredentials returns nil for a non-shared or missing game")
306 func ensurePushCredentialsNonShared() throws {
307 let persistence = makeTestPersistence()
308 let store = makeTestStore(persistence: persistence)
309 let localOnly = try makeGame(scope: 0, in: persistence.viewContext)
310 #expect(store.ensurePushCredentials(for: localOnly) == nil)
311 #expect(store.ensurePushCredentials(for: UUID()) == nil)
312 }
313
314 @Test("deleteGame requests a push registration refresh")
315 func deleteGameRequestsPushRegistrationRefresh() throws {
316 let persistence = makeTestPersistence()
317 let store = makeTestStore(persistence: persistence)
318 let gameID = try makeGame(scope: 1, in: persistence.viewContext)
319 var refreshCount = 0
320 store.onPushRegistrationMayNeedRefresh = {
321 refreshCount += 1
322 }
323
324 try store.deleteGame(id: gameID)
325
326 #expect(refreshCount == 1)
327 }
328}