Aller au contenu
English
Compte : non connecté, synchronisation possible Mon apprentissage
Selectionner le thème
English
Read in English

pytest : écrire et lancer des tests en Python

Par mis à jour le

Améliorer cette page

Logo Python

pytest est un framework de test très répandu en Python. Un test s'écrit avec une simple fonction et le mot-clé assert, sans classe ni cérémonie. Ce guide part de zéro : vous installez pytest, écrivez un premier test, le lancez, puis vous montez en puissance avec le paramétrage, les fixtures, le test des exceptions et la couverture de code. Les exemples visent pytest 9, dont la dernière version stable est la 9.2.0 (publiée le 2026-10-27, Python 3.10 ou supérieur requis).

Il s'adresse aux développeurs qui veulent des scripts fiables et à celles et ceux qui intègrent des tests dans un pipeline CI/CD. À la différence de unittest, intégré à Python mais plus verbeux, pytest privilégie la concision : moins de code pour le même résultat.

  • Installer pytest et écrire un premier test avec assert.
  • Lancer vos tests et lire un rapport d'échec.
  • Paramétrer un test pour couvrir plusieurs cas sans le dupliquer.
  • Factoriser la préparation avec des fixtures.
  • Vérifier qu'une fonction lève bien une exception.
  • Mesurer la couverture de votre code testé.

Python fournit déjà unittest dans sa bibliothèque standard. Alors pourquoi installer autre chose ? Parce que pytest réduit le code à écrire. Là où unittest impose une classe qui hérite de TestCase et des méthodes comme assertEqual, pytest se contente d'une fonction et du mot-clé assert. Le même test tient en moins de lignes et se lit d'un coup d'œil.

pytest apporte aussi le paramétrage des tests, des fixtures pour préparer les données, des messages d'échec détaillés (il montre les valeurs comparées) et de nombreux plugins (couverture, tests asynchrones, Django). Beaucoup de projets Python l'ont adopté : les exemples et les plugins y sont faciles à trouver.

pytest s'installe dans un environnement virtuel, pour ne pas polluer votre Python système. Si vous n'avez encore jamais créé d'environnement virtuel, la page liée explique comment.

Fenêtre de terminal
pip install pytest

Vérifiez l'installation. La sortie doit afficher la version installée :

Fenêtre de terminal
pytest --version
# pytest 9.2.0 (la sortie est de cette forme, selon la version installée)

Prenons un module à tester, calculs.py :

calculs.py
def addition(a, b):
return a + b
def diviser(a, b):
if b == 0:
raise ValueError("division par zéro")
return a / b

La fonction diviser ne sert pas encore : elle est testée plus bas, avec pytest.raises et pytest.approx.

Le test vit dans un fichier dont le nom commence par test_ (ou se termine par _test.py), avec une fonction dont le nom commence aussi par test_. On y utilise le mot-clé assert :

test_calculs.py
from calculs import addition
def test_addition():
assert addition(2, 3) == 5

Lancez la commande pytest à la racine du projet. pytest découvre automatiquement les fichiers et fonctions test_* :

Fenêtre de terminal
pytest
============================= test session starts ==============================
platform linux -- Python 3.13.5, pytest-9.2.0, pluggy-1.7.0
rootdir: /chemin/vers/mon_projet
collected 1 item
test_calculs.py . [100%]
============================== 1 passed in 0.01s ===============================

Les lignes platform et rootdir dépendent de votre poste. Un point signale chaque test réussi. Cette découverte automatique est un des grands conforts de pytest : pas de liste de tests à maintenir.

L'intérêt d'un test est de signaler une régression. Si addition renvoyait un résultat faux, pytest afficherait précisément l'écart :

def test_addition():
> assert addition(2, 3) == 5
E assert 6 == 5
E + where 6 = addition(2, 3)
test_calculs.py:5: AssertionError
=========================== short test summary info ============================
FAILED test_calculs.py::test_addition - assert 6 == 5
============================== 1 failed in 0.02s ===============================

pytest montre la ligne fautive, les valeurs comparées (6 == 5) et d'où vient la valeur. Pas besoin d'ajouter des print() : le rapport contient déjà l'essentiel pour comprendre.

Quelques options utiles au quotidien :

Fenêtre de terminal
pytest -v # détaille chaque test (verbose)
pytest -q # sortie compacte
pytest test_calculs.py # un seul fichier
pytest -k addition # seulement les tests dont le nom contient "addition"
pytest -x # s'arrête au premier échec

Tester addition sur une seule paire de valeurs est insuffisant. Plutôt que d'écrire un test par cas, le décorateur @pytest.mark.parametrize rejoue la même fonction avec plusieurs jeux de données :

import pytest
from calculs import addition
@pytest.mark.parametrize("a, b, attendu", [
(2, 3, 5),
(-1, 1, 0),
(0, 0, 0),
])
def test_addition(a, b, attendu):
assert addition(a, b) == attendu

pytest compte alors trois tests distincts, un par ligne, et nomme chacun par ses valeurs :

