async def test_facebook_message_handler(opsdroid):
"""Test the new facebook message handler."""
import aiohttp
connector = ConnectorFacebook({}, opsdroid=opsdroid)
req_ob = {
"object":
"page",
"entry": [{
"messaging": [{
"message": {
"text": "Hello"
},
"sender": {
"id": "1234567890"
}
}]
}],
}
mock_request = amock.CoroutineMock()
mock_request.json = amock.CoroutineMock()
mock_request.json.return_value = req_ob
connector.opsdroid = opsdroid
connector.opsdroid.parse = amock.CoroutineMock()
response = await connector.facebook_message_handler(mock_request)
assert connector.opsdroid.parse.called
assert isinstance(response, aiohttp.web.Response)
assert response.status == 200
async def test_facebook_message_handler_invalid(self):
"""Test the new facebook message handler for invalid message."""
import aiohttp
opsdroid = amock.CoroutineMock()
connector = ConnectorFacebook({}, opsdroid=opsdroid)
req_ob = {
"object": "page",
"entry": [{
"messaging": [{
"message": {"text": "Hello"},
"sender": {}
}]
}]
}
mock_request = amock.CoroutineMock()
mock_request.json = amock.CoroutineMock()
mock_request.json.return_value = req_ob
with OpsDroid() as opsdroid:
connector.opsdroid = opsdroid
connector.opsdroid.parse = amock.CoroutineMock()
response = await connector.facebook_message_handler(mock_request)
self.assertFalse(connector.opsdroid.parse.called)
self.assertLogs('_LOGGER', 'error')
self.assertEqual(type(response), aiohttp.web.Response)
self.assertEqual(response.status, 200)
async def test_facebook_message_handler_invalid(opsdroid, caplog):
"""Test the new facebook message handler for invalid message."""
import aiohttp
connector = ConnectorFacebook({}, opsdroid=opsdroid)
req_ob = {
"object": "page",
"entry": [{
"messaging": [{
"message": {
"text": "Hello"
},
"sender": {}
}]
}],
}
mock_request = amock.CoroutineMock()
mock_request.json = amock.CoroutineMock()
mock_request.json.return_value = req_ob
connector.opsdroid = opsdroid
connector.opsdroid.parse = amock.CoroutineMock()
response = await connector.facebook_message_handler(mock_request)
assert not connector.opsdroid.parse.called
assert "Unable to process message." in caplog.text
assert isinstance(response, aiohttp.web.Response)
assert response.status == 200
async def test_facebook_message_handler(self):
"""Test the new facebook message handler."""
import aiohttp
connector = ConnectorFacebook({})
req_ob = {
"object":
"page",
"entry": [{
"messaging": [{
"message": {
"text": "Hello"
},
"sender": {
"id": '1234567890'
}
}]
}]
}
mock_request = amock.CoroutineMock()
mock_request.json = amock.CoroutineMock()
mock_request.json.return_value = req_ob
with OpsDroid() as opsdroid:
connector.opsdroid = opsdroid
connector.opsdroid.parse = amock.CoroutineMock()
response = await connector.facebook_message_handler(mock_request)
self.assertTrue(connector.opsdroid.parse.called)
self.assertEqual(type(response), aiohttp.web.Response)
self.assertEqual(response.status, 200)
async def test_facebook_message_handler_invalid(self):
"""Test the new facebook message handler for invalid message."""
import aiohttp
connector = ConnectorFacebook({})
req_ob = {
"object":
"page",
"entry": [{
"messaging": [{
"message": {
"text": "Hello"
},
"sender": {}
}]
}]
}
mock_request = amock.CoroutineMock()
mock_request.json = amock.CoroutineMock()
mock_request.json.return_value = req_ob
with OpsDroid() as opsdroid, \
amock.patch('opsdroid.connector.facebook._LOGGER.error') \
as logmock:
connector.opsdroid = opsdroid
connector.opsdroid.parse = amock.CoroutineMock()
response = await connector.facebook_message_handler(mock_request)
self.assertFalse(connector.opsdroid.parse.called)
self.assertTrue(logmock.called)
self.assertEqual(type(response), aiohttp.web.Response)
self.assertEqual(response.status, 200)
async def test_facebook_challenge_handler(self):
"""Test the facebook challenge handler."""
import aiohttp
opsdroid = amock.CoroutineMock()
connector = ConnectorFacebook({"verify-token": "token_123"},
opsdroid=opsdroid)
mock_request = amock.Mock()
mock_request.query = {
"hub.verify_token": "token_123",
"hub.challenge": "challenge_123",
}
response = await connector.facebook_challenge_handler(mock_request)
self.assertEqual(type(response), aiohttp.web.Response)
self.assertEqual(response.text, "challenge_123")
self.assertEqual(response.status, 200)
mock_request.query = {
"hub.verify_token": "token_abc",
"hub.challenge": "challenge_123",
}
response = await connector.facebook_challenge_handler(mock_request)
self.assertEqual(type(response), aiohttp.web.Response)
self.assertEqual(response.status, 403)
async def test_connect(opsdroid):
"""Test the connect method adds the handlers."""
connector = ConnectorFacebook({}, opsdroid=opsdroid)
opsdroid.web_server = amock.CoroutineMock()
opsdroid.web_server.web_app = amock.CoroutineMock()
opsdroid.web_server.web_app.router = amock.CoroutineMock()
opsdroid.web_server.web_app.router.add_get = amock.CoroutineMock()
opsdroid.web_server.web_app.router.add_post = amock.CoroutineMock()
await connector.connect()
assert opsdroid.web_server.web_app.router.add_get.called
assert opsdroid.web_server.web_app.router.add_post.called
async def test_respond(opsdroid):
"""Test that responding sends a message."""
post_response = amock.Mock()
post_response.status = 200
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
async def test_respond(self):
"""Test that responding sends a message."""
post_response = amock.Mock()
post_response.status = 200
with OpsDroid() as opsdroid, \
amock.patch('aiohttp.ClientSession.post',
new=asynctest.CoroutineMock()) as patched_request:
self.assertTrue(opsdroid.__class__.instances)
connector = ConnectorFacebook({})
room = "a146f52c-548a-11e8-a7d1-28cfe949e12d"
test_message = Message(text="Hello world",
user="******",
room=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)
async def test_facebook_challenge_handler(self):
"""Test the facebook challenge handler."""
import aiohttp
connector = ConnectorFacebook({'verify-token': 'token_123'})
mock_request = amock.Mock()
mock_request.query = {
"hub.verify_token": 'token_123',
'hub.challenge': 'challenge_123'
}
response = await connector.facebook_challenge_handler(mock_request)
self.assertEqual(type(response), aiohttp.web.Response)
self.assertEqual(response.text, 'challenge_123')
self.assertEqual(response.status, 200)
mock_request.query = {
"hub.verify_token": 'token_abc',
'hub.challenge': 'challenge_123'
}
response = await connector.facebook_challenge_handler(mock_request)
self.assertEqual(type(response), aiohttp.web.Response)
self.assertEqual(response.status, 403)
async def test_facebook_challenge_handler(opsdroid):
"""Test the facebook challenge handler."""
import aiohttp
connector = ConnectorFacebook({"verify-token": "token_123"},
opsdroid=opsdroid)
mock_request = amock.Mock()
mock_request.query = {
"hub.verify_token": "token_123",
"hub.challenge": "challenge_123",
}
response = await connector.facebook_challenge_handler(mock_request)
assert isinstance(response, aiohttp.web.Response)
assert response.text == "challenge_123"
assert response.status == 200
mock_request.query = {
"hub.verify_token": "token_abc",
"hub.challenge": "challenge_123",
}
response = await connector.facebook_challenge_handler(mock_request)
assert isinstance(response, aiohttp.web.Response)
assert response.status == 403
def test_property(opsdroid):
connector = ConnectorFacebook({}, opsdroid=opsdroid)
assert connector.name == "facebook"
async def test_listen(self):
"""Test that listen does nothing."""
opsdroid = amock.CoroutineMock()
connector = ConnectorFacebook({}, opsdroid=opsdroid)
await connector.listen()
def test_init(self):
connector = ConnectorFacebook({})
self.assertEqual(None, connector.default_room)
self.assertEqual("facebook", connector.name)
def test_property(self):
connector = ConnectorFacebook({})
self.assertEqual("facebook", connector.name)
def test_init(opsdroid):
connector = ConnectorFacebook({}, opsdroid=opsdroid)
assert connector.default_target is None
assert connector.name == "facebook"
async def test_listen(self):
"""Test that listen does nothing."""
connector = ConnectorFacebook({})
await connector.listen(None)
async def test_listen(opsdroid):
"""Test that listen does nothing."""
connector = ConnectorFacebook({}, opsdroid=opsdroid)
await connector.listen()
assert True # Listen should not block and return immediately
def test_property(self):
opsdroid = amock.CoroutineMock()
connector = ConnectorFacebook({}, opsdroid=opsdroid)
self.assertEqual("facebook", connector.name)
def test_init(self):
opsdroid = amock.CoroutineMock()
connector = ConnectorFacebook({}, opsdroid=opsdroid)
self.assertEqual(None, connector.default_target)
self.assertEqual("facebook", connector.name)
