def test_should_not_create_existing_release_order_items_when_there_is_no_matching_purchase_order_item(
self):
self.create_consignees()
self.create_items()
self.create_sales_orders()
self.purchase_order_one = PurchaseOrderFactory(
order_number=81018523, sales_order=self.sales_order_one)
self.purchase_order_two = PurchaseOrderFactory(
order_number=45132639, sales_order=self.sales_order_two)
self.facade.save_records(self.imported_release_order_data)
self.assertEqual(ReleaseOrderItem.objects.count(), 0)
def test_should_get_orders__as_a_queryset__whose_items_have_been_delivered_to_a_specific_consignee(self):
consignee = ConsigneeFactory()
order_one = PurchaseOrderFactory()
order_two = PurchaseOrderFactory()
order_three = PurchaseOrderFactory()
order_item_one = PurchaseOrderItemFactory(purchase_order=order_one)
order_item_two = PurchaseOrderItemFactory(purchase_order=order_two)
NodeFactory(item=order_item_one, consignee=consignee)
NodeFactory(item=order_item_two, consignee=consignee)
consignee_orders = PurchaseOrder.objects.for_consignee(consignee.id).order_by('id')
self.assertListEqual(list(consignee_orders), [order_one, order_two])
self.assertNotIn(order_three, consignee_orders)
def add_a_node_with_response(self, number=1):
delivery = DeliveryFactory(track=True)
programme = ProgrammeFactory(name='special_program')
sales_order = SalesOrderFactory(programme=programme)
quantity_received_qn = NumericQuestion.objects.get(label='amountReceived')
while number > 0:
purchase_order = PurchaseOrderFactory(order_number=4748278 + number, sales_order=sales_order)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order,
item=ItemFactory(material_code='Code 23' + str(number),
description='Jerrycans' + str(number)))
self.extra_ip_node = DeliveryNodeFactory(programme=delivery.programme, distribution_plan=delivery,
item=po_item,
quantity=40, acknowledged=40, balance=40, location='Amudat',
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
run = RunFactory(runnable=self.extra_ip_node)
NumericAnswerFactory(question=quantity_received_qn, value=40, run=run)
number -= 1
end_node_one = DeliveryNodeFactory(programme=delivery.programme,
consignee=self.end_user,
parents=[(self.extra_ip_node, 30)],
tree_position=DistributionPlanNode.END_USER,
item=po_item)
run_end_node_one = RunFactory(runnable=end_node_one)
NumericAnswerFactory(question=quantity_received_qn, value=43, run=run_end_node_one)
def test_should_fetch_name_from_contacts_and_adds_alert_attribute(self):
answer_values = [
{"category": {"base": "No"}, "label": Question.LABEL.deliveryReceived},
{"category": {"base": "Yes"}, "label": Question.LABEL.isDeliveryInGoodOrder}
]
purchase_order = PurchaseOrderFactory(order_number=5678)
purchase_order_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
consignee = ConsigneeFactory(name="Liverpool FC - Unique")
contact_person_id = 'some_id'
contact = {u'_id': contact_person_id,
u'firstName': u'chris',
u'lastName': u'george',
u'phone': u'+256781111111'}
delivery = DeliveryFactory(consignee=consignee, contact_person_id=contact_person_id)
DeliveryNodeFactory(item=purchase_order_item, distribution_plan=delivery)
response = MagicMock(json=MagicMock(return_value=contact), status_code=200)
requests.get = MagicMock(return_value=response)
ResponseAlertHandler(runnable=delivery, answer_values=answer_values).process()
alert = Alert.objects.get(consignee_name="Liverpool FC - Unique", order_number=5678)
self.assertEqual(alert.contact['contact_name'], "chris george")
def test_should_get_export_list_for_direct_delivery(self, mock_build_contact):
self.clean()
contact = {'firstName': 'John', 'lastName': 'Ssenteza', 'phone': '+256 782 123456'}
mock_build_contact.return_value = contact
delivery = DeliveryFactory()
consignee_name = 'the consignee'
consignee = ConsigneeFactory(name=consignee_name)
order_number = 5404939
mama_kit = 'Mama kit'
material_code = 'Code 33'
ro_item = PurchaseOrderItemFactory(item=ItemFactory(description=mama_kit, material_code=material_code),
purchase_order=PurchaseOrderFactory(order_number=order_number))
delivery_date = '2015-09-06'
luweero = 'Luweero'
remark = 'some remark'
DeliveryNodeFactory(distribution_plan=delivery, delivery_date=delivery_date,
consignee=consignee, item=ro_item, location=luweero, remark=remark)
header = [
'Purchase Order', 'Item Description', 'Material Code', 'Quantity Shipped', 'Shipment Date',
'Implementing Partner', 'Contact Person', 'Contact Number', 'District', 'Is End User',
'Is Tracked', 'Remarks']
row_one = [order_number, mama_kit, material_code, 10, delivery_date, consignee_name,
'%s %s' % (contact['firstName'], contact['lastName']),
contact['phone'], luweero, 'Yes', 'No', remark]
expected_data = [header, row_one]
csv_exporter = DeliveryCSVExporter.create_delivery_exporter_by_type('Direct', self.HOSTNAME)
logger.info(expected_data)
logger.info(csv_exporter.assemble_csv_data())
self.assertEqual(csv_exporter.assemble_csv_data(), expected_data)
def test_should_know_if_it_has_a_distribution_plan_or_not(self):
purchase_order = PurchaseOrderFactory()
purchase_order_item = PurchaseOrderItemFactory(
purchase_order=purchase_order)
self.assertFalse(purchase_order.has_plan())
NodeFactory(item=purchase_order_item)
self.assertTrue(purchase_order.has_plan())
def test_should_return_delivery_with_order_number(self):
po = PurchaseOrderFactory(order_number=123456)
po_item = PurchaseOrderItemFactory(purchase_order=po)
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery, item=po_item)
self.assertEqual(delivery.number(), 123456)
def test_should_get_track_status_if_delivery_is_just_saved(self):
order = PurchaseOrderFactory()
order_item = PurchaseOrderItemFactory(purchase_order=order, quantity=100)
delivery_one = DeliveryFactory(track=False)
NodeFactory(item=order_item, distribution_plan=delivery_one, quantity=100, track=False)
self.assertEqual(order.track(), PurchaseOrder.NOT_TRACKED)
def test_should_create_alert(self, mock_contact):
purchase_order = PurchaseOrderFactory(order_number=5678)
purchase_order_item = PurchaseOrderItemFactory(
purchase_order=purchase_order)
consignee = ConsigneeFactory(name="Liverpool FC")
contact_person_id = 'some_id'
contact = {
u'_id': contact_person_id,
u'firstName': u'Chris',
u'lastName': u'George',
u'phone': u'+256781111111'
}
mock_contact.return_value = contact
delivery = DeliveryFactory(consignee=consignee,
contact_person_id=contact_person_id)
DeliveryNodeFactory(item=purchase_order_item,
distribution_plan=delivery)
delivery.create_alert(Alert.ISSUE_TYPES.not_received)
alerts = Alert.objects.filter(consignee_name="Liverpool FC",
order_number=5678)
self.assertEqual(alerts.count(), 1)
alert = alerts.first()
self.assertEqual(alert.order_type, PurchaseOrderItem.PURCHASE_ORDER)
self.assertEqual(alert.order_number, 5678)
self.assertEqual(alert.consignee_name, "Liverpool FC")
self.assertEqual(alert.contact['contact_name'], "Chris George")
self.assertEqual(alert.issue, Alert.ISSUE_TYPES.not_received)
self.assertFalse(alert.is_resolved)
self.assertIsNone(alert.remarks)
self.assertEqual(alert.runnable.id, delivery.id)
self.assertIsNone(alert.item_description)
def test_should_get_track_status_if_delivery_is_sent_partially(self):
order = PurchaseOrderFactory()
order_item = PurchaseOrderItemFactory(purchase_order=order, quantity=100)
delivery_one = DeliveryFactory(track=True)
NodeFactory(item=order_item, distribution_plan=delivery_one, quantity=50, track=True)
self.assertEqual(order.track(), PurchaseOrder.PARTIALLY_TRACKED)
def test_should_filter_deliveries_by_ip_and_number(self):
first_consignee = ConsigneeFactory()
second_consignee = ConsigneeFactory()
purchase_order = PurchaseOrderFactory(order_number=123)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
first_delivery = DeliveryFactory(consignee=first_consignee, track=True)
DeliveryNodeFactory(item=po_item, distribution_plan=first_delivery)
second_delivery = DeliveryFactory(consignee=first_consignee,
track=True)
third_delivery = DeliveryFactory(consignee=second_consignee)
self.logout()
self.log_consignee_in(consignee=first_consignee)
response = self.client.get(ENDPOINT_URL + '?query=123')
ids = map(lambda delivery: delivery['id'], response.data)
self.assertEqual(response.status_code, 200)
self.assertIn(first_delivery.id, ids)
self.assertNotIn(second_delivery.id, ids)
self.assertNotIn(third_delivery.id, ids)
def test_should_filter_admin_deliveries_by_multiple_queries(self):
first_consignee = ConsigneeFactory()
second_consignee = ConsigneeFactory()
purchase_order = PurchaseOrderFactory(order_number=123)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
date = datetime.date(2014, 07, 9)
first_delivery = DeliveryFactory(consignee=first_consignee,
track=True,
delivery_date=date)
DeliveryNodeFactory(item=po_item, distribution_plan=first_delivery)
second_delivery = DeliveryFactory(consignee=first_consignee,
track=True,
delivery_date=date)
third_delivery = DeliveryFactory(consignee=second_consignee)
response = self.client.get(ENDPOINT_URL +
'?from=2014-07-6&to=2014-12-31&query=123')
ids = map(lambda delivery: delivery['id'], response.data)
self.assertEqual(response.status_code, 200)
self.assertIn(first_delivery.id, ids)
self.assertNotIn(second_delivery.id, ids)
self.assertNotIn(third_delivery.id, ids)
def 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_create_alerts_integration(self):
purchase_order = PurchaseOrderFactory(order_number=5678)
purchase_order_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
consignee = ConsigneeFactory(name="Liverpool FC")
delivery = DeliveryFactory(consignee=consignee)
DeliveryNodeFactory(item=purchase_order_item, distribution_plan=delivery)
date_of_receipt = self.__get_current_date()
good_comment = "All is good"
data = {
'runnable': delivery.id, 'answers': [
{'question_label': 'deliveryReceived', 'value': 'No'},
{'question_label': 'dateOfReceipt', 'value': date_of_receipt},
{'question_label': 'isDeliveryInGoodOrder', 'value': 'Yes'},
{'question_label': 'areYouSatisfied', 'value': 'Yes'},
{'question_label': 'additionalDeliveryComments', 'value': good_comment}
]}
response = self.client.post(ENDPOINT_URL, data=json.dumps(data), content_type='application/json')
self.assertEqual(response.status_code, 201)
alert = Alert.objects.get(consignee_name="Liverpool FC", order_number=5678)
self.assertEqual(alert.issue, Alert.ISSUE_TYPES.not_received)
self.assertTrue(self.mock_distribution_alert_raise.delay.called)
def test_should_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_multiple_deliveries_along_with_their_corresponding_nodes(
self):
order = PurchaseOrderFactory()
order_item_one = PurchaseOrderItemFactory(purchase_order=order)
order_item_two = PurchaseOrderItemFactory(purchase_order=order)
delivery_one = DeliveryFactory()
delivery_two = DeliveryFactory()
node_one = NodeFactory(item=order_item_one,
distribution_plan=delivery_one)
node_two = NodeFactory(item=order_item_two,
distribution_plan=delivery_one)
node_three = NodeFactory(item=order_item_one,
distribution_plan=delivery_two)
node_four = NodeFactory(item=order_item_two,
distribution_plan=delivery_two)
deliveries = order.deliveries()
self.assertEqual(len(deliveries), 2)
self.assertIn(delivery_one, list(deliveries))
self.assertIn(delivery_two, list(deliveries))
first_delivery_nodes = delivery_one.distributionplannode_set.all()
second_delivery_nodes = delivery_two.distributionplannode_set.all()
self.assertIn(node_one, first_delivery_nodes)
self.assertIn(node_two, first_delivery_nodes)
self.assertIn(node_three, second_delivery_nodes)
self.assertIn(node_four, second_delivery_nodes)
def test_should_know_if_it_is_fully_delivered_or_not_using_only_tracked_nodes(
self):
purchase_order = PurchaseOrderFactory()
item_one = PurchaseOrderItemFactory(purchase_order=purchase_order,
quantity=100)
item_two = PurchaseOrderItemFactory(purchase_order=purchase_order,
quantity=100)
self.assertFalse(purchase_order.is_fully_delivered())
delivery = DeliveryFactory()
node_one = NodeFactory(
item=item_one,
quantity=100,
distribution_plan=delivery,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
self.assertFalse(purchase_order.is_fully_delivered())
node_two = NodeFactory(
item=item_two,
quantity=100,
distribution_plan=delivery,
tree_position=DistributionPlanNode.IMPLEMENTING_PARTNER)
self.assertFalse(purchase_order.is_fully_delivered())
delivery.track = True
delivery.save()
node_two.quantity = 50
node_two.save()
self.assertFalse(purchase_order.is_fully_delivered())
node_two.quantity = 100
node_two.save()
self.assertTrue(purchase_order.is_fully_delivered())
def test_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 create_purchase_orders(self):
self.purchase_order_one = PurchaseOrderFactory(
order_number=81018523, sales_order=self.sales_order_one)
self.purchase_order_two = PurchaseOrderFactory(
order_number=45132639, sales_order=self.sales_order_two)
self.purchase_order_item_one = PurchaseOrderItemFactory(
purchase_order=self.purchase_order_one,
sales_order_item=self.sales_order_item_one,
item_number=10)
self.purchase_order_item_two = PurchaseOrderItemFactory(
purchase_order=self.purchase_order_one,
sales_order_item=self.sales_order_item_two,
item_number=20)
self.purchase_order_item_three = PurchaseOrderItemFactory(
purchase_order=self.purchase_order_two,
sales_order_item=self.sales_order_item_three,
item_number=20)
def test_delivery_node_knows_its_item_description(self):
purchase_order = PurchaseOrderFactory(order_number=200)
description = "some description"
item = ItemFactory(description=description)
po_node = DeliveryNodeFactory(item=PurchaseOrderItemFactory(
purchase_order=purchase_order, item=item))
self.assertEqual(po_node.item_description(), description)
def create_purchase_orders(self):
programme = ProgrammeFactory(name='YP104 MANAGEMENT RESULTS')
consignee = ConsigneeFactory(name='Wakiso DHO')
date = datetime.date(2014, 07, 9)
po_one = PurchaseOrderFactory(order_number=45143984)
po_two = PurchaseOrderFactory(
order_number=40141010,
sales_order=SalesOrderFactory(programme=programme),
last_shipment_date=date)
po_item = PurchaseOrderItemFactory(
purchase_order=po_two, item=ItemFactory(description="HEK2013"))
distribution_plan = DeliveryFactory()
DeliveryNodeFactory(item=po_item,
distribution_plan=distribution_plan,
location="Wakiso",
consignee=consignee)
return po_one, po_two, programme, consignee
def test_returned_nodes_should_have_order_type_field(self):
po_node = DeliveryNodeFactory(item=PurchaseOrderItemFactory(purchase_order=(PurchaseOrderFactory())))
ro_node = DeliveryNodeFactory(item=ReleaseOrderItemFactory(release_order=(ReleaseOrderFactory())))
response = self.client.get(ENDPOINT_URL)
node_order_types = [node['order_type'] for node in response.data]
self.assertItemsEqual([po_node.type(), ro_node.type()], node_order_types)
def test_should_return_number_of_delivery(self):
purchase_order = PurchaseOrderFactory(order_number=98765)
po_item = PurchaseOrderItemFactory(purchase_order=purchase_order)
delivery = DeliveryFactory()
DeliveryNodeFactory(distribution_plan=delivery, item=po_item)
response = self.client.get(ENDPOINT_URL)
self.assertEqual(response.data[0]['number'], 98765)
def _create_node(self, delivery, is_purchase, order_number, track, tree_position, location='Madagascar'):
if is_purchase:
DeliveryNodeFactory(
track=track, distribution_plan=delivery, tree_position=tree_position, location=location,
item=PurchaseOrderItemFactory(purchase_order=PurchaseOrderFactory(order_number=order_number)))
else:
DeliveryNodeFactory(
track=track, distribution_plan=delivery, tree_position=tree_position, location=location,
item=ReleaseOrderItemFactory(release_order=ReleaseOrderFactory(waybill=order_number)))
def setup_purchase_orders_and_items(self):
self.programme_one = ProgrammeFactory(name='programme_one')
self.programme_two = ProgrammeFactory(name='programme_two')
so_one = SalesOrderFactory(programme=self.programme_one)
so_two = SalesOrderFactory(programme=self.programme_two)
so_item_one = SalesOrderItemFactory(sales_order=so_one, quantity=20, net_price=10, net_value=20 * 10)
so_item_two = SalesOrderItemFactory(sales_order=so_one, quantity=5, net_price=10, net_value=5 * 10)
so_item_three = SalesOrderItemFactory(sales_order=so_two, quantity=2, net_price=10, net_value=2 * 10)
self.po_one = PurchaseOrderFactory(sales_order=so_one)
self.po_two = PurchaseOrderFactory(sales_order=so_two)
self.po_item_one = PurchaseOrderItemFactory(purchase_order=self.po_one, quantity=20,
sales_order_item=so_item_one, value=200)
self.po_item_two = PurchaseOrderItemFactory(purchase_order=self.po_one, quantity=5,
sales_order_item=so_item_two, value=50)
self.po_item_three = PurchaseOrderItemFactory(purchase_order=self.po_two, quantity=2,
sales_order_item=so_item_three, value=20)
def test_should_know_its_order_number(self):
purchase_order = PurchaseOrderFactory(order_number=200)
po_node = DeliveryNodeFactory(item=PurchaseOrderItemFactory(
purchase_order=purchase_order))
self.assertEqual(po_node.order_number(), 200)
release_order = ReleaseOrderFactory(waybill=300)
ro_node = DeliveryNodeFactory(item=ReleaseOrderItemFactory(
release_order=release_order))
self.assertEqual(ro_node.order_number(), 300)
def test_should_include_order_number_in_delivery_node_fields(self):
purchase_order = PurchaseOrderFactory(order_number=200)
DeliveryNodeFactory(item=PurchaseOrderItemFactory(purchase_order=purchase_order))
release_order = ReleaseOrderFactory(waybill=300)
DeliveryNodeFactory(item=ReleaseOrderItemFactory(release_order=release_order))
response = self.client.get(ENDPOINT_URL)
node_order_numbers = [node['order_number'] for node in response.data]
self.assertItemsEqual([300, 200], node_order_numbers)
def test_should_compute_purchase_order_total_value(self):
order = PurchaseOrderFactory()
PurchaseOrderItemFactory(purchase_order=order, value=100)
total_value_route = '%s%d/total_value/' % (ENDPOINT_URL, order.id)
response = self.client.get(total_value_route)
self.assertEqual(response.data, 100)
PurchaseOrderItemFactory(purchase_order=order, value=200)
response = self.client.get(total_value_route)
self.assertEqual(response.data, 300)
def test_should_provide_purchase_orders_that_have_deliveries_for_a_specific_consignee(
self, mock_for_consignee):
consignee_id = u'10'
order = PurchaseOrderFactory()
mock_for_consignee.return_value = PurchaseOrder.objects.all()
response = self.client.get('%s?consignee=%s' %
(ENDPOINT_URL, consignee_id))
mock_for_consignee.assert_called_with(consignee_id)
self.assertDictContainsSubset({'id': order.id}, response.data[0])
def test_fetched_purchase_orders_should_have_programme_name_and_programme_id(
self):
programme = ProgrammeFactory()
purchase_order = PurchaseOrderFactory(sales_order=SalesOrderFactory(
programme=programme))
response = self.client.get('%s%s/' % (ENDPOINT_URL, purchase_order.id))
self.assertDictContainsSubset(
{
'programme': programme.id,
'programme_name': programme.name
}, response.data)
