Tests/Unit/GridStateMergerTests.swift (12154B)
1import Foundation
2import Testing
3
4@testable import Crossmate
5
6@Suite("GridStateMerger.merge")
7struct GridStateMergerTests {
8
9 private let gameID = UUID(uuidString: "11111111-2222-3333-4444-555555555555")!
10
11 private func view(
12 author: String,
13 device: String,
14 cells: [(row: Int, col: Int, letter: String, updatedAt: Date)],
15 cellAuthor: String? = nil
16 ) -> MovesValue {
17 let resolvedCellAuthor = cellAuthor ?? author
18 var dict: [GridPosition: TimestampedCell] = [:]
19 for entry in cells {
20 dict[GridPosition(row: entry.row, col: entry.col)] = TimestampedCell(
21 letter: entry.letter,
22 mark: .none,
23 updatedAt: entry.updatedAt,
24 authorID: resolvedCellAuthor
25 )
26 }
27 return MovesValue(
28 gameID: gameID,
29 authorID: author,
30 deviceID: device,
31 cells: dict,
32 updatedAt: cells.map(\.updatedAt).max() ?? .distantPast
33 )
34 }
35
36 @Test("Empty input produces an empty grid")
37 func emptyInputs() {
38 #expect(GridStateMerger.merge([]).isEmpty)
39 }
40
41 @Test("Single MovesValue is reproduced cell-for-cell")
42 func singleViewPassesThrough() {
43 let v = view(
44 author: "alice",
45 device: "d1",
46 cells: [
47 (0, 0, "A", Date(timeIntervalSince1970: 1)),
48 (1, 2, "B", Date(timeIntervalSince1970: 2)),
49 ]
50 )
51 let grid = GridStateMerger.merge([v])
52 #expect(grid[GridPosition(row: 0, col: 0)]?.letter == "A")
53 #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "alice")
54 #expect(grid[GridPosition(row: 1, col: 2)]?.letter == "B")
55 }
56
57 @Test("Later updatedAt wins for the same cell across devices")
58 func laterTimestampWins() {
59 let earlier = view(
60 author: "alice",
61 device: "d1",
62 cells: [(0, 0, "A", Date(timeIntervalSince1970: 1))]
63 )
64 let later = view(
65 author: "bob",
66 device: "d2",
67 cells: [(0, 0, "B", Date(timeIntervalSince1970: 2))]
68 )
69 let grid = GridStateMerger.merge([earlier, later])
70 #expect(grid[GridPosition(row: 0, col: 0)]?.letter == "B")
71 #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "bob")
72 }
73
74 @Test("A higher logical tick wins despite an older wall clock")
75 func logicalTickWinsAcrossClockSkew() {
76 let position = GridPosition(row: 0, col: 0)
77 let legacyDate = Date(timeIntervalSince1970: 2_000)
78 let legacy = MovesValue(
79 gameID: gameID,
80 authorID: "alice",
81 deviceID: "legacy",
82 cells: [position: TimestampedCell(
83 letter: "N",
84 mark: .none,
85 updatedAt: legacyDate,
86 authorID: "alice"
87 )],
88 updatedAt: legacyDate
89 )
90 let modern = MovesValue(
91 gameID: gameID,
92 authorID: "bob",
93 deviceID: "modern",
94 cells: [position: TimestampedCell(
95 letter: "M",
96 mark: .none,
97 updatedAt: Date(timeIntervalSince1970: 1),
98 authorID: "bob",
99 tick: 2_000_001
100 )],
101 updatedAt: Date(timeIntervalSince1970: 1)
102 )
103
104 #expect(GridStateMerger.merge([legacy, modern])[position]?.letter == "M")
105 }
106
107 @Test("Logical ticks, not wall time, order modern cells")
108 func logicalTicksIgnoreModernWallClock() {
109 let position = GridPosition(row: 0, col: 0)
110 let lowerTick = MovesValue(
111 gameID: gameID,
112 authorID: "alice",
113 deviceID: "fast-clock",
114 cells: [position: TimestampedCell(
115 letter: "N",
116 mark: .none,
117 updatedAt: Date(timeIntervalSince1970: 9_999),
118 authorID: "alice",
119 tick: 40
120 )],
121 updatedAt: Date(timeIntervalSince1970: 9_999)
122 )
123 let higherTick = MovesValue(
124 gameID: gameID,
125 authorID: "bob",
126 deviceID: "slow-clock",
127 cells: [position: TimestampedCell(
128 letter: "M",
129 mark: .none,
130 updatedAt: Date(timeIntervalSince1970: 1),
131 authorID: "bob",
132 tick: 41
133 )],
134 updatedAt: Date(timeIntervalSince1970: 1)
135 )
136
137 #expect(GridStateMerger.merge([lowerTick, higherTick])[position]?.letter == "M")
138 }
139
140 @Test("Input order does not affect the merged result")
141 func inputOrderIndependent() {
142 let earlier = view(
143 author: "alice",
144 device: "d1",
145 cells: [(0, 0, "A", Date(timeIntervalSince1970: 1))]
146 )
147 let later = view(
148 author: "bob",
149 device: "d2",
150 cells: [(0, 0, "B", Date(timeIntervalSince1970: 2))]
151 )
152 let forward = GridStateMerger.merge([earlier, later])
153 let reversed = GridStateMerger.merge([later, earlier])
154 #expect(forward == reversed)
155 }
156
157 @Test("Equal updatedAt: lexicographically smaller authorID wins")
158 func authorTieBreak() {
159 let same = Date(timeIntervalSince1970: 5)
160 let bob = view(
161 author: "bob",
162 device: "d1",
163 cells: [(0, 0, "B", same)]
164 )
165 let alice = view(
166 author: "alice",
167 device: "d2",
168 cells: [(0, 0, "A", same)]
169 )
170 let grid = GridStateMerger.merge([bob, alice])
171 #expect(grid[GridPosition(row: 0, col: 0)]?.letter == "A")
172 #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "alice")
173 }
174
175 @Test("Equal updatedAt and author: smaller deviceID wins")
176 func deviceTieBreak() {
177 let same = Date(timeIntervalSince1970: 5)
178 let onPhone = view(
179 author: "alice",
180 device: "phone",
181 cells: [(0, 0, "P", same)]
182 )
183 let onIpad = view(
184 author: "alice",
185 device: "ipad",
186 cells: [(0, 0, "I", same)]
187 )
188 let grid = GridStateMerger.merge([onPhone, onIpad])
189 #expect(grid[GridPosition(row: 0, col: 0)]?.letter == "I")
190 }
191
192 @Test("Cells touched by only one device are all present in the merged grid")
193 func disjointCellsCoexist() {
194 let alice = view(
195 author: "alice",
196 device: "d1",
197 cells: [(0, 0, "A", Date(timeIntervalSince1970: 1))]
198 )
199 let bob = view(
200 author: "bob",
201 device: "d2",
202 cells: [(1, 1, "B", Date(timeIntervalSince1970: 1))]
203 )
204 let grid = GridStateMerger.merge([alice, bob])
205 #expect(grid.count == 2)
206 #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "alice")
207 #expect(grid[GridPosition(row: 1, col: 1)]?.authorID == "bob")
208 }
209
210 @Test("Cell-level authorID is preserved when the winning entry's parent writer differs")
211 func cellLevelAuthorWins() {
212
213
214
215 let preserved = view(
216 author: "bob",
217 device: "d1",
218 cells: [(0, 0, "A", Date(timeIntervalSince1970: 2))],
219 cellAuthor: "alice"
220 )
221 let grid = GridStateMerger.merge([preserved])
222 #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "alice")
223 }
224
225 @Test("Cleared letter (empty string) still wins if its updatedAt is latest")
226 func clearingMoveWins() {
227 let written = view(
228 author: "alice",
229 device: "d1",
230 cells: [(0, 0, "A", Date(timeIntervalSince1970: 1))]
231 )
232 let cleared = view(
233 author: "alice",
234 device: "d2",
235 cells: [(0, 0, "", Date(timeIntervalSince1970: 2))]
236 )
237 let grid = GridStateMerger.merge([written, cleared])
238 let cell = grid[GridPosition(row: 0, col: 0)]
239 #expect(cell?.letter == "")
240 #expect(cell != nil)
241 }
242
243 @Test("notAfter keeps the latest write at or before the cutoff")
244 func cutoffKeepsPreLatchWinner() {
245 let cutoff = Date(timeIntervalSince1970: 100)
246 let preLatch = view(
247 author: "alice",
248 device: "d1",
249 cells: [(0, 0, "A", Date(timeIntervalSince1970: 100))]
250 )
251 let postLatch = view(
252 author: "bob",
253 device: "d2",
254 cells: [(0, 0, "B", Date(timeIntervalSince1970: 101))]
255 )
256 let grid = GridStateMerger.merge([preLatch, postLatch], notAfter: cutoff)
257
258
259 #expect(grid[GridPosition(row: 0, col: 0)]?.letter == "A")
260 #expect(grid[GridPosition(row: 0, col: 0)]?.authorID == "alice")
261 }
262
263 @Test("notAfter drops a cell whose only write is after the cutoff")
264 func cutoffDropsPostLatchOnlyCell() {
265 let cutoff = Date(timeIntervalSince1970: 100)
266 let postLatch = view(
267 author: "bob",
268 device: "d2",
269 cells: [(3, 4, "Z", Date(timeIntervalSince1970: 200))]
270 )
271 let grid = GridStateMerger.merge([postLatch], notAfter: cutoff)
272 #expect(grid[GridPosition(row: 3, col: 4)] == nil)
273 }
274
275 @Test("A nil cutoff merges every write")
276 func nilCutoffIsUnbounded() {
277 let v = view(
278 author: "alice",
279 device: "d1",
280 cells: [(0, 0, "A", Date(timeIntervalSince1970: 9_999))]
281 )
282 #expect(GridStateMerger.merge([v], notAfter: nil) == GridStateMerger.merge([v]))
283 }
284}
285
286@Suite("MovesCodec round-trip")
287struct MovesCodecTests {
288
289 @Test("Round-trip preserves all cell fields including per-cell authorID")
290 func roundTrip() throws {
291 let cells: [GridPosition: TimestampedCell] = [
292 GridPosition(row: 0, col: 0): TimestampedCell(
293 letter: "A",
294 mark: .pencil(checked: .wrong),
295 updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
296 authorID: "alice",
297 tick: 42
298 ),
299 GridPosition(row: 4, col: 7): TimestampedCell(
300 letter: "",
301 mark: .none,
302 updatedAt: Date(timeIntervalSince1970: 1_700_000_500),
303 authorID: nil
304 ),
305 ]
306 let data = try MovesCodec.encode(cells)
307 let decoded = try MovesCodec.decode(data)
308 #expect(decoded == cells)
309 }
310
311 @Test("Encoded entries are sorted in row-major, col-minor order")
312 func encodingIsDeterministic() throws {
313 let cells: [GridPosition: TimestampedCell] = [
314 GridPosition(row: 2, col: 1): TimestampedCell(
315 letter: "X", mark: .none,
316 updatedAt: Date(timeIntervalSince1970: 1),
317 authorID: "alice"
318 ),
319 GridPosition(row: 0, col: 0): TimestampedCell(
320 letter: "A", mark: .none,
321 updatedAt: Date(timeIntervalSince1970: 2),
322 authorID: "bob"
323 ),
324 ]
325 let payload = try JSONDecoder().decode(
326 MovesCodec.Payload.self,
327 from: MovesCodec.encode(cells)
328 )
329 #expect(payload.entries.map { GridPosition(row: $0.row, col: $0.col) } == [
330 GridPosition(row: 0, col: 0),
331 GridPosition(row: 2, col: 1),
332 ])
333 #expect(payload.entries.map(\.authorID) == ["bob", "alice"])
334 }
335
336 @Test("Legacy payloads decode without a logical tick")
337 func legacyPayloadHasNoTick() throws {
338 let data = Data(#"{"entries":[{"row":0,"col":0,"letter":"N","markCode":0,"updatedAt":0}]}"#.utf8)
339 let decoded = try MovesCodec.decode(data)
340 #expect(decoded[GridPosition(row: 0, col: 0)]?.tick == nil)
341 }
342}