Rework partner tests for readability

oscar/apps/partner/wrappers.py

@@ -7,6 +7,9 @@ class DefaultWrapper(object):
     """
     Default stockrecord wrapper
     """
+    CODE_IN_STOCK = 'instock'
+    CODE_AVAILABLE = 'available'
+    CODE_UNAVAILABLE = 'outofstock'
 
     def is_available_to_buy(self, stockrecord):
         """
@@ -55,10 +58,10 @@ class DefaultWrapper(object):
         :param oscar.apps.partner.models.StockRecord stockrecord: stockrecord instance
         """
         if stockrecord.net_stock_level > 0:
-            return 'instock'
+            return self.CODE_IN_STOCK
         if self.is_available_to_buy(stockrecord):
-            return 'available'
-        return 'outofstock'
+            return self.CODE_AVAILABLE
+        return self.CODE_UNAVAILABLE
 
     def availability(self, stockrecord):
         """

tests/unit/partner/stock_tests.py → tests/functional/stock_alert_tests.py

@@ -8,59 +8,73 @@ from oscar.apps.partner.models import StockRecord, StockAlert
 from oscar.apps.order.utils import OrderCreator
 
 
-class StockActionTests(TestCase):
+# These aren't really unit tests - move them?
+class TestPlacingAnOrder(TestCase):
 
     def setUp(self):
         self.product = create_product(price=D('12.00'), num_in_stock=5)
         self.basket = Basket()
         self.basket.add_product(self.product)
 
-    def tearDown(self):
-        StockAlert.objects.all().delete()
-
     def set_threshold(self, threshold):
         self.product.stockrecord.low_stock_threshold = threshold
         self.product.stockrecord.save()
 
-    def test_stock_is_allocated_after_checkout(self):
-        order = OrderCreator().place_order(self.basket)
+    def test_correctly_allocates_stock(self):
+        OrderCreator().place_order(self.basket)
 
         record = StockRecord.objects.get(product=self.product)
         self.assertEqual(5, record.num_in_stock)
         self.assertEqual(1, record.num_allocated)
         self.assertEqual(4, record.net_stock_level)
 
-    def test_no_alert_raised_if_threshold_not_breached(self):
-        self.set_threshold(3)
-        order = OrderCreator().place_order(self.basket)
+    def test_does_not_raise_an_alert_if_threshold_not_broken(self):
+        self.set_threshold(4)
+        OrderCreator().place_order(self.basket)
 
         alerts = StockAlert.objects.all()
         self.assertEqual(0, len(alerts))
 
-    def test_alert_created_when_threhold_met(self):
+    def test_raises_alert_when_threshold_is_reached(self):
         self.set_threshold(5)
-        order = OrderCreator().place_order(self.basket)
+        OrderCreator().place_order(self.basket)
 
-        alerts = StockAlert.objects.filter(stockrecord=self.product.stockrecord)
+        alerts = StockAlert.objects.filter(
+            stockrecord=self.product.stockrecord)
         self.assertEqual(1, len(alerts))
 
-    def test_alert_only_created_when_no_alert_exists_already(self):
+    def test_only_raises_an_alert_once(self):
         self.set_threshold(5)
         StockAlert.objects.create(stockrecord=self.product.stockrecord,
                                   threshold=10)
-        order = OrderCreator().place_order(self.basket)
+        OrderCreator().place_order(self.basket)
 
-        alerts = StockAlert.objects.filter(stockrecord=self.product.stockrecord)
+        alerts = StockAlert.objects.filter(
+            stockrecord=self.product.stockrecord)
         self.assertEqual(1, len(alerts))
 
-    def test_alert_closed_when_stock_replenished(self):
+
+class TestRestockingProduct(TestCase):
+
+    def setUp(self):
+        self.product = create_product(price=D('12.00'), num_in_stock=5)
+        self.basket = Basket()
+        self.basket.add_product(self.product)
+
+    def set_threshold(self, threshold):
+        self.product.stockrecord.low_stock_threshold = threshold
+        self.product.stockrecord.save()
+
+    def test_closes_open_alert(self):
         self.set_threshold(5)
-        order = OrderCreator().place_order(self.basket)
+        OrderCreator().place_order(self.basket)
 
         alert = StockAlert.objects.get(stockrecord=self.product.stockrecord)
         self.assertEqual(StockAlert.OPEN, alert.status)
 
+        # Restock product
         self.product.stockrecord.num_in_stock = 15
         self.product.stockrecord.save()
+
         alert = StockAlert.objects.get(stockrecord=self.product.stockrecord)
         self.assertEqual(StockAlert.CLOSED, alert.status)

tests/unit/partner/model_tests.py

@@ -1,5 +1,4 @@
 from decimal import Decimal as D
-import datetime
 
 from django.test import TestCase
 
@@ -66,28 +65,6 @@ class TestStockRecord(TestCase):
         self.assertEqual(10, self.stockrecord.max_purchase_quantity())
 
 
-class DefaultWrapperTests(TestCase):
-
-    def test_default_wrapper_for_in_stock(self):
-        product = create_product(price=D('10.00'), partner="Acme", num_in_stock=10)
-        self.assertEquals("In stock (10 available)", product.stockrecord.availability)
-        self.assertEqual("instock", product.stockrecord.availability_code)
-
-    def test_default_wrapper_for_out_of_stock(self):
-        product = create_product(price=D('10.00'), partner="Acme", num_in_stock=0)
-        self.assertEquals(u"Not available",
-                          unicode(product.stockrecord.availability))
-        self.assertEqual("outofstock", product.stockrecord.availability_code)
-
-    def test_dispatch_date_for_in_stock(self):
-        product = create_product(price=D('10.00'), partner="Acme", num_in_stock=1)
-        self.assertIsNone(product.stockrecord.dispatch_date)
-
-    def test_dispatch_date_for_out_of_stock(self):
-        product = create_product(price=D('10.00'), partner="Acme", num_in_stock=0)
-        self.assertIsNone(product.stockrecord.dispatch_date)
-
-
 class CustomWrapperTests(TestCase):
 
     def setUp(self):

tests/unit/partner/wrapper_tests.py

@@ -1,77 +1,153 @@
-import datetime
+from decimal import Decimal as D
 
 from django.test import TestCase
-from mock import patch
 
 from oscar.apps.partner.wrappers import DefaultWrapper
+from oscar.apps.catalogue.models import Product, ProductClass
 from oscar.apps.partner.models import StockRecord
-from oscar.test.helpers import create_product
 
 
-class TestDefaultWrapper(TestCase):
+class TestStockRecordWithNullStockLevel(TestCase):
+    """
+    Stock record with num_in_stock=None
+    """
 
     def setUp(self):
         self.wrapper = DefaultWrapper()
-        self.product = create_product()
-
-    def test_num_in_stock_is_none_is_available_to_buy(self):
-        record = StockRecord(num_in_stock=None, product=self.product)
-        self.assertTrue(self.wrapper.is_available_to_buy(record))
-
-    def test_zero_stock_is_not_available_to_buy(self):
-        record = StockRecord(num_in_stock=0, product=self.product)
-        self.assertFalse(self.wrapper.is_available_to_buy(record))
-
-    def test_nonzero_stock_is_available_to_buy(self):
-        record = StockRecord(num_in_stock=10, product=self.product)
-        self.assertTrue(self.wrapper.is_available_to_buy(record))
-
-    def test_matching_purchase_is_permitted(self):
-        record = StockRecord(num_in_stock=4, product=self.product)
-        result, reason = self.wrapper.is_purchase_permitted(record, quantity=4)
-        self.assertTrue(result)
-
-    def test_smaller_purchase_is_permitted(self):
-        record = StockRecord(num_in_stock=4, product=self.product)
-        result, reason = self.wrapper.is_purchase_permitted(record, quantity=3)
-        self.assertTrue(result)
-
-    def test_too_large_purchase_is_not_permitted(self):
-        record = StockRecord(num_in_stock=4, product=self.product)
-        result, reason = self.wrapper.is_purchase_permitted(record, quantity=5)
-        self.assertFalse(result)
-
-    def test_max_purchase_quantity(self):
-        record = StockRecord(num_in_stock=4, product=self.product)
-        self.assertEqual(record.num_in_stock, self.wrapper.max_purchase_quantity(record))
-
-    def test_availability_code_for_in_stock(self):
-        record = StockRecord(num_in_stock=4, product=self.product)
-        self.assertEqual('instock', self.wrapper.availability_code(record))
-
-    def test_availability_code_for_zero_stock(self):
-        record = StockRecord(num_in_stock=0, product=self.product)
-        self.assertEqual('outofstock', self.wrapper.availability_code(record))
-
-    def test_availability_code_for_null_stock_but_available(self):
-        record = StockRecord(num_in_stock=None, product=self.product)
-        self.assertEqual('available', self.wrapper.availability_code(record))
-
-    def test_availability_message_for_in_stock(self):
-        record = StockRecord(num_in_stock=4, product=self.product)
-        self.assertEqual(u'In stock (4 available)', unicode(self.wrapper.availability(record)))
-
-    def test_availability_message_for_available(self):
-        record = StockRecord(num_in_stock=None, product=self.product)
-        self.assertEqual(u'Available', unicode(self.wrapper.availability(record)))
-
-    def test_availability_message_for_out_of_stock(self):
-        record = StockRecord(num_in_stock=0, product=self.product)
-        self.assertEqual(u'Not available', unicode(self.wrapper.availability(record)))
-
-    def test_backorder_purchase_is_permitted(self):
-        record = StockRecord(num_in_stock=None, product=self.product)
-        with patch.object(self.wrapper, 'max_purchase_quantity') as m:
-            m.return_value = None
-            result, reason = self.wrapper.is_purchase_permitted(record)
-            self.assertTrue(result)
+        self.product = Product()
+        self.product.product_class = ProductClass()
+        self.record = StockRecord(num_in_stock=None, product=self.product)
+
+    def test_is_available_to_buy(self):
+        self.assertTrue(self.wrapper.is_available_to_buy(self.record))
+
+    def test_permits_purchase(self):
+        is_permitted, reason = self.wrapper.is_purchase_permitted(
+            self.record)
+        self.assertTrue(is_permitted)
+
+    def test_has_no_max_purchase_quantity(self):
+        self.assertIsNone(self.wrapper.max_purchase_quantity(self.record))
+
+    def test_returns_available_code(self):
+        self.assertEqual(DefaultWrapper.CODE_AVAILABLE,
+                         self.wrapper.availability_code(self.record))
+
+    def test_returns_correct_availability_message(self):
+        self.assertEqual("Available",
+                         self.wrapper.availability(self.record))
+
+    def test_returns_no_estimated_dispatch_date(self):
+        self.assertIsNone(self.wrapper.dispatch_date(self.record))
+
+    def test_returns_zero_tax(self):
+        self.assertEqual(D('0.00'), self.wrapper.calculate_tax(self.record))
+
+
+class TestStockRecordOfDigitalProduct(TestCase):
+
+    def setUp(self):
+        self.wrapper = DefaultWrapper()
+        self.product = Product()
+        self.product.product_class = ProductClass(track_stock=False)
+        self.record = StockRecord(num_in_stock=None, product=self.product)
+
+    def test_is_available_to_buy(self):
+        self.assertTrue(self.wrapper.is_available_to_buy(self.record))
+
+    def test_permits_purchase(self):
+        is_permitted, reason = self.wrapper.is_purchase_permitted(
+            self.record)
+        self.assertTrue(is_permitted)
+
+    def test_has_no_max_purchase_quantity(self):
+        self.assertIsNone(self.wrapper.max_purchase_quantity(self.record))
+
+    def test_returns_available_code(self):
+        self.assertEqual(DefaultWrapper.CODE_AVAILABLE,
+                         self.wrapper.availability_code(self.record))
+
+    def test_returns_correct_availability_message(self):
+        self.assertEqual("Available",
+                         self.wrapper.availability(self.record))
+
+    def test_returns_no_estimated_dispatch_date(self):
+        self.assertIsNone(self.wrapper.dispatch_date(self.record))
+
+    def test_returns_zero_tax(self):
+        self.assertEqual(D('0.00'), self.wrapper.calculate_tax(self.record))
+
+
+class TestStockRecordOfZeroStockProduct(TestCase):
+
+    def setUp(self):
+        self.wrapper = DefaultWrapper()
+        self.product = Product()
+        self.product.product_class = ProductClass()
+        self.record = StockRecord(num_in_stock=0, product=self.product)
+
+    def test_is_not_available_to_buy(self):
+        self.assertFalse(self.wrapper.is_available_to_buy(self.record))
+
+    def test_does_not_permit_purchase(self):
+        is_permitted, reason = self.wrapper.is_purchase_permitted(
+            self.record)
+        self.assertFalse(is_permitted)
+
+    def test_has_zero_max_purchase_quantity(self):
+        self.assertEqual(0, self.wrapper.max_purchase_quantity(self.record))
+
+    def test_returns_unavailable_code(self):
+        self.assertEqual(DefaultWrapper.CODE_UNAVAILABLE,
+                         self.wrapper.availability_code(self.record))
+
+    def test_returns_correct_availability_message(self):
+        self.assertEqual("Not available",
+                         self.wrapper.availability(self.record))
+
+    def test_returns_no_estimated_dispatch_date(self):
+        self.assertIsNone(self.wrapper.dispatch_date(self.record))
+
+    def test_returns_zero_tax(self):
+        self.assertEqual(D('0.00'), self.wrapper.calculate_tax(self.record))
+
+
+class TestStockRecordWithPositiveStock(TestCase):
+
+    def setUp(self):
+        self.wrapper = DefaultWrapper()
+        self.product = Product()
+        self.product.product_class = ProductClass()
+        self.record = StockRecord(num_in_stock=5, product=self.product)
+
+    def test_is_available_to_buy(self):
+        self.assertTrue(self.wrapper.is_available_to_buy(self.record))
+
+    def test_does_permit_purchase_for_smaller_quantities(self):
+        for x in range(1, 6):
+            is_permitted, reason = self.wrapper.is_purchase_permitted(
+                self.record, quantity=x)
+            self.assertTrue(is_permitted)
+
+    def test_does_not_permit_purchase_for_larger_quantities(self):
+        for x in range(6, 10):
+            is_permitted, reason = self.wrapper.is_purchase_permitted(
+                self.record, quantity=x)
+            self.assertFalse(is_permitted)
+
+    def test_has_correct_max_purchase_quantity(self):
+        self.assertEqual(5, self.wrapper.max_purchase_quantity(self.record))
+
+    def test_returns_available_code(self):
+        self.assertEqual(DefaultWrapper.CODE_IN_STOCK,
+                         self.wrapper.availability_code(self.record))
+
+    def test_returns_correct_availability_message(self):
+        self.assertEqual("In stock (5 available)",
+                         self.wrapper.availability(self.record))
+
+    def test_returns_no_estimated_dispatch_date(self):
+        self.assertIsNone(self.wrapper.dispatch_date(self.record))
+
+    def test_returns_zero_tax(self):
+        self.assertEqual(D('0.00'), self.wrapper.calculate_tax(self.record))