Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

@@ -0,0 +1,300 @@
// 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 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 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()
}
}