Merge branch 'develop' into feature/global_exception_handler_for_pyramid

hapic/context.py

         """
         raise NotImplementedError()
 
+    def is_debug(self) -> bool:
+        """
+        Method called to know if Hapic has been called in debug mode.
+        Debug mode provide some informations like debug trace and error
+        message in body when internal error happen.
+        :return: True if in debug mode
+        """
+        raise NotImplementedError()
+
 
 class HandledException(object):
     """

hapic/decorator.py

                 func_kwargs,
             )
         except self.handled_exception_class as exc:
-            response_content = self.error_builder.build_from_exception(exc)
+            response_content = self.error_builder.build_from_exception(
+                exc,
+                include_traceback=self.context.is_debug(),
+            )
 
             # Check error format
             dumped = self.error_builder.dump(response_content).data

hapic/error.py

 # -*- coding: utf-8 -*-
+import traceback
+
 import marshmallow
 
 from hapic.processor import ProcessValidationError
     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:
+    def build_from_exception(
+        self,
+        exception: Exception,
+        include_traceback: bool = False,
+    ) -> dict:
         """
         Build the error response content from given exception
         :param exception: Original exception who invoke this method
     details = marshmallow.fields.Dict(required=False, missing={})
     code = marshmallow.fields.Raw(missing=None)
 
-    def build_from_exception(self, exception: Exception) -> dict:
+    def build_from_exception(
+        self,
+        exception: Exception,
+        include_traceback: bool = False,
+    ) -> dict:
         """
         See hapic.error.ErrorBuilderInterface#build_from_exception docstring
         """
         # TODO: "error_detail" attribute name should be configurable
+        message = str(exception)
+        if not message:
+            message = type(exception).__name__
+
+        details = {
+            'error_detail': getattr(exception, 'error_detail', {}),
+        }
+        if include_traceback:
+            details['traceback'] = traceback.format_exc()
+
         return {
-            'message': str(exception),
-            'details': getattr(exception, 'error_detail', {}),
+            'message': message,
+            'details': details,
             'code': None,
         }
 

hapic/ext/bottle/context.py

         self,
         app: bottle.Bottle,
         default_error_builder: ErrorBuilderInterface=None,
+        debug: bool = False,
     ):
         self._handled_exceptions = []  # type: typing.List[HandledException]  # nopep8
         self._exceptions_handler_installed = False
         self.app = app
         self.default_error_builder = \
             default_error_builder or DefaultErrorBuilder()  # FDV
+        self.debug = debug
 
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
         path_parameters = dict(bottle.request.url_args)
         See hapic.context.BaseContext#_get_handled_exception_class_and_http_codes  # nopep8
         """
         return self._handled_exceptions
+
+    def is_debug(self) -> bool:
+        return self.debug

hapic/ext/flask/context.py

         self,
         app: Flask,
         default_error_builder: ErrorBuilderInterface=None,
+        debug: bool = False,
     ):
         self._handled_exceptions = []  # type: typing.List[HandledException]  # nopep8
         self.app = app
         self.default_error_builder = \
             default_error_builder or DefaultErrorBuilder()  # FDV
+        self.debug = debug
 
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
         from flask import request
         http_code: int,
     ) -> None:
         raise NotImplementedError('TODO')
+
+    def is_debug(self) -> bool:
+        return self.debug

hapic/ext/pyramid/context.py

         self,
         configurator: 'Configurator',
         default_error_builder: ErrorBuilderInterface = None,
+        debug: bool = False,
     ):
         self._handled_exceptions = []  # type: typing.List[HandledException]  # nopep8
         self.configurator = configurator
         self.default_error_builder = \
             default_error_builder or DefaultErrorBuilder()  # FDV
+        self.debug = debug
 
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
         req = args[-1]  # TODO : Check
         exception_class: typing.Type[Exception],
         http_code: int,
     ) -> None:
-
         def factory_view_func(exception_class, http_code):
             def view_func(exc, request):
                 # TODO BS 2018-05-04: How to be attentive to hierarchy ?
             context=exception_class,
         )
 
+        raise NotImplementedError('TODO')
+
+    def is_debug(self) -> bool:
+        return self.debug

tests/unit/test_decorator.py

         response = func(42)
         assert HTTPStatus.INTERNAL_SERVER_ERROR == response.status_code
         assert {
-                   'details': {},
+                   'details': {'error_detail': {}},
                    'message': 'We are testing',
                    'code': None,
                } == json.loads(response.body)
         assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR
         assert {
             'message': 'We are testing',
-            'details': {'foo': 'bar'},
+            'details': {'error_detail': {'foo': 'bar'}},
             'code': None,
         } == json.loads(response.body)
 
             pass
 
         class MyErrorBuilder(DefaultErrorBuilder):
-            def build_from_exception(self, exception: Exception) -> dict:
+            def build_from_exception(
+                self,
+                exception: Exception,
+                include_traceback: bool = False,
+            ) -> dict:
                 # this is not matching with DefaultErrorBuilder schema
                 return {}