Merge branch 'master' into merge

blueyed · blueyed · commit 3c66c7d9de08 · 2020-02-12T23:22:23.000+01:00
Conflicts:
	.github/workflows/main.yml
	src/_pytest/_code/code.py
	src/_pytest/_io/__init__.py
	testing/conftest.py
	testing/test_assertion.py
	testing/test_terminal.py
diff --git a/AUTHORS b/AUTHORS
@@ -246,6 +246,7 @@ Simon Gomizelj
 Skylar Downes
 Srinivas Reddy Thatiparthy
 Stefan Farmbauer
+Stefan Scherfke
 Stefan Zimmermann
 Stefano Taschini
 Steffen Allner
diff --git a/changelog/6658.improvement.rst b/changelog/6658.improvement.rst
@@ -0,0 +1,4 @@
+Code is now highlighted in tracebacks when ``pygments`` is installed.
+
+Users are encouraged to install ``pygments`` into their environment and provide feedback, because
+the plan is to make ``pygments`` a regular dependency in the future.
diff --git a/changelog/6673.breaking.rst b/changelog/6673.breaking.rst
@@ -0,0 +1 @@
+Reversed / fix meaning of "+/-" in error diffs.  "-" means that sth. expected is missing in the result and "+" means that there are unexpected extras in the result.
diff --git a/doc/en/example/reportingdemo.rst b/doc/en/example/reportingdemo.rst
@@ -81,8 +81,8 @@ Here is a nice run of several failures and how ``pytest`` presents things:
         def test_eq_text(self):
     >       assert "spam" == "eggs"
     E       AssertionError: assert 'spam' == 'eggs'
-    E         - spam
-    E         + eggs
+    E         - eggs
+    E         + spam
 
     failure_demo.py:45: AssertionError
     _____________ TestSpecialisedExplanations.test_eq_similar_text _____________
@@ -92,9 +92,9 @@ Here is a nice run of several failures and how ``pytest`` presents things:
         def test_eq_similar_text(self):
     >       assert "foo 1 bar" == "foo 2 bar"
     E       AssertionError: assert 'foo 1 bar' == 'foo 2 bar'
-    E         - foo 1 bar
+    E         - foo 2 bar
     E         ?     ^
-    E         + foo 2 bar
+    E         + foo 1 bar
     E         ?     ^
 
     failure_demo.py:48: AssertionError
@@ -106,8 +106,8 @@ Here is a nice run of several failures and how ``pytest`` presents things:
     >       assert "foo\nspam\nbar" == "foo\neggs\nbar"
     E       AssertionError: assert 'foo\nspam\nbar' == 'foo\neggs\nbar'
     E           foo
-    E         - spam
-    E         + eggs
+    E         - eggs
+    E         + spam
     E           bar
 
     failure_demo.py:51: AssertionError
@@ -122,9 +122,9 @@ Here is a nice run of several failures and how ``pytest`` presents things:
     E       AssertionError: assert '111111111111...2222222222222' == '111111111111...2222222222222'
     E         Skipping 90 identical leading characters in diff, use -v to show
     E         Skipping 91 identical trailing characters in diff, use -v to show
-    E         - 1111111111a222222222
+    E         - 1111111111b222222222
     E         ?           ^
-    E         + 1111111111b222222222
+    E         + 1111111111a222222222
     E         ?           ^
 
     failure_demo.py:56: AssertionError
