Como você testa código PHP com PHPUnit?

Question

Accepted Answer

**PHPUnit** é o framework de testes padrão para PHP — usado para escrever testes unitários e de integração que verificam se o código se comporta corretamente. Combinado com injeção de dependência (para mocking) e ferramentas como data providers, ele permite testes minuciosos e mantíveis.

## Um teste básico

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

Classes de teste estendem `TestCase`, métodos de teste começam com `test` (ou usam o atributo `#[Test]`), e usam métodos `assert*` para verificar expectativas (`assertEquals`, `assertTrue`, `assertCount`, etc.). `expectException` testa caminhos de erro.

## Mockando dependências (isolamento via 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');
}
```

O mocking do PHPUnit permite substituir dependências (mailers, repositórios, APIs) por fakes controláveis — e injeção de dependência torna injetar essas dependências trivial. Você pode afirmar que mocks são chamados corretamente. Esta é a base de testes unitários rápidos e isolados.

## Data providers (testar muitos casos)

```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 providers** executam o mesmo teste contra muitos conjuntos de entrada — cobertura limpa de múltiplos casos sem duplicação.

## Boas práticas

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

## Por que isso importa

Testes são essenciais para construir aplicações PHP confiáveis e mantíveis, e **PHPUnit** é a ferramenta padrão — portanto, entender como testar PHP é importante tanto para a qualidade do código quanto como uma expectativa profissional.

Saber como escrever testes (estendendo `TestCase`, usando assertions, testando caminhos de exceção) é fundamental, mas a visão mais valiosa é como **injeção de dependência permite testes limpos**: como classes PHP bem projetadas recebem suas dependências, o mocking do PHPUnit permite substituir dependências reais (bancos de dados, mailers, APIs externas) por fakes controláveis — permitindo testes unitários rápidos e isolados sem infraestrutura real, e permitindo verificar interações (afirmando que um mock foi chamado corretamente).

Esta conexão entre DI e testabilidade é exatamente por que o padrão de injeção de dependência importa tanto.

Compreender mocking, **data providers** (testando eficientemente muitos casos de entrada), e boas práticas de teste (testar comportamento não implementação, mockando dependências externas, cobrindo casos extremos e caminhos de erro, usando bancos de teste para testes de integração) cobre o escopo prático de testes PHP eficazes.

PHP bem testado captura regressões, habilita refatoração confiante, e documenta o comportamento esperado, e como frameworks modernos (Laravel, Symfony) constroem seu teste em PHPUnit, conhecê-lo é amplamente aplicável.

Dominar PHPUnit — especialmente aproveitando mocking e DI para testes isolados — é conhecimento importante de nível sênior que distingue desenvolvedores que constroem aplicações robustas, mantíveis e bem testadas daqueles que entregam código não testado e frágil, tornando-o um tópico frequentemente relevante e profissionalmente importante.