Kako testirate PHP kodo s PHPUnit?

Question

Accepted Answer

**PHPUnit** je standardno testno ogrodje za PHP — uporablja se za pisanje enot in integracijskih testov, ki preverijo, da se koda obnaša pravilno. V kombinaciji z vbrizgavanjem odvisnosti (za prikrivanje) in orodji, kot so podatkovni ponudniki, omogoča temeljito in vzdrževljivo testiranje.

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

Testni razredi razširjajo `TestCase`, testne metode se začnejo s `test` (ali uporabijo atribut `#[Test]`), in uporabljajo metode `assert*` za preverjanje pričakovanj (`assertEquals`, `assertTrue`, `assertCount`, itd.). `expectException` testira poti napak.

## Prikrivanje odvisnosti (izolacija prek vbrizgavanja odvisnosti)

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

PHPUnitev prikrivanje vam omogoča zamenjavo odvisnosti (pošiljalci e-pošte, skladišča, API-ji) z nadzorljivimi ponaredki — in vbrizgavanje odvisnosti naredi njihovo vbrizgavanje trivialno. Preverite lahko, da so ponaredki klicani pravilno. To je temelj hitrih, izoliranih enot testov.

## Podatkovni ponudniki (testiranje več primerov)

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

**Podatkovni ponudniki** poganjajo isti test proti številnim nizom vhodov — čista pokritost več primerov brez podvajanja.

## Najboljše prakse

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

## Zakaj je to pomembno

Testiranje je bistveno za gradnjo zanesljivih in vzdrževljivih PHP aplikacij, in **PHPUnit** je standardno orodje — zato je razumevanje, kako testirati PHP, pomembno tako za kakovost kode kot za profesionalna pričakovanja.

Znanje, kako pisati teste (razširjanje `TestCase`, uporaba trditev, testiranje izjem), je temeljno, vendar je najpomembnejši vpogled, kako **vbrizgavanje odvisnosti omogoča čisto testiranje**: ker so dobro zasnovani PHP razredi prejemniki svojih odvisnosti, PHPUnitev prikrivanje vam omogoča zamenjavo resničnih odvisnosti (baz podatkov, pošiljalcev, zunanjih API-jev) z nadzorljivimi ponaredki — omogočijo hitre, izolirane enote testov brez resnične infrastrukture in vam omogočijo preverjanje interakcij (preverjanje, da je bil ponaredek pravilno klican).

Ta povezava med vbrizgavanjem odvisnosti in testirljivostjo je natanko razlog, zakaj je vzorec vbrizgavanja odvisnosti tako pomemben.

Razumevanje prikrivanja, **podatkovnih ponudnikov** (učinkovito testiranje številnih primerov vhodov) in testnih najboljših praks (testiranje vedenja ne implementacije, prikrivanje zunanjih odvisnosti, pokritost mejnih primerov in poti napak, uporaba testnih baz podatkov za integracijske teste) pokriva praktični obseg učinkovitega testiranja PHP.

Testirane PHP ujame regresije, omogoča samozavesten refaktoriranje in dokumentira pričakovano vedenje, in ker sodobna ogrodja (Laravel, Symfony) gradijo svoje testiranje na PHPUnitu, ga poznavanje na splošno velja.

Ovladovanje PHPUnita — posebej izkorišćanje prikrivanja in vbrizgavanja odvisnosti za izolirane teste — je pomembno znanje višje ravni, ki loči razvojnike, ki gradijo robustne, vzdrževljive, dobro testirane aplikacije, od tistih, ki pošiljajo netestirane, krhke kode, zato je pogosto relevantna, strokovno pomembna tema.