Account for changes in fixture dependencies properly

changelog/14103.bugfix.rst

@@ -0,0 +1 @@
+Fixtures are now rebuilt when param changes for a fixture they depend on, if the dependency is via :func:`request.getfixturevalue() <pytest.FixtureRequest.getfixturevalue>`.

changelog/14114.bugfix.rst

@@ -0,0 +1 @@
+An exception from :hook:`pytest_fixture_post_finalizer` no longer prevents fixtures from being torn down, causing additional errors in the following tests.

changelog/4871.improvement.rst

@@ -0,0 +1,3 @@
+Garbage finalizers for fixture teardown are no longer accumulated in nodes and fixtures.
+
+:func:`Node.addfinalizer <_pytest.nodes.Node.addfinalizer>` and :func:`request.addfinalizer() <pytest.FixtureRequest.addfinalizer>` now return a handle that allows to remove the finalizer.

changelog/5848.improvement.rst

@@ -0,0 +1 @@
+:hook:`pytest_fixture_post_finalizer` is no longer called extra times for the same fixture teardown.

changelog/9287.bugfix.rst

@@ -0,0 +1,63 @@
+Teardown of parametrized fixtures now happens in the teardown stage of the test before the parameter changes.
+
+Previously teardown would happen in the setup stage of the test where the parameter changes.
+
+If a test forces teardown of a parametrized fixture, e.g. using :func:`request.getfixturevalue() <pytest.FixtureRequest.getfixturevalue>`, it instead fails. An example of such test:
+
+.. code-block:: pytest
+
+    # conftest.py
+    import pytest
+
+    @pytest.hookimpl(wrapper=True, tryfirst=True)
+    def pytest_collection_modifyitems(items):
+        # Disable built-in test reordering.
+        original_items = items[:]
+        yield
+        items[:] = original_items
+
+    # test_invalid.py
+    import pytest
+
+    @pytest.fixture(scope="session")
+    def foo(request):
+        return getattr(request, "param", "default")
+
+    @pytest.mark.parametrize("foo", [1], indirect=True)
+    def test_a(foo):
+        assert foo == 1
+
+    def test_b(request):
+        request.getfixturevalue("foo")
+
+    @pytest.mark.parametrize("foo", [1], indirect=True)
+    def test_c(foo):
+        assert foo == 1
+
+This produces the following error:
+
+.. code-block:: console
+
+    Parameter for the requested fixture changed unexpectedly in test:
+        test_invalid.py::test_b
+    Requested fixture 'foo' defined in:
+        test_invalid.py:4
+
+    Previous parameter value: 1
+    New parameter value: None
+
+    This could happen because the current test requested the previously parametrized
+    fixture dynamically via 'getfixturevalue' and did not provide a parameter for the
+    fixture.
+    Either provide a parameter for the fixture, or make fixture 'foo' statically
+    reachable from the current test, e.g. by adding it as an argument to the test
+    function.
+
+Indeed, the following change to ``test_b`` fixes the issue:
+
+.. code-block:: pytest
+
+    def test_b(request, foo):
+        # This is now a little unnecessary as written, but imagine that this dynamic
+        # fixture loading happens inside another fixture or inside an utility function.
+        request.getfixturevalue("foo")

doc/en/reference/reference.rst

@@ -993,6 +993,13 @@ ExitCode
     :members:
 
 
+FinalizerHandle
+~~~~~~~~~~~~~~~
+
+.. autoclass:: pytest.FinalizerHandle()
+    :members:
+
+
 FixtureDef
 ~~~~~~~~~~