Tests Unitarios en Laravel: Guía Completa con Ejemplos

• 16/04/2025

Tests Unitarios en Laravel Paso a Paso Para Asegurar la Calidad de Tu Código

¿Te ha pasado que haces un cambio pequeño en tu proyecto Laravel y de repente algo deja de funcionar? Los tests unitarios están diseñados para evitar esos sustos. En este artículo aprenderás cómo testear código Laravel fácilmente, cómo usar PHPUnit en Laravel, qué es el enfoque TDD en Laravel y cómo automatizar tus pruebas con GitHub Actions. Todo explicado paso a paso para que incluso si nunca has hecho testing, puedas dominarlo desde hoy.

✅ Este artículo forma parte de nuestra sección de tutoriales prácticos sobre Laravel en dCreations.es, donde te ayudamos a convertirte en un programador más profesional, eficiente y productivo.

Únete a nuestra comunidad de Discord

Qué Son los Tests Unitarios en Laravel y Por Qué Deberías Usarlos

Antes de meternos en código, entendamos el concepto. Un test unitario es una pequeña función que prueba que una parte específica de tu código (una "unidad") funciona correctamente. En Laravel, usamos PHPUnit para escribir estos tests.

Los tests permiten:

• - Detectar errores antes de que lleguen a producción.

• - Refactorizar con confianza.

• - Asegurar que el código nuevo no rompe lo anterior (regresiones).

• - Documentar el comportamiento esperado.

🧠 Piensa en los tests como una red de seguridad para tu aplicación.

Ventajas de usar Laravel Unit Testing en tus proyectos

1. Reducción de bugs en producción

2. Código más mantenible

3. Mejor documentación del comportamiento

4. Te ayudan a pensar mejor el diseño de tu aplicación

5. ¡Son automatizables!

Diferencia entre pruebas unitarias y pruebas funcionales en Laravel

---

Cómo Crear Tests en Laravel con PHPUnit de Forma Profesional

Laravel ya viene con PHPUnit configurado. Solo necesitas ejecutar un comando para empezar a crear tus tests.

Para empezar:

php artisan make:test CalculadoraTest 

Esto creará un archivo en tests/Feature con una estructura inicial.

Laravel PHPUnit Tutorial para empezar desde cero

Supongamos que tienes esta clase simple:

class Calculadora {
    public function suma($a, $b) {
        return $a + $b;
    }
}

Puedes testearla con:

use Tests\TestCase;

// Este test prueba una clase externa llamada Calculadora
class CalculadoraTest extends TestCase
{
    public function test_suma_correctamente()
    {
        // Creamos una instancia de la clase que queremos probar
        $calc = new Calculadora();

        // Ejecutamos el método 'suma' pasando dos números
        $resultado = $calc->suma(2, 3);

        // Comprobamos que el resultado sea exactamente 5
        $this->assertEquals(5, $resultado);
        // assertEquals compara el resultado esperado con el real
        // Si no son iguales, el test falla
    }
}

Estructura básica de un test unitario en Laravel

public function test_nombre_del_test()
{
    // Preparación
    // Acción
    // Aserción
}

Esto te ayuda a separar claramente cada paso del test.

Cómo testear código Laravel fácilmente usando assertions

Laravel extiende PHPUnit y añade helpers útiles como:

• - $this->assertDatabaseHas()

• - $this->assertSee()

• - $this->get()->assertStatus(200)

Ejemplo:

public function test_usuario_puede_ver_la_home()
{
    // Simulamos una petición GET a la raíz del sitio
    $response = $this->get('/');

    // Verificamos que la respuesta tenga un código HTTP 200 (OK)
    $response->assertStatus(200);

    // Verificamos que el texto "Bienvenido" esté presente en la vista
    $response->assertSee('Bienvenido');
    // assertSee busca texto literal en el HTML devuelto
}

Ejemplo Completo con Varios asserts

Vamos a ver un ejemplo más completo en el que testamos una ruta, verificamos el contenido de la vista, el estado de la respuesta, la estructura de los datos y más. Ideal para familiarizarse con los asserts más comunes en Laravel.

use Tests\TestCase;
use App\Models\User;

