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-parametrization-ids`` command-line flag and :confval:`require_unique_parametrization_ids` configuration option.
+
+When passed, pytest will emit an error if it detects non-unique parameter set IDs,
+rather than automatically making the IDs unique by adding `0`, `1`, ... to them.

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_parametrization_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-parametrization-ids`.
+
+    .. code-block:: ini
+
+          [pytest]
+          require_unique_parametrization_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-parametrization-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-parametrization-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_parametrization_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"""
+                    Duplicate parametrization IDs detected, but --require-unique-parametrization-ids is set.
+
+                    Test name: {self.nodeid}
+                    Argument names: {self.argnames}
+                    Argument values: {arugment_values}
+                    Resolved IDs: {resolved_ids}
+                    Duplicates: {duplicates}
+
+                    You can fix this problem using:
+                    the `ids` argument of `@pytest.mark.parametrize()` or the `id` argument of `pytest.param()`.
+                    """
+                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_parametrization_ids")
+            if cli_value:
+                return bool(cli_value)
+            return bool(self.config.getini("require_unique_parametrization_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

@@ -1,10 +1,12 @@
 # mypy: allow-untyped-defs
 from __future__ import annotations
 
+from collections.abc import Sequence
 import os
 from pathlib import Path
 from pathlib import PurePath
 import pprint
+import re
 import shutil
 import sys
 import tempfile
@@ -20,6 +22,7 @@
 from _pytest.pathlib import symlink_or_skip
 from _pytest.pytester import HookRecorder
 from _pytest.pytester import Pytester
+from _pytest.pytester import RunResult
 import pytest
 
 
@@ -2497,7 +2500,7 @@ def test_1(): pass
                 "      <Class TestIt>",
                 "        <Function test_2>",
                 "      <Function test_3>",
-                "    <Module test_2.py>",
+                # "    <Module test_2.py>",
                 "      <Function test_1>",
                 "  <Package top2>",
                 "    <Module test_1.py>",
@@ -2702,3 +2705,126 @@ def test_1(): pass
             ],
             consecutive=True,
         )
+
+
+class TestRequireUniqueParametrizationtIds:
+    @staticmethod
+    def _fnmatch_escape_repr(obj: Sequence[tuple[int]]) -> str:
+        return re.sub(r"[*?[\]]", (lambda m: f"[{m.group()}]"), repr(obj))
+
+    def _assert_duplicate_msg(
+        self,
+        result: RunResult,
+        expected_indices: dict[str, Sequence[int]],
+        argument_values: Sequence[str],
+        resolved_ids: Sequence[str],
+    ) -> None:
+        stream = result.stdout
+        stream.fnmatch_lines(
+            [
+                "Duplicate parametrization IDs detected, but --require-unique-parametrization-ids is set.",
+                "Test name: *::test1",
+                "Argument names: [[]'x', 'y'[]]",
+                f"Argument values: {argument_values}",
+                f"Resolved IDs: {resolved_ids}",
+                f"Duplicates: {expected_indices}",
+                "You can fix this problem using:",
+                "the `ids` argument of `@pytest.mark.parametrize()` or the `id` argument of `pytest.param()`.",
+            ]
+        )
+        assert result.ret != 0
+
+    def _convert_to_resolved_ids(
+        self, parametrize_args: Sequence[tuple[int, int]]
+    ) -> Sequence[str]:
+        return [f"{x}-{y}" for (x, y) in parametrize_args]
+
+    def _convert_to_argument_values(
+        self, parametrize_args: Sequence[tuple[int, int]]
+    ) -> Sequence[str]:
+        return [str(t) for t in parametrize_args]
+
+    # Change the test data to native Python types
+    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]}),
+    ]
+
+    @pytest.mark.parametrize(("parametrize_args", "expected_indices"), CASES)
+    def test_cli_enables(
+        self,
+        pytester: Pytester,
+        parametrize_args: Sequence[tuple[int, int]],
+        expected_indices: dict[str, Sequence[int]],
+    ) -> None:
+        pytester.makepyfile(
+            f"""
+            import pytest
+
+            @pytest.mark.parametrize('x, y', {parametrize_args})
+            def test1(y, x):
+                pass
+            """
+        )
+        result = pytester.runpytest("--require-unique-parametrization-ids")
+        resolved_ids = self._convert_to_resolved_ids(parametrize_args)
+        argument_values = self._convert_to_argument_values(parametrize_args)
+        self._assert_duplicate_msg(
+            result, expected_indices, argument_values, resolved_ids
+        )
+
+    @pytest.mark.parametrize("parametrize_args, expected_indices", CASES)
+    def test_ini_enables(
+        self,
+        pytester: Pytester,
+        parametrize_args: Sequence[tuple[int, int]],
+        expected_indices: dict[str, Sequence[int]],
+    ) -> None:
+        pytester.makeini(
+            """
+            [pytest]
+            require_unique_parametrization_ids = true
+            """
+        )
+        pytester.makepyfile(
+            f"""
+                    import pytest
+
+                    @pytest.mark.parametrize('x, y', {parametrize_args})
+                    def test1(y, x):
+                        pass
+                    """
+        )
+        result = pytester.runpytest()
+        resolved_ids = self._convert_to_resolved_ids(parametrize_args)
+        argument_values = self._convert_to_argument_values(parametrize_args)
+        self._assert_duplicate_msg(
+            result, expected_indices, argument_values, resolved_ids
+        )
+
+    def test_cli_overrides_ini_false(self, pytester: Pytester) -> None:
+        """CLI True should override ini False."""
+        pytester.makeini(
+            """
+            [pytest]
+            require_unique_parametrization_ids = false
+            """
+        )
+        pytester.makepyfile(
+            """
+            import pytest
+
+            @pytest.mark.parametrize('x, y', [(1,1), (1,1)])
+            def test1(y, x):
+                pass
+            """
+        )
+        result = pytester.runpytest("--require-unique-parametrization-ids")
+        parametrization_args = [(1, 1), (1, 1)]
+        resolved_ids = self._convert_to_resolved_ids(parametrization_args)
+        argument_values = self._convert_to_argument_values(parametrization_args)
+        self._assert_duplicate_msg(
+            result, {"1-1": [0, 1]}, argument_values, resolved_ids
+        )