Saltar al contenido

Hay algo que aprendí con los años y es que el código sin pruebas es código que da miedo tocar. Da igual lo bien que lo hayas escrito; si dentro de seis meses tienes que cambiar algo y no hay ni un test que te avise de si rompes otra cosa, la vas a pasar canutas… y lo cierto es que muchas veces te encuentras con lo que conocemos en el sector como "Código Espaghetti", algo que en su momento hizo alguien con prisa y sin muchos miramientos (o que directamente ni siquiera sabía muy bien lo que estaba haciendo), pero que después de todo "funcionaba" y el problema viene cuando hay que modificar ese código, ya que, por mucho que sepas… tienes que construir la solución sobre arenas movedizas. Pues justo para eso está PHPUnit, para poner un poco de red bajo los pies: tanto para ti, como para el que venga después y tenga que tocar tu código.

Qué es un test unitario

Un test unitario, en esencia, es un script que comprueba un bloque concreto de código. Le das unos datos, ejecutas el método y verificas que el resultado es el que esperabas. Nada más, y nada menos. La gracia, claro, está en tener muchos de esos scripts, para que un cambio en una parte no rompa otra sin que nadie se entere.

Preparar el proyecto

Para montarlo con PHPUnit, lo primero es tener el proyecto con Composer. La estructura que uso suele ser esta:

En el composer.json se declara el autoload con PSR-4, para que las clases de app/ se carguen solas, y luego se instala PHPUnit como dependencia de desarrollo:

composer require --dev phpunit/phpunit
composer dump

La configuración

Después hace falta un fichero phpunit.xml en la raíz, que le dice a PHPUnit dónde está el autoload y dónde las pruebas:

<?xml version="1.0" encoding="UTF-8"?>
<phpunit bootstrap="vendor/autoload.php" colors="true">
    <testsuite name="Test directory">
        <directory>tests</directory>
    </testsuite>
</phpunit>

Una clase de ejemplo y su prueba

Para verlo claro, pongo una clase muy simple, un Calc con un método que suma:

<?php

namespace AppClasses;

class Calc
{
    public function sum(int $num1, int $num2)
    {
        return $num1 + $num2;
    }
}

La prueba va en tests/CalcTest.php. Conviene fijarse en dos detalles: el fichero debe terminar en Test.php y el método debe empezar por test_, porque si no, PHPUnit lo ignora sin decir nada:

<?php

use PHPUnitFrameworkTestCase;
use AppClassesCalc;

class CalcTest extends TestCase
{
    public function test_sum()
    {
        $calc = new Calc();
        $result = $calc->sum(1, 2);
        $this->assertEquals(3, $result);
        $this->assertIsInt($result);
    }
}

assertEquals comprueba que el valor obtenido es el esperado, y assertIsInt que además es un entero. Hay muchos más tipos de aserciones, para cadenas, para arrays, para excepciones, y merece la pena tenerlos a mano.

Ejecutar las pruebas

Para lanzarlas, desde la raíz:

php vendor/phpunit/phpunit/phpunit

Si todo va bien, el mensaje de éxito confirma que las pruebas han pasado.

Por qué merece la pena

Lo que se gana con esto es tranquilidad. Un test que falla te avisa en segundos, y no cuando ya has subido el cambio y el cliente está mirando. Es la misma idea que está detrás de un pipeline de CI: detectar el problema cuanto antes, cuando arreglarlo es barato. Si quieres ver el conjunto, en la entrada sobre CI/CD lo explico con más calma.