Cum testezi cod PHP cu PHPUnit?

Question

Accepted Answer

**PHPUnit** este framework-ul standard de testare pentru PHP — utilizat pentru a scrie teste unitare și de integrare care verifică că codul se comportă corect. Combinat cu injectarea dependențelor (pentru mock-uri) și instrumente cum ar fi furnizorii de date, permite testarea minuțioasă și ușor de întreținut.

## Un test de bază

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

Clasele de test extind `TestCase`, metodele de test încep cu `test` (sau folosesc atributul `#[Test]`), și utilizează metode `assert*` pentru a verifica așteptările (`assertEquals`, `assertTrue`, `assertCount`, etc.). `expectException` testează căile de eroare.

## Mock-urile dependențelor (izolare prin 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');
}
```

Mock-urile PHPUnit-ului îți permit să înlocuiești dependențele (maileri, depozite, API-uri) cu falsuri controlabile — și injectarea dependențelor face injectarea lor banală. Poți afirma că mock-urile sunt apelate corect. Aceasta este fundamentul testelor unitare rapide și izolate.

## Furnizorii de date (testează multe cazuri)

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

**Furnizorii de date** rulează același test pe mai multe seturi de intrare — acoperire curată a mai multor cazuri fără duplicare.

## Cele mai bune practici

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

## De ce contează

Testarea este esențială pentru construirea aplicațiilor PHP fiabile și ușor de întreținut, iar **PHPUnit** este instrumentul standard — deci înțelegerea modului de testare a PHP-ului este importantă atât pentru calitatea codului, cât și ca așteptare profesională.

Cunoașterea modului de scriere a testelor (extinderea `TestCase`, utilizarea asertiunilor, testarea căilor de excepție) este fundamentală, dar cel mai valoros intelect este cum **injectarea dependențelor permite testarea curată**: deoarece clasele PHP bine proiectate primesc dependențele lor, mock-urile PHPUnit-ului îți permit să înlocuiești dependențele reale (baze de date, maileri, API-uri externe) cu falsuri controlabile — permițând teste unitare rapide și izolate fără infrastructură reală, și permițându-ți să verifici interacțiunile (afirmând că un mock a fost apelat corect).

Această legătură între DI și testabilitate este exact de ce modelul de injectare a dependențelor contează atât de mult.

Înțelegerea mock-urilor, **furnizorilor de date** (testarea eficient a multor cazuri de intrare), și a celor mai bune practici de testare (testarea comportamentului și nu a implementării, mock-urile dependențelor externe, acoperirea cazurilor limită și căilor de eroare, utilizarea bazelor de date de test pentru testele de integrare) acoperă domeniul practic al testării PHP efective.

PHP-ul bine testat prinde regresiile, permite refactorizare cu încredere, și documentează comportamentul așteptat, iar din moment ce framework-urile moderne (Laravel, Symfony) construiesc testarea lor pe PHPUnit, cunoașterea acestuia este larg aplicabilă.

Stăpânirea PHPUnit — în special valorificarea mock-urilor și DI pentru teste izolate — este cunoștință importantă de nivel senior care deosebește dezvoltatorii care construiesc aplicații robuste, ușor de întreținut și bine testate de cei care lansează cod netestat și fragil, făcând-o un subiect frecvent relevant și profesional important.