// SPDX-License-Identifier: GPL-3.0-or-later import XCTest import SQLite3 final class SoftwareLibraryTests: XCTestCase { private var directory: URL! override func setUpWithError() throws { directory = FileManager.default.temporaryDirectory.appendingPathComponent("SoftwareLibrary-" + UUID().uuidString) try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true) } override func tearDownWithError() throws { try? FileManager.default.removeItem(at: directory) } private func fixture() throws -> URL { let url = directory.appendingPathComponent("catalog.sqlite") try execute(url, """ PRAGMA user_version=1; CREATE TABLE metadata(key TEXT PRIMARY KEY,value TEXT NOT NULL); INSERT INTO metadata VALUES('schema_version','1'),('recipe_contract','2'),('archive_attribution','Color Computer Archive'); CREATE TABLE title(id TEXT PRIMARY KEY,name TEXT,identity_status TEXT); CREATE TABLE package(sha256 TEXT PRIMARY KEY,byte_size INTEGER); CREATE TABLE release(id TEXT PRIMARY KEY,title_id TEXT REFERENCES title(id),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 REFERENCES package(sha256),language_status TEXT,metadata_json TEXT CHECK(json_valid(metadata_json))); CREATE TABLE setup(release_id TEXT REFERENCES release(id),status TEXT,command TEXT,instructions TEXT,configuration_json TEXT CHECK(json_valid(configuration_json)),selected_members_json TEXT CHECK(json_valid(selected_members_json)),reasons_json TEXT CHECK(json_valid(reasons_json)),validation_json TEXT CHECK(json_valid(validation_json))); CREATE TABLE asset(id TEXT PRIMARY KEY,name TEXT,kind TEXT,source_url TEXT,sha256 TEXT,byte_size INTEGER,credit TEXT); CREATE TABLE release_asset(release_id TEXT REFERENCES release(id),asset_id TEXT REFERENCES asset(id),status TEXT,reason TEXT); CREATE TABLE download_location(package_sha256 TEXT,url TEXT,priority INTEGER); INSERT INTO title VALUES('title-a','Example Game','suggested'); INSERT INTO package VALUES('\(String(repeating: "a", count: 64))',123),('\(String(repeating: "b", count: 64))',456); INSERT INTO release VALUES('cassette','title-a','Example (SG-12).zip','Cassettes/Games/','cassette','software','https://colorcomputerarchive.com/repo/Cassettes/Example.zip','2026-11-01T12:30:00','minute',NULL,'\(String(repeating: "a", count: 64))','unknown','{"system":"CoCo 1/2","publisher":"Example Publisher","year":1983,"video_modes":["SG-12"],"catalog_number":"26-0000"}'); INSERT INTO release VALUES('cartridge','title-a','Example.ccc','Cartridges/','cartridge','software','https://colorcomputerarchive.com/repo/Cartridges/Example.ccc',NULL,NULL,NULL,'\(String(repeating: "b", count: 64))','unknown','{"system":"unknown"}'); INSERT INTO setup VALUES('cassette','source-ready','CLOADM','Mount the cassette; select Play.','{"compatibility_notes":["SG-12 not verified"],"configuration_requirements":[],"profile":"disk-basic","processor":"6809","ram_kib":2048}','[]','[]','{}'); INSERT INTO setup VALUES('cartridge','manual-setup',NULL,'Choose one cartridge.','{"compatibility_notes":[],"configuration_requirements":["Choose controller"]}','[]','["Choose media"]','{}'); INSERT INTO asset VALUES('manual','Example manual','manual','https://colorcomputerarchive.com/manual.pdf',NULL,NULL,'Original author; Color Computer Archive'); INSERT INTO release_asset VALUES('cassette','manual','candidate','Title match only'); INSERT INTO download_location VALUES('\(String(repeating: "a", count: 64))','https://vccplus.brianholman.com/dl/software/CoCoLibrary/Cassettes/Example.zip',0); """) return url } private func execute(_ url: URL, _ sql: String) throws { var db: OpaquePointer? XCTAssertEqual(sqlite3_open(url.path, &db), SQLITE_OK) defer { sqlite3_close(db) } let status = sqlite3_exec(db, sql, nil, nil, nil) guard status == SQLITE_OK else { throw NSError(domain: "SQLite", code: Int(status), userInfo: [NSLocalizedDescriptionKey: String(cString: sqlite3_errmsg(db))]) } } func testLegacyCompanionCannotReceiveTitlesItsUIWouldMisattribute() async throws { let legacy = try JSONDecoder().decode(CompanionLibraryRequest.self, from: Data("{\"operation\":\"snapshot\",\"requestID\":\"\(UUID().uuidString)\"}".utf8)) XCTAssertNil(legacy.ownedTitlesVersion) XCTAssertEqual(CompanionLibraryRequest(operation: .snapshot).ownedTitlesVersion, 1) let url = try fixture(); try installOwnedRecord(ownedRecord(), in: url) let catalog = try await SoftwareLibraryCatalog.load(from: url) let old = catalog.companionDisks(includingOwnedTitles: legacy.ownedTitlesVersion == 1) XCTAssertFalse(old.releases.contains(where: { $0.ownedGame != nil })) XCTAssertTrue(catalog.companionDisksOnly.releases.contains(where: { $0.ownedGame != nil })) } private func ownedRecord(gameID: String = "vccplus.fixture-orbit", releaseID: String = "cassette", categories: [String] = ["Educational", "Games"], featured: Bool = true) -> [String: Any] { let sha = String(repeating: "a", count: 64) func file(_ prefix: String, _ name: String, _ bytes: Int = 123) -> [String: Any] { ["url": "https://vccplus.brianholman.com/dl/software/CoCoLibrary/" + prefix + "/Fixture/1/" + name, "sha256": sha, "byte_size": bytes] } return [ "schema_version": 1, "id": gameID, "release_id": releaseID, "publication_status": "approved", "getting_started": true, "category_featured": featured, "browse_categories": categories, "primary_browse_category": categories[0], "provenance": ["kind": "project-owned", "collection": "vccplus-exclusive", "author": "Fixture Author", "license": "CC0 fixture", "project_url": "https://example.invalid/fixture"], "disk_package": file("Exclusives", "Fixture.zip"), "disk": ["path": "GAME.DSK", "sha256": sha, "byte_size": 161280], "setup": ["configuration": ["profile": "disk-basic", "processor": "6809", "ram_kib": 512], "selected_members": [["path": "GAME.DSK", "target": "disk0"]], "command": "DOS\r", "validation": ["scope": "runtime-verified", "disk_sha256": sha]], "first_play": ["mode": "cold-restart-dos"], "links": ["manual_online": "https://vccplus.brianholman.com/games/fixture/", "manual_pdf": file("Documents/Manuals/Exclusives", "Manual.pdf"), "source_repository": "https://example.invalid/fixture/source"], "source": ["package": file("Sources/Exclusives", "Source.zip"), "project_directory": "Fixture", "configuration_file": "Fixture/vccplus-project.json", "entry_source": "main.c", "license_files": ["Fixture/LICENSE"], "companion_packages": [file("Sources/Exclusives", "Library-Sources.zip")]] ] } private func libraryJSON(_ object: Any) throws -> LibraryJSON { try JSONDecoder().decode(LibraryJSON.self, from: JSONSerialization.data(withJSONObject: object)) } private func installOwnedRecord(_ record: [String: Any], in url: URL) throws { let json = String(data: try JSONSerialization.data(withJSONObject: ["owned_game": record]), encoding: .utf8)! .replacingOccurrences(of: "'", with: "''") try execute(url, """ UPDATE title SET id='vccplus.fixture-orbit' WHERE id='title-a'; UPDATE release SET title_id='vccplus.fixture-orbit'; UPDATE release SET metadata_json='\(json)',media_type='disk' WHERE id='cassette'; UPDATE setup SET command='DOS' || char(13), configuration_json='{"profile":"disk-basic","processor":"6809","ram_kib":512}', selected_members_json='[{"path":"GAME.DSK","target":"disk0"}]' WHERE release_id='cassette'; """) } private func ownedEditionsFixture() throws -> URL { let url = try fixture() var older = ownedRecord(), newer = ownedRecord(releaseID: "cartridge") older["game_version"] = "2026-11-11"; newer["game_version"] = "2026-11-12" try installOwnedRecord(older, in: url) newer["disk_package"] = ["url": "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Exclusives/Fixture/2/New.zip", "sha256": String(repeating: "b", count: 64), "byte_size": 456] func metadata(_ record: [String: Any], published: String) throws -> String { var record = record var links = record["links"] as! [String: Any] var manual = links["manual_pdf"] as! [String: Any] manual["url"] = "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Documents/Manuals/Exclusives/Fixture/" + (record["game_version"] as! String) + "/Manual.pdf" links["manual_pdf"] = manual; record["links"] = links var source = record["source"] as! [String: Any] var package = source["package"] as! [String: Any] package["url"] = "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Sources/Exclusives/Fixture/" + (record["game_version"] as! String) + "/Source.zip" source["package"] = package; record["source"] = source let value: [String: Any] = ["owned_game": record, "owned_publication": ["state": "verified", "verified_at": published]] return String(data: try JSONSerialization.data(withJSONObject: value), encoding: .utf8)! .replacingOccurrences(of: "'", with: "''") } // The older edition was republished later. Its actual game date must // still lose to the newer edition, independently of SQL filename order. let oldJSON = try metadata(older, published: "2026-11-13T01:00:00Z") let newJSON = try metadata(newer, published: "2026-11-12T07:25:22.863738+00:00") try execute(url, """ UPDATE release SET metadata_json='\(oldJSON)',name='A older edition.zip' WHERE id='cassette'; UPDATE release SET metadata_json='\(newJSON)',name='Z newer edition.zip',media_type='disk' WHERE id='cartridge'; UPDATE setup SET command='DOS' || char(13), configuration_json='{"profile":"disk-basic","processor":"6809","ram_kib":512}', selected_members_json='[{"path":"GAME.DSK","target":"disk0"}]' WHERE release_id='cartridge'; """) return url } private func edition(_ release: SoftwareLibraryRelease, version: String, published: String) throws -> SoftwareLibraryRelease { var object = try JSONSerialization.jsonObject(with: JSONEncoder().encode(release)) as! [String: Any] var metadata = object["metadata"] as! [String: Any] var owned = metadata["owned_game"] as! [String: Any] owned["game_version"] = version; metadata["owned_game"] = owned metadata["owned_publication"] = ["state": "verified", "verified_at": published] object["metadata"] = metadata return try JSONDecoder().decode(SoftwareLibraryRelease.self, from: JSONSerialization.data(withJSONObject: object)) } func testNewestOwnedEditionDefaultsFirstWhilePriorManualAndSourceRemainDistinct() async throws { let catalog = try await SoftwareLibraryCatalog.load(from: ownedEditionsFixture()) let title = try XCTUnwrap(catalog.titles.first) XCTAssertEqual(title.releases.map(\.id), ["cartridge", "cassette"]) XCTAssertEqual(title.releases.map(\.editionLabel), ["Disk — 2026-11-12", "Disk — 2026-11-11"]) let rows = LibraryBrowseQuery(scope: .started).apply(to: catalog.titles, favorites: [], installed: []) XCTAssertEqual(rows.first?.matchingReleases.first?.id, "cartridge", "Shelf cards and detail fallback share the sorted editions") let older = try XCTUnwrap(title.releases.last?.ownedGame), newer = try XCTUnwrap(title.releases.first?.ownedGame) XCTAssertTrue(older.manualPDF.url.path.contains("2026-11-11")) XCTAssertTrue(older.source.package.url.path.contains("2026-11-11")) XCTAssertTrue(newer.manualPDF.url.path.contains("2026-11-12")) XCTAssertNotEqual(older.manualPDF.url, newer.manualPDF.url) // Companion decoding must apply the same rule even to an unsorted sender. var object = try JSONSerialization.jsonObject(with: JSONEncoder().encode(title)) as! [String: Any] object["releases"] = Array((object["releases"] as! [[String: Any]]).reversed()) let decoded = try JSONDecoder().decode(SoftwareLibraryTitle.self, from: JSONSerialization.data(withJSONObject: object)) XCTAssertEqual(decoded.releases.map(\.id), ["cartridge", "cassette"]) } func testOwnedPublicationFallbackComparesAbsoluteInstantsAndRejectsInvalidCalendarVersions() async throws { let catalog = try await SoftwareLibraryCatalog.load(from: ownedEditionsFixture()) let base = try XCTUnwrap(catalog.titles.first) let earlier = try edition(base.releases[1], version: "build-09", published: "2026-11-12T10:00:00+09:00") let later = try edition(base.releases[0], version: "build-10", published: "2026-11-12T02:00:00.500000Z") let ordered = SoftwareLibraryTitle(id: base.id, name: base.name, identityStatus: base.identityStatus, releases: [earlier, later]) XCTAssertEqual(ordered.releases.map(\.id), ["cartridge", "cassette"], "10:00+09 is earlier than 02:00Z") let invalidDate = try edition(earlier, version: "9999-02-30", published: "2026-11-12T01:00:00Z") let unknownDate = try edition(later, version: "build-10", published: "2026-11-12T02:00:00Z") XCTAssertEqual(SoftwareLibraryTitle(id: base.id, name: base.name, identityStatus: base.identityStatus, releases: [invalidDate, unknownDate]).releases.first?.id, "cartridge") } func testArchiveAndMixedEditionOrderAndLegacyLabelsRemainUnchanged() async throws { let archive = try await SoftwareLibraryCatalog.load(from: fixture()) let legacy = try XCTUnwrap(archive.titles.first) let requested = Array(legacy.releases.reversed()) XCTAssertEqual(SoftwareLibraryTitle(id: legacy.id, name: legacy.name, identityStatus: legacy.identityStatus, releases: requested).releases.map(\.id), requested.map(\.id)) XCTAssertEqual(legacy.releases[0].editionLabel, legacy.releases[0].mediaLabel + " — " + legacy.releases[0].name) // A mixed provenance title is not an owned-edition chronology. var owned = ownedRecord(); owned["game_version"] = "2026-11-12" let value = try XCTUnwrap(SoftwareLibraryOwnedGame.parse(libraryJSON(owned))) XCTAssertEqual(value.gameID, "vccplus.fixture-orbit") let catalogURL = directory.appendingPathComponent("catalog.sqlite") try installOwnedRecord(owned, in: catalogURL) let mixed = try await SoftwareLibraryCatalog.load(from: catalogURL) XCTAssertEqual(mixed.titles[0].releases.map(\.id), ["cassette", "cartridge"]) } @MainActor func testExplicitOlderOwnedEditionPreferenceSurvivesNewestDefault() async throws { let catalogURL = try ownedEditionsFixture() let state = SoftwareLibraryState(directory: directory.appendingPathComponent("Owned Preference")) let model = SoftwareLibraryModel(state: state) await model.load(from: catalogURL) for _ in 0..<500 where model.loading || model.filtering || model.rows.isEmpty { try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertEqual(model.selectedRelease?.id, "cartridge") model.chooseRelease("cassette") for _ in 0..<500 where model.filtering { try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertEqual(model.selectedRelease?.id, "cassette") await state.flush() let restored = SoftwareLibraryModel(state: SoftwareLibraryState(directory: state.directory)) await restored.load(from: catalogURL) for _ in 0..<500 where restored.loading || restored.filtering || restored.rows.isEmpty { try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertEqual(restored.selectedRelease?.id, "cassette", "A saved edition choice overrides the chronological default") XCTAssertEqual(restored.rows.first?.matchingReleases.first?.id, "cartridge", "The default card edition stays newest") await model.shutdown(); await restored.shutdown() } func testOwnedCatalogPreservesProvenanceManualSourceAndExactRAM() async throws { let url = try fixture() try installOwnedRecord(ownedRecord(), in: url) let catalog = try await SoftwareLibraryCatalog.load(from: url) let release = try XCTUnwrap(catalog.releases.first { $0.id == "cassette" }) let owned = try XCTUnwrap(release.ownedGame) XCTAssertEqual(owned.author, "Fixture Author") XCTAssertEqual(owned.gameID, "vccplus.fixture-orbit") XCTAssertTrue(owned.firstPlayColdDOS) XCTAssertEqual(owned.ramKiB, 512) XCTAssertEqual(release.setup.ramKiB, 512) XCTAssertEqual(owned.source.projectDirectory, "Fixture") XCTAssertEqual(owned.source.entrySource, "main.c") XCTAssertEqual(owned.source.companionPackages.count, 1) XCTAssertEqual(release.browseCategories, ["Educational", "Games"]) XCTAssertEqual(release.primaryBrowseCategory, "Educational") XCTAssertTrue(release.gettingStarted) XCTAssertEqual(release.primaryManualAsset?.manualURL, owned.manualPDF.url) XCTAssertEqual(release.primaryManualAsset?.sha256, String(repeating: "a", count: 64)) XCTAssertEqual(release.primaryManualAsset?.credit, "Fixture Author") XCTAssertTrue(release.searchText.contains("Fixture Author")) XCTAssertEqual(SoftwareLibraryOwnedGame.categoryLabel("Educational"), "Education") XCTAssertNil(catalog.releases.first(where: { $0.id == "cartridge" })?.ownedGame) var record = ownedRecord() var source = record["source"] as! [String: Any] record["library_sources"] = (source.removeValue(forKey: "companion_packages") as! [[String: Any]])[0] source["build_configuration"] = "Release"; record["source"] = source let published = try XCTUnwrap(SoftwareLibraryOwnedGame.parse(libraryJSON(record))) XCTAssertEqual(published.source.companionPackages.count, 1) XCTAssertEqual(published.source.buildConfiguration, "Release") } func testMalformedOwnedMetadataFailsClosedAndCannotChangeDeliveryArea() async throws { let url = try fixture() var record = ownedRecord() record["browse_categories"] = ["Games", "Games"] try installOwnedRecord(record, in: url) do { _ = try await SoftwareLibraryCatalog.load(from: url); XCTFail("Duplicate categories accepted") } catch { XCTAssertTrue(error.localizedDescription.contains("project-owned")) } record = ownedRecord() var source = record["source"] as! [String: Any] source["package"] = ["url": "https://example.invalid/Source.zip", "sha256": String(repeating: "a", count: 64), "byte_size": 123] record["source"] = source try installOwnedRecord(record, in: url) do { _ = try await SoftwareLibraryCatalog.load(from: url); XCTFail("Unapproved source URL accepted") } catch { XCTAssertTrue(error.localizedDescription.contains("delivery area")) } record = ownedRecord() record["disk_package"] = ["url": "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Exclusives/Fixture.zip", "sha256": String(repeating: "b", count: 64), "byte_size": 123] try installOwnedRecord(record, in: url) do { _ = try await SoftwareLibraryCatalog.load(from: url); XCTFail("Different release package accepted") } catch { XCTAssertTrue(error.localizedDescription.contains("does not match")) } } func testOwnedSourceDescriptorsRejectTraversalFalseFlagsAndUnverifiedAutomaticPlay() throws { var record = ownedRecord() var source = record["source"] as! [String: Any] source["entry_source"] = "../outside.c"; record["source"] = source XCTAssertThrowsError(try SoftwareLibraryOwnedGame.parse(libraryJSON(record))) record = ownedRecord(); record["getting_started"] = 1 XCTAssertThrowsError(try SoftwareLibraryOwnedGame.parse(libraryJSON(record))) record = ownedRecord(); record["publication_status"] = "fixture-only" let owned = try XCTUnwrap(SoftwareLibraryOwnedGame.parse(libraryJSON(record))) XCTAssertFalse(owned.firstPlayColdDOS, "Fixture metadata never opts into the vetted launch shortcut") } func testCompanionDecodedReleasesApplyTheSameOwnedMetadataValidation() async throws { let url = try fixture(); try installOwnedRecord(ownedRecord(), in: url) let catalog = try await SoftwareLibraryCatalog.load(from: url) let release = try XCTUnwrap(catalog.releases.first { $0.id == "cassette" }) let encoded = try JSONEncoder().encode(release) XCTAssertEqual(try JSONDecoder().decode(SoftwareLibraryRelease.self, from: encoded).ownedGame, release.ownedGame) var object = try JSONSerialization.jsonObject(with: encoded) as! [String: Any] var metadata = object["metadata"] as! [String: Any] metadata["owned_game"] = ["schema_version": 99]; object["metadata"] = metadata XCTAssertThrowsError(try JSONDecoder().decode(SoftwareLibraryRelease.self, from: JSONSerialization.data(withJSONObject: object))) } func testMultipleCategoriesAndCuratedGroupApplyBeforeAlphabeticalRegularTitles() throws { func title(_ id: String, name: String, featured: Bool, owned: Bool = true, copies: Int = 1) throws -> SoftwareLibraryTitle { let gameID = "vccplus." + id let releases = try (0.. SoftwareLibraryRelease in let releaseID = id + "-" + String(index) let record = ownedRecord(gameID: gameID, releaseID: releaseID, featured: featured) return SoftwareLibraryRelease(id: releaseID, titleID: gameID, name: name, category: "Disks/Educational", mediaType: "disk", contentRole: "software", sourceURL: URL(string: "https://example.invalid/fixture")!, modifiedAt: nil, modifiedPrecision: nil, modifiedTimezone: nil, packageSHA256: String(repeating: "a", count: 64), byteSize: index == 0 ? 123 : 999, languageStatus: "english", metadata: try libraryJSON(owned ? ["owned_game": record] : [:]), setup: .init(status: "spot-checked", command: "DOS\r", instructions: "Fixture", configuration: .object(["profile": .string("disk-basic"), "processor": .string("6809"), "ram_kib": .number(512)]), selectedMembers: .array([.object(["path": .string("GAME.DSK"), "target": .string("disk0")])]), reasons: [], validation: .object([:])), assets: [], downloadURLs: []) } return .init(id: gameID, name: name, identityStatus: "authored-fixture", releases: releases) } let titles = try [title("regular", name: "Aardvark", featured: false), title("second", name: "Quadrapassel", featured: true, copies: 2), title("first", name: "CoCoMan", featured: true), title("education", name: "Education Only", featured: false, owned: false)] var query = LibraryBrowseQuery(scope: .all, softwareType: "Games") let rows = query.apply(to: titles, favorites: [], installed: []) XCTAssertEqual(rows.map(\.name), ["CoCoMan", "Quadrapassel", "Aardvark"]) XCTAssertEqual(rows[1].matchingReleases.count, 2, "Editions stay together without duplicating their title") XCTAssertEqual(Set(rows.map(\.id)).count, 3) query.softwareType = "Educational" XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).count, 4) query.softwareType = "Games"; query.text = "Aardvark" XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).map(\.name), ["Aardvark"], "Filtering precedes promotion") query.text = ""; query.sort = .size XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).prefix(2).map(\.name), ["CoCoMan", "Quadrapassel"], "The curated group remains alphabetical") query.softwareType = ""; query.sort = .title XCTAssertEqual(query.apply(to: titles, favorites: [], installed: []).first?.name, "Aardvark", "All Software retains its ordinary selected sort") } func testReadOnlyGroupingAndEvidenceRemainDistinct() async throws { let url = try fixture(), original = try Data(contentsOf: url) let catalog = try await SoftwareLibraryCatalog.load(from: url) XCTAssertEqual(catalog.releaseCount, 2) XCTAssertEqual(catalog.titles.count, 1) XCTAssertEqual(catalog.titles[0].identityStatus, "suggested") XCTAssertEqual(catalog.categories, ["Cartridges", "Cassettes/Games"]) let cassette = try XCTUnwrap(catalog.releases.first { $0.id == "cassette" }) XCTAssertEqual(cassette.byteSize, 123) XCTAssertEqual(cassette.year, 1983) XCTAssertEqual(cassette.publisher, "Example Publisher") XCTAssertTrue(cassette.searchText.contains("SG-12")) XCTAssertTrue(cassette.searchText.contains("26-0000")) XCTAssertEqual(cassette.setup.compatibilityNotes, ["SG-12 not verified"]) XCTAssertTrue(cassette.setup.reasons.isEmpty) XCTAssertEqual(cassette.setup.instructions, "Mount the cassette; select Play.") XCTAssertEqual(cassette.setup.statusLabel, "Archive-assisted loading") XCTAssertEqual(cassette.assets[0].matchStatus, "candidate") XCTAssertEqual(cassette.assets[0].credit, "Original author; Color Computer Archive") XCTAssertEqual(cassette.modifiedAt, "2026-11-01T12:30:00") XCTAssertNil(cassette.modifiedTimezone) let cartridge = try XCTUnwrap(catalog.releases.first { $0.id == "cartridge" }) XCTAssertEqual(cartridge.setup.reasons, ["Choose media"]) XCTAssertEqual(cartridge.setup.configurationRequirements, ["Choose controller"]) XCTAssertNil(cartridge.modifiedAt) XCTAssertTrue(cartridge.downloadURLs.isEmpty) XCTAssertEqual(try Data(contentsOf: url), original) XCTAssertFalse(FileManager.default.fileExists(atPath: url.path + "-wal")) XCTAssertFalse(FileManager.default.fileExists(atPath: url.path + "-journal")) } func testMissingCatalogIsNotCreatedAndUnsupportedVersionIsRejected() async throws { let missing = directory.appendingPathComponent("missing.sqlite") do { _ = try await SoftwareLibraryCatalog.load(from: missing); XCTFail("Missing catalog accepted") } catch { XCTAssertTrue(error.localizedDescription.contains("does not contain")) } XCTAssertFalse(FileManager.default.fileExists(atPath: missing.path)) let url = try fixture() try execute(url, "PRAGMA user_version=99") do { _ = try await SoftwareLibraryCatalog.load(from: url); XCTFail("Newer catalog accepted") } catch { XCTAssertTrue(error.localizedDescription.contains("unsupported version")) } } func testBadRelationshipsJSONAndURLsAreRejected() async throws { let url = try fixture() try execute(url, "PRAGMA ignore_check_constraints=ON; UPDATE setup SET configuration_json='not json' WHERE release_id='cassette'") do { _ = try await SoftwareLibraryCatalog.load(from: url); XCTFail("Malformed JSON accepted") } catch { XCTAssertTrue(error.localizedDescription.contains("configuration_json")) } try execute(url, "UPDATE setup SET configuration_json='{}'; UPDATE release SET source_url='file:///private/catalog' WHERE id='cassette'") do { _ = try await SoftwareLibraryCatalog.load(from: url); XCTFail("File source URL accepted") } catch { XCTAssertTrue(error.localizedDescription.contains("source_url")) } try execute(url, "UPDATE release SET source_url='https://example.com/a'; DELETE FROM title") do { _ = try await SoftwareLibraryCatalog.load(from: url); XCTFail("Broken relationships accepted") } catch { XCTAssertTrue(error.localizedDescription.contains("relationships")) } } @MainActor func testPersonalStatePersistsIndependentlyOfCatalog() async throws { let url = try fixture(), original = try Data(contentsOf: url) let stateDirectory = directory.appendingPathComponent("Personal") let state = SoftwareLibraryState(directory: stateDirectory) XCTAssertTrue(state.installedReleases.isEmpty) state.toggleFavorite("title-a") state.selectRelease("cassette", for: "title-a") state.toggleFavorite("title-no-longer-in-catalog") await state.flush() let restored = SoftwareLibraryState(directory: stateDirectory) XCTAssertTrue(restored.isFavorite("title-a")) XCTAssertTrue(restored.isFavorite("title-no-longer-in-catalog")) XCTAssertEqual(restored.preferredReleaseID(for: "title-a"), "cassette") XCTAssertTrue(restored.installedReleases.isEmpty) XCTAssertEqual(try Data(contentsOf: url), original) restored.toggleFavorite("title-a") await restored.flush() XCTAssertFalse(SoftwareLibraryState(directory: stateDirectory).isFavorite("title-a")) } @MainActor func testCorruptOrNewerPersonalStateIsPreserved() async throws { let file = directory.appendingPathComponent("LibraryState.json") for bytes in [Data("damaged".utf8), Data("{\"version\":99,\"favoriteTitleIDs\":[],\"preferredReleaseIDs\":{},\"installedReleases\":{}}".utf8)] { try bytes.write(to: file) let state = SoftwareLibraryState(directory: directory) XCTAssertNotNil(state.saveError) state.toggleFavorite("title-a") state.selectRelease("cassette", for: "title-a") await state.flush() XCTAssertTrue(state.favoriteTitleIDs.isEmpty) XCTAssertEqual(try Data(contentsOf: file), bytes) } } }