Merge branch 'main' into main

Author: solaluset

.github/workflows/test.yml

@@ -139,6 +139,7 @@ jobs:
             python: "3.14"
             os: windows-latest
             tox_env: "py314"
+            use_coverage: true
 
           # Use separate jobs for different unittest flavors (twisted, asynctest) to ensure proper coverage.
           - name: "ubuntu-py310-unittest-asynctest"

.pre-commit-config.yaml

@@ -1,7 +1,7 @@
 minimum_pre_commit_version: "4.4.0"
 repos:
 - repo: https://github.com/astral-sh/ruff-pre-commit
-  rev: "v0.14.4"
+  rev: "v0.14.5"
   hooks:
     - id: ruff-check
       args: ["--fix"]

AUTHORS

@@ -459,6 +459,7 @@ TJ Bruno
 Tobias Diez
 Tobias Petersen
 Tom Dalton
+Tom Most
 Tom Viner
 Tomáš Gavenčiak
 Tomer Keren

changelog/13896.bugfix.rst

@@ -0,0 +1,5 @@
+The terminal progress feature added in pytest 9.0.0 has been disabled by default, except on Windows, due to compatibility issues with some terminal emulators.
+
+You may enable it again by passing ``-p terminalprogress``. We may enable it by default again once compatibility improves in the future.
+
+Additionally, when the environment variable ``TERM`` is ``dumb``, the escape codes are no longer emitted, even if the plugin is enabled.

doc/en/changelog.rst

@@ -178,6 +178,10 @@ New features
 
 
 - `#13072 <https://github.com/pytest-dev/pytest/issues/13072>`_: Added support for displaying test session **progress in the terminal tab** using the `OSC 9;4; <https://conemu.github.io/en/AnsiEscapeCodes.html#ConEmu_specific_OSC>`_ ANSI sequence.
+
+  **Note**: *This feature has been disabled by default in version 9.0.2, except on Windows, due to compatibility issues with some terminal emulators.
+  You may enable it again by passing* ``-p terminalprogress``. *We may enable it by default again once compatibility improves in the future.*
+
   When pytest runs in a supported terminal emulator like ConEmu, Gnome Terminal, Ptyxis, Windows Terminal, Kitty or Ghostty,
   you'll see the progress in the terminal tab or window,
   allowing you to monitor pytest's progress at a glance.
@@ -326,7 +330,7 @@ Bug fixes
 - `#13865 <https://github.com/pytest-dev/pytest/issues/13865>`_: Fixed `--show-capture` with `--tb=line`.
 
 
-- `#13522 <https://github.com/pytest-dev/pytest/issues/13522>`_: Fixed :fixture:`pytester` in subprocess mode ignored all :attr`pytester.plugins <pytest.Pytester.plugins>` except the first.
+- `#13522 <https://github.com/pytest-dev/pytest/issues/13522>`_: Fixed :fixture:`pytester` in subprocess mode ignored all :attr:`pytester.plugins <pytest.Pytester.plugins>` except the first.
 
   Fixed :fixture:`pytester` in subprocess mode silently ignored non-str :attr:`pytester.plugins <pytest.Pytester.plugins>`.
   Now it errors instead.

src/_pytest/config/__init__.py

@@ -303,6 +303,7 @@ def directory_arg(path: str, optname: str) -> str:
     *default_plugins,
     "pytester",
     "pytester_assertions",
+    "terminalprogress",
 }
 
 

src/_pytest/fixtures.py

@@ -25,6 +25,7 @@
 from typing import Final
 from typing import final
 from typing import Generic
+from typing import Literal
 from typing import NoReturn
 from typing import overload
 from typing import TYPE_CHECKING
@@ -1472,6 +1473,45 @@ def pytest_cmdline_main(config: Config) -> int | ExitCode | None:
     return None
 
 
+def _resolve_args_directness(
+    argnames: Sequence[str],
+    indirect: bool | Sequence[str],
+    nodeid: str,
+) -> dict[str, Literal["indirect", "direct"]]:
+    """Resolve if each parametrized argument must be considered an indirect
+    parameter to a fixture of the same name, or a direct parameter to the
+    parametrized function, based on the ``indirect`` parameter of the
+    parametrize() call.
+
+    :param argnames:
+        List of argument names passed to ``parametrize()``.
+    :param indirect:
+        Same as the ``indirect`` parameter of ``parametrize()``.
+    :param nodeid:
+        Node ID to which the parametrization is applied.
+    :returns:
+        A dict mapping each arg name to either "indirect" or "direct".
+    """
+    arg_directness: dict[str, Literal["indirect", "direct"]]
+    if isinstance(indirect, bool):
+        arg_directness = dict.fromkeys(argnames, "indirect" if indirect else "direct")
+    elif isinstance(indirect, Sequence):
+        arg_directness = dict.fromkeys(argnames, "direct")
+        for arg in indirect:
+            if arg not in argnames:
+                fail(
+                    f"In {nodeid}: indirect fixture '{arg}' doesn't exist",
+                    pytrace=False,
+                )
+            arg_directness[arg] = "indirect"
+    else:
+        fail(
+            f"In {nodeid}: expected Sequence or boolean for indirect, got {type(indirect).__name__}",
+            pytrace=False,
+        )
+    return arg_directness
+
+
 def _get_direct_parametrize_args(node: nodes.Node) -> set[str]:
     """Return all direct parametrization arguments of a node, so we don't
     mistake them for fixtures.
@@ -1483,11 +1523,16 @@ def _get_direct_parametrize_args(node: nodes.Node) -> set[str]:
     """
     parametrize_argnames: set[str] = set()
     for marker in node.iter_markers(name="parametrize"):
