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