444 lines
33 KiB
Swift
444 lines
33 KiB
Swift
// 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()
|
|
}
|
|
|
|
}
|