Wie testet man PHP-Code mit PHPUnit?

Question

Accepted Answer

**PHPUnit** ist das Standard-Test-Framework für PHP — wird verwendet, um Unit- und Integrationstests zu schreiben, die überprüfen, dass Code sich korrekt verhält. In Kombination mit Dependency Injection (zum Mocken) und Tools wie Data Providern ermöglicht es umfassende, wartbare Tests.

## Ein einfacher Test

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

Test-Klassen erweitern `TestCase`, Test-Methoden beginnen mit `test` (oder verwenden das `#[Test]`-Attribut), und nutzen `assert*`-Methoden, um Erwartungen zu überprüfen (`assertEquals`, `assertTrue`, `assertCount`, etc.). `expectException` testet Fehlerpfade.

## Mocking von Abhängigkeiten (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');
}
```

PHPUnits Mocking lässt dich Abhängigkeiten (Mailer, Repositories, APIs) durch kontrollierbare Fakes ersetzen — und Dependency Injection macht das Injizieren trivial. Du kannst überprüfen, dass Mocks korrekt aufgerufen werden. Dies ist das Fundament schneller, isolierter Unit-Tests.

## Data Provider (viele Fälle 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 Provider** führen denselben Test gegen mehrere Input-Sets aus — saubere Abdeckung mehrerer Fälle ohne Wiederholung.

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

## Warum es wichtig ist

Testen ist essentiell für den Aufbau zuverlässiger, wartbarer PHP-Anwendungen, und **PHPUnit** ist das Standard-Tool — daher ist das Verständnis, wie man PHP testet, wichtig sowohl für Code-Qualität als auch als berufliche Erwartung.

Zu wissen, wie man Tests schreibt (erweitere `TestCase`, verwende Assertions, teste Exception-Pfade), ist grundlegend, aber die wertvollste Erkenntnis ist, wie **Dependency Injection sauberes Testen ermöglicht**: Weil gut gestaltete PHP-Klassen ihre Abhängigkeiten erhalten, lässt dich PHPUnits Mocking reale Abhängigkeiten (Datenbanken, Mailer, externe APIs) durch kontrollierbare Fakes ersetzen — was schnelle, isolierte Unit-Tests ohne reale Infrastruktur ermöglicht und dir lässt, Interaktionen zu überprüfen (überprüfe, dass ein Mock korrekt aufgerufen wurde).

Diese Verbindung zwischen DI und Testbarkeit ist genau warum das Dependency-Injection-Pattern so wichtig ist.

Das Verstehen von Mocking, **Data Providern** (effiziente Tests vieler Input-Fälle) und Test-Best-Practices (teste Verhalten nicht Implementierung, mocke externe Abhängigkeiten, decke Edge-Cases und Fehlerpfade ab, verwende Test-Datenbanken für Integrationstests) deckt den praktischen Umfang effektiven PHP-Testings ab.

Wohl-getestetes PHP fängt Regressions ein, ermöglicht sicheres Refactoring und dokumentiert erwartetes Verhalten, und da moderne Frameworks (Laravel, Symfony) ihr Testing auf PHPUnit aufbauen, ist es breit anwendbar.

PHPUnit zu beherrschen — besonders Mocking und DI für isolierte Tests zu nutzen — ist wichtiges Senior-Level-Wissen, das Entwickler unterscheidet, die robuste, wartbare, gut-getestete Anwendungen bauen, von denen, die ungetesteten, fragilen Code ausliefern, was es zu einem häufig relevanten, beruflich-wichtigen Thema macht.