Support handle exception for aiohttp

hapic/decorator.py

                 func_kwargs,
             )
         except self.handled_exception_class as exc:
-            response_content = self.error_builder.build_from_exception(
-                exc,
-                include_traceback=self.context.is_debug(),
-            )
+            return self._build_error_response(exc)
+
+    def _build_error_response(self, exc: Exception) -> typing.Any:
+        response_content = self.error_builder.build_from_exception(
+            exc,
+            include_traceback=self.context.is_debug(),
+        )
 
-            # Check error format
-            dumped = self.error_builder.dump(response_content).data
-            unmarshall = self.error_builder.load(dumped)
-            if unmarshall.errors:
-                raise OutputValidationException(
-                    'Validation error during dump of error response: {}'
+        # Check error format
+        dumped = self.error_builder.dump(response_content).data
+        unmarshall = self.error_builder.load(dumped)
+        if unmarshall.errors:
+            raise OutputValidationException(
+                'Validation error during dump of error response: {}'
                     .format(
-                        str(unmarshall.errors)
-                    )
+                    str(unmarshall.errors)
                 )
+            )
+
+        error_response = self.context.get_response(
+            json.dumps(dumped),
+            self.http_code,
+        )
+        return error_response
+
 
-            error_response = self.context.get_response(
-                json.dumps(dumped),
-                self.http_code,
+# TODO BS 2018-07-23: This class is an async version of
+# ExceptionHandlerControllerWrapper
+# to permit async compatibility. Please re-think about code refact
+# TAG: REFACT_ASYNC
+class AsyncExceptionHandlerControllerWrapper(ExceptionHandlerControllerWrapper):
+    def get_wrapper(
+        self,
+        func: 'typing.Callable[..., typing.Any]',
+    ) -> 'typing.Callable[..., typing.Any]':
+        # async def wrapper(*args, **kwargs) -> typing.Any:
+        async 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 is not None:
+                return replacement_response
+
+            response = await self._execute_wrapped_function(func, args, kwargs)
+            new_response = self.after_wrapped_function(response)
+            return new_response
+        return functools.update_wrapper(wrapper, func)
+
+    async def _execute_wrapped_function(
+        self,
+        func,
+        func_args,
+        func_kwargs,
+    ) -> typing.Any:
+        try:
+            return await super()._execute_wrapped_function(
+                func,
+                func_args,
+                func_kwargs,
             )
-            return error_response
+        except self.handled_exception_class as exc:
+            return self._build_error_response(exc)

hapic/hapic.py

 from hapic.decorator import DECORATION_ATTRIBUTE_NAME
 from hapic.decorator import ControllerReference
 from hapic.decorator import ExceptionHandlerControllerWrapper
+from hapic.decorator import AsyncExceptionHandlerControllerWrapper
 from hapic.decorator import InputBodyControllerWrapper
 from hapic.decorator import AsyncInputBodyControllerWrapper
 from hapic.decorator import InputHeadersControllerWrapper
         context = context or self._context_getter
         error_builder = error_builder or self._error_builder_getter
 
-        decoration = ExceptionHandlerControllerWrapper(
-            handled_exception_class,
-            context,
-            error_builder=error_builder,
-            http_code=http_code,
-        )
+        if self._async:
+            decoration = AsyncExceptionHandlerControllerWrapper(
+                handled_exception_class,
+                context,
+                error_builder=error_builder,
+                http_code=http_code,
+            )
+
+        else:
+            decoration = ExceptionHandlerControllerWrapper(
+                handled_exception_class,
+                context,
+                error_builder=error_builder,
+                http_code=http_code,
+            )
 
         def decorator(func):
             self._buffer.errors.append(ErrorDescription(decoration))

tests/ext/unit/test_aiohttp.py

                    'i': ['Missing data for required field.'],
                } == data.get('details')
 
+    async def test_aiohttp_handle_excpetion__ok__nominal_case(
+        self,
+        aiohttp_client,
+        loop,
+    ):
+        hapic = Hapic(async_=True)
+
+        @hapic.handle_exception(ZeroDivisionError, http_code=400)
+        async def hello(request):
+            1 / 0
+
+        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 == 400
+
+        data = await resp.json()
+        assert 'division by zero' == data.get('message')
+
     async def test_aiohttp_output_stream__ok__nominal_case(
         self,
         aiohttp_client,