Merge pull request #31 from inkhey/feature/generic_hapic

.travis.yml

@@ -6,7 +6,7 @@ python:
 
 install:
   - python setup.py develop
-  - pip install pytest pytest-cov python-coveralls
+  - pip install -e ."[test]"
 
 script: 
   - pytest --cov=hapic tests

example_a.py → example/example_a_bottle.py

@@ -5,32 +5,13 @@ from http import HTTPStatus
 import bottle
 import time
 import yaml
-from beaker.middleware import SessionMiddleware
 
 import hapic
+from hapic.ext.bottle.context import BottleContext
 from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema, \
     ErrorResponseSchema, HelloQuerySchema, HelloFileSchema
 from hapic.data import HapicData
 
-# hapic.global_exception_handler(UnAuthExc, StandardErrorSchema)
-# hapic.global_exception_handler(UnAuthExc2, StandardErrorSchema)
-# hapic.global_exception_handler(UnAuthExc3, StandardErrorSchema)
-# bottle.default_app.push(app)
-
-# session_opts = {
-#     'session.type': 'file',
-#     'session.data_dir': '/tmp',
-#     'session.cookie_expires': 3600,
-#     'session.auto': True
-# }
-# session_middleware = SessionMiddleware(
-#     app,
-#     session_opts,
-#     environ_key='beaker.session',
-#     key='beaker.session.id',
-# )
-# app = session_middleware.wrap_app
-
 
 def bob(f):
     def boby(*args, **kwargs):
@@ -90,7 +71,7 @@ class Controllers(object):
     # @hapic.error_schema(ErrorResponseSchema())
     @hapic.input_path(HelloPathSchema())
     @hapic.output_body(HelloResponseSchema())
