Comment éviter la troncature d'une chaîne dans l'unité test python

Question

Je fais un test unitaire en python pour mon programme et je voudrais faire un test assertEquals.

Mon code ressemble à ceci:

class UnitTest(unittest.TestCase): 
     def test_parser(self): 
      self.assertEquals(parser,"some long string", "String is not equal") 

Cependant, comme ma chaîne est trop longue, je suis quelque chose comme test [471 caractères] 0 = test [473] caractères!. Je veux voir quelle est la différence exacte entre les deux chaînes au lieu de voir celles qui sont tronquées.

Quelqu'un a une idée pour contrer ce problème?

Answer 1

unittest.TestCase.assertEquals essaie de vous donner la différence réelle dans la chaîne tout en faisant en même temps le texte entrer dans votre écran.

Pour ce faire, il tronque les sections communes, de sorte que les sections qui ont aucune différence sont tronqués en les remplaçant par [<count> chars] morceaux:

>>> case.assertEqual('foo' * 200, 'foo' * 100 + 'bar' + 'foo' * 99) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "/Users/mjpieters/Development/Library/buildout.python/parts/opt/lib/python3.6/unittest/case.py", line 821, in assertEqual 
    assertion_func(first, second, msg=msg) 
    File "/Users/mjpieters/Development/Library/buildout.python/parts/opt/lib/python3.6/unittest/case.py", line 1194, in assertMultiLineEqual 
    self.fail(self._formatMessage(msg, standardMsg)) 
    File "/Users/mjpieters/Development/Library/buildout.python/parts/opt/lib/python3.6/unittest/case.py", line 666, in fail 
    raise self.failureException(msg) 
AssertionError: 'foof[291 chars]oofoofoofoofoofoofoofoofoofoofoofoofoofoofoofo[255 chars]ofoo' != 'foof[291 chars]oofoobarfoofoofoofoofoofoofoofoofoofoofoofoofo[255 chars]ofoo' 
Diff is 1819 characters long. Set self.maxDiff to None to see it. 

Dans l'exemple ci-dessus, les deux chaînes partagent un long préfixe, qui a été raccourci en remplaçant 291 caractères par [291 chars] dans les deux préfixes. Ils partagent également un long postfix, à nouveau raccourci dans les deux emplacements en remplaçant le texte par [255 chars].

La différence réelle est toujours affichée, juste au milieu.

Bien sûr, quand vous faites cette différence trop longtemps, alors même la différence est tronquée:

>>> case.assertEqual('foo' * 200, 'foo' * 80 + 'bar' * 30 + 'foo' * 80) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "/Users/mjpieters/Development/Library/buildout.python/parts/opt/lib/python3.6/unittest/case.py", line 821, in assertEqual 
    assertion_func(first, second, msg=msg) 
    File "/Users/mjpieters/Development/Library/buildout.python/parts/opt/lib/python3.6/unittest/case.py", line 1194, in assertMultiLineEqual 
    self.fail(self._formatMessage(msg, standardMsg)) 
    File "/Users/mjpieters/Development/Library/buildout.python/parts/opt/lib/python3.6/unittest/case.py", line 666, in fail 
    raise self.failureException(msg) 
AssertionError: 'foof[231 chars]oofoofoofoofoofoofoofoofoofoofoofoofoofoofoofo[315 chars]ofoo' != 'foof[231 chars]oofoobarbarbarbarbarbarbarbarbarbarbarbarbarba[285 chars]ofoo' 
Diff is 1873 characters long. Set self.maxDiff to None to see it. 

Ici, le postfix commun commence à différer, mais le début de la différence est encore visible, et devrait vous aider à comprendre où le texte a mal tourné.

Si cela ne suffit toujours pas, vous pouvez augmenter ou éliminer les limites de diff. Réglez le TestCase.maxDiff attribute à un nombre plus élevé (la valeur par défaut est 8 * 80, 80 lignes de texte), ou le mettre à None d'éliminer complètement:

self.maxDiff = None 

Notez que si votre chaîne contient sauts de ligne que la diff est susceptible d'être illisible:

AssertionError: 'foof[231 chars]oofoofoofoofoofoofoofoofoofoofoofoofoofoofoofo[315 chars]ofoo' != 'foof[231 chars]oofoobarbarbarbarbarbarbarbarbarbarbarbarbarba[285 chars]ofoo' - foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo ?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoobarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarfoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo ?
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Dans ce cas, il peut être plus utile pour envelopper vos d'entrée et de sortie des textes:

from textwrap import wrap 

self.maxDiff = None 
self.assertEquals(wrap(parser), wrap("some long string"), "String is not equal") 

juste pour que vous obtenez mieux et plus lisible sortie diff:

>>> from textwrap import wrap 
>>> case.assertEqual(wrap('foo' * 200), wrap('foo' * 80 + 'bar' * 30 + 'foo' * 80)) 
Traceback (most recent call last): 
    File "<stdin>", line 1, in <module> 
    File "/Users/mjpieters/Development/Library/buildout.python/parts/opt/lib/python3.6/unittest/case.py", line 821, in assertEqual 
    assertion_func(first, second, msg=msg) 
    File "/Users/mjpieters/Development/Library/buildout.python/parts/opt/lib/python3.6/unittest/case.py", line 1019, in assertListEqual 
    self.assertSequenceEqual(list1, list2, msg, seq_type=list) 
    File "/Users/mjpieters/Development/Library/buildout.python/parts/opt/lib/python3.6/unittest/case.py", line 1001, in assertSequenceEqual 
    self.fail(msg) 
    File "/Users/mjpieters/Development/Library/buildout.python/parts/opt/lib/python3.6/unittest/case.py", line 666, in fail 
    raise self.failureException(msg) 
AssertionError: Lists differ: ['foo[244 chars]oofoofoofoofoofoofoofoofoofoofoofoofoofoofoof'[336 chars]foo'] != ['foo[244 chars]oofoobarbarbarbarbarbarbarbarbarbarbarbarbarb'[306 chars]foo'] 

First differing element 3: 
'foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoof' 
'foofoofoofoofoofoofoofoofoofoobarbarbarbarbarbarbarbarbarbarbarbarbarb' 

    ['foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoof', 
    'oofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofo', 
    'ofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo', 
- 'foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoof', 
- 'oofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofo', 
+ 'foofoofoofoofoofoofoofoofoofoobarbarbarbarbarbarbarbarbarbarbarbarbarb', 
+ 'arbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarfoofoofoofoofoofoofo', 
    'ofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoo', 
    'foofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoof', 
    'oofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofoofo', 
- 'ofoofoofoofoofoofoofoofoofoofoofoofoofoo'] 
+ 'ofoofoofoo']