Hogyan tesztelsz PHP kódot PHPUnit-tal?

Question

Accepted Answer

A **PHPUnit** a PHP standard tesztelési keretrendszere — unit és integrációs tesztek írásához használják, amelyek ellenőrzik, hogy a kód megfelelően viselkedik. A dependency injection-nal (mockoláshoz) és olyan eszközökkel kombinálva, mint az adatszolgáltatók, lehetővé teszi az alapos, karbantartható tesztelést.

## Egy alapvető teszt

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

A teszt osztályok kiterjesztik a `TestCase`-t, a teszt metódusok a `test` előtaggal kezdődnek (vagy a `#[Test]` attribútumot használják), és az `assert*` metódusokat használják az elvárások ellenőrzésére (`assertEquals`, `assertTrue`, `assertCount`, stb.). Az `expectException` a hibakezelési útvonalakat teszteli.

## Függőségek mockolása (izoláció DI-n keresztül)

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

A PHPUnit mockolása lehetővé teszi, hogy helyettesítsd a függőségeket (levélküldők, adattárak, API-k) kontrollálható álutakkal — és a dependency injection triviálissá teszi az injektálást. Meg tudod erősíteni, hogy a mockok helyesen hívódnak meg. Ez a gyors, izolált unit tesztek alapja.

## Adatszolgáltatók (sok eset tesztelése)

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

Az **adatszolgáltatók** ugyanazt a tesztet sok bemenetikészletre futtatják — több eset tiszta lefedettségét biztosítják duplikáció nélkül.

## Legjobb gyakorlatok

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

## Miért fontos

A tesztelés elengedhetetlen a megbízható, karbantartható PHP alkalmazások felépítéséhez, és a **PHPUnit** a standard eszköz — így a PHP tesztelésének módja fontos mind a kódminőség, mind a szakmai elvárás szempontjából.

Az alapok ismerete (TestCase kiterjesztése, asszercók használata, kivételkezelési útvonalak tesztelése) alapvető, de a legértékesebb felismerés az, hogy **a dependency injection lehetővé teszi a tiszta tesztelést**: mivel a jól megtervezett PHP osztályok a függőségeiket kapják, a PHPUnit mockolása lehetővé teszi, hogy az igazi függőségeket (adatbázisok, levélküldők, külső API-k) kontrollálható álutakkal helyettesítsd — gyors, izolált unit teszteket tesz lehetővé valós infrastruktúra nélkül, és lehetővé teszi az interakciók ellenőrzését (meg tudod erősíteni, hogy egy mock helyesen hívódott meg).

Ez a kapcsolat a DI és a tesztelhető-ség között pontosan azért fontos a dependency injection minta annyira.

A mockolás, az **adatszolgáltatók** (sok bemenetikészlet hatékony tesztelése) és a tesztelési legjobb gyakorlatok ismerete (viselkedés tesztelése, nem implementáció, külső függőségek mockolása, peremesetek és hibakezelési útvonalak lefedése, tesztadatbázisok használata integrációs tesztekhez) kiterjed az effektív PHP tesztelés gyakorlati hatókörére.

A jól tesztelt PHP megelőzi a regressziókat, lehetővé teszi az önmagabiztos refaktorálást és dokumentálja a várt viselkedést, és mivel a modern keretrendszerek (Laravel, Symfony) a tesztelésüket PHPUnit-ra építik, az ismert széles körben alkalmazható.

A PHPUnit elsajátítása — különösen a mockolás és a DI kihasználása az izolált tesztekhez — fontos senior szintű tudás, amely megkülönböztet azokat a fejlesztőket, akik robusztus, karbantartható, jól tesztelt alkalmazásokat építenek, azokattól, akik teszteletlen, törékenyek kódot szállítanak, ami gyakran releváns, szakmailag fontos témává teszi.