[IMP] stock_available_location_orderpoint: Improve tests for sublocations

Author: rousseldenis

stock_available_location_orderpoint/models/product_product.py

@@ -71,6 +71,8 @@ def _compute_available_quantities_dict(self):
         for product in self:
             qties_replenished_for_location = {product: 0.0}
             for orderpoint in orderpoints:
+                # As we compute global quantities for the product, pass
+                # always 0 to the already replenished quantity
                 qty_to_replenish = orderpoint._get_qty_to_replenish(
                     product,
                     qties_on_locations,

stock_available_location_orderpoint/readme/ROADMAP.rst

@@ -139,8 +139,11 @@ def test_available_on_one_shelf_location(self):
         move = self._create_outgoing_move(1)
         self.assertEqual(move.state, "confirmed")
         self.product.invalidate_recordset()
+        # The quantity to replenish is equal to the total of replenishment locations
+        # quantity as they are in shelf parents path.
         self.assertEqual(
-            7.0, self.product.with_context(location=self.shelf.id).quantity_to_replenish
+            17.0,
+            self.product.with_context(location=self.shelf.id).quantity_to_replenish,
         )
 
     def test_available_on_one_stock_location_with_shelf(self):
@@ -204,16 +207,17 @@ def test_available_on_one_stock_location_with_shelf(self):
 
         # Check the replenishment value for shelf location only
         self.assertEqual(
-            5.0, self.product.with_context(location=self.shelf.id).quantity_to_replenish
+            15.0,
+            self.product.with_context(location=self.shelf.id).quantity_to_replenish,
         )
 
         # We are not in shelf location context
-        product = self.product.search([("quantity_to_replenish", "=", 5.0)])
-        self.assertFalse(self.product.id in product.ids)
+        product = self.product.search([("quantity_to_replenish", "=", 15.0)])
+        self.assertTrue(self.product.id in product.ids)
 
         # We are in shelf location context
         product = self.product.with_context(location=self.shelf.id).search(
-            [("quantity_to_replenish", "=", 5.0)]
+            [("quantity_to_replenish", "=", 15.0)]
         )
         self.assertTrue(self.product.id in product.ids)
 

stock_available_location_orderpoint/tests/test_available_location_orderpoint.py

@@ -329,11 +329,114 @@ def test_available_on_one_stock_location_with_shelf(self):
 
         # We are in shelf context
         self.template.invalidate_recordset()
+        self.template.product_variant_ids.invalidate_recordset()
+        self.template.with_context(
+            location=self.shelf.id
+        )._compute_available_quantities_dict()
+        self.assertEqual(
+            15.0,
+            self.template.with_context(location=self.shelf.id).quantity_to_replenish,
+        )
         templates = self.template.with_context(location=self.shelf.id).search(
-            [("quantity_to_replenish", "=", 5.0)]
+            [("quantity_to_replenish", "=", 15.0)]
         )
         self.assertTrue(self.template.id in templates.ids)
 
+    def test_available_on_different_sublocation(self):
+        """
+        Remove the existing orderpoints
+
+        Create a location structure like:
+            - Stock
+                - Area 1
+                    - Shelf 1
+                - Area 2
+                    - Shelf 2
+
+        Create orderpoints for both areas.
+
+        Create ougoing moves for both shelves:
+            - Shelf 1: 12.0
+            - Shelf 2: 2.0
+
+        Global quantity to replenish should be 8.0
+
+        Quantity for Shelf 1 should be 6.0
+
+        """
+        # Archive orderpoints
+        self.env["stock.location.orderpoint"].search([]).write({"active": False})
+
+        self.area_1 = self.env["stock.location"].create(
+            {
+                "name": "Area 1",
+                "location_id": self.location_dest.id,
+                "usage": "view",
+            }
+        )
+
+        self.shelf_1 = self.env["stock.location"].create(
+            {"name": "Shelf 1", "location_id": self.area_1.id}
+        )
+
+        self.area_2 = self.env["stock.location"].create(
+            {
+                "name": "Area 2",
+                "location_id": self.location_dest.id,
+                "usage": "view",
+            }
+        )
+
+        self.shelf_2 = self.env["stock.location"].create(
+            {"name": "Shelf 1", "location_id": self.area_2.id}
+        )
+
+        # Create an orderpoint by shelf
+        self.location_dest = self.area_1
+        (
+            self.orderpoint_shelf_1,
+            self.location_src_shelf_1,
+        ) = self._create_orderpoint_complete("Area 1 Replenishment", trigger="manual")
+
+        self.location_dest = self.area_2
+        (
+            self.orderpoint_shelf_2,
+            self.location_src_shelf_2,
+        ) = self._create_orderpoint_complete("Area 2 Replenishment", trigger="manual")
+
+        # Set stock on replenishment locations
+        self.env["stock.quant"].with_context(inventory_mode=True).create(
+            {
+                "inventory_quantity": 6.0,
+                "location_id": self.location_src_shelf_1.id,
+                "product_id": self.product.id,
+            }
+        )._apply_inventory()
+        self.env["stock.quant"].with_context(inventory_mode=True).create(
+            {
+                "inventory_quantity": 4.0,
+                "location_id": self.location_src_shelf_2.id,
+                "product_id": self.product.id,
+            }
+        )._apply_inventory()
+
+        self.location_dest = self.shelf_1
+        move = self._create_outgoing_move(12)
+        self.assertEqual(move.state, "confirmed")
+
+        self.location_dest = self.shelf_2
+        move = self._create_outgoing_move(2)
+        self.assertEqual(move.state, "confirmed")
+
+        self.template.invalidate_recordset()
+        self.assertEqual(8.0, self.template.quantity_to_replenish)
+
+        self.template.invalidate_recordset()
+        self.assertEqual(
+            6.0,
+            self.template.with_context(location=self.shelf_1.id).quantity_to_replenish,
+        )
+
     def test_action(self):
         action = self.template.action_open_replenishments()
         self.assertIn(