crossmate

NYTPuzzleUpgraderTests.swift (7905B)

---

 import Foundation
 import Testing
 
 @testable import Crossmate
 
 @Suite("NYTPuzzleUpgrader")
 struct NYTPuzzleUpgraderTests {
 
     // MARK: - Fixtures
 
     /// 3×3 open grid with default solutions ABC/DEF/GHI. Override `gridRows`
     /// for solution-diff tests; clue text overrides are independent so the
     /// verifier sees a clue-only change.
     private func openGridSource(
         clueAcross1: String = "Across one",
         clueAcross4: String = "Across four",
         clueAcross5: String = "Across five",
         clueDown1: String = "Down one",
         clueDown2: String = "Down two",
         clueDown3: String = "Down three",
         gridRows: [String] = ["ABC", "DEF", "GHI"]
     ) -> String {
         precondition(gridRows.count == 3 && gridRows.allSatisfy { $0.count == 3 })
         let metadata = """
         Title: Test
         Publisher: New York Times
         Date: 2025-01-26
         """
         let grid = gridRows.joined(separator: "\n")
         func col(_ idx: Int) -> String {
             String(gridRows.map { Array($0)[idx] })
         }
         let clues = """
         A1. \(clueAcross1) ~ \(gridRows[0])
         A4. \(clueAcross4) ~ \(gridRows[1])
         A5. \(clueAcross5) ~ \(gridRows[2])
 
         D1. \(clueDown1) ~ \(col(0))
         D2. \(clueDown2) ~ \(col(1))
         D3. \(clueDown3) ~ \(col(2))
         """
         return [metadata, grid, clues].joined(separator: "\n\n\n")
     }
 
     /// 2×2 open grid for the dimensions-diff test.
     private func smallGridSource() -> String {
         let metadata = """
         Title: Small
         Publisher: New York Times
         Date: 2025-01-26
         """
         let grid = "AB\nCD"
         let clues = """
         A1. Top ~ AB
         A3. Bottom ~ CD
 
         D1. Left ~ AC
         D2. Right ~ BD
         """
         return [metadata, grid, clues].joined(separator: "\n\n\n")
     }
 
     /// 3×3 grid with a single block at (0,2). Manually written because the
     /// open-grid helper assumes every cell is open.
     private func blockedSource() -> String {
         let metadata = """
         Title: Blocked
         Publisher: New York Times
         Date: 2025-01-26
         """
         let grid = "AB#\nDEF\nGHI"
         let clues = """
         A1. Top ~ AB
         A3. Middle ~ DEF
         A5. Bottom ~ GHI
 
         D1. Left ~ ADG
         D2. Mid ~ BEH
         D4. Right ~ FI
         """
         return [metadata, grid, clues].joined(separator: "\n\n\n")
     }
 
     /// 1×1 grid whose single cell is a rebus fill, used to check that a solution
     /// differing only in Schrödinger slash placement upgrades in place.
     private func rebusSource(fill: String) -> String {
         let metadata = """
         Title: Rebus
         Publisher: New York Times
         Date: 2025-01-26
         Rebus: 1=\(fill)
         """
         let clues = """
         A1. Clue ~ \(fill)
         D1. Clue ~ \(fill)
         """
         return [metadata, "1", clues].joined(separator: "\n\n\n")
     }
 
     // MARK: - Outcomes
 
     @Test("Materialised Chronicles are not re-fetched as writable NYT games")
     @MainActor
     func materializedChronicleHasNoUpgradePlan() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let originalID = UUID()
         let entity = GameEntity(context: persistence.viewContext)
         entity.id = Archive.archiveGameID(for: originalID)
         entity.title = "Test"
         entity.puzzleSource = openGridSource()
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.completedAt = Date()
         entity.databaseScope = 0
         entity.ckRecordName = Archive.recordName(forOriginalGameID: originalID)
         entity.ckZoneName = Archive.zoneName
         try persistence.viewContext.save()
 
         #expect(NYTPuzzleUpgrader.plan(for: entity.id!, store: store) == nil)
     }
 
     @Test("Completed owned games are not re-fetched for NYT upgrades")
     @MainActor
     func completedOwnedGameHasNoUpgradePlan() throws {
         let persistence = makeTestPersistence()
         let store = makeTestStore(persistence: persistence)
         let entity = GameEntity(context: persistence.viewContext)
         entity.id = UUID()
         entity.title = "Test"
         entity.puzzleSource = openGridSource()
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.completedAt = Date()
         entity.databaseScope = 0
         try persistence.viewContext.save()
 
         #expect(NYTPuzzleUpgrader.plan(for: entity.id!, store: store) == nil)
     }
 
     @Test("Clue-only diff is .upgraded — grid + solutions match")
     func clueOnlyDiffIsUpgraded() async {
         let old = openGridSource(clueAcross1: "[aria-label] Old prefix")
         let new = openGridSource(clueAcross1: "Old prefix")
         let outcome = await NYTPuzzleUpgrader.upgrade(
             date: Date(),
             currentSource: old,
             fetch: { _ in new }
         )
         guard case .upgraded(let returned) = outcome else {
             Issue.record("Expected .upgraded but got \(outcome)")
             return
         }
         #expect(returned == new)
     }
 
     @Test("Solution diff is .mismatched")
     func solutionDiffIsMismatched() async {
         let old = openGridSource()
         let new = openGridSource(gridRows: ["ABC", "DEF", "GHJ"])
         let outcome = await NYTPuzzleUpgrader.upgrade(
             date: Date(),
             currentSource: old,
             fetch: { _ in new }
         )
         if case .mismatched = outcome { return }
         Issue.record("Expected .mismatched but got \(outcome)")
     }
 
     @Test("Any rebus fill change is .upgraded — slash re-representation or otherwise")
     func rebusFillChangeIsUpgraded() async {
         // Rebus diffs are presumed to be converter fixes and defer to the
         // fresh conversion — refusing them would keep a broken conversion in
         // place forever. Even a wholly different fill replaces the source;
         // a stale existing fill at that square is the accepted cost.
         for (old, new) in [("HITMISS", "HIT/MISS"), ("LOVE", "HATE")] {
             let outcome = await NYTPuzzleUpgrader.upgrade(
                 date: Date(),
                 currentSource: rebusSource(fill: old),
                 fetch: { _ in rebusSource(fill: new) }
             )
             guard case .upgraded(let returned) = outcome else {
                 Issue.record("Expected .upgraded for \(old)→\(new) but got \(outcome)")
                 return
             }
             #expect(returned == rebusSource(fill: new))
         }
     }
 
     @Test("Block-pattern diff is .mismatched")
     func blockPatternDiffIsMismatched() async {
         let old = openGridSource()
         let new = blockedSource()
         let outcome = await NYTPuzzleUpgrader.upgrade(
             date: Date(),
             currentSource: old,
             fetch: { _ in new }
         )
         if case .mismatched = outcome { return }
         Issue.record("Expected .mismatched but got \(outcome)")
     }
 
     @Test("Dimensions diff is .mismatched")
     func dimensionsDiffIsMismatched() async {
         let old = openGridSource()
         let new = smallGridSource()
         let outcome = await NYTPuzzleUpgrader.upgrade(
             date: Date(),
             currentSource: old,
             fetch: { _ in new }
         )
         if case .mismatched = outcome { return }
         Issue.record("Expected .mismatched but got \(outcome)")
     }
 
     @Test("Fetcher throwing is .failed")
     func fetcherThrowingIsFailed() async {
         struct StubError: Error {}
         let old = openGridSource()
         let outcome = await NYTPuzzleUpgrader.upgrade(
             date: Date(),
             currentSource: old,
             fetch: { _ in throw StubError() }
         )
         if case .failed = outcome { return }
         Issue.record("Expected .failed but got \(outcome)")
     }
 }