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 create_runs_and_answers(self): self.run_one = RunFactory(runnable=self.middle_man_node, status='completed') self.run_one_multiple_answer_one = MultipleChoiceAnswerFactory( run=self.run_one, question=self.multiple_choice_question, value=self.yes_option) self.run_one_multiple_answer_two = MultipleChoiceAnswerFactory( run=self.run_one, question=self.multiple_choice_question_two, value=self.yes_option) self.run_one_numeric_answer_one = NumericAnswerFactory( run=self.run_one, value=80, question=self.numeric_question) self.run_two = RunFactory(runnable=self.end_user_node, status='completed') self.run_two_multiple_answer_one = MultipleChoiceAnswerFactory( run=self.run_two, question=self.multiple_choice_question, value=self.yes_option) self.run_two_multiple_answer_two = MultipleChoiceAnswerFactory( run=self.run_two, question=self.multiple_choice_question_two, value=self.yes_option) self.run_two_numeric_answer_one = NumericAnswerFactory( run=self.run_two, value=80, question=self.numeric_question)
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_gets_correct_last_shipment_date_value_for_stock_report(self): programme = ProgrammeFactory(name='special_program') delivery = DeliveryFactory(track=True, programme=programme) sales_order = SalesOrderFactory(programme=programme) purchase_order = PurchaseOrderFactory(order_number=4748278, sales_order=sales_order) po_item = PurchaseOrderItemFactory(purchase_order=purchase_order, item=ItemFactory(material_code='Code 23', description='Jerrycans')) ip_node_one = DeliveryNodeFactory(distribution_plan=delivery, item=po_item, quantity=40, tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER, delivery_date=FakeDate.build(2015, 03, 19)) run_one = RunFactory(runnable=ip_node_one) quantity_received_qn = NumericQuestion.objects.get(label='amountReceived') NumericAnswerFactory(question=quantity_received_qn, value=39, run=run_one) last_shipment_date = FakeDate.build(2015, 10, 07) ip_node_two = DeliveryNodeFactory(distribution_plan=delivery, item=po_item, quantity=30, tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER, delivery_date=last_shipment_date) run_two = RunFactory(runnable=ip_node_two) NumericAnswerFactory(question=quantity_received_qn, value=40, run=run_two) expected_data = [ {'document_number': purchase_order.order_number, 'programme': programme.name, 'last_shipment_date': str(last_shipment_date), 'total_value_received': Decimal('79'), 'total_value_dispensed': Decimal('0'), 'total_value_lost': Decimal('0'), 'balance': Decimal('79'), 'items': [{'code': unicode(po_item.item.material_code), 'description': unicode(po_item.item.description), 'consignee': self.ip.name, 'location': ip_node_one.location, 'quantity_delivered': 3, 'date_delivered': str(self.ip_node_two.delivery_date), 'quantity_confirmed': 2, 'date_confirmed': '2014-01-02', 'quantity_dispatched': 2, 'quantity_lost': 0, 'balance': 0 }, {'code': unicode(po_item.item.material_code), 'description': unicode(po_item.item.description), 'consignee': self.ip.name, 'location': ip_node_two.location, 'quantity_delivered': 5, 'date_delivered': str(self.ip_node_one.delivery_date), 'quantity_confirmed': 4, 'date_confirmed': '2014-01-01', 'quantity_dispatched': 2, 'quantity_lost': 0, 'balance': 2 }] }] response = self.client.get(ENDPOINT_URL) self.assert_api_response_with_correct_last_shipment_date(response, expected_data)
def test_should_update_run_status(self): run = RunFactory(status=Run.STATUS.scheduled) run.update_status(Run.STATUS.completed) updated_run = Run.objects.get(id=run.id) self.assertEqual(updated_run.status, Run.STATUS.completed)
def test_should_get_all_answers(self): run = RunFactory() multiple_answer_one = MultipleChoiceAnswerFactory(run=run) numeric_answer_one = NumericAnswerFactory(run=run) run_answers = run.answers() self.assertIn(multiple_answer_one, run_answers) self.assertIn(numeric_answer_one, run_answers)
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_responses_serialisation_should_have_an_entry_for_each_response_a_node_has( self): node = DeliveryNodeFactory() answer_one = MultipleChoiceAnswerFactory(run=RunFactory(runnable=node)) answer_two = MultipleChoiceAnswerFactory(run=RunFactory(runnable=node)) serialised = serialise_nodes([node]) answer_ids = [ response['id'] for response in serialised[0]['responses'] ] self.assertItemsEqual(answer_ids, [answer_one.id, answer_two.id])
def test_should_get_scheduled_runs_for_contact(self): runnable = DeliveryNodeFactory(contact_person_id=2) contact_person_id = 2 self.assertEqual(Run.has_scheduled_run(contact_person_id), False) run = RunFactory(runnable=runnable) self.assertEqual(Run.has_scheduled_run(contact_person_id), True) run.status = Run.STATUS.completed run.save() self.assertEqual(Run.has_scheduled_run(contact_person_id), False)
def setup_runs(self): self.run_one = RunFactory(runnable=self.ip_node_one) self.run_two = RunFactory(runnable=self.ip_node_two) self.run_three = RunFactory(runnable=self.ip_node_three) self.run_four = RunFactory(runnable=self.middle_man_node_one) self.run_five = RunFactory(runnable=self.middle_man_node_two) self.run_six = RunFactory(runnable=self.end_user_node) self.run_delivery_one = RunFactory(runnable=self.plan_one) self.run_delivery_two = RunFactory(runnable=self.plan_two) self.run_delivery_three = RunFactory(runnable=self.plan_three)
def test_should_get_all_questions_and_responses(self): run = RunFactory() item_received_question = MultipleChoiceQuestionFactory(label='product_received') yes = OptionFactory(question=item_received_question, text='Yes') item_received_question.multiplechoiceanswer_set.create(value=yes, run=run) date_received_question = TextQuestionFactory(label='date_received') date_received_question.textanswer_set.create(value='2014-01-01', run=run) quantity_received_question = NumericQuestionFactory(label='quantity_received') quantity_received_question.numericanswer_set.create(value=12, run=run) expected_data = {'product_received': 'Yes', 'quantity_received': 12, 'date_received': '2014-01-01'} self.assertDictEqual(run.questions_and_responses(), expected_data)
def test_should_mark_run_returned_by_dequeue_as_started( self, mock_run_queue_dequeue, *_): uuid = '18aed9e2-125c-4c6d-a73d-c7ecdb53aa8c' question = NumericQuestionFactory( text='How much was received?', label='amountReceived', flow=self.flow, ) self.flow.final_end_nodes = [[question.id, Flow.NO_OPTION]] self.flow.save() current_node = DeliveryNodeFactory() next_node = copy.deepcopy(current_node) RunFactory(runnable=current_node, phone=self.PHONE) next_run_queue = RunQueueFactory( runnable=next_node, contact_person_id=current_node.contact_person_id) mock_run_queue_dequeue.return_value = next_run_queue url_params = self._create_rapid_pro_url_params(self.PHONE, uuid, '42', None, 'amountReceived') self.client.post(HOOK_URL, url_params) run_returned_by_dequeue = RunQueue.objects.get(id=next_run_queue.id) self.assertEqual(run_returned_by_dequeue.status, RunQueue.STATUS.started)
def test_should_return_default_answers_for_delivery(self): delivery = DeliveryFactory() flow = FlowFactory(label='IMPLEMENTING_PARTNER') question_1 = MultipleChoiceQuestionFactory( label='deliveryReceived', flow=flow, text='Was Delivery Received?') question_2 = TextQuestionFactory(label='dateOfReceipt', flow=flow, text='When was Delivery Received?') OptionFactory(text='Yes', question=question_1) RunFactory(runnable=delivery) expected_multiple_choice_answer = { 'question_label': question_1.label, 'type': 'multipleChoice', 'text': question_1.text, 'value': '', 'options': ['Yes'], 'position': question_1.position } expected_text_answer = { 'question_label': question_2.label, 'type': 'text', 'text': question_2.text, 'value': '', 'position': question_2.position } answers = delivery.answers() self.assertEqual(len(answers), 2) self.assertIn(expected_multiple_choice_answer, answers) self.assertIn(expected_text_answer, answers)
def test_should_delete_item_entry_when_the_only_yes_answer_on_a_node_is_deleted(self): yes_answer = MultipleChoiceAnswerFactory(question=self.was_item_received, value=self.yes, run=RunFactory(runnable=self.node)) self.assertEqual(ConsigneeItem.objects.get(consignee=self.consignee, item=self.item).deliveries, [self.node.id]) yes_answer.delete() self.assertFalse(ConsigneeItem.objects.filter(consignee=self.consignee, item=self.item).exists())
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_mark_run_as_complete_when_question_is_final( self, mock_run_queue_dequeue, mock_schedule_next_run, *_): mock_schedule_next_run.return_value = None uuid = '18aed9e2-125c-4c6d-a73d-c7ecdb53aa8c' question = NumericQuestionFactory(text='How much was received?', label='amountReceived', flow=self.flow) node = DeliveryNodeFactory() run = RunFactory(runnable=node, phone=self.PHONE, status=Run.STATUS.scheduled) mock_run_queue_dequeue.return_value = RunQueueFactory( runnable=node, contact_person_id=node.contact_person_id) self.flow.end_nodes = [[question.id, Flow.NO_OPTION]] self.flow.save() url_params = self._create_rapid_pro_url_params(self.PHONE, uuid, '42', None, 'amountReceived') self.client.post(HOOK_URL, url_params) run = Run.objects.get(id=run.id) self.assertEqual(run.status, Run.STATUS.completed)
def test_should_not_return_deliveries_for_ip_if_received_is_false(self): first_consignee = ConsigneeFactory() date = datetime.date(2014, 07, 9) first_delivery = DeliveryFactory(consignee=first_consignee, track=True, delivery_date=date) second_delivery = DeliveryFactory(consignee=first_consignee, track=True) self.logout() self.log_consignee_in(consignee=first_consignee) response = self.client.get(ENDPOINT_URL) ids = map(lambda delivery: delivery['id'], response.data) self.assertEqual(response.status_code, 200) self.assertIn(first_delivery.id, ids) self.assertIn(second_delivery.id, ids) flow = FlowFactory(label=Flow.Label.IMPLEMENTING_PARTNER) delivery_received_qn = MultipleChoiceQuestionFactory(label='deliveryReceived', flow=flow) OptionFactory(question=delivery_received_qn, text='Yes') option_no = OptionFactory(question=delivery_received_qn, text='No') run = RunFactory(runnable=first_delivery) MultipleChoiceAnswerFactory(run=run, question=delivery_received_qn, value=option_no) response = self.client.get(ENDPOINT_URL) ids = map(lambda delivery: delivery['id'], response.data) self.assertEqual(response.status_code, 200) self.assertNotIn(first_delivery.id, ids) self.assertIn(second_delivery.id, ids)
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_should_return_answers_for_delivery_in_the_same_order_as_flow( self): delivery = DeliveryFactory() flow = FlowFactory(label='IMPLEMENTING_PARTNER') question_1 = MultipleChoiceQuestionFactory( label='deliveryReceived', flow=flow, text='Was Delivery Received?', position=3) question_2 = TextQuestionFactory(label='dateOfReceipt', flow=flow, text='When was Delivery Received?', position=1) question_3 = TextQuestionFactory( label='satisfiedWithProduct', flow=flow, text='Are you satisfied with product?', position=2) OptionFactory(text='No', question=question_1) OptionFactory(text='Yes', question=question_1) RunFactory(runnable=delivery) answers = delivery.answers() self.assertEqual(len(answers), 3) self.assertEqual(question_2.label, answers[0]['question_label']) self.assertEqual(question_3.label, answers[1]['question_label']) self.assertEqual(question_1.label, answers[2]['question_label'])
def test_should_record_an_answer_of_type_multiple_choice_for_a_node_from_request_data( self, *_): uuid = '5b0f1f19-767f-47f1-97a5-b9b32c45a47c' question = MultipleChoiceQuestionFactory(text='Was product received?', label='productReceived', flow=self.flow) Option.objects.get_or_create(text='Yes', question=question) Option.objects.get_or_create(text='No', question=question) delivery = DeliveryFactory() run = RunFactory(phone=self.PHONE, runnable=delivery) url_params = self._create_rapid_pro_url_params(self.PHONE, uuid, 'Yes', 'Yes', 'productReceived') response = self.client.post(HOOK_URL, url_params) expected_question = MultipleChoiceQuestion.objects.get( label='productReceived') yes_option = expected_question.option_set.get(text='Yes') answers = MultipleChoiceAnswer.objects.filter( question__label='productReceived', run=run) created_answer = answers.first() self.assertEqual(response.status_code, 200) self.assertEqual(created_answer.value, yes_option) self.assertEqual(delivery.answers()[0]['value'], created_answer.value.text)
def test_should_record_an_answer_of_type_multiple_choice_for_a_node_with_multiple_uuids_from_request_data( self, *_): uuids = [ '2ff9fab3-4c12-400e-a2fe-4551fa1ebc18', 'abc9c005-7a7c-44f8-b946-e970a361b6cf' ] question = MultipleChoiceQuestionFactory(text='Was item received?', label='productReceived', flow=self.flow) Option.objects.get_or_create(text='Yes', question=question) Option.objects.get_or_create(text='No', question=question) run = RunFactory(phone=self.PHONE) uuid_for_no = uuids[1] url_params = self._create_rapid_pro_url_params(self.PHONE, uuid_for_no, 'No', 'No', 'productReceived') response = self.client.post(HOOK_URL, url_params) expected_question = MultipleChoiceQuestion.objects.get( label='productReceived') no_option = expected_question.option_set.get(text='No') answers = MultipleChoiceAnswer.objects.filter( question__label='productReceived', run=run) created_answer = answers.first() self.assertEqual(response.status_code, 200) self.assertEqual(created_answer.value, no_option)
def test_should_expire_overdue_runs(self, mock_get_overdue_runs): run = RunFactory() mock_get_overdue_runs.return_value = [run] self.flow_scheduler.expire_overdue_runs() mock_get_overdue_runs.assert_called() self.assertEqual(run.status, Run.STATUS.expired)
def test_should_not_get_completed_expired_or_cancelled_runs_when_getting_expired_runs( self): expired_run_date = datetime.date(1990, 1, 1) RunFactory( status=Run.STATUS.completed, runnable=DeliveryNodeFactory(delivery_date=expired_run_date)) RunFactory( status=Run.STATUS.expired, runnable=DeliveryNodeFactory(delivery_date=expired_run_date)) RunFactory( status=Run.STATUS.cancelled, runnable=DeliveryNodeFactory(delivery_date=expired_run_date)) overdue_runs = Run.overdue_runs() self.assertEqual(len(overdue_runs), 0)
def test_should_return_false_when_delivery_run_was_cancelled(self): delivery = DeliveryFactory() question = MultipleChoiceQuestionFactory(label='deliveryReceived') option = OptionFactory(text='Yes', question=question) run = RunFactory(runnable=delivery, status=Run.STATUS.cancelled) MultipleChoiceAnswerFactory(run=run, question=question, value=option) self.assertFalse(delivery.is_received())
def test_should_return_answers_for_completed_or_scheduled_runs_only(self): delivery = DeliveryFactory() flow = FlowFactory(for_runnable_type="IMPLEMENTING_PARTNER") question_1 = MultipleChoiceQuestionFactory( label="deliveryReceived", flow=flow, text="Was Delivery Received?", position=3 ) question_2 = TextQuestionFactory( label="dateOfReceipt", flow=flow, text="When was Delivery Received?", position=1 ) question_3 = TextQuestionFactory( label="satisfiedWithProduct", flow=flow, text="Are you satisfied with product?", position=2 ) option_no = OptionFactory(text="No", question=question_1) option_yes = OptionFactory(text="Yes", question=question_1) run_one = RunFactory(runnable=delivery) MultipleChoiceAnswerFactory(question=question_1, value=option_no, run=run_one) TextAnswerFactory(question=question_2, value="2014-10-10", run=run_one) TextAnswerFactory(question=question_3, value="yup", run=run_one) answers = delivery.answers() self.assertEqual(len(answers), 3) self.assertEqual(answers[0]["value"], "2014-10-10") run_one.status = "cancelled" run_one.save() answers = delivery.answers() self.assertEqual(len(answers), 3) self.assertEqual(answers[0]["value"], "") run_two = RunFactory(runnable=delivery) MultipleChoiceAnswerFactory(question=question_1, value=option_yes, run=run_two) answers = delivery.answers() self.assertEqual(len(answers), 3) self.assertEqual(answers[0]["value"], "") self.assertEqual(answers[1]["value"], "") self.assertEqual(answers[2]["value"], "Yes")
def test_should_serialise_node_response_run(self): node = DeliveryNodeFactory() run = MultipleChoiceAnswerFactory(run=RunFactory(runnable=node)).run expected = {"status": run.status, "phone": run.phone, "id": run.id} serialised = serialise_nodes([node]) self.assertDictContainsSubset(expected, serialised[0]['responses'][0]['run'])
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_serialise_node_with_value_lost(self): po_item = PurchaseOrderItemFactory(quantity=108, value=33) node = DeliveryNodeFactory(quantity=100, item=po_item) amount_received_qn = NumericQuestionFactory(label='amountReceived') run = RunFactory(runnable=node) NumericAnswerFactory(question=amount_received_qn, run=run, value=53) serialised = serialise_nodes([node]) self.assertDictContainsSubset({'value_lost': 14.36}, serialised[0])
def test_should_not_create_new_run_for_runnables_with_completed_run(self): RunFactory(runnable=self.node, status=Run.STATUS.completed) self.assertEqual(Run.objects.count(), 1) self.flow_scheduler.schedule_run_for(self.node) self.assertEqual(Run.objects.count(), 1) self.assertEqual( Run.objects.filter(runnable=self.node, status=Run.STATUS.scheduled).count(), 0)
def test_should_provide_shipment_received_value_from_api(self): delivery = DeliveryFactory() question = MultipleChoiceQuestionFactory(label='deliveryReceived') option = OptionFactory(text='Yes', question=question) run = RunFactory(runnable=delivery) MultipleChoiceAnswerFactory(run=run, question=question, value=option) response = self.client.get(ENDPOINT_URL) self.assertEqual(response.data[0]['shipment_received'], True)
def test_should_remove_consignee_items_entry_when_the_only_delivery_attached_is_edited_to_being_unreceived(self): item_was_received = MultipleChoiceAnswerFactory(question=self.was_item_received, value=self.yes, run=RunFactory(runnable=self.node)) consignee_item_entry = ConsigneeItem.objects.get(consignee=self.consignee, item=self.item) self.assertEqual(consignee_item_entry.deliveries, [self.node.id]) item_was_received.value = self.no item_was_received.save() self.assertFalse(ConsigneeItem.objects.filter(consignee=self.consignee, item=self.item).exists())
def test_should_return_answers_for_completed_or_scheduled_runs_only(self): delivery = DeliveryFactory() flow = FlowFactory(label='IMPLEMENTING_PARTNER') question_1 = MultipleChoiceQuestionFactory(label='deliveryReceived', flow=flow, text='Was Delivery Received?', position=3) question_2 = TextQuestionFactory(label='dateOfReceipt', flow=flow, text='When was Delivery Received?', position=1) question_3 = TextQuestionFactory(label='satisfiedWithProduct', flow=flow, text='Are you satisfied with product?', position=2) option_no = OptionFactory(text='No', question=question_1) option_yes = OptionFactory(text='Yes', question=question_1) run_one = RunFactory(runnable=delivery) MultipleChoiceAnswerFactory(question=question_1, value=option_no, run=run_one) TextAnswerFactory(question=question_2, value="2014-10-10", run=run_one) TextAnswerFactory(question=question_3, value="yup", run=run_one) answers = delivery.answers() self.assertEqual(len(answers), 3) self.assertEqual(answers[0]['value'], '2014-10-10') run_one.status = 'cancelled' run_one.save() answers = delivery.answers() self.assertEqual(len(answers), 3) self.assertEqual(answers[0]['value'], '') run_two = RunFactory(runnable=delivery) MultipleChoiceAnswerFactory(question=question_1, value=option_yes, run=run_two) answers = delivery.answers() self.assertEqual(len(answers), 3) self.assertEqual(answers[0]['value'], '') self.assertEqual(answers[1]['value'], '') self.assertEqual(answers[2]['value'], 'Yes')