crossmate

RecordSerializerTests.swift (6578B)

---

 import CloudKit
 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("RecordSerializer")
 struct RecordSerializerTests {
 
     // MARK: - Record name generation
 
     @Test("Game record name uses expected format")
     func gameRecordNameFormat() {
         let id = UUID(uuidString: "12345678-1234-1234-1234-123456789ABC")!
         let name = RecordSerializer.recordName(forGameID: id)
         #expect(name == "game-12345678-1234-1234-1234-123456789ABC")
     }
 
     @Test("Record names are deterministic")
     func recordNamesAreDeterministic() {
         let id = UUID()
         let a = RecordSerializer.recordName(forGameID: id)
         let b = RecordSerializer.recordName(forGameID: id)
         #expect(a == b)
     }
 
     // MARK: - Per-game zone
 
     @Test("zoneID(for:) uses game-<UUID> as zone name")
     func perGameZoneName() {
         let id = UUID(uuidString: "12345678-1234-1234-1234-123456789ABC")!
         let zone = RecordSerializer.zoneID(for: id)
         #expect(zone.zoneName == "game-12345678-1234-1234-1234-123456789ABC")
         #expect(zone.ownerName == CKCurrentUserDefaultName)
     }
 
     @Test("zoneID(for:ownerName:) accepts explicit owner")
     func perGameZoneExplicitOwner() {
         let id = UUID()
         let zone = RecordSerializer.zoneID(for: id, ownerName: "alice_record_id")
         #expect(zone.ownerName == "alice_record_id")
     }
 
     // MARK: - Player round-trip
 
     @Test("recordName(forPlayerInGame:authorID:) uses expected format")
     func playerRecordNameFormat() {
         let id = UUID(uuidString: "12345678-1234-1234-1234-123456789ABC")!
         let name = RecordSerializer.recordName(forPlayerInGame: id, authorID: "_abc")
         #expect(name == "player-12345678-1234-1234-1234-123456789ABC-_abc")
     }
 
     @Test("parsePlayerRecordName splits gameID and authorID")
     func parsePlayerRecordRoundTrip() {
         let gameID = UUID()
         let authorID = "_someAuthorID"
         let recordName = RecordSerializer.recordName(forPlayerInGame: gameID, authorID: authorID)
         let parsed = RecordSerializer.parsePlayerRecordName(recordName)
         #expect(parsed?.0 == gameID)
         #expect(parsed?.1 == authorID)
     }
 
     @Test("parsePlayerRecordName rejects malformed names")
     func parsePlayerRecordRejectsBadInput() {
         #expect(RecordSerializer.parsePlayerRecordName("game-foo") == nil)
         #expect(RecordSerializer.parsePlayerRecordName("player-not-a-uuid") == nil)
         #expect(RecordSerializer.parsePlayerRecordName("player-12345678-1234-1234-1234-123456789ABC") == nil)
     }
 
     // MARK: - applyGameRecord
 
     /// Writes `source` to a temp file and returns a `CKAsset` pointing to it.
     /// The caller is responsible for removing the file when done.
     private func makePuzzleAsset(source: String = "dummy puzzle source") throws -> (CKAsset, URL) {
         let url = FileManager.default.temporaryDirectory
             .appendingPathComponent(UUID().uuidString)
         try source.write(to: url, atomically: true, encoding: .utf8)
         return (CKAsset(fileURL: url), url)
     }
 
     @Test("applyGameRecord creates entity with id derived from record name")
     @MainActor func applyGameRecordCreatesEntity() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let gameID = UUID()
         let zone = RecordSerializer.zoneID(for: gameID)
         let recordName = RecordSerializer.recordName(forGameID: gameID)
         let record = CKRecord(recordType: "Game", recordID: CKRecord.ID(recordName: recordName, zoneID: zone))
         record["title"] = "Test Title" as CKRecordValue
         let (asset, tmpURL) = try makePuzzleAsset()
         defer { try? FileManager.default.removeItem(at: tmpURL) }
         record["puzzleSource"] = asset as CKRecordValue
 
         let entity = RecordSerializer.applyGameRecord(record, to: ctx)
         try ctx.save()
 
         #expect(entity.id == gameID)
         #expect(entity.title == "Test Title")
         #expect(entity.ckRecordName == recordName)
     }
 
     @Test("applyGameRecord preserves id and createdAt on second apply, updates title")
     @MainActor func applyGameRecordMergesOnServerRecordChanged() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let gameID = UUID()
         let zone = RecordSerializer.zoneID(for: gameID)
         let recordName = RecordSerializer.recordName(forGameID: gameID)
         let recordID = CKRecord.ID(recordName: recordName, zoneID: zone)
 
         let (asset1, tmpURL1) = try makePuzzleAsset(source: "original source")
         defer { try? FileManager.default.removeItem(at: tmpURL1) }
 
         // First apply — creates the entity.
         let record1 = CKRecord(recordType: "Game", recordID: recordID)
         record1["title"] = "Original" as CKRecordValue
         record1["puzzleSource"] = asset1 as CKRecordValue
         let entity = RecordSerializer.applyGameRecord(record1, to: ctx)
         try ctx.save()
 
         let frozenID = entity.id
         let frozenCreatedAt = entity.createdAt
 
         // Second apply — simulates a server record change with an updated title.
         // puzzleSource is intentionally absent here to verify it isn't wiped.
         let record2 = CKRecord(recordType: "Game", recordID: recordID)
         record2["title"] = "Updated" as CKRecordValue
         let merged = RecordSerializer.applyGameRecord(record2, to: ctx)
         try ctx.save()
 
         #expect(merged === entity)               // same managed object
         #expect(merged.id == frozenID)           // id not overwritten
         #expect(merged.createdAt == frozenCreatedAt) // createdAt not overwritten
         #expect(merged.title == "Updated")       // mutable field updated
     }
 
     // MARK: - System fields round-trip
 
     @Test("Encode and decode system fields preserves record type and zone")
     func systemFieldsRoundTrip() {
         let gameID = UUID()
         let zoneID = RecordSerializer.zoneID(for: gameID)
         let recordID = CKRecord.ID(recordName: "test-record", zoneID: zoneID)
         let original = CKRecord(recordType: "Cell", recordID: recordID)
 
         let encoded = RecordSerializer.encodeSystemFields(of: original)
         #expect(encoded != nil)
 
         let decoded = RecordSerializer.decodeRecord(from: encoded!)
         #expect(decoded != nil)
         #expect(decoded?.recordType == "Cell")
         #expect(decoded?.recordID.zoneID.zoneName == "game-\(gameID.uuidString)")
         #expect(decoded?.recordID.recordName == "test-record")
     }
 }