error message

example_a.py

 # -*- coding: utf-8 -*-
+from http import HTTPStatus
+
 import bottle
 import hapic
 from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema, \
 
 @hapic.with_api_doc()
 # @hapic.ext.bottle.bottle_context()
-# @hapic.error_schema(ErrorResponseSchema())
+@hapic.handle_exception(ZeroDivisionError, http_code=HTTPStatus.BAD_REQUEST)
 @hapic.input_path(HelloPathSchema())
 @hapic.output_body(HelloResponseSchema())
 def hello(name: str, hapic_data: HapicData):
+    if name == 'zero':
+        raise ZeroDivisionError('Don\'t call him zero !')
+
     return {
         'sentence': 'Hello !',
         'name': name,

hapic/__init__.py

 output_body = _hapic_default.output_body
 # with_api_doc_bis = _hapic_default.with_api_doc_bis
 generate_doc = _hapic_default.generate_doc
+handle_exception = _hapic_default.handle_exception
 
 # from hapic.hapic import with_api_doc
 # from hapic.hapic import with_api_doc_bis

hapic/decorator.py

 
 
 class ControllerWrapper(object):
-    def __init__(
-        self,
-        context: ContextInterface,
-        processor: ProcessorInterface,
-        error_http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
-        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 before_wrapped_func(
         self,
         func_args: typing.Tuple[typing.Any, ...],
             if replacement_response:
                 return replacement_response
 
-            response = func(*args, **kwargs)
+            response = self._execute_wrapped_function(func, args, kwargs)
             new_response = self.after_wrapped_function(response)
             return new_response
         return wrapper
 
+    def _execute_wrapped_function(
+        self,
+        func,
+        func_args,
+        func_kwargs,
+    ) -> typing.Any:
+        return func(*func_args, **func_kwargs)
+
 
-class InputControllerWrapper(ControllerWrapper):
+class InputOutputControllerWrapper(ControllerWrapper):
+    def __init__(
+        self,
+        context: ContextInterface,
+        processor: ProcessorInterface,
+        error_http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
+        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
+
+
+class InputControllerWrapper(InputOutputControllerWrapper):
     def before_wrapped_func(
         self,
         func_args: typing.Tuple[typing.Any, ...],
         return error_response
 
 
-class OutputControllerWrapper(ControllerWrapper):
+class OutputControllerWrapper(InputOutputControllerWrapper):
     def __init__(
         self,
         context: ContextInterface,
         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
+        super().__init__(
+            context,
+            processor,
+            error_http_code,
+            default_http_code,
+        )
 
     def get_error_response(
         self,
             request_parameters.form_parameters,
         )
         return processed_data
+
+
+class ExceptionHandlerControllerWrapper(ControllerWrapper):
+    def __init__(
+        self,
+        handled_exception_class: typing.Type[Exception],
+        context: ContextInterface,
+        http_code: HTTPStatus=HTTPStatus.INTERNAL_SERVER_ERROR,
+    ) -> None:
+        self.handled_exception_class = handled_exception_class
+        self.context = context
+        self.http_code = http_code
+
+    def _execute_wrapped_function(
+        self,
+        func,
+        func_args,
+        func_kwargs,
+    ) -> typing.Any:
+        try:
+            return super()._execute_wrapped_function(
+                func,
+                func_args,
+                func_kwargs,
+            )
+        except self.handled_exception_class as exc:
+            # TODO: error_dict configurable name
+            # TODO: Who assume error structure ? We have to rethink it
+            error_dict = {
+                'error_message': str(exc),
+            }
+            if hasattr(exc, 'error_dict'):
+                error_dict.update(exc.error_dict)
+
+            error_response = self.context.get_response(
+                error_dict,
+                self.http_code,
+            )
+            return error_response

hapic/hapic.py

 from hapic.buffer import DecorationBuffer
 from hapic.context import ContextInterface, BottleContext
 from hapic.decorator import DecoratedController
+from hapic.decorator import ExceptionHandlerControllerWrapper
 from hapic.decorator import InputBodyControllerWrapper
 from hapic.decorator import InputHeadersControllerWrapper
 from hapic.decorator import InputPathControllerWrapper
             return decoration.get_wrapper(func)
         return decorator
 
+    def handle_exception(
+        self,
+        handled_exception_class: typing.Type[Exception],
+        http_code: HTTPStatus = HTTPStatus.INTERNAL_SERVER_ERROR,
+        context: ContextInterface = None,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
+        context = context or _default_global_context
+
+        decoration = ExceptionHandlerControllerWrapper(
+            handled_exception_class,
+            context,
+            http_code,
+        )
+
+        def decorator(func):
+            self._buffer.input_forms = InputFormsDescription(decoration)
+            return decoration.get_wrapper(func)
+        return decorator
+
     def generate_doc(self, app=None):
         # TODO @Damien bottle specific code !
         app = app or bottle.default_app()

tests/unit/test_decorator.py

 
 from hapic.context import ContextInterface
 from hapic.data import HapicData
-from hapic.decorator import ControllerWrapper
+from hapic.decorator import InputOutputControllerWrapper
+from hapic.decorator import ExceptionHandlerControllerWrapper
 from hapic.decorator import InputControllerWrapper
 from hapic.decorator import OutputControllerWrapper
 from hapic.processor import RequestParameters
         )
 
 
-class MyControllerWrapper(ControllerWrapper):
+class MyControllerWrapper(InputOutputControllerWrapper):
     def before_wrapped_func(
         self,
         func_args: typing.Tuple[typing.Any, ...],
     def test_unit__base_controller_wrapper__ok__no_behaviour(self):
         context = MyContext()
         processor = MyProcessor()
-        wrapper = ControllerWrapper(context, processor)
+        wrapper = InputOutputControllerWrapper(context, processor)
 
         @wrapper.get_wrapper
         def func(foo):
         assert result['original_error'].error_details == {
             'name': ['Missing data for required field.']
         }
+
+
+class TestExceptionHandlerControllerWrapper(Base):
+    def test_unit__exception_handled__ok__nominal_case(self):
+        context = MyContext()
+        wrapper = ExceptionHandlerControllerWrapper(
+            ZeroDivisionError,
+            context,
+            http_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+        )
+
+        @wrapper.get_wrapper
+        def func(foo):
+            raise ZeroDivisionError('We are testing')
+
+        response = func(42)
+        assert 'http_code' in response
+        assert response['http_code'] == HTTPStatus.INTERNAL_SERVER_ERROR
+        assert 'original_response' in response
+        assert response['original_response'] == {
+            'error_message': 'We are testing',
+        }
+
+    def test_unit__exception_handled__ok__exception_error_dict(self):
+        class MyException(Exception):
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.error_dict = {}
+
+        context = MyContext()
+        wrapper = ExceptionHandlerControllerWrapper(
+            MyException,
+            context,
+            http_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+        )
+
+        @wrapper.get_wrapper
+        def func(foo):
+            exc = MyException('We are testing')
+            exc.error_dict = {'foo': 'bar'}
+            raise exc
+
+        response = func(42)
+        assert 'http_code' in response
+        assert response['http_code'] == HTTPStatus.INTERNAL_SERVER_ERROR
+        assert 'original_response' in response
+        assert response['original_response'] == {
+            'error_message': 'We are testing',
+            'foo': 'bar',
+        }