Lección 38 de 47 · Un proyecto real✦ WebMCP implementado
Tests: de PHPUnit a unittest y pytest
10 min de lectura4 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(...)).
pytest no necesita clases: una función que empieza por test_ y un assert normal. Cuando falla, pytest te enseña los valores de cada lado, sin docenas de métodos assertXxx.
Una fixture prepara y entrega lo que necesita el test (y con yield también lo limpia después); @pytest.mark.parametrize repite el test con varios datos (el setUp() y el #[DataProvider] de PHPUnit).
Una API de FastAPI se prueba sin servidor: TestClient llama a la aplicación directamente, como si llegase la petición (en PHP necesitarías levantar php -S o simular el $_GET).
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:
Idea
PHPUnit
unittest
pytest
Dónde viven
clase que extends TestCase
clase que hereda de unittest.TestCase
funciones 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 datos
setUp()
setUp()
@pytest.fixture
Varios datos
#[DataProvider]
with self.subTest(...)
@pytest.mark.parametrize
Lanzarlos
vendor/bin/phpunit
python -m unittest
pytest
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
defvalida_titulo(titulo):
limpio = titulo.strip()
ifnot limpio:
raiseValueError("el titulo no puede estar vacio")
return limpio
classPruebasTitulo(unittest.TestCase):
deftest_quita_espacios(self):
self.assertEqual(valida_titulo(" Comprar pan "), "Comprar pan")
deftest_vacio_lanza_error(self):
withself.assertRaises(ValueError):
valida_titulo(" ")
deftest_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
import pytest
defvalida_titulo(titulo):
limpio = titulo.strip()
ifnot limpio:
raiseValueError("el titulo no puede estar vacio")
return limpio
deftest_quita_espacios():
assertvalida_titulo(" Comprar pan ") == "Comprar pan"@pytest.mark.parametrize("titulo", ["", " "])
deftest_titulo_vacio(titulo):
with pytest.raises(ValueError):
valida_titulo(titulo)
if __name__ == "__main__":
raiseSystemExit(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)
Python
Quién lo ve
class TituloTest extends TestCase
class PruebasTitulo(unittest.TestCase); en pytest, ninguna clase
El 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 yield
Cada prueba
$this->assertSame($a, $b)
self.assertEqual(a, b) o assert a == b
La prueba
try { … } catch / expectException
with self.assertRaises(X): o with pytest.raises(X):
La prueba
#[DataProvider('titulos')]
with self.subTest(...) o @pytest.mark.parametrize
La 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:
$ 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
defvalida_titulo(titulo):
limpio = titulo.strip()
ifnot limpio:
raiseValueError("el titulo no puede estar vacio")
return limpio
defpendientes(tareas):
return [t for t in tareas ifnot t["hecha"]]
@pytest.fixturedeftareas():
return [
{"titulo": "Comprar pan", "hecha": False},
{"titulo": "Llamar al banco", "hecha": True},
]
@pytest.fixturedefpapelera():
cajon = []
yield cajon
cajon.clear()
@pytest.mark.parametrize("titulo", ["", " ", "\t"])
deftest_titulo_vacio(titulo):
with pytest.raises(ValueError, match="vacio"):
valida_titulo(titulo)
deftest_pendientes(tareas):
assert [t["titulo"] for t inpendientes(tareas)] == ["Comprar pan"]
deftest_papelera_empieza_vacia(papelera):
assert papelera == []
papelera.append("tarea borrada")
deftest_papelera_vuelve_vacia(papelera):
assert papelera == []
if __name__ == "__main__":
raiseSystemExit(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:
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
defprioridad_valida(n):
return1 <= n <= 3classPruebasPrioridad(unittest.TestCase):
deftest_varias(self):
casos = [(1, True), (3, True), (0, False), (4, False), (5, True)]
for n, esperado in casos:
withself.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
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.
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
Pista. Un título con letras es válido (True) y uno de solo espacios no (False). Cambia lo que esperan los dos assert.
Reto 2 de 4 · ✓ Resuelto
Valida el título
Escribe valida_titulo(titulo): devuelve el título sin espacios al principio ni al final, y lanza ValueError si queda vacío. Es la función que probaste en la lección y que en PHP lanzaría InvalidArgumentException.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.titulo.strip() quita los espacios. Si el resultado es un texto vacío, if not limpio: es verdadero y ahí haces raise ValueError("...").
Reto 3 de 4 · ✓ Resuelto
Tu propio parametrize
Escribe ejecuta_casos(funcion, casos): casos es una lista de pares (argumentos, esperado), donde argumentos es una tupla. Llama a funcion(*argumentos) con cada caso y devuelve la lista de los que fallan, cada uno como (argumentos, esperado, obtenido). Si todos pasan, []. Es lo que hace @pytest.mark.parametrize por dentro.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Recorre casos desempaquetando cada par: for argumentos, esperado in casos. Llama con funcion(*argumentos) (el * abre la tupla) y guarda en una lista los que no coinciden.
Reto 4 de 4 · ✓ Resuelto
Tu propia fixture con yield
Escribe ejecuta_con_fixture(fixture, prueba): fixture es una función generadora con un solo yield (lo de antes del yield prepara, lo de después limpia) y prueba una función que recibe lo que entrega la fixture. Debes obtener el valor, llamar a prueba(valor), devolver True si no falla y False si lanza AssertionError, y ejecutar la limpieza siempre, también si la prueba falla.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.next(generador) ejecuta la fixture hasta el yield y te da el valor. Llama a la prueba dentro de un try, y en el finally haz next(generador, None) para que corra lo de después del yield.
Resumen
Lo que te llevas de esta lección
unittest viene con Python y se parece a PHPUnit: TestCase, métodos test_*, assertEqual (el assertSame) y assertRaises (el expectException).
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.
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).
@pytest.mark.parametrize y subTest repiten una prueba con varios datos (el #[DataProvider] de PHPUnit).
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.