Sync source edition with VCC Plus 3.7.0 build 63

This commit is contained in:
Brian Holman committed 2026-11-14 01:43:46 -07:00
1 parent c652a5276d
commit b2ecec4d87
86 files changed
+10519 -472

No files matched your search

@@ -0,0 +1,380 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import CryptoKit
import ImageIO
import UniformTypeIdentifiers
final class SoftwareLibraryPersonalTests: XCTestCase {
private var root: URL!
override func setUpWithError() throws {
root = FileManager.default.temporaryDirectory.resolvingSymlinksInPath().appendingPathComponent("PersonalLibraryTests-" + UUID().uuidString)
try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
}
override func tearDownWithError() throws { if let root { try? FileManager.default.removeItem(at: root) } }
private func service() -> PersonalSoftwareLibraryStore { .init(root: root.appendingPathComponent("PersonalLibrary")) }
private func cartridge(_ name: String = "GAME.ccc") throws -> URL {
let source = root.appendingPathComponent(name)
try Data([0x39,0x12,0x12,0x12]).write(to: source)
return source
}
private func png(width: Int = 96, height: Int = 128, gray: CGFloat = 0.25) throws -> Data {
let context = try XCTUnwrap(CGContext(data: nil, width: width, height: height, bitsPerComponent: 8,
bytesPerRow: width * 4, space: CGColorSpaceCreateDeviceRGB(), bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue))
context.setFillColor(CGColor(gray: gray, alpha: 1))
context.fill(CGRect(x: 0, y: 0, width: width, height: height))
let data = NSMutableData()
let destination = try XCTUnwrap(CGImageDestinationCreateWithData(data, UTType.png.identifier as CFString, 1, nil))
CGImageDestinationAddImage(destination, try XCTUnwrap(context.makeImage()), nil)
XCTAssertTrue(CGImageDestinationFinalize(destination))
return data as Data
}
func testSingleFloppyDefaultsToFD0WithoutEnablingAutomation() async throws {
let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/DECB.dsk")
let source = root.appendingPathComponent("GAME.dsk")
let bytes = try Data(contentsOf: fixture); try bytes.write(to: source)
let readme = root.appendingPathComponent("README.txt"); try Data("Instructions".utf8).write(to: readme)
let store = service(), draft = try await store.inspect([source, readme])
XCTAssertEqual(draft.entry.files.first(where: { $0.kind == "disk" })?.role, "disk0")
XCTAssertFalse(draft.entry.configured); XCTAssertTrue(draft.entry.command.isEmpty)
let entry = try await store.save(draft), directory = await store.directory(for: entry.id)
XCTAssertFalse(SoftwareLibraryLaunchPlan.hasPlayAction(for: entry.release(in: directory)))
let recovered = try await store.entries()
XCTAssertEqual(recovered.first?.files.first(where: { $0.kind == "disk" })?.role, "disk0")
XCTAssertEqual(try Data(contentsOf: source), bytes)
}
func testMultipleFloppiesKeepExplicitRolesAndSavedChoicesAreNotReset() async throws {
let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/DECB.dsk")
let first = root.appendingPathComponent("FIRST.dsk"), second = root.appendingPathComponent("SECOND.dsk")
let bytes = try Data(contentsOf: fixture); try bytes.write(to: first); try bytes.write(to: second)
let store = service(), multiple = try await store.inspect([first, second])
XCTAssertTrue(multiple.entry.files.allSatisfy { $0.role.isEmpty }, "Do not infer a boot disk from filename order")
await store.cancel(multiple.id)
let single = try await store.inspect([first]); var entry = try await store.save(single)
entry.files[0].role = "disk2"; try await store.update(entry)
let saved = try await store.entries()
XCTAssertEqual(saved.first?.files[0].role, "disk2", "Defaulting applies to new imports, not saved user choices")
XCTAssertEqual(try Data(contentsOf: second), bytes)
}
func testImportPreservesOriginalsAndWorkingSavesAndNeverPublishes() async throws {
let source = try cartridge(), bytes = try Data(contentsOf: source), store = service()
let draft = try await store.inspect([source])
XCTAssertEqual(draft.entry.profile, "rom-cartridge")
XCTAssertFalse(draft.entry.configured)
let entry = try await store.save(draft)
let directory = await store.directory(for: entry.id)
let working = directory.appendingPathComponent("Working/GAME.ccc")
XCTAssertEqual(try Data(contentsOf: working), bytes)
let saved = Data([0x10,0x20,0x30]); try saved.write(to: working)
XCTAssertEqual(try Data(contentsOf: source), bytes)
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Original/Files/GAME.ccc")), bytes)
let restored = try await service().entries()
XCTAssertEqual(restored.map(\.id), [entry.id])
XCTAssertEqual(try Data(contentsOf: working), saved)
let release = entry.release(in: directory)
XCTAssertTrue(release.isPersonal); XCTAssertFalse(release.isArchive)
XCTAssertTrue(release.downloadURLs.isEmpty)
XCTAssertTrue(release.sourceURL.isFileURL)
let catalog = SoftwareLibraryCatalog(titles: [.init(id: entry.titleID, name: entry.title, identityStatus: "personal", releases: [release])], metadata: [:])
XCTAssertTrue(catalog.companionDisksOnly.titles.isEmpty)
XCTAssertEqual(LibraryBrowseQuery(scope: .all).apply(to: catalog.titles, favorites: [], installed: []).map(\.id), [entry.titleID])
XCTAssertEqual(LibraryBrowseQuery(scope: .personal).apply(to: catalog.titles, favorites: [], installed: []).count,1)
XCTAssertEqual(LibraryBrowseQuery(scope: .favorites).apply(to: catalog.titles, favorites: [entry.titleID], installed: []).count,1)
}
func testDuplicateRequiresExplicitSeparateCopyAndHiddenEntryStaysHidden() async throws {
let source = try cartridge(), store = service()
let initial = try await store.inspect([source])
let first = try await store.save(initial)
let duplicate = try await store.inspect([source])
do { _ = try await store.save(duplicate); XCTFail("Expected duplicate review") }
catch PersonalSoftwareLibraryStore.Failure.duplicate(let id) { XCTAssertEqual(id, first.id) }
let second = try await store.save(duplicate, allowDuplicate: true)
XCTAssertNotEqual(first.id, second.id)
var removed = first; removed.hidden = true
try await store.update(removed)
let visible = try await service().entries()
XCTAssertEqual(visible.map(\.id), [second.id])
let retained = await store.directory(for: first.id)
XCTAssertTrue(FileManager.default.fileExists(atPath: retained.appendingPathComponent("Working/GAME.ccc").path))
}
func testPersonalCategoryDefaultsAndNormalizesWithoutReplacingWorkingFiles() async throws {
let source = try cartridge(), store = service()
var draft = try await store.inspect([source])
XCTAssertEqual(draft.entry.category, "Other")
draft.entry.category = "A custom category"
var entry = try await store.save(draft)
XCTAssertEqual(entry.category, "Other")
let directory = await store.directory(for: entry.id)
let working = directory.appendingPathComponent("Working/GAME.ccc")
let bytes = Data([0x39, 0x20, 0x30]); try bytes.write(to: working)
entry.category = "Games"; try await store.update(entry)
var recovered = try await store.entries()
XCTAssertEqual(recovered.first?.category, "Games")
for category in PersonalSoftwareEntry.standardCategories {
entry.category = category
let release = entry.release(in: directory)
XCTAssertEqual(LibraryBrowseQuery.type(of: release), category, "Each dropdown choice must use its actual category illustration")
}
// Simulate a free-form category saved by the previous development UI.
entry.category = "An old custom category"
try JSONEncoder().encode(entry).write(to: directory.appendingPathComponent("Entry.json"), options: .atomic)
recovered = try await store.entries()
XCTAssertEqual(recovered.first?.category, "Other")
XCTAssertEqual(try Data(contentsOf: working), bytes)
XCTAssertEqual(try Data(contentsOf: source), Data([0x39,0x12,0x12,0x12]))
}
func testSavedReviewedBasicCommandsOfferAutomaticLaunchWithoutTouchingMedia() async throws {
let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/DECB.dsk")
let source = root.appendingPathComponent("POPSTAR.DSK")
let bytes = try Data(contentsOf: fixture)
try bytes.write(to: source)
let store = service(), draft = try await store.inspect([source])
var entry = try await store.save(draft)
entry.configured = true; entry.video = "rgb"; entry.ramKiB = 512
entry.files[0].role = "disk0"
entry.command = "LOAD \"POPSTAR\"\nRUN"
try await store.update(entry)
let recovered = try await store.entries()
let saved = try XCTUnwrap(recovered.first)
let directory = await store.directory(for: saved.id)
let release = saved.release(in: directory)
XCTAssertTrue(SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: release))
let plan = try SoftwareLibraryLaunchPlan.prepare(release: release, receipt: saved.receipt(in: directory))
XCTAssertTrue(plan.automaticallyStarts)
XCTAssertEqual(plan.commands, ["LOAD \"POPSTAR\"", "RUN"])
XCTAssertEqual(plan.floppyURLs[0], directory.appendingPathComponent("Working/POPSTAR.DSK"))
XCTAssertEqual(plan.ramKiB, 512)
XCTAssertEqual(try Data(contentsOf: source), bytes)
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Working/POPSTAR.DSK")), bytes)
var manual = saved; manual.configured = false
XCTAssertFalse(SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: manual.release(in: directory)))
}
func testCancelAndSymlinkFailurePreserveSelectedFiles() async throws {
let source = try cartridge(), store = service()
let draft = try await store.inspect([source])
await store.cancel(draft.id)
let entries = try await store.entries(); XCTAssertTrue(entries.isEmpty)
XCTAssertEqual(try Data(contentsOf: source), Data([0x39,0x12,0x12,0x12]))
let folder = root.appendingPathComponent("Set")
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
try FileManager.default.createSymbolicLink(at: folder.appendingPathComponent("GAME.ccc"), withDestinationURL: source)
do { _ = try await store.inspect([folder]); XCTFail("Symbolic links must not be followed") } catch { }
XCTAssertEqual(try Data(contentsOf: source), Data([0x39,0x12,0x12,0x12]))
do { _ = try await store.inspect([root]); XCTFail("A source folder must not recursively include its own import destination.") } catch { }
}
func testMultiFileSetMetadataEditsAndInvalidRecipePreserveMedia() async throws {
let folder = root.appendingPathComponent("Owned Software")
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
try Data([0x39]).write(to: folder.appendingPathComponent("GAME.ccc"))
try Data("Private instructions".utf8).write(to: folder.appendingPathComponent("README.txt"))
let store = service(); let draft = try await store.inspect([folder])
XCTAssertEqual(draft.entry.files.map(\.path), ["GAME.ccc", "README.txt"], "Selected-folder aliases must not become member prefixes.")
var entry = try await store.save(draft)
let directory = await store.directory(for: entry.id)
let original = try Data(contentsOf: directory.appendingPathComponent("Original/Files/GAME.ccc"))
entry.title = "My purchased game"; entry.author = "Original author"
try await store.update(entry)
let recovered = try await service().entries()
XCTAssertEqual(recovered.first?.title, entry.title)
XCTAssertEqual(recovered.first?.files.count,2)
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Working/README.txt")), Data("Private instructions".utf8))
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Original/Files/GAME.ccc")), original)
entry.command = "hello\u{1B}"
do { try await store.update(entry); XCTFail("Control injection must fail") } catch { }
XCTAssertEqual(try Data(contentsOf: folder.appendingPathComponent("README.txt")), Data("Private instructions".utf8))
let release = recovered[0].release(in: directory)
let manual = try XCTUnwrap(release.primaryManualAsset)
try SoftwareLibraryLocalAsset.validate(manual, url: manual.manualURL!, maximumBytes: 1024*1024)
try Data("changed".utf8).write(to: manual.manualURL!)
XCTAssertThrowsError(try SoftwareLibraryLocalAsset.validate(manual,url:manual.manualURL!,maximumBytes:1024*1024))
}
func testZIPKeepsOriginalPackageAndCompleteWorkingTree() async throws {
let archive = root.appendingPathComponent("Authored Software.zip")
let bytes = Data(base64Encoded: "UEsDBBQAAAAAAAAAIVyFZweNAQAAAAEAAAANAAAAR2FtZS9HQU1FLmNjYzlQSwMEFAAAAAAAAAAhXFokposcAAAAHAAAAA8AAABHYW1lL1JFQURNRS50eHRBdXRob3JlZCBsb2NhbCBpbnN0cnVjdGlvbnMKUEsBAhQDFAAAAAAAAAAhXIVnB40BAAAAAQAAAA0AAAAAAAAAAAAAAKSBAAAAAEdhbWUvR0FNRS5jY2NQSwECFAMUAAAAAAAAACFcWiSmixwAAAAcAAAADwAAAAAAAAAAAAAApIEsAAAAR2FtZS9SRUFETUUudHh0UEsFBgAAAAACAAIAeAAAAHUAAAAAAA==")!
try bytes.write(to: archive)
let store = service()
let owned = try await store.inspect([archive])
let entry = try await store.save(owned)
let directory = await store.directory(for: entry.id)
XCTAssertEqual(entry.files.map(\.path), ["Game/GAME.ccc", "Game/README.txt"])
XCTAssertEqual(try Data(contentsOf: archive),bytes)
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Original/Package.zip")),bytes)
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Working/Game/README.txt")),Data("Authored local instructions\n".utf8))
}
func testReviewedZIPRejectsChangedValidBytesAndPreservesExistingLibrary() async throws {
let source = root.appendingPathComponent("Authored.zip")
let original = Data(base64Encoded: "UEsDBBQAAAAAAAAAIVyFZweNAQAAAAEAAAANAAAAR2FtZS9HQU1FLmNjYzlQSwMEFAAAAAAAAAAhXFokposcAAAAHAAAAA8AAABHYW1lL1JFQURNRS50eHRBdXRob3JlZCBsb2NhbCBpbnN0cnVjdGlvbnMKUEsBAhQDFAAAAAAAAAAhXIVnB40BAAAAAQAAAA0AAAAAAAAAAAAAAKSBAAAAAEdhbWUvR0FNRS5jY2NQSwECFAMUAAAAAAAAACFcWiSmixwAAAAcAAAADwAAAAAAAAAAAAAApIEsAAAAR2FtZS9SRUFETUUudHh0UEsFBgAAAAACAAIAeAAAAHUAAAAAAA==")!
try original.write(to: source)
let store = service(), reviewedHash = SHA256.hash(data: original).map { String(format: "%02x", $0) }.joined()
let draft = try await store.inspect([source]), entry = try await store.save(draft)
let retained = await store.directory(for: entry.id)
// Rename ZIP member directories in both local/central headers. Sizes and
// file CRCs remain valid: rejection must bind bytes, not just ZIP validity.
var changed = original, offset = 0
while let range = changed.range(of: Data("Game/".utf8), in: offset..<changed.count) {
changed.replaceSubrange(range, with: Data("Play/".utf8)); offset = range.upperBound
}
XCTAssertEqual(changed.count, original.count); XCTAssertNotEqual(changed, original)
try changed.write(to: source)
let extracted = root.appendingPathComponent("ChangedIsValid")
let paths = try VCCLibraryArchive.extractZIP(at: source, toNewDirectory: extracted, maximumExpandedBytes: 1024*1024, maximumEntries: 10, shouldCancel: { false })
XCTAssertEqual(paths, ["Play/GAME.ccc", "Play/README.txt"])
let attempted = root.appendingPathComponent("Unpublished.zip")
XCTAssertThrowsError(try PersonalSoftwareLibraryStore.copyReviewedPackage(from: source, to: attempted,
byteSize: Int64(original.count), sha256: reviewedHash))
XCTAssertFalse(FileManager.default.fileExists(atPath: attempted.path))
XCTAssertEqual(try Data(contentsOf: source), changed, "Failed import must not modify the selected source")
XCTAssertEqual(try Data(contentsOf: retained.appendingPathComponent("Original/Package.zip")), original)
XCTAssertEqual(try Data(contentsOf: retained.appendingPathComponent("Working/Game/GAME.ccc")), Data([0x39]))
let existing = try await store.entries(); XCTAssertEqual(existing.map(\.id), [entry.id])
}
func testPersonalCoverSelectionReplacementRemovalAndReloadPreserveMedia() async throws {
let source = try cartridge(), store = service(), firstPNG = try png(), secondPNG = try png(gray: 0.75)
let first = root.appendingPathComponent("A.png"), second = root.appendingPathComponent("B.png")
try firstPNG.write(to: first); try secondPNG.write(to: second)
let manual = root.appendingPathComponent("README.txt")
try Data("Retained manual".utf8).write(to: manual)
var draft = try await store.inspect([source, first, second, manual])
XCTAssertNil(draft.entry.cover)
XCTAssertEqual(draft.entry.selectedCoverFile?.path, "A.png")
let initialPreview = try await store.previewCover(draft.entry, draftID: draft.id)
XCTAssertEqual(initialPreview, try PersonalCoverImage.prepare(firstPNG))
draft.entry.cover = .imported("B.png")
let selectedPreview = try await store.previewCover(draft.entry, draftID: draft.id)
XCTAssertEqual(selectedPreview, try PersonalCoverImage.prepare(secondPNG))
var entry = try await store.save(draft)
let identity = entry.packageSHA256, files = entry.files.map(\.path)
let directory = await store.directory(for: entry.id), working = directory.appendingPathComponent("Working/GAME.ccc")
let savedProgram = Data([0x39, 0x20]); try savedProgram.write(to: working)
let release = entry.release(in: directory)
XCTAssertEqual(release.assets.filter { $0.kind == "cover" }.map(\.name), ["B.png"])
XCTAssertEqual(release.assets.filter(\.isManual).map(\.name), ["README.txt"])
let replacement = try png(width: 1800, height: 1000)
try await store.update(entry, coverPNG: replacement)
var reloaded = try await store.entries(); entry = try XCTUnwrap(reloaded.first)
guard case .custom(let custom) = entry.cover else { return XCTFail("Replacement cover must use a separate local asset.") }
XCTAssertTrue(custom.path.hasPrefix("PersonalCovers/"))
let customURL = directory.appendingPathComponent("Assets").appendingPathComponent(custom.path)
let customBytes = try Data(contentsOf: customURL)
XCTAssertEqual(Int64(customBytes.count), custom.byteSize)
XCTAssertEqual(custom.sha256, SHA256.hash(data: customBytes).map { String(format: "%02x", $0) }.joined())
let image = try XCTUnwrap(SoftwareLibraryArtworkCache.image(from: customBytes))
XCTAssertEqual(image.width, 640); XCTAssertLessThanOrEqual(image.height, 640)
let customAsset = try XCTUnwrap(entry.release(in: directory).assets.first { $0.kind == "cover" })
XCTAssertEqual(customAsset.name, "Personal Cover Image")
try SoftwareLibraryLocalAsset.validate(customAsset, url: customURL, maximumBytes: 2 * 1024 * 1024)
let customPreview = try await store.previewCover(entry)
XCTAssertEqual(customPreview, try PersonalCoverImage.prepare(customBytes))
try await store.update(entry, coverPNG: secondPNG)
reloaded = try await store.entries(); entry = try XCTUnwrap(reloaded.first)
XCTAssertNotEqual(entry.selectedCoverFile?.path, custom.path)
XCTAssertTrue(FileManager.default.fileExists(atPath: customURL.path), "Prior cover assets remain recoverable.")
entry.cover = .categoryIcon
try await store.update(entry)
reloaded = try await store.entries(); entry = try XCTUnwrap(reloaded.first)
XCTAssertEqual(entry.cover, .categoryIcon)
let removedPreview = try await store.previewCover(entry)
XCTAssertNil(removedPreview)
XCTAssertTrue(entry.release(in: directory).assets.filter { $0.kind == "cover" }.isEmpty)
XCTAssertEqual(entry.release(in: directory).assets.filter(\.isManual).map(\.name), ["README.txt"])
entry.cover = .imported("A.png"); try await store.update(entry)
reloaded = try await store.entries(); entry = try XCTUnwrap(reloaded.first)
XCTAssertEqual(entry.cover, .imported("A.png"))
XCTAssertEqual(entry.packageSHA256, identity); XCTAssertEqual(entry.files.map(\.path), files)
XCTAssertEqual(entry.receipt(in: directory).relativeFiles, files)
XCTAssertEqual(try Data(contentsOf: working), savedProgram)
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Original/Files/GAME.ccc")), Data([0x39,0x12,0x12,0x12]))
XCTAssertEqual(try Data(contentsOf: source), Data([0x39,0x12,0x12,0x12]))
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Original/Files/A.png")), firstPNG)
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Working/A.png")), firstPNG)
XCTAssertEqual(try Data(contentsOf: first), firstPNG)
XCTAssertTrue(FileManager.default.fileExists(atPath: customURL.path))
}
func testPersonalCoverPendingSaveCancelAndLegacyEntryCompatibility() async throws {
let source = try cartridge(), store = service(), image = try png()
let art = root.appendingPathComponent("cover.png"); try image.write(to: art)
let draft = try await store.inspect([source, art])
let pending = try PersonalCoverImage.prepare(art)
await store.cancel(draft.id)
let cancelled = try await store.entries(); XCTAssertTrue(cancelled.isEmpty)
do { _ = try await store.save(draft, coverPNG: pending); XCTFail("A canceled cover edit must not persist.") } catch { }
XCTAssertEqual(try Data(contentsOf: art), image)
let newDraft = try await store.inspect([source, art])
let entry = try await store.save(newDraft, coverPNG: pending)
guard case .custom = entry.cover else { return XCTFail("New imports can save their chosen local cover atomically.") }
let directory = await store.directory(for: entry.id)
XCTAssertEqual(entry.packageSHA256, newDraft.entry.packageSHA256)
XCTAssertEqual(entry.files.map(\.path), newDraft.entry.files.map(\.path))
// An actual pre-cover JSON record omits the optional key entirely.
var json = try XCTUnwrap(JSONSerialization.jsonObject(with: JSONEncoder().encode(entry)) as? [String: Any])
json.removeValue(forKey: "cover")
try JSONSerialization.data(withJSONObject: json).write(to: directory.appendingPathComponent("Entry.json"), options: .atomic)
let restored = try await store.entries(), legacy = try XCTUnwrap(restored.first)
XCTAssertNil(legacy.cover)
XCTAssertEqual(legacy.release(in: directory).assets.filter { $0.kind == "cover" }.map(\.name), ["cover.png"])
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Working/cover.png")), image)
}
func testCoverInputsRejectCorruptOversizedAndUnsafeFiles() throws {
let valid = try png(), selected = root.appendingPathComponent("selected.png")
try valid.write(to: selected)
XCTAssertThrowsError(try PersonalCoverImage.prepare(Data()))
XCTAssertThrowsError(try PersonalCoverImage.prepare(Data("invalid image".utf8)))
XCTAssertThrowsError(try PersonalCoverImage.prepare(Data(repeating: 0, count: 8 * 1024 * 1024 + 1)))
XCTAssertThrowsError(try PersonalCoverImage.prepare(png(width: 16_385, height: 1)))
XCTAssertThrowsError(try PersonalCoverImage.prepare(URL(string: "https://example.com/cover.png")!))
let link = root.appendingPathComponent("link.png")
try FileManager.default.createSymbolicLink(at: link, withDestinationURL: selected)
XCTAssertThrowsError(try PersonalCoverImage.prepare(link))
XCTAssertThrowsError(try PersonalCoverImage.prepare(root))
XCTAssertEqual(try Data(contentsOf: selected), valid)
}
func testCoverInvalidDescriptorsSymlinksAndStaleEditsPreserveSavedEntry() async throws {
let source = try cartridge(), store = service(), image = try png()
let draft = try await store.inspect([source]), entry = try await store.save(draft)
let directory = await store.directory(for: entry.id), record = directory.appendingPathComponent("Entry.json")
let before = try Data(contentsOf: record)
do { try await store.update(entry, coverPNG: Data("corrupt".utf8)); XCTFail("Invalid replacement must be refused.") } catch { }
var invalid = entry; invalid.cover = .imported("GAME.ccc")
do { try await store.update(invalid); XCTFail("Media cannot be selected as an imported cover.") } catch { }
for path in ["../outside.png", "PersonalCovers/../outside.png", "/outside.png", "PersonalCovers/not-a-uuid.png"] {
invalid.cover = .custom(.init(path: path, sha256: String(repeating: "a", count: 64), byteSize: 10))
do { try await store.update(invalid); XCTFail("Unsafe cover path must be refused: " + path) } catch { }
}
let assets = directory.appendingPathComponent("Assets"), outside = root.appendingPathComponent("Outside")
try FileManager.default.createDirectory(at: outside, withIntermediateDirectories: true)
try FileManager.default.createSymbolicLink(at: assets.appendingPathComponent("PersonalCovers"), withDestinationURL: outside)
do { try await store.update(entry, coverPNG: image); XCTFail("The cover destination must not follow links.") } catch { }
XCTAssertTrue(try FileManager.default.contentsOfDirectory(atPath: outside.path).isEmpty)
XCTAssertEqual(try Data(contentsOf: record), before)
try FileManager.default.removeItem(at: assets.appendingPathComponent("PersonalCovers"))
var external = entry; external.title = "Changed in another editor"
try await store.update(external)
let changed = try Data(contentsOf: record)
do { try await store.update(entry, coverPNG: image); XCTFail("An older cover editor must not overwrite newer metadata.") } catch { }
var staleRemoval = entry; staleRemoval.cover = .categoryIcon
do { try await store.update(staleRemoval); XCTFail("Stale cover removal must be refused.") } catch { }
XCTAssertEqual(try Data(contentsOf: record), changed)
XCTAssertFalse(FileManager.default.fileExists(atPath: assets.appendingPathComponent("PersonalCovers").path))
let recovered = try await store.entries(), current = try XCTUnwrap(recovered.first)
try await store.update(current, coverPNG: image)
let withCover = try await store.entries(), selected = try XCTUnwrap(withCover.first)
let cover = try XCTUnwrap(selected.selectedCoverFile), coverURL = assets.appendingPathComponent(cover.path)
let retained = try Data(contentsOf: coverURL), savedRecord = try Data(contentsOf: record)
try FileManager.default.removeItem(at: coverURL)
try FileManager.default.createSymbolicLink(at: coverURL, withDestinationURL: source)
do { _ = try await store.previewCover(selected); XCTFail("Preview must refuse a linked asset.") } catch { }
do { try await store.update(selected); XCTFail("Saving a linked selected asset must be refused.") } catch { }
XCTAssertEqual(try Data(contentsOf: record), savedRecord)
try FileManager.default.removeItem(at: coverURL); try retained.write(to: coverURL)
XCTAssertEqual(try Data(contentsOf: directory.appendingPathComponent("Working/GAME.ccc")), Data([0x39,0x12,0x12,0x12]))
XCTAssertEqual(try Data(contentsOf: source), Data([0x39,0x12,0x12,0x12]))
}
func testRelatedReferenceValidationAndPrivateCompanionBoundary() throws {
let id = String(repeating: "a",count:64)
let good = LibraryJSON.object(["id": .string("guide"), "title": .string("Example guide"), "document_id": .string(id), "sha256": .string(id), "role": .string("Hints"), "spoiler": .bool(true)])
XCTAssertEqual(try SoftwareLibraryRelatedReference.parse(good).documentID,id)
var bad = good.object; bad["page"] = .number(0)
XCTAssertThrowsError(try SoftwareLibraryRelatedReference.parse(.object(bad)))
bad = good.object; bad["sha256"] = .string(String(repeating:"b",count:64))
XCTAssertThrowsError(try SoftwareLibraryRelatedReference.parse(.object(bad)))
}
}