Initial commit: OCA Technical packages (595 packages)

odoo-bringout-oca-rest-framework-datamodel/datamodel/tests/common.py

@@ -0,0 +1,185 @@
+# Copyright 2017 Camptocamp SA
+# Copyright 2019 ACSONE SA/NV
+# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html)
+
+import copy
+from contextlib import contextmanager
+
+import odoo
+from odoo import api
+from odoo.tests import common
+
+from ..core import (
+    DatamodelRegistry,
+    MetaDatamodel,
+    _datamodel_databases,
+    _get_addon_name,
+)
+
+
+@contextmanager
+def new_rollbacked_env():
+    registry = odoo.registry(common.get_db_name())
+    uid = odoo.SUPERUSER_ID
+    cr = registry.cursor()
+    try:
+        yield api.Environment(cr, uid, {})
+    finally:
+        cr.rollback()  # we shouldn't have to commit anything
+        cr.close()
+
+
+class DatamodelMixin(object):
+    @classmethod
+    def setUpDatamodel(cls):
+        with new_rollbacked_env() as env:
+            builder = env["datamodel.builder"]
+            # build the datamodels of every installed addons
+            datamodel_registry = builder._init_global_registry()
+            cls._datamodels_registry = datamodel_registry
+            # ensure that we load only the datamodels of the 'installed'
+            # modules, not 'to install', which means we load only the
+            # dependencies of the tested addons, not the siblings or
+            # chilren addons
+            builder.build_registry(datamodel_registry, states=("installed",))
+            # build the datamodels of the current tested addon
+            current_addon = _get_addon_name(cls.__module__)
+            env["datamodel.builder"].load_datamodels(current_addon)
+
+    # pylint: disable=W8106
+    def setUp(self):
+        # should be ready only during tests, never during installation
+        # of addons
+        self._datamodels_registry.ready = True
+
+        @self.addCleanup
+        def notready():
+            self._datamodels_registry.ready = False
+
+
+class TransactionDatamodelCase(common.TransactionCase, DatamodelMixin):
+    """A TransactionCase that loads all the datamodels
+
+    It is used like an usual Odoo's TransactionCase, but it ensures
+    that all the datamodels of the current addon and its dependencies
+    are loaded.
+
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.setUpDatamodel()
+
+    # pylint: disable=W8106
+    def setUp(self):
+        # resolve an inheritance issue (common.TransactionCase does not call
+        # super)
+        common.TransactionCase.setUp(self)
+        DatamodelMixin.setUp(self)
+
+
+class DatamodelRegistryCase(
+    common.BaseCase, common.MetaCase("DummyCase", (object,), {})
+):
+    """This test case can be used as a base for writings tests on datamodels
+
+    This test case is meant to test datamodels in a special datamodel registry,
+    where you want to have maximum control on which datamodels are loaded
+    or not, or when you want to create additional datamodels in your tests.
+
+    If you only want to *use* the datamodels of the tested addon in your tests,
+    then consider using:
+
+    * :class:`TransactionDatamodelCase`
+
+    This test case creates a special
+    :class:`odoo.addons.datamodel.core.DatamodelRegistry` for the purpose of
+    the tests. By default, it loads all the datamodels of the dependencies, but
+    not the datamodels of the current addon (which you have to handle
+    manually). In your tests, you can add more datamodels in 2 manners.
+
+    All the datamodels of an Odoo module::
+
+        self._load_module_datamodels('connector')
+
+    Only specific datamodels::
+
+        self._build_datamodels(MyDatamodel1, MyDatamodel2)
+
+    Note: for the lookups of the datamodels, the default datamodel
+    registry is a global registry for the database. Here, you will
+    need to explicitly pass ``self.datamodel_registry`` in the
+    """
+
+    def setUp(self):
+        super().setUp()
+        # keep the original classes registered by the metaclass
+        # so we'll restore them at the end of the tests, it avoid
+        # to pollute it with Stub / Test datamodels
+        self._original_datamodels = copy.deepcopy(MetaDatamodel._modules_datamodels)
+
+        # it will be our temporary datamodel registry for our test session
+        self.datamodel_registry = DatamodelRegistry()
+
+        # it builds the 'final datamodel' for every datamodel of the
+        # 'datamodel' addon and push them in the datamodel registry
+        self.datamodel_registry.load_datamodels("datamodel")
+        # build the datamodels of every installed addons already installed
+        # but the current addon (when running with pytest/nosetest, we
+        # simulate the --test-enable behavior by excluding the current addon
+        # which is in 'to install' / 'to upgrade' with --test-enable).
+        current_addon = _get_addon_name(self.__module__)
+
+        registry = odoo.registry(common.get_db_name())
+        uid = odoo.SUPERUSER_ID
+        cr = registry.cursor()
+        env = api.Environment(cr, uid, {})
+        env["datamodel.builder"].build_registry(
+            self.datamodel_registry,
+            states=("installed",),
+            exclude_addons=[current_addon],
+        )
+        self.env = env
+        _datamodel_databases[self.env.cr.dbname] = self.datamodel_registry
+
+        @self.addCleanup
+        def _close_and_roolback():
+            cr.rollback()  # we shouldn't have to commit anything
+            cr.close()
+
+        # Fake that we are ready to work with the registry
+        # normally, it is set to True and the end of the build
+        # of the datamodels. Here, we'll add datamodels later in
+        # the datamodels registry, but we don't mind for the tests.
+        self.datamodel_registry.ready = True
+
+    def tearDown(self):
+        super().tearDown()
+        # restore the original metaclass' classes
+        MetaDatamodel._modules_datamodels = self._original_datamodels
+
+    def _load_module_datamodels(self, module):
+        self.datamodel_registry.load_datamodels(module)
+
+    def _build_datamodels(self, *classes):
+        for cls in classes:
+            cls._build_datamodel(self.datamodel_registry)
+
+
+class TransactionDatamodelRegistryCase(common.TransactionCase, DatamodelRegistryCase):
+    """Adds Odoo Transaction in the base Datamodel TestCase"""
+
+    # pylint: disable=W8106
+    @classmethod
+    def setUpClass(cls):
+        # resolve an inheritance issue (common.TransactionCase does not use
+        # super)
+        common.TransactionCase.setUpClass(cls)
+        DatamodelRegistryCase.setUp(cls)
+        cls.collection = cls.env["collection.base"]
+
+    @classmethod
+    def tearDownClass(cls):
+        common.TransactionCase.tearDownClass(cls)
+        DatamodelRegistryCase.tearDown(cls)