Wie testet man, dass eine Python-Funktion eine Ausnahme auslöst?

Question

Wie kann man einen Unittest schreiben, der nur dann fehlschlägt, wenn eine Funktion keine erwartete Ausnahme auslöst?

Answer 1

Utilisez TestCase.assertRaises (oder TestCase.failUnlessRaises ) aus dem Unittest-Modul, zum Beispiel:

import mymod

class MyTestCase(unittest.TestCase):
    def test1(self):
        self.assertRaises(SomeCoolException, mymod.myfunc)

Answer 2

Seit Python 2.7 können Sie den Kontext-Manager verwenden, um an das tatsächliche Exception-Objekt zu gelangen, das ausgelöst wurde:

import unittest

def broken_function():
    raise Exception('This is broken')

class MyTestCase(unittest.TestCase):
    def test(self):
        with self.assertRaises(Exception) as context:
            broken_function()

        self.assertTrue('This is broken' in context.exception)

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

http://docs.python.org/dev/library/unittest.html#unittest.TestCase.assertRaises

---

En Python 3.5 müssen Sie einpacken context.exception en str , sonst erhalten Sie eine TypeError

self.assertTrue('This is broken' in str(context.exception))

Answer 3

Der Code in meiner vorherigen Antwort kann vereinfacht werden zu:

def test_afunction_throws_exception(self):
    self.assertRaises(ExpectedException, afunction)

Und wenn eine Funktion Argumente benötigt, übergeben Sie diese einfach wie folgt an assertRaises:

def test_afunction_throws_exception(self):
    self.assertRaises(ExpectedException, afunction, arg1, arg2)

Answer 4

Wie testet man, dass eine Python-Funktion eine Ausnahme auslöst?

Wie kann man einen Test schreiben, der nur dann fehlschlägt, wenn eine Funktion keine eine erwartete Ausnahme auslöst?

Kurze Antwort:

Verwenden Sie die self.assertRaises Methode als Kontextmanager:

    def test_1_cannot_add_int_and_str(self):
        with self.assertRaises(TypeError):
            1 + '1'

Demonstration

Der Best-Practice-Ansatz lässt sich recht einfach in einer Python-Shell demonstrieren.

El unittest Bibliothek

In Python 2.7 oder 3:

import unittest

In Python 2.6 können Sie einen Backport der 2.7er Version installieren unittest Bibliothek, genannt ungetestet2 und benennen Sie es einfach als unittest :

import unittest2 as unittest

Beispieltests

Fügen Sie nun in Ihrer Python-Shell den folgenden Test der Typsicherheit von Python ein:

class MyTestCase(unittest.TestCase):
    def test_1_cannot_add_int_and_str(self):
        with self.assertRaises(TypeError):
            1 + '1'
    def test_2_cannot_add_int_and_str(self):
        import operator
        self.assertRaises(TypeError, operator.add, 1, '1')

Test eins verwendet assertRaises als Kontextmanager, der sicherstellt, dass der Fehler ordnungsgemäß abgefangen und bereinigt wird, während er aufgezeichnet wird.

Wir könnten es auch so schreiben ohne den Kontextmanager, siehe Test zwei. Das erste Argument ist der Fehlertyp, den Sie erwarten, das zweite Argument ist die Funktion, die Sie testen, und die übrigen Args und Keyword-Args werden an diese Funktion übergeben.

Ich denke, es ist viel einfacher, lesbarer und wartbarer, einfach den Kontextmanager zu verwenden.

Durchführung der Tests

So führen Sie die Tests durch:

unittest.main(exit=False)

In Python 2.6 werden Sie wahrscheinlich benötigen Folgendes :

unittest.TextTestRunner().run(unittest.TestLoader().loadTestsFromTestCase(MyTestCase))

Und Ihr Terminal sollte folgendes ausgeben:

..
----------------------------------------------------------------------
Ran 2 tests in 0.007s

OK
<unittest2.runner.TextTestResult run=2 errors=0 failures=0>

Und wir sehen, dass, wie erwartet, der Versuch, eine 1 y un '1' führen zu einer TypeError .

---

Wenn Sie eine ausführlichere Ausgabe wünschen, versuchen Sie dies:

unittest.TextTestRunner(verbosity=2).run(unittest.TestLoader().loadTestsFromTestCase(MyTestCase))

Answer 5

Ihr Code sollte diesem Muster folgen (dies ist ein Test im Stil eines Unittest-Moduls):

def test_afunction_throws_exception(self):
    try:
        afunction()
    except ExpectedException:
        pass
    except Exception:
       self.fail('unexpected exception raised')
    else:
       self.fail('ExpectedException not raised')

Unter Python < 2.7 ist dieses Konstrukt nützlich, um auf bestimmte Werte in der erwarteten Ausnahme zu prüfen. Die Unittest-Funktion assertRaises prüft nur, ob eine Ausnahme ausgelöst wurde.