add test on decorator and processor error management

hapic/decorator.py

 
 
 class OutputControllerWrapper(ControllerWrapper):
+    def __init__(
+        self,
+        context: ContextInterface,
+        processor: ProcessorInterface,
+        error_http_code: HTTPStatus=HTTPStatus.INTERNAL_SERVER_ERROR,
+        default_http_code: HTTPStatus=HTTPStatus.OK,
+    ) -> None:
+        self.context = context
+        self.processor = processor
+        self.error_http_code = error_http_code
+        self.default_http_code = default_http_code
+
     def get_error_response(
         self,
         response: typing.Any,

hapic/processor.py

 
 class MarshmallowOutputProcessor(OutputProcessor):
     def process(self, data: typing.Any):
-        unmarshall = self.schema.dump(data)
-        # TODO: Il n'y a jamais rien dans le error au dump. il faut check le
-        # data au travers de .validate
-        if unmarshall.errors:
-            raise InputValidationException(
+        data = self.schema.dump(data).data
+        self.validate(data)
+        return data
+
+    def validate(self, data: typing.Any) -> None:
+        errors = self.schema.load(data).errors
+        if errors:
+            raise OutputValidationException(
                 'Error when validate input: {}'.format(
-                    str(unmarshall.errors),
+                    str(errors),
                 )
             )
 
-        return unmarshall.data
-
     def get_validation_error(self, data: dict) -> ProcessValidationError:
-        marshmallow_errors = self.schema.dump(data).errors
+        data = self.schema.dump(data).data
+        errors = self.schema.load(data).errors
         return ProcessValidationError(
             error_message='Validation error of output data',
-            error_details=marshmallow_errors,
+            error_details=errors,
         )
 
 

tests/unit/test_decorator.py

 import typing
 from http import HTTPStatus
 
+import marshmallow
+
 from hapic.context import ContextInterface
 from hapic.data import HapicData
 from hapic.decorator import ControllerWrapper
 from hapic.decorator import InputControllerWrapper
 from hapic.decorator import OutputControllerWrapper
 from hapic.processor import RequestParameters
+from hapic.processor import MarshmallowOutputProcessor
 from hapic.processor import ProcessValidationError
 from hapic.processor import ProcessorInterface
 from tests.base import Base
         hapic_data.query = processed_data
 
 
+class MySchema(marshmallow.Schema):
+    name = marshmallow.fields.String(required=True)
+
+
 class TestControllerWrapper(Base):
     def test_unit__base_controller_wrapper__ok__no_behaviour(self):
         context = MyContext()
                    'http_code': HTTPStatus.OK,
                    'original_response': 43,
                } == result
+
+    def test_unit__output_data_wrapping__fail__error_response(self):
+        context = MyContext()
+        processor = MarshmallowOutputProcessor()
+        processor.schema = MySchema()
+        wrapper = OutputControllerWrapper(context, processor)
+
+        @wrapper.get_wrapper
+        def func(foo):
+            return 'wrong result format'
+
+        result = func(42)
+        # see MyProcessor#process
+        assert isinstance(result, dict)
+        assert 'http_code' in result
+        assert result['http_code'] == HTTPStatus.INTERNAL_SERVER_ERROR
+        assert 'original_error' in result
+        assert result['original_error'].error_details == {
+            'name': ['Missing data for required field.']
+        }

tests/unit/test_processor.py

         assert data == tested_data
 
     def test_unit__marshmallow_output_processor__ok__missing_data(self):
-        """
-        Important note: Actually marshmallow don't validate when deserialize.
-        But we think about make it possible:
-        https://github.com/marshmallow-code/marshmallow/issues/684
-        """
         processor = MarshmallowOutputProcessor()
         processor.schema = MySchema()
 
             'last_name': 'Turing',
         }
 
-        data = processor.process(tested_data)
-        assert {
-            'last_name': 'Turing',
-        } == data
+        with pytest.raises(OutputValidationException):
+            processor.process(tested_data)
 
     def test_unit__marshmallow_input_processor__ok__process_success(self):
         processor = MarshmallowInputProcessor()