Basket tests house-keeping

- Restructure into unit and integration tests.
- Add more tests for the various basket properties.

oscar/apps/basket/abstract_models.py

         self._lines = None
         self.offer_applications = results.OfferApplications()
 
+    def __unicode__(self):
+        return _(
+            u"%(status)s basket (owner: %(owner)s, lines: %(num_lines)d)") % {
+                'status': self.status,
+                'owner': self.owner,
+                'num_lines': self.num_lines}
+
+    # ========
+    # Strategy
+    # ========
+
     @property
     def has_strategy(self):
         return hasattr(self, '_strategy')
 
     strategy = property(_get_strategy, _set_strategy)
 
-    def __unicode__(self):
-        return _(
-            u"%(status)s basket (owner: %(owner)s, lines: %(num_lines)d)") % {
-                'status': self.status,
-                'owner': self.owner,
-                'num_lines': self.num_lines}
-
     def all_lines(self):
         """
         Return a cached set of basket lines.
             line.save()
         self.reset_offer_applications()
     add_product.alters_data = True
-
     add = add_product
 
     def applied_offers(self):
 
     @property
     def contains_a_voucher(self):
+        if not self.id:
+            return False
         return self.vouchers.all().count() > 0
 
-    # =============
-    # Query methods
-    # =============
+    @property
+    def is_submitted(self):
+        return self.status == self.SUBMITTED
 
+    @property
     def can_be_edited(self):
         """
         Test if a basket can be edited
         """
         return self.status in self.editable_statuses
 
+    # =============
+    # Query methods
+    # =============
+
     def contains_voucher(self, code):
         """
         Test whether the basket contains a voucher with a given code
         """
+        if not self.id:
+            return False
         try:
             self.vouchers.get(code=code)
         except ObjectDoesNotExist:
         except ObjectDoesNotExist:
             return 0
 
-    def is_submitted(self):
-        return self.status == self.SUBMITTED
 
 
 class AbstractLine(models.Model):
         """
         Saves a line or deletes if the quantity is 0
         """
-        if not self.basket.can_be_edited():
+        if not self.basket.can_be_edited:
             raise PermissionDenied(
                 _("You cannot modify a %s basket") % (
                     self.basket.status.lower(),))

tests/integration/basket/model_tests.py

+from decimal import Decimal as D
+
+from django.test import TestCase
+
+from oscar.apps.basket.models import Basket
+from oscar.apps.partner import strategy
+from oscar.test import factories
+from oscar.apps.catalogue.models import Option
+
+
+class TestAddingAProductToABasket(TestCase):
+
+    def setUp(self):
+        self.basket = Basket()
+        self.basket.strategy = strategy.Default()
+        self.product = factories.create_product()
+        self.record = factories.create_stockrecord(
+            self.product, price_excl_tax=D('10.00'))
+        self.stockinfo = factories.create_stockinfo(self.record)
+        self.basket.add(self.product, self.stockinfo)
+
+    def test_creates_a_line(self):
+        self.assertEqual(1, self.basket.num_lines)
+
+    def test_sets_line_prices(self):
+        line = self.basket.lines.all()[0]
+        self.assertEqual(line.price_incl_tax, self.stockinfo.price.incl_tax)
+        self.assertEqual(line.price_excl_tax, self.stockinfo.price.excl_tax)
+
+
+class TestANonEmptyBasket(TestCase):
+
+    def setUp(self):
+        self.basket = Basket()
+        self.basket.strategy = strategy.Default()
+        self.product = factories.create_product()
+        self.record = factories.create_stockrecord(
+            self.product, price_excl_tax=D('10.00'))
+        self.stockinfo = factories.create_stockinfo(self.record)
+        self.basket.add(self.product, self.stockinfo, 10)
+
+    def test_can_be_flushed(self):
+        self.basket.flush()
+        self.assertEqual(self.basket.num_items, 0)
+
+    def test_returns_correct_product_quantity(self):
+        self.assertEqual(10, self.basket.product_quantity(
+            self.product))
+
+    def test_returns_correct_line_quantity_for_existing_product_and_stockrecord(self):
+        self.assertEqual(10, self.basket.line_quantity(
+            self.product, self.record))
+
+    def test_returns_zero_line_quantity_for_alternative_stockrecord(self):
+        record = factories.create_stockrecord(
+            self.product, price_excl_tax=D('5.00'))
+        self.assertEqual(0, self.basket.line_quantity(
+            self.product, record))
+
+    def test_returns_zero_line_quantity_for_missing_product_and_stockrecord(self):
+        product = factories.create_product()
+        record = factories.create_stockrecord(
+            product, price_excl_tax=D('5.00'))
+        self.assertEqual(0, self.basket.line_quantity(
+            product, record))
+
+    def test_returns_correct_quantity_for_existing_product_and_stockrecord_and_options(self):
+        product = factories.create_product()
+        record = factories.create_stockrecord(
+            product, price_excl_tax=D('5.00'))
+        stockinfo = factories.create_stockinfo(record)
+        option = Option.objects.create(name="Message")
+        options = [{"option": option, "value": "2"}]
+
+        self.basket.add(product, stockinfo, options=options)
+        self.assertEqual(0, self.basket.line_quantity(
+            product, record))
+        self.assertEqual(1, self.basket.line_quantity(
+            product, record, options))
+
+
+class TestMergingTwoBaskets(TestCase):
+
+    def setUp(self):
+        self.product = factories.create_product()
+        self.record = factories.create_stockrecord(
+            self.product, price_excl_tax=D('10.00'))
+        self.stockinfo = factories.create_stockinfo(self.record)
+
+        self.main_basket = Basket()
+        self.main_basket.strategy = strategy.Default()
+        self.main_basket.add(self.product, self.stockinfo,
+                             quantity=2)
+
+        self.merge_basket = Basket()
+        self.merge_basket.strategy = strategy.Default()
+        self.merge_basket.add(self.product, self.stockinfo,
+                              quantity=1)
+
+        self.main_basket.merge(self.merge_basket)
+
+    def test_doesnt_sum_quantities(self):
+        self.assertEquals(1, self.main_basket.num_lines)
+
+    def test_changes_status_of_merge_basket(self):
+        self.assertEquals(Basket.MERGED, self.merge_basket.status)
+
+
+class TestASubmittedBasket(TestCase):
+
+    def setUp(self):
+        self.basket = Basket()
+        self.basket.strategy = strategy.Default()
+        self.basket.submit()
+
+    def test_has_correct_status(self):
+        self.assertTrue(self.basket.is_submitted)
+
+    def test_can_be_edited(self):
+        self.assertFalse(self.basket.can_be_edited)

tests/unit/basket/middleware_tests.py

+from django.test import TestCase
+from django.test.client import RequestFactory
+from django.contrib.auth.models import AnonymousUser
+
+from oscar.apps.basket import middleware
+
+
+class TestBasketMiddleware(TestCase):
+
+    def setUp(self):
+        self.middleware = middleware.BasketMiddleware()
+        self.request = RequestFactory().get('/')
+        self.request.user = AnonymousUser()
+        self.middleware.process_request(self.request)
+
+    def test_basket_is_attached_to_request(self):
+        self.assertTrue(hasattr(self.request, 'basket'))
+
+    def test_strategy_is_attached_to_basket(self):
+        self.assertTrue(hasattr(self.request.basket, 'strategy'))
+
+    def test_strategy_is_attached_to_request(self):
+        self.assertTrue(hasattr(self.request, 'strategy'))

tests/unit/basket/model_tests.py

+from django.test import TestCase
+
+from oscar.apps.basket.models import Basket
+from oscar.apps.partner import strategy
+
+
+class TestANewBasket(TestCase):
+
+    def setUp(self):
+        self.basket = Basket()
+        self.basket.strategy = strategy.Default()
+
+    def test_has_zero_lines(self):
+        self.assertEqual(0, self.basket.num_lines)
+
+    def test_has_zero_items(self):
+        self.assertEqual(0, self.basket.num_items)
+
+    def test_doesnt_contain_vouchers(self):
+        self.assertFalse(self.basket.contains_a_voucher)
+
+    def test_can_be_edited(self):
+        self.assertTrue(self.basket.can_be_edited)
+
+    def test_is_empty(self):
+        self.assertTrue(self.basket.is_empty)
+
+    def test_is_not_submitted(self):
+        self.assertFalse(self.basket.is_submitted)
+
+    def test_has_no_applied_offers(self):
+        self.assertEquals({}, self.basket.applied_offers())

tests/unit/basket/report_tests.py

+import datetime
+
+from django.test import TestCase
+
+from oscar.apps.basket.reports import (
+    OpenBasketReportGenerator, SubmittedBasketReportGenerator)
+
+
+class TestBasketReports(TestCase):
+
+    def test_open_report_doesnt_error(self):
+        data = {
+            'start_date': datetime.date(2012, 5, 1),
+            'end_date': datetime.date(2012, 5, 17),
+            'formatter': 'CSV'
+        }
+        generator = OpenBasketReportGenerator(**data)
+        generator.generate()
+
+    def test_submitted_report_doesnt_error(self):
+        data = {
+            'start_date': datetime.date(2012, 5, 1),
+            'end_date': datetime.date(2012, 5, 17),
+            'formatter': 'CSV'
+        }
+        generator = SubmittedBasketReportGenerator(**data)
+        generator.generate()

tests/unit/basket_tests.py

-import datetime
-from decimal import Decimal as D
-
-from django.test import TestCase
-from django.test.client import RequestFactory
-from django.contrib.auth.models import AnonymousUser
-
-from oscar.apps.basket.models import Basket
-from oscar.apps.basket.middleware import BasketMiddleware
-from oscar.apps.partner import strategy
-from oscar.test import factories
-from oscar.apps.basket.reports import (
-    OpenBasketReportGenerator, SubmittedBasketReportGenerator)
-from oscar.apps.catalogue.models import Option
-
-
-class TestABasket(TestCase):
-
-    def setUp(self):
-        self.basket = Basket()
-        self.basket.strategy = strategy.Default()
-        self.product = factories.create_product()
-        self.record = factories.create_stockrecord(
-            self.product, price_excl_tax=D('10.00'))
-        self.stockinfo = factories.create_stockinfo(self.record)
-
-    def test_an_empty_basket_has_zero_lines(self):
-        self.assertEqual(0, self.basket.num_lines)
-
-    def test_new_baskets_are_empty(self):
-        self.assertTrue(self.basket.is_empty)
-
-    def test_adding_product_creates_line(self):
-        self.basket.add_product(self.product, self.stockinfo)
-        self.assertEqual(1, self.basket.num_lines)
-
-    def test_adding_multiproduct_line_returns_correct_number_of_items(self):
-        self.basket.add_product(self.product, self.stockinfo, 10)
-        self.assertEqual(self.basket.num_items, 10)
-        self.assertEqual(self.basket.num_lines, 1)
-
-    def test_add_product_creates_line(self):
-        self.basket.add_product(self.product, self.stockinfo)
-        self.assertTrue(self.basket.num_lines == 1)
-
-    def test_add_product_sets_line_prices(self):
-        self.basket.add_product(self.product, self.stockinfo)
-        basket_line = self.basket.lines.all()[0]
-        self.assertEqual(basket_line.price_incl_tax, D('10.00'))
-        self.assertEqual(basket_line.price_excl_tax, D('10.00'))
-
-    def test_flushing_basket_removes_all_lines(self):
-        self.basket.add_product(self.product, self.stockinfo, 10)
-        self.assertEqual(self.basket.num_items, 10)
-        self.basket.flush()
-        self.assertEqual(self.basket.num_items, 0)
-
-    def test_returns_correct_quantity_for_missing_product(self):
-        self.assertEqual(0, self.basket.line_quantity(
-            self.product, self.record))
-
-    def test_returns_correct_quantity_for_existing_product(self):
-        self.basket.add_product(self.product, self.stockinfo)
-        self.assertEqual(1, self.basket.line_quantity(
-            self.product, self.record))
-
-    def test_returns_correct_quantity_for_existing_product_with_options(self):
-        option = Option.objects.create(name="Message")
-        options = [{"option": option, "value": "2"}]
-        self.basket.add_product(self.product, self.stockinfo, options=options)
-        self.assertEqual(0, self.basket.line_quantity(
-            self.product, self.record))
-        self.assertEqual(1, self.basket.line_quantity(
-            self.product, self.record, options))
-        self.assertEqual(1, self.basket.product_quantity(self.product))
-
-    def test_has_method_to_test_if_submitted(self):
-        self.basket.set_as_submitted()
-        self.assertTrue(self.basket.is_submitted())
-
-
-class TestBasketMiddleware(TestCase):
-
-    def setUp(self):
-        self.middleware = BasketMiddleware()
-
-    def test_basket_is_attached_to_request(self):
-        request = RequestFactory().get('/')
-        request.user = AnonymousUser()
-        self.middleware.process_request(request)
-        self.assertTrue(hasattr(request, 'basket'))
-
-
-class TestBasketReports(TestCase):
-
-    def test_open_report_doesnt_error(self):
-        data = {
-            'start_date': datetime.date(2012, 5, 1),
-            'end_date': datetime.date(2012, 5, 17),
-            'formatter': 'CSV'
-        }
-        generator = OpenBasketReportGenerator(**data)
-        generator.generate()
-
-    def test_submitted_report_doesnt_error(self):
-        data = {
-            'start_date': datetime.date(2012, 5, 1),
-            'end_date': datetime.date(2012, 5, 17),
-            'formatter': 'CSV'
-        }
-        generator = SubmittedBasketReportGenerator(**data)
-        generator.generate()