Comment testez-vous le code PHP avec PHPUnit ?

Question

Accepted Answer

**PHPUnit** est le framework de test standard pour PHP — utilisé pour écrire des tests unitaires et d'intégration qui vérifient que le code se comporte correctement. Combiné avec l'injection de dépendances (pour les mocks) et des outils comme les data providers, il permet un test approfondi et maintenable.

## Un test basique

```php
<?php
use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase {
    public function testAdd(): void {
        $calc = new Calculator();
        $result = $calc->add(2, 3);
        $this->assertEquals(5, $result);          // assertion
        $this->assertIsInt($result);
    }

public function testDivideByZeroThrows(): void {
        $this->expectException(DivisionByZeroError::class);   // assert it throws
        (new Calculator())->divide(1, 0);
    }
}
// run with: ./vendor/bin/phpunit
```

Les classes de test étendent `TestCase`, les méthodes de test commencent par `test` (ou utilisent l'attribut `#[Test]`), et utilisent les méthodes `assert*` pour vérifier les attentes (`assertEquals`, `assertTrue`, `assertCount`, etc.). `expectException` teste les chemins d'erreur.

## Mocker les dépendances (isolation via DI)

```php
public function testSendsWelcomeEmail(): void {
    // create a MOCK of a dependency — no real mailer needed
    $mailer = $this->createMock(MailerInterface::class);
    $mailer->expects($this->once())          // assert it's called exactly once
           ->method('send')
           ->with('ann@x.com', $this->stringContains('Welcome'));

$service = new UserService($mailer);     // INJECT the mock (DI makes this easy)
    $service->register('ann@x.com');
}
```

Le mocking de PHPUnit vous permet de remplacer les dépendances (mailers, repositories, APIs) par des fakes contrôlables — et l'injection de dépendances rend l'injection triviale. Vous pouvez vérifier que les mocks sont appelés correctement. C'est la base des tests unitaires rapides et isolés.

## Data providers (tester plusieurs cas)

```php
public static function additionCases(): array {
    return [[1, 1, 2], [0, 5, 5], [-1, 1, 0]];   // [a, b, expected]
}

#[DataProvider('additionCases')]
public function testAdd(int $a, int $b, int $expected): void {
    $this->assertEquals($expected, (new Calculator())->add($a, $b));
}
```

Les **data providers** exécutent le même test contre plusieurs ensembles d'entrées — une couverture propre de plusieurs cas sans duplication.

## Bonnes pratiques

```text
✓ Test behavior/public API, not implementation details (so refactors don't break tests)
✓ Mock external dependencies (DB, APIs, mailers) for fast, isolated unit tests
✓ Use a test database for integration tests; setUp/tearDown for fixtures
✓ Measure coverage; test edge cases and error paths, not just the happy path
✓ Frameworks (Laravel, Symfony) build on PHPUnit with extra testing helpers
```

## Pourquoi c'est important

Les tests sont essentiels pour construire des applications PHP fiables et maintenables, et **PHPUnit** est l'outil standard — donc comprendre comment tester PHP est important à la fois pour la qualité du code et comme attente professionnelle.

Savoir comment écrire des tests (étendre `TestCase`, utiliser des assertions, tester les chemins d'exception) est fondamental, mais l'insight le plus précieux est comment **l'injection de dépendances permet un test propre** : parce que les classes PHP bien conçues reçoivent leurs dépendances, le mocking de PHPUnit vous permet de remplacer les vraies dépendances (bases de données, mailers, APIs externes) par des fakes contrôlables — permettant des tests unitaires rapides et isolés sans infrastructure réelle, et vous permettant de vérifier les interactions (affirmer qu'un mock a été appelé correctement).

Cette connexion entre DI et testabilité est exactement pourquoi le pattern d'injection de dépendances est si important.

Comprendre le mocking, les **data providers** (tester efficacement plusieurs cas d'entrée), et les bonnes pratiques de test (tester le comportement et non l'implémentation, mocker les dépendances externes, couvrir les cas limites et les chemins d'erreur, utiliser des bases de données de test pour les tests d'intégration) couvre la portée pratique du test PHP efficace.

Le PHP bien testé détecte les régressions, permet une refactorisation confiante, et documente le comportement attendu, et comme les frameworks modernes (Laravel, Symfony) construisent leur test sur PHPUnit, le connaître est largement applicable.

Maîtriser PHPUnit — en particulier en exploitant le mocking et DI pour les tests isolés — est une connaissance importante au niveau senior qui distingue les développeurs qui construisent des applications robustes, maintenables et bien testées de ceux qui livrent du code non testé et fragile, ce qui en fait un sujet fréquemment pertinent et professionnellement important.