feat: add cli, ini option skips pytest internal logic of id generation and raise error

Author: gomri15

changelog/13737.feature.rst

@@ -0,0 +1,4 @@
+Added the ``--require-unique-parameterization-ids`` command-line flag and :confval:`require_unique_parameterization_ids` configuration option to pytest.
+
+When passed, this flag causes pytest to raise an exception upon detection of non-unique parameter set IDs,
+rather than automatically modifying the IDs to ensure uniqueness.

doc/en/reference/reference.rst

@@ -2082,6 +2082,30 @@ passed multiple times. The expected format is ``name=value``. For example::
         [pytest]
         xfail_strict = True
 
+.. confval:: require_unique_parameterization_ids
+
+    When passed, this flag causes pytest to raise an exception upon detection of non-unique parameter set IDs,
+    rather than attempting to generate them automatically.
+
+    Can be overridden by `--require-unique-parameterization-ids`.
+
+    .. code-block:: ini
+
+          [pytest]
+          require_unique_parameterization_ids = True
+
+    .. code-block:: python
+
+        import pytest
+
+
+        @pytest.mark.parametrize("x", [1, 2], ids=["a", "a"])
+        def test_example(x):
+            assert x in (1, 2)
+
+    will raise an exception due to the duplicate IDs "a".
+    when normal pytest behavior would be to handle this by generating unique IDs like "a-0", "a-1".
+
 
 .. _`command-line-flags`:
 
@@ -2239,6 +2263,11 @@ All the command-line flags can be obtained by running ``pytest --help``::
       --doctest-continue-on-failure
                             For a given doctest, continue to run after the first
                             failure
+      --require-unique-parameterization-ids
+                            If pytest collects test ids with non-unique names, raise an
+                            error rather than handling it.
+                            Useful if you collect in one process,
+                            and then execute tests in independent workers.
 
     test session debugging and configuration:
       -c, --config-file FILE

src/_pytest/main.py

@@ -90,6 +90,21 @@ def pytest_addoption(parser: Parser) -> None:
         action="store_true",
         help="(Deprecated) alias to --strict-markers",
     )
+    group.addoption(
+        "--require-unique-parameterization-ids",
+        action="store_true",
+        default=False,
+        help="When passed, this flag causes pytest to raise an exception upon detection of non-unique parameter set IDs"
+        " rather than attempting to generate them automatically.",
+    )
+
+    parser.addini(
+        "require_unique_parameterization_ids",
+        type="bool",
+        default=False,
+        help="When passed, this flag causes pytest to raise an exception upon detection of non-unique parameter set IDs"
+        " rather than attempting to generate them automatically.",
+    )
 
     group = parser.getgroup("pytest-warnings")
     group.addoption(

src/_pytest/python.py

@@ -21,6 +21,7 @@
 import os
 from pathlib import Path
 import re
+import textwrap
 import types
 from typing import Any
 from typing import final
@@ -902,6 +903,29 @@ def make_unique_parameterset_ids(self) -> list[str | _HiddenParam]:
         resolved_ids = list(self._resolve_ids())
         # All IDs must be unique!
         if len(resolved_ids) != len(set(resolved_ids)):
+            if self._require_unique_ids_enabled():
+                duplicate_indexs = defaultdict(list)
+                for i, val in enumerate(resolved_ids):
+                    duplicate_indexs[val].append(i)
+
+                # Keep only duplicates
+                duplicates = {k: v for k, v in duplicate_indexs.items() if len(v) > 1}
+                arugment_values = [
+                    saferepr(param.values) for param in self.parametersets
+                ]
+                error_msg = f"""
+                    When --require-unique-parameterization-ids set, pytest won't generate unique IDs for parameters.
+                    test name: {self.nodeid}
+                    argument names: {self.argnames}
+                    argument values: {arugment_values}
+                    resolved (with non-unique) IDs: {resolved_ids}
+                    duplicates: {duplicates}
+                    you must make sure all parameterization IDs are unique, either by:
+                    - providing unique IDs per parameterization via the ids=[...] argument to @pytest.mark.parametrize
+                    - providing a custom id function that generates unique IDs for each parameterization
+                    - not setting --require-unique-parameterization-ids
+                    """
+                raise nodes.Collector.CollectError(textwrap.dedent(error_msg))
             # Record the number of occurrences of each ID.
             id_counts = Counter(resolved_ids)
             # Map the ID to its next suffix.
@@ -925,6 +949,14 @@ def make_unique_parameterset_ids(self) -> list[str | _HiddenParam]:
         )
         return resolved_ids
 
