DeprecationWarning if sync test requests async fixture

changelog/10839.deprecation.rst

@@ -0,0 +1 @@
+Synchronous tests that request an asynchronous fixture with ``autouse=True`` will now give a DeprecationWarning.

changelog/10839.improvement.rst

@@ -0,0 +1 @@
+Synchronous tests that request asynchronous fixtures will now error, instead of silently accepting an unawaited coroutine object as the fixture value.

src/_pytest/fixtures.py

@@ -73,6 +73,7 @@
 from _pytest.scope import _ScopeName
 from _pytest.scope import HIGH_SCOPES
 from _pytest.scope import Scope
+from _pytest.warning_types import PytestRemovedIn9Warning
 
 
 if sys.version_info < (3, 11):
@@ -575,6 +576,7 @@
         # The are no fixtures with this name applicable for the function.
         if not fixturedefs:
             raise FixtureLookupError(argname, self)
+
         # A fixture may override another fixture with the same name, e.g. a
         # fixture in a module can override a fixture in a conftest, a fixture in
         # a class can override a fixture in the module, and so on.
@@ -593,6 +595,39 @@
             raise FixtureLookupError(argname, self)
         fixturedef = fixturedefs[index]
 
+        # Check for attempted use of an async fixture by a sync test
+        # `self.scope` here is not the scope of the requested fixture, but the scope of
+        # the requester.
+        if (
+            self.scope == "function"
+            and not inspect.iscoroutinefunction(self._pyfuncitem.obj)
+            and (
+                inspect.iscoroutinefunction(fixturedef.func)
+                or inspect.isasyncgenfunction(fixturedef.func)
+            )
+        ):
+            if fixturedef._autouse:
+                warnings.warn(
+                    PytestRemovedIn9Warning(
+                        "Sync test requested an async fixture with autouse=True. "
+                        "If you intended to use the fixture you may want to make the "
+                        "test asynchronous. If you did not intend to use it you should "
+                        "restructure your test setup. "
+                        "This will turn into an error in pytest 9."
+                    ),
+                    stacklevel=3,
+                )
+            else:
+                raise FixtureLookupError(
+                    argname,
+                    self,
+                    (
+                        "ERROR: Sync test requested async fixture. "
+                        "You may want to make the test asynchronous and run it with "
+                        "a suitable async framework test plugin."
+                    ),
+                )
+
         # Prepare a SubRequest object for calling the fixture.
         try:
             callspec = self._pyfuncitem.callspec
@@ -805,7 +840,7 @@
         stack = [self.request._pyfuncitem.obj]
         stack.extend(map(lambda x: x.func, self.fixturestack))
         msg = self.msg
-        if msg is not None:
+        if msg is not None and len(stack) > 1:
             # The last fixture raise an error, let's present
             # it at the requesting side.
             stack = stack[:-1]
@@ -959,6 +994,8 @@
         ids: tuple[object | None, ...] | Callable[[Any], object | None] | None = None,
         *,
         _ispytest: bool = False,
+        # only used to emit a deprecationwarning, can be removed in pytest9
+        _autouse: bool = False,
     ) -> None:
         check_ispytest(_ispytest)
         # The "base" node ID for the fixture.
@@ -1005,6 +1042,9 @@
         self.cached_result: _FixtureCachedResult[FixtureValue] | None = None
         self._finalizers: Final[list[Callable[[], object]]] = []
 
+        # only used to emit a deprecationwarning, can be removed in pytest9
+        self._autouse = _autouse
+
     @property
     def scope(self) -> _ScopeName:
         """Scope string, one of "function", "class", "module", "package", "session"."""
@@ -1666,6 +1706,7 @@
             params=params,
             ids=ids,
             _ispytest=True,
+            _autouse=autouse,
         )
 
         faclist = self._arg2fixturedefs.setdefault(name, [])

testing/acceptance_test.py

@@ -1286,6 +1286,93 @@ def test_3():
     result.assert_outcomes(failed=3)
 
 
+def test_error_on_sync_test_async_fixture(pytester: Pytester) -> None:
+    pytester.makepyfile(
+        test_sync="""
+            import pytest
+
+            @pytest.fixture
+            async def async_fixture():
+                ...
+
+            def test_foo(async_fixture):
+                ...
+        """
+    )
+    result = pytester.runpytest()
+    result.stdout.fnmatch_lines(
+        [
+            (
+                "*ERROR: Sync test requested async fixture. "
+                "You may want to make the test asynchronous and run it with "
+                "a suitable async framework test plugin.*"
+            ),
+            "*ERROR test_sync.py::test_foo*",
+        ]
+    )
+    result.assert_outcomes(errors=1)
+
+
+def test_error_on_sync_test_async_fixture_gen(pytester: Pytester) -> None:
+    pytester.makepyfile(
+        test_sync="""
+            import pytest
+
+            @pytest.fixture
+            async def async_fixture():
+                yield
+
+            def test_foo(async_fixture):
+                ...
+        """
+    )
+    result = pytester.runpytest()
+    result.stdout.fnmatch_lines(
+        [
+            (
+                "*ERROR: Sync test requested async fixture. "
+                "You may want to make the test asynchronous and run it with "
+                "a suitable async framework test plugin.*"
+            ),
+            "*ERROR test_sync.py::test_foo*",
+        ]
+    )
+    result.assert_outcomes(errors=1)
+
+
+def test_warning_on_sync_test_async_autouse_fixture(pytester: Pytester) -> None:
+    pytester.makepyfile(
+        test_sync="""
+            import pytest
+
+            @pytest.fixture(autouse=True)
+            async def async_fixture():
+                ...
+
+            # We explicitly request the fixture to be able to
+            # suppress the RuntimeWarning for unawaited coroutine.
+            def test_foo(async_fixture):
+                try:
+                    async_fixture.send(None)
+                except StopIteration:
+                    pass
+        """
+    )
+    result = pytester.runpytest()
+    result.stdout.fnmatch_lines(
+        [
+            (
+                "*Sync test requested an async fixture with autouse=True. "
+                "If you intended to use the fixture you may want to make the "
+                "test asynchronous. If you did not intend to use it you should "
+                "restructure your test setup. "
+                "This will turn into an error in pytest 9.*"
+            ),
+        ]
+    )
+    result.assert_outcomes(passed=1)
+
+
 def test_pdb_can_be_rewritten(pytester: Pytester) -> None:
     pytester.makepyfile(
         **{