Tests unitaires avec le module unittest de Python

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.
Écrivez ou mettez à 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 testés correctement

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 du bloc de code indépendant

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 pourriez avoir 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 idéal pour commencer à tester en Python

Nous devons suivre les étapes suivantes pour tester le code Python en utilisant le 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 nom_du_fichier_test.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. Nous devons 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 'Negative numbers are not allowed'

 if n <= 1 :
 return False

 if n == 2 :
 return True

 if n % 2 == 0 :
 return False

 for i in range(2, int(math.sqrt(n)) 1) :
 if n % i == 0 :
 return False
 return True


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


def say_hello(name) :
 return "Hello, " name

Nous avons trois fonctions différentes dans le fichier utils.py. Nous devons maintenant tester chaque fonction avec des cas de test différents. É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 à 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


class 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
.
----------------------------------------------------------------------

A exécuté

 1 test en 0.001s

OK

Essayez maintenant d’écrire des scénarios de test pour d’autres fonctions. 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. Maintenant, il est 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 les deux autres façons d’exécuter les tests en utilisant le module unittest

#1. Utiliser 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 auto-détecter 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 sur Python et les réponses.

Hafeezul Kareem Shaik

Auteur