[FIX] edi_*_oca: New way for FakeModelLoader

Author: Ricardoalso

edi_component_oca/tests/test_edi_configuration.py

@@ -40,66 +40,64 @@ def setUpClass(cls):
 
     def setUp(self):
         super().setUp()
-        FakeOutputGenerator.reset_faked()
-        FakeOutputSender.reset_faked()
-        FakeOutputChecker.reset_faked()
-        self.consumer_record = self.env["edi.exchange.consumer.test"].create(
-            {
-                "name": "Test Consumer",
-                "edi_config_ids": [
-                    (4, self.create_config.id),
-                    (4, self.write_config.id),
-                ],
-            }
-        )
-
-    @classmethod
-    def _setup_records(cls):  # pylint:disable=missing-return
-        super()._setup_records()
-        # Load fake models ->/
-        cls.loader = FakeModelLoader(cls.env, cls.__module__)
-        cls.loader.backup_registry()
+        self.loader = FakeModelLoader(self.env, self.__module__)
+        self.loader.backup_registry()
         from odoo.addons.edi_core_oca.tests.fake_models import EdiExchangeConsumerTest
 
         EdiExchangeConsumerTest._edi_config_field_relation = lambda self: self.env[
             "edi.configuration"
         ]
-        # We need to override it, as we want to test the usage with components
+        self.loader.update_registry((EdiExchangeConsumerTest,))
 
