crossmate

InboundRecordIdentityTests.swift (8136B)

---

 import CloudKit
 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("Inbound game record identity")
 @MainActor
 struct InboundRecordIdentityTests {
 
     private let gameID = UUID(uuidString: "AABBCCDD-0000-0000-0000-111122223333")!
 
     private func movesRecord(in zoneID: CKRecordZone.ID) throws -> CKRecord {
         try RecordSerializer.movesRecord(
             from: MovesValue(
                 gameID: gameID,
                 authorID: "alice",
                 deviceID: "devicea",
                 cells: [:],
                 updatedAt: .now
             ),
             zone: zoneID,
             systemFields: nil
         )
     }
 
     @Test("per-game records require their matching zone and CloudKit creator")
     func recordRequiresMatchingZoneAndCreator() throws {
         let matchingZone = RecordSerializer.zoneID(for: gameID, ownerName: "owner")
         let matching = try movesRecord(in: matchingZone)
         #expect(
             RecordSerializer.isTrustedGameScopedRecord(
                 matching,
                 creatorUserRecordName: "alice"
             )
         )
         #expect(
             !RecordSerializer.isTrustedGameScopedRecord(
                 matching,
                 creatorUserRecordName: "mallory"
             )
         )
 
         let foreignZone = RecordSerializer.zoneID(for: UUID(), ownerName: "owner")
         let crossZone = try movesRecord(in: foreignZone)
         #expect(
             !RecordSerializer.isTrustedGameScopedRecord(
                 crossZone,
                 creatorUserRecordName: "alice"
             )
         )
     }
 
     @Test("self-created records round-trip as the creator placeholder and stay trusted")
     func recordAcceptsCreatorPlaceholder() throws {
         // CloudKit reports the creator of a record the fetching user created
         // themselves as `CKCurrentUserDefaultName`, not their concrete record
         // name. Rejecting the placeholder would drop every self-authored
         // record on a fresh install or second device. Accepting it stays
         // safe: a remote participant's record never arrives carrying it.
         let zone = RecordSerializer.zoneID(for: gameID, ownerName: "owner")
         let record = try movesRecord(in: zone)
         #expect(
             RecordSerializer.isTrustedGameScopedRecord(
                 record,
                 creatorUserRecordName: CKCurrentUserDefaultName
             )
         )
         #expect(
             !RecordSerializer.isTrustedGameScopedRecord(
                 record,
                 creatorUserRecordName: nil
             )
         )
     }
 
     @Test("root game record must be named for its zone")
     func rootGameRecordRequiresMatchingZone() {
         let record = CKRecord(
             recordType: "Game",
             recordID: CKRecord.ID(
                 recordName: RecordSerializer.recordName(forGameID: gameID),
                 zoneID: RecordSerializer.zoneID(for: UUID(), ownerName: "owner")
             )
         )
         #expect(
             !RecordSerializer.isTrustedGameScopedRecord(
                 record,
                 creatorUserRecordName: "owner"
             )
         )
     }
 
     @Test("deletions are confined to the record's game zone")
     func deletionRequiresMatchingZone() {
         let recordName = RecordSerializer.recordName(
             forMovesInGame: gameID,
             authorID: "alice",
             deviceID: "devicea"
         )
         let valid = CKRecord.ID(
             recordName: recordName,
             zoneID: RecordSerializer.zoneID(for: gameID, ownerName: "owner")
         )
         #expect(RecordSerializer.isTrustedGameScopedDeletion(recordID: valid, recordType: "Moves"))
 
         let forged = CKRecord.ID(
             recordName: recordName,
             zoneID: RecordSerializer.zoneID(for: UUID(), ownerName: "owner")
         )
         #expect(!RecordSerializer.isTrustedGameScopedDeletion(recordID: forged, recordType: "Moves"))
     }
 
     @Test("ping deletions follow the same zone confinement as ping records")
     func pingDeletionConfinement() {
         let pingName = RecordSerializer.recordName(
             forPingInGame: gameID,
             authorID: "alice",
             deviceID: "devicea",
             eventTimestampMs: 1_700_000_000_000
         )
         // A ping in its own game's zone is fine.
         let inGameZone = CKRecord.ID(
             recordName: pingName,
             zoneID: RecordSerializer.zoneID(for: gameID, ownerName: "owner")
         )
         #expect(
             RecordSerializer.isTrustedGameScopedDeletion(recordID: inGameZone, recordType: "Ping")
         )
         // A friend-mailbox ping names a game outside its zone by design.
         let inFriendZone = CKRecord.ID(
             recordName: pingName,
             zoneID: CKRecordZone.ID(zoneName: "friend-pair", ownerName: "owner")
         )
         #expect(
             RecordSerializer.isTrustedGameScopedDeletion(recordID: inFriendZone, recordType: "Ping")
         )
         // A ping in a *different* game's zone is not.
         let crossGameZone = CKRecord.ID(
             recordName: pingName,
             zoneID: RecordSerializer.zoneID(for: UUID(), ownerName: "owner")
         )
         #expect(
             !RecordSerializer.isTrustedGameScopedDeletion(recordID: crossGameZone, recordType: "Ping")
         )
     }
 
     @Test("a private game's row is found under either owner-name spelling")
     func privateGameLookupIgnoresOwnerSpelling() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let name = RecordSerializer.recordName(forGameID: gameID)
         // CloudKit round-trips the current user's own zones with either the
         // `CKCurrentUserDefaultName` placeholder or their concrete record ID.
         // Both spellings must resolve to the same private row, or every
         // fetch after the first would spawn a duplicate game.
         let placeholderZone = RecordSerializer.zoneID(for: gameID)
         let concreteZone = RecordSerializer.zoneID(for: gameID, ownerName: "_myOwnRecordID")
 
         let first = CKRecord(
             recordType: "Game",
             recordID: CKRecord.ID(recordName: name, zoneID: placeholderZone)
         )
         first["title"] = "Original" as CKRecordValue
         let second = CKRecord(
             recordType: "Game",
             recordID: CKRecord.ID(recordName: name, zoneID: concreteZone)
         )
         second["title"] = "Round-tripped" as CKRecordValue
 
         let firstEntity = RecordSerializer.applyGameRecord(first, to: ctx, databaseScope: .private)
         let secondEntity = RecordSerializer.applyGameRecord(second, to: ctx, databaseScope: .private)
 
         #expect(firstEntity.objectID == secondEntity.objectID)
         #expect(secondEntity.title == "Round-tripped")
     }
 
     @Test("same-named records in distinct owner zones do not share a local row")
     func gameLookupIncludesZoneOwner() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let firstZone = RecordSerializer.zoneID(for: gameID, ownerName: "owner-a")
         let secondZone = RecordSerializer.zoneID(for: gameID, ownerName: "owner-b")
 
         let first = CKRecord(
             recordType: "Game",
             recordID: CKRecord.ID(
                 recordName: RecordSerializer.recordName(forGameID: gameID),
                 zoneID: firstZone
             )
         )
         first["title"] = "First" as CKRecordValue
         let second = CKRecord(
             recordType: "Game",
             recordID: CKRecord.ID(
                 recordName: RecordSerializer.recordName(forGameID: gameID),
                 zoneID: secondZone
             )
         )
         second["title"] = "Second" as CKRecordValue
 
         let firstEntity = RecordSerializer.applyGameRecord(first, to: ctx, databaseScope: .shared)
         let secondEntity = RecordSerializer.applyGameRecord(second, to: ctx, databaseScope: .shared)
 
         #expect(firstEntity.objectID != secondEntity.objectID)
         #expect(firstEntity.title == "First")
         #expect(secondEntity.title == "Second")
     }
 }