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

# car.py - Eine einfache Car-Klasse zur Demonstration, wie man Unit-Tests schreibt
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

# test_car.py - Unit-Tests für die Car-Klasse
# 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

  1. Öffnen SieSettings(Tastaturkürzel: Ctrl + Alt + S oder Command + , unter macOS).
  2. Navigieren Sie zu Python。
  3. Gehen Sie zum AbschnittIntegrierte Toolsund suchen Sie das Dropdown-MenüTesting.
  4. vonUnittests、pytest、NosetestsWählen Sie das benötigte Framework aus.
  5. 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