async def test_get_active_registry_not_found(self):
CRED_DEF_ID = f"{self.test_did}:3:CL:1234:default"
request = async_mock.MagicMock()
request.app = self.app
request.match_info = {"cred_def_id": CRED_DEF_ID}
with async_mock.patch.object(
test_module, "IndyRevocation", autospec=True
) as mock_indy_revoc, async_mock.patch.object(
test_module.web, "json_response", async_mock.Mock()
) as mock_json_response:
mock_indy_revoc.return_value = async_mock.MagicMock(
get_active_issuer_rev_reg_record=async_mock.CoroutineMock(
side_effect=test_module.StorageNotFoundError(error_code="dummy")
)
)
with self.assertRaises(HTTPNotFound):
result = await test_module.get_active_registry(request)
mock_json_response.assert_not_called()
async def test_invitation_create_x(self):
self.request.query = {"multi_use": "true"}
self.request.json = async_mock.CoroutineMock(
return_value={
"attachments": async_mock.MagicMock(),
"include_handshake": True,
"use_public_did": True,
})
with async_mock.patch.object(
test_module, "OutOfBandManager",
autospec=True) as mock_oob_mgr, async_mock.patch.object(
test_module.web, "json_response",
async_mock.Mock()) as mock_json_response:
mock_oob_mgr.return_value.create_invitation = async_mock.CoroutineMock(
side_effect=test_module.OutOfBandManagerError())
with self.assertRaises(test_module.web.HTTPBadRequest):
await test_module.invitation_create(self.request)
mock_json_response.assert_not_called()
async def test_revocation_registries_created(self):
CRED_DEF_ID = f"{self.test_did}:3:CL:1234:default"
STATE = "active"
request = async_mock.MagicMock()
request.app = self.app
request.query = {
"cred_def_id": CRED_DEF_ID,
"state": test_module.IssuerRevRegRecord.STATE_ACTIVE,
}
with async_mock.patch.object(
test_module.IssuerRevRegRecord, "query", async_mock.CoroutineMock()
) as mock_query, async_mock.patch.object(
test_module.web, "json_response", async_mock.Mock()
) as mock_json_response:
mock_query.return_value = [async_mock.MagicMock(revoc_reg_id="dummy")]
result = await test_module.revocation_registries_created(request)
mock_json_response.assert_called_once_with({"rev_reg_ids": ["dummy"]})
assert result is mock_json_response.return_value
async def test_respond(self):
post_response = amock.Mock()
post_response.status = 200
with OpsDroid() as opsdroid, \
amock.patch('aiohttp.ClientSession.post') as patched_request, \
amock.patch('opsdroid.connector.rocketchat._LOGGER.debug') \
as logmock:
self.assertTrue(opsdroid.__class__.instances)
test_message = Message(text="This is a test",
user="******",
room="test",
connector=self.connector)
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(post_response)
await test_message.respond("Response")
self.assertTrue(patched_request.called)
self.assertTrue(logmock.called)
async def test_get_tails_file(self):
REV_REG_ID = "{}:4:{}:3:CL:1234:default:CL_ACCUM:default".format(
self.test_did, self.test_did
)
self.request.match_info = {"rev_reg_id": REV_REG_ID}
with async_mock.patch.object(
test_module, "IndyRevocation", autospec=True
) as mock_indy_revoc, async_mock.patch.object(
test_module.web, "FileResponse", async_mock.Mock()
) as mock_file_response:
mock_indy_revoc.return_value = async_mock.MagicMock(
get_issuer_rev_reg_record=async_mock.CoroutineMock(
return_value=async_mock.MagicMock(tails_local_path="dummy")
)
)
result = await test_module.get_tails_file(self.request)
mock_file_response.assert_called_once_with(path="dummy", status=200)
assert result is mock_file_response.return_value
async def test_get_active_rev_reg(self):
CRED_DEF_ID = f"{self.test_did}:3:CL:1234:default"
self.request.match_info = {"cred_def_id": CRED_DEF_ID}
with async_mock.patch.object(
test_module, "IndyRevocation", autospec=True
) as mock_indy_revoc, async_mock.patch.object(
test_module.web, "json_response", async_mock.Mock()
) as mock_json_response:
mock_indy_revoc.return_value = async_mock.MagicMock(
get_active_issuer_rev_reg_record=async_mock.CoroutineMock(
return_value=async_mock.MagicMock(
serialize=async_mock.MagicMock(return_value="dummy")
)
)
)
result = await test_module.get_active_rev_reg(self.request)
mock_json_response.assert_called_once_with({"result": "dummy"})
assert result is mock_json_response.return_value
async def test_credentials_list(self):
request = async_mock.MagicMock(app=self.app,
query={
"start": "0",
"count": "10"
})
request.app["request_context"].inject = async_mock.CoroutineMock(
return_value=async_mock.MagicMock(
get_credentials=async_mock.CoroutineMock(
return_value={"hello": "world"})))
with async_mock.patch.object(test_module.web, "json_response",
async_mock.Mock()) as json_response:
result = await test_module.credentials_list(request)
json_response.assert_called_once_with(
{"results": {
"hello": "world"
}})
assert result is json_response.return_value
async def test_get_registry(self):
REV_REG_ID = "{}:4:{}:3:CL:1234:default:CL_ACCUM:default".format(
self.test_did, self.test_did)
request = async_mock.MagicMock()
request.app = self.app
request.match_info = {"rev_reg_id": REV_REG_ID}
with async_mock.patch.object(
test_module, "IndyRevocation",
autospec=True) as mock_indy_revoc, async_mock.patch.object(
test_module.web, "json_response",
async_mock.Mock()) as mock_json_response:
mock_indy_revoc.return_value = async_mock.MagicMock(
get_issuer_rev_reg_record=async_mock.CoroutineMock(
return_value=async_mock.MagicMock(
serialize=async_mock.MagicMock(return_value="dummy"))))
result = await test_module.get_registry(request)
mock_json_response.assert_called_once_with({"result": "dummy"})
assert result is mock_json_response.return_value
async def test_update_stream_title(opsdroid, caplog):
connector = ConnectorTwitch(connector_config, opsdroid=opsdroid)
caplog.set_level(logging.DEBUG)
post_response = amock.Mock()
post_response.status = 204
post_response.json = amock.CoroutineMock()
with amock.patch("aiohttp.ClientSession.patch",
new=amock.CoroutineMock()) as mocked_session:
mocked_session.return_value = asyncio.Future()
mocked_session.return_value.set_result(post_response)
status_event = twitch_event.UpdateTitle(status="Test title!")
await connector.update_stream_title(status_event)
assert "Test title!" in caplog.text
async def test_get_cred_rev_record_by_cred_ex_id(self):
CRED_EX_ID = test_module.UUID4["example"]
request = async_mock.MagicMock()
request.app = self.app
request.query = {"cred_ex_id": CRED_EX_ID}
with async_mock.patch.object(
test_module.IssuerCredRevRecord,
"retrieve_by_cred_ex_id",
async_mock.CoroutineMock(),
) as mock_retrieve, async_mock.patch.object(
test_module.web, "json_response",
async_mock.Mock()) as mock_json_response:
mock_retrieve.return_value = async_mock.MagicMock(
serialize=async_mock.MagicMock(return_value="dummy"))
result = await test_module.get_cred_rev_record(request)
mock_json_response.assert_called_once_with({"result": "dummy"})
assert result is mock_json_response.return_value
async def test_update_stream_title_failure(opsdroid, caplog):
connector = ConnectorTwitch(connector_config, opsdroid=opsdroid)
caplog.set_level(logging.DEBUG)
post_response = amock.Mock()
post_response.status = 500
post_response.message = "Internal Server Error"
with amock.patch("aiohttp.ClientSession.patch",
new=amock.CoroutineMock()) as mocked_session:
mocked_session.return_value = asyncio.Future()
mocked_session.return_value.set_result(post_response)
status_event = twitch_event.UpdateTitle(status="Test title!")
await connector.update_stream_title(status_event)
assert "Failed to update Twitch channel title" in caplog.text
async def test_call_rasanlu_bad_response(self):
opsdroid = amock.CoroutineMock()
mock_connector = Connector({}, opsdroid=opsdroid)
message = Message(
text="how's the weather outside",
user="******",
target="default",
connector=mock_connector,
)
config = {"name": "rasanlu", "token": "test", "min-score": 0.3}
result = amock.Mock()
result.status = 403
result.text = amock.CoroutineMock()
result.text.return_value = "unauthorized"
with amock.patch("aiohttp.ClientSession.post") as patched_request:
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(result)
response = await rasanlu.call_rasanlu(message.text, config)
self.assertTrue(patched_request.called)
self.assertEqual(response, result.text.return_value)
async def test_get_rev_reg_not_found(self):
REV_REG_ID = "{}:4:{}:3:CL:1234:default:CL_ACCUM:default".format(
self.test_did, self.test_did
)
self.request.match_info = {"rev_reg_id": REV_REG_ID}
with async_mock.patch.object(
test_module, "IndyRevocation", autospec=True
) as mock_indy_revoc, async_mock.patch.object(
test_module.web, "json_response", async_mock.Mock()
) as mock_json_response:
mock_indy_revoc.return_value = async_mock.MagicMock(
get_issuer_rev_reg_record=async_mock.CoroutineMock(
side_effect=test_module.StorageNotFoundError(error_code="dummy")
)
)
with self.assertRaises(HTTPNotFound):
result = await test_module.get_rev_reg(self.request)
mock_json_response.assert_not_called()
async def test_match_webhook_response_with_authorization_failure(self):
with OpsDroid() as opsdroid:
opsdroid.loader.current_import_config = {"name": "testhook"}
opsdroid.config["web"] = {"webhook-token": "aabbccddeeff"}
opsdroid.web_server = Web(opsdroid)
opsdroid.web_server.web_app = mock.Mock()
webhook = "test"
decorator = matchers.match_webhook(webhook)
opsdroid.skills.append(decorator(await self.getMockSkill()))
opsdroid.skills[0].config = {"name": "mockedskill"}
opsdroid.web_server.setup_webhooks(opsdroid.skills)
postcalls, _ = opsdroid.web_server.web_app.router.add_post.call_args_list[
0]
wrapperfunc = postcalls[1]
webhookresponse = await wrapperfunc(
make_mocked_request(
"POST",
postcalls[0],
headers={"Authorization": "Bearer wwxxyyzz"}))
self.assertEqual(type(webhookresponse), aiohttp.web.Response)
async def test_respond(self):
post_response = amock.Mock()
post_response.status = 200
with OpsDroid() as opsdroid, amock.patch.object(
self.connector.session, "post") as patched_request:
self.assertTrue(opsdroid.__class__.instances)
test_message = Message(
text="This is a test",
user="******",
target={"id": 12404},
connector=self.connector,
)
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(post_response)
await test_message.respond("Response")
self.assertTrue(patched_request.called)
self.assertLogs("_LOGGER", "debug")
async def test_call_dialogflow(self):
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "path/test.json"
config = {"name": "dialogflow", "project-id": "test"}
opsdroid = amock.CoroutineMock()
mock_connector = Connector({}, opsdroid=opsdroid)
message = Message(text="Hello",
user="******",
target="default",
connector=mock_connector)
result = amock.Mock()
result.json = amock.CoroutineMock()
result.json.return_value = {
"query_result": {
"query_text": "what is up",
"action": "smalltalk.greetings.whatsup",
"parameters": {},
"all_required_params_present": True,
"fulfillment_text": "Not much. What's new with you?",
"fulfillment_messages": {
"text": {
"text": "Not much. What's new with you?"
}
},
"intent": {},
"intent_detection_confidence": 1.0,
"language_code": "en",
}
}
with amock.patch(
"dialogflow.SessionsClient") as patched_request, amock.patch(
"dialogflow.types.TextInput") as mocked_input, amock.patch(
"dialogflow.types.QueryInput") as mocked_response:
patched_request.session_path.return_value = (
"projects/test/agent/sessions/opsdroid")
mocked_input.return_value = 'text: "hi"'
mocked_response.return_value = asyncio.Future()
patched_request.return_value.set_result(result)
await dialogflow.call_dialogflow(message, opsdroid, config)
self.assertTrue(patched_request.called)
async def test_call_rasanlu(self):
opsdroid = amock.CoroutineMock()
mock_connector = Connector({}, opsdroid=opsdroid)
message = Message("how's the weather outside", "user", "default",
mock_connector)
config = {
'name': 'rasanlu',
'access-token': 'test',
'min-score': 0.3,
'token': '12345'
}
result = amock.Mock()
result.status = 200
result.json = amock.CoroutineMock()
result.json.return_value = {
"entities": [{
"end": 32,
"entity": "state",
"extractor": "ner_crf",
"start": 25,
"value": "running"
}],
"intent": {
"confidence": 0.5745766766665303,
"name": "get_weather"
},
"intent_ranking": [{
"confidence": 0.5745766766665303,
"name": "get_weather"
}, {
"confidence": 0.42542332333346977,
"name": "other_weather"
}],
"text":
"how's the weather outside"
}
with amock.patch('aiohttp.ClientSession.post') as patched_request:
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(result)
await rasanlu.call_rasanlu(message.text, config)
self.assertTrue(patched_request.called)
async def test_wallet_create(self):
body = {
"wallet_name": "test",
"wallet_type": "indy",
"wallet_key": "test",
"key_management_mode": "managed",
}
self.request.json = async_mock.CoroutineMock(return_value=body)
mock_multitenant_mgr = self.session_inject[MultitenantManager]
with async_mock.patch.object(test_module.web,
"json_response") as mock_response:
wallet_mock = async_mock.MagicMock(serialize=async_mock.MagicMock(
return_value={
"wallet_id": "test",
"settings": {},
"key_management_mode": body["key_management_mode"],
})) # wallet_record
mock_multitenant_mgr.create_wallet = async_mock.CoroutineMock(
return_value=wallet_mock)
mock_multitenant_mgr.create_auth_token = async_mock.Mock(
return_value="test_token")
print(self.request["context"])
await test_module.wallet_create(self.request)
mock_multitenant_mgr.create_wallet.assert_called_once_with(
{
"wallet.name": body["wallet_name"],
"wallet.type": body["wallet_type"],
"wallet.key": body["wallet_key"],
},
body["key_management_mode"],
)
mock_multitenant_mgr.create_auth_token.assert_called_once_with(
wallet_mock, body["wallet_key"])
mock_response.assert_called_once_with({
**test_module.format_wallet_record(wallet_mock), "token":
"test_token"
})
async def test_did_list(self):
with async_mock.patch.object(
test_module.web, "json_response", async_mock.Mock(
)) as json_response: # , async_mock.patch.object(
self.wallet.get_local_dids.return_value = [
DIDInfo(
self.test_did,
self.test_verkey,
DIDPosture.WALLET_ONLY.metadata,
DIDMethod.SOV,
KeyType.ED25519,
),
DIDInfo(
self.test_posted_did,
self.test_posted_verkey,
DIDPosture.POSTED.metadata,
DIDMethod.SOV,
KeyType.ED25519,
),
]
result = await test_module.wallet_did_list(self.request)
json_response.assert_called_once_with({
"results": [
{
"did": self.test_posted_did,
"verkey": self.test_posted_verkey,
"posture": DIDPosture.POSTED.moniker,
"key_type": KeyType.ED25519.key_type,
"method": DIDMethod.SOV.method_name,
},
{
"did": self.test_did,
"verkey": self.test_verkey,
"posture": DIDPosture.WALLET_ONLY.moniker,
"key_type": KeyType.ED25519.key_type,
"method": DIDMethod.SOV.method_name,
},
]
})
assert json_response.return_value is json_response()
assert result is json_response.return_value
async def test_call_witai(self):
opsdroid = amock.CoroutineMock()
mock_connector = Connector({}, opsdroid=opsdroid)
message = Message(
"how's the weather outside", "user", "default", mock_connector
)
config = {"name": "witai", "access-token": "test", "min-score": 0.3}
result = amock.Mock()
result.json = amock.CoroutineMock()
result.json.return_value = {
"msg_id": "0fI07qSgCwM79NEjs",
"_text": "how's the weather outside",
"entities": {
"intent": [{"confidence": 0.99897986426571, "value": "get_weather"}]
},
}
with amock.patch("aiohttp.ClientSession.get") as patched_request:
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(result)
await witai.call_witai(message, config)
self.assertTrue(patched_request.called)
async def test_set_public_did_no_wallet_did(self):
request = async_mock.MagicMock()
request.app = self.app
request.query = {"did": self.test_did}
Ledger = async_mock.MagicMock()
self.ledger = Ledger()
self.ledger.update_endpoint_for_did = async_mock.CoroutineMock()
self.ledger.get_key_for_did = async_mock.CoroutineMock()
self.ledger.__aenter__ = async_mock.CoroutineMock(return_value=self.ledger)
self.context.injector.bind_instance(BaseLedger, self.ledger)
with async_mock.patch.object(
test_module.web, "json_response", async_mock.Mock()
) as json_response:
self.wallet.get_public_did.return_value = DIDInfo(
self.test_did, self.test_verkey, DIDPosture.PUBLIC.metadata
)
self.wallet.set_public_did.side_effect = test_module.WalletNotFoundError()
with self.assertRaises(test_module.web.HTTPNotFound):
await test_module.wallet_set_public_did(request)
async def test_create_did(self):
with async_mock.patch.object(test_module.web, "json_response",
async_mock.Mock()) as json_response:
self.wallet.create_local_did.return_value = DIDInfo(
self.test_did,
self.test_verkey,
DIDPosture.WALLET_ONLY.metadata,
DIDMethod.SOV,
KeyType.ED25519,
)
result = await test_module.wallet_create_did(self.request)
json_response.assert_called_once_with({
"result": {
"did": self.test_did,
"verkey": self.test_verkey,
"posture": DIDPosture.WALLET_ONLY.moniker,
"key_type": KeyType.ED25519.key_type,
"method": DIDMethod.SOV.method_name,
}
})
assert result is json_response.return_value
async def test_set_public_did_x(self):
self.request.query = {"did": self.test_did}
Ledger = async_mock.MagicMock()
ledger = Ledger()
ledger.update_endpoint_for_did = async_mock.CoroutineMock()
ledger.get_key_for_did = async_mock.CoroutineMock()
ledger.__aenter__ = async_mock.CoroutineMock(return_value=ledger)
self.profile.context.injector.bind_instance(BaseLedger, ledger)
with async_mock.patch.object(test_module.web, "json_response",
async_mock.Mock()) as json_response:
self.wallet.get_public_did.return_value = DIDInfo(
self.test_did,
self.test_verkey,
DIDPosture.PUBLIC.metadata,
DIDMethod.SOV,
KeyType.ED25519,
)
self.wallet.set_public_did.side_effect = test_module.WalletError()
with self.assertRaises(test_module.web.HTTPBadRequest):
await test_module.wallet_set_public_did(self.request)
async def test_respond_bad_response(opsdroid):
"""Test that responding sends a message and get bad response."""
post_response = amock.Mock()
post_response.status = 401
post_response.text = amock.CoroutineMock()
post_response.text.return_value = "Error"
with amock.patch("aiohttp.ClientSession.post",
new=amock.CoroutineMock()) as patched_request:
assert opsdroid.__class__.instances
connector = ConnectorFacebook({}, opsdroid=opsdroid)
room = "a146f52c-548a-11e8-a7d1-28cfe949e12d"
test_message = Message(text="Hello world",
user="******",
target=room,
connector=connector)
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(post_response)
await test_message.respond("Response")
assert patched_request.called
assert post_response.text.called
async def test_call_dialogflow(self):
mock_connector = Connector({})
message = Message("Hello world", "user", "default", mock_connector)
config = {'name': 'dialogflow', 'access-token': 'test'}
result = amock.Mock()
result.json = amock.CoroutineMock()
result.json.return_value = {
"result": {
"action": "myaction",
"score": 0.7
},
"status": {
"code": 200,
"errorType": "success"
}
}
with amock.patch('aiohttp.ClientSession.post') as patched_request:
patched_request.return_value = helpers.create_future(self.loop)
patched_request.return_value.set_result(result)
await dialogflow.call_dialogflow(message, config)
self.assertTrue(patched_request.called)
async def test_get_did_endpoint(self):
self.request.query = {"did": self.test_did}
self.wallet.get_local_did.return_value = DIDInfo(
self.test_did,
self.test_verkey,
{
"public": False,
"endpoint": "http://old-endpoint.ca"
},
)
with async_mock.patch.object(test_module.web, "json_response",
async_mock.Mock()) as json_response:
await test_module.wallet_get_did_endpoint(self.request)
json_response.assert_called_once_with({
"did":
self.test_did,
"endpoint":
self.wallet.get_local_did.return_value.metadata["endpoint"],
})
async def test_request_oauth_token_failure(opsdroid, caplog):
connector = ConnectorTwitch(connector_config, opsdroid=opsdroid)
post_response = amock.Mock()
post_response.status = 400
post_response.json = amock.CoroutineMock()
post_response.json.return_value = {
"status": 400,
"message": "Parameter redirect_uri does not match registered URI",
}
with amock.patch("aiohttp.ClientSession.post",
new=amock.CoroutineMock()) as patched_request:
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(post_response)
await connector.request_oauth_token()
assert connector.token is None
assert "Unable to request oauth token" in caplog.text
assert "Parameter redirect_uri does not match registered URI" in caplog.text
async def test_credentials_revoked(self):
request = async_mock.MagicMock(
app=self.app, match_info={"credential_id": "dummy"}
)
ledger = async_mock.create_autospec(BaseLedger)
request.app["request_context"].inject = async_mock.CoroutineMock(
side_effect=[
ledger,
async_mock.MagicMock(
credential_revoked=async_mock.CoroutineMock(return_value=False)
),
]
)
with async_mock.patch.object(
test_module.web, "json_response", async_mock.Mock()
) as json_response:
result = await test_module.credentials_revoked(request)
json_response.assert_called_once_with({"revoked": False})
assert result is json_response.return_value
async def test_create_registry_no_such_cred_def(self):
CRED_DEF_ID = f"{self.test_did}:3:CL:1234:default"
request = async_mock.MagicMock()
request.app = self.app
request.json = async_mock.CoroutineMock(
return_value={
"max_cred_num": "1000",
"credential_definition_id": CRED_DEF_ID,
})
with async_mock.patch.object(
self.storage, "search_records",
autospec=True) as mock_search, async_mock.patch.object(
test_module.web, "json_response",
async_mock.Mock()) as mock_json_response:
mock_search.return_value.fetch_all = async_mock.CoroutineMock(
return_value=False)
with self.assertRaises(HTTPNotFound):
result = await test_module.revocation_create_registry(request)
mock_json_response.assert_not_called()
async def test_get_nym_role_multitenant(self):
self.context.injector.bind_instance(
BaseMultitenantManager,
async_mock.MagicMock(MultitenantManager, autospec=True),
)
self.request.query = {"did": self.test_did}
with async_mock.patch.object(
IndyLedgerRequestsExecutor,
"get_ledger_for_identifier",
async_mock.CoroutineMock(return_value=("test_ledger_id",
self.ledger)),
), async_mock.patch.object(test_module.web, "json_response",
async_mock.Mock()) as json_response:
self.ledger.get_nym_role.return_value = Role.USER
result = await test_module.get_nym_role(self.request)
json_response.assert_called_once_with({
"ledger_id": "test_ledger_id",
"role": "USER"
})
assert result is json_response.return_value
