À retenir
- Le TDD consiste à écrire le test avant le code, selon un cycle court : rouge, vert, refactor.
- En 2026, PHPUnit 13 exige PHP 8.4 et s'installe par projet avec Composer ; les annotations ont cédé la place aux attributs PHP.
- L'erreur la plus fréquente consiste à négliger l'étape de refactoring, qui donne pourtant au code sa structure durable.
Qu'est-ce que le test driven development (TDD) ?
Le test driven development, ou développement piloté par les tests, inverse l'ordre habituel du travail. Au lieu d'écrire une fonctionnalité puis de la vérifier, le développeur commence par écrire un test automatisé qui décrit le comportement attendu. Ce test échoue, puisque le code n'existe pas encore. Le développeur écrit alors le minimum de code nécessaire pour le faire passer, puis améliore la structure de l'ensemble sans changer son comportement.
La méthode a été formalisée par Kent Beck à la fin des années 1990, dans le cadre de l'Extreme Programming, puis exposée dans son livre Test-Driven Development: By Example. Elle s'applique à presque tous les langages, du PHP au JavaScript, dès lors qu'il existe un outil capable d'exécuter des tests automatisés. Son intérêt ne tient pas au test lui-même, que l'on pourrait écrire après coup, mais à la discipline qu'elle impose : chaque ligne de code répond à un besoin exprimé et vérifié.
Le cycle du TDD : rouge, vert, refactor
Le TDD repose sur une boucle très courte, répétée pour chaque comportement à ajouter. Dans la présentation qu'il en donne, Martin Fowler recommande de dresser au préalable la liste des cas de test à traiter, puis d'enchaîner les trois étapes suivantes.
- Rouge : écrire un test qui échoue. Le test décrit un seul comportement, par exemple le calcul d'un prix toutes taxes comprises. Son échec prouve qu'il vérifie bien quelque chose et que la fonctionnalité n'existe pas encore.
- Vert : faire passer le test. Le développeur écrit le code le plus simple qui satisfait le test, sans anticiper les besoins futurs. L'objectif est de revenir le plus vite possible à une suite de tests entièrement verte.
- Refactor : améliorer le code. Une fois les tests au vert, on renomme, on supprime les doublons et on clarifie la structure, pour le nouveau code comme pour l'ancien. Les tests garantissent que ces modifications ne cassent rien.
Chaque cycle est volontairement court. Cette cadence produit, au fil du projet, une suite de tests qui couvre l'ensemble des règles métier et qui sert de filet de sécurité à chaque évolution.
Ce que le TDD apporte à un projet web sur mesure
Pour un décideur, le TDD se juge à ses effets sur la durée de vie et le coût d'évolution d'une application. Un logiciel métier, un extranet ou une plateforme connectée évoluent pendant des années : nouvelles règles tarifaires, nouveaux profils d'utilisateurs, connexion à d'autres outils. Sans tests automatisés, chaque modification fait courir un risque de régression que seule une recette manuelle, longue et incomplète, peut limiter. Avec une suite de tests écrite au fil du développement, l'équipe sait en quelques secondes si une évolution a cassé un comportement existant.
Les tests jouent aussi un rôle de documentation vivante. Un test intitulé refuseUnPrixNegatif décrit une règle métier plus sûrement qu'un commentaire, car il est vérifié à chaque exécution. Enfin, la méthode pousse vers un code découpé en éléments indépendants, faciles à tester isolément, ce qui rejoint les principes d'une architecture modulaire et la séparation des responsabilités du modèle MVC côté serveur.
Le lien avec la sobriété numérique est indirect mais concret : une application que l'on peut modifier sans crainte se fait évoluer plutôt que remplacer. Cet argument pèse d'autant plus dans un développement web sur mesure, dont le code appartient au client : une base testée peut être reprise, prolongée et confiée à une autre équipe sans repartir de zéro.
Installer PHPUnit en 2026
PHPUnit, publié depuis 2004, est l'outil historique des tests unitaires en PHP. Sa version 13, publiée le 6 février 2026, exige PHP 8.4 ou une version ultérieure. Un projet encore sous PHP 8.3 peut utiliser PHPUnit 12, maintenu jusqu'en février 2027, mais cette branche de PHP ne reçoit plus que des correctifs de sécurité selon le calendrier officiel des versions de PHP. Nous détaillons l'intérêt de suivre ces mises à jour dans notre article sur le rôle de PHP 8 dans un développement sobre.
Le guide de démarrage officiel installe PHPUnit comme dépendance de développement du projet, avec Composer, plutôt que globalement sur le poste. Chaque projet fixe ainsi sa propre version, et toute l'équipe exécute les tests dans les mêmes conditions.
composer require --dev phpunit/phpunit ^13
./vendor/bin/phpunit --version
Pour que les tests trouvent les classes du projet, le fichier composer.json déclare un chargement automatique sur le dossier src/. Après l'ajout d'une nouvelle classe, la commande composer dump-autoload met à jour cette table de correspondance.
{
"autoload": {
"classmap": ["src/"]
},
"require-dev": {
"phpunit/phpunit": "^13"
}
}
Un premier cycle TDD en PHP avec PHPUnit
L'exemple suivant développe, test après test, une classe qui calcule un prix TTC à partir d'un prix hors taxes et d'un taux de TVA. Il suit strictement le cycle rouge, vert, refactor.
Étape rouge : le test, écrit avant toute ligne de code (tests/CalculateurTvaTest.php)
<?php
declare(strict_types=1);
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;
final class CalculateurTvaTest extends TestCase
{
#[Test]
public function calculeLePrixTtcAvecLeTauxNormal(): void
{
$calculateur = new CalculateurTva();
$this->assertSame(120.0, $calculateur->prixTtc(100.0, 20.0));
}
}
La commande ./vendor/bin/phpunit tests lance la suite. PHPUnit signale une erreur, puisque la classe CalculateurTva n'existe pas encore : c'est le rouge attendu. L'attribut #[Test] désigne la méthode comme un test, ce qui permet de lui donner un nom lisible sans le préfixe test. Depuis PHPUnit 12, les anciennes annotations placées dans les commentaires, comme @test ou @dataProvider, ne sont plus prises en charge et doivent être remplacées par ces attributs.
Étape verte : le code minimal (src/CalculateurTva.php)
<?php
declare(strict_types=1);
final class CalculateurTva
{
public function prixTtc(float $prixHt, float $taux): float
{
return round($prixHt * (1 + $taux / 100), 2);
}
}
Après un composer dump-autoload, le test passe et PHPUnit conclut par une ligne OK suivie du nombre de tests et d'assertions. L'option --testdox affiche en complément chaque test sous forme de phrase, ce qui rend le rapport lisible par toute l'équipe.
Nouveau cycle : d'autres taux et un cas d'erreur
On ajoute maintenant les comportements suivants de la liste : le taux réduit, l'exonération et le refus d'un prix négatif. Un fournisseur de données (#[DataProvider]) évite de dupliquer le test pour chaque taux.
<?php
declare(strict_types=1);
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\TestCase;
final class CalculateurTvaTest extends TestCase
{
public static function tauxEtPrixAttendus(): array
{
return [
'taux normal' => [100.0, 20.0, 120.0],
'taux réduit' => [59.9, 5.5, 63.19],
'exonération' => [10.0, 0.0, 10.0],
];
}
#[Test]
#[DataProvider('tauxEtPrixAttendus')]
public function calculeLePrixTtc(float $ht, float $taux, float $ttcAttendu): void
{
$calculateur = new CalculateurTva();
$this->assertSame($ttcAttendu, $calculateur->prixTtc($ht, $taux));
}
#[Test]
public function refuseUnPrixNegatif(): void
{
$this->expectException(InvalidArgumentException::class);
(new CalculateurTva())->prixTtc(-10.0, 20.0);
}
}
Les trois calculs passent déjà, mais le test refuseUnPrixNegatif échoue : la classe accepte un prix négatif. On ajoute donc la règle manquante, puis on relance la suite jusqu'au vert.
public function prixTtc(float $prixHt, float $taux): float
{
if ($prixHt < 0) {
throw new InvalidArgumentException('Le prix HT ne peut pas être négatif.');
}
return round($prixHt * (1 + $taux / 100), 2);
}
Reste l'étape de refactoring. Sur un exemple aussi court, elle peut se limiter à relire les noms et à vérifier qu'aucune logique n'est dupliquée. Sur un projet réel, c'est le moment d'extraire une constante, de regrouper des calculs proches ou de séparer une responsabilité devenue trop large, avec la certitude que les tests signaleront toute régression.
Les limites du TDD et les erreurs fréquentes
Le TDD n'est pas une garantie automatique de qualité. Martin Fowler observe que la manière la plus courante de mal appliquer la méthode consiste à négliger la troisième étape, le refactoring. Le code passe alors les tests mais s'accumule en fragments mal structurés, et la suite de tests finit par protéger un code difficile à faire évoluer.
Deux autres écueils reviennent souvent. Le premier consiste à tester la manière dont le code est écrit plutôt que ce qu'il doit produire : au moindre refactoring, des dizaines de tests cassent sans qu'aucune règle métier n'ait changé. Le second tient à la lenteur de la suite, lorsque les tests unitaires dépendent d'une base de données ou d'un service distant. Les développeurs cessent alors de les lancer à chaque modification, et la méthode perd son intérêt.
Enfin, le TDD convient mieux aux règles métier qu'aux interfaces visuelles ou aux prototypes jetables, où le comportement attendu n'est pas encore connu. La même exigence s'applique au code produit avec l'aide d'outils d'intelligence artificielle : un test écrit en premier reste le moyen le plus sûr de vérifier qu'un code généré fait ce qu'on attend de lui, comme nous l'expliquons dans notre article sur l'IA et le code en production.
Faire développer un logiciel testé et maintenable
Un logiciel métier conçu avec des tests automatisés se maintient plus sereinement : les mises à jour de PHP, les évolutions fonctionnelles et les corrections de sécurité s'appliquent en vérifiant à chaque étape que rien n'a été cassé. C'est cette continuité que nous assurons dans le cadre de notre maintenance web proactive, après la mise en production.
- vote(s)