-    def hello3(self, name: str):
+    def hello3(self, name: str, hapic_data: HapicData):
         return {
             'sentence': 'Hello !',
             'name': name,
@@ -113,19 +94,11 @@ app = bottle.Bottle()
 controllers = Controllers()
 controllers.bind(app)
 
+hapic.set_context(BottleContext(app))
 
-# time.sleep(1)
-# s = hapic.generate_doc(app)
-# ss = json.loads(json.dumps(s))
-# for path in ss['paths']:
-#     for method in ss['paths'][path]:
-#         for response_code in ss['paths'][path][method]['responses']:
-#             ss['paths'][path][method]['responses'][int(response_code)] = ss['paths'][path][method]['responses'][response_code]
-#             del ss['paths'][path][method]['responses'][int(response_code)]
-# print(yaml.dump(ss, default_flow_style=False))
-# time.sleep(1)
-
-hapic.set_context(hapic.ext.bottle.BottleContext())
-print(json.dumps(hapic.generate_doc(app)))
+print(yaml.dump(
+    json.loads(json.dumps(hapic.generate_doc())),
+    default_flow_style=False,
+))
 
 app.run(host='localhost', port=8080, debug=True)

example/example_a_flask.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+import json
+from http import HTTPStatus
+
+from flask import Flask
+import hapic
+from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema, \
+    ErrorResponseSchema, HelloQuerySchema
+from hapic.data import HapicData
+from hapic.ext.flask import FlaskContext
+
+
+def bob(f):
+    def boby(*args, **kwargs):
+        return f(*args, **kwargs)
+    return boby
+
+app = Flask(__name__)
+
+
+class Controllers(object):
+    @hapic.with_api_doc()
+    # @hapic.ext.bottle.bottle_context()
+    @hapic.handle_exception(ZeroDivisionError, http_code=HTTPStatus.BAD_REQUEST)
+    @hapic.input_path(HelloPathSchema())
+    @hapic.input_query(HelloQuerySchema())
+    @hapic.output_body(HelloResponseSchema())
+    def hello(self, name: str, hapic_data: HapicData):
+        """
+        my endpoint hello
+        ---
+        get:
+            description: my description
+            parameters:
+                - in: "path"
+                  description: "hello"
+                  name: "name"
+                  type: "string"
+            responses:
+                200:
+                    description: A pet to be returned
+                    schema: HelloResponseSchema
+        """
+        if name == 'zero':
+            raise ZeroDivisionError('Don\'t call him zero !')
+
+        return {
+            'sentence': 'Hello !',
+            'name': name,
+        }
+
+    @hapic.with_api_doc()
+    # @hapic.ext.bottle.bottle_context()
+    # @hapic.error_schema(ErrorResponseSchema())
+    @hapic.input_path(HelloPathSchema())
+    @hapic.input_body(HelloJsonSchema())
+    @hapic.output_body(HelloResponseSchema())
+    @bob
+    def hello2(self, name: str, hapic_data: HapicData):
+        return {
+            'sentence': 'Hello !',
+            'name': name,
+            'color': hapic_data.body.get('color'),
+        }
+
+    kwargs = {'validated_data': {'name': 'bob'}, 'name': 'bob'}
+
+    @hapic.with_api_doc()
+    # @hapic.ext.bottle.bottle_context()
+    # @hapic.error_schema(ErrorResponseSchema())
+    @hapic.input_path(HelloPathSchema())
+    @hapic.output_body(HelloResponseSchema())
+    def hello3(self, name: str,hapic_data: HapicData ):
+        return {
+            'sentence': 'Hello !',
+            'name': name,
+        }
+
+    def bind(self, app):
+        pass
+        app.add_url_rule('/hello/<name>', "hello", self.hello)
+        app.add_url_rule('/hello/<name>', "hello2",
+                         self.hello2, methods=['POST', ])
+        app.add_url_rule('/hello3/<name>', "hello3", self.hello3)
+
+controllers = Controllers()
+controllers.bind(app)
+
+hapic.set_context(FlaskContext(app))
+print(json.dumps(hapic.generate_doc()))
+app.run(host='localhost', port=8080, debug=True)

example/example_a_pyramid.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+import json
+from http import HTTPStatus
+
+from pyramid.config import Configurator
+from wsgiref.simple_server import make_server
+
+import hapic
+from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema, \
+    ErrorResponseSchema, HelloQuerySchema
+from hapic.data import HapicData
+from hapic.ext.pyramid import PyramidContext
+
+
+def bob(f):
+    def boby(*args, **kwargs):
+        return f(*args, **kwargs)
+    return boby
+
+
+class Controllers(object):
+    @hapic.with_api_doc()
+    # @hapic.ext.bottle.bottle_context()
+    @hapic.handle_exception(ZeroDivisionError, http_code=HTTPStatus.BAD_REQUEST)
+    @hapic.input_path(HelloPathSchema())
+    @hapic.input_query(HelloQuerySchema())
+    @hapic.output_body(HelloResponseSchema())
+    def hello(self, context, request, hapic_data: HapicData):
+        """
+        my endpoint hello
+        ---
+        get:
+            description: my description
+            parameters:
+                - in: "path"
+                  description: "hello"
+                  name: "name"
+                  type: "string"
+            responses:
+                200:
+                    description: A pet to be returned
+                    schema: HelloResponseSchema
+        """
+        name = request.matchdict.get('name', None)
+        if name == 'zero':
+            raise ZeroDivisionError('Don\'t call him zero !')
+
+        return {
+            'sentence': 'Hello !',
+            'name': name,
+        }
+
+    @hapic.with_api_doc()
+    # @hapic.ext.bottle.bottle_context()
+    # @hapic.error_schema(ErrorResponseSchema())
+    @hapic.input_path(HelloPathSchema())
+    @hapic.input_body(HelloJsonSchema())
+    @hapic.output_body(HelloResponseSchema())
+    @bob
+    def hello2(self, context, request, hapic_data: HapicData):
+        name = request.matchdict.get('name', None)
+        return {
+            'sentence': 'Hello !',
+            'name': name,
+            'color': hapic_data.body.get('color'),
+        }
+
+    kwargs = {'validated_data': {'name': 'bob'}, 'name': 'bob'}
+
+    @hapic.with_api_doc()
+    # @hapic.ext.bottle.bottle_context()
+    # @hapic.error_schema(ErrorResponseSchema())
+    @hapic.input_path(HelloPathSchema())
+    @hapic.output_body(HelloResponseSchema())
+    def hello3(self, context, request, hapic_data: HapicData):
+        name = request.matchdict.get('name', None)
+        return {
+            'sentence': 'Hello !',
+            'name': name,
+        }
+
+    def bind(self, configurator: Configurator):
+        configurator.add_route('hello', '/hello/{name}', request_method='GET')
+        configurator.add_view(self.hello, route_name='hello', renderer='json')
+
+        configurator.add_route('hello2', '/hello/{name}', request_method='POST')  # nopep8
+        configurator.add_view(self.hello2, route_name='hello2', renderer='json')  # nopep8
+
+        configurator.add_route('hello3', '/hello3/{name}', request_method='GET')  # nopep8
+        configurator.add_view(self.hello3, route_name='hello3', renderer='json')  # nopep8
+
+
+configurator = Configurator(autocommit=True)
+controllers = Controllers()
+
+controllers.bind(configurator)
+
+hapic.set_context(PyramidContext(configurator))
+print(json.dumps(hapic.generate_doc()))
+
+server = make_server('0.0.0.0', 8080, configurator.make_wsgi_app())
+server.serve_forever()

example/fake_api/bottle_api.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+import json
+from http import HTTPStatus
+
+import bottle
+import time
+from datetime import datetime
+
+from example.fake_api.model import User
+from hapic import Hapic
+from example.fake_api.schema import *
+from hapic.data import HapicData
+from hapic.ext.bottle import BottleContext
+
+hapic = Hapic()
+
+
+class BottleController(object):
+    @hapic.with_api_doc()
+    @hapic.output_body(AboutResponseSchema())
+    def about(self):
+        """
+        General information about this API.
+        """
+        return {
+            'version': '1.2.3',
+            'datetime': datetime(2017, 12, 7, 10, 55, 8, 488996),
+        }
+
+    @hapic.with_api_doc()
+    @hapic.output_body(ListsUserSchema())
+    def get_users(self):
+        """
+        Obtain users list.
+        """
+        some_user = User(
+            id=4,
+            username='some_user',
+            display_name='Damien Accorsi',
+            company='Algoo',
+        )
+        return {
+            'item_nb': 1,
+            'items': [
+                some_user,
+            ],
+            'pagination': {
+                'first_id': 0,
+                'last_id': 5,
+                'current_id': 0,
+            }
+        }
+
+    @hapic.with_api_doc()
+    @hapic.input_path(UserPathSchema())
+    @hapic.output_body(UserSchema())
+    def get_user(self, id, hapic_data: HapicData):
+        """
+        Obtain one user
+        """
+        return {
+             'id': 4,
+             'username': 'some_user',
+             'email_address': 'some.user@hapic.com',
+             'first_name': 'Damien',
+             'last_name': 'Accorsi',
+             'display_name': 'Damien Accorsi',
+             'company': 'Algoo',
+        }
+
+    @hapic.with_api_doc()
+    # TODO - G.M - 2017-12-5 - Support input_forms ?
+    # TODO - G.M - 2017-12-5 - Support exclude, only ?
+    @hapic.input_body(UserSchema(exclude=('id',)))
+    @hapic.output_body(UserSchema())
+    def add_user(self, hapic_data: HapicData):
+        """
+        Add new user
+        """
+        return {
+             'id': 4,
+             'username': 'some_user',
+             'email_address': 'some.user@hapic.com',
+             'first_name': 'Damien',
+             'last_name': 'Accorsi',
+             'display_name': 'Damien Accorsi',
+             'company': 'Algoo',
+        }
+
+    @hapic.with_api_doc()
+    @hapic.output_body(NoContentSchema(),
+                       default_http_code=204)
+    @hapic.input_path(UserPathSchema())
+    def del_user(self, id, hapic_data: HapicData):
+        """
+        delete user
+        """
+        return NoContentSchema()
+
+    def bind(self, app:bottle.Bottle):
+        app.route('/about', callback=self.about)
+        app.route('/users', callback=self.get_users)
+        app.route('/users/<id>', callback=self.get_user)
+        app.route('/users/', callback=self.add_user,  method='POST')
+        app.route('/users/<id>', callback=self.del_user, method='DELETE')
+
+if __name__ == "__main__":
+    app = bottle.Bottle()
+    controllers = BottleController()
+    controllers.bind(app)
+    hapic.set_context(BottleContext(app))
+    time.sleep(1)
+    s = json.dumps(
+        hapic.generate_doc(
+            title='Fake API',
+            description='just an example of hapic API'
+        )
+    )
+    time.sleep(1)
+    # print swagger doc
+    print(s)
+    # Run app
+    app.run(host='localhost', port=8081, debug=True)

example/fake_api/flask_api.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+import json
+from http import HTTPStatus
+
+import flask
+import time
+from datetime import datetime
+from hapic import Hapic
+
+from example.fake_api.schema import *
+from hapic.ext.flask import FlaskContext
+from hapic.data import HapicData
+
+hapic = Hapic()
+
+
+class FlaskController(object):
+    @hapic.with_api_doc()
+    @hapic.output_body(AboutResponseSchema())
+    def about(self):
+        """
+        General information about this API.
+        """
+        return {
+            'version': '1.2.3',
+            'datetime': datetime(2017, 12, 7, 10, 55, 8, 488996),
+        }
+
+    @hapic.with_api_doc()
+    @hapic.output_body(ListsUserSchema())
+    def get_users(self):
+        """
+        Obtain users list.
+        """
+        return {
+            'item_nb': 1,
+            'items': [
+                {
+                    'id': 4,
+                    'username': 'some_user',
+                    'display_name': 'Damien Accorsi',
+                    'company': 'Algoo',
+                },
+            ],
+            'pagination': {
+                'first_id': 0,
+                'last_id': 5,
+                'current_id': 0,
+            }
+        }
+
+    @hapic.with_api_doc()
+    @hapic.input_path(UserPathSchema())
+    @hapic.output_body(UserSchema())
+    def get_user(self, id, hapic_data: HapicData):
+        """
+        Obtain one user
+        """
+        return {
+             'id': 4,
+             'username': 'some_user',
+             'email_address': 'some.user@hapic.com',
+             'first_name': 'Damien',
+             'last_name': 'Accorsi',
+             'display_name': 'Damien Accorsi',
+             'company': 'Algoo',
+        }
+
+    @hapic.with_api_doc()
+    # TODO - G.M - 2017-12-5 - Support input_forms ?
+    # TODO - G.M - 2017-12-5 - Support exclude, only ?
+    @hapic.input_body(UserSchema(exclude=('id',)))
+    @hapic.output_body(UserSchema())
+    def add_user(self, hapic_data: HapicData):
+        """
+        Add new user
+        """
+        return {
+             'id': 4,
+             'username': 'some_user',
+             'email_address': 'some.user@hapic.com',
+             'first_name': 'Damien',
+             'last_name': 'Accorsi',
+             'display_name': 'Damien Accorsi',
+             'company': 'Algoo',
+        }
+
+    @hapic.with_api_doc()
+    @hapic.output_body(NoContentSchema(),
+                       default_http_code=204)
+    @hapic.input_path(UserPathSchema())
+    def del_user(self, id, hapic_data: HapicData):
+        """
+        delete user
+        """
+        return NoContentSchema()
+
+    def bind(self, app: flask.Flask):
+        app.add_url_rule('/about',
+                         view_func=self.about)
+        app.add_url_rule('/users',
+                         view_func=self.get_users)
+        app.add_url_rule('/users/<id>',
+                         view_func=self.get_user)
+        app.add_url_rule('/users/',
+                         view_func=self.add_user,
+                         methods=['POST'])
+        app.add_url_rule('/users/<id>',
+                         view_func=self.del_user,
+                         methods=['DELETE'])
+
+if __name__ == "__main__":
+    app = flask.Flask(__name__)
+    controllers = FlaskController()
+    controllers.bind(app)
+    hapic.set_context(FlaskContext(app))
+    time.sleep(1)
+    s = json.dumps(
+        hapic.generate_doc(
+            title='Fake API',
+            description='just an example of hapic API'
+        )
+    )
+    time.sleep(1)
+    # print swagger doc
+    print(s)
+    # Run app
+    app.run(host='localhost', port=8082, debug=True)

example/fake_api/model.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+
+class User(object):
+    def __init__(
+        self,
+        id: int,
+        username: str,
+        display_name: str,
+        company: str,
+        email_address: str='',
+        first_name: str='',
+        last_name: str='',
+    ) -> None:
+        self.id = id
+        self.username = username
+        self.email_address = email_address
+        self.first_name = first_name
+        self.last_name = last_name
+        self.display_name = display_name
+        self.company = company

example/fake_api/pyramid_api.py

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+import json
+from http import HTTPStatus
+from pyramid.response import Response
+from pyramid.config import Configurator
+from wsgiref.simple_server import make_server
+import time
+from datetime import datetime
+from hapic import Hapic
+from example.fake_api.schema import *
+
+from hapic.data import HapicData
+from hapic.ext.pyramid import PyramidContext
+
+hapic = Hapic()
+
+
+class PyramidController(object):
+    @hapic.with_api_doc()
+    @hapic.output_body(AboutResponseSchema())
+    def about(self, context, request):
+        """
+        General information about this API.
+        """
+        return {
+            'version': '1.2.3',
+            'datetime': datetime(2017, 12, 7, 10, 55, 8, 488996),
+        }
+
+    @hapic.with_api_doc()
+    @hapic.output_body(ListsUserSchema())
+    def get_users(self, context, request):
+        """
+        Obtain users list.
+        """
+        return {
+            'item_nb': 1,
+            'items': [
+                {
+                    'id': 4,
+                    'username': 'some_user',
+                    'display_name': 'Damien Accorsi',
+                    'company': 'Algoo',
+                },
+            ],
+            'pagination': {
+                'first_id': 0,
+                'last_id': 5,
+                'current_id': 0,
+            }
+        }
+
+    @hapic.with_api_doc()
+    @hapic.input_path(UserPathSchema())
+    @hapic.output_body(UserSchema())
+    def get_user(self, context, request, hapic_data: HapicData):
+        """
+        Obtain one user
+        """
+        return {
+             'id': 4,
+             'username': 'some_user',
+             'email_address': 'some.user@hapic.com',
+             'first_name': 'Damien',
+             'last_name': 'Accorsi',
+             'display_name': 'Damien Accorsi',
+             'company': 'Algoo',
+        }
+
+    @hapic.with_api_doc()
+    # TODO - G.M - 2017-12-5 - Support input_forms ?
+    # TODO - G.M - 2017-12-5 - Support exclude, only ?
+    @hapic.input_body(UserSchema(exclude=('id',)))
+    @hapic.output_body(UserSchema())
+    def add_user(self, context, request, hapic_data: HapicData):
+        """
+        Add new user
+        """
+        return {
+             'id': 4,
+             'username': 'some_user',
+             'email_address': 'some.user@hapic.com',
+             'first_name': 'Damien',
+             'last_name': 'Accorsi',
+             'display_name': 'Damien Accorsi',
+             'company': 'Algoo',
+        }
+
+    @hapic.with_api_doc()
+    @hapic.output_body(NoContentSchema(),
+                       default_http_code=204)
+    @hapic.input_path(UserPathSchema())
+    def del_user(self, context, request, hapic_data: HapicData):
+        """
+        delete user
+        """
+        return NoContentSchema()
+
+    def bind(self, configurator: Configurator):
+        configurator.add_route('about', '/about', request_method='GET')
+        configurator.add_view(self.about, route_name='about', renderer='json')
+
+        configurator.add_route('get_users', '/users', request_method='GET')  # nopep8
+        configurator.add_view(self.get_users, route_name='get_users', renderer='json')  # nopep8
+
+        configurator.add_route('get_user', '/users/{id}', request_method='GET')  # nopep8
+        configurator.add_view(self.get_user, route_name='get_user', renderer='json')  # nopep8
+
+        configurator.add_route('add_user', '/users/', request_method='POST')  # nopep8
+        configurator.add_view(self.add_user, route_name='add_user', renderer='json')  # nopep8
+
+        configurator.add_route('del_user', '/users/{id}', request_method='DELETE')  # nopep8
+        configurator.add_view(self.del_user, route_name='del_user', renderer='json')  # nopep8
+
+if __name__ == "__main__":
+    configurator = Configurator(autocommit=True)
+    controllers = PyramidController()
+    controllers.bind(configurator)
+    hapic.set_context(PyramidContext(configurator))
+    time.sleep(1)
+    s = json.dumps(
+        hapic.generate_doc(
+            title='Fake API',
+            description='just an example of hapic API'
+        )
+    )
+    time.sleep(1)
+    # print swagger doc
+    print(s)
+    # Run app
+    server = make_server('0.0.0.0', 8083, configurator.make_wsgi_app())
+    server.serve_forever()

example/fake_api/schema.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+import marshmallow
+
+class NoContentSchema(marshmallow.Schema):
+    pass
+
+class AboutResponseSchema(marshmallow.Schema):
+    version = marshmallow.fields.String(required=True,)
+    datetime = marshmallow.fields.DateTime(required=True)
+
+
+class UserPathSchema(marshmallow.Schema):
+    id = marshmallow.fields.Int(
+        required=True,
+        validate=marshmallow.validate.Range(min=1),
+    )
+
+
+class UserSchema(marshmallow.Schema):
+    id = marshmallow.fields.Int(required=True)
+    username = marshmallow.fields.String(
+        required=True,
+        validate = marshmallow.validate.Regexp(regex='[\w-]+'),
+    )
+    email_address = marshmallow.fields.Email(required=True)
+    first_name = marshmallow.fields.String(required=True)
+    last_name = marshmallow.fields.String(required=True)
+    display_name = marshmallow.fields.String(required=True)
+    company = marshmallow.fields.String(required=True)
+
+
+class PaginationSchema(marshmallow.Schema):
+    first_id = marshmallow.fields.Int(required=True)
+    last_id = marshmallow.fields.Int(required=True)
+    current_id = marshmallow.fields.Int(required=True)
+
+
+class ListsUserSchema(marshmallow.Schema):
+    item_nb = marshmallow.fields.Int(
+        required=True,
+        validate=marshmallow.validate.Range(min=0)
+    )
+    items = marshmallow.fields.Nested(
+        UserSchema,
+        many=True,
+        only=['id', 'username', 'display_name', 'company']
+    )
+    # TODO - G.M - 2017-12-05 - Fix nested schema import into doc !
+    # Can't add doc for nested Schema properly
+    # When schema item isn't added through their own method
+    # Ex : Pagination Schema doesn't work here but UserSchema is ok.
+    pagination = marshmallow.fields.Nested(
+        PaginationSchema
+    )

hapic/__init__.py

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 from hapic.hapic import Hapic
 from hapic.data import HapicData
-from hapic import ext
 
 _hapic_default = Hapic()
 

hapic/context.py

@@ -1,13 +1,24 @@
 # -*- coding: utf-8 -*-
-import json
 import typing
 from http import HTTPStatus
 
-import bottle
+from hapic.processor import RequestParameters
+from hapic.processor import ProcessValidationError
 
-from hapic.exception import OutputValidationException
-# from hapic.hapic import _default_global_error_schema
-from hapic.processor import RequestParameters, ProcessValidationError
+if typing.TYPE_CHECKING:
+    from hapic.decorator import DecoratedController
+
+
+class RouteRepresentation(object):
+    def __init__(
+        self,
+        rule: str,
+        method: str,
+        original_route_object: typing.Any=None,
+    ) -> None:
+        self.rule = rule
+        self.method = method
+        self.original_route_object = original_route_object
 
 
 class ContextInterface(object):
@@ -27,3 +38,26 @@ class ContextInterface(object):
         http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
     ) -> typing.Any:
         raise NotImplementedError()
