/
test_alert_endpoint.py
175 lines (140 loc) · 8.04 KB
/
test_alert_endpoint.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
import requests
from mock import MagicMock
from eums.models import ReleaseOrderItem, Flow, Question
from eums.models.alert import Alert
from eums.test.api.authorization.authenticated_api_test_case import AuthenticatedAPITestCase
from eums.test.config import BACKEND_URL
from eums.test.factories.alert_factory import AlertFactory
from eums.test.factories.answer_factory import TextAnswerFactory
from eums.test.factories.delivery_factory import DeliveryFactory
from eums.test.factories.delivery_node_factory import DeliveryNodeFactory
from eums.test.factories.flow_factory import FlowFactory
from eums.test.factories.question_factory import TextQuestionFactory
from eums.test.factories.run_factory import RunFactory
from eums.test.factories.runnable_factory import RunnableFactory
ENDPOINT_URL = BACKEND_URL + 'alert/'
class AlertEndpointTest(AuthenticatedAPITestCase):
def setUp(self):
self.flow_ip = FlowFactory(label=Flow.Label.IMPLEMENTING_PARTNER)
FlowFactory(label=Flow.Label.END_USER)
FlowFactory(label=Flow.Label.MIDDLE_MAN)
super(AlertEndpointTest, self).setUp()
def test_should_return_information_on_an_alert(self):
contact_id = '54335c56b3ae9d92f038abb0'
runnable = DeliveryFactory(contact_person_id=contact_id)
AlertFactory(
order_type=ReleaseOrderItem.WAYBILL,
order_number=123456,
issue=Alert.ISSUE_TYPES.not_received,
is_resolved=False,
remarks='some remarks',
consignee_name='wakiso',
item_description="some description",
runnable=runnable)
fake_contact = {'firstName': "test", 'lastName': "user1", 'phone': "+256 782 443439", '_id': contact_id}
response = MagicMock(json=MagicMock(return_value=fake_contact), status_code=200)
requests.get = MagicMock(return_value=response)
response = self.client.get('%s?type=delivery' % ENDPOINT_URL)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
first_alert = response.data[0]
self.assertIsNotNone(first_alert['id'])
self.assertEqual(first_alert['order_type'], ReleaseOrderItem.WAYBILL)
self.assertEqual(first_alert['order_number'], 123456)
self.assertEqual(first_alert['issue'], Alert.ISSUE_TYPES.not_received)
self.assertEqual(first_alert['is_resolved'], False)
self.assertEqual(first_alert['remarks'], 'some remarks')
self.assertEqual(first_alert['consignee_name'], 'wakiso')
self.assertEqual(first_alert['item_description'], 'some description')
self.assertEqual(first_alert['issue_display_name'], Alert.ISSUE_TYPES[Alert.ISSUE_TYPES.not_received])
self.assertEqual(first_alert['contact'], {'contact_name': 'test user1', 'contact_phone': '+256 782 443439'})
def test_should_return_multiple_alerts_when_multiple_exist(self):
AlertFactory()
AlertFactory()
AlertFactory()
response = self.client.get('%s?type=delivery' % ENDPOINT_URL)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 3)
def test_should_paginate_alert_list_on_request(self):
AlertFactory()
AlertFactory()
response = self.client.get('%s?paginate=true&type=delivery' % ENDPOINT_URL)
self.assertIn('results', response.data)
self.assertIn('count', response.data)
self.assertIn('next', response.data)
self.assertIn('previous', response.data)
self.assertIn('pageSize', response.data)
self.assertEqual(len(response.data['results']), 2)
def test_should_not_paginate_alert_list_when_paginate_is_not_true(self):
response = self.client.get('%s?paginate=falsy' % ENDPOINT_URL)
self.assertEqual(response.status_code, 200)
self.assertNotIn('results', response.data)
self.assertEqual(response.data, [])
def test_should_update_alert(self):
alert = AlertFactory()
response = self.client.patch('%s%s/' % (ENDPOINT_URL, alert.id), data={'remarks': 'some remarks', 'is_resolved': True})
updated_alert = Alert.objects.get(pk=alert.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(updated_alert.remarks, 'some remarks')
self.assertEqual(updated_alert.is_resolved, True)
def test_should_not_update_alert_when_remark_does_not_exist(self):
alert = AlertFactory()
response = self.client.patch('%s%s/' % (ENDPOINT_URL, alert.id),
data={'id': alert.id, 'alert_remarks': 'some remarks'})
updated_alert = Alert.objects.get(pk=alert.id)
self.assertEqual(response.status_code, 400)
self.assertEqual(updated_alert.remarks, None)
self.assertEqual(updated_alert.is_resolved, False)
def test_should_not_update_alert_when_remark_is_blank(self):
alert = AlertFactory()
response = self.client.patch('%s%s/' % (ENDPOINT_URL, alert.id), data={'remarks': ''})
updated_alert = Alert.objects.get(pk=alert.id)
self.assertEqual(response.status_code, 400)
self.assertEqual(updated_alert.remarks, None)
self.assertEqual(updated_alert.is_resolved, False)
def test_should_not_update_alert_when_id_does_not_exist(self):
alert = AlertFactory()
response = self.client.patch('%s%s/' % (ENDPOINT_URL, alert.id), data={'alert_remarks': 'some remarks'})
updated_alert = Alert.objects.get(pk=alert.id)
self.assertEqual(response.status_code, 400)
self.assertEqual(updated_alert.remarks, None)
self.assertEqual(updated_alert.is_resolved, False)
def test_should_filter_alerts_by_runnable_type_when_item(self):
item_alert = AlertFactory(runnable=DeliveryNodeFactory())
item_alert_ids, item_alerts = self.__respond_by_alert_type('item')
self.assertEqual(Alert.objects.count(), 1)
self.assertEqual(len(item_alerts), 1)
self.assertIn(item_alert.id, item_alert_ids)
def test_should_filter_alerts_by_runnable_type_when_delivery(self):
delivery_alert = AlertFactory(runnable=DeliveryFactory())
delivery_alert_ids, delivery_alerts = self.__respond_by_alert_type('delivery')
self.assertEqual(Alert.objects.count(), 1)
self.assertEqual(len(delivery_alerts), 1)
self.assertIn(delivery_alert.id, delivery_alert_ids)
def test_should_filter_alerts_by_runnable_type_when_distribution(self):
delivery = DeliveryFactory(time_limitation_on_distribution=3)
question_received_date = TextQuestionFactory(label=Question.LABEL.dateOfReceipt, flow=self.flow_ip)
run = RunFactory(runnable=delivery)
DeliveryNodeFactory(distribution_plan=delivery, tree_position=Flow.Label.IMPLEMENTING_PARTNER)
received_date = '2015-11-20T16:00:00'
TextAnswerFactory(run=run, question=question_received_date, value=received_date)
distribution_alert = AlertFactory(runnable=delivery, issue=Alert.ISSUE_TYPES.distribution_expired)
distribution_alert_ids, distribution_alerts = self.__respond_by_alert_type('distribution')
self.assertEqual(Alert.objects.count(), 1)
self.assertTrue(distribution_alerts[0]['date_received'])
self.assertEqual(distribution_alerts[0]['date_received'], received_date)
self.assertEqual(len(distribution_alerts), 1)
self.assertIn(distribution_alert.id, distribution_alert_ids)
def __respond_by_alert_type(self, alert_type):
alerts_response = self.client.get('%s?type=%s' % (ENDPOINT_URL, alert_type))
alerts = alerts_response.data
alert_ids = [alert['id'] for alert in alerts]
return alert_ids, alerts
class AlertCountEndpointTest(AuthenticatedAPITestCase):
def test_should_show_alerts_count(self):
AlertFactory(is_resolved=False)
AlertFactory(is_resolved=True)
response = self.client.get(ENDPOINT_URL + "count/")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['total'], 2)
self.assertEqual(response.data['unresolved'], 1)