Comprendre les tests unitaires en Python

Le test de votre code est une partie essentielle du cycle de vie du développement logiciel, et il doit toujours intervenir avant le déploiement de l'application en production. Le test est crucial car il permet de suivre et de trouver des bogues dans le code.

Le test est une méthode de vérification des unités individuelles de code source pour confirmer qu'il fonctionne de manière optimale avant d'expédier le code à la production. Il est important de noter que le déploiement du fichier source en production pour les utilisateurs n'est pas nécessaire lors des tests unitaires.

Il serait préférable que vous vous souveniez également que les tests ne sont pas spécifiques à Python.

Cet article vous apprendra à écrire des tests de base à l'aide de tests unitaires Python pour vérifier si votre code réussit ou échoue pendant les tests.

Conditions préalables

Pour terminer ce didacticiel, vous avez besoin des éléments suivants :

• Connaissance de l'écriture de code Python
• Une installation du sur votre ordinateur local
• Un éditeur de code de votre choix

Commencer

Les tests d'écriture sont des programmes logiques qu'un programmeur écrit pour tester une base de code. Pendant le développement, un AQ doit comprendre le processus pour mettre en évidence ce qui doit être amélioré dans l'application avant d'expédier le produit à l'utilisateur. Pour cela, écrivons une fonction qui additionne deux nombres et renvoie le résultat.

Pour commencer, créez un dossier contenant tous les fichiers pour écrire le test de ce tutoriel. Ajoutez un fichier nommé main.py pour écrire la fonction dans ce nouveau dossier.

 # main.py # Add the sum of two numbers def add_sum(num1, num2): return int(num1) + int(num2)

Maintenant que nous avons le bloc de code ci-dessus, vérifions que le code fonctionne en écrivant une fonction permettant aux utilisateurs d'entrer la valeur souhaitée via l'invite de saisie. La fonction add_sum() prend deux nombres comme paramètres et renvoie la valeur en utilisant l'opérateur + signe pour obtenir la somme. Dans un autre fichier, result.py , copiez et collez le code suivant :

 # result.py from main import add_sum print("Please enter the two values\n") num1 = int(input("Please enter the first number: \n")) num2 = int(input("Please enter the second number: \n")) total = add_sum(num1, num2) print(f"The sum of the values is {total}")

Ce bloc de code effectue les opérations suivantes :

• Importe le add_sum() de main.py
• converti la valeur de l'invite d'entrée en un entier à l'aide de la méthode int
• additionne les valeurs qui impriment son total en utilisant les f-strings (syntaxe de formatage) pour obtenir la sortie

Que sont les tests unitaires et les cas de test ?

Python est livré avec un module de bibliothèque standard intégré appelé unittest, qui fournit des outils pour construire et exécuter des tests pour votre code. L'objectif principal des tests unitaires est de vérifier si toutes les fonctions du code fonctionnent comme prévu.

Un cas de test est une manière standard de travailler avec un test unitaire, avec des fonctionnalités disponibles dans la classe de nom de test. En outre, un cas de test est essentiel dans le code du composant pour les tests unitaires individuels. Il utilise différentes méthodes d'assertion pour rechercher et signaler les échecs immédiatement après l'exécution du code.

Passer un test

Cette section concerne l'écriture d'une série de tests.

Avant de créer le fichier de test pour écrire tous les cas de test pour la fonction add_sum() , mettons à jour le main.py . Copiez et collez le code suivant :

 # main.py def add_sum(num1, num2): try: return int(num1) + int(num2) except ValueError as err: return err

Le bloc de code utilise l'instruction try/except qui gère les exceptions dans votre code et vous avertit en cas d'erreur dans le bloc except. Cette méthode de programmation aide à détecter les erreurs et vous indique le numéro de ligne spécifique où l'erreur s'est produite.

Maintenant, créez un fichier de test dans le même répertoire appelé test.py. Dans ce fichier, copiez et collez le code suivant :

 # test.py import unittest from main import add_sum class MainTest(unittest.TestCase): def test_do_stuff(self): result = add_sum(5, 10) self.assertEqual(result, 15) if __name__ == '__main__': unittest.main()

