92 lines
5.6 KiB
Swift
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: []))
|
|
}
|
|
}
|
|
}
|