[16.0][IMP] dms: Improve tests

dms/tests/common.py

@@ -1,97 +1,25 @@
 # Copyright 2017-2019 MuK IT GmbH.
 # Copyright 2020 Creu Blanca
-# Copyright 2021-2022 Tecnativa - Víctor Martínez
+# Copyright 2021-2024 Tecnativa - Víctor Martínez
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
 import base64
 import functools
 import logging
-import os
 import threading
 import time
 import uuid
 
-from odoo import SUPERUSER_ID, _
-from odoo.modules.module import get_module_resource
-from odoo.tests import Form, common, new_test_user
-from odoo.tools import convert_file
+from odoo.tests import Form, new_test_user
+
+from odoo.addons.base.tests.common import BaseCommon
 
-_path = os.path.dirname(os.path.dirname(__file__))
 _logger = logging.getLogger(__name__)
 
 # ----------------------------------------------------------
 # Decorators
 # ----------------------------------------------------------
 
 
-def multi_users(users=False, reset=True, raise_exception=True, callback=False):
-    def decorator(func):
-        @functools.wraps(func)
-        def wrapper(self, *args, **kwargs):
-            user_list = users(self) if callable(users) else users
-            test_results = []
-            for user in user_list:
-                self.cr.execute("SAVEPOINT test_multi_users")
-                try:
-                    if not isinstance(user[0], int):
-                        self.uid = self.ref(user[0])
-                    else:
-                        self.uid = user[0]
-                    if hasattr(self, callback):
-                        callb = getattr(self, callback)
-                        if callable(callb):
-                            callb()
-                    func(self, *args, **kwargs)
-                except Exception as error:
-                    test_results.append(
-                        {
-                            "user": user[0],
-                            "expect": user[1],
-                            "result": False,
-                            "error": error,
-                        }
-                    )
-                else:
-                    test_results.append(
-                        {
-                            "user": user[0],
-                            "expect": user[1],
-                            "result": True,
-                            "error": None,
-                        }
-                    )
-                if reset:
-                    self.env.cache.invalidate()
-                    self.registry.clear_caches()
-                    self.registry.reset_changes()
-                    self.cr.execute("ROLLBACK TO SAVEPOINT test_multi_users")
-                else:
-                    self._cr.execute("RELEASE SAVEPOINT test_multi_users")
-            test_fails = []
-            for result in test_results:
-                if result["expect"] != result["result"]:
-                    message = "Test (%s) with user (%s) failed!"
-                    _logger.info(message % (func.__name__, result["user"]))
-                    if result["error"]:
-                        _logger.error(result["error"], exc_info=True)
-                    test_fails.append(result)
-            if test_fails:
-                message = "{} out of {} tests failed".format(
-                    len(test_fails),
-                    len(test_results),
-                )
-                if raise_exception and test_fails[0]["error"]:
-                    raise test_fails[0]["error"]
-                elif raise_exception:
-                    raise Exception(_("Error has not been raised"))
-                else:
-                    _logger.info(message)
-            return test_results
-
-        return wrapper
-
-    return decorator
-
-
 def track_function(
     max_query_count=None, max_query_time=None, max_time=None, return_tracking=False
 ):
@@ -148,87 +76,53 @@ def wrapper(*args, **kwargs):
 # ----------------------------------------------------------
 
 
-class DocumentsBaseCase(common.TransactionCase):
-    def setUp(self):
-        super().setUp()
-        self.super_uid = SUPERUSER_ID
-        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,
-            )
-        )
+class DocumentsBaseCase(BaseCommon):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
         # models
-        self.access_group_model = self.env["dms.access.group"]
-        self.storage_model = self.env["dms.storage"]
-        self.directory_model = self.env["dms.directory"]
-        self.file_model = self.env["dms.file"]
-        self.category_model = self.env["dms.category"]
-        self.tag_model = self.env["dms.tag"]
-        self.attachment_model = self.env["ir.attachment"]
-        self.partner_model = self.env["res.partner"]
+        cls.access_group_model = cls.env["dms.access.group"]
+        cls.storage_model = cls.env["dms.storage"]
+        cls.directory_model = cls.env["dms.directory"]
+        cls.file_model = cls.env["dms.file"]
+        cls.category_model = cls.env["dms.category"]
+        cls.tag_model = cls.env["dms.tag"]
+        cls.attachment_model = cls.env["ir.attachment"]
+        cls.partner_model = cls.env["res.partner"]
         # users
