Files
VCCPlusOSS/platforms/macos/Tests/CompanionLibraryTests.swift
T

92 lines
5.6 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
final class CompanionLibraryTests: XCTestCase {
private static func release(_ id: String, media: String = "disk") -> SoftwareLibraryRelease {
.init(id: id, titleID: "title", name: id, category: "Disks/Games", mediaType: media,
contentRole: "software", sourceURL: URL(string: "https://colorcomputerarchive.com/repo/Example.zip")!,
modifiedAt: nil, modifiedPrecision: nil, modifiedTimezone: nil,
packageSHA256: String(repeating: "a", count: 64), byteSize: 256, languageStatus: "unknown",
metadata: .object(["title": .string("Authored Example"), "optional": .null, "enabled": .bool(false), "count": .number(2)]),
setup: .init(status: "manual-setup", command: nil, instructions: "Follow the authored instructions.",
configuration: .object([:]), selectedMembers: .array([]), reasons: [], validation: .object([:])),
assets: [], downloadURLs: [])
}
private static var catalog: SoftwareLibraryCatalog {
.init(titles: [.init(id: "title", name: "Authored Example", identityStatus: "reviewed",
releases: [release("disk"), release("tape", media: "cassette")]),
.init(id: "cart-title", name: "Cartridge only", identityStatus: "reviewed",
releases: [release("cart", media: "cartridge")])],
metadata: ["schema_version": "1", "archive_attribution": "Color Computer Archive"])
}
func testWireRoundTripKeepsMetadataAndDiskFilterRemovesAlternateEditions() throws {
let bytes = try JSONEncoder().encode(Self.catalog)
let restored = try JSONDecoder().decode(SoftwareLibraryCatalog.self, from: bytes)
XCTAssertEqual(restored.titles.count, 2)
XCTAssertEqual(restored.releases.first?.metadata, Self.catalog.releases.first?.metadata)
XCTAssertEqual(restored.companionDisksOnly.titles.map(\.id), ["title"])
XCTAssertEqual(restored.companionDisksOnly.releases.map(\.id), ["disk"])
let request = CompanionLibraryRequest(operation: .setFavorite, titleID: "title", enabled: false)
XCTAssertEqual(try JSONDecoder().decode(CompanionLibraryRequest.self,
from: JSONEncoder().encode(request)).enabled, false)
}
@MainActor
func testCompanionStatePersistsMutationsThroughAuthority() async throws {
let service = FakeLibrary(catalog: Self.catalog)
let state = SoftwareLibraryState(companion: service)
state.toggleFavorite("title")
state.selectRelease("disk", for: "title")
await state.flush()
let requests = await service.requests
XCTAssertEqual(requests.map(\.operation), [.setFavorite, .setPreferredRelease])
XCTAssertTrue(state.isFavorite("title"))
XCTAssertEqual(state.preferredReleaseID(for: "title"), "disk")
XCTAssertNil(state.saveError)
XCTAssertFalse(FileManager.default.fileExists(atPath: state.directory.appendingPathComponent("Unused.json").path))
}
@MainActor
func testClearingFiltersAndChangingEditionCannotExposeTapeOrCartridge() async throws {
let service = FakeLibrary(catalog: Self.catalog)
let model = SoftwareLibraryModel(companion: service) { _ in XCTFail("Browsing must not insert media.") }
XCTAssertEqual(model.query.scope, .all, "Disk software without artwork must be visible on first opening.")
await model.load()
model.clearFilters()
for _ in 0..<100 where model.filtering { try await Task.sleep(nanoseconds: 20_000_000) }
XCTAssertEqual(model.rows.map(\.id), ["title"])
XCTAssertEqual(model.catalog?.releases.map(\.id), ["disk"])
XCTAssertEqual(model.selectedRow?.title.releases.map(\.id), ["disk"])
model.chooseRelease("tape")
XCTAssertEqual(model.selectedRelease?.id, "disk")
XCTAssertEqual(model.launchLabel(Self.release("disk"), installed: true), "Insert Disk…")
await model.shutdown()
}
func testAuthorityDiskMemberGateRejectsOtherMediaAndEscapes() {
XCTAssertTrue(CompanionLibraryAuthority.diskMember("disks/hello.DSK"))
XCTAssertTrue(CompanionLibraryAuthority.diskMember("boot.os9"))
for member in ["../hello.dsk", "/hello.dsk", "dir/../hello.dsk", "dir//hello.dsk", "dir\\hello.dsk", "disk:hello.dsk", "cart.ccc", "tape.cas", "graphic.png", "disk.dsk\n"] {
XCTAssertFalse(CompanionLibraryAuthority.diskMember(member), member)
}
}
private actor FakeLibrary: CompanionLibraryAccess {
let catalog: SoftwareLibraryCatalog
var favorites = Set<String>()
var preferred: [String: String] = [:]
private(set) var requests: [CompanionLibraryRequest] = []
init(catalog: SoftwareLibraryCatalog) { self.catalog = catalog }
func libraryRequest(_ request: CompanionLibraryRequest) async throws -> CompanionLibraryResponse {
requests.append(request)
switch request.operation {
case .setFavorite:
if request.enabled == true { favorites.insert(request.titleID!) }
else { favorites.remove(request.titleID!) }
case .setPreferredRelease: preferred[request.titleID!] = request.releaseID!
case .snapshot: break
default: throw CompanionLibraryFailure(message: "Unexpected operation in authored test.")
}
// Deliberately return unfiltered metadata: the client enforces disks-only too.
return .init(snapshot: .init(catalog: catalog, favorites: favorites, preferredReleaseIDs: preferred, installations: []))
}
}
}