diff --git a/src/_pytest/_code/code.py b/src/_pytest/_code/code.py
@@ -1066,18 +1066,31 @@ def __init__(
     @staticmethod
     def _color_error_lines(tw: TerminalWriter, lines: Sequence[str]) -> None:
         bold_before = False
+        seen_indent_lines = []  # type: List[str]
+        seen_source_lines = []  # type: List[str]
         for line in lines:
             if line.startswith("E   "):
+                if seen_source_lines:
+                    tw._write_source(seen_source_lines, seen_indent_lines)
+                    seen_indent_lines = []
+                    seen_source_lines = []
+
                 if bold_before:
                     markup = tw.markup("E   ", bold=True, red=True)
                     markup += tw.markup(line[4:])
                 else:
                     markup = tw.markup(line, bold=True, red=True)
                     bold_before = True
+                tw.line(markup)
             else:
                 bold_before = False
-                markup = line
-            tw.line(markup)
+                seen_indent_lines.append(line[:4])
+                seen_source_lines.append(line[4:])
+
+        if seen_source_lines:
+            tw._write_source(seen_source_lines, seen_indent_lines)
+            seen_indent_lines = []
+            seen_source_lines = []
 
     def toterminal(self, tw: TerminalWriter) -> None:
         if self.style == "short":
diff --git a/src/_pytest/_io/__init__.py b/src/_pytest/_io/__init__.py
@@ -1,3 +1,6 @@
+from typing import List
+from typing import Sequence
+
 import py.io
 
 
@@ -14,3 +17,36 @@ def fullwidth(self):
     @fullwidth.setter
     def fullwidth(self, value):
         self._terminal_width = value
+
+    def _write_source(self, lines: List[str], indents: Sequence[str] = ()) -> None:
+        """Write lines of source code possibly highlighted.
+
+        Keeping this private for now because the API is clunky. We should discuss how
+        to evolve the terminal writer so we can have more precise color support, for example
+        being able to write part of a line in one color and the rest in another, and so on.
+        """
+        if indents and len(indents) != len(lines):
+            raise ValueError(
+                "indents size ({}) should have same size as lines ({})".format(
+                    len(indents), len(lines)
+                )
+            )
+        if not indents:
+            indents = [""] * len(lines)
+        source = "\n".join(lines)
+        new_lines = self._highlight(source).splitlines()
+        for indent, new_line in zip(indents, new_lines):
+            self.line(indent + new_line)
+
+    def _highlight(self, source):
+        """Highlight the given source code according to the "code_highlight" option"""
+        if not self.hasmarkup:
+            return source
+        try:
+            from pygments.formatters.terminal import TerminalFormatter
+            from pygments.lexers.python import PythonLexer
+            from pygments import highlight
+        except ImportError:
+            return source
+        else:
+            return highlight(source, PythonLexer(), TerminalFormatter(bg="dark"))
diff --git a/src/_pytest/_io/saferepr.py b/src/_pytest/_io/saferepr.py
@@ -99,5 +99,5 @@ def _format(self, object, stream, indent, allowance, context, level):
 
 def _pformat_dispatch(object, indent=1, width=80, depth=None, *, compact=False):
     return AlwaysDispatchingPrettyPrinter(
-        indent=1, width=80, depth=None, compact=False
+        indent=indent, width=width, depth=depth, compact=compact
     ).pformat(object)
diff --git a/src/_pytest/assertion/util.py b/src/_pytest/assertion/util.py
@@ -226,9 +226,11 @@ def _diff_text(left: str, right: str, verbose: int = 0) -> List[str]:
         left = repr(str(left))
         right = repr(str(right))
         explanation += ["Strings contain only whitespace, escaping them using repr()"]
+    # "right" is the expected base against which we compare "left",
+    # see https://github.com/pytest-dev/pytest/issues/3333
     explanation += [
         line.strip("\n")
-        for line in ndiff(left.splitlines(keepends), right.splitlines(keepends))
+        for line in ndiff(right.splitlines(keepends), left.splitlines(keepends))
     ]
     return explanation
 
@@ -239,8 +241,8 @@ def _compare_eq_verbose(left: Any, right: Any) -> List[str]:
     right_lines = repr(right).splitlines(keepends)
 
     explanation = []  # type: List[str]
-    explanation += ["-" + line for line in left_lines]
-    explanation += ["+" + line for line in right_lines]
+    explanation += ["+" + line for line in left_lines]
+    explanation += ["-" + line for line in right_lines]
 
     return explanation
 
@@ -283,8 +285,10 @@ def _compare_eq_iterable(
         _surrounding_parens_on_own_lines(right_formatting)
 
     explanation = ["Full diff:"]
+    # "right" is the expected base against which we compare "left",
+    # see https://github.com/pytest-dev/pytest/issues/3333
     explanation.extend(
-        line.rstrip() for line in difflib.ndiff(left_formatting, right_formatting)
+        line.rstrip() for line in difflib.ndiff(right_formatting, left_formatting)
     )
     return explanation
 
@@ -319,8 +323,9 @@ def _compare_eq_sequence(
             break
 
     if comparing_bytes:
-        # when comparing bytes, it doesn't help to show the "sides contain one or more items"
-        # longer explanation, so skip it
+        # when comparing bytes, it doesn't help to show the "sides contain one or more
+        # items" longer explanation, so skip it
+
         return explanation
 
     len_diff = len_left - len_right
@@ -447,7 +452,7 @@ def _notin_text(term: str, text: str, verbose: int = 0) -> List[str]:
     head = text[:index]
     tail = text[index + len(term) :]
     correct_text = head + tail
-    diff = _diff_text(correct_text, text, verbose)
+    diff = _diff_text(text, correct_text, verbose)
     newdiff = ["%s is contained here:" % saferepr(term, maxsize=42)]
     for line in diff:
         if line.startswith("Skipping"):
diff --git a/testing/acceptance_test.py b/testing/acceptance_test.py
@@ -1282,8 +1282,8 @@ def test():
             "    def check():",
             ">       assert 1 == 2",
             "E       assert 1 == 2",
-            "E         -1",
-            "E         +2",
+            "E         +1",
+            "E         -2",
             "",
             "pdb.py:2: AssertionError",
             "*= 1 failed in *",
diff --git a/testing/code/test_terminal_writer.py b/testing/code/test_terminal_writer.py
@@ -0,0 +1,28 @@
+import re
+from io import StringIO
+
+import pytest
+from _pytest._io import TerminalWriter
+
+
+@pytest.mark.parametrize(
+    "has_markup, expected",
+    [
+        pytest.param(
+            True, "{kw}assert{hl-reset} {number}0{hl-reset}\n", id="with markup"
+        ),
+        pytest.param(False, "assert 0\n", id="no markup"),
+    ],
+)
+def test_code_highlight(has_markup, expected, color_mapping):
+    f = StringIO()
+    tw = TerminalWriter(f)
+    tw.hasmarkup = has_markup
+    tw._write_source(["assert 0"])
+    assert f.getvalue().splitlines(keepends=True) == color_mapping.format([expected])
+
+    with pytest.raises(
+        ValueError,
+        match=re.escape("indents size (2) should have same size as lines (1)"),
+    ):
+        tw._write_source(["assert 0"], [" ", " "])
diff --git a/testing/conftest.py b/testing/conftest.py
@@ -1,7 +1,10 @@
 import os
+import re
 import sys
+from typing import List
 
 import pytest
+from _pytest.pytester import RunResult
 from _pytest.pytester import Testdir
 
 
@@ -107,6 +110,12 @@ def sep(self, sep, line=None):
         def write(self, msg, **kw):
             self.lines.append((TWMock.WRITE, msg))
 
+        def _write_source(self, lines, indents=()):
+            if not indents:
+                indents = [""] * len(lines)
+            for indent, line in zip(indents, lines):
+                self.line(indent + line)
+
         def line(self, line, **kw):
             self.lines.append(line)
 
@@ -154,3 +163,64 @@ def runtest(self):
 def testdir(testdir: Testdir) -> Testdir:
     testdir.monkeypatch.setenv("PYTEST_DISABLE_PLUGIN_AUTOLOAD", "1")
     return testdir
+
+
+@pytest.fixture(scope="session")
+def color_mapping():
+    """Returns a utility class which can replace keys in strings in the form "{NAME}"
+    by their equivalent ASCII codes in the terminal.
+
+    Used by tests which check the actual colors output by pytest.
+    """
+
+    class ColorMapping:
+        COLORS = {
+            "red": "\x1b[31m",
+            "green": "\x1b[32m",
+            "yellow": "\x1b[33m",
+            "bold": "\x1b[1m",
+            "reset": "\x1b[0m",
+            "kw": "\x1b[94m",
+            "hl-reset": "\x1b[39;49;00m",
+            "function": "\x1b[92m",
+            "number": "\x1b[94m",
+            "str": "\x1b[33m",
+            "print": "\x1b[96m",
+        }
+        RE_COLORS = {k: re.escape(v) for k, v in COLORS.items()}
+
+        @classmethod
+        def format(cls, lines: List[str]) -> List[str]:
+            """Straightforward replacement of color names to their ASCII codes."""
+            return [line.format(**cls.COLORS) for line in lines]
+
+        @classmethod
+        def format_for_fnmatch(cls, lines: List[str]) -> List[str]:
+            """Replace color names for use with LineMatcher.fnmatch_lines"""
+            return [line.format(**cls.COLORS).replace("[", "[[]") for line in lines]
+
+        @classmethod
+        def format_for_rematch(cls, lines: List[str]) -> List[str]:
+            """Replace color names for use with LineMatcher.re_match_lines"""
+            return [line.format(**cls.RE_COLORS) for line in lines]
+
+        @classmethod
+        def requires_ordered_markup(cls, result: RunResult):
+            """Should be called if a test expects markup to appear in the output
+            in the order they were passed, for example:
+
+                tw.write(line, bold=True, red=True)
+
+            In Python 3.5 there's no guarantee that the generated markup will appear
+            in the order called, so we do some limited color testing and skip the rest of
+            the test.
+            """
+            if sys.version_info < (3, 6):
+                # terminal writer.write accepts keyword arguments, so
+                # py36+ is required so the markup appears in the expected order
+                output = result.stdout.str()
+                assert "test session starts" in output
+                assert "\x1b[1m" in output
+                pytest.skip("doing limited testing because lacking ordered markup")
+
+    return ColorMapping
diff --git a/testing/io/test_saferepr.py b/testing/io/test_saferepr.py
@@ -1,4 +1,5 @@
 import pytest
+from _pytest._io.saferepr import _pformat_dispatch
 from _pytest._io.saferepr import saferepr
 
 
@@ -147,3 +148,9 @@ def test_unicode():
     val = "£€"
     reprval = "'£€'"
     assert saferepr(val) == reprval
+
+
+def test_pformat_dispatch():
+    assert _pformat_dispatch("a") == "'a'"
+    assert _pformat_dispatch("a" * 10, width=5) == "'aaaaaaaaaa'"
+    assert _pformat_dispatch("foo bar", width=5) == "('foo '\n 'bar')"
diff --git a/testing/test_assertion.py b/testing/test_assertion.py
diff --git a/testing/test_assertrewrite.py b/testing/test_assertrewrite.py
diff --git a/testing/test_error_diffs.py b/testing/test_error_diffs.py
diff --git a/testing/test_terminal.py b/testing/test_terminal.py
diff --git a/tox.ini b/tox.ini

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+Reversed / fix meaning of "+/-" in error diffs. "-" means that sth. expected is missing in the result and "+" means that there are unexpected extras in the result.`