Tests en PHP : unitaires, d'intégration, e2e — guide complet

Introduction : pourquoi tester les applications PHP ?

Tester le code n'est pas simplement une tendance à la mode, mais une pratique fondamentale du développement professionnel. Dans le monde PHP, où un grand nombre de projets interagissent avec des bases de données, des API externes et une logique métier complexe, la qualité du code impacte directement la stabilité et la sécurité du produit. Sans tests, même une petite modification peut casser une fonctionnalité qui fonctionnait depuis des années.

Dans cet article, nous allons détailler trois niveaux clés de test : unit (tests unitaires), integration (tests d'intégration) et e2e (tests de bout en bout). Vous découvrirez leurs différences, quand les utiliser, et verrez des exemples de code PHP concrets. Que vous utilisiez Laravel, Symfony ou que vous écriviez du PHP pur, ces connaissances vous aideront à créer des applications fiables.

Tests unitaires : vérification des composants isolés

Les tests unitaires sont le niveau de test le plus bas et le plus rapide. Leur objectif est de vérifier le fonctionnement d'une méthode ou d'une fonction individuelle en isolation complète des dépendances externes (base de données, système de fichiers, requêtes HTTP).

Outils pour les tests unitaires en PHP

• PHPUnit — le standard de facto. Puissant, flexible, supporté par la plupart des frameworks.
• Pest — une alternative moderne avec une syntaxe plus concise. Idéal pour les débutants et les équipes qui valorisent la lisibilité.

Exemple avec PHPUnit

Supposons que nous ayons une classe simple pour calculer une remise :

<?phpclass DiscountCalculator{    public function calculate(float $price, float $percent): float    {        if ($percent < 0 || $percent > 100) {            throw new \\InvalidArgumentException('Le pourcentage de remise doit être compris entre 0 et 100');        }        return $price - ($price * $percent / 100);    }}?>

Le test pour cette classe ressemblera à ceci :

<?phpuse PHPUnit\\Framework\\TestCase;

class DiscountCalculatorTest extends TestCase{    public function testCalculateWithValidDiscount(): void    {        $calculator = new DiscountCalculator();        $result = $calculator->calculate(1000, 20);        $this->assertEquals(800.0, $result);    }

    public function testCalculateWithZeroPercent(): void    {        $calculator = new DiscountCalculator();        $result = $calculator->calculate(500, 0);        $this->assertEquals(500.0, $result);    }

    public function testCalculateThrowsExceptionForInvalidPercent(): void    {        $this->expectException(\\InvalidArgumentException::class);        $calculator = new DiscountCalculator();        $calculator->calculate(100, 150);    }}?>

Principes clés des tests unitaires :

• Un test = une vérification (un seul assert).
• Les tests ne doivent pas dépendre les uns des autres.
• Utilisez des mocks pour isoler les services externes. Par exemple, avec createMock() dans PHPUnit.
• Couvrez les cas limites : null, chaînes vides, valeurs négatives.

Tests d'intégration : vérification de l'interaction des composants

Les tests d'intégration vérifient comment les différentes parties de l'application fonctionnent ensemble : classes, bases de données, services externes. Contrairement aux tests unitaires, on utilise ici des dépendances réelles (ou quasi réelles).

Quand écrire des tests d'intégration ?

• Vérification de l'interaction avec la base de données (ORM, requêtes).
• Travail avec le système de fichiers (upload/lecture de fichiers).
• Interaction avec des API externes (via des bouchons de test).
• Vérification du bon fonctionnement des repositories et de la couche service.

Exemple en PHP avec PDO (sans framework)

<?phpuse PHPUnit\\Framework\\TestCase;

class User