Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 38 de 47 · Un proyecto real ✦ WebMCP implementado

Tests: de PHPUnit a unittest y pytest

10 min de lectura 4 retos

Un test es un programa pequeño que comprueba que otro programa hace lo que dice. En PHP lo haces con PHPUnit; en Python tienes unittest (viene con el lenguaje, parecido a PHPUnit) y pytest (lo instalas tú, y es lo que usa casi todo el mundo). En esta lección ves los dos con la app de tareas y cómo se prueba una API sin levantar ningún servidor.

¿De dónde vienen los nombres?

unittest = inglés unit test (prueba de unidad)
El módulo de pruebas que trae Python. Está inspirado en JUnit (Java), igual que PHPUnit: por eso se parecen tanto.
TestCase = inglés test case (caso de prueba)
La clase de la que heredas para agrupar pruebas. Es el extends TestCase de PHPUnit.
assert = inglés assert (afirmar)
Una instrucción que dice «esto tiene que ser verdad»; si no lo es, lanza AssertionError. PHP tiene un assert() parecido; en Python es la base de los tests de pytest.
pytest = py de Python + test
La biblioteca de tests más usada. Se instala con pip install pytest.
fixture = inglés fixture (pieza fija); viene de los bancos de pruebas de hardware, donde es el soporte fijo que sujeta lo que se prueba
Una función que prepara lo que necesita un test (datos, una BD en memoria) y se lo entrega. Es el setUp() de PHPUnit, pero reutilizable.
parametrize = parametrizar: convertir en parámetro
Ejecutar el mismo test con varios datos de entrada. Es el #[DataProvider] de PHPUnit.
En 4 ideas
1/4

unittest viene con Python y es casi PHPUnit: una clase que hereda de TestCase, métodos que empiezan por test y self.assertEqual(...) (el $this->assertSame(...)).

1 · Qué se prueba y cómo se llama a cada cosa

Imagina que cada vez que cambias una receta tienes que cenarte el plato entero para saber si sigue bien. Un test es una cata automática: se hace sola, en un segundo, y avisa si algo ha cambiado. En PHP ya lo conoces con PHPUnit; las ideas son las mismas:

IdeaPHPUnitunittestpytest
Dónde vivenclase que extends TestCaseclase que hereda de unittest.TestCasefunciones sueltas test_algo() en test_*.py
Comprobar un valor$this->assertSame($a, $b)self.assertEqual(a, b)assert a == b
Comprobar un error$this->expectException(X::class)with self.assertRaises(X):with pytest.raises(X):
Preparar datossetUp()setUp()@pytest.fixture
Varios datos#[DataProvider]with self.subTest(...)@pytest.mark.parametrize
Lanzarlosvendor/bin/phpunitpython -m unittestpytest

Todos los ejemplos usan una función de nuestra app de tareas: valida un título quitando los espacios sobrantes y lanza un error si queda vacío.

2 · unittest: el que ya viene con Python

Este programa define la función y una clase de pruebas, las ejecuta a mano (para ver el resultado en la página) y cuenta el resultado. Hay una prueba que falla a propósito para que veas cómo se informa:

Pythonmain.py
import unittest


def valida_titulo(titulo):
    limpio = titulo.strip()
    if not limpio:
        raise ValueError("el titulo no puede estar vacio")
    return limpio


class PruebasTitulo(unittest.TestCase):
    def test_quita_espacios(self):
        self.assertEqual(valida_titulo("  Comprar pan "), "Comprar pan")

    def test_vacio_lanza_error(self):
        with self.assertRaises(ValueError):
            valida_titulo("   ")

    def test_este_falla_a_proposito(self):
        self.assertEqual(valida_titulo("pan"), "leche")


