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_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 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))
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_get_a_nodes_ip_from_the_root_node_of_the_node_delivery(
self):
delivery = DeliveryFactory()
root_node = DeliveryNodeFactory(distribution_plan=delivery)
self.assertEqual(
root_node.get_ip(), {
'id': root_node.id,
'consignee': root_node.consignee,
'location': root_node.location
})
intermediary_node = DeliveryNodeFactory(distribution_plan=delivery,
parents=[(root_node, 5)])
self.assertEqual(
intermediary_node.get_ip(), {
'id': root_node.id,
'consignee': root_node.consignee,
'location': root_node.location
})
leaf_node = DeliveryNodeFactory(parents=[(intermediary_node, 3)],
distribution_plan=delivery)
self.assertEqual(
leaf_node.get_ip(), {
'id': root_node.id,
'consignee': root_node.consignee,
'location': root_node.location
})
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_gets_correct_last_shipment_date_value_for_stock_report(self):
programme = ProgrammeFactory(name='special_program')
delivery = DeliveryFactory(track=True, programme=programme)
sales_order = SalesOrderFactory(programme=programme)
purchase_order = PurchaseOrderFactory(order_number=4748278, sales_order=sales_order)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order,
item=ItemFactory(material_code='Code 23', description='Jerrycans'))
ip_node_one = DeliveryNodeFactory(distribution_plan=delivery, item=po_item, quantity=40,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER,
delivery_date=FakeDate.build(2015, 03, 19))
run_one = RunFactory(runnable=ip_node_one)
quantity_received_qn = NumericQuestion.objects.get(label='amountReceived')
NumericAnswerFactory(question=quantity_received_qn, value=39, run=run_one)
last_shipment_date = FakeDate.build(2015, 10, 07)
ip_node_two = DeliveryNodeFactory(distribution_plan=delivery, item=po_item, quantity=30,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER,
delivery_date=last_shipment_date)
run_two = RunFactory(runnable=ip_node_two)
NumericAnswerFactory(question=quantity_received_qn, value=40, run=run_two)
expected_data = [
{'document_number': purchase_order.order_number,
'programme': programme.name,
'last_shipment_date': str(last_shipment_date),
'total_value_received': Decimal('79'),
'total_value_dispensed': Decimal('0'),
'total_value_lost': Decimal('0'),
'balance': Decimal('79'),
'items': [{'code': unicode(po_item.item.material_code),
'description': unicode(po_item.item.description),
'consignee': self.ip.name,
'location': ip_node_one.location,
'quantity_delivered': 3,
'date_delivered': str(self.ip_node_two.delivery_date),
'quantity_confirmed': 2,
'date_confirmed': '2014-01-02',
'quantity_dispatched': 2,
'quantity_lost': 0,
'balance': 0
},
{'code': unicode(po_item.item.material_code),
'description': unicode(po_item.item.description),
'consignee': self.ip.name,
'location': ip_node_two.location,
'quantity_delivered': 5,
'date_delivered': str(self.ip_node_one.delivery_date),
'quantity_confirmed': 4,
'date_confirmed': '2014-01-01',
'quantity_dispatched': 2,
'quantity_lost': 0,
'balance': 2
}]
}]
response = self.client.get(ENDPOINT_URL)
self.assert_api_response_with_correct_last_shipment_date(response, expected_data)
def test_should_return_false_when_delivery_run_was_cancelled(self):
delivery = DeliveryFactory()
question = MultipleChoiceQuestionFactory(label='deliveryReceived')
option = OptionFactory(text='Yes', question=question)
run = RunFactory(runnable=delivery, status=Run.STATUS.cancelled)
MultipleChoiceAnswerFactory(run=run, question=question, value=option)
self.assertFalse(delivery.is_received())
def test_should_return_type_of_delivery(self):
po_item = PurchaseOrderItemFactory()
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery, item=po_item)
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.data[0]['type'], 'Purchase Order')
def test_should_filter_based_on_outcome(self):
outcome_one = ProgrammeFactory(name='Outcome One')
outcome_two = ProgrammeFactory(name='Outcome Two')
delivery_one = DeliveryFactory(programme=outcome_one, track=True)
delivery_two = DeliveryFactory(programme=outcome_two, track=True)
DeliveryNodeFactory(distribution_plan=delivery_one, tree_position=Flow.Label.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(distribution_plan=delivery_two, tree_position=Flow.Label.IMPLEMENTING_PARTNER)
endpoint_url = BACKEND_URL + 'stock-report?outcome=%d' % outcome_two.id
response = self.client.get(endpoint_url)
results = response.data['results']
self.assertEqual(len(results), 1)
self.assertEqual(results[0]['programme'], 'Outcome Two')
self.assertEqual(len(results[0]['items']), 1)
def _test_should_provide_delivery_total_value_from_api(self):
po_item = PurchaseOrderItemFactory(value=200, quantity=100)
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery, item=po_item, quantity=10)
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.data[0]['total_value'], 20)
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_get_correct_track_status_when_delivery_is_tracked(self):
release_order = ReleaseOrderFactory(order_number=2342)
release_order_item = ReleaseOrderItemFactory(
release_order=release_order)
delivery = DeliveryFactory(track=True)
DeliveryNodeFactory(distribution_plan=delivery,
item=release_order_item,
track=True)
self.assertEqual(release_order.track(), True)
def test_should_create_delivery(self):
today = datetime.date.today()
programme = ProgrammeFactory()
delivery = DeliveryFactory(programme=programme, delivery_date=today)
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'], delivery.id)
def test_should_return_delivery_with_waybill_number(self):
release_order = ReleaseOrderFactory(waybill=98765)
release_order_item = ReleaseOrderItemFactory(
release_order=release_order)
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery,
item=release_order_item)
self.assertEqual(delivery.number(), 98765)
def test_should_return_number_of_delivery(self):
purchase_order = PurchaseOrderFactory(order_number=98765)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery, item=po_item)
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.data[0]['number'], 98765)
def test_should_get_track_status_if_delivery_is_sent_and_tracked_fully(
self):
order = PurchaseOrderFactory()
order_item = PurchaseOrderItemFactory(purchase_order=order,
quantity=100)
self.assertEqual(order.track(), PurchaseOrder.NOT_TRACKED)
delivery_one = DeliveryFactory(track=True)
delivery_two = DeliveryFactory(track=True)
NodeFactory(item=order_item,
distribution_plan=delivery_one,
quantity=50,
track=True)
NodeFactory(item=order_item,
distribution_plan=delivery_two,
quantity=50,
track=True)
self.assertEqual(order.track(), PurchaseOrder.FULLY_TRACKED)
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)
def test_should_get_correct_delivery_if_exists(self):
release_order = ReleaseOrderFactory(order_number=2342)
release_order_item = ReleaseOrderItemFactory(
release_order=release_order)
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery,
item=release_order_item)
self.assertEqual(release_order.delivery(), delivery.id)
def test_should_provide_shipment_received_value_from_api(self):
delivery = DeliveryFactory()
question = MultipleChoiceQuestionFactory(label='deliveryReceived')
option = OptionFactory(text='Yes', question=question)
run = RunFactory(runnable=delivery)
MultipleChoiceAnswerFactory(run=run, question=question, value=option)
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.data[0]['shipment_received'], True)
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()
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))
DeliveryFactory(location='Other location',
delivery_date=self.today,
track=True)
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)
RunFactory(runnable=non_response_delivery_one,
status=Run.STATUS.scheduled)
def test_should_return_answers_for_delivery(self):
delivery = DeliveryFactory()
flow = FlowFactory(label='IMPLEMENTING_PARTNER')
question_1 = MultipleChoiceQuestionFactory(
label='deliveryReceived', flow=flow, text='Was Delivery Received?')
question_2 = TextQuestionFactory(label='dateOfReceipt',
flow=flow,
text='When was Delivery Received?')
question_3 = NumericQuestionFactory(text='How much was received?',
label='amountReceived',
flow=flow)
option_yes = OptionFactory(text='Yes', question=question_1)
run = RunFactory(runnable=delivery)
multiple_choice_answer = MultipleChoiceAnswerFactory(
run=run, question=question_1, value=option_yes)
text_answer = TextAnswerFactory(run=run,
question=question_2,
value='2015-10-10')
numeric_answer = NumericAnswerFactory(run=run,
question=question_3,
value=10)
expected_multiple_choice_answer = {
'question_label': question_1.label,
'type': 'multipleChoice',
'text': question_1.text,
'value': multiple_choice_answer.value.text,
'options': ['Yes'],
'position': question_1.position
}
expected_text_answer = {
'question_label': question_2.label,
'type': 'text',
'text': question_2.text,
'value': text_answer.value,
'position': question_2.position
}
expected_numeric_answer = {
'question_label': question_3.label,
'type': 'numeric',
'text': question_3.text,
'value': numeric_answer.value,
'position': question_3.position
}
answers = delivery.answers()
self.assertEqual(len(answers), 3)
self.assertIn(expected_multiple_choice_answer, answers)
self.assertIn(expected_text_answer, answers)
self.assertIn(expected_numeric_answer, answers)
def test_should_return_description_of_purchase_order_item_with_purchase_order_and_order_number(
self):
purchase_order = PurchaseOrderFactory(order_number=222333444)
item = PurchaseOrderItemFactory(purchase_order=purchase_order)
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery, item=item)
message = DeliveryRunMessage(delivery)
self.assertRegexpMatches(message.description(), r'purchase order(?i)')
self.assertRegexpMatches(message.description(), r'222333444')
def test_should_return_number_of_items_on_a_delivery(self):
po = PurchaseOrderFactory(order_number=123456)
po_item_one = PurchaseOrderItemFactory(purchase_order=po)
po_item_two = PurchaseOrderItemFactory(purchase_order=po)
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery, item=po_item_one)
self.assertEqual(delivery.number_of_items(), 1)
DeliveryNodeFactory(distribution_plan=delivery, item=po_item_two)
self.assertEqual(delivery.number_of_items(), 2)
def test_should_not_create_alert_when_non_delivery_question_are_answered_no(self):
answer_values = [
{"category": {"base": "No"}, "label": "This is not a delivery question"},
{"category": {"base": "Yes"}, "label": Question.LABEL.isDeliveryInGoodOrder}
]
delivery = DeliveryFactory()
response_alert_handler = ResponseAlertHandler(runnable=delivery, answer_values=answer_values)
response_alert_handler.process()
self.assertEqual(Alert.objects.count(), 0)
def test_should_get_track_status_if_delivery_is_just_saved(self):
order = PurchaseOrderFactory()
order_item = PurchaseOrderItemFactory(purchase_order=order,
quantity=100)
delivery_one = DeliveryFactory(track=False)
NodeFactory(item=order_item,
distribution_plan=delivery_one,
quantity=100,
track=False)
self.assertEqual(order.track(), PurchaseOrder.NOT_TRACKED)
def setUp(self):
self.po_item_one = PurchaseOrderItemFactory(value=400, quantity=200)
self.po_item_two = PurchaseOrderItemFactory(value=600, quantity=100)
self.delivery = DeliveryFactory()
self.node_one = DeliveryNodeFactory(distribution_plan=self.delivery,
item=self.po_item_one,
quantity=50)
DeliveryNodeFactory(distribution_plan=self.delivery,
item=self.po_item_two,
quantity=30)
def test_should_not_create_alert_when_no_issues_with_delivery(self):
answer_values = [
{"category": {"base": "Yes"}, "label": Question.LABEL.deliveryReceived},
{"category": {"base": "Yes"}, "label": Question.LABEL.isDeliveryInGoodOrder}
]
delivery = DeliveryFactory()
response_alert_handler = ResponseAlertHandler(runnable=delivery, answer_values=answer_values)
response_alert_handler.process()
self.assertEqual(Alert.objects.count(), 0)
def test_should_return_answers_for_completed_or_scheduled_runs_only(self):
delivery = DeliveryFactory()
flow = FlowFactory(label='IMPLEMENTING_PARTNER')
question_1 = MultipleChoiceQuestionFactory(
label='deliveryReceived',
flow=flow,
text='Was Delivery Received?',
position=3)
question_2 = TextQuestionFactory(label='dateOfReceipt',
flow=flow,
text='When was Delivery Received?',
position=1)
question_3 = TextQuestionFactory(
label='satisfiedWithProduct',
flow=flow,
text='Are you satisfied with product?',
position=2)
option_no = OptionFactory(text='No', question=question_1)
option_yes = OptionFactory(text='Yes', question=question_1)
run_one = RunFactory(runnable=delivery)
MultipleChoiceAnswerFactory(question=question_1,
value=option_no,
run=run_one)
TextAnswerFactory(question=question_2, value="2014-10-10", run=run_one)
TextAnswerFactory(question=question_3, value="yup", run=run_one)
answers = delivery.answers()
self.assertEqual(len(answers), 3)
self.assertEqual(answers[0]['value'], '2014-10-10')
run_one.status = 'cancelled'
run_one.save()
answers = delivery.answers()
self.assertEqual(len(answers), 3)
self.assertEqual(answers[0]['value'], '')
run_two = RunFactory(runnable=delivery)
MultipleChoiceAnswerFactory(question=question_1,
value=option_yes,
run=run_two)
answers = delivery.answers()
self.assertEqual(len(answers), 3)
self.assertEqual(answers[0]['value'], '')
self.assertEqual(answers[1]['value'], '')
self.assertEqual(answers[2]['value'], 'Yes')
def test_should_return_true_when_delivery_is_partially_received(self):
delivery = DeliveryFactory()
question = MultipleChoiceQuestionFactory(label='deliveryReceived')
option = OptionFactory(text='Yes', question=question)
run = RunFactory(runnable=delivery)
self.assertFalse(delivery.is_received())
MultipleChoiceAnswerFactory(run=run, question=question, value=option)
self.assertTrue(delivery.is_partially_received())
def create_distribution_plan_node(test_case, node_details=None):
if not node_details:
plan_id = DeliveryFactory().id
node_details = make_node_details(test_case, plan_id)
response = test_case.client.post(DISTRIBUTION_PLAN_NODE_ENDPOINT_URL, node_details, format='json')
test_case.assertEqual(response.status_code, 201)
formatted_data = response.data
formatted_data['delivery_date'] = str(formatted_data['delivery_date'])
return formatted_data