+
+    def find_route(
+        self,
+        decorated_controller: 'DecoratedController',
+    ) -> RouteRepresentation:
+        raise NotImplementedError()
+
+    def get_swagger_path(self, contextualised_rule: str) -> str:
+        """
+        Return OpenAPI path with context path
+        :param contextualised_rule: path of original context
+        :return: OpenAPI path
+        """
+        raise NotImplementedError()
+
+    def by_pass_output_wrapping(self, response: typing.Any) -> bool:
+        """
+        Return True if the controller response is in final state: we do not
+        have to apply output wrapper on it.
+        :param response: the original response of controller
+        :return:
+        """
+        raise NotImplementedError()

hapic/decorator.py

@@ -5,7 +5,6 @@ from http import HTTPStatus
 
 # TODO BS 20171010: bottle specific !  # see #5
 import marshmallow
-from bottle import HTTPResponse
 from multidict import MultiDict
 
 from hapic.data import HapicData
@@ -215,7 +214,7 @@ class OutputControllerWrapper(InputOutputControllerWrapper):
 
     def after_wrapped_function(self, response: typing.Any) -> typing.Any:
         try:
-            if isinstance(response, HTTPResponse):
+            if self.context.by_pass_output_wrapping(response):
                 return response
 
             processed_response = self.processor.process(response)

hapic/doc.py

@@ -1,54 +1,19 @@
 # -*- coding: utf-8 -*-
-import re
 import typing
 
-import bottle
 from apispec import APISpec
 from apispec import Path
 from apispec.ext.marshmallow.swagger import schema2jsonschema
 
