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)