from datetime import timedelta from decimal import Decimal as D from django.test import TestCase from django.utils import timezone import mock from oscar.apps.address.models import Country from oscar.apps.basket.models import Basket from oscar.apps.order.models import ShippingAddress, Order, Line, \ ShippingEvent, ShippingEventType, ShippingEventQuantity, OrderNote, \ OrderDiscount from oscar.apps.order.exceptions import (InvalidOrderStatus, InvalidLineStatus, InvalidShippingEvent) from oscar.test.factories import create_order, create_product, create_offer, \ create_voucher ORDER_PLACED = 'order_placed' class ShippingAddressTest(TestCase): fixtures = ['countries.json'] def test_titleless_salutation_is_stripped(self): country = Country.objects.get(iso_3166_1_a2='GB') a = ShippingAddress.objects.create( last_name='Barrington', line1="75 Smith Road", postcode="N4 8TY", country=country) self.assertEquals("Barrington", a.salutation) class OrderStatusPipelineTests(TestCase): def setUp(self): Order.pipeline = {'PENDING': ('SHIPPED', 'CANCELLED'), 'SHIPPED': ('COMPLETE',)} Order.cascade = {'SHIPPED': 'SHIPPED'} def tearDown(self): Order.pipeline = {} Order.cascade = {} def test_available_statuses_for_pending(self): self.order = create_order(status='PENDING') self.assertEqual(('SHIPPED', 'CANCELLED'), self.order.available_statuses()) def test_available_statuses_for_shipped_order(self): self.order = create_order(status='SHIPPED') self.assertEqual(('COMPLETE',), self.order.available_statuses()) def test_no_statuses_available_for_no_status(self): self.order = create_order() self.assertEqual((), self.order.available_statuses()) def test_set_status_respects_pipeline(self): self.order = create_order(status='SHIPPED') with self.assertRaises(InvalidOrderStatus): self.order.set_status('PENDING') def test_set_status_does_nothing_for_same_status(self): self.order = create_order(status='PENDING') self.order.set_status('PENDING') self.assertEqual('PENDING', self.order.status) def test_set_status_works(self): self.order = create_order(status='PENDING') self.order.set_status('SHIPPED') self.assertEqual('SHIPPED', self.order.status) def test_cascading_status_change(self): self.order = create_order(status='PENDING') self.order.set_status('SHIPPED') for line in self.order.lines.all(): self.assertEqual('SHIPPED', line.status) class OrderNoteTests(TestCase): def setUp(self): self.order = create_order() def test_system_notes_are_not_editable(self): note = self.order.notes.create(note_type=OrderNote.SYSTEM, message='test') self.assertFalse(note.is_editable()) def test_non_system_notes_are_editable(self): note = self.order.notes.create(message='test') self.assertTrue(note.is_editable()) def test_notes_are_not_editable_after_timeout(self): OrderNote.editable_lifetime = 1 note = self.order.notes.create(message='test') self.assertTrue(note.is_editable()) now = timezone.now() with mock.patch.object(timezone, 'now') as mock_timezone: mock_timezone.return_value = now + timedelta(seconds=30) self.assertFalse(note.is_editable()) class LineTests(TestCase): def setUp(self): basket = Basket() basket.add_product(create_product(price=D('10.00')), 4) self.order = create_order(number='100002', basket=basket) self.line = self.order.lines.all()[0] self.order_placed, __ = ShippingEventType.objects.get_or_create( code='order_placed', name='Order placed') self.dispatched, __ = ShippingEventType.objects.get_or_create( code='dispatched', name='Dispatched') def tearDown(self): ShippingEventType.objects.all().delete() def event(self, type, quantity=None): """ Creates a shipping event for the test line """ event = ShippingEvent.objects.create(order=self.order, event_type=type) if quantity is None: quantity = self.line.quantity ShippingEventQuantity.objects.create( event=event, line=self.line, quantity=quantity) def test_shipping_event_history(self): self.event(self.order_placed, 3) self.event(self.dispatched, 1) history = self.line.shipping_event_breakdown self.assertEqual(3, history['Order placed']['quantity']) self.assertEqual(1, history['Dispatched']['quantity']) def test_shipping_status_is_empty_to_start_with(self): self.assertEquals('', self.line.shipping_status) def test_shipping_status_after_full_line_event(self): self.event(self.order_placed) self.assertEquals(self.order_placed.name, self.line.shipping_status) def test_shipping_status_after_two_full_line_events(self): type1 = self.order_placed self.event(type1) type2 = self.dispatched self.event(type2) self.assertEquals(type2.name, self.line.shipping_status) def test_shipping_status_after_partial_line_event(self): type = self.order_placed self.event(type, 3) expected = "%s (%d/%d items)" % (type.name, 3, self.line.quantity) self.assertEquals(expected, self.line.shipping_status) def test_has_passed_shipping_status_after_full_line_event(self): type = self.order_placed self.event(type) self.assertTrue(self.line.has_shipping_event_occurred(type)) def test_has_passed_shipping_status_after_partial_line_event(self): type = self.order_placed self.event(type, self.line.quantity - 1) self.assertFalse(self.line.has_shipping_event_occurred(type), 1) def test_has_passed_shipping_status_after_multiple_line_event(self): event_types = [ShippingEventType.objects.get(code='order_placed'), ShippingEventType.objects.get(code='dispatched')] for type in event_types: self.event(type) for type in event_types: self.assertTrue(self.line.has_shipping_event_occurred(type)) def test_inconsistent_shipping_status_setting(self): type = self.order_placed self.event(type, self.line.quantity - 1) with self.assertRaises(InvalidShippingEvent): self.event(type, self.line.quantity) def test_inconsistent_shipping_quantities(self): type = ShippingEventType.objects.get(code='order_placed') self.event(type, self.line.quantity - 1) with self.assertRaises(InvalidShippingEvent): # Total quantity is too high self.event(type, 2) class LineStatusTests(TestCase): def setUp(self): Line.pipeline = {'A': ('B', 'C'), 'B': ('C',)} self.order = create_order() self.line = self.order.lines.all()[0] self.line.status = 'A' self.line.save() def test_all_statuses_class_method(self): self.assertEqual(['A', 'B'], Line.all_statuses()) def test_invalid_status_set_raises_exception(self): with self.assertRaises(InvalidLineStatus): self.line.set_status('D') def test_set_status_changes_status(self): self.line.set_status('C') self.assertEqual('C', self.line.status) def test_setting_same_status_does_nothing(self): self.line.set_status('A') class ShippingEventTypeTests(TestCase): def tearDown(self): ShippingEventType.objects.all().delete() def test_code_is_set_automatically(self): etype = ShippingEventType.objects.create(name='Returned') self.assertEqual('returned', etype.code) class ShippingEventQuantityTests(TestCase): def setUp(self): basket = Basket() basket.add_product(create_product(price=D('10.00')), 4) self.order = create_order(number='100002', basket=basket) self.line = self.order.lines.all()[0] self.shipped,_ = ShippingEventType.objects.get_or_create(name='Shipped') self.returned,_ = ShippingEventType.objects.get_or_create(name='Returned') def tearDown(self): ShippingEventType.objects.all().delete() def test_quantity_defaults_to_all(self): event = self.order.shipping_events.create(event_type=self.shipped) event_quantity = ShippingEventQuantity.objects.create(event=event, line=self.line) self.assertEquals(self.line.quantity, event_quantity.quantity) def test_event_is_created_ok_when_prerequisites_are_met(self): shipped_event = self.order.shipping_events.create(event_type=self.shipped) ShippingEventQuantity.objects.create(event=shipped_event, line=self.line) event = self.order.shipping_events.create(event_type=self.returned) ShippingEventQuantity.objects.create(event=event, line=self.line, quantity=1) class TestOrderDiscount(TestCase): def test_can_be_created_without_offer_or_voucher(self): order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00')) self.assertTrue(discount.voucher is None) self.assertTrue(discount.offer is None) self.assertEquals(discount.description(), u'') def test_can_be_created_with_an_offer(self): offer = create_offer() order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00'), offer_id=offer.id) self.assertEqual(offer.id, discount.offer.id) self.assertEqual(offer.name, discount.offer_name) def test_can_be_created_with_an_offer_and_specified_offer_name(self): offer = create_offer(name="My offer") order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00'), offer_id=offer.id, offer_name="Your offer") self.assertEqual(offer.id, discount.offer.id) self.assertEqual("Your offer", discount.offer_name) def test_can_be_created_with_a_voucher(self): voucher = create_voucher() order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00'), voucher_id=voucher.id) self.assertEqual(voucher.id, discount.voucher.id) self.assertEqual(voucher.code, discount.voucher_code) def test_can_be_created_with_a_voucher_and_specidied_voucher_code(self): voucher = create_voucher() order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00'), voucher_id=voucher.id, voucher_code="anothercode") self.assertEqual(voucher.id, discount.voucher.id) self.assertEqual('anothercode', discount.voucher_code) def test_contains_offer_details_after_offer_is_deleted(self): offer = create_offer(name="Get 200% off") order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00'), offer_id=offer.id) offer.delete() self.assertTrue(discount.voucher is None) self.assertTrue(discount.offer is None) self.assertEquals(discount.description(), u'Get 200% off') def test_contains_voucher_details_after_voucher_is_deleted(self): voucher = create_voucher() order = create_order(number='100002') discount = OrderDiscount.objects.create(order=order, amount=D('10.00'), voucher_id=voucher.id) voucher.delete() self.assertTrue(discount.voucher is None) self.assertTrue(discount.offer is None) self.assertEquals(discount.description(), voucher.code)