11035384347

Committed 25 Sep 2024 02:40PM UTC coverage: 40.842% (-3.1%) from 43.981%

Build # 11035384347

Build Type

Pull #159

github

Committed by

web-flow

Commit Message

Merge 65ff99d66 into d3597e19d

Pull Request Pull Request #159: feat(agent): agent separation of concerns

Run Details

232 of 1063 new or added lines in 19 files covered. (21.83%)

187 existing lines in 14 files now uncovered.

5202 of 12737 relevant lines covered (40.84%)

97.32 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

46.15

/EdgeAgentSDK/EdgeAgent/Sources/DIDCommAgent/DIDCommAgent+Invitations.swift

import Domain
import Foundation

public extension DIDCommAgent {
    /// Enumeration representing the type of invitation
    enum InvitationType {
        /// Struct representing a Prism Onboarding invitation
        public struct PrismOnboarding {
            /// Sender of the invitation
            public let from: String
            /// Onboarding endpoint
            public let endpoint: URL
            /// The own DID of the user
            public let ownDID: DID
        }

        /// Case representing a Prism Onboarding invitation
        case onboardingPrism(PrismOnboarding)
        /// Case representing a DIDComm Out-of-Band invitation
        case onboardingDIDComm(OutOfBandInvitation)
    }

    /// Parses the given string as an Out-of-Band invitation
    /// - Parameter url: The string to parse
    /// - Returns: The parsed Out-of-Band invitation
    /// - Throws: `EdgeAgentError` if the string is not a valid URL
    func parseOOBInvitation(url: String) throws -> OutOfBandInvitation {
        guard let url = URL(string: url) else { throw CommonError.invalidURLError(url: url) }
        return try parseOOBInvitation(url: url)
    }

    /// Parses the given URL as an Out-of-Band invitation
    /// - Parameter url: The URL to parse
    /// - Returns: The parsed Out-of-Band invitation
    /// - Throws: `EdgeAgentError` if the URL is not a valid Out-of-Band invitation
    func parseOOBInvitation(url: URL) throws -> OutOfBandInvitation {
        return try DIDCommInvitationRunner(url: url).run()
    }

    /// Accepts a Prism Onboarding invitation and performs the onboarding process
    /// - Parameter invitation: The Prism Onboarding invitation to accept
    /// - Throws: `EdgeAgentError` if the onboarding process fails
    func acceptPrismInvitation(invitation: InvitationType.PrismOnboarding) async throws {
        struct SendDID: Encodable {
            let did: String
        }
        var request = URLRequest(url: invitation.endpoint)
        request.httpMethod = "POST"
        request.httpBody = try JSONEncoder().encode(SendDID(did: invitation.ownDID.string))
        request.setValue("application/json", forHTTPHeaderField: "content-type")
        do {
            let response = try await URLSession.shared.data(for: request)
            guard let urlResponse = response.1 as? HTTPURLResponse else {
                throw CommonError.invalidCoding(
                    message: "This should not happen cannot convert URLResponse to HTTPURLResponse"
                )
            }
            guard urlResponse.statusCode == 200 else {
                throw CommonError.httpError(
                    code: urlResponse.statusCode,
                    message: String(data: response.0, encoding: .utf8) ?? ""
                )
            }
        }
    }

    /// Parses the given string as an invitation
    /// - Parameter str: The string to parse
    /// - Returns: The parsed invitation
    /// - Throws: `EdgeAgentError` if the invitation is not a valid Prism or OOB type
    func parseInvitation(str: String) async throws -> InvitationType {
        if let prismOnboarding = try? await parsePrismInvitation(str: str) {
            return .onboardingPrism(prismOnboarding)
        } else if let message = try? parseOOBInvitation(url: str) {
            return .onboardingDIDComm(message)
        }
        throw EdgeAgentError.unknownInvitationTypeError
    }

