Kuinka testaat PHP-koodia PHPUnitin avulla?

Question

Accepted Answer

**PHPUnit** on PHP:n standardi testausframeworki — sitä käytetään yksikkö- ja integraatiotestien kirjoittamiseen, jotka varmistavat, että koodi toimii oikein. Yhdessä dependency injectionin (mockaukselle) ja työkalujen kuten data providereiden kanssa se mahdollistaa kattavat, ylläpidettävät testit.

## Perusyksikkötesti

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

Testiluokat perivät `TestCase`-luokan, testimetodien nimet alkavat `test`-etuliitteellä (tai käytä `#[Test]`-attribuuttia), ja ne käyttävät `assert*`-metodeja odotusten vahvistamiseen (`assertEquals`, `assertTrue`, `assertCount` jne.). `expectException` testaa virhepolkuja.

## Riippuuksien mockkaus (eristäminen DI:n kautta)

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

PHPUnitin mockkaus antaa sinun korvata riippuuksien (lähettäjät, repositoriot, API:t) ohjattavilla näennäisillä objekteilla — ja dependency injection tekee niiden injektoimisesta triviaalia. Voit vahvistaa, että mockit kutsutaan oikein. Tämä on nopeiden, eristettyjen yksikkötestien perusta.

## Data providerit (testaa monia tapauksia)

```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 providerit** suorittavat saman testin monella eri syötejoukoilla — puhdas useiden tapausten kattavuus ilman toistoa.

## Parhaat käytännöt

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

## Miksi se on tärkeää

Testaus on välttämätöntä luotettavien, ylläpidettävien PHP-sovellusten rakentamisessa, ja **PHPUnit** on standardi työkalu — joten PHP-testauksen ymmärtäminen on tärkeää sekä koodin laadun että ammatillisten vaatimusten kannalta.

Testien kirjoittamisen osaaminen (luokan laajentaminen `TestCase`-luokasta, väittämien käyttäminen, poikkeuspolkujen testaus) on perustavanlaatuista, mutta arvokkain näkemys on se, kuinka **dependency injection mahdollistaa puhtaan testauksen**: koska hyvin suunnitellut PHP-luokat saavat riippuuksensa, PHPUnitin mockkaus antaa sinun korvata todelliset riippuudet (tietokannat, lähettäjät, ulkoiset API:t) ohjattavilla näennäisillä objekteilla — mahdollistaen nopeat, eristetyt yksikkötestit ilman todellista infrastruktuuria, ja antaen sinun vahvistaa vuorovaikutukset (vahvistaa, että mock kutsuttiin oikein).

Tämä yhteys DI:n ja testattavuuden välillä on täsmälleen syy siihen, miksi dependency injection -kuvio on niin tärkeä.

Mockkauksen, **data providereiden** (useiden syötetapausten tehokas testaus) ja testauksen parhaiden käytäntöjen (käyttäytymisen testaus, ei toteutusta, ulkoisten riippuuksien mockkaus, reunatapausten ja virhepolkujen kattavuus, testikantojen käyttäminen integraatiotesteihin) ymmärtäminen kattaa käytännöllisen tehokkaiden PHP-testausten soveltamisalan.

Hyvin testattu PHP havaitsee regressiot, mahdollistaa itsevarman refaktoroinnin ja dokumentoi odotetun käyttäytymisen, ja koska modernit frameworkit (Laravel, Symfony) rakentavat testauksensa PHPUnitin päälle, sen tunteminen on laajasti sovellettavissa.

PHPUnitin hallinta — erityisesti mockkauksen ja DI:n hyödyntäminen eristettyihin testeihin — on tärkeä senior-tason tieto, joka erottaa kehittäjät, jotka rakentavat robusteja, ylläpidettäviä, hyvin testattuja sovelluksia niistä, jotka julkaisevat testaamattomia, hauraita koodia, mikä tekee siitä usein relevantin, ammattimaisesti tärkeän aiheen.