def test_mqtt_get_payload(self):
"""
Test MQTT backend get_payload function
"""
from_user = _create_user('Bob')
to_user = _create_user('Alice')
instance = _create_message(from_user, to_user, 'I love oov')
payload = {
'id': instance.id,
'time': instance.timestamp.isoformat(),
'payload': {
'author': {
'username': from_user.username,
'real_name': from_user.get_full_name()
},
'context': {
'type': to_user._meta.model_name,
'metadata': {
'id': to_user.pk,
'name': to_user.get_full_name()
}
},
'message': "I love oov"
}
}
self.assertEqual(json.dumps(payload), get_payload(instance))
def test_mqtt_send(self, mocked):
"""
Test MQTT Backend send method
"""
from_user = _create_user('Bob')
to_user = _create_user('Alice')
instance = _create_message(from_user, to_user, 'I love oov')
mqtt = MQTTBackend(
options={
'HOST': 'localhost',
'PORT': 8883,
'SECURE': True,
'CA_CERT_FILE': 'cacert.pem',
'CERT_FILE': 'emq.pem',
'KEY_FILE': 'emq.key'
})
mqtt.send(instance=instance)
self.assertTrue(mocked.called)
args, kwargs = mocked.call_args_list[0]
self.assertEquals(mqtt.get_topic(instance), args[0])
self.assertEquals(get_payload(instance), kwargs['payload'])
self.assertEquals('localhost', kwargs['hostname'])
self.assertEquals(8883, kwargs['port'])
self.assertEquals(0, kwargs['qos'])
self.assertEquals(False, kwargs['retain'])
self.assertDictEqual(
dict(ca_certs='cacert.pem',
certfile='emq.pem',
keyfile='emq.key',
tls_version=ssl.PROTOCOL_TLSv1_2,
cert_reqs=ssl.CERT_NONE), kwargs['tls'])
def test_mqtt_send(self, mocked):
"""
Test MQTT Backend send method
"""
from_user = _create_user('Bob')
to_user = _create_user('Alice')
instance = _create_message(from_user, to_user, 'I love oov')
mqtt = MQTTBackend(options={
'HOST': 'localhost',
'PORT': 8883,
'SECURE': True,
'CA_CERT_FILE': 'cacert.pem',
'CERT_FILE': 'emq.pem',
'KEY_FILE': 'emq.key'
})
mqtt.send(instance=instance)
self.assertTrue(mocked.called)
args, kwargs = mocked.call_args_list[0]
self.assertEquals(mqtt.get_topic(instance), args[0])
self.assertEquals(get_payload(instance), kwargs['payload'])
self.assertEquals('localhost', kwargs['hostname'])
self.assertEquals(8883, kwargs['port'])
self.assertEquals(0, kwargs['qos'])
self.assertEquals(False, kwargs['retain'])
self.assertDictEqual(
dict(ca_certs='cacert.pem',
certfile='emq.pem',
keyfile='emq.key',
tls_version=ssl.PROTOCOL_TLSv1_2,
cert_reqs=ssl.CERT_NONE),
kwargs['tls'])
def test_mqtt_get_payload(self):
"""
Test MQTT backend get_payload function
"""
from_user = _create_user('Bob')
to_user = _create_user('Alice')
instance = _create_message(from_user, to_user, 'I love oov')
payload = {
'id': instance.id,
'time': instance.timestamp.isoformat(),
'payload': {
'author': {
'username': from_user.username,
'real_name': from_user.get_full_name()
},
'context': {
'type': to_user._meta.model_name,
'metadata': {
'id': to_user.pk,
'name': to_user.get_full_name()
}
},
'message': "I love oov"
}
}
self.assertEqual(json.dumps(payload), get_payload(instance))
def test_call_backend(self):
"""
Test messaging call_backend task.
"""
from_user = _create_user('Bob')
to_user = _create_user('Alice')
instance = _create_message(from_user, to_user, 'I love oov')
with self.assertRaises(NotImplementedError):
call_backend('onadata.apps.messaging.backends.base.BaseBackend',
instance.id, {'HOST': 'localhost'})
def test_call_backend(self):
"""
Test messaging call_backend task.
"""
from_user = _create_user('Bob')
to_user = _create_user('Alice')
instance = _create_message(from_user, to_user, 'I love oov')
with self.assertRaises(NotImplementedError):
call_backend('onadata.apps.messaging.backends.base.BaseBackend',
instance.id, {'HOST': 'localhost'})
def test_call_backend_async(self):
"""
Test messaging call_backend_async task.
"""
from_user = _create_user('Bob')
to_user = _create_user('Alice')
instance = _create_message(from_user, to_user, 'I love oov')
with self.assertRaises(NotImplementedError):
call_backend_async.delay(
backend='onadata.apps.messaging.backends.base.BaseBackend',
instance_id=instance.id,
backend_options=None).get()
def test_mqtt_get_topic(self):
"""
Test MQTT backend get_topic method
"""
from_user = _create_user('Bob')
to_user = _create_user('Alice')
instance = _create_message(from_user, to_user, 'I love oov')
mqtt = MQTTBackend(options={'HOST': 'localhost'})
expected = (
"/{topic_root}/{target_name}/{target_id}/messages/publish".format(
topic_root='onadata', target_name='user',
target_id=to_user.id))
self.assertEqual(expected, mqtt.get_topic(instance))
def test_mqtt_get_topic(self):
"""
Test MQTT backend get_topic method
"""
from_user = _create_user('Bob')
to_user = _create_user('Alice')
instance = _create_message(from_user, to_user, 'I love oov')
mqtt = MQTTBackend(options={'HOST': 'localhost'})
expected = (
"/{topic_root}/{target_name}/{target_id}/messages/publish".format(
topic_root='onadata', target_name='user',
target_id=to_user.id))
self.assertEqual(expected, mqtt.get_topic(instance))
def test_call_backend_async(self):
"""
Test messaging call_backend_async task.
"""
from_user = _create_user('Bob')
to_user = _create_user('Alice')
instance = _create_message(from_user, to_user, 'I love oov')
with self.assertRaises(NotImplementedError):
call_backend_async.delay(
backend='onadata.apps.messaging.backends.base.BaseBackend',
instance_id=instance.id,
backend_options=None).get()
def test_get_target_metadata(self):
"""
Test MQTT backend get_target_metadata function
"""
# User objects
user = _create_user('John')
user_metadata = {'id': user.pk, 'name': user.get_full_name()}
self.assertEqual(
json.dumps(user_metadata), json.dumps(get_target_metadata(user)))
# XForm objects
xform = MagicMock()
xform.pk = 1337
xform.title = 'Test Form'
xform.id_string = 'Test_Form_ID'
xform._meta.model_name = XFORM
xform_metadata = {
'id': 1337,
'name': 'Test Form',
'form_id': 'Test_Form_ID'
}
self.assertEqual(
json.dumps(xform_metadata), json.dumps(get_target_metadata(xform)))
# Project objects
project = MagicMock()
project.pk = 7331
project.name = 'Test Project'
project._meta.model_name = PROJECT
project_metadata = {'id': 7331, 'name': 'Test Project'}
self.assertEqual(
json.dumps(project_metadata),
json.dumps(get_target_metadata(project)))
def test_get_target_metadata(self):
"""
Test MQTT backend get_target_metadata function
"""
# User objects
user = _create_user('John')
user_metadata = {'id': user.pk, 'name': user.get_full_name()}
self.assertEqual(json.dumps(user_metadata),
json.dumps(get_target_metadata(user)))
# XForm objects
xform = MagicMock()
xform.pk = 1337
xform.title = 'Test Form'
xform.id_string = 'Test_Form_ID'
xform._meta.model_name = XFORM
xform_metadata = {
'id': 1337,
'name': 'Test Form',
'form_id': 'Test_Form_ID'
}
self.assertEqual(json.dumps(xform_metadata),
json.dumps(get_target_metadata(xform)))
# Project objects
project = MagicMock()
project.pk = 7331
project.name = 'Test Project'
project._meta.model_name = PROJECT
project_metadata = {'id': 7331, 'name': 'Test Project'}
self.assertEqual(json.dumps(project_metadata),
json.dumps(get_target_metadata(project)))
def test_retrieve_permissions(self):
"""
Test that correct permissions are required when retrieving a message
"""
user = _create_user()
other_user = _create_user('anotheruser')
message_data = self._create_message(user)
view = MessagingViewSet.as_view({'get': 'retrieve'})
request = self.factory.get('/messaging/{}'.format(message_data['id']))
force_authenticate(request, user=other_user)
response = view(request=request, pk=message_data['id'])
self.assertEqual(response.status_code, 403)
request = self.factory.get('/messaging/{}'.format(message_data['id']))
force_authenticate(request, user=user)
response = view(request=request, pk=message_data['id'])
self.assertEqual(response.status_code, 200)
def test_delete_message(self):
"""
Test DELETE /messaging/[pk] deleting a message.
"""
user = _create_user()
message_data = self._create_message(user)
view = MessagingViewSet.as_view({'delete': 'destroy'})
request = self.factory.delete('/messaging/%s' % message_data['id'])
force_authenticate(request, user=user)
response = view(request=request, pk=message_data['id'])
self.assertEqual(response.status_code, 204)
self.assertFalse(Action.objects.filter(pk=message_data['id']).exists())
def test_retrieve_message(self):
"""
Test GET /messaging/[pk] return a message matching pk.
"""
user = _create_user()
message_data = self._create_message(user)
view = MessagingViewSet.as_view({'get': 'retrieve'})
request = self.factory.get('/messaging/{}'.format(message_data['id']))
force_authenticate(request, user=user)
response = view(request=request, pk=message_data['id'])
self.assertEqual(response.status_code, 200)
self.assertDictEqual(response.data, message_data)
def test_target_does_not_exist(self):
"""
Test POST /messaging adding a new message for a specific form with a
target that does not exist.
"""
user = _create_user()
view = MessagingViewSet.as_view({'post': 'create'})
data = {
"message": "Hello World!",
"target_id": 1000000000,
"target_type": 'user',
} # yapf: disable
request = self.factory.post('/messaging', data)
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 400, response.data)
self.assertEqual(response.data['target_id'], 'target_id not found')
def _create_message(self, user=None):
"""
Helper to create a single message
"""
if not user:
user = _create_user()
assign_perm('auth.change_user', user, user)
view = MessagingViewSet.as_view({'post': 'create'})
data = {
"message": "Hello World!",
"target_id": user.pk,
"target_type": 'user',
} # yapf: disable
request = self.factory.post('/messaging', data)
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 201, response.data)
self.assertDictContainsSubset(data, response.data)
# ensure that id and timestamp are returned
self.assertTrue(
'id' and 'timestamp' in [text(x) for x in list(response.data)])
return response.data
def test_create_permissions(self):
"""
Test that correct permissions are required to create a message.
"""
user = _create_user()
data = {
"message": "Hello World!",
"target_id": user.pk,
"target_type": 'user',
} # yapf: disable
view = MessagingViewSet.as_view({'post': 'create'})
request = self.factory.post('/messaging', data)
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 403)
self.assertIn(u'You do not have permission', response.data['detail'])
# assign add_user permissions
assign_perm('auth.change_user', user, user)
request = self.factory.post('/messaging', data)
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 201)
def test_list_messages(self):
"""
Test GET /messaging listing of messages for specific forms.
"""
user = _create_user()
message_data = self._create_message(user)
target_id = message_data['target_id']
view = MessagingViewSet.as_view({'get': 'list'})
# return data only when a target_type is provided
request = self.factory.get('/messaging', {
'target_type': 'user',
'target_id': target_id
})
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, [message_data])
# returns empty list when a target type does not have any records
request = self.factory.get('/messaging', {
'target_type': 'xform',
'target_id': target_id
})
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, [])
# return status 400 if both target_type and target_id are misssing
request = self.factory.get('/messaging')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 400)
# returns 400 status when a target_id is missing
request = self.factory.get('/messaging', {'target_type': 'user'})
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data,
{u'detail': u"Parameter 'target_id' is missing."})
# returns 400 status when a target_type is missing
request = self.factory.get('/messaging', {'target_id': target_id})
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data,
{u'detail': u"Parameter 'target_type' is missing."})
# returns 400 status when a target type is not known
request = self.factory.get('/messaging', {
'target_type': 'xyz',
'target_id': target_id
})
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data,
{u'detail': u'Unknown target_type xyz'})
def test_messaging_timestamp_filter(self):
"""
Test that a user is able to filter messages using the timestamp
"""
user = _create_user()
message_one = self._create_message(user)
message_two = self._create_message(user)
view = MessagingViewSet.as_view({'get': 'list'})
message_one_timestamp = message_one['timestamp']
target_id = user.id
request = self.factory.get(
f'/messaging?timestamp={message_one_timestamp}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0].get('id'), message_one['id'])
# Test able to filter using gt & gte lookups
request = self.factory.get(
f'/messaging?timestamp__gt={message_one_timestamp}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0].get('id'), message_two['id'])
request = self.factory.get(
f'/messaging?timestamp__gte={message_one_timestamp}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
# Test able to filter using lt & lte lookups
message_two_timestamp = message_two['timestamp']
request = self.factory.get(
f'/messaging?timestamp__lt={message_two_timestamp}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0].get('id'), message_one['id'])
message_two_timestamp = message_two['timestamp']
request = self.factory.get(
f'/messaging?timestamp__lte={message_two_timestamp}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
# Test able to use day filters
day = Action.objects.get(id=message_one['id']).timestamp.day
request = self.factory.get(f'/messaging?timestamp__day={day}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
request = self.factory.get(f'/messaging?timestamp__day__gt={day}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
request = self.factory.get(f'/messaging?timestamp__day__gte={day}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
request = self.factory.get(f'/messaging?timestamp__day__lt={day}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
request = self.factory.get(f'/messaging?timestamp__day__lte={day}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
# Test able to use month filters
month = Action.objects.get(id=message_one['id']).timestamp.month
request = self.factory.get(f'/messaging?timestamp__month={month}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
request = self.factory.get(f'/messaging?timestamp__month__gt={month}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
request = self.factory.get(f'/messaging?timestamp__month__gte={month}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
request = self.factory.get(f'/messaging?timestamp__month__lt={month}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
request = self.factory.get(f'/messaging?timestamp__month__lte={month}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
# Test able to use year filters
year = Action.objects.get(id=message_one['id']).timestamp.year
request = self.factory.get(f'/messaging?timestamp__year={year}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
request = self.factory.get(f'/messaging?timestamp__year__gt={year}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
request = self.factory.get(f'/messaging?timestamp__year__gte={year}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
request = self.factory.get(f'/messaging?timestamp__year__lt={year}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
request = self.factory.get(f'/messaging?timestamp__year__lte={year}&'
f'target_type=user&target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
# Test able to use hour & minute filters
hour = Action.objects.get(id=message_one['id']).timestamp.hour
minute = Action.objects.get(id=message_one['id']).timestamp.minute
request = self.factory.get(
f'/messaging?timestamp__hour={hour}&target_type=user&'
f'target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
request = self.factory.get(
f'/messaging?timestamp__hour__lt={hour}&target_type=user&'
f'target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
request = self.factory.get(
f'/messaging?timestamp__hour__gt={hour}&target_type=user&'
f'target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
request = self.factory.get(
f'/messaging?timestamp__hour__lte={hour}&target_type=user&'
f'target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
request = self.factory.get(
f'/messaging?timestamp__hour__gte={hour}&target_type=user&'
f'target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
request = self.factory.get(
f'/messaging?timestamp__minute__gt={minute}&target_type=user&'
f'target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
request = self.factory.get(
f'/messaging?timestamp__minute__lt={minute}&target_type=user&'
f'target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
request = self.factory.get(
f'/messaging?timestamp__minute__gte={minute}&target_type=user&'
f'target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
request = self.factory.get(
f'/messaging?timestamp__minute__lte={minute}&target_type=user&'
f'target_id={target_id}')
force_authenticate(request, user=user)
response = view(request=request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
