Merge branch 'feature/76__aiohttp' of github.com:algoo/hapic into feature/76__aiohttp

example/example_a_aiohttp.py

 # coding: utf-8
-import json
-import yaml
-
 from aiohttp import web
 from hapic import async as hapic
 from hapic import async as HapicData
 from hapic.ext.aiohttp.context import AiohttpContext
 
 
-class HandleInputPath(marshmallow.Schema):
+class DisplayNameInputPathSchema(marshmallow.Schema):
     name = marshmallow.fields.String(
         required=False,
         allow_none=True,
     )
 
 
-class HandleInputBody(marshmallow.Schema):
+class DisplayBodyInputBodySchema(marshmallow.Schema):
     foo = marshmallow.fields.String(
         required=True,
     )
 
 
-class Handle2OutputBody(marshmallow.Schema):
+class DisplayBodyOutputBodySchema(marshmallow.Schema):
     data = marshmallow.fields.Dict(
         required=True,
     )
 
 
-class HandleOutputBody(marshmallow.Schema):
-    sentence = marshmallow.fields.String(
-        required=True,
-    )
-
-
 @hapic.with_api_doc()
-@hapic.input_path(HandleInputPath())
-# @hapic.output_body(HandleOutputBody())
-async def handle(request, hapic_data):
+@hapic.input_path(DisplayNameInputPathSchema())
+async def display_name(request, hapic_data):
     name = request.match_info.get('name', "Anonymous")
     text = "Hello, " + name
     return web.json_response({
 
 
 @hapic.with_api_doc()
-@hapic.input_body(HandleInputBody())
-@hapic.output_body(Handle2OutputBody())
-async def handle2(request, hapic_data: HapicData):
+@hapic.input_body(DisplayBodyInputBodySchema())
+@hapic.output_body(DisplayBodyOutputBodySchema())
+async def display_body(request, hapic_data: HapicData):
     data = hapic_data.body
     return {
         'data': data,
 
 app = web.Application(debug=True)
 app.add_routes([
-    web.get('/n/', handle),
-    web.get('/n/{name}', handle),
-    web.post('/n/{name}', handle),
-    web.post('/b/', handle2),
+    web.get('/n/', display_name),
+    web.get('/n/{name}', display_name),
+    web.post('/n/{name}', display_name),
+    web.post('/b/', display_body),
     web.post('/login', do_login),
 ])
 
 
 hapic.set_context(AiohttpContext(app))
 
+
+# import json
+# import yaml
 # print(yaml.dump(
 #     json.loads(json.dumps(hapic.generate_doc())),
 #     default_flow_style=False,

hapic/buffer.py

 from hapic.description import InputFormsDescription
 from hapic.description import InputFilesDescription
 from hapic.description import OutputBodyDescription
+from hapic.description import OutputStreamDescription
 from hapic.description import OutputFileDescription
 from hapic.description import OutputHeadersDescription
 from hapic.description import ErrorDescription
         self._description.output_body = description
 
     @property
+    def output_stream(self) -> OutputStreamDescription:
+        return self._description.output_stream
+
+    @output_stream.setter
+    def output_stream(self, description: OutputStreamDescription) -> None:
+        if self._description.output_stream is not None:
+            raise AlreadyDecoratedException()
+        self._description.output_stream = description
+
+    @property
     def output_file(self) -> OutputFileDescription:
         return self._description.output_file
 

hapic/decorator.py

 
 
 class AsyncOutputStreamControllerWrapper(OutputControllerWrapper):
+    """
+    This controller wrapper produce a wrapper who caught the http view items
+    to check and serialize them into a stream response.
+    """
+    def __init__(
+        self,
+        context: typing.Union[ContextInterface, typing.Callable[[], ContextInterface]],  # nopep8
+        processor: ProcessorInterface,
+        error_http_code: HTTPStatus=HTTPStatus.INTERNAL_SERVER_ERROR,
+        default_http_code: HTTPStatus=HTTPStatus.OK,
+        ignore_on_error: bool = True,
+    ) -> None:
+        super().__init__(
+            context,
+            processor,
+            error_http_code,
+            default_http_code,
+        )
+        self.ignore_on_error = ignore_on_error
+
     def get_wrapper(
         self,
         func: 'typing.Callable[..., typing.Any]',
                 args,
                 kwargs,
             ):
-                serialized_item = self._get_serialized_item(stream_item)
-                await self.context.feed_stream_response(
-                    stream_response,
-                    serialized_item,
-                )
+                try:
+                    serialized_item = self._get_serialized_item(stream_item)
+                    await self.context.feed_stream_response(
+                        stream_response,
+                        serialized_item,
+                    )
+                except OutputValidationException as exc:
+                    if not self.ignore_on_error:
+                        # TODO BS 2018-07-31: Something should inform about
+                        # error, a log ?
+                        return stream_response
 
             return stream_response
 
         self,
         item_object: typing.Any,
     ) -> dict:
-        try:
-            return self.processor.process(item_object)
-        except ProcessException:
-            # TODO BS 2018-07-25: Must interrupt stream response: but how
-            # inform about error ?
-            raise NotImplementedError('todo')
+        return self.processor.process(item_object)
 
 
 class OutputHeadersControllerWrapper(OutputControllerWrapper):

hapic/doc.py

                 )
             }
 
