Structurer ses tests en fonctions

Sur un vrai projet, tu vas avoir des centaines de tests. Si tu les mets tous en vrac dans un script, ca devient vite illisible. La solution : les organiser en fonctions nommees.

La convention universelle en Python, c'est de nommer tes fonctions de test avec le prefixe test_. Par exemple test_addition_basique, test_addition_negatifs. Tous les frameworks (pytest, unittest) utilisent cette convention pour detecter automatiquement les tests. Un bon nom de test, c'est de la documentation gratuite : quand un test echoue, tu sais immediatement ce qui est casse.

Une bonne organisation ressemble a ca :

def test_carre_positif():
assert carre(3) == 9
assert carre(5) == 25

def test_carre_zero():
assert carre(0) == 0

def test_carre_negatif():
assert carre(-3) == 9

Chaque fonction teste UN aspect precis. Le nom de la fonction dit exactement ce qu'on teste. Si un test echoue, tu sais immediatement ou est le problème sans lire le code.

Pour aller plus loin, on peut créer une fonction run_tests() qui exécute toutes les fonctions de test et renvoie un compte-rendu.

Écris une fonction run_tests(func) qui prend une fonction de calcul de la valeur absolue (qui devrait renvoyer la valeur absolue d'un nombre) et qui :

1. Definit au moins 3 fonctions de test internes (nommees test_xxx)
2. Execute chaque fonction de test dans un try/except
3. Renvoie un dictionnaire avec le nom de chaque test en clé et True (passe) ou False (echoue) en valeur

Exemple :

def ma_valeur_abs(n):
if n < 0:
return -n
return n

run_tests(ma_valeur_abs) renvoie {'test_positif': True, 'test_negatif': True, 'test_zero': True}

def buggy(n):
return n

run_tests(buggy) renvoie {'test_positif': True, 'test_negatif': False, 'test_zero': True}

Tests (4/5)

Fonction correcte

def bonne_abs(n):
    return n if n >= 0 else -n
r = run_tests(bonne_abs)
assert all(r.values()), f'Tous les tests devraient passer pour une bonne valeur absolue, mais on a {r}'

Fonction buggee detectee

def mauvaise_abs(n):
    return n
r = run_tests(mauvaise_abs)
assert not all(r.values()), 'Tes tests devraient detecter que cette fonction ne gere pas les negatifs'

Au moins 3 tests

def dummy(n): return abs(n)
r = run_tests(dummy)
assert len(r) >= 3, f'Tu dois avoir au moins 3 fonctions de test, tu en as {len(r)}'

Les clés commencent par test_

def dummy(n): return abs(n)
r = run_tests(dummy)
for nom in r.keys():
    assert nom.startswith('test_'), f'Le nom {nom} devrait commencer par test_'

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

def run_tests(func):
    def test_positif():
        assert func(5) == 5
        assert func(42) == 42

    def test_negatif():
        assert func(-3) == 3
        assert func(-100) == 100

    def test_zero():
        assert func(0) == 0

    tests = [test_positif, test_negatif, test_zero]
    résultats = {}
    for test in tests:
        try:
            test()
            résultats[test.__name__] = True
        except AssertionError:
            résultats[test.__name__] = False
    return résultats

← Écrire un premier test assert Tester les cas limites →

solution.py

Bravo!

Structurer ses tests en fonctions

Tests (4/5)

Indices (3 disponibles)

Solution officielle