def test_should_return_multiple_deliveries_along_with_their_corresponding_nodes(
self):
order = PurchaseOrderFactory()
order_item_one = PurchaseOrderItemFactory(purchase_order=order)
order_item_two = PurchaseOrderItemFactory(purchase_order=order)
delivery_one = DeliveryFactory()
delivery_two = DeliveryFactory()
node_one = NodeFactory(item=order_item_one,
distribution_plan=delivery_one)
node_two = NodeFactory(item=order_item_two,
distribution_plan=delivery_one)
node_three = NodeFactory(item=order_item_one,
distribution_plan=delivery_two)
node_four = NodeFactory(item=order_item_two,
distribution_plan=delivery_two)
deliveries = order.deliveries()
self.assertEqual(len(deliveries), 2)
self.assertIn(delivery_one, list(deliveries))
self.assertIn(delivery_two, list(deliveries))
first_delivery_nodes = delivery_one.distributionplannode_set.all()
second_delivery_nodes = delivery_two.distributionplannode_set.all()
self.assertIn(node_one, first_delivery_nodes)
self.assertIn(node_two, first_delivery_nodes)
self.assertIn(node_three, second_delivery_nodes)
self.assertIn(node_four, second_delivery_nodes)
def test_should_know_if_it_is_fully_delivered_or_not_using_only_tracked_nodes(
self):
purchase_order = PurchaseOrderFactory()
item_one = PurchaseOrderItemFactory(purchase_order=purchase_order,
quantity=100)
item_two = PurchaseOrderItemFactory(purchase_order=purchase_order,
quantity=100)
self.assertFalse(purchase_order.is_fully_delivered())
delivery = DeliveryFactory()
node_one = NodeFactory(
item=item_one,
quantity=100,
distribution_plan=delivery,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
self.assertFalse(purchase_order.is_fully_delivered())
node_two = NodeFactory(
item=item_two,
quantity=100,
distribution_plan=delivery,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
self.assertFalse(purchase_order.is_fully_delivered())
delivery.track = True
delivery.save()
node_two.quantity = 50
node_two.save()
self.assertFalse(purchase_order.is_fully_delivered())
node_two.quantity = 100
node_two.save()
self.assertTrue(purchase_order.is_fully_delivered())
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 test_should_return_deliveries_made_by_logged_in_consignee_for_a_specific_item(
self):
self.logout()
self.log_consignee_in(self.consignee)
item = ItemFactory()
parent_node_one = DeliveryNodeFactory(consignee=self.consignee)
parent_node_two = DeliveryNodeFactory(consignee=self.consignee)
non_consignee_node = DeliveryNodeFactory()
child_one = DeliveryNodeFactory(
item=PurchaseOrderItemFactory(item=item),
parents=[(parent_node_one, 10)])
child_two = DeliveryNodeFactory(
item=PurchaseOrderItemFactory(item=item),
parents=[(parent_node_two, 5)])
child_three = DeliveryNodeFactory(
item=PurchaseOrderItemFactory(item=item),
parents=[(non_consignee_node, 2)])
url_template = '%s?consignee_deliveries_for_item=%d&paginate=true'
response = self.client.get(url_template % (ENDPOINT_URL, item.id))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['count'], 2)
self.assertEqual(response.data['pageSize'], 10)
node_ids = map(lambda node_dict: node_dict['id'],
response.data['results'])
self.assertItemsEqual([child_one.id, child_two.id], node_ids)
self.assertNotIn(child_three.id, node_ids)
def setup_purchase_order_items(self):
self.po_item_one = PurchaseOrderItemFactory(
purchase_order=self.po_one, sales_order_item=self.po_item_one)
self.po_item_two = PurchaseOrderItemFactory(
purchase_order=self.po_one, sales_order_item=self.po_item_two)
self.po_item_three = PurchaseOrderItemFactory(
purchase_order=self.po_two, sales_order_item=self.po_item_three)
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_first_related_purchase_order_item(self):
sales_order_item = SalesOrderItemFactory()
purchase_order_item = PurchaseOrderItemFactory(
sales_order_item=sales_order_item)
PurchaseOrderItemFactory(sales_order_item=sales_order_item)
self.assertEqual(sales_order_item.purchase_order_item(),
purchase_order_item)
def test_should_only_include_top_level_nodes_when_calculating_available_balance(self):
purchase_order_item = PurchaseOrderItemFactory(purchase_order=(PurchaseOrderFactory()), quantity=500)
root_one = NodeFactory(item=purchase_order_item, quantity=200, distribution_plan=DeliveryFactory(track=True))
self.assertEquals(purchase_order_item.available_balance(), 300)
NodeFactory(item=purchase_order_item, parents=[(root_one, 120)], distribution_plan=DeliveryFactory(track=True))
self.assertEquals(purchase_order_item.available_balance(), 300)
def test_balance_should_decrease_when_nodes_exist(self):
purchase_order = PurchaseOrderFactory()
purchase_order_item = PurchaseOrderItemFactory(
purchase_order=purchase_order,
quantity=500)
NodeFactory(item=purchase_order_item, targeted_quantity=200)
NodeFactory(item=purchase_order_item, targeted_quantity=120)
self.assertEquals(purchase_order_item.available_balance(), 180)
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_compute_purchase_order_total_value(self):
order = PurchaseOrderFactory()
PurchaseOrderItemFactory(purchase_order=order, value=100)
total_value_route = '%s%d/total_value/' % (ENDPOINT_URL, order.id)
response = self.client.get(total_value_route)
self.assertEqual(response.data, 100)
PurchaseOrderItemFactory(purchase_order=order, value=200)
response = self.client.get(total_value_route)
self.assertEqual(response.data, 300)
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_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_filter_purchase_order_items_by_consignee_and_purchase_order(
self):
po_item = PurchaseOrderItemFactory()
PurchaseOrderItemFactory()
consignee = ConsigneeFactory()
DeliveryNodeFactory(item=po_item, consignee=consignee)
response = self.client.get(
'%s?consignee=%d&purchase_order=%d' %
(ENDPOINT_URL, consignee.id, po_item.purchase_order_id))
self.assertEqual(PurchaseOrderItem.objects.count(), 2)
self.assertEqual(len(response.data), 1)
self.assertDictContainsSubset({'id': po_item.id}, response.data[0])
def test_should_only_include_top_level_nodes_when_calculating_available_balance(
self):
purchase_order_item = PurchaseOrderItemFactory(quantity=500)
root_one = NodeFactory(item=purchase_order_item,
quantity=200,
distribution_plan=DeliveryFactory(track=True))
self.assertEquals(purchase_order_item.available_balance(), 300)
NodeFactory(item=purchase_order_item,
parents=[(root_one, 120)],
distribution_plan=DeliveryFactory(track=True))
self.assertEquals(purchase_order_item.available_balance(), 300)
def test_balance_should_decrease_when_tracked_nodes_exist(self):
purchase_order_item = PurchaseOrderItemFactory(purchase_order=(PurchaseOrderFactory()), quantity=500)
delivery = DeliveryFactory()
node_one = NodeFactory(item=purchase_order_item, quantity=200, distribution_plan=delivery)
self.assertEquals(purchase_order_item.available_balance(), 500)
delivery.track = True
delivery.save()
self.assertEquals(purchase_order_item.available_balance(), 300)
NodeFactory(item=purchase_order_item, quantity=120, distribution_plan=delivery)
self.assertEquals(purchase_order_item.available_balance(), 180)
def test_should_get_orders__as_a_queryset__whose_items_have_been_delivered_to_a_specific_consignee(self):
consignee = ConsigneeFactory()
order_one = PurchaseOrderFactory()
order_two = PurchaseOrderFactory()
order_three = PurchaseOrderFactory()
order_item_one = PurchaseOrderItemFactory(purchase_order=order_one)
order_item_two = PurchaseOrderItemFactory(purchase_order=order_two)
NodeFactory(item=order_item_one, consignee=consignee)
NodeFactory(item=order_item_two, consignee=consignee)
consignee_orders = PurchaseOrder.objects.for_consignee(consignee.id).order_by('id')
self.assertListEqual(list(consignee_orders), [order_one, order_two])
self.assertNotIn(order_three, consignee_orders)
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_return_number_of_items_on_the_delivery(self):
purchase_order = PurchaseOrderFactory(order_number=98765)
po_item_one = PurchaseOrderItemFactory(purchase_order=purchase_order)
po_item_two = PurchaseOrderItemFactory(purchase_order=purchase_order)
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery, item=po_item_one)
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.data[0]['number_of_items'], 1)
DeliveryNodeFactory(distribution_plan=delivery, item=po_item_two)
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.data[0]['number_of_items'], 2)
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_know_if_it_has_a_distribution_plan_or_not(self):
purchase_order = PurchaseOrderFactory()
purchase_order_item = PurchaseOrderItemFactory(
purchase_order=purchase_order)
self.assertFalse(purchase_order.has_plan())
NodeFactory(item=purchase_order_item)
self.assertTrue(purchase_order.has_plan())
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_get_track_status_if_delivery_is_sent_partially(self):
order = PurchaseOrderFactory()
order_item = PurchaseOrderItemFactory(purchase_order=order, quantity=100)
delivery_one = DeliveryFactory(track=True)
NodeFactory(item=order_item, distribution_plan=delivery_one, quantity=50, track=True)
self.assertEqual(order.track(), PurchaseOrder.PARTIALLY_TRACKED)
def test_should_return_delivery_with_order_number(self):
po = PurchaseOrderFactory(order_number=123456)
po_item = PurchaseOrderItemFactory(purchase_order=po)
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery, item=po_item)
self.assertEqual(delivery.number(), 123456)
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 test_node_should_get_its_parents_distribution_plan_when_for_single_parent(
self):
purchaser_order_item = PurchaseOrderItemFactory()
delivery_one = DeliveryFactory()
delivery_two = DeliveryFactory()
root_one = DeliveryNodeFactory(distribution_plan=delivery_one,
item=purchaser_order_item,
quantity=50)
root_two = DeliveryNodeFactory(distribution_plan=delivery_two,
item=purchaser_order_item,
quantity=60)
child_one = DeliveryNodeFactory(parents=[(root_one, 10)],
distribution_plan=None)
child_two = DeliveryNodeFactory(parents=[(root_two, 20)],
distribution_plan=None)
child_three = DeliveryNodeFactory(parents=[(root_one, 10),
(root_two, 10)],
distribution_plan=None)
self.assertEqual(child_one.distribution_plan, delivery_one)
self.assertEqual(child_two.distribution_plan, delivery_two)
self.assertIsNone(child_three.distribution_plan)
grand_child_one = DeliveryNodeFactory(parents=[(child_one, 5)],
distribution_plan=None)
grand_child_two = DeliveryNodeFactory(parents=[(child_two, 20)],
distribution_plan=None)
grand_child_three = DeliveryNodeFactory(parents=[(child_three, 15)],
distribution_plan=None)
self.assertEqual(grand_child_one.distribution_plan, delivery_one)
self.assertEqual(grand_child_two.distribution_plan, delivery_two)
self.assertIsNone(grand_child_three.distribution_plan)
def test_should_get_root_nodes_for_an_order_item_list(self):
purchase_order_item_one = PurchaseOrderItemFactory()
purchase_order_item_two = PurchaseOrderItemFactory()
root_node_one = DeliveryNodeFactory(item=purchase_order_item_one)
root_node_two = DeliveryNodeFactory(item=purchase_order_item_two)
DeliveryNodeFactory(item=purchase_order_item_one,
parents=[(root_node_one, 5)])
item_list = PurchaseOrderItem.objects.filter(
pk__in=[purchase_order_item_one.pk, purchase_order_item_two.pk])
root_nodes = DeliveryNode.objects.root_nodes_for(order_items=item_list)
self.assertEqual(root_nodes.count(), 2)
self.assertIn(root_node_one, root_nodes)
self.assertIn(root_node_two, root_nodes)
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_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_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_filter_deliveries_by_ip_and_number(self):
first_consignee = ConsigneeFactory()
second_consignee = ConsigneeFactory()
purchase_order = PurchaseOrderFactory(order_number=123)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
first_delivery = DeliveryFactory(consignee=first_consignee, track=True)
DeliveryNodeFactory(item=po_item, distribution_plan=first_delivery)
second_delivery = DeliveryFactory(consignee=first_consignee,
track=True)
third_delivery = DeliveryFactory(consignee=second_consignee)
self.logout()
self.log_consignee_in(consignee=first_consignee)
response = self.client.get(ENDPOINT_URL + '?query=123')
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_filter_admin_deliveries_by_multiple_queries(self):
first_consignee = ConsigneeFactory()
second_consignee = ConsigneeFactory()
purchase_order = PurchaseOrderFactory(order_number=123)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
date = datetime.date(2014, 07, 9)
first_delivery = DeliveryFactory(consignee=first_consignee,
track=True,
delivery_date=date)
DeliveryNodeFactory(item=po_item, distribution_plan=first_delivery)
second_delivery = DeliveryFactory(consignee=first_consignee,
track=True,
delivery_date=date)
third_delivery = DeliveryFactory(consignee=second_consignee)
response = self.client.get(ENDPOINT_URL +
'?from=2014-07-6&to=2014-12-31&query=123')
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_decrease_balance_when_saving_tracked_or_not_tracked_nodes(self):
purchase_order_item = PurchaseOrderItemFactory(quantity=500)
delivery = DeliveryFactory()
DeliveryNodeFactory(item=purchase_order_item, quantity=200, distribution_plan=delivery)
self.assertEquals(purchase_order_item.available_balance(), 300)
self.assertEquals(purchase_order_item.quantity_shipped(), 200)
delivery.track = True
delivery.save()
self.assertEquals(purchase_order_item.available_balance(), 300)
self.assertEquals(purchase_order_item.quantity_shipped(), 200)
tracked_delivery = DeliveryFactory(track=True)
DeliveryNodeFactory(item=purchase_order_item, quantity=120, distribution_plan=tracked_delivery)
self.assertEquals(purchase_order_item.available_balance(), 180)
self.assertEquals(purchase_order_item.quantity_shipped(), 320)
def test_should_show_total_quantity_as_balance_when_no_nodes_exist(self):
purchase_order = PurchaseOrderFactory()
purchase_order_item = PurchaseOrderItemFactory(
purchase_order=purchase_order,
quantity=500)
self.assertEquals(purchase_order_item.available_balance(), 500)
def test_should_return_type(self):
purchase_order = PurchaseOrderFactory()
purchase_order_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
self.assertEqual(purchase_order_item.type(), "Purchase Order")
