PyCharm-Unit-Testing
Unit-Tests sind ein grundlegendes Mittel zur Sicherung der Codequalität; sie überprüfen, ob das Verhalten der kleinsten testbaren Einheit in einem Programm den Erwartungen entspricht.
Das Schreiben und Ausführen von Unit-Tests in PyCharm ist sehr praktisch; die IDE bietet einen vollständigen Workflow von der Testerstellung bis zur Ausführung und Ergebnisanalyse.
PyCharm bietet integrierte Unterstützung für drei gängige Python-Testframeworks:unittest、pytestundnose。
Testbeispiele schreiben
Das folgende vollständige Beispiel zeigt, wie man Unit-Tests in PyCharm schreibt.
Zuerst erstellen wir eine einfacheCar-Klasse und schreiben dann Testfälle dafür.
Zu testender Code: car.py
Beispiel
class Car:
"""Simuliert eine Auto-Klasse mit Beschleunigungs- und Bremsfunktionen."""
def __init__(self, make="example", model="EXAMPLE-X1"):
# Automarke und Modell initialisieren
self.make = make
self.model = model
# Anfangsgeschwindigkeit ist 0
self.speed = 0
def accelerate(self, increment):
"""Beschleunigungsmethode.
Parameter:
increment: Geschwindigkeitszuwachs, muss eine positive ganze Zahl sein
Rückgabe:
Die aktuelle Geschwindigkeit nach der Beschleunigung
Ausnahmen:
ValueError: wird ausgelöst, wenn increment negativ oder null ist
"""
if increment <= 0:
raise ValueError("Das Beschleunigungsinkrement muss positiv sein")
self.speed += increment
return self.speed
def brake(self, decrement):
"""Bremsmethode.
Parameter:
decrement: Verzögerungsbetrag, muss eine positive Ganzzahl sein
Rückgabe:
Die aktuelle Geschwindigkeit nach dem Bremsen, mindestens 0
Ausnahmen:
ValueError: wird ausgelöst, wenn decrement negativ oder null ist
"""
if decrement <= 0:
raise ValueError("Der Verzögerungsbetrag muss positiv sein")
self.speed = max(0, self.speed - decrement)
return self.speed
Testcode: test_car.py
Beispiel
# Testfälle mit dem unittest-Framework schreiben
import unittest
from car import Car
class TestCar(unittest.TestCase):
"""Testsuite für die Car-Klasse."""
def setUp(self):
"""setUp wird vor jeder Testmethode aufgerufen, um eine brandneue Car-Instanz zu erstellen."""
self.car = Car()
def test_initial_speed(self):
"""Testet, ob die Anfangsgeschwindigkeit 0 ist."""
self.assertEqual(self.car.speed, 0,
"Die Anfangsgeschwindigkeit des neuen Autos sollte 0 sein")
def test_accelerate_normal(self):
"""Testet ein normales Beschleunigungsszenario."""
# Um 50 beschleunigen
result = self.car.accelerate(50)
# Rückgabewert überprüfen
self.assertEqual(result, 50,
"Die Geschwindigkeit nach der Beschleunigung sollte 50 sein")
# Objektzustand überprüfen
self.assertEqual(self.car.speed, 50,
"Das Attribut car.speed sollte auf 50 aktualisiert werden")
def test_accelerate_multiple_times(self):
"""Testet den kumulativen Effekt mehrerer Beschleunigungen."""
# Erste Beschleunigung um 30
self.car.accelerate(30)
# Zweite Beschleunigung um 20
result = self.car.accelerate(20)
# Die Gesamtgeschwindigkeit sollte 50 betragen
self.assertEqual(result, 50,
"Die Geschwindigkeit nach zwei Beschleunigungen sollte 50 betragen")
def test_accelerate_with_zero(self):
"""Testet, dass eine Ausnahme ausgelöst wird, wenn der Beschleunigungszuwachs 0 ist."""
with self.assertRaises(ValueError,
msg="Ein Beschleunigungszuwachs von 0 sollte ValueError auslösen"):
self.car.accelerate(0)
def test_accelerate_negative(self):
"""Testet, dass eine Ausnahme ausgelöst wird, wenn der Beschleunigungszuwachs negativ ist."""
with self.assertRaises(ValueError,
msg="Ein negatives Beschleunigungsinkrement sollte ValueError auslösen"):
self.car.accelerate(-10)
def test_brake_normal(self):
"""Test eines normalen Bremsvorgangs."""
# Zuerst auf 80 beschleunigen
self.car.accelerate(80)
# Um 30 bremsen
result = self.car.brake(30)
# Die Geschwindigkeit überprüfen
self.assertEqual(result, 50,
"Die Geschwindigkeit nach dem Bremsen sollte 50 sein")
def test_brake_below_zero(self):
"""Testet, dass das Bremsen die Geschwindigkeit nicht unter 0 fallen lässt."""
# Zuerst auf 20 beschleunigen
self.car.accelerate(20)
# Um 50 bremsen, die Geschwindigkeit sollte auf 0 begrenzt werden
result = self.car.brake(50)
self.assertEqual(result, 0,
"Die Geschwindigkeit darf nicht unter 0 liegen")
def test_brake_with_zero(self):
"""Testet, dass eine Ausnahme ausgelöst wird, wenn der Verzögerungsbetrag 0 ist."""
with self.assertRaises(ValueError,
msg="Ein Verzögerungsbetrag von 0 sollte ValueError auslösen"):
self.car.brake(0)
# Tests ausführen, wenn das Skript direkt ausgeführt wird
if __name__ == "__main__":
unittest.main()

