odoo-addon-stock-request 16.0.1.0.0.3__py3-none-any.whl → 17.0.1.0.0.2__py3-none-any.whl

odoo/addons/stock_request/tests/test_stock_request.py

@@ -1,136 +1,137 @@
 # Copyright 2017 ForgeFlow S.L.
+# Copyright 2022-2023 Tecnativa - Víctor Martínez
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl-3.0).
+
 from collections import Counter
 from datetime import datetime
 
 from odoo import exceptions, fields
-from odoo.tests import new_test_user
-
-from odoo.addons.base.tests.common import BaseCommon
-
-
-class TestStockRequest(BaseCommon):
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-
+from odoo.tests import common, new_test_user
+
+
+class TestStockRequest(common.TransactionCase):
+    def setUp(self):
+        super().setUp()
+        self.env = self.env(
+            context=dict(
+                self.env.context,
+                mail_create_nolog=True,
+                mail_create_nosubscribe=True,
+                mail_notrack=True,
+                no_reset_password=True,
+                tracking_disable=True,
+            )
+        )
         # common models
-        cls.stock_request = cls.env["stock.request"]
-        cls.request_order = cls.env["stock.request.order"]
-
+        self.stock_request = self.env["stock.request"]
+        self.request_order = self.env["stock.request.order"]
         # refs
