validation error use now the error builder

hapic/context.py

 # -*- coding: utf-8 -*-
 import typing
+
+from hapic.error import ErrorBuilderInterface
+
 try:  # Python 3.5+
     from http import HTTPStatus
 except ImportError:
         :return:
         """
         raise NotImplementedError()
+
+    def get_default_error_builder(self) -> ErrorBuilderInterface:
+        """
+        Return a ErrorBuilder who will be used to build default errors
+        :return: ErrorBuilderInterface instance
+        """
+        raise NotImplementedError()
+
+
+class BaseContext(ContextInterface):
+    def get_default_error_builder(self) -> ErrorBuilderInterface:
+        """ see hapic.context.ContextInterface#get_default_error_builder"""
+        return self.default_error_builder

hapic/decorator.py

 except ImportError:
     from http import client as HTTPStatus
 
-# TODO BS 20171010: bottle specific !  # see #5
-import marshmallow
 from multidict import MultiDict
-
 from hapic.data import HapicData
 from hapic.description import ControllerDescription
 from hapic.exception import ProcessException
+from hapic.exception import OutputValidationException
 from hapic.context import ContextInterface
 from hapic.processor import ProcessorInterface
 from hapic.processor import RequestParameters
+from hapic.error import ErrorBuilderInterface
 
 # TODO: Ensure usage of DECORATION_ATTRIBUTE_NAME is documented and
 # var names correctly choose.  see #6
         self,
         handled_exception_class: typing.Type[Exception],
         context: typing.Union[ContextInterface, typing.Callable[[], ContextInterface]],  # nopep8
-        schema: marshmallow.Schema,
+        error_builder: typing.Union[ErrorBuilderInterface, typing.Callable[[], ErrorBuilderInterface]],  # nopep8
         http_code: HTTPStatus=HTTPStatus.INTERNAL_SERVER_ERROR,
     ) -> None:
         self.handled_exception_class = handled_exception_class
         self._context = context
         self.http_code = http_code
-        self.schema = schema
+        self._error_builder = error_builder
 
     @property
     def context(self) -> ContextInterface:
             return self._context()
         return self._context
 
+    @property
+    def error_builder(self) -> ErrorBuilderInterface:
+        if callable(self._error_builder):
+            return self._error_builder()
+        return self._error_builder
+
     def _execute_wrapped_function(
         self,
         func,
                 func_kwargs,
             )
         except self.handled_exception_class as exc:
-            # TODO: "error_detail" attribute name should be configurable
-            # TODO BS 20171013: use overrideable mechanism, error object given
-            #  to schema ? see #15
-            raw_response = {
-                'message': str(exc),
-                'code': None,
-                'detail': getattr(exc, 'error_detail', {}),
-            }
+            response_content = self.error_builder.build_from_exception(exc)
+
+            # Check error format
+            dumped = self.error_builder.dump(response_content).data
+            unmarshall = self.error_builder.load(dumped)
+            if unmarshall.errors:
+                raise OutputValidationException(
+                    'Validation error during dump of error response: {}'
+                    .format(
+                        str(unmarshall.errors)
+                    )
+                )
 
             error_response = self.context.get_response(
-                raw_response,
+                response_content,
                 self.http_code,
             )
             return error_response

hapic/error.py

+# -*- coding: utf-8 -*-
+import marshmallow
+
+from hapic.processor import ProcessValidationError
+
+
+class ErrorBuilderInterface(marshmallow.Schema):
+    """
+    ErrorBuilder is a class who represent a Schema (marshmallow.Schema) and
+    can generate a response content from exception (build_from_exception)
+    """
+    def build_from_exception(self, exception: Exception) -> dict:
+        """
+        Build the error response content from given exception
+        :param exception: Original exception who invoke this method
+        :return: a dict representing the error response content
+        """
+        raise NotImplementedError()
+
+    def build_from_validation_error(
+        self,
+        error: ProcessValidationError,
+    ) -> dict:
+        """
+        Build the error response content from given process validation error
+        :param error: Original ProcessValidationError who invoke this method
+        :return: a dict representing the error response content
+        """
+        raise NotImplementedError()
+
+
+class DefaultErrorBuilder(ErrorBuilderInterface):
+    message = marshmallow.fields.String(required=True)
+    details = marshmallow.fields.Dict(required=False, missing={})
+    code = marshmallow.fields.Raw(missing=None)
+
+    def build_from_exception(self, exception: Exception) -> dict:
+        """
+        See hapic.error.ErrorBuilderInterface#build_from_exception docstring
+        """
+        # TODO: "error_detail" attribute name should be configurable
+        return {
+            'message': str(exception),
+            'details': getattr(exception, 'error_detail', {}),
+            'code': None,
+        }
+
+    def build_from_validation_error(
+        self,
+        error: ProcessValidationError,
+    ) -> dict:
+        """
+        See hapic.error.ErrorBuilderInterface#build_from_validation_error
+        docstring
+        """
+        return {
+            'message': error.message,
+            'details': error.details,
+            'code': None,
+        }

