Merge pull request #4138 from django-oscar/register-discounts

Register discounts per line

docs/source/releases/v1.0.rst

@@ -552,8 +552,7 @@ Misc
 * Support for the ``OSCAR_OFFER_BLACKLIST_PRODUCT`` setting has been removed.
   It was only partially supported: it prevented products from being
   added to a range, but offers could be applied to the products nonetheless.
-  To prevent an offer being applied to a product, use ``is_discountable`` or
-  override ``get_is_discountable`` on your product instances.
+  To prevent an offer being applied to a product, use ``is_discountable``
 
 * ``Category.get_ancestors`` used to return a list of ancestors and would
   default to include itself. For consistency with get_descendants and to avoid

src/oscar/apps/basket/abstract_models.py

@@ -14,12 +14,13 @@ from django.utils.translation import gettext_lazy as _
 from oscar.core.compat import AUTH_USER_MODEL
 from oscar.core.loading import get_class, get_classes
 from oscar.core.utils import get_default_currency, round_half_up
+from oscar.core.decorators import deprecated
 from oscar.models.fields.slugfield import SlugField
 from oscar.templatetags.currency_filters import currency
 
 OfferApplications = get_class("offer.results", "OfferApplications")
 Unavailable = get_class("partner.availability", "Unavailable")
-LineOfferConsumer = get_class("basket.utils", "LineOfferConsumer")
+LineDiscountRegistry = get_class("basket.utils", "LineDiscountRegistry")
 OpenBasketManager, SavedBasketManager = get_classes(
     "basket.managers", ["OpenBasketManager", "SavedBasketManager"]
 )
@@ -726,10 +727,7 @@ class AbstractLine(models.Model):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        # Instance variables used to persist discount information
-        self._discount_excl_tax = D("0.00")
-        self._discount_incl_tax = D("0.00")
-        self.consumer = LineOfferConsumer(self)
+        self.discounts = LineDiscountRegistry(self)
 
     class Meta:
         abstract = True
@@ -740,6 +738,11 @@ class AbstractLine(models.Model):
         verbose_name = _("Basket line")
         verbose_name_plural = _("Basket lines")
 
