Merge branch 'main' into feat/tests-with-uv

Author: sgaist

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: "v0.14.0"
+  rev: "v0.14.1"
   hooks:
     - id: ruff-check
       args: ["--fix"]
@@ -12,7 +12,7 @@ repos:
     -   id: end-of-file-fixer
     -   id: check-yaml
 - repo: https://github.com/woodruffw/zizmor-pre-commit
-  rev: v1.14.2
+  rev: v1.15.2
   hooks:
     - id: zizmor
 -   repo: https://github.com/adamchainz/blacken-docs
@@ -66,7 +66,7 @@ repos:
         # Manual because passing pyright is a work in progress.
         stages: [manual]
 - repo: https://github.com/tox-dev/pyproject-fmt
-  rev: "v2.10.0"
+  rev: "v2.11.0"
   hooks:
     - id: pyproject-fmt
       # https://pyproject-fmt.readthedocs.io/en/latest/#calculating-max-supported-python-version

AUTHORS

@@ -346,6 +346,7 @@ Oliver Bestwalter
 Olivier Grisel
 Omar Kohl
 Omer Hadari
+Omri Golan
 Ondřej Súkup
 Oscar Benjamin
 Parth Patel

changelog/13737.feature.rst

@@ -0,0 +1,4 @@
+Added the :confval:`strict_parametrization_ids` configuration option.
+
+When set, pytest emits an error if it detects non-unique parameter set IDs,
+rather than automatically making the IDs unique by adding `0`, `1`, ... to them.

changelog/13829.feature.rst

@@ -0,0 +1,5 @@
+Added support for ini option aliases via the ``aliases`` parameter in :meth:`Parser.addini() <pytest.Parser.addini>`.
+
+Plugins can now register alternative names for ini options,
+allowing for more flexibility in configuration naming and supporting backward compatibility when renaming options.
+The canonical name always takes precedence if both the canonical name and an alias are specified in the configuration file.

changelog/13830.misc.rst

@@ -0,0 +1 @@
+Configuration overrides (``-o``/``--override-ini``) are now processed during startup rather than during :func:`config.getini() <pytest.Config.getini>`.

doc/en/reference/plugin_list.rst

@@ -2082,6 +2082,44 @@ passed multiple times. The expected format is ``name=value``. For example::
         [pytest]
         xfail_strict = True
 
+.. confval:: strict_parametrization_ids
+
+    If set, pytest emits an error if it detects non-unique parameter set IDs.
+
+    If not set (the default), pytest automatically handles this by adding `0`, `1`, ... to duplicate IDs,
+    making them unique.
+
+    .. code-block:: ini
+
+          [pytest]
+          strict_parametrization_ids = True
+
+    For example,
+
+    .. code-block:: python
+
+        import pytest
+
+
+        @pytest.mark.parametrize("letter", ["a", "a"])
+        def test_letter_is_ascii(letter):
+            assert letter.isascii()
+
+    will emit an error because both cases (parameter sets) have the same auto-generated ID "a".
+
+    To fix the error, if you decide to keep the duplicates, explicitly assign unique IDs:
+
+    .. code-block:: python
+
+        import pytest
+
+
+        @pytest.mark.parametrize("letter", ["a", "a"], ids=["a0", "a1"])
+        def test_letter_is_ascii(letter):
+            assert letter.isascii()
+
+    See :func:`parametrize <pytest.Metafunc.parametrize>` and :func:`pytest.param` for other ways to set IDs.
+
 
 .. _`command-line-flags`:
 

doc/en/reference/reference.rst

@@ -379,6 +379,7 @@ norecursedirs = [
     "dist",
 ]
 xfail_strict = true
