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