def test_gets_all_response_for_node_consignee(self):
multichoice_question = MultipleChoiceQuestionFactory(label='productReceived')
yes_option = OptionFactory(text='Yes', question=multichoice_question)
no_option = OptionFactory(text='No', question=multichoice_question)
sugar = ItemFactory(description='Sugar')
salt = ItemFactory(description='Salt')
numeric_question = NumericQuestionFactory(label='AmountReceived')
item = SalesOrderItemFactory(item=salt, description='10 bags of salt')
salt_node = DeliveryNodeFactory(quantity=100, item=PurchaseOrderItemFactory(sales_order_item=item))
run = RunFactory(runnable=salt_node, status='completed')
sugar_item = SalesOrderItemFactory(item=sugar, description='10 bags of sugar')
sugar_node = DeliveryNodeFactory(quantity=100, item=PurchaseOrderItemFactory(sales_order_item=sugar_item))
sugar_run = RunFactory(runnable=sugar_node, status='completed')
multiple_answer_one = MultipleChoiceAnswerFactory(run=run, question=multichoice_question, value=yes_option)
numeric_answer_one = NumericAnswerFactory(run=run, value=80, question=numeric_question)
multiple_answer_two = MultipleChoiceAnswerFactory(run=sugar_run, question=multichoice_question, value=no_option)
numeric_answer_two = NumericAnswerFactory(run=sugar_run, value=80, question=numeric_question)
salt_node_responses = salt_node.responses()
sugar_node_responses = sugar_node.responses()
self.assertIn(multiple_answer_one, salt_node_responses[run])
self.assertIn(numeric_answer_one, salt_node_responses[run])
self.assertIn(multiple_answer_two, sugar_node_responses[sugar_run])
self.assertIn(numeric_answer_two, sugar_node_responses[sugar_run])
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 test_should_save_acknowledged_quantity(self):
node = DeliveryNodeFactory(quantity=100, acknowledged=100)
child = DeliveryNodeFactory(parents=[(node, 50)])
self.assertEqual(node.acknowledged, 100)
self.assertEqual(child.acknowledged, 0)
self.assertEqual(child.balance, 50)
def _setup_nodes_with_answers(self):
self._create_questions()
programme_one = ProgrammeFactory(name='programme one')
programme_two = ProgrammeFactory(name='programme two')
programme_three = ProgrammeFactory(name='programme three')
delivery_one = DeliveryFactory(track=True, programme=programme_one, delivery_date=date(2015, 3, 10),
location='Wakiso')
delivery_two = DeliveryFactory(track=True, programme=programme_two, delivery_date=date(2015, 6, 20),
location='Kampala')
delivery_three = DeliveryFactory(track=True, programme=programme_three, delivery_date=date(2015, 9, 30),
location='Fort portal')
DeliveryNodeFactory(distribution_plan=delivery_one, programme=programme_one,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(distribution_plan=delivery_two, programme=programme_two,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(distribution_plan=delivery_three, programme=programme_two,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
run_one = RunFactory(runnable=delivery_one)
MultipleChoiceAnswerFactory(run=run_one, question=self.delivery_received_qtn, value=self.yes_one)
MultipleChoiceAnswerFactory(run=run_one, question=self.delivery_in_good_order, value=self.no_two)
MultipleChoiceAnswerFactory(run=run_one, question=self.satisfied_with_delivery, value=self.no_three)
run_two = RunFactory(runnable=delivery_two)
MultipleChoiceAnswerFactory(run=run_two, question=self.delivery_received_qtn, value=self.no_one)
MultipleChoiceAnswerFactory(run=run_two, question=self.delivery_in_good_order, value=self.yes_two)
MultipleChoiceAnswerFactory(run=run_two, question=self.satisfied_with_delivery, value=self.yes_three)
run_three = RunFactory(runnable=delivery_three)
MultipleChoiceAnswerFactory(run=run_three, question=self.delivery_received_qtn, value=self.yes_one)
MultipleChoiceAnswerFactory(run=run_three, question=self.delivery_in_good_order, value=self.no_two)
MultipleChoiceAnswerFactory(run=run_three, question=self.satisfied_with_delivery, value=self.yes_three)
def add_a_node_with_response(self, number=1):
delivery = DeliveryFactory(track=True)
programme = ProgrammeFactory(name='special_program')
sales_order = SalesOrderFactory(programme=programme)
quantity_received_qn = NumericQuestion.objects.get(label='amountReceived')
while number > 0:
purchase_order = PurchaseOrderFactory(order_number=4748278 + number, sales_order=sales_order)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order,
item=ItemFactory(material_code='Code 23' + str(number),
description='Jerrycans' + str(number)))
self.extra_ip_node = DeliveryNodeFactory(programme=delivery.programme, distribution_plan=delivery,
item=po_item,
quantity=40, acknowledged=40, balance=40, location='Amudat',
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
run = RunFactory(runnable=self.extra_ip_node)
NumericAnswerFactory(question=quantity_received_qn, value=40, run=run)
number -= 1
end_node_one = DeliveryNodeFactory(programme=delivery.programme,
consignee=self.end_user,
parents=[(self.extra_ip_node, 30)],
tree_position=DistributionPlanNode.END_USER,
item=po_item)
run_end_node_one = RunFactory(runnable=end_node_one)
NumericAnswerFactory(question=quantity_received_qn, value=43, run=run_end_node_one)
def test_should_filter_based_on_outcome_and_ip(self):
outcome_one = ProgrammeFactory(name='Outcome One')
outcome_two = ProgrammeFactory(name='Outcome Two')
consignee_one = ConsigneeFactory(name="Consignee One", type=Consignee.TYPES.implementing_partner)
consignee_two = ConsigneeFactory(name="Consignee Two", type=Consignee.TYPES.implementing_partner)
delivery_one = DeliveryFactory(programme=outcome_one, track=True)
delivery_two = DeliveryFactory(programme=outcome_two, track=True)
DeliveryNodeFactory(
distribution_plan=delivery_one,
consignee=consignee_one,
tree_position=Flow.Label.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(
distribution_plan=delivery_two,
consignee=consignee_one,
tree_position=Flow.Label.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(
distribution_plan=delivery_two,
consignee=consignee_two,
tree_position=Flow.Label.IMPLEMENTING_PARTNER)
endpoint_url = BACKEND_URL + 'stock-report?consignee=%d&outcome=%d' % (consignee_one.id, 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)
self.assertEqual(results[0]['items'][0]['consignee'], 'Consignee One')
def test_should_get_a_nodes_ip_from_the_root_node_of_its_first_parent(
self):
root_node = DeliveryNodeFactory()
self.assertEqual(
root_node.get_ip(), {
'id': root_node.id,
'consignee': root_node.consignee,
'location': root_node.location
})
second_parent = DeliveryNodeFactory()
self.assertEqual(
second_parent.get_ip(), {
'id': second_parent.id,
'consignee': second_parent.consignee,
'location': second_parent.location
})
first_level_child_node = DeliveryNodeFactory(
parents=[(root_node, 2), (second_parent, 3)])
self.assertEqual(
first_level_child_node.get_ip(), {
'id': root_node.id,
'consignee': root_node.consignee,
'location': root_node.location
})
second_level_child_node = DeliveryNodeFactory(
parents=[(first_level_child_node, 2)])
self.assertEqual(
second_level_child_node.get_ip(), {
'id': root_node.id,
'consignee': root_node.consignee,
'location': root_node.location
})
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_returned_nodes_should_have_order_type_field(self):
po_node = DeliveryNodeFactory(item=PurchaseOrderItemFactory(purchase_order=(PurchaseOrderFactory())))
ro_node = DeliveryNodeFactory(item=ReleaseOrderItemFactory(release_order=(ReleaseOrderFactory())))
response = self.client.get(ENDPOINT_URL)
node_order_types = [node['order_type'] for node in response.data]
self.assertItemsEqual([po_node.type(), ro_node.type()], node_order_types)
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 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_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_node_should_calculate_total_value_from_order_item_value(self):
po_item_one = PurchaseOrderItemFactory(value=400, quantity=200)
po_item_two = PurchaseOrderItemFactory(value=600, quantity=100)
node_one = DeliveryNodeFactory(item=po_item_one, quantity=50)
node_two = DeliveryNodeFactory(item=po_item_two, quantity=50)
self.assertEqual(node_one.total_value, 100)
self.assertEqual(node_two.total_value, 300)
def test_should_return_list_of_children(self):
parent_node = DeliveryNodeFactory(quantity=100)
child_one = DeliveryNodeFactory(parents=[(parent_node, 30)])
child_two = DeliveryNodeFactory(parents=[(parent_node, 20)])
children = parent_node.children()
self.assertEqual(children.count(), 2)
self.assertIn(child_one, children)
self.assertIn(child_two, children)
def test_should_compute_quantity_out_from_outgoing_arcs(self):
node_one = DeliveryNodeFactory(quantity=50)
node_two = DeliveryNodeFactory()
ArcFactory(source=node_one, target=node_two, quantity=50)
self.assertEqual(node_one.quantity_out(), 50)
self.assertEqual(node_two.quantity_out(), 0)
Arc.objects.all().delete()
self.assertEqual(node_one.quantity_out(), 0)
def _create_node(self, delivery, is_purchase, order_number, track, tree_position, location='Madagascar'):
if is_purchase:
DeliveryNodeFactory(
track=track, distribution_plan=delivery, tree_position=tree_position, location=location,
item=PurchaseOrderItemFactory(purchase_order=PurchaseOrderFactory(order_number=order_number)))
else:
DeliveryNodeFactory(
track=track, distribution_plan=delivery, tree_position=tree_position, location=location,
item=ReleaseOrderItemFactory(release_order=ReleaseOrderFactory(waybill=order_number)))
def test_should_filter_distribution_plan_nodes_by_contact_person_id(self):
contact_person_id = '8541BD02-E862-48FD-952D-470445347DAE'
DeliveryNodeFactory()
node = DeliveryNodeFactory(contact_person_id=contact_person_id, additional_remarks='It is very good')
self.assertEqual(DeliveryNode.objects.count(), 2)
response = self.client.get('%s?contact_person_id=%s' % (ENDPOINT_URL, contact_person_id))
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'], node.id)
self.assertEqual(response.data[0]['additional_remarks'], node.additional_remarks)
def test_should_return_no_results_when_from_date_greater_than_all_dates_on_nodes(self):
DeliveryNodeFactory(delivery_date=datetime.date(2015, 10, 1), tree_position=Flow.Label.IMPLEMENTING_PARTNER)
DeliveryNodeFactory(delivery_date=datetime.date(2015, 11, 1), tree_position=Flow.Label.IMPLEMENTING_PARTNER)
endpoint_url = BACKEND_URL + 'stock-report?fromDate=2015-11-15'
response = self.client.get(endpoint_url)
results = response.data['results']
self.assertEqual(len(results), 0)
def test_should_set_total_value_on_multiple_parent_node_when_saved(self):
parent_one = DeliveryNodeFactory(quantity=100)
parent_two = DeliveryNodeFactory(quantity=100)
po_item = PurchaseOrderItemFactory(quantity=100, value=1000.0)
node = DeliveryNodeFactory(parents=[(parent_one, 50),
(parent_two, 40)],
item=po_item)
self.assertEqual(node.total_value, 900)
def test_should_include_order_number_in_delivery_node_fields(self):
purchase_order = PurchaseOrderFactory(order_number=200)
DeliveryNodeFactory(item=PurchaseOrderItemFactory(purchase_order=purchase_order))
release_order = ReleaseOrderFactory(waybill=300)
DeliveryNodeFactory(item=ReleaseOrderItemFactory(release_order=release_order))
response = self.client.get(ENDPOINT_URL)
node_order_numbers = [node['order_number'] for node in response.data]
self.assertItemsEqual([300, 200], node_order_numbers)
def test_should_know_its_order_number(self):
purchase_order = PurchaseOrderFactory(order_number=200)
po_node = DeliveryNodeFactory(item=PurchaseOrderItemFactory(
purchase_order=purchase_order))
self.assertEqual(po_node.order_number(), 200)
release_order = ReleaseOrderFactory(waybill=300)
ro_node = DeliveryNodeFactory(item=ReleaseOrderItemFactory(
release_order=release_order))
self.assertEqual(ro_node.order_number(), 300)
def test_should_update_delivery_node_parents(self):
node_one = DeliveryNodeFactory()
node = DeliveryNodeFactory(parents=[{'id': node_one.id, 'quantity': 5}])
changes = {'parents': [{'id': node_one.id, 'quantity': 8}]}
path = '%s%d/' % (ENDPOINT_URL, node.id)
response = self.client.patch(path, data=json.dumps(changes), content_type='application/json')
self.assertEqual(response.status_code, 200)
self.assertEqual(node.quantity_in(), 8)
def test_should_paginate_items_list_on_request(self):
DeliveryNodeFactory()
DeliveryNodeFactory()
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_nodes_by_location(self):
kagoma_one = DeliveryNodeFactory(location='Kagoma')
DeliveryNodeFactory(location='Kabaale')
kagoma_two = DeliveryNodeFactory(location='Kagoma')
response = self.client.get('%s?search=%s' % (ENDPOINT_URL, 'Kag'))
nodes = response.data
node_ids = [node['id'] for node in nodes]
self.assertEqual(len(nodes), 2)
self.assertItemsEqual([kagoma_one.id, kagoma_two.id], node_ids)
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_search_nodes_by_date(self):
delivery_node = DeliveryNodeFactory(delivery_date=datetime(2014, 04, 14))
DeliveryNodeFactory(delivery_date=datetime(2015, 04, 23))
response = self.client.get('%s?search=%s' % (ENDPOINT_URL, '2014-04'))
nodes = response.data
node_ids = [node['id'] for node in nodes]
self.assertEqual(len(nodes), 1)
self.assertItemsEqual([delivery_node.id], node_ids)
def test_should_create_itself_with_any_type_of_order_item(self):
purchase_order_item = PurchaseOrderItemFactory()
release_order_item = ReleaseOrderItemFactory()
node_with_po_item = DeliveryNodeFactory(item=purchase_order_item)
node_with_ro_item = DeliveryNodeFactory(item=release_order_item)
self.assertEqual(DeliveryNode.objects.get(item=purchase_order_item),
node_with_po_item)
self.assertEqual(DeliveryNode.objects.get(item=release_order_item),
node_with_ro_item)
def test_should_create_itself_with_parent_as_list_of_parent_quantity_tuples(
self):
parent_one = DeliveryNodeFactory(quantity=100)
parent_two = DeliveryNodeFactory(quantity=40)
node = DeliveryNodeFactory(parents=[(parent_one, 50), (parent_two,
40)])
self.assertEqual(node.quantity_in(), 90)
self.assertEqual(parent_one.quantity_out(), 50)
self.assertEqual(parent_two.quantity_out(), 40)
def test_should_ignore_updates_to_quantity_on_non_root_node(self):
node_one = DeliveryNodeFactory()
node = DeliveryNodeFactory(parents=[{
'id': node_one.id,
'quantity': 7
}])
node.quantity = 50
node.save()
self.assertEqual(node.quantity_in(), 7)
