Fix fixtures seeing the wrong event loop

Author: tjkuson

changelog.d/1373.fixed.rst

@@ -1 +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.
+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, and sync ``@pytest_asyncio.fixture`` seeing the wrong event loop when multiple loop scopes are active.

pytest_asyncio/plugin.py

@@ -334,8 +334,50 @@ def _fixture_synchronizer(
         return _wrap_asyncgen_fixture(fixture_function, runner, request)  # type: ignore[arg-type]
     elif inspect.iscoroutinefunction(fixturedef.func):
         return _wrap_async_fixture(fixture_function, runner, request)  # type: ignore[arg-type]
+    elif inspect.isgeneratorfunction(fixturedef.func):
+        return _wrap_syncgen_fixture(fixture_function, runner)  # type: ignore[arg-type]
     else:
-        return fixturedef.func
+        return _wrap_sync_fixture(fixture_function, runner)  # type: ignore[arg-type]
+
+
+SyncGenFixtureParams = ParamSpec("SyncGenFixtureParams")
+SyncGenFixtureYieldType = TypeVar("SyncGenFixtureYieldType")
+
+
+def _wrap_syncgen_fixture(
+    fixture_function: Callable[
+        SyncGenFixtureParams, Generator[SyncGenFixtureYieldType]
+    ],
+    runner: Runner,
+) -> Callable[SyncGenFixtureParams, Generator[SyncGenFixtureYieldType]]:
+    @functools.wraps(fixture_function)
+    def _syncgen_fixture_wrapper(
+        *args: SyncGenFixtureParams.args,
+        **kwargs: SyncGenFixtureParams.kwargs,
+    ) -> Generator[SyncGenFixtureYieldType]:
+        with _temporary_event_loop(runner.get_loop()):
+            yield from fixture_function(*args, **kwargs)
+
+    return _syncgen_fixture_wrapper
+
+
+SyncFixtureParams = ParamSpec("SyncFixtureParams")
+SyncFixtureReturnType = TypeVar("SyncFixtureReturnType")
+
+
+def _wrap_sync_fixture(
+    fixture_function: Callable[SyncFixtureParams, SyncFixtureReturnType],
+    runner: Runner,
+) -> Callable[SyncFixtureParams, SyncFixtureReturnType]:
+    @functools.wraps(fixture_function)
+    def _sync_fixture_wrapper(
+        *args: SyncFixtureParams.args,
+        **kwargs: SyncFixtureParams.kwargs,
+    ) -> SyncFixtureReturnType:
+        with _temporary_event_loop(runner.get_loop()):
+            return fixture_function(*args, **kwargs)
+
+    return _sync_fixture_wrapper
 
 
 AsyncGenFixtureParams = ParamSpec("AsyncGenFixtureParams")
@@ -735,6 +777,22 @@ def pytest_generate_tests(metafunc: pytest.Metafunc) -> None:
     )
 
 
+@contextlib.contextmanager
+def _temporary_event_loop(loop: AbstractEventLoop) -> Iterator[None]:
+    try:
+        old_loop = _get_event_loop_no_warn()
+    except RuntimeError:
+        old_loop = None
+    if old_loop is loop:
+        yield
+        return
+    _set_event_loop(loop)
+    try:
+        yield
+    finally:
+        _set_event_loop(old_loop)
+
+
 @contextlib.contextmanager
 def _temporary_event_loop_policy(policy: AbstractEventLoopPolicy) -> Iterator[None]:
     old_loop_policy = _get_event_loop_policy()

tests/test_loop_factory_parametrization.py

@@ -605,6 +605,119 @@ async def test_debug_mode_visible():
     result.assert_outcomes(passed=1)
 
 
