// SPDX-License-Identifier: GPL-3.0-or-later import XCTest import ImageIO import UniformTypeIdentifiers final class CompanionLibraryTests: XCTestCase { func testColdServiceReadinessCanOutlastOldSixSecondLimitWithoutDelayingReadyService() async throws { var uptime: TimeInterval = 100, attempts = 0, pauses = 0 try await CompanionTransport.waitForService(now: { uptime }, sleep: { delay in pauses += 1; uptime += delay }, probe: { remaining in attempts += 1 XCTAssertGreaterThan(remaining, 0); XCTAssertLessThanOrEqual(remaining, 45) if uptime < 123 { throw CompanionTransport.Failure.unavailable } }) XCTAssertGreaterThan(uptime - 100, 22.9) XCTAssertGreaterThan(attempts, 60); XCTAssertEqual(pauses, attempts - 1) pauses = 0; attempts = 0 try await CompanionTransport.waitForService(now: { uptime }, sleep: { _ in pauses += 1 }, probe: { _ in attempts += 1 }) XCTAssertEqual(attempts, 1); XCTAssertEqual(pauses, 0) } func testColdServiceReadinessHasBoundedDeadlineAndKeepsRealErrors() async throws { var uptime: TimeInterval = 0, pauses = 0 do { try await CompanionTransport.waitForService(timeout: 0.25, now: { uptime }, sleep: { delay in pauses += 1; uptime += delay }, probe: { _ in throw CompanionTransport.Failure.unavailable }) XCTFail("A service that never starts must time out") } catch CompanionTransport.Failure.startupTimedOut { } XCTAssertEqual(uptime, 0.25, accuracy: 0.00001); XCTAssertEqual(pauses, 3) for failure in [CompanionTransport.Failure.untrustedPeer, .unsafeEndpoint, .unsupportedVersion, .timedOut, .remote("Denied")] { pauses = 0 do { try await CompanionTransport.waitForService(sleep: { _ in pauses += 1 }, probe: { _ in throw failure }) XCTFail("A real companion error must not be retried") } catch { XCTAssertEqual(error.localizedDescription, failure.localizedDescription) } XCTAssertEqual(pauses, 0) } } func testColdServiceReadinessCancelsDuringStartupWait() async throws { let waiting = expectation(description: "Startup is waiting for its missing listener") let task = Task { try await CompanionTransport.waitForService(sleep: { _ in waiting.fulfill() try await Task.sleep(for: .seconds(60)) }, probe: { _ in throw CompanionTransport.Failure.unavailable }) } await fulfillment(of: [waiting], timeout: 2) task.cancel() do { try await task.value; XCTFail("Cancellation must end startup polling") } catch is CancellationError { } } private static func release(_ id: String, media: String = "disk", owned: Bool = false) -> SoftwareLibraryRelease { var metadata: [String: LibraryJSON] = ["title": .string("Authored Example"), "optional": .null, "enabled": .bool(false), "count": .number(2)] if owned { metadata["owned_game"] = .object([:]) } return .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(metadata), 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 testBothAppsSharePersistedFavoritesAndEditionChoicesWithoutASecondStateFile() async throws { let root = FileManager.default.temporaryDirectory.appendingPathComponent("CompanionChoices-" + UUID().uuidString) defer { try? FileManager.default.removeItem(at: root) } let catalog = SoftwareLibraryCatalog(titles: [.init(id: "title", name: "Authored Example", identityStatus: "reviewed", releases: [Self.release("disk"), Self.release("second-disk")])], metadata: [:]) let host = SoftwareLibraryModel(state: .init(directory: root)) await host.load(from: root.appendingPathComponent("authored.sqlite"), catalogLoader: { _ in catalog }) host.state.toggleFavorite("title") host.state.selectRelease("second-disk", for: "title") await host.state.flush() let service = AuthorityLibrary(authority: .init(model: host)) let client = SoftwareLibraryModel(companion: service) { _ in XCTFail("Changing choices must not insert media.") } await client.load() XCTAssertTrue(client.state.isFavorite("title"), "A companion opening after a VCC Plus change reads the same choices.") XCTAssertEqual(client.state.preferredReleaseID(for: "title"), "second-disk") client.state.toggleFavorite("title") client.state.selectRelease("disk", for: "title") await client.state.flush() XCTAssertNil(client.state.saveError) XCTAssertFalse(host.state.isFavorite("title")) XCTAssertEqual(host.state.preferredReleaseID(for: "title"), "disk") // Reopening the authoritative state proves the response was persisted, // rather than copied only between the two current in-memory models. let persisted = SoftwareLibraryState(directory: root) XCTAssertNil(persisted.saveError) XCTAssertFalse(persisted.isFavorite("title")) XCTAssertEqual(persisted.preferredReleaseID(for: "title"), "disk") XCTAssertFalse(FileManager.default.fileExists(atPath: client.state.directory.appendingPathComponent("Unused.json").path)) let reopened = SoftwareLibraryModel(companion: service) { _ in XCTFail("Reopening must not insert media.") } await reopened.load() XCTAssertFalse(reopened.state.isFavorite("title")) XCTAssertEqual(reopened.state.preferredReleaseID(for: "title"), "disk") await reopened.shutdown(); await client.shutdown(); await host.shutdown() } @MainActor func testUnavailableCompanionCanBeRetriedWithoutCreatingLocalLibraryState() async throws { let service = RecoveringLibrary(catalog: Self.catalog) let model = SoftwareLibraryModel(companion: service) { _ in XCTFail("A failed or retried browse must not insert media.") } await model.load() XCTAssertNotNil(model.error) XCTAssertNil(model.catalog) XCTAssertFalse(model.loading) await service.reconnect() await model.load() XCTAssertNil(model.error) XCTAssertEqual(model.catalog?.releases.map(\.id), ["disk"]) XCTAssertFalse(model.loading) XCTAssertFalse(FileManager.default.fileExists(atPath: model.state.directory.appendingPathComponent("Unused.json").path)) await model.shutdown() } @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) } } func testPersonalCapabilityIsExplicitAndOlderRequestsDecodeWithoutIt() throws { let current = CompanionLibraryRequest(operation: .snapshot) XCTAssertEqual(current.personalTitlesVersion, 1) let old = try JSONDecoder().decode(CompanionLibraryRequest.self, from: Data("{\"operation\":\"snapshot\",\"requestID\":\"00000000-0000-0000-0000-000000000001\"}".utf8)) XCTAssertNil(old.personalTitlesVersion) XCTAssertNil(old.ownedTitlesVersion) let entry = PersonalSoftwareEntry(id: UUID(), title: "Private disk", files: [ .init(path: "game.dsk", kind: "disk", byteSize: 256, sha256: String(repeating: "a", count: 64))]) let release = entry.release(in: URL(fileURLWithPath: "/unused/PersonalLibrary/" + entry.id.uuidString.lowercased())) let catalog = SoftwareLibraryCatalog(titles: Self.catalog.titles + [ .init(id: entry.titleID, name: entry.title, identityStatus: "personal", releases: [release])], metadata: [:]) XCTAssertEqual(catalog.companionDisks(includingOwnedTitles: true).releases.map(\.id), ["disk"]) XCTAssertEqual(Set(catalog.companionDisksOnly.releases.map(\.id)), Set(["disk", entry.releaseID])) let mixed = SoftwareLibraryCatalog(titles: [.init(id: "title", name: "Mixed editions", identityStatus: "reviewed", releases: [Self.release("disk"), Self.release("owned", owned: true), Self.release("cart", media: "cartridge")])], metadata: [:]) XCTAssertEqual(mixed.companionDisks(includingOwnedTitles: false, includingPersonalTitles: true).releases.map(\.id), ["disk"]) XCTAssertEqual(mixed.companionDisks(includingOwnedTitles: true).releases.map(\.id), ["disk", "owned"]) } @MainActor func testAuthoritySharesCurrentPersonalDiskChoicesAndIndependentWritableCopies() async throws { let root = FileManager.default.temporaryDirectory.resolvingSymlinksInPath().appendingPathComponent("CompanionPersonal-" + UUID().uuidString) try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) defer { try? FileManager.default.removeItem(at: root) } let model = SoftwareLibraryModel(state: .init(directory: root.appendingPathComponent("State"))) let source = root.appendingPathComponent("GAME.dsk") let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/DECB.dsk") let original = try Data(contentsOf: fixture) try original.write(to: source) let manual = root.appendingPathComponent("README.txt"), instructions = Data("Private local instructions".utf8) try instructions.write(to: manual) let draft = try await model.personalStore.inspect([source, manual]) let entry = try await model.personalStore.save(draft) await model.load(from: root.appendingPathComponent("authored.sqlite"), catalogLoader: { _ in Self.catalog }) let authority = CompanionLibraryAuthority(model: model) let initial = try await authority.handle(.init(operation: .snapshot)) let snapshot = try XCTUnwrap(initial.snapshot) XCTAssertEqual(Set(snapshot.catalog.releases.map(\.id)), Set(["disk", entry.releaseID])) XCTAssertEqual(snapshot.installations.map(\.releaseID), [entry.releaseID]) XCTAssertTrue(snapshot.catalog.releases.first(where: { $0.id == entry.releaseID })!.downloadURLs.isEmpty) let favorite = try await authority.handle(.init(operation: .setFavorite, titleID: entry.titleID, enabled: true)) XCTAssertTrue(favorite.snapshot!.favorites.contains(entry.titleID)) let preferred = try await authority.handle(.init(operation: .setPreferredRelease, releaseID: entry.releaseID, titleID: entry.titleID)) XCTAssertEqual(preferred.snapshot!.preferredReleaseIDs[entry.titleID], entry.releaseID) for operation in [CompanionLibraryRequest.Operation.install, .installStatus] { let status = try await authority.handle(.init(operation: operation, releaseID: entry.releaseID)) XCTAssertFalse(status.isInstalling); XCTAssertEqual(status.receipt?.releaseID, entry.releaseID) } let directory = model.personalDirectory(entry), working = directory.appendingPathComponent("Working/GAME.dsk") var saved = original; saved[0] ^= 1; try saved.write(to: working) let members = try await authority.handle(.init(operation: .diskMembers, releaseID: entry.releaseID)) XCTAssertEqual(members.disks?.map(\.path), ["GAME.dsk"]) let export = try await authority.handle(.init(operation: .exportDisk, releaseID: entry.releaseID, memberPath: "GAME.dsk")) let copy = try XCTUnwrap(export.exportedDiskURL) XCTAssertNotEqual(copy, working); XCTAssertEqual(try Data(contentsOf: copy), saved) try Data([1, 2, 3]).write(to: copy) let second = try await authority.handle(.init(operation: .exportDisk, releaseID: entry.releaseID, memberPath: "GAME.dsk")) XCTAssertNotEqual(second.exportedDiskURL, copy) XCTAssertEqual(try Data(contentsOf: working), saved) XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Original/Files/GAME.dsk")), original) XCTAssertEqual(try Data(contentsOf: source), original) let asset = try XCTUnwrap(snapshot.catalog.releases.first(where: { $0.id == entry.releaseID })?.primaryManualAsset) let response = try await authority.handle(.init(operation: .manual, assetID: asset.id)) XCTAssertEqual(try Data(contentsOf: XCTUnwrap(response.assetFileURL)), instructions) let localManual = try XCTUnwrap(response.assetFileURL) try FileManager.default.removeItem(at: localManual) try FileManager.default.createSymbolicLink(at: localManual, withDestinationURL: manual) await assertFailure(authority, .init(operation: .manual, assetID: asset.id)) await assertFailure(authority, .init(operation: .removeInstallation, releaseID: entry.releaseID)) XCTAssertTrue(FileManager.default.fileExists(atPath: working.path)) await model.shutdown() } @MainActor func testAuthorityRefusesHiddenUnknownNondiskAndUnnegotiatedPersonalIDs() async throws { let root = FileManager.default.temporaryDirectory.resolvingSymlinksInPath().appendingPathComponent("CompanionHidden-" + UUID().uuidString) try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) defer { try? FileManager.default.removeItem(at: root) } let model = SoftwareLibraryModel(state: .init(directory: root.appendingPathComponent("State"))) let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/DECB.dsk") let draft = try await model.personalStore.inspect([fixture]) let visible = try await model.personalStore.save(draft) let duplicate = try await model.personalStore.inspect([fixture]) var hidden = try await model.personalStore.save(duplicate, allowDuplicate: true) hidden.hidden = true; try await model.personalStore.update(hidden) let cart = root.appendingPathComponent("CART.ccc"); try Data([0x39]).write(to: cart) let cartDraft = try await model.personalStore.inspect([cart]) let nondisk = try await model.personalStore.save(cartDraft) var unsupported: [PersonalSoftwareEntry] = [] for ext in ["dmk", "jvc", "vdk"] { let file = root.appendingPathComponent("Unsupported." + ext) try FileManager.default.copyItem(at: fixture, to: file) let draft = try await model.personalStore.inspect([file]) unsupported.append(try await model.personalStore.save(draft)) } await model.load(from: fixture, catalogLoader: { _ in Self.catalog }) let authority = CompanionLibraryAuthority(model: model) let current = try await authority.handle(.init(operation: .snapshot)) XCTAssertEqual(Set(current.snapshot!.catalog.releases.map(\.id)), Set(["disk", visible.releaseID])) for version in [nil, 2] as [Int?] { let response = try await authority.handle(.init(operation: .snapshot, personalTitlesVersion: version)) XCTAssertEqual(response.snapshot?.catalog.releases.map(\.id), ["disk"]) XCTAssertTrue(response.snapshot!.installations.isEmpty) await assertFailure(authority, .init(operation: .diskMembers, releaseID: visible.releaseID, personalTitlesVersion: version)) await assertFailure(authority, .init(operation: .setFavorite, titleID: visible.titleID, enabled: true, personalTitlesVersion: version)) } for entry in [hidden, nondisk] + unsupported { await assertFailure(authority, .init(operation: .diskMembers, releaseID: entry.releaseID)) await assertFailure(authority, .init(operation: .setFavorite, titleID: entry.titleID, enabled: true)) } await assertFailure(authority, .init(operation: .diskMembers, releaseID: "personal:unknown:edition")) await assertFailure(authority, .init(operation: .setPreferredRelease, releaseID: visible.releaseID, titleID: hidden.titleID)) await assertFailure(authority, .init(operation: .exportDisk, releaseID: visible.releaseID, memberPath: "../DECB.dsk")) await assertFailure(authority, .init(operation: .exportDisk, releaseID: visible.releaseID, memberPath: "missing.dsk")) var removed = visible; removed.hidden = true; try await model.personalStore.update(removed) await assertFailure(authority, .init(operation: .diskMembers, releaseID: visible.releaseID)) await model.shutdown() } @MainActor func testAuthorityRefusesPersonalWorkingAndMemberSymlinks() async throws { let root = FileManager.default.temporaryDirectory.resolvingSymlinksInPath().appendingPathComponent("CompanionLinks-" + UUID().uuidString) try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) defer { try? FileManager.default.removeItem(at: root) } let model = SoftwareLibraryModel(state: .init(directory: root.appendingPathComponent("State"))) let source = root.appendingPathComponent("Set/sub"), fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/DECB.dsk") try FileManager.default.createDirectory(at: source, withIntermediateDirectories: true) try FileManager.default.copyItem(at: fixture, to: source.appendingPathComponent("GAME.dsk")) let draft = try await model.personalStore.inspect([source.deletingLastPathComponent()]) let entry = try await model.personalStore.save(draft) await model.load(from: fixture, catalogLoader: { _ in Self.catalog }) let authority = CompanionLibraryAuthority(model: model), directory = model.personalDirectory(entry) let working = directory.appendingPathComponent("Working"), member = working.appendingPathComponent("sub/GAME.dsk") let original = try Data(contentsOf: fixture) try FileManager.default.removeItem(at: member) try FileManager.default.createSymbolicLink(at: member, withDestinationURL: fixture) await assertFailure(authority, .init(operation: .exportDisk, releaseID: entry.releaseID, memberPath: "sub/GAME.dsk")) try FileManager.default.removeItem(at: working.appendingPathComponent("sub")) try FileManager.default.createSymbolicLink(at: working.appendingPathComponent("sub"), withDestinationURL: source) await assertFailure(authority, .init(operation: .exportDisk, releaseID: entry.releaseID, memberPath: "sub/GAME.dsk")) try FileManager.default.moveItem(at: working, to: directory.appendingPathComponent("RetainedWorking")) try FileManager.default.createSymbolicLink(at: working, withDestinationURL: directory.appendingPathComponent("RetainedWorking")) await assertFailure(authority, .init(operation: .diskMembers, releaseID: entry.releaseID)) XCTAssertEqual(try Data(contentsOf: fixture), original) XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Original/Files/sub/GAME.dsk")), original) await model.shutdown() } @MainActor func testCompanionModelPlaysPersonalDiskThroughActualAuthority() async throws { let root = FileManager.default.temporaryDirectory.resolvingSymlinksInPath().appendingPathComponent("CompanionClient-" + UUID().uuidString) try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) defer { try? FileManager.default.removeItem(at: root) } let host = SoftwareLibraryModel(state: .init(directory: root.appendingPathComponent("State"))) let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/DECB.dsk") let source = root.appendingPathComponent("PRIVATE.dsk"), original = try Data(contentsOf: fixture) try original.write(to: source) let draft = try await host.personalStore.inspect([source]) let entry = try await host.personalStore.save(draft) await host.load(from: fixture, catalogLoader: { _ in Self.catalog }) let directory = host.personalDirectory(entry), working = directory.appendingPathComponent("Working/PRIVATE.dsk") var workingBytes = original; workingBytes[0] ^= 1 try workingBytes.write(to: working) let service = AuthorityLibrary(authority: .init(model: host)) var inserted: [URL] = [] var insertedBytes: [Data] = [] let client = SoftwareLibraryModel(companion: service) { url in inserted.append(url) insertedBytes.append(try Data(contentsOf: url)) // Real DriveWire writes must affect only its separate handoff image. try Data([0x42, 0x43]).write(to: url) } await client.load() XCTAssertNil(client.error) let release = try XCTUnwrap(client.catalog?.releases.first(where: { $0.id == entry.releaseID })) XCTAssertTrue(release.isPersonal) XCTAssertNotNil(client.state.installedReleases[entry.releaseID]) client.play(release) for _ in 0..<100 where client.installingReleaseID != nil { try await Task.sleep(nanoseconds: 20_000_000) } XCTAssertNil(client.installingReleaseID, "The local companion operation must complete without downloading or launching the emulator.") XCTAssertNil(client.installationErrors[entry.releaseID]); XCTAssertNil(client.launchError) XCTAssertEqual(inserted.count, 1) XCTAssertEqual(insertedBytes, [workingBytes]) let copy = try XCTUnwrap(inserted.first) XCTAssertNotEqual(copy, working) XCTAssertTrue(copy.path.hasPrefix(host.state.directory.appendingPathComponent("CompanionDisks").path + "/")) XCTAssertEqual(try Data(contentsOf: copy), Data([0x42, 0x43])) XCTAssertEqual(try Data(contentsOf: working), workingBytes) XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Original/Files/PRIVATE.dsk")), original) XCTAssertEqual(try Data(contentsOf: source), original) let requests = await service.requests XCTAssertEqual(requests.map(\.operation), [.snapshot, .install, .diskMembers, .exportDisk]) XCTAssertTrue(requests.allSatisfy { $0.personalTitlesVersion == 1 }) await client.shutdown(); await host.shutdown() } @MainActor func testSelectedPersonalCoverAndRemovalReachCompanionWithoutChangingDiskBytes() async throws { let root = FileManager.default.temporaryDirectory.resolvingSymlinksInPath().appendingPathComponent("CompanionCover-" + UUID().uuidString) try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) defer { try? FileManager.default.removeItem(at: root) } let host = SoftwareLibraryModel(state: .init(directory: root.appendingPathComponent("State"))) let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/DECB.dsk") let source = root.appendingPathComponent("GAME.dsk"), original = try Data(contentsOf: fixture) try original.write(to: source) let context = try XCTUnwrap(CGContext(data: nil, width: 24, height: 36, bitsPerComponent: 8, bytesPerRow: 24 * 4, space: CGColorSpaceCreateDeviceRGB(), bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)) context.setFillColor(CGColor(gray: 0.3, alpha: 1)); context.fill(CGRect(x: 0, y: 0, width: 24, height: 36)) let imageBytes = NSMutableData() let encoder = try XCTUnwrap(CGImageDestinationCreateWithData(imageBytes, UTType.png.identifier as CFString, 1, nil)) CGImageDestinationAddImage(encoder, try XCTUnwrap(context.makeImage()), nil) XCTAssertTrue(CGImageDestinationFinalize(encoder)) let authored = imageBytes as Data, imported = root.appendingPathComponent("Imported.png") try authored.write(to: imported) var draft = try await host.personalStore.inspect([source, imported]); draft.entry.category = "Games" let entry = try await host.personalStore.save(draft, coverPNG: authored) let directory = host.personalDirectory(entry), working = directory.appendingPathComponent("Working/GAME.dsk") var saved = original; saved[0] ^= 1; try saved.write(to: working) await host.load(from: fixture, catalogLoader: { _ in Self.catalog }) let authority = CompanionLibraryAuthority(model: host), service = AuthorityLibrary(authority: authority) let client = SoftwareLibraryModel(companion: service) { _ in XCTFail("Artwork browsing must not insert media.") } await client.load() let release = try XCTUnwrap(client.catalog?.releases.first { $0.id == entry.releaseID }) let asset = try XCTUnwrap(release.assets.first { $0.kind == "cover" }) XCTAssertEqual(release.assets.filter { $0.kind == "cover" }.count, 1) XCTAssertEqual(asset.name, "Personal Cover Image") XCTAssertTrue(asset.id.contains(":asset:PersonalCovers/")) XCTAssertTrue(SoftwareLibraryArtworkCache.canDisplay(asset)) let local = try XCTUnwrap(asset.thumbnailURL), retainedCover = try Data(contentsOf: local) let thumbnail = try await service.libraryRequest(.init(operation: .thumbnail, assetID: asset.id)) let decoded = try XCTUnwrap(SoftwareLibraryArtworkCache.image(from: XCTUnwrap(thumbnail.assetData))) XCTAssertEqual(decoded.width, 24); XCTAssertEqual(decoded.height, 36) // Even an otherwise selected local asset must retain its recorded hash. var changed = retainedCover; changed[changed.count - 1] ^= 1; try changed.write(to: local) await assertFailure(authority, .init(operation: .thumbnail, assetID: asset.id)) try retainedCover.write(to: local) let oldClient = try await service.libraryRequest(.init(operation: .snapshot, personalTitlesVersion: nil)) XCTAssertFalse(oldClient.snapshot!.catalog.titles.contains { $0.id == entry.titleID }) let beforeRemoval = try await service.libraryRequest(.init(operation: .exportDisk, releaseID: entry.releaseID, memberPath: "GAME.dsk")) let beforeCopy = try XCTUnwrap(beforeRemoval.exportedDiskURL) XCTAssertEqual(try Data(contentsOf: beforeCopy), saved) host.query.scope = .personal; host.selection = entry.titleID host.selectPersonalCover(.categoryIcon, for: entry) for _ in 0..<100 where host.personalSaving { try await Task.sleep(nanoseconds: 20_000_000) } XCTAssertFalse(host.personalSaving); XCTAssertNil(host.personalError) let reopened = SoftwareLibraryModel(companion: service) { _ in XCTFail("Removing artwork must not insert media.") } await reopened.load() let withoutCover = try XCTUnwrap(reopened.catalog?.releases.first { $0.id == entry.releaseID }) XCTAssertTrue(withoutCover.assets.filter { $0.thumbnailURL != nil }.isEmpty, "Removal must suppress the imported image as well, leaving the category illustration.") XCTAssertEqual(SoftwareLibraryCategoryStyle.symbol(for: LibraryBrowseQuery.type(of: withoutCover)), "gamecontroller") XCTAssertEqual(withoutCover.packageSHA256, release.packageSHA256) await assertFailure(authority, .init(operation: .thumbnail, assetID: asset.id)) let afterRemoval = try await service.libraryRequest(.init(operation: .exportDisk, releaseID: entry.releaseID, memberPath: "GAME.dsk")) let afterCopy = try XCTUnwrap(afterRemoval.exportedDiskURL) XCTAssertNotEqual(beforeCopy, afterCopy) XCTAssertEqual(try Data(contentsOf: afterCopy), saved) XCTAssertEqual(try Data(contentsOf: beforeCopy), saved) XCTAssertEqual(try Data(contentsOf: working), saved) XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Original/Files/GAME.dsk")), original) XCTAssertEqual(try Data(contentsOf: source), original) XCTAssertEqual(try Data(contentsOf: local), retainedCover) XCTAssertEqual(try Data(contentsOf: imported), authored) await client.shutdown(); await reopened.shutdown(); await host.shutdown() } @MainActor private func assertFailure(_ authority: CompanionLibraryAuthority, _ request: CompanionLibraryRequest, file: StaticString = #filePath, line: UInt = #line) async { do { _ = try await authority.handle(request); XCTFail("Expected refusal for \(request.operation)", file: file, line: line) } catch { } } private actor AuthorityLibrary: CompanionLibraryAccess { let authority: CompanionLibraryAuthority private(set) var requests: [CompanionLibraryRequest] = [] init(authority: CompanionLibraryAuthority) { self.authority = authority } func libraryRequest(_ request: CompanionLibraryRequest) async throws -> CompanionLibraryResponse { requests.append(request) return try await authority.handle(request) } } private actor RecoveringLibrary: CompanionLibraryAccess { let catalog: SoftwareLibraryCatalog private var connected = false init(catalog: SoftwareLibraryCatalog) { self.catalog = catalog } func reconnect() { connected = true } func libraryRequest(_ request: CompanionLibraryRequest) async throws -> CompanionLibraryResponse { guard connected else { throw CompanionTransport.Failure.unavailable } guard request.operation == .snapshot else { throw CompanionLibraryFailure(message: "Unexpected mutation in reconnect fixture.") } return .init(snapshot: .init(catalog: catalog, favorites: [], preferredReleaseIDs: [:], installations: [])) } } private actor FakeLibrary: CompanionLibraryAccess { let catalog: SoftwareLibraryCatalog var favorites = Set() 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: [])) } } }