+    if description.output_stream:
+        # TODO BS 2018-07-31: Is that a correct way to re
+        # instanciate with .__class__ ... ?
+        method_operations.setdefault('responses', {})\
+            [int(description.output_stream.wrapper.default_http_code)] = {
+                'description': str(int(description.output_stream.wrapper.default_http_code)),  # nopep8
+                'schema': generate_schema_ref(
+                    spec,
+                    description
+                        .output_stream
+                        .wrapper
+                        .processor
+                        .schema
+                        .__class__(many=True),
+                )
+            }
+
     if description.output_file:
         method_operations.setdefault('produces', []).extend(
             description.output_file.wrapper.output_types

hapic/ext/aiohttp/context.py

 from aiohttp import web
 
 
-# Bottle regular expression to locate url parameters
+# Aiohttp regular expression to locate url parameters
 AIOHTTP_RE_PATH_URL = re.compile(r'{([^:<>]+)(?::[^<>]+)?}')
 
 

hapic/hapic.py

         context: ContextInterface = None,
         error_http_code: HTTPStatus = HTTPStatus.INTERNAL_SERVER_ERROR,
         default_http_code: HTTPStatus = HTTPStatus.OK,
+        ignore_on_error: bool = True,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Any]:
+        """
+        Decorate with a wrapper who check and serialize each items in output
+        stream.
+
+        :param item_schema: Schema of output stream items
+        :param processor: ProcessorInterface object to process with given
+        schema
+        :param context: Context to use here
+        :param error_http_code: http code in case of error
+        :param default_http_code: http code in case of success
+        :param ignore_on_error: if set, an error of serialization will be
+        ignored: stream will not send this failed object
+        :return: decorator
+        """
         processor = processor or MarshmallowOutputProcessor()
         processor.schema = item_schema
         context = context or self._context_getter
                 processor=processor,
                 error_http_code=error_http_code,
                 default_http_code=default_http_code,
+                ignore_on_error=ignore_on_error,
             )
         else:
             # TODO BS 2018-07-25: To do

tests/ext/unit/test_aiohttp.py

         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 ?
+    async def test_aiohttp_output_stream__error__ignore(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        class AsyncGenerator:
+            def __init__(self):
+                self._iterator = iter([
+                    {'name': 'Hello, bob'},
+                    {'nameZ': 'Hello, Z'},  # This line is incorrect
+                    {'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(required=True)
+
+        @hapic.output_stream(OuputStreamItemSchema(), ignore_on_error=True)
+        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
+
+    async def test_aiohttp_output_stream__error__interrupt(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        class AsyncGenerator:
+            def __init__(self):
+                self._iterator = iter([
+                    {'name': 'Hello, bob'},
+                    {'nameZ': 'Hello, Z'},  # This line is incorrect
+                    {'name': 'Hello, franck'},  # This line must not be reached
+                ])
+
+            async def __aiter__(self):
+                return self
+
+            async def __anext__(self):
+                return next(self._iterator)
+
+        class OuputStreamItemSchema(marshmallow.Schema):
+            name = marshmallow.fields.String(required=True)
+
+        @hapic.output_stream(OuputStreamItemSchema(), ignore_on_error=False)
+        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'' == line
 
     def test_unit__generate_doc__ok__nominal_case(
         self,
                        'description': '200',
                    }
                } == doc['paths']['/{username}']['get']['responses']
+
+    def test_unit__generate_output_stream_doc__ok__nominal_case(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        class OuputStreamItemSchema(marshmallow.Schema):
+            name = marshmallow.fields.String(required=True)
+
+        @hapic.with_api_doc()
+        @hapic.output_stream(OuputStreamItemSchema())
+        async def get_users(request, hapic_data):
+            pass
+
+        app = web.Application(debug=True)
+        app.router.add_get('/', get_users)
+        hapic.set_context(AiohttpContext(app))
+
+        doc = hapic.generate_doc('aiohttp', 'testing')
+        assert '/' in doc.get('paths')
+        assert 'get' in doc['paths']['/']
+        assert 200 in doc['paths']['/']['get'].get('responses', {})
+        assert {
+            'items': {
+                '$ref': '#/definitions/OuputStreamItemSchema'
+            },
+            'type': 'array',
+        } == doc['paths']['/']['get']['responses'][200]['schema']