Unit Testing in Python Tutorial

Unit Testing ist eine Softwaretestmethode, bei der einzelne Einheiten des Quellcodes verschiedenen Tests unterzogen werden, um festzustellen, ob sie brauchbar sind. Sie bestimmt und prüft die Qualität deines Codes.

Wenn der Entwicklungsprozess abgeschlossen ist, kodiert der Entwickler in der Regel Kriterien oder Ergebnisse, von denen bekannt ist, dass sie potenziell praktisch und nützlich sind, in das Testskript, um die Korrektheit einer bestimmten Einheit zu überprüfen. Während der Ausführung von Testfällen protokollieren verschiedene Frameworks Tests, die ein Kriterium nicht erfüllen, und melden sie in einer Zusammenfassung.

Von den Entwicklern wird erwartet, dass sie automatisierte Testskripte schreiben, die sicherstellen, dass jeder einzelne Abschnitt oder jede Einheit ihrem Design entspricht und sich wie erwartet verhält.

Python Unit Testing

Obwohl das Schreiben von manuellen Tests für deinen Code definitiv eine mühsame und zeitaufwändige Aufgabe ist, hat das in Python eingebaute Unit-Testing-Framework das Leben um einiges einfacher gemacht.

Das Unit-Test-Framework in Python heißt unittest und wird mit Python mitgeliefert.

Unit-Tests machen deinen Code zukunftssicher, da du die Fälle vorhersiehst, in denen dein Code möglicherweise versagen oder einen Fehler produzieren könnte. Du kannst zwar nicht alle Fälle vorhersagen, aber die meisten davon kannst du trotzdem angehen.

Eine Einheit kann in verschiedene Kategorien eingeteilt werden:

• Ein ganzes Modul,
• Eine individuelle Funktion,
• Eine vollständige Schnittstelle wie eine Klasse oder eine Methode.

Am besten schreibst du Unit-Tests für deinen Code, indem du mit der kleinsten testbaren Einheit beginnst, die dein Code haben könnte, und dann zu anderen Einheiten übergehst, um zu sehen, wie diese kleinste Einheit mit anderen Einheiten interagiert.

Pythons Unit-Testing-Framework wurde von Javas JUnit inspiriert und hat ähnliche Funktionen wie die wichtigsten Unit-Testing-Frameworks in anderen Sprachen. Das Python-Framework für Unit-Tests bietet verschiedene Funktionendarunter:

• Testautomatisierung
• Gemeinsame Nutzung von Einrichtungs- und Abschaltcode für Tests
• Tests in Sammlungen zusammenfassen
• Unabhängigkeit der Tests vom Berichtsrahmen

Nehmen wir nun ein Beispiel, um zu verstehen, warum du Unit-Tests für deinen Code brauchst.

Erste Schritte mit Python unittest

Im Folgenden haben wir die Schritte zusammengefasst, die du brauchst, um das Python-Framework unittest zu nutzen

Erstellen einer Würfelfunktion

Lass uns einen Code schreiben, um das Volumen eines Würfels in Python zu berechnen

def cuboid_volume(l):
    return (l*l*l)
length = [2,1.1, -2.5, 2j, 'two']
for i in range(len(length)):
    print ("The volume of cuboid:",cuboid_volume(length[i]))

The volume of cuboid: 8
The volume of cuboid: 1.3310000000000004
The volume of cuboid: -15.625
The volume of cuboid: (-0-8j)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-7-67e1c37a435f> in <module>
      1 for i in range(len(length)):
----> 2     print ("The volume of cuboid:",cuboid_volume(length[i]))
<ipython-input-2-f50464fd88da> in cuboid_volume(l)
      1 def cuboid_volume(l):
----> 2     return (l*l*l)
TypeError: can't multiply sequence by non-int of type 'str'

Ergebnisanalyse

Die obige Ausgabe sollte dir ein Gefühl dafür geben, wie wichtig es ist, einen Unit-Test für deinen Code zu haben. Nun gibt es drei Dinge, die in dem obigen Code sicherlich falsch sind:

• Erstens: Das Volumen des Quaders ist negativ,
• Zweitens: Das Volumen des Quaders ist eine komplexe Zahl,
• Schließlich führt der Code zu TypeError, da du eine Zeichenkette nicht multiplizieren kannst, da sie keine Inte ist.

Die dritte Aufgabe führte glücklicherweise zu einem Fehler, während die erste und zweite Aufgabe noch erfolgreich waren, obwohl das Volumen des Quaders nicht negativ und eine komplexe Zahl sein kann.

Unit-Tests werden in der Regel als separater Code in einer anderen Datei geschrieben, und es kann verschiedene Namenskonventionen geben, denen du folgen kannst. Du kannst den Namen der Unit-Test-Datei entweder als name of the code/unit + test, getrennt durch einen Unterstrich, oder als test + name of the code/unit, getrennt durch einen Unterstrich, schreiben.

Nehmen wir zum Beispiel an, der Name der obigen Codedatei lautet cuboid_volume.py, dann könnte der Name deines Unit-Test-Codes lauten cuboid_volume_test.py

