mirror of
https://github.com/XcodesOrg/XcodesApp.git
synced 2026-03-29 09:35:47 +00:00
459 lines
20 KiB
Swift
459 lines
20 KiB
Swift
import AppleAPI
|
||
import Combine
|
||
import CombineExpectations
|
||
import Path
|
||
import Version
|
||
import XCTest
|
||
import XcodesKit
|
||
|
||
@testable import Xcodes
|
||
|
||
class AppStateTests: XCTestCase {
|
||
var subject: AppState!
|
||
|
||
override func setUpWithError() throws {
|
||
Current = .mock
|
||
subject = AppState()
|
||
}
|
||
|
||
func test_ParseCertificateInfo_Succeeds() throws {
|
||
let sampleRawInfo = """
|
||
Executable=/Applications/Xcode-10.1.app/Contents/MacOS/Xcode
|
||
Identifier=com.apple.dt.Xcode
|
||
Format=app bundle with Mach-O thin (x86_64)
|
||
CodeDirectory v=20200 size=434 flags=0x2000(library-validation) hashes=6+5 location=embedded
|
||
Signature size=4485
|
||
Authority=Software Signing
|
||
Authority=Apple Code Signing Certification Authority
|
||
Authority=Apple Root CA
|
||
Info.plist entries=39
|
||
TeamIdentifier=59GAB85EFG
|
||
Sealed Resources version=2 rules=13 files=253327
|
||
Internal requirements count=1 size=68
|
||
"""
|
||
let info = subject.parseCertificateInfo(sampleRawInfo)
|
||
|
||
XCTAssertEqual(info.authority, ["Software Signing", "Apple Code Signing Certification Authority", "Apple Root CA"])
|
||
XCTAssertEqual(info.teamIdentifier, "59GAB85EFG")
|
||
XCTAssertEqual(info.bundleIdentifier, "com.apple.dt.Xcode")
|
||
}
|
||
|
||
func test_VerifySecurityAssessment_Fails() throws {
|
||
Current.shell.spctlAssess = { _ in
|
||
Fail(error: ProcessExecutionError(process: Process(), standardOutput: "stdout", standardError: "stderr"))
|
||
.eraseToAnyPublisher()
|
||
}
|
||
|
||
let installedXcode = InstalledXcode(path: Path("/Applications/Xcode-0.0.0.app")!)!
|
||
let recorder = subject.verifySecurityAssessment(of: installedXcode).record()
|
||
let completion = try wait(for: recorder.completion, timeout: 1, description: "Completion")
|
||
|
||
if case let .failure(error as InstallationError) = completion {
|
||
XCTAssertEqual(error, InstallationError.failedSecurityAssessment(xcode: installedXcode, output: "stdout\nstderr"))
|
||
}
|
||
else {
|
||
XCTFail()
|
||
}
|
||
}
|
||
|
||
func test_VerifySecurityAssessment_Succeeds() throws {
|
||
Current.shell.spctlAssess = { _ in
|
||
Just((0, "", "")).setFailureType(to: Error.self).eraseToAnyPublisher()
|
||
}
|
||
|
||
let installedXcode = InstalledXcode(path: Path("/Applications/Xcode-0.0.0.app")!)!
|
||
let recorder = subject.verifySecurityAssessment(of: installedXcode).record()
|
||
try wait(for: recorder.finished, timeout: 1, description: "Finished")
|
||
}
|
||
|
||
func test_Install_FullHappyPath_Apple() throws {
|
||
// Available xcode doesn't necessarily have build identifier
|
||
subject.allXcodes = [
|
||
.init(version: Version("0.0.0")!, installState: .notInstalled, selected: false, icon: nil),
|
||
.init(version: Version("0.0.0-Beta.1")!, installState: .notInstalled, selected: false, icon: nil),
|
||
.init(version: Version("0.0.0-Beta.2")!, installState: .notInstalled, selected: false, icon: nil),
|
||
]
|
||
|
||
// It hasn't been downloaded
|
||
Current.files.fileExistsAtPath = { path in
|
||
if path == (Path.xcodesApplicationSupport/"Xcode-0.0.0.xip").string {
|
||
return false
|
||
}
|
||
else {
|
||
return true
|
||
}
|
||
}
|
||
Xcodes.Current.network.validateSession = {
|
||
return Just(())
|
||
.setFailureType(to: Error.self).eraseToAnyPublisher()
|
||
}
|
||
Xcodes.Current.network.dataTask = { urlRequest in
|
||
// Don't have a valid session
|
||
if urlRequest.url! == URLRequest.olympusSession.url! {
|
||
return Fail(error: AuthenticationError.invalidSession)
|
||
.eraseToAnyPublisher()
|
||
}
|
||
// It's an available release version
|
||
else if urlRequest.url! == URLRequest.downloads.url! {
|
||
let downloads = Downloads(resultCode: 0, resultsString: nil, downloads: [Download(name: "Xcode 0.0.0", files: [Download.File(remotePath: "https://apple.com/xcode.xip", fileSize: 9484444)], dateModified: Date())])
|
||
let encoder = JSONEncoder()
|
||
encoder.dateEncodingStrategy = .formatted(.downloadsDateModified)
|
||
let downloadsData = try! encoder.encode(downloads)
|
||
return Just(
|
||
(
|
||
data: downloadsData,
|
||
response: HTTPURLResponse(url: urlRequest.url!, statusCode: 200, httpVersion: nil, headerFields: nil)!
|
||
)
|
||
)
|
||
.setFailureType(to: Error.self)
|
||
.eraseToAnyPublisher()
|
||
}
|
||
|
||
return Just(
|
||
(
|
||
data: Data(),
|
||
response: HTTPURLResponse(url: urlRequest.url!, statusCode: 200, httpVersion: nil, headerFields: nil)!
|
||
)
|
||
)
|
||
.setFailureType(to: Error.self)
|
||
.eraseToAnyPublisher()
|
||
}
|
||
// It downloads and updates progress
|
||
let progress = Progress(totalUnitCount: 100)
|
||
Current.network.downloadTask = { (url, saveLocation, _) -> (Progress, AnyPublisher<(saveLocation: URL, response: URLResponse), Error>) in
|
||
return (
|
||
progress,
|
||
Deferred {
|
||
Future { promise in
|
||
// Need this to run after the Promise has returned to the caller. This makes the test async, requiring waiting for an expectation.
|
||
DispatchQueue.main.async {
|
||
for i in 0...100 {
|
||
progress.completedUnitCount = Int64(i)
|
||
}
|
||
promise(.success((saveLocation: saveLocation,
|
||
response: HTTPURLResponse(url: url, statusCode: 200, httpVersion: nil, headerFields: nil)!)))
|
||
}
|
||
}
|
||
}
|
||
.eraseToAnyPublisher()
|
||
)
|
||
}
|
||
// It's a valid .app
|
||
Current.shell.codesignVerify = { _ in
|
||
Just(
|
||
ProcessOutput(
|
||
status: 0,
|
||
out: "",
|
||
err: """
|
||
TeamIdentifier=\(XcodeTeamIdentifier)
|
||
Authority=\(XcodeCertificateAuthority[0])
|
||
Authority=\(XcodeCertificateAuthority[1])
|
||
Authority=\(XcodeCertificateAuthority[2])
|
||
""")
|
||
)
|
||
.setFailureType(to: Error.self)
|
||
.eraseToAnyPublisher()
|
||
}
|
||
// Helper is already installed
|
||
subject.helperInstallState = .installed
|
||
|
||
let allXcodesRecorder = subject.$allXcodes.record()
|
||
let installRecorder = subject.install(
|
||
.version(AvailableXcode(version: Version("0.0.0")!, url: URL(string: "https://apple.com/xcode.xip")!, filename: "mock.xip", releaseDate: nil)),
|
||
downloader: .urlSession
|
||
).record()
|
||
try wait(for: installRecorder.finished, timeout: 1, description: "Finished")
|
||
|
||
let allXcodesElements = try wait(for: allXcodesRecorder.availableElements, timeout: 1, description: "All Xcodes Elements")
|
||
XCTAssertEqual(
|
||
allXcodesElements.map { $0.map(\.installState) },
|
||
[
|
||
[XcodeInstallState.notInstalled, .notInstalled, .notInstalled],
|
||
[.installing(.downloading(progress: progress)), .notInstalled, .notInstalled],
|
||
[.installing(.unarchiving), .notInstalled, .notInstalled],
|
||
[.installing(.moving(destination: "/Applications/Xcode-0.0.0.app")), .notInstalled, .notInstalled],
|
||
[.installing(.trashingArchive), .notInstalled, .notInstalled],
|
||
[.installing(.checkingSecurity), .notInstalled, .notInstalled],
|
||
[.installing(.finishing), .notInstalled, .notInstalled],
|
||
[.installed(Path("/Applications/Xcode-0.0.0.app")!), .notInstalled, .notInstalled]
|
||
]
|
||
)
|
||
}
|
||
|
||
func test_Install_FullHappyPath_XcodeReleases() throws {
|
||
// Available xcode has build identifier
|
||
subject.allXcodes = [
|
||
.init(version: Version("0.0.0+ABC123")!, installState: .notInstalled, selected: false, icon: nil),
|
||
.init(version: Version("0.0.0-Beta.1+DEF456")!, installState: .notInstalled, selected: false, icon: nil),
|
||
.init(version: Version("0.0.0-Beta.2+GHI789")!, installState: .notInstalled, selected: false, icon: nil)
|
||
]
|
||
|
||
// It hasn't been downloaded
|
||
Current.files.fileExistsAtPath = { path in
|
||
if path == (Path.xcodesApplicationSupport/"Xcode-0.0.0.xip").string {
|
||
return false
|
||
}
|
||
else {
|
||
return true
|
||
}
|
||
}
|
||
Xcodes.Current.network.dataTask = { urlRequest in
|
||
// Don't have a valid session
|
||
if urlRequest.url! == URLRequest.olympusSession.url! {
|
||
return Fail(error: AuthenticationError.invalidSession)
|
||
.eraseToAnyPublisher()
|
||
}
|
||
// It's an available release version
|
||
else if urlRequest.url! == URLRequest.downloads.url! {
|
||
let downloads = Downloads(resultCode: 0, resultsString: nil, downloads: [Download(name: "Xcode 0.0.0", files: [Download.File(remotePath: "https://apple.com/xcode.xip", fileSize: 9494944)], dateModified: Date())])
|
||
let encoder = JSONEncoder()
|
||
encoder.dateEncodingStrategy = .formatted(.downloadsDateModified)
|
||
let downloadsData = try! encoder.encode(downloads)
|
||
return Just(
|
||
(
|
||
data: downloadsData,
|
||
response: HTTPURLResponse(url: urlRequest.url!, statusCode: 200, httpVersion: nil, headerFields: nil)!
|
||
)
|
||
)
|
||
.setFailureType(to: Error.self)
|
||
.eraseToAnyPublisher()
|
||
}
|
||
|
||
return Just(
|
||
(
|
||
data: Data(),
|
||
response: HTTPURLResponse(url: urlRequest.url!, statusCode: 200, httpVersion: nil, headerFields: nil)!
|
||
)
|
||
)
|
||
.setFailureType(to: Error.self)
|
||
.eraseToAnyPublisher()
|
||
}
|
||
// It downloads and updates progress
|
||
let progress = Progress(totalUnitCount: 100)
|
||
Current.network.downloadTask = { (url, saveLocation, _) -> (Progress, AnyPublisher<(saveLocation: URL, response: URLResponse), Error>) in
|
||
return (
|
||
progress,
|
||
Deferred {
|
||
Future { promise in
|
||
// Need this to run after the Promise has returned to the caller. This makes the test async, requiring waiting for an expectation.
|
||
DispatchQueue.main.async {
|
||
for i in 0...100 {
|
||
progress.completedUnitCount = Int64(i)
|
||
}
|
||
promise(.success((saveLocation: saveLocation,
|
||
response: HTTPURLResponse(url: url, statusCode: 200, httpVersion: nil, headerFields: nil)!)))
|
||
}
|
||
}
|
||
}
|
||
.eraseToAnyPublisher()
|
||
)
|
||
}
|
||
// It's a valid .app
|
||
Current.shell.codesignVerify = { _ in
|
||
Just(
|
||
ProcessOutput(
|
||
status: 0,
|
||
out: "",
|
||
err: """
|
||
TeamIdentifier=\(XcodeTeamIdentifier)
|
||
Authority=\(XcodeCertificateAuthority[0])
|
||
Authority=\(XcodeCertificateAuthority[1])
|
||
Authority=\(XcodeCertificateAuthority[2])
|
||
""")
|
||
)
|
||
.setFailureType(to: Error.self)
|
||
.eraseToAnyPublisher()
|
||
}
|
||
// Helper is already installed
|
||
subject.helperInstallState = .installed
|
||
|
||
let allXcodesRecorder = subject.$allXcodes.record()
|
||
let installRecorder = subject.install(
|
||
.version(AvailableXcode(version: Version("0.0.0")!, url: URL(string: "https://apple.com/xcode.xip")!, filename: "mock.xip", releaseDate: nil)),
|
||
downloader: .urlSession
|
||
).record()
|
||
try wait(for: installRecorder.finished, timeout: 1, description: "Finished")
|
||
|
||
let allXcodesElements = try wait(for: allXcodesRecorder.availableElements, timeout: 1, description: "All Xcodes Elements")
|
||
XCTAssertEqual(
|
||
allXcodesElements.map { $0.map(\.installState) },
|
||
[
|
||
[XcodeInstallState.notInstalled, .notInstalled, .notInstalled],
|
||
[.installing(.downloading(progress: progress)), .notInstalled, .notInstalled],
|
||
[.installing(.unarchiving), .notInstalled, .notInstalled],
|
||
[.installing(.moving(destination: "/Applications/Xcode-0.0.0.app")), .notInstalled, .notInstalled],
|
||
[.installing(.trashingArchive), .notInstalled, .notInstalled],
|
||
[.installing(.checkingSecurity), .notInstalled, .notInstalled],
|
||
[.installing(.finishing), .notInstalled, .notInstalled],
|
||
[.installed(Path("/Applications/Xcode-0.0.0.app")!), .notInstalled, .notInstalled]
|
||
]
|
||
)
|
||
}
|
||
|
||
func test_Install_NotEnoughFreeSpace() throws {
|
||
Current.shell.unxip = { _, _ in
|
||
Fail(error: ProcessExecutionError(
|
||
process: Process(),
|
||
standardOutput: "xip: signing certificate was \"Development Update\" (validation not attempted)",
|
||
standardError: "xip: error: The archive “Xcode-12.4.0-Release.Candidate+12D4e.xip” can’t be expanded because the selected volume doesn’t have enough free space."
|
||
))
|
||
.eraseToAnyPublisher()
|
||
}
|
||
let archiveURL = URL(fileURLWithPath: "/Users/user/Library/Application Support/Xcode-0.0.0.xip")
|
||
|
||
let recorder = subject.unarchiveAndMoveXIP(
|
||
availableXcode: AvailableXcode(
|
||
version: Version("0.0.0")!,
|
||
url: URL(string: "https://developer.apple.com")!,
|
||
filename: "Xcode-0.0.0.xip",
|
||
releaseDate: nil
|
||
),
|
||
at: archiveURL,
|
||
to: URL(string: "/Applications/Xcode-0.0.0.app")!
|
||
).record()
|
||
|
||
let completion = try wait(for: recorder.completion, timeout: 1, description: "Completion")
|
||
|
||
if case let .failure(error as InstallationError) = completion {
|
||
XCTAssertEqual(
|
||
error,
|
||
InstallationError.notEnoughFreeSpaceToExpandArchive(archivePath: Path(url: archiveURL)!,
|
||
version: Version("0.0.0")!)
|
||
)
|
||
}
|
||
else {
|
||
XCTFail()
|
||
}
|
||
}
|
||
|
||
func test_UnarchiveAndMoveXIP_ConcurrentInstalls_DoNotShareExtractionDirectory() throws {
|
||
enum CollisionError: Error {
|
||
case extractionDirectoryCollision(String)
|
||
}
|
||
|
||
let stateQueue = DispatchQueue(label: "AppStateTests.ConcurrentInstallState")
|
||
var existingPaths = Set<String>()
|
||
var activeExtractionDirectories = Set<String>()
|
||
var usedExtractionDirectories: [String] = []
|
||
var failures: [Error] = []
|
||
var movedDestinations: [String] = []
|
||
var cancellables = Set<AnyCancellable>()
|
||
|
||
Current.files.createDirectory = { directoryURL, _, _ in
|
||
stateQueue.sync {
|
||
existingPaths.insert(directoryURL.path)
|
||
}
|
||
}
|
||
Current.files.fileExistsAtPath = { path in
|
||
stateQueue.sync {
|
||
existingPaths.contains(path)
|
||
}
|
||
}
|
||
Current.files.moveItem = { source, destination in
|
||
try stateQueue.sync {
|
||
guard existingPaths.remove(source.path) != nil else {
|
||
throw CocoaError(.fileNoSuchFile)
|
||
}
|
||
existingPaths.insert(destination.path)
|
||
}
|
||
}
|
||
Current.files.removeItem = { url in
|
||
stateQueue.sync {
|
||
existingPaths.remove(url.path)
|
||
existingPaths = Set(existingPaths.filter { !$0.hasPrefix(url.path + "/") })
|
||
}
|
||
}
|
||
|
||
Current.shell.unxip = { _, extractionDirectory in
|
||
Deferred {
|
||
Future { promise in
|
||
let hasCollision = stateQueue.sync { () -> Bool in
|
||
usedExtractionDirectories.append(extractionDirectory.path)
|
||
if activeExtractionDirectories.contains(extractionDirectory.path) {
|
||
return true
|
||
}
|
||
activeExtractionDirectories.insert(extractionDirectory.path)
|
||
return false
|
||
}
|
||
|
||
if hasCollision {
|
||
promise(.failure(CollisionError.extractionDirectoryCollision(extractionDirectory.path)))
|
||
return
|
||
}
|
||
|
||
DispatchQueue.global().asyncAfter(deadline: .now() + 0.05) {
|
||
stateQueue.sync {
|
||
existingPaths.insert(extractionDirectory.appendingPathComponent("Xcode.app").path)
|
||
activeExtractionDirectories.remove(extractionDirectory.path)
|
||
}
|
||
promise(.success((0, "", "")))
|
||
}
|
||
}
|
||
}
|
||
.eraseToAnyPublisher()
|
||
}
|
||
|
||
let sourceDirectory = URL(fileURLWithPath: "/tmp/xcodes-tests", isDirectory: true)
|
||
let availableXcode16_0 = AvailableXcode(
|
||
version: Version("16.0.0")!,
|
||
url: URL(string: "https://developer.apple.com/download/Xcode-16.0.xip")!,
|
||
filename: "Xcode-16.0.xip",
|
||
releaseDate: nil
|
||
)
|
||
let availableXcode16_1 = AvailableXcode(
|
||
version: Version("16.1.0")!,
|
||
url: URL(string: "https://developer.apple.com/download/Xcode-16.1.xip")!,
|
||
filename: "Xcode-16.1.xip",
|
||
releaseDate: nil
|
||
)
|
||
|
||
let firstDestination = URL(fileURLWithPath: "/Applications/Xcode-16.0.app")
|
||
let secondDestination = URL(fileURLWithPath: "/Applications/Xcode-16.1.app")
|
||
|
||
let finished = expectation(description: "Both unarchive operations finished")
|
||
finished.expectedFulfillmentCount = 2
|
||
|
||
func subscribe(_ publisher: AnyPublisher<URL, Error>) {
|
||
publisher
|
||
.sink(receiveCompletion: { completion in
|
||
if case let .failure(error) = completion {
|
||
stateQueue.sync {
|
||
failures.append(error)
|
||
}
|
||
}
|
||
finished.fulfill()
|
||
}, receiveValue: { movedURL in
|
||
stateQueue.sync {
|
||
movedDestinations.append(movedURL.path)
|
||
}
|
||
})
|
||
.store(in: &cancellables)
|
||
}
|
||
|
||
subscribe(
|
||
subject.unarchiveAndMoveXIP(
|
||
availableXcode: availableXcode16_0,
|
||
at: sourceDirectory.appendingPathComponent("Xcode-16.0.xip"),
|
||
to: firstDestination
|
||
)
|
||
)
|
||
subscribe(
|
||
subject.unarchiveAndMoveXIP(
|
||
availableXcode: availableXcode16_1,
|
||
at: sourceDirectory.appendingPathComponent("Xcode-16.1.xip"),
|
||
to: secondDestination
|
||
)
|
||
)
|
||
|
||
wait(for: [finished], timeout: 2.0)
|
||
|
||
XCTAssertTrue(failures.isEmpty, "Expected no extraction directory collisions, but got \(failures)")
|
||
XCTAssertEqual(Set(movedDestinations), Set([firstDestination.path, secondDestination.path]))
|
||
|
||
let expectedExtractionDirectories = Set([
|
||
sourceDirectory.appendingPathComponent("Xcode-\(availableXcode16_0.version)-extract").path,
|
||
sourceDirectory.appendingPathComponent("Xcode-\(availableXcode16_1.version)-extract").path
|
||
])
|
||
XCTAssertEqual(Set(usedExtractionDirectories), expectedExtractionDirectories)
|
||
}
|
||
}
|