PyCharm kann Testklassen und Testmethoden automatisch erkennen. Testklassennamen beginnen mitTestund Testmethodennamen beginnen mittest_Dies ist die Python-Test-Namenskonvention.
Tests ausführen
Nach dem Schreiben des Testcodes gibt es mehrere Möglichkeiten, die Tests auszuführen.
Methode 1: Klicken Sie auf das grüne Ausführen-Symbol
PyCharm zeigt im linken Gutter-Bereich neben der Testklasse und jeder Testmethodeein grünes Ausführen-Symbol an.。
Wenn Sie auf das grüne Symbol neben dem Klassennamen klicken, werden alle Tests in dieser Klasse ausgeführt, während ein Klick auf das Symbol neben einer Methode nur diesen einzelnen Test ausführt.
Sie können auch mit der rechten Maustaste auf die Testdatei klicken und aus dem MenüRun 'test_car' auswählen。
Methode 2: Tastaturkürzel verwenden
Platzieren Sie den Cursor in der Testklasse oder Testmethode und drücken SieCtrl + Shift + F10, um den aktuellen Test auszuführen.
Testergebnisse anzeigen
Nach Abschluss des Testlaufs zeigt PyCharm im unterenRun-Tool-Fensterdie Testergebnisse in einerBaumansicht an.
Bestandene Tests werden mit einem grünen Häkchen markiert, fehlgeschlagene Tests mit einem roten Kreuz, zusammen mit detaillierten Fehlermeldungen und Stack-Traces.
Wenn Sie auf einen fehlgeschlagenen Testeintrag klicken, springt PyCharm direkt zu der Codezeile, in der der Fehler aufgetreten ist, sodass Sie das Problem schnell finden können.
Test-Frameworks wechseln
PyCharm verwendet standardmäßigunittestals Test-Runner, aber Sie können problemlos zu anderen Frameworks wechseln.
Konfigurationsschritte
- Öffnen SieSettings(Tastaturkürzel: Ctrl + Alt + S oder Command + , unter macOS).
- Navigieren Sie zu Python。
- Gehen Sie zum AbschnittIntegrierte Toolsund suchen Sie das Dropdown-MenüTesting.
- vonUnittests、pytest、NosetestsWählen Sie das benötigte Framework aus.
- Klicken Sie aufOK, um die Einstellungen zu speichern.

Wenn Sie pytest als Test-Runner auswählen, stellen Sie sicher, dass Sie das pytest-Paket mitpip install pytestinstalliert haben.
Tipps zur testgetriebenen Entwicklung
Unit-Tests werden nicht nur verwendet, um vorhandenen Code zu überprüfen; sie sind auch dieTest-Driven Development (TDD)Kernpraxis.
Der empfohlene Entwicklungsprozess besteht darin, zuerst Testfälle zu schreiben, dann den Implementierungscode zu schreiben und schließlich durch bestandene Tests zu verifizieren.
Entwickeln Sie die Gewohnheit, Tests zu schreiben, und Ihre Codequalität wird deutlich verbessert.
Andere Erweiterungen