Fix loop factory lifecycle

Author: tjkuson

changelog.d/1373.fixed.rst

@@ -0,0 +1 @@
+Fixed ``pytest_asyncio_loop_factories`` not installing the custom event loop as the current loop, and async fixture teardown/cache invalidation not being tied to the runner lifecycle.

pytest_asyncio/plugin.py

@@ -498,7 +498,15 @@ def _can_substitute(item: Function) -> bool:
 
     def setup(self) -> None:
         runner_fixture_id = f"_{self._loop_scope}_scoped_runner"
-        if runner_fixture_id not in self.fixturenames:
+        if runner_fixture_id in self.fixturenames:
+            return super().setup()
+        # The runner must be resolved before async fixtures when loop
+        # factories are configured. Otherwise, the async fixtures see a
+        # stale loop from the previous factory.
+        hook_caller = self.config.hook.pytest_asyncio_loop_factories
+        if hook_caller.get_hookimpls():
+            self.fixturenames.insert(0, runner_fixture_id)
+        else:
             self.fixturenames.append(runner_fixture_id)
         return super().setup()
 
@@ -846,6 +854,11 @@ def pytest_fixture_setup(fixturedef: FixtureDef, request) -> object | None:
     )
     runner_fixture_id = f"_{loop_scope}_scoped_runner"
     runner = request.getfixturevalue(runner_fixture_id)
+    # Prevent the runner closing before the fixture's async teardown.
+    runner_fixturedef = request._get_active_fixturedef(runner_fixture_id)
+    runner_fixturedef.addfinalizer(
+        functools.partial(fixturedef.finish, request=request)
+    )
     synchronizer = _fixture_synchronizer(fixturedef, runner, request)
     _make_asyncio_fixture_function(synchronizer, loop_scope)
     with MonkeyPatch.context() as c:
@@ -940,6 +953,8 @@ def _scoped_runner(
                 debug=debug_mode,
                 loop_factory=_asyncio_loop_factory,
             ).__enter__()
+            if _asyncio_loop_factory is not None:
+                _set_event_loop(runner.get_loop())
             try:
                 yield runner
             except Exception as e:

tests/test_loop_factory_parametrization.py

@@ -571,3 +571,110 @@ async def test_b():
         """))
     result = pytester.runpytest("--asyncio-mode=strict")
     result.assert_outcomes(passed=2)
+
+
+def test_sync_fixture_sees_same_loop_as_async_test_under_custom_factory(
+    pytester: Pytester,
+) -> None:
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makeconftest(dedent("""\
+        import asyncio
+
+        class CustomEventLoop(asyncio.SelectorEventLoop):
+            pass
+
+        def pytest_asyncio_loop_factories(config, item):
+            return {"custom": CustomEventLoop}
+        """))
+    pytester.makepyfile(dedent("""\
+        import asyncio
+        import pytest
+        import pytest_asyncio
+
+        pytest_plugins = "pytest_asyncio"
+
+        @pytest_asyncio.fixture(autouse=True)
+        def enable_debug_on_event_loop():
+            asyncio.get_event_loop().set_debug(True)
+
+        @pytest.mark.asyncio
+        async def test_debug_mode_visible():
+            assert asyncio.get_running_loop().get_debug()
+        """))
+    result = pytester.runpytest("--asyncio-mode=strict")
+    result.assert_outcomes(passed=1)
+
+
+@pytest.mark.parametrize("loop_scope", ("module", "package", "session"))
+def test_async_generator_fixture_teardown_runs_under_custom_factory(
+    pytester: Pytester,
+    loop_scope: str,
+) -> None:
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makeconftest(dedent(f"""\
+        import asyncio
+        import pytest_asyncio
+
+        class CustomEventLoop(asyncio.SelectorEventLoop):
+            pass
+
+        def pytest_asyncio_loop_factories(config, item):
+            return {{"custom": CustomEventLoop}}
+
+        @pytest_asyncio.fixture(
+            autouse=True, scope="{loop_scope}", loop_scope="{loop_scope}"
+        )
+        async def fixture_with_teardown():
+            yield
+            print("TEARDOWN_EXECUTED")
+        """))
+    pytester.makepyfile(dedent(f"""\
+        import pytest
+
+        pytest_plugins = "pytest_asyncio"
+
+        @pytest.mark.asyncio(loop_scope="{loop_scope}")
+        async def test_passes():
+            assert True
+        """))
+    result = pytester.runpytest("--asyncio-mode=strict", "-s")
+    result.assert_outcomes(passed=1)
+    result.stdout.fnmatch_lines(["*TEARDOWN_EXECUTED*"])
+
+
+@pytest.mark.parametrize("loop_scope", ("module", "package", "session"))
+def test_async_fixture_recreated_per_loop_factory_variant(
+    pytester: Pytester,
+    loop_scope: str,
+) -> None:
+    pytester.makeini("[pytest]\nasyncio_default_fixture_loop_scope = function")
+    pytester.makeconftest(dedent(f"""\
+        import asyncio
+        import pytest_asyncio
+
+        class CustomLoopA(asyncio.SelectorEventLoop):
+            pass
+
+        class CustomLoopB(asyncio.SelectorEventLoop):
+            pass
+
+        def pytest_asyncio_loop_factories(config, item):
+            return {{"loop_a": CustomLoopA, "loop_b": CustomLoopB}}
+
+        @pytest_asyncio.fixture(scope="{loop_scope}", loop_scope="{loop_scope}")
+        async def fixture_loop_type():
+            return type(asyncio.get_running_loop()).__name__
+        """))
+    pytester.makepyfile(dedent(f"""\
+        import asyncio
+        import pytest
+
+        pytest_plugins = "pytest_asyncio"
+
+        @pytest.mark.asyncio(loop_scope="{loop_scope}")
+        async def test_fixture_matches_running_loop(fixture_loop_type):
+            running_loop_type = type(asyncio.get_running_loop()).__name__
+            assert fixture_loop_type == running_loop_type
+        """))
+    result = pytester.runpytest("--asyncio-mode=strict", "-v")
+    result.assert_outcomes(passed=2)