    /// Parses the given string as a Prism Onboarding invitation
    /// - Parameter str: The string to parse
    /// - Returns: The parsed Prism Onboarding invitation
    /// - Throws: `EdgeAgentError` if the string is not a valid Prism Onboarding invitation
    func parsePrismInvitation(
        str: String
    ) async throws -> InvitationType.PrismOnboarding {
        let prismOnboarding = try PrismOnboardingInvitation(jsonString: str)
        guard
            let url = URL(string: prismOnboarding.body.onboardEndpoint)
        else { throw CommonError.invalidURLError(url: prismOnboarding.body.onboardEndpoint) }

        let ownDID = try await createNewPeerDID(
            services: [.init(
                id: "#didcomm-1",
                type: ["DIDCommMessaging"],
                serviceEndpoint: [.init(
                    uri: "https://localhost:8080/didcomm"
                )]
            )],
            updateMediator: false
        )

        return .init(
            from: prismOnboarding.body.from,
            endpoint: url,
            ownDID: ownDID
        )
    }

    /// Accepts an Out-of-Band (DIDComm) invitation and establishes a new connection
    /// - Parameter invitation: The Out-of-Band invitation to accept
    /// - Throws: `EdgeAgentError` if there is no mediator available or other errors occur during the acceptance process
    func acceptDIDCommInvitation(invitation: OutOfBandInvitation) async throws {
        guard
            let connectionManager
        else { throw EdgeAgentError.noMediatorAvailableError }
        logger.info(message: "Start accept DIDComm invitation")
        let ownDID = try await createNewPeerDID(updateMediator: true)

        logger.info(message: "Sending DIDComm Connection message")

        let pair = try await DIDCommConnectionRunner(
            invitationMessage: invitation,
            pluto: pluto,
            ownDID: ownDID,
            connection: connectionManager
        ).run()
        try await connectionManager.addConnection(pair)
    }
}

