Sync source edition with VCC Plus 3.7.0 build 63
This commit is contained in:
1 parent
c652a5276d
commit
b2ecec4d87
86 files changed
+10519
-472
No files matched your search
@@ -0,0 +1,324 @@
|
||||
// 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))
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user