def setUp(self): self.connection_invitation = ConnectionInvitation( label=self.label, recipient_keys=[self.key], endpoint=self.endpoint_url ) self.invitation = ForwardInvitation( invitation=self.connection_invitation, message=self.test_message )
async def test_handle_auto_accept(self): handler = test_module.InvitationRequestHandler() self.context.update_settings({"accept_requests": True}) conn_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, ) mock_conn_rec = async_mock.MagicMock(connection_id="dummy") responder = MockResponder() with async_mock.patch.object(test_module, "ConnectionManager", autospec=True) as mock_mgr: mock_mgr.return_value.create_invitation = async_mock.CoroutineMock( return_value=(mock_conn_rec, conn_invitation)) await handler.handle(self.context, responder) assert mock_mgr.return_value.create_invitation.called_once_with() messages = responder.messages assert len(messages) == 1 (result, _) = messages[0] assert type(result) == Invitation assert result._thread._thid == self.context.message._message_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 handle(self, context: RequestContext, responder: BaseResponder): """Handle recieve invitation request.""" connection_mgr = ConnectionManager(context) invitation = ConnectionInvitation.from_url(context.message.invitation) connection = await connection_mgr.receive_invitation( invitation, auto_accept=context.message.auto_accept) connection_resp = Connection(**conn_record_to_message_repr(connection)) await responder.send_reply(connection_resp)
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_make_model(self): invitation = ForwardInvitation( invitation=ConnectionInvitation( label=self.label, recipient_keys=[self.key], endpoint=self.endpoint_url ), message=self.test_message, ) data = invitation.serialize() model_instance = ForwardInvitation.deserialize(data) assert type(model_instance) is type(invitation)
async def setUp(self): self.context = RequestContext(base_context=InjectionContext( enforce_typing=False)) self.context.connection_ready = True self.context.message = ForwardInvitation( 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", ) self.context.update_settings({"accept_invites": False})
async def setUp(self): self.storage = BasicStorage() self.context = RequestContext(base_context=InjectionContext( enforce_typing=False)) self.context.injector.bind_instance(BaseStorage, self.storage) self.context.connection_ready = True self.context.message = 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", ) self.context.connection_record = async_mock.MagicMock( connection_id="dummy")
async def receive_invitation( self, invitation: InvitationMessage) -> ConnectionRecord: """Receive an out of band invitation message.""" ledger: BaseLedger = await self.context.inject(BaseLedger) # New message format invitation_message = InvitationMessage.deserialize(invitation) # Convert to old format and pass to relevant manager # The following logic adheres to Aries RFC 0496 # There must be exactly 1 service entry if (len(invitation_message.service_blocks) + len(invitation_message.service_dids) != 1): raise OutOfBandManagerError( "service array must have exactly one element") # Get the single service item if invitation_message.service_blocks: service = invitation_message.service_blocks[0] else: # If it's in the did format, we need to convert to a full service block service_did = invitation_message.service_dids[0] async with ledger: verkey = await ledger.get_key_for_did(service_did) endpoint = await ledger.get_endpoint_for_did(service_did) service = ServiceMessage.deserialize({ "id": "#inline", "type": "did-communication", "recipientKeys": [verkey], "routingKeys": [], "serviceEndpoint": endpoint, }) # If we are dealing with an invitation if (len(invitation_message.handshake_protocols) == 1 and invitation_message.handshake_protocols[0] == "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/connections/1.0/invitation" ): if len(invitation_message.request_attach) != 0: raise OutOfBandManagerError( "request block must be empty for invitation message type.") # Convert to the old message format connection_invitation = ConnectionInvitation.deserialize({ "@id": invitation_message._id, "@type": invitation_message.handshake_protocols[0], "label": invitation_message.label, "recipientKeys": service.recipient_keys, "serviceEndpoint": service.service_endpoint, "routingKeys": service.routing_keys, }) connection_mgr = ConnectionManager(self.context) connection = await connection_mgr.receive_invitation( connection_invitation, auto_accept=True) elif (len(invitation_message.request_attach) == 1 and invitation_message.request_attach[0].data.json["@type"] == "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec" + "/present-proof/1.0/request-presentation"): raise OutOfBandManagerNotImplementedError( "did:sov:BzCbsNYhMrjHiqZDTUASHg;spec" + "/present-proof/1.0/request-presentation " + "request type not implemented.") else: raise OutOfBandManagerError("Invalid request type") return connection