[feat] Test items based on asynchronous generators always exit with *xfail* status and emit a warning during the collection phase. This behavior is consistent with synchronous yield tests.

Signed-off-by: Michael Seifert <m.seifert@digitalernachschub.de>

Author: seifertm

docs/source/reference/changelog.rst

@@ -9,6 +9,7 @@ Changelog
 - Deprecate redefinition of the `event_loop` fixture. `#587 <https://github.com/pytest-dev/pytest-asyncio/issues/531>`_
   Users requiring a class-scoped or module-scoped asyncio event loop for their tests
   should mark the corresponding class or module with `asyncio_event_loop`.
+- Test items based on asynchronous generators always exit with *xfail* status and emit a warning during the collection phase. This behavior is consistent with synchronous yield tests. `#642 <https://github.com/pytest-dev/pytest-asyncio/issues/642>`__
 - Remove support for Python 3.7
 - Declare support for Python 3.12
 

pytest_asyncio/plugin.py

@@ -34,6 +34,7 @@
     Item,
     Metafunc,
     Parser,
+    PytestCollectionWarning,
     PytestPluginManager,
     Session,
     StashKey,
@@ -387,13 +388,13 @@ def _can_substitute(item: Function) -> bool:
         raise NotImplementedError()
 
 
-class AsyncFunction(PytestAsyncioFunction):
-    """Pytest item that is a coroutine or an asynchronous generator"""
+class Coroutine(PytestAsyncioFunction):
+    """Pytest item created by a coroutine"""
 
     @staticmethod
     def _can_substitute(item: Function) -> bool:
         func = item.obj
-        return _is_coroutine_or_asyncgen(func)
+        return asyncio.iscoroutinefunction(func)
 
     def runtest(self) -> None:
         if self.get_closest_marker("asyncio"):
@@ -404,6 +405,28 @@ def runtest(self) -> None:
         super().runtest()
 
 