+    @property
+    @deprecated
+    def consumer(self):
+        return self.discounts
+
     def __str__(self):
         return _(
             "Basket #%(basket_id)d, Product #%(product_id)d, quantity %(quantity)d"
@@ -764,29 +767,25 @@ class AbstractLine(models.Model):
         """
         Remove any discounts from this line.
         """
-        self._discount_excl_tax = D("0.00")
-        self._discount_incl_tax = D("0.00")
-        self.consumer = LineOfferConsumer(self)
+        self.discounts = LineDiscountRegistry(self)
 
     def discount(self, discount_value, affected_quantity, incl_tax=True, offer=None):
         """
         Apply a discount to this line
         """
         if incl_tax:
-            if self._discount_excl_tax > 0:
+            if self.discounts.excl_tax > 0:
                 raise RuntimeError(
                     "Attempting to discount the tax-inclusive price of a line "
                     "when tax-exclusive discounts are already applied"
                 )
-            self._discount_incl_tax += discount_value
         else:
-            if self._discount_incl_tax > 0:
+            if self.discounts.incl_tax > 0:
                 raise RuntimeError(
                     "Attempting to discount the tax-exclusive price of a line "
                     "when tax-inclusive discounts are already applied"
                 )
-            self._discount_excl_tax += discount_value
-        self.consume(affected_quantity, offer=offer)
+        self.discounts.discount(discount_value, affected_quantity, incl_tax, offer)
 
     def consume(self, quantity, offer=None):
         """
@@ -794,7 +793,7 @@ class AbstractLine(models.Model):
 
         Consumed items are no longer available to be used in offers.
         """
-        return self.consumer.consume(quantity, offer=offer)
+        return self.discounts.consume(quantity, offer=offer)
 
     def get_price_breakdown(self):
         """
@@ -815,14 +814,16 @@ class AbstractLine(models.Model):
         else:
             # Need to split the discount among the affected quantity
             # of products.
-            item_incl_tax_discount = self.discount_value / int(self.consumer.consumed())
+            item_incl_tax_discount = self.discount_value / int(
+                self.discounts.num_consumed()
+            )
             item_excl_tax_discount = item_incl_tax_discount * self._tax_ratio
             item_excl_tax_discount = round_half_up(item_excl_tax_discount)
             prices.append(
                 (
                     self.unit_price_incl_tax - item_incl_tax_discount,
                     self.unit_price_excl_tax - item_excl_tax_discount,
-                    self.consumer.consumed(),
+                    self.discounts.num_consumed(),
                 )
             )
             if self.quantity_without_discount:
@@ -841,6 +842,14 @@ class AbstractLine(models.Model):
 
     @property
     def _tax_ratio(self):
+        # this function tries to computate the tax ratio based on the incl tax price
+        # versus the excl tax price. Since these values are allready rounded, this will
+        # NOT return the exact ratio corresponding to your tax rate.
+        # if this is a problem you need to provide your own implementation of _tax_ratio
+        # that returns the ratio based on the exact tax percentage in use.
+        # one way to make this value correct is to use 4 decimals for all prices everywhere,
+        # and round only at the last moment when presenting the values to the user.
+        # that would make this value precise and correct because there would be no rounding
         if not self.unit_price_incl_tax:
             return 0
         return self.unit_price_excl_tax / self.unit_price_incl_tax
@@ -850,16 +859,16 @@ class AbstractLine(models.Model):
     # ===============
 
     def has_offer_discount(self, offer):
-        return self.consumer.consumed(offer) > 0
+        return self.discounts.num_consumed(offer) > 0
 
     def quantity_with_offer_discount(self, offer):
-        return self.consumer.consumed(offer)
+        return self.discounts.num_consumed(offer)
 
     def quantity_without_offer_discount(self, offer):
-        return self.consumer.available(offer)
+        return self.discounts.available(offer)
 
     def is_available_for_offer_discount(self, offer):
-        return self.consumer.available(offer) > 0
+        return self.discounts.available(offer) > 0
 
     def quantity_available_for_offer(self, offer):
         return self.quantity_without_offer_discount(
@@ -870,22 +879,39 @@ class AbstractLine(models.Model):
     # Properties
     # ==========
 
+    @property
+    @deprecated
+    def _discount_incl_tax(self):
+        return self.discounts.incl_tax
+
+    @_discount_incl_tax.setter
+    def _discount_incl_tax(self, value):
+        raise Exception("You can not set _discount_incl_tax")
+
+    @property
+    @deprecated
+    def _discount_excl_tax(self):
+        return self.discounts.excl_tax
+
+    @_discount_excl_tax.setter
+    def _discount_excl_tax(self, value):
+        raise Exception("You can not set _discount_excl_tax")
+
     @property
     def has_discount(self):
-        return bool(self.consumer.consumed())
+        return bool(self.discounts.num_consumed())
 
     @property
     def quantity_with_discount(self):
-        return self.consumer.consumed()
+        return self.discounts.num_consumed()
 
     @property
     def quantity_without_discount(self):
-        return self.consumer.available()
+        return self.discounts.available()
 
     @property
     def discount_value(self):
-        # Only one of the incl- and excl- discounts should be non-zero
-        return max(self._discount_incl_tax, self._discount_excl_tax)
+        return self.discounts.total
 
     # pylint: disable=W0201
     @property
@@ -928,34 +954,55 @@ class AbstractLine(models.Model):
 
     @property
     def line_price_excl_tax_incl_discounts(self):
-        if self._discount_excl_tax and self.line_price_excl_tax is not None:
-            return max(0, self.line_price_excl_tax - self._discount_excl_tax)
-        if self._discount_incl_tax and self.line_price_incl_tax is not None:
-            # This is a tricky situation.  We know the discount as calculated
-            # against tax inclusive prices but we need to guess how much of the
-            # discount applies to tax-exclusive prices.  We do this by
-            # assuming a linear tax and scaling down the original discount.
-            return max(
-                0,
-                self.line_price_excl_tax
-                - round_half_up(self._tax_ratio * self._discount_incl_tax),
-            )
+        if self.line_price_excl_tax is None:
+            return None
+
+        excl_tax_discounts = self.discounts.excl_tax
+        if excl_tax_discounts:
+            # these are discounts that return a value excluding tax, we can simply
+            # subtract this value from line_price_excl_tax to get to line_price_excl_tax_incl_discounts
+            return max(0, self.line_price_excl_tax - excl_tax_discounts)
+
+        # This is a tricky situation.  We know the discount as calculated
+        # against tax inclusive prices but we need to guess how much of the
+        # discount applies to tax-exclusive prices.  We do this by
+        # assuming a linear tax and scaling down the original discount.
+        # Please refer to the _tax_ratio method for more details on how
+        # to make this calculation more precise.
+
+        incl_tax_discounts = self.discounts.incl_tax
+        if incl_tax_discounts and self._tax_ratio:
+            if self.line_price_excl_tax is not None:
+                # if we got a precise line_price_excl_tax use that first, if _tax_ratio is off,
+                # this will create the smallest deviation becaise incl_tax_discounts is usually
+                # smaller than line_price_excl_tax
+                return max(
+                    0,
+                    self.line_price_excl_tax
+                    - round_half_up(self._tax_ratio * incl_tax_discounts),
+                )
+            elif self.line_price_incl_tax is not None:
+                # when all else fails, compute based on line_price_incl_tax
+                return max(
+                    0, self._tax_ratio * (self.line_price_incl_tax - incl_tax_discounts)
+                )
+
+        # there are no discounts so just return the line_price_excl_tax
         return self.line_price_excl_tax
 
     @property
     def line_price_incl_tax_incl_discounts(self):
+        excl_tax_discounts = self.discounts.excl_tax
+        incl_tax_discounts = self.discounts.incl_tax
+
         # We use whichever discount value is set.  If the discount value was
         # calculated against the tax-exclusive prices, then the line price
         # including tax
-        if self.line_price_incl_tax is not None and self._discount_incl_tax:
-            return max(0, self.line_price_incl_tax - self._discount_incl_tax)
-        elif self.line_price_excl_tax is not None and self._discount_excl_tax:
-            return max(
-                0,
-                round_half_up(
-                    (self.line_price_excl_tax - self._discount_excl_tax)
-                    / self._tax_ratio
-                ),
+        if self.line_price_incl_tax is not None and incl_tax_discounts:
+            return max(0, self.line_price_incl_tax - incl_tax_discounts)
+        elif self.line_price_excl_tax is not None and excl_tax_discounts:
+            return round_half_up(
+                self.line_price_excl_tax_incl_discounts / self._tax_ratio
             )
 
         return self.line_price_incl_tax

src/oscar/apps/basket/utils.py

@@ -1,13 +1,18 @@
-from collections import defaultdict
+from collections import defaultdict, namedtuple
 
 from django.contrib import messages
 from django.template.loader import render_to_string
 
 from oscar.core.loading import get_class, get_model
+from oscar.core.decorators import deprecated
 
 Applicator = get_class("offer.applicator", "Applicator")
 ConditionalOffer = get_model("offer", "ConditionalOffer")
 
+DiscountApplication = namedtuple(
+    "DiscountApplication", ["amount", "quantity", "incl_tax", "offer"]
+)
+
 
 class BasketMessageGenerator(object):
     new_total_template_name = "oscar/basket/messages/new_total.html"
@@ -125,7 +130,11 @@ class LineOfferConsumer(object):
             self._consumptions[offer.pk] += num_consumed
         return num_consumed
 
+    @deprecated
     def consumed(self, offer=None):
+        return self.num_consumed(offer)
+
+    def num_consumed(self, offer=None):
         """
         check how many items on this line have been
         consumed by an offer
@@ -145,7 +154,7 @@ class LineOfferConsumer(object):
 
     @property
     def consumers(self):
-        return [x for x in self._offers.values() if self.consumed(x)]
+        return [x for x in self._offers.values() if self.num_consumed(x)]
 
     def available(self, offer=None) -> int:
         """
@@ -172,7 +181,9 @@ class LineOfferConsumer(object):
                         ):
                             # Exclusive offers cannot be applied if any other exclusive
                             # offer with higher priority is active already.
-                            max_affected_items = max_affected_items - self.consumed(a)
+                            max_affected_items = max_affected_items - self.num_consumed(
+                                a
+                            )
                             if max_affected_items == 0:
                                 return 0
 
@@ -191,4 +202,46 @@ class LineOfferConsumer(object):
                 if check and offer not in x.combined_offers:
                     return 0
 
-        return max_affected_items - self.consumed(offer)
+        return max_affected_items - self.num_consumed(offer)
+
+
+class LineDiscountRegistry(LineOfferConsumer):
+    def __init__(self, line):
+        super().__init__(line)
+        self._discounts = []
+        self._discount_excl_tax = None
+        self._discount_incl_tax = None
+
+    def discount(self, amount, quantity, incl_tax=True, offer=None):
+        self._discounts.append(DiscountApplication(amount, quantity, incl_tax, offer))
+        self.consume(quantity, offer=offer)
+        if incl_tax:
+            self._discount_incl_tax = None
+        else:
+            self._discount_excl_tax = None
+
+    @property
+    def excl_tax(self):
+        if self._discount_excl_tax is None:
+            self._discount_excl_tax = sum(
+                [d.amount for d in self._discounts if not d.incl_tax], 0
+            )
+        return self._discount_excl_tax
+
+    @property
+    def incl_tax(self):
+        if self._discount_incl_tax is None:
+            self._discount_incl_tax = sum(
+                [d.amount for d in self._discounts if d.incl_tax], 0
+            )
+        return self._discount_incl_tax
+
+    @property
+    def total(self):
+        return sum([d.amount for d in self._discounts], 0)
+
+    def all(self):
+        return self._discounts
+
+    def __iter__(self):
+        return iter(self._discounts)

src/oscar/apps/order/abstract_models.py

@@ -1286,6 +1286,33 @@ class AbstractOrderDiscount(models.Model):
         return self.offer_name or ""
 
 
+class AbstractOrderLineDiscount(models.Model):
+    line = models.ForeignKey(
+        "order.Line",
+        on_delete=models.CASCADE,
+        related_name="discounts",
+        verbose_name=_("Line"),
+    )
+    order_discount = models.ForeignKey(
+        "order.OrderDiscount",
+        on_delete=models.CASCADE,
+        related_name="discount_lines",
+        verbose_name=_("Order discount"),
+    )
+
+    is_incl_tax = models.BooleanField()
+    amount = models.DecimalField(
+        _("Line discount (excl. tax)"), decimal_places=2, max_digits=12, default=0
+    )
+
+    class Meta:
+        abstract = True
+        app_label = "order"
+        ordering = ["pk"]
+        verbose_name = _("Order line discount")
+        verbose_name_plural = _("Order line discounts")
+
+
 class AbstractSurcharge(models.Model):
     order = models.ForeignKey(
         "order.Order",

src/oscar/apps/order/migrations/0015_orderlinediscount.py

@@ -0,0 +1,66 @@
+# Generated by Django 4.2.2 on 2023-07-19 13:16
+
+from django.db import migrations, models
+import django.db.models.deletion
+
+from django.utils.module_loading import import_string
+from django.conf import settings
+
+models_AutoField = import_string(settings.DEFAULT_AUTO_FIELD)
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("order", "0014_tax_code"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="OrderLineDiscount",
+            fields=[
+                (
+                    "id",
+                    models_AutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("is_incl_tax", models.BooleanField()),
+                (
+                    "amount",
+                    models.DecimalField(
+                        decimal_places=2,
+                        default=0,
+                        max_digits=12,
+                        verbose_name="Line discount (excl. tax)",
+                    ),
+                ),
+                (
+                    "line",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="discounts",
+                        to="order.line",
+                        verbose_name="Line",
+                    ),
+                ),
+                (
+                    "order_discount",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="discount_lines",
+                        to="order.orderdiscount",
+                        verbose_name="Order discount",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Order line discount",
+                "verbose_name_plural": "Order line discounts",
+                "ordering": ["pk"],
+                "abstract": False,
+            },
+        ),
+    ]

src/oscar/apps/order/models.py

@@ -120,6 +120,15 @@ if not is_model_registered("order", "OrderDiscount"):
 
     __all__.append("OrderDiscount")
 
+
+if not is_model_registered("order", "OrderLineDiscount"):
+
+    class OrderLineDiscount(AbstractOrderLineDiscount):
+        pass
+
+    __all__.append("OrderDiscount")
+
+
 if not is_model_registered("order", "Surcharge"):
 
     class Surcharge(AbstractSurcharge):

src/oscar/apps/order/utils.py

@@ -14,6 +14,7 @@ from . import exceptions
 Order = get_model("order", "Order")
 Line = get_model("order", "Line")
 OrderDiscount = get_model("order", "OrderDiscount")
+OrderLineDiscount = get_model("order", "OrderLineDiscount")
 CommunicationEvent = get_model("order", "CommunicationEvent")
 CommunicationEventType = get_model("communication", "CommunicationEventType")
 Dispatcher = get_class("communication.utils", "Dispatcher")
@@ -88,10 +89,6 @@ class OrderCreator(object):
                 request,
                 **kwargs
             )
-            for line in basket.all_lines():
-                self.create_line_models(order, line)
-                self.update_stock_records(line)
-
             for voucher in basket.vouchers.select_for_update():
                 if not voucher.is_active():  # basket ignores inactive vouchers
                     basket.vouchers.remove(voucher)
@@ -123,6 +120,10 @@ class OrderCreator(object):
             for voucher in basket.vouchers.all():
                 self.record_voucher_usage(order, voucher, user)
 
+            for line in basket.all_lines():
+                self.create_line_models(order, line)
+                self.update_stock_records(line)
+
         # Send signal for analytics to pick up
         order_placed.send(sender=self, order=order, user=user)
 
@@ -232,6 +233,7 @@ class OrderCreator(object):
         order_line = Line._default_manager.create(**line_data)
         self.create_line_price_models(order, order_line, basket_line)
         self.create_line_attributes(order, order_line, basket_line)
+        self.create_line_discount_models(order, order_line, basket_line)
         self.create_additional_line_models(order, order_line, basket_line)
 
         return order_line
@@ -243,6 +245,18 @@ class OrderCreator(object):
         if line.product.get_product_class().track_stock:
             line.stockrecord.allocate(line.quantity)
 
+    def create_line_discount_models(self, order, order_line, basket_line):
+        for discount in basket_line.discounts:
+            order_discount = order.discounts.filter(offer_id=discount.offer.id).first()
+            # If we are unable to find the discount we do not care, the total amount is still saved on the discount model,
+            # these models are only created so we know how much discount was given per line for each offer
+            if order_discount:
+                order_line.discounts.create(
+                    order_discount=order_discount,
+                    is_incl_tax=discount.incl_tax,
+                    amount=discount.amount,
+                )
+
     def create_additional_line_models(self, order, order_line, basket_line):
         """
         Empty method designed to be overridden.

src/oscar/apps/partner/prices.py

@@ -1,4 +1,5 @@
 from oscar.core import prices
+from django.conf import settings
 
 
 class Base(object):
@@ -21,6 +22,8 @@ class Base(object):
     #: Price to use for offer calculations
     @property
     def effective_price(self):
+        if settings.OSCAR_OFFERS_INCL_TAX:
+            return self.incl_tax
         # Default to using the price excluding tax for calculations
         return self.excl_tax
 

src/oscar/templates/oscar/dashboard/ranges/range_product_list.html

@@ -132,7 +132,7 @@
                     </td>
                     <td>{{ product.upc|default:"-" }}</td>
                     <td><a href="{% url 'dashboard:catalogue-product' pk=product.id %}">{{ product.get_title }}</a></td>
-                    <td>{% if product.get_is_discountable %}{% trans "Yes" %}{% else %}{% trans "No" %}{% endif %}</td>
+                    <td>{% if product.is_discountable %}{% trans "Yes" %}{% else %}{% trans "No" %}{% endif %}</td>
                     <td>
                       <a class="btn btn-danger" href="#" data-behaviours="remove">{% trans "Remove" %}</a>
                       {% if range.is_reorderable %}
@@ -242,7 +242,7 @@
                       </td>
                       <td>{{ product.upc|default:"-" }}</td>
                       <td><a href="{% url 'dashboard:catalogue-product' pk=product.id %}">{{ product.get_title }}</a></td>
-                      <td>{% if product.get_is_discountable %}{% trans "Yes" %}{% else %}{% trans "No" %}{% endif %}</td>
+                      <td>{% if product.is_discountable %}{% trans "Yes" %}{% else %}{% trans "No" %}{% endif %}</td>
                       <td><a class="btn btn-danger" href="#" data-behaviours="remove">{% trans "Remove" %}</a></td>
                     </tr>
                   {% endfor %}

tests/integration/basket/test_utils.py

@@ -60,7 +60,7 @@ def multi_offers():
 class TestLineOfferConsumer:
     def test_consumed_no_offer(self, filled_basket):
         for line in filled_basket.all_lines():
-            assert line.consumer.consumed() == 0
+            assert line.discounts.num_consumed() == 0
 
     def test_available_with_offer(self):
         basket = BasketFactory()
@@ -78,8 +78,8 @@ class TestLineOfferConsumer:
 
         offer1 = ConditionalOfferFactory(name="offer1", benefit=benefit)
         lines = basket.all_lines()
-        assert lines[0].consumer.available(offer1) == 1
-        assert lines[1].consumer.available(offer1) == 10
+        assert lines[0].discounts.available(offer1) == 1
+        assert lines[1].discounts.available(offer1) == 10
 
     def test_consumed_with_offer(self, filled_basket):
         offer1 = ConditionalOfferFactory(name="offer1")
@@ -88,31 +88,31 @@ class TestLineOfferConsumer:
         offer2.exclusive = False
 
         for line in filled_basket.all_lines():
-            assert line.consumer.consumed(offer1) == 0
-            assert line.consumer.consumed(offer2) == 0
+            assert line.discounts.num_consumed(offer1) == 0
+            assert line.discounts.num_consumed(offer2) == 0
 
         line1 = filled_basket.all_lines()[0]
         line2 = filled_basket.all_lines()[1]
 
-        line1.consumer.consume(1, offer1)
-        assert line1.consumer.consumed() == 1
-        assert line1.consumer.consumed(offer1) == 1
-        assert line1.consumer.consumed(offer2) == 0
+        line1.discounts.consume(1, offer1)
+        assert line1.discounts.num_consumed() == 1
+        assert line1.discounts.num_consumed(offer1) == 1
+        assert line1.discounts.num_consumed(offer2) == 0
 
-        line1.consumer.consume(9, offer1)
-        assert line1.consumer.consumed() == line1.quantity
-        assert line1.consumer.consumed(offer1) == line1.quantity
-        assert line1.consumer.consumed(offer2) == 0
+        line1.discounts.consume(9, offer1)
+        assert line1.discounts.num_consumed() == line1.quantity
+        assert line1.discounts.num_consumed(offer1) == line1.quantity
+        assert line1.discounts.num_consumed(offer2) == 0
 
-        line1.consumer.consume(99, offer1)
-        assert line1.consumer.consumed(offer1) == line1.quantity
-        assert line1.consumer.consumed(offer2) == 0
+        line1.discounts.consume(99, offer1)
+        assert line1.discounts.num_consumed(offer1) == line1.quantity
+        assert line1.discounts.num_consumed(offer2) == 0
 
-        line1.consumer.consume(1, offer2)
-        line2.consumer.consume(1, offer2)
+        line1.discounts.consume(1, offer2)
+        line2.discounts.consume(1, offer2)
 
-        assert line1.consumer.consumed(offer2) == 1
-        assert line2.consumer.consumed(offer2) == 1
+        assert line1.discounts.num_consumed(offer2) == 1
+        assert line2.discounts.num_consumed(offer2) == 1
 
     def test_consume(self, filled_basket):
         line = filled_basket.all_lines()[0]
@@ -130,29 +130,29 @@ class TestLineOfferConsumer:
         offer3.exclusive = False
 
         for line in filled_basket.all_lines():
-            assert line.consumer.consumed(offer1) == 0
-            assert line.consumer.consumed(offer2) == 0
+            assert line.discounts.num_consumed(offer1) == 0
+            assert line.discounts.num_consumed(offer2) == 0
 
         line1, line2 = list(filled_basket.all_lines())
 
         # exclusive offer consumes one item on line1
-        line1.consumer.consume(1, offer1)
+        line1.discounts.consume(1, offer1)
 
         # offer1 is exclusive so that blocks other offers
         assert line1.is_available_for_offer_discount(offer2) is False
 
-        line1.consumer.consume(99, offer1)
+        line1.discounts.consume(99, offer1)
         # ran out of room for offer1
         assert line1.is_available_for_offer_discount(offer1) is False
         # offer2 was never an option
         assert line1.is_available_for_offer_discount(offer2) is False
 
         # exclusivity is per line so line2 is available for offer2
-        line2.consumer.consume(1, offer2)
+        line2.discounts.consume(1, offer2)
         # nope: exclusive and non-exclusive don't mix
         assert line2.is_available_for_offer_discount(offer1) is False
 
-        line2.consumer.consume(99, offer2)
+        line2.discounts.consume(99, offer2)
         # ran out of room for offer2
         assert line2.is_available_for_offer_discount(offer1) is False
         # but still room for offer3!
@@ -167,13 +167,13 @@ class TestLineOfferConsumer:
         offer3.exclusive = False
 
         for line in filled_basket.all_lines():
-            assert line.consumer.consumed(offer1) == 0
-            assert line.consumer.consumed(offer2) == 0
+            assert line.discounts.num_consumed(offer1) == 0
+            assert line.discounts.num_consumed(offer2) == 0
 
         line1, line2 = list(filled_basket.all_lines())
 
         # exclusive offer consumes one item on line1
-        line1.consumer.consume(1, offer1)
+        line1.discounts.consume(1, offer1)
         remaining1 = line1.quantity - 1
 
         assert line1.quantity_with_offer_discount(offer1) == 1
@@ -185,7 +185,7 @@ class TestLineOfferConsumer:
         assert line1.quantity_without_offer_discount(offer3) == 0
 
         # exclusive offer consumes all items on line1
-        line1.consumer.consume(remaining1, offer1)
+        line1.discounts.consume(remaining1, offer1)
         assert line1.quantity_with_offer_discount(offer1) == line1.quantity
         assert line1.quantity_with_offer_discount(offer2) == 0
         assert line1.quantity_with_offer_discount(offer3) == 0
@@ -195,7 +195,7 @@ class TestLineOfferConsumer:
         assert line1.quantity_without_offer_discount(offer3) == 0
 
         # non-exclusive offer consumes one item on line2
-        line2.consumer.consume(1, offer2)
+        line2.discounts.consume(1, offer2)
         remaining2 = line2.quantity - 1
 
         assert line2.quantity_with_offer_discount(offer1) == 0
@@ -207,7 +207,7 @@ class TestLineOfferConsumer:
         assert line2.quantity_without_offer_discount(offer3) == line2.quantity
 
         # non-exclusive offer consumes all items on line2
-        line2.consumer.consume(remaining2, offer2)
+        line2.discounts.consume(remaining2, offer2)
 
         assert line2.quantity_with_offer_discount(offer1) == 0
         assert line2.quantity_with_offer_discount(offer2) == line2.quantity
@@ -222,7 +222,7 @@ class TestLineOfferConsumer:
         basket = filled_basket
         Applicator().apply(basket)
         assert len(basket.offer_applications.offer_discounts) == 1
-        assert [x.consumer.consumed() for x in basket.all_lines()] == [1, 0]
+        assert [x.discounts.num_consumed() for x in basket.all_lines()] == [1, 0]
 
     def test_apply_multiple_vouchers(self, filled_basket):
         offer1 = ConditionalOfferFactory(
@@ -264,14 +264,14 @@ class TestLineOfferConsumer:
         assert offer2 in offer3.combined_offers
 
         for line in filled_basket.all_lines():
-            assert line.consumer.consumed(offer1) == 0
-            assert line.consumer.consumed(offer2) == 0
-            assert line.consumer.consumed(offer3) == 0
+            assert line.discounts.num_consumed(offer1) == 0
+            assert line.discounts.num_consumed(offer2) == 0
+            assert line.discounts.num_consumed(offer3) == 0
 
         line1 = filled_basket.all_lines()[0]
 
         # combinable offer consumes one item of line1
-        line1.consumer.consume(1, offer2)
+        line1.discounts.consume(1, offer2)
         remaining1 = line1.quantity - 1
 
         assert line1.quantity_with_offer_discount(offer1) == 0
@@ -285,7 +285,7 @@ class TestLineOfferConsumer:
         assert line1.quantity_without_offer_discount(offer4) == 0
 
         # combinable offer consumes one item of line1
-        line1.consumer.consume(1, offer3)
+        line1.discounts.consume(1, offer3)
         assert line1.quantity_with_offer_discount(offer1) == 0
         assert line1.quantity_with_offer_discount(offer2) == 1
         assert line1.quantity_with_offer_discount(offer3) == 1
@@ -297,7 +297,7 @@ class TestLineOfferConsumer:
         assert line1.quantity_without_offer_discount(offer4) == 0
 
         # combinable offer consumes all items of line1
-        line1.consumer.consume(remaining1, offer2)
+        line1.discounts.consume(remaining1, offer2)
 
         assert line1.quantity_with_offer_discount(offer1) == 0
         assert line1.quantity_with_offer_discount(offer2) == line1.quantity

tests/integration/management_commands/test_oscar_fork_statics.py

@@ -2,6 +2,7 @@ import io
 import os
 import pathlib
 import tempfile
+import shutil
 
 from django.core.management import call_command
 from django.core.management.base import CommandError
@@ -18,7 +19,7 @@ class OscarForkStaticsTestCase(TestCase):
         self.oscar_static_dir_path = pathlib.Path(
             os.path.dirname(oscar.__file__), "static"
         )
-        self.oscar_static_dir_path.mkdir()
+        self.oscar_static_dir_path.mkdir(exist_ok=True)
         self.oscar_static_file_path = pathlib.Path(
             self.oscar_static_dir_path, "name.css"
         )
@@ -32,7 +33,10 @@ class OscarForkStaticsTestCase(TestCase):
     def tearDown(self):
         # Delete dummy Oscar static-files directory
         self.oscar_static_file_path.unlink()
-        self.oscar_static_dir_path.rmdir()
+        try:
+            self.oscar_static_dir_path.rmdir()
+        except OSError:
+            pass
 
     def test_command_with_already_existing_directory(self):
         project_static_dir_path = pathlib.Path(self.project_base_dir_path, "static")
@@ -45,7 +49,7 @@ class OscarForkStaticsTestCase(TestCase):
             "The folder %s already exists - aborting!" % project_static_dir_path,
         )
 
-        project_static_dir_path.rmdir()
+        shutil.rmtree(project_static_dir_path.rmdir(), ignore_errors=True)
 
     def test_command_with_default_target_path(self):
         project_static_dir_path = pathlib.Path(self.project_base_dir_path, "static")
@@ -64,8 +68,7 @@ class OscarForkStaticsTestCase(TestCase):
             "picked up" % project_static_dir_path,
         )
 
