finish basic support (without doc generation) of aiohttp and outuput stream in async

hapic/async.py

 # -*- coding: utf-8 -*-
 from hapic.hapic import Hapic
 
-_hapic_default = Hapic(async=True)
+_hapic_default = Hapic(async_=True)
 
 with_api_doc = _hapic_default.with_api_doc
 input_headers = _hapic_default.input_headers

hapic/decorator.py

             # 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:
+            if replacement_response is not None:
                 return replacement_response
 
             response = self._execute_wrapped_function(func, args, kwargs)
             # Note: Design of before_wrapped_func can be to update kwargs
             # by reference here
             replacement_response = await self.before_wrapped_func(args, kwargs)
-            if replacement_response:
+            if replacement_response is not None:
                 return replacement_response
 
             response = await self._execute_wrapped_function(func, args, kwargs)
             processed_data = await self.get_processed_data(request_parameters)
             self.update_hapic_data(hapic_data, processed_data)
         except ProcessException:
-            error_response = self.get_error_response(request_parameters)
+            error_response = await self.get_error_response(request_parameters)
             return error_response
 
     async def get_processed_data(
             # 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:
+            if replacement_response is not None:
                 return replacement_response
 
             response = await self._execute_wrapped_function(func, args, kwargs)
             # 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:
+            if replacement_response is not None:
                 return replacement_response
 
             stream_response = await self.context.get_stream_response_object(
                 args,
                 kwargs,
             )
-            async for stream_item in self._execute_wrapped_function(
+            async for stream_item in await self._execute_wrapped_function(
                 func,
                 args,
                 kwargs,
     async def get_parameters_data(self, request_parameters: RequestParameters) -> dict:  # nopep8
         return await request_parameters.body_parameters
 
+    async def get_error_response(
+        self,
+        request_parameters: RequestParameters,
+    ) -> typing.Any:
+        parameters_data = await self.get_parameters_data(request_parameters)
+        error = self.processor.get_validation_error(parameters_data)
+        error_response = self.context.get_validation_error_response(
+            error,
+            http_code=self.error_http_code,
+        )
+        return error_response
+
 
 class InputHeadersControllerWrapper(InputControllerWrapper):
     def update_hapic_data(

hapic/ext/aiohttp/context.py

 from hapic.context import BaseContext
 from hapic.context import RouteRepresentation
 from hapic.decorator import DecoratedController
-from hapic.exception import WorkflowException
+from hapic.error import ErrorBuilderInterface, DefaultErrorBuilder
+from hapic.exception import WorkflowException, OutputValidationException
 from hapic.processor import ProcessValidationError
 from hapic.processor import RequestParameters
 from aiohttp import web
     def __init__(
         self,
         app: web.Application,
+        default_error_builder: ErrorBuilderInterface=None,
         debug: bool = False,
     ) -> None:
         self._app = app
         self._debug = debug
+        self.default_error_builder = \
+            default_error_builder or DefaultErrorBuilder()  # FDV
 
     @property
     def app(self) -> web.Application:
         error: ProcessValidationError,
         http_code: HTTPStatus = HTTPStatus.BAD_REQUEST,
     ) -> typing.Any:
-        # TODO BS 2018-07-24: To do
-        raise NotImplementedError('todo')
+        error_builder = self.get_default_error_builder()
+        error_content = error_builder.build_from_validation_error(
+            error,
+        )
+
+        # Check error
+        dumped = error_builder.dump(error_content).data
+        unmarshall = error_builder.load(dumped)
+        if unmarshall.errors:
+            raise OutputValidationException(
+                'Validation error during dump of error response: {}'.format(
+                    str(unmarshall.errors)
+                )
+            )
+
+        return web.Response(
+            text=json.dumps(dumped),
+            headers=[
+                ('Content-Type', 'application/json'),
+            ],
+            status=int(http_code),
+        )
 
     def find_route(
         self,
         self,
         response: typing.Any,
     ) -> bool:
-        # TODO BS 2018-07-15: to do
-        raise NotImplementedError('todo')
+        return isinstance(response, web.Response)
 
     def add_view(
         self,

hapic/hapic.py

 class Hapic(object):
     def __init__(
         self,
-        async: bool = False,
+        async_: bool = False,
     ):
         self._buffer = DecorationBuffer()
         self._controllers = []  # type: typing.List[DecoratedController]
         self._context = None  # type: ContextInterface
         self._error_builder = None  # type: ErrorBuilderInterface
-        self._async = async
+        self._async = async_
         self.doc_generator = DocGenerator()
 
         # This local function will be pass to different components

setup.py

     'flask',
     'pyramid',
     'webtest',
+    'aiohttp',
+    'pytest-aiohttp',
 ]
 dev_require = [
     'requests',

tests/ext/unit/test_aiohttp.py

+# coding: utf-8
+from aiohttp import web
+import marshmallow
+
+from hapic import Hapic
+from hapic import HapicData
+from hapic.ext.aiohttp.context import AiohttpContext
+
+
+class TestAiohttpExt(object):
+    async def test_aiohttp_only__ok__nominal_case(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        async def hello(request):
+            return web.Response(text='Hello, world')
+
+        app = web.Application(debug=True)
+        app.router.add_get('/', hello)
+        client = await aiohttp_client(app)
+        resp = await client.get('/')
+        assert resp.status == 200
+        text = await resp.text()
+        assert 'Hello, world' in text
+
+    async def test_aiohttp_input_path__ok__nominal_case(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        class InputPathSchema(marshmallow.Schema):
+            name = marshmallow.fields.String()
+
+        @hapic.input_path(InputPathSchema())
+        async def hello(request, hapic_data: HapicData):
+            name = hapic_data.path.get('name')
+            return web.Response(text='Hello, {}'.format(name))
+
+        app = web.Application(debug=True)
+        app.router.add_get('/{name}', hello)
+        hapic.set_context(AiohttpContext(app))
+        client = await aiohttp_client(app)
+
+        resp = await client.get('/bob')
+        assert resp.status == 200
+
+        text = await resp.text()
+        assert 'Hello, bob' in text
+
+    async def test_aiohttp_input_path__error_wrong_input_parameter(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        class InputPathSchema(marshmallow.Schema):
+            i = marshmallow.fields.Integer()
+
+        @hapic.input_path(InputPathSchema())
+        async def hello(request, hapic_data: HapicData):
+            i = hapic_data.path.get('i')
+            return web.Response(text='integer: {}'.format(str(i)))
+
+        app = web.Application(debug=True)
+        app.router.add_get('/{i}', hello)
+        hapic.set_context(AiohttpContext(app))
+        client = await aiohttp_client(app)
+
+        resp = await client.get('/bob')  # NOTE: should be integer here
+        assert resp.status == 400
+
+        error = await resp.json()
+        assert 'Validation error of input data' in error.get('message')
+        assert {'i': ['Not a valid integer.']} == error.get('details')
+
+    async def test_aiohttp_input_body__ok_nominal_case(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        class InputBodySchema(marshmallow.Schema):
+            name = marshmallow.fields.String()
+
+        @hapic.input_body(InputBodySchema())
+        async def hello(request, hapic_data: HapicData):
+            name = hapic_data.body.get('name')
+            return web.Response(text='Hello, {}'.format(name))
+
+        app = web.Application(debug=True)
+        app.router.add_post('/', hello)
+        hapic.set_context(AiohttpContext(app))
+        client = await aiohttp_client(app)
+
+        resp = await client.post('/', data={'name': 'bob'})
+        assert resp.status == 200
+
+        text = await resp.text()
+        assert 'Hello, bob' in text
+
+    async def test_aiohttp_input_body__error__incorrect_input_body(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        class InputBodySchema(marshmallow.Schema):
+            i = marshmallow.fields.Integer()
+
+        @hapic.input_body(InputBodySchema())
+        async def hello(request, hapic_data: HapicData):
+            i = hapic_data.body.get('i')
+            return web.Response(text='integer, {}'.format(i))
+
+        app = web.Application(debug=True)
+        app.router.add_post('/', hello)
+        hapic.set_context(AiohttpContext(app))
+        client = await aiohttp_client(app)
+
+        resp = await client.post('/', data={'i': 'bob'})  # NOTE: should be int
+        assert resp.status == 400
+
+        error = await resp.json()
+        assert 'Validation error of input data' in error.get('message')
+        assert {'i': ['Not a valid integer.']} == error.get('details')
+
+    async def test_aiohttp_output_body__ok__nominal_case(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        class OuputBodySchema(marshmallow.Schema):
+            name = marshmallow.fields.String()
+
+        @hapic.output_body(OuputBodySchema())
+        async def hello(request):
+            return {
+                'name': 'bob',
+            }
+
+        app = web.Application(debug=True)
+        app.router.add_get('/', hello)
+        hapic.set_context(AiohttpContext(app))
+        client = await aiohttp_client(app)
+
+        resp = await client.get('/')
+        assert resp.status == 200
+
+        data = await resp.json()
+        assert 'bob' == data.get('name')
+
+    async def test_aiohttp_output_body__error__incorrect_output_body(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        class OuputBodySchema(marshmallow.Schema):
+            i = marshmallow.fields.Integer(required=True)
+
+        @hapic.output_body(OuputBodySchema())
+        async def hello(request):
+            return {
+                'i': 'bob',  # NOTE: should be integer
+            }
+
+        app = web.Application(debug=True)
+        app.router.add_get('/', hello)
+        hapic.set_context(AiohttpContext(app))
+        client = await aiohttp_client(app)
+
+        resp = await client.get('/')
+        assert resp.status == 500
+
+        data = await resp.json()
+        assert 'Validation error of output data' == data.get('message')
+        assert {
+                   'i': ['Missing data for required field.'],
+               } == data.get('details')
+
+    async def test_aiohttp_output_stream__ok__nominal_case(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        class AsyncGenerator:
+            def __init__(self):
+                self._iterator = iter([
+                    {'name': 'Hello, bob'},
+                    {'name': 'Hello, franck'},
+                ])
+
+            async def __aiter__(self):
+                return self
+
+            async def __anext__(self):
+                return next(self._iterator)
+
+        class OuputStreamItemSchema(marshmallow.Schema):
+            name = marshmallow.fields.String()
+
+        @hapic.output_stream(OuputStreamItemSchema())
+        async def hello(request):
+            return AsyncGenerator()
+
+        app = web.Application(debug=True)
+        app.router.add_get('/', hello)
+        hapic.set_context(AiohttpContext(app))
+        client = await aiohttp_client(app)
+
+        resp = await client.get('/')
+        assert resp.status == 200
+
+        line = await resp.content.readline()
+        assert b'{"name": "Hello, bob"}\n' == line
+
+        line = await resp.content.readline()
+        assert b'{"name": "Hello, franck"}\n' == line
+
+        # TODO BS 2018-07-26: How to ensure we are at end of response ?