If a product has a option it cannot be oversold (#4096)

* if a product has a option it cannot be oversold

* Improve error message

---------

Co-authored-by: wessel <wessel@highbiza.nl>
Co-authored-by: Lars van de Kerkhof <lars@permanentmarkers.nl>

.github/workflows/test.yml

       run: |
         coverage run --parallel -m pytest -x
     - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v1
+      uses: codecov/codecov-action@v1.5.2
       with:
         fail_ci_if_error: true
   lint_python:

src/oscar/apps/basket/abstract_models.py

             return max_allowed, basket_threshold
         return None, None
 
-    def is_quantity_allowed(self, qty):
+    def is_quantity_allowed(self, qty, line=None):
         """
         Test whether the passed quantity of items can be added to the basket
         """
         # We enforce a max threshold to prevent a DOS attack via the offers
         # system.
         max_allowed, basket_threshold = self.max_allowed_quantity()
+
+        if line is not None:
+            line_purchase_permitted, reason = line.purchase_info.availability.is_purchase_permitted(qty)
+
+            if not line_purchase_permitted:
+                return line_purchase_permitted, reason
+
+            # Also check if it's permitted with potentional other lines of the same product & stocrecord
+            total_lines_quantity = self.basket_quantity(line) + qty
+            line_purchase_permitted, reason = line.purchase_info.availability.is_purchase_permitted(
+                total_lines_quantity)
+
+            if not line_purchase_permitted:
+                return line_purchase_permitted, _(
+                    "Available stock is only %(max)d, which has been exceeded because "
+                    "multiple lines contain the same product."
+                ) % {'max': line.purchase_info.availability.num_available}
+
         if max_allowed is not None and qty > max_allowed:
             return False, _(
                 "Due to technical limitations we are not able "
                 "to ship more than %(threshold)d items in one order.") \
                 % {'threshold': basket_threshold}
+
         return True, None
 
+    def basket_quantity(self, line):
+        """Return the quantity of similar lines in the basket.
+        The basket can contain multiple lines with the same product and
+        stockrecord, but different options. Those quantities are summed up.
+        """
+        matching_lines = self.lines.filter(stockrecord=line.stockrecord)
+        quantity = matching_lines.aggregate(Sum('quantity'))['quantity__sum']
+        return quantity or 0
     # ============
     # Manipulation
     # ============

src/oscar/apps/basket/forms.py

         # number and updated. Thus, product already in the basket and we don't
         # add second time, just updating number of items.
         qty_delta = qty - self.instance.quantity
-        is_allowed, reason = self.instance.basket.is_quantity_allowed(qty_delta)
+        is_allowed, reason = self.instance.basket.is_quantity_allowed(qty_delta, line=self.instance)
         if not is_allowed:
             raise forms.ValidationError(reason)
 

tests/functional/test_basket.py

 from oscar.core.compat import get_user_model
 from oscar.test import factories
 from oscar.test.basket import add_product
-from oscar.test.factories import create_product
+from oscar.test.factories import OptionFactory, create_product
 from oscar.test.testcases import WebTestCase
 
 User = get_user_model()
         self.assertFalse(response.context['formset'].forms[0].is_valid())
         self.assertEqual(basket.lines.count(), 1)
         self.assertEqual(basket.lines.all()[0].quantity, 1)
+
+    def test_formset_quantity_update_with_options(self):
+        product = create_product(num_in_stock=2)
+        option = OptionFactory()
+        # Add the option to the product class
+        product.get_product_class().options.add(option)
+
+        basket = factories.create_basket(empty=True)
+        basket.owner = self.user
+        basket.save()
+        basket.add_product(product, options=[{"option": option, "value": "Test 1"}])
+        basket.add_product(product, options=[{"option": option, "value": "Test 2"}])
+
+        response = self.get(reverse('basket:summary'))
+        formset = response.context['formset']
+        self.assertEqual(len(formset.forms), 2)
+
+        # Now update one of the quantities to 2
+        data = {
+            formset.add_prefix('TOTAL_FORMS'): formset.management_form.initial['TOTAL_FORMS'],
+            formset.add_prefix('INITIAL_FORMS'): formset.management_form.initial['INITIAL_FORMS'],
+            formset.add_prefix('MIN_NUM_FORMS'): formset.management_form.initial['MIN_NUM_FORMS'],
+            formset.add_prefix('MAX_NUM_FORMS'): formset.management_form.initial['MAX_NUM_FORMS'],
+            formset.forms[0].add_prefix('id'): formset.forms[0].instance.pk,
+            formset.forms[0].add_prefix('quantity'): 2,
+            formset.forms[1].add_prefix('id'): formset.forms[1].instance.pk,
+            formset.forms[1].add_prefix('quantity'): formset.forms[1].instance.quantity,
+        }
+        response = self.post(reverse('basket:summary'), params=data, xhr=True)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertFalse(response.context['formset'].forms[0].is_valid())
+        self.assertIn(
+            "can be bought which has been exceeded because you have multiple lines of the same product.",
+            str(response.context['formset'].forms[0].errors)
+        )

tests/integration/basket/test_forms.py

             queryset=self.basket.all_lines())
         self.assertTrue(formset.forms[0].instance.has_discount)
 
+    def test_max_allowed_quantity_with_options(self):
+        self.basket.flush()
+
+        option = OptionFactory(required=False)
+        product = factories.create_product(num_in_stock=2)
+        product.get_product_class().options.add(option)
+        self.basket.add_product(product, options=[{"option": option, "value": "Test 1"}])
+        self.basket.add_product(product, options=[{"option": option, "value": "Test 2"}])
+
+        form = forms.BasketLineForm(
+            strategy=self.basket.strategy,
+            data={'quantity': 2},
+            instance=self.basket.all_lines()[0]
+        )
+        self.assertFalse(form.is_valid())
+        self.assertIn(
+            "can be bought which has been exceeded because you have multiple lines of the same product.",
+            str(form.errors)
+        )
+
 
 class TestAddToBasketForm(TestCase):