-        project_static_file_path.unlink()
-        project_static_dir_path.rmdir()
+        shutil.rmtree(project_static_dir_path)
 
     def test_command_with_relative_target_path(self):
         project_static_dir_path = pathlib.Path(
@@ -86,8 +89,7 @@ class OscarForkStaticsTestCase(TestCase):
             "picked up" % project_static_dir_path,
         )
 
-        project_static_file_path.unlink()
-        project_static_dir_path.rmdir()
+        shutil.rmtree(project_static_dir_path)
         project_static_dir_path.parent.rmdir()
 
     def test_command_with_absolute_target_path(self):
@@ -109,6 +111,5 @@ class OscarForkStaticsTestCase(TestCase):
             "picked up" % project_static_dir_path,
         )
 
-        project_static_file_path.unlink()
-        project_static_dir_path.rmdir()
+        shutil.rmtree(project_static_dir_path)
         project_static_dir_path.parent.rmdir()

tests/integration/order/test_creator.py

@@ -13,6 +13,7 @@ from django.utils import timezone
 from oscar.apps.catalogue.models import Product, ProductClass
 from oscar.apps.checkout import calculators
 from oscar.apps.offer.utils import Applicator
+from oscar.apps.offer import models
 from oscar.apps.order.models import Order
 from oscar.apps.order.utils import OrderCreator
 from oscar.apps.shipping.methods import FixedPrice, Free
