Start introduce to hapic global exception handling

hapic/context.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import json
 import typing
 
 from hapic.error import ErrorBuilderInterface
@@ -106,8 +107,80 @@ class ContextInterface(object):
         """
         raise NotImplementedError()
 
+    def handle_exception(
+        self,
+        exception_class: typing.Type[Exception],
+        http_code: int,
+    ) -> None:
+        raise NotImplementedError()
+
+    def handle_exceptions(
+        self,
+        exception_classes: typing.List[typing.Type[Exception]],
+        http_code: int,
+    ) -> None:
+        raise NotImplementedError()
+
+    def _add_exception_class_to_catch(
+        self,
+        exception_class: typing.List[typing.Type[Exception]],
+        http_code: int,
+    ) -> None:
+        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
+
+    def handle_exception(
+        self,
+        exception_class: typing.Type[Exception],
+        http_code: int,
+    ) -> None:
+        self._add_exception_class_to_catch(exception_class, http_code)
+
+    def handle_exceptions(
+        self,
+        exception_classes: typing.List[typing.Type[Exception]],
+        http_code: int,
+    ) -> None:
+        for exception_class in exception_classes:
+            self._add_exception_class_to_catch(exception_class, http_code)
+
+    def handle_exceptions_decorator_builder(
+        self,
+        func: typing.Callable[..., typing.Any],
+    ) -> typing.Callable[..., typing.Any]:
+        def decorator(*args, **kwargs):
+            try:
+                return func(*args, **kwargs)
+            except Exception as exc:
+                # Reverse list to read first user given exception before
+                # the hapic default Exception catch
+                handled = reversed(self._get_handled_exception_classes())
+                for handled_exception_class, http_code in handled:
+                    # TODO BS 2018-05-04: How to be attentive to hierarchy ?
+                    if isinstance(exc, handled_exception_class):
+                        error_builder = self.get_default_error_builder()
+                        error_body = error_builder.build_from_exception(exc)
+                        return self.get_response(
+                            json.dumps(error_body),
+                            http_code,
+                        )
+                raise exc
+
+        return decorator
+
+    def _get_handled_exception_classes(
+        self,
+    ) -> typing.List[typing.Tuple[typing.Type[Exception], int]]:
+        raise NotImplementedError()
+
+    def _add_exception_class_to_catch(
+        self,
+        exception_class: typing.Type[Exception],
+        http_code: int,
+    ) -> None:
+        raise NotImplementedError()

hapic/ext/bottle/context.py

@@ -33,6 +33,7 @@ class BottleContext(BaseContext):
         app: bottle.Bottle,
         default_error_builder: ErrorBuilderInterface=None,
     ):
+        self._handled_exceptions = []  # type: typing.List[typing.Tuple[typing.Type[Exception], int]]  # nopep8
         self.app = app
         self.default_error_builder = \
             default_error_builder or DefaultErrorBuilder()  # FDV
@@ -134,3 +135,13 @@ class BottleContext(BaseContext):
         if isinstance(response, bottle.HTTPResponse):
             return True
         return False
+
+    def _add_exception_class_to_catch(
+        self,
+        exception_class: typing.Type[Exception],
+        http_code: int,
+    ) -> None:
+        self._handled_exceptions.append((exception_class, http_code))
+
+    def _install_exceptions_handler(self) -> None:
+        self.app.install(self.handle_exceptions_decorator_builder)

hapic/ext/flask/context.py

@@ -33,6 +33,7 @@ class FlaskContext(BaseContext):
         app: Flask,
         default_error_builder: ErrorBuilderInterface=None,
     ):
+        self._handled_exceptions = []  # type: typing.List[typing.Tuple[typing.Type[Exception], int]]  # nopep8
         self.app = app
         self.default_error_builder = \
             default_error_builder or DefaultErrorBuilder()  # FDV
@@ -157,3 +158,11 @@ class FlaskContext(BaseContext):
         )
         def api_doc(path):
             return send_from_directory(directory_path, path)
+
+    def _add_exception_class_to_catch(
+        self,
+        exception_class: typing.Type[Exception],
+        http_code: int,
+    ) -> None:
+        self._handled_exceptions.append((exception_class, http_code))
+

hapic/ext/pyramid/context.py

@@ -32,6 +32,7 @@ class PyramidContext(BaseContext):
         configurator: 'Configurator',
         default_error_builder: ErrorBuilderInterface = None,
     ):
+        self._handled_exceptions = []  # type: typing.List[typing.Tuple[typing.Type[Exception], int]]  # nopep8
         self.configurator = configurator
         self.default_error_builder = \
             default_error_builder or DefaultErrorBuilder()  # FDV
@@ -181,3 +182,10 @@ class PyramidContext(BaseContext):
             name=route_prefix,
             path=directory_path,
         )
+
+    def _add_exception_class_to_catch(
+        self,
+        exception_class: typing.Type[Exception],
+        http_code: int,
+    ) -> None:
+        self._handled_exceptions.append((exception_class, http_code))

tests/base.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+import json
 import typing
 try:  # Python 3.5+
     from http import HTTPStatus
@@ -6,6 +7,7 @@ except ImportError:
     from http import client as HTTPStatus
 
 from multidict import MultiDict
+import bottle
 
 from hapic.ext.bottle import BottleContext
 from hapic.processor import RequestParameters
@@ -29,6 +31,8 @@ class MyContext(BottleContext):
         fake_files_parameters=None,
     ) -> None:
         super().__init__(app=app)
+        self._handled_exceptions = []  # type: typing.List[typing.Tuple[typing.Type[Exception], int]]  # nopep8
+        self._exceptions_handler_installed = False
         self.fake_path_parameters = fake_path_parameters or {}
         self.fake_query_parameters = fake_query_parameters or MultiDict()
         self.fake_body_parameters = fake_body_parameters or {}
@@ -46,23 +50,32 @@ class MyContext(BottleContext):
             files_parameters=self.fake_files_parameters,
         )
 
-    def get_response(
-        self,
-        response: str,
-        http_code: int,
-        mimetype: str='application/json',
-    ) -> typing.Any:
-        return {
-            'original_response': response,
-            'http_code': http_code,
-        }
-
     def get_validation_error_response(
         self,
         error: ProcessValidationError,
         http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
     ) -> typing.Any:
-        return {
-            'original_error': error,
-            'http_code': http_code,
-        }
+        return self.get_response(
+            response=json.dumps({
+                'original_error': {
+                    'details': error.details,
+                    'message': error.message,
+                },
+                'http_code': http_code,
+            }),
+            http_code=http_code,
+        )
+
+    def _add_exception_class_to_catch(
+        self,
+        exception_class: typing.Type[Exception],
+        http_code: int,
+    ) -> None:
+        if not self._exceptions_handler_installed:
+            self._install_exceptions_handler()
+        self._handled_exceptions.append((exception_class, http_code))
+
+    def _get_handled_exception_classes(
+        self,
+    ) -> typing.List[typing.Tuple[typing.Type[Exception], int]]:
+        return self._handled_exceptions

tests/func/test_exception_handling.py

@@ -0,0 +1,27 @@
+# coding: utf-8
+import bottle
+from webtest import TestApp
+
+from hapic import Hapic
+from tests.base import Base
+from tests.base import MyContext
+
+
+class TestExceptionHandling(Base):
+    def test_func__catch_one_exception__ok__nominal_case(self):
+        hapic = Hapic()
+        # TODO BS 2018-05-04: Make this test non-bottle
+        app = bottle.Bottle()
+        context = MyContext(app=app)
+        hapic.set_context(context)
+
+        def my_view():
+            raise ZeroDivisionError('An exception message')
+
+        app.route('/my-view', method='GET', callback=my_view)
+        context.handle_exception(ZeroDivisionError, http_code=400)
+
+        test_app = TestApp(app)
+        response = test_app.get('/my-view', status='*')
+
+        assert 400 == response.status_code

tests/func/test_marshmallow_decoration.py

@@ -1,4 +1,6 @@
 # coding: utf-8
+import json
+
 try:  # Python 3.5+
     from http import HTTPStatus
 except ImportError:
@@ -52,11 +54,16 @@ class TestMarshmallowDecoration(Base):
             return 'OK'
 
         result = my_controller()
-        assert 'http_code' in result
-        assert HTTPStatus.BAD_REQUEST == result['http_code']
+        assert HTTPStatus.BAD_REQUEST == result.status_code
         assert {
-                   'file_abc': ['Missing data for required field.']
-               } == result['original_error'].details
+                    'http_code': 400,
+                    'original_error': {
+                        'details': {
+                            'file_abc': ['Missing data for required field.']
+                        },
+                        'message': 'Validation error of input data'
+                    }
+               } == json.loads(result.body)
 
     def test_unit__input_files__ok__file_is_empty_string(self):
         hapic = Hapic()
@@ -77,6 +84,13 @@ class TestMarshmallowDecoration(Base):
             return 'OK'
 
         result = my_controller()
-        assert 'http_code' in result
-        assert HTTPStatus.BAD_REQUEST == result['http_code']
-        assert {'file_abc': ['Missing data for required field']} == result['original_error'].details
+        assert HTTPStatus.BAD_REQUEST == result.status_code
+        assert {
+                    'http_code': 400,
+                    'original_error': {
+                        'details': {
+                            'file_abc': ['Missing data for required field']
+                        },
+                        'message': 'Validation error of input data'
+                    }
+               } == json.loads(result.body)

tests/unit/test_decorator.py

@@ -233,11 +233,8 @@ class TestOutputControllerWrapper(Base):
             return foo
 
         result = func(42)
-        # see MyProcessor#process
-        assert {
-                   'http_code': HTTPStatus.OK,
-                   'original_response': '43',
-               } == result
+        assert HTTPStatus.OK == result.status_code
+        assert '43' == result.body
 
     def test_unit__output_data_wrapping__fail__error_response(self):
         context = MyContext(app=None)
@@ -250,6 +247,7 @@ class TestOutputControllerWrapper(Base):
             return 'wrong result format'
 
         result = func(42)
+        assert HTTPStatus.INTERNAL_SERVER_ERROR == result.status_code
         # see MyProcessor#process
         assert isinstance(result, dict)
         assert 'http_code' in result
@@ -305,14 +303,12 @@ class TestExceptionHandlerControllerWrapper(Base):
             raise exc
 
         response = func(42)
-        assert 'http_code' in response
-        assert response['http_code'] == HTTPStatus.INTERNAL_SERVER_ERROR
-        assert 'original_response' in response
-        assert json.loads(response['original_response']) == {
+        assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
+        assert {
             'message': 'We are testing',
             'details': {'foo': 'bar'},
             'code': None,
-        }
+        } == json.loads(response.body)
 
     def test_unit__exception_handler__error__error_content_malformed(self):
         class MyException(Exception):