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_only_return_implementing_partner_responses(self):
question = MultipleChoiceQuestionFactory(label='productReceived')
yes_option = OptionFactory(text='Yes', question=question)
item = ItemFactory(description='Salt')
order_item = PurchaseOrderItemFactory(item=item, value=1000)
node_ip_one = DeliveryNodeFactory(tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER, item=order_item)
node_end_user = DeliveryNodeFactory(tree_position=DistributionPlanNode.END_USER, item=order_item)
run_one = RunFactory(runnable=node_ip_one, status='completed')
run_two = RunFactory(runnable=node_end_user, status='completed')
answer_one = MultipleChoiceAnswerFactory(run=run_one, question=question, value=yes_option)
MultipleChoiceAnswerFactory(run=run_two, question=question, value=yes_option)
response = self.client.get(IP_ENDPOINT_URL, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
node_item = response.data[0]
self.assertEqual(node_item['item'], 'Salt')
self.assertEqual(node_item['programme'], {'id': node_ip_one.distribution_plan.programme.id,
'name': node_ip_one.distribution_plan.programme.name})
self.assertEqual(node_item['ip'], {'id': node_ip_one.ip.id, 'location': unicode(node_ip_one.ip.location)})
self.assertEqual(node_item[question.label], answer_one.format())
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_tell_if_question_answer_combination_ends_the_flow(self):
answer_1 = MultipleChoiceAnswerFactory()
answer_2 = MultipleChoiceAnswerFactory()
flow = Flow(end_nodes=[[answer_1.question.id, answer_1.value.id],
[answer_2.question.id, answer_2.value.id]])
self.assertTrue(flow.is_end(answer_1))
self.assertTrue(flow.is_end(answer_2))
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 test_should_remove_item_entry_when_a_new_no_answer_is_received_for_the_only_delivery_for_the_item(self):
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])
MultipleChoiceAnswerFactory(question=self.was_item_received, value=self.no, run=RunFactory(runnable=self.node))
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_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 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_should_only_update_deliveries_when_item_is_received_again_by_ip(self):
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])
new_node = DeliveryNodeFactory(consignee=self.consignee, item=PurchaseOrderItemFactory(item=self.item))
MultipleChoiceAnswerFactory(question=self.was_item_received, value=self.yes, run=RunFactory(runnable=new_node))
updated_consignee_item_entry = ConsigneeItem.objects.get(consignee=self.consignee, item=self.item)
self.assertItemsEqual(updated_consignee_item_entry.deliveries, [self.node.id, new_node.id])
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_remove_node_from_item_entry_when_that_node_is_modified_to_be_unreceived(self):
MultipleChoiceAnswerFactory(question=self.was_item_received, value=self.yes, run=RunFactory(runnable=self.node))
new_node = DeliveryNodeFactory(consignee=self.consignee, item=PurchaseOrderItemFactory(item=self.item))
MultipleChoiceAnswerFactory(question=self.was_item_received, value=self.yes, run=RunFactory(runnable=new_node))
updated_item_entry = ConsigneeItem.objects.get(consignee=self.consignee, item=self.item)
self.assertItemsEqual(updated_item_entry.deliveries, [self.node.id, new_node.id])
MultipleChoiceAnswerFactory(question=self.was_item_received, value=self.no, run=RunFactory(runnable=self.node))
updated_item_entry = ConsigneeItem.objects.get(consignee=self.consignee, item=self.item)
self.assertItemsEqual(updated_item_entry.deliveries, [new_node.id])
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 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')
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 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 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_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_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_create_new_consignee_items_entry_when_new_item_is_received_by_ip(self):
self.assertFalse(ConsigneeItem.objects.filter(consignee=self.consignee, item=self.item).exists())
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.available_balance(), 0)
self.assertEqual(consignee_item_entry.amount_received, 0)
self.assertEqual(consignee_item_entry.deliveries, [self.node.id])
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 create_node_and_answers(self,
number_of_deliveries,
order_number,
programme_name,
consignee,
comment,
is_purchase,
track,
tree_position=Flow.Label.IMPLEMENTING_PARTNER,
location='Madagascar',
contact_person_id=CONTACT_PERSON_ID):
while number_of_deliveries > 0:
delivery = DeliveryFactory(
contact_person_id=contact_person_id,
track=track,
programme=ProgrammeFactory(name=programme_name),
consignee=ConsigneeFactory(name=consignee),
delivery_date=date(2015, 3, 10),
location=location)
self._create_node(delivery, is_purchase, order_number, track,
tree_position, location)
run = RunFactory(runnable=delivery)
MultipleChoiceAnswerFactory(run=run,
question=self.delivery_received_qtn,
value=self.yes_one)
delivery_date = '12/03/2015'
TextAnswerFactory(run=run,
question=self.date_received_qtn,
value=delivery_date)
MultipleChoiceAnswerFactory(run=run,
question=self.delivery_in_good_order,
value=self.yes_two)
MultipleChoiceAnswerFactory(run=run,
question=self.satisfied_with_delivery,
value=self.no_three)
TextAnswerFactory(run=run,
question=self.additional_comments,
value=comment)
FileUploadFactory(plan=delivery, file='photo/2016/02/14/world.jpg')
FileUploadFactory(plan=delivery, file='photo/2016/02/14/peace.jpg')
number_of_deliveries -= 1
order_number += 1
def test_should_return_false_when_delivery_is_received_and_there_are_no_answers_for_some_nodes(
self):
delivery = DeliveryFactory()
question = MultipleChoiceQuestionFactory(label='deliveryReceived')
option = OptionFactory(text='Yes', question=question)
run = RunFactory(runnable=delivery)
MultipleChoiceAnswerFactory(run=run, question=question, value=option)
node_one = DeliveryNodeFactory(distribution_plan=delivery)
DeliveryNodeFactory(distribution_plan=delivery)
item_question = MultipleChoiceQuestionFactory(label='itemReceived')
yes_node_option = OptionFactory(text='Yes', question=item_question)
MultipleChoiceAnswerFactory(run=RunFactory(runnable=node_one),
question=item_question,
value=yes_node_option)
self.assertFalse(delivery.is_received())
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 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()
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))
DeliveryFactory(location='Other location',
delivery_date=self.today,
track=True)
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)
RunFactory(runnable=non_response_delivery_one,
status=Run.STATUS.scheduled)
def create_line_item_runs_and_answers(self):
self.line_item_run_one = NodeLineItemRunFactory(node_line_item=self.node_line_item_one, status='completed')
self.run_one_multiple_answer_one = MultipleChoiceAnswerFactory(line_item_run=self.line_item_run_one,
question=self.multiple_choice_question,
value=self.yes_option)
self.run_one_multiple_answer_two = MultipleChoiceAnswerFactory(line_item_run=self.line_item_run_one,
question=self.multiple_choice_question_two,
value=self.yes_option)
self.run_one_numeric_answer_one = NumericAnswerFactory(line_item_run=self.line_item_run_one, value=80,
question=self.numeric_question)
self.line_item_run_two = NodeLineItemRunFactory(node_line_item=self.node_line_item_two, status='completed')
self.run_two_multiple_answer_one = MultipleChoiceAnswerFactory(line_item_run=self.line_item_run_two,
question=self.multiple_choice_question,
value=self.yes_option)
self.run_two_multiple_answer_two = MultipleChoiceAnswerFactory(line_item_run=self.line_item_run_two,
question=self.multiple_choice_question_two,
value=self.yes_option)
self.run_two_numeric_answer_one = NumericAnswerFactory(line_item_run=self.line_item_run_two, value=80,
question=self.numeric_question)
def test_should_return_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?')
question_3 = NumericQuestionFactory(text='How much was received?',
label='amountReceived',
flow=flow)
option_yes = OptionFactory(text='Yes', question=question_1)
run = RunFactory(runnable=delivery)
multiple_choice_answer = MultipleChoiceAnswerFactory(
run=run, question=question_1, value=option_yes)
text_answer = TextAnswerFactory(run=run,
question=question_2,
value='2015-10-10')
numeric_answer = NumericAnswerFactory(run=run,
question=question_3,
value=10)
expected_multiple_choice_answer = {
'question_label': question_1.label,
'type': 'multipleChoice',
'text': question_1.text,
'value': multiple_choice_answer.value.text,
'options': ['Yes'],
'position': question_1.position
}
expected_text_answer = {
'question_label': question_2.label,
'type': 'text',
'text': question_2.text,
'value': text_answer.value,
'position': question_2.position
}
expected_numeric_answer = {
'question_label': question_3.label,
'type': 'numeric',
'text': question_3.text,
'value': numeric_answer.value,
'position': question_3.position
}
answers = delivery.answers()
self.assertEqual(len(answers), 3)
self.assertIn(expected_multiple_choice_answer, answers)
self.assertIn(expected_text_answer, answers)
self.assertIn(expected_numeric_answer, answers)
def test_should_return_true_when_delivery_is_partially_received(self):
delivery = DeliveryFactory()
question = MultipleChoiceQuestionFactory(label='deliveryReceived')
option = OptionFactory(text='Yes', question=question)
run = RunFactory(runnable=delivery)
self.assertFalse(delivery.is_received())
MultipleChoiceAnswerFactory(run=run, question=question, value=option)
self.assertTrue(delivery.is_partially_received())
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 test_should_get_number_of_successful_deliveries_from_only_the_latest_scheduled_or_completed_runs(
self):
canceled_run = RunFactory(runnable=self.end_user_node_two,
status=Run.STATUS.cancelled)
from eums.fixtures.end_user_questions import WAS_PRODUCT_RECEIVED, PRODUCT_WAS_RECEIVED
MultipleChoiceAnswerFactory(run=canceled_run,
question=WAS_PRODUCT_RECEIVED,
value=PRODUCT_WAS_RECEIVED)
response = self.client.get('%s?treePosition=END_USER' % ENDPOINT_URL)
self.assertEqual(
response.data.get('numberOfSuccessfulProductDeliveries'), 2)
def test_should_only_return_implementing_partner_responses(self):
question = MultipleChoiceQuestionFactory(label='productReceived')
yes_option = OptionFactory(text='Yes', question=question)
item = ItemFactory(description='Salt')
order_item = PurchaseOrderItemFactory(item=item, value=1000)
node_ip_one = DeliveryNodeFactory(
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER,
item=order_item)
node_end_user = DeliveryNodeFactory(
tree_position=DistributionPlanNode.END_USER, item=order_item)
run_one = RunFactory(runnable=node_ip_one, status='completed')
run_two = RunFactory(runnable=node_end_user, status='completed')
answer_one = MultipleChoiceAnswerFactory(run=run_one,
question=question,
value=yes_option)
MultipleChoiceAnswerFactory(run=run_two,
question=question,
value=yes_option)
response = self.client.get(IP_ENDPOINT_URL, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
node_item = response.data[0]
self.assertEqual(node_item['item'], 'Salt')
self.assertEqual(
node_item['programme'], {
'id': node_ip_one.distribution_plan.programme.id,
'name': node_ip_one.distribution_plan.programme.name
})
self.assertEqual(node_item['ip'], {
'id': node_ip_one.ip.id,
'location': unicode(node_ip_one.ip.location)
})
self.assertEqual(node_item[question.label], answer_one.format())
def test_should_return_true_when_delivery_is_received_and_all_node_answers_are_received(
self):
delivery = DeliveryFactory()
question = MultipleChoiceQuestionFactory(label='deliveryReceived')
option = OptionFactory(text='Yes', question=question)
run = RunFactory(runnable=delivery)
MultipleChoiceAnswerFactory(run=run, question=question, value=option)
node_one = DeliveryNodeFactory(distribution_plan=delivery)
node_two = DeliveryNodeFactory(distribution_plan=delivery)
item_question = MultipleChoiceQuestionFactory(label='itemReceived')
option_two = OptionFactory(text='Yes', question=item_question)
MultipleChoiceAnswerFactory(run=RunFactory(runnable=node_one),
question=item_question,
value=option_two)
MultipleChoiceAnswerFactory(run=RunFactory(runnable=node_two),
question=item_question,
value=option_two)
self.assertTrue(delivery.is_received())
def test_should_serialise_node_response_flat_fields(self):
node = DeliveryNodeFactory()
answer = MultipleChoiceAnswerFactory(run=RunFactory(runnable=node))
expected = {
"value_id": answer.value.id,
"run_id": answer.run.id,
"id": answer.id,
"value": answer.value.text,
"question_id": answer.question.id
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected, serialised[0]['responses'][0])
def test_should_roll_back_hook_effect_when_answer_is_deleted(self, mock_rollback, mock_run):
question = MultipleChoiceQuestionFactory(when_answered='update_consignee_stock_level')
answer = MultipleChoiceAnswerFactory(question=question)
mock_run.return_value = None
answer.delete()
mock_rollback.assert_called()
class ResponsesEndPointTest(AuthenticatedAPITestCase):
def create_questions_and_items(self):
self.multiple_choice_question_two = MultipleChoiceQuestionFactory(label='satisfiedWithProduct')
self.multiple_choice_question = MultipleChoiceQuestionFactory(label='productReceived')
self.yes_option = OptionFactory(text='Yes', question=self.multiple_choice_question)
OptionFactory(text='No', question=self.multiple_choice_question)
self.numeric_question = NumericQuestionFactory(label='amountReceived')
salt = ItemFactory(description='Salt')
self.sales_order_item = SalesOrderItemFactory(item=salt, description='10 bags of salt')
self.item = PurchaseOrderItemFactory(item=salt, value=1000)
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 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 expected_response_data(self, node, consignee, programme, type):
expected_data = {u'item': u'Salt', u'amountSent': 100, u'value': 1000, u'latestResponseDate': node.latest_response().date_created, u'node': node.id,
u'consignee': {u'id': consignee.id, u'name': consignee.name,
u'type': type},
u'ip': {'id': node.ip.id, 'location': node.ip.location},
u'%s' % self.numeric_question.label: u'%s' % self.run_one_numeric_answer_one.format(),
u'%s' % self.multiple_choice_question.label: u'%s' % self.run_one_multiple_answer_one.format(),
u'%s' % self.multiple_choice_question_two.label: u'%s' % self.run_one_multiple_answer_two.format(),
u'programme': {u'id': programme.id, u'name': programme.name},
u'location': node.location}
return expected_data
def test_should_provide_summary_data_from_node_response(self):
self.create_questions_and_items()
self.create_nodes()
self.create_runs_and_answers()
url = "%s%d/" % (ENDPOINT_URL, self.middle_man_node.consignee.id)
response = self.client.get(url, format='json')
consignee = self.middle_man_node.consignee
programme = self.middle_man_node.distribution_plan.programme
expected_data = self.expected_response_data(self.middle_man_node, consignee, programme,
DistributionPlanNode.MIDDLE_MAN)
self.assertEqual(response.status_code, 200)
self.assertEquals(expected_data, response.data[0])
self.assertEquals(len(response.data), 1)
self.assertDictContainsSubset(expected_data, response.data[0])
def test_should_provide_summary_data_from_all_node_responses(self):
self.create_questions_and_items()
self.create_nodes()
self.create_runs_and_answers()
response = self.client.get(ENDPOINT_URL, format='json')
consignee_one = self.middle_man_node.consignee
consignee_two = self.end_user_node.consignee
programme = self.middle_man_node.distribution_plan.programme
expected_data_node_one = self.expected_response_data(self.middle_man_node, consignee_one, programme,
DistributionPlanNode.MIDDLE_MAN)
expected_data_node_two = self.expected_response_data(self.end_user_node, consignee_two, programme,
DistributionPlanNode.END_USER)
self.assertEqual(response.status_code, 200)
self.assertEquals(len(response.data), 2)
self.assertIn(expected_data_node_one, response.data)
self.assertIn(expected_data_node_two, response.data)
def test_should_provide_summary_data_from_all_end_user_node_responses(self):
self.create_questions_and_items()
self.create_nodes()
self.create_runs_and_answers()
response = self.client.get(END_USER_ENDPOINT_URL, format='json')
consignee = self.end_user_node.consignee
programme = self.middle_man_node.distribution_plan.programme
expected_data_node = self.expected_response_data(self.end_user_node, consignee, programme,
DistributionPlanNode.END_USER)
self.assertEqual(response.status_code, 200)
self.assertEquals(len(response.data), 1)
self.assertEquals(expected_data_node, response.data[0])
self.assertDictContainsSubset(expected_data_node, response.data[0])
def test_should_provide_summary_data_from_node_response_for_end_user(self):
self.create_questions_and_items()
self.create_nodes()
self.create_runs_and_answers()
url = "%s%d/" % (NODE_ENDPOINT_URL, self.end_user_node.id)
response = self.client.get(url, format='json')
expected_data = {
"node": {
"plan_id": self.end_user_node.distribution_plan.id,
"contact_person_id": self.end_user_node.contact_person_id,
"consignee": self.end_user_node.consignee.id,
"id": self.end_user_node.id,
"location": self.end_user_node.location
},
"run_id": self.run_two.id,
"responses": {
self.numeric_question.label: {
"id": self.run_two_numeric_answer_one.id,
"value": self.run_two_numeric_answer_one.value,
"formatted_value": self.run_two_numeric_answer_one.format()
},
self.multiple_choice_question.label: {
"id": self.run_two_multiple_answer_one.id,
"value": self.yes_option.id,
"formatted_value": self.run_two_multiple_answer_one.format()
},
self.multiple_choice_question_two.label: {
"id": self.run_two_multiple_answer_two.id,
"value": self.yes_option.id,
"formatted_value": self.run_two_multiple_answer_two.format()
}
}
}
self.assertEqual(response.status_code, 200)
self.assertEquals(expected_data, response.data)
self.assertDictContainsSubset(expected_data, response.data)
def test_should_not_provide_summary_data_from_node_response_for_middleman_user(self):
self.create_questions_and_items()
self.create_nodes()
self.create_runs_and_answers()
url = "%s%d/" % (NODE_ENDPOINT_URL, self.run_one.id)
response = self.client.get(url, format='json')
expected_data = {}
self.assertEqual(response.status_code, 200)
self.assertEquals(expected_data, response.data)
self.assertEquals(len(response.data), 0)
def test_should_only_return_implementing_partner_responses(self):
question = MultipleChoiceQuestionFactory(label='productReceived')
yes_option = OptionFactory(text='Yes', question=question)
item = ItemFactory(description='Salt')
order_item = PurchaseOrderItemFactory(item=item, value=1000)
node_ip_one = DeliveryNodeFactory(tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER, item=order_item)
node_end_user = DeliveryNodeFactory(tree_position=DistributionPlanNode.END_USER, item=order_item)
run_one = RunFactory(runnable=node_ip_one, status='completed')
run_two = RunFactory(runnable=node_end_user, status='completed')
answer_one = MultipleChoiceAnswerFactory(run=run_one, question=question, value=yes_option)
MultipleChoiceAnswerFactory(run=run_two, question=question, value=yes_option)
response = self.client.get(IP_ENDPOINT_URL, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
node_item = response.data[0]
self.assertEqual(node_item['item'], 'Salt')
self.assertEqual(node_item['programme'], {'id': node_ip_one.distribution_plan.programme.id,
'name': node_ip_one.distribution_plan.programme.name})
self.assertEqual(node_item['ip'], {'id': node_ip_one.ip.id, 'location': unicode(node_ip_one.ip.location)})
self.assertEqual(node_item[question.label], answer_one.format())
class ResponsesEndPointTest(AuthenticatedAPITestCase):
def create_questions_and_items(self):
self.multiple_choice_question_two = MultipleChoiceQuestionFactory(label='satisfiedWithProduct')
self.multiple_choice_question = MultipleChoiceQuestionFactory(label='productReceived')
self.yes_option = OptionFactory(text='Yes', question=self.multiple_choice_question)
OptionFactory(text='No', question=self.multiple_choice_question)
self.numeric_question = NumericQuestionFactory(label='amountReceived')
salt = ItemFactory(description='Salt')
self.item = SalesOrderItemFactory(item=salt, description='10 bags of salt')
def create_nodes_and_line_item(self):
self.ip_node = DistributionPlanNodeFactory()
self.middle_man_node = DistributionPlanNodeFactory(parent=self.ip_node,
tree_position=DistributionPlanNode.MIDDLE_MAN,
distribution_plan=self.ip_node.distribution_plan)
self.node_line_item_one = DistributionPlanLineItemFactory(distribution_plan_node=self.middle_man_node,
targeted_quantity=100,
item=self.item)
self.end_user_node = DistributionPlanNodeFactory(parent=self.middle_man_node,
tree_position=DistributionPlanNode.END_USER,
distribution_plan=self.ip_node.distribution_plan)
self.node_line_item_two = DistributionPlanLineItemFactory(distribution_plan_node=self.end_user_node,
targeted_quantity=100,
item=self.item)
def create_line_item_runs_and_answers(self):
self.line_item_run_one = NodeLineItemRunFactory(node_line_item=self.node_line_item_one, status='completed')
self.run_one_multiple_answer_one = MultipleChoiceAnswerFactory(line_item_run=self.line_item_run_one,
question=self.multiple_choice_question,
value=self.yes_option)
self.run_one_multiple_answer_two = MultipleChoiceAnswerFactory(line_item_run=self.line_item_run_one,
question=self.multiple_choice_question_two,
value=self.yes_option)
self.run_one_numeric_answer_one = NumericAnswerFactory(line_item_run=self.line_item_run_one, value=80,
question=self.numeric_question)
self.line_item_run_two = NodeLineItemRunFactory(node_line_item=self.node_line_item_two, status='completed')
self.run_two_multiple_answer_one = MultipleChoiceAnswerFactory(line_item_run=self.line_item_run_two,
question=self.multiple_choice_question,
value=self.yes_option)
self.run_two_multiple_answer_two = MultipleChoiceAnswerFactory(line_item_run=self.line_item_run_two,
question=self.multiple_choice_question_two,
value=self.yes_option)
self.run_two_numeric_answer_one = NumericAnswerFactory(line_item_run=self.line_item_run_two, value=80,
question=self.numeric_question)
def expected_response_data(self, node, consignee, programme, type):
expected_data = {u'item': u'10 bags of salt', u'amountSent': 100, u'node': node.id,
u'consignee': {u'id': consignee.id, u'name': consignee.name,
u'type': type},
u'ip': node.get_ip(),
u'%s' % self.numeric_question.label: u'%s' % self.run_one_numeric_answer_one.format(),
u'%s' % self.multiple_choice_question.label: u'%s' % self.run_one_multiple_answer_one.format(),
u'%s' % self.multiple_choice_question_two.label: u'%s' % self.run_one_multiple_answer_two.format(),
u'programme': {u'id': programme.id, u'name': programme.name},
u'location': node.location}
return expected_data
def test_should_provide_summary_data_from_node_response(self):
self.create_questions_and_items()
self.create_nodes_and_line_item()
self.create_line_item_runs_and_answers()
url = "%s%d/" % (ENDPOINT_URL, self.middle_man_node.consignee.id)
response = self.client.get(url, format='json')
consignee = self.middle_man_node.consignee
programme = self.middle_man_node.distribution_plan.programme
expected_data = self.expected_response_data(self.middle_man_node, consignee, programme,
DistributionPlanNode.MIDDLE_MAN)
self.assertEqual(response.status_code, 200)
self.assertEquals(expected_data, response.data[0])
self.assertEquals(len(response.data), 1)
self.assertDictContainsSubset(expected_data, response.data[0])
def test_should_provide_summary_data_from_all_node_responses(self):
self.create_questions_and_items()
self.create_nodes_and_line_item()
self.create_line_item_runs_and_answers()
response = self.client.get(ENDPOINT_URL, format='json')
consignee_one = self.middle_man_node.consignee
consignee_two = self.end_user_node.consignee
programme = self.middle_man_node.distribution_plan.programme
expected_data_node_one = self.expected_response_data(self.middle_man_node, consignee_one, programme,
DistributionPlanNode.MIDDLE_MAN)
expected_data_node_two = self.expected_response_data(self.end_user_node, consignee_two, programme,
DistributionPlanNode.END_USER)
self.assertEqual(response.status_code, 200)
self.assertEquals(len(response.data), 2)
self.assertEquals(expected_data_node_one, response.data[0])
self.assertEquals(expected_data_node_two, response.data[1])
self.assertDictContainsSubset(expected_data_node_one, response.data[0])
self.assertDictContainsSubset(expected_data_node_two, response.data[1])
def test_should_provide_summary_data_from_all_end_user_node_responses(self):
self.create_questions_and_items()
self.create_nodes_and_line_item()
self.create_line_item_runs_and_answers()
response = self.client.get(END_USER_ENDPOINT_URL, format='json')
consignee = self.end_user_node.consignee
programme = self.middle_man_node.distribution_plan.programme
expected_data_node = self.expected_response_data(self.end_user_node, consignee, programme,
DistributionPlanNode.END_USER)
self.assertEqual(response.status_code, 200)
self.assertEquals(len(response.data), 1)
self.assertEquals(expected_data_node, response.data[0])
self.assertDictContainsSubset(expected_data_node, response.data[0])
def test_should_provide_summary_data_from_plan_item_response_for_end_user(self):
self.create_questions_and_items()
self.create_nodes_and_line_item()
self.create_line_item_runs_and_answers()
url = "%s%d/" % (PLAN_ITEM_ENDPOINT_URL, self.node_line_item_two.id)
response = self.client.get(url, format='json')
expected_data = {
"node": {
"plan_id": self.end_user_node.distribution_plan.id,
"contact_person_id": self.end_user_node.contact_person_id,
"consignee": self.end_user_node.consignee.id,
"id": self.end_user_node.id,
"location": self.end_user_node.location
},
"line_item_run_id": self.line_item_run_two.id,
"responses": {
self.numeric_question.label: {
"id": self.run_two_numeric_answer_one.id,
"value": self.run_two_numeric_answer_one.value,
"formatted_value": self.run_two_numeric_answer_one.format()
},
self.multiple_choice_question.label: {
"id": self.run_two_multiple_answer_one.id,
"value": self.yes_option.id,
"formatted_value": self.run_two_multiple_answer_one.format()
},
self.multiple_choice_question_two.label: {
"id": self.run_two_multiple_answer_two.id,
"value": self.yes_option.id,
"formatted_value": self.run_two_multiple_answer_two.format()
}
}
}
self.assertEqual(response.status_code, 200)
self.assertEquals(expected_data, response.data)
self.assertDictContainsSubset(expected_data, response.data)
def test_should_not_provide_summary_data_from_plan_item_response_for_middleman_user(self):
self.create_questions_and_items()
self.create_nodes_and_line_item()
self.create_line_item_runs_and_answers()
url = "%s%d/" % (PLAN_ITEM_ENDPOINT_URL, self.node_line_item_one.id)
response = self.client.get(url, format='json')
expected_data = {}
self.assertEqual(response.status_code, 200)
self.assertEquals(expected_data, response.data)
self.assertEquals(len(response.data), 0)
