Tests unitaires avec le module Python unittest

Aucun bon développeur ne déploie du code sans des tests approfondis. Le test unitaire est le processus de test des modules individuels 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, comprenons quels sont les types de tests.

Si vous préférez vers les tests, il existe des tests manuels et des tests automatiques. Test manuel est une technique de test où les humains effectuent le test manuellement après l'achèvement du développement. Test d'automatisation est une technique de test où les programmes effectuent le test automatiquement et nous donnent les résultats.

Vous l'aurez compris, les tests manuels sont longs et difficiles à réaliser. Ainsi, les développeurs écrivent du code pour effectuer des tests (tests automatiques). Il existe différents types de tests dans les tests automatisés. Certains d'entre eux sont Tests unitaires, Tests d'intégration, Tests de bout en bout, Tests de résistance, etc..,

Voyons le déroulement standard des tests.

Écrivez ou mettez à jour le code.
Ecrivez ou mettez à jour des tests pour différents cas pour votre code.
Exécutez les tests (soit manuellement, soit à l'aide d'un lanceur de tests).
Voir les résultats des tests. S'il y a des erreurs, corrigez-les et répétez les étapes.

Ici, nous allons discuter du type de test le plus essentiel et le plus basique appelé tests unitaires. Sans plus tarder, plongeons-nous dans le didacticiel lui-même.

What is Unit Testing?

Les tests unitaires sont une technique pour tester un petit bloc de code indépendant. Le code en petits blocs sera une fonction dans la plupart des cas. Le mot indépendant signifie qu'il ne dépend pas d'autres morceaux de code du projet.

Disons que nous devons vérifier si une chaîne est égale à « Geekflare » ou pas. Pour cela, nous avons écrit une fonction qui prend un argument et renvoie s'il est égal à « Geekflare » ou non.

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

La fonction ci-dessus ne dépend d'aucun autre code. Ainsi, nous pouvons le tester indépendamment en donnant différentes entrées. Le morceau de code indépendant peut être utilisé dans l'ensemble du projet.

Importance of Unit Testing

En général, le code des blocs indépendants peut être utilisé dans l'ensemble du projet. Donc, il doit ê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é de petits blocs de code utilisés dans le projet. Tous les autres tests comme les tests d'intégration, les tests de bout en bout, etc., utilisant les autres petits blocs de code peuvent échouer. Cela interrompt l'application. C'est pourquoi les blocs de construction de base du code doivent être bien testés.

Maintenant, nous connaissons l'importance des tests unitaires et des tests unitaires écrits pour tous les blocs de code indépendants. Depuis que nous avons effectué des tests unitaires, d'autres tests comme l'intégration les tests, les tests de bout en bout, etc., n'échoueront pas en raison du bloc de codes indépendant.

Dans les sections à venir, nous verrons ce qu'est le module Python unittest et comment nous utilisons le module unittest pour écrire des tests unitaires dans Python.

Remarque : Nous supposons que vous êtes familiarisé avec les classes, modules, etc. Python. Si vous n'êtes pas familiarisé avec les concepts intermédiaires Python tels que les classes, les modules, etc., vous aurez peut-être du mal à comprendre les sections à venir.

What is Python unittest?

Python unittest est un framework de test intégré pour tester le code Python. Il dispose d'un lanceur de test, ce qui nous permet d'exécuter les tests sans trop d'effort. Ainsi, nous pouvons utiliser la fonction intégrée Test de l'unité module pour tester sans utiliser les modules tiers. Mais, cela change en fonction de vos besoins. Le intégré Test de l'unité module est bon pour commencer à tester en Python.

Nous devons suivre les étapes ci-dessous pour tester le code Python à l'aide du module unittest.

# 1. Écrivez le code.

# 2. Importer le unittest module.

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

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

# 5. Écrire des méthodes (tests) à l'intérieur de la classe. Chaque méthode contient différents cas de test en fonction de vos besoins. Il faut nommer la méthode commençant par test mot-clé.

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

Exécuter 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_filename.py. Pour que cette méthode fonctionne, nous devons invoquer le main méthode de unittest dans le fichier d'essai.
Et enfin, en utilisant le 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émarrage.

Généralement, lors des tests, nous comparons la sortie du code avec la sortie attendue. Donc, pour comparer les sorties Test de l'unité propose différentes méthodes. Vous pouvez trouver la liste des fonctions de comparaison ici.

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

C'est beaucoup de théorie. Il faut maintenant se lancer dans le codage.

Remarque : Si vous avez des questions sur le module unittest, vous pouvez aller sur le Documentation et dissiper vos doutes. Sans plus tarder, utilisons le module unittest.

Unit Tests in Python using 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 favori éditeur de code. 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 utils.py déposer. Maintenant, nous devons 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 d'exemples en tant que utils.py.

# 2. Importer le utils et unittest module.

# 3. Créer une classe avec le nom TestUtils extension unittest.TestCase classer. Le nom de la classe peut être n'importe quoi. Essayez de donner à la classe un nom significatif.

# 4. Dans 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 pour le is_prime et comparer la sortie avec la sortie attendue.

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

# 7. Nous attendons la sortie du is_prime(1) sera faux dans le cas ci-dessus.

# 8. Semblable au cas ci-dessus, nous allons différents cas de test 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),
                         "Negative numbers are not allowed")


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

Nous invoquons le main méthode de unittest le module pour exécuter les tests en utilisant python filename.py la commande. Maintenant, lancez les tests.

Vous verrez une sortie similaire à la sortie ci-dessous.

$ python test_utils.py 
.
----------------------------------------------------------------------
Ran 1 test in 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 elles. Jetez un œil aux tests suivants qui sont ajoutés à la classe ci-dessus.

...


class 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"), "Hello, Chandan")
        self.assertNotEqual(utils.say_hello("Chandan"), "Hi, Chandan")
        self.assertNotEqual(utils.say_hello("Hafeez"), "Hi, Hafeez")


...

Nous n'avons utilisé que certaines des fonctions de comparaison de la unittest module. 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 différentes manières d'exécuter les tests.

How to Run Tests using unittest

Nous avons déjà vu un moyen d'exécuter les cas de test dans la section ci-dessus. Voyons les deux autres façons d'exécuter les tests en utilisant le module unittest.

# 1. Utilisation du nom de fichier et du module unittest.

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

# 2. Utiliser la méthode de découverte

Nous allons utiliser la discover méthode du module unittest pour détecter automatiquement 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 à l'aide de la méthode de découverte est python -m unittest discover. La commande détectera tous les fichiers dont les noms commencent par test et les exécuter.

Conclusion

Les tests unitaires sont des tests de base dans le monde de la programmation. Il y a beaucoup d'autres tests dans le monde réel. Essayez de les apprendre une par une. J'espère que ce tutoriel vous aidera à écrire des tests de base en Python à l'aide du module unittest. Il existe des bibliothèques tierces telles que pytest, Robot Framework, nose, nose2, slash, etc. Vous pouvez les explorer en fonction des exigences de votre projet.

Bon test 😎

Vous pouvez également être intéressé par Questions et réponses d'entretien Python.