test_calculs.py::test_addition[2-3-5] PASSED
test_calculs.py::test_addition[-1-1-0] PASSED
test_calculs.py::test_addition[0-0-0] PASSED

Si un cas échoue, vous savez immédiatement lequel. C'est la façon idiomatique de couvrir les cas limites sans dupliquer le code.

Une fixture prépare un contexte réutilisable (des données, une connexion, un fichier temporaire) et l'injecte dans les tests qui en ont besoin. On la déclare avec @pytest.fixture, et un test la reçoit simplement en la nommant dans ses paramètres :

import pytest
@pytest.fixture
def utilisateur():
return {"nom": "Alice", "roles": ["admin"]}
def test_droits_admin(utilisateur):
assert "admin" in utilisateur["roles"]
def test_nom(utilisateur):
assert utilisateur["nom"] == "Alice"

Par défaut, chaque test reçoit une instance fraîche de la fixture, ce qui garantit leur indépendance : un test ne peut pas polluer l'autre. pytest fournit aussi des fixtures intégrées très utiles, comme tmp_path pour un dossier temporaire propre à chaque test.

Tester le chemin d'erreur est aussi important que le cas nominal. Le gestionnaire de contexte pytest.raises vérifie qu'un bloc lève bien l'exception attendue, et match contrôle le message :

import pytest
from calculs import diviser
def test_division_par_zero():
with pytest.raises(ValueError, match="division par zéro"):
diviser(10, 0)

Pour comparer des nombres flottants, dont l'égalité stricte est piégeuse, utilisez pytest.approx :

def test_resultat_flottant():
assert diviser(10, 3) == pytest.approx(3.3333, rel=1e-3)

La couverture indique quelle part de votre code est réellement exécutée par les tests. Le plugin pytest-cov l'ajoute à pytest :

Fenêtre de terminal
pip install pytest-cov
pytest --cov=calculs --cov-report=term-missing
Name Stmts Miss Cover Missing
------------------------------------------
calculs.py 6 0 100%
------------------------------------------
TOTAL 6 0 100%

La colonne Missing liste les lignes jamais exécutées par un test, donc non vérifiées.

Sur un vrai projet, le code et les tests vivent séparés : les tests dans un dossier tests/, et les fixtures communes dans un fichier conftest.py que pytest charge automatiquement pour tout le dossier.

  • Répertoiremon_projet/
    • calculs.py
    • Répertoiretests/
      • conftest.py
      • test_calculs.py

Avec cette disposition, test_calculs.py ne trouve plus le module calculs. Ce module n'est importable que si le dossier du projet figure dans le chemin de recherche de Python, et pytest ne l'y met pas tout seul quand les tests sont dans tests/. Sans réglage, la commande pytest s'arrête à la collecte avec ModuleNotFoundError: No module named 'calculs'. Deux solutions : lancer python -m pytest, qui ajoute le dossier courant à ce chemin, ou déclarer l'option pythonpath de pytest dans le pyproject.toml :

[tool.pytest.ini_options]
pythonpath = ["."]

Ce découpage garde le projet lisible et permet de lancer toute la suite d'une seule commande pytest. Intégrée dans un pipeline CI/CD, cette commande devient un filet de sécurité : chaque modification est validée automatiquement avant d'être fusionnée ou déployée.

Le dernier lab du fil rouge de la formation Python vous fait écrire la suite pytest de security_check.py, avec CliRunner de Click pour les codes de sortie. Elle n'est pas notée sur son nombre de tests verts, mais sur ce qu'elle attrape : c'est le test par mutation. Votre suite doit passer sur l'outil de référence, puis échouer sur quatre mutants qui portent chacun un bug réaliste : seuil exclusif, casse oubliée, doublons comptés, rapport absent qui rend 1. Une suite qui ne tue aucun mutant ne protège de rien.

Ce lab clôt le fil rouge de la formation Python et utilise Click. Dans la formation sur les applications générées par IA, où cette leçon est partagée, il est facultatif.

  • pytest teste avec une simple fonction test_* et le mot-clé assert, sans classe.
  • La commande pytest découvre seule les fichiers et fonctions de test.
  • En cas d'échec, le rapport montre les valeurs comparées et la ligne fautive.
  • @pytest.mark.parametrize rejoue un test sur plusieurs cas sans le dupliquer.
  • Une fixture prépare un contexte réutilisable et indépendant entre tests.
  • pytest.raises vérifie les exceptions, pytest.approx compare les flottants.
  • pytest-cov mesure la couverture, mais 100 % ne garantit pas l'absence de bugs.
  • pytest exécute aussi les tests unittest : la migration peut être progressive.

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions
6 min.
70% requis

Informations

  • Le chronomètre démarre au clic sur Démarrer
  • Questions à choix multiples, vrai/faux et réponses courtes
  • Vous pouvez naviguer entre les questions
  • Les résultats détaillés sont affichés à la fin

Lance le quiz et démarre le chronomètre