Excise partner wrapper functionality

docs/source/releases/v0.8.rst

@@ -17,6 +17,10 @@ Overview
 
 Oscar now has a demo site customised for the US!
 
+Lots of methods deprecated in the 0.6 release have now been removed.
+Specifically, the partner "wrapper" functionality is now gone. All price and
+availability logic now needs to be handled with strategies.
+
 .. _compatibility_of_0.8:
 
 Compatibility

oscar/apps/partner/abstract_models.py

@@ -1,46 +1,11 @@
 from django.db import models
 from django.conf import settings
 from django.utils.translation import ugettext_lazy as _
-from django.utils.importlib import import_module as django_import_module
 
-from oscar.core.loading import get_model, get_class
 from oscar.core.compat import AUTH_USER_MODEL
 from oscar.models.fields import AutoSlugField
 from oscar.apps.partner.exceptions import InvalidStockAdjustment
 
-DefaultWrapper = get_class('partner.wrappers', 'DefaultWrapper')
-
-
-# Cache dict of partner_id => availability wrapper instance
-partner_wrappers = None
-
-default_wrapper = DefaultWrapper()
-
-
-def get_partner_wrapper(partner_id):
-    """
-    Returns the appropriate partner wrapper given the partner's PK
-    """
-    if partner_wrappers is None:
-        _load_partner_wrappers()
-    return partner_wrappers.get(partner_id, default_wrapper)
-
-
-def _load_partner_wrappers():
-    # Prime cache of partner wrapper dict
-    global partner_wrappers
-    partner_wrappers = {}
-    Partner = get_model('partner', 'Partner')
-    for code, class_str in settings.OSCAR_PARTNER_WRAPPERS.items():
-        try:
-            partner = Partner.objects.get(code=code)
-        except Partner.DoesNotExist:
-            continue
-        else:
-            module_path, klass = class_str.rsplit('.', 1)
-            module = django_import_module(module_path)
-            partner_wrappers[partner.id] = getattr(module, klass)()
-
 
 class AbstractPartner(models.Model):
     """

oscar/apps/partner/wrappers.py

@@ -1,97 +0,0 @@
-from decimal import Decimal as D
-
-from django.utils.translation import ugettext_lazy as _
-
-
-class DefaultWrapper(object):
-    """
-    Default stockrecord wrapper
-    """
-    CODE_IN_STOCK = 'instock'
-    CODE_AVAILABLE = 'available'
-    CODE_UNAVAILABLE = 'outofstock'
-
-    def is_available_to_buy(self, stockrecord):
-        """
-        Test whether a product is available to buy.
-
-        This is used to determine whether to show the add-to-basket button.
-        """
-        if stockrecord.num_in_stock is None:
-            return True
-        return stockrecord.net_stock_level > 0
-
-    def is_purchase_permitted(self, stockrecord, user=None, quantity=1,
-                              product=None):
-        """
-        Test whether a particular purchase is possible (is a user buying a
-        given quantity of the product)
-        """
-        # check, if fetched product is provided, to avoid db call
-        product = product or stockrecord.product
-        if not self.is_available_to_buy(stockrecord):
-            return False, _("'%s' is unavailable to purchase") % product.title
-        max_qty = self.max_purchase_quantity(stockrecord, user, product)
-        if max_qty is None:
-            return True, None
-        if max_qty < quantity:
-            return False, _("A maximum of %(max)d can be bought" %
-                            {'max': max_qty})
-        return True, None
-
-    def max_purchase_quantity(self, stockrecord, user=None, product=None):
-        """
-        Return the maximum available purchase quantity for a given user
-        """
-        product = product or stockrecord.product
-
-        if not product.get_product_class().track_stock:
-            return None
-        if stockrecord.num_in_stock is None:
-            return None
-        return stockrecord.net_stock_level
-
-    def availability_code(self, stockrecord):
-        """
-        Return a code for the availability of this product.
-
-        This is normally used within CSS to add icons to stock messages
-
-        :param oscar.apps.partner.models.StockRecord stockrecord: stockrecord
-        instance
-        """
-        if stockrecord.net_stock_level > 0:
-            return self.CODE_IN_STOCK
-        if self.is_available_to_buy(stockrecord):
-            return self.CODE_AVAILABLE
-        return self.CODE_UNAVAILABLE
-
-    def availability(self, stockrecord):
-        """
-        Return an availability message for the passed stockrecord.
-
-        :param oscar.apps.partner.models.StockRecord stockrecord: stockrecord
-        instance
-        """
-        if stockrecord.net_stock_level > 0:
-            return _("In stock (%d available)") % stockrecord.net_stock_level
-        if self.is_available_to_buy(stockrecord):
-            return _('Available')
-        return _("Not available")
-
-    def dispatch_date(self, stockrecord):
-        """
-        We don't provide a default value as it could be confusing.  Subclass
-        and override this method to provide estimated dispatch dates
-        """
-        return None
-
-    def lead_time(self, stockrecord):
-        """
-        We don't provide a default value as it could be confusing.  Subclass
-        and override this method to provide estimated dispatch dates
-        """
-        return None
-
-    def calculate_tax(self, stockrecord):
-        return D('0.00')

oscar/defaults.py

@@ -38,9 +38,6 @@ OSCAR_PRODUCTS_PER_PAGE = 20
 # Checkout
 OSCAR_ALLOW_ANON_CHECKOUT = False
 
-# Partners
-OSCAR_PARTNER_WRAPPERS = {}
-
 # Promotions
 COUNTDOWN, LIST, SINGLE_PRODUCT, TABBED_BLOCK = (
     'Countdown', 'List', 'SingleProduct', 'TabbedBlock')

tests/unit/partner/model_tests.py

@@ -1,26 +1,15 @@
-import six
 from decimal import Decimal as D
 from oscar.core.loading import get_model
 
 from django.test import TestCase
 
-from oscar.test import factories, decorators
-from oscar.apps.partner import abstract_models
+from oscar.test import factories
 
 Partner = get_model('partner', 'Partner')
 PartnerAddress = get_model('partner', 'PartnerAddress')
 Country = get_model('address', 'Country')
 
 
-class DummyWrapper(object):
-
-    def availability(self, stockrecord):
-        return 'Dummy response'
-
-    def dispatch_date(self, stockrecord):
-        return "Another dummy response"
-
-
 class TestStockRecord(TestCase):
 
     def setUp(self):

tests/unit/partner/wrapper_tests.py

@@ -1,165 +0,0 @@
-from decimal import Decimal as D
-
-from django.test import TestCase
-
-from oscar.apps.partner.wrappers import DefaultWrapper
-from oscar.apps.catalogue.models import Product, ProductClass
-from oscar.apps.partner.models import StockRecord
-
-
-class TestStockRecordWithNullStockLevel(TestCase):
-    """
-    Stock record with num_in_stock=None
-    """
-
-    def setUp(self):
-        self.wrapper = DefaultWrapper()
-        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_no_estimated_lead_time(self):
-        self.assertIsNone(self.wrapper.lead_time(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_no_estimated_lead_time(self):
-        self.assertIsNone(self.wrapper.lead_time(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_no_estimated_lead_time(self):
-        self.assertIsNone(self.wrapper.lead_time(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_no_estimated_lead_time(self):
-        self.assertIsNone(self.wrapper.lead_time(self.record))
-
-    def test_returns_zero_tax(self):
-        self.assertEqual(D('0.00'), self.wrapper.calculate_tax(self.record))