class DashboardTest extends TestCase
{
    public function test_dashboard_muestra_contenido_correcto()
    {
        // Creamos un usuario usando el factory (no se guarda en la DB sin persistencia)
        $user = User::factory()->create();

        // Actuamos como ese usuario y visitamos la ruta /dashboard
        $response = $this->actingAs($user)->get('/dashboard');

        // Verificamos que la respuesta es exitosa (código 200)
        $response->assertStatus(200);

        // Verificamos que la vista contiene cierto texto
        $response->assertSee('Hola, ' . $user->name);

        // Verificamos que un string NO está presente (protección contra errores)
        $response->assertDontSee('Error');

        // Verificamos que se está usando una vista en particular
        $response->assertViewIs('dashboard.index');

        // Verificamos que la vista recibe una variable llamada 'estadisticas'
        $response->assertViewHas('estadisticas');

        // Verificamos estructura del array estadisticas
        $estadisticas = $response->viewData('estadisticas');

        // assertIsArray valida que sea array (tipo de dato)
        $this->assertIsArray($estadisticas);

        // assertArrayHasKey valida que exista una clave específica
        $this->assertArrayHasKey('usuariosActivos', $estadisticas);

        // Validamos un valor numérico esperado en la clave
        $this->assertGreaterThan(0, $estadisticas['usuariosActivos']);

        // También puedes usar asserts combinados con lógica si necesitas validar más cosas
        $this->assertTrue(in_array('visitas', array_keys($estadisticas)));
    }
}

Este ejemplo cubre los asserts más frecuentes:

🧠 Consejo: No escribas tests solo para que pasen. Escríbelos para detectar errores reales y validar que tu app funcione como esperas.

---

Pruebas Automatizadas en Laravel con Enfoque TDD

El TDD (Test Driven Development) es una metodología donde primero escribes el test, luego el código mínimo para pasarlo y finalmente mejoras el código.

Qué es Laravel TDD y cómo aplicarlo correctamente

Pasos del TDD:

1. Escribe un test que falle (rojo).

2. Escribe el código necesario para pasarlo (verde).

3. Refactoriza el código manteniendo el test en verde.

Laravel facilita esto con Artisan y PHPUnit listos para correr rápidamente tus tests:

php artisan test

Testing en Laravel con PHPUnit y Laravel Dusk

PHPUnit sirve para pruebas unitarias y funcionales del backend.

Laravel Dusk sirve para pruebas E2E (end-to-end) del frontend simulando un navegador.

composer require --dev laravel/dusk
php artisan dusk:install

Ejemplo en Dusk:

public function test_login()
{
    $this->browse(function ($browser) {
        $browser->visit('/login')
                ->type('email', '[email protected]')
                ->type('password', 'password')
                ->press('Login')
                ->assertPathIs('/dashboard');
    });
}

Automatización del testing Laravel apps con ejemplos prácticos

La forma más común de automatizar tus tests es usando GitHub Actions.

.github/workflows/tests.yml

name: Run Laravel Tests

on: [push]

jobs:
  laravel-tests:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Setup PHP
      uses: shivammathur/setup-php@v2
      with:
        php-version: '8.2'
    - name: Install dependencies
      run: composer install --prefer-dist --no-progress --no-suggest
    - name: Copy .env
      run: cp .env.example .env
    - name: Generate app key
      run: php artisan key:generate
    - name: Run tests
      run: php artisan test

🎯 Puedes modificarlo para correr migraciones, semillar datos, etc.

---

Buenas Prácticas para Hacer Tests Limpios y Eficientes en Laravel

La clave no es solo escribir tests, sino mantenerlos organizados, legibles y escalables a largo plazo.

Naming y organización de archivos de tests en Laravel

• - Usa nombres claros como UsuarioPuedeRegistrarTest.php

• - Agrupa tests por dominio (carpetas Feature/Usuarios, Unit/Productos, etc.)

• - Prefiere Unit/ para clases puras y Feature/ para interacciones con Laravel

Consejos para mantener pruebas escalables y legibles

1. Usa Factories y Model Factories

2. No repitas código: usa setUp()

3. Escribe un test por comportamiento

4. Usa @test o nombres que expresen el resultado esperado

Errores comunes al escribir pruebas en Laravel y cómo evitarlos

---

Conclusión

Los tests unitarios en Laravel no son solo para grandes empresas o proyectos complejos. Son una herramienta que está al alcance de todos y puede ahorrarte muchos dolores de cabeza.

Aprendiste:

• - Qué son los unit tests

• - Cómo usar PHPUnit en Laravel

• - Cómo hacer testing en Laravel paso a paso

• - Cómo aplicar TDD y automatizar con GitHub Actions

• - Buenas prácticas para mantener tu base de código limpia

💡 Empieza pequeño: crea un test hoy para una función clave de tu app. Es el primer paso hacia un desarrollo profesional y sostenible.