Aucun développeur digne de ce nom ne déploie de code sans procéder à des tests approfondis. Les tests unitaires consistent à tester les différents modules d’un grand programme.

Cet article explique comment vous pouvez effectuer des tests unitaires de votre code à l’aide du module Python unittest. Tout d’abord, il convient de comprendre quels sont les différents types de tests.

En matière de tests, il existe des tests manuels et des tests automatiques. Le test manuel est une technique de test dans laquelle les humains effectuent le test manuellement après l’achèvement du développement. L’automatisation des tests est une technique de test dans laquelle des programmes effectuent les tests automatiquement et nous communiquent les résultats.

Vous aurez compris que les tests manuels prennent du temps et sont difficiles à réaliser. Les développeurs écrivent donc du code pour effectuer les tests (tests automatiques). Il existe différents types de tests dans les tests automatisés. Certains d’entre eux sont les tests unitaires, les tests d’intégration, les tests de bout en bout, les tests de stress, etc..,

Voyons le déroulement standard des tests.

  • Écrire ou mettre à jour le code.
  • Écrire ou mettre à jour les tests pour les différents cas de votre code.
  • Exécutez les tests (manuellement ou à l’aide d’un programme de test).
  • Consultez les résultats des tests. S’il y a des erreurs, corrigez-les et répétez les étapes.

Nous allons parler ici du type de test le plus essentiel et le plus basique, appelé test unitaire. Sans plus attendre, plongeons dans le tutoriel proprement dit.

Qu’est-ce que le test unitaire ?

Les tests unitaires sont une technique permettant de tester un petit bloc de code indépendant. Dans la plupart des cas, le petit bloc de code sera une fonction. Le terme “indépendant” signifie qu’il ne dépend pas d’autres morceaux de code dans le projet.

Supposons que nous devions vérifier si une chaîne de caractères est égale à “Geekflare” ou non. Pour cela, nous avons écrit une fonction qui prend un argument et renvoie si elle est égale à “Geekflare” ou non.

def is_equal_to_geekflare(string) :
	return string == "Geekflare"

La fonction ci-dessus ne dépend d’aucun autre code. Nous pouvons donc la tester indépendamment en lui donnant différentes entrées. Le morceau de code indépendant peut être utilisé dans l’ensemble du projet.

Importance des tests unitaires

En général, les blocs de code indépendants peuvent être utilisés dans l’ensemble du projet. Il doit donc être bien écrit et testé. Les tests unitaires sont les tests utilisés pour tester ces types de blocs de code indépendants. Que se passe-t-il si nous n’utilisons pas de tests unitaires pour notre projet ?

Supposons que nous n’ayons pas testé les petits blocs de code utilisés dans l’ensemble du projet. Tous les autres tests, comme les tests d’intégration, les tests de bout en bout, etc., qui utilisent les autres petits blocs de code peuvent échouer. L’application s’effondre alors. C’est pourquoi les éléments de base du code doivent être bien testés.

Maintenant, nous connaissons l’importance des tests unitaires et nous avons écrit des tests unitaires pour tous les blocs de code indépendants. Puisque nous avons effectué des tests unitaires, d’autres tests comme les tests d’intégration, les tests de bout en bout, etc. n’échoueront pas à cause des blocs de code indépendants.

Dans les prochaines sections, nous verrons ce qu’est le module Python unittest et comment nous l’utilisons pour écrire des tests unitaires en Python.

Note : Nous supposons que vous êtes familier avec les classes Python, les modules, etc. Si vous n’êtes pas familier avec les concepts intermédiaires de Python tels que les classes, les modules, etc., vous aurez peut-être des difficultés à comprendre les sections suivantes.

Qu’est-ce que Python unittest ?

Python unittest est un cadre de test intégré pour tester le code Python. Il dispose d’un programme d’exécution des tests, qui nous permet d’exécuter les tests sans trop d’efforts. Nous pouvons donc utiliser le module intégré unittest pour tester sans utiliser de modules tiers. Mais cela change en fonction de vos besoins. Le module unittest intégré est bon pour commencer à tester en Python.

Nous devons suivre les étapes suivantes pour tester le code Python à l’aide du module unittest.

#1. Ecrivez le code.

#2. Importez le module unittest.

#3. Créez un fichier commençant par le mot-clé test. Par exemple test_prime.py. Le mot-clé test est utilisé pour identifier les fichiers de test.

#4. Créez une classe étendant la classe unittest.TestCase.

#5. Ecrivez des méthodes (tests) à l’intérieur de la classe. Chaque méthode contient différents cas de test en fonction de vos besoins. Nous devons nommer la méthode en commençant par le mot-clé test.

#6. Exécutez les tests. Nous pouvons exécuter les tests de différentes manières.

  • Exécutez la commande python -m unittest test_filename.py.
  • Nous exécutons les fichiers de test comme des fichiers Python généraux avec la commande python test_nom_du_fichier.py. Pour que cette méthode fonctionne, nous devons invoquer la méthode principale de l’unittest dans le fichier de test.
  • Et enfin, en utilisant la fonction ” discover“. Nous pouvons exécuter automatiquement les tests en utilisant la commande python -m unittest discover sans mentionner le nom de fichier du test. Il trouvera les tests en utilisant la convention de nommage que nous avons suivie. Nous devons donc nommer nos fichiers de test avec le mot-clé test au début.

Généralement, dans les tests, nous comparons la sortie du code avec la sortie attendue. Ainsi, pour comparer les sorties, unittest fournit différentes méthodes. Vous pouvez trouver la liste des fonctions de comparaison ici.

Vous pouvez facilement les comprendre sans aucune difficulté. Elles sont simples.

