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")