Do not wrap async function with threaded_callback

Async callbacks are being wrapped by ThreadedCoroutine when they shouldn't be. For some context, the purpose of ThreadedCoroutine is to allow sync callbacks with aiohttp client. When the callback is an async function, this condition should skip this behavior.

See #256

CHANGELOG.rst

@@ -6,6 +6,12 @@ All notable changes to this project will be documented in this file.
 The format is based on `Keep a Changelog`_, and this project adheres to the
 `Semantic Versioning`_ scheme.
 
+Unreleased
+==========
+Fixed
+-----
+- Fix behavior of async ``@response_handler`` with ``AiohttpClient``. (`#256`_)
+
 0.9.6_ - 2022-01-24
 ===================
 Added

tests/conftest.py

@@ -5,6 +5,7 @@
     collect_ignore.extend(
         [
             "unit/test_aiohttp_client.py",
+            "integration/test_handlers_aiohttp.py",
             "integration/test_retry_aiohttp.py",
         ]
     )

tests/integration/test_handlers_aiohttp.py

@@ -0,0 +1,48 @@
+# Local imports.
+import uplink
+
+# Third-party imports
+import aiohttp
+import pytest
+from uplink.clients.aiohttp_ import AiohttpClient
+
+# Constants
+BASE_URL = "https://example.com/"
+SIMPLE_RESPONSE = "simple response"
+
+
+@pytest.fixture
+def mock_aiohttp_session(mocker):
+    return mocker.Mock(spec=aiohttp.ClientSession)
+
+
+@uplink.response_handler
+async def simple_async_handler(response):
+    return SIMPLE_RESPONSE
+
+
+class Calendar(uplink.Consumer):
+    @simple_async_handler
+    @uplink.get("todos/{todo_id}")
+    def get_todo(self, todo_id):
+        pass
+
+
+@pytest.mark.asyncio
+async def test_simple_async_handler(mock_aiohttp_session, mock_response):
+    mock_response.status = 200
+
+    async def request(*args, **kwargs):
+        return mock_response
+
+    mock_aiohttp_session.request = request
+
+    calendar = Calendar(
+        base_url=BASE_URL, client=AiohttpClient(mock_aiohttp_session)
+    )
+
+    # Run
+    response = await calendar.get_todo(todo_id=1)
+
+    # Verify
+    assert response == SIMPLE_RESPONSE

tests/unit/test_hooks.py

@@ -16,15 +16,15 @@ def test_handle_response(self, mocker):
 
 class TestRequestAuditor(object):
     def test_audit_request(self, mocker):
-        auditor = mocker.stub()
+        auditor = mocker.Mock()
         ra = hooks.RequestAuditor(auditor)
         ra.audit_request("consumer", "request")
         auditor.assert_called_with("request")
 
 
 class TestExceptionHandler(object):
     def test_handle_exception_masked(self, mocker):
-        handler = mocker.stub()
+        handler = mocker.Mock()
         eh = hooks.ExceptionHandler(handler)
         eh.handle_exception("consumer", "exc_type", "exc_val", "exc_tb")
         handler.assert_called_with("exc_type", "exc_val", "exc_tb")
@@ -45,8 +45,8 @@ def test_delegate_handle_response(self, transaction_hook_mock):
 
     def test_delegate_handle_response_multiple(self, mocker):
         # Include one hook that can't handle responses
-        mock_response_handler = mocker.stub()
-        mock_request_auditor = mocker.stub()
+        mock_response_handler = mocker.Mock()
+        mock_request_auditor = mocker.Mock()
 
         chain = hooks.TransactionHookChain(
             hooks.RequestAuditor(mock_request_auditor),

uplink/builder.py

@@ -7,6 +7,7 @@
     arguments,
     auth as auth_,
     clients,
+    compat,
     converters as converters_,
     exceptions,
     helpers,
@@ -41,7 +42,11 @@ def _get_request_hooks(contract):
         return chain
 
     def _wrap_hook(self, func):
-        return functools.partial(func, self._consumer)
+        @compat.wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(self._consumer, *args, **kwargs)
+
+        return wrapper
 
     def apply_hooks(self, execution_builder, chain):
         # TODO:

uplink/clients/aiohttp_.py

@@ -5,6 +5,7 @@
 # Standard library imports
 import asyncio
 import collections
+import inspect
 import threading
 from concurrent import futures
 
@@ -86,7 +87,8 @@ async def session(self):
         return self._session
 
     def wrap_callback(self, callback):
-        if not asyncio.iscoroutinefunction(callback):
+        func = inspect.unwrap(callback)
+        if not asyncio.iscoroutinefunction(func):
             callback = self._sync_callback_adapter(callback)
         return callback
 

uplink/compat.py

@@ -5,3 +5,4 @@
 
 abc = six.moves.collections_abc
 reraise = six.reraise
+wraps = six.wraps

uplink/hooks.py

@@ -15,6 +15,7 @@ def _wrap_if_necessary(hook, requires_consumer):
 
 
 def _wrap_to_ignore_consumer(hook):
+    @compat.wraps(hook)
     def wrapper(_, *args, **kwargs):
         # Expects that consumer is the first argument
         return hook(*args, **kwargs)