Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

@@ -0,0 +1,197 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import CryptoKit
import Darwin
final class SoftwareLibraryInstallerTests: XCTestCase {
private var root: URL!
override func setUpWithError() throws {
root = FileManager.default.temporaryDirectory.appendingPathComponent("LibraryInstall-" + UUID().uuidString)
}
override func tearDownWithError() throws { if let root { try? FileManager.default.removeItem(at: root) } }
private func installer() -> SoftwareLibraryInstaller {
let configuration = URLSessionConfiguration.ephemeral
configuration.protocolClasses = [LibraryInstallTestTransport.self]
return SoftwareLibraryInstaller(root: root, session: URLSession(configuration: configuration))
}
private func release(_ scenario: String = "success", id: String = "authored-example", zipped: Bool = false) -> SoftwareLibraryRelease {
let bytes = zipped ? LibraryInstallTestTransport.zip : LibraryInstallTestTransport.bytes
let ext = zipped ? "zip" : "ccc"
let sha = SHA256.hash(data: bytes).map { String(format: "%02x", $0) }.joined()
return SoftwareLibraryRelease(id: id, titleID: "title", name: "Example." + ext, category: "Cartridges",
mediaType: "cartridge", contentRole: "software", sourceURL: URL(string: "https://example.invalid/Example." + ext)!,
modifiedAt: nil, modifiedPrecision: nil, modifiedTimezone: nil, packageSHA256: sha,
byteSize: Int64(bytes.count), languageStatus: "english", metadata: .object([:]),
setup: .init(status: "manual-setup", command: nil, instructions: "Manual loading", configuration: .object([:]),
selectedMembers: .array([]), reasons: [], validation: .object([:])), assets: [],
downloadURLs: [URL(string: "https://vccplus.brianholman.com/dl/software/CoCoLibrary/Cartridges/" + scenario + "." + ext)!])
}
func testHostedURLBoundaryAndOpaqueReleaseIdentity() {
XCTAssertTrue(SoftwareLibraryInstaller.acceptsDownloadURL(release().downloadURLs[0]))
for text in ["http://vccplus.brianholman.com/dl/software/CoCoLibrary/a.zip", "https://evil.test/a.zip",
"https://vccplus.brianholman.com/other/a.zip", "https://[email protected]/dl/software/CoCoLibrary/a.zip",
"https://vccplus.brianholman.com/dl/software/CoCoLibrary/a.zip?next=evil"] {
XCTAssertFalse(SoftwareLibraryInstaller.acceptsDownloadURL(URL(string: text)!))
}
let key = SoftwareLibraryInstaller.releaseKey("../../title with spaces")
XCTAssertEqual(key.count, 64); XCTAssertTrue(key.allSatisfy(\.isHexDigit))
}
func testInstallRawRecoversAndNeverReplacesEditedWorkingMedia() async throws {
let service = installer(), selected = release()
let receipt = try await service.install(selected)
let file = receipt.workingDirectory.appendingPathComponent("Example.ccc")
XCTAssertEqual(try Data(contentsOf: file), LibraryInstallTestTransport.bytes)
try Data("user saved changes".utf8).write(to: file)
let repeated = try await service.install(selected)
XCTAssertEqual(repeated.workingDirectory.resolvingSymlinksInPath(), receipt.workingDirectory.resolvingSymlinksInPath())
XCTAssertEqual(try Data(contentsOf: file), Data("user saved changes".utf8))
let recovered = try await installer().recoverInstallations()
XCTAssertEqual(recovered.count, 1)
XCTAssertEqual(recovered.first?.releaseID, selected.id)
let original = receipt.workingDirectory.deletingLastPathComponent().appendingPathComponent("Original/Files/Example.ccc")
XCTAssertEqual(try Data(contentsOf: original), LibraryInstallTestTransport.bytes)
let attrs = try FileManager.default.attributesOfItem(atPath: original.path)
XCTAssertEqual((attrs[.posixPermissions] as? NSNumber)?.intValue, 0o444)
XCTAssertTrue(try FileManager.default.contentsOfDirectory(atPath: root.appendingPathComponent(".Staging").path).isEmpty)
}
func testZIPTreeIsPreservedAndWorkingCopyIsIndependent() async throws {
let receipt = try await installer().install(release(zipped: true))
XCTAssertEqual(Set(receipt.relativeFiles), ["Game/HELLO.BAS", "Game/DATA.TXT"])
let file = receipt.workingDirectory.appendingPathComponent("Game/DATA.TXT")
XCTAssertEqual(String(data: try Data(contentsOf: file), encoding: .utf8), "sample data\r")
try Data("edited".utf8).write(to: file)
let original = receipt.workingDirectory.deletingLastPathComponent().appendingPathComponent("Original/Files/Game/DATA.TXT")
XCTAssertEqual(String(data: try Data(contentsOf: original), encoding: .utf8), "sample data\r")
}
func testCorruptTruncatedAndFailedDownloadsLeaveNoReceiptOrPartialWorkingTree() async throws {
for scenario in ["corrupt", "truncated", "http-error", "oversized"] {
let service = installer()
do { _ = try await service.install(release(scenario)); XCTFail("Expected failure for \(scenario)") }
catch { }
let found = try await service.recoverInstallations()
XCTAssertTrue(found.isEmpty, scenario)
XCTAssertTrue(try FileManager.default.contentsOfDirectory(atPath: root.appendingPathComponent(".Staging").path).isEmpty)
}
}
func testCancellationCleansStagingAndRetrySucceeds() async throws {
let service = installer()
let selected = release("cancel")
let task = Task { try await service.install(selected) }
try await Task.sleep(nanoseconds: 100_000_000)
task.cancel()
do { _ = try await task.value; XCTFail("Expected cancellation") }
catch is CancellationError { }
catch { XCTFail("Unexpected cancellation error: \(error)") }
let remaining = try await service.recoverInstallations()
XCTAssertTrue(remaining.isEmpty)
XCTAssertTrue(try FileManager.default.contentsOfDirectory(atPath: root.appendingPathComponent(".Staging").path).isEmpty)
_ = try await service.install(release())
}
func testForgetPreservesFilesAndReinstallCreatesFreshGeneration() async throws {
let service = installer(), selected = release()
let first = try await service.install(selected)
let working = first.workingDirectory.appendingPathComponent("Example.ccc")
try Data("keep my changes".utf8).write(to: working)
let retained = try await service.forgetInstallation(releaseID: selected.id)
XCTAssertEqual(retained?.resolvingSymlinksInPath(), first.workingDirectory.resolvingSymlinksInPath())
let remaining = try await service.recoverInstallations()
XCTAssertTrue(remaining.isEmpty)
XCTAssertEqual(String(data: try Data(contentsOf: working), encoding: .utf8), "keep my changes")
let second = try await service.install(selected)
XCTAssertNotEqual(second.workingDirectory, first.workingDirectory)
XCTAssertEqual(try Data(contentsOf: second.workingDirectory.appendingPathComponent("Example.ccc")), LibraryInstallTestTransport.bytes)
XCTAssertEqual(String(data: try Data(contentsOf: working), encoding: .utf8), "keep my changes")
}
func testCorruptSharedPackageIsReplacedOnlyInsideOwnedCache() async throws {
let service = installer(), selected = release()
_ = try await service.recoverInstallations()
let cached = root.appendingPathComponent("Packages/" + selected.packageSHA256 + ".package")
try Data("bad cache".utf8).write(to: cached)
_ = try await service.install(selected)
XCTAssertEqual(try Data(contentsOf: cached), LibraryInstallTestTransport.bytes)
}
func testCorruptReceiptIsPreservedAndCannotRedirectWorkingDirectory() async throws {
let service = installer(), selected = release()
let receipt = try await service.install(selected)
let path = receipt.workingDirectory.deletingLastPathComponent().appendingPathComponent("receipt.json")
let original = try Data(contentsOf: path)
var json = try XCTUnwrap(JSONSerialization.jsonObject(with: original) as? [String: Any])
json["relativeFiles"] = ["../../outside"]
let broken = try JSONSerialization.data(withJSONObject: json)
try broken.write(to: path)
let recovered = try await service.recoverInstallations()
XCTAssertTrue(recovered.isEmpty)
let warnings = await service.recoveryWarnings
XCTAssertEqual(warnings.count, 1)
do { _ = try await service.install(selected); XCTFail("Damaged target must block reinstall") } catch { }
let other = try await service.install(release(id: "unrelated-title"))
let remaining = try await service.recoverInstallations()
XCTAssertEqual(remaining.map(\.releaseID), [other.releaseID])
XCTAssertEqual(try Data(contentsOf: path), broken)
XCTAssertTrue(FileManager.default.fileExists(atPath: receipt.workingDirectory.path))
}
func testRecoveryRemovesAbandonedStageButPreservesLockedStageAndUnknownFiles() async throws {
let service = installer()
_ = try await service.recoverInstallations()
let id = UUID().uuidString
let staging = root.appendingPathComponent(".Staging")
let stage = staging.appendingPathComponent(id)
try FileManager.default.createDirectory(at: stage, withIntermediateDirectories: false)
try Data("partial".utf8).write(to: stage.appendingPathComponent("partial.package"))
let unrelated = staging.appendingPathComponent("user-note.txt")
try Data("retain".utf8).write(to: unrelated)
let fd = open(root.appendingPathComponent(".Locks/stage-" + id).path, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR)
XCTAssertGreaterThanOrEqual(fd, 0)
defer { close(fd) }
XCTAssertEqual(flock(fd, LOCK_EX | LOCK_NB), 0)
_ = try await service.recoverInstallations()
XCTAssertTrue(FileManager.default.fileExists(atPath: stage.path))
XCTAssertEqual(flock(fd, LOCK_UN), 0)
_ = try await service.recoverInstallations()
XCTAssertFalse(FileManager.default.fileExists(atPath: stage.path))
XCTAssertTrue(FileManager.default.fileExists(atPath: unrelated.path))
}
func testSymlinkStoreIsRejectedWithoutTouchingTarget() async throws {
let external = root.appendingPathExtension("outside")
try FileManager.default.createDirectory(at: external, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: external) }
try FileManager.default.createSymbolicLink(at: root, withDestinationURL: external)
do { _ = try await installer().install(release()); XCTFail("Expected rejected symlink") } catch { }
XCTAssertTrue(try FileManager.default.contentsOfDirectory(atPath: external.path).isEmpty)
}
}
private final class LibraryInstallTestTransport: URLProtocol, @unchecked Sendable {
static let bytes = Data(repeating: 0x12, count: 8192)
static let zip = Data(base64Encoded: "UEsDBBQAAAAIAIF1ZF3932cmEwAAABEAAAAOAAAAR2FtZS9IRUxMTy5CQVMzNFAICPL0C1FQ8nD18fFX4gUAUEsDBBQAAAAIAIF1ZF065ACKDgAAAAwAAAANAAAAR2FtZS9EQVRBLlRYVCtOzC3ISVVISSxJ5AUAUEsBAhQDFAAAAAgAgXVkXf3fZyYTAAAAEQAAAA4AAAAAAAAAAAAAAIABAAAAAEdhbWUvSEVMTE8uQkFTUEsBAhQDFAAAAAgAgXVkXTrkAIoOAAAADAAAAA0AAAAAAAAAAAAAAIABPwAAAEdhbWUvREFUQS5UWFRQSwUGAAAAAAIAAgB3AAAAeAAAAAAA")!
private let lock = NSLock()
private var cancelled = false
override class func canInit(with request: URLRequest) -> Bool { true }
override class func canonicalRequest(for request: URLRequest) -> URLRequest { request }
override func startLoading() {
guard let url = request.url else { return }
let scenario = url.deletingPathExtension().lastPathComponent
if scenario == "http-error" {
client?.urlProtocol(self, didReceive: HTTPURLResponse(url: url, statusCode: 503, httpVersion: nil, headerFields: ["Content-Length": "0"])!, cacheStoragePolicy: .notAllowed)
client?.urlProtocolDidFinishLoading(self); return
}
var data = url.pathExtension == "zip" ? Self.zip : Self.bytes
if scenario == "corrupt" { data[0] ^= 0xff }
if scenario == "truncated" { data = Data(data.dropLast(5)) }
let expected = scenario == "oversized" ? data.count * 2 : data.count
client?.urlProtocol(self, didReceive: HTTPURLResponse(url: url, statusCode: 200, httpVersion: nil, headerFields: ["Content-Length": String(expected)])!, cacheStoragePolicy: .notAllowed)
if scenario == "cancel" {
DispatchQueue.global().asyncAfter(deadline: .now() + 1) { [weak self] in
guard let self else { return }
self.lock.lock(); let cancelled = self.cancelled; self.lock.unlock()
guard !cancelled else { return }
self.client?.urlProtocol(self, didLoad: Self.bytes)
self.client?.urlProtocolDidFinishLoading(self)
}
} else {
client?.urlProtocol(self, didLoad: data)
client?.urlProtocolDidFinishLoading(self)
}
}
override func stopLoading() { lock.lock(); cancelled = true; lock.unlock() }
}