Schreiben wir nun kurzerhand den Unit-Test für den obigen Code.

assertAlmostEqual verwenden

Zuerst erstellen wir eine Python-Datei mit dem Namen volume_cuboid.py, die den Code für die Berechnung des Volumens enthält, und eine zweite mit dem Namen test_volume_cuboid.py, die den Unit-Testing-Code enthält.

import unittest

Die Klasse TestCuboid erbt das Modul unittest, und in dieser Klasse würdest du verschiedene Methoden definieren, die dein Einheitstest mit deiner Funktion cuboid_volume überprüfen soll.

Die erste Funktion, die du definieren wirst, ist test_volume. Sie prüft, ob die Ausgabe deiner cuboid_volume mit dem übereinstimmt, was du erwartest. Um dies zu erreichen, nutzt du die Methode assertAlmostEqual.

Test 1

class TestCuboid(unittest.TestCase):
    def test_volume(self):
        self.assertAlmostEqual(cuboid_volume(2),8)
        self.assertAlmostEqual(cuboid_volume(1),1)
        self.assertAlmostEqual(cuboid_volume(0),0)
        self.assertAlmostEqual(cuboid_volume(5.5),166.375)

Lass uns das obige Skript ausführen. Du führst das Modul unittest als Skript aus, indem du -m angibst , während du es ausführst.

!python -m unittest test_volume_cuboid.py

Ausgabe:

.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK

Toll! Du hast also deinen ersten Unit-Test-Code zum Laufen gebracht.

Der Test verlief erfolgreich und lieferte OK, was bedeutet, dass die Funktion cuboid_volume so funktioniert, wie du es erwartest.

Test 2

Mal sehen, was passiert, wenn eine der assertAlmostEqual Methoden fehlschlägt.

Beachte, dass die letzte Assert-Anweisung geändert wurde.

!python -m unittest test_volume_cuboid.py

Ausgabe:

F
======================================================================
FAIL: test_volume (test_volume_cuboid.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "C:\Users\hda3kor\Documents\Unit_Testing_Python\test_volume_cuboid.py", line 15, in test_volume
    self.assertAlmostEqual(cuboid_volume(5.5),0)
AssertionError: 166.375 != 0 within 7 places (166.375 difference)
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)

Aus der obigen Ausgabe kannst du ersehen, dass die letzte Assert-Anweisung zu einem AssertionError geführt hat, also ein Fehlschlag des Einheitstests. Pythons Unit-Test-Modul zeigt dir den Grund für den Fehler und die Anzahl der Fehler in deinem Code an.

assertRaises verwenden

Jetzt wollen wir uns eine andere Assert-Methode ansehen, nämlich assertRaises, mit der du herausfinden kannst, ob deine Funktion cuboid_volume die Eingabewerte richtig verarbeitet.

Angenommen, du möchtest testen, ob deine Funktion cuboid_volume die Klasse oder den Typ der Eingabe behandelt. Wenn du zum Beispiel eine Zeichenkette als Eingabe übergibst, wird sie diese Eingabe entweder als Ausnahme oder mit einer Wenn-Bedingung behandeln, da die Länge des Quaders niemals eine Zeichenkette sein kann.

!python -m unittest test_volume_cuboid.py

Ausgabe:

