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

@@ -328,8 +328,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")
@@ -729,6 +771,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,127 @@ 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,