hapic/ext/bottle/context.py

 import json
 import re
 import typing
+
 try:  # Python 3.5+
     from http import HTTPStatus
 except ImportError:
 import bottle
 from multidict import MultiDict
 
-from hapic.context import ContextInterface
+from hapic.context import BaseContext
 from hapic.context import RouteRepresentation
 from hapic.decorator import DecoratedController
 from hapic.decorator import DECORATION_ATTRIBUTE_NAME
 from hapic.exception import RouteNotFound
 from hapic.processor import RequestParameters
 from hapic.processor import ProcessValidationError
+from hapic.error import DefaultErrorBuilder
+from hapic.error import ErrorBuilderInterface
 
 # Bottle regular expression to locate url parameters
 BOTTLE_RE_PATH_URL = re.compile(r'<([^:<>]+)(?::[^<>]+)?>')
 
 
-class BottleContext(ContextInterface):
-    def __init__(self, app: bottle.Bottle):
+class BottleContext(BaseContext):
+    def __init__(
+        self,
+        app: bottle.Bottle,
+        default_error_builder: ErrorBuilderInterface=None,
+    ):
         self.app = app
+        self.default_error_builder = \
+            default_error_builder or DefaultErrorBuilder()  # FDV
 
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
         path_parameters = dict(bottle.request.url_args)
         error: ProcessValidationError,
         http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
     ) -> typing.Any:
