Buckets:
localhost1978/localhost / LOCALHOST1978 /Modules /SSK_Foundation /Tests /SSK_FoundationTests /XPCBridgeDocGenTests.swift
| #if os(macOS) | |
| import Foundation | |
| import SSK_Abstractions | |
| import XCTest | |
| @testable import SSK_Foundation | |
| final class XPCBridgeDocGenTests: XCTestCase { | |
| func testStaleConnectionCallbackCannotClearReplacementGeneration() { | |
| var state = XPCConnectionGenerationState() | |
| let first = state.begin() | |
| let replacement = state.begin() | |
| XCTAssertFalse(state.clearIfActive(first)) | |
| XCTAssertEqual(state.activeGeneration, replacement) | |
| XCTAssertTrue(state.clearIfActive(replacement)) | |
| XCTAssertNil(state.activeGeneration) | |
| } | |
| func testExportedDocGenMethodUsesTheTypedRouter() async throws { | |
| let executor = XPCBridgeFakeDocGenExecutor() | |
| let router = DocGenXPCCommandRouter(executorResolver: { executor }) | |
| let exportedObject = SSKHostExportedObject(docGenRouter: router) | |
| let requestURI = makeDocGenRequestURI() | |
| let command = DocGenHostCommand.readResource( | |
| requestURI: requestURI, | |
| resource: .masterMarkdownIndex | |
| ) | |
| let commandData = try JSONEncoder().encode(command) | |
| let reply: (Data?, Error?) = await withCheckedContinuation { continuation in | |
| exportedObject.executeDocGenCommand(commandData) { data, error in | |
| continuation.resume(returning: (data, error)) | |
| } | |
| } | |
| XCTAssertNil(reply.1) | |
| let response = try JSONDecoder().decode( | |
| DocGenHostResponse.self, | |
| from: XCTUnwrap(reply.0) | |
| ) | |
| XCTAssertEqual( | |
| response, | |
| .resource( | |
| requestURI: command.requestURI, | |
| value: DocGenWorkerResponse( | |
| resource: .masterMarkdownIndex, | |
| uri: DocGenResource.masterMarkdownIndex.uri, | |
| mimeType: DocGenResource.masterMarkdownIndex.mimeType, | |
| text: "# Index" | |
| ) | |
| ) | |
| ) | |
| let requests = await executor.requests() | |
| XCTAssertEqual(requests, [DocGenWorkerRequest(resource: .masterMarkdownIndex)]) | |
| } | |
| func testMalformedDocGenDataDoesNotResolveTheWorker() async throws { | |
| let resolver = XPCBridgeResolverProbe() | |
| let router = DocGenXPCCommandRouter(executorResolver: { | |
| await resolver.markCalled() | |
| throw DocGenExecutorResolutionError.workerUnavailable | |
| }) | |
| let exportedObject = SSKHostExportedObject(docGenRouter: router) | |
| let responseData = await withCheckedContinuation { continuation in | |
| exportedObject.executeDocGenCommand(Data("not-json".utf8)) { data, _ in | |
| continuation.resume(returning: data) | |
| } | |
| } | |
| let response = try JSONDecoder().decode( | |
| DocGenHostResponse.self, | |
| from: XCTUnwrap(responseData) | |
| ) | |
| XCTAssertEqual(response, .failure(requestURI: nil, error: .malformedData)) | |
| let resolverWasCalled = await resolver.wasCalled() | |
| XCTAssertFalse(resolverWasCalled) | |
| } | |
| func testExportedVaultMethodRoutesTypedHealthRequestToController() async throws { | |
| let exportedObject = SSKHostExportedObject( | |
| docGenRouter: nil, | |
| vaultLifecycleController: VaultLifecycleController() | |
| ) | |
| let requestData = try JSONEncoder().encode( | |
| VaultHostRequest(operation: .health) | |
| ) | |
| let reply: (Data?, Error?) = await withCheckedContinuation { continuation in | |
| exportedObject.performVaultRequest(requestData) { data, error in | |
| continuation.resume(returning: (data, error)) | |
| } | |
| } | |
| XCTAssertNil(reply.1) | |
| let response = try JSONDecoder().decode( | |
| VaultHostResponse.self, | |
| from: XCTUnwrap(reply.0) | |
| ) | |
| XCTAssertEqual(response.isHealthy, true) | |
| XCTAssertNil(response.failure) | |
| } | |
| func testExportedVaultMethodReturnsTypedMalformedRequestFailure() async throws { | |
| let exportedObject = SSKHostExportedObject( | |
| docGenRouter: nil, | |
| vaultLifecycleController: VaultLifecycleController() | |
| ) | |
| let reply: (Data?, Error?) = await withCheckedContinuation { continuation in | |
| exportedObject.performVaultRequest(Data("not-json".utf8)) { data, error in | |
| continuation.resume(returning: (data, error)) | |
| } | |
| } | |
| XCTAssertNil(reply.1) | |
| let response = try JSONDecoder().decode( | |
| VaultHostResponse.self, | |
| from: XCTUnwrap(reply.0) | |
| ) | |
| XCTAssertEqual(response.failure?.code, .malformedRequest) | |
| } | |
| func testAnonymousExportedObjectRejectsVaultWork() async throws { | |
| let exportedObject = SSKHostExportedObject(docGenRouter: nil) | |
| let requestData = try JSONEncoder().encode( | |
| VaultHostRequest.mount(vaultID: VaultID()) | |
| ) | |
| let reply: (Data?, Error?) = await withCheckedContinuation { continuation in | |
| exportedObject.performVaultRequest(requestData) { data, error in | |
| continuation.resume(returning: (data, error)) | |
| } | |
| } | |
| XCTAssertNil(reply.1) | |
| let response = try JSONDecoder().decode( | |
| VaultHostResponse.self, | |
| from: XCTUnwrap(reply.0) | |
| ) | |
| XCTAssertEqual(response.failure?.code, .hostUnavailable) | |
| } | |
| func testMountRequestContainsIdentityButNoPathOrPassphrase() throws { | |
| let vaultID = VaultID(rawValue: UUID()) | |
| let requestData = try JSONEncoder().encode( | |
| VaultHostRequest.mount(vaultID: vaultID) | |
| ) | |
| let object = try XCTUnwrap( | |
| JSONSerialization.jsonObject(with: requestData) as? [String: Any] | |
| ) | |
| XCTAssertEqual(object["operation"] as? String, "mount") | |
| XCTAssertNotNil(object["vaultID"]) | |
| XCTAssertNil(object["imageURL"]) | |
| XCTAssertNil(object["passkey"]) | |
| XCTAssertNil(object["passphrase"]) | |
| XCTAssertNil(object["key"]) | |
| } | |
| func testUnknownVaultFailureRemainsTypedAcrossExportedBoundary() async throws { | |
| let exportedObject = SSKHostExportedObject( | |
| docGenRouter: nil, | |
| vaultLifecycleController: makeEmptyVaultController() | |
| ) | |
| let requestData = try JSONEncoder().encode( | |
| VaultHostRequest.status(vaultID: VaultID()) | |
| ) | |
| let reply: (Data?, Error?) = await withCheckedContinuation { continuation in | |
| exportedObject.performVaultRequest(requestData) { data, error in | |
| continuation.resume(returning: (data, error)) | |
| } | |
| } | |
| XCTAssertNil(reply.1) | |
| let response = try JSONDecoder().decode( | |
| VaultHostResponse.self, | |
| from: XCTUnwrap(reply.0) | |
| ) | |
| XCTAssertEqual(response.failure?.code, .vaultNotRegistered) | |
| XCTAssertNil(response.status) | |
| } | |
| func testFailedHealthReplyDoesNotSetConnectedState() async { | |
| let listener = NSXPCListener.anonymous() | |
| let delegate = XPCBridgeFailedHealthListenerDelegate() | |
| listener.delegate = delegate | |
| listener.resume() | |
| defer { listener.invalidate() } | |
| let bridge = XPCBridge() | |
| await bridge.connect(with: listener.endpoint) | |
| let isConnected = await bridge.isConnected | |
| XCTAssertFalse(isConnected) | |
| } | |
| } | |
| private actor XPCBridgeFakeDocGenExecutor: DocGenWorkerExecuting { | |
| private var recordedRequests: [DocGenWorkerRequest] = [] | |
| func execute(_ request: DocGenWorkerRequest) async throws -> DocGenWorkerResponse { | |
| recordedRequests.append(request) | |
| return DocGenWorkerResponse( | |
| resource: request.resource, | |
| uri: request.resource.uri, | |
| mimeType: request.resource.mimeType, | |
| text: "# Index" | |
| ) | |
| } | |
| func requests() -> [DocGenWorkerRequest] { | |
| recordedRequests | |
| } | |
| } | |
| private actor XPCBridgeResolverProbe { | |
| private var called = false | |
| func markCalled() { | |
| called = true | |
| } | |
| func wasCalled() -> Bool { | |
| called | |
| } | |
| } | |
| private func makeEmptyVaultController() -> VaultLifecycleController { | |
| let credentials = VaultCredentialStore( | |
| getOrCreatePassphrase: { _ in "unused" }, | |
| existingPassphrase: { _ in nil }, | |
| deleteKey: { _ in }, | |
| loadRecords: { [] }, | |
| saveRecords: { _ in } | |
| ) | |
| return VaultLifecycleController( | |
| credentials: credentials, | |
| diskOperator: XPCBridgeNoopVaultDiskOperator(), | |
| mountRootURL: URL( | |
| fileURLWithPath: "/private/tmp/ssk-xpc-vault-tests", | |
| isDirectory: true | |
| ), | |
| backgroundHooks: .unavailable | |
| ) | |
| } | |
| private struct XPCBridgeNoopVaultDiskOperator: VaultDiskOperating { | |
| func createVault( | |
| at imageURL: URL, | |
| passphrase: String, | |
| configuration: SparsebundleConfig | |
| ) throws -> VaultDiskCreation { | |
| throw XPCBridgeError.invalidVaultHostResponse | |
| } | |
| func mountVault( | |
| at imageURL: URL, | |
| passphrase: String, | |
| mountPoint: URL, | |
| expectedVolumeUUID: UUID | |
| ) throws -> VaultDiskSession { | |
| throw XPCBridgeError.invalidVaultHostResponse | |
| } | |
| func unmountVault(_ session: VaultDiskSession) throws { | |
| throw XPCBridgeError.invalidVaultHostResponse | |
| } | |
| } | |
| private final class XPCBridgeFailedHealthListenerDelegate: NSObject, NSXPCListenerDelegate { | |
| private let exportedObject = XPCBridgeFailedHealthHost() | |
| func listener( | |
| _ listener: NSXPCListener, | |
| shouldAcceptNewConnection newConnection: NSXPCConnection | |
| ) -> Bool { | |
| newConnection.exportedInterface = NSXPCInterface(with: SSKHostProtocol.self) | |
| newConnection.exportedObject = exportedObject | |
| newConnection.resume() | |
| return true | |
| } | |
| } | |
| private final class XPCBridgeFailedHealthHost: NSObject, SSKHostProtocol { | |
| func sendJSONRPCMessage( | |
| _ messageData: Data, | |
| reply: @escaping (Data?, Error?) -> Void | |
| ) { | |
| reply(nil, XPCBridgeError.inactiveConnection) | |
| } | |
| func executeDocGenCommand( | |
| _ commandData: Data, | |
| reply: @escaping (Data?, Error?) -> Void | |
| ) { | |
| reply(nil, XPCBridgeError.inactiveConnection) | |
| } | |
| func setDroppedFiles( | |
| _ files: [String], | |
| reply: @escaping (Bool) -> Void | |
| ) { | |
| reply(false) | |
| } | |
| func setupVPN( | |
| _ configData: Data, | |
| reply: @escaping (Bool, Error?) -> Void | |
| ) { | |
| reply(false, XPCBridgeError.inactiveConnection) | |
| } | |
| func performVaultRequest( | |
| _ requestData: Data, | |
| reply: @escaping (Data?, Error?) -> Void | |
| ) { | |
| let response = VaultHostResponse( | |
| failure: VaultHostFailure( | |
| code: .hostUnavailable, | |
| message: "The test host is unavailable." | |
| ) | |
| ) | |
| reply(try? JSONEncoder().encode(response), nil) | |
| } | |
| } | |
| private func makeDocGenRequestURI() -> SSKURI { | |
| SSKURI( | |
| authority: .node(nodeID: SSKURI.NodeIdentifier(uuid: UUID())), | |
| domain: .identity, | |
| subdomain: "docgen-request" | |
| ) | |
| } | |
| #endif | |
Xet Storage Details
- Size:
- 11.2 kB
- Xet hash:
- 53c10d53a56e3b7c44a970af3982021e11027049278e2f57e6105db58fc465c1
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.