Pruebas en PHP: Unit, Integration, E2E — guía completa

Introducción: ¿por qué es necesario el testing en PHP?

Desarrollar en PHP no es solo escribir código que "funciona". En el desarrollo web moderno, la estabilidad y previsibilidad de la aplicación pasan a primer plano. Sin testing, cualquier cambio en el código corre el riesgo de romper la funcionalidad existente, y buscar errores manualmente se convierte en una "cacería de bugs" interminable. Aquí es donde el testing viene al rescate.

En este artículo, analizaremos tres niveles clave de testing para aplicaciones PHP: Unit (pruebas unitarias), Integration (pruebas de integración) y E2E (pruebas de extremo a extremo). Aprenderás en qué se diferencian, qué herramientas usar y cómo construir una estrategia de testing efectiva para tu proyecto.

Pruebas Unitarias: la base de la pirámide

Las pruebas unitarias son el nivel de testing más rápido y aislado. Su objetivo es verificar el funcionamiento de una "unidad" individual (clase, método o función) de forma independiente de las dependencias externas: base de datos, sistema de archivos, API.

Herramientas para PHP

El framework más popular es PHPUnit. Una alternativa más moderna es Pest, que ofrece una sintaxis más concisa.

Ejemplo de Prueba Unitaria con PHPUnit

Supongamos que tenemos una clase calculadora simple:

<?php
// src/Calculator.php
class Calculator
{
    public function add(int $a, int $b): int
    {
        return $a + $b;
    }

    public function divide(int $a, int $b): float
    {
        if ($b === 0) {
            throw new \\InvalidArgumentException('Division by zero');
        }
        return $a / $b;
    }
}

La prueba para ella se vería así:

<?php
// tests/Unit/CalculatorTest.php
use PHPUnit\\Framework\\TestCase;

class CalculatorTest extends TestCase
{
    private Calculator $calculator;

    protected function setUp(): void
    {
        $this->calculator = new Calculator();
    }

    public function testAddReturnsCorrectSum(): void
    {
        $result = $this->calculator->add(2, 3);
        $this->assertEquals(5, $result);
    }

    public function testDivideThrowsExceptionOnZero(): void
    {
        $this->expectException(\\InvalidArgumentException::class);
        $this->calculator->divide(10, 0);
    }
}

Principios clave de las Pruebas Unitarias:

• Aislamiento: todas las dependencias externas (BD, API) se reemplazan con mock (simulaciones) o stub (suplentes).
• Velocidad: se ejecutan en milisegundos.
• Verifican un escenario específico (un assert por prueba es una buena práctica).

Ejecución: ./vendor/bin/phpunit tests/Unit

Pruebas de Integración: verificando la interacción

Las pruebas de integración van un nivel más arriba. Verifican cómo diferentes partes del sistema trabajan juntas: una clase con la base de datos, un controlador con un modelo, un servicio con una API externa (real o simulada).

¿Cuándo se necesitan las Pruebas de Integración?

• Verificar la corrección de las consultas SQL.
• Validar la conexión entre las capas de la aplicación (por ejemplo, Repository + Entity).
• Probar middleware o eventos (events).

Ejemplo: probando un repositorio con una BD real

Para las pruebas de integración, a menudo se utiliza una base de datos de prueba (SQLite en memoria o transacciones en PostgreSQL). Veamos un ejemplo usando PHPUnit y un trait para reiniciar la BD:

<?php
// tests/Integration/UserRepositoryTest.php
use PHPUnit\\Framework\\TestCase;

class UserRepositoryTest extends TestCase
{
    private PDO $pdo;
    private UserRepository $repository;

    protected function setUp(): void
    {
        // Creamos una SQLite en memoria para el aislamiento
        $this->pdo = new PDO('sqlite::memory:');
        $this->pdo->exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)');