Tests unitaires paramétrés en Python : un guide pour la génération de tests dynamiques

Dans le développement de logiciels, les tests jouent un rôle crucial pour garantir la fiabilité et l'exactitude de notre code. Les tests unitaires, en particulier, impliquent la création de tests individuels pour des fonctions ou des modules spécifiques. Cependant, lorsqu'il s'agit de grands ensembles de données ou de scénarios de test complexes, il devient laborieux d'écrire manuellement des tests pour chaque paramètre.

Tests paramétrés : une solution à la génération de tests dynamiques

Les tests paramétrés, également appelés tests unitaires paramétrés, relèvent ce défi en automatisant le processus de génération de tests en fonction des paramètres d'entrée. Il nous permet d'exécuter un seul test sur plusieurs ensembles de données, avec les paramètres de test substitués dynamiquement au moment de l'exécution.

Outils et techniques de paramétrage

Python propose une gamme d'outils et de bibliothèques pour le paramétrage. Ceux-ci incluent :

1. Décorateur de pytest :
pytest propose un décorateur pratique @pytest.mark.parametrize qui simplifie la paramétrisation. Cela nous permet de transmettre une liste de tuples contenant des paramètres de test, et le décorateur étend le test pour chaque ensemble de valeurs.

Exemple :

import pytest

@pytest.mark.parametrize("name, a, b", [
    ("foo", "a", "a"),
    ("bar", "a", "b"),
    ("lee", "b", "b"),
])
def test_sequence(name, a, b):
    assert a == b

2. Bibliothèque paramétrée :
La bibliothèque paramétrée offre une approche alternative à la paramétrisation. Cela nous permet d'utiliser un décorateur @parameterized.expand pour spécifier les paramètres de test sous forme de listes ou de générateurs.

Exemple :

from parameterized import parameterized

class TestSequence(unittest.TestCase):

    @parameterized.expand([
        ("foo", "a", "a"),
        ("bar", "a", "b"),
        ("lee", "b", "b"),
    ])
    def test_sequence(self, name, a, b):
        self.assertEqual(a, b)

Avantages des tests paramétrés :

• Efforts de test réduits : Élimine le besoin d'écrire des tests pour chaque combinaison de paramètres, économisant du temps et des efforts.
• Couverture de test améliorée : En testant tous valeurs de paramètres possibles, il garantit une couverture complète des tests et réduit le risque de cas extrêmes manquants.
• Tests basés sur les données : Facilite les tests de scénarios complexes où les données elles-mêmes déterminent le comportement des tests.
• Efficace et évolutif : Le processus de génération de tests automatisé rend les tests plus efficaces et évolutifs, en particulier pour les grands ensembles de données.

Approche héritée :

Pour le contexte historique, nous pouvons mentionner une approche plus ancienne qui implique l'utilisation de la création de classes dynamiques pour générer des tests :

Exemple :

import unittest

l = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]

class TestSequense(unittest.TestCase):
    pass

def test_generator(a, b):
    def test(self):
        self.assertEqual(a,b)
    return test

if __name__ == '__main__':
    for t in l:
        test_name = 'test_%s' % t[0]
        test = test_generator(t[1], t[2])
        setattr(TestSequense, test_name, test)
    unittest.main()

Cette approche héritée est moins courante dans le développement Python moderne en raison de la disponibilité d'outils de paramétrage plus efficaces et plus conviviaux.