+@pytest.mark.parametrize(
+    ("fixture_scope", "wider_scope"),
+    [
+        ("function", "module"),
+        ("function", "package"),
+        ("function", "session"),
+        ("module", "session"),
+        ("package", "session"),
+    ],
+)
+def test_sync_fixture_sees_its_own_loop_when_wider_scoped_loop_active(
+    pytester: Pytester,
+    fixture_scope: str,
+    wider_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="{wider_scope}",
+            loop_scope="{wider_scope}",
+        )
+        async def wider_scoped_fixture():
+            yield
+
+        @pytest_asyncio.fixture(
+            autouse=True,
+            scope="{fixture_scope}",
+            loop_scope="{fixture_scope}",
+        )
+        def sync_fixture_captures_loop():
+            return id(asyncio.get_event_loop())
+        """))
+    pytester.makepyfile(dedent(f"""\
+        import asyncio
+        import pytest
+
+        pytest_plugins = "pytest_asyncio"
+
+        @pytest.mark.asyncio(loop_scope="{fixture_scope}")
+        async def test_sync_fixture_and_test_see_same_loop(sync_fixture_captures_loop):
+            assert sync_fixture_captures_loop == id(asyncio.get_running_loop())
+        """))
+    result = pytester.runpytest("--asyncio-mode=strict")
+    result.assert_outcomes(passed=1)
+
+
+@pytest.mark.parametrize(
+    ("fixture_scope", "wider_scope"),
+    [
+        ("function", "module"),
+        ("function", "session"),
+        ("module", "session"),
+    ],
+)
+def test_sync_generator_fixture_teardown_sees_own_loop(
+    pytester: Pytester,
+    fixture_scope: str,
+    wider_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="{wider_scope}",
+            loop_scope="{wider_scope}",
+        )
+        async def wider_scoped_fixture():
+            yield
+
+        @pytest_asyncio.fixture(
+            autouse=True,
+            scope="{fixture_scope}",
+            loop_scope="{fixture_scope}",
+        )
+        def sync_generator_fixture():
+            loop_at_setup = id(asyncio.get_event_loop())
+            yield loop_at_setup
+            loop_at_teardown = id(asyncio.get_event_loop())
+            assert loop_at_setup == loop_at_teardown
+        """))
+    pytester.makepyfile(dedent(f"""\
+        import asyncio
+        import pytest
+
+        pytest_plugins = "pytest_asyncio"
+
+        @pytest.mark.asyncio(loop_scope="{fixture_scope}")
+        async def test_generator_fixture_sees_correct_loop(sync_generator_fixture):
+            assert sync_generator_fixture == id(asyncio.get_running_loop())
+        """))
+    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,

tests/test_set_event_loop.py

@@ -329,3 +329,60 @@ async def test_after_second(second_webserver):
             """))
     result = pytester.runpytest("--asyncio-mode=strict")
     result.assert_outcomes(passed=5)
+
+
+@pytest.mark.parametrize("test_loop_scope", ("module", "package", "session"))
+@pytest.mark.parametrize(
+    "loop_breaking_action",
+    [
+        "asyncio.set_event_loop(None)",
+        "asyncio.run(asyncio.sleep(0))",
+        pytest.param(
+            "with asyncio.Runner(): pass",
+            marks=pytest.mark.skipif(
+                sys.version_info < (3, 11),
+                reason="asyncio.Runner requires Python 3.11+",
+            ),
+        ),
+    ],
+)
+def test_sync_fixture_sees_correct_loop_after_loop_broken_with_factory(
+    pytester: Pytester,
+    test_loop_scope: str,
+    loop_breaking_action: str,
+):
+    pytester.makeini(dedent(f"""\
+            [pytest]
+            asyncio_default_test_loop_scope = {test_loop_scope}
+            asyncio_default_fixture_loop_scope = function
+            """))
+    pytester.makepyfile(dedent(f"""\
+            import asyncio
+            import pytest
+            import pytest_asyncio
+
+            pytest_plugins = "pytest_asyncio"
+
+            class CustomEventLoop(asyncio.SelectorEventLoop):
+                pass
+
+            def pytest_asyncio_loop_factories(config, item):
+                return {{"custom": CustomEventLoop}}
+
+            @pytest.mark.asyncio
+            async def test_before():
+                pass
+
+            def test_break_event_loop():
+                {loop_breaking_action}
+
+            @pytest_asyncio.fixture(loop_scope="{test_loop_scope}")
+            def sync_fixture_loop_id():
+                return id(asyncio.get_event_loop())
+
+            @pytest.mark.asyncio
+            async def test_sync_fixture_sees_correct_loop(sync_fixture_loop_id):
+                assert sync_fixture_loop_id == id(asyncio.get_running_loop())
+            """))
+    result = pytester.runpytest_subprocess()
+    result.assert_outcomes(passed=3)