En Python, l'un des frameworks de tests unitaires les plus couramment utilisés est unittest, qui est inclus dans la bibliothèque standard. Il fournit un riche ensemble d'outils pour créer et exécuter des tests, ainsi que pour rapporter les résultats.

Principales fonctionnalités du framework unittest

1. Scénario de test : un scénario de test est créé en sous-classant unittest.TestCase. Chaque méthode de la classe commençant par test_ est considérée comme un test.

2. Assertions : le framework fournit une variété de méthodes d'assertion pour vérifier les résultats attendus, telles que assertEqual, assertTrue, assertFalse, etc.

3. Test Runner : le framework comprend un exécuteur de tests qui exécute les tests et rapporte les résultats.

Structure de base d'un test unitaire

1. Importez le module unittest : Commencez par importer la bibliothèque unittest.

2. Créer un scénario de test : définissez une classe qui hérite de unittest.TestCase.

3. Définir les méthodes de test : chaque méthode doit commencer par test_ et contenir des assertions pour vérifier le comportement attendu.

4. Exécuter les tests : utilisez unittest.main() pour exécuter les tests si le script est exécuté directement.

Exemple simple

Voici un exemple simple qui montre comment utiliser le framework unittest pour tester une fonction simple.

Fonction à tester

Tout d'abord, créons une fonction simple que nous allons tester :

math_functions.py

def ajouter(a, b):
renvoyer un b

def soustraire(a, b):
retourner a - b

Test unitaire pour la fonction

Maintenant, nous allons créer un test unitaire pour les fonctions d'ajout et de soustraction :

test_math_functions.py

importer un test unitaire
from math_functions import add, soustract # Importer les fonctions à tester

classe TestMathFunctions(unittest.TestCase) :

def test_add(self):
    self.assertEqual(add(2, 3), 5)          # Test case: 2   3 = 5
    self.assertEqual(add(-1, 1), 0)         # Test case: -1   1 = 0
    self.assertEqual(add(0, 0), 0)          # Test case: 0   0 = 0

def test_subtract(self):
    self.assertEqual(subtract(5, 3), 2)     # Test case: 5 - 3 = 2
    self.assertEqual(subtract(-1, -1), 0)   # Test case: -1 - (-1) = 0
    self.assertEqual(subtract(0, 5), -5)    # Test case: 0 - 5 = -5

if nom == 'main' :
unittest.main()

Explication du test unitaire

1. Importer les déclarations :

import unittest : importe le module unittest.

from math_functions import add, subtract : importe les fonctions que nous voulons tester.

1. Création d'un scénario de test :

class TestMathFunctions(unittest.TestCase) : définit une classe de scénario de test qui hérite de unittest.TestCase.

1. Définition des méthodes de test :

Chaque méthode commençant par test_ représente un test distinct.

Dans chaque méthode de test, self.assertEqual() vérifie si la sortie de la fonction correspond à la valeur attendue.

1. Exécution des tests :

if name == 'main' : unittest.main() : Cette ligne permet au script d'exécuter les tests lorsqu'il est exécuté directement.

Exécution des tests

Pour exécuter les tests, exécutez simplement le script test_math_functions.py. Vous pouvez le faire à partir de la ligne de commande :

python test_math_functions.py

Sortir

Si tous les tests réussissent, vous verrez un résultat similaire à celui-ci :

..

A effectué 2 tests en 0,001 s

D'ACCORD

Cela indique que les méthodes test_add et test_subtract ont réussi. Si une assertion échoue, unittest signalera l'échec, indiquant quel test a échoué et pourquoi.

Conclusion

Le framework unittest en Python fournit un moyen simple et efficace de créer et d'exécuter des tests unitaires. En écrivant des tests pour vos fonctions, vous pouvez vous assurer qu'elles se comportent comme prévu et maintiennent une qualité de code élevée tout au long de votre processus de développement.