feat: add --require-unique-paramset-ids option skips pytest internal logic of id generation

Author: gomri15

changelog/13737.feature.rst

@@ -0,0 +1,4 @@
+Added the ``--require-unique-paramset-ids`` flag to pytest.
+
+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.

doc/en/example/.ruff.toml

@@ -1 +1 @@
-ignore = ["RUF059"]
+lint.ignore = ["RUF059"]

doc/en/reference/reference.rst

@@ -2220,6 +2220,10 @@ 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-paramset-ids
+                            If pytest generates non-unique parameter ids, raise an
+                            error rather than fixing this.  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/assertion/rewrite.py

@@ -703,24 +703,17 @@ def run(self, mod: ast.Module) -> None:
             return
         pos = 0
         for item in mod.body:
-            if (
-                expect_docstring
-                and isinstance(item, ast.Expr)
-                and isinstance(item.value, ast.Constant)
-                and isinstance(item.value.value, str)
-            ):
-                doc = item.value.value
-                if self.is_rewrite_disabled(doc):
-                    return
-                expect_docstring = False
-            elif (
-                isinstance(item, ast.ImportFrom)
-                and item.level == 0
-                and item.module == "__future__"
-            ):
-                pass
-            else:
-                break
+            match item:
+                case ast.Expr(value=ast.Constant(value=str() as doc)) if (
+                    expect_docstring
+                ):
+                    if self.is_rewrite_disabled(doc):
+                        return
+                    expect_docstring = False
+                case ast.ImportFrom(level=0, module="__future__"):
+                    pass
+                case _:
+                    break
             pos += 1
         # Special case: for a decorated function, set the lineno to that of the
         # first decorator, not the `def`. Issue #4984.
@@ -1017,20 +1010,17 @@ def visit_BoolOp(self, boolop: ast.BoolOp) -> tuple[ast.Name, str]:
                 # cond is set in a prior loop iteration below
                 self.expl_stmts.append(ast.If(cond, fail_inner, []))  # noqa: F821
                 self.expl_stmts = fail_inner
-                # Check if the left operand is a ast.NamedExpr and the value has already been visited
-                if (
-                    isinstance(v, ast.Compare)
-                    and isinstance(v.left, ast.NamedExpr)
-                    and v.left.target.id
-                    in [
-                        ast_expr.id
-                        for ast_expr in boolop.values[:i]
-                        if hasattr(ast_expr, "id")
-                    ]
-                ):
-                    pytest_temp = self.variable()
-                    self.variables_overwrite[self.scope][v.left.target.id] = v.left  # type:ignore[assignment]
-                    v.left.target.id = pytest_temp
+                match v:
+                    # Check if the left operand is an ast.NamedExpr and the value has already been visited
+                    case ast.Compare(
+                        left=ast.NamedExpr(target=ast.Name(id=target_id))
+                    ) if target_id in [
+                        e.id for e in boolop.values[:i] if hasattr(e, "id")
+                    ]:
+                        pytest_temp = self.variable()
+                        self.variables_overwrite[self.scope][target_id] = v.left  # type:ignore[assignment]
+                        # mypy's false positive, we're checking that the 'target' attribute exists.
+                        v.left.target.id = pytest_temp  # type:ignore[attr-defined]
             self.push_format_context()
             res, expl = self.visit(v)
             body.append(ast.Assign([ast.Name(res_var, ast.Store())], res))
@@ -1080,10 +1070,11 @@ def visit_Call(self, call: ast.Call) -> tuple[ast.Name, str]:
             arg_expls.append(expl)
             new_args.append(res)
         for keyword in call.keywords:
-            if isinstance(
-                keyword.value, ast.Name
-            ) and keyword.value.id in self.variables_overwrite.get(self.scope, {}):
-                keyword.value = self.variables_overwrite[self.scope][keyword.value.id]  # type:ignore[assignment]
+            match keyword.value:
+                case ast.Name(id=id) if id in self.variables_overwrite.get(
+                    self.scope, {}
+                ):
+                    keyword.value = self.variables_overwrite[self.scope][id]  # type:ignore[assignment]
             res, expl = self.visit(keyword.value)
             new_kwargs.append(ast.keyword(keyword.arg, res))
             if keyword.arg:
@@ -1119,12 +1110,13 @@ def visit_Attribute(self, attr: ast.Attribute) -> tuple[ast.Name, str]:
     def visit_Compare(self, comp: ast.Compare) -> tuple[ast.expr, str]:
         self.push_format_context()
         # We first check if we have overwritten a variable in the previous assert
-        if isinstance(
-            comp.left, ast.Name
-        ) and comp.left.id in self.variables_overwrite.get(self.scope, {}):
-            comp.left = self.variables_overwrite[self.scope][comp.left.id]  # type:ignore[assignment]
-        if isinstance(comp.left, ast.NamedExpr):
-            self.variables_overwrite[self.scope][comp.left.target.id] = comp.left  # type:ignore[assignment]
+        match comp.left:
+            case ast.Name(id=name_id) if name_id in self.variables_overwrite.get(
+                self.scope, {}
+            ):
+                comp.left = self.variables_overwrite[self.scope][name_id]  # type: ignore[assignment]
+            case ast.NamedExpr(target=ast.Name(id=target_id)):
+                self.variables_overwrite[self.scope][target_id] = comp.left  # type: ignore[assignment]
         left_res, left_expl = self.visit(comp.left)
         if isinstance(comp.left, ast.Compare | ast.BoolOp):
             left_expl = f"({left_expl})"