+from hapic.context import ContextInterface
+from hapic.context import RouteRepresentation
 from hapic.decorator import DecoratedController
-from hapic.decorator import DECORATION_ATTRIBUTE_NAME
 from hapic.description import ControllerDescription
-from hapic.exception import NoRoutesException
-from hapic.exception import RouteNotFound
-
-# Bottle regular expression to locate url parameters
-BOTTLE_RE_PATH_URL = re.compile(r'<(?:[^:<>]+:)?([^<>]+)>')
-
-
-def find_bottle_route(
-    decorated_controller: DecoratedController,
-    app: bottle.Bottle,
-):
-    if not app.routes:
-        raise NoRoutesException('There is no routes in your bottle app')
-
-    reference = decorated_controller.reference
-    for route in app.routes:
-        route_token = getattr(
-            route.callback,
-            DECORATION_ATTRIBUTE_NAME,
-            None,
-        )
-
-        match_with_wrapper = route.callback == reference.wrapper
-        match_with_wrapped = route.callback == reference.wrapped
-        match_with_token = route_token == reference.token
-
-        if match_with_wrapper or match_with_wrapped or match_with_token:
-            return route
-    # TODO BS 20171010: Raise exception or print error ? see #10
-    raise RouteNotFound(
-        'Decorated route "{}" was not found in bottle routes'.format(
-            decorated_controller.name,
-        )
-    )
 
 
 def bottle_generate_operations(
     spec,
-    bottle_route: bottle.Route,
+    route: RouteRepresentation,
     description: ControllerDescription,
 ):
     method_operations = dict()
@@ -129,7 +94,7 @@ def bottle_generate_operations(
             })
 
     operations = {
-        bottle_route.method.lower(): method_operations,
+        route.method.lower(): method_operations,
     }
 
     return operations
@@ -139,23 +104,15 @@ class DocGenerator(object):
     def get_doc(
         self,
         controllers: typing.List[DecoratedController],
-        app,
+        context: ContextInterface,
         title: str='',
         description: str='',
     ) -> dict:
-        # TODO: Découper, see #11
-        # TODO: bottle specific code !, see #11
-        if not app:
-            app = bottle.default_app()
-        else:
-            bottle.default_app.push(app)
-
         spec = APISpec(
             title=title,
             info=dict(description=description),
             version='1.0.0',
             plugins=(
-                'apispec.ext.bottle',
                 'apispec.ext.marshmallow',
             ),
             schema_name_resolver=generate_schema_name,
@@ -192,12 +149,12 @@ class DocGenerator(object):
         # with app.test_request_context():
         paths = {}
         for controller in controllers:
-            bottle_route = find_bottle_route(controller, app)
-            swagger_path = BOTTLE_RE_PATH_URL.sub(r'{\1}', bottle_route.rule)
+            route = context.find_route(controller)
+            swagger_path = context.get_swagger_path(route.rule)
 
             operations = bottle_generate_operations(
                 spec,
-                bottle_route,
+                route,
                 controller.description,
             )
 
@@ -218,18 +175,6 @@ class DocGenerator(object):
 
         return spec.to_dict()
 
-        # route_by_callbacks = []
-        # routes = flatten(app.router.dyna_routes.values())
-        # for path, path_regex, route, func_ in routes:
-        #     route_by_callbacks.append(route.callback)
-        #
-        # for description in self._controllers:
-        #     for path, path_regex, route, func_ in routes:
-        #         if route.callback == description.reference:
-        #             # TODO: use description to feed apispec
-        #             print(route.method, path, description)
-        #             continue
-
 
 # TODO BS 20171109: Must take care of already existing definition names
 def generate_schema_name(schema):

hapic/ext/__init__.py

@@ -1,2 +1 @@
 # -*- coding: utf-8 -*-
-from hapic.ext import bottle

hapic/ext/bottle/context.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import json
+import re
 import typing
 from http import HTTPStatus
 
@@ -7,11 +8,23 @@ import bottle
 from multidict import MultiDict
 
 from hapic.context import ContextInterface
+from hapic.context import RouteRepresentation
+from hapic.decorator import DecoratedController
+from hapic.decorator import DECORATION_ATTRIBUTE_NAME
 from hapic.exception import OutputValidationException
-from hapic.processor import RequestParameters, ProcessValidationError
+from hapic.exception import NoRoutesException
+from hapic.exception import RouteNotFound
+from hapic.processor import RequestParameters
+from hapic.processor import ProcessValidationError
+
+# Bottle regular expression to locate url parameters
+BOTTLE_RE_PATH_URL = re.compile(r'<([^:<>]+)(?::[^<>]+)?>')
 
 
 class BottleContext(ContextInterface):
+    def __init__(self, app: bottle.Bottle):
+        self.app = app
+
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
         path_parameters = dict(bottle.request.url_args)
         query_parameters = MultiDict(bottle.request.query.allitems())
@@ -64,3 +77,43 @@ class BottleContext(ContextInterface):
             ],
             status=int(http_code),
         )
+
+    def find_route(
+        self,
+        decorated_controller: DecoratedController,
+    ) -> RouteRepresentation:
+        if not self.app.routes:
+            raise NoRoutesException('There is no routes in your bottle app')
+
+        reference = decorated_controller.reference
+        for route in self.app.routes:
+            route_token = getattr(
+                route.callback,
+                DECORATION_ATTRIBUTE_NAME,
+                None,
+            )
+
+            match_with_wrapper = route.callback == reference.wrapper
+            match_with_wrapped = route.callback == reference.wrapped
+            match_with_token = route_token == reference.token
+
+            if match_with_wrapper or match_with_wrapped or match_with_token:
+                return RouteRepresentation(
+                    rule=self.get_swagger_path(route.rule),
+                    method=route.method.lower(),
+                    original_route_object=route,
+                )
+        # TODO BS 20171010: Raise exception or print error ? see #10
+        raise RouteNotFound(
+            'Decorated route "{}" was not found in bottle routes'.format(
+                decorated_controller.name,
+            )
+        )
+
+    def get_swagger_path(self, contextualised_rule: str) -> str:
+        return BOTTLE_RE_PATH_URL.sub(r'{\1}', contextualised_rule)
+
+    def by_pass_output_wrapping(self, response: typing.Any) -> bool:
+        if isinstance(response, bottle.HTTPResponse):
+            return True
+        return False

hapic/ext/flask/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+from hapic.ext.flask.context import FlaskContext

hapic/ext/flask/context.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+import json
+import re
+import typing
+from http import HTTPStatus
+
+from hapic.context import ContextInterface
+from hapic.context import RouteRepresentation
+from hapic.decorator import DecoratedController
+from hapic.decorator import DECORATION_ATTRIBUTE_NAME
+from hapic.exception import OutputValidationException
+from hapic.processor import RequestParameters, ProcessValidationError
+from flask import Flask
+
+if typing.TYPE_CHECKING:
+    from flask import Response
+
+# flask regular expression to locate url parameters
+FLASK_RE_PATH_URL = re.compile(r'<(?:[^:<>]+:)?([^<>]+)>')
+
+
+class FlaskContext(ContextInterface):
+    def __init__(self, app: Flask):
+        self.app = app
+
+    def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
+        from flask import request
+        return RequestParameters(
+            path_parameters=request.view_args,
+            query_parameters=request.args,  # TODO: Check
+            body_parameters=request.get_json(),  # TODO: Check
+            form_parameters=request.form,
+            header_parameters=request.headers,
+            files_parameters={},  # TODO: BS 20171115: Code it
+        )
+
+    def get_response(
+        self,
+        response: dict,
+        http_code: int,
+    ) -> 'Response':
+        from flask import Response
+        return Response(
+            response=json.dumps(response),
+            mimetype='application/json',
+            status=http_code,
+        )
+
+    def get_validation_error_response(
+        self,
+        error: ProcessValidationError,
+        http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
+    ) -> typing.Any:
+        # TODO BS 20171010: Manage error schemas, see #4
+        from hapic.hapic import _default_global_error_schema
+        unmarshall = _default_global_error_schema.dump(error)
+        if unmarshall.errors:
+            raise OutputValidationException(
+                'Validation error during dump of error response: {}'.format(
+                    str(unmarshall.errors)
+                )
+            )
+        from flask import Response
+        return Response(
+            response=json.dumps(unmarshall.data),
+            mimetype='application/json',
+            status=int(http_code),
+        )
+
+    def find_route(
+        self,
+        decorated_controller: 'DecoratedController',
+    ):
+        reference = decorated_controller.reference
+        for route in self.app.url_map.iter_rules():
+            if route.endpoint not in self.app.view_functions:
+                continue
+            route_callback = self.app.view_functions[route.endpoint]
+            route_token = getattr(
+                route_callback,
+                DECORATION_ATTRIBUTE_NAME,
+                None,
+            )
+            match_with_wrapper = route_callback == reference.wrapper
+            match_with_wrapped = route_callback == reference.wrapped
+            match_with_token = route_token == reference.token
+
+            # FIXME - G.M - 2017-12-04 - return list instead of one method
+            # This fix, return only 1 allowed method, change this when
+            # RouteRepresentation is adapted to return multiples methods.
+            method = [x for x in route.methods
+                      if x not in ['OPTIONS', 'HEAD']][0]
+
+            if match_with_wrapper or match_with_wrapped or match_with_token:
+                return RouteRepresentation(
+                    rule=self.get_swagger_path(route.rule),
+                    method=method,
+                    original_route_object=route,
+                )
+
+    def get_swagger_path(self, contextualised_rule: str) -> str:
+        # TODO - G.M - 2017-12-05 Check if all route path are handled correctly
+        return FLASK_RE_PATH_URL.sub(r'{\1}', contextualised_rule)
+
+    def by_pass_output_wrapping(self, response: typing.Any) -> bool:
+        return False