if __name__ == "__main__":
    suite = unittest.defaultTestLoader.loadTestsFromTestCase(PruebasTitulo)
    resultado = unittest.TestResult()
    suite.run(resultado)
    print("ejecutadas:", resultado.testsRun)
    print("fallos:", len(resultado.failures))
    print("¿todo bien?", resultado.wasSuccessful())
    for prueba, detalle in resultado.failures:
        error = [l for l in detalle.splitlines() if l.startswith("AssertionError")][0]
        print(prueba.id().split(".")[-1], "->", error)

En el día a día no lo haces así: guardas las pruebas en un fichero test_*.py y las lanzas desde la terminal. Con las dos primeras pruebas (las buenas), la salida real es esta:

$ python -m unittest -v
test_quita_espacios (test_titulo.PruebasTitulo.test_quita_espacios) ... ok
test_vacio_lanza_error (test_titulo.PruebasTitulo.test_vacio_lanza_error) ... ok

----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK
PHP 8.5TituloTest.php
<?php
declare(strict_types=1);

use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

final class TituloTest extends TestCase
{
    public static function titulosVacios(): array
    {
        return [[''], ['   ']];
    }

    public function testQuitaEspacios(): void
    {
        $this->assertSame('Comprar pan', validaTitulo('  Comprar pan '));
    }

    #[DataProvider('titulosVacios')]
    public function testTituloVacio(string $titulo): void
    {
        $this->expectException(InvalidArgumentException::class);
        validaTitulo($titulo);
    }
}
Pythontest_titulo.pySolo lectura: necesita pytest
import pytest


def valida_titulo(titulo):
    limpio = titulo.strip()
    if not limpio:
        raise ValueError("el titulo no puede estar vacio")
    return limpio


def test_quita_espacios():
    assert valida_titulo("  Comprar pan ") == "Comprar pan"


@pytest.mark.parametrize("titulo", ["", "   "])
def test_titulo_vacio(titulo):
    with pytest.raises(ValueError):
        valida_titulo(titulo)


if __name__ == "__main__":
    raise SystemExit(pytest.main([__file__, "-q", "-p", "no:cacheprovider"]))

Equivalencia POO · PHP → Python

PHPUnit y unittest comparten esqueleto: es una clase de pruebas que hereda. Aquí el mapa completo, incluido pytest, que prescinde de la clase.

PHP (PHPUnit)PythonQuién lo ve
class TituloTest extends TestCaseclass PruebasTitulo(unittest.TestCase); en pytest, ninguna claseEl descubridor de pruebas
public function testX()def test_x(self) (unittest) o def test_x() (pytest)Solo se ejecutan los que empiezan por test
setUp() / tearDown()setUp() / tearDown() o una fixture con yieldCada prueba
$this->assertSame($a, $b)self.assertEqual(a, b) o assert a == bLa prueba
try { … } catch / expectExceptionwith self.assertRaises(X): o with pytest.raises(X):La prueba
#[DataProvider('titulos')]with self.subTest(...) o @pytest.mark.parametrizeLa prueba

3 · pytest: asserts normales y mensajes que ayudan

La gracia de pytest es que no hay vocabulario que aprender: escribes un assert normal. Y como pytest reescribe el assert por dentro, cuando falla te cuenta qué valía cada lado. Con una prueba que espera 3 y recibe 2, la salida real es:

Pythonmain.py
def test_cuenta_pendientes():
    tareas = [{"titulo": "a", "hecha": False}, {"titulo": "b", "hecha": False}]
    assert len(pendientes(tareas)) == 3
$ pytest -q
F                                                                        [100%]
=================================== FAILURES ===================================
____________________________ test_cuenta_pendientes ____________________________

    def test_cuenta_pendientes():
        tareas = [{"titulo": "a", "hecha": False}, {"titulo": "b", "hecha": False}]
>       assert len(pendientes(tareas)) == 3
E       AssertionError: assert 2 == 3
E        +  where 2 = len([{'titulo': 'a', 'hecha': False}, {'titulo': 'b', 'hecha': False}])
E        +    where [{'titulo': 'a', 'hecha': False}, {'titulo': 'b', 'hecha': False}] = pendientes([{'titulo': 'a', 'hecha': False}, {'titulo': 'b', 'hecha': False}])

