Merge branch 'main' into Improvement-catch-duplicate-values-when-determining-param-indices-in-metafunc-parametrize

Author: sadra-barikbin

AUTHORS

@@ -266,6 +266,7 @@ Michael Goerz
 Michael Krebs
 Michael Seifert
 Michal Wajszczuk
+Michał Górny
 Michał Zięba
 Mickey Pashov
 Mihai Capotă

changelog/11520.improvement.rst

@@ -1,3 +1,5 @@
 Improved very verbose diff output to color it as a diff instead of only red.
 
 Improved the error reporting to better separate each section.
+
+Improved the error reporting to syntax-highlight Python code when Pygments is available.

changelog/11712.bugfix.rst

@@ -0,0 +1 @@
+Fixed handling ``NO_COLOR`` and ``FORCE_COLOR`` to ignore an empty value.

doc/en/reference/plugin_list.rst

@@ -1146,13 +1146,13 @@ When set to ``0``, pytest will not use color.
 
 .. envvar:: NO_COLOR
 
-When set (regardless of value), pytest will not use color in terminal output.
+When set to a non-empty string (regardless of value), pytest will not use color in terminal output.
 ``PY_COLORS`` takes precedence over ``NO_COLOR``, which takes precedence over ``FORCE_COLOR``.
 See `no-color.org <https://no-color.org/>`__ for other libraries supporting this community standard.
 
 .. envvar:: FORCE_COLOR
 
-When set (regardless of value), pytest will use color in terminal output.
+When set to a non-empty string (regardless of value), pytest will use color in terminal output.
 ``PY_COLORS`` and ``NO_COLOR`` take precedence over ``FORCE_COLOR``.
 
 Exceptions

doc/en/reference/reference.rst

@@ -29,9 +29,9 @@ def should_do_markup(file: TextIO) -> bool:
         return True
     if os.environ.get("PY_COLORS") == "0":
         return False
-    if "NO_COLOR" in os.environ:
+    if os.environ.get("NO_COLOR"):
         return False
-    if "FORCE_COLOR" in os.environ:
+    if os.environ.get("FORCE_COLOR"):
         return True
     return (
         hasattr(file, "isatty") and file.isatty() and os.environ.get("TERM") != "dumb"
@@ -223,7 +223,15 @@ def _highlight(
                         style=os.getenv("PYTEST_THEME"),
                     ),
                 )
