Files
shotdeck/Tests/ShotdeckCoreTests/PDFComposerTests.swift
T
Claude Fable 5 02fa791b78 feat(sessions): keep every session, record review details, name and stamp the PDF
Sessions are now the unit of the product instead of an implicit capture run.

- Nothing is deleted by default: the fixed 10-session cap is gone. An age limit
  (Never / 7 / 14 / 30 / 90 / 180 / 365 days) is chosen in Settings > Sessions and
  applied on launch, after archiving, and by "Clean up now". Sent PDFs are never
  touched.
- Each session carries review details: lane, deployed version, commit, reviewer
  (pre-filled with the Mac user) and a free note. They persist in session.json and
  are inherited by the next session, so a review run is typed once.
- PDF file names are Redline-<yyyyMMdd-HHmm>-<LANE>-<SHORTID>.pdf, and every page
  carries a two-line reference footer (tool, build time, session / lane, deployed
  build, commit, reviewer, note). The PDF document info carries the same values in
  Author and Keywords.
- Verification: 159 tests, a headless panel self-test, and a LaunchServices-driven
  end-to-end run that types and clicks the real panel.
2026-10-31 11:32:54 +04:00

697 lines
29 KiB
Swift
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import CoreGraphics
import Foundation
import ImageIO
import PDFKit
import ShotdeckCore
import Testing
import UniformTypeIdentifiers
enum TestFixtureError: Error { case cannotCreateBitmap, cannotCreatePNG, cannotFinalizePNG }
func writeSolidPNG(
pixelWidth: Int,
pixelHeight: Int,
red: UInt8,
green: UInt8,
blue: UInt8,
to url: URL
) throws {
let colorSpace = CGColorSpaceCreateDeviceRGB()
guard let context = CGContext(
data: nil,
width: pixelWidth,
height: pixelHeight,
bitsPerComponent: 8,
bytesPerRow: pixelWidth * 4,
space: colorSpace,
bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
) else { throw TestFixtureError.cannotCreateBitmap }
context.setFillColor(CGColor(
red: CGFloat(red) / 255,
green: CGFloat(green) / 255,
blue: CGFloat(blue) / 255,
alpha: 1
))
context.fill(CGRect(x: 0, y: 0, width: pixelWidth, height: pixelHeight))
guard let image = context.makeImage(),
let destination = CGImageDestinationCreateWithURL(
url as CFURL,
UTType.png.identifier as CFString,
1,
nil
)
else { throw TestFixtureError.cannotCreatePNG }
CGImageDestinationAddImage(destination, image, nil)
guard CGImageDestinationFinalize(destination) else { throw TestFixtureError.cannotFinalizePNG }
}
private let fixtureDate = Date(timeIntervalSince1970: 1_777_482_180)
private func makeCapture(
sequence: Int,
pixelWidth: Int,
pixelHeight: Int,
scale: CGFloat = 1,
capturedAt: Date = fixtureDate,
id: UUID = UUID(),
fileName: String? = nil
) -> Capture {
Capture(
id: id,
sequence: sequence,
fileName: fileName ?? String(format: "%03d.png", sequence),
pixelWidth: pixelWidth,
pixelHeight: pixelHeight,
scale: scale,
capturedAt: capturedAt
)
}
private func makeSession(
captures: [Capture],
id: UUID = UUID(),
createdAt: Date = fixtureDate
) -> CaptureSession {
CaptureSession(
id: id,
createdAt: createdAt,
state: .open,
captures: captures,
pdfFileName: nil
)
}
private func makeScratchDirectory() throws -> URL {
let url = FileManager.default.temporaryDirectory
.appendingPathComponent("shotdeck-pdf-\(UUID().uuidString)", isDirectory: true)
try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
return url
}
private func writePNG(
for capture: Capture,
red: UInt8,
green: UInt8,
blue: UInt8,
in directory: URL
) throws -> URL {
let url = directory.appendingPathComponent(capture.fileName)
try writeSolidPNG(
pixelWidth: capture.pixelWidth,
pixelHeight: capture.pixelHeight,
red: red,
green: green,
blue: blue,
to: url
)
return url
}
private func imageURLMap(_ urls: [UUID: URL]) -> (Capture) -> URL {
{ capture in
urls[capture.id] ?? URL(fileURLWithPath: "/nonexistent/\(capture.id.uuidString).png")
}
}
private func openDocument(_ url: URL) throws -> PDFDocument {
let document = try #require(PDFDocument(url: url))
return document
}
private func pdftoppm(pdf: URL, prefix: URL) throws {
let process = Process()
process.executableURL = URL(fileURLWithPath: "/opt/homebrew/bin/pdftoppm")
process.arguments = ["-png", "-r", "110", pdf.path, prefix.path]
let err = Pipe()
process.standardError = err
try process.run()
process.waitUntilExit()
guard process.terminationStatus == 0 else {
let message = String(data: err.fileHandleForReading.readDataToEndOfFile(), encoding: .utf8) ?? ""
throw ShotdeckError.pdfCompositionFailed(reason: "pdftoppm failed: \(message)")
}
}
private struct RGBABitmap {
let width: Int
let height: Int
let bytesPerRow: Int
let data: Data
func pixel(x: Int, y: Int) -> (UInt8, UInt8, UInt8)? {
guard x >= 0, y >= 0, x < width, y < height else { return nil }
let offset = y * bytesPerRow + x * 4
guard offset + 2 < data.count else { return nil }
return (data[offset], data[offset + 1], data[offset + 2])
}
func containsNonWhite(x0: Int, y0: Int, x1: Int, y1: Int) -> Bool {
let xStart = max(0, x0)
let yStart = max(0, y0)
let xEnd = min(width, x1)
let yEnd = min(height, y1)
guard xStart < xEnd, yStart < yEnd else { return false }
for y in yStart..<yEnd {
for x in xStart..<xEnd {
if let (r, g, b) = pixel(x: x, y: y), r != 255 || g != 255 || b != 255 {
return true
}
}
}
return false
}
static func loadPNG(at url: URL) throws -> RGBABitmap {
let colorSpace = CGColorSpaceCreateDeviceRGB()
let source = try #require(CGImageSourceCreateWithURL(url as CFURL, nil))
let image = try #require(CGImageSourceCreateImageAtIndex(source, 0, nil))
let width = image.width
let height = image.height
let bytesPerRow = width * 4
var data = Data(count: bytesPerRow * height)
try data.withUnsafeMutableBytes { raw in
guard let base = raw.baseAddress else {
throw TestFixtureError.cannotCreateBitmap
}
guard let context = CGContext(
data: base,
width: width,
height: height,
bitsPerComponent: 8,
bytesPerRow: bytesPerRow,
space: colorSpace,
bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
) else {
throw TestFixtureError.cannotCreateBitmap
}
context.interpolationQuality = .none
context.draw(image, in: CGRect(x: 0, y: 0, width: width, height: height))
}
return RGBABitmap(width: width, height: height, bytesPerRow: bytesPerRow, data: data)
}
}
private func pixelWindow(
for rect: CGRect,
pageHeightPt: CGFloat,
scale k: CGFloat
) -> (x0: Int, y0: Int, x1: Int, y1: Int) {
let pixelX0 = Int(floor(rect.minX * k))
let pixelX1 = Int(ceil(rect.maxX * k))
let pixelY0 = Int(floor((pageHeightPt - rect.maxY) * k))
let pixelY1 = Int(ceil((pageHeightPt - rect.minY) * k))
return (pixelX0, pixelY0, pixelX1, pixelY1)
}
@Test("fileName is Redline-yyyyMMdd-HHmm-SHORTID.pdf and uses compose time")
func fileNameUsesComposeTimeNotSessionCreatedAt() {
let old = Date(timeIntervalSince1970: 1_600_000_000) // 2020-09-13
let session = makeSession(captures: [], createdAt: old)
let name = PDFComposer.fileName(for: session)
#expect(name.wholeMatch(of: /^Redline-\d{8}-\d{4}-[0-9A-F]{8}\.pdf$/) != nil)
#expect(name.contains(session.shortID))
#expect(!name.contains(DubaiTime.fileMinuteStamp(old)))
let today = String(DubaiTime.fileMinuteStamp(Date()).prefix(8))
#expect(name.contains(today))
}
@Test("fileName carries the lane slug between the timestamp and the session id")
func fileNameCarriesTheLaneSlug() {
let session = CaptureSession(
id: UUID(uuidString: "4f2a9c1d-0000-4000-8000-000000000000")!,
createdAt: fixtureDate,
state: .open,
captures: [],
pdfFileName: nil,
context: ReviewContext(lane: "OMS test lane"))
let name = PDFComposer.fileName(for: session)
#expect(name.wholeMatch(of: /^Redline-\d{8}-\d{4}-OMS-TEST-LANE-4F2A9C1D\.pdf$/) != nil)
}
@Test("Review footer lines state the tool, date, session and the recorded review details")
func footerLinesStateTheReviewDetails() {
let session = CaptureSession(
id: UUID(uuidString: "4f2a9c1d-0000-4000-8000-000000000000")!,
createdAt: fixtureDate,
state: .open,
captures: [],
pdfFileName: nil,
context: ReviewContext(
lane: "dev03", deployedVersion: "v1.4.2 (41)", commit: "a1b2c3d4",
reviewer: "Ben Hippler", note: "checkout"))
let lines = PDFComposer.footerLines(
session: session, toolVersion: "0.5.0", composedAt: fixtureDate)
#expect(lines.count == 2)
#expect(lines[0].contains("Redline 0.5.0"))
#expect(lines[0].contains("Session 4F2A9C1D"))
#expect(lines[0].contains(DubaiTime.stamp(fixtureDate)))
#expect(lines[1].contains("Lane dev03"))
#expect(lines[1].contains("Deployed v1.4.2 (41)"))
#expect(lines[1].contains("Commit a1b2c3d4"))
#expect(lines[1].contains("Reviewer Ben Hippler"))
#expect(lines[1].contains("Note checkout"))
// A session with no recorded details still identifies itself; nothing is faked.
let bare = makeSession(captures: [])
let bareLines = PDFComposer.footerLines(
session: bare, toolVersion: "", composedAt: fixtureDate)
#expect(bareLines.count == 1)
#expect(bareLines[0].hasPrefix("Redline · "))
}
@Test("Document info carries the reviewer and the lane/build/commit keywords")
func documentInfoCarriesTheReviewDetails() {
let session = CaptureSession(
id: UUID(uuidString: "deadbeef-dead-4eef-8ead-deadbeef0001")!,
createdAt: fixtureDate,
state: .open,
captures: [],
pdfFileName: nil,
context: ReviewContext(
lane: "DEV03", deployedVersion: "v1.4.2", commit: "a1b2c3d4",
reviewer: "Ben Hippler", note: "checkout"))
let info = PDFComposer.documentInfo(
session: session, title: "Redline – DEV03", toolVersion: "0.5.0", composedAt: fixtureDate)
#expect(info[kCGPDFContextAuthor as String] as? String == "Ben Hippler")
#expect(info[kCGPDFContextCreator as String] as? String == "Redline 0.5.0")
let keywords = try? #require(info[kCGPDFContextKeywords as String] as? String)
#expect(keywords?.contains("lane=DEV03") == true)
#expect(keywords?.contains("deployed=v1.4.2") == true)
#expect(keywords?.contains("commit=a1b2c3d4") == true)
#expect(keywords?.contains("reviewer=Ben Hippler") == true)
#expect(keywords?.contains("built=\(DubaiTime.keywordStamp(fixtureDate))") == true)
}
@Test("A composed PDF carries the footer text and document info a reader can see")
func composedPDFCarriesTheReferenceBlock() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let capture = makeCapture(sequence: 1, pixelWidth: 800, pixelHeight: 600)
let png = try writePNG(for: capture, red: 60, green: 60, blue: 60, in: directory)
let session = CaptureSession(
id: UUID(uuidString: "4f2a9c1d-0000-4000-8000-000000000000")!,
createdAt: fixtureDate,
state: .open,
captures: [capture],
pdfFileName: nil,
context: ReviewContext(
lane: "dev03", deployedVersion: "v1.4.2", commit: "a1b2c3d4",
reviewer: "Ben Hippler", note: "checkout"))
let output = directory.appendingPathComponent("footer.pdf")
_ = try PDFComposer().compose(
session: session,
imageURL: { _ in png },
title: "Redline – dev03",
to: output,
toolVersion: "0.5.0",
composedAt: fixtureDate
)
let document = try openDocument(output)
let pageText = try #require(document.page(at: 0)?.string ?? "")
#expect(pageText.contains("Redline 0.5.0"))
#expect(pageText.contains("Lane dev03"))
#expect(pageText.contains("Commit a1b2c3d4"))
#expect(pageText.contains("Ben Hippler"))
let attributes = try #require(document.documentAttributes)
#expect(attributes[PDFDocumentAttribute.authorAttribute] as? String == "Ben Hippler")
}
@Test("Three-page basic compose")
func threePageBasicCompose() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let c1 = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
let c2 = makeCapture(sequence: 2, pixelWidth: 900, pixelHeight: 1600)
let c3 = makeCapture(sequence: 3, pixelWidth: 1200, pixelHeight: 800)
let urls: [UUID: URL] = [
c1.id: try writePNG(for: c1, red: 200, green: 20, blue: 20, in: directory),
c2.id: try writePNG(for: c2, red: 20, green: 200, blue: 20, in: directory),
c3.id: try writePNG(for: c3, red: 20, green: 20, blue: 200, in: directory),
]
let session = makeSession(captures: [c1, c2, c3])
let output = directory.appendingPathComponent("three.pdf")
let pageCount = try PDFComposer().compose(
session: session,
imageURL: imageURLMap(urls),
title: "Three page",
to: output
)
#expect(pageCount == 3)
let document = try openDocument(output)
#expect(document.pageCount == 3)
let p0 = try #require(document.page(at: 0))
let p1 = try #require(document.page(at: 1))
let p2 = try #require(document.page(at: 2))
#expect(p0.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 842, height: 595))
#expect(p1.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
#expect(p2.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 842, height: 595))
}
@Test("Wide/tall page geometry exact")
func wideTallPageGeometryExact() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let wide = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
let tall = makeCapture(sequence: 1, pixelWidth: 900, pixelHeight: 1600)
let wideURL = try writePNG(for: wide, red: 10, green: 10, blue: 10, in: directory)
let tallURL = try writePNG(for: tall, red: 10, green: 10, blue: 10, in: directory)
let wideOut = directory.appendingPathComponent("wide.pdf")
_ = try PDFComposer().compose(
session: makeSession(captures: [wide]),
imageURL: { _ in wideURL },
title: "Wide",
to: wideOut
)
let tallOut = directory.appendingPathComponent("tall.pdf")
_ = try PDFComposer().compose(
session: makeSession(captures: [tall]),
imageURL: { _ in tallURL },
title: "Tall",
to: tallOut
)
let widePage = try #require(openDocument(wideOut).page(at: 0))
let tallPage = try #require(openDocument(tallOut).page(at: 0))
#expect(widePage.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 842, height: 595))
#expect(tallPage.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
}
@Test("Square resolves to portrait (Capture.swift:39-42 isLandscape strict >)")
func squareResolvesToPortrait() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let square = makeCapture(sequence: 1, pixelWidth: 1000, pixelHeight: 1000)
let png = try writePNG(for: square, red: 80, green: 80, blue: 80, in: directory)
let output = directory.appendingPathComponent("square.pdf")
_ = try PDFComposer().compose(
session: makeSession(captures: [square]),
imageURL: { _ in png },
title: "Square",
to: output
)
let page = try #require(openDocument(output).page(at: 0))
#expect(page.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
}
@Test("Retina capture uses point size, not pixel size")
func retinaCaptureUsesPointSize() throws {
let capture = makeCapture(sequence: 1, pixelWidth: 2880, pixelHeight: 1620, scale: 2.0)
let layout = PageLayout(capture: capture, pageIndex: 1, pageCount: 1)
let expectedScale = min(806.0 / 1440.0, 523.0 / 810.0, 1.0)
let expected = CGSize(width: 1440.0 * expectedScale, height: 810.0 * expectedScale)
#expect(abs(layout.imageRect.width - expected.width) < 0.01)
#expect(abs(layout.imageRect.height - expected.height) < 0.01)
#expect(layout.imageRect.width < 2000)
#expect(layout.isLandscape)
}
@Test("Zero PDFAnnotation objects on every page")
func zeroPDFAnnotationObjects() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let c1 = makeCapture(sequence: 1, pixelWidth: 800, pixelHeight: 600)
let c2 = makeCapture(sequence: 2, pixelWidth: 600, pixelHeight: 800)
let c3 = makeCapture(sequence: 3, pixelWidth: 1000, pixelHeight: 1000)
let urls: [UUID: URL] = [
c1.id: try writePNG(for: c1, red: 30, green: 30, blue: 30, in: directory),
c2.id: try writePNG(for: c2, red: 40, green: 40, blue: 40, in: directory),
c3.id: try writePNG(for: c3, red: 50, green: 50, blue: 50, in: directory),
]
let output = directory.appendingPathComponent("no-annots.pdf")
_ = try PDFComposer().compose(
session: makeSession(captures: [c1, c2, c3]),
imageURL: imageURLMap(urls),
title: "No annotations",
to: output
)
let document = try openDocument(output)
#expect(document.pageCount == 3)
for index in 0..<document.pageCount {
let page = try #require(document.page(at: index))
#expect(page.annotations.isEmpty)
}
}
@Test("Mixed orientations coexist, unnormalised")
func mixedOrientationsCoexist() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let wide = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
let tall = makeCapture(sequence: 2, pixelWidth: 900, pixelHeight: 1600)
let square = makeCapture(sequence: 3, pixelWidth: 1000, pixelHeight: 1000)
let urls: [UUID: URL] = [
wide.id: try writePNG(for: wide, red: 90, green: 10, blue: 10, in: directory),
tall.id: try writePNG(for: tall, red: 10, green: 90, blue: 10, in: directory),
square.id: try writePNG(for: square, red: 10, green: 10, blue: 90, in: directory),
]
let output = directory.appendingPathComponent("mixed.pdf")
_ = try PDFComposer().compose(
session: makeSession(captures: [wide, tall, square]),
imageURL: imageURLMap(urls),
title: "Mixed",
to: output
)
let document = try openDocument(output)
#expect(document.pageCount == 3)
let p0 = try #require(document.page(at: 0))
let p1 = try #require(document.page(at: 1))
let p2 = try #require(document.page(at: 2))
#expect(p0.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 842, height: 595))
#expect(p1.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
#expect(p2.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
}
@Test("No cover page, no before/after, exactly one page per capture")
func noCoverPageExactlyOnePagePerCapture() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let c1 = makeCapture(sequence: 1, pixelWidth: 800, pixelHeight: 500)
let c2 = makeCapture(sequence: 2, pixelWidth: 500, pixelHeight: 800)
let urls: [UUID: URL] = [
c1.id: try writePNG(for: c1, red: 12, green: 12, blue: 12, in: directory),
c2.id: try writePNG(for: c2, red: 22, green: 22, blue: 22, in: directory),
]
let output = directory.appendingPathComponent("two.pdf")
let pageCount = try PDFComposer().compose(
session: makeSession(captures: [c1, c2]),
imageURL: imageURLMap(urls),
title: "Two",
to: output
)
#expect(pageCount == 2)
#expect(try openDocument(output).pageCount == 2)
}
@Test("Small image is never upscaled")
func smallImageIsNeverUpscaled() throws {
let capture = makeCapture(sequence: 1, pixelWidth: 200, pixelHeight: 150)
let layout = PageLayout(capture: capture, pageIndex: 1, pageCount: 1)
#expect(layout.imageRect.size == CGSize(width: 200, height: 150))
}
@Test("Empty session throws, produces nothing on disk")
func emptySessionThrowsProducesNothing() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let output = directory.appendingPathComponent("empty.pdf")
var threwCompositionFailed = false
do {
_ = try PDFComposer().compose(
session: makeSession(captures: []),
imageURL: { _ in directory.appendingPathComponent("missing.png") },
title: "Empty",
to: output
)
} catch ShotdeckError.pdfCompositionFailed {
threwCompositionFailed = true
}
#expect(threwCompositionFailed)
#expect(!FileManager.default.fileExists(atPath: output.path))
let leftover = try FileManager.default.contentsOfDirectory(atPath: directory.path)
#expect(leftover.isEmpty)
}
@Test("A missing PNG is skipped, page count drops, document still opens")
func missingPNGIsSkipped() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let first = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
let missing = makeCapture(sequence: 2, pixelWidth: 800, pixelHeight: 600)
let third = makeCapture(sequence: 3, pixelWidth: 900, pixelHeight: 1600)
let firstURL = try writePNG(for: first, red: 220, green: 10, blue: 10, in: directory)
let thirdURL = try writePNG(for: third, red: 10, green: 10, blue: 220, in: directory)
let missingURL = directory.appendingPathComponent("does-not-exist.png")
let urls: [UUID: URL] = [
first.id: firstURL,
missing.id: missingURL,
third.id: thirdURL,
]
let output = directory.appendingPathComponent("skip-missing.pdf")
let pageCount = try PDFComposer().compose(
session: makeSession(captures: [first, missing, third]),
imageURL: imageURLMap(urls),
title: "Skip missing",
to: output
)
#expect(pageCount == 2)
let document = try openDocument(output)
#expect(document.pageCount == 2)
let p0 = try #require(document.page(at: 0))
let p1 = try #require(document.page(at: 1))
#expect(p0.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 842, height: 595))
#expect(p1.bounds(for: .mediaBox) == CGRect(x: 0, y: 0, width: 595, height: 842))
// Distinct fill colors sampled from pdftoppm at each imageRect center.
let prefix = directory.appendingPathComponent("skip-missing")
try pdftoppm(pdf: output, prefix: prefix)
let page1PNG = directory.appendingPathComponent("skip-missing-1.png")
let page2PNG = directory.appendingPathComponent("skip-missing-2.png")
let bitmap1 = try RGBABitmap.loadPNG(at: page1PNG)
let bitmap2 = try RGBABitmap.loadPNG(at: page2PNG)
let k = 110.0 / 72.0
let layout1 = PageLayout(capture: first, pageIndex: 1, pageCount: 2)
let layout2 = PageLayout(capture: third, pageIndex: 2, pageCount: 2)
let c1 = try #require(bitmap1.pixel(
x: Int((layout1.imageRect.midX * k).rounded()),
y: Int(((layout1.pageRect.height - layout1.imageRect.midY) * k).rounded())
))
let c2 = try #require(bitmap2.pixel(
x: Int((layout2.imageRect.midX * k).rounded()),
y: Int(((layout2.pageRect.height - layout2.imageRect.midY) * k).rounded())
))
#expect(c1.0 > 150 && c1.1 < 80 && c1.2 < 80)
#expect(c2.2 > 150 && c2.0 < 80 && c2.1 < 80)
}
@Test("An unreadable (corrupt) PNG is treated exactly like a missing one (D-A)")
func unreadablePNGIsSkippedLikeMissing() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let good = makeCapture(sequence: 1, pixelWidth: 800, pixelHeight: 500)
let bad = makeCapture(sequence: 2, pixelWidth: 800, pixelHeight: 500)
let goodURL = try writePNG(for: good, red: 30, green: 140, blue: 30, in: directory)
let badURL = directory.appendingPathComponent("corrupt.png")
try Data([0x00, 0x01, 0x02, 0xFF, 0xD8, 0x00]).write(to: badURL)
let urls: [UUID: URL] = [good.id: goodURL, bad.id: badURL]
let output = directory.appendingPathComponent("skip-corrupt.pdf")
let pageCount = try PDFComposer().compose(
session: makeSession(captures: [good, bad]),
imageURL: imageURLMap(urls),
title: "Skip corrupt",
to: output
)
#expect(pageCount == 1)
let document = try openDocument(output)
#expect(document.pageCount == 1)
}
@Test("Document attributes round-trip exactly")
func documentAttributesRoundTrip() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let sessionID = try #require(UUID(uuidString: "deadbeef-dead-4eef-8ead-deadbeef0001"))
let capture = makeCapture(sequence: 1, pixelWidth: 640, pixelHeight: 480)
let png = try writePNG(for: capture, red: 40, green: 40, blue: 40, in: directory)
let output = directory.appendingPathComponent("attrs.pdf")
_ = try PDFComposer().compose(
session: makeSession(captures: [capture], id: sessionID),
imageURL: { _ in png },
title: "Ben review — 2026-08-30",
to: output
)
let document = try openDocument(output)
let attributes = try #require(document.documentAttributes)
#expect(attributes[PDFDocumentAttribute.creatorAttribute] as? String == "Redline")
#expect(attributes[PDFDocumentAttribute.titleAttribute] as? String == "Ben review — 2026-08-30")
#expect(attributes[PDFDocumentAttribute.subjectAttribute] as? String == "deadbeef-dead-4eef-8ead-deadbeef0001")
#expect(document.pageCount == 1)
#expect(try #require(document.page(at: 0)).annotations.isEmpty)
}
@Test("Rendered page is not blank (pdftoppm, pinned renderer + rounding)")
func renderedPageIsNotBlank() throws {
let directory = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: directory) }
let capture = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
let png = try writePNG(for: capture, red: 128, green: 128, blue: 128, in: directory)
let output = directory.appendingPathComponent("not-blank.pdf")
_ = try PDFComposer().compose(
session: makeSession(captures: [capture]),
imageURL: { _ in png },
title: "Not blank",
to: output
)
let prefix = directory.appendingPathComponent("not-blank")
try pdftoppm(pdf: output, prefix: prefix)
let rendered = directory.appendingPathComponent("not-blank-1.png")
let bitmap = try RGBABitmap.loadPNG(at: rendered)
let layout = PageLayout(capture: capture, pageIndex: 1, pageCount: 1)
let k: CGFloat = 110.0 / 72.0
let imageWin = pixelWindow(for: layout.imageRect, pageHeightPt: layout.pageRect.height, scale: k)
let headerWin = pixelWindow(for: layout.headerRect, pageHeightPt: layout.pageRect.height, scale: k)
#expect(bitmap.containsNonWhite(x0: imageWin.x0, y0: imageWin.y0, x1: imageWin.x1, y1: imageWin.y1))
#expect(bitmap.containsNonWhite(x0: headerWin.x0, y0: headerWin.y0, x1: headerWin.x1, y1: headerWin.y1))
}
@Test("Right-edge tick group geometry matches D-12 exactly, both orientations")
func rightEdgeTickGroupGeometry() throws {
let landscape = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
let portrait = makeCapture(sequence: 1, pixelWidth: 900, pixelHeight: 1600)
let landscapeLayout = PageLayout(capture: landscape, pageIndex: 1, pageCount: 1)
let portraitLayout = PageLayout(capture: portrait, pageIndex: 1, pageCount: 1)
#expect(landscapeLayout.failTickBox.maxX == 824)
#expect(landscapeLayout.headerRect.maxX == 824)
#expect(portraitLayout.failTickBox.maxX == 577)
#expect(portraitLayout.headerRect.maxX == 577)
#expect(landscapeLayout.failTickBox.width == 13)
#expect(landscapeLayout.failTickBox.height == 13)
#expect(portraitLayout.failTickBox.width == 13)
#expect(portraitLayout.failTickBox.height == 13)
#expect(landscapeLayout.passTickBox.maxX == landscapeLayout.failLabelOrigin.x - 8)
#expect(portraitLayout.passTickBox.maxX == portraitLayout.failLabelOrigin.x - 8)
}
@Test("Writes visual sample for review")
func writesVisualSampleForReview() throws {
let verifyDir = URL(fileURLWithPath: "/Users/benjaminhippler/mmd-projects/multi-agent-runs/shotdeck-20260830/verify")
try FileManager.default.createDirectory(at: verifyDir, withIntermediateDirectories: true)
let scratch = try makeScratchDirectory()
defer { try? FileManager.default.removeItem(at: scratch) }
let wide = makeCapture(sequence: 1, pixelWidth: 1600, pixelHeight: 900)
let tall = makeCapture(sequence: 2, pixelWidth: 900, pixelHeight: 1600)
let retina = makeCapture(sequence: 3, pixelWidth: 2880, pixelHeight: 1620, scale: 2.0)
let urls: [UUID: URL] = [
wide.id: try writePNG(for: wide, red: 196, green: 42, blue: 42, in: scratch),
tall.id: try writePNG(for: tall, red: 32, green: 96, blue: 176, in: scratch),
retina.id: try writePNG(for: retina, red: 36, green: 148, blue: 84, in: scratch),
]
let output = verifyDir.appendingPathComponent("wp2-sample.pdf")
let pageCount = try PDFComposer().compose(
session: makeSession(captures: [wide, tall, retina]),
imageURL: imageURLMap(urls),
title: "WP-2 visual sample",
to: output
)
#expect(pageCount == 3)
let prefix = verifyDir.appendingPathComponent("wp2-sample")
try pdftoppm(pdf: output, prefix: prefix)
}