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