Tests/Unit/Sync/ShareRoutingTests.swift (14077B)
1import CloudKit
2import CoreData
3import Foundation
4import Testing
5
6@testable import Crossmate
7
8
9
10
11
12
13@Suite("ShareRouting", .serialized)
14@MainActor
15struct ShareRoutingTests {
16
17 private static let writerAuthorID = "alice"
18
19 private func makeEngineWithGames() async throws -> (SyncEngine, UUID, UUID) {
20 let persistence = makeTestPersistence()
21 let ctx = persistence.viewContext
22
23 let privateID = UUID()
24 let privateEntity = GameEntity(context: ctx)
25 privateEntity.id = privateID
26 privateEntity.title = "Private"
27 privateEntity.puzzleSource = ""
28 privateEntity.createdAt = Date()
29 privateEntity.updatedAt = Date()
30 privateEntity.ckRecordName = "game-\(privateID.uuidString)"
31 privateEntity.ckZoneName = "game-\(privateID.uuidString)"
32 privateEntity.databaseScope = 0
33 Self.seedMovesEntity(for: privateEntity, gameID: privateID, in: ctx)
34
35 let sharedID = UUID()
36 let sharedEntity = GameEntity(context: ctx)
37 sharedEntity.id = sharedID
38 sharedEntity.title = "Shared"
39 sharedEntity.puzzleSource = ""
40 sharedEntity.createdAt = Date()
41 sharedEntity.updatedAt = Date()
42 sharedEntity.ckRecordName = "game-\(sharedID.uuidString)"
43 sharedEntity.ckZoneName = "game-\(sharedID.uuidString)"
44 sharedEntity.ckZoneOwnerName = "_someOtherUser"
45 sharedEntity.databaseScope = 1
46 Self.seedMovesEntity(for: sharedEntity, gameID: sharedID, in: ctx)
47
48 try ctx.save()
49
50 let container = CloudContainer.container
51 let engine = SyncEngine(container: container, persistence: persistence)
52 await engine.start()
53
54 return (engine, privateID, sharedID)
55 }
56
57
58
59
60
61
62
63 private static func seedMovesEntity(
64 for game: GameEntity,
65 gameID: UUID,
66 in ctx: NSManagedObjectContext,
67 confirmed: Bool = false,
68 authorID: String = writerAuthorID
69 ) {
70 let entity = MovesEntity(context: ctx)
71 entity.game = game
72 entity.authorID = authorID
73 entity.deviceID = RecordSerializer.localDeviceID
74 entity.cells = Data()
75 entity.updatedAt = Date()
76 entity.ckRecordName = RecordSerializer.recordName(
77 forMovesInGame: gameID,
78 authorID: authorID,
79 deviceID: RecordSerializer.localDeviceID
80 )
81 if confirmed {
82 entity.ckSystemFields = Data([0xff])
83 }
84 }
85
86 private func makeEngineWithPersistedMove() async throws -> (SyncEngine, UUID) {
87 let persistence = makeTestPersistence()
88 let ctx = persistence.viewContext
89
90 let gameID = UUID()
91 let game = GameEntity(context: ctx)
92 game.id = gameID
93 game.title = "Private"
94 game.puzzleSource = ""
95 game.createdAt = Date()
96 game.updatedAt = Date()
97 game.ckRecordName = "game-\(gameID.uuidString)"
98 game.ckZoneName = "game-\(gameID.uuidString)"
99 game.databaseScope = 0
100
101
102 Self.seedMovesEntity(for: game, gameID: gameID, in: ctx)
103
104 try ctx.save()
105
106 let container = CloudContainer.container
107 let engine = SyncEngine(container: container, persistence: persistence)
108 await engine.start()
109
110 return (engine, gameID)
111 }
112
113 private func movesRecordName(for gameID: UUID) -> String {
114 RecordSerializer.recordName(
115 forMovesInGame: gameID,
116 authorID: Self.writerAuthorID,
117 deviceID: RecordSerializer.localDeviceID
118 )
119 }
120
121 @Test("Private-game moves land on the private engine only")
122 func privateMoveEnqueue() async throws {
123 let (engine, privateID, _) = try await makeEngineWithGames()
124 await engine.enqueueMoves(gameIDs: [privateID])
125
126 let privateNames = await engine.pendingSaveRecordNames(scope: .private)
127 let sharedNames = await engine.pendingSaveRecordNames(scope: .shared)
128
129 #expect(privateNames.contains(movesRecordName(for: privateID)))
130 #expect(sharedNames.isEmpty)
131 }
132
133 @Test("Shared-game moves land on the shared engine only")
134 func sharedMoveEnqueue() async throws {
135 let (engine, _, sharedID) = try await makeEngineWithGames()
136 await engine.enqueueMoves(gameIDs: [sharedID])
137
138 let privateNames = await engine.pendingSaveRecordNames(scope: .private)
139 let sharedNames = await engine.pendingSaveRecordNames(scope: .shared)
140
141 #expect(sharedNames.contains(movesRecordName(for: sharedID)))
142 #expect(privateNames.isEmpty)
143 }
144
145 @Test("Mixed-scope batch fans out to the correct engines")
146 func mixedScopeEnqueue() async throws {
147 let (engine, privateID, sharedID) = try await makeEngineWithGames()
148 await engine.enqueueMoves(gameIDs: [privateID, sharedID])
149
150 let privateNames = await engine.pendingSaveRecordNames(scope: .private)
151 let sharedNames = await engine.pendingSaveRecordNames(scope: .shared)
152
153 let privateMoves = movesRecordName(for: privateID)
154 let sharedMoves = movesRecordName(for: sharedID)
155 #expect(privateNames.contains(privateMoves))
156 #expect(!privateNames.contains(sharedMoves))
157 #expect(sharedNames.contains(sharedMoves))
158 #expect(!sharedNames.contains(privateMoves))
159 }
160
161 @Test("Deleting a private game queues its zone for private CloudKit deletion")
162 func privateGameDeleteEnqueue() async throws {
163 let persistence = makeTestPersistence()
164 let ctx = persistence.viewContext
165 let gameID = UUID()
166 let zoneName = "game-\(gameID.uuidString)"
167
168 let game = GameEntity(context: ctx)
169 game.id = gameID
170 game.title = "Private"
171 game.puzzleSource = ""
172 game.createdAt = Date()
173 game.updatedAt = Date()
174 game.ckRecordName = zoneName
175 game.ckZoneName = zoneName
176 game.databaseScope = 0
177 try ctx.save()
178
179 let container = CloudContainer.container
180 let engine = SyncEngine(container: container, persistence: persistence)
181 await engine.start()
182
183 var capturedDeletion: GameCloudDeletion?
184 let store = makeTestStore(
185 persistence: persistence,
186 onGameDeleted: { deletion in
187 capturedDeletion = deletion
188 }
189 )
190 try store.deleteGame(id: gameID)
191 let deletion = try #require(capturedDeletion)
192 await engine.enqueueDeleteGame(deletion)
193
194 let privateDeletes = await engine.pendingDeletedZoneNames(scope: .private)
195 let sharedDeletes = await engine.pendingDeletedZoneNames(scope: .shared)
196 #expect(privateDeletes.contains(zoneName))
197 #expect(sharedDeletes.isEmpty)
198 }
199
200 @Test("Deleting a shared game queues its zone for shared CloudKit deletion")
201 func sharedGameDeleteEnqueue() async throws {
202 let persistence = makeTestPersistence()
203 let ctx = persistence.viewContext
204 let gameID = UUID()
205 let zoneName = "game-\(gameID.uuidString)"
206
207 let game = GameEntity(context: ctx)
208 game.id = gameID
209 game.title = "Shared"
210 game.puzzleSource = ""
211 game.createdAt = Date()
212 game.updatedAt = Date()
213 game.ckRecordName = zoneName
214 game.ckZoneName = zoneName
215 game.ckZoneOwnerName = "_someOtherUser"
216 game.databaseScope = 1
217 try ctx.save()
218
219 let container = CloudContainer.container
220 let engine = SyncEngine(container: container, persistence: persistence)
221 await engine.start()
222
223 var capturedDeletion: GameCloudDeletion?
224 let store = makeTestStore(
225 persistence: persistence,
226 onGameDeleted: { deletion in
227 capturedDeletion = deletion
228 }
229 )
230 try store.deleteGame(id: gameID)
231 let deletion = try #require(capturedDeletion)
232 await engine.enqueueDeleteGame(deletion)
233
234 let privateDeletes = await engine.pendingDeletedZoneNames(scope: .private)
235 let sharedDeletes = await engine.pendingDeletedZoneNames(scope: .shared)
236 #expect(sharedDeletes.contains(zoneName))
237 #expect(privateDeletes.isEmpty)
238 }
239
240 @Test("Unknown game IDs enqueue nothing")
241 func unknownGameIsDropped() async throws {
242 let (engine, _, _) = try await makeEngineWithGames()
243 let orphan = UUID()
244 await engine.enqueueMoves(gameIDs: [orphan])
245
246 let privateNames = await engine.pendingSaveRecordNames(scope: .private)
247 let sharedNames = await engine.pendingSaveRecordNames(scope: .shared)
248
249 #expect(privateNames.isEmpty)
250 #expect(sharedNames.isEmpty)
251 }
252
253 @Test("Duplicate enqueue keeps one pending save")
254 func duplicateMoveEnqueueIsDeduped() async throws {
255 let (engine, privateID, _) = try await makeEngineWithGames()
256
257 await engine.enqueueMoves(gameIDs: [privateID])
258 await engine.enqueueMoves(gameIDs: [privateID])
259
260 let recordName = movesRecordName(for: privateID)
261 let privateNames = await engine.pendingSaveRecordNames(scope: .private)
262 #expect(privateNames.filter { $0 == recordName }.count == 1)
263 }
264
265 @Test("Unconfirmed persisted Moves rows are re-enqueued")
266 func unconfirmedPersistedMovesAreReEnqueued() async throws {
267 let (engine, gameID) = try await makeEngineWithPersistedMove()
268
269 let count = await engine.enqueueUnconfirmedMoves()
270
271 let recordName = movesRecordName(for: gameID)
272 let privateNames = await engine.pendingSaveRecordNames(scope: .private)
273 #expect(count == 1)
274 #expect(privateNames.contains(recordName))
275 }
276
277
278
279
280
281 @Test("Enqueue targets the current author's row, not an old account's")
282 func enqueueScopedToCurrentAuthorAfterAccountSwitch() async throws {
283 let persistence = makeTestPersistence()
284 let ctx = persistence.viewContext
285
286 let gameID = UUID()
287 let game = GameEntity(context: ctx)
288 game.id = gameID
289 game.title = "Private"
290 game.puzzleSource = ""
291 game.createdAt = Date()
292 game.updatedAt = Date()
293 game.ckRecordName = "game-\(gameID.uuidString)"
294 game.ckZoneName = "game-\(gameID.uuidString)"
295 game.databaseScope = 0
296 Self.seedMovesEntity(for: game, gameID: gameID, in: ctx, authorID: "old-account")
297 Self.seedMovesEntity(for: game, gameID: gameID, in: ctx)
298 try ctx.save()
299
300 let container = CloudContainer.container
301 let engine = SyncEngine(container: container, persistence: persistence)
302 await engine.start()
303 await engine.setLocalAuthorIDProvider { Self.writerAuthorID }
304
305 await engine.enqueueMoves(gameIDs: [gameID])
306
307 let privateNames = await engine.pendingSaveRecordNames(scope: .private)
308 #expect(privateNames.contains(movesRecordName(for: gameID)))
309 #expect(!privateNames.contains(RecordSerializer.recordName(
310 forMovesInGame: gameID,
311 authorID: "old-account",
312 deviceID: RecordSerializer.localDeviceID
313 )))
314 }
315
316 @Test("Unconfirmed recovery skips an old account's leftover rows")
317 func unconfirmedRecoveryScopedToCurrentAuthor() async throws {
318 let persistence = makeTestPersistence()
319 let ctx = persistence.viewContext
320
321
322
323 func makeGame(_ title: String) -> (GameEntity, UUID) {
324 let id = UUID()
325 let game = GameEntity(context: ctx)
326 game.id = id
327 game.title = title
328 game.puzzleSource = ""
329 game.createdAt = Date()
330 game.updatedAt = Date()
331 game.ckRecordName = "game-\(id.uuidString)"
332 game.ckZoneName = "game-\(id.uuidString)"
333 game.databaseScope = 0
334 return (game, id)
335 }
336 let (gameA, idA) = makeGame("Old account's")
337 Self.seedMovesEntity(for: gameA, gameID: idA, in: ctx, authorID: "old-account")
338 let (gameB, idB) = makeGame("Current author's")
339 Self.seedMovesEntity(for: gameB, gameID: idB, in: ctx)
340 try ctx.save()
341
342 let container = CloudContainer.container
343 let engine = SyncEngine(container: container, persistence: persistence)
344 await engine.start()
345 await engine.setLocalAuthorIDProvider { Self.writerAuthorID }
346
347 let count = await engine.enqueueUnconfirmedMoves()
348
349 let privateNames = await engine.pendingSaveRecordNames(scope: .private)
350 #expect(count == 1)
351 #expect(privateNames.contains(movesRecordName(for: idB)))
352 #expect(!privateNames.contains(RecordSerializer.recordName(
353 forMovesInGame: idA,
354 authorID: "old-account",
355 deviceID: RecordSerializer.localDeviceID
356 )))
357 }
358}