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

Author: gomri15

doc/en/reference/reference.rst

@@ -2104,7 +2104,7 @@ passed multiple times. The expected format is ``name=value``. For example::
             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".
+    Otherwise, pytest would handle this by generating unique IDs like "a0", "a1".
 
 
 .. _`command-line-flags`:

src/_pytest/python.py

@@ -913,7 +913,7 @@ def make_unique_parameterset_ids(self) -> list[str | _HiddenParam]:
                 arugment_values = [
                     saferepr(param.values) for param in self.parametersets
                 ]
-                error_msg = f"""
+                error_msg = textwrap.dedent(f"""
                     Duplicate parametrization IDs detected, but --require-unique-parametrization-ids is set.
 
                     Test name: {self.nodeid}
@@ -924,8 +924,8 @@ def make_unique_parameterset_ids(self) -> list[str | _HiddenParam]:
 
                     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))
+                    """)
+                raise nodes.Collector.CollectError(error_msg)
             # Record the number of occurrences of each ID.
             id_counts = Counter(resolved_ids)
             # Map the ID to its next suffix.

testing/test_collection.py

@@ -1,6 +1,7 @@
 # mypy: allow-untyped-defs
 from __future__ import annotations
 
+from collections.abc import Sequence
 from collections.abc import Sequence
 import os
 from pathlib import Path
@@ -2708,41 +2709,6 @@ def test_1(): pass
 
 
 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 = [
@@ -2812,19 +2778,53 @@ def test_cli_overrides_ini_false(self, pytester: Pytester) -> None:
             require_unique_parametrization_ids = false
             """
         )
+        parametrization_args = [(1, 1), (1, 1)]
         pytester.makepyfile(
-            """
+            f"""
             import pytest
 
-            @pytest.mark.parametrize('x, y', [(1,1), (1,1)])
+            @pytest.mark.parametrize('x, y', {parametrization_args})
             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
         )
+
+    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"{argument1}-{argument2}" for (argument1, argument2) in parametrize_args
+        ]
+
+    def _convert_to_argument_values(
+        self, parametrize_args: Sequence[tuple[int, int]]
+    ) -> Sequence[str]:
+        return [str(argument) for argument in parametrize_args]