¿Cómo pruebas código PHP con PHPUnit?

Question

Accepted Answer

**PHPUnit** es el framework estándar de testing para PHP — se utiliza para escribir pruebas unitarias e de integración que verifican que el código se comporta correctamente. Combinado con inyección de dependencias (para mocking) y herramientas como data providers, permite realizar pruebas exhaustivas y mantenibles.

## Una prueba básica

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

Las clases de prueba extienden `TestCase`, los métodos de prueba comienzan con `test` (o usan el atributo `#[Test]`), y utilizan métodos `assert*` para verificar expectativas (`assertEquals`, `assertTrue`, `assertCount`, etc.). `expectException` prueba rutas de error.

## Mocking de dependencias (aislamiento mediante 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');
}
```

El mocking de PHPUnit te permite reemplazar dependencias (mailers, repositorios, APIs) con fakes controlables — y la inyección de dependencias hace trivial inyectarlos. Puedes verificar que los mocks se llamen correctamente. Esta es la base de las pruebas unitarias rápidas y aisladas.

## Data providers (prueba muchos 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));
}
```

Los **data providers** ejecutan la misma prueba contra muchos conjuntos de entrada — cobertura limpia de múltiples casos sin duplicación.

## Mejores prácticas

```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 qué es importante

Las pruebas son esenciales para construir aplicaciones PHP confiables y mantenibles, y **PHPUnit** es la herramienta estándar — por lo que entender cómo probar PHP es importante tanto para la calidad del código como para las expectativas profesionales.

Saber escribir pruebas (extendiendo `TestCase`, usando assertions, probando rutas de excepciones) es fundamental, pero el insight más valioso es cómo **la inyección de dependencias permite pruebas limpias**: porque las clases PHP bien diseñadas reciben sus dependencias, el mocking de PHPUnit te permite reemplazar dependencias reales (bases de datos, mailers, APIs externas) con fakes controlables — permitiendo pruebas unitarias rápidas y aisladas sin infraestructura real, y dejándote verificar interacciones (verificando que un mock fue llamado correctamente).

Esta conexión entre DI y testability es exactamente por qué el patrón de inyección de dependencias importa tanto.

Entender mocking, **data providers** (pruebas eficientes de muchos casos de entrada), y mejores prácticas de testing (probar comportamiento no implementación, hacer mocking de dependencias externas, cubrir casos límite y rutas de error, usar bases de datos de prueba para pruebas de integración) cubre el alcance práctico del testing efectivo en PHP.

PHP bien testeado atrapa regresiones, permite refactoring confiado, y documenta el comportamiento esperado, y como los frameworks modernos (Laravel, Symfony) construyen su testing sobre PHPUnit, conocerlo es ampliamente aplicable.

Dominar PHPUnit — especialmente aprovechando mocking y DI para pruebas aisladas — es conocimiento importante de nivel senior que distingue a desarrolladores que construyen aplicaciones robustas, mantenibles y bien testeadas de aquellos que envían código sin probar y frágil, haciéndolo un tema frecuentemente relevante e importante profesionalmente.