+    def _require_unique_ids_enabled(self) -> bool:
+        if self.config:
+            cli_value = self.config.getoption("require_unique_parameterization_ids")
+            if cli_value:
+                return bool(cli_value)
+            return bool(self.config.getini("require_unique_parameterization_ids"))
+        return False
+
     def _resolve_ids(self) -> Iterable[str | _HiddenParam]:
         """Resolve IDs for all ParameterSets (may contain duplicates)."""
         for idx, parameterset in enumerate(self.parametersets):

testing/test_collection.py

@@ -5,6 +5,7 @@
 from pathlib import Path
 from pathlib import PurePath
 import pprint
+import re
 import shutil
 import sys
 import tempfile
@@ -2702,3 +2703,98 @@ def test_1(): pass
             ],
             consecutive=True,
         )
+
+
+class TestRequireUniqueParamsetIds:
+    CASES = [
+        ("[(1, 1), (1, 1)]", {"1-1": [0, 1]}),
+        ("[(1, 1), (1, 2), (1, 1)]", {"1-1": [0, 2]}),
+        ("[(1, 1), (2, 2), (1, 1)]", {"1-1": [0, 2]}),
+        ("[(1, 1), (2, 2), (1, 2), (2, 1), (1, 1)]", {"1-1": [0, 4]}),
+    ]
+
+    @staticmethod
+    def _make_testfile(pytester: Pytester, parametrize_args: str) -> None:
+        pytester.makepyfile(
+            f"""
+            import pytest
+
+            @pytest.mark.parametrize('y, x', {parametrize_args})
+            def test1(y, x):
+                pass
+            """
+        )
+
+    @staticmethod
+    def _fnmatch_escape_repr(obj) -> str:
+        return re.sub(r"[*?[\]]", (lambda m: f"[{m.group()}]"), repr(obj))
+
+    def _assert_duplicate_msg(self, result, expected_indices):
+        stream = result.stdout
+        stream.fnmatch_lines(
+            [
+                "When --require-unique-parameterization-ids set, pytest won't generate unique IDs for parameters.",
+                "test name: *::test1",
+                "argument names: [[]'y', 'x'[]]",
+                f"duplicates: {self._fnmatch_escape_repr(expected_indices)}",
+                "you must make sure all parameterization IDs are unique, either by:",
+                "- providing unique IDs per parameterization via the ids=[...] argument to @pytest.mark.parametrize",
+                "- providing a custom id function that generates unique IDs for each parameterization",
+                "- not setting --require-unique-parameterization-ids",
+            ]
+        )
+        assert result.ret != 0
+
+    @pytest.mark.parametrize("parametrize_args, expected_indices", CASES)
+    def test_cli_enables(self, pytester: Pytester, parametrize_args, expected_indices):
+        pytester.makepyfile(
+            f"""
+            import pytest
+
+            @pytest.mark.parametrize('y, x', {parametrize_args})
+            def test1(y, x):
+                pass
+            """
+        )
+        result = pytester.runpytest("--require-unique-parameterization-ids")
+        self._assert_duplicate_msg(result, expected_indices)
+
+    @pytest.mark.parametrize("parametrize_args, expected_indices", CASES)
+    def test_ini_enables(self, pytester: Pytester, parametrize_args, expected_indices):
+        pytester.makeini(
+            """
+            [pytest]
+            require_unique_parameterization_ids = true
+            """
+        )
+        pytester.makepyfile(
+            f"""
+                    import pytest
+
+                    @pytest.mark.parametrize('y, x', {parametrize_args})
+                    def test1(y, x):
+                        pass
+                    """
+        )
+        result = pytester.runpytest()
+        self._assert_duplicate_msg(result, expected_indices)
+
+    def test_cli_overrides_ini_false(self, pytester: Pytester):
+        """CLI True should override ini False."""
+        pytester.makeini(
+            """
+            [pytest]
+            require_unique_parameterization_ids = false
+            """
+        )
+        pytester.makepyfile(
+            """
+            import pytest
+
+            @pytest.mark.parametrize('y, x', [(1,1), (1,1)])
+            def test1(y, x):
+                pass
+            """
+        )
+        result = pytester.runpytest("--require-unique-parameterization-ids")
+        self._assert_duplicate_msg(result, {"1-1": [0, 1]})