In Pythons Unittest fortfahren, wenn eine Assertion fehlschlägt

Anderen Weg, um nicht-schwerwiegende Behauptungen ist das erfassen der Geltendmachung Ausnahme, und speichern Sie die Ausnahmen in einer Liste. Dann behaupten, dass diese Liste leer ist als Teil der ZERLEGUNG.

import unittest

class Car(object):
  def __init__(self, make, model):
    self.make = make
    self.model = make  # Copy and paste error: should be model.
    self.has_seats = True
    self.wheel_count = 3  # Typo: should be 4.

class CarTest(unittest.TestCase):
  def setUp(self):
    self.verificationErrors = []

  def tearDown(self):
    self.assertEqual([], self.verificationErrors)

  def test_init(self):
    make = "Ford"
    model = "Model T"
    car = Car(make=make, model=model)
    try: self.assertEqual(car.make, make)
    except AssertionError, e: self.verificationErrors.append(str(e))
    try: self.assertEqual(car.model, model)  # Failure!
    except AssertionError, e: self.verificationErrors.append(str(e))
    try: self.assertTrue(car.has_seats)
    except AssertionError, e: self.verificationErrors.append(str(e))
    try: self.assertEqual(car.wheel_count, 4)  # Failure!
    except AssertionError, e: self.verificationErrors.append(str(e))

if __name__ == "__main__":
    unittest.main()

InformationsquelleAutor der Antwort Anthony Batchelor

Es wird als ein anti-pattern, das mehrere asserts in einem einzigen unit-test. Eine single-unit-test wird erwartet, dass der test nur eins. Vielleicht sind Sie testen zu viel. Aufteilen dieser test in mehreren tests. Auf diese Weise können Sie den Namen jeder richtig testen.

Manchmal jedoch, es in Ordnung ist, überprüfen Sie mehrere Dinge zur gleichen Zeit. Zum Beispiel, wenn Sie die Geltendmachung von Eigenschaften des gleichen Objekts. In diesem Fall sind Sie in der Tat behaupten, ob das Objekt korrekt ist. Ein Weg, dies zu tun ist, schreiben Sie eine benutzerdefinierte helper-Methode, die weiß, wie zu behaupten, die auf diesem Objekt. Sie können schreiben, dass die Methode in einer solchen Weise, dass es zeigt alle fehlerhaften Eigenschaften oder zum Beispiel zeigt den vollständigen Zustand der erwarteten Objekt und den vollständigen Zustand des eigentlichen Objekts, wenn eine Assertion fehlschlägt.

InformationsquelleAutor der Antwort Steven

Ich mochte den Ansatz von @Anthony-Batchelor, zu erfassen, die AssertionError-Ausnahme. Aber eine leichte variation dieses Ansatzes mit Hilfe von Dekoratoren und auch ein Weg, Bericht zu den tests Fälle mit pass/fail.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import unittest

class UTReporter(object):
    '''
    The UT Report class keeps track of tests cases
    that have been executed.
    '''
    def __init__(self):
        self.testcases = []
        print "init called"

    def add_testcase(self, testcase):
        self.testcases.append(testcase)

    def display_report(self):
        for tc in self.testcases:
            msg = "=============================" + "\n" + \
                "Name: " + tc['name'] + "\n" + \
                "Description: " + str(tc['description']) + "\n" + \
                "Status: " + tc['status'] + "\n"
            print msg

reporter = UTReporter()

def assert_capture(*args, **kwargs):
    '''
    The Decorator defines the override behavior.
    unit test functions decorated with this decorator, will ignore
    the Unittest AssertionError. Instead they will log the test case
    to the UTReporter.
    '''
    def assert_decorator(func):
        def inner(*args, **kwargs):
            tc = {}
            tc['name'] = func.__name__
            tc['description'] = func.__doc__
            try:
                func(*args, **kwargs)
                tc['status'] = 'pass'
            except AssertionError:
                tc['status'] = 'fail'
            reporter.add_testcase(tc)
        return inner
    return assert_decorator



class DecorateUt(unittest.TestCase):

    @assert_capture()
    def test_basic(self):
        x = 5
        self.assertEqual(x, 4)

    @assert_capture()
    def test_basic_2(self):
        x = 4
        self.assertEqual(x, 4)

def main():
    #unittest.main()
    suite = unittest.TestLoader().loadTestsFromTestCase(DecorateUt)
    unittest.TextTestRunner(verbosity=2).run(suite)

    reporter.display_report()


if __name__ == '__main__':
    main()

Ausgabe von der Konsole:

(awsenv)$ ./decorators.py 
init called
test_basic (__main__.DecorateUt) ... ok
test_basic_2 (__main__.DecorateUt) ... ok

----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK
=============================
Name: test_basic
Description: None
Status: fail

=============================
Name: test_basic_2
Description: None
Status: pass

InformationsquelleAutor der Antwort Zoro_77

Ich glaube nicht, dass es einen Weg gibt, dies zu tun mit PyUnit und würde nicht wollen, um zu sehen, PyUnit verlängert auf diese Weise.

Ich bleibe lieber auf eine assertion pro test-Funktion (oder genauer gesagt die Durchsetzung Konzept pro test) und würde umzuschreiben test_addition() als vier separate test-Funktionen. Dies würde es erlauben, mehr nützliche Informationen über Fehler, viz:

.FF.
======================================================================
FAIL: test_addition_with_two_negatives (__main__.MathTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_addition.py", line 10, in test_addition_with_two_negatives
    self.assertEqual(-1 + (-1), -1)
AssertionError: -2 != -1

======================================================================
FAIL: test_addition_with_two_positives (__main__.MathTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_addition.py", line 6, in test_addition_with_two_positives
    self.assertEqual(1 + 1, 3)  # Failure!
AssertionError: 2 != 3

----------------------------------------------------------------------
Ran 4 tests in 0.000s

FAILED (failures=2)

Wenn Sie entscheiden, dass dieser Ansatz nicht für Sie, können Sie finden diese Antwort hilfreich.

Update

Es sieht aus wie Sie sind, testen die beiden Konzepte mit Ihren aktualisierten Frage-und ich würde teilen diese in zwei unit-tests. Die erste ist, dass die Parameter gespeichert sind, die auf die Schaffung eines neuen Objekts. Dies hätte zwei Aussagen, eine für make und eine für model. Wenn der erste ausfällt, der das deutlich repariert werden muss, ob der zweite Test besteht oder nicht besteht, ist irrelevant an dieser Stelle.

Das zweite Konzept ist eher fraglich... Man testen, ob einige default-Werten initialisiert werden. Warum? Es wäre nützlicher, um zu testen, diese Werte an dem Punkt, dass Sie tatsächlich verwendet werden (und wenn Sie nicht gewohnt sind, warum sind Sie dann da?).

Beide diese tests fehlschlagen, und beide sollten. Wenn ich unit-Tests, ich bin weit mehr daran interessiert, in der Fehler als ich in den Erfolg, wie das ist, wo ich brauche zu konzentrieren.

FF
======================================================================
FAIL: test_creation_defaults (__main__.CarTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_car.py", line 25, in test_creation_defaults
    self.assertEqual(self.car.wheel_count, 4)  # Failure!
AssertionError: 3 != 4

======================================================================
FAIL: test_creation_parameters (__main__.CarTest)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_car.py", line 20, in test_creation_parameters
    self.assertEqual(self.car.model, self.model)  # Failure!
AssertionError: 'Ford' != 'Model T'

----------------------------------------------------------------------
Ran 2 tests in 0.000s

FAILED (failures=2)

InformationsquelleAutor der Antwort Johnsyweb