Sync source edition with VCC Plus 3.7.0 build 63
This commit is contained in:
1 parent
c652a5276d
commit
b2ecec4d87
86 files changed
+10519
-472
No files matched your search
@@ -1,13 +1,66 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
import XCTest
|
||||
import ImageIO
|
||||
import UniformTypeIdentifiers
|
||||
|
||||
final class CompanionLibraryTests: XCTestCase {
|
||||
private static func release(_ id: String, media: String = "disk") -> SoftwareLibraryRelease {
|
||||
.init(id: id, titleID: "title", name: id, category: "Disks/Games", mediaType: media,
|
||||
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(["title": .string("Authored Example"), "optional": .null, "enabled": .bool(false), "count": .number(2)]),
|
||||
metadata: .object(metadata),
|
||||
setup: .init(status: "manual-setup", command: nil, instructions: "Follow the authored instructions.",
|
||||
configuration: .object([:]), selectedMembers: .array([]), reasons: [], validation: .object([:])),
|
||||
assets: [], downloadURLs: [])
|
||||
@@ -44,6 +97,61 @@ final class CompanionLibraryTests: XCTestCase {
|
||||
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)
|
||||
@@ -68,6 +176,301 @@ final class CompanionLibraryTests: XCTestCase {
|
||||
}
|
||||
}
|
||||
|
||||
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>()
|
||||
|
||||
Reference in new issue
Block a user