Kako testirate PHP kod s PHPUnit-om?

Question

Accepted Answer

**PHPUnit** je standardni okvir za testiranje u PHP-u — koristi se za pisanje jediničnih i integracijskih testova koji verificiraju da se kod ponaša ispravno. Kombiniran s ubrizgavanjem ovisnosti (za mocking) i alatima poput pružatelja podataka, omogućava temeljito i lako održavano 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
```

Klase testova proširuju `TestCase`, metode testova počinju s `test` (ili koriste atribut `#[Test]`), i koriste `assert*` metode za provjeru očekivanja (`assertEquals`, `assertTrue`, `assertCount`, itd.). `expectException` testira putanje grešaka.

## Mocking ovisnosti (izolacija preko 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-ov mocking vam omogućava zamjenu ovisnosti (pošiljači e-pošte, repozitoriji, API-ji) s kontrolabilnim lažnjacima — a ubrizgavanje ovisnosti čini njihovo ubrizgavanje trivijalno. Možete tvrditi da se mock-ovi pozivaju ispravno. Ovo je temelj brzih, izolovanih jediničnih testova.

## Pružatelji podataka (testiranje mnogih slučajeva)

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

**Pružatelji podataka** pokrenuti su isti test protiv mnogo skupova unosa — čista pokrivenost više slučajeva bez ponavljanja.

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

## Zašto je to važno

Testiranje je bitno za izgradnju pouzdanih i lako održavanih PHP aplikacija, a **PHPUnit** je standardni alat — tako da razumijevanje kako testirati PHP je važno kako za kvalitetu koda tako i kao profesionalno očekivanje.

Znati kako pisati testove (proširenje `TestCase`, korištenje tvrdnji, testiranje putanja iznimki) je temeljno, ali najvrjedniji uvid je kako **ubrizgavanje ovisnosti omogućava čisto testiranje**: jer dobro dizajnirane PHP klase primaju svoje ovisnosti, PHPUnit-ov mocking vam omogućava zamjenu stvarnih ovisnosti (baze podataka, pošiljači e-pošte, vanjski API-ji) s kontrolabilnim lažnjacima — omogućavajući brze, izolirane jedinične testove bez stvarne infrastrukture, i omogućavajući vam provjeru interakcija (tvrdnja da je mock-a ispravno pozvan).

Ova veza između DI i testabilnosti je upravo razlog zašto obrazac ubrizgavanja ovisnosti toliko matters.

Razumijevanje mocking-a, **pružatelja podataka** (učinkovito testiranje mnogih slučajeva unosa), i najboljih praksi testiranja (testiranje ponašanja ne implementacije, mocking vanjskih ovisnosti, pokrivenost rubnih slučajeva i putanja grešaka, korištenje test baza podataka za integracijske testove) obuhvaća praktičan opseg učinkovitog PHP testiranja.

Bazno testirani PHP hvata regresije, omogućava pouzdano refaktoriranje, i dokumentira očekivano ponašanje, a budući da moderni okviri (Laravel, Symfony) grade svoje testiranje na PHPUnit-u, znati ga je široko primjenjivo.

Savladavanje PHPUnit-a — posebno korištenje mocking-a i DI za izolirane testove — je važno znanje na razini seniora koje razlikuje razvijatelje koji grade robusne, lako održavane, dobro testirane aplikacije od onih koji isporučuju netestirane, krhke kod, što ga čini često relevantnom, profesionalno važnom temom.