Was ist ein Python-Unit-Test? (ausführliche Beispiele)

Im folgenden Artikel erfahren wir, was Unit-Tests in Python sind. Erfahren Sie mehr über Python-Unit-Tests und welche Rolle Python-Unit-Tests bei der Python-Programmierung spielen können.

Unit-Testing

Unit-Tests werden verwendet, um die Korrektheit eines Moduls, einer Funktion oder einer Klasse zu testen.

Für die Funktion abs() können wir beispielsweise die folgenden Testfälle schreiben:

1. Geben Sie eine positive Zahl ein, z. B. 1, 1,2, 0,99, und erwarten Sie den Rückgabewert muss derselbe sein wie die Eingabe; . Geben Sie 0 ein und erwarten Sie die Rückgabe von 0. Wenn Sie einen nicht numerischen Typ eingeben, z. B. None, [], {}, wird ein TypeError ausgegeben.

Fügen Sie die oben genannten Testfälle in ein Testmodul ein, bei dem es sich um einen vollständigen Komponententest handelt.

Wenn der Komponententest bestanden wird, bedeutet dies, dass die von uns getestete Funktion normal funktionieren kann. Wenn der Unit-Test fehlschlägt, liegt entweder ein Fehler in der Funktion vor oder die Testbedingungen wurden falsch eingegeben. Kurz gesagt, es muss behoben werden, damit der Unit-Test erfolgreich ist.

Was bringt es, einen Unit-Test zu bestehen? Wenn wir Änderungen am Funktionscode abs() vornehmen, müssen wir den Komponententest nur erneut ausführen. Wenn er erfolgreich ist, bedeutet dies, dass unsere Änderung das ursprüngliche Verhalten der Funktion abs() nicht beeinträchtigt bedeutet, dass unsere Änderung nicht mit dem ursprünglichen Verhalten übereinstimmt. Ändern Sie entweder den Code oder ändern Sie den Test.

Der größte Vorteil dieses testgetriebenen Entwicklungsmodells besteht darin, sicherzustellen, dass das Verhalten eines Programmmoduls den von uns entworfenen Testfällen entspricht. Bei zukünftigen Änderungen kann mit großer Sicherheit sichergestellt werden, dass das Modulverhalten immer noch korrekt ist.

Schreiben wir eine Dict-Klasse. Diese Klasse verhält sich genauso wie dict, kann aber wie folgt verwendet werden:

 >>> d = Dict(a=1, b=2)
>>> d['a']
1
>>> d.a
1

Der mydict.py-Code lautet wie folgt:

class Dict(dict):
    def __init__(self, **kw):
        super().__init__(**kw)
    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)
    def __setattr__(self, key, value):
        self[key] = value

Um Unit-Tests zu schreiben, müssen wir das mit Python gelieferte Unittest-Modul einführen und mydict_test.py wie folgt schreiben:

import unittest

from mydict import Dict
class TestDict(unittest.TestCase):
    def test_init(self):
        d = Dict(a=1, b='test')
        self.assertEqual(d.a, 1)
        self.assertEqual(d.b, 'test')
        self.assertTrue(isinstance(d, dict))
    def test_key(self):
        d = Dict()
        d['key'] = 'value'
        self.assertEqual(d.key, 'value')
    def test_attr(self):
        d = Dict()
        d.key = 'value'
        self.assertTrue('key' in d)
        self.assertEqual(d['key'], 'value')
    def test_keyerror(self):
        d = Dict()
        with self.assertRaises(KeyError):
            value = d['empty']
    def test_attrerror(self):
        d = Dict()
        with self.assertRaises(AttributeError):
            value = d.empty

Wenn wir Unit-Tests schreiben, müssen wir a schreiben Testklasse, die von unittest.TestCase erbt.

Methoden, die mit „test“ beginnen, sind Testmethoden, die nicht mit „test“ beginnen, gelten nicht als Testmethoden und werden während des Tests nicht ausgeführt.

Für jeden Testtyp muss eine test_xxx()-Methode geschrieben werden. Da unittest.TestCase viele integrierte bedingte Beurteilungen bereitstellt, müssen wir diese Methoden nur aufrufen, um festzustellen, ob die Ausgabe unseren Erwartungen entspricht. Die am häufigsten verwendete Behauptung ist „assertEqual()“:

self.assertEqual(abs(-1), 1) # 断言函数返回的结果与1相等

Eine weitere wichtige Behauptung besteht darin, zu erwarten, dass ein Fehler eines bestimmten Typs ausgelöst wird, wenn beispielsweise über d['empty'] auf einen nicht vorhandenen Schlüssel zugegriffen wird. , wird die Behauptung KeyError:

with self.assertRaises(KeyError):
    value = d['empty']

auslösen. Wenn über d.empty auf einen nicht vorhandenen Schlüssel zugegriffen wird, erwarten wir, dass AttributeError:

with self.assertRaises(AttributeError):
    value = d.empty

Run Unit Test<🎜 ausgegeben wird >

Sobald die Unit-Tests geschrieben sind, können wir die Unit-Tests ausführen. Der einfachste Weg, es auszuführen, besteht darin, am Ende von mydict_test.py zwei Codezeilen hinzuzufügen:

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

这样就可以把mydict_test.py当做正常的python脚本运行：

$ python mydict_test.py

另一种方法是在命令行通过参数-m unittest直接运行单元测试：

$ python -m unittest mydict_test
.....
----------------------------------------------------------------------
Ran 5 tests in 0.000s
OK

 这是推荐的做法，因为这样可以一次批量运行很多单元测试，并且，有很多工具可以自动来运行这些单元测试。

以上就是本篇文章所讲述的所有内容，这篇文章主要介绍了python单元测试的相关知识，希望你能借助资料从而理解上述所说的内容。希望我在这片文章所讲述的内容能够对你有所帮助，让你学习python更加轻松。

更多相关知识，请访问php中文网Python教程栏目。

Das obige ist der detaillierte Inhalt vonWas ist ein Python-Unit-Test? (ausführliche Beispiele). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!