Voilà beaucoup de théorie. Il faut maintenant passer au codage.

Note : Si vous avez des questions sur le module unittest, vous pouvez consulter la documentation et lever vos doutes. Sans plus attendre, utilisons le module unittest.

Tests unitaires en Python avec unittest

Nous allons d’abord écrire quelques fonctions, puis nous nous concentrerons sur l’écriture des tests. Tout d’abord, ouvrez un dossier dans votre éditeur de code préféré. Et créez un fichier appelé utils.py. Collez le code suivant dans le fichier.

import math


def is_prime(n) :
    if n < 0 :
        return 'Les nombres négatifs ne sont pas autorisés'

    si n <= 1 :
        return False

    si n == 2 :
        return True

    si n % 2 == 0 :
        retour Faux

    for i in range(2, int(math.sqrt(n)) 1) :
        si n % i == 0 :
            retour Faux
    retour de True


def cubic(a) :
    return a * a * a


def say_hello(name) :
    return "Bonjour, " nom

Nous avons trois fonctions différentes dans le fichier utils.py. Nous devons maintenant tester chaque fonction avec différents cas de test. Écrivons les tests pour la première fonction is_prime.

#1. Créez un fichier appelé test_utils.py dans le dossier sample comme utils.py.

#2. Importez les modules utils et unittest.

#3. Créez une classe avec le nom TestUtils étendant la classe unittest.TestCase. Le nom de la classe peut être n’importe quoi. Essayez de lui donner un nom significatif.

#4. A l’intérieur de la classe, écrivez une méthode appelée test_is_prime qui accepte self comme argument.

#5. Ecrivez différents cas de test avec des arguments à la méthode is_prime et comparez la sortie avec la sortie attendue.

#6. Exemple de cas de test self.assertFalse(utils.is_prime(1)).

#7. Nous nous attendons à ce que la sortie de is_prime(1) soit fausse dans le cas ci-dessus.

#8. Comme dans le cas précédent, nous allons tester différents cas en fonction de la fonction que nous testons.

Voyons les tests.

import unittest

import utils


classe TestUtils(unittest.TestCase) :
    def test_is_prime(self) :
        self.assertFalse(utils.is_prime(4))
        self.assertTrue(utils.is_prime(2))
        self.assertTrue(utils.is_prime(3))
        self.assertFalse(utils.is_prime(8))
        self.assertFalse(utils.is_prime(10))
        self.assertTrue(utils.is_prime(7))
        self.assertEqual(utils.is_prime(-3),
                         "Les nombres négatifs ne sont pas autorisés")


if __name__ == '__main__' :
    unittest.main()

Nous invoquons la méthode main du module unittest pour exécuter les tests en utilisant la commande python filename.py. Exécutez maintenant les tests.

Vous obtiendrez un résultat similaire à celui ci-dessous.

python test_utils.py 
.
----------------------------------------------------------------------
Exécution de 1 test en 0.001s

OK

Maintenant, essayez d’écrire les cas de test pour d’autres fonctions également. Pensez à différents cas pour les fonctions et écrivez des tests pour eux. Jetez un coup d’œil aux tests suivants qui sont ajoutés à la classe ci-dessus.

...


classe TestUtils(unittest.TestCase) :
    def test_is_prime(self) :
        ...

    def test_cubic(self) :
        self.assertEqual(utils.cubic(2), 8)
        self.assertEqual(utils.cubic(-2), -8)
        self.assertNotEqual(utils.cubic(2), 4)
        self.assertNotEqual(utils.cubic(-3), 27)

    def test_say_hello(self) :
        self.assertEqual(utils.say_hello("Geekflare"), "Hello, Geekflare")
        self.assertEqual(utils.say_hello("Chandan"), "Bonjour, Chandan")
        self.assertNotEqual(utils.say_hello("Chandan"), "Bonjour, Chandan")
        self.assertNotEqual(utils.say_hello("Hafeez"), "Bonjour, Hafeez")


...

Nous n’avons utilisé qu’une partie des fonctions de comparaison du module unittest. Vous pouvez trouver la liste complète ici.

Nous avons appris à écrire des tests unitaires à l’aide du module unittest. Il est maintenant temps de voir les différentes façons d’exécuter les tests.

Comment exécuter des tests avec unittest

Nous avons déjà vu une façon d’exécuter les cas de test dans la section précédente. Voyons maintenant les deux autres façons d’exécuter les tests en utilisant le module unittest.

#1. En utilisant le nom du fichier et le module unittest.

Dans cette méthode, nous utiliserons le module unittest et le nom du fichier pour exécuter les tests. La commande pour exécuter les tests est python -m unittest nomdufichier.py. Dans notre cas, la commande pour exécuter les tests est python -m unittest test_utils.py.

#2. Utiliser la méthode discover

Nous allons utiliser la méthode discover du module unittest pour auto-détecter tous les fichiers de test et les exécuter. Pour détecter automatiquement les fichiers de test, nous devons les nommer en commençant par le mot-clé test.

La commande pour exécuter les tests en utilisant la méthode discover est python -m unittest discover. La commande détectera tous les fichiers dont le nom commence par test et les exécutera.

Conclusion 👩‍💻

Les tests unitaires sont les tests de base dans le monde de la programmation. Il existe de nombreux autres tests dans le monde réel. Essayez de les apprendre un par un. J’espère que ce tutoriel vous aidera à écrire des tests de base en Python en utilisant le module unittest. Il existe des bibliothèques tierces comme pytest, Robot Framework, nose, nose2, slash, etc. Vous pouvez les explorer en fonction des exigences de votre projet.

Bons tests 😎

Vous pourriez également être intéressé par les questions d’entretien Python et les réponses.