Kaip testuoti PHP kodą naudojant PHPUnit?

Question

Accepted Answer

**PHPUnit** yra standartinis PHP testavimo plynas — naudojamas parašyti vienetiniais ir integraciniai testai, kurie patikrina, kad kodas veikia teisingai. Kartu su priklausomybių injekciniu (klaidoms mėsti) ir tokiais įrankiais kaip duomenų teikėjai, tai leidžia atlikti nuodugnų, lengvai prižiūrimą testavimą.

## Paprastas testas

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

Testavimo klasės išplečia `TestCase`, testavimo metodai pradedami su `test` (arba naudoja `#[Test]` atributą), ir naudoja `assert*` metodus tikslams patikrinti (`assertEquals`, `assertTrue`, `assertCount` ir kt.). `expectException` testuoja klaidų kelius.

## Klaidų padarinių dalinis (izoliacija per 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 mėlynės jums leidžia pakeisti priklausomybes (el. paštą, saugyklas, API) su kontroliuojamais sukčiais — ir priklausomybių injekcija daro jų injekcija triviale. Galite tvirtinti, kad klaidės vadinamos teisingai. Tai yra greitų, izoliuotų vienetinių testų pagrindas.

## Duomenų teikėjai (daug atvejų testuoti)

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

**Duomenų teikėjai** vykdo tą patį testą pagal daugelį įvesties rinkinių — švarūs daugelio atvejų aprėpdimas be dubliavimo.

## Geriausia praktika

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

## Kodėl tai svarbu

Testavimas yra būtinas norint sukurti patikimų, lengvai prižiūrimų PHP programų, ir **PHPUnit** yra standartinis įrankis — taigi suprasti, kaip testuoti PHP, yra svarbiausia tiek kodo kokybei, tiek profesionaliam lūkesčiui.

Žinojimas, kaip rašyti testus (išplečiant `TestCase`, naudojant tvirtinimus, testuojant išimties kelius) yra pagrindinis, tačiau vertingiausia nuomonė yra, kaip **priklausomybių injekcija leidžia šiauriam testavimui**: kadangi gerai suprojektuotos PHP klasės gauna savo priklausomybes, PHPUnit mėlynės jums leidžia pakeisti reales priklausomybes (duombazės, pašto paslaugos, išoriniai API) su kontroliuojamais sukčiais — leisdami greitam, izoliuotam vienetiniam testavimui be realios infrastruktūros, ir leisdami patikrinti sąveikumas (tvirtinant, kad klaidė buvo iškviesta teisingai).

Šis DI ir testavimo ryšys yra būtent tai, kodėl priklausomybių injekciniu modelis tiek daug reikalingas.

Supratimas klaidų, **duomenų teikėjų** (efektyviai testuojant daugelį įvesties atvejų), ir testavimo praktiką (testuojant elgesį, o ne realizaciją, klaidų išorinės priklausomybės, aprėpdamas kraštutiniais atvejais ir klaidų kelius, naudojant testavimo duombazės integraciniams testams) apima praktinį veiksmingų PHP testavimo apimtį.

Gerai testuotas PHP paima regresjus, leidžia pasitikėti refaktoringu, ir dokumentuoja tikėtą elgesį, ir kadangi šiuolaikiniai plynas (Laravel, Symfony) pagrindi jų testavimą ant PHPUnit, žinojimas jo plačiai taikytinas.

Mastering PHPUnit — ypač naudojant klaidų ir DI izoliuotiems testams — yra svarbi aukštesnio lygio žinios, kuri atskiria kūrėjus, kurie kuria kietą, lengvai prižiūrimą, gerai testuotą programų nuo tų, kurie siunta netestuotą, trapią kodą, todėl tai yra dažnai susijęs, profesionaliai svarbus argumentas.