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_delivery_node_knows_its_item_description(self): purchase_order = PurchaseOrderFactory(order_number=200) description = "some description" item = ItemFactory(description=description) po_node = DeliveryNodeFactory(item=PurchaseOrderItemFactory(purchase_order=purchase_order, item=item)) self.assertEqual(po_node.item_description(), description)
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_create_alert_with_item_description(self, mock_contact): purchase_order = PurchaseOrderFactory(order_number=5678) description = "some description" item = ItemFactory(description=description) purchase_order_item = PurchaseOrderItemFactory(purchase_order=purchase_order, item=item) 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 node = DeliveryNodeFactory(item=purchase_order_item, consignee=consignee, contact_person_id=contact_person_id) node.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, node) self.assertEqual(alert.item_description, description)
def test_should_delete_node_from_elasticsearch_when_deleted(self): node = DeliveryNodeFactory() SyncInfo.objects.create(status=SyncInfo.STATUS.SUCCESSFUL) node.delete() nodes_to_delete = list_nodes_to_delete() self.assertIn(node.id, nodes_to_delete)
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_delete_tracked_node_on_update_with_zero_quantity(self): node = DeliveryNodeFactory(quantity=10, track=True) self.assertEqual(DeliveryNode.objects.count(), 1) node.quantity = 0 returned_node = node.save() self.assertEqual(DeliveryNode.objects.count(), 0) self.assertTrue(isinstance(returned_node, DeliveryNode))
def test_should_delete_tracked_node_on_update_with_zero_quantity(self): node = DeliveryNodeFactory(quantity=10, track=True) self.assertEqual(DeliveryNode.objects.count(), 1) node.quantity = 0 returned_node = node.save() self.assertEqual(DeliveryNode.objects.count(), 0) self.assertTrue(isinstance(returned_node, DeliveryNode))
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)
def test_delivery_node_knows_its_item_description(self): purchase_order = PurchaseOrderFactory(order_number=200) description = "some description" item = ItemFactory(description=description) po_node = DeliveryNodeFactory(item=PurchaseOrderItemFactory( purchase_order=purchase_order, item=item)) self.assertEqual(po_node.item_description(), description)
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_schedule_flow_to_start_after_buffer_when_calculated_send_time_is_in_past(self): some_date = FakeDate.today() - datetime.timedelta(days=10) node = NodeFactory(delivery_date=some_date) node.build_contact = MagicMock(return_value=self.contact) schedule_run_for(node) self.assertEqual(mock_celery.invoked_after, 10.0)
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 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_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_queue_run_for_a_contact_if_contact_has_current_run_for_a_different_runnable(self, mock_run_queue_enqueue): RunFactory(runnable=self.node) node_two = NodeFactory(contact_person_id=self.node.contact_person_id) node_two.build_contact = MagicMock(return_value=self.contact) mock_run_queue_enqueue.return_value = None schedule_run_for(node_two) mock_run_queue_enqueue.assert_called_with(node_two, ANY)
def test_should_queue_run_for_a_contact_if_contact_has_current_run_for_a_different_runnable( self, mock_run_queue_enqueue): RunFactory(runnable=self.node) node_two = NodeFactory(contact_person_id=self.node.contact_person_id) node_two.build_contact = MagicMock(return_value=self.contact) mock_run_queue_enqueue.return_value = None self.flow_scheduler.schedule_run_for(node_two) mock_run_queue_enqueue.assert_called_with(node_two, ANY)
def test_should_schedule_flow_to_start_after_buffer_when_calculated_send_time_is_in_past( self): some_date = FakeDate.today() - datetime.timedelta(days=10) node = NodeFactory(delivery_date=some_date) node.build_contact = MagicMock(return_value=self.contact) self.flow_scheduler.schedule_run_for(node) self.assertEqual(self.mock_celery.invoked_after, 10.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_schedule_end_user_flow_if_node_tree_position_is_end_user(self): node = NodeFactory(tree_position=Node.END_USER) node.build_contact = MagicMock(return_value=self.contact) Runnable.objects.get = MagicMock(return_value=node) self.flow_scheduler.schedule_run_for(node) self.mocked_create_run.assert_called_with(self.contact, self.end_user_flow, ANY, ANY)
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_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_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 test_should_schedule_middleman_flow_if_node_tree_position_is_middleman(self): node = NodeFactory(tree_position=Node.MIDDLE_MAN) node.build_contact = MagicMock(return_value=self.contact) Runnable.objects.get = MagicMock(return_value=node) self.flow_scheduler.schedule_run_for(node) self.mocked_create_run.assert_called_with(self.contact, self.middle_man_flow, ANY, ANY)
def test_node_flow_is_middleman_for_non_end_user_node(self): middleman_flow = FlowFactory(label=Flow.Label.MIDDLE_MAN) runnable = DeliveryNodeFactory(tree_position=Flow.Label.IMPLEMENTING_PARTNER) self.assertEqual(runnable.flow(), middleman_flow) runnable.tree_position = Flow.Label.MIDDLE_MAN self.assertEqual(runnable.flow(), middleman_flow)
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_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_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_in_from_incoming_arcs(self): node = DeliveryNodeFactory(quantity=0) ArcFactory(source=None, target=node, quantity=50) self.assertEqual(node.quantity_in(), 50) ArcFactory(source=None, target=node, quantity=50) self.assertEqual(node.quantity_in(), 100) Arc.objects.all().delete() self.assertEqual(node.quantity_in(), 0)
def test_should_add_changed_node_to_sync_data(self, *_): node = DeliveryNodeFactory(location='Kampala') SyncInfo.objects.create(status=SyncInfo.STATUS.SUCCESSFUL) list_nodes_to_update() node.location = 'Changed location' node.save() nodes_to_sync = list_nodes_to_update() self.assertIn(node, nodes_to_sync)
def test_should_schedule_end_user_flow_if_node_tree_position_is_end_user(self): node = NodeFactory(tree_position=Node.END_USER) node.build_contact = MagicMock(return_value=self.contact) Runnable.objects.get = MagicMock(return_value=node) schedule_run_for(node) mock_start_delivery_run.assert_called_with(contact_person=self.contact, flow=self.END_USER_FLOW_ID, item_description=ANY, sender=ANY)
def test_should_compute_quantity_in_from_incoming_arcs(self): node = DeliveryNodeFactory(quantity=0) ArcFactory(source=None, target=node, quantity=50) self.assertEqual(node.quantity_in(), 50) ArcFactory(source=None, target=node, quantity=50) self.assertEqual(node.quantity_in(), 100) Arc.objects.all().delete() self.assertEqual(node.quantity_in(), 0)
def test_node_flow_is_middleman_for_non_end_user_node(self): middleman_flow = FlowFactory(label=Flow.Label.MIDDLE_MAN) runnable = DeliveryNodeFactory( tree_position=Flow.Label.IMPLEMENTING_PARTNER) self.assertEqual(runnable.flow(), middleman_flow) runnable.tree_position = Flow.Label.MIDDLE_MAN self.assertEqual(runnable.flow(), middleman_flow)
def test_update_should_leave_parents_intact_if_parents_are_not_specified(self): node_one = DeliveryNodeFactory() node_two = DeliveryNodeFactory() node = DeliveryNodeFactory(parents=[{'id': node_one.id, 'quantity': 8}, {'id': node_two.id, 'quantity': 10}]) node.location = 'Changed' node.save() self.assertEqual(node.quantity_in(), 18) self.assertEqual(node.location, 'Changed')
def test_should_add_changed_node_to_sync_data(self, *_): node = DeliveryNodeFactory(location='Kampala') SyncInfo.objects.create(status=SyncInfo.STATUS.SUCCESSFUL) list_nodes_to_update() node.location = 'Changed location' node.save() nodes_to_sync = list_nodes_to_update() self.assertIn(node, nodes_to_sync)
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_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_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_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(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_schedule_end_user_flow_if_node_tree_position_is_end_user( self): node = NodeFactory(tree_position=Node.END_USER) node.build_contact = MagicMock(return_value=self.contact) Runnable.objects.get = MagicMock(return_value=node) self.flow_scheduler.schedule_run_for(node) self.mocked_create_run.assert_called_with(self.contact, self.end_user_flow, ANY, ANY)
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_not_include_match_clauses_with_empty_id_lists(self, mock_scan): node = DeliveryNodeFactory(location='Kampala') SyncInfo.objects.create(status=SyncInfo.STATUS.SUCCESSFUL) list_nodes_to_update() node.location = 'Changed location' node.save() nodes_to_sync = list_nodes_to_update() self.assertFalse(mock_scan.called) self.assertIn(node, nodes_to_sync)
def test_should_build_contact_with_details_from_contacts_service(self, mock_get): contact_id = '54335c56b3ae9d92f038abb0' fake_contact_json = {'firstName': "test", 'lastName': "user1", 'phone': "+256 782 443439", '_id': contact_id} fake_response = FakeResponse(fake_contact_json, 200) node = NodeFactory(contact_person_id=contact_id) mock_get.return_value = fake_response contact = node.build_contact() self.assertEqual(contact, fake_contact_json) mock_get.assert_called_with("%s%s/" % (settings.CONTACTS_SERVICE_URL, contact_id))
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_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 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_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_create_delivery_node_with_parents(self): node_one = DeliveryNodeFactory() node_two = DeliveryNodeFactory() self.node_details['parents'] = [{'id': node_one.id, 'quantity': 5}, {'id': node_two.id, 'quantity': 6}] response = self.client.post(ENDPOINT_URL, data=json.dumps(self.node_details), content_type='application/json') node = DeliveryNode.objects.get(pk=response.data['id']) self.assertEqual(response.status_code, 201) self.assertTrue(node.quantity_in(), 11) self.assertTrue(node_one.quantity_out(), 5) self.assertTrue(node_two.quantity_out(), 6)
def test_should_update_parent_total_value_if_root_node_when_saved(self): po_item = PurchaseOrderItemFactory(quantity=100, value=1000.0) parent = DeliveryFactory() DeliveryNodeFactory(quantity=80, item=po_item, distribution_plan=parent) self.assertEqual(parent.total_value, 800) DeliveryNodeFactory(quantity=90, item=po_item, distribution_plan=parent) self.assertEqual(parent.total_value, 1700)
def create_nodes(self): self.ip_node = DeliveryNodeFactory(quantity=100) self.middle_man_node = DeliveryNodeFactory( parents=[(self.ip_node, 100)], tree_position=DistributionPlanNode.MIDDLE_MAN, distribution_plan=self.ip_node.distribution_plan, item=self.item) self.end_user_node = DeliveryNodeFactory( parents=[(self.middle_man_node, 100)], tree_position=DistributionPlanNode.END_USER, distribution_plan=self.ip_node.distribution_plan, item=self.item)
def test_should_filter_based_on_to_date(self): DeliveryNodeFactory(distribution_plan=DeliveryFactory(track=True), delivery_date=datetime.date(2015, 10, 1), tree_position=Flow.Label.IMPLEMENTING_PARTNER) DeliveryNodeFactory(distribution_plan=DeliveryFactory(track=True), delivery_date=datetime.date(2015, 11, 1), tree_position=Flow.Label.IMPLEMENTING_PARTNER) endpoint_url = BACKEND_URL + 'stock-report?toDate=2015-10-15' response = self.client.get(endpoint_url) results = response.data['results'] self.assertEqual(len(results), 1) self.assertEqual(results[0]['last_shipment_date'], '2015-10-01')
def test_should_schedule_flow_with_sender_as_parent_node_consignee_name_if_node_has_parent(self): sender_org_name = "Dwelling Places" sender_org = ConsigneeFactory(name=sender_org_name) parent_node = NodeFactory(consignee=sender_org) node = NodeFactory(consignee=sender_org, parents=[(parent_node, 10)]) node.build_contact = MagicMock(return_value=self.contact) Runnable.objects.get = MagicMock(return_value=node) node.consignee.build_contact = MagicMock(return_value=self.contact) self.flow_scheduler.schedule_run_for(node) self.mocked_create_run.assert_called_with(self.contact, ANY, node.item.item.description, sender_org_name)
def test_should_ignore_quantity_on_update_if_parents_are_specified(self): node_one = DeliveryNodeFactory() node = DeliveryNodeFactory(quantity=0) node.parents = [{'id': node_one.id, 'quantity': 7}] node.quantity = 50 node.save() self.assertEqual(node.quantity_in(), 7) node.parents = [] node.save() self.assertEqual(node.quantity_in(), 0)
def test_should_update_balance_when_node_quantities_change(self): node = DeliveryNodeFactory(quantity=100, acknowledged=100) child = DeliveryNodeFactory(parents=[(node, 50)]) self.assertEqual(child.balance, 50) self.assertEqual(DeliveryNode.objects.get(id=node.id).balance, 50) child_two = DeliveryNodeFactory(parents=[(node, 40)]) self.assertEqual(child_two.balance, 40) self.assertEqual(DeliveryNode.objects.get(id=node.id).balance, 10) child_two.delete() self.assertEqual(DeliveryNode.objects.get(id=node.id).balance, 50)
def test_should_schedule_flow_with_sender_as_parent_node_consignee_name_if_node_has_parent(self): sender_org_name = "Dwelling Places" sender_org = ConsigneeFactory(name=sender_org_name) parent_node = NodeFactory(consignee=sender_org) node = NodeFactory(consignee=sender_org, parents=[(parent_node, 10)]) node.build_contact = MagicMock(return_value=self.contact) Runnable.objects.get = MagicMock(return_value=node) node.consignee.build_contact = MagicMock(return_value=self.contact) schedule_run_for(node) mock_start_delivery_run.assert_called_with(contact_person=self.contact, flow=ANY, sender=sender_org_name, item_description=node.item.item.description)
def test_update_should_override_parents_when_parents_list_is_passed(self): node_one = DeliveryNodeFactory() node_two = DeliveryNodeFactory() node = DeliveryNodeFactory(parents=[{'id': node_one.id, 'quantity': 8}, {'id': node_two.id, 'quantity': 10}]) self.assertEqual(node.quantity_in(), 18) node.parents = [{'id': node_one.id, 'quantity': 7}] node.save() self.assertEqual(node.quantity_in(), 7) node.parents = [] node.save() self.assertEqual(node.quantity_in(), 0)
def test_should_get_latest_response(self): multichoice_question = MultipleChoiceQuestionFactory(label='productReceived') no_option = OptionFactory(text='No', question=multichoice_question) sugar = ItemFactory(description='Sugar') numeric_question = NumericQuestionFactory(label='AmountReceived') node = DeliveryNodeFactory(quantity=100, item=PurchaseOrderItemFactory(item=sugar)) run = RunFactory(runnable=node, status='completed') self.assertIsNone(node.latest_response()) multiple_answer = MultipleChoiceAnswerFactory(run=run, question=multichoice_question, value=no_option) self.assertEqual(node.latest_response(), multiple_answer) numeric_answer = NumericAnswerFactory(run=run, value=80, question=numeric_question) self.assertEqual(node.latest_response(), numeric_answer)