// SPDX-License-Identifier: GPL-3.0-or-later import XCTest import PDFKit import SwiftUI import CryptoKit @MainActor final class SoftwareLibraryManualTests: XCTestCase { private func fixture(id: String = "manual", pages: Int = 2, size: NSSize = NSSize(width: 300, height: 500)) throws -> (SoftwareLibraryAsset, Data) { let pdf = PDFDocument() for _ in 0.. Bool) async throws { let deadline = ContinuousClock.now + .seconds(8) while !condition() { guard ContinuousClock.now < deadline else { XCTFail(message) throw CocoaError(.fileReadUnknown) } try await Task.sleep(for: .milliseconds(10)) } } func attach(_ model: SoftwareLibraryManualModel) -> NSWindow { let window = NSWindow(contentRect: frame, styleMask: [.titled], backing: .buffered, defer: false) let host = NSHostingView(rootView: SoftwareLibraryManualView(model: model)) window.contentView = host host.layoutSubtreeIfNeeded() window.displayIfNeeded() return window } let saved: LibraryReadingPosition do { let model = SoftwareLibraryManualModel() let store = LibraryContinuityStore(directory: root) model.continuity = store let window = attach(model) defer { window.contentView = nil } XCTAssertNil(store.reading(for: key)) model.open(asset, directory: root) try await waitFor("Fresh PDF did not fit its cover in the attached reader") { model.pdfView.window === window && model.pdfView.autoScales && model.pdfView.scaleFactor > 1 && model.pdfView.currentDestination?.page != nil } XCTAssertEqual(model.page, 1) let document = try XCTUnwrap(model.document) XCTAssertTrue(model.pdfView.currentDestination?.page === document.page(at: 0)) model.goToPage(model.page + 1) try await waitFor("Next skipped the second page") { model.page == 2 && model.pdfView.currentDestination?.page === document.page(at: 1) } model.goToPage(model.page - 1) try await waitFor("Previous did not return to the cover") { model.page == 1 && model.pdfView.currentDestination?.page === document.page(at: 0) } model.pdfView.autoScales = false model.pdfView.scaleFactor = 4 let second = try XCTUnwrap(document.page(at: 1)) model.pdfView.go(to: PDFDestination(page: second, at: CGPoint(x: 60, y: 205))) try await waitFor("The user-selected location was not observed") { model.page == 2 } model.cancel() await store.flush() saved = try XCTUnwrap(store.reading(for: key)) XCTAssertEqual(saved.page, 2) XCTAssertEqual(saved.autoScales, false) XCTAssertEqual(try XCTUnwrap(saved.zoom), 4, accuracy: 0.01) XCTAssertGreaterThan(saved.offset, 0.1) XCTAssertLessThan(saved.offset, 0.95) } // Closing a different reader while its PDF has loaded but the view has // not been attached must not replace the last real position. let unopened = SoftwareLibraryManualModel() let previousStore = LibraryContinuityStore(directory: root) unopened.continuity = previousStore unopened.open(asset, directory: root) try await waitFor("Detached PDF failed to open") { unopened.document != nil } unopened.cancel() XCTAssertEqual(previousStore.reading(for: key), saved) let restored = SoftwareLibraryManualModel() let reopenedStore = LibraryContinuityStore(directory: root) restored.continuity = reopenedStore XCTAssertEqual(reopenedStore.reading(for: key), saved) let window = attach(restored) defer { window.contentView = nil } restored.open(asset, directory: root) try await waitFor("Stored PDF page and zoom were lost during attachment") { restored.page == 2 && !restored.pdfView.autoScales && abs(restored.pdfView.scaleFactor - 4) < 0.01 } let (other, otherBytes) = try fixture(id: "another-manual", pages: 3) try otherBytes.write(to: root.appendingPathComponent(try XCTUnwrap(other.sha256) + ".pdf")) restored.open(other, directory: root) try await waitFor("Switching manuals did not open a fitted cover") { restored.readingReady && restored.page == 1 && restored.pdfView.autoScales } XCTAssertEqual(restored.document?.pageCount, 3) let reopened = try XCTUnwrap(reopenedStore.reading(for: key)) XCTAssertEqual(reopened.page, saved.page) XCTAssertEqual(reopened.horizontalOffset, saved.horizontalOffset, accuracy: 0.01) XCTAssertEqual(reopened.offset, saved.offset, accuracy: 0.01) } func testCompanionManualChecksRegularFileBeforeOpening() async throws { let (asset, bytes) = try fixture() let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) defer { try? FileManager.default.removeItem(at: directory) } let original = directory.appendingPathComponent("Manual.pdf") try bytes.write(to: original) let link = directory.appendingPathComponent("Link.pdf") try FileManager.default.createSymbolicLink(at: link, withDestinationURL: original) let empty = directory.appendingPathComponent("Empty.pdf") try Data().write(to: empty) for url in [original, directory, link, empty] { let model = SoftwareLibraryManualModel() model.open(asset, directory: directory, companion: ManualCompanion(file: url)) for _ in 0..<100 where model.loading { try await Task.sleep(nanoseconds: 20_000_000) } XCTAssertFalse(model.loading) if url == original { XCTAssertEqual(model.document?.pageCount, 2) XCTAssertNil(model.error) } else { XCTAssertNil(model.document) XCTAssertNotNil(model.error, "Companion manuals must reject directories, symlinks and empty files") } } XCTAssertEqual(try Data(contentsOf: original), bytes) } func testUnsupportedManualAndCancellationDoNotCreateFiles() async throws { var (asset, _) = try fixture(); asset.manualURL = URL(string: "https://example.com/a.pdf") let directory = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) let config = URLSessionConfiguration.ephemeral; config.protocolClasses = [ManualNoNetwork.self] let cache = SoftwareLibraryManualCache(session: URLSession(configuration: config)) do { _ = try await cache.localCopy(for: asset, directory: directory); XCTFail("Invalid source") } catch SoftwareLibraryManualCache.Failure.unavailable { } let task = Task { withUnsafeCurrentTask { $0?.cancel() } return try await cache.localCopy(for: asset, directory: directory) } do { _ = try await task.value; XCTFail("Cancelled") } catch is CancellationError { } XCTAssertFalse(FileManager.default.fileExists(atPath: directory.path)) } } private struct ManualCompanion: CompanionLibraryAccess { let file: URL func libraryRequest(_ request: CompanionLibraryRequest) async throws -> CompanionLibraryResponse { XCTAssertEqual(request.operation, .manual) return CompanionLibraryResponse(assetFileURL: file) } } private final class ManualNoNetwork: URLProtocol { override class func canInit(with request: URLRequest) -> Bool { true } override class func canonicalRequest(for request: URLRequest) -> URLRequest { request } override func startLoading() { client?.urlProtocol(self, didFailWithError: URLError(.notConnectedToInternet)) } override func stopLoading() { } }