+class AsyncGenerator(PytestAsyncioFunction):
+    """Pytest item created by an asynchronous generator"""
+
+    @staticmethod
+    def _can_substitute(item: Function) -> bool:
+        func = item.obj
+        return inspect.isasyncgenfunction(func)
+
+    @classmethod
+    def _from_function(cls, function: Function, /) -> Function:
+        async_gen_item = super()._from_function(function)
+        unsupported_item_type_message = (
+            f"Tests based on asynchronous generators are not supported. "
+            f"{function.name} will be ignored."
+        )
+        async_gen_item.warn(PytestCollectionWarning(unsupported_item_type_message))
+        async_gen_item.add_marker(
+            pytest.mark.xfail(run=False, reason=unsupported_item_type_message)
+        )
+        return async_gen_item
+
+
 class AsyncStaticMethod(PytestAsyncioFunction):
     """
     Pytest item that is a coroutine or an asynchronous generator

tests/test_asyncio_mark.py

@@ -0,0 +1,223 @@
+from textwrap import dedent
+
+from pytest import Pytester
+
+
+def test_asyncio_mark_on_sync_function_emits_warning(pytester: Pytester):
+    pytester.makepyfile(
+        dedent(
+            """\
+            import pytest
+
+            @pytest.mark.asyncio
+            def test_a():
+                pass
+            """
+        )
+    )
+    pytester.makefile(
+        ".ini",
+        pytest=dedent(
+            """\
+            [pytest]
+            asyncio_mode = strict
+            filterwarnings =
+                default
+            """
+        ),
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(passed=1)
+    result.stdout.fnmatch_lines(
+        ["*is marked with '@pytest.mark.asyncio' but it is not an async function.*"]
+    )
+
+
+def test_asyncio_mark_on_async_generator_function_emits_warning_in_strict_mode(
+    pytester: Pytester,
+):
+    pytester.makepyfile(
+        dedent(
+            """\
+            import pytest
+
+            @pytest.mark.asyncio
+            async def test_a():
+                yield
+            """
+        )
+    )
+    pytester.makefile(
+        ".ini",
+        pytest=dedent(
+            """\
+            [pytest]
+            asyncio_mode = strict
+            filterwarnings =
+                default
+            """
+        ),
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(xfailed=1, warnings=1)
+    result.stdout.fnmatch_lines(
+        ["*Tests based on asynchronous generators are not supported*"]
+    )
+
+
+def test_asyncio_mark_on_async_generator_function_emits_warning_in_auto_mode(
+    pytester: Pytester,
+):
+    pytester.makepyfile(
+        dedent(
+            """\
+            async def test_a():
+                yield
+            """
+        )
+    )
+    pytester.makefile(
+        ".ini",
+        pytest=dedent(
+            """\
+            [pytest]
+            asyncio_mode = auto
+            filterwarnings =
+                default
+            """
+        ),
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(xfailed=1, warnings=1)
+    result.stdout.fnmatch_lines(
+        ["*Tests based on asynchronous generators are not supported*"]
+    )
+
+
+def test_asyncio_mark_on_async_generator_method_emits_warning_in_strict_mode(
+    pytester: Pytester,
+):
+    pytester.makepyfile(
+        dedent(
+            """\
+            import pytest
+
+            class TestAsyncGenerator:
+                @pytest.mark.asyncio
+                async def test_a(self):
+                    yield
+            """
+        )
+    )
+    pytester.makefile(
+        ".ini",
+        pytest=dedent(
+            """\
+            [pytest]
+            asyncio_mode = strict
+            filterwarnings =
+                default
+            """
+        ),
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(xfailed=1, warnings=1)
+    result.stdout.fnmatch_lines(
+        ["*Tests based on asynchronous generators are not supported*"]
+    )
+
+
+def test_asyncio_mark_on_async_generator_method_emits_warning_in_auto_mode(
+    pytester: Pytester,
+):
+    pytester.makepyfile(
+        dedent(
+            """\
+            class TestAsyncGenerator:
+                @staticmethod
+                async def test_a():
+                    yield
+            """
+        )
+    )
+    pytester.makefile(
+        ".ini",
+        pytest=dedent(
+            """\
+            [pytest]
+            asyncio_mode = auto
+            filterwarnings =
+                default
+            """
+        ),
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(xfailed=1, warnings=1)
+    result.stdout.fnmatch_lines(
+        ["*Tests based on asynchronous generators are not supported*"]
+    )
+
+
+def test_asyncio_mark_on_async_generator_staticmethod_emits_warning_in_strict_mode(
+    pytester: Pytester,
+):
+    pytester.makepyfile(
+        dedent(
+            """\
+            import pytest
+
+            class TestAsyncGenerator:
+                @staticmethod
+                @pytest.mark.asyncio
+                async def test_a():
+                    yield
+            """
+        )
+    )
+    pytester.makefile(
+        ".ini",
+        pytest=dedent(
+            """\
+            [pytest]
+            asyncio_mode = strict
+            filterwarnings =
+                default
+            """
+        ),
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(xfailed=1, warnings=1)
+    result.stdout.fnmatch_lines(
+        ["*Tests based on asynchronous generators are not supported*"]
+    )
+
+
+def test_asyncio_mark_on_async_generator_staticmethod_emits_warning_in_auto_mode(
+    pytester: Pytester,
+):
+    pytester.makepyfile(
+        dedent(
+            """\
+            class TestAsyncGenerator:
+                @staticmethod
+                async def test_a():
+                    yield
+            """
+        )
+    )
+    pytester.makefile(
+        ".ini",
+        pytest=dedent(
+            """\
+            [pytest]
+            asyncio_mode = auto
+            filterwarnings =
+                default
+            """
+        ),
+    )
+    result = pytester.runpytest()
+    result.assert_outcomes(xfailed=1, warnings=1)
+    result.stdout.fnmatch_lines(
+        ["*Tests based on asynchronous generators are not supported*"]
+    )