test_falla.py:6: AssertionError
=========================== short test summary info ============================
FAILED test_falla.py::test_cuenta_pendientes - AssertionError: assert 2 == 3
1 failed in 0.03s

Mira la línea assert 2 == 3 y las de where: sabes que len(...) valía 2 sin añadir ningún print. Con unittest sería self.assertEqual(len(pendientes(tareas)), 3) y el mensaje diría solo 2 != 3.

¿Por qué? · En PHP no existe

¿Por qué pytest usa assert y no métodos assertXxx? En PHP no existe

PHPUnit necesita un método por cada tipo de comprobación (assertSame, assertCount, assertContains…) porque en PHP un assert() normal no dice qué falló. Hay que aprender decenas de nombres.

pytest cambia el código del assert justo antes de ejecutarlo para recordar los valores intermedios. Así un assert a == b te da el mismo mensaje detallado que un assertEqual, y usas el operador que ya conoces (==, in, is, >).

4 · Fixtures y parametrize

Una fixture es una función que prepara algo y se lo da al test por el nombre del parámetro. Si tu prueba tiene un parámetro tareas, pytest busca una fixture que se llame tareas, la ejecuta y le pasa el resultado. Si la fixture usa yield, lo que va después del yield se ejecuta al terminar el test (aunque falle): el sitio para limpiar.

Pythonmain.pySolo lectura: necesita pytest
import pytest


def valida_titulo(titulo):
    limpio = titulo.strip()
    if not limpio:
        raise ValueError("el titulo no puede estar vacio")
    return limpio


def pendientes(tareas):
    return [t for t in tareas if not t["hecha"]]


@pytest.fixture
def tareas():
    return [
        {"titulo": "Comprar pan", "hecha": False},
        {"titulo": "Llamar al banco", "hecha": True},
    ]


@pytest.fixture
def papelera():
    cajon = []
    yield cajon
    cajon.clear()


@pytest.mark.parametrize("titulo", ["", "   ", "\t"])
def test_titulo_vacio(titulo):
    with pytest.raises(ValueError, match="vacio"):
        valida_titulo(titulo)


def test_pendientes(tareas):
    assert [t["titulo"] for t in pendientes(tareas)] == ["Comprar pan"]


def test_papelera_empieza_vacia(papelera):
    assert papelera == []
    papelera.append("tarea borrada")


def test_papelera_vuelve_vacia(papelera):
    assert papelera == []


if __name__ == "__main__":
    raise SystemExit(pytest.main([__file__, "-v", "-p", "no:cacheprovider"]))

Con -v (de verbose, «detallado») pytest enseña cada prueba, y parametrize la repite una vez por dato. Salida real:

$ pytest -v
collected 6 items

test_tareas.py::test_titulo_vacio[] PASSED                               [ 16%]
test_tareas.py::test_titulo_vacio[   ] PASSED                            [ 33%]
test_tareas.py::test_titulo_vacio[\t] PASSED                             [ 50%]
test_tareas.py::test_pendientes PASSED                                   [ 66%]
test_tareas.py::test_papelera_empieza_vacia PASSED                       [ 83%]
test_tareas.py::test_papelera_vuelve_vacia PASSED                        [100%]

============================== 6 passed in 0.03s ===============================

Fíjate en las dos últimas pruebas: la primera mete una tarea en la papelera y la segunda la encuentra vacía. Cada prueba recibe una fixture nueva, así que ninguna contamina a la siguiente. Por defecto una fixture se crea una vez por prueba (ese es su alcance, o scope).

unittest también sabe repetir una prueba con varios datos, con subTest. Si uno falla, el resto se sigue ejecutando y cada fallo se informa por separado. Aquí el caso (5, True) está mal a propósito:

Pythonmain.py
import unittest


def prioridad_valida(n):
    return 1 <= n <= 3


