[FIX] base_rest*: Translate validation exception

Before this change, the translation method didn't have access to the environement to kwow the target language. We now use the mtranslation method on the env linked to the service to translate the exceptions

Author: lmignon

base_rest/restapi.py

@@ -7,7 +7,7 @@
 
 from cerberus import Validator
 
-from odoo import _, http
+from odoo import http
 from odoo.exceptions import UserError, ValidationError
 
 from .tools import ROUTING_DECORATOR_ATTR, cerberus_to_json
@@ -218,13 +218,13 @@ def from_params(self, service, params):
         validator = self.get_cerberus_validator(service, "input")
         if validator.validate(params):
             return validator.document
-        raise UserError(_("BadRequest %s") % validator.errors)
+        raise UserError(service.env._("BadRequest %s") % validator.errors)
 
     def to_response(self, service, result):
         validator = self.get_cerberus_validator(service, "output")
         if validator.validate(result):
             return validator.document
-        raise SystemError(_("Invalid Response %s") % validator.errors)
+        raise SystemError(service.env._("Invalid Response %s") % validator.errors)
 
     def to_openapi_query_parameters(self, service, spec):
         json_schema = self.to_json_schema(service, spec, "input")
@@ -275,7 +275,9 @@ def get_cerberus_validator(self, service, direction):
             return schema
         if isinstance(schema, dict):
             return Validator(schema, purge_unknown=True)
-        raise Exception(_("Unable to get cerberus schema from %s") % self._schema)
+        raise Exception(
+            service.env._("Unable to get cerberus schema from %s") % self._schema
+        )
 
     def to_json_schema(self, service, spec, direction):
         schema = self.get_cerberus_validator(service, direction).schema
