// SPDX-License-Identifier: GPL-3.0-or-later import XCTest import SQLite3 final class SoftwareLibraryBrowseTests: XCTestCase { private var directory: URL! private let starter = "authored-curated-edition" override func setUpWithError() throws { directory = FileManager.default.temporaryDirectory.appendingPathComponent("LibraryBrowse-" + UUID().uuidString) try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) } override func tearDownWithError() throws { try? FileManager.default.removeItem(at: directory) } private func release(_ id: String, title: String = "game", name: String = "Example", category: String = "Disks/Games", media: String = "disk", system: String = "CoCo 3", status: String = "source-ready", note: String? = nil, bytes: Int64 = 100, date: String? = nil, assets: [SoftwareLibraryAsset] = [], environment: String = "unknown", processor: String = "unknown", hardware: [String: String] = [:], videoModes: [String] = ["SG-12"], gettingStarted: Bool = false) -> SoftwareLibraryRelease { SoftwareLibraryRelease(id: id, titleID: title, name: name, category: category, mediaType: media, contentRole: "software", sourceURL: URL(string: "https://colorcomputerarchive.com/\(id)")!, modifiedAt: date, modifiedPrecision: date == nil ? nil : "minute", modifiedTimezone: nil, packageSHA256: String(repeating: "a", count: 64), byteSize: bytes, languageStatus: "unknown", metadata: .object(["getting_started": .bool(gettingStarted), "system": .string(system), "publisher": .string("Test Publisher"), "video_modes": .array(videoModes.map(LibraryJSON.string))]), setup: SoftwareLibrarySetup(status: status, command: nil, instructions: "Mount selected media.", configuration: .object(["browse_environment": .string(environment), "processor_requirement": .string(processor), "hardware_support": .object(hardware.mapValues(LibraryJSON.string)), "compatibility_notes": .array(note.map { [.string($0)] } ?? []), "configuration_requirements": .array([])]), selectedMembers: .array([]), reasons: [], validation: .object(["scope": .string("opening-gameplay-and-disk-switching")])), assets: assets, downloadURLs: []) } private func title(_ id: String, name: String, _ releases: [SoftwareLibraryRelease]) -> SoftwareLibraryTitle { SoftwareLibraryTitle(id: id, name: name, identityStatus: "suggested", releases: releases) } func testCategoryTreePreservesHierarchyAndPrefixBoundaries() { let tree = LibraryCategory.tree(["Disks/Games", "Disks/Coco SDC/Games", "Disks/Coco SDC/Music", "Cassettes/Games", "DisksExtra/Tools", "Cartridges"]) XCTAssertEqual(tree.map(\.id), ["Cartridges", "Cassettes", "Disks", "DisksExtra"]) XCTAssertNil(tree[0].children) let disks = tree[2] XCTAssertEqual(disks.children?.map(\.id), ["Disks/Coco SDC", "Disks/Games"]) XCTAssertEqual(disks.children?.first?.children?.map(\.id), ["Disks/Coco SDC/Games", "Disks/Coco SDC/Music"]) var query = LibraryBrowseQuery(scope: .all); query.category = "Disks" XCTAssertTrue(query.matches(release("a", category: "Disks/Coco SDC/Games"), titleName: "A")) XCTAssertFalse(query.matches(release("b", category: "DisksExtra/Tools"), titleName: "B")) } func testSearchAndFacetsApplyToSameVariantWithoutDroppingSiblingEditions() { let titles = [title("game", name: "Café Adventure", [ release("cassette", name: "Cassette original", category: "Cassettes/Games", media: "cassette", system: "CoCo 1/2", note: "SG-12 introduction unverified"), release("disk", name: "Disk edition", status: "manual-setup")])] var query = LibraryBrowseQuery(scope: .all, text: "cafe publisher sg-12", media: "cassette", system: "CoCo 1/2", evidence: "notes") let rows = query.apply(to: titles, favorites: [], installed: []) XCTAssertEqual(rows.count, 1) XCTAssertEqual(rows[0].matchingReleases.map(\.id), ["cassette"]) XCTAssertEqual(rows[0].title.releases.count, 2) query.evidence = "manual" XCTAssertTrue(query.apply(to: titles, favorites: [], installed: []).isEmpty) query.media = "disk"; query.system = "CoCo 3" XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).first?.matchingReleases.map(\.id), ["disk"]) } func testStarterMembershipIsEditorialAndFavoritesAndInstalledUseCorrectIdentity() { let curated = release("curated", status: "spot-checked", gettingStarted: true) let formerID = "6062d9b73d08579671fe0d489c53fdd0" let formerStarter = release(formerID, status: "spot-checked") let extra = release("another-checked", status: "spot-checked") let titles = [title("game", name: "Example", [curated, formerStarter, extra]), title("other", name: "Other", [release("other-release", title: "other")])] let starters = LibraryBrowseQuery(scope: .started).apply(to: titles, favorites: [], installed: []) XCTAssertEqual(starters.flatMap(\.matchingReleases).map(\.id), ["curated"]) XCTAssertTrue(LibraryBrowseQuery(scope: .all).apply(to: titles, favorites: [], installed: []).flatMap(\.matchingReleases).contains { $0.id == formerID }) XCTAssertEqual(LibraryBrowseQuery(scope: .favorites).apply(to: titles, favorites: ["game"], installed: []).map(\.id), ["game"]) let installed = LibraryBrowseQuery(scope: .installed).apply(to: titles, favorites: [], installed: ["another-checked"]) XCTAssertEqual(installed.map(\.id), ["game"]) XCTAssertEqual(installed[0].matchingReleases.map(\.id), ["another-checked"]) XCTAssertTrue(LibraryBrowseQuery(scope: .installed).apply(to: titles, favorites: [], installed: ["game"]).isEmpty) } func testCoverCollectionUsesArtworkWithoutPromotingRuntimeEvidence() { func asset(_ kind: String) -> SoftwareLibraryAsset { var item = SoftwareLibraryAsset(id: kind, name: "Example", kind: kind, sourceURL: URL(string: "https://colorcomputerarchive.com/repo/Media/example.png")!, sha256: nil, byteSize: nil, credit: "Archive contributor", matchStatus: "candidate", matchReason: "Title match") item.thumbnailURL = URL(string: "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Artwork/Thumbnails/Manuals/example.png") item.thumbnailSHA256 = String(repeating: "a", count: 64) item.thumbnailByteSize = 100 return item } let titles = [title("manual", name: "Manual only", [release("manual", title: "manual", assets: [asset("manual")])]), title("cover", name: "Cover", [release("cover", title: "cover", status: "manual-setup", assets: [asset("replacement-label")])]), title("screen", name: "Screenshot", [release("screen", title: "screen", assets: [asset("screenshot")])]), title("none", name: "No art", [release("none", title: "none")])] XCTAssertEqual(LibraryBrowseQuery().scope, .started) let query = LibraryBrowseQuery(scope: .showcase) let rows = query.apply(to: titles, favorites: [], installed: []) XCTAssertEqual(rows.map(\.id), ["cover", "manual", "screen"]) XCTAssertEqual(rows[0].matchingReleases[0].setup.status, "manual-setup") XCTAssertEqual(rows[0].matchingReleases[0].assets[0].matchStatus, "candidate") XCTAssertTrue(LibraryBrowseQuery(scope: .started).apply(to: titles, favorites: [], installed: []).isEmpty) } func testSoftwareTypesSpanFormatsAndRetainMachineAndFormatConstraints() { let disk = release("disk", category: "Disks/Games") let cassette = release("tape", category: "Cassettes/Games", media: "cassette", system: "CoCo 1/2") let sdc = release("sdc", category: "Disks/Coco SDC/OS-9/Level 2/Games", media: "sdc") let cartridge = release("cart", category: "Cartridges", media: "cartridge") let music = release("music", category: "Disks/Coco SDC/Music", media: "sdc") let titles = [title("game", name: "Game", [disk, cassette, sdc, cartridge]), title("music", name: "Music", [music])] var query = LibraryBrowseQuery(scope: .all, softwareType: "Games") XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).flatMap(\.matchingReleases).map(\.id), ["disk", "tape", "sdc", "cart"]) query.system = "CoCo 3"; query.media = "sdc" XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).flatMap(\.matchingReleases).map(\.id), ["sdc"]) query.softwareType = "Music" XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).flatMap(\.matchingReleases).map(\.id), ["music"]) XCTAssertEqual(LibraryBrowseQuery.type(of: cartridge), "Other", "An unclassified cartridge is not assumed to be a game") XCTAssertEqual(LibraryBrowseQuery.type(of: cartridge, related: [disk, music]), "Other", "Conflicting editions do not establish a type") XCTAssertEqual(LibraryBrowseQuery.type(of: release("demo", category: "Disks/Games/Sierra Games/Demos")), "Games") } func testUnifiedPersonalGamesAreFirstAndAvailableToLocalDiskCompanion() { var entry = PersonalSoftwareEntry(id: UUID(), title: "Private Game", files: [ .init(path: "PRIVATE.DSK", kind: "disk", byteSize: 4, sha256: String(repeating: "a", count: 64)) ]) entry.category = "Games" let privateRelease = entry.release(in: directory) let privateTitle = SoftwareLibraryTitle(id: entry.titleID, name: entry.title, identityStatus: "personal", releases: [privateRelease]) let publicGame = title("public-game", name: "Public Game", [release("public-edition", category: "Disks/Games")]) let titles = [privateTitle, publicGame] XCTAssertEqual(LibraryBrowseQuery(scope: .all, softwareType: "Games").apply(to: titles, favorites: [entry.titleID], installed: [entry.releaseID]).map(\.id), [entry.titleID, publicGame.id]) XCTAssertEqual(LibraryBrowseQuery(scope: .all, category: "Games").apply(to: [privateTitle], favorites: [], installed: []).count, 1) for scope in [LibraryBrowseQuery.Scope.started, .showcase, .installed] { XCTAssertTrue(LibraryBrowseQuery(scope: scope).apply(to: [privateTitle], favorites: [entry.titleID], installed: [entry.releaseID]).isEmpty) } XCTAssertEqual(LibraryBrowseQuery(scope: .personal).apply(to: titles, favorites: [], installed: []).map(\.id), [entry.titleID]) XCTAssertEqual(LibraryBrowseQuery(scope: .favorites).apply(to: titles, favorites: [entry.titleID], installed: []).map(\.id), [entry.titleID]) XCTAssertEqual(LibraryBrowseQuery(scope: .search, text: "Private Game").apply(to: titles, favorites: [], installed: []).map(\.id), [entry.titleID]) let companion = SoftwareLibraryCatalog(titles: titles, metadata: [:]).companionDisksOnly XCTAssertEqual(companion.titles.map(\.id), [privateTitle.id, publicGame.id], "The user's local companion can browse their own disks") } func testPersonalGroupIsAlphabeticalBeforeCatalogWithoutMergingSameNames() { func personal(_ name: String, bytes: Int64) -> SoftwareLibraryTitle { var entry = PersonalSoftwareEntry(id: UUID(), title: name, files: [.init(path: "GAME.dsk", kind: "disk", byteSize: bytes, sha256: String(repeating: "a", count: 64))]) entry.category = "Games" return .init(id: entry.titleID, name: name, identityStatus: "personal", releases: [entry.release(in: directory)]) } let privateA = personal("A Game", bytes: 10000), privateZ = personal("Z Game", bytes: 1) let publicA = title("public-a", name: "A Game", [release("a", bytes: 10)]) let publicB = title("public-b", name: "B Game", [release("b", bytes: 50)]) for sort in LibraryBrowseQuery.Sort.allCases { let rows = LibraryBrowseQuery(scope: .all, softwareType: "Games", sort: sort).apply(to: [publicA, privateZ, publicB, privateA], favorites: [], installed: []) XCTAssertEqual(Array(rows.prefix(2)).map(\.id), [privateA.id, privateZ.id]) XCTAssertTrue(rows[0].isPersonal); XCTAssertFalse(rows[2].isPersonal) XCTAssertEqual(rows.count, 4, "Personal and catalog editions with the same name stay distinct") XCTAssertEqual(Array(rows.suffix(2)).map(\.id), sort == .size ? [publicB.id, publicA.id] : [publicA.id, publicB.id]) } XCTAssertTrue(LibraryBrowseQuery(scope: .all, softwareType: "Music").apply(to: [privateA], favorites: [], installed: []).isEmpty) } @MainActor func testHeaderSearchEscapesEveryPriorScopeAndFacetsAndResumes() async throws { let support = directory.appendingPathComponent("GlobalSearch") let continuity = LibraryContinuityStore(directory: support) let model = SoftwareLibraryModel(state: .init(directory: support), continuity: continuity) model.restoreBrowseContext() for scope in LibraryBrowseQuery.Scope.allCases where scope != .search { model.query = .init(scope: scope, category: "Disks", softwareType: "Music", media: "cassette", evidence: "checked", sort: .modified) model.setSearchText("Popstar") XCTAssertEqual(model.query, .init(scope: .search, text: "Popstar", sort: .modified)) } model.query.media = "disk"; model.setSearchText("Popstar Game") XCTAssertEqual(model.query.media, "disk", "Explicit filters within Search Results survive further typing") model.saveBrowseContext(); await continuity.flush() let resumed = SoftwareLibraryModel(state: .init(directory: support), continuity: LibraryContinuityStore(directory: support)) await resumed.load(from: try database()); try await settle(resumed) XCTAssertEqual(resumed.query.scope, .search); XCTAssertEqual(resumed.query.text, "Popstar Game") XCTAssertEqual(resumed.query.media, "disk") model.setSearchText("") XCTAssertEqual(model.query.scope, .all); XCTAssertEqual(model.query.text, "") await model.shutdown(); await resumed.shutdown() } func testAdvancedFacetsMatchTheSameEditionAndKeepUnknownEvidenceHonest() { let disk = release("disk", environment: "os9", processor: "6309", hardware: ["speech-sound": "optional"], videoModes: ["SG-12"]) let tape = release("tape", media: "cassette", environment: "basic", processor: "either", hardware: ["joystick": "unspecified"], videoModes: ["6847T1"]) let titles = [title("game", name: "Example", [disk, tape])] var query = LibraryBrowseQuery(scope: .all) query.environment = "os9"; query.processor = "6309"; query.hardware = "speech-sound" query.hardwareUse = "optional"; query.displayFeature = "semigraphics" XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).first?.matchingReleases.map(\.id), ["disk"]) query.hardware = "joystick"; query.hardwareUse = "" XCTAssertTrue(query.apply(to: titles, favorites: [], installed: []).isEmpty, "Do not combine evidence from sibling editions") query = LibraryBrowseQuery(scope: .all); query.processor = "6309" XCTAssertFalse(query.matches(tape, titleName: "Example"), "Supports both is not 6309 required") XCTAssertFalse(query.matches(release("unknown"), titleName: "Unknown")) query.processor = ""; query.hardware = "joystick"; query.hardwareUse = "required" XCTAssertFalse(query.matches(tape, titleName: "Example"), "A suggested joystick is not mandatory") query.hardwareUse = "unspecified" XCTAssertTrue(query.matches(tape, titleName: "Example")) query.hardware = ""; query.hardwareUse = ""; query.displayFeature = "semigraphics" XCTAssertFalse(query.matches(tape, titleName: "Example"), "6847T1 is not a semigraphics tag") XCTAssertEqual(tape.videoBadges, ["6847T1"]) query.displayFeature = "SG-12" XCTAssertTrue(query.matches(disk, titleName: "Example")) query.displayFeature = "SG-24" XCTAssertFalse(query.matches(disk, titleName: "Example")) query.environment = "os9"; query.processor = "6309"; query.hardware = "speech-sound"; query.hardwareUse = "optional" XCTAssertEqual(query.additionalFilterLabels, ["OS-9 / NitrOS-9", "Requires Hitachi 6309", "Speech/Sound — Optional", "Semigraphics-24"]) } func testSortUsesMatchingEditionAndKeepsUnknownDatesLast() { let titles = [title("a", name: "A", [release("a1", title: "a", bytes: 20), release("a2", title: "a", media: "cassette", bytes: 900, date: "2026-01-01")]), title("b", name: "B", [release("b1", title: "b", bytes: 100, date: "2020-01-01")])] var query = LibraryBrowseQuery(scope: .all, media: "disk", sort: .modified) XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).map(\.id), ["b", "a"]) query.sort = .size XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).map(\.id), ["b", "a"]) query.media = "" XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).map(\.id), ["a", "b"]) } private func database() throws -> URL { let url = directory.appendingPathComponent("catalog.sqlite") var db: OpaquePointer? XCTAssertEqual(sqlite3_open(url.path, &db), SQLITE_OK) defer { sqlite3_close(db) } let sql = """ PRAGMA user_version=1; CREATE TABLE metadata(key TEXT,value TEXT); INSERT INTO metadata VALUES('schema_version','1'),('recipe_contract','2'); CREATE TABLE title(id TEXT,name TEXT,identity_status TEXT); INSERT INTO title VALUES('game','Example Game','suggested'),('other','Other Game','suggested'); CREATE TABLE package(sha256 TEXT,byte_size INTEGER); INSERT INTO package VALUES('\(String(repeating: "a", count: 64))',123); CREATE TABLE release(id TEXT,title_id TEXT,name TEXT,category TEXT,media_type TEXT,content_role TEXT,source_url TEXT,modified_at TEXT,modified_precision TEXT,modified_timezone TEXT,package_sha256 TEXT,language_status TEXT,metadata_json TEXT); CREATE TABLE setup(release_id TEXT,status TEXT,command TEXT,instructions TEXT,configuration_json TEXT,selected_members_json TEXT,reasons_json TEXT,validation_json TEXT); CREATE TABLE asset(id TEXT,name TEXT,kind TEXT,source_url TEXT,sha256 TEXT,byte_size INTEGER,credit TEXT); CREATE TABLE release_asset(release_id TEXT,asset_id TEXT,status TEXT,reason TEXT); CREATE TABLE download_location(package_sha256 TEXT,url TEXT,priority INTEGER); """ XCTAssertEqual(sqlite3_exec(db, sql, nil, nil, nil), SQLITE_OK) for (id, title, name, media, category) in [(starter, "game", "SDC Edition", "sdc", "Disks/Coco SDC/Games"), ("cassette", "game", "Cassette Original", "cassette", "Cassettes/Games"), ("other", "other", "Other Game", "disk", "Disks/Games")] { let rows = """ INSERT INTO release VALUES('\(id)','\(title)','\(name)','\(category)','\(media)','software','https://colorcomputerarchive.com/\(id)',NULL,NULL,NULL,'\(String(repeating: "a", count: 64))','unknown','{"system":"CoCo 3","getting_started":\(id == starter ? "true" : "false")}'); INSERT INTO setup VALUES('\(id)','spot-checked',NULL,'Mount selected media.','{"browse_environment":"disk-basic","processor_requirement":"\(media == "sdc" ? "6309" : "unknown")","hardware_support":{"joystick":"unspecified"}}','[]','[]','{}'); """ XCTAssertEqual(sqlite3_exec(db, rows, nil, nil, nil), SQLITE_OK) } return url } @MainActor private func settle(_ model: SoftwareLibraryModel) async throws { for _ in 0..<200 { try await Task.sleep(nanoseconds: 10_000_000) if !model.filtering && !model.loading { return } } XCTFail("Library query did not settle") } @MainActor func testPreferredReleaseCannotBypassScopeAndExplicitChoiceClearsConflictingSearch() async throws { let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Personal")) state.selectRelease("cassette", for: "game") let model = SoftwareLibraryModel(state: state) model.query.scope = .started await model.load(from: try database()); try await settle(model) XCTAssertEqual(model.selectedRelease?.id, starter, "A previously preferred edition must not bypass Getting Started") model.query = LibraryBrowseQuery(scope: .all, text: "sdc", category: "Disks", media: "sdc") try await settle(model) XCTAssertEqual(model.selectedRelease?.id, starter) model.chooseRelease("cassette") try await settle(model) XCTAssertEqual(model.selectedRelease?.id, "cassette") XCTAssertEqual(model.query.text, "") XCTAssertEqual(model.query.category, "") XCTAssertEqual(state.preferredReleaseID(for: "game"), "cassette") model.query.scope = .started; try await settle(model) XCTAssertEqual(model.selectedRelease?.id, starter) model.chooseRelease("cassette"); try await settle(model) XCTAssertEqual(model.query.scope, .all) XCTAssertEqual(model.selectedRelease?.id, "cassette") await state.flush() } @MainActor func testEditionChoiceRetainsSharedTitleSearchAndCompatibleFacets() async throws { let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Personal")) let model = SoftwareLibraryModel(state: state) model.query = LibraryBrowseQuery(scope: .all, text: "Example Game", category: "Disks", media: "sdc", system: "CoCo 3", evidence: "checked") await model.load(from: try database()); try await settle(model) XCTAssertEqual(model.rows.map(\.id), ["game"]) XCTAssertEqual(model.selectedRelease?.id, starter) model.query.environment = "disk-basic"; model.query.processor = "6309" model.query.hardware = "joystick"; model.query.hardwareUse = "unspecified" try await settle(model) model.chooseRelease(starter) try await settle(model) XCTAssertEqual(model.query.category, "Disks", "A matching ancestor category should be preserved") XCTAssertEqual(model.query.media, "sdc") model.chooseRelease("cassette") try await settle(model) XCTAssertEqual(model.selectedRelease?.id, "cassette") XCTAssertEqual(model.rows.map(\.id), ["game"], "Changing editions should not discard a shared title search") XCTAssertEqual(model.query.text, "Example Game") XCTAssertEqual(model.query.system, "CoCo 3") XCTAssertEqual(model.query.evidence, "checked") XCTAssertEqual(model.query.category, "", "Only the conflicting category should be cleared") XCTAssertEqual(model.query.media, "", "Only the conflicting format should be cleared") XCTAssertEqual(model.query.processor, "", "Clear the incompatible processor requirement") XCTAssertEqual(model.query.environment, "disk-basic") XCTAssertEqual(model.query.hardware, "joystick") XCTAssertEqual(model.query.hardwareUse, "unspecified") await state.flush() } @MainActor func testColdResumeRetainsSelectionWhileCatalogRecoveryIsDelayed() async throws { let support = directory.appendingPathComponent("DelayedResume") let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support) let query = LibraryBrowseQuery(scope: .all) let encoded = String(decoding: try JSONEncoder().encode(query), as: UTF8.self) continuity.setBrowse(.init(scope: "all", filters: ["browse-query": encoded, "layout": "Table"], selectedID: "other"), for: "software-main") await continuity.flush() let restored = LibraryContinuityStore(directory: support) let model = SoftwareLibraryModel(state: state, continuity: restored), url = try database() let loading = Task { await model.load(from: url, catalogLoader: { url in try await Task.sleep(nanoseconds: 350_000_000) return try await SoftwareLibraryCatalog.load(from: url) }) } for _ in 0..<100 where !model.loading { try await Task.sleep(nanoseconds: 1_000_000) } try await Task.sleep(nanoseconds: 180_000_000) // exceeds the empty-result filter debounce XCTAssertTrue(model.loading) XCTAssertEqual(model.selection, "other") XCTAssertEqual(restored.browse(for: "software-main")?.selectedID, "other", "An empty interim result must not overwrite resume state") await loading.value; try await settle(model) XCTAssertEqual(model.selection, "other"); XCTAssertEqual(model.layout, "Table") XCTAssertEqual(model.selectedRow?.name, "Other Game") await model.shutdown() } @MainActor func testFailedCatalogReadKeepsPublicResumePendingForRetry() async throws { let support = directory.appendingPathComponent("FailedResume") let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support) let encoded = String(decoding: try JSONEncoder().encode(LibraryBrowseQuery(scope: .all)), as: UTF8.self) continuity.setBrowse(.init(scope: "all", filters: ["browse-query": encoded], selectedID: "other"), for: "software-main") let model = SoftwareLibraryModel(state: state, continuity: continuity), url = try database() await model.load(from: url, catalogLoader: { _ in throw CocoaError(.fileReadNoPermission) }) try await settle(model) XCTAssertNotNil(model.error); XCTAssertNil(model.catalog) XCTAssertEqual(model.selection, "other") XCTAssertEqual(continuity.browse(for: "software-main")?.selectedID, "other") await model.load(from: url); try await settle(model) XCTAssertNil(model.error); XCTAssertEqual(model.selection, "other") XCTAssertEqual(model.selectedRow?.name, "Other Game") await model.shutdown() } @MainActor func testPrivateScopeRemainsUsableWhenPublicCatalogCannotLoad() async throws { let support = directory.appendingPathComponent("PrivateWithoutCatalog") let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support) let encoded = String(decoding: try JSONEncoder().encode(LibraryBrowseQuery(scope: .personal)), as: UTF8.self) continuity.setBrowse(.init(scope: "personal", filters: ["browse-query": encoded], selectedID: "personal:missing"), for: "software-main") let model = SoftwareLibraryModel(state: state, continuity: continuity) let source = directory.appendingPathComponent("LOCAL.ccc"); try Data([0x12,0x39]).write(to: source) let draft = try await model.personalStore.inspect([source]), entry = try await model.personalStore.save(draft) await model.load(from: directory.appendingPathComponent("Unavailable.sqlite"), catalogLoader: { _ in throw CocoaError(.fileReadNoSuchFile) }) try await settle(model) XCTAssertNil(model.catalog); XCTAssertNotNil(model.error) XCTAssertEqual(model.query.scope, .personal); XCTAssertEqual(model.selectedRow?.id, entry.titleID) await model.shutdown() } @MainActor func testPersonalSaveDuringColdCatalogLoadWinsOverResumedPublicScope() async throws { let support = directory.appendingPathComponent("PersonalDuringLoad") let state = SoftwareLibraryState(directory: support), continuity = LibraryContinuityStore(directory: support) let encoded = String(decoding: try JSONEncoder().encode(LibraryBrowseQuery(scope: .all)), as: UTF8.self) continuity.setBrowse(.init(scope: "all", filters: ["browse-query": encoded], selectedID: "other"), for: "software-main") let model = SoftwareLibraryModel(state: state, continuity: continuity), url = try database() let source = directory.appendingPathComponent("AUTHORED.ccc") try Data([0x12,0x39]).write(to: source) let draft = try await model.personalStore.inspect([source]), entry = try await model.personalStore.save(draft) let loading = Task { await model.load(from: url, catalogLoader: { url in try await Task.sleep(nanoseconds: 500_000_000) return try await SoftwareLibraryCatalog.load(from: url) }) } for _ in 0..<100 where !model.loading { try await Task.sleep(nanoseconds: 1_000_000) } try await Task.sleep(nanoseconds: 150_000_000) model.editPersonal(entry); model.savePersonal(entry, allowDuplicate: false) for _ in 0..<100 where model.personalSaving { try await Task.sleep(nanoseconds: 5_000_000) } XCTAssertEqual(model.query.scope, .personal); XCTAssertEqual(model.selection, entry.titleID) await loading.value; try await settle(model) XCTAssertEqual(model.query.scope, .personal); XCTAssertEqual(model.selection, entry.titleID) XCTAssertEqual(model.selectedRow?.id, entry.titleID) await model.shutdown() XCTAssertEqual(continuity.browse(for: "software-main")?.selectedID, entry.titleID) } @MainActor func testRapidQueriesAndFavoriteChangesPublishLatestResults() async throws { let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Personal")) let model = SoftwareLibraryModel(state: state) await model.load(from: try database()); try await settle(model) for text in ["none", "cassette", "sdc", "missing", "other"] { model.query = LibraryBrowseQuery(scope: .all, text: text) } try await settle(model) XCTAssertEqual(model.rows.map(\.id), ["other"]) XCTAssertEqual(model.selection, "other") try await Task.sleep(nanoseconds: 200_000_000) XCTAssertEqual(model.rows.map(\.id), ["other"], "A stale search must not replace the newest result") model.query = LibraryBrowseQuery(scope: .favorites) state.toggleFavorite("game") try await settle(model) XCTAssertEqual(model.rows.map(\.id), ["game"]) state.toggleFavorite("game"); try await settle(model) XCTAssertTrue(model.rows.isEmpty) XCTAssertNil(model.selection) XCTAssertNil(model.selectedRelease) await state.flush() } @MainActor func testSidebarNavigationReplacesOldCategoryAndTypeButKeepsSearchAndFacets() async throws { let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Navigation")) let model = SoftwareLibraryModel(state: state) await model.load(from: try database()); try await settle(model) model.query = LibraryBrowseQuery(scope: .showcase, text: "Example", media: "sdc", system: "CoCo 3", evidence: "checked", sort: .size) model.browseType("Educational"); try await settle(model) XCTAssertTrue(model.rows.isEmpty) XCTAssertNil(model.selectedRelease) model.browse(.all); try await settle(model) XCTAssertEqual(model.rows.map(\.id), ["game"]) XCTAssertEqual(model.query.softwareType, "") XCTAssertEqual(model.query.text, "Example") XCTAssertEqual(model.query.media, "sdc") XCTAssertEqual(model.query.system, "CoCo 3") XCTAssertEqual(model.query.evidence, "checked") XCTAssertEqual(model.query.sort, .size) model.browseType("Educational") model.browse(.all, category: "Disks"); try await settle(model) XCTAssertEqual(model.query.softwareType, "") XCTAssertEqual(model.query.category, "Disks") XCTAssertEqual(model.rows.map(\.id), ["game"]) model.browseType("Games"); try await settle(model) XCTAssertEqual(model.query.category, "") model.browse(.showcase) XCTAssertEqual(model.query.softwareType, "") for scope in [LibraryBrowseQuery.Scope.started, .favorites, .installed] { model.browseType("Educational"); model.browse(scope) XCTAssertEqual(model.query.softwareType, "") XCTAssertEqual(model.query.category, "") } await state.flush() } @MainActor func testClearFiltersPreservesSearchFolderSortAndPresentation() async throws { let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Clear")) let model = SoftwareLibraryModel(state: state) model.layout = "Table" model.query = LibraryBrowseQuery(scope: .all, text: "Example", category: "Disks", softwareType: "Games", media: "sdc", system: "CoCo 3", evidence: "checked", sort: .modified) model.query.environment = "os9"; model.query.processor = "6309" model.query.hardware = "joystick"; model.query.hardwareUse = "required"; model.query.displayFeature = "SG-12" model.clearFilters() XCTAssertTrue(model.query.additionalFilterLabels.isEmpty) XCTAssertEqual(model.query.hardwareUse, "") XCTAssertEqual(model.query.text, "Example") XCTAssertEqual(model.query.category, "Disks") XCTAssertEqual(model.query.scope, .all) XCTAssertEqual(model.query.sort, .modified) XCTAssertEqual(model.layout, "Table") XCTAssertEqual(model.query.softwareType, "") XCTAssertEqual(model.query.media, "") XCTAssertEqual(model.query.system, "") XCTAssertEqual(model.query.evidence, "") await state.flush() } }