@@ -27,6 +28,7 @@ Range = get_class("offer.models", "Range")
 Benefit = get_class("offer.models", "Benefit")
 
 SurchargeApplicator = get_class("checkout.applicator", "SurchargeApplicator")
+UK = get_class("partner.strategy", "UK")
 
 
 def place_order(creator, **kwargs):
@@ -263,6 +265,56 @@ class TestShippingOfferForOrder(TestCase):
         self.assertEqual(D("34.00"), order.total_incl_tax)
 
 
+class TestOrderOfferCreation(TestCase):
+    def setUp(self):
+        self.creator = OrderCreator()
+        self.basket = factories.create_basket(empty=True)
+        self.basket.strategy = UK()
+        self.surcharges = SurchargeApplicator().get_applicable_surcharges(self.basket)
+        product_range = Range.objects.create(
+            name="All products range", includes_all_products=True
+        )
+        condition = models.CountCondition.objects.create(
+            range=product_range, type=models.Condition.COUNT, value=1
+        )
+        benefit = models.PercentageDiscountBenefit.objects.create(
+            range=product_range,
+            type=models.Benefit.PERCENTAGE,
+            value=20,
+        )
+        self.offer = models.ConditionalOffer(
+            name="Test",
+            offer_type=models.ConditionalOffer.SITE,
+            condition=condition,
+            benefit=benefit,
+        )
+        self.offer.save()
+        self.applicator = Applicator()
+
+    def test_multi_lines_discount(self):
+        add_product(self.basket, D(10))
+        add_product(self.basket, D(20))
+
+        self.applicator.apply_offers(self.basket, [self.offer])
+
+        place_order(
+            self.creator,
+            surcharges=self.surcharges,
+            basket=self.basket,
+            order_number="klatsieknoekie666",
+        )
+
+        order = Order.objects.get(number="klatsieknoekie666")
+
+        discount = order.discounts.first()
+        self.assertEqual(discount.amount, D("7.20"))
+        self.assertEqual(discount.discount_lines.count(), 2)
+        self.assertEqual(
+            discount.amount,
+            sum([discount.amount for discount in discount.discount_lines.all()]),
+        )
+
+
 class TestMultiSiteOrderCreation(TestCase):
     def setUp(self):
         self.creator = OrderCreator()