1	import Domain
2	import Foundation
3
4	public extension DIDCommAgent {
5	/// Enumeration representing the type of invitation
6	enum InvitationType {
7	/// Struct representing a Prism Onboarding invitation
8	public struct PrismOnboarding {
9	/// Sender of the invitation
10	public let from: String
11	/// Onboarding endpoint
12	public let endpoint: URL
13	/// The own DID of the user
14	public let ownDID: DID
15	}
16
17	/// Case representing a Prism Onboarding invitation
18	case onboardingPrism(PrismOnboarding)
19	/// Case representing a DIDComm Out-of-Band invitation
20	case onboardingDIDComm(OutOfBandInvitation)
21	}
22
23	/// Parses the given string as an Out-of-Band invitation
24	/// - Parameter url: The string to parse
25	/// - Returns: The parsed Out-of-Band invitation
26	/// - Throws: `EdgeAgentError` if the string is not a valid URL
27	func parseOOBInvitation(url: String) throws -> OutOfBandInvitation {	2✔
28	guard let url = URL(string: url) else { throw CommonError.invalidURLError(url: url) }	2✔
29	return try parseOOBInvitation(url: url)	2✔
30	}	2✔
31
32	/// Parses the given URL as an Out-of-Band invitation
33	/// - Parameter url: The URL to parse
34	/// - Returns: The parsed Out-of-Band invitation
35	/// - Throws: `EdgeAgentError` if the URL is not a valid Out-of-Band invitation
36	func parseOOBInvitation(url: URL) throws -> OutOfBandInvitation {	2✔
37	return try DIDCommInvitationRunner(url: url).run()	2✔
38	}	2✔
39
40	/// Accepts a Prism Onboarding invitation and performs the onboarding process
41	/// - Parameter invitation: The Prism Onboarding invitation to accept
42	/// - Throws: `EdgeAgentError` if the onboarding process fails
NEW 43	func acceptPrismInvitation(invitation: InvitationType.PrismOnboarding) async throws {	×
NEW 44	struct SendDID: Encodable {	×
NEW 45	let did: String	×
NEW 46	}	×
NEW 47	var request = URLRequest(url: invitation.endpoint)	×
NEW 48	request.httpMethod = "POST"	×
NEW 49	request.httpBody = try JSONEncoder().encode(SendDID(did: invitation.ownDID.string))	×
NEW 50	request.setValue("application/json", forHTTPHeaderField: "content-type")	×
NEW 51	do {	×
NEW 52	let response = try await URLSession.shared.data(for: request)	×
NEW 53	guard let urlResponse = response.1 as? HTTPURLResponse else {	×
NEW 54	throw CommonError.invalidCoding(	×
NEW 55	message: "This should not happen cannot convert URLResponse to HTTPURLResponse"	×
NEW 56	)	×
NEW 57	}	×
NEW 58	guard urlResponse.statusCode == 200 else {	×
NEW 59	throw CommonError.httpError(	×
NEW 60	code: urlResponse.statusCode,	×
NEW 61	message: String(data: response.0, encoding: .utf8) ?? ""	×
NEW 62	)	×
NEW 63	}	×
NEW 64	}	×
NEW 65	}	×
66
67	/// Parses the given string as an invitation
68	/// - Parameter str: The string to parse
69	/// - Returns: The parsed invitation
70	/// - Throws: `EdgeAgentError` if the invitation is not a valid Prism or OOB type
71	func parseInvitation(str: String) async throws -> InvitationType {	2✔
72	if let prismOnboarding = try? await parsePrismInvitation(str: str) {	2✔
73	return .onboardingPrism(prismOnboarding)	×
74	} else if let message = try? parseOOBInvitation(url: str) {	2✔
75	return .onboardingDIDComm(message)	2✔
76	}	2✔
77	throw EdgeAgentError.unknownInvitationTypeError	×
78	}	2✔
79
80	/// Parses the given string as a Prism Onboarding invitation
81	/// - Parameter str: The string to parse
82	/// - Returns: The parsed Prism Onboarding invitation
83	/// - Throws: `EdgeAgentError` if the string is not a valid Prism Onboarding invitation
84	func parsePrismInvitation(
85	str: String
86	) async throws -> InvitationType.PrismOnboarding {	2✔
87	let prismOnboarding = try PrismOnboardingInvitation(jsonString: str)	2✔
88	guard	2✔
89	let url = URL(string: prismOnboarding.body.onboardEndpoint)	2✔
90	else { throw CommonError.invalidURLError(url: prismOnboarding.body.onboardEndpoint) }	2✔
91		2✔
92	let ownDID = try await createNewPeerDID(	2✔
93	services: [.init(	2✔
94	id: "#didcomm-1",	2✔
95	type: ["DIDCommMessaging"],	2✔
96	serviceEndpoint: [.init(	2✔
97	uri: "https://localhost:8080/didcomm"	2✔
98	)]	2✔
99	)],	2✔
100	updateMediator: false	2✔
101	)	2✔
102		2✔
103	return .init(	2✔
104	from: prismOnboarding.body.from,	2✔
105	endpoint: url,	2✔
106	ownDID: ownDID	2✔
107	)	2✔
108	}	2✔
109
110	/// Accepts an Out-of-Band (DIDComm) invitation and establishes a new connection
111	/// - Parameter invitation: The Out-of-Band invitation to accept
112	/// - Throws: `EdgeAgentError` if there is no mediator available or other errors occur during the acceptance process
113	func acceptDIDCommInvitation(invitation: OutOfBandInvitation) async throws {	×
114	guard	×
115	let connectionManager	×
116	else { throw EdgeAgentError.noMediatorAvailableError }	×
117	logger.info(message: "Start accept DIDComm invitation")	×
118	let ownDID = try await createNewPeerDID(updateMediator: true)	×
119		×
120	logger.info(message: "Sending DIDComm Connection message")	×
121		×
122	let pair = try await DIDCommConnectionRunner(	×
123	invitationMessage: invitation,	×
124	pluto: pluto,	×
125	ownDID: ownDID,	×
126	connection: connectionManager	×
127	).run()	×
128	try await connectionManager.addConnection(pair)	×
129	}	×
130	}

hyperledger / identus-edge-agent-sdk-swift / 11035384347

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous