Support async/await fixtures

Redo of pytest-dev#35 but straight off of master

Author: altendky

pytest_twisted.py

@@ -1,4 +1,13 @@
 import inspect
+import sys
+
+ASYNC_AWAIT = sys.version_info >= (3, 5)
+
+if ASYNC_AWAIT:
+    import asyncio
+else:
+    asyncio = None
+
 
 import decorator
 import greenlet
@@ -83,28 +92,48 @@ def stop_twisted_greenlet():
         _instances.gr_twisted.switch()
 
 
+def is_coroutine(maybe_coroutine):
+    if ASYNC_AWAIT:
+        return asyncio.iscoroutine(maybe_coroutine)
+
+    return False
+
+
+@defer.inlineCallbacks
 def _pytest_pyfunc_call(pyfuncitem):
     testfunction = pyfuncitem.obj
     if pyfuncitem._isyieldedfunction():
-        return testfunction(*pyfuncitem._args)
+        defer.returnValue(testfunction(*pyfuncitem._args))
     else:
         funcargs = pyfuncitem.funcargs
         if hasattr(pyfuncitem, "_fixtureinfo"):
             testargs = {}
             for arg in pyfuncitem._fixtureinfo.argnames:
-                testargs[arg] = funcargs[arg]
+                maybe_coroutine = funcargs[arg]
+                if is_coroutine(maybe_coroutine):
+                    maybe_coroutine = yield defer.ensureDeferred(
+                        maybe_coroutine,
+                    )
+                testargs[arg] = maybe_coroutine
         else:
             testargs = funcargs
-        return testfunction(**testargs)
+        result = yield testfunction(**testargs)
+        defer.returnValue(result)
 
 
 def pytest_pyfunc_call(pyfuncitem):
     if _instances.gr_twisted is not None:
         if _instances.gr_twisted.dead:
             raise RuntimeError("twisted reactor has stopped")
 
+        @defer.inlineCallbacks
         def in_reactor(d, f, *args):
-            return defer.maybeDeferred(f, *args).chainDeferred(d)
+            try:
+                result = yield f(*args)
+            except Exception as e:
+                d.callback(failure.Failure(e))
+            else:
+                d.callback(result)
 
         d = defer.Deferred()
         _instances.reactor.callLater(

testing/test_basic.py

@@ -3,6 +3,8 @@
 
 import pytest
 
+import pytest_twisted
+
 
 def assert_outcomes(run_result, outcomes):
     formatted_output = format_run_result_output_for_assert(run_result)
@@ -37,6 +39,13 @@ def skip_if_reactor_not(expected_reactor):
     )
 
 
+def skip_if_no_async_await():
+    return pytest.mark.skipif(
+        not pytest_twisted.ASYNC_AWAIT,
+        reason="async/await syntax not support on Python <3.5",
+    )
+
+
 @pytest.fixture
 def cmd_opts(request):
     reactor = request.config.getoption("reactor", "default")
@@ -165,6 +174,33 @@ def test_succeed(foo):
     assert_outcomes(rr, {"passed": 2, "failed": 1})
 
 
+@skip_if_no_async_await()
+def test_async_fixture(testdir, cmd_opts):
+    test_file = """
+    from twisted.internet import reactor, defer
+    import pytest
+    import pytest_twisted
+
+    @pytest.fixture(scope="function", params=["fs", "imap", "web"])
+    async def foo(request):
+        d1, d2 = defer.Deferred(), defer.Deferred()
+        reactor.callLater(0.01, d1.callback, 1)
+        reactor.callLater(0.02, d2.callback, request.param)
+        await d1
+        return d2,
+
+    @pytest_twisted.inlineCallbacks
+    def test_succeed(foo):
+        x = yield foo[0]
+        print('+++', x)
+        if x == "web":
+            raise RuntimeError("baz")
+    """
+    testdir.makepyfile(test_file)
+    rr = testdir.run(sys.executable, "-m", "pytest", "-v", *cmd_opts)
+    assert_outcomes(rr, {"passed": 2, "failed": 1})
+
+
 @skip_if_reactor_not("default")
 def test_blockon_in_hook(testdir, cmd_opts):
     conftest_file = """