crossmate

PersistenceControllerHealTests.swift (6829B)

---

 import CloudKit
 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 /// Covers the TEMPORARY v1.1 heal for `GameEntity` rows stranded at
 /// `databaseScope == 1` with the owner placeholder. Delete this file as one
 /// block with `PersistenceController.healStrandedSharedGameRows_v1`.
 @Suite("Stranded shared game row heal")
 @MainActor
 struct PersistenceControllerHealTests {
 
     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
     """
 
     /// The shape the mis-scoped placeholder branch left behind: shared scope,
     /// owner placeholder, no puzzle.
     @discardableResult
     private func makeStranded(
         id: UUID,
         in ctx: NSManagedObjectContext
     ) -> GameEntity {
         let entity = GameEntity(context: ctx)
         entity.id = id
         entity.ckRecordName = "game-\(id.uuidString)"
         entity.ckZoneName = "game-\(id.uuidString)"
         entity.ckZoneOwnerName = CKCurrentUserDefaultName
         entity.databaseScope = 1
         entity.title = "Joining\u{2026}"
         entity.puzzleSource = ""
         entity.createdAt = .now
         entity.updatedAt = .now
         return entity
     }
 
     @discardableResult
     private func makeReal(
         id: UUID,
         in ctx: NSManagedObjectContext
     ) -> GameEntity {
         let entity = GameEntity(context: ctx)
         entity.id = id
         entity.ckRecordName = "game-\(id.uuidString)"
         entity.ckZoneName = "game-\(id.uuidString)"
         entity.ckZoneOwnerName = nil
         entity.databaseScope = 0
         entity.title = "Test Puzzle"
         entity.puzzleSource = Self.puzzleSource
         entity.createdAt = .now
         entity.updatedAt = .now
         return entity
     }
 
     @discardableResult
     private func makeMoves(
         recordName: String,
         on game: GameEntity,
         in ctx: NSManagedObjectContext
     ) -> MovesEntity {
         let moves = MovesEntity(context: ctx)
         moves.ckRecordName = recordName
         moves.authorID = "alice"
         moves.deviceID = "devicea"
         moves.cells = Data()
         moves.updatedAt = .now
         moves.game = game
         return moves
     }
 
     private func games(in ctx: NSManagedObjectContext, id: UUID) throws -> [GameEntity] {
         let req = NSFetchRequest<GameEntity>(entityName: "GameEntity")
         req.predicate = NSPredicate(format: "id == %@", id as CVarArg)
         return try ctx.fetch(req)
     }
 
     @Test("a stranded row is merged away when the real row exists")
     func mergesStrandedRowIntoSibling() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let id = UUID()
         makeStranded(id: id, in: ctx)
         makeReal(id: id, in: ctx)
         try ctx.save()
         #expect(try games(in: ctx, id: id).count == 2)
 
         persistence.healStrandedSharedGameRows_v1(force: true)
         ctx.refreshAllObjects()
 
         let survivors = try games(in: ctx, id: id)
         #expect(survivors.count == 1)
         // The row that survives is the playable one — that is the whole point.
         #expect(survivors.first?.puzzleSource == Self.puzzleSource)
         #expect(survivors.first?.databaseScope == 0)
     }
 
     @Test("moves parented to the stranded row move across, without duplicating")
     func adoptsStrandedChildren() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let id = UUID()
         let stranded = makeStranded(id: id, in: ctx)
         let real = makeReal(id: id, in: ctx)
         // One row only the stranded parent holds, and one both hold — the
         // latter is what a doubly-applied Moves record leaves behind.
         makeMoves(recordName: "moves-\(id.uuidString)-alice-devicea", on: stranded, in: ctx)
         makeMoves(recordName: "moves-\(id.uuidString)-bob-deviceb", on: stranded, in: ctx)
         makeMoves(recordName: "moves-\(id.uuidString)-bob-deviceb", on: real, in: ctx)
         try ctx.save()
 
         persistence.healStrandedSharedGameRows_v1(force: true)
         ctx.refreshAllObjects()
 
         let survivor = try #require(try games(in: ctx, id: id).first)
         let names = ((survivor.moves as? Set<MovesEntity>) ?? []).compactMap(\.ckRecordName)
         #expect(Set(names) == [
             "moves-\(id.uuidString)-alice-devicea",
             "moves-\(id.uuidString)-bob-deviceb",
         ])
         // The already-present row is not duplicated by the adoption.
         #expect(names.count == 2)
 
         let allMoves = NSFetchRequest<MovesEntity>(entityName: "MovesEntity")
         #expect(try ctx.fetch(allMoves).count == 2)
     }
 
     @Test("a stranded row with no sibling is repaired, never deleted")
     func repairsLoneStrandedRow() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let id = UUID()
         makeStranded(id: id, in: ctx)
         try ctx.save()
 
         persistence.healStrandedSharedGameRows_v1(force: true)
         ctx.refreshAllObjects()
 
         // Deleting would lose the only row for a game the user owns; repairing
         // it to private scope lets the ordinary sync path fill it in.
         let rows = try games(in: ctx, id: id)
         #expect(rows.count == 1)
         #expect(rows.first?.databaseScope == 0)
         #expect(rows.first?.ckZoneOwnerName == nil)
     }
 
     @Test("a shared row that carries a puzzle is left alone")
     func leavesPopulatedSharedRowsAlone() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let id = UUID()
         // Same stranded owner spelling, but with real content: not this bug's
         // work, and scope 0 would wrongly claim ownership of a joined game.
         let joined = makeStranded(id: id, in: ctx)
         joined.title = "Test Puzzle"
         joined.puzzleSource = Self.puzzleSource
         try ctx.save()
 
         persistence.healStrandedSharedGameRows_v1(force: true)
         ctx.refreshAllObjects()
 
         let rows = try games(in: ctx, id: id)
         #expect(rows.count == 1)
         #expect(rows.first?.databaseScope == 1)
         #expect(rows.first?.ckZoneOwnerName == CKCurrentUserDefaultName)
     }
 
     @Test("a healthy store is untouched")
     func healthyStoreIsUntouched() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let id = UUID()
         makeReal(id: id, in: ctx)
         try ctx.save()
 
         persistence.healStrandedSharedGameRows_v1(force: true)
         ctx.refreshAllObjects()
 
         let rows = try games(in: ctx, id: id)
         #expect(rows.count == 1)
         #expect(rows.first?.puzzleSource == Self.puzzleSource)
     }
 }