{"canonical_url":"https://engineer.company/fr/glossary/unit-test/","content_markdown":"# Test unitaire\n\n## Ce que c'est\n\nUn test unitaire est une petite vérification automatisée d'un élément de code pris isolément :\nil appelle une fonction, une classe ou un petit module avec des entrées choisies et vérifie que\nle résultat est bien celui attendu. Ces tests sont généralement conçus pour s'exécuter dans le\nmême processus que le code vérifié, finir rapidement et ne nécessiter ni réseau, ni base de données,\nni navigateur. Ce sont des choix utiles en matière de ressources et d'isolation, pas des garanties qui\ndécoulent du seul périmètre réduit du test. La pratique qui consiste à les écrire est généralement appelée\ntest unitaire, et leur ensemble dans un projet constitue sa suite de tests unitaires.\n\nCe qui constitue une unité est moins établi que son nom ne le suggère. Dans le chapitre sur les\ntests unitaires de _Software Engineering at Google_, Erik Kuefler emploie le terme pour des tests\nde portée relativement réduite, comme une classe ou une méthode, et ajoute qu'une unité peut aller\nd'une fonction à plusieurs paquets liés. La frontière utile se situe à l'interface appelée de l'extérieur :\nune unité fournit une interface dont dépendent des appelants extérieurs, et ses tests utilisent\ncette interface comme le font ces appelants.\n\nLes frameworks modernes ont une ascendance commune. L'article de Kent Beck, _Simple Smalltalk\nTesting: With Patterns_, décrit un petit framework composé de fixtures, de cas de\ntest, de vérifications et de suites, et recommande aux développeurs d'écrire eux-mêmes leurs tests\nunitaires, un par classe. La documentation de `unittest` en Python indique qu'il s'inspire à\nl'origine de JUnit et conserve les quatre mêmes idées : la fixture de test, préparation nécessaire\nau test et nettoyage qui le suit ; le cas de test, unité individuelle de test ; la suite de tests ;\net l'exécuteur de tests. Les deux tracent une distinction à conserver : un échec est une vérification\nqui a reçu une mauvaise réponse, tandis qu'une erreur est un événement que le test n'avait pas du\ntout prévu, comme une exception levée au fond du code.\n\nLes tests unitaires sont les tests au périmètre le plus restreint. Le chapitre d'Adam Bender sur les\ntests dans le même livre les classe selon leur portée : les tests de portée réduite sont\ncouramment appelés tests unitaires, les tests de portée moyenne couvrant plusieurs composants\nensemble sont des tests d'intégration, et les tests de grande portée qui pilotent tout le système\nsont des tests de bout en bout.\n\n## Pourquoi c'est important\n\nLa rapidité est la première raison. Un petit test unitaire isolé s'exécute dans le même processus\nque le code vérifié : un ingénieur peut donc en exécuter des milliers dans une journée ordinaire,\net une erreur apparaît alors que la modification qui l'a causée est encore à l'écran. Les règles\nde Google sont nettes sur ce qu'elles autorisent : un petit test ne doit ni suspendre son exécution pour attendre,\nni effectuer d'entrées-sorties, ni accéder au réseau ou au disque. Ces contraintes facilitent la\nconstruction de tests rapides et répétables, et une équipe apprend à se fier à une suite qui donne\nla même réponse à chaque fois.\n\nLa deuxième raison est le diagnostic. Lorsqu'un test de portée réduite échoue, le défaut se trouve\ndans une petite partie du code, généralement celle qui vient de changer. Lorsqu'un test pilotant\ntout le système échoue, le défaut peut être n'importe où entre le navigateur et la base de données.\nC'est pourquoi _Software Engineering at Google_ présente une pyramide comme une indication\napproximative : environ 80 % de tests de portée réduite, 15 % de tests d'intégration et 5 % de tests\nde bout en bout.\n\nLa troisième raison est le changement. Une suite qui vérifie le comportement à travers une\ninterface publique permet de restructurer le code derrière cette interface sans crainte : si les\ntests réussissent encore, les besoins des appelants restent satisfaits. L'idéal de Kuefler est un test qui\nne doit jamais changer sans changement des exigences ; une simple refonte interne ne touche donc\naucun test.\n\nLes tests unitaires servent aussi de documentation. Un test nommé d'après un comportement, avec\ndes entrées simples et un résultat attendu écrit en entier, montre au prochain lecteur comment\nappeler le code et ce qu'il promet ; contrairement à un commentaire, il échoue lorsque cela cesse\nd'être vrai.\n\n## À quoi cela ressemble en pratique\n\nPrenons une fonction qui lit des durées comme `1h30m` dans un fichier de configuration et les\nconvertit en secondes :\n\n```python\n# durations.py\nUNITS = {\"h\": 3600, \"m\": 60, \"s\": 1}\n\n\ndef to_seconds(text: str) -\u003e int:\n    \"\"\"Turn \"1h30m\" or \"45s\" into a whole number of seconds.\"\"\"\n    total, digits = 0, \"\"\n    for char in text:\n        if char.isdigit():\n            digits += char\n        elif char in UNITS and digits:\n            total += int(digits) * UNITS[char]\n            digits = \"\"\n        else:\n            raise ValueError(f\"not a duration: {text!r}\")\n    if digits or not text:\n        raise ValueError(f\"not a duration: {text!r}\")\n    return total\n```\n\nSes tests unitaires, écrits pour pytest, vérifient deux comportements : ce qu'elle accepte et ce\nqu'elle refuse.\n\n```python\n# test_durations.py\nimport pytest\n\nfrom durations import to_seconds\n\n\n@pytest.mark.parametrize(\n    \"text,expected\",\n    [(\"45s\", 45), (\"2m\", 120), (\"1h30m\", 5400), (\"0s\", 0)],\n)\ndef test_counts_each_unit(text, expected):\n    assert to_seconds(text) == expected\n\n\n@pytest.mark.parametrize(\"text\", [\"\", \"90\", \"h\", \"1x\", \"1.5h\"])\ndef test_refuses_what_it_cannot_read(text):\n    with pytest.raises(ValueError):\n        to_seconds(text)\n```\n\nDans le répertoire, `pytest` repère tous les fichiers nommés `test_*.py` ou `*_test.py` ;\nles deux fonctions donnent neuf cas, un par ligne de paramètres. La documentation de pytest\ndécrit chaque test comme une préparation, une action, une assertion et un nettoyage ; ici, la\npréparation est la ligne de paramètres, l'action est l'appel unique, et il n'y a rien à nettoyer\npuisque rien en dehors de la fonction n'est touché. Si quelqu'un fixe ensuite par erreur la minute\nà 3 600 secondes, deux cas échouent et le rapport nomme chacun par ses paramètres :\n`test_counts_each_unit[2m-120]` affiche 7 200 au lieu des 120 attendus, et\n`test_counts_each_unit[1h30m-5400]` affiche 111 600 au lieu de 5 400. Les valeurs attendues sont calculées\nà la main, pas copiées sur ce qu'a renvoyé le code à sa première exécution.\n\nLes mêmes vérifications dans le `unittest` de la bibliothèque standard seraient une sous-classe\nde `unittest.TestCase` avec des méthodes dont le nom commence par `test`, utilisant `assertEqual`\net `assertRaises` ; `python -m unittest` trouve par défaut les fichiers correspondant à `test*.py`.\nGo intègre cette convention dans sa chaîne d'outils : une fonction `func TestXxx(t *testing.T)`\ndans un fichier finissant par `_test.go` est exécutée par `go test`.\n\nL'augmentation du volume change le suivi, pas le principe. Le\n[générateur de base de données soumis à 981 cas de test](/fr/portfolio/held-the-generator-to-981-tests-and-92-coverage/),\ndans le cadre d'un travail réalisé en juillet 2026, compte 383 fonctions de test qui deviennent 981 cas une fois les\ntests paramétrés développés, répartis dans 45 fichiers et 7 944 lignes. Sa compilation impose un\nplancher de couverture des branches de 92 %, avec environ 95 % mesurés, et traite les avertissements\ncomme des échecs. La page expose franchement la limite du chiffre : deux défauts découverts plus\ntard se trouvaient dans du code que le rapport de couverture indiquait comme couvert.\n\n## Où les problèmes surviennent\n\n**Les tests reproduisent l'implémentation.** Un test qui accède à des fonctions auxiliaires privées\nou vérifie la séquence exacte des appels internes casse à chaque restructuration, alors que rien\nde visible pour un appelant n'a changé. Kuefler parle de test fragile et désigne le recours excessif\naux frameworks de simulation comme la cause la plus fréquente des problèmes de tests d'interactions.\nTestez par l'interface publique, vérifiez l'état obtenu plutôt que les appels qui y ont mené et\nutilisez de vrais objets lorsqu'ils sont peu coûteux.\n\n**Les tests dépendent les uns des autres.** Un test crée un enregistrement, le suivant le lit,\net la suite ne réussit que dans cet ordre. Exécutez un seul test, ou les mêmes dans un autre ordre,\net elle échoue sans raison visible pour le lecteur. Le framework de Beck créait puis jetait ses\ndonnées pour chaque test, et la documentation de `unittest` demande qu'un cas de test soit entièrement\nautonome. Donnez à chaque test sa propre fixture et nettoyez après son exécution.\n\n**La couverture devient le but.** La couverture montre qu'une ligne s'est exécutée, pas qu'une\nvérification a contrôlé son effet. Un test sans assertion augmente le chiffre et ne prouve rien ;\n_Software Engineering at Google_ avertit qu'une barre de 80 % tend à devenir un plafond, avec des\nmodifications qui arrivent exactement au minimum. Traitez le chiffre comme un plancher et lisez\nles assertions en revue.\n\n**Un test par méthode.** Associer chaque méthode de production à une méthode de test semble\nordonné, mais le test grossit à chaque nouvelle branche de la méthode, jusqu'à ce que personne ne\nsache dire ce qu'il vérifie. Kuefler conseille de tester les comportements : un comportement par\ntest, nommé selon ce qu'il prouve, pour que le rapport d'échec se lise comme une phrase décrivant\nce qui a cassé.\n\n**Le test attend que le temps passe.** Un `sleep()` pour laisser quelque chose finir ralentit la\nsuite à chaque exécution et échoue encore sur une machine chargée. Dans un test unitaire, le temps\nest une entrée : passez une horloge ou un horodatage, pour que le test choisisse lui-même l'instant voulu\nau lieu de l'attendre.\n\n## Pour aller plus loin\n\n- [unittest : framework de tests unitaires](https://docs.python.org/3/library/unittest.html)\n  — le framework de la bibliothèque standard Python : fixtures, cas de test, suites, exécuteurs,\n  découverte et distinction entre échec et erreur.\n- [Anatomie d'un test](https://docs.pytest.org/en/stable/explanation/anatomy.html)\n  — l'explication de pytest sur la préparation, l'action, l'assertion et le nettoyage.\n- [Premiers pas](https://docs.pytest.org/en/stable/getting-started.html)\n  — l'introduction de pytest : simple `assert`, découverte des tests et `pytest.raises`.\n- [Tests unitaires](https://abseil.io/resources/swe-book/html/ch12.html)\n  — le chapitre d'Erik Kuefler dans _Software Engineering at Google_ sur les tests fragiles,\n  les API publiques, l'état plutôt que les interactions et les tests de comportement.\n- [Simple Smalltalk Testing: With Patterns](https://web.archive.org/web/20150315073817/http://www.xprogramming.com/testfram.htm)\n  — l'article de Kent Beck sur le framework, l'argument en faveur d'un test unitaire par classe\n  et la distinction entre échecs et erreurs, dans une copie archivée.\n- [testing](https://pkg.go.dev/testing)\n  — le paquet de test standard de Go : fonctions `TestXxx`, fichiers `_test.go` et `go test`.\n\n\u003chttps://engineer.company/fr/glossary/unit-test/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Ce qui constitue une unité, comment garder un test rapide et indépendant, un exemple avec pytest et les habitudes qui fragilisent une suite.","formats":{"gemtext":"https://engineer.company/fr/glossary/unit-test/index.gmi","gopher":"https://engineer.company/fr/glossary/unit-test/gophermap","html":"https://engineer.company/fr/glossary/unit-test/","json":"https://engineer.company/fr/glossary/unit-test/index.json","markdown":"https://engineer.company/fr/glossary/unit-test/index.md","pdf":"https://engineer.company/fr/glossary/unit-test/index.pdf"},"kind":"page","language":"fr","title":"Qu'est-ce qu'un test unitaire ?","url":"https://engineer.company/fr/glossary/unit-test/","version":1}