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.
697 lines
29 KiB
Swift
697 lines
29 KiB
Swift
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)
|
||
}
|