Kurs Python richtig lernen/Unit Testing: Unterschied zwischen den Versionen

Aktuelle Version vom 17. Januar 2013, 16:08 Uhr

Zurück zum Kurs Python richtig lernen#Uebungen.

Übung "Unit Testing mit Python und Nose"

In dieser Übung lernen Sie Unit Testing mit dem Python Test Runner Nose.

Geschätzter Zeitaufwand für diese Übung: ca. 2h.

Voraussetzungen: Python & Nose (Python Library) installiert.

Einstieg

Um Nose kennenzulernen starten wir mit einem Beispiel. Speichern Sie den folgenden Unit test in einem File "test_42.py":

def test_life_the_universe_and_everything():
    assert 42 == 42

Führen Sie diesen Test wie folgt aus:

$ nosetests

Als Output bekommen Sie eine kleine Statistik inkl. dem Fehlerstatus (OK/NOK). Möchten Sie detailliertere Infos (welche Tests durchgeführt wurden), dann verwenden Sie die Option -v für verbose (en. für "gesprächig").

Wie Sie sehen, müssen wir nirgends angeben, welche Funktionen und Module Nose als Testfunktionen betrachtet. Für Funktionen und Module gibt es eine einfache Namenskonvention (Abmachung), wobei verlangt wird, dass der Filename mit test oder Test beginnen muss (die exakte Definition ist eine Regular Expression und sieht so aus: ((?:^|[b_.-])[Tt]est)).

Manchmal benötigen Sie für Ihre Unit Tests Fixtures. Diese können Sie wie folgt definieren:

def test_life_the_universe_and_everything():
    assert 42 != 42
 
def setUp(): print "Setup"
def tearDown(): print "tearDown"

test_life_the_universe_and_everything.setUp = setUp
test_life_the_universe_and_everything.tearDown = tearDown

Führen Sie dieses Beispiel aus und verifizieren Sie, dass die Ausgaben Ihren Erwartungen entsprechen (setup, failing test, teardown).

Nose erlaubt es Ihnen - neben Testfunktionen - Ihre Tests auch innerhalb einer Klasse zu schreiben (gemäss Unit Testing Konvention 'xUnit', hier bei Python unittest). Das gleiche Beispiel wie vorhin:

class Test42:
    def setUp(self): 
        print "Setup"

    def tearDown(self):
        print "tearDown"

    def test_life_the_universe_and_everything(self):
        assert 42 != 42

Tip: Wundern Sie sich nicht, wenn Sie Ausgaben in Ihren Unit Tests mit print nicht auf Ihrer Konsole sehen. Nose fängt alle Ausgaben auf stdout auf und zeigt diese nur bei fehlgeschlagenen Tests an. Dieses Verhalten kann mit der Option -s unterbunden werden.

Um das Werfen von Exceptions testen zu können, benutzen Sie folgende Nose Decoration (siehe die Zeile mit @):

 from nose.tools import raises

 @raises(ValueError)
 def test_rational_zero_denominator_raises_error():
     r = Rational(3, 0)

Weitere Informationen zu Nose finden Sie hier.

Aufgabe 1 - Bank Account

Testen Sie folgenden Code mit Nose (denken Sie auch an das Testen von Exceptions):

class BankAccount(object):
    def __init__(self, initial_balance=0):
        self.balance = initial_balance 
    
    def deposit(self, amount):
        self.balance += amount      

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError('Amount is higher than current balance')
        self.balance -= amount

Aufgabe 2 - Rationale Zahlen

Testen Sie folgenden Code mit Nose (denken Sie auch an das Testen von Exceptions):

def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)


class Rational(object):
    
    def __init__(self, n, d):
        if d == 0:
            raise ValueError("Denominator must not be zero.")
        else:
            g = gcd (n, d)
            self.n = n / g
            self.d = d / g
           
    def __add__(self, other):
        return Rational(self.n * other.d + other.n * self.d,
                        self.d * other.d)
       
    def __sub__(self, other):
        return Rational(self.n * other.d - other.n * self.d,
                        self.d * other.d)
       
    def __mul__(self, other):
        return Rational(self.n * other.n, self.d * other.d)
   
    def __div__(self, other):
        return Rational(self.n * other.d, self.d * other.n)
   
    def __str__(self):
        return "%d/%d" % (self.n, self.d)
   
    def __float__(self):
        return float(self.n) / float(self.d)
    
    def __eq__(self, other):
        if self is other:
            return True
        elif type(self) != type(other):
            return False
        else:
            return self.n == other.n and self.d == other.d
        
    def __ne__(self, other):
        return not self.__eq__(other)