[MIG] purchase_operating_unit: refactor unit tests - add common class…

… + fixes

purchase_operating_unit/tests/test_po_security.py

@@ -11,30 +11,31 @@ def test_po_ou_security(self):
         # User 2 is only assigned to Operating Unit 2, and cannot list
         # purchase orders from Operating Unit 1.
         po_ids = (
-            self.PurchaseOrder.with_user(self.user2_id)
+            self.PurchaseOrder.with_user(self.user2)
             .search([("operating_unit_id", "=", self.ou1.id)])
             .ids
         )
         self.assertEqual(po_ids, [])
+        invoice = self._create_invoice(self.purchase1.with_user(self.user1))
         # User 2 cannot list the invoice that was created from PO 1
         invoice_ids = (
-            self.AccountInvoice.with_user(self.user2_id)
-            .search([("id", "=", self.invoice.id)])
+            self.AccountInvoice.with_user(self.user2)
+            .search([("id", "=", invoice.id)])
             .ids
         )
         self.assertEqual(invoice_ids, [])
         # User 1 is assigned to Operating Unit 1, and can list
         # the purchase order 1 from Operating Unit 1.
         po_ids = (
-            self.PurchaseOrder.with_user(self.user1_id)
+            self.PurchaseOrder.with_user(self.user1)
             .search([("operating_unit_id", "=", self.ou1.id)])
             .ids
         )
         self.assertNotEqual(po_ids, [])
         # User 1 can list the invoice that was created from PO 2
         invoice_ids = (
-            self.AccountInvoice.with_user(self.user1_id)
-            .search([("id", "=", self.invoice.id)])
+            self.AccountInvoice.with_user(self.user1)
+            .search([("id", "=", invoice.id)])
             .ids
         )
         self.assertNotEqual(invoice_ids, [])

purchase_operating_unit/tests/test_purchase_operating_unit.py

@@ -5,73 +5,52 @@
 import time
 
 from odoo.exceptions import ValidationError
-from odoo.tests import Form, common
+from odoo.models import Command
+from odoo.tests import Form
 from odoo.tools import DEFAULT_SERVER_DATETIME_FORMAT
 
+from odoo.addons.operating_unit.tests.common import OperatingUnitCommon
 
-class TestPurchaseOperatingUnit(common.TransactionCase):
+
+class TestPurchaseOperatingUnit(OperatingUnitCommon):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        cls.ResUsers = cls.env["res.users"]
         cls.PurchaseOrder = cls.env["purchase.order"]
         cls.AccountInvoice = cls.env["account.move"]
         cls.AccountAccount = cls.env["account.account"]
-        # company
-        cls.company = cls.env.ref("base.main_company")
         # groups
         cls.group_purchase_user = cls.env.ref("purchase.group_purchase_user")
-        # Main Operating Unit
-        cls.ou1 = cls.env.ref("operating_unit.main_operating_unit")
-        # B2B Operating Unit
-        cls.b2b = cls.env.ref("operating_unit.b2b_operating_unit")
-        # Partner
-        cls.partner1 = cls.env.ref("base.res_partner_1")
         # Products
         cls.product1 = cls.env.ref("product.product_product_7")
         cls.product2 = cls.env.ref("product.product_product_9")
         cls.product3 = cls.env.ref("product.product_product_11")
+        (cls.product1 | cls.product2).write({"purchase_method": "purchase"})
         # Account
         cls.account = cls.AccountAccount.search(
             [("account_type", "=", "liability_payable")], limit=1
         )
-        # Create users
-        cls.user1_id = cls._create_user(
-            "user_1",
-            [cls.group_purchase_user],
-            cls.company,
-            [cls.ou1],
+        # Update users
+        cls.user1.write(
+            {
+                "groups_id": [
+                    Command.link(cls.group_purchase_user.id),
+                ],
+            }
         )
-        cls.user2_id = cls._create_user(
-            "user_2",
-            [cls.group_purchase_user],
-            cls.company,
-            [cls.b2b],
+        cls.user2.write(
+            {
+                "groups_id": [
+                    Command.link(cls.group_purchase_user.id),
+                ],
+                "operating_unit_ids": [Command.set([cls.b2b.id])],
+            }
         )
         cls.purchase1 = cls._create_purchase(
-            cls.user1_id,
+            cls.user1,
             [(cls.product1, 1000), (cls.product2, 500), (cls.product3, 800)],
         )
-        cls.purchase1.with_user(cls.user1_id).button_confirm()
-        cls.invoice = cls._create_invoice(cls.purchase1, cls.partner1, cls.account)
-
-    @classmethod
-    def _create_user(cls, login, groups, company, operating_units):
-        """Create a user."""
-        group_ids = [group.id for group in groups]
-        user = cls.ResUsers.with_context(**{"no_reset_password": True}).create(
-            {
-                "name": "Chicago Purchase User",
-                "login": login,
-                "password": "demo",
-                "email": "[email protected]",
-                "company_id": company.id,
-                "company_ids": [(4, company.id)],
-                "operating_unit_ids": [(4, ou.id) for ou in operating_units],
-                "groups_id": [(6, 0, group_ids)],
-            }
-        )
-        return user.id
+        cls.purchase1.with_user(cls.user1).button_confirm()
 
     @classmethod
     def _create_purchase(cls, user_id, line_products):
@@ -84,6 +63,7 @@ def _create_purchase(cls, user_id, line_products):
                 "name": product.name,
                 "product_id": product.id,
                 "product_qty": qty,
+                "qty_received_manual": qty,
                 "product_uom": product.uom_id.id,
                 "price_unit": 50,
                 "date_planned": time.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
@@ -101,39 +81,21 @@ def _create_purchase(cls, user_id, line_products):
         return purchase
 
     @classmethod
-    def _create_invoice(cls, purchase, partner, account):
+    def _create_invoice(cls, purchase):
         """Create a vendor invoice for the purchase order."""
-        invoice_vals = {
-            "purchase_id": purchase.id,
-            "partner_id": partner.id,
-            "move_type": "in_invoice",
-        }
-        purchase_context = {
-            "active_id": purchase.id,
-            "active_ids": purchase.ids,
-            "active_model": "purchase.order",
-        }
-        res = (
-            cls.env["account.move"]
-            .with_context(**purchase_context)
-            .create(invoice_vals)
-        )
-        return res
+        purchase.action_create_invoice()
+        return purchase.invoice_ids
 
     def test_01_purchase_operating_unit(self):
         self.purchase1.button_cancel()
         self.purchase1.button_draft()
         # Check change operating unit in purchase
         with self.assertRaises(ValidationError):
-            self.b2b.company_id = False
+            self.b2b.company_id = self.company_2
             with Form(self.purchase1) as po:
                 po.operating_unit_id = self.b2b
-        self.purchase1.with_user(self.user1_id).button_confirm()
-        # Create Vendor Bill
-        f = Form(self.env["account.move"].with_context(default_move_type="in_invoice"))
-        f.partner_id = self.purchase1.partner_id
-        f.purchase_id = self.purchase1
-        invoice = f.save()
+        self.purchase1.with_user(self.user1).button_confirm()
+        invoice = self._create_invoice(self.purchase1)
         self.assertEqual(invoice.operating_unit_id, self.purchase1.operating_unit_id)
         self.assertEqual(
             invoice.invoice_line_ids[0].operating_unit_id,