Conseils pour les tests unitaires en Python

Python est un langage de programmation de haut niveau En raison de ses caractéristiques telles que facile à apprendre, facile à comprendre, facile à lire et facile à étendre, il est devenu le langage préféré en science des données, en programmation réseau, en développement Web et en machine. l'apprentissage et d'autres domaines et est largement utilisé. Cependant, les tests unitaires sont toujours une tâche nécessaire, quel que soit le développement de tout type d'application.

Les tests unitaires sont une technique de test logiciel qui examine la plus petite unité de code (appelée « unité ») dans une application. Le but de l'exécution de tests unitaires est de déterminer si l'unité de code s'exécute dans les bonnes circonstances et de vérifier si l'unité de code gère les exceptions de manière appropriée lorsque des exceptions se produisent.

Python fournit de nombreux frameworks pour tester les applications Python (tels que unittest, nose, pytest, etc.). Dans cet article, nous présenterons quelques techniques de tests unitaires en Python.

1. Utiliser le framework unittest

unittest est le framework de tests unitaires intégré de Python. Il fournit un environnement de test complet capable d'écrire divers scénarios de test et suites de tests et de les exécuter automatiquement. Le cœur du framework unittest est la classe TestCase. Lorsqu'une classe de test hérite de la classe TestCase, elle disposera de méthodes de test qui seront automatiquement appelées lors de l'exécution de la suite de tests.

Il s'agit d'un exemple simple de test unitaire :

import unittest

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

class TestSum(unittest.TestCase):
    def test_sum(self):
        self.assertEqual(sum(1, 2), 3, "Sum should return 3")
        self.assertEqual(sum(0, 0), 0, "Sum should return 0")
        self.assertEqual(sum(-1, 1), 0, "Sum should return 0")

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

Dans cet exemple, nous définissons une fonction appelée sum qui ajoute deux nombres, puis écrivons une classe de test qui hérite de unittest.TestCase, où contient une méthode test_sum qui utilise l'instruction assertEqual pour tester si la fonction somme fonctionne comme prévu. Enfin, nous appelons la fonction unittest.main() pour exécuter le scénario de test.

2. Utilisation de simulations

L'un des plus gros problèmes lors de l'écriture de tests unitaires consiste à tester les dépendances telles que les connexions à la base de données, les services Web, les E/S de fichiers, les requêtes réseau, etc. Des bibliothèques simulées peuvent être utilisées pour simuler ces dépendances et fournir un environnement de contrôle fiable pour les tests. Le module mock fournit une classe fictive qui peut être utilisée pour remplacer n'importe quel objet Python.

Ceci est un exemple fictif simple :

from unittest.mock import MagicMock

def test_divide_magicmock():
    calculator = Calculator()
    calculator.divide = MagicMock(return_value=2)
    assert calculator.divide(8, 4) == 2
    calculator.divide.assert_called_once_with(8, 4)

Dans cet exemple, nous utilisons la classe MagicMock pour remplacer la méthode Divide dans la classe Calculator et spécifions que sa valeur de retour est 2. Nous appelons ensuite la méthode Divide et vérifions qu'elle appelle les paramètres corrects et renvoie la valeur attendue.

3. Utilisation de Coverage.py

Coverage.py est un outil en Python permettant d'évaluer la couverture du code. Il peut être utilisé pour identifier les lignes de code non testées afin que davantage de cas de test puissent être introduits lors de l'écriture de tests unitaires. Coverage.py détermine quel code dans une application Python a été exécuté et quel code n'a pas été exécuté. Il génère un rapport HTML qui permet aux développeurs de mieux comprendre la couverture du code et fournit des statistiques détaillées sur la couverture des tests de code.

Voici un exemple de Coverage.py :

pip install coverage

coverage run my_program.py
coverage report -m

Dans cet exemple, nous avons installé Coverage.py, puis utilisé la commande coverage run pour exécuter le script my_program.py, et utilisé la commande coverage report pour générer le rapport de couverture.

4. Générer des données de test aléatoires

La quantité et la qualité des données de test sont cruciales pour la qualité des tests unitaires. Afin de rendre les données de test plus représentatives et de couvrir davantage de cas extrêmes, nous pouvons utiliser le module aléatoire intégré de Python pour générer des données de test aléatoires.

Voici un exemple de générateur de données de test aléatoire :

import random

def generate_random_data():
    return random.randint(1, 100), random.randint(1, 100)

class TestSum(unittest.TestCase):
    def test_sum(self):
        a, b = generate_random_data()
        result = sum(a, b)
        self.assertEqual(result, a + b)

Dans cet exemple, nous utilisons le module random pour générer deux entiers aléatoires, puis testons si la fonction somme renvoie correctement leur somme.

5. Utilisation de pytest

Pytest est un framework de test Python extensible. pytest est un framework plus simple et plus flexible qui aide les développeurs à rédiger des tests unitaires efficaces. Il offre les fonctionnalités suivantes :

• Découverte automatique des modules de test et des fonctions de test.
• Prend en charge les tests paramétrés
• Prend en charge la réexécution des tests ayant échoué.
• Prend en charge les cas de test pour s'exécuter dans plusieurs processus, accélère les tests et raccourcit la durée des tests

Voici un exemple de framework de tests unitaires Python simple utilisant Pytest :

pip install pytest

pytest test_sample.py

Dans cet exemple, nous avons installé le framework pytest et utilisé pytest Exécutez notre script de test.

Résumé

Cet article présente plusieurs techniques de tests unitaires en Python, notamment l'utilisation du framework unittest, de l'outil simulé, Coverage.py et la génération de données de test aléatoires. Ces conseils peuvent aider les développeurs Python à rédiger des tests unitaires plus efficaces et plus complets. Si vous êtes sur le point de commencer à écrire des tests unitaires Python, pensez à utiliser ces conseils pour améliorer la qualité de vos tests unitaires.

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!