381 lines
28 KiB
Swift
381 lines
28 KiB
Swift
// 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)))
|
|
}
|
|
}
|