Test parametrise

Tu as 20 cas a tester pour une seule fonction, et tu te retrouves a copier-coller le meme assert en changeant juste les valeurs :

assert convertir(0) == 32 # 0 C = 32 F
assert convertir(100) == 212 # 100 C = 212 F
assert convertir(-40) == -40 # -40 C = -40 F

C'est repetitif. Et si tu as 20 cas a tester, ca devient vite penible. Le test parametrise resout ce problème : tu definis une liste de cas (entrée, sortie attendue) et tu boucles dessus.

En Python pur, ca donne :

cas_de_test = [
(0, 32),
(100, 212),
(-40, -40),
]

for entrée, attendu in cas_de_test:
résultat = convertir(entrée)
assert résultat == attendu, f"convertir({entrée}) a renvoye {résultat}, attendu {attendu}"

C'est exactement ce que fait le decorateur @pytest.mark.parametrize de pytest, mais en plus simple. L'avantage est que pour ajouter un cas de test, tu ajoutes juste une ligne dans la liste.

Écris une fonction run_parametrized(func, cas_de_test) qui :

1. Prend une fonction func et une liste de tuples (entrée, attendu)
2. Execute func(entrée) pour chaque cas
3. Renvoie un dictionnaire avec :
- "passes" : le nombre de tests qui passent
- "echecs" : le nombre de tests qui echouent
- "details" : une liste de dicts avec "entrée", "attendu", "obtenu", "ok" pour chaque cas

Exemple :

def double(n):
return n * 2

cas = [(2, 4), (0, 0), (3, 6), (-1, -2)]
r = run_parametrized(double, cas)
r vaut {"passes": 4, "echecs": 0, "details": [{"entrée": 2, "attendu": 4, "obtenu": 4, "ok": True}, ...]}

def buggy_double(n):
return n + n if n > 0 else 0

cas = [(2, 4), (0, 0), (-1, -2)]
r = run_parametrized(buggy_double, cas)
r["echecs"] vaut 1 (le cas -1 echoue)

Tests (4/5)

Tous les tests passent

def double(n): return n * 2
cas = [(2, 4), (0, 0), (3, 6), (-1, -2)]
r = run_parametrized(double, cas)
assert r['passes'] == 4 and r['echecs'] == 0

Detecte un echec

def buggy(n): return n * 2 if n > 0 else 0
cas = [(2, 4), (0, 0), (-1, -2)]
r = run_parametrized(buggy, cas)
assert r['echecs'] == 1, f'Il devrait y avoir 1 echec, on en a {r["echecs"]}'

Les details sont corrects

def carre(n): return n ** 2
cas = [(3, 9), (0, 0)]
r = run_parametrized(carre, cas)
assert len(r['details']) == 2
assert r['details'][0] == {'entrée': 3, 'attendu': 9, 'obtenu': 9, 'ok': True}

Gere un seul cas

def identite(n): return n
r = run_parametrized(identite, [(5, 5)])
assert r['passes'] == 1 and r['echecs'] == 0

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

def run_parametrized(func, cas_de_test):
    passes = 0
    echecs = 0
    details = []

    for entrée, attendu in cas_de_test:
        obtenu = func(entrée)
        ok = obtenu == attendu
        if ok:
            passes += 1
        else:
            echecs += 1
        details.append({
            "entrée": entrée,
            "attendu": attendu,
            "obtenu": obtenu,
            "ok": ok,
        })

    return {"passes": passes, "echecs": echecs, "details": details}

← Mock basique Tester un validateur (approche TDD) →

solution.py

Bravo!

Test parametrise

Tests (4/5)

Indices (3 disponibles)

Solution officielle