Enhance controller references strategy and write tests

hapic/decorator.py

 DECORATION_ATTRIBUTE_NAME = '_hapic_decoration_token'
 
 
+class ControllerReference(object):
+    def __init__(
+        self,
+        wrapper: typing.Callable[..., typing.Any],
+        wrapped: typing.Callable[..., typing.Any],
+        token: str,
+    ) -> None:
+        """
+        This class is a centralization of different ways to match
+        final controller with decorated function:
+          - wrapper will match if final controller is the hapic returned
+            wrapper
+          - wrapped will match if final controller is the controller itself
+          - token will match if only apposed token still exist: This case
+            happen when hapic decoration is make on class function and final
+            controller is the same function but as instance function.
+
+        :param wrapper: Wrapper returned by decorator
+        :param wrapped: Function wrapped by decorator
+        :param token: String token set on these both functions
+        """
+        self.wrapper = wrapper
+        self.wrapped = wrapped
+        self.token = token
+
+
 class ControllerWrapper(object):
     def before_wrapped_func(
         self,
 class DecoratedController(object):
     def __init__(
         self,
-        token: str,
+        reference: ControllerReference,
         description: ControllerDescription,
         name: str='',
     ) -> None:
-        self._token = token
+        self._reference = reference
         self._description = description
         self._name = name
 
     @property
-    def token(self) -> str:
-        return self._token
+    def reference(self) -> ControllerReference:
+        return self._reference
 
     @property
     def description(self) -> ControllerDescription:

hapic/doc.py

 BOTTLE_RE_PATH_URL = re.compile(r'<(?:[^:<>]+:)?([^<>]+)>')
 
 
-def bottle_route_for_view(
+def find_bottle_route(
     decorated_controller: DecoratedController,
     app: bottle.Bottle,
 ):
+    if not app.routes:
+        # TODO BS 20171010: specialize exception
+        raise Exception('There is no routes in yout bottle app')
+
+    reference = decorated_controller.reference
     for route in app.routes:
         route_token = getattr(
             route.callback,
             DECORATION_ATTRIBUTE_NAME,
             None,
         )
-        if route_token == decorated_controller.token:
+
+        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: specialize exception
     # TODO BS 20171010: Raise exception or print error ?
         # with app.test_request_context():
         paths = {}
         for controller in controllers:
-            bottle_route = bottle_route_for_view(controller, app)
+            bottle_route = find_bottle_route(controller, app)
             swagger_path = BOTTLE_RE_PATH_URL.sub(r'{\1}', bottle_route.rule)
 
             operations = bottle_generate_operations(

hapic/hapic.py

 
 from hapic.buffer import DecorationBuffer
 from hapic.context import ContextInterface
-from hapic.decorator import DecoratedController, DECORATION_ATTRIBUTE_NAME
+from hapic.decorator import DecoratedController
+from hapic.decorator import DECORATION_ATTRIBUTE_NAME
+from hapic.decorator import ControllerReference
 from hapic.decorator import ExceptionHandlerControllerWrapper
 from hapic.decorator import InputBodyControllerWrapper
 from hapic.decorator import InputHeadersControllerWrapper
     def __init__(self):
         self._buffer = DecorationBuffer()
         self._controllers = []  # type: typing.List[DecoratedController]
-        self._context = None
+        self._context = None  # type: ContextInterface
 
         # This local function will be pass to different components
         # who will need context but declared (like with decorator)
 
         # TODO: Permettre la surcharge des classes utilisés ci-dessous
 
+    @property
+    def controllers(self) -> typing.List[DecoratedController]:
+        return self._controllers
+
+    @property
+    def context(self) -> ContextInterface:
+        return self._context
+
     def with_api_doc(self):
         def decorator(func):
 
 
             token = uuid.uuid4().hex
             setattr(wrapper, DECORATION_ATTRIBUTE_NAME, token)
+            setattr(func, DECORATION_ATTRIBUTE_NAME, token)
+
             description = self._buffer.get_description()
 
-            decorated_controller = DecoratedController(
+            reference = ControllerReference(
+                wrapper=wrapper,
+                wrapped=func,
                 token=token,
+            )
+            decorated_controller = DecoratedController(
+                reference=reference,
                 description=description,
                 name=func.__name__,
             )

tests/ext/__init__.py

+# -*- coding: utf-8 -*-

tests/ext/unit/__init__.py

+# -*- coding: utf-8 -*-

tests/ext/unit/test_bottle.py

+# -*- coding: utf-8 -*-
+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.bottle_context)
+
+        app = bottle.Bottle()
+
+        @hapic_.with_api_doc()
+        @app.route('/')
+        def controller_a():
+            pass
+
+        assert hapic_.controllers
+        decoration = hapic_.controllers[0]
+        route = find_bottle_route(decoration, app)
+
+        assert route
+        assert route.callback != controller_a
+        assert route.callback == decoration.reference.wrapped
+        assert route.callback != decoration.reference.wrapper
+
+    def test_unit__map_binding__ok__mapped_function(self):
+        hapic_ = hapic.Hapic()
+        hapic_.set_context(hapic.ext.bottle.bottle_context)
+
+        app = bottle.Bottle()
+
+        @hapic_.with_api_doc()
+        def controller_a():
+            pass
+
+        app.route('/', callback=controller_a)
+
+        assert hapic_.controllers
+        decoration = hapic_.controllers[0]
+        route = find_bottle_route(decoration, app)
+
+        assert route
+        assert route.callback == controller_a
+        assert route.callback == decoration.reference.wrapper
+        assert route.callback != decoration.reference.wrapped
+
+    def test_unit__map_binding__ok__mapped_method(self):
+        hapic_ = hapic.Hapic()
+        hapic_.set_context(hapic.ext.bottle.bottle_context)
+
+        app = bottle.Bottle()
+
+        class MyControllers(object):
+            def bind(self, app):
+                app.route('/', callback=self.controller_a)
+
+            @hapic_.with_api_doc()
+            def controller_a(self):
+                pass
+
+        my_controllers = MyControllers()
+        my_controllers.bind(app)
+
+        assert hapic_.controllers
+        decoration = hapic_.controllers[0]
+        route = find_bottle_route(decoration, app)
+
+        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

tests/unit/test_hapic.py

+# -*- coding: utf-8 -*-
+from hapic import Hapic
+from hapic.decorator import DECORATION_ATTRIBUTE_NAME
+from tests.base import Base
+
+
+class TestHapic(Base):
+    def test_unit__decoration__ok__simple_function(self):
+        hapic = Hapic()
+
+        @hapic.with_api_doc()
+        def controller_a():
+            pass
+
+        token = getattr(controller_a, DECORATION_ATTRIBUTE_NAME, None)
+        assert token
+
+        assert hapic.controllers
+        assert 1 == len(hapic.controllers)
+        reference = hapic.controllers[0].reference
+
+        assert token == reference.token
+        assert controller_a == reference.wrapper
+        assert controller_a != reference.wrapped
+
+    def test_unit__decoration__ok__method(self):
+        hapic = Hapic()
+
+        class MyControllers(object):
+            @hapic.with_api_doc()
+            def controller_a(self):
+                pass
+
+        my_controllers = MyControllers()
+        class_method_token = getattr(
+            MyControllers.controller_a,
+            DECORATION_ATTRIBUTE_NAME,
+            None,
+        )
+        assert class_method_token
+        instance_method_token = getattr(
+            my_controllers.controller_a,
+            DECORATION_ATTRIBUTE_NAME,
+            None,
+        )
+        assert instance_method_token
+
+        assert hapic.controllers
+        assert 1 == len(hapic.controllers)
+        reference = hapic.controllers[0].reference
+
+        assert class_method_token == reference.token
+        assert instance_method_token == reference.token
+
+        assert MyControllers.controller_a == reference.wrapper
+        assert MyControllers.controller_a != reference.wrapped
+        assert my_controllers.controller_a != reference.wrapper
+        assert my_controllers.controller_a != reference.wrapped