hapic/ext/pyramid/__init__.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+from hapic.ext.pyramid.context import PyramidContext

hapic/ext/pyramid/context.py

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+import json
+import re
+import typing
+from http import HTTPStatus
+
+from hapic.context import ContextInterface
+from hapic.context import RouteRepresentation
+from hapic.decorator import DecoratedController
+from hapic.decorator import DECORATION_ATTRIBUTE_NAME
+from hapic.ext.bottle.context import BOTTLE_RE_PATH_URL
+from hapic.exception import OutputValidationException
+from hapic.processor import RequestParameters
+from hapic.processor import ProcessValidationError
+
+if typing.TYPE_CHECKING:
+    from pyramid.response import Response
+    from pyramid.config import Configurator
+
+# Bottle regular expression to locate url parameters
+PYRAMID_RE_PATH_URL = re.compile(r'')
+
+
+class PyramidContext(ContextInterface):
+    def __init__(self, configurator: 'Configurator'):
+        self.configurator = configurator
+
+    def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
+        req = args[-1]  # TODO : Check
+        # TODO : move this code to check_json
+        # same idea as in : https://bottlepy.org/docs/dev/_modules/bottle.html#BaseRequest.json
+        if req.body and req.content_type in ('application/json', 'application/json-rpc'):
+            json_body = req.json_body
+            # TODO : raise exception if not correct , return 400 if uncorrect instead ?
+        else:
+            json_body = {}
+
+        return RequestParameters(
+            path_parameters=req.matchdict,
+            query_parameters=req.GET,
+            body_parameters=json_body,
+            form_parameters=req.POST,
+            header_parameters=req.headers,
+            files_parameters={},  # TODO - G.M - 2017-11-05 - Code it
+        )
+
+    def get_response(
+        self,
+        response: dict,
+        http_code: int,
+    ) -> 'Response':
+        from pyramid.response import Response
+        return Response(
+            body=json.dumps(response),
+            headers=[
+                ('Content-Type', 'application/json'),
+            ],
+            status=http_code,
+        )
+
+    def get_validation_error_response(
+        self,
+        error: ProcessValidationError,
+        http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
+    ) -> typing.Any:
+        # TODO BS 20171010: Manage error schemas, see #4
+        from pyramid.response import Response
+        from hapic.hapic import _default_global_error_schema
+        unmarshall = _default_global_error_schema.dump(error)
+        if unmarshall.errors:
+            raise OutputValidationException(
+                'Validation error during dump of error response: {}'.format(
+                    str(unmarshall.errors)
+                )
+            )
+
+        return Response(
+            body=json.dumps(unmarshall.data),
+            headers=[
+                ('Content-Type', 'application/json'),
+            ],
+            status=int(http_code),
+        )
+
+    def find_route(
+        self,
+        decorated_controller: DecoratedController,
+    ) -> RouteRepresentation:
+        for category in self.configurator.introspector.get_category('views'):
+            view_intr = category['introspectable']
+            route_intr = category['related']
+
+            reference = decorated_controller.reference
+            route_token = getattr(
+                view_intr.get('callable'),
+                DECORATION_ATTRIBUTE_NAME,
+                None,
+            )
+
+            match_with_wrapper = view_intr.get('callable') == reference.wrapper
+            match_with_wrapped = view_intr.get('callable') == reference.wrapped
+            match_with_token = route_token == reference.token
+
+            if match_with_wrapper or match_with_wrapped or match_with_token:
+                # TODO BS 20171107: C'est une liste de route sous pyramid !!!
+                # Mais de toute maniere les framework womme pyramid, flask
+                # peuvent avoir un controlleur pour plusieurs routes doc
+                # .find_route doit retourner une liste au lieu d'une seule
+                # route
+                route_pattern = route_intr[0].get('pattern')
+                route_method = route_intr[0].get('request_methods')[0]
+
+                return RouteRepresentation(
+                    rule=self.get_swagger_path(route_pattern),
+                    method=route_method,
+                    original_route_object=route_intr[0],
+                )
+
+    def get_swagger_path(self, contextualised_rule: str) -> str:
+        # TODO BS 20171110: Pyramid allow route like '/{foo:\d+}', so adapt
+        # and USE regular expression (see https://docs.pylonsproject.org/projects/pyramid/en/latest/narr/urldispatch.html#custom-route-predicates)  # nopep8
+        return contextualised_rule
+
+    def by_pass_output_wrapping(self, response: typing.Any) -> bool:
+        return False

hapic/hapic.py

@@ -55,6 +55,7 @@ class Hapic(object):
         self._buffer = DecorationBuffer()
         self._controllers = []  # type: typing.List[DecoratedController]
         self._context = None  # type: ContextInterface
+        self.doc_generator = DocGenerator()
 
         # This local function will be pass to different components
         # who will need context but declared (like with decorator)
@@ -340,15 +341,9 @@ class Hapic(object):
             return decoration.get_wrapper(func)
         return decorator
 
-    def generate_doc(self, app, title: str='', description: str=''):
-        # FIXME: j'ai du tricher avec app, see #11
-        # FIXME @Damien bottle specific code ! see #11
-        # rendre ca generique
-        app = app or self._context.get_app()
-        doc_generator = DocGenerator()
-        return doc_generator.get_doc(
+    def generate_doc(self, title: str='', description: str=''):
+        return self.doc_generator.get_doc(
             self._controllers,
-            app,
+            self.context,
             title=title,
-            description=description,
-        )
+            description=description)

setup.py

