Les tests unitaires en Python avec pytest

Pourquoi tester son code ? L'importance des tests unitaires

Tu as passé des heures à coder une fonction complexe pour ton projet NSI. Elle semble fonctionner avec les exemples que tu as essayés. Mais es-tu sûr à 100% qu'elle gère tous les cas, y compris les erreurs ? C'est là que les tests unitaires entrent en jeu. Un test unitaire est un petit programme qui vérifie automatiquement qu'une partie spécifique de ton code (une fonction, une méthode) se comporte comme prévu. En NSI, et plus tard dans tes études ou ton métier, écrire des tests n'est pas une option, c'est une pratique professionnelle essentielle. Cela te permet de :

• Détecter les bugs rapidement : Dès que tu modifies ton code, les tests te disent si tu as cassé quelque chose.
• Gagner du temps : Plus besoin de tout tester manuellement à chaque changement.
• Documenter ton code : Les tests montrent concrètement comment tes fonctions sont censées être utilisées.
• Travailler en équipe : Tes camarades peuvent modifier le projet en confiance, sachant que les tests vérifieront leur travail.

Parmi les outils de test en Python, pytest s'est imposé comme le plus simple, puissant et populaire. C'est celui que nous allons explorer ensemble.

Installer et configurer pytest pour tes projets

La première étape est d'installer pytest. Comme souvent en Python, on utilise pip. Ouvre ton terminal ou l'invite de commandes et tape :

pip install pytest

Pour vérifier que l'installation a réussi, tu peux taper pytest --version. Maintenant, organisons un projet type. Crée un dossier pour ton projet, par exemple mon_projet_nsi. À l'intérieur, crée deux fichiers :

• operations.py : Ce fichier contiendra le code que tu veux tester (le « code métier »).
• test_operations.py : Ce fichier contiendra tous tes tests. La convention avec pytest est de préfixer les fichiers de test par test_.

Cette séparation est cruciale pour garder ton projet propre. Dans operations.py, écris une fonction simple pour commencer :

def addition(a, b):
"""Retourne la somme de a et b."""
return a + b

Ton environnement de test est prêt !

Écrire ton premier test avec pytest

Ouvre maintenant le fichier test_operations.py. Avec pytest, écrire un test est incroyablement simple. Il suffit d'écrire une fonction dont le nom commence aussi par test_. À l'intérieur, on utilise l'instruction assert pour vérifier une condition.

from operations import addition

def test_addition_nombres_positifs():
# Arrange (Préparer) : On définit les données d'entrée.
a = 5
b = 3
# Act (Agir) : On appelle la fonction à tester.
resultat = addition(a, b)
# Assert (Vérifier) : On compare le résultat à la valeur attendue.
assert resultat == 8

Pour exécuter tes tests, retourne dans ton terminal, place-toi dans le dossier mon_projet_nsi et lance simplement la commande :

pytest

Pytest va automatiquement chercher tous les fichiers test_*.py, exécuter les fonctions test_* et te donner un rapport. Si tout est vert (PASSED), félicitations ! Tu viens d'écrire et de passer ton premier test unitaire.

Aller plus loin : tester plusieurs cas et les échecs

Un bon test couvre plusieurs scénarios. Au lieu d'écrire dix fonctions, pytest te permet d'utiliser des paramètres. Modifions notre test :

import pytest
from operations import addition

@pytest.mark.parametrize("a, b, attendu", [
(5, 3, 8), # Nombres positifs
(-2, 7, 5), # Nombre négatif et positif
(0, 0, 0), # Zéros
(2.5, 1.5, 4.0), # Nombres à virgule
])
def test_addition_parametree(a, b, attendu):
assert addition(a, b) == attendu

Et si ta fonction peut échouer ? Par exemple, une fonction qui fait une division. Il faut tester qu'elle lève bien l'exception attendue (ZeroDivisionError).

import pytest
from operations import division # Supposons cette fonction écrite

def test_division_par_zero():
with pytest.raises(ZeroDivisionError):
division(10, 0)

Bonnes pratiques et intégration dans ton workflow NSI

Écrire des tests, c'est bien. Écrire de bons tests, c'est mieux. Voici quelques conseils pour tes projets :

• Un test, une idée : Chaque fonction de test doit vérifier un seul comportement. Cela rend les échecs plus faciles à comprendre.
• Nommage explicite : test_addition_nombres_positifs est bien plus clair que test1.
• Tester les cas limites : Que se passe-t-il avec une liste vide ? Avec un très grand nombre ? Avec une entrée inattendue ? C'est souvent là que les bugs se cachent.
• Tests indépendants : Un test ne doit pas dépendre du résultat d'un autre. Pytest exécute les tests dans un ordre aléatoire par défaut.

Comment intégrer cela à ton workflow en NSI ?
1. Avant de coder (Méthode TDD - Test Driven Development) : Écris d'abord les tests pour la fonctionnalité que tu imagines. Ils vont échouer (rouge).
2. Écris le code le plus simple pour faire passer les tests (vert).
3. Améliore (refactorise) ton code en toute confiance, car les tests te protègent.
Cette boucle Red-Green-Refactor est un pilier du développement moderne.

pytest vs. unittest : lequel choisir pour la NSI ?

Tu entendras peut-être parler du module unittest, intégré directement à Python. Alors, lequel utiliser ?

• pytest : Plus concis, plus flexible, plus « pythonique ». La syntaxe est simple (juste assert). C'est le choix de la majorité de la communauté. Il peut d'ailleurs exécuter les tests écrits avec unittest.
• unittest : Inspiré des frameworks Java (comme JUnit). Il utilise des classes et des méthodes comme self.assertEqual(). Il est plus verbeux mais peut être demandé dans certains contextes académiques.

Notre recommandation pour la NSI : commence avec pytest. Sa simplicité te permet de te concentrer sur l'apprentissage des concepts de test sans te perdre dans du code boilerplate. Tu auras une longueur d'avance pour tes projets personnels et post-bac.

En maîtrisant pytest, tu ne rendras pas seulement ton code plus fiable pour l'épreuve pratique, tu acquerras une compétence professionnelle valorisée sur ton CV. Alors, à toi de jouer : écris une fonction, puis écris ses tests !