-        if not marker.kwargs.get("indirect", False):
-            p_argnames, _ = ParameterSet._parse_parametrize_args(
-                *marker.args, **marker.kwargs
-            )
-            parametrize_argnames.update(p_argnames)
+        indirect = marker.kwargs.get("indirect", False)
+        p_argnames, _ = ParameterSet._parse_parametrize_args(
+            *marker.args, **marker.kwargs
+        )
+        p_directness = _resolve_args_directness(p_argnames, indirect, node.nodeid)
+        parametrize_argnames.update(
+            argname
+            for argname, directness in p_directness.items()
+            if directness == "direct"
+        )
     return parametrize_argnames
 
 

src/_pytest/python.py

@@ -53,6 +53,7 @@
 from _pytest.config import hookimpl
 from _pytest.config.argparsing import Parser
 from _pytest.deprecated import check_ispytest
+from _pytest.fixtures import _resolve_args_directness
 from _pytest.fixtures import FixtureDef
 from _pytest.fixtures import FixtureRequest
 from _pytest.fixtures import FuncFixtureInfo
@@ -870,7 +871,6 @@ class IdMaker:
     __slots__ = (
         "argnames",
         "config",
-        "func_name",
         "idfn",
         "ids",
         "nodeid",
@@ -893,9 +893,6 @@ class IdMaker:
     # Optionally, the ID of the node being parametrized.
     # Used only for clearer error messages.
     nodeid: str | None
-    # Optionally, the ID of the function being parametrized.
-    # Used only for clearer error messages.
-    func_name: str | None
 
     def make_unique_parameterset_ids(self) -> list[str | _HiddenParam]:
         """Make a unique identifier for each ParameterSet, that may be used to
@@ -1083,9 +1080,7 @@ def _complain_multiple_hidden_parameter_sets(self) -> NoReturn:
         )
 
     def _make_error_prefix(self) -> str:
-        if self.func_name is not None:
-            return f"In {self.func_name}: "
-        elif self.nodeid is not None:
+        if self.nodeid is not None:
             return f"In {self.nodeid}: "
         else:
             return ""
@@ -1333,7 +1328,9 @@ def parametrize(
             object.__setattr__(_param_mark._param_ids_from, "_param_ids_generated", ids)
 
         # Calculate directness.
-        arg_directness = self._resolve_args_directness(argnames, indirect)
+        arg_directness = _resolve_args_directness(
+            argnames, indirect, self.definition.nodeid
+        )
         self._params_directness.update(arg_directness)
 
         # Add direct parametrizations as fixturedefs to arg2fixturedefs by
@@ -1435,23 +1432,21 @@ def _resolve_parameter_set_ids(
             ids_ = None
         else:
             idfn = None
-            ids_ = self._validate_ids(ids, parametersets, self.function.__name__)
+            ids_ = self._validate_ids(ids, parametersets)
         id_maker = IdMaker(
             argnames,
             parametersets,
             idfn,
             ids_,
             self.config,
             nodeid=nodeid,
-            func_name=self.function.__name__,
         )
         return id_maker.make_unique_parameterset_ids()
 
     def _validate_ids(
         self,
         ids: Iterable[object | None],
         parametersets: Sequence[ParameterSet],
-        func_name: str,
     ) -> list[object | None]:
         try:
             num_ids = len(ids)  # type: ignore[arg-type]
@@ -1464,49 +1459,13 @@ def _validate_ids(
 
         # num_ids == 0 is a special case: https://github.com/pytest-dev/pytest/issues/1849
         if num_ids != len(parametersets) and num_ids != 0:
-            msg = "In {}: {} parameter sets specified, with different number of ids: {}"
-            fail(msg.format(func_name, len(parametersets), num_ids), pytrace=False)
-
-        return list(itertools.islice(ids, num_ids))
-
-    def _resolve_args_directness(
-        self,
-        argnames: Sequence[str],
-        indirect: bool | Sequence[str],
-    ) -> dict[str, Literal["indirect", "direct"]]:
-        """Resolve if each parametrized argument must be considered an indirect
-        parameter to a fixture of the same name, or a direct parameter to the
-        parametrized function, based on the ``indirect`` parameter of the
-        parametrized() call.
-
-        :param argnames:
-            List of argument names passed to ``parametrize()``.
-        :param indirect:
-            Same as the ``indirect`` parameter of ``parametrize()``.
-        :returns
-            A dict mapping each arg name to either "indirect" or "direct".
-        """
-        arg_directness: dict[str, Literal["indirect", "direct"]]
-        if isinstance(indirect, bool):
-            arg_directness = dict.fromkeys(
-                argnames, "indirect" if indirect else "direct"
-            )
-        elif isinstance(indirect, Sequence):
-            arg_directness = dict.fromkeys(argnames, "direct")
-            for arg in indirect:
-                if arg not in argnames:
-                    fail(
-                        f"In {self.function.__name__}: indirect fixture '{arg}' doesn't exist",
-                        pytrace=False,
-                    )
-                arg_directness[arg] = "indirect"
-        else:
+            nodeid = self.definition.nodeid
             fail(
-                f"In {self.function.__name__}: expected Sequence or boolean"
-                f" for indirect, got {type(indirect).__name__}",
+                f"In {nodeid}: {len(parametersets)} parameter sets specified, with different number of ids: {num_ids}",
                 pytrace=False,
             )
-        return arg_directness
+
+        return list(itertools.islice(ids, num_ids))
 
     def _validate_if_using_arg_names(
         self,
@@ -1520,12 +1479,12 @@ def _validate_if_using_arg_names(
         :raises ValueError: If validation fails.
         """
         default_arg_names = set(get_default_arg_names(self.function))
-        func_name = self.function.__name__
+        nodeid = self.definition.nodeid
         for arg in argnames:
             if arg not in self.fixturenames:
                 if arg in default_arg_names:
                     fail(
-                        f"In {func_name}: function already takes an argument '{arg}' with a default value",
+                        f"In {nodeid}: function already takes an argument '{arg}' with a default value",
                         pytrace=False,
                     )
                 else:
@@ -1534,7 +1493,7 @@ def _validate_if_using_arg_names(
                     else:
                         name = "fixture" if indirect else "argument"
                     fail(
-                        f"In {func_name}: function uses no {name} '{arg}'",
+                        f"In {nodeid}: function uses no {name} '{arg}'",
                         pytrace=False,
                     )
 

src/_pytest/terminal.py

@@ -16,7 +16,6 @@
 import datetime
 from functools import partial
 import inspect
-import os
 from pathlib import Path
 import platform
 import sys
@@ -299,16 +298,10 @@ def mywriter(tags, args):
 
         config.trace.root.setprocessor("pytest:config", mywriter)
 
-    if reporter.isatty():
-        # Some terminals interpret OSC 9;4 as desktop notification,
-        # skip on those we know (#13896).
-        should_skip_terminal_progress = (
-            # iTerm2 (reported on version 3.6.5).
-            "ITERM_SESSION_ID" in os.environ
-        )
-        if not should_skip_terminal_progress:
-            plugin = TerminalProgressPlugin(reporter)
-            config.pluginmanager.register(plugin, "terminalprogress")
+    # See terminalprogress.py.
+    # On Windows it's safe to load by default.
+    if sys.platform == "win32":
+        config.pluginmanager.import_plugin("terminalprogress")
 
 
 def getreportopt(config: Config) -> str:

src/_pytest/terminalprogress.py

@@ -0,0 +1,30 @@
+# A plugin to register the TerminalProgressPlugin plugin.
+#
+# This plugin is not loaded by default due to compatibility issues (#13896),
+# but can be enabled in one of these ways:
+# - The terminal plugin enables it in a few cases where it's safe, and not
+#   blocked by the user (using e.g. `-p no:terminalprogress`).
+# - The user explicitly requests it, e.g. using `-p terminalprogress`.
+#
+# In a few years, if it's safe, we can consider enabling it by default. Then,
+# this file will become unnecessary and can be inlined into terminal.py.
+
+from __future__ import annotations
+
+import os
+
+from _pytest.config import Config
+from _pytest.config import hookimpl
+from _pytest.terminal import TerminalProgressPlugin
+from _pytest.terminal import TerminalReporter
+
+
+@hookimpl(trylast=True)
+def pytest_configure(config: Config) -> None:
+    reporter: TerminalReporter | None = config.pluginmanager.get_plugin(
+        "terminalreporter"
+    )
+
+    if reporter is not None and reporter.isatty() and os.environ.get("TERM") != "dumb":
+        plugin = TerminalProgressPlugin(reporter)
+        config.pluginmanager.register(plugin, name="terminalprogress-plugin")