Tests/Unit/Sync/PlayerRecordPresenceTests.swift (12806B)
1import CloudKit
2import CoreData
3import Foundation
4import Testing
5
6@testable import Crossmate
7
8
9
10
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
183
184 try makeExistingLocalPlayer(
185 in: ctx,
186 game: game,
187 updatedAt: Date(timeIntervalSince1970: 20)
188 )
189 let engine = makeEngine(persistence: persistence)
190
191
192
193
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
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
227
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
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}