Files
VCCPlusOSS/platforms/macos/Tests/LibraryContinuityTests.swift
T

325 lines
20 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import AppKit
import CryptoKit
import Foundation
import PDFKit
import WebKit
import XCTest
import SQLite3
@MainActor
final class LibraryContinuityTests: XCTestCase {
private var directory: URL!
override func setUpWithError() throws {
directory = FileManager.default.temporaryDirectory.appendingPathComponent("LibraryContinuity-" + UUID().uuidString)
try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: false)
}
override func tearDownWithError() throws { try FileManager.default.removeItem(at: directory) }
func testBrowseReadingAndIndependentBookmarksRoundTripAcrossRelaunch() async throws {
let store = LibraryContinuityStore(directory: directory)
var browse = LibraryBrowseState()
browse.scope = "Games"; browse.query = "adventure"; browse.selectedID = "personal:one"
browse.filters = ["format":"disk", "sort":"name"]; browse.topVisibleID = "personal:two"
store.setBrowse(browse, for: "software-main")
let first = LibraryReadingPosition(documentID: "book-one", relativePath: "book-one/chapter.html", anchor: "alpha", offset: 0.25)
let second = LibraryReadingPosition(documentID: "book-two", relativePath: "book-two/chapter.html", anchor: "beta", offset: 0.5)
let mark = try XCTUnwrap(store.addBookmark(bookID: "book-one", bookTitle: "Book One", sectionTitle: "Alpha", position: first))
store.setReading(second, for: "manual-last")
store.renameBookmark(mark.id, label: "My reference")
await store.flush()
let restored = LibraryContinuityStore(directory: directory)
XCTAssertEqual(restored.browse(for: "software-main"), browse)
XCTAssertEqual(restored.reading(for: "manual-last"), second)
XCTAssertEqual(restored.bookmarks.first?.position, first)
XCTAssertEqual(restored.bookmarks.first?.displayName, "My reference")
}
func testDuplicateBookmarkPreservesOriginalLabelAndPosition() async throws {
let store = LibraryContinuityStore(directory: directory)
let position = LibraryReadingPosition(documentID: "book-one", relativePath: "book-one/a.html", anchor: "section", offset: 0.2)
let mark = try XCTUnwrap(store.addBookmark(bookID: "book-one", bookTitle: "One", sectionTitle: "Section", position: position))
store.renameBookmark(mark.id, label: "Keep this")
var moved = position; moved.offset = 0.8
let again = store.addBookmark(bookID: "book-one", bookTitle: "One", sectionTitle: "New heading", position: moved)
XCTAssertEqual(again?.id, mark.id)
XCTAssertEqual(store.bookmarks.count, 1)
XCTAssertEqual(store.bookmarks.first?.position.offset, 0.2)
XCTAssertEqual(store.bookmarks.first?.label, "Keep this")
store.removeBookmark(mark.id)
await store.flush()
XCTAssertTrue(LibraryContinuityStore(directory: directory).bookmarks.isEmpty)
}
func testNewerOrUnreadableStateIsNeverOverwritten() async throws {
let file = directory.appendingPathComponent("LibraryContinuity.json")
for bytes in [Data("{\"version\":999,\"browse\":{},\"reading\":{},\"bookmarks\":[]}".utf8), Data("invalid json".utf8)] {
try bytes.write(to: file, options: .atomic)
let store = LibraryContinuityStore(directory: directory)
XCTAssertNotNil(store.saveError)
store.setBrowse(LibraryBrowseState(), for: "archive-main")
await store.flush()
XCTAssertEqual(try Data(contentsOf: file), bytes)
}
}
func testInvalidPositionsCannotEscapeContentRootOrPersistNonfiniteValues() async throws {
let store = LibraryContinuityStore(directory: directory)
store.setReading(LibraryReadingPosition(documentID: "one", relativePath: "../private.html"), for: "bad-path")
store.setReading(LibraryReadingPosition(documentID: "one", offset: .nan), for: "bad-offset")
var browse = LibraryBrowseState(); browse.pageOffset = -1
store.setBrowse(browse, for: "bad-browse")
await store.flush()
XCTAssertNil(store.reading(for: "bad-path")); XCTAssertNil(store.reading(for: "bad-offset"))
XCTAssertNil(store.browse(for: "bad-browse"))
}
func testManualScrollBookmarkAndResumeUseStableSectionInSeparateReader() async throws {
_ = NSApplication.shared
let contentRoot = directory.appendingPathComponent("Manuals")
let book = contentRoot.appendingPathComponent("book-one")
try FileManager.default.createDirectory(at: book, withIntermediateDirectories: true)
let page = book.appendingPathComponent("chapter.html")
try """
<!doctype html><html><head><title>One</title></head><body>
<nav class="crumb"><a href="../index.html">Library</a><a href="template.html">Book One</a></nav>
<article><h1>Chapter</h1><section id="alpha" style="height:1400px"><h2>Alpha</h2></section>
<section id="beta" style="height:1400px"><h2>Beta</h2></section></article>
</body></html>
""".write(to: page, atomically: true, encoding: .utf8)
try "<html><body>Home</body></html>".write(to: contentRoot.appendingPathComponent("index.html"), atomically: true, encoding: .utf8)
let store = LibraryContinuityStore(directory: directory.appendingPathComponent("State"))
let reader = ManualReader(content: ManualLibraryContent(root: contentRoot), continuity: store)
reader.webView.frame = CGRect(x: 0, y: 0, width: 800, height: 600)
reader.webView.loadFileURL(page, allowingReadAccessTo: contentRoot)
try await waitFor { reader.currentPosition?.relativePath == "book-one/chapter.html" }
_ = try await reader.webView.evaluateJavaScript("window.scrollTo(0,document.getElementById('beta').offsetTop+100);window.vccLibraryCheckpoint();")
try await waitFor { reader.currentPosition?.anchor == "beta" }
reader.bookmarkCurrentLocation()
try await waitFor { store.bookmarks.count == 1 }
XCTAssertEqual(store.bookmarks.first?.sectionTitle, "Beta")
await store.flush()
let restoredStore = LibraryContinuityStore(directory: directory.appendingPathComponent("State"))
let reopened = ManualReader(content: ManualLibraryContent(root: contentRoot), continuity: restoredStore)
reopened.webView.frame = reader.webView.frame
reopened.resume()
try await waitFor { reopened.currentPosition?.anchor == "beta" }
XCTAssertGreaterThan(reopened.currentPosition?.offset ?? 0, 0)
XCTAssertEqual(reopened.currentBookTitle, "Book One")
XCTAssertEqual(restoredStore.bookmarks.count, 1)
}
func testImmediateBookmarkSamplesFreshScrollAndIgnoresSupersedingNavigation() async throws {
_ = NSApplication.shared
let root = directory.appendingPathComponent("Manuals")
let book = root.appendingPathComponent("book-one")
try FileManager.default.createDirectory(at: book, withIntermediateDirectories: true)
let page = book.appendingPathComponent("chapter.html")
try """
<!doctype html><html><head><title>One</title></head><body>
<article><h1>Chapter</h1><section id="alpha" style="height:1400px"><h2>Alpha</h2></section>
<section id="beta" style="height:1400px"><h2>Beta</h2></section></article>
</body></html>
""".write(to: page, atomically: true, encoding: .utf8)
try "<html><body>Home</body></html>".write(to: root.appendingPathComponent("index.html"), atomically: true, encoding: .utf8)
let store = LibraryContinuityStore(directory: directory.appendingPathComponent("State"))
let reader = ManualReader(content: ManualLibraryContent(root: root), continuity: store)
reader.webView.frame = CGRect(x: 0, y: 0, width: 800, height: 600)
reader.webView.loadFileURL(page, allowingReadAccessTo: root)
try await waitFor { reader.currentPosition != nil }
XCTAssertNotEqual(reader.currentPosition?.anchor, "beta")
// Deliberately do not call the checkpoint or wait for its one-second
// scroll timer before performing the user's bookmark action.
_ = try await reader.webView.evaluateJavaScript("window.scrollTo(0,document.getElementById('beta').offsetTop+100)")
reader.bookmarkCurrentLocation()
try await waitFor { store.bookmarks.count == 1 }
XCTAssertEqual(store.bookmarks[0].position.anchor, "beta")
XCTAssertEqual(store.bookmarks[0].sectionTitle, "Beta")
XCTAssertGreaterThan(store.bookmarks[0].position.offset, 0)
store.removeBookmark(store.bookmarks[0].id)
reader.bookmarkCurrentLocation()
reader.showHome()
try await waitFor { reader.currentPosition?.relativePath == "index.html" }
XCTAssertTrue(store.bookmarks.isEmpty, "A checkpoint from a superseded page must not create a bookmark")
}
func testArchiveDeepLinkFindsExactDocumentOutsideFirstBrowseBatch() async throws {
let database = directory.appendingPathComponent("Archive.sqlite")
var handle: OpaquePointer?
XCTAssertEqual(sqlite3_open(database.path, &handle), SQLITE_OK)
defer { sqlite3_close(handle) }
var sql = """
PRAGMA application_id=0x56434341; PRAGMA user_version=2;
CREATE TABLE document(id INTEGER PRIMARY KEY,sha256 TEXT,title TEXT,collection TEXT,format TEXT,source_url TEXT,page_count INTEGER,issue_year TEXT);
"""
for n in 0..<72 {
let digest = String(format: "%064x", n+1)
sql += "INSERT INTO document VALUES(\(n+1),'\(digest)','Title \(String(format: "%03d", n))','Books','text','https://colorcomputerarchive.com/repo/Documents/Books/\(n).txt',1,NULL);"
}
XCTAssertEqual(sqlite3_exec(handle, sql, nil, nil, nil), SQLITE_OK)
let catalog = ArchiveLibraryCatalog(url: database)
let digest = String(format: "%064x", 61)
let exact = try await catalog.document(id: digest)
XCTAssertEqual(exact?.title, "Title 060")
let offset = try await catalog.browseOffset(documentID: digest, collection: "Books", batchSize: 35)
XCTAssertEqual(offset, 35)
let rows = try await catalog.browse(collection: "Books", limit: 35, offset: offset ?? 0)
XCTAssertTrue(rows.contains { $0.id == digest })
let malformed = try await catalog.document(id: "not-a-content-identity")
XCTAssertNil(malformed)
}
func testTwoBookReadingPositionsAndBookmarksSurviveReaderAndStoreRecreation() async throws {
_ = NSApplication.shared
let root = try makeTwoBookManuals()
let state = directory.appendingPathComponent("State")
let store = LibraryContinuityStore(directory: state)
let reader = ManualReader(content: ManualLibraryContent(root: root), continuity: store)
reader.webView.frame = CGRect(x: 0, y: 0, width: 800, height: 600)
for book in ["book-one", "book-two"] {
reader.webView.loadFileURL(root.appendingPathComponent(book + "/chapter.html"), allowingReadAccessTo: root)
try await waitFor { reader.currentBookID == book }
_ = try await reader.webView.evaluateJavaScript("window.scrollTo(0,document.getElementById('beta').offsetTop+100);window.vccLibraryCheckpoint();")
try await waitFor { reader.currentPosition?.anchor == "beta" }
reader.bookmarkCurrentLocation()
try await waitFor { store.bookmarks.contains { $0.bookID == book } }
}
let originalBookmarks = store.bookmarks
func assertSavedBookmarks(_ actual: [ManualBookmark], file: StaticString = #filePath, line: UInt = #line) {
// Successful navigation may update location validation metadata;
// the user's saved identity, label and position must stay fixed.
XCTAssertEqual(actual.map(\.id), originalBookmarks.map(\.id), file: file, line: line)
XCTAssertEqual(actual.map(\.position), originalBookmarks.map(\.position), file: file, line: line)
XCTAssertEqual(actual.map(\.displayName), originalBookmarks.map(\.displayName), file: file, line: line)
}
let firstPosition = try XCTUnwrap(store.reading(for: "manual-book:book-one"))
let secondPosition = try XCTUnwrap(store.reading(for: "manual-book:book-two"))
XCTAssertNotEqual(firstPosition.relativePath, secondPosition.relativePath)
await store.flush()
let recreatedStore = LibraryContinuityStore(directory: state)
let reopened = ManualReader(content: ManualLibraryContent(root: root), continuity: recreatedStore)
reopened.webView.frame = reader.webView.frame
reopened.resume()
try await waitFor { reopened.currentBookID == "book-two" && reopened.currentPosition?.anchor == "beta" }
XCTAssertEqual(recreatedStore.reading(for: "manual-book:book-one"), firstPosition)
assertSavedBookmarks(recreatedStore.bookmarks)
// An explicit bookmark in another book wins over the last-active book.
reopened.openBookmark(try XCTUnwrap(originalBookmarks.first { $0.bookID == "book-one" }))
try await waitFor { reopened.currentBookID == "book-one" && reopened.currentPosition?.anchor == "beta" }
_ = try await reopened.webView.evaluateJavaScript("window.scrollTo(0,0);window.vccLibraryCheckpoint();")
try await waitFor { reopened.currentPosition?.anchor == nil }
assertSavedBookmarks(recreatedStore.bookmarks)
XCTAssertEqual(recreatedStore.reading(for: "manual-book:book-two"), secondPosition)
reopened.showHome()
try await waitFor { reopened.currentPosition?.relativePath == "index.html" }
reopened.resume()
XCTAssertEqual(reopened.currentPosition?.relativePath, "index.html", "Explicit Library Home must not be replaced by automatic resume")
await recreatedStore.flush()
assertSavedBookmarks(LibraryContinuityStore(directory: state).bookmarks)
}
func testUpdatedManualMissingSectionAndPagePreserveBookmarksWithoutOpeningOtherContent() async throws {
_ = NSApplication.shared
let root = try makeTwoBookManuals()
let state = directory.appendingPathComponent("State")
let store = LibraryContinuityStore(directory: state)
let position = LibraryReadingPosition(documentID: "book-one", relativePath: "book-one/chapter.html", anchor: "removed-section", offset: 0.7)
let mark = try XCTUnwrap(store.addBookmark(bookID: "book-one", bookTitle: "Book One", sectionTitle: "Removed section", position: position))
store.renameBookmark(mark.id, label: "Keep my reference")
let reader = ManualReader(content: ManualLibraryContent(root: root), continuity: store)
reader.webView.frame = CGRect(x: 0, y: 0, width: 800, height: 600)
reader.openBookmark(mark)
try await waitFor { reader.error?.contains("Location changed") == true }
XCTAssertEqual(reader.webView.url?.lastPathComponent, "chapter.html")
let fallbackScroll = try await reader.webView.evaluateJavaScript("window.scrollY") as? Double
XCTAssertEqual(fallbackScroll, 0)
XCTAssertFalse(reader.bookmarkAvailable(try XCTUnwrap(store.bookmarks.first)))
await store.flush()
let preserved = try XCTUnwrap(LibraryContinuityStore(directory: state).bookmarks.first)
XCTAssertEqual(preserved.id, mark.id)
XCTAssertEqual(preserved.position, position)
XCTAssertEqual(preserved.displayName, "Keep my reference")
XCTAssertEqual(preserved.locationChanged, true)
reader.showHome()
try await waitFor { reader.currentPosition?.relativePath == "index.html" }
try FileManager.default.removeItem(at: root.appendingPathComponent("book-one/chapter.html"))
reader.openBookmark(preserved)
XCTAssertTrue(reader.error?.contains("page is no longer") == true)
XCTAssertEqual(reader.currentPosition?.relativePath, "index.html")
XCTAssertEqual(store.bookmarks.first?.position, position)
XCTAssertEqual(store.bookmarks.count, 1)
}
func testLegacyArchivePageMigratesToPersistentStateIndependentOfAssetCache() async throws {
let pdf = PDFDocument()
for color in [NSColor.white, .gray] {
let image = NSImage(size: NSSize(width: 240, height: 900), flipped: false) { rect in color.setFill(); rect.fill(); return true }
pdf.insert(try XCTUnwrap(PDFPage(image: image)), at: pdf.pageCount)
}
let bytes = try XCTUnwrap(pdf.dataRepresentation())
let digest = SHA256.hash(data: bytes).map { String(format: "%02x", $0) }.joined()
let key = "archive-library.page." + digest
let original = UserDefaults.standard.object(forKey: key)
defer {
if let original { UserDefaults.standard.set(original, forKey: key) }
else { UserDefaults.standard.removeObject(forKey: key) }
}
UserDefaults.standard.set(2, forKey: key)
let cached = directory.appendingPathComponent(digest + ".pdf")
try bytes.write(to: cached)
let state = directory.appendingPathComponent("State")
let store = LibraryContinuityStore(directory: state)
let reader = ArchiveReaderModel(remembersPage: true, cache: ArchiveAssetCache(directory: directory), continuity: store)
defer { reader.reset() }
reader.view.frame = NSRect(x: 0, y: 0, width: 300, height: 300)
let item = ArchiveDocument(id: digest, title: "Migration fixture", collection: "Books",
sourceURL: URL(string: "https://colorcomputerarchive.com/repo/Documents/Books/Migration.pdf")!, memberPath: nil,
pageCount: 2, deliveryURL: URL(string: "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Documents/Books/Migration.pdf")!, deliveryBytes: Int64(bytes.count))
reader.open(item, page: reader.savedPage(for: digest), resumePosition: true)
try await waitFor { reader.progress == nil }
XCTAssertNil(reader.error)
XCTAssertEqual(reader.page, 2)
reader.reset()
await store.flush()
// Clearing an asset cache or moving away from old preferences must not
// clear the user's newly migrated reading position.
try FileManager.default.removeItem(at: cached)
UserDefaults.standard.removeObject(forKey: key)
let recreated = LibraryContinuityStore(directory: state)
let reopened = ArchiveReaderModel(remembersPage: true, cache: ArchiveAssetCache(directory: directory), continuity: recreated)
defer { reopened.reset() }
XCTAssertEqual(reopened.savedPage(for: digest), 2)
XCTAssertEqual(recreated.reading(for: "archive:" + digest)?.documentID, digest)
XCTAssertFalse(FileManager.default.fileExists(atPath: cached.path))
}
private func makeTwoBookManuals() throws -> URL {
let root = directory.appendingPathComponent("Manuals")
for book in ["book-one", "book-two"] {
let folder = root.appendingPathComponent(book)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
try """
<!doctype html><html><head><title>\(book)</title></head><body>
<nav class="crumb"><a href="../index.html">Library</a><a href="template.html">\(book)</a></nav>
<article><h1>Chapter</h1><section id="alpha" style="height:1400px"><h2>Alpha</h2></section>
<section id="beta" style="height:1400px"><h2>Beta</h2></section></article></body></html>
""".write(to: folder.appendingPathComponent("chapter.html"), atomically: true, encoding: .utf8)
}
try "<html><body>Library Home</body></html>".write(to: root.appendingPathComponent("index.html"), atomically: true, encoding: .utf8)
return root
}
private func waitFor(_ condition: () -> Bool) async throws {
let deadline = ContinuousClock.now + .seconds(8)
while !condition() {
guard ContinuousClock.now < deadline else { XCTFail("Reader did not reach its expected state"); throw CocoaError(.fileReadUnknown) }
try await Task.sleep(for: .milliseconds(25))
}
}
}