Merge branch 'releases/0.3'

Conflicts:
	oscar/__init__.py

CHANGELOG.rst

 Changelog
 =========
 
-0.3 
----
+0.3.2
+-----
+
+* Bug fix for basket calculations
+* Bug fix for absolute discount benefit calculations
+
+0.3.1 - 2012-08-08
+------------------
+
+* Now including the translation files.
+
+0.3 - 2012-08-08
+----------------
 
 * i18n support added - Oscar now ships with .po files for seven languages.
   Translation files are welcome.

oscar/app.py

 
 class Shop(Application):
     name = None
-    
+
     catalogue_app = catalogue_app
     customer_app = customer_app
     basket_app = basket_app
     search_app = search_app
     dashboard_app = dashboard_app
     offer_app = offer_app
-    
+
     def get_urls(self):
         urlpatterns = patterns('',
             (r'^products/', include(self.catalogue_app.urls)),
             # from working.
             url(r'^password-reset/$', auth_views.password_reset, name='password-reset'),
             url(r'^password-reset/done/$', auth_views.password_reset_done, name='password-reset-done'),
-            url(r'^password-reset/confirm/$', auth_views.password_reset_confirm, name='password-reset-confirm'),
+            url(r'^password-reset/confirm/(?P<uidb36>[0-9A-Za-z]{1,13})-(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/$',
+                auth_views.password_reset_confirm, name='password-reset-confirm'),
             url(r'^password-reset/complete/$', auth_views.password_reset_complete, name='password-reset-complete'),
 
             (r'', include(self.promotions_app.urls)),
         )
         return urlpatterns
-    
+
+
 # 'shop' kept for legacy projects - 'application' is a better name
 shop = application = Shop()

oscar/apps/basket/views.py

     form_class = BasketLineForm
     extra = 0
     can_delete = True
-    template_name='basket/basket.html'
+    template_name = 'basket/basket.html'
 
     def get_queryset(self):
         return self.request.basket.all_lines()

oscar/apps/offer/models.py

     description = __unicode__
 
     def consume_items(self, basket, lines=None):
