Merge branch 'main' into fix-blocked-conftest

Author: Bubble-Interface

CONTRIBUTING.rst

@@ -49,7 +49,7 @@ Look through the `GitHub issues for bugs <https://github.com/pytest-dev/pytest/l
 See also the `"good first issue" issues <https://github.com/pytest-dev/pytest/labels/good%20first%20issue>`_
 that are friendly to new contributors.
 
-:ref:`Talk <contact>` to developers to find out how you can fix specific bugs. To indicate that you are going
+`Talk to developers <https://docs.pytest.org/en/stable/contact.html>`_ to find out how you can fix specific bugs. To indicate that you are going
 to work on a particular issue, add a comment to that effect on the specific issue.
 
 Don't forget to check the issue trackers of your favourite plugins, too!
@@ -61,7 +61,7 @@ Implement features
 
 Look through the `GitHub issues for enhancements <https://github.com/pytest-dev/pytest/labels/type:%20enhancement>`_.
 
-:ref:`Talk <contact>` to developers to find out how you can implement specific
+`Talk to developers <https://docs.pytest.org/en/stable/contact.html>`_ to find out how you can implement specific
 features.
 
 Write documentation

doc/en/deprecations.rst

@@ -148,76 +148,6 @@ Simply remove the ``__init__.py`` file entirely.
 Python 3.3+ natively supports namespace packages without ``__init__.py``.
 
 
-.. _sync-test-async-fixture:
-
-sync test depending on async fixture
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. deprecated:: 8.4
-
-Pytest has for a long time given an error when encountering an asynchronous test function, prompting the user to install
-a plugin that can handle it. It has not given any errors if you have an asynchronous fixture that's depended on by a
-synchronous test. If the fixture was an async function you did get an "unawaited coroutine" warning, but for async yield fixtures you didn't even get that.
-This is a problem even if you do have a plugin installed for handling async tests, as they may require
-special decorators for async fixtures to be handled, and some may not robustly handle if a user accidentally requests an
-async fixture from their sync tests. Fixture values being cached can make this even more unintuitive, where everything will
-"work" if the fixture is first requested by an async test, and then requested by a synchronous test.
-
-Unfortunately there is no 100% reliable method of identifying when a user has made a mistake, versus when they expect an
-unawaited object from their fixture that they will handle on their own. To suppress this warning
-when you in fact did intend to handle this you can wrap your async fixture in a synchronous fixture:
-
-.. code-block:: python
-
-    import asyncio
-    import pytest
-
-
-    @pytest.fixture
-    async def unawaited_fixture():
-        return 1
-
-
-    def test_foo(unawaited_fixture):
-        assert 1 == asyncio.run(unawaited_fixture)
-
-should be changed to
-
-
-.. code-block:: python
-
-    import asyncio
-    import pytest
-
-
-    @pytest.fixture
-    def unawaited_fixture():
-        async def inner_fixture():
-            return 1
-
-        return inner_fixture()
-
-
-    def test_foo(unawaited_fixture):
-        assert 1 == asyncio.run(unawaited_fixture)
-
-
-You can also make use of `pytest_fixture_setup` to handle the coroutine/asyncgen before pytest sees it - this is the way current async pytest plugins handle it.
-
-If a user has an async fixture with ``autouse=True`` in their ``conftest.py``, or in a file
-containing both synchronous tests and the fixture, they will receive this warning.
-Unless you're using a plugin that specifically handles async fixtures
-with synchronous tests, we strongly recommend against this practice.
-It can lead to unpredictable behavior (with larger scopes, it may appear to "work" if an async
-test is the first to request the fixture, due to value caching) and will generate
-unawaited-coroutine runtime warnings (but only for non-yield fixtures).
-Additionally, it creates ambiguity for other developers about whether the fixture is intended to perform
-setup for synchronous tests.
-
-The `anyio pytest plugin <https://anyio.readthedocs.io/en/stable/testing.html>`_ supports
-synchronous tests with async fixtures, though certain limitations apply.
-
-
 .. _import-or-skip-import-error:
 
 ``pytest.importorskip`` default behavior regarding :class:`ImportError`
@@ -423,6 +353,78 @@ an appropriate period of deprecation has passed.
 
 Some breaking changes which could not be deprecated are also listed.
 
+.. _sync-test-async-fixture:
+
+sync test depending on async fixture
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. deprecated:: 8.4
+.. versionremoved:: 9.0
+
+Pytest has for a long time given an error when encountering an asynchronous test function, prompting the user to install
+a plugin that can handle it. It has not given any errors if you have an asynchronous fixture that's depended on by a
+synchronous test. If the fixture was an async function you did get an "unawaited coroutine" warning, but for async yield fixtures you didn't even get that.
+This is a problem even if you do have a plugin installed for handling async tests, as they may require
+special decorators for async fixtures to be handled, and some may not robustly handle if a user accidentally requests an
+async fixture from their sync tests. Fixture values being cached can make this even more unintuitive, where everything will
+"work" if the fixture is first requested by an async test, and then requested by a synchronous test.
+
+Unfortunately there is no 100% reliable method of identifying when a user has made a mistake, versus when they expect an
+unawaited object from their fixture that they will handle on their own. To suppress this warning
+when you in fact did intend to handle this you can wrap your async fixture in a synchronous fixture:
+
+.. code-block:: python
+
+    import asyncio
+    import pytest
+
+
+    @pytest.fixture
+    async def unawaited_fixture():
+        return 1
+
+
+    def test_foo(unawaited_fixture):
+        assert 1 == asyncio.run(unawaited_fixture)
+
+should be changed to
+
+
+.. code-block:: python
+
+    import asyncio
+    import pytest
+
+
+    @pytest.fixture
+    def unawaited_fixture():
+        async def inner_fixture():
+            return 1
+
+        return inner_fixture()
+
+
+    def test_foo(unawaited_fixture):
+        assert 1 == asyncio.run(unawaited_fixture)
+
+
+You can also make use of `pytest_fixture_setup` to handle the coroutine/asyncgen before pytest sees it - this is the way current async pytest plugins handle it.
+
+If a user has an async fixture with ``autouse=True`` in their ``conftest.py``, or in a file
+containing both synchronous tests and the fixture, they will receive this warning.
+Unless you're using a plugin that specifically handles async fixtures
+with synchronous tests, we strongly recommend against this practice.
+It can lead to unpredictable behavior (with larger scopes, it may appear to "work" if an async
+test is the first to request the fixture, due to value caching) and will generate
+unawaited-coroutine runtime warnings (but only for non-yield fixtures).
+Additionally, it creates ambiguity for other developers about whether the fixture is intended to perform
+setup for synchronous tests.
+
+The `anyio pytest plugin <https://anyio.readthedocs.io/en/stable/testing.html>`_ supports
+synchronous tests with async fixtures, though certain limitations apply.
+
+
+
 Applying a mark to a fixture function
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~