crossmate

MovesInboundTests.swift (17013B)

---

 import CloudKit
 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 /// Pins down `RecordSerializer.applyMovesRecord` — the inbound persistence path
 /// that turns a `Moves` CKRecord into a `MovesEntity` row.
 @Suite("RecordSerializer.applyMovesRecord")
 @MainActor
 struct MovesInboundTests {
 
     private let gameID = UUID(uuidString: "AABBCCDD-0000-0000-0000-111122223333")!
 
     private func record(
         in ctx: NSManagedObjectContext,
         authorID: String,
         deviceID: String,
         cells: [GridPosition: TimestampedCell],
         updatedAt: Date
     ) throws -> (CKRecord, MovesValue) {
         let value = MovesValue(
             gameID: gameID,
             authorID: authorID,
             deviceID: deviceID,
             cells: cells,
             updatedAt: updatedAt
         )
         let record = try RecordSerializer.movesRecord(
             from: value,
             zone: RecordSerializer.zoneID(for: gameID),
             systemFields: nil
         )
         return (record, value)
     }
 
     private func fetchAll(_ ctx: NSManagedObjectContext) -> [MovesEntity] {
         let req = NSFetchRequest<MovesEntity>(entityName: "MovesEntity")
         return (try? ctx.fetch(req)) ?? []
     }
 
     @Test("Persists a MovesEntity with the record's fields")
     func persistsEntity() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let (rec, value) = try record(
             in: ctx,
             authorID: "alice",
             deviceID: "deadbeef",
             cells: [
                 GridPosition(row: 0, col: 0): TimestampedCell(
                     letter: "A", mark: .none,
                     updatedAt: Date(timeIntervalSince1970: 1_700_000_000)
                 ),
             ],
             updatedAt: Date(timeIntervalSince1970: 1_700_000_000)
         )
 
         RecordSerializer.applyMovesRecord(rec, value: value, to: ctx)
 
         let rows = fetchAll(ctx)
         #expect(rows.count == 1)
         let entity = try #require(rows.first)
         #expect(entity.ckRecordName == rec.recordID.recordName)
         #expect(entity.authorID == "alice")
         #expect(entity.deviceID == "deadbeef")
         #expect(entity.updatedAt == value.updatedAt)
         #expect(entity.ckSystemFields != nil)
         // `cells` should be the verbatim record blob — decode round-trip recovers
         // the same cells we encoded.
         let decoded = try MovesCodec.decode(entity.cells ?? Data())
         #expect(decoded == value.cells)
     }
 
     @Test("Re-applying the same record updates the existing row in place")
     func reapplyUpdatesSameRow() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
 
         let cells1: [GridPosition: TimestampedCell] = [
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "A", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
                 authorID: "alice"
             ),
         ]
         let (rec1, value1) = try record(
             in: ctx,
             authorID: "alice",
             deviceID: "d1",
             cells: cells1,
             updatedAt: Date(timeIntervalSince1970: 1_700_000_000)
         )
         RecordSerializer.applyMovesRecord(rec1, value: value1, to: ctx)
         let firstID = try #require(fetchAll(ctx).first?.objectID)
 
         // A later update from the same device should land on the same row
         // (matched by ckRecordName), not create a duplicate.
         let cells2: [GridPosition: TimestampedCell] = [
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "B", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 1_700_000_500),
                 authorID: "alice"
             ),
             GridPosition(row: 1, col: 1): TimestampedCell(
                 letter: "C", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 1_700_000_500),
                 authorID: "alice"
             ),
         ]
         let (rec2, value2) = try record(
             in: ctx,
             authorID: "alice",
             deviceID: "d1",
             cells: cells2,
             updatedAt: Date(timeIntervalSince1970: 1_700_000_500)
         )
         RecordSerializer.applyMovesRecord(rec2, value: value2, to: ctx)
 
         let rows = fetchAll(ctx)
         #expect(rows.count == 1)
         #expect(rows.first?.objectID == firstID)
         #expect(rows.first?.updatedAt == value2.updatedAt)
         let decoded = try MovesCodec.decode(rows.first?.cells ?? Data())
         #expect(decoded == cells2)
     }
 
     @Test("onNewAuthor fires once for a remote contributor's first row, not repeats")
     func onNewAuthorFiresForNewRemoteContributor() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let cell: [GridPosition: TimestampedCell] = [
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "A", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
                 authorID: "bob"
             ),
         ]
         let (rec, value) = try record(
             in: ctx, authorID: "bob", deviceID: "d1",
             cells: cell, updatedAt: Date(timeIntervalSince1970: 1_700_000_000)
         )
 
         var newAuthors: [String] = []
         RecordSerializer.applyMovesRecord(
             rec, value: value, to: ctx, localAuthorID: "alice",
             onNewAuthor: { newAuthors.append($0) }
         )
         #expect(newAuthors == ["bob"])
 
         // A later update lands on the same row (ckRecordName), so it is not a
         // new contributor and must not re-trigger the roster.
         let (rec2, value2) = try record(
             in: ctx, authorID: "bob", deviceID: "d1",
             cells: cell, updatedAt: Date(timeIntervalSince1970: 1_700_000_500)
         )
         RecordSerializer.applyMovesRecord(
             rec2, value: value2, to: ctx, localAuthorID: "alice",
             onNewAuthor: { newAuthors.append($0) }
         )
         #expect(newAuthors == ["bob"])
     }
 
     @Test("onNewAuthor does not fire for a known contributor's second device")
     func onNewAuthorSkipsKnownAuthorSecondDevice() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let cell: [GridPosition: TimestampedCell] = [
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "A", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
                 authorID: "bob"
             ),
         ]
         let (phoneRecord, phoneValue) = try record(
             in: ctx, authorID: "bob", deviceID: "phone",
             cells: cell, updatedAt: Date(timeIntervalSince1970: 1_700_000_000)
         )
         let (ipadRecord, ipadValue) = try record(
             in: ctx, authorID: "bob", deviceID: "ipad",
             cells: cell, updatedAt: Date(timeIntervalSince1970: 1_700_000_500)
         )
 
         var newAuthors: [String] = []
         RecordSerializer.applyMovesRecord(
             phoneRecord, value: phoneValue, to: ctx, localAuthorID: "alice",
             onNewAuthor: { newAuthors.append($0) }
         )
         RecordSerializer.applyMovesRecord(
             ipadRecord, value: ipadValue, to: ctx, localAuthorID: "alice",
             onNewAuthor: { newAuthors.append($0) }
         )
 
         #expect(newAuthors == ["bob"])
     }
 
     @Test("onNewAuthor does not fire for the local author's own moves")
     func onNewAuthorSkipsLocalAuthor() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let cell: [GridPosition: TimestampedCell] = [
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "A", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 1_700_000_000),
                 authorID: "alice"
             ),
         ]
         // A sibling device of the local author (same authorID, new row) is not
         // a new participant.
         let (rec, value) = try record(
             in: ctx, authorID: "alice", deviceID: "sibling-device",
             cells: cell, updatedAt: Date(timeIntervalSince1970: 1_700_000_000)
         )
 
         var newAuthors: [String] = []
         RecordSerializer.applyMovesRecord(
             rec, value: value, to: ctx, localAuthorID: "alice",
             onNewAuthor: { newAuthors.append($0) }
         )
         #expect(newAuthors.isEmpty)
     }
 
     @Test("Inbound local-device record does not clobber existing local row")
     func inboundLocalDeviceRecordDoesNotClobberExistingLocalRow() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
 
         let game = GameEntity(context: ctx)
         game.id = gameID
         game.ckRecordName = "game-\(gameID.uuidString)"
         game.title = ""
         game.puzzleSource = ""
         game.createdAt = Date(timeIntervalSince1970: 0)
         game.updatedAt = Date(timeIntervalSince1970: 20)
 
         let localCells: [GridPosition: TimestampedCell] = [
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "B", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 20),
                 authorID: "alice"
             ),
         ]
         let local = MovesEntity(context: ctx)
         local.game = game
         local.ckRecordName = RecordSerializer.recordName(
             forMovesInGame: gameID,
             authorID: "alice",
             deviceID: RecordSerializer.localDeviceID
         )
         local.authorID = "alice"
         local.deviceID = RecordSerializer.localDeviceID
         local.updatedAt = Date(timeIntervalSince1970: 20)
         local.cells = try MovesCodec.encode(localCells)
         try ctx.save()
 
         let serverCells: [GridPosition: TimestampedCell] = [
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "A", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 10),
                 authorID: "alice"
             ),
         ]
         let (rec, value) = try record(
             in: ctx,
             authorID: "alice",
             deviceID: RecordSerializer.localDeviceID,
             cells: serverCells,
             updatedAt: Date(timeIntervalSince1970: 10)
         )
 
         RecordSerializer.applyMovesRecord(
             rec,
             value: value,
             to: ctx,
             localAuthorID: "alice"
         )
 
         let row = try #require(fetchAll(ctx).first)
         #expect(row.updatedAt == Date(timeIntervalSince1970: 20))
         let decoded = try MovesCodec.decode(row.cells ?? Data())
         #expect(decoded == localCells)
         #expect(row.ckSystemFields != nil)
     }
 
     @Test("Inbound other-device record preserves newer realtime cells")
     func inboundOtherDeviceRecordPreservesNewerRealtimeCells() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
 
         let game = GameEntity(context: ctx)
         game.id = gameID
         game.ckRecordName = "game-\(gameID.uuidString)"
         game.title = ""
         game.puzzleSource = ""
         game.createdAt = Date(timeIntervalSince1970: 0)
         game.updatedAt = Date(timeIntervalSince1970: 20)
 
         let cachedCells: [GridPosition: TimestampedCell] = [
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "B", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 20),
                 authorID: "bob"
             ),
             GridPosition(row: 1, col: 1): TimestampedCell(
                 letter: "", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 30),
                 authorID: "bob"
             ),
         ]
         let cached = MovesEntity(context: ctx)
         cached.game = game
         cached.ckRecordName = RecordSerializer.recordName(
             forMovesInGame: gameID,
             authorID: "bob",
             deviceID: "phone"
         )
         cached.authorID = "bob"
         cached.deviceID = "phone"
         cached.updatedAt = Date(timeIntervalSince1970: 20)
         cached.cells = try MovesCodec.encode(cachedCells)
         try ctx.save()
 
         let serverCells: [GridPosition: TimestampedCell] = [
             GridPosition(row: 0, col: 0): TimestampedCell(
                 letter: "A", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 10),
                 authorID: "bob"
             ),
             GridPosition(row: 1, col: 1): TimestampedCell(
                 letter: "Z", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 15),
                 authorID: "bob"
             ),
             GridPosition(row: 2, col: 2): TimestampedCell(
                 letter: "C", mark: .none,
                 updatedAt: Date(timeIntervalSince1970: 40),
                 authorID: "bob"
             ),
         ]
         let (rec, value) = try record(
             in: ctx,
             authorID: "bob",
             deviceID: "phone",
             cells: serverCells,
             updatedAt: Date(timeIntervalSince1970: 10)
         )
 
         RecordSerializer.applyMovesRecord(
             rec,
             value: value,
             to: ctx,
             localAuthorID: "alice"
         )
 
         let row = try #require(fetchAll(ctx).first)
         #expect(row.updatedAt == Date(timeIntervalSince1970: 40))
         let decoded = try MovesCodec.decode(row.cells ?? Data())
         #expect(decoded[GridPosition(row: 0, col: 0)]?.letter == "B")
         #expect(decoded[GridPosition(row: 1, col: 1)]?.letter == "")
         #expect(decoded[GridPosition(row: 2, col: 2)]?.letter == "C")
     }
 
     @Test("Two devices for the same game produce two distinct rows")
     func twoDevicesYieldTwoRows() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
 
         let (rec1, value1) = try record(
             in: ctx,
             authorID: "alice",
             deviceID: "phone",
             cells: [
                 GridPosition(row: 0, col: 0): TimestampedCell(
                     letter: "A", mark: .none,
                     updatedAt: Date(timeIntervalSince1970: 1),
                     authorID: "alice"
                 ),
             ],
             updatedAt: Date(timeIntervalSince1970: 1)
         )
         let (rec2, value2) = try record(
             in: ctx,
             authorID: "alice",
             deviceID: "ipad",
             cells: [
                 GridPosition(row: 1, col: 1): TimestampedCell(
                     letter: "B", mark: .none,
                     updatedAt: Date(timeIntervalSince1970: 2),
                     authorID: "alice"
                 ),
             ],
             updatedAt: Date(timeIntervalSince1970: 2)
         )
         RecordSerializer.applyMovesRecord(rec1, value: value1, to: ctx)
         RecordSerializer.applyMovesRecord(rec2, value: value2, to: ctx)
 
         let rows = fetchAll(ctx)
         #expect(rows.count == 2)
         #expect(Set(rows.compactMap(\.deviceID)) == ["phone", "ipad"])
     }
 
     @Test("Creates a stub GameEntity if none exists yet (lazy parent)")
     func lazyParentStub() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
 
         let (rec, value) = try record(
             in: ctx,
             authorID: "alice",
             deviceID: "d1",
             cells: [:],
             updatedAt: Date(timeIntervalSince1970: 1)
         )
         RecordSerializer.applyMovesRecord(rec, value: value, to: ctx)
 
         let gameReq = NSFetchRequest<GameEntity>(entityName: "GameEntity")
         gameReq.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
         let games = try ctx.fetch(gameReq)
         #expect(games.count == 1)
         #expect(games.first?.title == "")
         // The Moves row should be parented to the new stub.
         let movesRows = fetchAll(ctx)
         #expect(movesRows.count == 1)
         #expect(movesRows.first?.game?.objectID == games.first?.objectID)
     }
 
     @Test("Bumps the parent game's updatedAt when the record is fresher")
     func bumpsGameUpdatedAt() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
 
         // Pre-create the game with an old timestamp so the bump is observable.
         let game = GameEntity(context: ctx)
         game.id = gameID
         game.ckRecordName = "game-\(gameID.uuidString)"
         game.title = ""
         game.puzzleSource = ""
         game.createdAt = Date(timeIntervalSince1970: 0)
         game.updatedAt = Date(timeIntervalSince1970: 0)
         try ctx.save()
 
         let (rec, value) = try record(
             in: ctx,
             authorID: "alice",
             deviceID: "d1",
             cells: [:],
             updatedAt: Date(timeIntervalSince1970: 1_700_000_000)
         )
         RecordSerializer.applyMovesRecord(rec, value: value, to: ctx)
 
         #expect(game.updatedAt == value.updatedAt)
     }
 }