crossmate

InboundRecordIdentityTests.swift (11924B)

---

 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")
     }
 
     // MARK: - Own-owner shared rows
 
     /// The shape that made a puzzle unopenable on a real device: a
     /// `databaseScope == 1` row holding the owner placeholder. Both scopes'
     /// predicates miss it — private wants `ckZoneOwnerName == NIL`, shared
     /// wants a concrete owner — so the arriving Game record forks a second
     /// row instead of filling this one in, and the empty row then shadows the
     /// real game in every `id`-keyed lookup. Nothing may create it.
     @Test("an own-owner shared row is unreachable from either scope's lookup")
     func ownOwnerSharedRowIsUnmatchable() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let name = RecordSerializer.recordName(forGameID: gameID)
 
         let stranded = GameEntity(context: ctx)
         stranded.id = gameID
         stranded.ckRecordName = name
         stranded.ckZoneName = name
         stranded.ckZoneOwnerName = CKCurrentUserDefaultName
         stranded.databaseScope = 1
         stranded.title = "Joining\u{2026}"
         stranded.puzzleSource = ""
         stranded.createdAt = .now
         stranded.updatedAt = .now
         try ctx.save()
 
         // The private Game record that should have healed it forks instead.
         let record = CKRecord(
             recordType: "Game",
             recordID: CKRecord.ID(
                 recordName: name,
                 zoneID: RecordSerializer.zoneID(for: gameID)
             )
         )
         record["title"] = "Real Puzzle" as CKRecordValue
         let applied = RecordSerializer.applyGameRecord(record, to: ctx, databaseScope: .private)
 
         #expect(applied.objectID != stranded.objectID)
         #expect(stranded.puzzleSource == "")
 
         // Two rows now answer to the same game id — which is what breaks the
         // `fetchLimit = 1` lookups in `GameStore.loadGame(id:)`.
         let byID = NSFetchRequest<GameEntity>(entityName: "GameEntity")
         byID.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
         #expect(try ctx.fetch(byID).count == 2)
     }
 
     @Test("constructJoinedGame refuses a zone the current user owns")
     func constructJoinedGameRefusesOwnOwnerZone() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let ownZone = RecordSerializer.zoneID(for: gameID)
 
         #expect(throws: GameStore.LoadError.sharedZoneOwnedByCurrentUser) {
             try store.constructJoinedGame(
                 gameID: gameID,
                 zoneID: ownZone,
                 source: Self.puzzleSource
             )
         }
 
         let all = NSFetchRequest<GameEntity>(entityName: "GameEntity")
         #expect(try persistence.viewContext.fetch(all).isEmpty)
     }
 
     @Test("constructJoinedGame keeps the share owner's concrete record name")
     func constructJoinedGameStoresConcreteOwner() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let sharedZone = RecordSerializer.zoneID(for: gameID, ownerName: "_owner")
 
         try store.constructJoinedGame(
             gameID: gameID,
             zoneID: sharedZone,
             source: Self.puzzleSource
         )
 
         let req = NSFetchRequest<GameEntity>(entityName: "GameEntity")
         req.predicate = NSPredicate(format: "id == %@", gameID as CVarArg)
         let entity = try #require(try persistence.viewContext.fetch(req).first)
         #expect(entity.databaseScope == 1)
         #expect(entity.ckZoneOwnerName == "_owner")
     }
 
     private static let puzzleSource = """
     Title: Test Puzzle
     Author: Test
 
 
     AB
     CD
 
 
     A1. Top row ~ AB
     A3. Bottom row ~ CD
 
     D1. Left column ~ AC
     D2. Right column ~ BD
     """
 }