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

495 lines
34 KiB
Swift

// 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<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: []))
}
}
}