-        # TODO BS 20171010: Manage error schemas, see #4
-        from hapic.hapic import _default_global_error_schema
-        unmarshall = _default_global_error_schema.dump(error)
+        error_content = self.default_error_builder.build_from_validation_error(
+            error,
+        )
+
+        # Check error
+        dumped = self.default_error_builder.dump(error).data
+        unmarshall = self.default_error_builder.load(dumped)
         if unmarshall.errors:
             raise OutputValidationException(
                 'Validation error during dump of error response: {}'.format(
             )
 
         return bottle.HTTPResponse(
-            body=json.dumps(unmarshall.data),
+            body=json.dumps(error_content),
             headers=[
                 ('Content-Type', 'application/json'),
             ],

hapic/ext/flask/context.py

 import json
 import re
 import typing
+
 try:  # Python 3.5+
     from http import HTTPStatus
 except ImportError:
     from http import client as HTTPStatus
 
-from hapic.context import ContextInterface
+from hapic.context import BaseContext
 from hapic.context import RouteRepresentation
 from hapic.decorator import DecoratedController
 from hapic.decorator import DECORATION_ATTRIBUTE_NAME
 from hapic.exception import OutputValidationException
-from hapic.processor import RequestParameters, ProcessValidationError
+from hapic.processor import RequestParameters
+from hapic.processor import ProcessValidationError
+from hapic.error import DefaultErrorBuilder
+from hapic.error import ErrorBuilderInterface
 from flask import Flask
 
 if typing.TYPE_CHECKING:
 FLASK_RE_PATH_URL = re.compile(r'<(?:[^:<>]+:)?([^<>]+)>')
 
 
-class FlaskContext(ContextInterface):
-    def __init__(self, app: Flask):
+class FlaskContext(BaseContext):
+    def __init__(
+        self,
+        app: Flask,
+        default_error_builder: ErrorBuilderInterface=None,
+    ):
         self.app = app
+        self.default_error_builder = \
+            default_error_builder or DefaultErrorBuilder()  # FDV
 
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
         from flask import request
             body_parameters=request.get_json(),  # TODO: Check
             form_parameters=request.form,
             header_parameters=request.headers,
-            files_parameters={},  # TODO: BS 20171115: Code it
+            files_parameters=request.files,
         )
 
     def get_response(
         error: ProcessValidationError,
         http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
     ) -> typing.Any:
-        # TODO BS 20171010: Manage error schemas, see #4
-        from hapic.hapic import _default_global_error_schema
-        unmarshall = _default_global_error_schema.dump(error)
+        error_content = self.default_error_builder.build_from_validation_error(
+            error,
+        )
+
+        # Check error
+        dumped = self.default_error_builder.dump(error).data
+        unmarshall = self.default_error_builder.load(dumped)
+
         if unmarshall.errors:
             raise OutputValidationException(
                 'Validation error during dump of error response: {}'.format(
             )
         from flask import Response
         return Response(
-            response=json.dumps(unmarshall.data),
+            response=json.dumps(error_content),
             mimetype='application/json',
             status=int(http_code),
         )

hapic/ext/pyramid/context.py

 import json
 import re
 import typing
+
 try:  # Python 3.5+
     from http import HTTPStatus
 except ImportError:
     from http import client as HTTPStatus
 
-from hapic.context import ContextInterface
+from hapic.context import BaseContext
 from hapic.context import RouteRepresentation
 from hapic.decorator import DecoratedController
 from hapic.decorator import DECORATION_ATTRIBUTE_NAME
 from hapic.exception import OutputValidationException
 from hapic.processor import RequestParameters
 from hapic.processor import ProcessValidationError
+from hapic.error import DefaultErrorBuilder
+from hapic.error import ErrorBuilderInterface
 
 if typing.TYPE_CHECKING:
     from pyramid.response import Response
 PYRAMID_RE_PATH_URL = re.compile(r'')
 
 
-class PyramidContext(ContextInterface):
-    def __init__(self, configurator: 'Configurator'):
+class PyramidContext(BaseContext):
+    def __init__(
+        self,
+        configurator: 'Configurator',
+        default_error_builder: ErrorBuilderInterface = None,
+    ):
         self.configurator = configurator
+        self.default_error_builder = \
+            default_error_builder or DefaultErrorBuilder()  # FDV
 
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
         req = args[-1]  # TODO : Check
         error: ProcessValidationError,
         http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
     ) -> typing.Any:
-        # TODO BS 20171010: Manage error schemas, see #4
         from pyramid.response import Response
-        from hapic.hapic import _default_global_error_schema
-        unmarshall = _default_global_error_schema.dump(error)
+
+        error_content = self.default_error_builder.build_from_validation_error(
+            error,
+        )
+
+        # Check error
+        dumped = self.default_error_builder.dump(error).data
+        unmarshall = self.default_error_builder.load(dumped)
         if unmarshall.errors:
             raise OutputValidationException(
                 'Validation error during dump of error response: {}'.format(
             )
 
         return Response(
-            body=json.dumps(unmarshall.data),
+            body=json.dumps(error_content),
             headers=[
                 ('Content-Type', 'application/json'),
             ],

hapic/hapic.py

 # -*- coding: utf-8 -*-
 import typing
 import uuid
+import functools
 try:  # Python 3.5+
     from http import HTTPStatus
 except ImportError:
     from http import client as HTTPStatus
 
-import functools
-
-import marshmallow
-
 from hapic.buffer import DecorationBuffer
 from hapic.context import ContextInterface
 from hapic.decorator import DecoratedController
 from hapic.processor import MarshmallowInputProcessor
 from hapic.processor import MarshmallowInputFilesProcessor
 from hapic.processor import MarshmallowOutputProcessor
-
-
-class ErrorResponseSchema(marshmallow.Schema):
-    message = marshmallow.fields.String(required=True)
-    details = marshmallow.fields.Dict(required=False, missing={})
-    code = marshmallow.fields.Raw(missing=None)
-
-
-_default_global_error_schema = ErrorResponseSchema()
+from hapic.error import ErrorBuilderInterface
 
 
 # TODO: Gérer les cas ou c'est une liste la réponse (items, item_nb), see #12
         self._buffer = DecorationBuffer()
         self._controllers = []  # type: typing.List[DecoratedController]
         self._context = None  # type: ContextInterface
+        self._error_builder = None  # type: ErrorBuilderInterface
         self.doc_generator = DocGenerator()
 
         # This local function will be pass to different components
         def context_getter():
             return self._context
 
+        # This local function will be pass to different components
+        # who will need error_builder but declared (like with decorator)
+        # before error_builder declaration
+        def error_builder_getter():
+            return self._context.get_default_error_builder()
+
         self._context_getter = context_getter
+        self._error_builder_getter = error_builder_getter
 
         # TODO: Permettre la surcharge des classes utilisés ci-dessous, see #14
 
 
     def handle_exception(
         self,
-        handled_exception_class: typing.Type[Exception],
+        handled_exception_class: typing.Type[Exception]=Exception,
         http_code: HTTPStatus = HTTPStatus.INTERNAL_SERVER_ERROR,
+        error_builder: ErrorBuilderInterface=None,
         context: ContextInterface = None,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
         context = context or self._context_getter
+        error_builder = error_builder or self._error_builder_getter
 
         decoration = ExceptionHandlerControllerWrapper(
             handled_exception_class,
             context,
-            # TODO BS 20171013: Permit schema overriding, see #15
-            schema=_default_global_error_schema,
+            error_builder=error_builder,
             http_code=http_code,
         )
 

tests/func/fake_api/test_bottle.py

     resp = app.post('/users/', status='*')
     assert resp.status_int == 400
     assert resp.json == {
+        'code': None,
         'details': {
             'email_address': ['Missing data for required field.'],
             'username': ['Missing data for required field.'],

tests/func/fake_api/test_flask.py

     resp = app.post('/users/', status='*')
     assert resp.status_int == 400
     assert resp.json == {
+        'code': None,
         'details': {
             'email_address': ['Missing data for required field.'],
             'username': ['Missing data for required field.'],

tests/func/fake_api/test_pyramid.py

     resp = app.post('/users/', status='*')
     assert resp.status_int == 400
     assert resp.json == {
+        'code': None,
         'details': {
             'email_address': ['Missing data for required field.'],
             'username': ['Missing data for required field.'],

tests/unit/test_decorator.py

 # -*- coding: utf-8 -*-
+import pytest
 import typing
+
+from hapic.exception import OutputValidationException
+
 try:  # Python 3.5+
     from http import HTTPStatus
 except ImportError:
 from hapic.decorator import InputControllerWrapper
 from hapic.decorator import InputOutputControllerWrapper
 from hapic.decorator import OutputControllerWrapper
-from hapic.hapic import ErrorResponseSchema
+from hapic.error import DefaultErrorBuilder
 from hapic.processor import MarshmallowOutputProcessor
 from hapic.processor import ProcessValidationError
 from hapic.processor import ProcessorInterface
         wrapper = ExceptionHandlerControllerWrapper(
             ZeroDivisionError,
             context,
-            schema=ErrorResponseSchema(),
+            error_builder=DefaultErrorBuilder(),
             http_code=HTTPStatus.INTERNAL_SERVER_ERROR,
         )
 
         assert response['original_response'] == {
             'message': 'We are testing',
             'code': None,
-            'detail': {},
+            'details': {},
         }
 
     def test_unit__exception_handled__ok__exception_error_dict(self):
         wrapper = ExceptionHandlerControllerWrapper(
             MyException,
             context,
-            schema=ErrorResponseSchema(),
+            error_builder=DefaultErrorBuilder(),
             http_code=HTTPStatus.INTERNAL_SERVER_ERROR,
         )
 
         assert response['original_response'] == {
             'message': 'We are testing',
             'code': None,
-            'detail': {'foo': 'bar'},
+            'details': {'foo': 'bar'},
         }
+
+    def test_unit__exception_handler__error__error_content_malformed(self):
+        class MyException(Exception):
+            pass
+
+        class MyErrorBuilder(DefaultErrorBuilder):
+            def build_from_exception(self, exception: Exception) -> dict:
+                # this is not matching with DefaultErrorBuilder schema
+                return {}
+
+        context = MyContext(app=None)
+        wrapper = ExceptionHandlerControllerWrapper(
+            MyException,
+            context,
+            error_builder=MyErrorBuilder(),
+        )
+
+        def raise_it():
+            raise MyException()
+
+        wrapper = wrapper.get_wrapper(raise_it)
+        with pytest.raises(OutputValidationException):
+            wrapper()