399 lines
30 KiB
Swift
399 lines
30 KiB
Swift
// 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..<copies).map { index -> 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)
|
|
}
|
|
}
|
|
}
|