def test_should_paginate_consignee_list_on_request(self):
ConsigneeFactory()
ConsigneeFactory()
response = self.client.get('%s?paginate=true' % 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_filter_consignees_by_imported_from_vision_flag(self):
vision_consignee = ConsigneeFactory(imported_from_vision=True)
ConsigneeFactory(imported_from_vision=False)
response = self.client.get(ENDPOINT_URL + '?imported_from_vision=True')
self.assertEqual(response.status_code, 200)
self.assertEqual(Consignee.objects.count(), 2)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'], vision_consignee.id)
def test_should_build_contact_with_details_from_contacts_service(self):
contact_id = '54335c56b3ae9d92f038abb0'
fake_contact_json = {'firstName': "test", 'lastName': "user1", 'phone': "+256 782 443439",
'_id': contact_id}
fake_response = FakeResponse(fake_contact_json, 200)
consignee = ConsigneeFactory(contact_person_id=contact_id)
when(requests).get("%s%s/" % (settings.CONTACTS_SERVICE_URL, contact_id)).thenReturn(fake_response)
contact = consignee.build_contact()
self.assertEqual(contact, fake_contact_json)
self.assertEqual(consignee.contact, contact)
def test_should_save_node_when_quantity_is_not_specified_but_parents_are(
self):
parent = DeliveryNodeFactory(consignee=ConsigneeFactory())
node = DeliveryNode.objects.create(
parents=[(parent, 5)],
consignee=ConsigneeFactory(),
item=PurchaseOrderItemFactory(),
tree_position=Flow.Label.MIDDLE_MAN,
location='Jinja',
contact_person_id='89878528-864A-4320-8426-1DB5C9A5A337',
delivery_date=datetime.today())
self.assertEqual(DeliveryNode.objects.get(pk=node.id), node)
def test_should_not_fetch_contact_from_contacts_service_if_contact_was_already_built(self):
contact_id = '54335c56b3ae9d92f038abb1'
fake_contact_json = {'firstName': "test", 'lastName': "user1", 'phone': "+256 782 443439",
'_id': contact_id}
fake_response = FakeResponse(fake_contact_json, 200)
consignee = ConsigneeFactory(contact_person_id=contact_id)
when(requests).get("%s%s/" % (settings.CONTACTS_SERVICE_URL, contact_id)).thenReturn(fake_response)
consignee.build_contact()
consignee.build_contact()
verify(requests, times=1).get("%s%s/" % (settings.CONTACTS_SERVICE_URL, contact_id))
def test_should_get_programme_ips(self):
programe = ProgrammeFactory(name='Our Programme')
delivery = DeliveryFactory(programme=programe)
kisoro = ConsigneeFactory(name="KISORO")
wakiso = ConsigneeFactory(name="WAKISO")
guru = ConsigneeFactory(name="GURU DHO")
DeliveryNodeFactory(consignee=wakiso, distribution_plan=delivery)
DeliveryNodeFactory(consignee=guru, distribution_plan=delivery)
DeliveryNodeFactory(consignee=kisoro, distribution_plan=delivery)
self.assertEqual(len(programe.to_dict_with_ips()['ips']), 3)
def test_should_list_only_consignees_imported_from_vision_sorted_in_ascending_order_of_name(self):
one = ConsigneeFactory(name='A', imported_from_vision=True)
two = ConsigneeFactory(name='Z', imported_from_vision=True)
three = ConsigneeFactory(name='G', imported_from_vision=True)
four = ConsigneeFactory(name='E', imported_from_vision=True)
ConsigneeFactory(imported_from_vision=False)
response = self.client.get('/users/new/')
consignees = response.context['form'].consignees
consignee_ids = [c.id for c in consignees]
self.assertEqual(Consignee.objects.count(), 5)
self.assertEqual(len(consignees), 4)
self.assertListEqual(consignee_ids, [one.id, four.id, three.id, two.id])
def test_should_create_alerts_integration(self):
purchase_order = PurchaseOrderFactory(order_number=5678)
purchase_order_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
consignee = ConsigneeFactory(name="Liverpool FC")
delivery = DeliveryFactory(consignee=consignee)
DeliveryNodeFactory(item=purchase_order_item, distribution_plan=delivery)
date_of_receipt = self.__get_current_date()
good_comment = "All is good"
data = {
'runnable': delivery.id, 'answers': [
{'question_label': 'deliveryReceived', 'value': 'No'},
{'question_label': 'dateOfReceipt', 'value': date_of_receipt},
{'question_label': 'isDeliveryInGoodOrder', 'value': 'Yes'},
{'question_label': 'areYouSatisfied', 'value': 'Yes'},
{'question_label': 'additionalDeliveryComments', 'value': good_comment}
]}
response = self.client.post(ENDPOINT_URL, data=json.dumps(data), content_type='application/json')
self.assertEqual(response.status_code, 201)
alert = Alert.objects.get(consignee_name="Liverpool FC", order_number=5678)
self.assertEqual(alert.issue, Alert.ISSUE_TYPES.not_received)
self.assertTrue(self.mock_distribution_alert_raise.delay.called)
def test_should_create_alert(self, mock_contact):
purchase_order = PurchaseOrderFactory(order_number=5678)
purchase_order_item = PurchaseOrderItemFactory(
purchase_order=purchase_order)
consignee = ConsigneeFactory(name="Liverpool FC")
contact_person_id = 'some_id'
contact = {
u'_id': contact_person_id,
u'firstName': u'Chris',
u'lastName': u'George',
u'phone': u'+256781111111'
}
mock_contact.return_value = contact
delivery = DeliveryFactory(consignee=consignee,
contact_person_id=contact_person_id)
DeliveryNodeFactory(item=purchase_order_item,
distribution_plan=delivery)
delivery.create_alert(Alert.ISSUE_TYPES.not_received)
alerts = Alert.objects.filter(consignee_name="Liverpool FC",
order_number=5678)
self.assertEqual(alerts.count(), 1)
alert = alerts.first()
self.assertEqual(alert.order_type, PurchaseOrderItem.PURCHASE_ORDER)
self.assertEqual(alert.order_number, 5678)
self.assertEqual(alert.consignee_name, "Liverpool FC")
self.assertEqual(alert.contact['contact_name'], "Chris George")
self.assertEqual(alert.issue, Alert.ISSUE_TYPES.not_received)
self.assertFalse(alert.is_resolved)
self.assertIsNone(alert.remarks)
self.assertEqual(alert.runnable.id, delivery.id)
self.assertIsNone(alert.item_description)
def test_should_return_delivery_empty_value_if_no_answers(self):
self._create_questions()
programme_name = 'YP104 MANAGEMENT RESULTS'
wakiso = 'WAKISO DHO'
shipment_date = date(2015, 3, 10)
delivery = DeliveryFactory(
contact_person_id=CONTACT_PERSON_ID,
track=True,
programme=ProgrammeFactory(name=programme_name),
consignee=ConsigneeFactory(name=wakiso),
delivery_date=shipment_date)
order_number = 34230335
DeliveryNodeFactory(
contact_person_id=CONTACT_PERSON_ID,
distribution_plan=delivery,
track=True,
tree_position=Flow.Label.IMPLEMENTING_PARTNER,
item=PurchaseOrderItemFactory(purchase_order=PurchaseOrderFactory(
order_number=order_number)))
run = RunFactory(runnable=delivery)
MultipleChoiceAnswerFactory(run=run,
question=self.delivery_received_qtn,
value=self.yes_one)
MultipleChoiceAnswerFactory(run=run,
question=self.satisfied_with_delivery,
value=self.no_three)
programme = Programme.objects.get(name=programme_name)
consignee = Consignee.objects.get(name=wakiso)
yes = 'Yes'
no = 'No'
empty = ''
expected_response = [{
'deliveryReceived': yes,
'shipmentDate': date(2015, 3, 10),
'dateOfReceipt': empty,
'orderNumber': order_number,
'programme': {
'id': programme.id,
'name': programme.name
},
'consignee': {
'id': consignee.id,
'name': consignee.name
},
Question.LABEL.isDeliveryInGoodOrder: empty,
'satisfiedWithDelivery': no,
'urls': [],
'absoluteUrls': [],
'additionalDeliveryComments': empty,
'contactPersonId': CONTACT_PERSON_ID,
'value': 100,
'location': 'Kampala'
}]
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['results'], expected_response)
def setup_multiple_nodes_with_answers(self, number_of_nodes):
consignee_one = ConsigneeFactory(name='consignee one')
programme_one = ProgrammeFactory(name='my first programme')
po_item = PurchaseOrderItemFactory(item=ItemFactory(description='Mama kit'),
purchase_order=PurchaseOrderFactory(order_number=329293))
flow = FlowFactory(label='WEB')
question_1 = MultipleChoiceQuestionFactory(text='Was the item received?', label='itemReceived', flow=flow,
position=1)
option_1 = OptionFactory(text='Yes', question=question_1)
question_2 = NumericQuestionFactory(text='How much was received?', label='amountReceived', flow=flow)
question_3 = MultipleChoiceQuestionFactory(text='What is the quality of the product?', label='qualityOfProduct',
flow=flow, position=3)
option_3 = OptionFactory(text='Damaged', question=question_3)
question_4 = MultipleChoiceQuestionFactory(text='Are you satisfied with the product?',
label='satisfiedWithProduct', flow=flow, position=4)
option_4 = OptionFactory(text='Yes', question=question_4)
question_5 = TextQuestionFactory(label='dateOfReceipt', flow=flow, text='When was Delivery Received?')
nodes = []
for index in range(number_of_nodes):
node = DeliveryNodeFactory(consignee=consignee_one, item=po_item, programme=programme_one,
distribution_plan=DeliveryFactory(track=True),
track=True)
run_one = RunFactory(runnable=node)
MultipleChoiceAnswerFactory(question=question_1, run=run_one, value=option_1)
NumericAnswerFactory(question=question_2, run=run_one, value=5)
MultipleChoiceAnswerFactory(question=question_3, run=run_one, value=option_3)
MultipleChoiceAnswerFactory(question=question_4, run=run_one, value=option_4)
TextAnswerFactory(run=run_one, question=question_5, value='2014-10-10')
nodes.append(node)
return nodes
def test_should_fetch_name_from_contacts_and_adds_alert_attribute(self):
answer_values = [
{"category": {"base": "No"}, "label": Question.LABEL.deliveryReceived},
{"category": {"base": "Yes"}, "label": Question.LABEL.isDeliveryInGoodOrder}
]
purchase_order = PurchaseOrderFactory(order_number=5678)
purchase_order_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
consignee = ConsigneeFactory(name="Liverpool FC - Unique")
contact_person_id = 'some_id'
contact = {u'_id': contact_person_id,
u'firstName': u'chris',
u'lastName': u'george',
u'phone': u'+256781111111'}
delivery = DeliveryFactory(consignee=consignee, contact_person_id=contact_person_id)
DeliveryNodeFactory(item=purchase_order_item, distribution_plan=delivery)
response = MagicMock(json=MagicMock(return_value=contact), status_code=200)
requests.get = MagicMock(return_value=response)
ResponseAlertHandler(runnable=delivery, answer_values=answer_values).process()
alert = Alert.objects.get(consignee_name="Liverpool FC - Unique", order_number=5678)
self.assertEqual(alert.contact['contact_name'], "chris george")
def test_should_not_return_deliveries_for_ip_if_received_is_false(self):
first_consignee = ConsigneeFactory()
date = datetime.date(2014, 07, 9)
first_delivery = DeliveryFactory(consignee=first_consignee, track=True, delivery_date=date)
second_delivery = DeliveryFactory(consignee=first_consignee, track=True)
self.logout()
self.log_consignee_in(consignee=first_consignee)
response = self.client.get(ENDPOINT_URL)
ids = map(lambda delivery: delivery['id'], response.data)
self.assertEqual(response.status_code, 200)
self.assertIn(first_delivery.id, ids)
self.assertIn(second_delivery.id, ids)
flow = FlowFactory(label=Flow.Label.IMPLEMENTING_PARTNER)
delivery_received_qn = MultipleChoiceQuestionFactory(label='deliveryReceived', flow=flow)
OptionFactory(question=delivery_received_qn, text='Yes')
option_no = OptionFactory(question=delivery_received_qn, text='No')
run = RunFactory(runnable=first_delivery)
MultipleChoiceAnswerFactory(run=run, question=delivery_received_qn, value=option_no)
response = self.client.get(ENDPOINT_URL)
ids = map(lambda delivery: delivery['id'], response.data)
self.assertEqual(response.status_code, 200)
self.assertNotIn(first_delivery.id, ids)
self.assertIn(second_delivery.id, ids)
def test_should_get_all_nodes_delivered_by_a_consignee_for_a_specific_item(
self):
item = ItemFactory()
consignee = ConsigneeFactory()
node_one = DeliveryNodeFactory(
item=PurchaseOrderItemFactory(item=item), consignee=consignee)
child_node_one = DeliveryNodeFactory(
item=PurchaseOrderItemFactory(item=item), parents=[(node_one, 10)])
node_two = DeliveryNodeFactory(
item=PurchaseOrderItemFactory(item=item), consignee=consignee)
child_node_two = DeliveryNodeFactory(
item=PurchaseOrderItemFactory(item=item), parents=[(node_two, 10)])
other_item_node_to_consignee = DeliveryNodeFactory(consignee=consignee,
quantity=200)
non_item_child_node = DeliveryNodeFactory(
parents=[(other_item_node_to_consignee, 100)])
non_consignee_child_node = DeliveryNodeFactory(
item=PurchaseOrderItemFactory(item=item))
returned_nodes = DeliveryNode.objects.delivered_by_consignee(
consignee, item)
self.assertItemsEqual([child_node_one, child_node_two], returned_nodes)
self.assertNotIn(non_consignee_child_node, returned_nodes)
self.assertNotIn(non_item_child_node, returned_nodes)
def setUp(self):
self.consignee = ConsigneeFactory()
self.contact = {
'first_name': 'Test',
'last_name': 'User',
'phone': '+256 772 123456'
}
def test_should_disallow_ip_viewer_to_delete_consignee(self):
consignee = ConsigneeFactory(name='New Consignee')
self._login_as('Implementing Partner_viewer')
response = self.client.delete(ENDPOINT_URL + str(consignee.id) + '/')
self.assertEqual(response.status_code, 403)
def test_should_get_export_list_for_direct_delivery(self, mock_build_contact):
self.clean()
contact = {'firstName': 'John', 'lastName': 'Ssenteza', 'phone': '+256 782 123456'}
mock_build_contact.return_value = contact
delivery = DeliveryFactory()
consignee_name = 'the consignee'
consignee = ConsigneeFactory(name=consignee_name)
order_number = 5404939
mama_kit = 'Mama kit'
material_code = 'Code 33'
ro_item = PurchaseOrderItemFactory(item=ItemFactory(description=mama_kit, material_code=material_code),
purchase_order=PurchaseOrderFactory(order_number=order_number))
delivery_date = '2015-09-06'
luweero = 'Luweero'
remark = 'some remark'
DeliveryNodeFactory(distribution_plan=delivery, delivery_date=delivery_date,
consignee=consignee, item=ro_item, location=luweero, remark=remark)
header = [
'Purchase Order', 'Item Description', 'Material Code', 'Quantity Shipped', 'Shipment Date',
'Implementing Partner', 'Contact Person', 'Contact Number', 'District', 'Is End User',
'Is Tracked', 'Remarks']
row_one = [order_number, mama_kit, material_code, 10, delivery_date, consignee_name,
'%s %s' % (contact['firstName'], contact['lastName']),
contact['phone'], luweero, 'Yes', 'No', remark]
expected_data = [header, row_one]
csv_exporter = DeliveryCSVExporter.create_delivery_exporter_by_type('Direct', self.HOSTNAME)
logger.info(expected_data)
logger.info(csv_exporter.assemble_csv_data())
self.assertEqual(csv_exporter.assemble_csv_data(), expected_data)
def test_should_add_consignee_name_accessor_to_delivery_nodes_fetched_from_endpoint(
self):
consignee_name = 'WAKISO DHO'
consignee = ConsigneeFactory(name=consignee_name)
DeliveryNodeFactory(consignee=consignee)
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.data[0]['consignee_name'], consignee_name)
def setup_responses(self):
DeliveryNode.objects.all().delete()
MultipleChoiceQuestion.objects.all().delete()
from eums.fixtures.end_user_questions import seed_questions
questions, options = seed_questions()
po_item = PurchaseOrderItemFactory(quantity=100, value=1000)
end_user_node_one = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER, quantity=10, item=po_item)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_one, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_RECEIVED'])
self.programme = ProgrammeFactory(name='my-program')
self.ip = ConsigneeFactory()
distribution_plan = DeliveryFactory(programme=self.programme,
track=True)
self.today = FakeDate.today()
self.end_user_node_two = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER,
quantity=20,
item=po_item,
distribution_plan=distribution_plan)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=self.end_user_node_two, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_RECEIVED'])
end_user_node_three = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER,
quantity=30,
item=po_item,
distribution_plan=distribution_plan,
ip=self.ip,
consignee=self.ip,
delivery_date=self.today + datetime.timedelta(days=3))
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_three, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_NOT_RECEIVED'])
end_user_node_four = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER, quantity=40, item=po_item)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_four, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_NOT_RECEIVED'])
end_user_node_five = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER, quantity=50, item=po_item)
MultipleChoiceAnswerFactory(run=RunFactory(
runnable=end_user_node_five, status=Run.STATUS.scheduled),
question=questions['WAS_PRODUCT_RECEIVED'],
value=options['PRODUCT_WAS_NOT_RECEIVED'])
non_response_node = DeliveryNodeFactory(
tree_position=DeliveryNode.END_USER,
track=True,
quantity=60,
item=po_item)
RunFactory(runnable=non_response_node, status=Run.STATUS.scheduled)
def test_should_disallow_unicef_viewer_to_change_consignee(self):
consignee = ConsigneeFactory(name='New Consignee')
self._login_as('UNICEF_viewer')
response = self.client.put(ENDPOINT_URL + str(consignee.id) + '/',
{'name': 'Updated Consignee'})
self.assertEqual(response.status_code, 403)
def test_should_filter_admin_deliveries_by_date_when_only_form_date_exist(self):
first_consignee = ConsigneeFactory()
second_consignee = ConsigneeFactory()
date = datetime.date(2014, 07, 9)
first_delivery = DeliveryFactory(consignee=first_consignee, track=True, delivery_date=date)
second_delivery = DeliveryFactory(consignee=first_consignee, track=True)
third_delivery = DeliveryFactory(consignee=second_consignee, track=True, delivery_date=date)
response = self.client.get(ENDPOINT_URL + '?from=2014-07-6')
ids = map(lambda delivery: delivery['id'], response.data)
self.assertEqual(response.status_code, 200)
self.assertIn(first_delivery.id, ids)
self.assertIn(second_delivery.id, ids)
self.assertIn(third_delivery.id, ids)
def test_should_build_contact_with_details_from_contacts_service(self):
contact_id = '54335c56b3ae9d92f038abb0'
fake_contact_json = {
'firstName': "test",
'lastName': "user1",
'phone': "+256 782 443439",
'_id': contact_id
}
fake_response = FakeResponse(fake_contact_json, 200)
consignee = ConsigneeFactory(contact_person_id=contact_id)
when(requests).get("%s%s/" % (settings.CONTACTS_SERVICE_URL,
contact_id)).thenReturn(fake_response)
contact = consignee.build_contact()
self.assertEqual(contact, fake_contact_json)
self.assertEqual(consignee.contact, contact)
def test_should_return_parent_consignee_name_as_sender_for_node_when_parent(
self):
parent_consignee = ConsigneeFactory(name="Arsenal Fan Club")
parent_node = DeliveryNodeFactory(consignee=parent_consignee)
child_node = DeliveryNodeFactory(parents=[(parent_node, 5)])
message = DeliveryRunMessage(child_node)
self.assertEqual(message.sender_name(), "Arsenal Fan Club")
def test_should_get_sender_name(self):
sender_name = 'Save the children'
root_node = DeliveryNodeFactory(consignee=ConsigneeFactory(
name=sender_name))
self.assertEqual(root_node.sender_name(), 'UNICEF')
node = DeliveryNodeFactory(parents=[(root_node, 5)])
self.assertEqual(node.sender_name(), sender_name)
def test_should_get_programmes_with_associated_ips(self):
programme = ProgrammeFactory(name='Our Programme')
delivery = DeliveryFactory(programme=programme)
kisoro = ConsigneeFactory(name="KISORO")
wakiso = ConsigneeFactory(name="WAKISO")
guru = ConsigneeFactory(name="GURU DHO")
DeliveryNodeFactory(consignee=wakiso, distribution_plan=delivery)
DeliveryNodeFactory(consignee=guru, distribution_plan=delivery)
DeliveryNodeFactory(consignee=kisoro, distribution_plan=delivery)
response = self.client.get(ENDPOINT_URL + 'with-ips/', format='json')
self.assertEqual(response.status_code, 200)
expected_response = get_programme(programme, response.data)[0]
[self.assertIn(ip, expected_response['ips']) for ip in [kisoro.id, wakiso.id, guru.id]]
def setup_responses(self):
DeliveryNode.objects.all().delete()
MultipleChoiceQuestion.objects.all().delete()
MultipleChoiceAnswer.objects.all().delete()
from eums.fixtures.ip_questions import seed_ip_questions
questions, options, _ = seed_ip_questions()
self.programme = ProgrammeFactory(name='my-program')
self.ip = ConsigneeFactory()
self.today = FakeDate.today()
po_item = PurchaseOrderItemFactory(quantity=100, value=1000)
ip_delivery_one = DeliveryFactory(location='some location',
track=True,
programme=self.programme,
consignee=self.ip,
ip=self.ip,
delivery_date=self.today +
datetime.timedelta(days=3))
DeliveryNodeFactory(tree_position=DeliveryNode.IMPLEMENTING_PARTNER,
quantity=10,
item=po_item,
distribution_plan=ip_delivery_one,
consignee=self.ip)
other_delivery = DeliveryFactory(location='Other location',
delivery_date=self.today,
track=True)
DeliveryNodeFactory(tree_position=DeliveryNode.IMPLEMENTING_PARTNER,
quantity=20,
item=po_item,
distribution_plan=other_delivery)
MultipleChoiceAnswerFactory(
run=RunFactory(runnable=ip_delivery_one,
status=Run.STATUS.scheduled),
question=questions['WAS_DELIVERY_RECEIVED'],
value=options['DELIVERY_WAS_RECEIVED'])
MultipleChoiceAnswerFactory(
run=RunFactory(runnable=ip_delivery_one,
status=Run.STATUS.scheduled),
question=questions['IS_DELIVERY_IN_GOOD_ORDER'],
value=options['IN_GOOD_CONDITION'])
non_response_delivery_one = DeliveryFactory(delivery_date=self.today +
datetime.timedelta(days=4),
location='some location',
track=True)
DeliveryNodeFactory(tree_position=DeliveryNode.IMPLEMENTING_PARTNER,
quantity=30,
item=po_item,
distribution_plan=non_response_delivery_one)
RunFactory(runnable=non_response_delivery_one,
status=Run.STATUS.scheduled)
def test_should_give_unicef_user_permission_to_edit_non_vision_consignee(
self):
consignee = ConsigneeFactory(imported_from_vision=False)
self._login_as('UNICEF_admin')
response = self.client.get(ENDPOINT_URL + str(consignee.id) +
'/permission_to_edit/')
self.assertEqual(response.status_code, 200)
def test_nodes_should_be_saved_with_their_ip(self):
consignee = ConsigneeFactory()
root = DeliveryNodeFactory(consignee=consignee, quantity=100)
child = DeliveryNodeFactory(parents=[(root, 60)])
grandchild = DeliveryNodeFactory(parents=[(child, 30)])
self.assertEqual(root.ip, consignee)
self.assertEqual(child.ip, consignee)
self.assertEqual(grandchild.ip, consignee)
def test_should_disallow_ip_editor_to_delete_consignee_that_is_vision_imported(
self):
user = User.objects.create_user(username='******',
password='******')
consignee = ConsigneeFactory(name="User Attached Consignee")
profile = UserProfile(user=user, consignee=consignee)
profile.save()
user.groups = [Group.objects.get(name='Implementing Partner_editor')]
user.save()
consignee = ConsigneeFactory(name='New Consignee',
imported_from_vision=True)
self.client.login(username='******', password='******')
response = self.client.delete(ENDPOINT_URL + str(consignee.id) + '/')
self.assertEqual(response.status_code, 403)
self.assertEqual(
Consignee.objects.filter(name='New Consignee').count(), 1)
def test_should_disallow_ip_viewer_to_edit_vision_consignee(self):
consignee = ConsigneeFactory(imported_from_vision=True)
self._login_as('Implementing Partner_viewer')
response = self.client.get(ENDPOINT_URL + str(consignee.id) +
'/permission_to_edit/')
self.assertEqual(response.data['permission'], 'consignee_forbidden')
self.assertEqual(response.status_code, 200)
def create_consignee(_, consignee_details=None):
if not consignee_details:
consignee_details = {}
consignee = ConsigneeFactory(name=consignee_details.get('name', ''),
type=consignee_details.get('type', 'implementing_partner'),
customer_id=consignee_details.get('customer_id', 'L400'),
location=consignee_details.get('location', 'Kampala'),
imported_from_vision=consignee_details.get('imported_from_vision', False))
return consignee.__dict__
def test_should_filter_deliveries_by_ip(self):
first_consignee = ConsigneeFactory()
second_consignee = ConsigneeFactory()
first_delivery = DeliveryFactory(consignee=first_consignee, track=True)
second_delivery = DeliveryFactory(consignee=first_consignee)
third_delivery = DeliveryFactory(consignee=second_consignee)
self.logout()
self.log_consignee_in(consignee=first_consignee)
response = self.client.get(ENDPOINT_URL)
ids = map(lambda delivery: delivery['id'], response.data)
self.assertEqual(response.status_code, 200)
self.assertIn(first_delivery.id, ids)
self.assertNotIn(second_delivery.id, ids)
self.assertNotIn(third_delivery.id, ids)