+strict_parametrization_ids = true
 filterwarnings = [
     "error",
     "default:Using or importing the ABCs:DeprecationWarning:unittest2.*",

pyproject.toml

@@ -1083,7 +1083,6 @@ def __init__(
         self.trace = self.pluginmanager.trace.root.get("config")
         self.hook: pluggy.HookRelay = PathAwareHookProxy(self.pluginmanager.hook)  # type: ignore[assignment]
         self._inicache: dict[str, Any] = {}
-        self._override_ini: Sequence[str] = ()
         self._opt2dest: dict[str, str] = {}
         self._cleanup_stack = contextlib.ExitStack()
         self.pluginmanager.register(self, "pytestconfig")
@@ -1251,6 +1250,7 @@ def _initini(self, args: Sequence[str]) -> None:
         )
         rootpath, inipath, inicfg, ignored_config_files = determine_setup(
             inifile=ns.inifilename,
+            override_ini=ns.override_ini,
             args=ns.file_or_dir + unknown_args,
             rootdir_cmd_arg=ns.rootdir or None,
             invocation_dir=self.invocation_params.dir,
@@ -1272,7 +1272,6 @@ def _initini(self, args: Sequence[str]) -> None:
             type="args",
             default=[],
         )
-        self._override_ini = ns.override_ini or ()
 
     def _consider_importhook(self, args: Sequence[str]) -> None:
         """Install the PEP 302 import hook if using assertion rewriting.
@@ -1462,7 +1461,8 @@ def pytest_collection(self) -> Generator[None, object, object]:
     def _checkversion(self) -> None:
         import pytest
 
-        minver = self.inicfg.get("minversion", None)
+        minver_ini_value = self.inicfg.get("minversion", None)
+        minver = minver_ini_value.value if minver_ini_value is not None else None
         if minver:
             # Imported lazily to improve start-up time.
             from packaging.version import Version
@@ -1520,9 +1520,9 @@ def _warn_or_fail_if_strict(self, message: str) -> None:
 
         self.issue_config_time_warning(PytestConfigWarning(message), stacklevel=3)
 
-    def _get_unknown_ini_keys(self) -> list[str]:
-        parser_inicfg = self._parser._inidict
-        return [name for name in self.inicfg if name not in parser_inicfg]
+    def _get_unknown_ini_keys(self) -> set[str]:
+        known_keys = self._parser._inidict.keys() | self._parser._ini_aliases.keys()
+        return self.inicfg.keys() - known_keys
 
     def parse(self, args: list[str], addopts: bool = True) -> None:
         # Parse given cmdline arguments into this config object.
@@ -1622,10 +1622,11 @@ def getini(self, name: str) -> Any:
         :func:`parser.addini <pytest.Parser.addini>` call (usually from a
         plugin), a ValueError is raised.
         """
+        canonical_name = self._parser._ini_aliases.get(name, name)
         try:
-            return self._inicache[name]
+            return self._inicache[canonical_name]
         except KeyError:
-            self._inicache[name] = val = self._getini(name)
+            self._inicache[canonical_name] = val = self._getini(canonical_name)
             return val
 
     # Meant for easy monkeypatching by legacypath plugin.
@@ -1637,18 +1638,32 @@ def _getini_unknown_type(self, name: str, type: str, value: object):
         raise ValueError(msg)  # pragma: no cover
 
     def _getini(self, name: str):
+        # If this is an alias, resolve to canonical name.
+        canonical_name = self._parser._ini_aliases.get(name, name)
+
         try:
-            _description, type, default = self._parser._inidict[name]
+            _description, type, default = self._parser._inidict[canonical_name]
         except KeyError as e:
             raise ValueError(f"unknown configuration value: {name!r}") from e
-        override_value = self._get_override_ini_value(name)
-        if override_value is None:
-            try:
-                value = self.inicfg[name]
-            except KeyError:
-                return default
-        else:
-            value = override_value
+
+        # Collect all possible values (canonical name + aliases) from inicfg.
+        # Each candidate is (IniValue, is_canonical).
+        candidates = []
+        if canonical_name in self.inicfg:
+            candidates.append((self.inicfg[canonical_name], True))
+        for alias, target in self._parser._ini_aliases.items():
+            if target == canonical_name and alias in self.inicfg:
+                candidates.append((self.inicfg[alias], False))
+
+        if not candidates:
+            return default
+
+        # Pick the best candidate based on precedence:
+        # 1. CLI override takes precedence over file, then
+        # 2. Canonical name takes precedence over alias.
+        ini_value = max(candidates, key=lambda x: (x[0].origin == "override", x[1]))[0]
+        value = ini_value.value
+
         # Coerce the values based on types.
         #
         # Note: some coercions are only required if we are reading from .ini files, because
@@ -1719,23 +1734,6 @@ def _getconftest_pathlist(
             values.append(relroot)
         return values
 
-    def _get_override_ini_value(self, name: str) -> str | None:
-        value = None
-        # override_ini is a list of "ini=value" options.
-        # Always use the last item if multiple values are set for same ini-name,
-        # e.g. -o foo=bar1 -o foo=bar2 will set foo to bar2.
-        for ini_config in self._override_ini:
-            try:
-                key, user_ini_value = ini_config.split("=", 1)
-            except ValueError as e:
-                raise UsageError(
-                    f"-o/--override-ini expects option=value style (got: {ini_config!r})."
-                ) from e
-            else:
-                if key == name:
-                    value = user_ini_value
-        return value
-
     def getoption(self, name: str, default: Any = notset, skip: bool = False):
         """Return command line option value.
 

src/_pytest/config/__init__.py

@@ -52,6 +52,8 @@ def __init__(
         self._usage = usage
         self._inidict: dict[str, tuple[str, str | None, Any]] = {}
         self._ininames: list[str] = []
+        # Maps alias -> canonical name.
+        self._ini_aliases: dict[str, str] = {}
         self.extra_info: dict[str, Any] = {}
 
     def processoption(self, option: Argument) -> None:
@@ -179,6 +181,8 @@ def addini(
         ]
         | None = None,
         default: Any = NOT_SET,
+        *,
+        aliases: Sequence[str] = (),
     ) -> None:
         """Register an ini-file option.
 
@@ -213,6 +217,12 @@ def addini(
             Defaults to ``string`` if ``None`` or not passed.
         :param default:
             Default value if no ini-file option exists but is queried.
+        :param aliases:
+            Additional names by which this option can be referenced.
+            Aliases resolve to the canonical name.
+
+            .. versionadded:: 9.0
+                The ``aliases`` parameter.
 
         The value of ini-variables can be retrieved via a call to
         :py:func:`config.getini(name) <pytest.Config.getini>`.
@@ -234,6 +244,13 @@ def addini(
         self._inidict[name] = (help, type, default)
         self._ininames.append(name)
 
+        for alias in aliases:
+            if alias in self._inidict:
+                raise ValueError(f"alias {alias!r} conflicts with existing ini option")
+            if (already := self._ini_aliases.get(alias)) is not None:
+                raise ValueError(f"{alias!r} is already an alias of {already!r}")
+            self._ini_aliases[alias] = name
+
 
 def get_ini_default_for_type(
     type: Literal[