Tutoriel PyUnit : Python Cadre de tests unitaires (avec exemple)

Qu'est-ce que le test unitaire?

Tests unitaires in Python est fait pour identifier les bogues dès le début de la phase de développement de l'application, lorsque les bogues sont moins récurrents et moins coûteux à corriger.

Un test unitaire est un test de niveau code scripté conçu dans Python pour vérifier une petite « unité » de fonctionnalité. Le test unitaire est un framework orienté objet basé sur des appareils de test.

Python Techniques de tests unitaires

Python Les tests unitaires consistent principalement à tester un module particulier sans accéder à aucun code dépendant. Les développeurs peuvent utiliser des techniques telles que des stubs et des simulations pour séparer le code en « unités » et exécuter des tests au niveau unitaire sur les éléments individuels.

• Développement piloté par les tests TDD : Les tests unitaires doivent être effectués avec le Python, et pour cela, les développeurs utilisent la méthode de développement piloté par les tests. Dans la méthode TDD, vous concevez d'abord Python Testez unitairement et ensuite seulement vous continuez à écrire le code qui implémentera cette fonctionnalité.
• Talons et simulations : Ce sont deux techniques principales qui simulent de fausses méthodes testées. UN Talon est utilisé pour remplir certaines dépendances requises pour que le test unitaire s'exécute correctement. UN Moquer d'autre part c'est un faux objet qui exécute les tests où l'on met de l'assertion.

  Les intentions des deux méthodes sont les mêmes : éliminer le test de toutes les dépendances d’une classe ou d’une fonction.

Python Cadre de tests unitaires

Pour faciliter le processus de tests unitaires et améliorer la qualité de votre projet, il est recommandé de Python Cadre de tests unitaires. Le cadre de tests unitaires comprend

• UnitéPy : PyUnit prend en charge les appareils, les cas de test, les suites de tests et un programme d'exécution de tests pour les tests automatisés du code. Dans PyUnit, vous pouvez organiser les cas de test en suites avec les mêmes accessoires
• Nez: Les plug-ins intégrés de Nose vous aident avec la capture de sortie, la couverture de code, les doctests, etc. La syntaxe de Nose est assez simple et réduit les obstacles à l'écriture de tests. Il s'étend Python unittest pour faciliter les tests.
• Document : Le script de test Doctest est placé dans docstring avec une petite fonction au bas du fichier. Doctest vous permet de tester votre code en exécutant des exemples inclus dans la documentation et en vérifiant qu'ils ont renvoyé les résultats attendus. Le cas d'utilisation de doctest est moins détaillé et ne prend pas en compte les cas particuliers. Ils sont utiles en tant que documentation expressive du cas d'utilisation principal d'un module et de ses composants.

Tests unitaires avec PyUnit

Pyunit est un Python port de JUnit. Faisant partie de Pyunit, le module unittest contient cinq classes clés.

• Classe TestCase: La classe TestCase supporte les routines de test et fournit des hooks pour créer chaque routine et nettoyer par la suite
• Classe TestSuite: Il sert de conteneur de collection et peut posséder plusieurs objets de cas de test et plusieurs objets de suites de tests.
• Classe TestLoader: Cette classe charge les cas de test et les suites définis localement ou à partir d'un fichier externe. Il émet une suite de tests qui possède ces suites et cas
• Classe TextTestRunner: Pour exécuter les tests, il propose une plate-forme standard pour exécuter les tests
• La classe TestResults: Il propose un conteneur standard pour les résultats des tests

Concevoir un cas de test pour Python Test avec PyUnit

Un test unitaire fournit une classe de base, un scénario de test, qui peut être utilisé pour créer de nouveaux scénarios de test. Pour concevoir le scénario de test, trois ensembles de méthodes sont utilisées :

unittest.TestCase

setUp()
teardown()

skipTest(aMesg:string)
fail(aMesg:string)

id():string
shortDescription():string

Dans le premier ensemble se trouvent les crochets pré et post-test. La méthode setup() commence avant chaque routine de test, la méthode teardown() après la routine.

Le deuxième ensemble de méthodes contrôle l’exécution des tests. Les deux méthodes prennent une chaîne de message en entrée et annulent toutes deux un test en cours. Mais la méthode skiptest() abandonne le test en cours tandis que la méthode fail() l'échoue complètement.

La dernière ou la troisième méthode aide à déterminer le test. La méthode id() renvoie une chaîne composée du nom de l'objet testcase et de la routine de test. Et la méthode courteDescription() renvoie le commentaire docstr au lancement de chaque routine de test.

Python Exemple de test unitaire

L'exemple ci-dessous teste une simple fonction add() avec le module unittest. Chaque méthode préfixée par test_ s'exécute automatiquement, et assertEqual vérifie que le résultat correspond à la valeur attendue.

import unittest

def add(a, b):
    return a + b

class TestAdd(unittest.TestCase):
    def test_add_positive(self):
        self.assertEqual(add(2, 3), 5)

    def test_add_negative(self):
        self.assertEqual(add(-1, -1), -2)

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

Enregistrez le code et exécutez-le avec la commande `python filename.py`. L'outil d'exécution des tests unitaires indiquera le nombre de tests réussis ou échoués.

Avantages de l'utilisation Python Tests unitaires

• Il vous aide à détecter les bugs dès le début du cycle de développement
• Cela vous aide à écrire de meilleurs programmes
• Il se synchronise facilement avec d'autres méthodes et outils de test
• Il y aura beaucoup moins de bugs
• Il est plus facile de modifier à l'avenir avec très peu de conséquences

FAQ