crossmate

GameSummaryThumbnailTests.swift (7284B)

---

 import CoreData
 import Foundation
 import Testing
 
 @testable import Crossmate
 
 /// Pins down `GameSummary`'s thumbnail derivation. An in-progress game's
 /// thumbnail mirrors the `CellEntity` cache, but a completed game is terminal
 /// and always renders solved (restore seals it to the solution), so its
 /// thumbnail must come from the completion latch — the raw merge behind the
 /// cache can permanently lack the winning letter when a clear stamped after
 /// the latch wins LWW.
 @Suite("GameSummary thumbnail")
 @MainActor
 struct GameSummaryThumbnailTests {
 
     private static let puzzleSource = """
     Title: Test Puzzle
     Author: Test
 
 
     ABC
     D#E
     FGH
 
 
     A1. Across 1 ~ ABC
     A4. Across 4 ~ DE
     A5. Across 5 ~ FGH
     D1. Down 1 ~ ADF
     D2. Down 2 ~ BG
     D3. Down 3 ~ CEH
     """
 
     private func makeGame(in ctx: NSManagedObjectContext) throws -> GameEntity {
         let xd = try XD.parse(Self.puzzleSource)
         let puzzle = Puzzle(xd: xd)
 
         let entity = GameEntity(context: ctx)
         entity.id = UUID()
         entity.title = "Thumbnail"
         entity.puzzleSource = Self.puzzleSource
         entity.createdAt = Date()
         entity.updatedAt = Date()
         entity.populateCachedSummaryFields(from: puzzle)
         return entity
     }
 
     private func addCell(
         _ letter: String,
         row: Int16,
         col: Int16,
         to entity: GameEntity,
         in ctx: NSManagedObjectContext,
         authorID: String? = nil,
         mark: CellMark = .none
     ) {
         let cell = CellEntity(context: ctx)
         cell.game = entity
         cell.row = row
         cell.col = col
         cell.letter = letter
         cell.letterAuthorID = authorID
         cell.markCode = mark.code
     }
 
     private func addPlayer(
         authorID: String,
         name: String,
         to entity: GameEntity,
         in ctx: NSManagedObjectContext
     ) {
         let player = PlayerEntity(context: ctx)
         player.game = entity
         player.authorID = authorID
         player.name = name
         player.ckRecordName = "player-\(authorID)"
         player.updatedAt = Date()
     }
 
     private func addMoves(
         authorID: String,
         to entity: GameEntity,
         in ctx: NSManagedObjectContext
     ) {
         let moves = MovesEntity(context: ctx)
         moves.game = entity
         moves.authorID = authorID
         moves.deviceID = "device-\(authorID)"
         moves.cells = Data()
         moves.updatedAt = Date()
         moves.ckRecordName = "moves-\(authorID)"
     }
 
     @Test("In-progress thumbnail mirrors the CellEntity cache")
     func inProgressThumbnailMirrorsCache() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let entity = try makeGame(in: ctx)
         addCell("A", row: 0, col: 0, to: entity, in: ctx)
         addCell("", row: 2, col: 2, to: entity, in: ctx)
         try ctx.save()
 
         let summary = try #require(GameSummary(entity: entity))
         #expect(summary.thumbnailCells == [
             .filled, .empty, .empty,
             .empty, .block, .empty,
             .empty, .empty, .empty,
         ])
     }
 
     @Test("Completed thumbnail is full even when the cache has a hole")
     func completedThumbnailIgnoresCacheHoles() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let entity = try makeGame(in: ctx)
         // The winning letter never reached the durable merge: its cell holds
         // an empty tombstone and another square has no row at all.
         addCell("A", row: 0, col: 0, to: entity, in: ctx)
         addCell("", row: 2, col: 2, to: entity, in: ctx)
         entity.completedAt = Date()
         try ctx.save()
 
         let summary = try #require(GameSummary(entity: entity))
         #expect(summary.thumbnailCells == [
             .filled, .filled, .filled,
             .filled, .block, .filled,
             .filled, .filled, .filled,
         ])
     }
 
     @Test("Shared summary lists remote participants with deterministic colours")
     func sharedSummaryListsRemoteParticipants() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let entity = try makeGame(in: ctx)
         entity.ckShareRecordName = "cloudkit.zoneshare"
         addPlayer(authorID: "_Local", name: "Local", to: entity, in: ctx)
         addPlayer(authorID: "_Alice", name: "Alice", to: entity, in: ctx)
         addMoves(authorID: "_Bob", to: entity, in: ctx)
 
         let friend = FriendEntity(context: ctx)
         friend.authorID = "_Alice"
         friend.createdAt = Date()
         friend.databaseScope = 0
         friend.displayName = "Alice"
         friend.displayNameVersion = 0
         friend.friendZoneName = "friend-zone"
         friend.friendZoneOwnerName = "_Local"
         friend.isBlocked = false
         friend.nickname = "Ace"
         friend.nicknameVersion = 1
         friend.pairKey = "pair"
         try ctx.save()
 
         let summary = try #require(GameSummary(
             entity: entity,
             localAuthorID: "_Local",
             localName: "Local Player",
             localColor: .blue
         ))
 
         #expect(summary.allParticipants.map(\.authorID) == ["_Local", "_Alice", "_Bob"])
         #expect(summary.allParticipants.map(\.name) == ["Local Player", "Ace", "Waiting for player..."])
         #expect(summary.allParticipants.map(\.isLocal) == [true, false, false])
         let remoteParticipants = summary.allParticipants.filter { !$0.isLocal }
         // Collaborators are de-conflicted within the game, so the two remotes
         // get distinct colours and neither collides with the local 'blue'.
         #expect(!remoteParticipants.map(\.color.id).contains(PlayerColor.blue.id))
         #expect(Set(remoteParticipants.map(\.color.id)).count == 2)
     }
 
     @Test("Shared strip includes local player and orders by score")
     func sharedStripIncludesLocalPlayerAndOrdersByScore() throws {
         let persistence = makeTestPersistence()
         let ctx = persistence.viewContext
         let entity = try makeGame(in: ctx)
         entity.ckShareRecordName = "cloudkit.zoneshare"
         addPlayer(authorID: "_Local", name: "Local", to: entity, in: ctx)
         addPlayer(authorID: "_Alice", name: "Alice", to: entity, in: ctx)
         addPlayer(authorID: "_Bob", name: "Bob", to: entity, in: ctx)
         addCell("A", row: 0, col: 0, to: entity, in: ctx, authorID: "_Alice")
         addCell("B", row: 0, col: 1, to: entity, in: ctx, authorID: "_Local")
         addCell("C", row: 0, col: 2, to: entity, in: ctx, authorID: "_Bob")
         addCell("D", row: 1, col: 0, to: entity, in: ctx, authorID: "_Alice")
         addCell("F", row: 2, col: 0, to: entity, in: ctx, authorID: "_Bob", mark: .revealed)
         try ctx.save()
 
         let summary = try #require(GameSummary(
             entity: entity,
             localAuthorID: "_Local",
             localName: "Local Player",
             localColor: .blue
         ))
 
         #expect(summary.stripParticipants.map(\.authorID) == ["_Alice", "_Bob", "_Local"])
         #expect(summary.stripParticipants.map(\.isLocal) == [false, false, true])
         #expect(summary.stripParticipants.map(\.color.id).contains(PlayerColor.blue.id))
     }
 }