Merge pull request #56 from tracim/fix/better_session_api

tracim/__init__.py

 from tracim.lib.utils.authentification import BASIC_AUTH_WEBUI_REALM
 from tracim.lib.utils.authorization import AcceptAllAuthorizationPolicy
 from tracim.lib.utils.authorization import TRACIM_DEFAULT_PERM
+from tracim.views import BASE_API_V2
 from tracim.views.core_api.session_controller import SessionController
-from tracim.views.default.default_controller import DefaultController
+from tracim.views.errors import ErrorSchema
 
 
 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=ErrorSchema()
+        )
+    )
     # Add controllers
-    default_controllers = DefaultController()
-    default_controllers.bind(configurator)
     session_api = SessionController()
-    session_api.bind(configurator)
+    configurator.include(session_api.bind, route_prefix=BASE_API_V2)
     hapic.add_documentation_view(
         '/api/v2/doc',
         'Tracim v2 API',

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_doc.py

 
 class TestDoc(FunctionalTest):
 
-    def test_index(self):
+    def test_api__check_doc_index_html_page__ok_200__nominal_case(self):
         res = self.testapp.get('/api/v2/doc/', status=200)
         assert res.content_type == 'text/html'
 
-    def test_spec_yml(self):
+    def test_api__check_spec_yaml_file__ok_200__nominal_case(self):
         res = self.testapp.get('/api/v2/doc/spec.yml', status=200)
         assert res.content_type == 'text/x-yaml'
 
-    def test_assets(self):
+    def test_api__check_docs_assets__ok_200__nominal_case(self):
         res = self.testapp.get(
             '/api/v2/doc/favicon-32x32.png',
             status=200,

tracim/tests/functional/test_session.py

 # coding=utf-8
 import pytest
+from sqlalchemy.exc import OperationalError
 
 from tracim.tests import FunctionalTest
+from tracim.tests import FunctionalTestNoDB
 
 
 class TestLogoutEndpoint(FunctionalTest):
 
-    def test_logout(self):
+    def test_api__access_logout_get_enpoint__ok__nominal_case(self):
+        res = self.testapp.post_json('/api/v2/sessions/logout', status=204)
+
+    def test_api__access_logout_post_enpoint__ok__nominal_case(self):
         res = self.testapp.get('/api/v2/sessions/logout', status=204)
 
 
+class TestLoginEndpointUnititedDB(FunctionalTestNoDB):
+
+    @pytest.mark.xfail(raises=OperationalError,
+                       reason='Not supported yet by hapic')
+    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,
+        )
+        assert isinstance(res.json, dict)
+        assert 'code' in res.json.keys()
+        assert 'message' in res.json.keys()
+        assert 'details' in res.json.keys()
+
+
 class TestLoginEndpoint(FunctionalTest):
 
-    def test_login_ok(self):
+    def test_api__try_login_enpoint__ok_204__nominal_case(self):
         params = {
             'email': 'admin@admin.admin',
             'password': 'admin@admin.admin',
         }
-        res = self.testapp.get(
+        res = self.testapp.post_json(
             '/api/v2/sessions/login',
+            params=params,
             status=204,
-            params=params
         )
 
-    def test_bad_password(self):
+    def test_api__try_login_enpoint__err_400__bad_password(self):
         params = {
             'email': 'admin@admin.admin',
             'password': 'bad_password',
         }
-        res = self.testapp.get(
+        res = self.testapp.post_json(
             '/api/v2/sessions/login',
             status=400,
             params=params,
         )
+        assert isinstance(res.json, dict)
+        assert 'code' in res.json.keys()
+        assert 'message' in res.json.keys()
+        assert 'details' in res.json.keys()
 
-    def test_bad_user(self):
+    def test_api__try_login_enpoint__err_400__unregistered_user(self):
         params = {
             'email': 'unknown_user@unknown.unknown',
             'password': 'bad_password',
         }
-        res = self.testapp.get(
+        res = self.testapp.post_json(
             '/api/v2/sessions/login',
             status=400,
             params=params,
         )
+        assert isinstance(res.json, dict)
+        assert 'code' in res.json.keys()
+        assert 'message' in res.json.keys()
+        assert 'details' in res.json.keys()
 
-    def test_uncomplete(self):
-        res = self.testapp.get('/api/v2/sessions/login', status=400)
+    def test_api__try_login_enpoint__err_400__no_json_body(self):
+        res = self.testapp.post_json('/api/v2/sessions/login', status=400)
+        assert isinstance(res.json, dict)
+        assert 'code' in res.json.keys()
+        assert 'message' in res.json.keys()
+        assert 'details' in res.json.keys()
 
 
 class TestWhoamiEndpoint(FunctionalTest):
 
-    def test_whoami_ok(self):
+    def test_api__try_whoami_enpoint__ok_200__nominal_case(self):
         self.testapp.authorization = (
             'Basic',
             (
         assert res.json_body['caldav_url'] is None
         assert res.json_body['avatar_url'] is None
 
-    def test_unauthenticated(self):
+    def test_api__try_whoami_enpoint__err_401__unauthenticated(self):
         self.testapp.authorization = (
             'Basic',
             (
             )
         )
         res = self.testapp.get('/api/v2/sessions/whoami', status=401)
+        assert isinstance(res.json, dict)
+        assert 'code' in res.json.keys()
+        assert 'message' in res.json.keys()
+        assert 'details' in res.json.keys()

tracim/views/core_api/session_controller.py

 # coding=utf-8
-import os
-from http.client import HTTPException
-
-from pyramid.httpexceptions import HTTPNoContent
-from pyramid.response import Response
+from pyramid.config import Configurator
 from sqlalchemy.orm.exc import NoResultFound
+try:  # Python 3.5+
+    from http import HTTPStatus
+except ImportError:
+    from http import client as HTTPStatus
+
 
 from tracim import TracimRequest
 from tracim.extensions import hapic
 from tracim.lib.core.user import UserApi
 from tracim.models.context_models import UserInContext
 from tracim.views.controllers import Controller
-from pyramid.config import Configurator
-
-from tracim.views import BASE_API_V2
-from tracim.views.core_api.schemas import UserSchema, NoContentSchema
+from tracim.views.core_api.schemas import UserSchema
+from tracim.views.core_api.schemas import NoContentSchema
 from tracim.views.core_api.schemas import LoginOutputHeaders
 from tracim.views.core_api.schemas import BasicAuthSchema
-from tracim.exceptions import NotAuthentificated, LoginFailed
-
-try:  # Python 3.5+
-    from http import HTTPStatus
-except ImportError:
-    from http import client as HTTPStatus
+from tracim.exceptions import NotAuthentificated
+from tracim.exceptions import LoginFailed
 
 
 class SessionController(Controller):
 
     @hapic.with_api_doc()
     @hapic.input_headers(LoginOutputHeaders())
-    @hapic.input_query(BasicAuthSchema())
+    @hapic.input_body(BasicAuthSchema())
     @hapic.handle_exception(LoginFailed, http_code=HTTPStatus.BAD_REQUEST)
     # TODO - G.M - 17-04-2018 - fix output header ?
     # @hapic.output_headers()
         """
         Logs user into the system
         """
-        email = request.params['email']
-        password = request.params['password']
-        if not (email and password):
-            raise Exception
+        email = request.json_body['email']
+        password = request.json_body['password']
         app_config = request.registry.settings['CFG']
         try:
             uapi = UserApi(
     def bind(self, configurator: Configurator):
 
         # Login
-        configurator.add_route(
-            'login',
-            os.path.join(BASE_API_V2, 'sessions', 'login'),
-            request_method='GET'
-        )
-        configurator.add_view(
-            self.login,
-            route_name='login',
-        )
+        configurator.add_route('login', '/sessions/login', request_method='POST')  # nopep8
+        configurator.add_view(self.login, route_name='login')
         # Logout
-        configurator.add_route(
-            'logout',
-            os.path.join(BASE_API_V2, 'sessions', 'logout'),
-            request_method='GET'
-        )
-
-        configurator.add_view(
-            self.logout,
-            route_name='logout',
-        )
+        configurator.add_route('logout', '/sessions/logout', request_method='POST')  # nopep8
+        configurator.add_view(self.logout, route_name='logout')
+        configurator.add_route('logout_get', '/sessions/logout', request_method='GET')  # nopep8
+        configurator.add_view(self.logout, route_name='logout_get')
         # Whoami
-        configurator.add_route(
-            'whoami',
-            os.path.join(BASE_API_V2, 'sessions', 'whoami'),
-            request_method='GET'
-        )
-        configurator.add_view(
-            self.whoami,
-            route_name='whoami',
-        )
+        configurator.add_route('whoami', '/sessions/whoami', request_method='GET')  # nopep8
+        configurator.add_view(self.whoami, route_name='whoami',)

tracim/views/default/default_controller.py

-# coding=utf-8
-from tracim import TracimRequest
-from tracim.extensions import hapic
-from tracim.views.controllers import Controller
-from pyramid.config import Configurator
-from pyramid.exceptions import NotFound
-
-
-class DefaultController(Controller):
-
-    def notfound_view(self, request: TracimRequest):
-        request.response.status = 404
-        return {}
-
-    def swagger_doc(self, request: TracimRequest):
-        return hapic.generate_doc(
-                title='Tracim v2 API',
-                description='API of Tracim v2',
-        )
-
-    def bind(self, configurator: Configurator):
-        configurator.add_view(
-            self.notfound_view,
-            renderer='json',
-            context=NotFound,
-        )
-        configurator.add_route(
-            'swagger_doc',
-            '/swagger_doc',
-            request_method='GET',
-        )
-        configurator.add_view(
-            self.swagger_doc,
-            route_name='swagger_doc',
-            renderer='json',
-        )

tracim/views/errors.py

+from hapic.error import DefaultErrorBuilder
+
+
+class ErrorSchema(DefaultErrorBuilder):
+    """
+    This class is both a builder and a Marshmallow Schema, His named is used for
+    swagger ui error schema. That's why we call it ErrorSchema To have
+    a nice naming in swagger ui.
+    """
+    pass