Buckets:
localhost1978/localhost / LOCALHOST1978 /Modules /SSK_Foundation /Tests /SSK_FoundationTests /SetupWorkflowTests.swift
| import Foundation | |
| @testable import SSK_Foundation | |
| import XCTest | |
| @available(macOS 27.0, iOS 27.0, *) | |
| final class SetupWorkflowTests: XCTestCase { | |
| func testFirstLaunchCompletesWithPrivateMountURL() async { | |
| let mountURL = privateMountURL() | |
| var events: [Event] = [] | |
| var states: [SetupWorkflow.State] = [] | |
| var activeVaultURL: URL? | |
| let workflow = makeWorkflow( | |
| bootstrapDaemon: { events.append(.bootstrap) }, | |
| connectToDaemon: { events.append(.connect) }, | |
| initializeVault: { | |
| events.append(.initialize) | |
| return mountURL | |
| }, | |
| activateVault: { url in | |
| events.append(.activate) | |
| activeVaultURL = url | |
| } | |
| ) | |
| await workflow.startSetup { states.append($0) } | |
| XCTAssertEqual(workflow.state, .completed(rootNodeURL: mountURL)) | |
| XCTAssertEqual(activeVaultURL, mountURL) | |
| XCTAssertEqual(events, [.bootstrap, .connect, .initialize, .activate]) | |
| XCTAssertEqual( | |
| states, | |
| [ | |
| .bootstrappingDaemon, | |
| .connectingToDaemon, | |
| .initializingVault, | |
| .completed(rootNodeURL: mountURL), | |
| ] | |
| ) | |
| XCTAssertFalse(mountURL.path.hasPrefix("/Volumes/")) | |
| } | |
| func testDaemonRegistrationFailureIsStableAndActionable() async { | |
| var events: [Event] = [] | |
| let workflow = makeWorkflow( | |
| bootstrapDaemon: { | |
| events.append(.bootstrap) | |
| throw FixtureError.privateDetail | |
| }, | |
| connectToDaemon: { events.append(.connect) }, | |
| initializeVault: { | |
| events.append(.initialize) | |
| return self.privateMountURL() | |
| } | |
| ) | |
| await workflow.startSetup() | |
| XCTAssertEqual( | |
| workflow.state, | |
| .failed(error: SetupWorkflowFailure.daemonRegistration.rawValue) | |
| ) | |
| XCTAssertEqual(events, [.bootstrap]) | |
| assertDoesNotExposePrivateError(workflow.state) | |
| } | |
| func testXPCHealthFailureStopsBeforeVaultInitialization() async { | |
| var events: [Event] = [] | |
| let workflow = makeWorkflow( | |
| bootstrapDaemon: { events.append(.bootstrap) }, | |
| connectToDaemon: { | |
| events.append(.connect) | |
| throw FixtureError.privateDetail | |
| }, | |
| initializeVault: { | |
| events.append(.initialize) | |
| return self.privateMountURL() | |
| } | |
| ) | |
| await workflow.startSetup() | |
| XCTAssertEqual( | |
| workflow.state, | |
| .failed(error: SetupWorkflowFailure.secureHostConnection.rawValue) | |
| ) | |
| XCTAssertEqual(events, [.bootstrap, .connect]) | |
| assertDoesNotExposePrivateError(workflow.state) | |
| } | |
| func testVaultInitializationFailureIsStableAndDoesNotActivateVault() async { | |
| var events: [Event] = [] | |
| let workflow = makeWorkflow( | |
| bootstrapDaemon: { events.append(.bootstrap) }, | |
| connectToDaemon: { events.append(.connect) }, | |
| initializeVault: { | |
| events.append(.initialize) | |
| throw FixtureError.privateDetail | |
| }, | |
| activateVault: { _ in events.append(.activate) } | |
| ) | |
| await workflow.startSetup() | |
| XCTAssertEqual( | |
| workflow.state, | |
| .failed(error: SetupWorkflowFailure.vaultInitialization.rawValue) | |
| ) | |
| XCTAssertEqual(events, [.bootstrap, .connect, .initialize]) | |
| assertDoesNotExposePrivateError(workflow.state) | |
| } | |
| func testRetryAfterFailureRunsTheFullFlowAndCompletes() async { | |
| let mountURL = privateMountURL() | |
| var bootstrapAttempts = 0 | |
| var connectionAttempts = 0 | |
| var initializationAttempts = 0 | |
| let workflow = makeWorkflow( | |
| bootstrapDaemon: { | |
| bootstrapAttempts += 1 | |
| if bootstrapAttempts == 1 { | |
| throw FixtureError.privateDetail | |
| } | |
| }, | |
| connectToDaemon: { connectionAttempts += 1 }, | |
| initializeVault: { | |
| initializationAttempts += 1 | |
| return mountURL | |
| } | |
| ) | |
| await workflow.startSetup() | |
| XCTAssertEqual( | |
| workflow.state, | |
| .failed(error: SetupWorkflowFailure.daemonRegistration.rawValue) | |
| ) | |
| await workflow.startSetup() | |
| XCTAssertEqual(workflow.state, .completed(rootNodeURL: mountURL)) | |
| XCTAssertEqual(bootstrapAttempts, 2) | |
| XCTAssertEqual(connectionAttempts, 1) | |
| XCTAssertEqual(initializationAttempts, 1) | |
| } | |
| func testDuplicateStartWhileSetupIsInProgressDoesNotStartASecondFlow() async { | |
| let gate = AsyncGate() | |
| var connectionAttempts = 0 | |
| var initializationAttempts = 0 | |
| let workflow = makeWorkflow( | |
| bootstrapDaemon: { await gate.wait() }, | |
| connectToDaemon: { connectionAttempts += 1 }, | |
| initializeVault: { | |
| initializationAttempts += 1 | |
| return self.privateMountURL() | |
| } | |
| ) | |
| let firstStart = Task { in | |
| await workflow.startSetup() | |
| } | |
| await gate.waitUntilEntered() | |
| await workflow.startSetup() | |
| let entriesBeforeRelease = await gate.entryCount | |
| XCTAssertEqual(entriesBeforeRelease, 1) | |
| await gate.open() | |
| await firstStart.value | |
| XCTAssertEqual(connectionAttempts, 1) | |
| XCTAssertEqual(initializationAttempts, 1) | |
| if case .completed = workflow.state { | |
| // Expected final state. | |
| } else { | |
| XCTFail("The first setup operation did not complete.") | |
| } | |
| } | |
| private func makeWorkflow( | |
| bootstrapDaemon: @escaping () async throws -> Void, | |
| connectToDaemon: @escaping () async throws -> Void, | |
| initializeVault: @escaping () async throws -> URL, | |
| activateVault: @escaping (URL) -> Void = { _ in } | |
| ) -> SetupWorkflow { | |
| SetupWorkflow( | |
| operations: SetupWorkflowOperations( | |
| bootstrapDaemon: bootstrapDaemon, | |
| connectToDaemon: connectToDaemon, | |
| initializeVault: initializeVault, | |
| activateVault: activateVault | |
| ) | |
| ) | |
| } | |
| private func privateMountURL() -> URL { | |
| URL( | |
| fileURLWithPath: "/Users/test/Library/Group Containers/group.com.superbright.ssk.mesh/VaultMounts/11111111-1111-1111-1111-111111111111", | |
| isDirectory: true | |
| ) | |
| } | |
| private func assertDoesNotExposePrivateError( | |
| _ state: SetupWorkflow.State, | |
| file: StaticString = #filePath, | |
| line: UInt = #line | |
| ) { | |
| guard case .failed(let message) = state else { | |
| XCTFail("Expected setup to fail.", file: file, line: line) | |
| return | |
| } | |
| XCTAssertFalse(message.contains(FixtureError.privateText), file: file, line: line) | |
| XCTAssertTrue(message.contains("retry"), file: file, line: line) | |
| } | |
| } | |
| @available(macOS 27.0, iOS 27.0, *) | |
| private extension SetupWorkflowTests { | |
| enum Event: Equatable { | |
| case bootstrap | |
| case connect | |
| case initialize | |
| case activate | |
| } | |
| enum FixtureError: LocalizedError { | |
| static let privateText = "/Users/private/Secret.sparsebundle" | |
| case privateDetail | |
| var errorDescription: String? { | |
| "Disk failed at \(Self.privateText) with internal code 42." | |
| } | |
| } | |
| } | |
| @available(macOS 27.0, iOS 27.0, *) | |
| private actor AsyncGate { | |
| private(set) var entryCount = 0 | |
| private var continuation: CheckedContinuation<Void, Never>? | |
| func wait() async { | |
| entryCount += 1 | |
| await withCheckedContinuation { continuation in | |
| self.continuation = continuation | |
| } | |
| } | |
| func waitUntilEntered() async { | |
| while entryCount == 0 { | |
| await Task.yield() | |
| } | |
| } | |
| func open() { | |
| continuation?.resume() | |
| continuation = nil | |
| } | |
| } | |
Xet Storage Details
- Size:
- 8.28 kB
- Xet hash:
- cfe1682e0344b60c495cab5473e1ce4ca47944bb9bb8ffd91bb5df9f105dc930
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.