← All repositories

crossmate

A collaborative crossword app for iPhone and iPad

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


Tests/Unit/JournalUploadTests.swift (12532B)

1import CloudKit
2import CoreData
3import Foundation
4import Testing
5
6@testable import Crossmate
7
8/// Phase 2 upload pipeline: the `JournalCodec` wire format, the `Journal`
9/// record naming/building in `RecordSerializer`, and the end-to-end enqueue +
10/// `buildRecord` path through `SyncEngine`. The replay viewer (Phase 2b) is not
11/// covered here.
12
13// MARK: - Wire format
14
15@Suite("JournalCodec")
16struct JournalCodecTests {
17
18    private func value(
19        seq: Int64,
20        row: Int,
21        col: Int,
22        letter: String,
23        mark: CellMark,
24        kind: JournalKind,
25        actingAuthorID: String? = nil,
26        cellAuthorID: String? = nil,
27        targetSeq: Int64? = nil,
28        batchID: UUID? = nil,
29        prevSeqAtCell: Int64? = nil,
30        direction: Puzzle.Direction? = nil
31    ) -> JournalValue {
32        JournalValue(
33            seq: seq,
34            timestamp: Date(timeIntervalSince1970: 1_700_000_000 + Double(seq)),
35            position: GridPosition(row: row, col: col),
36            state: JournalCellState(letter: letter, mark: mark, cellAuthorID: cellAuthorID),
37            actingAuthorID: actingAuthorID,
38            kind: kind,
39            targetSeq: targetSeq,
40            batchID: batchID,
41            prevSeqAtCell: prevSeqAtCell,
42            direction: direction
43        )
44    }
45
46    @Test("encode/decode round-trips every field, including nil optionals")
47    func roundTrip() throws {
48        let batch = UUID()
49        let values = [
50            value(seq: 0, row: 0, col: 0, letter: "A", mark: .pen(checked: nil), kind: .input,
51                  actingAuthorID: "alice", cellAuthorID: "alice", direction: .across),
52            value(seq: 1, row: 1, col: 2, letter: "B", mark: .pencil(checked: .wrong), kind: .clear,
53                  actingAuthorID: "alice", cellAuthorID: nil, batchID: batch, prevSeqAtCell: 0, direction: .down),
54            value(seq: 2, row: 2, col: 2, letter: "", mark: .none, kind: .undo,
55                  targetSeq: 0, batchID: batch),
56            value(seq: 3, row: 0, col: 1, letter: "C", mark: .revealed, kind: .reveal),
57        ]
58        let data = try JournalCodec.encode(values)
59        let decoded = try JournalCodec.decode(data)
60        #expect(decoded == values)
61    }
62
63    @Test("encode sorts entries by seq")
64    func encodeSortsBySeq() throws {
65        let values = [
66            value(seq: 2, row: 0, col: 0, letter: "C", mark: .none, kind: .input),
67            value(seq: 0, row: 0, col: 0, letter: "A", mark: .none, kind: .input),
68            value(seq: 1, row: 0, col: 0, letter: "B", mark: .none, kind: .input),
69        ]
70        let decoded = try JournalCodec.decode(try JournalCodec.encode(values))
71        #expect(decoded.map(\.seq) == [0, 1, 2])
72    }
73
74    @Test("decode tolerates a payload missing the optional keys (forward-compat)")
75    func decodeToleratesMissingOptionals() throws {
76        let ts = Date(timeIntervalSince1970: 1_700_000_000)
77        let json: [String: Any] = ["entries": [[
78            "seq": 5,
79            "timestamp": ts.timeIntervalSinceReferenceDate,
80            "row": 1,
81            "col": 2,
82            "letter": "Z",
83            "markCode": 7,
84            "kind": 2,
85        ]]]
86        let data = try JSONSerialization.data(withJSONObject: json)
87        let decoded = try JournalCodec.decode(data)
88        let entry = try #require(decoded.first)
89        #expect(entry.seq == 5)
90        #expect(entry.position == GridPosition(row: 1, col: 2))
91        #expect(entry.state.letter == "Z")
92        #expect(entry.state.mark == .revealed)
93        #expect(entry.kind == .reveal)
94        #expect(entry.state.cellAuthorID == nil)
95        #expect(entry.actingAuthorID == nil)
96        #expect(entry.targetSeq == nil)
97        #expect(entry.batchID == nil)
98        #expect(entry.prevSeqAtCell == nil)
99        #expect(entry.direction == nil)
100    }
101
102    @Test("decode rejects a blob over the byte cap before parsing")
103    func decodeRejectsOversizedBlob() {
104        let oversized = Data(count: JournalCodec.maxAssetBytes + 1)
105        #expect(throws: JournalCodec.LimitError.self) {
106            _ = try JournalCodec.decode(oversized)
107        }
108    }
109
110    @Test("decode rejects a blob over the entry-count cap")
111    func decodeRejectsTooManyEntries() throws {
112        let values = (0...JournalCodec.maxEntryCount).map {
113            value(seq: Int64($0), row: 0, col: 0, letter: "A", mark: .none, kind: .input)
114        }
115        let data = try JournalCodec.encode(values)
116        // Stays under the byte cap so the entry-count gate is what fires.
117        #expect(data.count <= JournalCodec.maxAssetBytes)
118        #expect(throws: JournalCodec.LimitError.self) {
119            _ = try JournalCodec.decode(data)
120        }
121    }
122
123    @Test("decode accepts a blob at the entry-count cap")
124    func decodeAcceptsEntryCountAtCap() throws {
125        let values = (0..<JournalCodec.maxEntryCount).map {
126            value(seq: Int64($0), row: 0, col: 0, letter: "A", mark: .none, kind: .input)
127        }
128        let decoded = try JournalCodec.decode(try JournalCodec.encode(values))
129        #expect(decoded.count == JournalCodec.maxEntryCount)
130    }
131}
132
133// MARK: - Record naming + building
134
135@Suite("RecordSerializer Journal")
136struct RecordSerializerJournalTests {
137
138    private let gameID = UUID(uuidString: "AABBCCDD-0000-0000-0000-111122223333")!
139    private var zoneID: CKRecordZone.ID { RecordSerializer.zoneID(for: gameID) }
140
141    @Test("Journal record name uses the expected format")
142    func nameFormat() {
143        let name = RecordSerializer.recordName(
144            forJournalInGame: gameID,
145            authorID: "alice",
146            deviceID: "deadbeef"
147        )
148        #expect(name == "journal-\(gameID.uuidString)-alice-deadbeef")
149    }
150
151    @Test("Journal record name parses back, even when authorID contains dashes")
152    func nameRoundTrip() {
153        let name = RecordSerializer.recordName(
154            forJournalInGame: gameID,
155            authorID: "alice-with-dashes",
156            deviceID: "deadbeef"
157        )
158        let parsed = RecordSerializer.parseJournalRecordName(name)
159        #expect(parsed?.0 == gameID)
160        #expect(parsed?.1 == "alice-with-dashes")
161        #expect(parsed?.2 == "deadbeef")
162    }
163
164    @Test("parse rejects a non-journal name")
165    func parseRejectsOtherPrefix() {
166        let moves = RecordSerializer.recordName(
167            forMovesInGame: gameID, authorID: "alice", deviceID: "deadbeef"
168        )
169        #expect(RecordSerializer.parseJournalRecordName(moves) == nil)
170    }
171
172    @Test("Journal record carries the entries asset, which decodes back")
173    func recordAssetRoundTrips() throws {
174        let entries = [
175            JournalValue(
176                seq: 0,
177                timestamp: Date(timeIntervalSince1970: 1_700_000_000),
178                position: GridPosition(row: 0, col: 0),
179                state: JournalCellState(letter: "A", mark: .pen(checked: nil), cellAuthorID: "alice"),
180                actingAuthorID: "alice",
181                kind: .input,
182                targetSeq: nil,
183                batchID: nil,
184                prevSeqAtCell: nil,
185                direction: nil
186            ),
187            JournalValue(
188                seq: 1,
189                timestamp: Date(timeIntervalSince1970: 1_700_000_010),
190                position: GridPosition(row: 1, col: 2),
191                state: JournalCellState(letter: "B", mark: .revealed, cellAuthorID: nil),
192                actingAuthorID: "bob",
193                kind: .reveal,
194                targetSeq: nil,
195                batchID: UUID(),
196                prevSeqAtCell: nil,
197                direction: nil
198            ),
199        ]
200        let updatedAt = Date(timeIntervalSince1970: 1_700_000_010)
201        let record = try RecordSerializer.journalRecord(
202            gameID: gameID,
203            authorID: "alice",
204            deviceID: "deadbeef",
205            updatedAt: updatedAt,
206            entries: entries,
207            zone: zoneID
208        )
209
210        #expect(record.recordType == "Journal")
211        // authorID/deviceID live in the record name, not as fields.
212        let parsed = try #require(RecordSerializer.parseJournalRecordName(record.recordID.recordName))
213        #expect(parsed.1 == "alice")
214        #expect(parsed.2 == "deadbeef")
215        #expect(record["updatedAt"] as? Date == updatedAt)
216
217        let asset = try #require(record["entries"] as? CKAsset)
218        let url = try #require(asset.fileURL)
219        let data = try Data(contentsOf: url)
220        #expect(try JournalCodec.decode(data) == entries)
221    }
222}
223
224// MARK: - End-to-end enqueue + build
225
226@Suite("Journal upload via SyncEngine", .serialized)
227@MainActor
228struct JournalUploadEngineTests {
229
230    private func makeEngine(persistence: PersistenceController) async -> SyncEngine {
231        let container = CloudContainer.container
232        let engine = SyncEngine(container: container, persistence: persistence)
233        await engine.start()
234        return engine
235    }
236
237    private func makePrivateGame(in ctx: NSManagedObjectContext) throws -> UUID {
238        let id = UUID()
239        let zoneName = "game-\(id.uuidString)"
240        let entity = GameEntity(context: ctx)
241        entity.id = id
242        entity.title = "Private"
243        entity.puzzleSource = ""
244        entity.createdAt = Date()
245        entity.updatedAt = Date()
246        entity.ckRecordName = zoneName
247        entity.ckZoneName = zoneName
248        entity.databaseScope = 0
249        try ctx.save()
250        return id
251    }
252
253    private func seedJournalRow(gameID: UUID, seq: Int64, in ctx: NSManagedObjectContext) throws {
254        let gameReq = NSFetchRequest<GameEntity>(entityName: "GameEntity")
255        gameReq.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
256        gameReq.fetchLimit = 1
257        let game = try #require(try ctx.fetch(gameReq).first)
258        let row = JournalEntity(context: ctx)
259        row.game = game
260        row.gameID = gameID
261        row.seq = seq
262        row.timestamp = Date(timeIntervalSince1970: 1_700_000_000 + Double(seq))
263        row.row = 0
264        row.col = Int16(seq)
265        row.letter = "A"
266        row.markCode = 0
267        row.kind = JournalKind.input.rawValue
268        try ctx.save()
269    }
270
271    @Test("enqueue registers a buildable Journal save that survives a batch build")
272    func enqueuePreservesBuildableJournal() async throws {
273        let persistence = makeTestPersistence()
274        let ctx = persistence.viewContext
275        let gameID = try makePrivateGame(in: ctx)
276        try seedJournalRow(gameID: gameID, seq: 0, in: ctx)
277        try seedJournalRow(gameID: gameID, seq: 1, in: ctx)
278        let engine = await makeEngine(persistence: persistence)
279
280        await engine.enqueueJournalUpload(gameID: gameID, authorID: "alice")
281        let before = await engine.pendingSaveRecordNames(scope: .private)
282        let journalName = try #require(before.first { $0.hasPrefix("journal-") })
283
284        // The JournalEntity rows back the record, so `buildRecord` materializes
285        // it and the reap must not fire.
286        _ = await engine.makeRecordZoneChangeBatch(forTestingScope: .private)
287
288        let after = await engine.pendingSaveRecordNames(scope: .private)
289        #expect(after.contains(journalName))
290    }
291
292    @Test("an enqueued journal with no rows is reaped (nothing to upload)")
293    func emptyJournalIsReaped() async throws {
294        let persistence = makeTestPersistence()
295        let ctx = persistence.viewContext
296        let gameID = try makePrivateGame(in: ctx)
297        let engine = await makeEngine(persistence: persistence)
298
299        await engine.enqueueJournalUpload(gameID: gameID, authorID: "alice")
300        let before = await engine.pendingSaveRecordNames(scope: .private)
301        let journalName = try #require(before.first { $0.hasPrefix("journal-") })
302
303        _ = await engine.makeRecordZoneChangeBatch(forTestingScope: .private)
304
305        let after = await engine.pendingSaveRecordNames(scope: .private)
306        #expect(!after.contains(journalName))
307    }
308
309    @Test("late journals invoke Chronicle reconciliation")
310    func lateJournalInvokesChronicleReconciliation() async {
311        let persistence = makeTestPersistence()
312        let engine = await makeEngine(persistence: persistence)
313        let first = UUID()
314        let second = UUID()
315        var reconciled = Set<UUID>()
316
317        await engine.setOnReplayJournalsSynced { gameIDs in
318            reconciled = gameIDs
319        }
320        await engine.notifyReplayJournalsSynced([first, second])
321
322        #expect(reconciled == [first, second])
323    }
324}