-        return ()
+        raise NotImplementedError("This method should never be called - "
+                                  "ensure you are using the correct proxy model")
 
     def is_satisfied(self, basket):
         """
         consumed_products = []
         value = self.value if value is None else value
         for line in lines:
+
             if self.can_apply_condition(line.product):
                 quantity_to_consume = min(line.quantity_without_discount,
                                           value - len(consumed_products))
 
                 # Update line with discounts
                 line_discount = self.round(min(remaining_discount, quantity_affected * price))
-                line.discount(line_discount, quantity_affected)
+                if condition:
+                    # Pass zero as quantity to avoid double consumption
+                    line.discount(line_discount, 0)
+                else:
+                    line.discount(line_discount, quantity_affected)
 
                 # Update loop vars
                 affected_items += quantity_affected
                 remaining_discount -= line_discount
                 discount += line_discount
 
+        if discount > 0 and condition:
+            condition.consume_items(basket)
+
         return discount
 
 

oscar/templates/oscar/customer/login_registration.html

             <h2>{% trans 'Log In' %}</h2>
             {% csrf_token %}
             {% include "partials/form_fields.html" with form=login_form %}
+			<p><a href="{% url password-reset %}">{% trans "I've forgotten my password" %}</a></p>
             <button name="login_submit" type="submit" value="Log In" class="btn btn-large btn-primary">{% trans 'Log In' %}</button>
         </form>
     </div>

oscar/templates/oscar/dashboard/layout.html

 	<link rel="stylesheet" href="{{ STATIC_URL }}oscar/css/dashboard.css" />
 {% endblock %}
 
-{% block extrahead %} {%endblock extrahead %}
+{% block extrahead %} {% endblock extrahead %}
 
 {% block title %}
 {% trans "Dashboard" %} | {{ block.super }}

oscar/templates/oscar/layout.html

             {% include "partials/nav_primary.html" %}
         {% endblock %}
     </header>
-    <div class="container-fluid page">
+	<div class="container-fluid page">
         {% block header %}{% endblock %}
         <div class="page_inner">
             {% block breadcrumbs %}{% endblock %}

oscar/templates/oscar/registration/password_reset_complete.html

 
 {% block title %}{% trans 'Password reset complete' %} | {{ block.super }}{% endblock %}
 
+{% block breadcrumbs %}
+<ul class="breadcrumb">
+    <li>
+        <a href="{% url promotions:home %}">{% trans 'Home' %}</a>
+        <span class="divider">/</span>
+    </li>
+	<li class="active"><a href=".">{% trans 'Password reset complete' %}</a></li>
+</ul>
+{% endblock %}
+
 {% block content %}
 	<h1>{% trans 'Password reset complete' %}</h1>
 	<p>{% trans "Your password has been set.  You may go ahead and log in now." %}</p>
-	<p><a href="{{ login_url }}">{% trans 'Log in' %}</a></p>
+	<p><a href="{{ login_url }}" class="btn btn-large btn-primary">{% trans 'Log in' %}</a></p>
 {% endblock %}

oscar/templates/oscar/registration/password_reset_confirm.html

 
 {% block title %}{% trans 'Password reset confirm' %} | {{ block.super }}{% endblock %}
 
+{% block breadcrumbs %}
+<ul class="breadcrumb">
+    <li>
+        <a href="{% url promotions:home %}">{% trans 'Home' %}</a>
+        <span class="divider">/</span>
+    </li>
+	<li class="active"><a href=".">{% trans 'Enter new password' %}</a></li>
+</ul>
+{% endblock %}
+
 {% block content %}
 
 {% if validlink %}
 
 <p>{% trans "Please enter your new password twice so we can verify you typed it in correctly." %}</p>
 
-<form action="" method="post">{% csrf_token %}
+<form id="password_reset_form" action="" method="post">{% csrf_token %}
 {{ form.new_password1.errors }}
 <p class="aligned wide"><label for="id_new_password1">{% trans 'New password:' %}</label>{{ form.new_password1 }}</p>
 {{ form.new_password2.errors }}
 <p class="aligned wide"><label for="id_new_password2">{% trans 'Confirm password:' %}</label>{{ form.new_password2 }}</p>
-<p><input type="submit" value="{% trans 'Change my password' %}" /></p>
+<p><button class="btn btn-primary btn-large" type="submit">{% trans 'Change my password' %}</button></p>
 </form>
 
 {% else %}

oscar/templates/oscar/registration/password_reset_done.html

 
 {% block title %}{% trans 'Password reset successful' %} | {{ block.super }}{% endblock %}
 
+{% block breadcrumbs %}
+<ul class="breadcrumb">
+    <li>
+        <a href="{% url promotions:home %}">{% trans 'Home' %}</a>
+        <span class="divider">/</span>
+    </li>
+	<li class="active"><a href=".">{% trans 'Password reset sent' %}</a></li>
+</ul>
+{% endblock %}
+
 {% block content %}
 
     <h1>{% trans 'Password reset successful' %}</h1>

oscar/templates/oscar/registration/password_reset_form.html

 
 {% block title %}{% trans 'Password reset' %} | {{ block.super }}{% endblock %}
 
+{% block breadcrumbs %}
+<ul class="breadcrumb">
+    <li>
+        <a href="{% url promotions:home %}">{% trans 'Home' %}</a>
+        <span class="divider">/</span>
+    </li>
+	<li class="active"><a href=".">{% trans 'Password reset' %}</a></li>
+</ul>
+{% endblock %}
+
 {% block content %}
 
     <div class="sub-header">
         <h2>{% trans "Password reset" %}</h2>
     </div>
 
-    <form action="" method="post" class="form-stacked well">
+    <form id="password_reset_form" action="" method="post" class="form-stacked well">
     {% csrf_token %}
 
         <p>{% trans "Forgotten your password? Enter your e-mail address below, and we'll e-mail instructions for setting a new one." %}</p>

oscar/test/helpers.py

 
 
 def create_product(price=None, title="Dummy title", product_class="Dummy item class",
-        partner="Dummy partner", partner_sku=None, upc=None, num_in_stock=10, attributes=None):
+        partner="Dummy partner", partner_sku=None, upc=None, num_in_stock=10,
+        attributes=None, **kwargs):
     """
     Helper method for creating products that are used in tests.
     """
     ic,_ = ProductClass._default_manager.get_or_create(name=product_class)
-    item = Product._default_manager.create(title=title, product_class=ic, upc=upc)
+    item = Product._default_manager.create(title=title, product_class=ic,
+                                           upc=upc, **kwargs)
     if price is not None or partner_sku or num_in_stock is not None:
         if not partner_sku:
             partner_sku = 'sku_%d_%d' % (item.id, random.randint(0, 10000))

setup.py

       packages=find_packages(exclude=["sandbox*", "tests*"]),
       include_package_data=True,
       install_requires=[
-          'django==1.4',
+          'django>=1.4',
           'PIL==1.1.7',
           'South==0.7.3',
           'django-extra-views==0.2.0',

tests/functional/customer/auth_tests.py

+import re
+
+from django.contrib.auth import models
+from django.core.urlresolvers import reverse
+from django.core import mail
+
+from django_webtest import WebTest
+
+
+class TestAUserWhoseForgottenHerPassword(WebTest):
+
+    def test_can_reset_her_password(self):
+        username, email, password = 'lucy', 'lucy@example.com', 'password'
+        models.User.objects.create_user(
+            username, email, password
+        )
+
+        # Fill in password reset form
+        page = self.app.get(reverse('password-reset'))
+        form = page.forms['password_reset_form']
+        form['email'] = email
+        response = form.submit()
+
+        # Response should be a redirect and an email should have been sent
+        self.assertEqual(302, response.status_code)
+        self.assertEqual(1, len(mail.outbox))
+
+        # Extract URL from email
+        email_body = mail.outbox[0].body
+        urlfinder = re.compile(r"http://example.com(?P<path>[-A-Za-z0-9\/\._]+)")
+        matches = urlfinder.search(email_body, re.MULTILINE)
+        self.assertTrue('path' in matches.groupdict())
+        path = matches.groupdict()['path']
+
+        # Reset password and check we get redirect
+        reset_page = self.app.get(path)
+        form = reset_page.forms['password_reset_form']
+        form['new_password1'] = 'monkey'
+        form['new_password2'] = 'monkey'
+        response = form.submit()
+        self.assertEqual(302, response.status_code)
+
+        # Now attempt to login with new password
+        url = reverse('customer:login')
+        form = self.app.get(url).forms['login_form']
+        form['login-username'] = email
+        form['login-password'] = 'monkey'
+        response = form.submit('login_submit')
+        self.assertEqual(302, response.status_code)

tests/unit/offer/__init__.py

 
 class OfferTest(TestCase):
     def setUp(self):
-        self.range = models.Range.objects.create(name="All products range", includes_all_products=True)
+        self.range = models.Range.objects.create(
+            name="All products range", includes_all_products=True)
         self.basket = Basket.objects.create()

tests/unit/offer/benefit_tests.py

-from decimal import Decimal
+from decimal import Decimal as D
 
 from django.conf import settings
 
 
     def setUp(self):
         super(PercentageDiscountBenefitTest, self).setUp()
-        self.benefit = models.PercentageDiscountBenefit(range=self.range, type="Percentage", value=Decimal('15.00'))
-        self.item = create_product(price=Decimal('5.00'))
+        self.benefit = models.PercentageDiscountBenefit(range=self.range, type="Percentage", value=D('15.00'))
+        self.item = create_product(price=D('5.00'))
         self.original_offer_rounding_function = getattr(settings, 'OSCAR_OFFER_ROUNDING_FUNCTION', None)
         if self.original_offer_rounding_function is not None:
             delattr(settings, 'OSCAR_OFFER_ROUNDING_FUNCTION')
             settings.OSCAR_OFFER_ROUNDING_FUNCTION = self.original_offer_rounding_function
 
     def test_no_discount_for_empty_basket(self):
-        self.assertEquals(Decimal('0.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('0.00'), self.benefit.apply(self.basket))
 
     def test_no_discount_for_not_discountable_product(self):
         self.item.is_discountable = False
         self.item.save()
         self.basket.add_product(self.item, 1)
-        self.assertEquals(Decimal('0.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('0.00'), self.benefit.apply(self.basket))
 
     def test_discount_for_single_item_basket(self):
         self.basket.add_product(self.item, 1)
-        self.assertEquals(Decimal('0.15') * Decimal('5.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('0.15') * D('5.00'), self.benefit.apply(self.basket))
 
     def test_discount_for_multi_item_basket(self):
         self.basket.add_product(self.item, 3)
-        self.assertEquals(Decimal('3') * Decimal('0.15') * Decimal('5.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('3') * D('0.15') * D('5.00'), self.benefit.apply(self.basket))
 
     def test_discount_for_multi_item_basket_with_max_affected_items_set(self):
         self.basket.add_product(self.item, 3)
         self.benefit.max_affected_items = 1
-        self.assertEquals(Decimal('0.15') * Decimal('5.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('0.15') * D('5.00'), self.benefit.apply(self.basket))
 
     def test_discount_can_only_be_applied_once(self):
         self.basket.add_product(self.item, 3)
         self.benefit.apply(self.basket)
         second_discount = self.benefit.apply(self.basket)
-        self.assertEquals(Decimal('0.00'), second_discount)
+        self.assertEquals(D('0.00'), second_discount)
 
     def test_discount_can_be_applied_several_times_when_max_is_set(self):
         self.basket.add_product(self.item, 3)
             self.assertTrue(self.benefit.apply(self.basket) > 0)
 
 
-class AbsoluteDiscountBenefitTest(OfferTest):
+class TestAbsoluteDiscount(OfferTest):
 
     def setUp(self):
-        super(AbsoluteDiscountBenefitTest, self).setUp()
+        super(TestAbsoluteDiscount, self).setUp()
+
         self.benefit = models.AbsoluteDiscountBenefit(
-            range=self.range, type="Absolute", value=Decimal('10.00'))
-        self.item = create_product(price=Decimal('5.00'))
-        self.original_offer_rounding_function = getattr(settings, 'OSCAR_OFFER_ROUNDING_FUNCTION', None)
+            range=self.range, type="Absolute", value=D('10.00'))
+        self.item = create_product(price=D('5.00'))
+
+        self.original_offer_rounding_function = getattr(
+            settings, 'OSCAR_OFFER_ROUNDING_FUNCTION', None)
         if self.original_offer_rounding_function is not None:
             delattr(settings, 'OSCAR_OFFER_ROUNDING_FUNCTION')
 
     def tearDown(self):
-        super(AbsoluteDiscountBenefitTest, self).tearDown()
         if self.original_offer_rounding_function is not None:
             settings.OSCAR_OFFER_ROUNDING_FUNCTION = self.original_offer_rounding_function
 
-    def test_no_discount_for_empty_basket(self):
-        self.assertEquals(Decimal('0.00'), self.benefit.apply(self.basket))
+    def test_gives_no_discount_for_an_empty_basket(self):
+        self.assertEquals(D('0.00'), self.benefit.apply(self.basket))
+
+    def test_gives_no_discount_for_a_non_discountable_product(self):
+        product = create_product(price=D('5.00'), is_discountable=False)
+        self.basket.add_product(product)
+        self.assertEquals(D('0.00'), self.benefit.apply(self.basket))
+
+    def test_gives_correct_discount_for_single_item_basket_cheaper_than_threshold(self):
+        product = create_product(price=D('5.00'))
+        self.basket.add_product(product)
+        self.assertEquals(D('5.00'), self.benefit.apply(self.basket))
+
+    def test_gives_correct_discount_for_single_item_basket_equal_to_threshold(self):
+        product = create_product(price=D('10.00'))
+        self.basket.add_product(product)
+        self.assertEquals(D('10.00'), self.benefit.apply(self.basket))
+
+    def test_gives_correct_discount_for_single_item_basket_more_expensive_than_threshold(self):
+        product = create_product(price=D('16.00'))
+        self.basket.add_product(product)
+        self.assertEquals(D('10.00'), self.benefit.apply(self.basket))
+
+    def test_gives_correct_discount_for_multi_item_basket_cheaper_than_threshold(self):
+        product = create_product(price=D('2.00'))
+        self.basket.add_product(product, 3)
+        self.assertEquals(D('6.00'), self.benefit.apply(self.basket))
+
+    def test_gives_correct_discount_for_multi_item_basket_more_expensive_than_threshold(self):
+        product = create_product(price=D('5.00'))
+        self.basket.add_product(product, 3)
+        self.assertEquals(D('10.00'), self.benefit.apply(self.basket))
+
+    def test_consumes_all_lines_for_multi_item_basket_cheaper_than_threshold(self):
+        product = create_product(price=D('2.00'))
+        self.basket.add_product(product, 3)
+        self.benefit.apply(self.basket)
+        for line in self.basket.all_lines():
+            self.assertTrue(line.has_discount)
+            self.assertEqual(0, line.quantity_without_discount)
 
-    def test_no_discount_for_not_discountable_product(self):
-        self.item.is_discountable = False
-        self.item.save()
-        self.basket.add_product(self.item, 1)
-        self.assertEquals(Decimal('0.00'), self.benefit.apply(self.basket))
+    def test_consumes_correct_quantity_for_multi_item_basket_more_expensive_than_threshold(self):
+        product = create_product(price=D('6.00'))
+        self.basket.add_product(product, 3)
+        self.benefit.apply(self.basket)
+        line = self.basket.all_lines()[0]
+        self.assertTrue(line.has_discount)
+        self.assertEqual(1, line.quantity_without_discount)
 
-    def test_discount_for_single_item_basket(self):
-        self.basket.add_product(self.item, 1)
-        self.assertEquals(Decimal('5.00'), self.benefit.apply(self.basket))
+    def test_gives_correct_discount_for_multi_item_basket_with_max_affected_items_set(self):
+        product = create_product(price=D('5.00'))
+        self.basket.add_product(product, 3)
+        self.benefit.max_affected_items = 1
+        self.assertEquals(D('5.00'), self.benefit.apply(self.basket))
 
-    def test_discount_for_multi_item_basket(self):
-        self.basket.add_product(self.item, 3)
-        self.assertEquals(Decimal('10.00'), self.benefit.apply(self.basket))
+    def test_gives_correct_discounts_when_applied_multiple_times(self):
+        product = create_product(price=D('5.00'))
+        self.basket.add_product(product, 3)
 
-    def test_discount_for_multi_item_basket_with_max_affected_items_set(self):
-        self.basket.add_product(self.item, 3)
-        self.benefit.max_affected_items = 1
-        self.assertEquals(Decimal('5.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('10.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('5.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('0.00'), self.benefit.apply(self.basket))
 
-    def test_discount_can_only_be_applied_once(self):
-        # Add 3 items to make total 15.00
-        self.basket.add_product(self.item, 3)
-        first_discount = self.benefit.apply(self.basket)
-        self.assertEquals(Decimal('10.00'), first_discount)
+    def test_gives_correct_discounts_when_applied_multiple_times_with_condition(self):
+        product = create_product(D('25000'))
+        rng = models.Range.objects.create(name='Dummy')
+        rng.included_products.add(product)
 
-        second_discount = self.benefit.apply(self.basket)
-        self.assertEquals(Decimal('5.00'), second_discount)
+        condition = models.ValueCondition(range=rng, type='Value', value=D('5000'))
 
-    def test_absolute_does_not_consume_twice(self):
-        product = create_product(Decimal('25000'))
+        self.basket.add_product(product, 5)
+        benefit = models.AbsoluteDiscountBenefit(range=rng, type='Absolute', value=D('100'))
+
+        for _ in range(5):
+            self.assertTrue(condition.is_satisfied(self.basket))
+            self.assertEquals(D('100'), benefit.apply(self.basket, condition))
+
+        self.assertFalse(condition.is_satisfied(self.basket))
+        self.assertEquals(D('0'), benefit.apply(self.basket, condition))
+
+    def test_consumes_all_products_for_heterogeneous_basket(self):
+        rng = models.Range.objects.create(name='Dummy')
+        products = [create_product(D('150')),
+                    create_product(D('300')),
+                    create_product(D('300'))]
+        for product in products:
+            rng.included_products.add(product)
+
+        condition = models.ValueCondition(range=rng, type='Value', value=D('500'))
+
+        basket = Basket.objects.create()
+        for product in products:
+            basket.add_product(product)
+
+        benefit = models.AbsoluteDiscountBenefit(range=rng, type='Absolute', value=D('100'))
+
+        self.assertTrue(condition.is_satisfied(basket))
+        self.assertEquals(D('100'), benefit.apply(basket, condition))
+        self.assertEquals(D('0'), benefit.apply(basket, condition))
+
+    def test_correctly_discounts_line(self):
+        product = create_product(D('500'))
         rng = models.Range.objects.create(name='Dummy')
         rng.included_products.add(product)
-        condition = models.ValueCondition(range=rng, type='Value', value=Decimal('5000'))
+
+        condition = models.ValueCondition(range=rng, type='Value', value=D('500'))
         basket = Basket.objects.create()
-        basket.add_product(product, 5)
-        benefit = models.AbsoluteDiscountBenefit(range=rng, type='Absolute', value=Decimal('100'))
+        basket.add_product(product, 1)
+
+        benefit = models.AbsoluteDiscountBenefit(range=rng, type='Absolute', value=D('100'))
+
         self.assertTrue(condition.is_satisfied(basket))
-        self.assertEquals(Decimal('100'), benefit.apply(basket, condition))
-        self.assertEquals(Decimal('100'), benefit.apply(basket, condition))
-        self.assertEquals(Decimal('100'), benefit.apply(basket, condition))
-        self.assertEquals(Decimal('100'), benefit.apply(basket, condition))
-        self.assertEquals(Decimal('100'), benefit.apply(basket, condition))
-        self.assertEquals(Decimal('0'), benefit.apply(basket, condition))
+        self.assertEquals(D('100'), benefit.apply(basket, condition))
+        self.assertEquals(D('100'), basket.all_lines()[0]._discount)
 
     def test_discount_is_applied_to_lines(self):
-        condition = models.Condition.objects.create(
+        condition = models.CountCondition.objects.create(
             range=self.range, type="Count", value=1)
         self.basket.add_product(self.item, 1)
         self.benefit.apply(self.basket, condition)
-
         self.assertTrue(self.basket.all_lines()[0].has_discount)
 
 
     def setUp(self):
         super(MultibuyDiscountBenefitTest, self).setUp()
         self.benefit = models.MultibuyDiscountBenefit(range=self.range, type="Multibuy", value=1)
-        self.item = create_product(price=Decimal('5.00'))
+        self.item = create_product(price=D('5.00'))
 
     def test_no_discount_for_empty_basket(self):
-        self.assertEquals(Decimal('0.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('0.00'), self.benefit.apply(self.basket))
 
     def test_discount_for_single_item_basket(self):
         self.basket.add_product(self.item, 1)
-        self.assertEquals(Decimal('5.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('5.00'), self.benefit.apply(self.basket))
 
     def test_discount_for_multi_item_basket(self):
         self.basket.add_product(self.item, 3)
-        self.assertEquals(Decimal('5.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('5.00'), self.benefit.apply(self.basket))
 
     def test_no_discount_for_not_discountable_product(self):
         self.item.is_discountable = False
         self.item.save()
         self.basket.add_product(self.item, 1)
-        self.assertEquals(Decimal('0.00'), self.benefit.apply(self.basket))
+        self.assertEquals(D('0.00'), self.benefit.apply(self.basket))
 
     def test_discount_does_not_consume_item_if_in_condition_range(self):
         self.basket.add_product(self.item, 1)
         first_discount = self.benefit.apply(self.basket)
-        self.assertEquals(Decimal('5.00'), first_discount)
+        self.assertEquals(D('5.00'), first_discount)
         second_discount = self.benefit.apply(self.basket)
-        self.assertEquals(Decimal('5.00'), second_discount)
+        self.assertEquals(D('5.00'), second_discount)
 
     def test_product_does_consume_item_if_not_in_condition_range(self):
         # Set up condition using a different range from benefit
         range = models.Range.objects.create(name="Small range")
-        other_product = create_product(price=Decimal('15.00'))
+        other_product = create_product(price=D('15.00'))
         range.included_products.add(other_product)
-        cond = models.ValueCondition(range=range, type="Value", value=Decimal('10.00'))
+        cond = models.ValueCondition(range=range, type="Value", value=D('10.00'))
 
         self.basket.add_product(self.item, 1)
         self.benefit.apply(self.basket, cond)
 
     def test_condition_consumes_most_expensive_lines_first(self):
         for i in range(10, 0, -1):
-            product = create_product(price=Decimal(i), title='%i'%i, upc='upc_%i' % i)
+            product = create_product(price=D(i), title='%i'%i, upc='upc_%i' % i)
             self.basket.add_product(product, 1)
 
         condition = models.CountCondition(range=self.range, type="Count", value=2)
         self.assertTrue(condition.is_satisfied(self.basket))
         # consume 1 and 10
         first_discount = self.benefit.apply(self.basket, condition=condition)
-        self.assertEquals(Decimal('1.00'), first_discount)
+        self.assertEquals(D('1.00'), first_discount)
 
         self.assertTrue(condition.is_satisfied(self.basket))
         # consume 2 and 9
         second_discount = self.benefit.apply(self.basket, condition=condition)
-        self.assertEquals(Decimal('2.00'), second_discount)
+        self.assertEquals(D('2.00'), second_discount)
 
         self.assertTrue(condition.is_satisfied(self.basket))
         # consume 3 and 8
         third_discount = self.benefit.apply(self.basket, condition=condition)
-        self.assertEquals(Decimal('3.00'), third_discount)
+        self.assertEquals(D('3.00'), third_discount)
 
         self.assertTrue(condition.is_satisfied(self.basket))
         # consume 4 and 7
         fourth_discount = self.benefit.apply(self.basket, condition=condition)
-        self.assertEquals(Decimal('4.00'), fourth_discount)
+        self.assertEquals(D('4.00'), fourth_discount)
 
         self.assertTrue(condition.is_satisfied(self.basket))
         # consume 5 and 6
         fifth_discount = self.benefit.apply(self.basket, condition=condition)
-        self.assertEquals(Decimal('5.00'), fifth_discount)
+        self.assertEquals(D('5.00'), fifth_discount)
 
         # end of items (one not discounted item in basket)
         self.assertFalse(condition.is_satisfied(self.basket))
 
     def test_condition_consumes_most_expensive_lines_first_when_products_are_repeated(self):
         for i in range(5, 0, -1):
-            product = create_product(price=Decimal(i), title='%i'%i, upc='upc_%i' % i)
+            product = create_product(price=D(i), title='%i'%i, upc='upc_%i' % i)
             self.basket.add_product(product, 2)
 
         condition = models.CountCondition(range=self.range, type="Count", value=2)
         self.assertTrue(condition.is_satisfied(self.basket))
         # consume 1 and 5
         first_discount = self.benefit.apply(self.basket, condition=condition)
-        self.assertEquals(Decimal('1.00'), first_discount)
+        self.assertEquals(D('1.00'), first_discount)
 
         self.assertTrue(condition.is_satisfied(self.basket))
         # consume 1 and 5
         second_discount = self.benefit.apply(self.basket, condition=condition)
-        self.assertEquals(Decimal('1.00'), second_discount)
+        self.assertEquals(D('1.00'), second_discount)
 
         self.assertTrue(condition.is_satisfied(self.basket))
         # consume 2 and 4
         third_discount = self.benefit.apply(self.basket, condition=condition)
-        self.assertEquals(Decimal('2.00'), third_discount)
+        self.assertEquals(D('2.00'), third_discount)
 
         self.assertTrue(condition.is_satisfied(self.basket))
         # consume 2 and 4
         third_discount = self.benefit.apply(self.basket, condition=condition)
-        self.assertEquals(Decimal('2.00'), third_discount)
+        self.assertEquals(D('2.00'), third_discount)
 
         self.assertTrue(condition.is_satisfied(self.basket))
         # consume 3 and 3
         third_discount = self.benefit.apply(self.basket, condition=condition)
-        self.assertEquals(Decimal('3.00'), third_discount)
+        self.assertEquals(D('3.00'), third_discount)
 
         # end of items (one not discounted item in basket)
         self.assertFalse(condition.is_satisfied(self.basket))
 
     def setUp(self):
         super(FixedPriceBenefitTest, self).setUp()
-        self.benefit = models.FixedPriceBenefit(range=self.range, type="FixedPrice", value=Decimal('10.00'))
+        self.benefit = models.FixedPriceBenefit(range=self.range, type="FixedPrice", value=D('10.00'))
 
     def test_correct_discount_for_count_condition(self):
-        products = [create_product(Decimal('7.00')),
-                    create_product(Decimal('8.00')),
-                    create_product(Decimal('12.00'))]
+        products = [create_product(D('7.00')),
+                    create_product(D('8.00')),
+                    create_product(D('12.00'))]
 
         # Create range that includes the products
         range = models.Range.objects.create(name="Dummy range")
         basket = Basket.objects.create()
         [basket.add_product(p, 2) for p in products]
 
-        benefit = models.FixedPriceBenefit(range=range, type="FixedPrice", value=Decimal('20.00'))
-        self.assertEquals(Decimal('2.00'), benefit.apply(basket, condition))
-        self.assertEquals(Decimal('12.00'), benefit.apply(basket, condition))
-        self.assertEquals(Decimal('0.00'), benefit.apply(basket, condition))
+        benefit = models.FixedPriceBenefit(range=range, type="FixedPrice", value=D('20.00'))
+        self.assertEquals(D('2.00'), benefit.apply(basket, condition))
+        self.assertEquals(D('12.00'), benefit.apply(basket, condition))
+        self.assertEquals(D('0.00'), benefit.apply(basket, condition))
 
     def test_correct_discount_is_returned(self):
-        products = [create_product(Decimal('8.00')), create_product(Decimal('4.00'))]
+        products = [create_product(D('8.00')), create_product(D('4.00'))]
         range = models.Range.objects.create(name="Dummy range")
         for product in products:
             range.included_products.add(product)
 
         condition = models.CoverageCondition(range=range, type="Coverage", value=2)
         discount = self.benefit.apply(basket, condition)
-        self.assertEquals(Decimal('2.00'), discount)
+        self.assertEquals(D('2.00'), discount)
 
     def test_no_discount_when_product_not_discountable(self):
-        product = create_product(Decimal('18.00'))
+        product = create_product(D('18.00'))
         product.is_discountable = False
         product.save()
 
 
         condition = models.CoverageCondition(range=product_range, type="Coverage", value=1)
         discount = self.benefit.apply(basket, condition)
-        self.assertEquals(Decimal('0.00'), discount)
+        self.assertEquals(D('0.00'), discount)
 
     def test_no_discount_is_returned_when_value_is_greater_than_product_total(self):
-        products = [create_product(Decimal('4.00')), create_product(Decimal('4.00'))]
+        products = [create_product(D('4.00')), create_product(D('4.00'))]
         range = models.Range.objects.create(name="Dummy range")
         for product in products:
             range.included_products.add(product)
 
         condition = models.CoverageCondition(range=range, type="Coverage", value=2)
         discount = self.benefit.apply(basket, condition)
-        self.assertEquals(Decimal('0.00'), discount)
+        self.assertEquals(D('0.00'), discount)
 
     def test_discount_when_more_products_than_required(self):
-        products = [create_product(Decimal('4.00')),
-                    create_product(Decimal('8.00')),
-                    create_product(Decimal('12.00'))]
+        products = [create_product(D('4.00')),
+                    create_product(D('8.00')),
+                    create_product(D('12.00'))]
 
         # Create range that includes the products
         range = models.Range.objects.create(name="Dummy range")
         [basket.add_product(p) for p in products]
         basket.add_product(products[0])
 
-        benefit = models.FixedPriceBenefit(range=range, type="FixedPrice", value=Decimal('20.00'))
+        benefit = models.FixedPriceBenefit(range=range, type="FixedPrice", value=D('20.00'))
         discount = benefit.apply(basket, condition)
-        self.assertEquals(Decimal('4.00'), discount)
+        self.assertEquals(D('4.00'), discount)
 
     def test_discount_when_applied_twice(self):
-        products = [create_product(Decimal('4.00')),
-                    create_product(Decimal('8.00')),
-                    create_product(Decimal('12.00'))]
+        products = [create_product(D('4.00')),
+                    create_product(D('8.00')),
+                    create_product(D('12.00'))]
 
         # Create range that includes the products
         range = models.Range.objects.create(name="Dummy range")
         basket = Basket.objects.create()
         [basket.add_product(p, 2) for p in products]
 
-        benefit = models.FixedPriceBenefit(range=range, type="FixedPrice", value=Decimal('20.00'))
+        benefit = models.FixedPriceBenefit(range=range, type="FixedPrice", value=D('20.00'))
         first_discount = benefit.apply(basket, condition)
-        self.assertEquals(Decimal('4.00'), first_discount)
+        self.assertEquals(D('4.00'), first_discount)
         second_discount = benefit.apply(basket, condition)
-        self.assertEquals(Decimal('4.00'), second_discount)
+        self.assertEquals(D('4.00'), second_discount)