$ pip install nose
Abhängig von Ihrer Umgebung benötigen Sie möglicherweise Sudo.
Angenommen, Sie haben die folgende Funktionssumme und die Funktion is_even in einem Modul namens hoge.
hoge.py
def sum(a, b):
return a + b
def is_even(n):
return (n % 2 == 0)
Erstellen Sie die folgende Datei test_hoge.py, die unittest.TestCase erbt.
Hier werden eq_, um zu überprüfen, ob der Wert mit dem erwarteten ** Wert ** übereinstimmt, und ok_, um zu überprüfen, ob der Wert ** true ** ist, aus nas.tools importiert und verwendet. Ich werde.
Als üblicher Mechanismus im Testframework werden "setUp" und "tearDown" für die Verarbeitung bereitgestellt, z. B. für die Initialisierung / Ressourcenfreigabe vor und nach dem Test. Versuchen Sie daher, eine print-Anweisung einzufügen.
test_hoge.py
from unittest import TestCase
from nose.tools import ok_, eq_
from hoge import sum, is_even
class HogeTestCase(TestCase):
def setUp(self):
print 'before test'
def tearDown(self):
print 'after test'
def test_sum(self):
eq_(sum(1, 2), 3)
eq_(sum(5, 11), 16)
eq_(sum(0, 0), 0)
def test_is_even(self):
ok_(is_even(2))
ok_(not is_even(3))
Nase kommt mit einem Test-Runner-Befehl namens Nosetests. (Pip Install Nase wird es installieren) Wenn Sie hier Nosetests ausführen, ist dies wie folgt.
$ nosetests
..
----------------------------------------------------------------------
Ran 2 tests in 0.003s
OK
Wenn nosetests ausgeführt wird, sucht es im aktuellen Verzeichnis nach testähnlichen Dateien (einschließlich Test im Dateinamen) und sammelt und führt Klassen aus, die unittest.TestCase erben.
Ich habe nicht die Nachricht erhalten, die ich mit der print-Anweisung hätte drucken sollen, da die Nase standardmäßig die Ausgabe auf die Standardausgabe erfasst.
Sie können die Ausgabe so sehen, wie sie ist, mit der Option -s.
$ nosetests -s
Fügen Sie die Option -v hinzu, um den Namen des Testfalls, der ausgeführt wird, anhand des Methodennamens sowie des Punkts anzuzeigen.
$ nosetests -v
Als ich versuchte, es zusammen auszuführen, wurde es wie folgt.
$ nosetests -s -v
test_is_even (test_hoge.HogeTestCase) ... before test
after test
ok
test_sum (test_hoge.HogeTestCase) ... before test
after test
ok
----------------------------------------------------------------------
Ran 2 tests in 0.002s
OK
Sie können auch einen Dateinamen für den Befehl nosetests angeben, um nur Tests für bestimmte Dateien auszuführen. Es wäre praktisch, wenn die Entwicklung voranschreiten und die Tests zunehmen würden.
$ nosetests ./test_hoge.py
Hier sind einige andere Testwerkzeuge für ok_ und eq_. Weitere Informationen finden Sie auf der Seite mit den Testtools von Nase (http://nose.readthedocs.org/en/latest/testing_tools.html).
raises
Verwenden Sie "Erhöhungen" als Dekorateur für Tests, die wahrscheinlich Ausnahmen verursachen.
Testen Sie die folgende Funktion div, bei der wahrscheinlich eine Ausnahme auftritt.
fuga.py
def div(n, m):
return n / m
Der Testfall ist unten.
fuga_hoge.py
from unittest import TestCase
from nose.tools import eq_, raises
from fuga import div
class FugaTestCase(TestCase):
def test_div(self):
eq_(div(10, 5), 2)
eq_(div(10, 10), 1)
eq_(div(9, 3), 3)
@raises(ZeroDivisionError)
def test_div_zerodiv(self):
div(10, 0)
Jetzt können Sie überprüfen, ob der Testfall test_div_zerodiv die Ausnahme ZeroDivisionError ordnungsgemäß auslöst.
timed
timed ist ein Dekorateur, der prüft, ob ein Testfall innerhalb einer bestimmten Zeitspanne (in Sekunden angegeben) abgeschlossen ist.
Stellen Sie sich einen Test vor, der überprüft, ob eine Funktion "do_something", deren Verarbeitung etwa 0,1 Sekunden dauert, innerhalb von 0,2 Sekunden abgeschlossen ist, z.
moge.py
import time
def do_something():
time.sleep(0.1)
Der Testfall sieht folgendermaßen aus:
test_moge.py
from unittest import TestCase
from nose.tools import timed
from moge import do_something
class MogeTestCase(TestCase):
@timed(0.2)
def test_do_something(self):
do_something()
Für Programme, die gevent verwenden, wird empfohlen, die folgenden Dekoratoren zu verwenden.
gtest Dekorateur
import gevent
def gtest(func):
def _gtest(*args, **kwargs):
gevent.spawn(func, *args, **kwargs).join()
_gtest.__name__ = func.__name__
return _gtest
Testen wir ein Programm wie das folgende. _tick und _tacik bewegen sich abwechselnd, senden abwechselnd nummerierte Zeichenketten wie tick1, Tack1, Tick2, Tack2 an die Warteschlange und saugen schließlich den gesamten Inhalt aus der Warteschlange heraus und geben ihn als Array zurück Werde dir geben.
g.py
import gevent
import gevent.queue
def ticktack(n):
q = gevent.queue.Queue()
def _tick(_q, _n):
for i in range(_n):
_q.put('tick%d' % (i + 1))
gevent.sleep()
def _tack(_q, _n):
for i in range(_n):
_q.put('tack%d' % (i + 1))
gevent.sleep()
_tick_thread = gevent.spawn(_tick, q, n)
_tack_thread = gevent.spawn(_tack, q, n)
result = []
while len(result) < n * 2:
result.append(q.get())
return result
Da gevent beim Aufruf von gevent.sleep () einen entscheidenden Greenlet-Schalter ausführt, werden immer zuerst das erzeugte _tick und später das erzeugte _tack aufgerufen.
Lassen Sie uns dies mit dem Dekorateur oben testen.
test_g.py
from unittest import TestCase
from nose.tools import eq_
import gevent
from g import ticktack
import gevent
def gtest(func):
def _gtest(*args, **kwargs):
gevent.spawn(func, *args, **kwargs).join()
_gtest.__name__ = func.__name__
return _gtest
class GTestCase(TestCase):
@gtest
def test_ticktack(self):
r1 = ticktack(1)
eq_(r1, ['tick1', 'tack1'])
r2 = ticktack(2)
eq_(r2, ['tick1', 'tack1', 'tick2', 'tack2'])
Hast du dich gut gefühlt
--nose macht es einfach und leicht, Testfälle zu schreiben --nosetests bietet verschiedene Optionen und kann flexibel ausgeführt werden
Ich hoffe, es hilft.
Recommended Posts