diff --git a/dms/tests/common.py b/dms/tests/common.py index 969e1d168..7aebd1065 100644 --- a/dms/tests/common.py +++ b/dms/tests/common.py @@ -1,21 +1,18 @@ # 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__) # ---------------------------------------------------------- @@ -23,75 +20,6 @@ # ---------------------------------------------------------- -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) diff --git a/dms/tests/test_benchmark.py b/dms/tests/test_benchmark.py index 8ef6a9c7b..8092fdd17 100644 --- a/dms/tests/test_benchmark.py +++ b/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() diff --git a/dms/tests/test_directory.py b/dms/tests/test_directory.py index 78e957fa1..005118cd3 100644 --- a/dms/tests/test_directory.py +++ b/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() diff --git a/dms/tests/test_file.py b/dms/tests/test_file.py index 52f59d70e..036df385e 100644 --- a/dms/tests/test_file.py +++ b/dms/tests/test_file.py @@ -17,22 +17,21 @@ class FileFilestoreTestCase(StorageFileBaseCase): - def setUp(self): - super().setUp() - self.user_a = new_test_user( - self.env, login="user-a", groups="dms.group_dms_user" - ) - self.group_a = self.access_group_model.create( + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.user_a = new_test_user(cls.env, login="user-a", groups="dms.group_dms_user") + cls.group_a = cls.access_group_model.create( { "name": "Group A", "perm_create": True, - "explicit_user_ids": [(6, 0, [self.user_a.id])], + "explicit_user_ids": [(6, 0, [cls.user_a.id])], } ) - self.directory_group_a = self.create_directory(storage=self.storage) - self.directory_group_a.group_ids = [(4, self.group_a.id)] - self.sub_directory_x = self.create_directory(directory=self.directory_group_a) - self.file2 = self.create_file(directory=self.sub_directory_x) + cls.directory_group_a = cls.create_directory(storage=cls.storage) + cls.directory_group_a.group_ids = [(4, cls.group_a.id)] + cls.sub_directory_x = cls.create_directory(directory=cls.directory_group_a) + cls.file2 = cls.create_file(directory=cls.sub_directory_x) @users("user-a") def test_file_access(self): diff --git a/dms/tests/test_file_database.py b/dms/tests/test_file_database.py index b53c0bf98..851080b6d 100644 --- a/dms/tests/test_file_database.py +++ b/dms/tests/test_file_database.py @@ -5,17 +5,19 @@ from odoo.exceptions import UserError from odoo.tests.common import users +from odoo.tools import mute_logger from .common import StorageDatabaseBaseCase class FileDatabaseTestCase(StorageDatabaseBaseCase): - def setUp(self): - super().setUp() - self.file_demo_01 = self.env.ref("dms.file_01_demo") - self.directory2 = self.create_directory(storage=self.storage) - self.new_storage2 = self.create_storage(save_type="database") - self.directory3 = self.create_directory(storage=self.new_storage2) + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.file_demo_01 = cls.env.ref("dms.file_01_demo") + cls.directory2 = cls.create_directory(storage=cls.storage) + cls.new_storage2 = cls.create_storage(save_type="database") + cls.directory3 = cls.create_directory(storage=cls.new_storage2) @users("dms-manager", "dms-user") def test_create_file(self): @@ -66,6 +68,7 @@ def test_move_directory(self): ) @users("dms-manager", "dms-user") + @mute_logger("odoo.models.unlink") def test_unlink_file(self): file = self.create_file(directory=self.directory) file.unlink() diff --git a/dms/tests/test_portal.py b/dms/tests/test_portal.py index 077b49687..f3f5f2e6f 100644 --- a/dms/tests/test_portal.py +++ b/dms/tests/test_portal.py @@ -9,14 +9,15 @@ @odoo.tests.tagged("post_install", "-at_install") class TestDmsPortal(odoo.tests.HttpCase, StorageAttachmentBaseCase): - def setUp(self): - super().setUp() - self.partner = self.env.ref("base.partner_demo_portal") - self.portal_user = self.partner.user_ids - self.portal_user.login = "portal" - self._create_attachment("test.txt") - self.directory_partner = self._get_partner_directory() - self.file_partner = self.directory_partner.file_ids[0] + @classmethod + def setUpClass(cls): + super().setUpClass() + cls.partner = cls.env.ref("base.partner_demo_portal") + cls.portal_user = cls.partner.user_ids + cls.portal_user.login = "portal" + cls._create_attachment("test.txt") + cls.directory_partner = cls._get_partner_directory() + cls.file_partner = cls.directory_partner.file_ids[0] def test_access_portal(self): self.authenticate("portal", "portal") diff --git a/dms/tests/test_storage_attachment.py b/dms/tests/test_storage_attachment.py index 576c7dc17..8677cc443 100644 --- a/dms/tests/test_storage_attachment.py +++ b/dms/tests/test_storage_attachment.py @@ -3,12 +3,14 @@ # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl). from odoo.tests.common import users +from odoo.tools import mute_logger from .common import StorageAttachmentBaseCase class StorageAttachmentTestCase(StorageAttachmentBaseCase): @users("dms-manager") + @mute_logger("odoo.models.unlink") def test_storage_attachment(self): self._create_attachment("demo.txt") self.assertTrue( diff --git a/dms/tests/test_storage_database.py b/dms/tests/test_storage_database.py index 4cfc45ef7..4915a8639 100644 --- a/dms/tests/test_storage_database.py +++ b/dms/tests/test_storage_database.py @@ -4,6 +4,7 @@ # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl). from odoo.tests.common import users +from odoo.tools import mute_logger from .common import StorageDatabaseBaseCase @@ -22,6 +23,7 @@ def test_count_storage_files(self): self.assertTrue(self.storage.count_storage_files) @users("dms-manager") + @mute_logger("odoo.models.unlink") def test_file_migrate(self): root_directory = self.storage.root_directory_ids.filtered( lambda x: x.is_root_directory