async def test_service_start_introduction_target_conn_rec_not_active(self): service = await demo_service.DemoIntroductionService.service_handler()( self.context) conn_rec_init = ConnectionRecord( connection_id=None, state=ConnectionRecord.STATE_ACTIVE, ) await conn_rec_init.save(self.context) assert conn_rec_init._id conn_rec_target = ConnectionRecord( connection_id=None, state=ConnectionRecord.STATE_INACTIVE, ) await conn_rec_target.save(self.context) assert conn_rec_target._id with self.assertRaises(base_service.IntroductionError): await service.start_introduction( init_connection_id=conn_rec_init._id, target_connection_id=conn_rec_target._id, message="Hello", outbound_handler=None, )
async def test_service_start_and_return_introduction(self): service = await demo_service.DemoIntroductionService.service_handler()( self.context ) start_responder = MockResponder() conn_rec_init = ConnectionRecord( connection_id=None, state=ConnectionRecord.STATE_ACTIVE, ) await conn_rec_init.save(self.context) assert conn_rec_init._id conn_rec_target = ConnectionRecord( connection_id=None, state=ConnectionRecord.STATE_ACTIVE, ) await conn_rec_target.save(self.context) assert conn_rec_target._id await service.start_introduction( init_connection_id=conn_rec_init._id, target_connection_id=conn_rec_target._id, message="Hello Start", outbound_handler=start_responder.send, ) messages = start_responder.messages assert len(messages) == 1 (result, target) = messages[0] assert isinstance(result, demo_service.InvitationRequest) assert result.message == "Hello Start" assert target["connection_id"] == conn_rec_target._id invite = demo_service.Invitation( invitation=ConnectionInvitation( label=TEST_LABEL, did=TEST_DID, recipient_keys=[TEST_VERKEY], endpoint=TEST_ENDPOINT, routing_keys=[TEST_ROUTE_VERKEY], image_url=TEST_IMAGE_URL, ), message="Hello Invite", _id=result._id, ) return_responder = MockResponder() await service.return_invitation( target_connection_id=conn_rec_target._id, invitation=invite, outbound_handler=return_responder.send, ) messages = return_responder.messages assert len(messages) == 1 (result, target) = messages[0] assert isinstance(result, demo_service.ForwardInvitation) assert result.message == "Hello Invite" assert target["connection_id"] == conn_rec_init._id
async def test_service_return_invitation_not_found(self): invite = demo_service.Invitation( invitation=ConnectionInvitation( label=TEST_LABEL, did=TEST_DID, recipient_keys=[TEST_VERKEY], endpoint=TEST_ENDPOINT, routing_keys=[TEST_ROUTE_VERKEY], image_url=TEST_IMAGE_URL, ), message="Hello World", ) service = await demo_service.DemoIntroductionService.service_handler()( self.context) conn_rec_target = ConnectionRecord( connection_id=None, state=ConnectionRecord.STATE_ACTIVE, ) await conn_rec_target.save(self.context) assert conn_rec_target._id await service.return_invitation( target_connection_id=conn_rec_target._id, invitation=invite, outbound_handler=None, )
async def test_request_credential(self): mock = async_mock.MagicMock() record = ConnectionRecord(state=ConnectionRecord.STATE_ACTIVE) context = RequestContext(base_context=InjectionContext( enforce_typing=False)) storage = BasicStorage() context.injector.bind_instance(BaseStorage, storage) connection_id = await record.save(context) mock.json = async_mock.CoroutineMock( return_value={ "connection_id": connection_id, "credential_type": "TYPE_EXAMPLE", "credential_values": { "test1": "1" }, }) mock.app = { "request_context": context, "outbound_message_router": async_mock.CoroutineMock(), } with async_mock.patch.object( test_module, "CredentialExchangeRecord", autospec=True) as mock_conn_rec, async_mock.patch.object( test_module.web, "json_response") as mock_response: await test_module.request_credential(mock) mock_response.assert_called_once()
def setUp(self): self.storage = BasicStorage() self.cache = BasicCache() self.wallet = BasicWallet() self.responder = MockResponder() self.responder.send = async_mock.CoroutineMock() self.context = InjectionContext(enforce_typing=False) self.context.injector.bind_instance(BaseStorage, self.storage) self.context.injector.bind_instance(BaseWallet, self.wallet) self.context.injector.bind_instance(BaseResponder, self.responder) self.context.injector.bind_instance(BaseCache, self.cache) self.context.injector.bind_instance(BaseLedger, async_mock.MagicMock()) self.context.update_settings({ "default_endpoint": "http://aries.ca/endpoint", "default_label": "This guy", "additional_endpoints": ["http://aries.ca/another-endpoint"], "debug.auto_accept_invites": True, "debug.auto_accept_requests": True, }) self.manager = OutOfBandManager(self.context) self.test_conn_rec = ConnectionRecord( my_did=self.test_did, their_did=self.test_target_did, their_role=None, state=ConnectionRecord.STATE_ACTIVE, )
async def setUp(self): self.context = RequestContext( base_context=InjectionContext(enforce_typing=False) ) self.context.connection_ready = True self.context.connection_record = ConnectionRecord(connection_id="conn-id") self.context.message_receipt = MessageReceipt(sender_verkey=TEST_VERKEY) self.context.injector.bind_instance(BaseStorage, BasicStorage())
def context(): """Fixture for context used in tests.""" # pylint: disable=W0621 context = RequestContext() context.message = ProvideData(goal_code="test_goal", data=[TEST_DATA]) context.connection_record = ConnectionRecord(connection_id=TEST_CONN_ID) context.connection_ready = True yield context
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle static connection creation request.""" connection_mgr = ConnectionManager(context) wallet: BaseWallet = await context.inject(BaseWallet) # Make our info for the connection my_info = await wallet.create_local_did() # Create connection record connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_SELF, my_did=my_info.did, their_did=context.message.static_did, their_label=context.message.label, their_role=context.message.role if context.message.role else None, state=ConnectionRecord.STATE_ACTIVE, invitation_mode=ConnectionRecord.INVITATION_MODE_STATIC ) # Construct their did doc from the basic components in message diddoc = DIDDoc(context.message.static_did) public_key = PublicKey( did=context.message.static_did, ident="1", value=context.message.static_key, pk_type=PublicKeyType.ED25519_SIG_2018, controller=context.message.static_did ) service = Service( did=context.message.static_did, ident="indy", typ="IndyAgent", recip_keys=[public_key], routing_keys=[], endpoint=context.message.static_endpoint ) diddoc.set(public_key) diddoc.set(service) # Save await connection_mgr.store_did_document(diddoc) await connection.save( context, reason='Created new static connection' ) # Prepare response info = StaticConnectionInfo( did=my_info.did, key=my_info.verkey, endpoint=context.settings.get("default_endpoint") ) info.assign_thread_from(context.message) await responder.send_reply(info) return
async def test_handle(self): handler = test_module.ForwardInvitationHandler() responder = MockResponder() with async_mock.patch.object(test_module, "ConnectionManager", autospec=True) as mock_mgr: mock_mgr.return_value.receive_invitation = async_mock.CoroutineMock( return_value=ConnectionRecord(connection_id="dummy")) await handler.handle(self.context, responder) assert not (responder.messages)
async def test_create_credential_null(self): connection = ConnectionRecord(my_did="1234-my", their_did="1234-their") with self.assertRaises(IssuerError): credential, _ = await self.issuer.create_credential( schema={"credential_type": "TestType"}, credential_values={}, credential_offer={}, credential_request={"connection_record": connection}, ) with self.assertRaises(IssuerError): credential, _ = await self.issuer.create_credential( schema={}, credential_values={}, credential_offer={}, credential_request={"connection_record": connection}, )
async def create_invitation( self, my_label: str = None, my_endpoint: str = None, their_role: str = None, auto_accept: bool = None, public: bool = False, multi_use: bool = False, alias: str = None, ) -> Tuple[ConnectionRecord, ConnectionInvitation]: """ Generate new connection invitation. This interaction represents an out-of-band communication channel. In the future and in practice, these sort of invitations will be received over any number of channels such as SMS, Email, QR Code, NFC, etc. Structure of an invite message: :: { "@type": "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0/invitation", "label": "Alice", "did": "did:sov:QmWbsNYhMrjHiqZDTUTEJs" } Or, in the case of a peer DID: :: { "@type": "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0/invitation", "label": "Alice", "did": "did:peer:oiSqsNYhMrjHiqZDTUthsw", "recipientKeys": ["8HH5gYEeNc3z7PYXmd54d4x6qAfCNrqQqEB3nS7Zfu7K"], "serviceEndpoint": "https://example.com/endpoint" } Currently, only peer DID is supported. Args: my_label: label for this connection my_endpoint: endpoint where other party can reach me their_role: a role to assign the connection auto_accept: auto-accept a corresponding connection request (None to use config) public: set to create an invitation from the public DID multi_use: set to True to create an invitation for multiple use alias: optional alias to apply to connection for later use Returns: A tuple of the new `ConnectionRecord` and `ConnectionInvitation` instances """ if not my_label: my_label = self.context.settings.get("default_label") wallet: BaseWallet = await self.context.inject(BaseWallet) if public: if not self.context.settings.get("public_invites"): raise ConnectionManagerError( "Public invitations are not enabled") public_did = await wallet.get_public_did() if not public_did: raise ConnectionManagerError( "Cannot create public invitation with no public DID") if multi_use: raise ConnectionManagerError( "Cannot use public and multi_use at the same time") # FIXME - allow ledger instance to format public DID with prefix? invitation = ConnectionInvitation(label=my_label, did=f"did:sov:{public_did.did}") return None, invitation invitation_mode = ConnectionRecord.INVITATION_MODE_ONCE if multi_use: invitation_mode = ConnectionRecord.INVITATION_MODE_MULTI if not my_endpoint: my_endpoint = self.context.settings.get("default_endpoint") accept = (ConnectionRecord.ACCEPT_AUTO if (auto_accept or (auto_accept is None and self.context.settings.get("debug.auto_accept_requests"))) else ConnectionRecord.ACCEPT_MANUAL) # Create and store new invitation key connection_key = await wallet.create_signing_key() # Create connection record connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_SELF, invitation_key=connection_key.verkey, their_role=their_role, state=ConnectionRecord.STATE_INVITATION, accept=accept, invitation_mode=invitation_mode, alias=alias, ) await connection.save(self.context, reason="Created new invitation") # Create connection invitation message # Note: Need to split this into two stages to support inbound routing of invites # Would want to reuse create_did_document and convert the result invitation = ConnectionInvitation( label=my_label, recipient_keys=[connection_key.verkey], endpoint=my_endpoint) await connection.attach_invitation(self.context, invitation) return connection, invitation
async def create_static_connection( self, my_did: str = None, my_seed: str = None, their_did: str = None, their_seed: str = None, their_verkey: str = None, their_endpoint: str = None, their_role: str = None, their_label: str = None, alias: str = None, ) -> (DIDInfo, DIDInfo, ConnectionRecord): """ Register a new static connection (for use by the test suite). Args: my_did: override the DID used in the connection my_seed: provide a seed used to generate our DID and keys their_did: provide the DID used by the other party their_seed: provide a seed used to generate their DID and keys their_verkey: provide the verkey used by the other party their_endpoint: their URL endpoint for routing messages their_role: their role in this connection alias: an alias for this connection record Returns: The new `ConnectionRecord` instance """ wallet: BaseWallet = await self.context.inject(BaseWallet) # seed and DID optional my_info = await wallet.create_local_did(my_seed, my_did) # must provide their DID and verkey if the seed is not known if (not their_did or not their_verkey) and not their_seed: raise ConnectionManagerError( "Either a verkey or seed must be provided for the other party") if not their_did: their_did = seed_to_did(their_seed) if not their_verkey: their_verkey_bin, _ = create_keypair(their_seed.encode()) their_verkey = bytes_to_b58(their_verkey_bin) their_info = DIDInfo(their_did, their_verkey, {}) # Create connection record connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_SELF, invitation_mode=ConnectionRecord.INVITATION_MODE_STATIC, my_did=my_info.did, their_did=their_info.did, their_role=their_role, their_label=their_label, state=ConnectionRecord.STATE_ACTIVE, alias=alias, ) await connection.save(self.context, reason="Created new static connection") # Synthesize their DID doc did_doc = await self.create_did_document(their_info, None, [their_endpoint]) await self.store_did_document(did_doc) return my_info, their_info, connection
async def receive_request(self, request: ConnectionRequest, receipt: MessageReceipt) -> ConnectionRecord: """ Receive and store a connection request. Args: request: The `ConnectionRequest` to accept receipt: The message receipt Returns: The new or updated `ConnectionRecord` instance """ ConnectionRecord.log_state(self.context, "Receiving connection request", {"request": request}) connection = None connection_key = None # Determine what key will need to sign the response if receipt.recipient_did_public: wallet: BaseWallet = await self.context.inject(BaseWallet) my_info = await wallet.get_local_did(receipt.recipient_did) connection_key = my_info.verkey else: connection_key = receipt.recipient_verkey try: connection = await ConnectionRecord.retrieve_by_invitation_key( self.context, connection_key, ConnectionRecord.INITIATOR_SELF) except StorageNotFoundError: raise ConnectionManagerError( "No invitation found for pairwise connection") invitation = None if connection: invitation = await connection.retrieve_invitation(self.context) connection_key = connection.invitation_key ConnectionRecord.log_state(self.context, "Found invitation", {"invitation": invitation}) if connection.is_multiuse_invitation: wallet: BaseWallet = await self.context.inject(BaseWallet) my_info = await wallet.create_local_did() new_connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_MULTIUSE, invitation_key=connection_key, my_did=my_info.did, state=ConnectionRecord.STATE_INVITATION, accept=connection.accept, their_role=connection.their_role, ) await new_connection.save( self.context, reason= "Received connection request from multi-use invitation DID", ) connection = new_connection conn_did_doc = request.connection.did_doc if not conn_did_doc: raise ConnectionManagerError( "No DIDDoc provided; cannot connect to public DID") if request.connection.did != conn_did_doc.did: raise ConnectionManagerError( "Connection DID does not match DIDDoc id", error_code=ProblemReportReason.REQUEST_NOT_ACCEPTED, ) await self.store_did_document(conn_did_doc) if connection: connection.their_label = request.label connection.their_did = request.connection.did connection.state = ConnectionRecord.STATE_REQUEST await connection.save( self.context, reason="Received connection request from invitation") elif not self.context.settings.get("public_invites"): raise ConnectionManagerError("Public invitations are not enabled") else: my_info = await wallet.create_local_did() connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_EXTERNAL, invitation_key=connection_key, my_did=my_info.did, their_did=request.connection.did, their_label=request.label, state=ConnectionRecord.STATE_REQUEST, ) if self.context.settings.get("debug.auto_accept_requests"): connection.accept = ConnectionRecord.ACCEPT_AUTO await connection.save( self.context, reason="Received connection request from public DID") # Attach the connection request so it can be found and responded to await connection.attach_request(self.context, request) if connection.accept == ConnectionRecord.ACCEPT_AUTO: response = await self.create_response(connection) responder: BaseResponder = await self._context.inject( BaseResponder, required=False) if responder: await responder.send_reply( response, connection_id=connection.connection_id) # refetch connection for accurate state connection = await ConnectionRecord.retrieve_by_id( self._context, connection.connection_id) else: self._logger.debug("Connection request will await acceptance") return connection
async def receive_invitation( self, invitation: ConnectionInvitation, their_role: str = None, auto_accept: bool = None, alias: str = None, ) -> ConnectionRecord: """ Create a new connection record to track a received invitation. Args: invitation: The `ConnectionInvitation` to store their_role: The role assigned to this connection auto_accept: set to auto-accept the invitation (None to use config) alias: optional alias to set on the record Returns: The new `ConnectionRecord` instance """ if not invitation.did: if not invitation.recipient_keys: raise ConnectionManagerError( "Invitation must contain recipient key(s)") if not invitation.endpoint: raise ConnectionManagerError( "Invitation must contain an endpoint") accept = (ConnectionRecord.ACCEPT_AUTO if (auto_accept or (auto_accept is None and self.context.settings.get("debug.auto_accept_invites"))) else ConnectionRecord.ACCEPT_MANUAL) # Create connection record connection = ConnectionRecord( initiator=ConnectionRecord.INITIATOR_EXTERNAL, invitation_key=invitation.recipient_keys and invitation.recipient_keys[0], their_label=invitation.label, their_role=their_role, state=ConnectionRecord.STATE_INVITATION, accept=accept, alias=alias, ) await connection.save( self.context, reason="Created new connection record from invitation", log_params={ "invitation": invitation, "role": their_role }, ) # Save the invitation for later processing await connection.attach_invitation(self.context, invitation) if connection.accept == ConnectionRecord.ACCEPT_AUTO: request = await self.create_request(connection) responder: BaseResponder = await self._context.inject( BaseResponder, required=False) if responder: await responder.send(request, connection_id=connection.connection_id) # refetch connection for accurate state connection = await ConnectionRecord.retrieve_by_id( self._context, connection.connection_id) else: self._logger.debug("Connection invitation will await acceptance") return connection