-        self.user = new_test_user(self.env, login="basic-user")
-        self.public_user = self.env.ref("base.public_user")
-        self.dms_user = new_test_user(
-            self.env, login="dms-user", groups="dms.group_dms_user"
+        cls.user = new_test_user(cls.env, login="basic-user")
+        cls.public_user = cls.env.ref("base.public_user")
+        cls.dms_user = new_test_user(
+            cls.env, login="dms-user", groups="dms.group_dms_user"
         )
-        self.dms_manager_user = new_test_user(
-            self.env, login="dms-manager", groups="dms.group_dms_manager"
+        cls.dms_manager_user = new_test_user(
+            cls.env, login="dms-manager", groups="dms.group_dms_manager"
         )
-        self.access_group = self.access_group_model.create(
+        cls.access_group = cls.access_group_model.create(
             {
                 "name": "Test",
                 "perm_create": True,
                 "perm_write": True,
                 "perm_unlink": True,
                 "explicit_user_ids": [
-                    (6, 0, [self.dms_user.id, self.dms_manager_user.id])
+                    (6, 0, [cls.dms_user.id, cls.dms_manager_user.id])
                 ],
             }
         )
 
-    def _setup_test_data(self):
-        self.storage_model = self.storage_model.with_user(self.env.uid)
-        self.directory_model = self.directory_model.with_user(self.env.uid)
-        self.file_model = self.file_model.with_user(self.env.uid)
-        self.category_model = self.category_model.with_user(self.env.uid)
-        self.tag_model = self.tag_model.with_user(self.env.uid)
-        self.attachment_model = self.attachment_model.with_user(self.env.uid)
-
-    def _load(self, module, *args):
-        convert_file(
-            self.cr,
-            "dms",
-            get_module_resource(module, *args),
-            {},
-            "init",
-            False,
-            "test",
-            self.registry._assertion_report,
-        )
-
-    def multi_users(self, super_user=True, admin=True, demo=True):
-        return [
-            [self.super_uid, super_user],
-            [self.dms_manager_user.id, admin],
-            [self.dms_user.id, demo],
-        ]
-
-    def content_base64(self):
+    @classmethod
+    def content_base64(cls):
         return base64.b64encode(b"\xff data")
 
-    def create_storage(self, save_type="database"):
-        return self.storage_model.create(
+    @classmethod
+    def create_storage(cls, save_type="database"):
+        return cls.storage_model.create(
             {"name": "Test Storage", "save_type": save_type}
         )
 
-    def create_directory(self, storage=False, directory=False, model_id=False):
-        record = Form(self.directory_model)
+    @classmethod
+    def create_directory(cls, storage=False, directory=False, model_id=False):
+        record = Form(cls.directory_model)
         record.name = uuid.uuid4().hex
         record.is_root_directory = True
         if model_id and storage.save_type == "attachment":
@@ -241,71 +135,78 @@ def create_directory(self, storage=False, directory=False, model_id=False):
         else:
             record.storage_id = storage
             if not storage.inherit_access_from_parent_record:
-                record.group_ids.add(self.access_group)
+                record.group_ids.add(cls.access_group)
         return record.save()
 
-    def create_file(self, directory=False, content=False):
-        record = Form(self.file_model)
+    @classmethod
+    def create_file(cls, directory=False, content=False):
+        record = Form(cls.file_model)
         record.name = uuid.uuid4().hex
         record.directory_id = directory
-        record.content = content or self.content_base64()
+        record.content = content or cls.content_base64()
         return record.save()
 
-    def create_attachment(self, name, res_model=False, res_id=False, content=False):
-        return self.attachment_model.create(
+    @classmethod
+    def create_attachment(cls, name, res_model=False, res_id=False, content=False):
+        return cls.attachment_model.create(
             {
                 "name": name,
                 "res_model": res_model,
                 "res_id": res_id,
-                "datas": content or self.content_base64(),
+                "datas": content or cls.content_base64(),
             }
         )
 
 
 class StorageAttachmentBaseCase(DocumentsBaseCase):
-    def setUp(self):
-        super().setUp()
-        self.storage = self.create_storage(save_type="attachment")
-        self.storage.write(
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.storage = cls.create_storage(save_type="attachment")
+        cls.storage.write(
             {
                 "inherit_access_from_parent_record": True,
                 "include_message_attachments": True,
-                "model_ids": [(6, 0, [self.env.ref("base.model_res_partner").id])],
+                "model_ids": [(6, 0, [cls.env.ref("base.model_res_partner").id])],
             }
         )
-        self.partner_model_id = self.env.ref("base.model_res_partner")
-        self.create_directory(storage=self.storage, model_id=self.partner_model_id)
-        self.partner = self.partner_model.create({"name": "test partner"})
-        self.model_partner = self.env.ref("base.model_res_partner")
-
-    def _create_attachment(self, name):
-        return self.create_attachment(
+        cls.partner_model_id = cls.env.ref("base.model_res_partner")
+        cls.create_directory(storage=cls.storage, model_id=cls.partner_model_id)
+        cls.partner = cls.partner_model.create({"name": "test partner"})
+        cls.model_partner = cls.env.ref("base.model_res_partner")
+
+    @classmethod
+    def _create_attachment(cls, name):
+        return cls.create_attachment(
             name=name,
-            res_model=self.partner_model._name,
-            res_id=self.partner.id,
+            res_model=cls.partner_model._name,
+            res_id=cls.partner.id,
         )
 
-    def _get_partner_directory(self):
-        return self.directory_model.search(
+    @classmethod
+    def _get_partner_directory(cls):
+        return cls.directory_model.search(
             [
-                ("storage_id", "=", self.storage.id),
-                ("res_model", "=", self.partner_model._name),
-                ("res_id", "=", self.partner.id),
+                ("storage_id", "=", cls.storage.id),
+                ("res_model", "=", cls.partner_model._name),
+                ("res_id", "=", cls.partner.id),
             ]
         )
 
 
 class StorageDatabaseBaseCase(DocumentsBaseCase):
-    def setUp(self):
-        super().setUp()
-        self.storage = self.create_storage(save_type="database")
-        self.directory = self.create_directory(storage=self.storage)
-        self.file = self.create_file(directory=self.directory)
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.storage = cls.create_storage(save_type="database")
+        cls.directory = cls.create_directory(storage=cls.storage)
+        cls.file = cls.create_file(directory=cls.directory)
 
 
 class StorageFileBaseCase(DocumentsBaseCase):
-    def setUp(self):
-        super().setUp()
-        self.storage = self.create_storage(save_type="file")
-        self.directory = self.create_directory(storage=self.storage)
-        self.file = self.create_file(directory=self.directory)
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.storage = cls.create_storage(save_type="file")
+        cls.directory = cls.create_directory(storage=cls.storage)
+        cls.file = cls.create_file(directory=cls.directory)

dms/tests/test_benchmark.py

@@ -20,7 +20,7 @@
 class BenchmarkTestCase(common.TransactionCase):
     @classmethod
     def setUpClass(cls):
-        super(BenchmarkTestCase, cls).setUpClass()
+        super().setUpClass()
         cls._clean_existing_records()
         cls._setup_benchmark_data()
 

dms/tests/test_directory.py

@@ -14,12 +14,13 @@
 _path = os.path.dirname(os.path.dirname(__file__))
 
 
-class DirectoryTestCase(StorageDatabaseBaseCase):
-    def setUp(self):
-        super().setUp()
-        self.subdirectory = self.create_directory(directory=self.directory)
-        self.file.directory_id = self.subdirectory
-        self.new_storage = self.create_storage(save_type="database")
+class DirectoryTestCaseBase(StorageDatabaseBaseCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.subdirectory = cls.create_directory(directory=cls.directory)
+        cls.file.directory_id = cls.subdirectory
+        cls.new_storage = cls.create_storage(save_type="database")
 
     @users("dms-manager", "dms-user")
     def test_create_directory(self):
@@ -102,6 +103,7 @@ def test_move_directory(self):
             )
 
     @users("dms-manager", "dms-user")
+    @mute_logger("odoo.models.unlink")
     def test_unlink_root_directory(self):
         root_directory = self.create_directory(storage=self.storage)
         sub_directory = self.create_directory(directory=root_directory)
@@ -111,6 +113,7 @@ def test_unlink_root_directory(self):
         self.assertFalse(sub_files.exists())
 
     @users("dms-manager", "dms-user")
+    @mute_logger("odoo.models.unlink")
     def test_unlink_directory(self):
         root_directory = self.create_directory(storage=self.storage)
         sub_directory = self.create_directory(directory=root_directory)
@@ -186,7 +189,7 @@ def test_search_panel(self):
         self.assertTrue(self.directory_model.search_panel_select_multi_range("tag_ids"))
 
 
-class DirectoryMailTestCase(DirectoryTestCase):
+class DirectoryMailTestCase(StorageDatabaseBaseCase):
     def setUp(self):
         super().setUp()
         self.params = self.env["ir.config_parameter"].sudo()