Jak testujesz kod PHP za pomocą PHPUnit?

Question

Accepted Answer

**PHPUnit** to standardowy framework testowania dla PHP — używany do pisania testów jednostkowych i integracyjnych, które weryfikują, że kod zachowuje się poprawnie. W połączeniu z injekcją zależności (do tworzenia Mock'ów) i narzędziami takimi jak dostawcy danych, umożliwia gruntowne, łatwe w utrzymaniu testowanie.

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

Klasy testowe rozszerzają `TestCase`, metody testowe zaczynają się od `test` (lub używają atrybutu `#[Test]`), i używają metod `assert*` do weryfikacji oczekiwań (`assertEquals`, `assertTrue`, `assertCount`, itp.). `expectException` testuje ścieżki błędów.

## Mockowanie zależności (izolacja poprzez 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');
}
```

Mockowanie w PHPUnit pozwala zastąpić zależności (mailery, repozytoria, API) kontrolowalnymi fałszywkami — a injekcja zależności sprawia, że ich wstrzyknięcie jest banalne. Możesz asertować, że mock'i są wywoływane poprawnie. To fundament szybkich, izolowanych testów jednostkowych.

## Dostawcy danych (testowanie wielu przypadków)

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

**Dostawcy danych** uruchamiają ten sam test na wielu zestawach wejściowych — czyste pokrycie wielu przypadków bez duplikacji.

## Dobre praktyki

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

## Dlaczego to ważne

Testowanie jest niezbędne do budowania niezawodnych, łatwych w utrzymaniu aplikacji PHP, a **PHPUnit** to narzędzie standardowe — dlatego zrozumienie sposobu testowania PHP jest ważne zarówno dla jakości kodu, jak i jako oczekiwanie zawodowe.

Znajomość pisania testów (rozszerzanie `TestCase`, używanie asercji, testowanie ścieżek wyjątków) jest fundamentalna, ale najcenniejszą wiadomością jest to, jak **injekcja zależności umożliwia czyste testowanie**: ponieważ dobrze zaprojektowane klasy PHP otrzymują swoje zależności, mockowanie PHPUnit pozwala zastąpić rzeczywiste zależności (bazy danych, mailery, zewnętrzne API) kontrolowalnymi fałszywkami — umożliwiając szybkie, izolowane testy jednostkowe bez rzeczywistej infrastruktury i pozwalając na weryfikację interakcji (asertowanie, że mock był wywoływany poprawnie).

Ta połączenie między DI a testowalności jest dokładnie tym, dlaczego wzorzec injekcji zależności jest tak ważny.

Zrozumienie mockowania, **dostawców danych** (efektywne testowanie wielu przypadków wejściowych) i dobrych praktyk testowania (testowanie zachowania nie implementacji, mockowanie zewnętrznych zależności, pokrycie przypadków granicznych i ścieżek błędów, używanie testowych baz danych dla testów integracyjnych) obejmuje praktyczny zakres efektywnego testowania PHP.

Dobrze testowany kod PHP łapie regresje, umożliwia pewne refaktoryzowanie i dokumentuje oczekiwane zachowanie, a ponieważ nowoczesne frameworki (Laravel, Symfony) budują swoje testowanie na PHPUnit, znajomość go jest szeroko zastosowalna.

Opanowanie PHPUnit — szczególnie wykorzystywanie mockowania i DI dla izolowanych testów — jest ważną wiedzą na poziomie senior, która wyróżnia developerów, którzy budują solidne, łatwe w utrzymaniu, dobrze testowane aplikacje, od tych, którzy wysyłają niestestowany, kruchy kod, co czyni to często istotnym, zawodowo ważnym tematem.