Écrire des tests d'unité professionnelle à Python

Les tests unitaires sont à la base de la construction de logiciels fiables. Il existe de nombreux types de tests, mais les tests unitaires sont les plus importants. Les tests unitaires vous permet de vous sentir assuré que vous avez des extraits de code entièrement testés en tant qu'unités de base et que vous comptez sur eux lors de la création de votre programme. Ils étendent vos réserves de code de confiance au-delà de la portée des fonctionnalités intégrées de la langue et des bibliothèques standard. De plus, Python fournit un soutien solide pour l'écriture de tests unitaires.

Exemple de course

Avant de plonger dans tous les principes, heuristiques et guides, jetons un œil à un exemple de test unitaire pratique.

Créez un nouveau répertoire appelé python_tests et ajoutez deux fichiers:

• car.py
• test_car.py

Définissez le répertoire en tant que package Python en ajoutant le fichier init .py . La structure du fichier doit être la suivante:

<code>python_tests/
        -__init__.py
        - car.py
        - test_car.py</code>

Le fichier

car.py sera utilisé pour écrire la logique du programme de voiture autonome que nous utilisons dans cet exemple, et le fichier test_car.py sera utilisé pour rédiger tous les tests.

contenu de fichier car.py:

class SelfDrivingCar:
    def __init__(self):
        self.speed = 0
        self.destination = None

    def _accelerate(self):
        self.speed += 1

    def _decelerate(self):
        if self.speed > 0:
            self.speed -= 1

    def _advance_to_destination(self):
        distance = self._calculate_distance_to_object_in_front()
        if distance < 1:  # 假设距离单位为米
            self.stop()
        elif distance < 5:
            self._decelerate()
        elif self.speed < self._get_speed_limit():
            self._accelerate()

    def _has_arrived(self):
        pass  # 需要实现到达目的地判断逻辑

    def _calculate_distance_to_object_in_front(self):
        pass  # 需要实现计算前方物体距离的逻辑

    def _get_speed_limit(self):
        pass  # 需要实现获取速度限制的逻辑

    def stop(self):
        self.speed = 0

    def drive(self, destination):
        self.destination = destination
        while not self._has_arrived():
            self._advance_to_destination()
        self.stop()

Il s'agit d'un test unitaire pour la classe TestCase. Obtenez le module unittest comme indiqué ci-dessous.

from unittest import TestCase

Vous pouvez ensuite remplacer le module unittest.main fourni par le framework de test unittest en ajoutant le script de test suivant en bas du fichier de test.

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

Continuez et ajoutez le script de test en bas du fichier test_car.py comme indiqué ci-dessous.

import unittest
from car import SelfDrivingCar

class SelfDrivingCarTest(unittest.TestCase):
    def setUp(self):
        self.car = SelfDrivingCar()

    def test_stop(self):
        self.car.speed = 5
        self.car.stop()
        self.assertEqual(0, self.car.speed)
        self.car.stop()
        self.assertEqual(0, self.car.speed)

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

Pour exécuter le test, exécutez le programme Python:

python test_car.py

Vous devriez voir la sortie suivante:

<code>test_stop (__main__.SelfDrivingCarTest) ... ok

----------------------------------------------------------------------
Ran 1 test in 0.000s

OK</code>

Discovery de test

L'autre méthode, et la méthode la plus facile, est de tester la découverte. Cette option n'est ajoutée que dans Python 2.7. Avant 2.7, vous pouvez utiliser le nez pour découvrir et exécuter des tests. Le nez présente d'autres avantages, tels que l'exécution des fonctions de test sans créer de classes pour les cas de test. Mais pour cet article, restons avec unittest.

Comme son nom l'indique, -v logo:

Auto-DrivingCarest.

Il existe plusieurs signes pour contrôler l'opération:

python -m unittest -h

Test Couverture

La couverture du test est un domaine souvent négligé. La couverture est la quantité de code que votre test teste réellement. Par exemple, si vous avez une fonction avec une instruction IF, vous devez rédiger un test pour remplacer les branches vraies et fausses de l'instruction IF. Idéalement, votre code devrait être dans un package. Les tests pour chaque package doivent être dans le répertoire des frères et sœurs du package. Dans le répertoire de test, un fichier nommé un module unittest doit être fourni pour chaque module du package.

Conclusion

Les tests unitaires sont à la base d'un code fiable. Dans ce tutoriel, j'explore certains principes et directives pour les tests unitaires et explique plusieurs raisons derrière les meilleures pratiques. Plus le système que vous construisez est grand, plus les tests unitaires sont importants. Mais les tests unitaires ne suffisent pas. Les grands systèmes nécessitent également d'autres types de tests: tests d'intégration, tests de performances, tests de charge, tests de pénétration, tests d'acceptation, etc.

Cet article a été mis à jour et contient des contributions d'Esther Vaati. Esther est un développeur de logiciels et contributeur à Envato TUTS.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!