async def test_import_routes_multitenant_middleware(self):
# imports all default admin routes
context = InjectionContext()
context.injector.bind_instance(ProtocolRegistry, ProtocolRegistry())
profile = InMemoryProfile.test_profile()
context.injector.bind_instance(
test_module.MultitenantManager,
test_module.MultitenantManager(profile),
)
await DefaultContextBuilder().load_plugins(context)
server = self.get_admin_server(
{
"admin.admin_insecure_mode": False,
"admin.admin_api_key": "test-api-key",
},
context,
)
# cover multitenancy start code
app = await server.make_application()
app["swagger_dict"] = {}
await server.on_startup(app)
# multitenant authz
[mt_authz_middle] = [
m for m in app.middlewares
if ".check_multitenant_authorization" in str(m)
]
mock_request = async_mock.MagicMock(
method="GET",
headers={"Authorization": "Bearer ..."},
path="/multitenancy/etc",
text=async_mock.CoroutineMock(return_value="abc123"),
)
with self.assertRaises(test_module.web.HTTPUnauthorized):
await mt_authz_middle(mock_request, None)
mock_request = async_mock.MagicMock(
method="GET",
headers={},
path="/protected/non-multitenancy/non-server",
text=async_mock.CoroutineMock(return_value="abc123"),
)
with self.assertRaises(test_module.web.HTTPUnauthorized):
await mt_authz_middle(mock_request, None)
mock_request = async_mock.MagicMock(
method="GET",
headers={"Authorization": "Bearer ..."},
path="/protected/non-multitenancy/non-server",
text=async_mock.CoroutineMock(return_value="abc123"),
)
mock_handler = async_mock.CoroutineMock()
await mt_authz_middle(mock_request, mock_handler)
assert mock_handler.called_once_with(mock_request)
# multitenant setup context exception paths
[setup_ctx_middle
] = [m for m in app.middlewares if ".setup_context" in str(m)]
mock_request = async_mock.MagicMock(
method="GET",
headers={"Authorization": "Non-bearer ..."},
path="/protected/non-multitenancy/non-server",
text=async_mock.CoroutineMock(return_value="abc123"),
)
with self.assertRaises(test_module.web.HTTPUnauthorized):
await setup_ctx_middle(mock_request, None)
mock_request = async_mock.MagicMock(
method="GET",
headers={"Authorization": "Bearer ..."},
path="/protected/non-multitenancy/non-server",
text=async_mock.CoroutineMock(return_value="abc123"),
)
with async_mock.patch.object(
server.multitenant_manager,
"get_profile_for_token",
async_mock.CoroutineMock(),
) as mock_get_profile:
mock_get_profile.side_effect = [
test_module.MultitenantManagerError("corrupt token"),
test_module.StorageNotFoundError("out of memory"),
]
for i in range(2):
with self.assertRaises(test_module.web.HTTPUnauthorized):
await setup_ctx_middle(mock_request, None)
async def test_called_auto_present(self):
request_context = RequestContext.test_context()
request_context.connection_record = async_mock.MagicMock()
request_context.connection_record.connection_id = "dummy"
request_context.message = PresentationRequest()
request_context.message.indy_proof_request = async_mock.MagicMock(
return_value={
"name": "proof-request",
"version": "1.0",
"nonce": "1234567890",
"requested_attributes": {
"0_favourite_uuid": {
"name": "favourite",
"restrictions": [
{
"cred_def_id": CD_ID,
}
],
},
"1_icon_uuid": {
"name": "icon",
"restrictions": [
{
"cred_def_id": CD_ID,
}
],
},
},
"requested_predicates": {},
}
)
request_context.message_receipt = MessageReceipt()
presentation_proposal = PresentationProposal(
comment="Hello World", presentation_proposal=PRES_PREVIEW
)
px_rec_instance = test_module.V10PresentationExchange(
presentation_proposal_dict=presentation_proposal,
auto_present=True,
)
with async_mock.patch.object(
test_module, "PresentationManager", autospec=True
) as mock_pres_mgr, async_mock.patch.object(
test_module, "V10PresentationExchange", autospec=True
) as mock_pres_ex_cls, async_mock.patch.object(
test_module, "IndyHolder", autospec=True
) as mock_holder:
mock_holder.get_credentials_for_presentation_request_by_referent = (
async_mock.CoroutineMock(
return_value=[{"cred_info": {"referent": "dummy"}}]
)
)
request_context.inject = async_mock.MagicMock(return_value=mock_holder)
mock_pres_ex_cls.return_value = px_rec_instance
mock_pres_ex_cls.retrieve_by_tag_filter = async_mock.CoroutineMock(
return_value=px_rec_instance
)
mock_pres_mgr.return_value.receive_request = async_mock.CoroutineMock(
return_value=px_rec_instance
)
mock_pres_mgr.return_value.create_presentation = async_mock.CoroutineMock(
return_value=(px_rec_instance, "presentation_message")
)
request_context.connection_ready = True
handler = test_module.PresentationRequestHandler()
responder = MockResponder()
await handler.handle(request_context, responder)
mock_pres_mgr.return_value.create_presentation.assert_called_once()
mock_pres_mgr.return_value.receive_request.assert_called_once_with(
px_rec_instance
)
messages = responder.messages
assert len(messages) == 1
(result, target) = messages[0]
assert result == "presentation_message"
assert target == {}
async def test_called_auto_present_bait_and_switch(self):
request_context = RequestContext.test_context()
request_context.connection_record = async_mock.MagicMock()
request_context.connection_record.connection_id = "dummy"
request_context.message = PresentationRequest()
request_context.message.indy_proof_request = async_mock.MagicMock(
return_value={
"name": "proof-request",
"version": "1.0",
"nonce": "1234567890",
"requested_attributes": {
"0_favourite_uuid": {
"name": "favourite",
"restrictions": [
{
"cred_def_id": CD_ID,
}
],
}
},
"requested_predicates": {},
}
)
request_context.message_receipt = MessageReceipt()
px_rec_instance = test_module.V10PresentationExchange(
presentation_proposal_dict={
"presentation_proposal": {
"@type": DIDCommPrefix.qualify_current(
"present-proof/1.0/presentation-preview"
),
"attributes": [
{"name": "favourite", "cred_def_id": CD_ID, "value": "potato"}
],
"predicates": [],
}
},
auto_present=True,
)
with async_mock.patch.object(
test_module, "PresentationManager", autospec=True
) as mock_pres_mgr, async_mock.patch.object(
test_module, "V10PresentationExchange", autospec=True
) as mock_pres_ex_cls, async_mock.patch.object(
test_module, "IndyHolder", autospec=True
) as mock_holder:
by_reft = async_mock.CoroutineMock(
return_value=[
{
"cred_info": {
"referent": "dummy-0",
"cred_def_id": CD_ID,
"attrs": {"ident": "zero", "favourite": "yam"},
}
},
{
"cred_info": {
"referent": "dummy-1",
"cred_def_id": CD_ID,
"attrs": {"ident": "one", "favourite": "turnip"},
}
},
{
"cred_info": {
"referent": "dummy-2",
"cred_def_id": CD_ID,
"attrs": {
"ident": "two",
"favourite": "the idea of a potato but not a potato",
},
}
},
]
)
mock_holder.get_credentials_for_presentation_request_by_referent = by_reft
request_context.inject = async_mock.MagicMock(return_value=mock_holder)
mock_pres_ex_cls.return_value = px_rec_instance
mock_pres_ex_cls.retrieve_by_tag_filter = async_mock.CoroutineMock(
return_value=px_rec_instance
)
mock_pres_mgr.return_value.receive_request = async_mock.CoroutineMock(
return_value=px_rec_instance
)
mock_pres_mgr.return_value.create_presentation = async_mock.CoroutineMock(
return_value=(px_rec_instance, "presentation_message")
)
request_context.connection_ready = True
handler = test_module.PresentationRequestHandler()
responder = MockResponder()
await handler.handle(request_context, responder)
mock_pres_mgr.return_value.create_presentation.assert_not_called()
mock_pres_mgr.return_value.receive_request.assert_called_once_with(
px_rec_instance
)
assert not responder.messages
async def test_respond_on_interactive_actions(self):
"""Test the respond method for interactive actions in Slack."""
result = amock.Mock()
result.json = amock.CoroutineMock()
result.json.return_value = {"success": "payload sent."}
payload = {
"type":
"message_action",
"team": {
"id": "TXXXXXX",
"domain": "coverbands"
},
"user": {
"id": "UXXXXXX",
"name": "dreamweaver"
},
"response_url":
"https://hooks.slack.com/app-actions/T0MJR11A4/21974584944/yk1S9ndf35Q1flupVG5JbpM6",
}
interactive_action = InteractiveAction(payload)
with amock.patch("aiohttp.ClientSession.post") as patched_request:
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(result)
await interactive_action.respond("Respond called with response_url"
)
self.assertTrue(patched_request.called)
payload = {
"type": "view_closed",
"team": {
"id": "TXXXXXX",
"domain": "coverbands"
},
"user": {
"id": "UXXXXXX",
"name": "dreamweaver"
},
}
interactive_action = InteractiveAction(payload)
with amock.patch("aiohttp.ClientSession.post") as patched_request:
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(result)
await interactive_action.respond(
"Respond called without response_url")
self.assertFalse(patched_request.called)
with OpsDroid() as opsdroid:
connector = ConnectorSlack({"token": "abc123"},
opsdroid=OpsDroid())
raw_message = {
"text": "Hello world",
"user_id": "user_id",
"user": "******",
"room": "default",
}
message = Message(
text="Hello world",
user_id="user_id",
user="******",
target="default",
connector=connector,
raw_event=raw_message,
)
opsdroid.send = amock.CoroutineMock()
with amock.patch("aiohttp.ClientSession.post") as patched_request:
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(result)
await interactive_action.respond(message)
self.assertTrue(opsdroid.send.called)
self.assertFalse(patched_request.called)
async def test_listen(self):
self.connector.side_effect = Exception()
await self.connector.listen(amock.CoroutineMock())
async def test_record(self):
with async_mock.patch.object(
test_wallet, "load_postgres_plugin",
async_mock.MagicMock()) as mock_load, async_mock.patch.object(
indy.wallet, "create_wallet", async_mock.CoroutineMock(
)) as mock_create, async_mock.patch.object(
indy.wallet, "open_wallet", async_mock.CoroutineMock()
) as mock_open, async_mock.patch.object(
indy.anoncreds, "prover_create_master_secret",
async_mock.CoroutineMock()
) as mock_master, async_mock.patch.object(
indy.wallet, "close_wallet", async_mock.CoroutineMock(
)) as mock_close, async_mock.patch.object(
indy.wallet, "delete_wallet",
async_mock.CoroutineMock()) as mock_delete:
fake_wallet = IndyWallet({
"auto_create":
True,
"auto_remove":
True,
"name":
"test_pg_wallet",
"key":
await IndyWallet.generate_wallet_key(),
"key_derivation_method":
"RAW",
"storage_type":
"postgres_storage",
"storage_config":
json.dumps({"url": "dummy"}),
"storage_creds":
json.dumps({
"account": "postgres",
"password": "******",
"admin_account": "postgres",
"admin_password": "******",
}),
})
await fake_wallet.open()
storage = IndyStorage(fake_wallet)
for record_x in [
None,
StorageRecord(
type="connection",
value=json.dumps({
"initiator":
"self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state":
"invitation",
"routing_state":
"none",
"error_msg":
None,
"their_label":
None,
"created_at":
"2019-05-14 21:58:24.143260+00:00",
"updated_at":
"2019-05-14 21:58:24.143260+00:00",
}),
tags={
"initiator": "self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state": "invitation",
"routing_state": "none",
},
id=None,
),
StorageRecord(
type=None,
value=json.dumps({
"initiator":
"self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state":
"invitation",
"routing_state":
"none",
"error_msg":
None,
"their_label":
None,
"created_at":
"2019-05-14 21:58:24.143260+00:00",
"updated_at":
"2019-05-14 21:58:24.143260+00:00",
}),
tags={
"initiator": "self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state": "invitation",
"routing_state": "none",
},
id="f96f76ec-0e9b-4f32-8237-f4219e6cf0c7",
),
StorageRecord(
type="connection",
value=None,
tags={
"initiator": "self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state": "invitation",
"routing_state": "none",
},
id="f96f76ec-0e9b-4f32-8237-f4219e6cf0c7",
),
]:
with pytest.raises(StorageError):
await storage.add_record(record_x)
with pytest.raises(StorageError):
await storage.get_record(None, "dummy-id")
with pytest.raises(StorageError):
await storage.get_record("connection", None)
with async_mock.patch.object(
test_module.non_secrets, "get_wallet_record",
async_mock.CoroutineMock()) as mock_get_record:
mock_get_record.side_effect = test_module.IndyError(
test_module.ErrorCode.CommonInvalidStructure)
with pytest.raises(test_module.StorageError):
await storage.get_record("connection", "dummy-id")
with async_mock.patch.object(
test_module.non_secrets,
"update_wallet_record_value",
async_mock.CoroutineMock(),
) as mock_update_value, async_mock.patch.object(
test_module.non_secrets,
"update_wallet_record_tags",
async_mock.CoroutineMock(),
) as mock_update_tags, async_mock.patch.object(
test_module.non_secrets,
"delete_wallet_record",
async_mock.CoroutineMock(),
) as mock_delete:
mock_update_value.side_effect = test_module.IndyError(
test_module.ErrorCode.CommonInvalidStructure)
mock_update_tags.side_effect = test_module.IndyError(
test_module.ErrorCode.CommonInvalidStructure)
mock_delete.side_effect = test_module.IndyError(
test_module.ErrorCode.CommonInvalidStructure)
rec = StorageRecord(
type="connection",
value=json.dumps({
"initiator":
"self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state":
"invitation",
"routing_state":
"none",
"error_msg":
None,
"their_label":
None,
"created_at":
"2019-05-14 21:58:24.143260+00:00",
"updated_at":
"2019-05-14 21:58:24.143260+00:00",
}),
tags={
"initiator": "self",
"invitation_key":
"9XgL7Y4TBTJyVJdomT6axZGUFg9npxcrXnRT4CG8fWYg",
"state": "invitation",
"routing_state": "none",
},
id="f96f76ec-0e9b-4f32-8237-f4219e6cf0c7",
)
with pytest.raises(test_module.StorageError):
await storage.update_record_value(rec, "dummy-value")
with pytest.raises(test_module.StorageError):
await storage.update_record_tags(rec, {"tag": "tag"})
with pytest.raises(test_module.StorageError):
await storage.delete_record(rec)
async def test_replace_usernames(self):
connector = ConnectorSlack({"token": "abc123"}, opsdroid=OpsDroid())
connector.lookup_username = amock.CoroutineMock()
connector.lookup_username.return_value = {"name": "user"}
result = await connector.replace_usernames("Hello <@U023BECGF>!")
self.assertEqual(result, "Hello user!")
async def setUp(self):
self.context = RequestContext(base_context=InjectionContext(
enforce_typing=False))
Ledger = async_mock.MagicMock(BaseLedger, autospec=True)
self.ledger = Ledger()
self.ledger.get_schema = async_mock.CoroutineMock(
return_value=async_mock.MagicMock())
self.ledger.get_credential_definition = async_mock.CoroutineMock(
return_value={"value": {
"revocation": {
"...": "..."
}
}})
self.ledger.get_revoc_reg_def = async_mock.CoroutineMock(
return_value={
"ver": "1.0",
"id": RR_ID,
"revocDefType": "CL_ACCUM",
"tag": RR_ID.split(":")[-1],
"credDefId": CD_ID,
"value": {
"IssuanceType": "ISSUANCE_BY_DEFAULT",
"maxCredNum": 1000,
"publicKeys": {
"accumKey": {
"z": "1 ..."
}
},
"tailsHash":
"3MLjUFQz9x9n5u9rFu8Ba9C5bo4HNFjkPNc54jZPSNaZ",
"tailsLocation": "http://sample.ca/path",
},
})
self.ledger.get_revoc_reg_delta = async_mock.CoroutineMock(
return_value=(
{
"ver": "1.0",
"value": {
"prevAccum": "1 ...",
"accum": "21 ...",
"issued": [1]
},
},
NOW,
))
self.ledger.get_revoc_reg_entry = async_mock.CoroutineMock(
return_value=(
{
"ver": "1.0",
"value": {
"prevAccum": "1 ...",
"accum": "21 ...",
"issued": [1]
},
},
NOW,
))
self.context.injector.bind_instance(BaseLedger, self.ledger)
Holder = async_mock.MagicMock(IndyHolder, autospec=True)
self.holder = Holder()
get_creds = async_mock.CoroutineMock(return_value=(
{
"cred_info": {
"referent": "dummy_reft",
"attrs": {
"player": "Richie Knucklez",
"screenCapture": "aW1hZ2luZSBhIHNjcmVlbiBjYXB0dXJl",
"highScore": "1234560",
},
}
}, # leave this comma: return a tuple
))
self.holder.get_credentials_for_presentation_request_by_referent = get_creds
self.holder.get_credential = async_mock.CoroutineMock(
return_value=json.dumps({
"schema_id": S_ID,
"cred_def_id": CD_ID,
"rev_reg_id": RR_ID,
"cred_rev_id": 1,
}))
self.holder.create_presentation = async_mock.CoroutineMock(
return_value="{}")
self.holder.create_revocation_state = async_mock.CoroutineMock(
return_value=json.dumps({
"witness": {
"omega": "1 ..."
},
"rev_reg": {
"accum": "21 ..."
},
"timestamp": NOW,
}))
self.context.injector.bind_instance(IndyHolder, self.holder)
Verifier = async_mock.MagicMock(IndyVerifier, autospec=True)
self.verifier = Verifier()
self.verifier.verify_presentation = async_mock.CoroutineMock(
return_value="true")
self.context.injector.bind_instance(IndyVerifier, self.verifier)
self.manager = PresentationManager(self.context)
async def test_fetch_genesis_transactions(self):
with async_mock.patch.object(test_module, "fetch",
async_mock.CoroutineMock()) as mock_fetch:
await test_module.fetch_genesis_transactions(
"http://1.2.3.4:9000/genesis")
async def test_create_presentation_bad_revoc_state(self):
self.context.connection_record = async_mock.MagicMock()
self.context.connection_record.connection_id = CONN_ID
exchange_in = V10PresentationExchange()
indy_proof_req = await PRES_PREVIEW.indy_proof_request(
name=PROOF_REQ_NAME,
version=PROOF_REQ_VERSION,
nonce=PROOF_REQ_NONCE,
ledger=await self.context.inject(BaseLedger, required=False),
)
exchange_in.presentation_request = indy_proof_req
request = async_mock.MagicMock()
request.indy_proof_request = async_mock.MagicMock()
request._thread_id = "dummy"
self.context.message = request
Holder = async_mock.MagicMock(IndyHolder, autospec=True)
self.holder = Holder()
get_creds = async_mock.CoroutineMock(return_value=(
{
"cred_info": {
"referent": "dummy_reft"
},
"attrs": {
"player": "Richie Knucklez",
"screenCapture": "aW1hZ2luZSBhIHNjcmVlbiBjYXB0dXJl",
"highScore": "1234560",
},
}, # leave this comma: return a tuple
))
self.holder.get_credentials_for_presentation_request_by_referent = get_creds
self.holder.get_credential = async_mock.CoroutineMock(
return_value=json.dumps({
"schema_id": S_ID,
"cred_def_id": CD_ID,
"rev_reg_id": RR_ID,
"cred_rev_id": 1,
}))
self.holder.create_presentation = async_mock.CoroutineMock(
return_value="{}")
self.holder.create_revocation_state = async_mock.CoroutineMock(
side_effect=test_module.IndyHolderError("Problem",
{"message": "Nope"}))
self.context.injector.clear_binding(IndyHolder)
self.context.injector.bind_instance(IndyHolder, self.holder)
more_magic_rr = async_mock.MagicMock(
get_or_fetch_local_tails_path=async_mock.CoroutineMock(
return_value="/tmp/sample/tails/path"))
with async_mock.patch.object(
V10PresentationExchange, "save",
autospec=True) as save_ex, async_mock.patch.object(
test_module, "AttachDecorator", autospec=True
) as mock_attach_decorator, async_mock.patch.object(
test_module, "RevocationRegistry",
autospec=True) as mock_rr:
mock_rr.from_definition = async_mock.MagicMock(
return_value=more_magic_rr)
mock_attach_decorator.from_indy_dict = async_mock.MagicMock(
return_value=mock_attach_decorator)
req_creds = await indy_proof_req_preview2indy_requested_creds(
indy_proof_req, holder=self.holder)
with self.assertRaises(test_module.IndyHolderError):
await self.manager.create_presentation(exchange_in, req_creds)
async def test_create_presentation_multi_matching_proposal_creds_names(
self):
self.context.connection_record = async_mock.MagicMock()
self.context.connection_record.connection_id = CONN_ID
exchange_in = V10PresentationExchange()
indy_proof_req = await PRES_PREVIEW_NAMES.indy_proof_request(
name=PROOF_REQ_NAME,
version=PROOF_REQ_VERSION,
nonce=PROOF_REQ_NONCE,
ledger=await self.context.inject(BaseLedger, required=False),
)
exchange_in.presentation_request = indy_proof_req
request = async_mock.MagicMock()
request.indy_proof_request = async_mock.MagicMock()
request._thread_id = "dummy"
self.context.message = request
Holder = async_mock.MagicMock(IndyHolder, autospec=True)
self.holder = Holder()
get_creds = async_mock.CoroutineMock(return_value=(
{
"cred_info": {
"referent": "dummy_reft_0",
"cred_def_id": CD_ID,
"attrs": {
"player": "Richie Knucklez",
"screenCapture": "aW1hZ2luZSBhIHNjcmVlbiBjYXB0dXJl",
"highScore": "1234560",
},
}
},
{
"cred_info": {
"referent": "dummy_reft_1",
"cred_def_id": CD_ID,
"attrs": {
"player": "Richie Knucklez",
"screenCapture":
"aW1hZ2luZSBhbm90aGVyIHNjcmVlbiBjYXB0dXJl",
"highScore": "1515880",
},
}
},
))
self.holder.get_credentials_for_presentation_request_by_referent = get_creds
self.holder.get_credential = async_mock.CoroutineMock(
return_value=json.dumps({
"schema_id": S_ID,
"cred_def_id": CD_ID,
"rev_reg_id": RR_ID,
"cred_rev_id": 1,
}))
self.holder.create_presentation = async_mock.CoroutineMock(
return_value="{}")
self.holder.create_revocation_state = async_mock.CoroutineMock(
return_value=json.dumps({
"witness": {
"omega": "1 ..."
},
"rev_reg": {
"accum": "21 ..."
},
"timestamp": NOW,
}))
self.context.injector.clear_binding(IndyHolder)
self.context.injector.bind_instance(IndyHolder, self.holder)
more_magic_rr = async_mock.MagicMock(
get_or_fetch_local_tails_path=async_mock.CoroutineMock(
return_value="/tmp/sample/tails/path"))
with async_mock.patch.object(
V10PresentationExchange, "save",
autospec=True) as save_ex, async_mock.patch.object(
test_module, "AttachDecorator", autospec=True
) as mock_attach_decorator, async_mock.patch.object(
test_module, "RevocationRegistry",
autospec=True) as mock_rr:
mock_rr.from_definition = async_mock.MagicMock(
return_value=more_magic_rr)
mock_attach_decorator.from_indy_dict = async_mock.MagicMock(
return_value=mock_attach_decorator)
req_creds = await indy_proof_req_preview2indy_requested_creds(
indy_proof_req, preview=PRES_PREVIEW_NAMES, holder=self.holder)
assert not req_creds["self_attested_attributes"]
assert len(req_creds["requested_attributes"]) == 1
assert len(req_creds["requested_predicates"]) == 1
(exchange_out, pres_msg) = await self.manager.create_presentation(
exchange_in, req_creds)
save_ex.assert_called_once()
assert exchange_out.state == V10PresentationExchange.STATE_PRESENTATION_SENT
async def test_create_presentation_no_revocation(self):
self.context.connection_record = async_mock.MagicMock()
self.context.connection_record.connection_id = CONN_ID
Ledger = async_mock.MagicMock(BaseLedger, autospec=True)
self.ledger = Ledger()
self.ledger.get_schema = async_mock.CoroutineMock(
return_value=async_mock.MagicMock())
self.ledger.get_credential_definition = async_mock.CoroutineMock(
return_value={"value": {
"revocation": None
}})
self.context.injector.clear_binding(BaseLedger)
self.context.injector.bind_instance(BaseLedger, self.ledger)
exchange_in = V10PresentationExchange()
indy_proof_req = await PRES_PREVIEW.indy_proof_request(
name=PROOF_REQ_NAME,
version=PROOF_REQ_VERSION,
nonce=PROOF_REQ_NONCE,
ledger=await self.context.inject(BaseLedger, required=False),
)
exchange_in.presentation_request = indy_proof_req
request = async_mock.MagicMock()
request.indy_proof_request = async_mock.MagicMock()
request._thread_id = "dummy"
self.context.message = request
Holder = async_mock.MagicMock(IndyHolder, autospec=True)
self.holder = Holder()
get_creds = async_mock.CoroutineMock(return_value=(
{
"cred_info": {
"referent": "dummy_reft"
},
"attrs": {
"player": "Richie Knucklez",
"screenCapture": "aW1hZ2luZSBhIHNjcmVlbiBjYXB0dXJl",
"highScore": "1234560",
},
}, # leave this comma: return a tuple
))
self.holder.get_credentials_for_presentation_request_by_referent = get_creds
self.holder.get_credential = async_mock.CoroutineMock(
return_value=json.dumps({
"schema_id": S_ID,
"cred_def_id": CD_ID,
"rev_reg_id": None,
"cred_rev_id": None,
}))
self.holder.create_presentation = async_mock.CoroutineMock(
return_value="{}")
self.context.injector.clear_binding(IndyHolder)
self.context.injector.bind_instance(IndyHolder, self.holder)
with async_mock.patch.object(
V10PresentationExchange, "save",
autospec=True) as save_ex, async_mock.patch.object(
test_module, "AttachDecorator",
autospec=True) as mock_attach_decorator:
mock_attach_decorator.from_indy_dict = async_mock.MagicMock(
return_value=mock_attach_decorator)
req_creds = await indy_proof_req_preview2indy_requested_creds(
indy_proof_req, holder=self.holder)
(exchange_out, pres_msg) = await self.manager.create_presentation(
exchange_in, req_creds)
save_ex.assert_called_once()
assert exchange_out.state == V10PresentationExchange.STATE_PRESENTATION_SENT
async def test_create_presentation_self_asserted(self):
self.context.connection_record = async_mock.MagicMock()
self.context.connection_record.connection_id = CONN_ID
PRES_PREVIEW_SELFIE = PresentationPreview(
attributes=[
PresAttrSpec(name="player", value="Richie Knucklez"),
PresAttrSpec(
name="screenCapture",
mime_type="image/png",
value="aW1hZ2luZSBhIHNjcmVlbiBjYXB0dXJl",
),
],
predicates=[
PresPredSpec(
name="highScore",
cred_def_id=None,
predicate=">=",
threshold=1000000,
)
],
)
exchange_in = V10PresentationExchange()
indy_proof_req = await PRES_PREVIEW_SELFIE.indy_proof_request(
name=PROOF_REQ_NAME,
version=PROOF_REQ_VERSION,
nonce=PROOF_REQ_NONCE,
ledger=await self.context.inject(BaseLedger, required=False),
)
exchange_in.presentation_request = indy_proof_req
request = async_mock.MagicMock()
request.indy_proof_request = async_mock.MagicMock()
request._thread_id = "dummy"
self.context.message = request
more_magic_rr = async_mock.MagicMock(
get_or_fetch_local_tails_path=async_mock.CoroutineMock(
return_value="/tmp/sample/tails/path"))
with async_mock.patch.object(
V10PresentationExchange, "save",
autospec=True) as save_ex, async_mock.patch.object(
test_module, "AttachDecorator", autospec=True
) as mock_attach_decorator, async_mock.patch.object(
test_module, "RevocationRegistry",
autospec=True) as mock_rr:
mock_rr.from_definition = async_mock.MagicMock(
return_value=more_magic_rr)
mock_attach_decorator.from_indy_dict = async_mock.MagicMock(
return_value=mock_attach_decorator)
req_creds = await indy_proof_req_preview2indy_requested_creds(
indy_proof_req, holder=self.holder)
assert len(req_creds["self_attested_attributes"]) == 3
assert not req_creds["requested_attributes"]
assert not req_creds["requested_predicates"]
(exchange_out, pres_msg) = await self.manager.create_presentation(
exchange_in, req_creds)
save_ex.assert_called_once()
assert exchange_out.state == V10PresentationExchange.STATE_PRESENTATION_SENT
async def test_generate_registry_etc(self):
rec = IssuerRevRegRecord(
issuer_did=TEST_DID,
cred_def_id=CRED_DEF_ID,
revoc_reg_id=REV_REG_ID,
)
issuer = async_mock.MagicMock(IndyIssuer)
self.profile.context.injector.bind_instance(IndyIssuer, issuer)
with async_mock.patch.object(
issuer, "create_and_store_revocation_registry",
async_mock.CoroutineMock()) as mock_create_store_rr:
mock_create_store_rr.side_effect = IndyIssuerError("Not this time")
with self.assertRaises(RevocationError):
await rec.generate_registry(self.profile)
issuer.create_and_store_revocation_registry.return_value = (
REV_REG_ID,
json.dumps({
"value": {
"tailsHash":
"59NY25UEV8a5CzNkXFQMppwofUxtYtf4FDp1h9xgeLcK",
"tailsLocation": "point at infinity",
}
}),
json.dumps({"revoc_reg_entry": "dummy-entry"}),
)
with async_mock.patch.object(test_module, "move",
async_mock.MagicMock()) as mock_move:
await rec.generate_registry(self.profile)
assert rec.revoc_reg_id == REV_REG_ID
assert rec.state == IssuerRevRegRecord.STATE_GENERATED
assert rec.tails_hash == "59NY25UEV8a5CzNkXFQMppwofUxtYtf4FDp1h9xgeLcK"
assert rec.tails_local_path == join(
indy_client_dir(join("tails", REV_REG_ID)), rec.tails_hash)
with self.assertRaises(RevocationError):
await rec.set_tails_file_public_uri(self.profile, "dummy")
await rec.set_tails_file_public_uri(self.profile,
"http://localhost/dummy")
assert rec.tails_public_uri == "http://localhost/dummy"
assert rec.revoc_reg_def["value"][
"tailsLocation"] == "http://localhost/dummy"
await rec.send_def(self.profile)
assert rec.state == IssuerRevRegRecord.STATE_POSTED
self.ledger.send_revoc_reg_def.assert_called_once()
await rec.send_entry(self.profile)
assert rec.state == IssuerRevRegRecord.STATE_ACTIVE
self.ledger.send_revoc_reg_entry.assert_called_once()
rev_reg = await rec.get_registry()
assert type(rev_reg) == RevocationRegistry
queried = await IssuerRevRegRecord.query_by_cred_def_id(
session=self.session,
cred_def_id=CRED_DEF_ID,
state=IssuerRevRegRecord.STATE_ACTIVE,
)
assert len(queried) == 1
retrieved = await IssuerRevRegRecord.retrieve_by_revoc_reg_id(
session=self.session, revoc_reg_id=rec.revoc_reg_id)
assert retrieved.revoc_reg_id == rec.revoc_reg_id
await rec.set_state(self.session)
assert rec.state == IssuerRevRegRecord.STATE_FULL
data = rec.serialize()
model_instance = IssuerRevRegRecord.deserialize(data)
assert isinstance(model_instance, IssuerRevRegRecord)
assert model_instance == rec
async def test_called_auto_present_indy(self):
request_context = RequestContext.test_context()
request_context.connection_record = async_mock.MagicMock()
request_context.connection_record.connection_id = "dummy"
request_context.message = V20PresRequest()
request_context.message.attachment = async_mock.MagicMock(
return_value=INDY_PROOF_REQ)
request_context.message_receipt = MessageReceipt()
pres_proposal = V20PresProposal(
formats=[
V20PresFormat(
attach_id="indy",
format_=V20PresFormat.Format.INDY.aries,
)
],
proposals_attach=[
AttachDecorator.data_base64(INDY_PROOF_REQ, ident="indy")
],
)
mock_px_rec = test_module.V20PresExRecord(
pres_proposal=pres_proposal.serialize(),
auto_present=True,
)
with async_mock.patch.object(
test_module, "V20PresManager",
autospec=True) as mock_pres_mgr, async_mock.patch.object(
test_module, "V20PresExRecord", autospec=True
) as mock_pres_ex_rec_cls, async_mock.patch.object(
test_indy_handler, "IndyHolder",
autospec=True) as mock_holder:
mock_holder.get_credentials_for_presentation_request_by_referent = (
async_mock.CoroutineMock(return_value=[{
"cred_info": {
"referent": "dummy"
}
}]))
request_context.inject = async_mock.MagicMock(
return_value=mock_holder)
mock_pres_ex_rec_cls.return_value = mock_px_rec
mock_pres_ex_rec_cls.retrieve_by_tag_filter = async_mock.CoroutineMock(
return_value=mock_px_rec)
mock_pres_mgr.return_value.receive_pres_request = async_mock.CoroutineMock(
return_value=mock_px_rec)
mock_pres_mgr.return_value.create_pres = async_mock.CoroutineMock(
return_value=(mock_px_rec, "pres message"))
request_context.connection_ready = True
handler = test_module.V20PresRequestHandler()
responder = MockResponder()
await handler.handle(request_context, responder)
mock_pres_mgr.return_value.create_pres.assert_called_once()
mock_pres_mgr.return_value.receive_pres_request.assert_called_once_with(
mock_px_rec)
messages = responder.messages
assert len(messages) == 1
(result, target) = messages[0]
assert result == "pres message"
assert target == {}
async def test_listen(self):
"""Test that listen does nothing."""
opsdroid = amock.CoroutineMock()
connector = ConnectorFacebook({}, opsdroid=opsdroid)
await connector.listen()
async def test_close(self):
self.transport._close_http_session = mock.CoroutineMock()
await self.transport.close()
self.transport._close_http_session.assert_called()
def test_init(self):
opsdroid = amock.CoroutineMock()
connector = ConnectorFacebook({}, opsdroid=opsdroid)
self.assertEqual(None, connector.default_target)
self.assertEqual("facebook", connector.name)
async def test_enqueue_message_x_redis_error(queue):
queue.redis.rpush = async_mock.CoroutineMock(
side_effect=aioredis.RedisError)
with pytest.raises(OutboundQueueError):
await queue.enqueue_message(payload="", endpoint=ENDPOINT)
def test_property(self):
opsdroid = amock.CoroutineMock()
connector = ConnectorFacebook({}, opsdroid=opsdroid)
self.assertEqual("facebook", connector.name)
async def test_block_actions_interactivity(self):
"""Test the block_actions interactivity type in Slack interactions handler."""
connector = ConnectorSlack({"token": "abc123"}, opsdroid=OpsDroid())
connector.opsdroid = amock.CoroutineMock()
connector.opsdroid.parse = amock.CoroutineMock()
req_ob = {
"type":
"block_actions",
"team": {
"id": "T9TK3CUKW",
"domain": "example"
},
"user": {
"id": "UA8RXUSPL",
"username": "******",
"team_id": "T9TK3CUKW",
},
"channel": {
"id": "CBR2V3XEX",
"name": "review-updates"
},
"actions": [
{
"action_id": "WaXA",
"block_id": "=qXel",
"text": {
"type": "plain_text",
"text": "View",
"emoji": True
},
"value": "click_me_123",
"type": "button",
"action_ts": "1548426417.840180",
},
{
"type": "overflow",
"block_id": "B5XNP",
"action_id": "BnhtF",
"selected_option": {
"text": {
"type": "plain_text",
"text": "Option 1",
"emoji": True,
},
"value": "value-0",
},
"action_ts": "1576336883.317406",
},
{
"type": "datepicker",
"block_id": "CAwR",
"action_id": "VS+",
"selected_date": "2019-12-31",
"initial_date": "1990-04-28",
"action_ts": "1576337318.133466",
},
{
"type":
"multi_static_select",
"block_id":
"rOL",
"action_id":
"Cd9",
"selected_options": [
{
"text": {
"type": "plain_text",
"text": "Choice 1",
"emoji": True,
},
"value": "value-0",
},
{
"text": {
"type": "plain_text",
"text": "Choice 2",
"emoji": True,
},
"value": "value-1",
},
],
"placeholder": {
"type": "plain_text",
"text": "Select items",
"emoji": True,
},
"action_ts":
"1576337351.609054",
},
{
"type": "static_select",
"block_id": "OGN1",
"action_id": "4jd",
"selected_option": {
"text": {
"type": "plain_text",
"text": "Choice 2",
"emoji": True,
},
"value": "value-1",
},
"placeholder": {
"type": "plain_text",
"text": "Select an item",
"emoji": True,
},
"action_ts": "1576337378.859991",
},
],
}
mock_request = amock.CoroutineMock()
mock_request.post = amock.CoroutineMock()
mock_request.post.return_value = {"payload": json.dumps(req_ob)}
response = await connector.slack_interactions_handler(mock_request)
self.assertTrue(connector.opsdroid.parse.called)
self.assertEqual(connector.opsdroid.parse.call_count,
len(req_ob["actions"]))
self.assertEqual(type(response), aiohttp.web.Response)
self.assertEqual(response.status, 200)
def test_property(self):
opsdroid = amock.CoroutineMock()
connector = Connector({"name": "shell"}, opsdroid=opsdroid)
self.assertEqual("shell", connector.configuration.get("name"))
async def test_get_messages_loop(self):
self.connector._get_messages = amock.CoroutineMock()
self.connector._get_messages.side_effect = Exception()
with contextlib.suppress(Exception):
await self.connector.get_messages_loop()
async def test_send_message(self):
context = InjectionContext()
mgr = OutboundTransportManager(context)
transport_cls = async_mock.Mock(spec=[])
with self.assertRaises(OutboundTransportRegistrationError):
mgr.register_class(transport_cls, "transport_cls")
transport = async_mock.MagicMock()
transport.handle_message = async_mock.CoroutineMock()
transport.wire_format.encode_message = async_mock.CoroutineMock()
transport.start = async_mock.CoroutineMock()
transport.stop = async_mock.CoroutineMock()
transport.schemes = ["http"]
transport_cls = async_mock.MagicMock()
transport_cls.schemes = ["http"]
transport_cls.return_value = transport
mgr.register_class(transport_cls, "transport_cls")
assert mgr.get_registered_transport_for_scheme(
"http") == "transport_cls"
await mgr.start()
await mgr.task_queue
transport.start.assert_awaited_once_with()
assert mgr.get_running_transport_for_scheme("http") == "transport_cls"
message = OutboundMessage(payload="{}")
assert "payload" in str(message)
message.target = ConnectionTarget(
endpoint="http://localhost",
recipient_keys=[1, 2],
routing_keys=[3],
sender_key=4,
)
send_session = InMemoryProfile.test_session()
send_profile = send_session.profile
setattr(send_profile, "session",
async_mock.MagicMock(return_value=send_session))
mgr.enqueue_message(send_profile, message)
await mgr.flush()
transport.wire_format.encode_message.assert_awaited_once_with(
send_session,
message.payload,
message.target.recipient_keys,
message.target.routing_keys,
message.target.sender_key,
)
transport.handle_message.assert_awaited_once_with(
send_profile,
transport.wire_format.encode_message.return_value,
message.target.endpoint,
None,
None,
)
with self.assertRaises(OutboundDeliveryError):
mgr.get_running_transport_for_endpoint("localhost")
message.target = ConnectionTarget(
endpoint="localhost",
recipient_keys=[1, 2],
routing_keys=[3],
sender_key=4,
)
with self.assertRaises(OutboundDeliveryError) as context:
mgr.enqueue_message(send_profile, message)
assert "No supported transport" in str(context.exception)
await mgr.stop()
assert mgr.get_running_transport_for_scheme("http") is None
transport.stop.assert_awaited_once_with()
async def test_called_auto_present_multi_cred_match_reft(self):
request_context = RequestContext.test_context()
request_context.connection_record = async_mock.MagicMock()
request_context.connection_record.connection_id = "dummy"
request_context.message = V20PresRequest()
request_context.message.attachment = async_mock.MagicMock(
return_value=INDY_PROOF_REQ)
request_context.message_receipt = MessageReceipt()
pres_proposal = V20PresProposal(
formats=[
V20PresFormat(
attach_id="indy",
format_=V20PresFormat.Format.INDY.aries,
)
],
proposals_attach=[
AttachDecorator.data_base64(INDY_PROOF_REQ, ident="indy")
],
)
px_rec_instance = test_module.V20PresExRecord(
pres_proposal=pres_proposal.serialize(),
auto_present=True,
)
with async_mock.patch.object(
test_module, "V20PresManager",
autospec=True) as mock_pres_mgr, async_mock.patch.object(
test_module, "V20PresExRecord", autospec=True
) as mock_pres_ex_rec_cls, async_mock.patch.object(
test_module, "IndyHolder", autospec=True) as mock_holder:
mock_holder.get_credentials_for_presentation_request_by_referent = (
async_mock.CoroutineMock(return_value=[
{
"cred_info": {
"referent": "dummy-0",
"cred_def_id": CD_ID,
"attrs": {
"ident": "zero",
"favourite": "potato",
"icon": "cG90YXRv",
},
}
},
{
"cred_info": {
"referent": "dummy-1",
"cred_def_id": CD_ID,
"attrs": {
"ident": "one",
"favourite": "spud",
"icon": "c3B1ZA==",
},
}
},
{
"cred_info": {
"referent": "dummy-2",
"cred_def_id": CD_ID,
"attrs": {
"ident": "two",
"favourite": "patate",
"icon": "cGF0YXRl",
},
}
},
]))
request_context.inject = async_mock.MagicMock(
return_value=mock_holder)
mock_pres_ex_rec_cls.return_value = px_rec_instance
mock_pres_ex_rec_cls.retrieve_by_tag_filter = async_mock.CoroutineMock(
return_value=px_rec_instance)
mock_pres_mgr.return_value.receive_pres_request = async_mock.CoroutineMock(
return_value=px_rec_instance)
mock_pres_mgr.return_value.create_pres = async_mock.CoroutineMock(
return_value=(px_rec_instance, "pres message"))
request_context.connection_ready = True
handler = test_module.V20PresRequestHandler()
responder = MockResponder()
await handler.handle(request_context, responder)
mock_pres_mgr.return_value.create_pres.assert_called_once()
mock_pres_mgr.return_value.receive_pres_request.assert_called_once_with(
px_rec_instance)
messages = responder.messages
assert len(messages) == 1
(result, target) = messages[0]
assert result == "pres message"
assert target == {}
async def test_respond(self):
connector = ConnectorSlack({"api-token": "abc123"},
opsdroid=OpsDroid())
connector.slacker.chat.post_message = amock.CoroutineMock()
await connector.send(Message("test", "user", "room", connector))
self.assertTrue(connector.slacker.chat.post_message.called)
async def test_called_auto_present_x(self):
request_context = RequestContext.test_context()
request_context.connection_record = async_mock.MagicMock()
request_context.connection_record.connection_id = "dummy"
request_context.message = PresentationRequest()
request_context.message.indy_proof_request = async_mock.MagicMock(
return_value={
"name": "proof-request",
"version": "1.0",
"nonce": "1234567890",
"requested_attributes": {
"0_favourite_uuid": {
"name": "favourite",
"restrictions": [
{
"cred_def_id": CD_ID,
}
],
},
"1_icon_uuid": {
"name": "icon",
"restrictions": [
{
"cred_def_id": CD_ID,
}
],
},
},
"requested_predicates": {},
}
)
request_context.message_receipt = MessageReceipt()
presentation_proposal = PresentationProposal(
comment="Hello World", presentation_proposal=PRES_PREVIEW
)
mock_px_rec = async_mock.MagicMock(
presentation_proposal_dict=presentation_proposal,
auto_present=True,
save_error_state=async_mock.CoroutineMock(),
)
with async_mock.patch.object(
test_module, "PresentationManager", autospec=True
) as mock_pres_mgr, async_mock.patch.object(
test_module, "V10PresentationExchange", autospec=True
) as mock_pres_ex_cls, async_mock.patch.object(
test_module, "IndyHolder", autospec=True
) as mock_holder:
mock_holder.get_credentials_for_presentation_request_by_referent = (
async_mock.CoroutineMock(
return_value=[{"cred_info": {"referent": "dummy"}}]
)
)
request_context.inject = async_mock.MagicMock(return_value=mock_holder)
mock_pres_ex_cls.return_value = mock_px_rec
mock_pres_ex_cls.retrieve_by_tag_filter = async_mock.CoroutineMock(
return_value=mock_px_rec
)
mock_pres_mgr.return_value.receive_request = async_mock.CoroutineMock(
return_value=mock_px_rec
)
mock_pres_mgr.return_value.create_presentation = async_mock.CoroutineMock(
side_effect=test_module.IndyHolderError()
)
request_context.connection_ready = True
handler = test_module.PresentationRequestHandler()
responder = MockResponder()
with async_mock.patch.object(
handler._logger, "exception", async_mock.MagicMock()
) as mock_log_exc:
await handler.handle(request_context, responder)
mock_log_exc.assert_called_once()
async def test_connections_list(self):
context = RequestContext(
base_context=InjectionContext(enforce_typing=False)
)
mock_req = async_mock.MagicMock()
mock_req.app = {
"request_context": context,
}
mock_req.query = {
"invitation_id": "dummy",
"initiator": ConnectionRecord.INITIATOR_SELF
}
test_module.web.json_response = async_mock.CoroutineMock()
with async_mock.patch.object(
test_module, "ConnectionRecord", autospec=True
) as mock_conn_rec:
mock_conn_rec.STATE_INVITATION=ConnectionRecord.STATE_INVITATION
mock_conn_rec.STATE_INACTIVE=ConnectionRecord.STATE_INACTIVE
mock_conn_rec.query = async_mock.CoroutineMock()
conns = [ # in order here
async_mock.MagicMock(
serialize=async_mock.MagicMock(
return_value={
"state": ConnectionRecord.STATE_ACTIVE,
"created_at": "1234567890"
}
)
),
async_mock.MagicMock(
serialize=async_mock.MagicMock(
return_value={
"state": ConnectionRecord.STATE_INVITATION,
"created_at": "1234567890"
}
)
),
async_mock.MagicMock(
serialize=async_mock.MagicMock(
return_value={
"state": ConnectionRecord.STATE_INACTIVE,
"created_at": "1234567890"
}
)
)
]
mock_conn_rec.query.return_value = [
conns[2], conns[0], conns[1] # jumbled
]
await test_module.connections_list(mock_req)
test_module.web.json_response.assert_called_once_with(
{
"results": [
{
k: c.serialize.return_value[k] for k in [
"state",
"created_at"
]
} for c in conns
]
} # sorted
)
async def test_called_auto_present_pred_multi_match(self):
request_context = RequestContext.test_context()
request_context.connection_record = async_mock.MagicMock()
request_context.connection_record.connection_id = "dummy"
request_context.message = PresentationRequest()
request_context.message.indy_proof_request = async_mock.MagicMock(
return_value={
"name": "proof-request",
"version": "1.0",
"nonce": "1234567890",
"requested_attributes": {},
"requested_predicates": {
"0_score_GE_uuid": {
"name": "score",
"p_type": ">=",
"p_value": 1000000,
"restrictions": [{
"cred_def_id": CD_ID,
}],
}
},
})
request_context.message_receipt = MessageReceipt()
px_rec_instance = handler.V10PresentationExchange(auto_present=True)
with async_mock.patch.object(
handler, "PresentationManager",
autospec=True) as mock_pres_mgr, async_mock.patch.object(
handler, "V10PresentationExchange", autospec=True
) as mock_pres_ex_rec, async_mock.patch.object(
handler, "IndyHolder", autospec=True) as mock_holder:
mock_holder.get_credentials_for_presentation_request_by_referent = (
async_mock.CoroutineMock(return_value=[
{
"cred_info": {
"referent": "dummy-0"
}
},
{
"cred_info": {
"referent": "dummy-1"
}
},
]))
request_context.inject = async_mock.MagicMock(
return_value=mock_holder)
mock_pres_ex_rec.return_value = px_rec_instance
mock_pres_ex_rec.retrieve_by_tag_filter = async_mock.CoroutineMock(
return_value=px_rec_instance)
mock_pres_mgr.return_value.receive_request = async_mock.CoroutineMock(
return_value=px_rec_instance)
mock_pres_mgr.return_value.create_presentation = async_mock.CoroutineMock(
return_value=(px_rec_instance, "presentation_message"))
request_context.connection_ready = True
handler_inst = handler.PresentationRequestHandler()
responder = MockResponder()
await handler_inst.handle(request_context, responder)
mock_pres_mgr.return_value.create_presentation.assert_called_once()
mock_pres_mgr.return_value.receive_request.assert_called_once_with(
px_rec_instance)
messages = responder.messages
assert len(messages) == 1
(result, target) = messages[0]
assert result == "presentation_message"
assert target == {}
async def test_resolver_not_found_error(mock_resolver, mock_request,
side_effect, error):
mock_resolver.resolve = async_mock.CoroutineMock(side_effect=side_effect())
with pytest.raises(error):
await test_module.resolve_did(mock_request)
