Use hapic error schema for alls Exception + Test 500 NoDB for login

tracim/__init__.py

 from tracim.lib.utils.authorization import TRACIM_DEFAULT_PERM
 from tracim.views.core_api.session_controller import SessionController
 from tracim.views.default.default_controller import DefaultController
+from tracim.views.errors import Error
 
 
 def main(global_config, **settings):
     # Add SqlAlchemy DB
     configurator.include('.models')
     # set Hapic
-    hapic.set_context(PyramidContext(configurator))
+    hapic.set_context(
+        PyramidContext(
+            configurator=configurator,
+            default_error_builder=Error()
+        )
+    )
     # Add controllers
     default_controllers = DefaultController()
     default_controllers.bind(configurator)

tracim/tests/__init__.py

 
 
 class FunctionalTest(unittest.TestCase):
+
+    fixtures = [BaseFixture]
+    sqlalchemy_url = 'sqlite:///tracim_test.sqlite'
+
     def setUp(self):
         DepotManager._clear()
         settings = {
-            'sqlalchemy.url': 'sqlite:///tracim_test.sqlite',
+            'sqlalchemy.url': self.sqlalchemy_url,
             'user.auth_token.validity': '604800',
             'depot_storage_dir': '/tmp/test/depot',
             'depot_storage_name': 'test',
             dbsession = get_tm_session(session_factory, transaction.manager)
             try:
                 fixtures_loader = FixturesLoader(dbsession, app_config)
-                fixtures_loader.loads([BaseFixture])
+                fixtures_loader.loads(self.fixtures)
                 transaction.commit()
                 print("Database initialized.")
             except IntegrityError:
         DepotManager._clear()
 
 
+class FunctionalTestEmptyDB(FunctionalTest):
+    fixtures = []
+
+
+class FunctionalTestNoDB(FunctionalTest):
+    sqlalchemy_url = 'sqlite://'
+
+    def init_database(self, settings):
+        self.engine = get_engine(settings)
+
+
 class BaseTest(unittest.TestCase):
     """
     Pyramid default test.
     """
+
     def setUp(self):
         logger.debug(self, 'Setup Test...')
         self.config = testing.setUp(settings={
             get_engine,
             get_session_factory,
             get_tm_session,
-            )
+        )
 
         self.engine = get_engine(settings)
         session_factory = get_session_factory(self.engine)

tracim/tests/functional/test_session.py

 # coding=utf-8
-import pytest
-
 from tracim.tests import FunctionalTest
+from tracim.tests import FunctionalTestNoDB
 
 
 class TestLogoutEndpoint(FunctionalTest):
         res = self.testapp.get('/api/v2/sessions/logout', status=204)
 
 
+class TestLoginEndpointUnititedDB(FunctionalTestNoDB):
+
+    def test_api__try_login_enpoint__err_500__no_inited_db(self):
+        params = {
+            'email': 'admin@admin.admin',
+            'password': 'admin@admin.admin',
+        }
+        res = self.testapp.post_json(
+            '/api/v2/sessions/login',
+            params=params,
+            status=500,
+        )
+
+
 class TestLoginEndpoint(FunctionalTest):
 
     def test_api__try_login_enpoint__ok_204__nominal_case(self):

tracim/views/default/default_controller.py

 # coding=utf-8
+from pyramid.httpexceptions import HTTPNotFound
+
 from tracim import TracimRequest
 from tracim.extensions import hapic
 from tracim.views.controllers import Controller
+from tracim.views.errors import Error
 from pyramid.config import Configurator
-from pyramid.exceptions import NotFound
 
 
 class DefaultController(Controller):
 
-    def notfound_view(self, request: TracimRequest):
+    def notfound_view(
+            self,
+            exception: HTTPNotFound,
+            request: TracimRequest
+    ):
+        """
+        Catch Not Found Exception
+        :param exception: Exception Object
+        :param request: current Request
+        :return: 500 Internal Server Error with same format as others errors
+        """
         request.response.status = 404
-        return {}
+        return hapic.context.get_default_error_builder().build_from_exception(
+            exception=exception
+        )
+
+    def exception_view(
+            self,
+            exception: Exception,
+            request: TracimRequest
+    ):
+        """
+        Catch all exceptions not handled in view
+        :param exception: Exception Object
+        :param request: current Request
+        :return: 500 Internal Server Error with same format as others errors
+        """
+        request.response.status = 500
+        return hapic.context.get_default_error_builder().build_from_exception(
+            exception=exception
+        )
 
     def swagger_doc(self, request: TracimRequest):
         return hapic.generate_doc(
         configurator.add_view(
             self.notfound_view,
             renderer='json',
-            context=NotFound,
+            context=HTTPNotFound,
+        )
+        configurator.add_view(
+            self.exception_view,
+            renderer='json',
+            context=Exception,
         )
         configurator.add_route(
             'swagger_doc',

tracim/views/errors.py

+from hapic.error import DefaultErrorBuilder
+
+
+class Error(DefaultErrorBuilder):
+    pass