def test_should_serialise_node_with_extra_tree_position_info_tag(self):
ip_node = DeliveryNodeFactory(tree_position=Runnable.IMPLEMENTING_PARTNER, quantity=100)
node_under_ip = DeliveryNodeFactory(parents=[(ip_node, 20)], tree_position=Runnable.MIDDLE_MAN)
deeper_node = DeliveryNodeFactory(parents=[(node_under_ip, 20)], tree_position=Runnable.END_USER)
serialised_node_under_ip = serialise_nodes([node_under_ip])[0]
self.assertDictContainsSubset({"is_directly_under_ip": True}, serialised_node_under_ip)
serialised_deeper_node = serialise_nodes([deeper_node])[0]
self.assertDictContainsSubset({"is_directly_under_ip": False}, serialised_deeper_node)
def test_should_serialise_node_with_extra_tree_position_info_tag(self):
ip_node = DeliveryNodeFactory(
tree_position=Flow.Label.IMPLEMENTING_PARTNER, quantity=100)
node_under_ip = DeliveryNodeFactory(
parents=[(ip_node, 20)], tree_position=Flow.Label.MIDDLE_MAN)
deeper_node = DeliveryNodeFactory(parents=[(node_under_ip, 20)],
tree_position=Flow.Label.END_USER)
serialised_node_under_ip = serialise_nodes([node_under_ip])[0]
self.assertDictContainsSubset({'is_directly_under_ip': True},
serialised_node_under_ip)
serialised_deeper_node = serialise_nodes([deeper_node])[0]
self.assertDictContainsSubset({'is_directly_under_ip': False},
serialised_deeper_node)
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_serialise_node_with_built_out_delivery(self):
delivery = DeliveryFactory()
node_with_delivery = DeliveryNodeFactory(distribution_plan=delivery)
node_parents = [(DeliveryNodeFactory(), 2), (DeliveryNodeFactory(), 2)]
node_without_delivery = DeliveryNodeFactory(parents=node_parents, distribution_plan=None)
expected_delivery_serialisation = {
"id": delivery.id,
"location": delivery.location,
"delivery_date": delivery.delivery_date,
}
serialised = serialise_nodes([node_with_delivery])
self.assertDictContainsSubset(expected_delivery_serialisation, serialised[0]["delivery"])
serialised_node_without_delivery = serialise_nodes([node_without_delivery])
self.assertNotIn("delivery", serialised_node_without_delivery[0].keys())
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_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_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_serialise_node_with_delivery_delay(self):
expected_delivery_date = timezone.datetime(2015, 1, 1).date()
date_of_receipt = timezone.datetime(2015, 1, 10).date()
node = DeliveryNodeFactory(delivery_date=expected_delivery_date)
date_received_question = TextQuestionFactory(label="dateOfReceipt")
run = RunFactory(runnable=node)
TextAnswerFactory(question=date_received_question, run=run, value=date_of_receipt)
serialised = serialise_nodes([node])
self.assertDictContainsSubset({"delivery_delay": 9}, serialised[0])
def test_should_convert_updated_nodes_to_bulk_api_format(self):
node = DeliveryNodeFactory()
expected_meta_data = '{"index": {"_index": \"%s\", "_type": \"%s\", "_id": %d}}\n' % (
ES_SETTINGS.INDEX, ES_SETTINGS.NODE_TYPE, node.id
)
serialised = serialise_nodes([node])
expected_node_string = json.dumps(serialised[0], default=_serialise_datetime) + '\n'
api_format = convert_to_bulk_api_format(serialised, [])
self.assertEqual(api_format, expected_meta_data + expected_node_string)
def test_should_convert_updated_nodes_to_bulk_api_format(self):
node = DeliveryNodeFactory()
expected_meta_data = '{"index": {"_index": \"%s\", "_type": \"%s\", "_id": %d}}\n' % (
ES_SETTINGS.INDEX, ES_SETTINGS.NODE_TYPE, node.id)
serialised = serialise_nodes([node])
expected_node_string = json.dumps(serialised[0],
default=_serialise_datetime) + '\n'
api_format = convert_to_bulk_api_format(serialised, [])
self.assertEqual(api_format, expected_meta_data + expected_node_string)
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_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_serialise_node_with_delivery_delay(self):
expected_delivery_date = timezone.datetime(2015, 1, 1).date()
date_of_receipt = timezone.datetime(2015, 1, 10).date()
node = DeliveryNodeFactory(delivery_date=expected_delivery_date)
date_received_question = TextQuestionFactory(label='dateOfReceipt')
run = RunFactory(runnable=node)
TextAnswerFactory(question=date_received_question,
run=run,
value=date_of_receipt)
serialised = serialise_nodes([node])
self.assertDictContainsSubset({'delivery_delay': 9}, serialised[0])
def test_should_serialise_node_with_built_out_delivery(self):
delivery = DeliveryFactory()
node_with_delivery = DeliveryNodeFactory(distribution_plan=delivery)
node_parents = [(DeliveryNodeFactory(), 2), (DeliveryNodeFactory(), 2)]
node_without_delivery = DeliveryNodeFactory(parents=node_parents,
distribution_plan=None)
expected_delivery_serialisation = {
"id": delivery.id,
"location": delivery.location,
"delivery_date": delivery.delivery_date,
}
serialised = serialise_nodes([node_with_delivery])
self.assertDictContainsSubset(expected_delivery_serialisation,
serialised[0]["delivery"])
serialised_node_without_delivery = serialise_nodes(
[node_without_delivery])
self.assertNotIn('delivery',
serialised_node_without_delivery[0].keys())
def test_should_serialise_node_with_built_out_programme(self):
programme = ProgrammeFactory()
delivery = DeliveryFactory(programme=programme)
node = DeliveryNodeFactory(distribution_plan=delivery)
expected_programme_serialisation = {
"wbs_element_ex": programme.wbs_element_ex,
"id": programme.id,
"name": programme.name,
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected_programme_serialisation, serialised[0]["programme"])
def test_should_serialise_node_with_built_out_programme(self):
programme = ProgrammeFactory()
delivery = DeliveryFactory(programme=programme)
node = DeliveryNodeFactory(distribution_plan=delivery)
expected_programme_serialisation = {
"wbs_element_ex": programme.wbs_element_ex,
"id": programme.id,
"name": programme.name
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected_programme_serialisation,
serialised[0]["programme"])
def test_should_serialise_item_under_node_order_item(self):
item = ItemFactory()
node = DeliveryNodeFactory(item=PurchaseOrderItemFactory(item=item))
expected = {
"description": item.description,
"material_code": item.material_code,
"unit_id": item.unit.id,
"id": item.id,
"unit": item.unit.name
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected, serialised[0]['order_item']['item'])
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_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_serialise_item_under_node_order_item(self):
item = ItemFactory()
node = DeliveryNodeFactory(item=PurchaseOrderItemFactory(item=item))
expected = {
"description": item.description,
"material_code": item.material_code,
"unit_id": item.unit.id,
"id": item.id,
"unit": item.unit.name
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected,
serialised[0]['order_item']['item'])
def test_should_serialise_node_response_question(self):
node = DeliveryNodeFactory()
question = MultipleChoiceAnswerFactory(run=RunFactory(runnable=node)).question
expected = {
"text": question.text,
"label": question.label,
"flow_id": question.flow.id,
"position": question.position,
"type": question.type,
"id": question.id
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected, serialised[0]['responses'][0]['question'])
def test_should_serialise_node_sales_order_under_order(self):
sales_order = SalesOrderFactory()
release_order = ReleaseOrderFactory(sales_order=sales_order)
node = DeliveryNodeFactory(item=(ReleaseOrderItemFactory(release_order=release_order)))
expected = {
"programme_id": sales_order.programme.id,
"description": sales_order.description,
"date": sales_order.date,
"order_number": sales_order.order_number,
"id": sales_order.id
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected, serialised[0]['order_item']['order']['sales_order'])
def test_should_serialise_node_purchase_order_item_with_flat_fields(self):
purchase_order_item = PurchaseOrderItemFactory()
node = DeliveryNodeFactory(item=purchase_order_item)
expected = {
"item_number": purchase_order_item.item_number,
"value": purchase_order_item.value,
"item_id": purchase_order_item.item.id,
"sales_order_item_id": purchase_order_item.sales_order_item.id,
"purchase_order_id": purchase_order_item.purchase_order.id,
"id": purchase_order_item.id,
"quantity": purchase_order_item.quantity
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected, serialised[0]['order_item'])
def test_should_serialise_node_purchase_order_item_with_flat_fields(self):
purchase_order_item = PurchaseOrderItemFactory()
node = DeliveryNodeFactory(item=purchase_order_item)
expected = {
"item_number": purchase_order_item.item_number,
"value": purchase_order_item.value,
"item_id": purchase_order_item.item.id,
"sales_order_item_id": purchase_order_item.sales_order_item.id,
"purchase_order_id": purchase_order_item.purchase_order.id,
"id": purchase_order_item.id,
"quantity": purchase_order_item.quantity
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected, serialised[0]['order_item'])
def test_should_serialise_node_purchase_order(self):
purchase_order = PurchaseOrderFactory()
node = DeliveryNodeFactory(item=(PurchaseOrderItemFactory(purchase_order=purchase_order)))
expected = {
"po_type": purchase_order.po_type,
"order_number": purchase_order.order_number,
"date": purchase_order.date,
"sales_order_id": purchase_order.sales_order.id,
"id": purchase_order.id,
"is_single_ip": purchase_order.is_single_ip,
"order_type": "purchase_order",
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected, serialised[0]['order_item']['order'])
def test_should_serialise_node_response_question(self):
node = DeliveryNodeFactory()
question = MultipleChoiceAnswerFactory(run=RunFactory(
runnable=node)).question
expected = {
"text": question.text,
"label": question.label,
"flow_id": question.flow.id,
"position": question.position,
"type": question.type,
"id": question.id
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(
expected, serialised[0]['responses'][0]['question'])
def test_should_serialise_node_with_built_out_implementing_partner(self):
ip = ConsigneeFactory()
node = DeliveryNodeFactory(consignee=ip)
expected_ip_serialisation = {
"created_by_user_id": ip.created_by_user.id,
"name": ip.name,
"imported_from_vision": ip.imported_from_vision,
"location": ip.location,
"remarks": ip.remarks,
"customer_id": ip.customer_id,
"type": ip.type,
"id": ip.id,
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected_ip_serialisation, serialised[0]["ip"])
def test_should_serialise_node_with_built_out_consignee(self):
consignee = ConsigneeFactory()
node = DeliveryNodeFactory(consignee=consignee)
expected_consignee_serialisation = {
"created_by_user_id": consignee.created_by_user.id,
"name": consignee.name,
"imported_from_vision": consignee.imported_from_vision,
"location": consignee.location,
"remarks": consignee.remarks,
"customer_id": consignee.customer_id,
"type": consignee.type,
"id": consignee.id,
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected_consignee_serialisation, serialised[0]["consignee"])
def test_should_serialise_node_sales_order_under_order(self):
sales_order = SalesOrderFactory()
release_order = ReleaseOrderFactory(sales_order=sales_order)
node = DeliveryNodeFactory(item=(ReleaseOrderItemFactory(
release_order=release_order)))
expected = {
"programme_id": sales_order.programme.id,
"description": sales_order.description,
"date": sales_order.date,
"order_number": sales_order.order_number,
"id": sales_order.id
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(
expected, serialised[0]['order_item']['order']['sales_order'])
def test_should_serialise_node_release_order(self):
release_order = ReleaseOrderFactory()
node = DeliveryNodeFactory(item=(ReleaseOrderItemFactory(release_order=release_order)))
expected = {
"consignee_id": release_order.consignee.id,
"sales_order_id": release_order.sales_order.id,
"purchase_order_id": release_order.purchase_order.id,
"order_number": release_order.waybill,
"order_type": "release_order",
"release_order_number": release_order.order_number,
"id": release_order.id,
"delivery_date": release_order.delivery_date
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected, serialised[0]['order_item']['order'])
def test_should_add_response_to_when_shipment_was_received_question_for_ip_nodes_to_responses_list(self):
date_received = timezone.datetime(2015, 1, 10).date()
delivery = DeliveryFactory()
ip_flow = Flow.objects.get(label=Flow.Label.IMPLEMENTING_PARTNER)
qn_date_of_receipt = TextQuestion.objects.get(flow=ip_flow, label='dateOfReceipt')
answer = TextAnswerFactory(run=RunFactory(runnable=delivery), question=qn_date_of_receipt, value=date_received)
node = DeliveryNodeFactory(tree_position=DeliveryNode.IMPLEMENTING_PARTNER, distribution_plan=delivery,
delivery_date=date_received)
expected = {
"run_id": answer.run.id,
"id": answer.id,
"value": str(answer.value),
"question_id": answer.question.id
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected, serialised[0]['responses'][0])
def test_should_serialise_node_with_built_out_consignee(self):
consignee = ConsigneeFactory()
node = DeliveryNodeFactory(consignee=consignee)
expected_consignee_serialisation = {
"created_by_user_id": consignee.created_by_user.id,
"name": consignee.name,
"imported_from_vision": consignee.imported_from_vision,
"location": consignee.location,
"remarks": consignee.remarks,
"customer_id": consignee.customer_id,
"type": consignee.type,
"id": consignee.id
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected_consignee_serialisation,
serialised[0]["consignee"])
def test_should_serialise_node_with_built_out_implementing_partner(self):
ip = ConsigneeFactory()
node = DeliveryNodeFactory(consignee=ip)
expected_ip_serialisation = {
"created_by_user_id": ip.created_by_user.id,
"name": ip.name,
"imported_from_vision": ip.imported_from_vision,
"location": ip.location,
"remarks": ip.remarks,
"customer_id": ip.customer_id,
"type": ip.type,
"id": ip.id
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected_ip_serialisation,
serialised[0]["ip"])
def test_should_serialise_node_purchase_order_under_release_order(self):
purchase_order = PurchaseOrderFactory()
release_order = ReleaseOrderFactory(purchase_order=purchase_order)
node = DeliveryNodeFactory(item=(ReleaseOrderItemFactory(
release_order=release_order)))
expected = {
"po_type": purchase_order.po_type,
"order_number": purchase_order.order_number,
"date": purchase_order.date,
"sales_order_id": purchase_order.sales_order.id,
"id": purchase_order.id,
"is_single_ip": purchase_order.is_single_ip
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(
expected, serialised[0]['order_item']['order']['purchase_order'])
def test_should_serialise_node_release_order(self):
release_order = ReleaseOrderFactory()
node = DeliveryNodeFactory(item=(ReleaseOrderItemFactory(
release_order=release_order)))
expected = {
"consignee_id": release_order.consignee.id,
"sales_order_id": release_order.sales_order.id,
"purchase_order_id": release_order.purchase_order.id,
"order_number": release_order.waybill,
"order_type": "release_order",
"release_order_number": release_order.order_number,
"id": release_order.id,
"delivery_date": release_order.delivery_date
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected,
serialised[0]['order_item']['order'])
def test_should_serialise_node_flat_fields(self):
node = DeliveryNodeFactory()
expected_node_serialisation = {
"total_value": node.total_value,
"track": node.track,
"ip_id": node.ip.id,
"tree_position": node.tree_position,
"contact_person_id": node.contact_person_id,
"item_id": node.item.id,
"id": node.id,
"remark": node.remark,
"consignee_id": node.consignee.id,
"acknowledged": node.acknowledged,
"programme_id": node.programme.id,
"location": node.location,
"balance": node.balance,
"distribution_plan_id": node.distribution_plan.id,
"delivery_date": node.delivery_date,
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected_node_serialisation, serialised[0])
def test_should_serialise_node_flat_fields(self):
node = DeliveryNodeFactory()
expected_node_serialisation = {
"total_value": node.total_value,
"track": node.track,
"ip_id": node.ip.id,
"tree_position": node.tree_position,
"contact_person_id": node.contact_person_id,
"item_id": node.item.id,
"id": node.id,
"remark": node.remark,
"consignee_id": node.consignee.id,
"acknowledged": node.acknowledged,
"programme_id": node.programme.id,
"location": node.location,
"balance": node.balance,
"distribution_plan_id": node.distribution_plan.id,
"delivery_date": node.delivery_date
}
serialised = serialise_nodes([node])
self.assertDictContainsSubset(expected_node_serialisation,
serialised[0])
def run():
sync = SyncInfo.objects.create()
nodes_to_update = serialise_nodes(list_nodes_to_update())
_push_to_elasticsearch(nodes_to_update, list_nodes_to_delete(), sync)
