← All repositories

crossmate

A collaborative crossword app for iPhone and iPad

git clone https://code.inqk.net/crossmate.git


Tests/Unit/Sync/ShareRoutingTests.swift (14077B)

1import CloudKit
2import CoreData
3import Foundation
4import Testing
5
6@testable import Crossmate
7
8/// Verifies that `SyncEngine.enqueueMoves` routes to the correct engine based
9/// on each game's `databaseScope`. Uses a real in-memory persistence store and
10/// inspects each engine's pending-changes queue after enqueueing. No iCloud
11/// account is required — `CKSyncEngine.init` and its local state APIs work
12/// offline; only `fetchChanges` / `sendChanges` need an account.
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    /// Inserts a confirmed (system-fields-bearing — simulated by setting non-nil
58    /// `ckSystemFields`-equivalent state) MovesEntity row for the local device.
59    /// `enqueueMoves` looks up rows by `(game.id, deviceID == localDeviceID)`,
60    /// narrowed to the current authorID when the engine knows one — the
61    /// account-switch tests below seed a second author on the same device to
62    /// pin that narrowing.
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        // Unconfirmed: ckSystemFields is nil so enqueueUnconfirmedMoves picks it up.
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    /// Simulates the residue of an iCloud account switch: the same device
278    /// holds Moves rows under two authorIDs. With the previous device-only
279    /// lookup, the `fetchLimit = 1` fetch could return the old account's row
280    /// and enqueue a record the current user no longer owns.
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        // Game A carries only the old account's unconfirmed row; game B
322        // carries the current author's. Recovery must re-enqueue B alone.
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}