Les tests unitaires en Python

1. Pourquoi tester son code ?

Quand on écrit un programme, il peut contenir des erreurs (bugs). Pour s’assurer que les fonctions produisent le bon résultat, on peut écrire des tests.

Un test unitaire permet de vérifier qu'une fonction donne le bon résultat pour une entrée donnée.

✅ Avantage : cela permet de repérer rapidement les erreurs et de vérifier que tout fonctionne après une modification du code.

2. Tester manuellement une fonction

Imaginons une fonction qui calcule le carré d’un nombre :

def carre(x):
    return x * x

print(carre(2))  # Devrait afficher 4
print(carre(-3)) # Devrait afficher 9

👉 Ici, on teste manuellement la fonction, mais ce n’est pas idéal si on a beaucoup de cas à tester.

3. Utiliser assert pour automatiser les tests

Python propose une instruction appelée assert (affirmer que) :

assert carre(2) == 4
assert carre(-3) == 9

➡️ Si l’égalité est vraie, Python continue.
➡️ Si elle est fausse, une erreur est levée et le programme s’arrête.

assert carre(3) == 10  # Erreur : 9 != 10

4. Créer une fonction de test

On peut créer une fonction spéciale pour tester d’autres fonctions :

def test_carre():
    assert carre(0) == 0
    assert carre(5) == 25
    assert carre(-2) == 4
    print("Tous les tests passent !")

test_carre()

5. Les erreurs les plus courantes

  • Ne pas couvrir tous les cas possibles (positif, zéro, négatif…)
  • Comparer des types différents (ex. : float et int)
  • Confondre valeur attendue et valeur retournée

6. Tests unitaires avec unittest (optionnel/bonus)

Python propose un module spécial pour les tests : unittest.

import unittest

def carre(x):
    return x * x

class TestFonctions(unittest.TestCase):
    def test_carre(self):
        self.assertEqual(carre(3), 9)
        self.assertEqual(carre(0), 0)
        self.assertEqual(carre(-2), 4)

unittest.main()

✅ Utile pour des projets plus gros, mais le mot-clé assert suffit souvent au lycée.

🧠 À retenir

  • Les tests unitaires servent à vérifier le bon fonctionnement d’une fonction.
  • Le mot-clé assert permet de détecter automatiquement si une valeur est incorrecte.
  • Les tests doivent couvrir plusieurs cas : valeurs normales, limites, erreurs.

Exercices

Exercice 1 – Tester une fonction factorielle

Voici une fonction factorielle à compléter :

def factorielle(n):
    if n == 0:
        return 1
    else:
        return n * factorielle(n - 1)
  1. Écrivez une fonction test_factorielle() avec plusieurs assert :
  • factorielle(0) doit renvoyer 1
  • factorielle(3) doit renvoyer 6
  • factorielle(5) doit renvoyer 120

Exercice 2 – Trouver l'erreur

Voici une fonction somme_pairs censée additionner les nombres pairs d'une liste :

def somme_pairs(liste):
    total = 0
    for x in liste:
        if x % 2 == 1:
            total += x
    return total
  1. Testez cette fonction avec :
assert somme_pairs([1, 2, 3, 4]) == 6
  1. Corrigez la fonction pour qu’elle fonctionne comme prévu.

Exercice 3 – Tester une fonction est_palindrome

Écrivez une fonction est_palindrome(mot) qui renvoie True si un mot est un palindrome (ex. "radar", "bob").

  1. Écrivez la fonction.
  2. Écrivez les tests unitaires suivants :
assert est_palindrome("radar") == True
assert est_palindrome("python") == False
assert est_palindrome("kayak") == True

Exercice 4 – Une erreur silencieuse

def divise(a, b):
    return a // b
  1. Écrivez un test qui vérifie que divise(10, 2) donne 5.
  2. Que se passe-t-il si vous testez divise(10, 0) ?
  3. Ajoutez un test qui provoque une erreur attendue, et ajoutez une condition de sécurité dans la fonction.