-                return highlighted
+                # pygments terminal formatter may add a newline when there wasn't one.
+                # We don't want this, remove.
+                if highlighted[-1] == "\n" and source[-1] != "\n":
+                    highlighted = highlighted[:-1]
+
+                # Some lexers will not set the initial color explicitly
+                # which may lead to the previous color being propagated to the
+                # start of the expression, so reset first.
+                return "\x1b[0m" + highlighted
             except pygments.util.ClassNotFound:
                 raise UsageError(
                     "PYTEST_THEME environment variable had an invalid value: '{}'. "

src/_pytest/_io/terminalwriter.py

@@ -192,12 +192,12 @@ def assertrepr_compare(
         right_repr = saferepr(right, maxsize=maxsize, use_ascii=use_ascii)
 
     summary = f"{left_repr} {op} {right_repr}"
+    highlighter = config.get_terminal_writer()._highlight
 
     explanation = None
     try:
         if op == "==":
-            writer = config.get_terminal_writer()
-            explanation = _compare_eq_any(left, right, writer._highlight, verbose)
+            explanation = _compare_eq_any(left, right, highlighter, verbose)
         elif op == "not in":
             if istext(left) and istext(right):
                 explanation = _notin_text(left, right, verbose)
@@ -206,16 +206,16 @@ def assertrepr_compare(
                 explanation = ["Both sets are equal"]
         elif op == ">=":
             if isset(left) and isset(right):
-                explanation = _compare_gte_set(left, right, verbose)
+                explanation = _compare_gte_set(left, right, highlighter, verbose)
         elif op == "<=":
             if isset(left) and isset(right):
-                explanation = _compare_lte_set(left, right, verbose)
+                explanation = _compare_lte_set(left, right, highlighter, verbose)
         elif op == ">":
             if isset(left) and isset(right):
-                explanation = _compare_gt_set(left, right, verbose)
+                explanation = _compare_gt_set(left, right, highlighter, verbose)
         elif op == "<":
             if isset(left) and isset(right):
-                explanation = _compare_lt_set(left, right, verbose)
+                explanation = _compare_lt_set(left, right, highlighter, verbose)
 
     except outcomes.Exit:
         raise
@@ -259,11 +259,11 @@ def _compare_eq_any(
             # used in older code bases before dataclasses/attrs were available.
             explanation = _compare_eq_cls(left, right, highlighter, verbose)
         elif issequence(left) and issequence(right):
-            explanation = _compare_eq_sequence(left, right, verbose)
+            explanation = _compare_eq_sequence(left, right, highlighter, verbose)
         elif isset(left) and isset(right):
-            explanation = _compare_eq_set(left, right, verbose)
+            explanation = _compare_eq_set(left, right, highlighter, verbose)
         elif isdict(left) and isdict(right):
-            explanation = _compare_eq_dict(left, right, verbose)
+            explanation = _compare_eq_dict(left, right, highlighter, verbose)
 
         if isiterable(left) and isiterable(right):
             expl = _compare_eq_iterable(left, right, highlighter, verbose)
@@ -350,7 +350,10 @@ def _compare_eq_iterable(
 
 
 def _compare_eq_sequence(
-    left: Sequence[Any], right: Sequence[Any], verbose: int = 0
+    left: Sequence[Any],
+    right: Sequence[Any],
+    highlighter: _HighlightFunc,
+    verbose: int = 0,
 ) -> List[str]:
     comparing_bytes = isinstance(left, bytes) and isinstance(right, bytes)
     explanation: List[str] = []
@@ -373,7 +376,10 @@ def _compare_eq_sequence(
                 left_value = left[i]
                 right_value = right[i]
 
-            explanation += [f"At index {i} diff: {left_value!r} != {right_value!r}"]
+            explanation.append(
+                f"At index {i} diff:"
+                f" {highlighter(repr(left_value))} != {highlighter(repr(right_value))}"
+            )
             break
 
     if comparing_bytes:
@@ -393,68 +399,91 @@ def _compare_eq_sequence(
             extra = saferepr(right[len_left])
 
         if len_diff == 1:
-            explanation += [f"{dir_with_more} contains one more item: {extra}"]
+            explanation += [
+                f"{dir_with_more} contains one more item: {highlighter(extra)}"
+            ]
         else:
             explanation += [
                 "%s contains %d more items, first extra item: %s"
-                % (dir_with_more, len_diff, extra)
+                % (dir_with_more, len_diff, highlighter(extra))
             ]
     return explanation
 
 
 def _compare_eq_set(
-    left: AbstractSet[Any], right: AbstractSet[Any], verbose: int = 0
+    left: AbstractSet[Any],
+    right: AbstractSet[Any],
+    highlighter: _HighlightFunc,
+    verbose: int = 0,
 ) -> List[str]:
     explanation = []
-    explanation.extend(_set_one_sided_diff("left", left, right))
-    explanation.extend(_set_one_sided_diff("right", right, left))
+    explanation.extend(_set_one_sided_diff("left", left, right, highlighter))
+    explanation.extend(_set_one_sided_diff("right", right, left, highlighter))
     return explanation
 
 
 def _compare_gt_set(
-    left: AbstractSet[Any], right: AbstractSet[Any], verbose: int = 0
+    left: AbstractSet[Any],
+    right: AbstractSet[Any],
+    highlighter: _HighlightFunc,
+    verbose: int = 0,
 ) -> List[str]:
-    explanation = _compare_gte_set(left, right, verbose)
+    explanation = _compare_gte_set(left, right, highlighter)
     if not explanation:
         return ["Both sets are equal"]
     return explanation
 
 
 def _compare_lt_set(
-    left: AbstractSet[Any], right: AbstractSet[Any], verbose: int = 0
+    left: AbstractSet[Any],
+    right: AbstractSet[Any],
+    highlighter: _HighlightFunc,
+    verbose: int = 0,
 ) -> List[str]:
-    explanation = _compare_lte_set(left, right, verbose)
+    explanation = _compare_lte_set(left, right, highlighter)
     if not explanation:
         return ["Both sets are equal"]
     return explanation
 
 
 def _compare_gte_set(
-    left: AbstractSet[Any], right: AbstractSet[Any], verbose: int = 0
+    left: AbstractSet[Any],
+    right: AbstractSet[Any],
+    highlighter: _HighlightFunc,
+    verbose: int = 0,
 ) -> List[str]:
-    return _set_one_sided_diff("right", right, left)
+    return _set_one_sided_diff("right", right, left, highlighter)
 
 
 def _compare_lte_set(
-    left: AbstractSet[Any], right: AbstractSet[Any], verbose: int = 0
+    left: AbstractSet[Any],
+    right: AbstractSet[Any],
+    highlighter: _HighlightFunc,
+    verbose: int = 0,
 ) -> List[str]:
-    return _set_one_sided_diff("left", left, right)
+    return _set_one_sided_diff("left", left, right, highlighter)
 
 
 def _set_one_sided_diff(
-    posn: str, set1: AbstractSet[Any], set2: AbstractSet[Any]
+    posn: str,
+    set1: AbstractSet[Any],
+    set2: AbstractSet[Any],
+    highlighter: _HighlightFunc,
 ) -> List[str]:
     explanation = []
     diff = set1 - set2
     if diff:
         explanation.append(f"Extra items in the {posn} set:")
         for item in diff:
-            explanation.append(saferepr(item))
+            explanation.append(highlighter(saferepr(item)))
     return explanation
 
 
 def _compare_eq_dict(
-    left: Mapping[Any, Any], right: Mapping[Any, Any], verbose: int = 0
+    left: Mapping[Any, Any],
+    right: Mapping[Any, Any],
+    highlighter: _HighlightFunc,
+    verbose: int = 0,
 ) -> List[str]:
     explanation: List[str] = []
     set_left = set(left)
@@ -465,12 +494,16 @@ def _compare_eq_dict(
         explanation += ["Omitting %s identical items, use -vv to show" % len(same)]
     elif same:
         explanation += ["Common items:"]
-        explanation += pprint.pformat(same).splitlines()
+        explanation += highlighter(pprint.pformat(same)).splitlines()
     diff = {k for k in common if left[k] != right[k]}
     if diff:
         explanation += ["Differing items:"]
         for k in diff:
-            explanation += [saferepr({k: left[k]}) + " != " + saferepr({k: right[k]})]
+            explanation += [
+                highlighter(saferepr({k: left[k]}))
+                + " != "
+                + highlighter(saferepr({k: right[k]}))
+            ]
     extra_left = set_left - set_right
     len_extra_left = len(extra_left)
     if len_extra_left:
@@ -479,7 +512,7 @@ def _compare_eq_dict(
             % (len_extra_left, "" if len_extra_left == 1 else "s")
         )
         explanation.extend(
-            pprint.pformat({k: left[k] for k in extra_left}).splitlines()
+            highlighter(pprint.pformat({k: left[k] for k in extra_left})).splitlines()
         )
     extra_right = set_right - set_left
     len_extra_right = len(extra_right)
@@ -489,7 +522,7 @@ def _compare_eq_dict(
             % (len_extra_right, "" if len_extra_right == 1 else "s")
         )
         explanation.extend(
-            pprint.pformat({k: right[k] for k in extra_right}).splitlines()
+            highlighter(pprint.pformat({k: right[k] for k in extra_right})).splitlines()
         )
     return explanation
 
@@ -528,17 +561,17 @@ def _compare_eq_cls(
         explanation.append("Omitting %s identical items, use -vv to show" % len(same))
     elif same:
         explanation += ["Matching attributes:"]
-        explanation += pprint.pformat(same).splitlines()
+        explanation += highlighter(pprint.pformat(same)).splitlines()
     if diff:
         explanation += ["Differing attributes:"]
-        explanation += pprint.pformat(diff).splitlines()
+        explanation += highlighter(pprint.pformat(diff)).splitlines()
         for field in diff:
             field_left = getattr(left, field)
             field_right = getattr(right, field)
             explanation += [
                 "",
-                "Drill down into differing attribute %s:" % field,
-                ("%s%s: %r != %r") % (indent, field, field_left, field_right),
+                f"Drill down into differing attribute {field}:",
+                f"{indent}{field}: {highlighter(repr(field_left))} != {highlighter(repr(field_right))}",
             ]
             explanation += [
                 indent + line

src/_pytest/assertion/util.py

@@ -11,15 +11,18 @@
 from io import StringIO
 from logging import LogRecord
 from pathlib import Path
+from types import TracebackType
 from typing import AbstractSet
 from typing import Dict
 from typing import final
 from typing import Generator
+from typing import Generic
 from typing import List
 from typing import Literal
 from typing import Mapping
 from typing import Optional
 from typing import Tuple
+from typing import Type
 from typing import TYPE_CHECKING
 from typing import TypeVar
 from typing import Union
@@ -62,7 +65,7 @@ class DatetimeFormatter(logging.Formatter):
     :func:`time.strftime` in case of microseconds in format string.
     """
 
-    def formatTime(self, record: LogRecord, datefmt=None) -> str:
+    def formatTime(self, record: LogRecord, datefmt: Optional[str] = None) -> str:
         if datefmt and "%f" in datefmt:
             ct = self.converter(record.created)
             tz = timezone(timedelta(seconds=ct.tm_gmtoff), ct.tm_zone)
@@ -331,7 +334,7 @@ def add_option_ini(option, dest, default=None, type=None, **kwargs):
 
 
 # Not using @contextmanager for performance reasons.
-class catching_logs:
+class catching_logs(Generic[_HandlerType]):
     """Context manager that prepares the whole logging machinery properly."""
 
     __slots__ = ("handler", "level", "orig_level")
@@ -340,7 +343,7 @@ def __init__(self, handler: _HandlerType, level: Optional[int] = None) -> None:
         self.handler = handler
         self.level = level
 
-    def __enter__(self):
+    def __enter__(self) -> _HandlerType:
         root_logger = logging.getLogger()
         if self.level is not None:
             self.handler.setLevel(self.level)
@@ -350,7 +353,12 @@ def __enter__(self):
             root_logger.setLevel(min(self.orig_level, self.level))
         return self.handler
 
-    def __exit__(self, type, value, traceback):
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
         root_logger = logging.getLogger()
         if self.level is not None:
             root_logger.setLevel(self.orig_level)
@@ -421,7 +429,7 @@ def handler(self) -> LogCaptureHandler:
         return self._item.stash[caplog_handler_key]
 
     def get_records(
-        self, when: "Literal['setup', 'call', 'teardown']"
+        self, when: Literal["setup", "call", "teardown"]
     ) -> List[logging.LogRecord]:
         """Get the logging records for one of the possible test phases.
 
@@ -742,7 +750,7 @@ def set_log_path(self, fname: str) -> None:
         if old_stream:
             old_stream.close()
 
-    def _log_cli_enabled(self):
+    def _log_cli_enabled(self) -> bool:
         """Return whether live logging is enabled."""
         enabled = self._config.getoption(
             "--log-cli-level"

src/_pytest/logging.py

@@ -317,7 +317,7 @@ def result(self) -> TResult:
     @classmethod
     def from_call(
         cls,
-        func: "Callable[[], TResult]",
+        func: Callable[[], TResult],
         when: Literal["collect", "setup", "call", "teardown"],
         reraise: Optional[
             Union[Type[BaseException], Tuple[Type[BaseException], ...]]