async def respond(self, message, room=None):
"""Send a message back to the chat service.
The message object will have a `text` property which should be sent
back to the chat service. It may also have a `room` and `user` property
which gives information on where the message should be directed.
Args:
message (Message): A message received by the connector.
room (string): Name of the room to send the message to
Returns:
bool: True for message successfully sent. False otherwise.
"""
warnings.warn(
"Connector.respond is deprecated. Use "
"Connector.send instead.",
DeprecationWarning)
if isinstance(message, str):
message = Message(message)
if room:
message.target = room
return await self.send(message)
async def test_respond(self):
"""Test that responding sends a message down the correct websocket."""
with OpsDroid() as opsdroid:
self.assertTrue(opsdroid.__class__.instances)
connector = ConnectorWebsocket({}, opsdroid=opsdroid)
room = "a146f52c-548a-11e8-a7d1-28cfe949e12d"
connector.active_connections[room] = amock.CoroutineMock()
connector.active_connections[room].send_str = amock.CoroutineMock()
test_message = Message(text="Hello world",
user="******",
target=room,
connector=connector)
await test_message.respond("Response")
self.assertTrue(connector.active_connections[room].send_str.called)
connector.active_connections[room].send_str.reset_mock()
test_message.target = None
await test_message.respond("Response")
self.assertTrue(
connector.active_connections[room].send_str.called)
connector.active_connections[room].send_str.reset_mock()
test_message.target = "Invalid Room"
await test_message.respond("Response")
self.assertFalse(
connector.active_connections[room].send_str.called)
async def _parse_message(self, response):
"""Handle logic to parse a received message.
Since everyone can send a private message to any user/bot
in Telegram, this method allows to set a list of whitelisted
users that can interact with the bot. If any other user tries
to interact with the bot the command is not parsed and instead
the bot will inform that user that he is not allowed to talk
with the bot.
We also set self.latest_update to +1 in order to get the next
available message (or an empty {} if no message has been received
yet) with the method self._get_messages().
Args:
response (dict): Response returned by aiohttp.ClientSession.
"""
for result in response["result"]:
_LOGGER.debug(result)
if result.get('edited_message', None):
result['message'] = result.pop('edited_message')
if "channel" in result["message"]["chat"]["type"]:
_LOGGER.debug("Channel message parsing not supported "
"- Ignoring message")
elif "message" in result and "text" in result["message"]:
user = self.get_user(result)
message = Message(
result["message"]["text"],
user,
result["message"]["chat"],
self)
if self.handle_user_permission(result, user):
await self.opsdroid.parse(message)
else:
message.text = "Sorry, you're not allowed " \
"to speak with this bot."
await self.send(message)
self.latest_update = result["update_id"] + 1
else:
_LOGGER.error("Unable to parse the message.")
async def test_parse_rasanlu_failure(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [
{"name": "rasanlu", "token": "test", "min-score": 0.3}
]
mock_skill = amock.CoroutineMock()
match_rasanlu("get_weather")(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message(
text="how's the weather outside",
user="******",
target="default",
connector=mock_connector,
)
with amock.patch.object(rasanlu, "call_rasanlu") as mocked_call_rasanlu:
mocked_call_rasanlu.return_value = "unauthorized"
skills = await rasanlu.parse_rasanlu(
opsdroid, opsdroid.skills, message, opsdroid.config["parsers"][0]
)
self.assertFalse(skills)
async def test_parse_rasanlu(self):
with OpsDroid() as opsdroid:
opsdroid.modules = {
"parsers": [{
"config": {
"name": "rasanlu",
"module": "",
"enabled": True
}
}]
}
rasanlu_intent = ""
skill = amock.CoroutineMock()
mock_connector = Connector({}, opsdroid=opsdroid)
match_rasanlu(rasanlu_intent)(skill)
message = Message(text="Hello",
user="******",
target="default",
connector=mock_connector)
with amock.patch("opsdroid.parsers.rasanlu.parse_rasanlu"):
tasks = await opsdroid.parse(message)
self.assertEqual(len(tasks), 2)
async def test_parse_dialogflow_raise_ClientOSError(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "dialogflow",
"access-token": "test",
"min-score": 0.8
}]
mock_skill = amock.CoroutineMock()
match_dialogflow_action("myaction")(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message("Hello world", "user", "default", mock_connector)
with amock.patch.object(dialogflow,
"call_dialogflow") as mocked_call:
mocked_call.side_effect = ClientOSError()
await dialogflow.parse_dialogflow(
opsdroid, opsdroid.skills, message,
opsdroid.config["parsers"][0])
self.assertFalse(mock_skill.called)
self.assertTrue(mocked_call.called)
async def test_respond_bad_response(self):
"""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 OpsDroid() as opsdroid, \
amock.patch('aiohttp.ClientSession.post',
new=asynctest.CoroutineMock()) as patched_request:
self.assertTrue(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")
self.assertTrue(patched_request.called)
self.assertTrue(post_response.text.called)
async def test_parse_witai_no_entity(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "witai",
"access-token": "test"
}]
mock_skill = amock.CoroutineMock()
match_witai("get_weather")(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message("hi", "user", "default", mock_connector)
with amock.patch.object(witai, "call_witai") as mocked_call_witai:
mocked_call_witai.return_value = {
"msg_id": "0MDw4dxgcoIyBZeVx",
"_text": "hi",
"entities": {},
}
await witai.parse_witai(opsdroid, opsdroid.skills, message,
opsdroid.config["parsers"][0])
self.assertFalse(mock_skill.called)
async def test_parse_witai_raises(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "witai",
"token": "test",
"min-score": 0.3
}]
mock_skill = await self.getRaisingMockSkill()
mock_skill.config = {"name": "mocked-skill"}
opsdroid.skills.append(match_witai("get_weather")(mock_skill))
mock_connector = amock.MagicMock()
mock_connector.send = amock.CoroutineMock()
message = Message(
text="how's the weather outside",
user="******",
target="default",
connector=mock_connector,
)
with amock.patch.object(witai, "call_witai") as mocked_call_witai:
mocked_call_witai.return_value = {
"msg_id": "0fI07qSgCwM79NEjs",
"_text": "how's the weather outside",
"entities": {
"intent": [{
"confidence": 0.99897986426571,
"value": "get_weather"
}]
},
}
skills = await witai.parse_witai(opsdroid, opsdroid.skills,
message,
opsdroid.config["parsers"][0])
self.assertEqual(mock_skill, skills[0]["skill"])
await opsdroid.run_skill(skills[0], skills[0]["skill"].config,
message)
self.assertLogs("_LOGGER", "exception")
async def test_parse_luisai_failure(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "luisai",
"appid": "test",
"appkey": "test",
"verbose": True
}]
mock_skill = amock.CoroutineMock()
match_luisai_intent("Calendar.Add")(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message("schedule meeting", "user", "default",
mock_connector)
with amock.patch.object(luisai,
"call_luisai") as mocked_call_luisai:
mocked_call_luisai.return_value = {"statusCode": 401}
skills = await luisai.parse_luisai(
opsdroid, opsdroid.skills, message,
opsdroid.config["parsers"][0])
self.assertFalse(skills)
async def test_parse_luisai_failure(self):
with OpsDroid() as opsdroid:
opsdroid.config['parsers'] = [{
'name': 'luisai',
'appid': 'test',
'appkey': 'test',
'verbose': True
}]
mock_skill = amock.CoroutineMock()
match_luisai_intent('Calendar.Add')(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message("user", "default", mock_connector,
"schedule meeting")
with amock.patch.object(luisai, 'call_luisai') as \
mocked_call_luisai:
mocked_call_luisai.return_value = {"statusCode": 401}
skills = await luisai.parse_luisai(
opsdroid, opsdroid.skills, message,
opsdroid.config['parsers'][0])
self.assertFalse(skills)
async def test_parse_sapcai_no_intent(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "sapcai",
"access-token": "test"
}]
mock_skill = await self.getMockSkill()
mock_skill.config = {"name": "greetings"}
opsdroid.skills.append(match_sapcai("greetings")(mock_skill))
mock_connector = amock.CoroutineMock()
message = Message("kdjiruetosakdg", "user", "default",
mock_connector)
with amock.patch.object(sapcai,
"call_sapcai") as mocked_call_sapcai:
mocked_call_sapcai.return_value = {
"results": {
"uuid": "e4b365be-815b-4e40-99c3-7a25583b4892",
"source": "kdjiruetosakdg",
"intents": [],
"act": "assert",
"type": None,
"sentiment": "neutral",
"entities": {},
"language": "en",
"processing_language": "en",
"version": "2.10.1",
"timestamp": "2017-11-15T07:32:42.641604+00:00",
"status": 200,
}
}
skills = await sapcai.parse_sapcai(
opsdroid, opsdroid.skills, message,
opsdroid.config["parsers"][0])
self.assertLogs("_LOGGER", "error")
self.assertFalse(skills)
async def test_parse_sapcai(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "sapcai",
"access-token": "test"
}]
mock_skill = await self.getMockSkill()
mock_skill.config = {"name": "greetings"}
opsdroid.skills.append(match_sapcai("greetings")(mock_skill))
mock_connector = amock.CoroutineMock()
message = Message("Hello" "user", "default", mock_connector)
with amock.patch.object(sapcai,
"call_sapcai") as mocked_call_sapcai:
mocked_call_sapcai.return_value = {
"results": {
"uuid": "f482bddd-a9d7-41ae-aae3-6e64ad3f02dc",
"source": "hello",
"intents": [{
"slug": "greetings",
"confidence": 0.99
}],
"act": "assert",
"type": None,
"sentiment": "vpositive",
"entities": {},
"language": "en",
"processing_language": "en",
"version": "2.10.1",
"timestamp": "2017-11-15T07:41:48.935990+00:00",
"status": 200,
}
}
skills = await sapcai.parse_sapcai(
opsdroid, opsdroid.skills, message,
opsdroid.config["parsers"][0])
self.assertEqual(mock_skill, skills[0]["skill"])
async def test_parse_luisai_low_score(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "luisai",
"appid": "test",
"appkey": "test",
"verbose": True,
"min-score": 0.95,
}]
mock_skill = amock.CoroutineMock()
match_luisai_intent("Calendar.Add")(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message(
text="schedule meeting",
user="******",
target="default",
connector=mock_connector,
)
with amock.patch.object(luisai,
"call_luisai") as mocked_call_luisai:
mocked_call_luisai.return_value = {
"query": "schedule meeting",
"topScoringIntent": {
"intent": "Calendar.Add",
"score": 0.900492251,
},
"intents": [{
"intent": "Calendar.Add",
"score": 0.900492251
}],
"entities": [],
}
await luisai.parse_luisai(opsdroid, opsdroid.skills, message,
opsdroid.config["parsers"][0])
self.assertFalse(mock_skill.called)
async def test_parse_sapcai_no_intent(self):
with OpsDroid() as opsdroid:
opsdroid.config['parsers'] = [{
'name': 'sapcai',
'access-token': "test"
}]
mock_skill = await self.getMockSkill()
mock_skill.config = {"name": "greetings"}
opsdroid.skills.append(match_sapcai('greetings')(mock_skill))
mock_connector = amock.CoroutineMock()
message = Message("kdjiruetosakdg", "user", "default",
mock_connector)
with amock.patch.object(sapcai, 'call_sapcai') as \
mocked_call_sapcai:
mocked_call_sapcai.return_value = {
'results': {
'uuid': 'e4b365be-815b-4e40-99c3-7a25583b4892',
'source': 'kdjiruetosakdg',
'intents': [],
'act': 'assert',
'type': None,
'sentiment': 'neutral',
'entities': {},
'language': 'en',
'processing_language': 'en',
'version': '2.10.1',
'timestamp': '2017-11-15T07:32:42.641604+00:00',
'status': 200
}
}
skills = await sapcai.parse_sapcai(
opsdroid, opsdroid.skills, message,
opsdroid.config['parsers'][0])
self.assertLogs('_LOGGER', 'error')
self.assertFalse(skills)
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_parse_witai_failure(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "witai",
"access-token": "test",
"min-score": 0.3
}]
mock_skill = amock.CoroutineMock()
match_witai("get_weather")(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message("how's the weather outside", "user", "default",
mock_connector)
with amock.patch.object(witai, "call_witai") as mocked_call_witai:
mocked_call_witai.return_value = {
"code": "auth",
"error": "missing or wrong auth token",
}
skills = await witai.parse_witai(opsdroid, opsdroid.skills,
message,
opsdroid.config["parsers"][0])
self.assertFalse(skills)
async def test_parse_sapcai_failure(self):
with OpsDroid() as opsdroid:
opsdroid.config['parsers'] = [{
'name': 'sapcai',
'access-token': "test"
}]
mock_skill = await self.getMockSkill()
mock_skill.config = {"name": "greetings"}
opsdroid.skills.append(match_sapcai('greetings')(mock_skill))
mock_connector = amock.CoroutineMock()
message = Message("", "user", "default", mock_connector)
with amock.patch.object(sapcai, 'call_sapcai') as \
mocked_call_sapcai:
mocked_call_sapcai.return_value = {
'results': None,
'message': 'Text is empty'
}
skills = await sapcai.parse_sapcai(
opsdroid, opsdroid.skills, message,
opsdroid.config['parsers'][0])
self.assertFalse(skills)
async def test_parse_rasanlu_no_entity(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{"name": "rasanlu", "token": "test"}]
mock_skill = amock.CoroutineMock()
match_rasanlu("get_weather")(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message(
text="hi", user="******", target="default", connector=mock_connector
)
with amock.patch.object(rasanlu, "call_rasanlu") as mocked_call_rasanlu:
mocked_call_rasanlu.return_value = {
"entities": [],
"intent": None,
"intent_ranking": [],
"text": "hi",
}
await rasanlu.parse_rasanlu(
opsdroid, opsdroid.skills, message, opsdroid.config["parsers"][0]
)
self.assertFalse(mock_skill.called)
async def test_parse_luisai_raise_ClientOSError(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "luisai",
"appid": "test",
"appkey": "test",
"verbose": True,
"min-score": 0.95,
}]
mock_skill = amock.CoroutineMock()
match_luisai_intent("Calendar.Add")(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message("schedule meeting", "user", "default",
mock_connector)
with amock.patch.object(luisai, "call_luisai") as mocked_call:
mocked_call.side_effect = ClientOSError()
await luisai.parse_luisai(opsdroid, opsdroid.skills, message,
opsdroid.config["parsers"][0])
self.assertFalse(mock_skill.called)
self.assertTrue(mocked_call.called)
async def test_parse_witai(self):
with OpsDroid() as opsdroid:
opsdroid.modules = {
"parsers": [{
"config": {
"name": "witai",
"enabled": True
}
}]
}
witai_intent = ""
skill = amock.CoroutineMock()
mock_connector = Connector({}, opsdroid=opsdroid)
match_witai(witai_intent)(skill)
message = Message(
text="Hello world",
user="******",
target="default",
connector=mock_connector,
)
with amock.patch("opsdroid.parsers.witai.parse_witai"):
tasks = await opsdroid.parse(message)
self.assertEqual(len(tasks), 3)
async def test_call_dialogflow(self):
opsdroid = amock.CoroutineMock()
mock_connector = Connector({}, opsdroid=opsdroid)
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 = asyncio.Future()
patched_request.return_value.set_result(result)
await dialogflow.call_dialogflow(message, config)
self.assertTrue(patched_request.called)
async def test_parse_sapcai_failure(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "sapcai",
"access-token": "test"
}]
mock_skill = await self.getMockSkill()
mock_skill.config = {"name": "greetings"}
opsdroid.skills.append(match_sapcai("greetings")(mock_skill))
mock_connector = amock.CoroutineMock()
message = Message("", "user", "default", mock_connector)
with amock.patch.object(sapcai,
"call_sapcai") as mocked_call_sapcai:
mocked_call_sapcai.return_value = {
"results": None,
"message": "Text is empty",
}
skills = await sapcai.parse_sapcai(
opsdroid, opsdroid.skills, message,
opsdroid.config["parsers"][0])
self.assertFalse(skills)
async def test_respond_bot_short(opsdroid):
opsdroid = amock.CoroutineMock()
connector = ConnectorGitHub({
"name": "github",
"token": "test"
},
opsdroid=opsdroid)
with amock.patch("aiohttp.ClientSession.post") as patched_request:
mockresponse = amock.CoroutineMock()
mockresponse.status = 201
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(mockresponse)
connector.github_username = "******"
resp = await connector.send(
Message(
text="test",
user="******",
target="opsdroid/opsdroid#1",
connector=connector,
))
assert not patched_request.called
assert resp
async def test_call_witai(self):
opsdroid = amock.CoroutineMock()
mock_connector = Connector({}, opsdroid=opsdroid)
message = Message("user", "default", mock_connector,
"how's the weather outside")
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_parse_witai_failure(self):
with OpsDroid() as opsdroid:
opsdroid.config['parsers'] = [{
'name': 'witai',
'access-token': 'test',
'min-score': 0.3
}]
mock_skill = amock.CoroutineMock()
match_witai('get_weather')(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message("user", "default", mock_connector,
"how's the weather outside")
with amock.patch.object(witai, 'call_witai') as mocked_call_witai:
mocked_call_witai.return_value = {
"code": "auth",
"error": "missing or wrong auth token"
}
skills = await witai.parse_witai(opsdroid, opsdroid.skills,
message,
opsdroid.config['parsers'][0])
self.assertFalse(skills)
async def test_send_message_bad_status(opsdroid, caplog):
caplog.set_level(logging.DEBUG)
connector = ConnectorGitlab(
{
"webhook-token": "secret-stuff!",
"token": "my-token"
},
opsdroid=opsdroid,
)
response = amock.Mock()
response.status = 422
with amock.patch("aiohttp.ClientSession.post",
new=amock.CoroutineMock()) as patched_request:
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(response)
assert opsdroid.__class__.instances
test_message = Message(
text="This is a test",
user="******",
target=ISSUE_TARGET,
connector=connector,
)
patched_request.return_value = asyncio.Future()
patched_request.return_value.set_result(response)
result = await connector.send(test_message)
assert patched_request.called
assert "Responding via Gitlab" in caplog.text
assert "Unable to send 'This is a test' to GitLab." in caplog.text
assert result is False
async def github_message_handler(self, request):
"""Handle event from GitHub."""
req = await request.post()
payload = json.loads(req["payload"])
try:
if payload["action"] == "created" and "comment" in payload:
issue_number = payload["issue"]["number"]
body = payload["comment"]["body"]
elif payload["action"] == "opened" and "issue" in payload:
issue_number = payload["issue"]["number"]
body = payload["issue"]["body"]
elif payload["action"] == "opened" and "pull_request" in payload:
issue_number = payload["pull_request"]["number"]
body = payload["pull_request"]["body"]
else:
_LOGGER.debug(_("No message to respond to."))
_LOGGER.debug(payload)
return aiohttp.web.Response(
text=json.dumps("No message to respond to."), status=200)
issue = "{}/{}#{}".format(
payload["repository"]["owner"]["login"],
payload["repository"]["name"],
issue_number,
)
message = Message(
text=body,
user=payload["sender"]["login"],
target=issue,
connector=self,
raw_event=payload,
)
await self.opsdroid.parse(message)
except KeyError as error:
_LOGGER.error(_("Key %s not found in payload"), error)
_LOGGER.debug(payload)
return aiohttp.web.Response(text=json.dumps("Received"), status=201)
async def websocket_handler(self, request):
"""Handle for aiohttp handling websocket connections."""
socket = request.match_info.get('socket')
available = [
item for item in self.available_connections if item["id"] == socket
]
if len(available) != 1:
return aiohttp.web.Response(
text=json.dumps("Please request a socket first"),
headers=HEADERS,
status=400)
if (datetime.now() - available[0]["date"]).total_seconds() \
> self.connection_timeout:
self.available_connections.remove(available[0])
return aiohttp.web.Response(
text=json.dumps("Socket request timed out"),
headers=HEADERS,
status=408)
self.available_connections.remove(available[0])
_LOGGER.debug("User connected to %s", socket)
websocket = aiohttp.web.WebSocketResponse()
await websocket.prepare(request)
self.active_connections[socket] = websocket
async for msg in websocket:
if msg.type == aiohttp.WSMsgType.TEXT:
message = Message(msg.data, None, None, self)
await self.opsdroid.parse(message)
elif msg.type == aiohttp.WSMsgType.ERROR:
_LOGGER.error('Websocket connection closed with exception %s',
websocket.exception())
_LOGGER.info('websocket connection closed')
self.active_connections.pop(socket, None)
return websocket
async def test_parse_sapcai_low_score(self):
with OpsDroid() as opsdroid:
opsdroid.config['parsers'] = [{
'name': 'sapcai',
'access-token': "test",
"min-score": 1.0
}]
mock_skill = await self.getMockSkill()
mock_skill.config = {"name": "greetings"}
opsdroid.skills.append(match_sapcai('intent')(mock_skill))
mock_connector = amock.CoroutineMock()
message = Message("Hello", "user", "default", mock_connector)
with amock.patch.object(sapcai, 'call_sapcai') as \
mocked_call_sapcai:
mocked_call_sapcai.return_value = {
'results': {
"uuid": "f482bddd-a9d7-41ae-aae3-6e64ad3f02dc",
"source": "hello",
"intents": [{
"slug": "greetings",
"confidence": 0.99
}],
"act": "assert",
"type": None,
"sentiment": "vpositive",
"entities": {},
"language": "en",
"processing_language": "en",
"version": "2.10.1",
"timestamp": "2017-11-15T07:41:48.935990+00:00",
"status": 200
}
}
await sapcai.parse_sapcai(opsdroid, opsdroid.skills, message,
opsdroid.config['parsers'][0])
async def test_parse_witai_no_intent(self):
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [
{"name": "witai", "access-token": "test", "min-score": 0.3}
]
mock_skill = amock.CoroutineMock()
match_witai("get_weather")(mock_skill)
mock_connector = amock.CoroutineMock()
message = Message(
"how's the weather outside", "user", "default", mock_connector
)
with amock.patch.object(witai, "call_witai") as mocked_call_witai:
mocked_call_witai.return_value = {
"msg_id": "0fI07qSgCwM79NEjs",
"_text": "Book an appointment for today",
"entities": {"test": [{"value": "test"}]},
}
await witai.parse_witai(
opsdroid, opsdroid.skills, message, opsdroid.config["parsers"][0]
)
self.assertFalse(mock_skill.called)
async def webexteams_message_handler(self, request):
"""Handle webhooks from the Webex Teams api."""
_LOGGER.debug("Handling message from Webex Teams")
req_data = await request.json()
_LOGGER.debug(req_data)
msg = self.api.messages.get(req_data["data"]["id"])
if req_data["data"]["personId"] != self.bot_webex_id:
person = await self.get_person(req_data["data"]["personId"])
try:
message = Message(
msg.text,
person.displayName,
{"id": msg.roomId, "type": msg.roomType},
self,
)
await self.opsdroid.parse(message)
except KeyError as error:
_LOGGER.error(error)
return aiohttp.web.Response(text=json.dumps("Received"), status=201)
async def test_parse_dialogflow(self):
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "path/test.json"
with OpsDroid() as opsdroid:
opsdroid.config["parsers"] = [{
"name": "dialogflow",
"project-id": "test"
}]
dialogflow_action = "smalltalk.greetings.whatsup"
skill = amock.CoroutineMock()
mock_connector = Connector({}, opsdroid=opsdroid)
match_dialogflow_action(dialogflow_action)(skill)
message = Message("Hello world", "user", "default", mock_connector)
with amock.patch(
"opsdroid.parsers.dialogflow.parse_dialogflow"
), amock.patch("opsdroid.parsers.dialogflow.call_dialogflow"):
tasks = await opsdroid.parse(message)
self.assertEqual(len(tasks), 1)
tasks = await opsdroid.parse(message)
self.assertLogs("_LOGGER", "warning")
# But leave this bit
for task in tasks:
await task