Commits

holger krekel  committed 28da538

use repr() to print extra / differing values in assertion comparison failures
and guard against failures in detail-representations

  • Participants
  • Parent commits a4c7bbb

Comments (0)

Files changed (4)

File doc/example/assertion/failure_demo.py

     def test_eq_set(self):
         assert set([0, 10, 11, 12]) == set([0, 20, 21])
 
+    def test_eq_longer_list(self):
+        assert [1,2] == [1,2,3]
+
     def test_in_list(self):
         assert 1 in [0, 2, 3, 4, 5]
 

File doc/example/assertion/test_failures.py

     failure_demo.copy(testdir.tmpdir.join(failure_demo.basename))
     result = testdir.runpytest(target)
     result.stdout.fnmatch_lines([
-        "*20 failed*"
+        "*31 failed*"
     ])
     assert result.ret != 0

File py/_plugin/pytest_assertion.py

     isset = lambda x: isinstance(x, set)
 
     explanation = None
-    if op == '==':
-        if istext(left) and istext(right):
-            explanation = _diff_text(left, right)
-        elif issequence(left) and issequence(right):
-            explanation = _compare_eq_sequence(left, right)
-        elif isset(left) and isset(right):
-            explanation = _compare_eq_set(left, right)
-        elif isdict(left) and isdict(right):
-            explanation = _diff_text(py.std.pprint.pformat(left),
-                                     py.std.pprint.pformat(right))
-    elif op == 'in':
-        pass                    # XXX
+    try:
+        if op == '==':
+            if istext(left) and istext(right):
+                explanation = _diff_text(left, right)
+            elif issequence(left) and issequence(right):
+                explanation = _compare_eq_sequence(left, right)
+            elif isset(left) and isset(right):
+                explanation = _compare_eq_set(left, right)
+            elif isdict(left) and isdict(right):
+                explanation = _diff_text(py.std.pprint.pformat(left),
+                                         py.std.pprint.pformat(right))
+    except py.builtin._sysex:
+        raise
+    except:
+        explanation = ['(pytest_assertion plugin: representation of '
+            'details failed. Probably an object has a faulty __repr__.)']
 
     if not explanation:
         return None
     explanation = []
     for i in range(min(len(left), len(right))):
         if left[i] != right[i]:
-            explanation += ['First differing item %s: %s != %s' %
+            explanation += ['At index %s diff: %r != %r' %
                             (i, left[i], right[i])]
             break
     if len(left) > len(right):
         explanation += ['Left contains more items, '
-                        'first extra item: %s' % left[len(right)]]
+            'first extra item: %s' % py.io.saferepr(left[len(right)],)]
     elif len(left) < len(right):
         explanation += ['Right contains more items, '
-                        'first extra item: %s' % right[len(left)]]
-    return explanation + _diff_text(py.std.pprint.pformat(left),
-                                    py.std.pprint.pformat(right))
+            'first extra item: %s' % py.io.saferepr(right[len(left)],)]
+    return explanation # + _diff_text(py.std.pprint.pformat(left),
+                       #             py.std.pprint.pformat(right))
 
 
 def _compare_eq_set(left, right):

File testing/plugin/test_pytest_assertion.py

         plugin.pytest_unconfigure(config)
         assert hook == py.code._reprcompare
 
+def callequal(left, right):
+    return plugin.pytest_assertrepr_compare('==', left, right)
+
 class TestAssert_reprcompare:
     def test_different_types(self):
-        assert plugin.pytest_assertrepr_compare('==', [0, 1], 'foo') is None
+        assert callequal([0, 1], 'foo') is None
 
     def test_summary(self):
-        summary = plugin.pytest_assertrepr_compare('==', [0, 1], [0, 2])[0]
+        summary = callequal([0, 1], [0, 2])[0]
         assert len(summary) < 65
 
     def test_text_diff(self):
-        diff = plugin.pytest_assertrepr_compare('==', 'spam', 'eggs')[1:]
+        diff = callequal('spam', 'eggs')[1:]
         assert '- spam' in diff
         assert '+ eggs' in diff
 
     def test_multiline_text_diff(self):
         left = 'foo\nspam\nbar'
         right = 'foo\neggs\nbar'
-        diff = plugin.pytest_assertrepr_compare('==', left, right)
+        diff = callequal(left, right)
         assert '- spam' in diff
         assert '+ eggs' in diff
 
     def test_list(self):
-        expl = plugin.pytest_assertrepr_compare('==', [0, 1], [0, 2])
+        expl = callequal([0, 1], [0, 2])
         assert len(expl) > 1
 
     def test_list_different_lenghts(self):
-        expl = plugin.pytest_assertrepr_compare('==', [0, 1], [0, 1, 2])
+        expl = callequal([0, 1], [0, 1, 2])
         assert len(expl) > 1
-        expl = plugin.pytest_assertrepr_compare('==', [0, 1, 2], [0, 1])
+        expl = callequal([0, 1, 2], [0, 1])
         assert len(expl) > 1
 
     def test_dict(self):
-        expl = plugin.pytest_assertrepr_compare('==', {'a': 0}, {'a': 1})
+        expl = callequal({'a': 0}, {'a': 1})
         assert len(expl) > 1
 
     def test_set(self):
-        expl = plugin.pytest_assertrepr_compare('==', set([0, 1]), set([0, 2]))
+        expl = callequal(set([0, 1]), set([0, 2]))
         assert len(expl) > 1
 
+    def test_list_tuples(self):
+        expl = callequal([], [(1,2)])
+        assert len(expl) > 1
+        expl = callequal([(1,2)], [])
+        assert len(expl) > 1
+
+    def test_list_bad_repr(self):
+        class A:
+            def __repr__(self):
+                raise ValueError(42)
+        expl = callequal([], [A()])
+        assert 'ValueError' in "".join(expl)
+        expl = callequal({}, {'1': A()})
+        assert 'faulty' in "".join(expl)
+
 @needsnewassert
 def test_pytest_assertrepr_compare_integration(testdir):
     testdir.makepyfile("""
         "*E*50*",
     ])
 
+@needsnewassert
+def test_sequence_comparison_uses_repr(testdir):
+    testdir.makepyfile("""
+        def test_hello():
+            x = set("hello x")
+            y = set("hello y")
+            assert x == y
+    """)
+    result = testdir.runpytest()
+    result.stdout.fnmatch_lines([
+        "*def test_hello():*",
+        "*assert x == y*",
+        "*E*Extra items*left*",
+        "*E*'x'*",
+        "*E*Extra items*right*",
+        "*E*'y'*",
+    ])
+
+
 def test_functional(testdir):
     testdir.makepyfile("""
         def test_hello():