class PruebasPrioridad(unittest.TestCase):
    def test_varias(self):
        casos = [(1, True), (3, True), (0, False), (4, False), (5, True)]
        for n, esperado in casos:
            with self.subTest(n=n):
                self.assertEqual(prioridad_valida(n), esperado)


if __name__ == "__main__":
    suite = unittest.defaultTestLoader.loadTestsFromTestCase(PruebasPrioridad)
    resultado = unittest.TestResult()
    suite.run(resultado)
    print("fallos:", len(resultado.failures))
    for prueba, detalle in resultado.failures:
        print(prueba.id().split(".")[-1], "->", detalle.strip().splitlines()[-1])

5 · Probar una API sin levantar un servidor

Cuando construyas la API de tareas del módulo 10 querrás probar que GET /tareas responde bien. En PHP tendrías que arrancar php -S y llamar con curl, o falsear el $_GET a mano. En FastAPI no hace falta ningún servidor: el TestClient llama directamente a la aplicación, como si la petición hubiera llegado. Por qué se puede hacer (la aplicación es solo una función) se explica en la lección de FastAPI y uvicorn.

Pythonmain.pySolo lectura: necesita FastAPI y pytest
import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient

app = FastAPI()
tareas = [{"id": 1, "titulo": "Comprar pan", "hecha": False}]


@app.get("/tareas")
def lista():
    return tareas


@pytest.fixture
def cliente():
    return TestClient(app)


def test_lista_tareas(cliente):
    respuesta = cliente.get("/tareas")
    assert respuesta.status_code == 200
    assert respuesta.json() == [{"id": 1, "titulo": "Comprar pan", "hecha": False}]


def test_ruta_inexistente(cliente):
    assert cliente.get("/nada").status_code == 404


if __name__ == "__main__":
    raise SystemExit(pytest.main([__file__, "-q", "-p", "no:cacheprovider"]))
  • TestClient(app) es el «navegador de mentira»: get, post, put y delete devuelven una respuesta con status_code y json().
  • No abre ningún puerto, así que los tests son rápidos y no chocan con nada del ordenador.
  • Necesita la biblioteca httpx: pip install httpx (o uv add --dev httpx pytest).

La pregunta que te vas a hacer

Vale, pero… ¿y probar con la base de datos de verdad?

Para los tests se usa otra BD, casi siempre SQLite en memoria (sqlite3.connect(":memory:")) que una fixture crea limpia para cada prueba, como en el módulo 10. Así los tests no tocan los datos de verdad y se ejecutan en milisegundos.

Hora de practicar

Retos · 0/4 resueltos

Reto 1 de 4

Tu primer test a mano

La función titulo_valido dice si un título tiene algo más que espacios. Los dos assert están al revés y el programa se rompe con AssertionError. Arréglalos para que el programa imprima ok.

Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.

Pythonmain.py · editable

Resumen

Lo que te llevas de esta lección

  1. unittest viene con Python y se parece a PHPUnit: TestCase, métodos test_*, assertEqual (el assertSame) y assertRaises (el expectException).
  2. pytest usa funciones y assert normales, y su mensaje de fallo enseña los valores de cada lado. Es lo que se usa en casi todos los proyectos.
  3. Una fixture entrega lo que necesita un test por el nombre del parámetro y, con yield, lo limpia después (el setUp() y tearDown() de PHPUnit).
  4. @pytest.mark.parametrize y subTest repiten una prueba con varios datos (el #[DataProvider] de PHPUnit).
  5. TestClient prueba una API de FastAPI sin servidor y sin abrir puertos; el assert no sirve para validar datos reales (con python -O desaparece).

Para recordarlo: «Prepara, Actúa, Afirma»

PPrepara
una fixture o setUp()
AActúa
llama a la función o a la ruta
AAfirma
assert resultado == esperado

Toda prueba tiene tres pasos: Prepara los datos, Actúa llamando a lo que pruebas y Afirma lo que debería haber pasado. En inglés se conoce como Arrange, Act, Assert.