reorganize and write unit tests

.gitignore

@@ -2,4 +2,5 @@
 *.pyc
 __pycache__
 *~
-/venv
+/venv
+.cache

example_a.py

@@ -3,7 +3,7 @@ import bottle
 import hapic
 from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema, \
     ErrorResponseSchema
-from hapic.hapic import HapicData
+from hapic.data import HapicData
 
 app = bottle.Bottle()
 
@@ -15,10 +15,10 @@ def bob(f):
 
 
 @hapic.with_api_doc()
-@hapic.ext.bottle.bottle_context()
-@hapic.error_schema(ErrorResponseSchema())
+# @hapic.ext.bottle.bottle_context()
+# @hapic.error_schema(ErrorResponseSchema())
 @hapic.input_path(HelloPathSchema())
-@hapic.output(HelloResponseSchema())
+@hapic.output_body(HelloResponseSchema())
 def hello(name: str, hapic_data: HapicData):
     return {
         'sentence': 'Hello !',
@@ -27,11 +27,11 @@ def hello(name: str, hapic_data: HapicData):
 
 
 @hapic.with_api_doc()
-@hapic.ext.bottle.bottle_context()
-@hapic.error_schema(ErrorResponseSchema())
+# @hapic.ext.bottle.bottle_context()
+# @hapic.error_schema(ErrorResponseSchema())
 @hapic.input_path(HelloPathSchema())
 @hapic.input_body(HelloJsonSchema())
-@hapic.output(HelloResponseSchema())
+@hapic.output_body(HelloResponseSchema())
 @bob
 def hello2(name: str, hapic_data: HapicData):
     return {
@@ -44,10 +44,10 @@ kwargs = {'validated_data': {'name': 'bob'}, 'name': 'bob'}
 
 
 @hapic.with_api_doc()
-@hapic.ext.bottle.bottle_context()
-@hapic.error_schema(ErrorResponseSchema())
-@hapic.output(HelloResponseSchema())
-def hello3(name: str, hapic_data: HapicData):
+# @hapic.ext.bottle.bottle_context()
+# @hapic.error_schema(ErrorResponseSchema())
+@hapic.output_body(HelloResponseSchema())
+def hello3(name: str):
     return {
         'sentence': 'Hello !',
         'name': name,

example_b.py

@@ -2,8 +2,9 @@
 import bottle
 import hapic
 from example import HelloResponseSchema, HelloPathSchema, HelloJsonSchema
-from hapic.hapic import MarshmallowOutputProcessor, BottleContext, \
-    MarshmallowPathInputProcessor, MarshmallowJsonInputProcessor
+from hapic.hapic import MarshmallowPathInputProcessor, MarshmallowJsonInputProcessor
+from hapic import BottleContext
+from hapic.processor import MarshmallowOutputProcessor
 
 
 def bob(f):
@@ -15,7 +16,7 @@ def bob(f):
 @hapic.with_api_doc_bis()
 @bottle.route('/hello/<name>')
 @hapic.input(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
-@hapic.output(HelloResponseSchema(), MarshmallowOutputProcessor())
+@hapic.output_body(HelloResponseSchema(), MarshmallowOutputProcessor())
 @bob
 def hello(name: str):
     return "Hello {}!".format(name)
@@ -25,7 +26,7 @@ def hello(name: str):
 @bottle.route('/hello2/<name>')
 @hapic.input(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
 @hapic.input(HelloJsonSchema(), MarshmallowJsonInputProcessor(), context=BottleContext())  # nopep8
-@hapic.output(HelloResponseSchema())
+@hapic.output_body(HelloResponseSchema())
 @bob
 def hello2(name: str):
     return "Hello {}!".format(name)
@@ -33,7 +34,7 @@ def hello2(name: str):
 
 @hapic.with_api_doc_bis()
 @bottle.route('/hello3/<name>')
-@hapic.output(HelloResponseSchema())
+@hapic.output_body(HelloResponseSchema())
 def hello3(name: str):
     return "Hello {}!".format(name)
 
@@ -49,7 +50,7 @@ bottle.run(host='localhost', port=8080, debug=True)
 @hapic.input_header(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
 @hapic.input_query(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
 @hapic.input_path(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
-@hapic.output(HelloResponseSchema(), MarshmallowOutputProcessor())
+@hapic.output_body(HelloResponseSchema(), MarshmallowOutputProcessor())
 def hello(name: str, hapic_data):
     return "Hello {}!".format(name)
 
@@ -57,7 +58,7 @@ def hello(name: str, hapic_data):
 @hapic.with_api_doc_bis()
 @bottle.route('/hello/<name>')
 @hapic.input(HelloPathSchema(), MarshmallowPathInputProcessor(), context=BottleContext())  # nopep8
-@hapic.output(HelloResponseSchema(), MarshmallowOutputProcessor())
+@hapic.output_body(HelloResponseSchema(), MarshmallowOutputProcessor())
 @bob
 def hello(name: str):
     return "Hello {}!".format(name)

hapic/__init__.py

@@ -1,37 +1,44 @@
 # -*- coding: utf-8 -*-
-# from hapic.hapic import Hapic
-
-# _hapic_default = Hapic()
-#
-# with_api_doc = _hapic_default.with_api_doc
+from hapic.hapic import Hapic
+
+_hapic_default = Hapic()
+
+with_api_doc = _hapic_default.with_api_doc
+input_headers = _hapic_default.input_headers
+input_body = _hapic_default.input_body
+input_path = _hapic_default.input_path
+input_query = _hapic_default.input_query
+input_forms = _hapic_default.input_forms
+output_headers = _hapic_default.output_headers
+output_body = _hapic_default.output_body
 # with_api_doc_bis = _hapic_default.with_api_doc_bis
-# generate_doc = _hapic_default.generate_doc
-
-from hapic.hapic import with_api_doc
-from hapic.hapic import with_api_doc_bis
-from hapic.hapic import generate_doc
-from hapic.hapic import output
-from hapic.hapic import input_body
-from hapic.hapic import input_query
-from hapic.hapic import input_path
-from hapic.hapic import input_headers
-from hapic.hapic import BottleContext
-from hapic.hapic import set_fake_default_context
-from hapic.hapic import error_schema
-
-
-class FakeSetContext(object):
-    def bottle_context(self):
-        hapic.set_fake_default_context(BottleContext())
-        def decorator(func):
-            def wrapper(*args, **kwargs):
-                return func(*args, **kwargs)
-            return wrapper
-        return decorator
-
-
-class FakeExt(object):
-    bottle = FakeSetContext()
-
-
-ext = FakeExt()
+generate_doc = _hapic_default.generate_doc
+
+# from hapic.hapic import with_api_doc
+# from hapic.hapic import with_api_doc_bis
+# from hapic.hapic import generate_doc
+# from hapic.hapic import output_body
+# from hapic.hapic import input_body
+# from hapic.hapic import input_query
+# from hapic.hapic import input_path
+# from hapic.hapic import input_headers
+# from hapic.context import BottleContext
+# from hapic.hapic import set_fake_default_context
+# from hapic.hapic import error_schema
+
+
+# class FakeSetContext(object):
+#     def bottle_context(self):
+#         hapic.set_fake_default_context(BottleContext())
+#         def decorator(func):
+#             def wrapper(*args, **kwargs):
+#                 return func(*args, **kwargs)
+#             return wrapper
+#         return decorator
+#
+#
+# class FakeExt(object):
+#     bottle = FakeSetContext()
+#
+#
+# ext = FakeExt()

hapic/buffer.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+import typing
+
+from hapic.description import ControllerDescription
+from hapic.description import InputPathDescription
+from hapic.description import InputQueryDescription
+from hapic.description import InputBodyDescription
+from hapic.description import InputHeadersDescription
+from hapic.description import InputFormsDescription
+from hapic.description import OutputBodyDescription
+from hapic.description import OutputHeadersDescription
+from hapic.description import ErrorDescription
+from hapic.exception import AlreadyDecoratedException
+
+
+class DecorationBuffer(object):
+    def __init__(self) -> None:
+        self._description = ControllerDescription()
+
+    def clear(self):
+        self._description = ControllerDescription()
+
+    def get_description(self) -> ControllerDescription:
+        return self._description
+
+    @property
+    def input_path(self) -> InputPathDescription:
+        return self._description.input_path
+
+    @input_path.setter
+    def input_path(self, description: InputPathDescription) -> None:
+        if self._description.input_path is not None:
+            raise AlreadyDecoratedException()
+        self._description.input_path = description
+
+    @property
+    def input_query(self) -> InputQueryDescription:
+        return self._description.input_query
+
+    @input_query.setter
+    def input_query(self, description: InputQueryDescription) -> None:
+        if self._description.input_query is not None:
+            raise AlreadyDecoratedException()
+        self._description.input_query = description
+
+    @property
+    def input_body(self) -> InputBodyDescription:
+        return self._description.input_body
+
+    @input_body.setter
+    def input_body(self, description: InputBodyDescription) -> None:
+        if self._description.input_body is not None:
+            raise AlreadyDecoratedException()
+        self._description.input_body = description
+
+    @property
+    def input_headers(self) -> InputHeadersDescription:
+        return self._description.input_headers
+
+    @input_headers.setter
+    def input_headers(self, description: InputHeadersDescription) -> None:
+        if self._description.input_headers is not None:
+            raise AlreadyDecoratedException()
+        self._description.input_headers = description
+
+    @property
+    def input_forms(self) -> InputFormsDescription:
+        return self._description.input_forms
+
+    @input_forms.setter
+    def input_forms(self, description: InputFormsDescription) -> None:
+        if self._description.input_forms is not None:
+            raise AlreadyDecoratedException()
+        self._description.input_forms = description
+
+    @property
+    def output_body(self) -> OutputBodyDescription:
+        return self._description.output_body
+
+    @output_body.setter
+    def output_body(self, description: OutputBodyDescription) -> None:
+        if self._description.output_body is not None:
+            raise AlreadyDecoratedException()
+        self._description.output_body = description
+
+    @property
+    def output_headers(self) -> OutputHeadersDescription:
+        return self._description.output_headers
+
+    @output_headers.setter
+    def output_headers(self, description: OutputHeadersDescription) -> None:
+        if self._description.output_headers is not None:
+            raise AlreadyDecoratedException()
+        self._description.output_headers = description
+
+    @property
+    def errors(self) -> typing.List[ErrorDescription]:
+        return self._description.errors
+
+    def add_error(self, description: ErrorDescription) -> None:
+        self._description.errors.append(description)

hapic/context.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+import json
+import typing
+from http import HTTPStatus
+
+import bottle
+
+from hapic.exception import OutputValidationException
+# from hapic.hapic import _default_global_error_schema
+from hapic.processor import RequestParameters, ProcessValidationError
+
+
+class ContextInterface(object):
+    def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
+        raise NotImplementedError()
+
+    def get_response(
+        self,
+        response: dict,
+        http_code: int,
+    ) -> typing.Any:
+        raise NotImplementedError()
+
+    def get_validation_error_response(
+        self,
+        error: ProcessValidationError,
+        http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
+    ) -> typing.Any:
+        raise NotImplementedError()
+
+
+class BottleContext(ContextInterface):
+    def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
+        return RequestParameters(
+            path_parameters=bottle.request.url_args,
+            query_parameters=bottle.request.params,
+            body_parameters=bottle.request.json,
+            form_parameters=bottle.request.forms,
+            header_parameters=bottle.request.headers,
+        )
+
+    def get_response(
+        self,
+        response: dict,
+        http_code: int,
+    ) -> bottle.HTTPResponse:
+        return bottle.HTTPResponse(
+            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
+        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 bottle.HTTPResponse(
+            body=json.dumps(unmarshall.data),
+            headers=[
+                ('Content-Type', 'application/json'),
+            ],
+            status=int(http_code),
+        )
+

hapic/data.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+
+class HapicData(object):
+    def __init__(self):
+        self.body = {}
+        self.path = {}
+        self.query = {}
+        self.headers = {}
+        self.forms = {}

hapic/decorator.py

@@ -0,0 +1,261 @@
+# -*- coding: utf-8 -*-
+import typing
+from http import HTTPStatus
+
+from hapic.data import HapicData
+from hapic.description import ControllerDescription
+from hapic.exception import ProcessException
+from hapic.context import ContextInterface
+from hapic.processor import ProcessorInterface
+from hapic.processor import RequestParameters
+
+
+class ControllerWrapper(object):
+    def __init__(
+        self,
+        context: ContextInterface,
+        processor: ProcessorInterface,
+        error_http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
+        default_http_code: HTTPStatus=HTTPStatus.OK,
+    ) -> None:
+        self.context = context
+        self.processor = processor
+        self.error_http_code = error_http_code
+        self.default_http_code = default_http_code
+
+    def before_wrapped_func(
+        self,
+        func_args: typing.Tuple[typing.Any, ...],
+        func_kwargs: typing.Dict[str, typing.Any],
+    ) -> typing.Union[None, typing.Any]:
+        pass
+
+    def after_wrapped_function(self, response: typing.Any) -> typing.Any:
+        return response
+
+    def get_wrapper(
+        self,
+        func: 'typing.Callable[..., typing.Any]',
+    ) -> 'typing.Callable[..., typing.Any]':
+        def wrapper(*args, **kwargs) -> typing.Any:
+            # Note: Design of before_wrapped_func can be to update kwargs
+            # by reference here
+            replacement_response = self.before_wrapped_func(args, kwargs)
+            if replacement_response:
+                return replacement_response
+
+            response = func(*args, **kwargs)
+            new_response = self.after_wrapped_function(response)
+            return new_response
+        return wrapper
+
+
+class InputControllerWrapper(ControllerWrapper):
+    def before_wrapped_func(
+        self,
+        func_args: typing.Tuple[typing.Any, ...],
+        func_kwargs: typing.Dict[str, typing.Any],
+    ) -> typing.Any:
+        # Retrieve hapic_data instance or create new one
+        # hapic_data is given though decorators
+        # Important note here: func_kwargs is update by reference !
+        hapic_data = self.ensure_hapic_data(func_kwargs)
+        request_parameters = self.get_request_parameters(
+            func_args,
+            func_kwargs,
+        )
+
+        try:
+            processed_data = self.get_processed_data(request_parameters)
+            self.update_hapic_data(hapic_data, processed_data)
+        except ProcessException:
+            error_response = self.get_error_response(request_parameters)
+            return error_response
+
+    @classmethod
+    def ensure_hapic_data(
+        cls,
+        func_kwargs: typing.Dict[str, typing.Any],
+    ) -> HapicData:
+        # TODO: Permit other name than "hapic_data" ?
+        try:
+            return func_kwargs['hapic_data']
+        except KeyError:
+            hapic_data = HapicData()
+            func_kwargs['hapic_data'] = hapic_data
+            return hapic_data
+
+    def get_request_parameters(
+        self,
+        func_args: typing.Tuple[typing.Any, ...],
+        func_kwargs: typing.Dict[str, typing.Any],
+    ) -> RequestParameters:
+        return self.context.get_request_parameters(
+            *func_args,
+            **func_kwargs
+        )
+
+    def get_processed_data(
+        self,
+        request_parameters: RequestParameters,
+    ) -> typing.Any:
+        raise NotImplementedError()
+
+    def update_hapic_data(
+        self,
+        hapic_data: HapicData,
+        processed_data: typing.Dict[str, typing.Any],
+    ) -> None:
+        raise NotImplementedError()
+
+    def get_error_response(
+        self,
+        request_parameters: RequestParameters,
+    ) -> typing.Any:
+        error = self.processor.get_validation_error(
+            request_parameters.body_parameters,
+        )
+        error_response = self.context.get_validation_error_response(
+            error,
+            http_code=self.error_http_code,
+        )
+        return error_response
+
+
+class OutputControllerWrapper(ControllerWrapper):
+    def get_error_response(
+        self,
+        response: typing.Any,
+    ) -> typing.Any:
+        error = self.processor.get_validation_error(response)
+        error_response = self.context.get_validation_error_response(
+            error,
+            http_code=self.error_http_code,
+        )
+        return error_response
+
+    def after_wrapped_function(self, response: typing.Any) -> typing.Any:
+        try:
+            processed_response = self.processor.process(response)
+            prepared_response = self.context.get_response(
+                processed_response,
+                self.default_http_code,
+            )
+            return prepared_response
+        except ProcessException:
+            # TODO: ici ou ailleurs: il faut pas forcement donner le detail
+            # de l'erreur (mode debug par exemple)
+            error_response = self.get_error_response(response)
+            return error_response
+
+
+class DecoratedController(object):
+    def __init__(
+        self,
+        reference: 'typing.Callable[..., typing.Any]',
+        description: ControllerDescription,
+    ) -> None:
+        self._reference = reference
+        self._description = description
+
+    @property
+    def reference(self) -> 'typing.Callable[..., typing.Any]':
+        return self._reference
+
+    @property
+    def description(self) -> ControllerDescription:
+        return self._description
+
+
+class OutputBodyControllerWrapper(OutputControllerWrapper):
+    pass
+
+
+class OutputHeadersControllerWrapper(OutputControllerWrapper):
+    # TODO: write me
+    pass
+
+
+class InputPathControllerWrapper(InputControllerWrapper):
+    def update_hapic_data(
+        self, hapic_data: HapicData,
+        processed_data: typing.Any,
+    ) -> None:
+        hapic_data.path = processed_data
+
+    def get_processed_data(
+        self,
+        request_parameters: RequestParameters,
+    ) -> typing.Any:
+        processed_data = self.processor.process(
+            request_parameters.path_parameters,
+        )
+        return processed_data
+
+
+class InputQueryControllerWrapper(InputControllerWrapper):
+    def update_hapic_data(
+        self, hapic_data: HapicData,
+        processed_data: typing.Any,
+    ) -> None:
+        hapic_data.query = processed_data
+
+    def get_processed_data(
+        self,
+        request_parameters: RequestParameters,
+    ) -> typing.Any:
+        processed_data = self.processor.process(
+            request_parameters.query_parameters,
+        )
+        return processed_data
+
+
+class InputBodyControllerWrapper(InputControllerWrapper):
+    def update_hapic_data(
+        self, hapic_data: HapicData,
+        processed_data: typing.Any,
+    ) -> None:
+        hapic_data.body = processed_data
+
+    def get_processed_data(
+        self,
+        request_parameters: RequestParameters,
+    ) -> typing.Any:
+        processed_data = self.processor.process(
+            request_parameters.body_parameters,
+        )
+        return processed_data
+
+
+class InputHeadersControllerWrapper(InputControllerWrapper):
+    def update_hapic_data(
+        self, hapic_data: HapicData,
+        processed_data: typing.Any,
+    ) -> None:
+        hapic_data.headers = processed_data
+
+    def get_processed_data(
+        self,
+        request_parameters: RequestParameters,
+    ) -> typing.Any:
+        processed_data = self.processor.process(
+            request_parameters.header_parameters,
+        )
+        return processed_data
+
+
+class InputFormsControllerWrapper(InputControllerWrapper):
+    def update_hapic_data(
+        self, hapic_data: HapicData,
+        processed_data: typing.Any,
+    ) -> None:
+        hapic_data.forms = processed_data
+
+    def get_processed_data(
+        self,
+        request_parameters: RequestParameters,
+    ) -> typing.Any:
+        processed_data = self.processor.process(
+            request_parameters.form_parameters,
+        )
+        return processed_data

hapic/description.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+import typing
+
+if typing.TYPE_CHECKING:
+    from hapic.decorator import ControllerWrapper
+
+
+class Description(object):
+    def __init__(self, wrapper: 'ControllerWrapper') -> None:
+        self.wrapper = wrapper
+
+
+class InputPathDescription(Description):
+    pass
+
+
+class InputQueryDescription(Description):
+    pass
+
+
+class InputBodyDescription(Description):
+    pass
+
+
+class InputHeadersDescription(Description):
+    pass
+
+
+class InputFormsDescription(Description):
+    pass
+
+
+class OutputBodyDescription(Description):
+    pass
+
+
+class OutputHeadersDescription(Description):
+    pass
+
+
+class ErrorDescription(Description):
+    pass
+
+
+class ControllerDescription(object):
+    def __init__(
+        self,
+        input_path: InputPathDescription=None,
+        input_query: InputQueryDescription=None,
+        input_body: InputBodyDescription=None,
+        input_headers: InputHeadersDescription=None,
+        input_forms: InputFormsDescription=None,
+        output_body: OutputBodyDescription=None,
+        output_headers: OutputHeadersDescription=None,
+        errors: typing.List[ErrorDescription]=None,
+    ):
+        self.input_path = input_path
+        self.input_query = input_query
+        self.input_body = input_body
+        self.input_headers = input_headers
+        self.input_forms = input_forms
+        self.output_body = output_body
+        self.output_headers = output_headers
+        self.errors = errors or []

hapic/exception.py

@@ -9,6 +9,14 @@ class WorkflowException(HapicException):
     pass
 
 
+class DecorationException(HapicException):
+    pass
+
+
+class AlreadyDecoratedException(DecorationException):
+    pass
+
+
 class ProcessException(HapicException):
     pass
 

hapic/hapic.py

@@ -1,422 +1,251 @@
 # -*- coding: utf-8 -*-
-import json
 import typing
 from http import HTTPStatus
 
-import functools
-
 import bottle
-
-# TODO: Gérer les erreurs de schema
-# TODO: Gérer les cas ou c'est une liste la réponse (items, item_nb)
-
+import functools
 
 # CHANGE
-from hapic.exception import InputValidationException, \
-    OutputValidationException, InputWorkflowException, ProcessException
+import marshmallow
+
+from hapic.buffer import DecorationBuffer
+from hapic.context import ContextInterface, BottleContext
+from hapic.decorator import DecoratedController
+from hapic.decorator import InputBodyControllerWrapper
+from hapic.decorator import InputHeadersControllerWrapper
+from hapic.decorator import InputPathControllerWrapper
+from hapic.decorator import InputQueryControllerWrapper
+from hapic.decorator import OutputBodyControllerWrapper
+from hapic.decorator import OutputHeadersControllerWrapper
+from hapic.description import InputBodyDescription
+from hapic.description import InputFormsDescription
+from hapic.description import InputHeadersDescription
+from hapic.description import InputPathDescription
+from hapic.description import InputQueryDescription
+from hapic.description import OutputBodyDescription
+from hapic.description import OutputHeadersDescription
+from hapic.processor import ProcessorInterface, MarshmallowInputProcessor
 
 flatten = lambda l: [item for sublist in l for item in sublist]
 
+# TODO: Gérer les erreurs de schema
+# TODO: Gérer les cas ou c'est une liste la réponse (items, item_nb)
+# TODO: Confusion nommage body/json/forms
 
-_waiting = {}
-_endpoints = {}
-_default_global_context = None
-_default_global_error_schema = None
-
-
-def error_schema(schema):
-    global _default_global_error_schema
-    _default_global_error_schema = schema
-
-    def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-        return wrapper
-    return decorator
-
-
-def set_fake_default_context(context):
-    global _default_global_context
-    _default_global_context = context
-
-
-def _register(func):
-    assert func not in _endpoints
-    global _waiting
-
-    _endpoints[func] = _waiting
-    _waiting = {}
-
-
-def with_api_doc():
-    def decorator(func):
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
-
-        _register(wrapper)
-        return wrapper
-
-    return decorator
-
-
-def with_api_doc_bis():
-    def decorator(func):
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            return func(*args, **kwargs)
+# _waiting = {}
+# _endpoints = {}
+# TODO NOW: C'est un gros gros fake !
+class ErrorResponseSchema(marshmallow.Schema):
+    error_message = marshmallow.fields.String(required=True)
+    error_details = marshmallow.fields.Dict(required=True)
 
-        _register(func)
-        return wrapper
+_default_global_context = BottleContext()
+_default_global_error_schema = ErrorResponseSchema()
 
-    return decorator
 
+class Hapic(object):
+    def __init__(self):
+        self._buffer = DecorationBuffer()
+        self._controllers = []
 
-def generate_doc(app=None):
-    # TODO @Damien bottle specific code !
-    app = app or bottle.default_app()
+    def with_api_doc(self):
+        def decorator(func):
 
-    route_by_callbacks = []
-    routes = flatten(app.router.dyna_routes.values())
-    for path, path_regex, route, func_ in routes:
-        route_by_callbacks.append(route.callback)
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
 
-    for func, descriptions in _endpoints.items():
-        routes = flatten(app.router.dyna_routes.values())
-        for path, path_regex, route, func_ in routes:
-            if route.callback == func:
-                print(route.method, path, descriptions)
-                continue
+            description = self._buffer.get_description()
+            decorated_controller = DecoratedController(
+                reference=wrapper,
+                description=description,
+            )
+            self._buffer.clear()
+            self._controllers.append(decorated_controller)
+            return wrapper
 
+        return decorator
 
-class RequestParameters(object):
-    def __init__(
-        self,
-        path_parameters,
-        query_parameters,
-        body_parameters,
-        form_parameters,
-        header_parameters,
-    ):
-        self.path_parameters = path_parameters
-        self.query_parameters = query_parameters
-        self.body_parameters = body_parameters
-        self.form_parameters = form_parameters
-        self.header_parameters = header_parameters
-
-
-class ProcessValidationError(object):
-    def __init__(
+    def output_body(
         self,
-        error_message: str,
-        error_details: dict,
-    ) -> None:
-        self.error_message = error_message
-        self.error_details = error_details
-
+        schema: typing.Any,
+        processor: ProcessorInterface = None,
+        context: ContextInterface = None,
+        error_http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
+        default_http_code: HTTPStatus = HTTPStatus.OK,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
+        processor = processor or MarshmallowInputProcessor()
+        processor.schema = schema
+        context = context or _default_global_context
+
+        decoration = OutputBodyControllerWrapper(
+            context=context,
+            processor=processor,
+            error_http_code=error_http_code,
+            default_http_code=default_http_code,
+        )
 
-class ContextInterface(object):
-    def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
-        raise NotImplementedError()
+        def decorator(func):
+            self._buffer.output_body = OutputBodyDescription(decoration)
+            return decoration.get_wrapper(func)
+        return decorator
 
-    def get_response(
+    def output_headers(
         self,
-        response: dict,
-        http_code: int,
-    ) -> typing.Any:
-        raise NotImplementedError()
-
-    def get_validation_error_response(
-        self,
-        error: ProcessValidationError,
-        http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
-    ) -> typing.Any:
-        raise NotImplementedError()
-
-
-class BottleContext(ContextInterface):
-    def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
-        return RequestParameters(
-            path_parameters=bottle.request.url_args,
-            query_parameters=bottle.request.params,
-            body_parameters=bottle.request.json,
-            form_parameters=bottle.request.forms,
-            header_parameters=bottle.request.headers,
+        schema: typing.Any,
+        processor: ProcessorInterface = None,
+        context: ContextInterface = None,
+        error_http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
+        default_http_code: HTTPStatus = HTTPStatus.OK,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
+        processor = processor or MarshmallowInputProcessor()
+        processor.schema = schema
+        context = context or _default_global_context
+
+        decoration = OutputHeadersControllerWrapper(
+            context=context,
+            processor=processor,
+            error_http_code=error_http_code,
+            default_http_code=default_http_code,
         )
 
-    def get_response(
-        self,
-        response: dict,
-        http_code: int,
-    ) -> bottle.HTTPResponse:
-        return bottle.HTTPResponse(
-            body=json.dumps(response),
-            headers=[
-                ('Content-Type', 'application/json'),
-            ],
-            status=http_code,
-        )
+        def decorator(func):
+            self._buffer.output_headers = OutputHeadersDescription(decoration)
+            return decoration.get_wrapper(func)
+        return decorator
 
-    def get_validation_error_response(
+    def input_headers(
         self,
-        error: ProcessValidationError,
-        http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
-    ) -> typing.Any:
-        unmarshall = _default_global_error_schema.dump(error)
-        if unmarshall.errors:
-            raise OutputValidationException(
-                'Validation error during dump of error response: {}'.format(
-                    str(unmarshall.errors)
-                )
-            )
-
-        return bottle.HTTPResponse(
-            body=json.dumps(unmarshall.data),
-            headers=[
-                ('Content-Type', 'application/json'),
-            ],
-            status=int(http_code),
+        schema: typing.Any,
+        processor: ProcessorInterface = None,
+        context: ContextInterface = None,
+        error_http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
+        default_http_code: HTTPStatus = HTTPStatus.OK,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
+        processor = processor or MarshmallowInputProcessor()
+        processor.schema = schema
+        context = context or _default_global_context
+
+        decoration = InputHeadersControllerWrapper(
+            context=context,
+            processor=processor,
+            error_http_code=error_http_code,
+            default_http_code=default_http_code,
         )
 
+        def decorator(func):
+            self._buffer.input_headers = InputHeadersDescription(decoration)
+            return decoration.get_wrapper(func)
+        return decorator
 
-class OutputProcessorInterface(object):
-    def __init__(self):
-        self.schema = None
-
-    def process(self, value):
-        raise NotImplementedError
-
-    def get_validation_error(
+    def input_path(
         self,
-        request_context: RequestParameters,
-    ) -> ProcessValidationError:
-        raise NotImplementedError
-
-
-class InputProcessorInterface(object):
-    def __init__(self):
-        self.schema = None
+        schema: typing.Any,
+        processor: ProcessorInterface = None,
+        context: ContextInterface = None,
+        error_http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
+        default_http_code: HTTPStatus = HTTPStatus.OK,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
+        processor = processor or MarshmallowInputProcessor()
+        processor.schema = schema
+        context = context or _default_global_context
+
+        decoration = InputPathControllerWrapper(
+            context=context,
+            processor=processor,
+            error_http_code=error_http_code,
+            default_http_code=default_http_code,
+        )
 
-    def process(
-        self,
-        request_context: RequestParameters,
-    ) -> typing.Any:
-        raise NotImplementedError
+        def decorator(func):
+            self._buffer.input_path = InputPathDescription(decoration)
+            return decoration.get_wrapper(func)
+        return decorator
 
-    def get_validation_error(
+    def input_query(
         self,
-        request_context: RequestParameters,
-    ) -> ProcessValidationError:
-        raise NotImplementedError
-
-
-class MarshmallowOutputProcessor(OutputProcessorInterface):
-    def process(self, data: typing.Any):
-        unmarshall = self.schema.dump(data)
-        if unmarshall.errors:
-            raise InputValidationException(
-                'Error when validate input: {}'.format(
-                    str(unmarshall.errors),
-                )
-            )
-
-        return unmarshall.data
-
-    def get_validation_error(self, data: dict) -> ProcessValidationError:
-        marshmallow_errors = self.schema.dump(data).errors
-        return ProcessValidationError(
-            error_message='Validation error of output data',
-            error_details=marshmallow_errors,
+        schema: typing.Any,
+        processor: ProcessorInterface = None,
+        context: ContextInterface = None,
+        error_http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
+        default_http_code: HTTPStatus = HTTPStatus.OK,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
+        processor = processor or MarshmallowInputProcessor()
+        processor.schema = schema
+        context = context or _default_global_context
+
+        decoration = InputQueryControllerWrapper(
+            context=context,
+            processor=processor,
+            error_http_code=error_http_code,
+            default_http_code=default_http_code,
         )
 
+        def decorator(func):
+            self._buffer.input_query = InputQueryDescription(decoration)
+            return decoration.get_wrapper(func)
+        return decorator
 
-class MarshmallowInputProcessor(OutputProcessorInterface):
-    def process(self, data: dict):
-        unmarshall = self.schema.load(data)
-        if unmarshall.errors:
-            raise OutputValidationException(
-                'Error when validate ouput: {}'.format(
-                    str(unmarshall.errors),
-                )
-            )
-
-        return unmarshall.data
-
-    def get_validation_error(self, data: dict) -> ProcessValidationError:
-        marshmallow_errors = self.schema.load(data).errors
-        return ProcessValidationError(
-            error_message='Validation error of input data',
-            error_details=marshmallow_errors,
+    def input_body(
+        self,
+        schema: typing.Any,
+        processor: ProcessorInterface = None,
+        context: ContextInterface = None,
+        error_http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
+        default_http_code: HTTPStatus = HTTPStatus.OK,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
+        processor = processor or MarshmallowInputProcessor()
+        processor.schema = schema
+        context = context or _default_global_context
+
+        decoration = InputBodyControllerWrapper(
+            context=context,
+            processor=processor,
+            error_http_code=error_http_code,
+            default_http_code=default_http_code,
         )
 
+        def decorator(func):
+            self._buffer.input_body = InputBodyDescription(decoration)
+            return decoration.get_wrapper(func)
+        return decorator
 
-class HapicData(object):
-    def __init__(self):
-        self.body = {}
-        self.path = {}
-        self.query = {}
-        self.headers = {}
-
-
-# TODO: Il faut un output_body et un output_header
-def output(
-    schema,
-    processor: OutputProcessorInterface=None,
-    context: ContextInterface=None,
-    default_http_code=200,
-    default_error_code=500,
-):
-    processor = processor or MarshmallowOutputProcessor()
-    processor.schema = schema
-    context = context or _default_global_context
-
-    def decorator(func):
-        # @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            raw_response = func(*args, **kwargs)
-            processed_response = processor.process(raw_response)
-            prepared_response = context.get_response(
-                processed_response,
-                default_http_code,
-            )
-            return prepared_response
-
-        _waiting['output'] = schema
-
-        return wrapper
-    return decorator
-
-# TODO: raccourcis 'input' tout court ?
-def input_body(
-    schema,
-    processor: InputProcessorInterface=None,
-    context: ContextInterface=None,
-    error_http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
-):
-    processor = processor or MarshmallowInputProcessor()
-    processor.schema = schema
-    context = context or _default_global_context
-
-    def decorator(func):
-
-        # @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            updated_kwargs = {'hapic_data': HapicData()}
-            updated_kwargs.update(kwargs)
-            hapic_data = updated_kwargs['hapic_data']
-
-            request_parameters = context.get_request_parameters(
-                *args,
-                **updated_kwargs
-            )
-
-            try:
-                hapic_data.body = processor.process(
-                    request_parameters.body_parameters,
-                )
-            except ProcessException:
-                error = processor.get_validation_error(
-                    request_parameters.body_parameters,
-                )
-                error_response = context.get_validation_error_response(
-                    error,
-                    http_code=error_http_code,
-                )
-                return error_response
-
-            return func(*args, **updated_kwargs)
-
-        _waiting.setdefault('input', []).append(schema)
-
-        return wrapper
-    return decorator
-
-
-def input_path(
-    schema,
-    processor: InputProcessorInterface=None,
-    context: ContextInterface=None,
-    error_http_code=400,
-):
-    processor = processor or MarshmallowInputProcessor()
-    processor.schema = schema
-    context = context or _default_global_context
-
-    def decorator(func):
-
-        # @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            updated_kwargs = {'hapic_data': HapicData()}
-            updated_kwargs.update(kwargs)
-            hapic_data = updated_kwargs['hapic_data']
-
-            request_parameters = context.get_request_parameters(*args, **updated_kwargs)
-            hapic_data.path = processor.process(request_parameters.path_parameters)
-
-            return func(*args, **updated_kwargs)
-
-        _waiting.setdefault('input', []).append(schema)
-
-        return wrapper
-    return decorator
-
-
-def input_query(
-    schema,
-    processor: InputProcessorInterface=None,
-    context: ContextInterface=None,
-    error_http_code=400,
-):
-    processor = processor or MarshmallowInputProcessor()
-    processor.schema = schema
-    context = context or _default_global_context
-
-    def decorator(func):
-
-        # @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            updated_kwargs = {'hapic_data': HapicData()}
-            updated_kwargs.update(kwargs)
-            hapic_data = updated_kwargs['hapic_data']
-
-            request_parameters = context.get_request_parameters(*args, **updated_kwargs)
-            hapic_data.query = processor.process(request_parameters.query_parameters)
-
-            return func(*args, **updated_kwargs)
-
-        _waiting.setdefault('input', []).append(schema)
-
-        return wrapper
-    return decorator
-
-
-def input_headers(
-    schema,
-    processor: InputProcessorInterface,
-    context: ContextInterface=None,
-    error_http_code=400,
-):
-    processor = processor or MarshmallowInputProcessor()
-    processor.schema = schema
-    context = context or _default_global_context
-
-    def decorator(func):
-
-        # @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            updated_kwargs = {'hapic_data': HapicData()}
-            updated_kwargs.update(kwargs)
-            hapic_data = updated_kwargs['hapic_data']
-
-            request_parameters = context.get_request_parameters(*args, **updated_kwargs)
-            hapic_data.headers = processor.process(request_parameters.header_parameters)
+    def input_forms(
+        self,
+        schema: typing.Any,
+        processor: ProcessorInterface=None,
+        context: ContextInterface=None,
+        error_http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
+        default_http_code: HTTPStatus = HTTPStatus.OK,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
+        processor = processor or MarshmallowInputProcessor()
+        processor.schema = schema
+        context = context or _default_global_context
+
+        decoration = InputBodyControllerWrapper(
+            context=context,
+            processor=processor,
+            error_http_code=error_http_code,
+            default_http_code=default_http_code,
+        )
 
-            return func(*args, **updated_kwargs)
+        def decorator(func):
+            self._buffer.input_forms = InputFormsDescription(decoration)
+            return decoration.get_wrapper(func)
+        return decorator
 
-        _waiting.setdefault('input', []).append(schema)
+    def generate_doc(self, app=None):
+        # TODO @Damien bottle specific code !
+        app = app or bottle.default_app()
 
-        return wrapper
-    return decorator
+        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

hapic/processor.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+import typing
+
+from hapic.exception import InputValidationException, OutputValidationException
+
+
+class RequestParameters(object):
+    def __init__(
+        self,
+        path_parameters,
+        query_parameters,
+        body_parameters,
+        form_parameters,
+        header_parameters,
+    ):
+        self.path_parameters = path_parameters
+        self.query_parameters = query_parameters
+        self.body_parameters = body_parameters
+        self.form_parameters = form_parameters
+        self.header_parameters = header_parameters
+
+
+class ProcessValidationError(object):
+    def __init__(
+        self,
+        error_message: str,
+        error_details: dict,
+    ) -> None:
+        self.error_message = error_message
+        self.error_details = error_details
+
+
+class ProcessorInterface(object):
+    def __init__(self):
+        self.schema = None
+
+    def process(self, value):
+        raise NotImplementedError
+
+    def get_validation_error(
+        self,
+        request_context: RequestParameters,
+    ) -> ProcessValidationError:
+        raise NotImplementedError
+
+
+class InputProcessor(ProcessorInterface):
+    pass
+
+
+class OutputProcessor(ProcessorInterface):
+    pass
+
+
+class MarshmallowOutputProcessor(OutputProcessor):
+    def process(self, data: typing.Any):
+        unmarshall = self.schema.dump(data)
+        # TODO: Il n'y a jamais rien dans le error au dump. il faut check le
+        # data au travers de .validate
+        if unmarshall.errors:
+            raise InputValidationException(
+                'Error when validate input: {}'.format(
+                    str(unmarshall.errors),
+                )
+            )
+
+        return unmarshall.data
+
+    def get_validation_error(self, data: dict) -> ProcessValidationError:
+        marshmallow_errors = self.schema.dump(data).errors
+        return ProcessValidationError(
+            error_message='Validation error of output data',
+            error_details=marshmallow_errors,
+        )
+
+
+class MarshmallowInputProcessor(OutputProcessor):
+    def process(self, data: dict):
+        unmarshall = self.schema.load(data)
+        if unmarshall.errors:
+            raise OutputValidationException(
+                'Error when validate ouput: {}'.format(
+                    str(unmarshall.errors),
+                )
+            )
+
+        return unmarshall.data
+
+    def get_validation_error(self, data: dict) -> ProcessValidationError:
+        marshmallow_errors = self.schema.load(data).errors
+        return ProcessValidationError(
+            error_message='Validation error of input data',
+            error_details=marshmallow_errors,
+        )
+

hapic/util.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

tests/base.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+class Base(object):
+    pass

tests/unit/test_buffer.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+from unittest import mock
+
+import pytest
+
+from hapic.buffer import DecorationBuffer
+from hapic.description import InputPathDescription
+from hapic.description import InputQueryDescription
+from hapic.description import InputBodyDescription
+from hapic.description import InputHeadersDescription
+from hapic.description import InputFormsDescription
+from hapic.description import OutputBodyDescription
+from hapic.description import OutputHeadersDescription
+from hapic.description import ErrorDescription
+from hapic.exception import AlreadyDecoratedException
+from tests.base import Base
+
+fake_controller_wrapper = mock.MagicMock()
+
+
+class TestBuffer(Base):
+    def test_unit__buffer_usage__ok__set_descriptions(self):
+        buffer = DecorationBuffer()
+
+        input_path_description = InputPathDescription(fake_controller_wrapper)
+        input_query_description = InputQueryDescription(fake_controller_wrapper)  # nopep8
+        input_body_description = InputBodyDescription(fake_controller_wrapper)
+        input_headers_description = InputHeadersDescription(fake_controller_wrapper)  # nopep8
+        input_forms_description = InputFormsDescription(fake_controller_wrapper)  # nopep8
+        output_headers_description = OutputHeadersDescription(fake_controller_wrapper)  # nopep8
+        output_body_description = OutputBodyDescription(fake_controller_wrapper)  # nopep8
+        error_description = ErrorDescription(fake_controller_wrapper)
+
+        buffer.input_path = input_path_description
+        buffer.input_query = input_query_description
+        buffer.input_body = input_body_description
+        buffer.input_headers = input_headers_description
+        buffer.input_forms = input_forms_description
+        buffer.output_headers = output_headers_description
+        buffer.output_body = output_body_description
+        buffer.add_error(error_description)
+
+        description = buffer.get_description()
+        assert description.input_path == input_path_description
+        assert description.input_query == input_query_description
+        assert description.input_body == input_body_description
+        assert description.input_headers == input_headers_description
+        assert description.input_forms == input_forms_description
+        assert description.output_headers == output_headers_description
+        assert description.output_body == output_body_description
+        assert description.errors == [error_description]
+
+        buffer.clear()
+        description = buffer.get_description()
+
+        assert description.input_path is None
+        assert description.input_query is None
+        assert description.input_body is None
+        assert description.input_headers is None
+        assert description.input_forms is None
+        assert description.output_headers is None
+        assert description.output_body is None
+        assert description.errors == []
+
+    def test_unit__buffer_usage__error__cant_replace(self):
+        buffer = DecorationBuffer()
+
+        input_path_description = InputPathDescription(fake_controller_wrapper)
+        input_query_description = InputQueryDescription(fake_controller_wrapper)  # nopep8
+        input_body_description = InputBodyDescription(fake_controller_wrapper)
+        input_headers_description = InputHeadersDescription(fake_controller_wrapper)  # nopep8
+        input_forms_description = InputFormsDescription(fake_controller_wrapper)  # nopep8
+        output_headers_description = OutputHeadersDescription(fake_controller_wrapper)  # nopep8
+        output_body_description = OutputBodyDescription(fake_controller_wrapper)  # nopep8
+
+        buffer.input_path = input_path_description
+        buffer.input_query = input_query_description
+        buffer.input_body = input_body_description
+        buffer.input_headers = input_headers_description
+        buffer.input_forms = input_forms_description
+        buffer.output_headers = output_headers_description
+        buffer.output_body = output_body_description
+
+        with pytest.raises(AlreadyDecoratedException):
+            buffer.input_path = input_path_description
+
+        with pytest.raises(AlreadyDecoratedException):
+            buffer.input_query = input_query_description
+
+        with pytest.raises(AlreadyDecoratedException):
+            buffer.input_body = input_body_description
+
+        with pytest.raises(AlreadyDecoratedException):
+            buffer.input_headers = input_headers_description
+
+        with pytest.raises(AlreadyDecoratedException):
+            buffer.input_forms = input_forms_description
+
+        with pytest.raises(AlreadyDecoratedException):
+            buffer.output_headers = output_headers_description
+
+        with pytest.raises(AlreadyDecoratedException):
+            buffer.output_body = output_body_description

tests/unit/test_decorator.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+import typing
+from http import HTTPStatus
+
+from hapic.context import ContextInterface
+from hapic.data import HapicData
+from hapic.decorator import ControllerWrapper
+from hapic.decorator import InputControllerWrapper
+from hapic.decorator import OutputControllerWrapper
+from hapic.processor import RequestParameters
+from hapic.processor import ProcessValidationError
+from hapic.processor import ProcessorInterface
+from tests.base import Base
+
+
+class MyContext(ContextInterface):
+    def get_request_parameters(self, *args, **kwargs) -> RequestParameters:
+        return RequestParameters(
+            path_parameters={'fake': args},
+            query_parameters={},
+            body_parameters={},
+            form_parameters={},
+            header_parameters={},
+        )
+
+    def get_response(
+        self,
+        response: dict,
+        http_code: int,
+    ) -> typing.Any:
+        return {
+            'original_response': response,
+            'http_code': http_code,
+        }
+
+    def get_validation_error_response(
+        self,
+        error: ProcessValidationError,
+        http_code: HTTPStatus=HTTPStatus.BAD_REQUEST,
+    ) -> typing.Any:
+        return {
+            'original_error': error,
+            'http_code': http_code,
+        }
+
+
+class MyProcessor(ProcessorInterface):
+    def process(self, value):
+        return value + 1
+
+    def get_validation_error(
+        self,
+        request_context: RequestParameters,
+    ) -> ProcessValidationError:
+        return ProcessValidationError(
+            error_details={
+                'original_request_context': request_context,
+            },
+            error_message='ERROR',
+        )
+
+
+class MyControllerWrapper(ControllerWrapper):
+    def before_wrapped_func(
+        self,
+        func_args: typing.Tuple[typing.Any, ...],
+        func_kwargs: typing.Dict[str, typing.Any],
+    ) -> typing.Union[None, typing.Any]:
+        if func_args and func_args[0] == 666:
+            return {
+                'error_response': 'we are testing'
+            }
+
+        func_kwargs['added_parameter'] = 'a value'
+
+    def after_wrapped_function(self, response: typing.Any) -> typing.Any:
+        return response * 2
+
+
+class MyInputControllerWrapper(InputControllerWrapper):
+    def get_processed_data(
+        self,
+        request_parameters: RequestParameters,
+    ) -> typing.Any:
+        return {'we_are_testing': request_parameters.path_parameters}
+
+    def update_hapic_data(
+        self,
+        hapic_data: HapicData,
+        processed_data: typing.Dict[str, typing.Any],
+    ) -> typing.Any:
+        hapic_data.query = processed_data
+
+
+class TestControllerWrapper(Base):
+    def test_unit__base_controller_wrapper__ok__no_behaviour(self):
+        context = MyContext()
+        processor = MyProcessor()
+        wrapper = ControllerWrapper(context, processor)
+
+        @wrapper.get_wrapper
+        def func(foo):
+            return foo
+
+        result = func(42)
+        assert result == 42
+
+    def test_unit__base_controller__ok__replaced_response(self):
+        context = MyContext()
+        processor = MyProcessor()
+        wrapper = MyControllerWrapper(context, processor)
+
+        @wrapper.get_wrapper
+        def func(foo):
+            return foo
+
+        # see MyControllerWrapper#before_wrapped_func
+        result = func(666)
+        # result have been replaced by MyControllerWrapper#before_wrapped_func
+        assert {'error_response': 'we are testing'} == result
+
+    def test_unit__controller_wrapper__ok__overload_input(self):
+        context = MyContext()
+        processor = MyProcessor()
+        wrapper = MyControllerWrapper(context, processor)
+
+        @wrapper.get_wrapper
+        def func(foo, added_parameter=None):
+            # see MyControllerWrapper#before_wrapped_func
+            assert added_parameter == 'a value'
+            return foo
+
+        result = func(42)
+        # See MyControllerWrapper#after_wrapped_function
+        assert result == 84
+
+
+class TestInputControllerWrapper(Base):
+    def test_unit__input_data_wrapping__ok__nominal_case(self):
+        context = MyContext()
+        processor = MyProcessor()
+        wrapper = MyInputControllerWrapper(context, processor)
+
+        @wrapper.get_wrapper
+        def func(foo, hapic_data=None):
+            assert hapic_data
+            assert isinstance(hapic_data, HapicData)
+            # see MyControllerWrapper#before_wrapped_func
+            assert hapic_data.query == {'we_are_testing': {'fake': (42,)}}
+            return foo
+
+        result = func(42)
+        assert result == 42
+
+
+class TestOutputControllerWrapper(Base):
+    def test_unit__output_data_wrapping__ok__nominal_case(self):
+        context = MyContext()
+        processor = MyProcessor()
+        wrapper = OutputControllerWrapper(context, processor)
+
+        @wrapper.get_wrapper
+        def func(foo, hapic_data=None):
+            # If no use of input wrapper, no hapic_data is given
+            assert not hapic_data
+            return foo
+
+        result = func(42)
+        # see MyProcessor#process
+        assert {
+                   'http_code': HTTPStatus.OK,
+                   'original_response': 43,
+               } == result

tests/unit/test_processor.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+import marshmallow as marshmallow
+import pytest
+
+from hapic.exception import OutputValidationException
+from hapic.processor import MarshmallowOutputProcessor
+from hapic.processor import MarshmallowInputProcessor
+from tests.base import Base
+
+
+class MySchema(marshmallow.Schema):
+    first_name = marshmallow.fields.String(required=True)
+    last_name = marshmallow.fields.String(missing='Doe')
+
+
+class TestProcessor(Base):
+    def test_unit__marshmallow_output_processor__ok__process_success(self):
+        processor = MarshmallowOutputProcessor()
+        processor.schema = MySchema()
+
+        tested_data = {
+            'first_name': 'Alan',
+            'last_name': 'Turing',
+        }
+        data = processor.process(tested_data)
+
+        assert data == tested_data
+
+    def test_unit__marshmallow_output_processor__ok__missing_data(self):
+        """
+        Important note: Actually marshmallow don't validate when deserialize.
+        But we think about make it possible:
+        https://github.com/marshmallow-code/marshmallow/issues/684
+        """
+        processor = MarshmallowOutputProcessor()
+        processor.schema = MySchema()
+
+        tested_data = {
+            'last_name': 'Turing',
+        }
+
+        data = processor.process(tested_data)
+        assert {
+            'last_name': 'Turing',
+        } == data
+
+    def test_unit__marshmallow_input_processor__ok__process_success(self):
+        processor = MarshmallowInputProcessor()
+        processor.schema = MySchema()
+
+        tested_data = {
+            'first_name': 'Alan',
+            'last_name': 'Turing',
+        }
+        data = processor.process(tested_data)
+
+        assert data == tested_data
+
+    def test_unit__marshmallow_input_processor__error__validation_error(self):
+        processor = MarshmallowInputProcessor()
+        processor.schema = MySchema()
+
+        tested_data = {
+            'last_name': 'Turing',
+        }
+
+        with pytest.raises(OutputValidationException):
+            processor.process(tested_data)
+
+        errors = processor.get_validation_error(tested_data)
+        assert errors.error_details
+        assert 'first_name' in errors.error_details
+
+    def test_unit__marshmallow_input_processor__ok__completed_data(self):
+        processor = MarshmallowInputProcessor()
+        processor.schema = MySchema()
+
+        tested_data = {
+            'first_name': 'Alan',
+        }
+
+        data = processor.process(tested_data)
+        assert {
+            'first_name': 'Alan',
+            'last_name': 'Doe',
+        } == data