Comme indiqué dans le bloc de code ci-dessus, les événements suivants se produisent :

• Importez l'unittest et la fonction que vous souhaitez tester (elle provient du main.py)
• Unittest fonctionne en créant une classe contenant les tests pour la fonction add_sum(), qui hérite à l'intérieur de la classe de ce que donne unittest, qui est le unittest.TestCase
• Définissez une fonction avec le mot-clé self dans le test_do_stuff() qui représente l'instance de la classe
• Dans la méthode de test test_do_stuff(), déclarez une variable et transmettez les deux arguments avec des valeurs différentes
• La dernière ligne utilise la méthode assert unittest, assertEqual, qui vérifie que les arguments que vous transmettez à partir de la variable de résultat correspondent au résultat que vous vous attendez à recevoir
• Enfin, exécutez l'intégralité du fichier de test avec unittest.main()

N'oubliez pas de démarrer chaque méthode avec le "test_" car le test.py s'exécute automatiquement. **
**

Chaque fois que vous exécutez un test, toutes les vérifications sont censées réussir avec un message OK dans la console, ce qui signifie qu'il a réussi.

 Ran 1 test in 0.000s OK

Échec à un test

Pendant le développement et les tests, il devrait y avoir des scénarios d'échec. Cela montre que chaque programme a des vulnérabilités et des bogues.

Dans le même fichier, test.py , modifions le code et collons ce qui suit :

 # test.py import unittest from main import add_sum class MainTest(unittest.TestCase): # other test def test_do_stuff2(self): result = add_sum("hulu", 5) self.assertEqual(result, 5) if __name__ == '__main__': unittest.main()

Le résultat de l'exécution de ce code ressemble à ceci :

 FAIL: test_do_stuff2 (__main__.MainTest) ---------------------------------------------------------------------- Traceback (most recent call last): File "test.py", line 11, in test_do_stuff3 self.assertEqual(result, 5) AssertionError: ValueError("invalid literal for int() with base 10: 'hulu'") != 5

À partir de la sortie ci-dessus, les éléments suivants peuvent être résolus en lisant le code d'erreur et en corrigeant le code en conséquence :

• L'erreur s'est produite sur un numéro de ligne spécifique, vous demandant de vérifier et de résoudre le numéro de ligne.
• Vient ensuite l'erreur d'assertion, qui donne une erreur de valeur signifiant que la chaîne 'hulu' n'est pas un littéral valide, sachant que dans le fichier main.py, les deux valeurs sont de type int
• Avec cette étape, vous savez ce qu'il faut corriger pour que le code exécute le test OK avec les bonnes valeurs à transmettre pour que le code réussisse.

Exécuter le code

Lorsque vous avez créé de nombreux fichiers et différents modules et que vous devez tous les tester simultanément au lieu d'essayer un seul fichier par défaut, vous pouvez utiliser cette commande pour exécuter tous les tests simultanément.

 python3 -m unittest

De plus, pour obtenir plus de détails sur le test, utilisez la commande avec le drapeau -v (verbeux), qui vous montre les tests qui sont OK et ceux qui ont échoué.

 python3 -m unittest -v

Le résultat ressemble à ceci :

 test_do_stuff (test.MainTest) ... ok test_do_stuff2 (test.MainTest) ... ok ---------------------------------------------------------------------- Ran 2 tests in 0.000s OK

Conclusion

Les tests unitaires doivent être une pratique effectuée par les QA et les développeurs impliqués dans l'écriture et l'expédition du code chaque fois qu'une nouvelle fonctionnalité est publiée avant que les utilisateurs ne puissent utiliser l'application. Faire des tests régulièrement ou périodiquement ne doit pas être une réflexion après coup, mais plutôt renforcer la confiance dans le fonctionnement et l'efficacité de l'application.

Cet article vous a donné un aperçu des raisons pour lesquelles les tests sont essentiels dans le développement et comment utiliser les tests unitaires pour vérifier la fonction du code et répondre à une spécification standard pour les utilisateurs avant le déploiement en production.

Apprendre encore plus