← All repositories

crossmate

A collaborative crossword app for iPhone and iPad

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


Tests/Unit/Sync/PlayerRecordPresenceTests.swift (12806B)

1import CloudKit
2import CoreData
3import Foundation
4import Testing
5
6@testable import Crossmate
7
8/// Pins down the inbound Player-record callback split: first sight of a
9/// collaborator still drives friendship bootstrap, while later presence
10/// updates from known collaborators wake live engagement.
11@Suite("Player record presence")
12@MainActor
13struct PlayerRecordPresenceTests {
14
15    private let gameID = UUID(uuidString: "ABCD1234-0000-0000-0000-111122223333")!
16    private let localAuthorID = "local-author"
17    private let remoteAuthorID = "remote-author"
18
19    private var zoneID: CKRecordZone.ID {
20        RecordSerializer.zoneID(for: gameID)
21    }
22
23    private func makeEngine(persistence: PersistenceController) -> SyncEngine {
24        SyncEngine(
25            container: CloudContainer.container,
26            persistence: persistence
27        )
28    }
29
30    private func makeGame(in ctx: NSManagedObjectContext) throws -> GameEntity {
31        let game = GameEntity(context: ctx)
32        game.id = gameID
33        game.title = "Presence Test"
34        game.puzzleSource = ""
35        game.createdAt = Date(timeIntervalSince1970: 1)
36        game.updatedAt = Date(timeIntervalSince1970: 1)
37        game.ckRecordName = RecordSerializer.recordName(forGameID: gameID)
38        game.ckZoneName = zoneID.zoneName
39        game.databaseScope = 0
40        try ctx.save()
41        return game
42    }
43
44    private func makeExistingRemotePlayer(
45        in ctx: NSManagedObjectContext,
46        game: GameEntity,
47        updatedAt: Date,
48        selection: PlayerSelection?
49    ) throws {
50        let player = PlayerEntity(context: ctx)
51        player.game = game
52        player.ckRecordName = RecordSerializer.recordName(
53            forPlayerInGame: gameID,
54            authorID: remoteAuthorID
55        )
56        player.authorID = remoteAuthorID
57        player.name = "Remote"
58        player.updatedAt = updatedAt
59        if let selection {
60            player.selRow = NSNumber(value: selection.row)
61            player.selCol = NSNumber(value: selection.col)
62            player.selDir = NSNumber(value: selection.direction.rawValue)
63        }
64        try ctx.save()
65    }
66
67    private func makeExistingLocalPlayer(
68        in ctx: NSManagedObjectContext,
69        game: GameEntity,
70        updatedAt: Date
71    ) throws {
72        let player = PlayerEntity(context: ctx)
73        player.game = game
74        player.ckRecordName = RecordSerializer.recordName(
75            forPlayerInGame: gameID,
76            authorID: localAuthorID
77        )
78        player.authorID = localAuthorID
79        player.name = "Local"
80        player.updatedAt = updatedAt
81        try ctx.save()
82    }
83
84    private func remotePlayerRecord(
85        updatedAt: Date,
86        selection: PlayerSelection?
87    ) -> CKRecord {
88        RecordSerializer.playerRecord(
89            gameID: gameID,
90            authorID: remoteAuthorID,
91            name: "Remote",
92            updatedAt: updatedAt,
93            selection: selection,
94            zone: zoneID,
95            systemFields: nil
96        )
97    }
98
99    @Test("Existing remote selection move fires presence change only")
100    func existingRemoteSelectionMoveFiresPresenceChangeOnly() throws {
101        let persistence = makeTestPersistence()
102        let ctx = persistence.viewContext
103        let game = try makeGame(in: ctx)
104        try makeExistingRemotePlayer(
105            in: ctx,
106            game: game,
107            updatedAt: Date(timeIntervalSince1970: 10),
108            selection: PlayerSelection(row: 1, col: 2, direction: .across)
109        )
110        let engine = makeEngine(persistence: persistence)
111
112        var firstTimeGameIDs: [UUID] = []
113        var presenceGameIDs: [UUID] = []
114        let record = remotePlayerRecord(
115            updatedAt: Date(timeIntervalSince1970: 20),
116            selection: PlayerSelection(row: 2, col: 2, direction: .down)
117        )
118
119        engine.applyPlayerRecord(
120            record,
121            in: ctx,
122            localAuthorID: localAuthorID,
123            onFirstTime: { firstTimeGameIDs.append($0) },
124            onPresenceChange: { presenceGameIDs.append($0) },
125            onReadCursor: { _, _, _ in }
126        )
127
128        #expect(firstTimeGameIDs.isEmpty)
129        #expect(presenceGameIDs == [gameID])
130
131        let fetched = try fetchRemotePlayer(in: ctx)
132        let row = try #require(fetched)
133        #expect(row.selRow?.intValue == 2)
134        #expect(row.selCol?.intValue == 2)
135        #expect(row.selDir?.intValue == Puzzle.Direction.down.rawValue)
136    }
137
138    @Test("Existing remote selection clear fires presence change only")
139    func existingRemoteSelectionClearFiresPresenceChangeOnly() throws {
140        let persistence = makeTestPersistence()
141        let ctx = persistence.viewContext
142        let game = try makeGame(in: ctx)
143        try makeExistingRemotePlayer(
144            in: ctx,
145            game: game,
146            updatedAt: Date(timeIntervalSince1970: 10),
147            selection: PlayerSelection(row: 1, col: 2, direction: .across)
148        )
149        let engine = makeEngine(persistence: persistence)
150
151        var firstTimeGameIDs: [UUID] = []
152        var presenceGameIDs: [UUID] = []
153        let record = remotePlayerRecord(
154            updatedAt: Date(timeIntervalSince1970: 20),
155            selection: nil
156        )
157
158        engine.applyPlayerRecord(
159            record,
160            in: ctx,
161            localAuthorID: localAuthorID,
162            onFirstTime: { firstTimeGameIDs.append($0) },
163            onPresenceChange: { presenceGameIDs.append($0) },
164            onReadCursor: { _, _, _ in }
165        )
166
167        #expect(firstTimeGameIDs.isEmpty)
168        #expect(presenceGameIDs == [gameID])
169
170        let fetched = try fetchRemotePlayer(in: ctx)
171        let row = try #require(fetched)
172        #expect(row.selRow == nil)
173        #expect(row.selCol == nil)
174        #expect(row.selDir == nil)
175    }
176
177    @Test("Stale-updatedAt local record still converges the catch-up baseline")
178    func staleLocalRecordStillAdoptsSessionSnapshot() throws {
179        let persistence = makeTestPersistence()
180        let ctx = persistence.viewContext
181        let game = try makeGame(in: ctx)
182        // This device already holds a fresher local cursor write on the
183        // account's own Player row (e.g. a live selection move).
184        try makeExistingLocalPlayer(
185            in: ctx,
186            game: game,
187            updatedAt: Date(timeIntervalSince1970: 20)
188        )
189        let engine = makeEngine(persistence: persistence)
190
191        // A sibling committed the catch-up baseline on leave: it ships the
192        // snapshot + read cursor but with a stale `updatedAt`, because leaving
193        // advances the read cursor and snapshot without bumping `updatedAt`.
194        let baseline = Date(timeIntervalSince1970: 12)
195        let presenceUntil = Date(timeIntervalSince1970: 15)
196        let record = RecordSerializer.playerRecord(
197            gameID: gameID,
198            authorID: localAuthorID,
199            name: "Local",
200            updatedAt: Date(timeIntervalSince1970: 10),
201            selection: PlayerSelection(row: 5, col: 5, direction: .across),
202            presenceUntil: presenceUntil,
203            viewedAt: baseline,
204            zone: zoneID,
205            systemFields: nil
206        )
207
208        var readCursors: [(UUID, Date, Date?)] = []
209        engine.applyPlayerRecord(
210            record,
211            in: ctx,
212            localAuthorID: localAuthorID,
213            onFirstTime: { _ in },
214            onPresenceChange: { _ in },
215            onReadCursor: { readCursors.append(($0, $1, $2)) }
216        )
217
218        // The baseline converges despite the stale `updatedAt`...
219        let fetched = try fetchLocalPlayer(in: ctx)
220        let row = try #require(fetched)
221        #expect(row.viewedAt == baseline)
222        #expect(readCursors.count == 1)
223        #expect(readCursors.first?.0 == gameID)
224        #expect(readCursors.first?.1 == presenceUntil)
225        #expect(readCursors.first?.2 == baseline)
226        // ...while the cursor LWW still shields the fresher local selection from
227        // the stale record.
228        #expect(row.selRow == nil)
229        #expect(row.updatedAt == Date(timeIntervalSince1970: 20))
230    }
231
232    @Test("A sibling read watermark clears the visible Chronicle projection")
233    func siblingReadThroughMirrorsToChronicle() throws {
234        let persistence = makeTestPersistence()
235        let ctx = persistence.viewContext
236        let game = try makeGame(in: ctx)
237        let latest = Date(timeIntervalSince1970: 12)
238        game.latestOtherMoveAt = latest
239        try makeExistingLocalPlayer(
240            in: ctx,
241            game: game,
242            updatedAt: Date(timeIntervalSince1970: 10)
243        )
244
245        let chronicle = GameEntity(context: ctx)
246        chronicle.id = Archive.archiveGameID(for: gameID)
247        chronicle.ckRecordName = Archive.recordName(forOriginalGameID: gameID)
248        chronicle.title = "Presence Test Chronicle"
249        chronicle.puzzleSource = ""
250        chronicle.createdAt = Date(timeIntervalSince1970: 1)
251        chronicle.updatedAt = Date(timeIntervalSince1970: 1)
252        chronicle.latestOtherMoveAt = latest
253        chronicle.readThroughAt = Date(timeIntervalSince1970: 5)
254        try ctx.save()
255
256        let record = RecordSerializer.playerRecord(
257            gameID: gameID,
258            authorID: localAuthorID,
259            name: "Local",
260            updatedAt: Date(timeIntervalSince1970: 20),
261            selection: nil,
262            presenceUntil: Date(timeIntervalSince1970: 20),
263            readThrough: latest,
264            zone: zoneID,
265            systemFields: nil
266        )
267
268        let engine = makeEngine(persistence: persistence)
269        engine.applyPlayerRecord(
270            record,
271            in: ctx,
272            localAuthorID: localAuthorID,
273            onFirstTime: { _ in },
274            onPresenceChange: { _ in },
275            onReadCursor: { _, _, _ in }
276        )
277
278        #expect(game.readThroughAt == latest)
279        #expect(chronicle.readThroughAt == latest)
280    }
281
282    @Test("Partial player record without name still applies other fields")
283    func partialPlayerRecordWithoutNameStillAppliesFields() throws {
284        let persistence = makeTestPersistence()
285        let ctx = persistence.viewContext
286        let game = try makeGame(in: ctx)
287        try makeExistingRemotePlayer(
288            in: ctx,
289            game: game,
290            updatedAt: Date(timeIntervalSince1970: 10),
291            selection: nil
292        )
293        let engine = makeEngine(persistence: persistence)
294
295        let recordName = RecordSerializer.recordName(
296            forPlayerInGame: gameID,
297            authorID: remoteAuthorID
298        )
299        let record = CKRecord(
300            recordType: "Player",
301            recordID: CKRecord.ID(recordName: recordName, zoneID: zoneID)
302        )
303        // authorID is recovered from the record name, not a field.
304        record["updatedAt"] = Date(timeIntervalSince1970: 20) as CKRecordValue
305        record["selRow"] = Int64(3) as CKRecordValue
306        record["selCol"] = Int64(4) as CKRecordValue
307        record["selDir"] = Int64(Puzzle.Direction.down.rawValue) as CKRecordValue
308
309        var firstTimeGameIDs: [UUID] = []
310        var presenceGameIDs: [UUID] = []
311        engine.applyPlayerRecord(
312            record,
313            in: ctx,
314            localAuthorID: localAuthorID,
315            onFirstTime: { firstTimeGameIDs.append($0) },
316            onPresenceChange: { presenceGameIDs.append($0) },
317            onReadCursor: { _, _, _ in }
318        )
319
320        #expect(firstTimeGameIDs.isEmpty)
321        #expect(presenceGameIDs == [gameID])
322
323        let fetched = try fetchRemotePlayer(in: ctx)
324        let row = try #require(fetched)
325        #expect(row.name == "Remote")
326        #expect(row.updatedAt == Date(timeIntervalSince1970: 20))
327        #expect(row.selRow?.intValue == 3)
328        #expect(row.selCol?.intValue == 4)
329        #expect(row.selDir?.intValue == Puzzle.Direction.down.rawValue)
330    }
331
332    private func fetchLocalPlayer(in ctx: NSManagedObjectContext) throws -> PlayerEntity? {
333        let req = NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity")
334        req.predicate = NSPredicate(
335            format: "ckRecordName == %@",
336            RecordSerializer.recordName(forPlayerInGame: gameID, authorID: localAuthorID)
337        )
338        req.fetchLimit = 1
339        return try ctx.fetch(req).first
340    }
341
342    private func fetchRemotePlayer(in ctx: NSManagedObjectContext) throws -> PlayerEntity? {
343        let req = NSFetchRequest<PlayerEntity>(entityName: "PlayerEntity")
344        req.predicate = NSPredicate(
345            format: "ckRecordName == %@",
346            RecordSerializer.recordName(forPlayerInGame: gameID, authorID: remoteAuthorID)
347        )
348        req.fetchLimit = 1
349        return try ctx.fetch(req).first
350    }
351}