trade concurrency for correct order

Author: altendky

pytest_twisted.py

@@ -50,11 +50,6 @@ class _instances:
     reactor = None
 
 
-class _tracking:
-    async_yield_fixture_cache = {}
-    to_be_torn_down = []
-
-
 def _deprecate(deprecated, recommended):
     def decorator(f):
         @functools.wraps(f)
@@ -282,6 +277,13 @@ def pytest_fixture_setup(fixturedef, request):
     return not None
 
 
+def async_yield_fixture_finalizer(coroutine):
+    _run_inline_callbacks(
+        tear_it_down,
+        defer.ensureDeferred(coroutine.__anext__()),
+    )
+
+
 @defer.inlineCallbacks
 def _async_pytest_fixture_setup(fixturedef, request, mark):
     """Setup an async or async yield fixture."""
@@ -299,15 +301,14 @@ def _async_pytest_fixture_setup(fixturedef, request, mark):
     elif mark == 'async_yield_fixture':
         coroutine = fixture_function(**kwargs)
 
-        finalizer = functools.partial(
-            _tracking.to_be_torn_down.append,
-            coroutine,
+        request.addfinalizer(
+            functools.partial(
+                async_yield_fixture_finalizer,
+                coroutine=coroutine,
+            ),
         )
-        request.addfinalizer(finalizer)
 
-        arg_value = yield defer.ensureDeferred(
-            coroutine.__anext__(),
-        )
+        arg_value = yield defer.ensureDeferred(coroutine.__anext__())
     else:
         raise UnrecognizedCoroutineMarkError.from_mark(mark=mark)
 
@@ -348,22 +349,6 @@ def in_reactor(d, f, *args):
         blockingCallFromThread(_instances.reactor, f, *args)
 
 
-@pytest.hookimpl(hookwrapper=True)
-def pytest_runtest_teardown(item):
-    """Tear down collected async yield fixtures."""
-    yield
-
-    deferreds = []
-    while len(_tracking.to_be_torn_down) > 0:
-        coroutine = _tracking.to_be_torn_down.pop(0)
-        deferred = defer.ensureDeferred(coroutine.__anext__())
-
-        deferreds.append(deferred)
-
-    for deferred in deferreds:
-        _run_inline_callbacks(tear_it_down, deferred)
-
-
 def pytest_pyfunc_call(pyfuncitem):
     """Interface to async test call handler."""
     # TODO: only handle 'our' tests?  what is the point of handling others?

testing/test_basic.py

@@ -413,40 +413,34 @@ def test_is_function_scope(scope):
 
 
 @skip_if_no_async_generators()
-def test_async_yield_fixture_concurrent_teardown(testdir, cmd_opts):
+def test_async_yield_fixture_ordered_teardown(testdir, cmd_opts):
     test_file = """
     from twisted.internet import reactor, defer
     import pytest
     import pytest_twisted
 
 
-    here = defer.Deferred()
-    there = defer.Deferred()
+    results = []
 
-    @pytest_twisted.async_yield_fixture()
-    async def this():
+    @pytest.fixture(scope='function')
+    def sync_fixture():
         yield 42
-
-        there.callback(None)
-        reactor.callLater(5, here.cancel)
-        await here
-
-    @pytest_twisted.async_yield_fixture()
-    async def that():
-        yield 37
-
-        here.callback(None)
-        reactor.callLater(5, there.cancel)
-        await there
-
-    def test_succeed(this, that):
-        pass
+        results.append(2)
+
+    @pytest_twisted.async_yield_fixture(scope='function')
+    async def async_fixture(sync_fixture):
+        yield sync_fixture
+        results.append(1)
+
+    def test_first(async_fixture):
+        assert async_fixture == 42
+    
+    def test_second():
+        assert results == [1, 2]
     """
     testdir.makepyfile(test_file)
-    # TODO: add a timeout, failure just hangs indefinitely for now
-    # https://github.com/pytest-dev/pytest/issues/4073
-    rr = testdir.run(*cmd_opts, timeout=timeout)
-    assert_outcomes(rr, {"passed": 1})
+    rr = testdir.run(*cmd_opts)#, timeout=timeout)
+    assert_outcomes(rr, {"passed": 2})
 
 
 @skip_if_no_async_generators()