@@ -1136,13 +1128,14 @@ def visit_Compare(self, comp: ast.Compare) -> tuple[ast.expr, str]:
         syms: list[ast.expr] = []
         results = [left_res]
         for i, op, next_operand in it:
-            if (
-                isinstance(next_operand, ast.NamedExpr)
-                and isinstance(left_res, ast.Name)
-                and next_operand.target.id == left_res.id
-            ):
-                next_operand.target.id = self.variable()
-                self.variables_overwrite[self.scope][left_res.id] = next_operand  # type:ignore[assignment]
+            match (next_operand, left_res):
+                case (
+                    ast.NamedExpr(target=ast.Name(id=target_id)),
+                    ast.Name(id=name_id),
+                ) if target_id == name_id:
+                    next_operand.target.id = self.variable()
+                    self.variables_overwrite[self.scope][name_id] = next_operand  # type: ignore[assignment]
+
             next_res, next_expl = self.visit(next_operand)
             if isinstance(next_operand, ast.Compare | ast.BoolOp):
                 next_expl = f"({next_expl})"

src/_pytest/main.py

@@ -90,6 +90,13 @@ def pytest_addoption(parser: Parser) -> None:
         action="store_true",
         help="(Deprecated) alias to --strict-markers",
     )
+    group.addoption(
+        "--require-unique-paramset-ids",
+        action="store_true",
+        default=False,
+        help="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

@@ -50,6 +50,7 @@
 from _pytest.config import Config
 from _pytest.config import hookimpl
 from _pytest.config.argparsing import Parser
+from _pytest.config.exceptions import UsageError
 from _pytest.deprecated import check_ispytest
 from _pytest.fixtures import FixtureDef
 from _pytest.fixtures import FixtureRequest
@@ -902,6 +903,25 @@ 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.config and self.config.cache._config.getoption(
+                "require_unique_paramset_ids"
+            ):
+                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}
+                raise UsageError(f"""
+                    Because: require_unique_parameterset_ids is set, pytest won't
+                    attempt to generate unique IDs for parameter sets.
+                    argument values: {self.parametersets}
+                    argument names: {self.argnames}
+                    function name: {self.func_name}
+                    test name: {self.nodeid}
+                    resolved (with non-unique) IDs: {resolved_ids}
+                    duplicates: {duplicates}
+                    """)
             # Record the number of occurrences of each ID.
             id_counts = Counter(resolved_ids)
             # Map the ID to its next suffix.

testing/test_assertrewrite.py

@@ -1552,7 +1552,9 @@ def test_simple_failure():
         result.stdout.fnmatch_lines(["*E*assert (1 + 1) == 3"])
 
 
-class TestIssue10743:
+class TestAssertionRewriteWalrusOperator:
+    """See #10743"""
+
     def test_assertion_walrus_operator(self, pytester: Pytester) -> None:
         pytester.makepyfile(
             """
@@ -1719,6 +1721,22 @@ def test_walrus_operator_not_override_value():
         result = pytester.runpytest()
         assert result.ret == 0
 
+    def test_assertion_namedexpr_compare_left_overwrite(
+        self, pytester: Pytester
+    ) -> None:
+        pytester.makepyfile(
+            """
+            def test_namedexpr_compare_left_overwrite():
+                a = "Hello"
+                b = "World"
+                c = "Test"
+                assert (a := b) == c and (a := "Test") == "Test"
+            """
+        )
+        result = pytester.runpytest()
+        assert result.ret == 1
+        result.stdout.fnmatch_lines(["*assert ('World' == 'Test'*"])
+
 
 class TestIssue11028:
     def test_assertion_walrus_operator_in_operand(self, pytester: Pytester) -> None:

testing/test_collection.py

@@ -2031,3 +2031,36 @@ def test_namespace_packages(pytester: Pytester, import_mode: str):
             "      <Function test_module3>",
         ]
     )
+
+
+@pytest.mark.parametrize(
+    "parametrize_args, expected_indexs",
+    [
+        ("[(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[]]}"),
+    ],
+)
+def test_option_parametrize_require_unique_paramset_ids(
+    pytester: Pytester, parametrize_args, expected_indexs
+) -> None:
+    pytester.makepyfile(
+        f"""
+        import pytest
+        @pytest.mark.parametrize('y, x', {parametrize_args})
+        def test1(y, x):
+            pass
+    """
+    )
+    result = pytester.runpytest("--require-unique-paramset-ids")
+    result.stdout.fnmatch_lines(
+        [
+            "E*Because: require_unique_parameterset_ids is set, pytest won't",
+            "E*attempt to generate unique IDs for parameter sets.",
+            "E*argument names: [[]'y', 'x'[]]",
+            "E*function name: test1",
+            "E*test name: test_option_parametrize_require_unique_paramset_ids.py::test1",
+            f"E*duplicates: {expected_indexs!s}",
+        ]
+    )