Use HandledException class instead tuple

hapic/context.py

         raise NotImplementedError()
 
 
+class HandledException(object):
+    """
+    Representation of an handled exception with it's http code
+    """
+    def __init__(
+        self,
+        exception_class: typing.Type[Exception],
+        http_code: int = 500,
+    ):
+        self.exception_class = exception_class
+        self.http_code = http_code
+
+
 class BaseContext(ContextInterface):
     def get_default_error_builder(self) -> ErrorBuilderInterface:
         """ see hapic.context.ContextInterface#get_default_error_builder"""
             except Exception as exc:
                 # Reverse list to read first user given exception before
                 # the hapic default Exception catch
-                handled = reversed(
+                handled_exceptions = reversed(
                     self._get_handled_exception_class_and_http_codes(),
                 )
-                for handled_exception_class, http_code in handled:
+                for handled_exception in handled_exceptions:
                     # TODO BS 2018-05-04: How to be attentive to hierarchy ?
-                    if isinstance(exc, handled_exception_class):
+                    if isinstance(exc, handled_exception.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,
+                            handled_exception.http_code,
                         )
                 raise exc
 
 
     def _get_handled_exception_class_and_http_codes(
         self,
-    ) -> typing.List[typing.Tuple[typing.Type[Exception], int]]:
+    ) -> typing.List[HandledException]:
         """
         :return: A list of tuple where: thirst item of tuple is a exception
         class and second tuple item is a http code. This list will be used by

hapic/ext/bottle/context.py

 from multidict import MultiDict
 
 from hapic.context import BaseContext
+from hapic.context import HandledException
 from hapic.context import RouteRepresentation
 from hapic.decorator import DecoratedController
 from hapic.decorator import DECORATION_ATTRIBUTE_NAME
         app: bottle.Bottle,
         default_error_builder: ErrorBuilderInterface=None,
     ):
-        self._handled_exception_and_http_codes = []  # type: typing.List[typing.Tuple[typing.Type[Exception], int]]  # nopep8
+        self._handled_exceptions = []  # type: typing.List[HandledException]  # nopep8
         self._exceptions_handler_installed = False
         self.app = app
         self.default_error_builder = \
         if not self._exceptions_handler_installed:
             self._install_exceptions_handler()
 
-        self._handled_exception_and_http_codes.append(
-            (exception_class, http_code),
+        self._handled_exceptions.append(
+            HandledException(exception_class, http_code),
         )
 
     def _install_exceptions_handler(self) -> None:
 
     def _get_handled_exception_class_and_http_codes(
         self,
-    ) -> typing.List[typing.Tuple[typing.Type[Exception], int]]:
+    ) -> typing.List[HandledException]:
         """
         See hapic.context.BaseContext#_get_handled_exception_class_and_http_codes  # nopep8
         """
-        return self._handled_exception_and_http_codes
+        return self._handled_exceptions

hapic/ext/flask/context.py

         app: Flask,
         default_error_builder: ErrorBuilderInterface=None,
     ):
-        self._handled_exception_and_http_codes = []  # type: typing.List[typing.Tuple[typing.Type[Exception], int]]  # nopep8
+        self._handled_exceptions = []  # type: typing.List[HandledException]  # nopep8
         self.app = app
         self.default_error_builder = \
             default_error_builder or DefaultErrorBuilder()  # FDV
         exception_class: typing.Type[Exception],
         http_code: int,
     ) -> None:
-        self._handled_exception_and_http_codes.append(
-            (exception_class, http_code),
-        )
-
+        raise NotImplementedError('TODO')

hapic/ext/pyramid/context.py

         configurator: 'Configurator',
         default_error_builder: ErrorBuilderInterface = None,
     ):
-        self._handled_exception_and_http_codes = []  # type: typing.List[typing.Tuple[typing.Type[Exception], int]]  # nopep8
+        self._handled_exceptions = []  # type: typing.List[HandledException]  # nopep8
         self.configurator = configurator
         self.default_error_builder = \
             default_error_builder or DefaultErrorBuilder()  # FDV
         exception_class: typing.Type[Exception],
         http_code: int,
     ) -> None:
-        self._handled_exception_and_http_codes.append(
-            (exception_class, http_code),
-        )
+        raise NotImplementedError('TODO')

tests/base.py

 # -*- coding: utf-8 -*-
 import json
 import typing
+
+
 try:  # Python 3.5+
     from http import HTTPStatus
 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
 from hapic.processor import ProcessValidationError
+from hapic.context import HandledException
 
 
 class Base(object):
         fake_files_parameters=None,
     ) -> None:
         super().__init__(app=app)
-        self._handled_exception_and_http_codes = []  # type: typing.List[typing.Tuple[typing.Type[Exception], int]]  # nopep8
+        self._handled_exceptions = []  # type: typing.List[HandledException]  # nopep8
         self._exceptions_handler_installed = False
         self.fake_path_parameters = fake_path_parameters or {}
         self.fake_query_parameters = fake_query_parameters or MultiDict()
     ) -> None:
         if not self._exceptions_handler_installed:
             self._install_exceptions_handler()
-        self._handled_exception_and_http_codes.append(
-            (exception_class, http_code),
+        self._handled_exceptions.append(
+            HandledException(exception_class, http_code),
         )
 
     def _get_handled_exception_class_and_http_codes(
         self,
-    ) -> typing.List[typing.Tuple[typing.Type[Exception], int]]:
-        return self._handled_exception_and_http_codes
+    ) -> typing.List[HandledException]:
+        return self._handled_exceptions