Remove deprecated partner methods

This completes the move away from partner wrappers to strategies. All
the methods for determining price and availability information have now
been removed from the partner classes.

The helper policy class ("DelegateToStockRecord") have been removed too
as they no longer have methods to call on the stockrecord.

docs/source/releases/v0.8.rst

@@ -162,3 +162,17 @@ These methods have been removed:
 * ``oscar.apps.catalogue.abstract_models.AbstractProduct.is_available_to_buy``
 * ``oscar.apps.catalogue.abstract_models.AbstractProduct.is_purchase_permitted``
 * ``oscar.apps.catalogue.views.get_product_base_queryset``
+* ``oscar.apps.partner.abstract_models.AbstractStockRecord.is_available_to_buy``
+* ``oscar.apps.partner.abstract_models.AbstractStockRecord.is_purchase_permitted``
+* ``oscar.apps.partner.abstract_models.AbstractStockRecord.availability_code``
+* ``oscar.apps.partner.abstract_models.AbstractStockRecord.availability``
+* ``oscar.apps.partner.abstract_models.AbstractStockRecord.max_purchase_quantity``
+* ``oscar.apps.partner.abstract_models.AbstractStockRecord.dispatch_date``
+* ``oscar.apps.partner.abstract_models.AbstractStockRecord.lead_time``
+* ``oscar.apps.partner.abstract_models.AbstractStockRecord.price_incl_tax``
+* ``oscar.apps.partner.abstract_models.AbstractStockRecord.price_tax``
+
+These classes have been removed
+
+* ``oscar.apps.partner.prices.DelegateToStockRecord``
+* ``oscar.apps.partner.availability.DelegateToStockRecord``

oscar/apps/partner/abstract_models.py

@@ -1,16 +1,13 @@
-from decimal import Decimal as D
-import warnings
-
 from django.db import models
 from django.conf import settings
-from oscar.core.loading import get_model
 from django.utils.translation import ugettext_lazy as _
 from django.utils.importlib import import_module as django_import_module
-from oscar.core.compat import AUTH_USER_MODEL
 
-from oscar.core.loading import get_class
+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')
 
 
@@ -255,119 +252,6 @@ class AbstractStockRecord(models.Model):
             return False
         return self.net_stock_level < self.low_stock_threshold
 
