Merge pyramid and doc generation refactorisation with current bottle context

hapic/context.py

         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):

hapic/doc.py

 # -*- coding: utf-8 -*-
 import typing
 
-import bottle
 from apispec import APISpec
 from apispec import Path
 from apispec.ext.marshmallow.swagger import schema2jsonschema
 
-from hapic.context import ContextInterface, RouteRepresentation
-from hapic.decorator import DECORATION_ATTRIBUTE_NAME
+from hapic.context import ContextInterface
+from hapic.context import RouteRepresentation
 from hapic.decorator import DecoratedController
 from hapic.description import ControllerDescription
-from hapic.exception import NoRoutesException
-from hapic.exception import RouteNotFound
-
-
-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(

hapic/ext/bottle/context.py

 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())
 
         return RequestParameters(
             path_parameters=path_parameters,
-            query_parameters=query_parameters, ## query?
+            query_parameters=query_parameters,
             body_parameters=body_parameters,
             form_parameters=form_parameters,
             header_parameters=header_parameters,
             ],
             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)

hapic/ext/pyramid/context.py

 import typing
 from http import HTTPStatus
 
-from pyramid.request import Request
-from pyramid.response import Response
-from pyramid.config import Configurator
-
 from hapic.context import ContextInterface
 from hapic.context import RouteRepresentation
 from hapic.decorator import DecoratedController
 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):
+    def __init__(self, configurator: 'Configurator'):
         self.configurator = configurator
 
     def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
         req = args[-1]  # TODO : Check
-        assert isinstance(req, Request)
         # 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'):
         self,
         response: dict,
         http_code: int,
-    ) -> Response:
+    ) -> 'Response':
+        from pyramid.response import Response
         return Response(
             body=json.dumps(response),
             headers=[
         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:
                 route_method = route_intr[0].get('request_methods')[0]
 
                 return RouteRepresentation(
-                    # TODO BS 20171107: ce code n'es pas du tout finis
-                    # (import bottle)
-                    rule=BOTTLE_RE_PATH_URL.sub(
-                        r'{\1}',
-                        route_pattern,
-                    ),
+                    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:

tests/base.py

 
 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
 
     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,
         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

 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('/')
 
         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():
 
         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):
 
         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/test_doc.py

 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)
             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']
 
     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)
             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']
 
     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'])
             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']
 
     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)
             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']
 
     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()
             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

 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)
 
     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)
 
     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

 
 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)
 
         assert result == 42
 
     def test_unit__base_controller__ok__replaced_response(self):
-        context = MyContext()
+        context = MyContext(app=None)
         processor = MyProcessor()
         wrapper = MyControllerWrapper(context, processor)
 
         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)
 
 
 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)
 
         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,
         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,
 
 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)
 
                } == 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)
 
 class TestExceptionHandlerControllerWrapper(Base):
     def test_unit__exception_handled__ok__nominal_case(self):
-        context = MyContext()
+        context = MyContext(app=None)
         wrapper = ExceptionHandlerControllerWrapper(
             ZeroDivisionError,
             context,
                 super().__init__(*args, **kwargs)
                 self.error_dict = {}
 
-        context = MyContext()
+        context = MyContext(app=None)
         wrapper = ExceptionHandlerControllerWrapper(
             MyException,
             context,