Add versionadded, add a failure case

Author: Anton3

doc/en/example/parametrize.rst

@@ -694,6 +694,8 @@ which is expected by pytest.
 Adding parameters depending on previous parametrizations
 --------------------------------------------------------------------
 
+.. versionadded: 8.4
+
 By default, :hook:`pytest_generate_tests` hooks and
 :ref:`pytest.mark.parametrize <pytest.mark.parametrize ref>` generate
 a Cartesian product of parameter sets in case of multiple parametrizations,
@@ -702,7 +704,8 @@ see :ref:`parametrize-basics` for some examples.
 Sometimes, values of some parameters need to be generated based on values
 of previous parameters or based on their associated marks.
 
-In such cases ``parametrize`` can be passed a callable for ``argvalues``,
+In such cases :py:func:`Metafunc.parametrize <pytest.Metafunc.parametrize>`
+can be passed a callable for ``argvalues``,
 which will decide how to further parametrize each test instance:
 
 .. code-block:: python
@@ -755,3 +758,10 @@ Running ``pytest`` with verbose mode outputs:
     test_parametrize_dependent.py::test_function[c-w] PASSED             [100%]
 
     ============================ 6 passed in 0.12s =============================
+
+In the example above, the callable form was used to ensure that all marks are
+accounted for.
+
+Params from :hook:`pytest_generate_tests` hooks go after params from
+:ref:`pytest.mark.parametrize <pytest.mark.parametrize ref>` by default.
+:py:func:`pytest.hookimpl` can be used to affect the order of hooks.

src/_pytest/python.py

@@ -1177,6 +1177,7 @@ def parametrize(
             A comma-separated string denoting one or more argument names, or
             a list/tuple of argument strings.
 
+        :type argvalues: Iterable[_pytest.mark.structures.ParameterSet | Sequence[object] | object] | Callable
         :param argvalues:
             The list of argvalues determines how often a test is invoked with
             different argument values.
@@ -1188,9 +1189,9 @@ def parametrize(
             :func:`pytest.param` can be used instead of tuples for additional
             control over parameter sets.
 
-            Parameter sets can be generated depending on previous
-            parametrizations, see :ref:`parametrize_dependent`.
-        :type argvalues: Iterable[_pytest.mark.structures.ParameterSet | Sequence[object] | object] | Callable
+            .. versionadded: 8.4
+                ``argvalues`` can be passed a callable,
+                see :ref:`parametrize_dependent`.
 
         :param indirect:
             A list of arguments' names (subset of argnames) or a boolean.

testing/python/metafunc.py

@@ -2176,11 +2176,13 @@ def test_function(foo, bar):
             ]
         )
 
-    def test_depend_on_marks(self, pytester: Pytester) -> None:
+    def test_hook_depends_on_marks(self, pytester: Pytester) -> None:
         pytester.makepyfile(
             """
             import pytest
 
+            # Note: without hookimpl, the hook goes after the parametrize mark.
+            @pytest.hookimpl(trylast=True)
             def pytest_generate_tests(metafunc: pytest.Metafunc):
                 if "bar" in metafunc.fixturenames:
                     base_bar_marks = list(metafunc.definition.iter_markers("bar_params"))
@@ -2211,16 +2213,60 @@ def test_function(foo, bar):
         result = pytester.runpytest("-vv", "-s")
         result.stdout.fnmatch_lines(
             [
-                "test_depend_on_marks.py::test_function[a-x] PASSED",
-                "test_depend_on_marks.py::test_function[b-x] PASSED",
-                "test_depend_on_marks.py::test_function[b-y] PASSED",
-                "test_depend_on_marks.py::test_function[b-z] PASSED",
-                "test_depend_on_marks.py::test_function[c-x] PASSED",
-                "test_depend_on_marks.py::test_function[c-w] PASSED",
+                "test_hook_depends_on_marks.py::test_function[a-x] PASSED",
+                "test_hook_depends_on_marks.py::test_function[b-x] PASSED",
+                "test_hook_depends_on_marks.py::test_function[b-y] PASSED",
+                "test_hook_depends_on_marks.py::test_function[b-z] PASSED",
+                "test_hook_depends_on_marks.py::test_function[c-x] PASSED",
+                "test_hook_depends_on_marks.py::test_function[c-w] PASSED",
                 "*= 6 passed in *",
             ]
         )
 
+    @pytest.mark.skip(reason=":(")
+    def test_mark_depends_on_hooks(self, pytester: Pytester) -> None:
+        pytester.makepyfile(
+            """
+            import pytest
+
+            # Note: with tryfirst, the hook goes before the parametrize mark.
+            @pytest.hookimpl(wrapper=True)
+            def pytest_generate_tests(metafunc: pytest.Metafunc):
+                if "foo" in metafunc.fixturenames:
+                    metafunc.parametrize(
+                        "foo",
+                        [
+                            pytest.param("a", marks=[pytest.mark.bar_params("x", "y")]),
+                            pytest.param("b", marks=[pytest.mark.bar_params("z")]),
+                        ],
+                    )
+                return (yield)
+
+
+            def gen_params(callspec: pytest.CallSpec):
+                bar_marks = [
+                    mark
+                    for mark in callspec.marks
+                    if mark.name == "bar_params"
+                ]
+                return [arg for mark in bar_marks for arg in mark.args]
+
+
+            @pytest.mark.parametrize("bar", gen_params)
+            def test_function(foo, bar):
+                pass
+        """
+        )
+        result = pytester.runpytest("-vv", "-s")
+        result.stdout.fnmatch_lines(
+            [
+                "test_mark_depends_on_hooks.py::test_function[a-x] PASSED",
+                "test_mark_depends_on_hooks.py::test_function[a-y] PASSED",
+                "test_mark_depends_on_hooks.py::test_function[b-z] PASSED",
+                "*= 3 passed in *",
+            ]
+        )
+
     def test_id_and_marks(self, pytester: Pytester) -> None:
         pytester.makepyfile(
             """