-    # Stock wrapper methods - deprecated since 0.6
-
-    @property
-    def is_available_to_buy(self):
-        """
-        Return whether this stockrecord allows the product to be purchased
-        """
-        warnings.warn((
-            "StockRecord.is_available_to_buy is deprecated and will be "
-            "removed in 0.7.  Use a strategy class to determine availability "
-            "instead"), DeprecationWarning)
-        return get_partner_wrapper(self.partner_id).is_available_to_buy(self)
-
-    def is_purchase_permitted(self, user=None, quantity=1, product=None):
-        """
-        Return whether this stockrecord allows the product to be purchased by a
-        specific user and quantity
-        """
-        warnings.warn((
-            "StockRecord.is_purchase_permitted is deprecated and will be "
-            "removed in 0.7.  Use a strategy class to determine availability "
-            "instead"), DeprecationWarning)
-        return get_partner_wrapper(
-            self.partner_id).is_purchase_permitted(self, user, quantity,
-                                                   product)
-
-    @property
-    def availability_code(self):
-        """
-        Return an product's availability as a code for use in CSS to add icons
-        to the overall availability mark-up.  For example, "instock",
-        "unavailable".
-        """
-        warnings.warn((
-            "StockRecord.availability_code is deprecated and will be "
-            "removed in 0.7.  Use a strategy class to determine availability "
-            "instead"), DeprecationWarning)
-        return get_partner_wrapper(self.partner_id).availability_code(self)
-
-    @property
-    def availability(self):
-        """
-        Return a product's availability as a string that can be displayed to
-        the user.  For example, "In stock", "Unavailable".
-        """
-        warnings.warn((
-            "StockRecord.availability is deprecated and will be "
-            "removed in 0.7.  Use a strategy class to determine availability "
-            "instead"), DeprecationWarning)
-        return get_partner_wrapper(self.partner_id).availability(self)
-
-    def max_purchase_quantity(self, user=None):
-        """
-        Return an item's availability as a string
-
-        :param user: (optional) The user who wants to purchase
-        """
-        warnings.warn((
-            "StockRecord.max_purchase_quantity is deprecated and will be "
-            "removed in 0.7.  Use a strategy class to determine availability "
-            "instead"), DeprecationWarning)
-        return get_partner_wrapper(
-            self.partner_id).max_purchase_quantity(self, user)
-
-    @property
-    def dispatch_date(self):
-        """
-        Return the estimated dispatch date for a line
-        """
-        warnings.warn((
-            "StockRecord.dispatch_date is deprecated and will be "
-            "removed in 0.7.  Use a strategy class to determine availability "
-            "instead"), DeprecationWarning)
-        return get_partner_wrapper(self.partner_id).dispatch_date(self)
-
-    @property
-    def lead_time(self):
-        warnings.warn((
-            "StockRecord.lead_time is deprecated and will be "
-            "removed in 0.7.  Use a strategy class to determine availability "
-            "instead"), DeprecationWarning)
-        return get_partner_wrapper(self.partner_id).lead_time(self)
-
-    # Price methods - deprecated in 0.6
-
-    @property
-    def price_incl_tax(self):
-        """
-        Return a product's price including tax.
-
-        This defaults to the price_excl_tax as tax calculations are
-        domain specific.  This class needs to be subclassed and tax logic
-        added to this method.
-        """
-        warnings.warn((
-            "StockRecord.price_incl_tax is deprecated and will be "
-            "removed in 0.7.  Use a strategy class to determine price "
-            "information instead"), DeprecationWarning, stacklevel=2)
-        if self.price_excl_tax is None:
-            return D('0.00')
-        return self.price_excl_tax + self.price_tax
-
-    @property
-    def price_tax(self):
-        """
-        Return a product's tax value
-        """
-        warnings.warn((
-            "StockRecord.price_incl_tax is deprecated and will be "
-            "removed in 0.7.  Use a strategy class to determine price "
-            "information instead"), DeprecationWarning)
-        return get_partner_wrapper(self.partner_id).calculate_tax(self)
-
 
 class AbstractStockAlert(models.Model):
     """

oscar/apps/partner/availability.py

@@ -108,42 +108,3 @@ class StockRequired(Base):
         if self.num_available > 0:
             return _("In stock (%d available)") % self.num_available
         return _("Unavailable")
-
-
-class DelegateToStockRecord(Base):
-    """
-    An availability class which delegates all calls to the
-    stockrecord itself.  This will exercise the deprecated methods on the
-    stockrecord that call "partner wrapper" classes.
-
-    This is backwards compatible with Oscar<0.6
-    """
-
-    def __init__(self, product, stockrecord=None, user=None):
-        self.product = product
-        self.stockrecord = stockrecord
-        self.user = user
-
-    @property
-    def is_available_to_buy(self):
-        if self.stockrecord is None:
-            return False
-        if not self.product.get_product_class().track_stock:
-            return True
-        return self.stockrecord.is_available_to_buy
-
-    def is_purchase_permitted(self, quantity):
-        return self.stockrecord.is_purchase_permitted(
-            self.user, quantity, self.product)
-
-    @property
-    def code(self):
-        return self.stockrecord.availability_code
-
-    @property
-    def message(self):
-        return self.stockrecord.availability
-
-    @property
-    def dispatch_date(self):
-        return self.stockrecord.dispatch_date

oscar/apps/partner/prices.py

@@ -94,40 +94,3 @@ class TaxInclusiveFixedPrice(FixedPrice):
     @property
     def effective_price(self):
         return self.incl_tax
-
-
-class DelegateToStockRecord(Base):
-    """
-    Pricing policy which wraps around an existing stockrecord.
-
-    This is backwards compatible with Oscar<0.6 where taxes were calculated by
-    "partner wrappers" which wrapped around stockrecords.
-    """
-    is_tax_known = True
-
-    def __init__(self, stockrecord):
-        self.stockrecord = stockrecord
-
-    @property
-    def exists(self):
-        return self.stockrecord is not None
-
-    @property
-    def excl_tax(self):
-        return self.stockrecord.price_excl_tax
-
-    @property
-    def incl_tax(self):
-        return self.stockrecord.price_incl_tax
-
-    @property
-    def tax(self):
-        return self.stockrecord.price_tax
-
-    @property
-    def retail(self):
-        return self.stockrecord.price_retail
-
-    @property
-    def currency(self):
-        return self.stockrecord.price_currency

oscar/test/factories.py

@@ -53,7 +53,8 @@ def create_purchase_info(record):
             record.price_excl_tax,
             D('0.00')  # Default to no tax
         ),
-        availability=availability.DelegateToStockRecord(record),
+        availability=availability.StockRequired(
+            record.net_stock_level),
         stockrecord=record
     )
 

tests/integration/partner/availability_tests.py

@@ -1,41 +0,0 @@
-from django.test import TestCase
-
-from oscar.apps.partner import availability
-from oscar.test import factories, decorators
-
-
-@decorators.ignore_deprecation_warnings
-class TestDelegateToStockRecordWrapper(TestCase):
-
-    def setUp(self):
-        self.product = factories.create_product()
-        self.stockrecord = factories.create_stockrecord(self.product)
-        self.assertTrue(self.product.get_product_class().track_stock)
-
-        self.availability = availability.DelegateToStockRecord(
-            self.product, self.stockrecord)
-
-    def test_delegates_is_available_to_buy(self):
-        self.assertEqual(
-            self.stockrecord.is_available_to_buy,
-            self.availability.is_available_to_buy)
-
-    def test_delegates_is_purchase_permitted(self):
-        self.assertEqual(
-            self.stockrecord.is_purchase_permitted(1),
-            self.availability.is_purchase_permitted(quantity=1))
-
-    def test_delegates_availability_code(self):
-        self.assertEqual(
-            self.stockrecord.availability_code,
-            self.availability.code)
-
-    def test_delegates_availability_message(self):
-        self.assertEqual(
-            self.stockrecord.availability,
-            self.availability.message)
-
-    def test_delegates_dispatch_date(self):
-        self.assertEqual(
-            self.stockrecord.dispatch_date,
-            self.availability.dispatch_date)

tests/unit/partner/model_tests.py

@@ -28,10 +28,6 @@ class TestStockRecord(TestCase):
         self.stockrecord = factories.create_stockrecord(
             self.product, price_excl_tax=D('10.00'), num_in_stock=10)
 
-    @decorators.ignore_deprecation_warnings
-    def test_get_price_incl_tax_defaults_to_no_tax(self):
-        self.assertEqual(D('10.00'), self.stockrecord.price_incl_tax)
-
     def test_get_price_excl_tax_returns_correct_value(self):
         self.assertEqual(D('10.00'), self.stockrecord.price_excl_tax)
 
@@ -69,38 +65,6 @@ class TestStockRecord(TestCase):
         self.assertEqual(0, self.stockrecord.num_allocated)
         self.assertEqual(10, self.stockrecord.num_in_stock)
 
-    @decorators.ignore_deprecation_warnings
-    def test_max_purchase_quantity(self):
-        self.assertEqual(10, self.stockrecord.max_purchase_quantity())
-
-
-@decorators.ignore_deprecation_warnings
-class CustomWrapperTests(TestCase):
-    """
-    Partner wrappers are deprecated.  This testcase will be removed/rewritten
-    in Oscar 0.7.
-    """
-
-    def setUp(self):
-        abstract_models.partner_wrappers = {1: DummyWrapper()}
-
-    def tearDown(self):
-        abstract_models.partner_wrappers = None
-
-    def test_wrapper_availability_gets_called(self):
-        product = factories.create_product(
-            price=D('10.00'), partner_name="Acme", num_in_stock=10)
-        stockrecord = product.stockrecords.all()[0]
-        self.assertEqual(u"Dummy response",
-                          six.text_type(stockrecord.availability))
-
-    def test_wrapper_dispatch_date_gets_called(self):
-        product = factories.create_product(
-            price=D('10.00'), partner_name="Acme", num_in_stock=10)
-        stockrecord = product.stockrecords.all()[0]
-        self.assertEqual("Another dummy response",
-                          stockrecord.dispatch_date)
-
 
 class TestPartnerAddress(TestCase):
 

tests/unit/partner/price_tests.py

@@ -2,7 +2,7 @@ from django.test import TestCase
 from decimal import Decimal as D
 
 from oscar.core.prices import TaxNotKnown
-from oscar.apps.partner import prices, models
+from oscar.apps.partner import prices
 
 
 class TestUnavailable(TestCase):
@@ -22,21 +22,6 @@ class TestUnavailable(TestCase):
         self.assertIsNone(self.price.tax)
 
 
-class TestDelegateToStockRecord(TestCase):
-
-    def setUp(self):
-        self.record = models.StockRecord(
-            price_excl_tax=D('12.99'))
-        self.price = prices.DelegateToStockRecord(self.record)
-
-    def test_assumes_tax_is_known(self):
-        self.assertTrue(self.price.is_tax_known)
-
-    def test_has_correct_price(self):
-        self.assertEqual(self.record.price_excl_tax,
-                          self.price.excl_tax)
-
-
 class TestFixedPriceWithoutTax(TestCase):
 
     def setUp(self):