-        cls.stock_request_user_group = cls.env.ref(
+        self.stock_request_user_group = self.env.ref(
             "stock_request.group_stock_request_user"
         )
-        cls.main_company = cls.env.ref("base.main_company")
-        cls.warehouse = cls.env.ref("stock.warehouse0")
-        cls.categ_unit = cls.env.ref("uom.product_uom_categ_unit")
-        cls.virtual_loc = cls.env.ref("stock.stock_location_customers")
-
+        self.main_company = self.env.ref("base.main_company")
+        self.warehouse = self.env.ref("stock.warehouse0")
+        self.categ_unit = self.env.ref("uom.product_uom_categ_unit")
+        self.virtual_loc = self.env.ref("stock.stock_location_customers")
         # common data
-        cls.company_2 = cls.env["res.company"].create(
-            {"name": "Comp2", "parent_id": cls.main_company.id}
+        self.company_2 = self.env["res.company"].create(
+            {"name": "Comp2", "parent_id": self.main_company.id}
         )
-        cls.company_2_address = (
-            cls.env["res.partner"]
-            .with_context(company_id=cls.company_2.id)
+        self.company_2_address = (
+            self.env["res.partner"]
+            .with_context(company_id=self.company_2.id)
             .create({"name": "Peñiscola"})
         )
-        cls.wh = cls.env["stock.warehouse"].search(
-            [("company_id", "=", cls.main_company.id)], limit=1
+        self.wh2 = self.env["stock.warehouse"].search(
+            [("company_id", "=", self.company_2.id)], limit=1
         )
-        cls.wh2 = cls.env["stock.warehouse"].search(
-            [("company_id", "=", cls.company_2.id)], limit=1
-        )
-        cls.stock_request_user = new_test_user(
-            cls.env,
+        self.stock_request_user = new_test_user(
+            self.env,
             login="stock_request_user",
             groups="stock_request.group_stock_request_user",
-            company_ids=[(4, cls.main_company.id), (4, cls.company_2.id)],
+            company_ids=[(6, 0, [self.main_company.id, self.company_2.id])],
         )
-        cls.stock_request_manager = new_test_user(
-            cls.env,
+        self.stock_request_manager = new_test_user(
+            self.env,
             login="stock_request_manager",
             groups="stock_request.group_stock_request_manager",
-            company_ids=[(4, cls.main_company.id), (4, cls.company_2.id)],
+            company_ids=[(6, 0, [self.main_company.id, self.company_2.id])],
         )
-        cls.product = cls._create_product("SH", "Shoes", False)
-        cls.product_company_2 = cls._create_product("SH_2", "Shoes", cls.company_2.id)
-
-        cls.ressuply_loc = cls._create_location(
+        self.product = self._create_product("SH", "Shoes", False)
+        self.product_company_2 = self._create_product(
+            "SH_2", "Shoes", self.company_2.id
+        )
+        self.ressuply_loc = self._create_location(
             name="Ressuply",
-            location_id=cls.warehouse.view_location_id.id,
-            company_id=cls.main_company.id,
+            location_id=self.warehouse.view_location_id.id,
+            company_id=self.main_company.id,
         )
-        cls.ressuply_loc_2 = cls._create_location(
+        self.ressuply_loc_2 = self._create_location(
             name="Ressuply",
-            location_id=cls.wh2.view_location_id.id,
-            company_id=cls.company_2.id,
+            location_id=self.wh2.view_location_id.id,
+            company_id=self.company_2.id,
         )
-
-        cls.route = cls._create_route(name="Transfer", company_id=cls.main_company.id)
-        cls.route_2 = cls._create_route(name="Transfer", company_id=cls.company_2.id)
-
-        cls.uom_dozen = cls.env["uom.uom"].create(
+        self.route = self._create_location_route(
+            name="Transfer", company_id=self.main_company.id
+        )
+        self.route_2 = self._create_location_route(
+            name="Transfer", company_id=self.company_2.id
+        )
+        self.uom_dozen = self.env["uom.uom"].create(
             {
                 "name": "Test-DozenA",
-                "category_id": cls.categ_unit.id,
+                "category_id": self.categ_unit.id,
                 "factor_inv": 12,
                 "uom_type": "bigger",
                 "rounding": 0.001,
             }
         )
-
-        cls.env["stock.rule"].create(
+        self.env["stock.rule"].create(
             {
                 "name": "Transfer",
-                "route_id": cls.route.id,
-                "location_src_id": cls.ressuply_loc.id,
-                "location_dest_id": cls.warehouse.lot_stock_id.id,
+                "route_id": self.route.id,
+                "location_src_id": self.ressuply_loc.id,
+                "location_dest_id": self.warehouse.lot_stock_id.id,
                 "action": "pull",
-                "picking_type_id": cls.warehouse.int_type_id.id,
+                "picking_type_id": self.warehouse.int_type_id.id,
                 "procure_method": "make_to_stock",
-                "warehouse_id": cls.warehouse.id,
-                "company_id": cls.main_company.id,
+                "warehouse_id": self.warehouse.id,
+                "company_id": self.main_company.id,
             }
         )
-
-        cls.env["stock.rule"].create(
+        self.env["stock.rule"].create(
             {
                 "name": "Transfer",
-                "route_id": cls.route_2.id,
-                "location_src_id": cls.ressuply_loc_2.id,
-                "location_dest_id": cls.wh2.lot_stock_id.id,
+                "route_id": self.route_2.id,
+                "location_src_id": self.ressuply_loc_2.id,
+                "location_dest_id": self.wh2.lot_stock_id.id,
                 "action": "pull",
-                "picking_type_id": cls.wh2.int_type_id.id,
+                "picking_type_id": self.wh2.int_type_id.id,
                 "procure_method": "make_to_stock",
-                "warehouse_id": cls.wh2.id,
-                "company_id": cls.company_2.id,
+                "warehouse_id": self.wh2.id,
+                "company_id": self.company_2.id,
             }
         )
-
-        cls.env["ir.config_parameter"].sudo().set_param(
+        self.env["ir.config_parameter"].sudo().set_param(
             "stock.no_auto_scheduler", "True"
         )
 
-    @classmethod
-    def _create_product(cls, default_code, name, company_id, **vals):
-        return cls.env["product.product"].create(
+    def _create_product(self, default_code, name, company_id, **vals):
+        return self.env["product.product"].create(
             dict(
                 name=name,
                 default_code=default_code,
-                uom_id=cls.env.ref("uom.product_uom_unit").id,
+                uom_id=self.env.ref("uom.product_uom_unit").id,
                 company_id=company_id,
-                type="product",
-                **vals
+                detailed_type="product",
+                **vals,
             )
         )
 
-    @classmethod
     def _create_product_template_attribute_line(
-        cls, product_tmpl_id, attribute_id, value_id
+        self, product_tmpl_id, attribute_id, value_id
     ):
-        return cls.env["product.template.attribute.line"].create(
+        return self.env["product.template.attribute.line"].create(
             {
                 "product_tmpl_id": product_tmpl_id,
                 "attribute_id": attribute_id,
@@ -138,33 +139,32 @@ class TestStockRequest(BaseCommon):
             }
         )
 
-    @classmethod
-    def _create_product_attribute_value(cls, name, attribute):
-        return cls.env["product.attribute.value"].create(
+    def _create_product_attribute_value(self, name, attribute):
+        return self.env["product.attribute.value"].create(
             {"name": name, "attribute_id": attribute}
         )
 
-    @classmethod
-    def _create_product_attribute(cls, name):
-        return cls.env["product.attribute"].create({"name": name})
+    def _create_product_attribute(self, name):
+        return self.env["product.attribute"].create({"name": name})
 
-    @classmethod
-    def _create_location(cls, **vals):
-        return cls.env["stock.location"].create(dict(usage="internal", **vals))
+    def _create_location(self, **vals):
+        return self.env["stock.location"].create(dict(usage="internal", **vals))
 
-    @classmethod
-    def _create_route(cls, **vals):
-        return cls.env["stock.route"].create(
+    def _create_location_route(self, **vals):
+        return self.env["stock.route"].create(
             dict(
                 product_categ_selectable=False,
                 product_selectable=True,
                 sequence=10,
-                **vals
+                **vals,
             )
         )
 
 
 class TestStockRequestBase(TestStockRequest):
+    def setUp(self):
+        super().setUp()
+
     def _create_stock_quant(self, product, location, qty):
         self.env["stock.quant"].create(
             {"product_id": product.id, "location_id": location.id, "quantity": qty}
@@ -176,17 +176,30 @@ class TestStockRequestBase(TestStockRequest):
             "product_uom_id": self.product.uom_id.id,
             "product_uom_qty": 5.0,
         }
-        request_model = self.stock_request.with_user(self.stock_request_user)
-        stock_request = request_model.with_company(self.main_company).create(vals)
+        stock_request = (
+            self.stock_request.with_user(self.stock_request_user)
+            .with_context(company_id=self.main_company.id)
+            .create(vals)
+        )
+
         self.assertEqual(stock_request.requested_by, self.stock_request_user)
+
         self.assertEqual(stock_request.warehouse_id, self.warehouse)
+
         self.assertEqual(stock_request.location_id, self.warehouse.lot_stock_id)
 
     def test_defaults_order(self):
-        request_model = self.request_order.with_user(self.stock_request_user)
-        order = request_model.with_company(self.main_company).create({})
+        vals = {}
+        order = (
+            self.request_order.with_user(self.stock_request_user)
+            .with_context(company_id=self.main_company.id)
+            .create(vals)
+        )
+
         self.assertEqual(order.requested_by, self.stock_request_user)
+
         self.assertEqual(order.warehouse_id, self.warehouse)
+
         self.assertEqual(order.location_id, self.warehouse.lot_stock_id)
 
     def test_onchanges_order(self):
@@ -215,6 +228,7 @@ class TestStockRequestBase(TestStockRequest):
         order = self.request_order.with_user(self.stock_request_user).new(vals)
         self.stock_request_user.company_id = self.company_2
         order.company_id = self.company_2
+
         order.onchange_company_id()
 
         stock_request = order.stock_request_ids
@@ -250,7 +264,6 @@ class TestStockRequestBase(TestStockRequest):
     def test_onchanges(self):
         self.product.route_ids = [(6, 0, self.route.ids)]
         vals = {
-            "product_id": self.product.id,
             "product_uom_id": self.product.uom_id.id,
             "product_uom_qty": 5.0,
             "company_id": self.main_company.id,
@@ -290,7 +303,7 @@ class TestStockRequestBase(TestStockRequest):
         # Test onchange_warehouse_id
         wh2_2 = (
             self.env["stock.warehouse"]
-            .with_company(self.company_2)
+            .with_context(company_id=self.company_2.id)
             .create(
                 {
                     "name": "C2_2",
@@ -702,7 +715,8 @@ class TestStockRequestBase(TestStockRequest):
         picking.with_user(self.stock_request_manager).action_assign()
         self.assertEqual(picking.origin, order.name)
         packout1 = picking.move_line_ids[0]
-        packout1.qty_done = 5
+        packout1.quantity = 5
+        packout1.picked = True
         picking.with_user(self.stock_request_manager)._action_done()
         self.assertEqual(stock_request.qty_in_progress, 0.0)
         self.assertEqual(stock_request.qty_done, stock_request.product_uom_qty)
@@ -747,7 +761,8 @@ class TestStockRequestBase(TestStockRequest):
         self.assertEqual(stock_request.qty_done, 0.0)
         picking.with_user(self.stock_request_manager).action_assign()
         packout1 = picking.move_line_ids[0]
-        packout1.qty_done = 1
+        packout1.quantity = 1
+        packout1.picked = True
         picking.with_user(self.stock_request_manager)._action_done()
         self.assertEqual(stock_request.qty_in_progress, 0.0)
         self.assertEqual(stock_request.qty_done, stock_request.product_uom_qty)
@@ -763,15 +778,14 @@ class TestStockRequestBase(TestStockRequest):
             "warehouse_id": self.warehouse.id,
             "location_id": self.warehouse.lot_stock_id.id,
         }
+
         stock_request_1 = (
-            self.env["stock.request"]
-            .with_user(self.stock_request_user)
-            .create(vals.copy())
+            self.env["stock.request"].with_user(self.stock_request_user).create(vals)
         )
         stock_request_2 = (
             self.env["stock.request"]
             .with_user(self.stock_request_manager.id)
-            .create(vals.copy())
+            .create(vals)
         )
         stock_request_2.product_uom_qty = 6.0
         self.product.route_ids = [(6, 0, self.route.ids)]
@@ -801,7 +815,8 @@ class TestStockRequestBase(TestStockRequest):
         self.assertEqual(stock_request_2.qty_done, 0)
         self.assertEqual(stock_request_2.qty_cancelled, 0)
         packout1 = picking.move_line_ids[0]
-        packout1.qty_done = 4
+        packout1.quantity = 4
+        packout1.picked = True
         self.env["stock.backorder.confirmation"].with_context(
             button_validate_picking_ids=[picking.id]
         ).create({"pick_ids": [(4, picking.id)]}).process_cancel_backorder()
@@ -903,10 +918,10 @@ class TestStockRequestBase(TestStockRequest):
             ],
         }
 
-        order = self.request_order.with_user(self.stock_request_manager).create(vals)
+        order = self.request_order.create(vals)
         self.product.route_ids = [(6, 0, self.route.ids)]
 
-        order.action_confirm()
+        order.with_user(self.stock_request_manager).action_confirm()
         stock_request = order.stock_request_ids
         self.assertTrue(stock_request.picking_ids)
         self.assertTrue(order.picking_ids)
@@ -1125,9 +1140,9 @@ class TestStockRequestBase(TestStockRequest):
         group = self.env["procurement.group"].create({"name": "Procurement group"})
         product2 = self._create_product("SH2", "Shoes2", False)
         product3 = self._create_product("SH3", "Shoes3", False)
-        self.product.type = "consu"
-        product2.type = "consu"
-        product3.type = "consu"
+        self.product.detailed_type = "consu"
+        product2.detailed_type = "consu"
+        product3.detailed_type = "consu"
         vals = {
             "company_id": self.main_company.id,
             "warehouse_id": self.warehouse.id,
@@ -1183,9 +1198,10 @@ class TestStockRequestBase(TestStockRequest):
         picking = order.picking_ids
         self.assertEqual(1, len(picking))
         picking.action_assign()
-        self.assertEqual(3, len(picking.move_line_ids))
-        line = picking.move_line_ids.filtered(lambda r: r.product_id == self.product)
-        line.qty_done = 1
+        self.assertEqual(3, len(picking.move_ids))
+        line = picking.move_ids.filtered(lambda r: r.product_id == self.product)
+        line.quantity = 1
+        line.picked = True
         sr1 = order.stock_request_ids.filtered(lambda r: r.product_id == self.product)
         sr2 = order.stock_request_ids.filtered(lambda r: r.product_id == product2)
         sr3 = order.stock_request_ids.filtered(lambda r: r.product_id == product3)
@@ -1195,9 +1211,9 @@ class TestStockRequestBase(TestStockRequest):
         self.env["stock.backorder.confirmation"].with_context(
             button_validate_picking_ids=[picking.id]
         ).create({"pick_ids": [(4, picking.id)]}).process()
-        sr1.env.invalidate_all()
-        sr2.env.invalidate_all()
-        sr3.env.invalidate_all()
+        sr1.invalidate_recordset()
+        sr2.invalidate_recordset()
+        sr3.invalidate_recordset()
         self.assertNotEqual(sr1.state, "done")
         self.assertNotEqual(sr2.state, "done")
         self.assertNotEqual(sr3.state, "done")
@@ -1206,58 +1222,64 @@ class TestStockRequestBase(TestStockRequest):
         )
         self.assertEqual(1, len(picking))
         picking.action_assign()
-        self.assertEqual(3, len(picking.move_line_ids))
-        line = picking.move_line_ids.filtered(lambda r: r.product_id == self.product)
-        line.qty_done = 4
-        line = picking.move_line_ids.filtered(lambda r: r.product_id == product2)
-        line.qty_done = 1
+        self.assertEqual(3, len(picking.move_ids))
+        line = picking.move_ids.filtered(lambda r: r.product_id == self.product)
+        line.quantity = 4
+        line.picked = True
+        line = picking.move_ids.filtered(lambda r: r.product_id == product2)
+        line.quantity = 1
+        line.picked = True
         self.env["stock.backorder.confirmation"].with_context(
             button_validate_picking_ids=[picking.id]
         ).create({"pick_ids": [(4, picking.id)]}).process_cancel_backorder()
-        sr1.env.invalidate_all()
-        sr2.env.invalidate_all()
-        sr3.env.invalidate_all()
+        sr1.invalidate_recordset()
+        sr2.invalidate_recordset()
+        sr3.invalidate_recordset()
         self.assertEqual(sr1.state, "done")
+        self.assertEqual(sr1.qty_done, 5)
         self.assertEqual(sr1.qty_cancelled, 0)
         self.assertEqual(sr2.state, "cancel")
+        self.assertEqual(sr2.qty_done, 1)
         self.assertEqual(sr2.qty_cancelled, 4)
         self.assertEqual(sr3.state, "cancel")
+        self.assertEqual(sr3.qty_done, 0)
         self.assertEqual(sr3.qty_cancelled, 5)
+        # Set the request order to done if there are any delivered lines
+        self.assertEqual(order.state, "done")
 
 
 class TestStockRequestOrderState(TestStockRequest):
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        cls.product_a = cls._create_product(
+    def setUp(self):
+        super().setUp()
+        self.product_a = self._create_product(
             "CODEA",
             "Product A",
-            cls.main_company.id,
+            self.main_company.id,
         )
-        cls.product_a.route_ids = [(6, 0, cls.route.ids)]
-        cls.product_b = cls._create_product(
+        self.product_a.route_ids = [(6, 0, self.route.ids)]
+        self.product_b = self._create_product(
             "CODEB",
             "Product B",
-            cls.main_company.id,
+            self.main_company.id,
         )
-        cls.product_b.route_ids = [(6, 0, cls.route.ids)]
+        self.product_b.route_ids = [(6, 0, self.route.ids)]
         expected_date = fields.Datetime.now()
         vals = {
-            "company_id": cls.main_company.id,
-            "warehouse_id": cls.warehouse.id,
-            "location_id": cls.warehouse.lot_stock_id.id,
+            "company_id": self.main_company.id,
+            "warehouse_id": self.warehouse.id,
+            "location_id": self.warehouse.lot_stock_id.id,
             "expected_date": expected_date,
             "stock_request_ids": [
                 (
                     0,
                     0,
                     {
-                        "product_id": cls.product_a.id,
-                        "product_uom_id": cls.product_a.uom_id.id,
+                        "product_id": self.product_a.id,
+                        "product_uom_id": self.product_a.uom_id.id,
                         "product_uom_qty": 1.0,
-                        "company_id": cls.main_company.id,
-                        "warehouse_id": cls.warehouse.id,
-                        "location_id": cls.warehouse.lot_stock_id.id,
+                        "company_id": self.main_company.id,
+                        "warehouse_id": self.warehouse.id,
+                        "location_id": self.warehouse.lot_stock_id.id,
                         "expected_date": expected_date,
                     },
                 ),
@@ -1265,23 +1287,23 @@ class TestStockRequestOrderState(TestStockRequest):
                     0,
                     0,
                     {
-                        "product_id": cls.product_b.id,
-                        "product_uom_id": cls.product_b.uom_id.id,
+                        "product_id": self.product_b.id,
+                        "product_uom_id": self.product_b.uom_id.id,
                         "product_uom_qty": 1.0,
-                        "company_id": cls.main_company.id,
-                        "warehouse_id": cls.warehouse.id,
-                        "location_id": cls.warehouse.lot_stock_id.id,
+                        "company_id": self.main_company.id,
+                        "warehouse_id": self.warehouse.id,
+                        "location_id": self.warehouse.lot_stock_id.id,
                         "expected_date": expected_date,
                     },
                 ),
             ],
         }
-        cls.order = cls.request_order.create(vals)
-        cls.request_a = cls.order.stock_request_ids.filtered(
-            lambda x: x.product_id == cls.product_a
+        self.order = self.request_order.new(vals)
+        self.request_a = self.order.stock_request_ids.filtered(
+            lambda x: x.product_id == self.product_a
         )
-        cls.request_b = cls.order.stock_request_ids.filtered(
-            lambda x: x.product_id == cls.product_b
+        self.request_b = self.order.stock_request_ids.filtered(
+            lambda x: x.product_id == self.product_b
         )
 
     def test_stock_request_order_state_01(self):