Reworked the availability logic of the DefaultWrapper

oscar/apps/basket/forms.py

         """
         self.fields[option.code] = forms.CharField()
 
+
 class SimpleAddToBasketForm(AddToBasketForm):
     quantity = forms.IntegerField(initial=1, min_value=1, widget=forms.HiddenInput)
 

oscar/apps/partner/abstract_models.py

         """
         Return the effective number in stock.  This is correct property to show
         the customer, not the num_in_stock field as that doesn't account for
-        allocations.
+        allocations.  This can be negative in some unusual circumstances
         """
         if self.num_in_stock is None:
             return 0
         Return an item's availability as a string
         """
         return get_partner_wrapper(self.partner.name).availability(self)
+
+    def max_purchase_quantity(self, user):
+        """
+        Return an item's availability as a string
+        """
+        return get_partner_wrapper(self.partner.name).availability(self)
     
     @property
     def dispatch_date(self):

oscar/apps/partner/tests/models.py

 from decimal import Decimal as D
 import datetime
 
-from django.utils import unittest
+from django.test import TestCase
 
 from oscar.test.helpers import create_product
 from oscar.apps.partner.abstract_models import partner_wrappers
         return "Another dummy response"
 
 
-class StockRecordTests(unittest.TestCase):
+class StockRecordTests(TestCase):
 
     def setUp(self):
         self.product = create_product(price=D('10.00'), num_in_stock=10)
         self.assertEqual(10, self.stockrecord.num_in_stock)
 
 
-class DefaultWrapperTests(unittest.TestCase):
+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(date, product.stockrecord.dispatch_date)
 
 
-class CustomWrapperTests(unittest.TestCase):
+class CustomWrapperTests(TestCase):
 
     def setUp(self):
         partner_wrappers['Acme'] = DummyWrapper()

oscar/apps/partner/tests/wrappers.py

         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)))
+
+

oscar/apps/partner/wrappers.py

         Test whether a particular purchase is possible (is a user buying a given
         quantity of the product)
         """
-        if stockrecord.net_stock_level <= 0:
+        if not self.is_available_to_buy(stockrecord):
             return False, _("'%s' is not available to purchase" % stockrecord.product.title)
         if stockrecord.net_stock_level < quantity:
             return False, _("'%s' - A maximum of %d can be bought" % (
                 stockrecord.product.title, stockrecord.net_stock_level))
         return True, None
 
+    def max_purchase_quantity(self, stockrecord, user=None):
+        """
+        Return the maximum available purchase quantity for a given user
+        """
+        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
         """
-        return 'instock' if stockrecord.net_stock_level > 0 else 'outofstock'
+        if stockrecord.net_stock_level > 0:
+            return 'instock'
+        if self.is_available_to_buy(stockrecord):
+            return 'available'
+        return 'outofstock'
     
     def availability(self, stockrecord):
         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):

oscar/templates/catalogue/partials/product.html

                 <p class="app-ico {{ product.stockrecord.availability_code }} avaliability ">{{ product.stockrecord.availability|truncatewords:2 }}</p>
             {% else %}
                 <p class="app-ico avaliability outofstock">Not available</p>
-                <button class="btn">Notify me</button> 
             {% endif %}
     {% endif %}
+
     {% basket_form basket product as basket_form single %}
     <form action="{% url basket:add %}" method="post">
         {% csrf_token %}