-        cls.loader.update_registry((EdiExchangeConsumerTest,))
-        cls.exchange_type_out.exchange_filename_pattern = "{record.id}"
-        cls.edi_configuration = cls.env["edi.configuration"]
-        cls.create_config = cls.edi_configuration.create(
+        FakeOutputGenerator.reset_faked()
+        FakeOutputSender.reset_faked()
+        FakeOutputChecker.reset_faked()
+
+        self.create_config = self.env["edi.configuration"].create(
             {
                 "name": "Create Config",
                 "active": True,
-                "backend_id": cls.backend.id,
-                "type_id": cls.exchange_type_out.id,
-                "trigger_id": cls.env.ref(
+                "backend_id": self.backend.id,
+                "type_id": self.exchange_type_out.id,
+                "trigger_id": self.env.ref(
                     "edi_core_oca.edi_conf_trigger_record_create"
                 ).id,
-                "model_id": cls.env["ir.model"]._get_id("edi.exchange.consumer.test"),
+                "model_id": self.env["ir.model"]._get_id("edi.exchange.consumer.test"),
                 "snippet_do": "record._edi_send_via_edi(conf.type_id)",
             }
         )
-        cls.write_config = cls.edi_configuration.create(
+        self.write_config = self.env["edi.configuration"].create(
             {
                 "name": "Write Config 1",
                 "active": True,
-                "backend_id": cls.backend.id,
-                "type_id": cls.exchange_type_out.id,
-                "trigger_id": cls.env.ref(
+                "backend_id": self.backend.id,
+                "type_id": self.exchange_type_out.id,
+                "trigger_id": self.env.ref(
                     "edi_core_oca.edi_conf_trigger_record_write"
                 ).id,
-                "model_id": cls.env["ir.model"]._get_id("edi.exchange.consumer.test"),
+                "model_id": self.env["ir.model"]._get_id("edi.exchange.consumer.test"),
                 "snippet_do": "record._edi_send_via_edi(conf.type_id)",
             }
         )
 
+        self.consumer_record = self.env["edi.exchange.consumer.test"].create(
+            {
+                "name": "Test Consumer",
+                "edi_config_ids": [
+                    (4, self.create_config.id),
+                    (4, self.write_config.id),
+                ],
+            }
+        )
+
     @classmethod
-    def tearDownClass(cls):
-        cls.loader.restore_registry()
-        super().tearDownClass()
+    def _setup_records(cls):  # pylint:disable=missing-return
+        super()._setup_records()
+        cls.exchange_type_out.exchange_filename_pattern = "{record.id}"
+
+    def tearDown(self):
+        self.loader.restore_registry()
+        super().tearDown()
 
     def test_edi_send_via_edi_config(self):
         # Check configuration on create

edi_core_oca/tests/test_backend_base.py

@@ -11,25 +11,22 @@
 
 
 class EDIBackendTestCaseBase(EDIBackendCommonTestCase):
-    @classmethod
-    def _setup_records(cls):  # pylint:disable=missing-return
-        super()._setup_records()
-        # Load fake models ->/
-        cls.loader = FakeModelLoader(cls.env, cls.__module__)
-        cls.loader.backup_registry()
+    def setUp(self):
+        super().setUp()
+        self.loader = FakeModelLoader(self.env, self.__module__)
+        self.loader.backup_registry()
         from .fake_models import EdiTestExecution
 
-        cls.loader.update_registry((EdiTestExecution,))
-        cls.ExecutionAbstractModel = cls.env["edi.framework.test.execution"]
-        cls.model = cls.env["ir.model"]._get("edi.framework.test.execution")
-        cls.exchange_type_in.receive_model_id = cls.model
-        cls.exchange_type_in.process_model_id = cls.model
-        cls.exchange_type_in.input_validate_model_id = cls.model
+        self.loader.update_registry((EdiTestExecution,))
+        self.ExecutionAbstractModel = self.env["edi.framework.test.execution"]
+        self.model = self.env["ir.model"]._get("edi.framework.test.execution")
+        self.exchange_type_in.receive_model_id = self.model
+        self.exchange_type_in.process_model_id = self.model
+        self.exchange_type_in.input_validate_model_id = self.model
 
-    @classmethod
-    def tearDownClass(cls):
-        cls.loader.restore_registry()
-        super().tearDownClass()
+    def tearDown(self):
+        self.loader.restore_registry()
+        super().tearDown()
 
     @freeze_time("2020-10-21 10:00:00")
     def test_create_record(self):

edi_core_oca/tests/test_backend_input.py

@@ -8,37 +8,6 @@
 
 
 class EDIBackendTestInputCase(EDIBackendCommonTestCase):
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        vals = {
-            "model": cls.partner._name,
-            "res_id": cls.partner.id,
-        }
-        cls.record = cls.backend.create_record("test_csv_input", vals)
-
-    @classmethod
-    def _setup_records(cls):  # pylint:disable=missing-return
-        super()._setup_records()
-        # Load fake models ->/
-        cls.loader = FakeModelLoader(cls.env, cls.__module__)
-        cls.loader.backup_registry()
-        from .fake_models import EdiTestExecution
-
-        cls.loader.update_registry((EdiTestExecution,))
-        cls.ExecutionAbstractModel = cls.env["edi.framework.test.execution"]
-        cls.model = cls.env["ir.model"].search(
-            [("model", "=", "edi.framework.test.execution")]
-        )
-        cls.exchange_type_in.receive_model_id = cls.model
-        cls.exchange_type_in.process_model_id = cls.model
-        cls.exchange_type_in.input_validate_model_id = cls.model
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.loader.restore_registry()
-        super().tearDownClass()
-
     @classmethod
     def _setup_context(cls):
         return dict(
@@ -49,8 +18,29 @@ def _setup_context(cls):
 
     def setUp(self):
         super().setUp()
+        self.loader = FakeModelLoader(self.env, self.__module__)
+        self.loader.backup_registry()
+        from .fake_models import EdiTestExecution
+
+        self.loader.update_registry((EdiTestExecution,))
+        self.ExecutionAbstractModel = self.env["edi.framework.test.execution"]
+        self.model = self.env["ir.model"].search(
+            [("model", "=", "edi.framework.test.execution")]
+        )
+        self.exchange_type_in.receive_model_id = self.model
+        self.exchange_type_in.process_model_id = self.model
+        self.exchange_type_in.input_validate_model_id = self.model
+        vals = {
+            "model": self.partner._name,
+            "res_id": self.partner.id,
+        }
+        self.record = self.backend.create_record("test_csv_input", vals)
         self.ExecutionAbstractModel.reset_faked("receive")
 
+    def tearDown(self):
+        self.loader.restore_registry()
+        super().tearDown()
+
     def test_receive_record_nothing_todo(self):
         self.backend.with_context(fake_output="yeah!").exchange_receive(self.record)
         self.assertEqual(self.record._get_file_content(), "")

edi_core_oca/tests/test_backend_output.py

@@ -15,44 +15,33 @@
 
 
 class EDIBackendTestOutputCase(EDIBackendCommonTestCase):
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-
-        vals = {
-            "model": cls.partner._name,
-            "res_id": cls.partner.id,
-        }
-        cls.record = cls.backend.create_record("test_csv_output", vals)
-
-    @classmethod
-    def _setup_records(cls):  # pylint:disable=missing-return
-        super()._setup_records()
-        # Load fake models ->/
-        cls.loader = FakeModelLoader(cls.env, cls.__module__)
-        cls.loader.backup_registry()
+    def setUp(self):
+        super().setUp()
+        self.loader = FakeModelLoader(self.env, self.__module__)
+        self.loader.backup_registry()
         from .fake_models import EdiTestExecution
 
-        cls.loader.update_registry((EdiTestExecution,))
-        cls.ExecutionAbstractModel = cls.env["edi.framework.test.execution"]
-        cls.model = cls.env["ir.model"].search(
+        self.loader.update_registry((EdiTestExecution,))
+        self.ExecutionAbstractModel = self.env["edi.framework.test.execution"]
+        self.model = self.env["ir.model"].search(
             [("model", "=", "edi.framework.test.execution")]
         )
-        cls.exchange_type_out.generate_model_id = cls.model
-        cls.exchange_type_out.send_model_id = cls.model
-        cls.exchange_type_out.output_validate_model_id = cls.model
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.loader.restore_registry()
-        super().tearDownClass()
-
-    def setUp(self):
-        super().setUp()
+        self.exchange_type_out.generate_model_id = self.model
+        self.exchange_type_out.send_model_id = self.model
+        self.exchange_type_out.output_validate_model_id = self.model
+        vals = {
+            "model": self.partner._name,
+            "res_id": self.partner.id,
+        }
+        self.record = self.backend.create_record("test_csv_output", vals)
         self.ExecutionAbstractModel.reset_faked("generate")
         self.ExecutionAbstractModel.reset_faked("send")
         self.ExecutionAbstractModel.reset_faked("check")
 
+    def tearDown(self):
+        self.loader.restore_registry()
+        super().tearDown()
+
     def test_generate_record_output(self):
         self.record.with_context(fake_output="yeah!").action_exchange_generate()
         self.assertEqual(self.record._get_file_content(), "yeah!")

edi_core_oca/tests/test_backend_process.py

@@ -15,42 +15,32 @@
 
 
 class EDIBackendTestProcessCase(EDIBackendCommonTestCase):
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        vals = {
-            "model": cls.partner._name,
-            "res_id": cls.partner.id,
-            "exchange_file": base64.b64encode(b"1234"),
-        }
-        cls.record = cls.backend.create_record("test_csv_input", vals)
-
-    @classmethod
-    def _setup_records(cls):  # pylint:disable=missing-return
-        super()._setup_records()
-        # Load fake models ->/
-        cls.loader = FakeModelLoader(cls.env, cls.__module__)
-        cls.loader.backup_registry()
+    def setUp(self):
+        super().setUp()
+        self.loader = FakeModelLoader(self.env, self.__module__)
+        self.loader.backup_registry()
         from .fake_models import EdiTestExecution
 
-        cls.loader.update_registry((EdiTestExecution,))
-        cls.ExecutionAbstractModel = cls.env["edi.framework.test.execution"]
-        cls.model = cls.env["ir.model"].search(
+        self.loader.update_registry((EdiTestExecution,))
+        self.ExecutionAbstractModel = self.env["edi.framework.test.execution"]
+        self.model = self.env["ir.model"].search(
             [("model", "=", "edi.framework.test.execution")]
         )
-        cls.exchange_type_in.generate_model_id = cls.model
-        cls.exchange_type_in.process_model_id = cls.model
-        cls.exchange_type_in.input_validate_model_id = cls.model
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.loader.restore_registry()
-        super().tearDownClass()
-
-    def setUp(self):
-        super().setUp()
+        self.exchange_type_in.generate_model_id = self.model
+        self.exchange_type_in.process_model_id = self.model
+        self.exchange_type_in.input_validate_model_id = self.model
+        vals = {
+            "model": self.partner._name,
+            "res_id": self.partner.id,
+            "exchange_file": base64.b64encode(b"1234"),
+        }
+        self.record = self.backend.create_record("test_csv_input", vals)
         self.ExecutionAbstractModel.reset_faked("process")
 
+    def tearDown(self):
+        self.loader.restore_registry()
+        super().tearDown()
+
     def test_process_record(self):
         self.record.write({"edi_exchange_state": "input_received"})
         with freeze_time("2020-10-22 10:00:00"):