Jak testujete PHP kód pomocí PHPUnit?

Question

Accepted Answer

**PHPUnit** je standardní testovací framework pro PHP — používá se k psaní unit testů a integračních testů, které ověřují, že se kód chová správně. V kombinaci s dependency injection (pro mockování) a nástroji jako data providers umožňuje důkladné, udržitelné testování.

## Základní 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
```

Testovací třídy dědí z `TestCase`, testovací metody začínají `test` (nebo používají atribut `#[Test]`), a používají metody `assert*` k ověření očekávání (`assertEquals`, `assertTrue`, `assertCount`, atd.). `expectException` testuje cesty chyb.

## Mockování závislostí (izolace přes 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');
}
```

PHPUnit mockování vám umožňuje nahradit závislosti (mailery, repozitáře, API) s ovladatelnými předstírkami — a dependency injection činí jejich injektování trivialním. Můžete ověřit, že jsou mocky volány správně. To je základ rychlých, izolovaných unit testů.

## Data providers (testování mnoha případů)

```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** spouští stejný test proti mnoha sadám vstupů — čistého pokrytí více případů bez duplikace.

## Osvědčené postupy

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

## Proč je to důležité

Testování je nezbytné pro vytváření spolehlivých, udržitelných PHP aplikací, a **PHPUnit** je standardní nástroj — takže pochopení toho, jak testovat PHP, je důležité jak pro kvalitu kódu, tak jako profesionální očekávání.

Znalost psaní testů (rozšíření `TestCase`, použití asercí, testování cest výjimek) je základní, ale nejcennější poznatkem je, jak **dependency injection umožňuje čisté testování**: protože dobře navržené PHP třídy přijímají své závislosti, PHPUnit mockování vám umožňuje nahradit skutečné závislosti (databáze, mailery, externí API) s ovladatelnými předstírkami — umožňuje rychlé, izolované unit testy bez skutečné infrastruktury, a umožňuje vám ověřit interakce (asertování, že mock byl volán správně).

Tato spojitost mezi DI a testovatelností je přesně důvod, proč je pattern dependency injection tak důležitý.

Pochopení mockování, **data providers** (efektivní testování mnoha vstupních případů), a osvědčených postupů testování (testování chování ne implementace, mockování externích závislostí, pokrytí hraničních případů a cest chyb, použití testovacích databází pro integrační testy) pokrývá praktický rozsah efektivního PHP testování.

Dobře otestovaný PHP odhaluje regrese, umožňuje sebevědomý refaktoring, a dokumentuje očekávané chování, a protože moderní frameworky (Laravel, Symfony) budují své testování na PHPUnit, jeho znalost je široce aplikovatelná.

Zvládnutí PHPUnit — zejména využití mockování a DI pro izolované testy — je důležitá knowledge na seniorské úrovni, která rozlišuje vývojáře, kteří vytváří robustní, udržitelné, dobře otestované aplikace, od těch, kteří odesílají netestovaný, křehký kód, což z toho dělá často relevantní, profesionálně důležité téma.