Allow hiding a parameter set from test name

Resolves: #13228

Author: Anton3

AUTHORS

@@ -43,6 +43,7 @@ Anthony Shaw
 Anthony Sottile
 Anton Grinevich
 Anton Lodder
+Anton Zhilin
 Antony Lee
 Arel Cordero
 Arias Emmanuel

changelog/13228.feature.rst

@@ -0,0 +1 @@
+``pytest.HIDDEN_PARAM`` can now be used in ``id`` of ``pytest.param`` or in ``ids`` of ``parametrize``. It hides the parameter set from the test name.

src/_pytest/mark/__init__.py

@@ -14,6 +14,7 @@
 from .expression import ParseError
 from .structures import EMPTY_PARAMETERSET_OPTION
 from .structures import get_empty_parameterset_mark
+from .structures import HIDDEN_PARAM
 from .structures import Mark
 from .structures import MARK_GEN
 from .structures import MarkDecorator
@@ -33,6 +34,7 @@
 
 
 __all__ = [
+    "HIDDEN_PARAM",
     "MARK_GEN",
     "Mark",
     "MarkDecorator",

src/_pytest/mark/structures.py

@@ -10,6 +10,7 @@
 from collections.abc import MutableMapping
 from collections.abc import Sequence
 import dataclasses
+import enum
 import inspect
 from typing import Any
 from typing import final
@@ -65,17 +66,27 @@ def get_empty_parameterset_mark(
     return mark
 
 
+# Singleton type for NOTSET, as described in:
+# https://www.python.org/dev/peps/pep-0484/#support-for-singleton-types-in-unions
+class _HiddenParam(enum.Enum):
+    token = 0
+
+
+#: Can be used as a parameter set id to hide it from the test name.
+HIDDEN_PARAM = _HiddenParam.token
+
+
 class ParameterSet(NamedTuple):
     values: Sequence[object | NotSetType]
     marks: Collection[MarkDecorator | Mark]
-    id: str | None
+    id: str | _HiddenParam | None
 
     @classmethod
     def param(
         cls,
         *values: object,
         marks: MarkDecorator | Collection[MarkDecorator | Mark] = (),
-        id: str | None = None,
+        id: str | _HiddenParam | None = None,
     ) -> ParameterSet:
         if isinstance(marks, MarkDecorator):
             marks = (marks,)
@@ -88,7 +99,7 @@ def param(
             )
 
         if id is not None:
-            if not isinstance(id, str):
+            if not isinstance(id, str) and id is not HIDDEN_PARAM:
                 raise TypeError(f"Expected id to be a string, got {type(id)}: {id!r}")
         return cls(values, marks, id)
 

src/_pytest/python.py

@@ -25,6 +25,7 @@
 from typing import Any
 from typing import final
 from typing import Literal
+from typing import NoReturn
 from typing import TYPE_CHECKING
 import warnings
 
@@ -57,6 +58,7 @@
 from _pytest.main import Session
 from _pytest.mark import ParameterSet
 from _pytest.mark.structures import get_unpacked_marks
+from _pytest.mark.structures import HIDDEN_PARAM
 from _pytest.mark.structures import Mark
 from _pytest.mark.structures import MarkDecorator
 from _pytest.mark.structures import normalize_mark_list
@@ -473,13 +475,14 @@ def _genfunctions(self, name: str, funcobj) -> Iterator[Function]:
             fixtureinfo.prune_dependency_tree()
 
             for callspec in metafunc._calls:
-                subname = f"{name}[{callspec.id}]"
+                params_id = callspec.id
+                subname = f"{name}[{params_id}]" if params_id else name
                 yield Function.from_parent(
                     self,
                     name=subname,
                     callspec=callspec,
                     fixtureinfo=fixtureinfo,
-                    keywords={callspec.id: True},
+                    keywords={params_id: True},
                     originalname=name,
                 )
 
@@ -884,7 +887,7 @@ class IdMaker:
     # Used only for clearer error messages.
     func_name: str | None
 
-    def make_unique_parameterset_ids(self) -> list[str]:
+    def make_unique_parameterset_ids(self) -> list[str | None]:
         """Make a unique identifier for each ParameterSet, that may be used to
         identify the parametrization in a node ID.
 
@@ -905,6 +908,8 @@ def make_unique_parameterset_ids(self) -> list[str]:
             # Suffix non-unique IDs to make them unique.
             for index, id in enumerate(resolved_ids):
                 if id_counts[id] > 1:
+                    if id is None:
+                        self._complain_multiple_hidden_parameter_sets()
                     suffix = ""
                     if id and id[-1].isdigit():
                         suffix = "_"
@@ -919,15 +924,21 @@ def make_unique_parameterset_ids(self) -> list[str]:
         )
         return resolved_ids
 
-    def _resolve_ids(self) -> Iterable[str]:
+    def _resolve_ids(self) -> Iterable[str | None]:
         """Resolve IDs for all ParameterSets (may contain duplicates)."""
         for idx, parameterset in enumerate(self.parametersets):
             if parameterset.id is not None:
                 # ID provided directly - pytest.param(..., id="...")
-                yield _ascii_escaped_by_config(parameterset.id, self.config)
+                if parameterset.id is HIDDEN_PARAM:
+                    yield None
+                else:
+                    yield _ascii_escaped_by_config(parameterset.id, self.config)
             elif self.ids and idx < len(self.ids) and self.ids[idx] is not None:
                 # ID provided in the IDs list - parametrize(..., ids=[...]).
-                yield self._idval_from_value_required(self.ids[idx], idx)
+                if self.ids[idx] is HIDDEN_PARAM:
+                    yield None
+                else:
+                    yield self._idval_from_value_required(self.ids[idx], idx)
             else:
                 # ID not provided - generate it.
                 yield "-".join(
@@ -1001,12 +1012,7 @@ def _idval_from_value_required(self, val: object, idx: int) -> str:
             return id
 
         # Fail.
-        if self.func_name is not None:
-            prefix = f"In {self.func_name}: "
-        elif self.nodeid is not None:
-            prefix = f"In {self.nodeid}: "
-        else:
-            prefix = ""
+        prefix = self._make_error_prefix()
         msg = (
             f"{prefix}ids contains unsupported value {saferepr(val)} (type: {type(val)!r}) at index {idx}. "
             "Supported types are: str, bytes, int, float, complex, bool, enum, regex or anything with a __name__."
@@ -1019,6 +1025,21 @@ def _idval_from_argname(argname: str, idx: int) -> str:
         and the index of the ParameterSet."""
         return str(argname) + str(idx)
 
+    def _complain_multiple_hidden_parameter_sets(self) -> NoReturn:
+        fail(
+            f"{self._make_error_prefix()}multiple instances of HIDDEN_PARAM "
+            "cannot be used in the same parametrize call, "
+            "because the tests names need to be unique."
+        )
+
+    def _make_error_prefix(self) -> str:
+        if self.func_name is not None:
+            return f"In {self.func_name}: "
+        elif self.nodeid is not None:
+            return f"In {self.nodeid}: "
+        else:
+            return ""
+
 
 @final
 @dataclasses.dataclass(frozen=True)
@@ -1047,7 +1068,7 @@ def setmulti(
         *,
         argnames: Iterable[str],
         valset: Iterable[object],
-        id: str,
+        id: str | None,
         marks: Iterable[Mark | MarkDecorator],
         scope: Scope,
         param_index: int,
@@ -1065,7 +1086,7 @@ def setmulti(
             params=params,
             indices=indices,
             _arg2scope=arg2scope,
-            _idlist=[*self._idlist, id],
+            _idlist=[*self._idlist, id] if id else self._idlist,
             marks=[*self.marks, *normalize_mark_list(marks)],
         )
 
@@ -1189,6 +1210,8 @@ def parametrize(
             ``bool``, or ``None``.
             They are mapped to the corresponding index in ``argvalues``.
             ``None`` means to use the auto-generated id.
+            ``pytest.HIDDEN_PARAM`` means to hide the parameter set
+            from the test name.
 
             If it is a callable it will be called for each entry in
             ``argvalues``, and the return value is used as part of the
@@ -1322,7 +1345,7 @@ def _resolve_parameter_set_ids(
         ids: Iterable[object | None] | Callable[[Any], object | None] | None,
         parametersets: Sequence[ParameterSet],
         nodeid: str,
-    ) -> list[str]:
+    ) -> list[str | None]:
         """Resolve the actual ids for the given parameter sets.
 
         :param argnames:

src/pytest/__init__.py

@@ -33,6 +33,7 @@
 from _pytest.logging import LogCaptureFixture
 from _pytest.main import Dir
 from _pytest.main import Session
+from _pytest.mark import HIDDEN_PARAM
 from _pytest.mark import Mark
 from _pytest.mark import MARK_GEN as mark
 from _pytest.mark import MarkDecorator
@@ -89,6 +90,7 @@
 
 
 __all__ = [
+    "HIDDEN_PARAM",
     "Cache",
     "CallInfo",
     "CaptureFixture",

testing/python/metafunc.py

@@ -2143,3 +2143,122 @@ def test_converted_to_str(a, b):
                 "*= 6 passed in *",
             ]
         )
+
+
+class TestHiddenParam:
+    """Test that pytest.HIDDEN_PARAM works"""
+
+    def test_parametrize_ids(self, pytester: Pytester) -> None:
+        pytester.makepyfile(
+            """
+            import pytest
+
+            @pytest.mark.parametrize(
+                ("foo", "bar"),
+                [
+                    ("a", "x"),
+                    ("b", "y"),
+                    ("c", "z"),
+                ],
+                ids=["paramset1", pytest.HIDDEN_PARAM, "paramset3"],
+            )
+            def test_func(foo, bar):
+                pass
+        """
+        )
+        result = pytester.runpytest("-vv", "-s")
+        result.stdout.fnmatch_lines(
+            [
+                "test_parametrize_ids.py::test_func[paramset1] PASSED",
+                "test_parametrize_ids.py::test_func PASSED",
+                "test_parametrize_ids.py::test_func[paramset3] PASSED",
+                "*= 3 passed in *",
+            ]
+        )
+
+    def test_param_id(self, pytester: Pytester) -> None:
+        pytester.makepyfile(
+            """
+            import pytest
+
+            @pytest.mark.parametrize(
+                ("foo", "bar"),
+                [
+                    pytest.param("a", "x", id="paramset1"),
+                    pytest.param("b", "y", id=pytest.HIDDEN_PARAM),
+                    ("c", "z"),
+                ],
+            )
+            def test_func(foo, bar):
+                pass
+        """
+        )
+        result = pytester.runpytest("-vv", "-s")
+        result.stdout.fnmatch_lines(
+            [
+                "test_param_id.py::test_func[paramset1] PASSED",
+                "test_param_id.py::test_func PASSED",
+                "test_param_id.py::test_func[c-z] PASSED",
+                "*= 3 passed in *",
+            ]
+        )
+
+    def test_multiple_hidden_param_is_forbidden(self, pytester: Pytester) -> None:
+        pytester.makepyfile(
+            """
+            import pytest
+
+            @pytest.mark.parametrize(
+                ("foo", "bar"),
+                [
+                    ("a", "x"),
+                    ("b", "y"),
+                ],
+                ids=[pytest.HIDDEN_PARAM, pytest.HIDDEN_PARAM],
+            )
+            def test_func(foo, bar):
+                pass
+        """
+        )
+        result = pytester.runpytest("--collect-only")
+        result.stdout.fnmatch_lines(
+            [
+                "collected 0 items / 1 error",
+                "",
+                "*= ERRORS =*",
+                "*_ ERROR collecting test_multiple_hidden_param_is_forbidden.py _*",
+                "E   Failed: In test_func: multiple instances of HIDDEN_PARAM cannot be used "
+                "in the same parametrize call, because the tests names need to be unique.",
+                "*! Interrupted: 1 error during collection !*",
+                "*= no tests collected, 1 error in *",
+            ]
+        )
+
+    def test_multiple_parametrize(self, pytester: Pytester) -> None:
+        pytester.makepyfile(
+            """
+            import pytest
+
+            @pytest.mark.parametrize(
+                "bar",
+                ["x", "y"],
+            )
+            @pytest.mark.parametrize(
+                "foo",
+                ["a", "b"],
+                ids=["a", pytest.HIDDEN_PARAM],
+            )
+            def test_func(foo, bar):
+                pass
+        """
+        )
+        result = pytester.runpytest("-vv", "-s")
+        result.stdout.fnmatch_lines(
+            [
+                "test_multiple_parametrize.py::test_func[a-x] PASSED",
+                "test_multiple_parametrize.py::test_func[a-y] PASSED",
+                "test_multiple_parametrize.py::test_func[x] PASSED",
+                "test_multiple_parametrize.py::test_func[y] PASSED",
+                "*= 4 passed in *",
+            ]
+        )