Dieser Kommentar ist eine kurze Aufzeichnung der Verwendung der unittest-Funktion von Python. Der Zweck besteht darin, die Unit-Test-Funktion von Python zu erläutern, ein einfaches Beispiel bereitzustellen und eine Vorlage bereitzustellen, wenn Sie in Zukunft Tests durchführen möchten.
Es geht nicht darum, wie man doctest benutzt.
Ich denke auch, dass ich Nosetests verwende, wenn ich viele Tests durchführe, aber das erkläre ich auch nicht.
** Wenn Sie ein Buch oder ein offizielles Dokument lesen, erhalten Sie natürlich nützliches Wissen. Wenn Sie es bei der Arbeit verwenden, sollten Sie stattdessen ein geeignetes lesen. Für jeden. ** ** **
Python 2.7.11
Python
Eine Gruppe von Modulen, die nützliche Funktionen zum Testen von Python-Code implementieren. Es ist in der Python-Ausführungsumgebung enthalten und sollte verfügbar sein, wenn Python installiert ist. Es kann durch Importieren wie folgt verwendet werden.
import unittest
Es scheint viele andere Testwerkzeuge zu geben. Werfen Sie einen Blick auf die Websites auf Referenzen.
Weitere Informationen zu den Funktionen von Python unittest finden Sie in der offiziellen Dokumentation.
Zunächst wird kurz beschrieben, welche Art von Funktion es hat. Danach werden Beispiele für die Verwendung gezeigt, damit viele Benutzer diese Verwendung unterdrücken können. Ab der mittleren Phase gibt es Details zu jeder Funktion und eine Liste der Assert-Hogehoge-Methoden, die zum Testen verwendet werden.
Englische Version: https://docs.python.org/2.7/library/unittest.html Japanische Version: https://docs.python.org/ja/2.7/library/unittest.html#module-unittest
Die grundlegende Verwendung ist wie folgt.
Angenommen, Sie haben einen geeigneten Code. Zum Beispiel die folgende Methode, die nur hinzugefügt wird.
tashizan.py
def tashizan(a, b):
""" calculate (a + b)
"""
return a + b
Ich möchte das testen. Die Funktion, die erfüllt sein sollte, wäre, dass die Addition korrekt ausgeführt wird (keine Subtraktion usw.). Ich werde ein Modul dafür schreiben.
test_tashizan.py
import unittest
from tashizan import tashizan
class TestTashizan(unittest.TestCase):
"""test class of tashizan.py
"""
def test_tashizan(self):
"""test method for tashizan
"""
value1 = 2
value2 = 6
expected = 8
actual = tashizan(value1, value2)
self.assertEqual(expected, actual)
if __name__ == "__main__":
unittest.main()
Wenn Sie unittest.main () drücken, wird eine Gruppe von Tests ausgeführt. Das Ergebnis ist wie folgt.
$ python test_tashizan.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
Wenn unittest.main () ausgeführt wird, werden alle Klassen erkannt, die unittest.TestCase im Zielskript erben, und alle Methoden mit Namen, die mit test beginnen, werden als Testfälle ausgeführt.
Wenn es mehrere Tests gibt, führen Sie sie mit der oben beschriebenen Methode aus und sie werden sofort ausgeführt. Das Ergebnis des Hinzufügens einer Subtraktion zur vorherigen und ihrer Ausführung ist wie folgt
keisan.py
def tashizan(a, b):
"""calculate a+b
:param a: value 1(int)
:param b: value 2(inte)
:return: a + b
"""
return a + b
def hikizan(a, b):
"""calculate a - b
:param a: value 1(int)
:param b: value 2(int)
:return: a - b
"""
return a - b
--−−−
test_keisan.py
import unittest
import keisan
class TestKeisan(unittest.TestCase):
"""test class of keisan.py
"""
def test_tashizan(self):
"""test method for tashizan
"""
value1 = 2
value2 = 6
expected = 8
actual = keisan.tashizan(value1, value2)
self.assertEqual(expected, actual)
class TestKeisan2(unittest.TestCase):
def test_hikizan(self):
"""test method for hikizan
"""
value1 = 2
value2 = 12
expected = -10
actual = keisan.hikizan(value1, value2)
self.assertEqual(expected, actual)
if __name__ == "__main__":
unittest.main()
$ python test_keisan.py -v
test_tashizan (__main__.TestKeisan)
test method for tashizan ... ok
test_hikizan (__main__.TestKeisan2)
test method for hikizan ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
(Beliebig getrennte Klassen. Im obigen Fall schreiben Sie wahrscheinlich in einer Klasse.) Es gibt jedoch Situationen, in denen Sie nur eine bestimmte Testklasse ausführen möchten. Verwenden Sie in diesem Fall zur Laufzeit die Option -m. Ein Beispiel ist unten gezeigt. Hier werden durch Hinzufügen der Option -v nach unittest Informationen zum Testinhalt angezeigt. Wenn Sie Python -m -v ... ausführen, wird die Option -v an den Python-Interpreter übergeben, sodass viele Informationen angezeigt werden, die nichts mit dem Test zu tun haben. (Siehe @ skawagt's Kommentar)
$ python -m unittest test_keisan.TestKeisan2 -v
.
test_hikizan (test_keisan.TestKeisan2)
test method for hikizan ... ok
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
Das Initialisieren des Werts kann zeitaufwändig sein. Wenn Sie verschiedene Vorgänge für ein bestimmtes Objekt überprüfen möchten, ist es schwierig, für jeden Testfall einen Wert einzugeben. In diesem Fall gibt es die Methoden setUp und tearDown. SetUp und TearDown werden für jeden Testfall ausgeführt.
Hier ist ein Beispiel dafür, wann Sie eine Klasse quadratischer Gleichungen haben und diese testen möchten.
QuadraticEquation.py
import numpy as np
class QuadraticEquation(object):
"""Quadratic equation class
"""
def __init__(self):
self.a = 1.0
self.b = 2.0
self.c = 1.0
def calc_root(self):
"""calculate root
:return: root1, root2 (root1 < root2)
"""
x1 = (-1.0 * self.b - np.sqrt(self.b * self.b - 4.0 * self.a * self.c)) / (2.0 * self.a)
x2 = (-1.0 * self.b + np.sqrt(self.b * self.b - 4.0 * self.a * self.c)) / (2.0 * self.a)
return x1, x2
def calc_value(self, x):
""" calculate polynomial value
:param x: x
:return: a * x^2 + b * x + c
"""
return self.a * np.power(x, 2.0) + self.b * x + self.c
Der Testfall hierfür ist wie folgt.
test_quadraticEquation.py
import unittest
import QuadraticEquation
from unittest import TestCase
class TestQuadraticEquation(unittest.TestCase):
def setUp(self):
print "setup"
self.eq = QuadraticEquation.QuadraticEquation()
def test_calc_root(self):
""" test method of s"""
expected = (-1.0, -1.0)
actual = self.eq.calc_root()
self.assertEqual(expected, actual)
self.assertEqual((0.0, 0.0), (self.eq.calc_value(actual[0]), self.eq.calc_value(actual[1])))
def test_calc_value(self):
""" test method of calc_value() """
expected = (4.0, 9.0)
actual = (self.eq.calc_value(1.0), self.eq.calc_value(2.0))
self.assertEqual(expected, actual)
def tearDown(self):
print "tearDown"
del self.eq
if __name__ == '__main__':
unittest.main()
Wenn dies ausgeführt wird, ist ersichtlich, dass die Methoden setUp und tearDown zu Beginn und am Ende des Testfalls aufgerufen werden, wie unten gezeigt.
$ python -m unittest test_quadraticEquation
setup
tearDown
.setup
tearDown
.
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
In Wirklichkeit denke ich, dass dies der Fall ist, wenn es mehrere Module gibt, die Sie explizit erstellen und Unit-Tests testen müssen. In diesem Fall können Sie nicht viele Testmodule einfach von Hand treffen.
In diesem Fall können Sie die Discovery-Funktion von unittest verwenden.
$ python -m unittest discover
Angesichts der beiden oben genannten Testfälle
$ ls
QuadraticEquation.py keisan.py test_keisan.py test_quadraticEquation.py
Mit der obigen Entdeckung sieht es so aus: Alle Tests wurden durchgeführt.
$ python -m unittest discover
....
----------------------------------------------------------------------
Ran 4 tests in 0.000s
OK
[Unvollendet]
Möglicherweise möchten Sie die Testabdeckungsrate messen, dies ist jedoch wahrscheinlich kein Merkmal von unittest. Damit Verwenden Sie die Abdeckung.
$ pip install coverage
Sie können dies verwenden, um die Abdeckung eines bestimmten Moduls zu messen oder es in eine HTML-Datei umzuwandeln ... Aber viel zu tun Sie müssen das Skript selbst schreiben.
Da es Nasentests gibt, ist es besser, sie zu verwenden (Werfen)
Auszug aus dem Beamten. Fast gleich ist auch nützlich für den Vergleich von Floats. Dies ist nicht alles, bitte beziehen Sie sich auf die Formel.
| ASSER-Methodentyp | Ziel überprüfen |
|---|---|
| assertEqual(a, b) | a == b |
| assertNotEqual(a, b) | a != b |
| assertTrue(x) | bool(x) is True |
| assertFalse(x) | bool(x) is False |
| assertIs(a, b) | a is b |
| assertIsNot(a, b) | a is not b |
| assertIsNone(x) | x is None |
| assertIsNotNone(x) | x is not None |
| assertIn(a, b) | a in b |
| assertNotIn(a, b) | a not in b |
| assertIsInstance(a, b) | isinstance(a, b) |
| assertNotIsInstance(a, b) | not isinstance(a, b) |
| assertAlmostEqual(a, b) | round(a-b, 7) == 0 |
| assertNotAlmostEqual(a, b) | round(a-b, 7) != 0 |
| assertGreater(a, b) | -a > b |
| assertGreaterEqual(a, b) | a >= b |
| assertLess(a, b) | a < b |
| assertLessEqual(a, b) | a <= b |
| assertRegexpMatches(s, r) | r.search(s) |
| assertNotRegexpMatches(s, r) | not r.search(s) |
| assertDictContainsSubset(a, b) | all the key/value pairs in a exist in b |
references Unten finden Sie Referenzen und Websites.
Recommended Posts