F.
======================================================================
FAIL: test_input_value (test_volume_cuboid.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "C:\Users\hda3kor\Documents\Unit_Testing_Python\test_volume_cuboid.py", line 17, in test_input_value
    self.assertRaises(TypeError, cuboid_volume, True)
AssertionError: TypeError not raised by cuboid_volume
----------------------------------------------------------------------
Ran 2 tests in 0.001s
FAILED (failures=1)

Toll! Aus der obigen Ausgabe geht also hervor, dass dein Code volume_cuboid.py die übergebenen Eingaben nicht richtig verarbeitet.

Ändern der Würfelfunktion

Fügen wir eine Bedingung in die volume_cuboid.py ein, um zu prüfen, ob die Eingabe oder die Länge des Quaders ein Boolean oder ein String ist und einen Fehler auszulösen.

!python -m unittest test_volume_cuboid.py

Ausgabe:

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s
OK

Ausführen des Python-Prüfskripts im Jupyter-Labor

Lass uns nun das Testskript im Jupyter-Labor ausführen. Um dies zu erreichen, musst du zunächst das Testskript im Jupyter-Labor definieren, wie unten gezeigt.

# -*- coding: utf-8 -*-
"""
Created on Sat Apr 25 20:16:58 2020
@author: Aditya
"""
from volume_cuboid import *
import unittest
class TestCuboid(unittest.TestCase):
    def test_volume(self):
        self.assertAlmostEqual(cuboid_volume(2),8)
        self.assertAlmostEqual(cuboid_volume(1),1)
        self.assertAlmostEqual(cuboid_volume(0),1)
    def test_input_value(self):
        self.assertRaises(TypeError, cuboid_volume, True)

Dann verwendest du die Methode unittest.main(), um das Testskript auszuführen. Du kannst der folgenden Methode mehrere Argumente übergeben, von denen eines verbosity level ist.

Lass uns mit verschiedenen Ausführlichkeitsgraden experimentieren und sehen, wie sich die Beschreibung der Ausgabe verändert.

Ausführlichkeit 0

unittest.main(argv=[''],verbosity=0, exit=False)
Output:
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK
<unittest.main.TestProgram at 0x1de02774348>

Mündlichkeit 1

unittest.main(argv=[''],verbosity=1, exit=False)
Output:
..
----------------------------------------------------------------------
Ran 2 tests in 0.002s
OK
<unittest.main.TestProgram at 0x1de027a1cc8>

Wortgewandtheit 2

unittest.main(argv=[''],verbosity=2, exit=False)
Output:
test_input_value (__main__.TestCuboid) ... ok
test_volume (__main__.TestCuboid) ... ok
----------------------------------------------------------------------
Ran 2 tests in 0.002s
OK
<unittest.main.TestProgram at 0x1de027a8308>

Visualisierung des AssertionError

Ändern wir zum Schluss die letzte assertAlmostEqual in der Methode test_volume und analysieren wir, wie die Ausführlichkeitsstufe 2 das Scheitern der Methode anzeigt.

# -*- coding: utf-8 -*-
"""
Created on Sat Apr 25 20:16:58 2020
@author: Aditya
"""
from volume_cuboid import *
import unittest
class TestCuboid(unittest.TestCase):
    def test_volume(self):
        self.assertAlmostEqual(cuboid_volume(2),8)
        self.assertAlmostEqual(cuboid_volume(1),1)
        self.assertAlmostEqual(cuboid_volume(0),1)
    def test_input_value(self):
        self.assertRaises(TypeError, cuboid_volume, True)
unittest.main(argv=[''],verbosity=2, exit=False)

Ausgabe:

test_input_value (__main__.TestCuboid) ... ok
test_volume (__main__.TestCuboid) ... FAIL
======================================================================
FAIL: test_volume (__main__.TestCuboid)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "<ipython-input-28-46ad33b909ee>", line 14, in test_volume
    self.assertAlmostEqual(cuboid_volume(0),1)
AssertionError: 0 != 1 within 7 places (1 difference)
----------------------------------------------------------------------
Ran 2 tests in 0.003s
FAILED (failures=1)
<unittest.main.TestProgram at 0x1de027b5448>

Zusammenfassung

Aus den oben genannten Ergebnissen lassen sich die folgenden Schlussfolgerungen ziehen:

• Die Ausführlichkeitsstufe 0 zeigt nur an, wie viele Tests durchgeführt wurden, z. B. 2 Tests und die Zeit, die für die Durchführung benötigt wurde,
• Verbositätsstufe 1 zwei Punkte hinzufügen .. was bedeutet, dass zwei Tests durchgeführt wurden,
• Verbosity Level 2 zeigt die detaillierten Methodennamen, die zusammen mit ihrem Status ausgeführt wurden OK oder FAIL.

Verfügbare unittest Assert-Methoden

Es gibt eine Menge Assert-Methoden im Unit-Test-Modul von Python, die du für deine Tests nutzen kannst.

Häufig verwendete Durchsetzungsmethoden

Quelle: Unittest-Dokumentation

 Produktionskontrollen

Mit den folgenden Methoden kannst du die Produktion von Ausnahmen, Warnungen und Protokollmeldungen überprüfen.

Quelle: Unittest-Dokumentation

 Aufgabenspezifische Methoden

Quelle: Unittest-Dokumentation

Detaillierte Informationen über die Methoden von assert findest du in der Python offiziellen Dokumentation.

Du kannst sie auch mit Hilfe des Moduls Pydoc kennenlernen, das einer help Funktion in Python ähnelt. Im Folgenden wird gezeigt, wie du das Modul Pydoc verwenden kannst, um die Dokumentation der Methode assertCountEqual zu lesen.

!python -m pydoc unittest.TestCase.assertCountEqual

Ausgabe:

Help on function assertCountEqual in unittest.TestCase:
unittest.TestCase.assertCountEqual = assertCountEqual(self, first, second, msg=None)
    An unordered sequence comparison asserting that the same elements,
    regardless of order.  If the same element occurs more than once,
    it verifies that the elements occur the same number of times.
        self.assertEqual(Counter(list(first)),
                         Counter(list(second)))
     Example:
        - [0, 1, 1] and [1, 0, 1] compare equal.
        - [0, 0, 1] and [0, 1] compare unequal.

Fazit

Dieses Tutorial war eine grundlegende Einführung in das Unit Testing in Python und seine Bedeutung als Entwickler. Eine gute Übung für dich wäre es, ein Unit-Test-Modul für eines deiner früheren Projekte zu schreiben. So bekommst du eine gute praktische Erfahrung mit dem Schreiben von Unit-Tests. Versuche auch, die anderen Assert-Methoden zu erkunden. Mehr über Unit-Tests kannst du in unserem Pytest-Anleitung.

Wenn du gerade erst mit Python anfängst und mehr erfahren möchtest, besuche unsere Einführung in die Datenwissenschaft in Python Kurs.