@@ -321,7 +323,7 @@ def _do_validate(self, service, data, direction):
         for idx, p in enumerate(data):
             if not validator.validate(p):
                 raise ExceptionClass(
-                    _(
+                    service.env._(
                         "BadRequest item %(idx)s :%(errors)s",
                         idx=idx,
                         errors=validator.errors,
@@ -330,7 +332,7 @@ def _do_validate(self, service, data, direction):
             values.append(validator.document)
         if self._min_items is not None and len(values) < self._min_items:
             raise ExceptionClass(
-                _(
+                service.env._(
                     "BadRequest: Not enough items in the list (%(current)s "
                     "< %(expected)s)",
                     current=len(values),
@@ -339,7 +341,7 @@ def _do_validate(self, service, data, direction):
             )
         if self._max_items is not None and len(values) > self._max_items:
             raise ExceptionClass(
-                _(
+                service.env._(
                     "BadRequest: Too many items in the list (%(current)s "
                     "> %(expected)s)",
                     current=len(values),
@@ -367,7 +369,7 @@ def __init__(self, parts):
         :param parts:  list of RestMethodParam
         """
         if not isinstance(parts, dict):
-            raise ValidationError(_("You must provide a dict of RestMethodParam"))
+            raise RuntimeError("You must provide a dict of RestMethodParam")
         self._parts = parts
 
     def to_openapi_properties(self, service, spec, direction):
@@ -410,7 +412,7 @@ def from_params(self, service, params):
                     )  # multipart ony sends its parts as string
                 except json.JSONDecodeError as error:
                     raise ValidationError(
-                        _(f"{key}'s JSON content is malformed: {error}")
+                        service.env._(f"{key}'s JSON content is malformed: {error}")
                     ) from error
                 param = part.from_params(service, json_param)
             params[key] = param

base_rest/tests/test_cerberus_list_validator.py

@@ -1,19 +1,18 @@
 # Copyright 2020 ACSONE SA/NV
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
 
-import logging
 import unittest
 
 from cerberus import Validator
 
 from odoo.exceptions import UserError
-from odoo.tests.common import BaseCase, MetaCase
+from odoo.tests.common import TransactionCase
 
 from ..components.cerberus_validator import BaseRestCerberusValidator
 from ..restapi import CerberusListValidator
 
 
-class TestCerberusListValidator(BaseCase, MetaCase("DummyCase", (object,), {})):
+class TestCerberusListValidator(TransactionCase):
     """Test all the methods that must be implemented by CerberusListValidator to
     be a valid RestMethodParam"""
 
@@ -47,18 +46,8 @@ def setUpClass(cls):
             schema=cls.nested_schema
         )
         cls.maxDiff = None
-
-    def setUp(self):
-        super().setUp()
-        # mute logger
-        loggers = ["odoo.tools.translate"]
-        for logger in loggers:
-            logging.getLogger(logger).addFilter(self)
-
-        @self.addCleanup
-        def un_mute_logger():
-            for logger_ in loggers:
-                logging.getLogger(logger_).removeFilter(self)
+        cls.mock_service = unittest.mock.Mock()
+        cls.mock_service.env = cls.env
 
     def filter(self, record):
         # required to mute logger
@@ -203,15 +192,18 @@ def test_from_params_validation(self):
         # minItems / maxItems
         with self.assertRaises(UserError):
             # minItems = 1
-            self.simple_schema_list_validator.from_params(None, params=[])
+            self.simple_schema_list_validator.from_params(self.mock_service, params=[])
         with self.assertRaises(UserError):
             # maxItems = 2
             self.simple_schema_list_validator.from_params(
-                None, params=[{"name": "test"}, {"name": "test"}, {"name": "test"}]
+                self.mock_service,
+                params=[{"name": "test"}, {"name": "test"}, {"name": "test"}],
             )
         with self.assertRaises(UserError):
             # name required
-            self.simple_schema_list_validator.from_params(None, params=[{}])
+            self.simple_schema_list_validator.from_params(
+                self.mock_service, params=[{}]
+            )
 
     def test_to_response_ignore_unknown(self):
         result = [{"name": "test", "unknown": True}]
@@ -223,15 +215,18 @@ def test_to_response_validation(self):
         # as a programmatic error not a user error
         with self.assertRaises(SystemError):
             # minItems = 1
-            self.simple_schema_list_validator.to_response(None, result=[])
+            self.simple_schema_list_validator.to_response(self.mock_service, result=[])
         with self.assertRaises(SystemError):
             # maxItems = 2
             self.simple_schema_list_validator.to_response(
-                None, result=[{"name": "test"}, {"name": "test"}, {"name": "test"}]
+                self.mock_service,
+                result=[{"name": "test"}, {"name": "test"}, {"name": "test"}],
             )
         with self.assertRaises(SystemError):
             # name required
-            self.simple_schema_list_validator.to_response(None, result=[{}])
+            self.simple_schema_list_validator.to_response(
+                self.mock_service, result=[{}]
+            )
 
     def test_schema_lookup_from_string(self):
         class MyService:

base_rest/tests/test_cerberus_validator.py

@@ -1,20 +1,19 @@
 # Copyright 2020 ACSONE SA/NV
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
 
-import logging
 import unittest
 
 from cerberus import Validator
 
 from odoo.exceptions import UserError
-from odoo.tests.common import BaseCase, MetaCase
+from odoo.tests.common import TransactionCase
 
 from ..components.cerberus_validator import BaseRestCerberusValidator
 from ..restapi import CerberusValidator
 from ..tools import cerberus_to_json
 
 
-class TestCerberusValidator(BaseCase, MetaCase("DummyCase", (object,), {})):
+class TestCerberusValidator(TransactionCase):
     """Test all the methods that must be implemented by CerberusValidator to
     be a valid RestMethodParam"""
 
@@ -50,22 +49,8 @@ def setUpClass(cls):
         cls.nested_schema_cerberus_validator = CerberusValidator(
             schema=cls.nested_schema
         )
-
-    def setUp(self):
-        super().setUp()
-        # mute logger
-        loggers = ["odoo.tools.translate"]
-        for logger in loggers:
-            logging.getLogger(logger).addFilter(self)
-
-        @self.addCleanup
-        def un_mute_logger():
-            for logger_ in loggers:
-                logging.getLogger(logger_).removeFilter(self)
-
-    def filter(self, record):
-        # required to mute logger
-        return 0
+        cls.mock_service = unittest.mock.Mock()
+        cls.mock_service.env = cls.env
 
     def test_to_openapi_responses(self):
         res = self.simple_schema_cerberus_validator.to_openapi_responses(None, None)
@@ -271,7 +256,9 @@ def test_from_params_ignore_unknown(self):
     def test_from_params_validation(self):
         # name is required
         with self.assertRaises(UserError):
-            self.simple_schema_cerberus_validator.from_params(None, params={})
+            self.simple_schema_cerberus_validator.from_params(
+                self.mock_service, params={}
+            )
 
     def test_to_response_add_default(self):
         result = {"name": "test"}
@@ -288,7 +275,9 @@ def test_to_response_validation(self):
         # If a response is not conform to the expected schema it's considered
         # as a programmatic error not a user error
         with self.assertRaises(SystemError):
-            self.simple_schema_cerberus_validator.to_response(None, result={})
+            self.simple_schema_cerberus_validator.to_response(
+                self.mock_service, result={}
+            )
 
     def test_schema_lookup_from_string(self):
         class MyService:

base_rest_pydantic/restapi.py

@@ -2,7 +2,6 @@
 # License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
 import json
 
-from odoo import _
 from odoo.exceptions import UserError
 
 from odoo.addons.base_rest import restapi
@@ -41,7 +40,7 @@ def from_params(self, service, params):
         try:
             return self._model_cls(**params)
         except ValidationError as ve:
-            raise UserError(_("BadRequest %s") % ve.json(indent=0)) from ve
+            raise UserError(service.env._("BadRequest %s") % ve.json(indent=0)) from ve
 
     def to_response(self, service, result):
         # do we really need to validate the instance????
@@ -58,7 +57,7 @@ def to_response(self, service, result):
         try:
             self._model_cls.model_validate_json(to_validate_jsonified)
         except ValidationError as validation_error:
-            raise SystemError(_("Invalid Response")) from validation_error
+            raise SystemError(service.env._("Invalid Response")) from validation_error
         return json_dict
 
     def to_openapi_query_parameters(self, servic, spec):
@@ -154,14 +153,14 @@ def __init__(
         self._unique_items = unique_items
 
     def from_params(self, service, params):
-        self._do_validate(params, "input")
+        self._do_validate(service, params, "input")
         return [
             super(PydanticModelList, self).from_params(service, param)
             for param in params
         ]
 
     def to_response(self, service, result):
-        self._do_validate(result, "output")
+        self._do_validate(service, result, "output")
         return [
             super(PydanticModelList, self).to_response(service=service, result=r)
             for r in result
@@ -170,11 +169,11 @@ def to_response(self, service, result):
     def to_openapi_query_parameters(self, service, spec):
         raise NotImplementedError("List are not (?yet?) supported as query paramters")
 
-    def _do_validate(self, values, direction):
+    def _do_validate(self, service, values, direction):
         ExceptionClass = UserError if direction == "input" else SystemError
         if self._min_items is not None and len(values) < self._min_items:
             raise ExceptionClass(
-                _(
+                service.env._(
                     (
                         "BadRequest: Not enough items in the list (%(current)s < "
                         "%(expected)s)"
@@ -185,7 +184,7 @@ def _do_validate(self, values, direction):
             )
         if self._max_items is not None and len(values) > self._max_items:
             raise ExceptionClass(
-                _(
+                service.env._(
                     (
                         "BadRequest: Too many items in the list (%(current)s > "
                         "%(expected)s)"