Hoe test je PHP-code met PHPUnit?

Question

Accepted Answer

**PHPUnit** is het standaard testframework voor PHP — gebruikt om unit- en integratietests te schrijven die verifiëren dat code correct werkt. Gecombineerd met dependency injection (voor mocking) en tools zoals data providers, maakt het grondige, onderhoudbare testing mogelijk.

## Een basistest

```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
```

Testklassen breiden `TestCase` uit, testmethodes beginnen met `test` (of gebruiken het `#[Test]` attribuut), en gebruiken `assert*` methodes om verwachtingen te verifiëren (`assertEquals`, `assertTrue`, `assertCount`, enz.). `expectException` test foutpaden.

## Mocking van afhankelijkheden (isolatie 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');
}
```

De mocking van PHPUnit laat je afhankelijkheden (mailers, repositories, API's) vervangen door controleerbare fakes — en dependency injection maakt het injiceren ervan triviaal. Je kunt verifiëren dat mocks correct worden aangeroepen. Dit is de basis van snelle, geïsoleerde unit tests.

## Data providers (veel cases testen)

```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));
}
```

**Data providers** voeren dezelfde test uit tegen veel invoersets — schone dekking van meerdere cases zonder duplicatie.

## Best practices

```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
```

## Waarom het belangrijk is

Testen is essentieel voor het bouwen van betrouwbare, onderhoudbare PHP-applicaties, en **PHPUnit** is het standaardgereedschap — dus weten hoe je PHP test is belangrijk voor zowel codekwaliteit als een professionele verwachting.

Weten hoe je tests schrijft (uitbreiding van `TestCase`, gebruik van assertions, testen van uitzonderingspaden) is fundamenteel, maar het meest waardevolle inzicht is hoe **dependency injection schoon testen maakt**: omdat goed ontworpen PHP-klassen hun afhankelijkheden ontvangen, laat PHPUnit's mocking je echte afhankelijkheden (databases, mailers, externe API's) vervangen door controleerbare fakes — wat snelle, geïsoleerde unit tests zonder echte infrastructuur mogelijk maakt, en je laat verifiëren dat interacties correct zijn (asserting dat een mock correct werd aangeroepen).

Deze verbinding tussen DI en testability is exact waarom het dependency injection patroon zo belangrijk is.

Het begrijpen van mocking, **data providers** (efficiënt testen van veel invoercases), en best practices voor testen (gedrag testen niet implementatie, externe afhankelijkheden mocken, edge cases en foutpaden dekken, testdatabases gebruiken voor integratietests) bestrijkt de praktische reikwijdte van effectieve PHP-testing.

Goed geteste PHP vangt regressies, maakt zelfverzekerd refactoring mogelijk, en documenteert verwacht gedrag, en omdat moderne frameworks (Laravel, Symfony) hun testen op PHPUnit bouwen, is het kennen ervan breed toepasbaar.

De meesterschap van PHPUnit — vooral het benutten van mocking en DI voor geïsoleerde tests — is belangrijke kennis op senior niveau die ontwikkelaars onderscheidt die robuuste, onderhoudbare, goed geteste applicaties bouwen van degenen die ongeteste, kwetsbare code leveren, waardoor het een veel relevante, professioneel belangrijke onderwerp is.