@@ -7,9 +7,6 @@ from os import path
 here = path.abspath(path.dirname(__file__))
 
 install_requires = [
-    # TODO: Bottle will be an extension in future, see #1
-    # TODO: marshmallow an extension too ? see #2
-    'bottle',
     'marshmallow',
     'apispec==0.27.1-algoo',
     'multidict'
@@ -19,10 +16,14 @@ dependency_links = [
 ]
 tests_require = [
     'pytest',
+    'pytest-cov',
+    'bottle',
+    'flask',
+    'pyramid',
+    'webtest',
 ]
 dev_require = [
-    'requests',
-]
+] + tests_require
 
 setup(
     name='hapic',

tests/base.py

@@ -4,7 +4,7 @@ from http import HTTPStatus
 
 from multidict import MultiDict
 
-from hapic.context import ContextInterface
+from hapic.ext.bottle import BottleContext
 from hapic.processor import RequestParameters
 from hapic.processor import ProcessValidationError
 
@@ -13,9 +13,11 @@ class Base(object):
     pass
 
 
-class MyContext(ContextInterface):
+# TODO BS 20171105: Make this bottle agnostic !
+class MyContext(BottleContext):
     def __init__(
         self,
+        app,
         fake_path_parameters=None,
         fake_query_parameters=None,
         fake_body_parameters=None,
@@ -23,6 +25,7 @@ class MyContext(ContextInterface):
         fake_header_parameters=None,
         fake_files_parameters=None,
     ) -> None:
+        super().__init__(app=app)
         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 {}

tests/ext/unit/test_bottle.py

@@ -2,16 +2,15 @@
 import bottle
 
 import hapic
-from hapic.doc import find_bottle_route
 from tests.base import Base
 
 
 class TestBottleExt(Base):
     def test_unit__map_binding__ok__decorated_function(self):
         hapic_ = hapic.Hapic()
-        hapic_.set_context(hapic.ext.bottle.BottleContext())
-
         app = bottle.Bottle()
+        context = hapic.ext.bottle.BottleContext(app=app)
+        hapic_.set_context(context)
 
         @hapic_.with_api_doc()
         @app.route('/')
@@ -20,18 +19,18 @@ class TestBottleExt(Base):
 
         assert hapic_.controllers
         decoration = hapic_.controllers[0]
-        route = find_bottle_route(decoration, app)
+        route = context.find_route(decoration)
 
         assert route
-        assert route.callback != controller_a
-        assert route.callback == decoration.reference.wrapped
-        assert route.callback != decoration.reference.wrapper
+        assert route.original_route_object.callback != controller_a
+        assert route.original_route_object.callback == decoration.reference.wrapped  # nopep8
+        assert route.original_route_object.callback != decoration.reference.wrapper  # nopep8
 
     def test_unit__map_binding__ok__mapped_function(self):
         hapic_ = hapic.Hapic()
-        hapic_.set_context(hapic.ext.bottle.BottleContext())
-
         app = bottle.Bottle()
+        context = hapic.ext.bottle.BottleContext(app=app)
+        hapic_.set_context(context)
 
         @hapic_.with_api_doc()
         def controller_a():
@@ -41,18 +40,18 @@ class TestBottleExt(Base):
 
         assert hapic_.controllers
         decoration = hapic_.controllers[0]
-        route = find_bottle_route(decoration, app)
+        route = context.find_route(decoration)
 
         assert route
-        assert route.callback == controller_a
-        assert route.callback == decoration.reference.wrapper
-        assert route.callback != decoration.reference.wrapped
+        assert route.original_route_object.callback == controller_a
+        assert route.original_route_object.callback == decoration.reference.wrapper  # nopep8
+        assert route.original_route_object.callback != decoration.reference.wrapped  # nopep8
 
     def test_unit__map_binding__ok__mapped_method(self):
         hapic_ = hapic.Hapic()
-        hapic_.set_context(hapic.ext.bottle.BottleContext())
-
         app = bottle.Bottle()
+        context = hapic.ext.bottle.BottleContext(app=app)
+        hapic_.set_context(context)
 
         class MyControllers(object):
             def bind(self, app):
@@ -67,11 +66,11 @@ class TestBottleExt(Base):
 
         assert hapic_.controllers
         decoration = hapic_.controllers[0]
-        route = find_bottle_route(decoration, app)
+        route = context.find_route(decoration)
 
         assert route
         # Important note: instance controller_a method is
         # not class controller_a, so no matches with callbacks
-        assert route.callback != MyControllers.controller_a
-        assert route.callback != decoration.reference.wrapped
-        assert route.callback != decoration.reference.wrapper
+        assert route.original_route_object.callback != MyControllers.controller_a  # nopep8
+        assert route.original_route_object.callback != decoration.reference.wrapped  # nopep8
+        assert route.original_route_object.callback != decoration.reference.wrapper  # nopep8

tests/func/fake_api/common.py

@@ -0,0 +1,92 @@
+from collections import OrderedDict
+SWAGGER_DOC_API = {
+ 'definitions': {
+     'AboutResponseSchema': {'properties': {
+                                'datetime': {'format': 'date-time',
+                                             'type': 'string'},
+                                'version': {'type': 'string'}
+                                },
+                             'required': ['datetime', 'version'],
+                             'type': 'object'},
+     'ListsUserSchema': {'properties':  {
+                            'item_nb': {'format': 'int32',
+                                        'minimum': 0,
+                                        'type': 'integer'},
+                            'items': {
+                                'items': {'$ref': '#/definitions/UserSchema'},
+                                'type': 'array'},
+                            'pagination': {'$ref': '#/definitions/PaginationSchema'}},
+                         'required': ['item_nb'],
+                         'type': 'object'},
+     'NoContentSchema': {'properties': {},
+                         'type': 'object'},
+     'PaginationSchema': {'properties': {
+                            'current_id': {'format': 'int32', 'type': 'integer'},
+                            'first_id': {'format': 'int32', 'type': 'integer'},
+                            'last_id': {'format': 'int32', 'type': 'integer'}},
+                          'required': ['current_id', 'first_id', 'last_id'],
+                          'type': 'object'},
+     'UserSchema': {'properties': {
+                        'company': {'type': 'string'},
+                        'display_name': {'type': 'string'},
+                        'email_address': {'format': 'email', 'type': 'string'},
+                        'first_name': {'type': 'string'},
+                        'id': {'format': 'int32', 'type': 'integer'},
+                        'last_name': {'type': 'string'},
+                        'username': {'type': 'string'}},
+                    'required': ['company',
+                                 'display_name',
+                                 'email_address',
+                                 'first_name',
+                                 'id',
+                                 'last_name',
+                                 'username'],
+                    'type': 'object'}},
+ 'info': {'description': 'just an example of hapic API',
+          'title': 'Fake API',
+          'version': '1.0.0'},
+ 'parameters': {},
+ 'paths': OrderedDict(
+     [('/about', {
+         'get': {
+           'description': 'General information about this API.',
+           'responses': {200: {
+               'description': 'HTTPStatus.OK',
+               'schema': {'$ref': '#/definitions/AboutResponseSchema'}}}}}),
+      ('/users', {
+         'get': {
+           'description': 'Obtain users list.',
+           'responses': {200: {
+               'description': 'HTTPStatus.OK',
+               'schema': {'$ref': '#/definitions/ListsUserSchema'}}}}}),
+      ('/users/{id}', {
+         'delete': {
+           'description': 'delete user',
+           'parameters': [{'in': 'path',
+                           'name': 'id',
+                           'required': True,
+                           'type': 'integer'}],
+           'responses': {204: {
+               'description': '204',
+               'schema': {'$ref': '#/definitions/NoContentSchema'}}}},
+         'get': {
+             'description': 'Obtain one user',
+             'parameters': [{'in': 'path',
+                             'name': 'id',
+                             'required': True,
+                             'type': 'integer'}],
+             'responses': {200: {
+                 'description': 'HTTPStatus.OK',
+                 'schema': {'$ref': '#/definitions/UserSchema'}}}}}),
+      ('/users/', {
+         'post': {
+             'description': 'Add new user',
+             'parameters': [{'in': 'body',
+                             'name': 'body',
+                             'schema': {'$ref': '#/definitions/UserSchema'}}],
+             'responses': {200: {
+                 'description': 'HTTPStatus.OK',
+                 'schema': {'$ref': '#/definitions/UserSchema'}}}}})]),
+ 'swagger': '2.0',
+ 'tags': []
+}

tests/func/fake_api/test_bottle.py

@@ -0,0 +1,94 @@
+from webtest import TestApp
+from bottle import Bottle
+
+from hapic.ext.bottle import BottleContext
+from example.fake_api.bottle_api import BottleController
+from tests.func.fake_api.common import SWAGGER_DOC_API
+from example.fake_api.bottle_api import hapic
+
+
+def test_func_bottle_fake_api():
+    bottle_app = Bottle()
+    controllers = BottleController()
+    controllers.bind(bottle_app)
+
+    hapic.set_context(BottleContext(bottle_app))
+    app = TestApp(bottle_app)
+    doc = hapic.generate_doc(
+        title='Fake API',
+        description='just an example of hapic API'
+    )
+
+    assert doc == SWAGGER_DOC_API
+    resp = app.get('/about')
+    assert resp.status_int == 200
+    assert resp.json == {'datetime': '2017-12-07T10:55:08.488996+00:00',
+                         'version': '1.2.3'}
+
+    resp = app.get('/users')
+    assert resp.status_int == 200
+    assert resp.json == {
+        'items':
+        [
+            {
+                'username': 'some_user',
+                'display_name': 'Damien Accorsi',
+                'company': 'Algoo', 'id': 4
+            }
+        ],
+        'pagination': {
+            'first_id': 0,
+            'last_id': 5,
+            'current_id': 0,
+        },
+        'item_nb': 1,
+    }
+
+    resp = app.get('/users/1')
+    assert resp.status_int == 200
+    assert resp.json == {
+        'last_name': 'Accorsi',
+        'username': 'some_user',
+        'first_name': 'Damien',
+        'id': 4,
+        'display_name': 'Damien Accorsi',
+        'email_address': 'some.user@hapic.com',
+        'company': 'Algoo'
+    }
+
+    resp = app.post('/users/', status='*')
+    assert resp.status_int == 400
+    assert resp.json == {
+        'details': {
+            'email_address': ['Missing data for required field.'],
+            'username': ['Missing data for required field.'],
+            'display_name': ['Missing data for required field.'],
+            'last_name': ['Missing data for required field.'],
+            'first_name': ['Missing data for required field.'],
+            'company': ['Missing data for required field.']},
+        'message': 'Validation error of input data'}
+
+    user = {
+        'email_address': 'some.user@hapic.com',
+        'username': 'some_user',
+        'display_name': 'Damien Accorsi',
+        'last_name': 'Accorsi',
+        'first_name': 'Damien',
+        'company': 'Algoo',
+    }
+
+    resp = app.post_json('/users/', user)
+    assert resp.status_int == 200
+    assert resp.json == {
+        'last_name': 'Accorsi',
+        'username': 'some_user',
+        'first_name': 'Damien',
+        'id': 4,
+        'display_name': 'Damien Accorsi',
+        'email_address': 'some.user@hapic.com',
+        'company': 'Algoo',
+    }
+
+    resp = app.delete('/users/1', status='*')
+    assert resp.status_int == 204
+

tests/func/fake_api/test_flask.py

@@ -0,0 +1,94 @@
+from webtest import TestApp
+from hapic.ext.flask import FlaskContext
+from flask import Flask
+from example.fake_api.flask_api import FlaskController
+from example.fake_api.flask_api import hapic
+from tests.func.fake_api.common import SWAGGER_DOC_API
+
+
+def test_func_flask_fake_api():
+    flask_app = Flask(__name__)
+    controllers = FlaskController()
+    controllers.bind(flask_app)
+    hapic.set_context(FlaskContext(flask_app))
+    app = TestApp(flask_app)
+    doc =  hapic.generate_doc(
+        title='Fake API',
+        description='just an example of hapic API'
+    )
+
+    assert doc == SWAGGER_DOC_API
+    resp = app.get('/about')
+    assert resp.status_int == 200
+    assert resp.json == {'datetime': '2017-12-07T10:55:08.488996+00:00',
+                         'version': '1.2.3'}
+
+    resp = app.get('/users')
+    assert resp.status_int == 200
+    assert resp.json == {
+        'items':
+        [
+            {
+                'username': 'some_user',
+                'display_name': 'Damien Accorsi',
+                'company': 'Algoo', 'id': 4
+            }
+        ],
+        'pagination': {
+            'first_id': 0,
+            'last_id': 5,
+            'current_id': 0,
+        },
+        'item_nb': 1,
+    }
+
+    resp = app.get('/users/1')
+    assert resp.status_int == 200
+    assert resp.json == {
+        'last_name': 'Accorsi',
+        'username': 'some_user',
+        'first_name': 'Damien',
+        'id': 4,
+        'display_name': 'Damien Accorsi',
+        'email_address': 'some.user@hapic.com',
+        'company': 'Algoo'
+    }
+
+    resp = app.post('/users/', status='*')
+    assert resp.status_int == 400
+    assert resp.json == {
+        'details': {
+            'email_address': ['Missing data for required field.'],
+            'username': ['Missing data for required field.'],
+            'display_name': ['Missing data for required field.'],
+            'last_name': ['Missing data for required field.'],
+            'first_name': ['Missing data for required field.'],
+            'company': ['Missing data for required field.']},
+        'message': 'Validation error of input data'}
+
+    user = {
+        'email_address': 'some.user@hapic.com',
+        'username': 'some_user',
+        'display_name': 'Damien Accorsi',
+        'last_name': 'Accorsi',
+        'first_name': 'Damien',
+        'company': 'Algoo',
+    }
+
+    resp = app.post_json('/users/', user)
+    assert resp.status_int == 200
+    assert resp.json == {
+        'last_name': 'Accorsi',
+        'username': 'some_user',
+        'first_name': 'Damien',
+        'id': 4,
+        'display_name': 'Damien Accorsi',
+        'email_address': 'some.user@hapic.com',
+        'company': 'Algoo',
+    }
+    # INFO - G.M - 2017-12-07 - Warning due to Webtest check
+    # Webtest check content_type. Up to know flask_api return json as
+    # content_type with 204 NO CONTENT status code which return a warning in
+    # WebTest check.
+    resp = app.delete('/users/1', status='*')
+    assert resp.status_int == 204

tests/func/fake_api/test_pyramid.py

@@ -0,0 +1,96 @@
+from webtest import TestApp
+from pyramid.config import Configurator
+import hapic
+from hapic.ext.pyramid import PyramidContext
+from example.fake_api.pyramid_api import hapic
+from example.fake_api.pyramid_api import PyramidController
+from tests.func.fake_api.common import SWAGGER_DOC_API
+
+
+def test_func_pyramid_fake_api_doc():
+    configurator = Configurator(autocommit=True)
+    controllers = PyramidController()
+    controllers.bind(configurator)
+    hapic.set_context(PyramidContext(configurator))
+    app = TestApp(configurator.make_wsgi_app())
+    doc = hapic.generate_doc(
+        title='Fake API',
+        description='just an example of hapic API'
+    )
+
+    assert doc == SWAGGER_DOC_API
+    resp = app.get('/about')
+    assert resp.status_int == 200
+    assert resp.json == {'datetime': '2017-12-07T10:55:08.488996+00:00',
+                         'version': '1.2.3'}
+
+    resp = app.get('/users')
+    assert resp.status_int == 200
+    assert resp.json == {
+        'items':
+        [
+            {
+                'username': 'some_user',
+                'display_name': 'Damien Accorsi',
+                'company': 'Algoo', 'id': 4
+            }
+        ],
+        'pagination': {
+            'first_id': 0,
+            'last_id': 5,
+            'current_id': 0,
+        },
+        'item_nb': 1,
+    }
+
+    resp = app.get('/users/1')
+    assert resp.status_int == 200
+    assert resp.json == {
+        'last_name': 'Accorsi',
+        'username': 'some_user',
+        'first_name': 'Damien',
+        'id': 4,
+        'display_name': 'Damien Accorsi',
+        'email_address': 'some.user@hapic.com',
+        'company': 'Algoo'
+    }
+
+    resp = app.post('/users/', status='*')
+    assert resp.status_int == 400
+    assert resp.json == {
+        'details': {
+            'email_address': ['Missing data for required field.'],
+            'username': ['Missing data for required field.'],
+            'display_name': ['Missing data for required field.'],
+            'last_name': ['Missing data for required field.'],
+            'first_name': ['Missing data for required field.'],
+            'company': ['Missing data for required field.']},
+        'message': 'Validation error of input data'}
+
+    user = {
+        'email_address': 'some.user@hapic.com',
+        'username': 'some_user',
+        'display_name': 'Damien Accorsi',
+        'last_name': 'Accorsi',
+        'first_name': 'Damien',
+        'company': 'Algoo',
+    }
+
+    resp = app.post_json('/users/', user)
+    assert resp.status_int == 200
+    assert resp.json == {
+        'last_name': 'Accorsi',
+        'username': 'some_user',
+        'first_name': 'Damien',
+        'id': 4,
+        'display_name': 'Damien Accorsi',
+        'email_address': 'some.user@hapic.com',
+        'company': 'Algoo',
+    }
+
+    # INFO - G.M - 2017-12-07 - Test for delete desactivated(Webtest check fail)
+    # Webtest check content_type. Up to know pyramid_api return json as
+    # content_type with 204 NO CONTENT status code which return an error in
+    # WebTest check.
+    # resp = app.delete('/users/1', status='*')
+    # assert resp.status_int == 204

tests/func/test_doc.py

@@ -10,8 +10,8 @@ from tests.base import MyContext
 class TestDocGeneration(Base):
     def test_func__input_files_doc__ok__one_file(self):
         hapic = Hapic()
-        hapic.set_context(MyContext())
         app = bottle.Bottle()
+        hapic.set_context(MyContext(app=app))
 
         class MySchema(marshmallow.Schema):
             file_abc = marshmallow.fields.Raw(required=True)
@@ -23,7 +23,7 @@ class TestDocGeneration(Base):
             assert hapic_data.files
 
         app.route('/upload', method='POST', callback=my_controller)
-        doc = hapic.generate_doc(app)
+        doc = hapic.generate_doc()
 
         assert doc
         assert '/upload' in doc['paths']
@@ -39,8 +39,8 @@ class TestDocGeneration(Base):
 
     def test_func__input_files_doc__ok__two_file(self):
         hapic = Hapic()
-        hapic.set_context(MyContext())
         app = bottle.Bottle()
+        hapic.set_context(MyContext(app=app))
 
         class MySchema(marshmallow.Schema):
             file_abc = marshmallow.fields.Raw(required=True)
@@ -53,7 +53,7 @@ class TestDocGeneration(Base):
             assert hapic_data.files
 
         app.route('/upload', method='POST', callback=my_controller)
-        doc = hapic.generate_doc(app)
+        doc = hapic.generate_doc()
 
         assert doc
         assert '/upload' in doc['paths']
@@ -75,8 +75,8 @@ class TestDocGeneration(Base):
 
     def test_func__output_file_doc__ok__nominal_case(self):
         hapic = Hapic()
-        hapic.set_context(MyContext())
         app = bottle.Bottle()
+        hapic.set_context(MyContext(app=app))
 
         @hapic.with_api_doc()
         @hapic.output_file(['image/jpeg'])
@@ -84,7 +84,7 @@ class TestDocGeneration(Base):
             return b'101010100101'
 
         app.route('/avatar', method='GET', callback=my_controller)
-        doc = hapic.generate_doc(app)
+        doc = hapic.generate_doc()
 
         assert doc
         assert '/avatar' in doc['paths']
@@ -94,8 +94,8 @@ class TestDocGeneration(Base):
 
     def test_func__input_files_doc__ok__one_file_and_text(self):
         hapic = Hapic()
-        hapic.set_context(MyContext())
         app = bottle.Bottle()
+        hapic.set_context(MyContext(app=app))
 
         class MySchema(marshmallow.Schema):
             name = marshmallow.fields.String(required=True)
@@ -111,7 +111,7 @@ class TestDocGeneration(Base):
             assert hapic_data.files
 
         app.route('/upload', method='POST', callback=my_controller)
-        doc = hapic.generate_doc(app)
+        doc = hapic.generate_doc()
 
         assert doc
         assert '/upload' in doc['paths']
@@ -127,8 +127,8 @@ class TestDocGeneration(Base):
 
     def test_func__docstring__ok__simple_case(self):
         hapic = Hapic()
-        hapic.set_context(MyContext())
         app = bottle.Bottle()
+        hapic.set_context(MyContext(app=app))
 
         # TODO BS 20171113: Make this test non-bottle
         @hapic.with_api_doc()
@@ -140,7 +140,7 @@ class TestDocGeneration(Base):
             assert hapic_data.files
 
         app.route('/upload', method='POST', callback=my_controller)
-        doc = hapic.generate_doc(app)
+        doc = hapic.generate_doc()
 
         assert doc.get('paths')
         assert '/upload' in doc['paths']

tests/func/test_marshmallow_decoration.py

@@ -11,9 +11,12 @@ from tests.base import MyContext
 class TestMarshmallowDecoration(Base):
     def test_unit__input_files__ok__file_is_present(self):
         hapic = Hapic()
-        hapic.set_context(MyContext(fake_files_parameters={
-            'file_abc': '10101010101',
-        }))
+        hapic.set_context(MyContext(
+            app=None,
+            fake_files_parameters={
+                'file_abc': '10101010101',
+            }
+        ))
 
         class MySchema(marshmallow.Schema):
             file_abc = marshmallow.fields.Raw(required=True)
@@ -30,9 +33,12 @@ class TestMarshmallowDecoration(Base):
 
     def test_unit__input_files__ok__file_is_not_present(self):
         hapic = Hapic()
-        hapic.set_context(MyContext(fake_files_parameters={
-            # No file here
-        }))
+        hapic.set_context(MyContext(
+            app=None,
+            fake_files_parameters={
+                # No file here
+            }
+        ))
 
         class MySchema(marshmallow.Schema):
             file_abc = marshmallow.fields.Raw(required=True)
@@ -53,9 +59,12 @@ class TestMarshmallowDecoration(Base):
 
     def test_unit__input_files__ok__file_is_empty_string(self):
         hapic = Hapic()
-        hapic.set_context(MyContext(fake_files_parameters={
-            'file_abc': '',
-        }))
+        hapic.set_context(MyContext(
+            app=None,
+            fake_files_parameters={
+                'file_abc': '',
+            }
+        ))
 
         class MySchema(marshmallow.Schema):
             file_abc = marshmallow.fields.Raw(required=True)

tests/unit/test_decorator.py

@@ -90,7 +90,7 @@ class MySchema(marshmallow.Schema):
 
 class TestControllerWrapper(Base):
     def test_unit__base_controller_wrapper__ok__no_behaviour(self):
-        context = MyContext()
+        context = MyContext(app=None)
         processor = MyProcessor()
         wrapper = InputOutputControllerWrapper(context, processor)
 
@@ -102,7 +102,7 @@ class TestControllerWrapper(Base):
         assert result == 42
 
     def test_unit__base_controller__ok__replaced_response(self):
-        context = MyContext()
+        context = MyContext(app=None)
         processor = MyProcessor()
         wrapper = MyControllerWrapper(context, processor)
 
@@ -116,7 +116,7 @@ class TestControllerWrapper(Base):
         assert {'error_response': 'we are testing'} == result
 
     def test_unit__controller_wrapper__ok__overload_input(self):
-        context = MyContext()
+        context = MyContext(app=None)
         processor = MyProcessor()
         wrapper = MyControllerWrapper(context, processor)
 
@@ -133,11 +133,14 @@ class TestControllerWrapper(Base):
 
 class TestInputControllerWrapper(Base):
     def test_unit__input_data_wrapping__ok__nominal_case(self):
-        context = MyContext(fake_query_parameters=MultiDict(
-            (
-                ('foo', 'bar',),
+        context = MyContext(
+            app=None,
+            fake_query_parameters=MultiDict(
+                (
+                    ('foo', 'bar',),
+                )
             )
-        ))
+        )
         processor = MyProcessor()
         wrapper = MyInputQueryControllerWrapper(context, processor)
 
@@ -153,12 +156,15 @@ class TestInputControllerWrapper(Base):
         assert result == 42
 
     def test_unit__multi_query_param_values__ok__use_as_list(self):
-        context = MyContext(fake_query_parameters=MultiDict(
-            (
-                ('user_id', 'abc'),
-                ('user_id', 'def'),
-            ),
-        ))
+        context = MyContext(
+            app=None,
+            fake_query_parameters=MultiDict(
+                (
+                    ('user_id', 'abc'),
+                    ('user_id', 'def'),
+                ),
+            )
+        )
         processor = MySimpleProcessor()
         wrapper = InputQueryControllerWrapper(
             context,
@@ -178,12 +184,15 @@ class TestInputControllerWrapper(Base):
         assert result == ['abc', 'def']
 
     def test_unit__multi_query_param_values__ok__without_as_list(self):
-        context = MyContext(fake_query_parameters=MultiDict(
-            (
-                ('user_id', 'abc'),
-                ('user_id', 'def'),
-            ),
-        ))
+        context = MyContext(
+            app=None,
+            fake_query_parameters=MultiDict(
+                (
+                    ('user_id', 'abc'),
+                    ('user_id', 'def'),
+                ),
+            )
+        )
         processor = MySimpleProcessor()
         wrapper = InputQueryControllerWrapper(
             context,
@@ -204,7 +213,7 @@ class TestInputControllerWrapper(Base):
 
 class TestOutputControllerWrapper(Base):
     def test_unit__output_data_wrapping__ok__nominal_case(self):
-        context = MyContext()
+        context = MyContext(app=None)
         processor = MyProcessor()
         wrapper = OutputControllerWrapper(context, processor)
 
@@ -222,7 +231,7 @@ class TestOutputControllerWrapper(Base):
                } == result
 
     def test_unit__output_data_wrapping__fail__error_response(self):
-        context = MyContext()
+        context = MyContext(app=None)
         processor = MarshmallowOutputProcessor()
         processor.schema = MySchema()
         wrapper = OutputControllerWrapper(context, processor)
@@ -244,7 +253,7 @@ class TestOutputControllerWrapper(Base):
 
 class TestExceptionHandlerControllerWrapper(Base):
     def test_unit__exception_handled__ok__nominal_case(self):
-        context = MyContext()
+        context = MyContext(app=None)
         wrapper = ExceptionHandlerControllerWrapper(
             ZeroDivisionError,
             context,
@@ -272,7 +281,7 @@ class TestExceptionHandlerControllerWrapper(Base):
                 super().__init__(*args, **kwargs)
                 self.error_dict = {}
 
-        context = MyContext()
+        context = MyContext(app=None)
         wrapper = ExceptionHandlerControllerWrapper(
             MyException,
             context,