Come si testano i codici PHP con PHPUnit?

Question

Accepted Answer

**PHPUnit** è il framework di test standard per PHP — usato per scrivere test unitari e di integrazione che verificano che il codice si comporti correttamente. Combinato con l'iniezione di dipendenze (per il mocking) e strumenti come i data provider, consente test approfonditi e manutenibili.

## Un test di base

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

Le classi di test estendono `TestCase`, i metodi di test iniziano con `test` (oppure usano l'attributo `#[Test]`), e utilizzano i metodi `assert*` per verificare le aspettative (`assertEquals`, `assertTrue`, `assertCount`, ecc.). `expectException` testa i percorsi di errore.

## Mocking delle dipendenze (isolamento tramite 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');
}
```

Il mocking di PHPUnit ti consente di sostituire le dipendenze (mailer, repository, API) con fake controllabili — e l'iniezione di dipendenze rende banale l'iniezione di questi. Puoi verificare che i mock vengano chiamati correttamente. Questa è la base dei test unitari veloci e isolati.

## Data provider (testare molti casi)

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

I **data provider** eseguono lo stesso test su molti set di input — copertura pulita di molteplici casi senza duplicazione.

## Best practice

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

## Perché è importante

I test sono essenziali per costruire applicazioni PHP affidabili e manutenibili, e **PHPUnit** è lo strumento standard — quindi capire come testare PHP è importante sia per la qualità del codice che come aspettativa professionale.

Sapere come scrivere test (estendendo `TestCase`, usando le asserzioni, testando i percorsi di eccezione) è fondamentale, ma l'intuizione più preziosa è come **l'iniezione di dipendenze abilita test puliti**: poiché le classi PHP ben progettate ricevono le loro dipendenze, il mocking di PHPUnit ti consente di sostituire le dipendenze reali (database, mailer, API esterne) con fake controllabili — abilitando test unitari veloci e isolati senza infrastruttura reale, e permettendoti di verificare le interazioni (asserendo che un mock sia stato chiamato correttamente).

Questa connessione tra DI e testabilità è esattamente il motivo per cui il pattern di iniezione di dipendenze è così importante.

Comprendere il mocking, i **data provider** (testing efficiente di molti casi di input), e le best practice per i test (testare il comportamento non l'implementazione, mockare le dipendenze esterne, coprire i casi limite e i percorsi di errore, usare database di test per i test di integrazione) copre l'ambito pratico del testing PHP efficace.

PHP ben testato cattura le regressioni, abilita il refactoring con sicurezza, e documenta il comportamento atteso, e poiché i framework moderni (Laravel, Symfony) costruiscono i loro test su PHPUnit, sapere come usarlo è ampiamente applicabile.

Padroneggiare PHPUnit — soprattutto sfruttando il mocking e DI per test isolati — è una conoscenza importante a livello senior che distingue gli sviluppatori che costruiscono applicazioni robuste, manutenibili e ben testate da coloro che lanciano codice non testato e fragile, rendendola un argomento frequentemente rilevante e professionalmente importante.