Tests unitaires PyCharm

Les tests unitaires sont un moyen fondamental de garantir la qualité du code ; ils vérifient si le comportement de la plus petite unité testable d'un programme correspond aux attentes.

Écrire et exécuter des tests unitaires dans PyCharm est très pratique ; l'IDE fournit un flux de travail complet, de la création des tests à l'exécution et à l'analyse des résultats.

PyCharm prend en charge nativement trois frameworks de test Python courants :unittest、pytestetnose。

Écrire des exemples de tests

L'exemple complet suivant montre comment écrire des tests unitaires dans PyCharm.

D'abord, nous créons uneCarclasse simple, puis nous écrivons des cas de test pour celle-ci.

Code à tester : car.py

Exemple

# car.py - Une simple classe Car pour démontrer comment écrire des tests unitaires
class Car:
    """Simule une classe de voiture, fournissant des fonctions d'accélération et de freinage."""

    def __init__(self, make="example", model="EXAMPLE-X1"):
        # Initialiser la marque et le modèle de la voiture
        self.make = make
        self.model = model
        # La vitesse initiale est 0
        self.speed = 0

    def accelerate(self, increment):
        """Méthode d'accélération.
Paramètres :
increment: incrément de vitesse, doit être un entier positif
Retourne :
La vitesse actuelle après accélération
Lève :
ValueError : levée lorsque increment est négatif ou nul
        """
        if increment <= 0:
            raise ValueError("L'incrément d'accélération doit être positif")
        self.speed += increment
        return self.speed

    def brake(self, decrement):
        """Méthode de freinage.
Paramètres :
decrement : quantité de décélération, doit être un entier positif
Retourne :
La vitesse actuelle après freinage, minimum 0
Lève :
ValueError : levée lorsque decrement est négatif ou zéro
        """
        if decrement <= 0:
            raise ValueError("La quantité de décélération doit être positive")
        self.speed = max(0, self.speed - decrement)
        return self.speed

Code de test : test_car.py

Exemple

# test_car.py - Tests unitaires pour la classe Car
# Écrire des cas de test en utilisant le framework unittest
import unittest
from car import Car


class TestCar(unittest.TestCase):
    """Suite de tests pour la classe Car."""

    def setUp(self):
        """setUp est appelé avant chaque méthode de test pour créer une toute nouvelle instance de Car."""
        self.car = Car()

    def test_initial_speed(self):
        """Vérifie si la vitesse initiale est 0."""
        self.assertEqual(self.car.speed, 0,
                         "La vitesse initiale de la nouvelle voiture doit être 0")

    def test_accelerate_normal(self):
        """Scénario de test d'accélération normale."""
        # Accélérer de 50
        result = self.car.accelerate(50)
        # Vérifier la valeur de retour
        self.assertEqual(result, 50,
                         "La vitesse après accélération doit être 50")
        # Vérifier l'état de l'objet
        self.assertEqual(self.car.speed, 50,
                         "L'attribut car.speed doit être mis à jour à 50")

    def test_accelerate_multiple_times(self):
        """Tester l'effet cumulatif de plusieurs accélérations."""
        # Première accélération de 30
        self.car.accelerate(30)
        # Deuxième accélération de 20
        result = self.car.accelerate(20)
        # La vitesse totale devrait être de 50
        self.assertEqual(result, 50,
                         "La vitesse après deux accélérations devrait être de 50")

    def test_accelerate_with_zero(self):
        """Tester qu'une exception est levée lorsque l'incrément d'accélération est 0."""
        with self.assertRaises(ValueError,
                               msg="Un incrément d'accélération de 0 devrait lever ValueError"):
            self.car.accelerate(0)

    def test_accelerate_negative(self):
        """Tester qu'une exception est levée lorsque l'incrément d'accélération est négatif."""
        with self.assertRaises(ValueError,
                               msg="Un incrément d'accélération négatif devrait lever ValueError"):
            self.car.accelerate(-10)

    def test_brake_normal(self):
        """Test du scénario de freinage normal."""
        # Accélérer d'abord jusqu'à 80
        self.car.accelerate(80)
        # Freiner de 30
        result = self.car.brake(30)
        # Vérifier la vitesse
        self.assertEqual(result, 50,
                         "La vitesse après freinage devrait être de 50")

    def test_brake_below_zero(self):
        """Test que le freinage ne fait pas passer la vitesse en dessous de 0."""
        # Accélérer d'abord jusqu'à 20
        self.car.accelerate(20)
        # Freiner de 50, la vitesse devrait être limitée à 0
        result = self.car.brake(50)
        self.assertEqual(result, 0,
                         "La vitesse ne doit pas être inférieure à 0")

    def test_brake_with_zero(self):
        """Vérifie qu'une exception est levée lorsque la quantité de décélération est 0."""
        with self.assertRaises(ValueError,
                               msg="Une quantité de décélération de 0 doit lever ValueError"):
            self.car.brake(0)


# Exécuter les tests lorsque le script est exécuté directement
if __name__ == "__main__":
    unittest.main()

PyCharm peut automatiquement reconnaître les classes de test et les méthodes de test. Les noms des classes de test commencent parTestet les noms des méthodes de test commencent partest_C'est la convention de nommage des tests Python.

Exécution des tests

Après avoir écrit le code de test, il existe plusieurs façons d'exécuter les tests.

Méthode 1 : Cliquez sur l'icône d'exécution verte

PyCharm affichera dans la zone Gutter gauche, à côté de la classe de test et de chaque méthode de testune icône d'exécution verte.。

Un clic sur l'icône verte à côté du nom de la classe exécute tous les tests de cette classe, tandis qu'un clic sur l'icône à côté d'une méthode n'exécute que ce seul test.

Vous pouvez également faire un clic droit sur le fichier de test et choisir dans le menuRun 'test_car'。

Méthode 2 : Utiliser les raccourcis clavier

Placez le curseur à l'intérieur de la classe de test ou de la méthode de test et appuyez surCtrl + Shift + F10pour exécuter le test actuel.

Affichage des résultats des tests

Une fois l'exécution des tests terminée, PyCharm, dans la fenêtre d'outilsRunen bas,affichera les résultats des tests dans unevue arborescente.

Les tests réussis sont marqués d'une coche verte, les tests en échec d'une croix rouge, avec des messages d'erreur détaillés et des traces de pile.

Un clic sur un test en échec amène PyCharm directement à la ligne de code où l'erreur s'est produite, ce qui permet de localiser rapidement le problème.

Changer de framework de test

PyCharm utilise par défautunittestcomme exécuteur de tests, mais vous pouvez facilement passer à d'autres frameworks.

Étapes de configuration

  1. OuvrezParamètres(Raccourci : Ctrl + Alt + S, ou Command + , sur macOS).
  2. Accédez à Python。
  3. Dansla section Outils intégréset trouvez le menu déroulantTests.
  4. parmiUnittests、pytest、NosetestsSélectionnez le framework dont vous avez besoin.
  5. Cliquez surOKpour enregistrer les paramètres.

Si vous choisissez pytest comme exécuteur de tests, assurez-vous d'avoir installé le paquet pytest avecpip install pytest.

Conseils sur le développement piloté par les tests

Les tests unitaires ne servent pas seulement à vérifier le code existant ; ils sont aussi la pratique fondamentale dudéveloppement piloté par les tests (TDD).

Le processus de développement recommandé consiste à écrire d'abord les cas de test, puis à écrire le code d'implémentation, et enfin à vérifier en faisant passer les tests.

Prenez l'habitude d'écrire des tests, et la qualité de votre code s'améliorera considérablement.

Autres extensions