Pruebas con pytest: demuestra que tu código funciona
Inicia sesión para descargarAprende a escribir pruebas automatizadas en Python con pytest, desde los conceptos fundamentales hasta las técnicas más utilizadas. Descubre cómo comprobar resultados con assert, detectar errores, evaluar casos límite y utilizar fixtures …
Contenido de la guía ⌄
- Que tu código funcione una vez no significa que siempre funcione
- ¿Qué aprenderás en esta guía?
- Ejecutar, depurar y probar: tres actividades que no significan lo mismo
- Tres formas de trabajar con nuestro código
- ¿Qué es exactamente una prueba automatizada?
- ¿Por qué es importante poder repetirlas?
- Un problema sencillo: ¿cuánto cuesta enviar un pedido?
- ¿Cuáles son las reglas del programa?
- ¿Qué deberíamos comprobar?
- ¿Qué hemos comprobado en nuestro laboratorio?
- ¿Qué es pytest y por qué utilizarlo en Python?
- ¿Qué hace pytest por nosotros?
- ¿pytest es parte de Python?
- ¿Cómo encuentra pytest las pruebas de nuestro programa?
- Conozcamos la organización de nuestro laboratorio
- Dos convenciones que debes recordar
- ¿Por qué aparecieron 15 pruebas?
- De una función a una prueba: cómo funciona assert
- ¿Qué significa assert?
- Las tres partes de una prueba
- ¿Por qué es importante elegir bien los datos?
- ¿Qué sucede cuando una prueba falla?
- Introducimos un error en una condición
- Mayor o igual
- Solamente mayor
- ¿Qué encontró pytest?
- ¿Cómo corregimos el problema?
- ¿Significa que pytest encontró la solución?
- Casos normales y casos límite: por qué una sola prueba no es suficiente
- ¿Qué es un caso normal?
- ¿Qué es un caso límite?
- ¿Por qué probar estos dos valores?
- ¿Cómo comprobamos que una función produce el error esperado?
- ¿Qué debería ocurrir?
- ¿Para qué sirve pytest.raises()?
- También podemos comprobar el mensaje
- Parametrización: probar muchos casos sin repetir el mismo código
- ¿Qué significa parametrizar una prueba?
- ¿Qué datos proporcionamos?
Que tu código funcione una vez no significa que siempre funcione
Imagina que acabas de escribir un programa en Python. Lo ejecutas, observas el resultado y todo parece funcionar correctamente.
Pero después modificas una condición, agregas una funcionalidad o cambias la forma en que se procesa un dato.
¿Cómo puedes saber si ese cambio afectó algo que anteriormente funcionaba?
Ejecutar el programa otra vez puede ayudarte, pero comprobar manualmente cada posible situación puede resultar repetitivo y difícil de mantener.
¿Podemos enseñarle a Python qué resultados esperamos y pedirle que los compruebe automáticamente?
La respuesta es sí. Para hacerlo utilizaremos pytest, una herramienta que permite escribir y ejecutar pruebas automatizadas en Python.
¿Qué aprenderás en esta guía?
Comenzaremos comprendiendo qué es una prueba automatizada y por qué puede ayudarnos a detectar errores.
Después conoceremos pytest, aprenderemos a escribir nuestras primeras comprobaciones y descubriremos cómo interpretar los resultados.
También estudiaremos casos límite, excepciones, pruebas parametrizadas y fixtures, utilizando ejemplos progresivos de un mismo programa.
Explicaremos cada concepto utilizando situaciones cotidianas, resultados esperados y fragmentos breves de código.
No necesitas experiencia previa escribiendo pruebas automatizadas.
Veremos cómo convertir reglas de funcionamiento en pruebas repetibles y cómo identificar situaciones que merecen una comprobación específica.
Para que los ejemplos no sean solamente teóricos, utilizaremos un pequeño laboratorio de Python que hemos ejecutado previamente.
Así podremos mostrar tanto el comportamiento esperado como los resultados de pruebas reales.
Ejecutar, depurar y probar: tres actividades que no significan lo mismo
Cuando aprendemos Python, normalmente comenzamos ejecutando instrucciones y observando los resultados en la terminal.
Por ejemplo, podemos crear una función que realiza un cálculo, llamarla con determinados valores e imprimir el resultado.
Esto nos permite observar el comportamiento del programa, pero no necesariamente comprueba de forma automática que ese comportamiento sea correcto.
Tres formas de trabajar con nuestro código
Ejecutamos instrucciones y revisamos los resultados que aparecen en pantalla.
Es una forma directa de comprobar manualmente cómo se comporta nuestro código.
Cuando encontramos un comportamiento inesperado, analizamos su causa.
Podemos inspeccionar variables, revisar condiciones y seguir la ejecución para localizar el problema.
Definimos previamente qué resultado debe producir una operación para determinada entrada.
Después utilizamos una comprobación automática para comparar lo esperado con lo obtenido.
¿Qué es exactamente una prueba automatizada?
Es código que ejecuta una parte de nuestro programa y comprueba si cumple una condición definida.
Por ejemplo, si una función debe devolver 10 cuando recibe determinados argumentos, podemos escribir una prueba que compare su resultado con el número 10.
Si ambos valores coinciden, la comprobación se cumple. Si no coinciden, la prueba señala un fallo.
¿Por qué es importante poder repetirlas?
Imagina que realizas un cambio en un programa que contiene varias funciones.
Aunque hayas modificado solamente unas pocas líneas, ese cambio podría afectar comportamientos que antes funcionaban correctamente.
Si tenemos pruebas automatizadas, podemos volver a ejecutarlas después de modificar el código.
Esto nos ayuda a detectar regresiones: situaciones donde un cambio introduce un problema en un comportamiento que anteriormente funcionaba.
Que todas nuestras pruebas sean aprobadas no significa que el programa esté libre de cualquier error posible.
Significa que, en esa ejecución, el programa cumplió las condiciones concretas que decidimos comprobar.
Por eso, escribir buenas pruebas también implica pensar qué situaciones podrían producir resultados inesperados.
Con esta idea en mente, podemos presentar el pequeño programa que utilizaremos durante toda la guía.
Un problema sencillo: ¿cuánto cuesta enviar un pedido?
Para aprender pytest utilizaremos un programa pequeño que calcula el costo de envío de los pedidos de una tienda ficticia.
Su objetivo no es representar un comercio real, sino ofrecernos reglas suficientemente claras para comprobar si una función se comporta correctamente.
En nuestro laboratorio,
la función principal se llama
calcular_envio()
y se encuentra en el archivo
envios.py.
¿Cuáles son las reglas del programa?
Cuando el pedido tiene un valor inferior a 100.000 pesos, el envío cuesta 10.000 pesos.
Si el pedido alcanza o supera los 100.000 pesos, el envío normal no tiene costo.
Un envío urgente cuesta 20.000 pesos, independientemente del valor del pedido.
Esta tarifa también se aplica a los pedidos que normalmente tendrían envío gratuito.
Si recibimos un total negativo, la función no debe calcular un envío.
En su lugar, debe generar un error ValueError.
Todos los importes se representan mediante números enteros expresados en pesos colombianos. Estas tarifas son ficticias y se utilizan exclusivamente con fines educativos.
¿Qué deberíamos comprobar?
Imaginemos que ejecutamos el programa con un pedido de 50.000 pesos.
Si el envío cuesta 10.000, el resultado parece correcto.
Pero eso todavía no demuestra que las demás reglas funcionen como esperamos.
El envío normal debería costar 10.000 pesos.
El envío normal debería ser gratuito.
El envío normal todavía debería costar 10.000 pesos.
El envío debería costar 20.000 pesos, aunque el total supere el límite del envío gratuito.
La función debería producir un ValueError en lugar de devolver una tarifa de envío.
¿Qué hemos comprobado en nuestro laboratorio?
Antes de redactar esta guía, ejecutamos el programa en un equipo Windows utilizando Python 3.13.15 y pytest 9.0.2.
Primero utilizamos demo.py para observar el comportamiento del cálculo de envíos.
Después ejecutamos las pruebas automatizadas definidas en tests/test_envios.py.
La ejecución completa terminó correctamente en aproximadamente 0,09 segundos.
Las comprobaciones incluyeron pedidos normales, envíos urgentes, importes negativos y valores cercanos al límite del envío gratuito.
Porque podemos describir fácilmente qué debería ocurrir en cada situación.
Y cuando conocemos el resultado esperado, podemos escribir una prueba que lo compruebe automáticamente.
Antes de escribir nuestra primera prueba con pytest, vamos a visualizar cómo funciona una comprobación automatizada.
¿Qué es pytest y por qué utilizarlo en Python?
Ya comprendimos que una prueba automatizada consiste en ejecutar una operación y comprobar si cumple una expectativa definida.
Sin embargo, cuando un programa necesita muchas comprobaciones, también necesitamos una forma de organizarlas, ejecutarlas e interpretar sus resultados.
Aquí entra pytest, una herramienta de código abierto para escribir y ejecutar pruebas en Python.
pytest permite definir pruebas utilizando funciones normales de Python, descubrirlas automáticamente y mostrar información útil cuando una comprobación falla.
¿Qué hace pytest por nosotros?
Podemos organizar las comprobaciones en archivos específicos. pytest identifica las funciones que siguen sus convenciones de nombres.
Podemos iniciar varias pruebas mediante un solo comando, sin llamar manualmente a cada función de prueba.
Cuando una aserción falla, pytest puede mostrar qué expresión se evaluó y qué valores se obtuvieron.
Mediante fixtures y parametrización podemos preparar datos y comprobar distintas entradas sin repetir innecesariamente el mismo código.
¿pytest es parte de Python?
No. pytest es un paquete externo que normalmente instalamos mediante pip.
Python también incluye el módulo unittest, con el que podemos escribir pruebas sin instalar pytest.
Ambas herramientas permiten crear pruebas automatizadas, pero pytest destaca por permitir pruebas sencillas con funciones y expresiones assert habituales.
Seguiremos escribiendo Python. Utilizaremos funciones, condiciones y expresiones que probablemente ya conoces.
pytest se encargará de descubrir y ejecutar las comprobaciones, además de presentar sus resultados.
En nuestro laboratorio utilizamos pytest 9.0.2 junto con Python 3.13.15. La herramienta ejecutó correctamente las 15 pruebas que preparamos para el cálculo de envíos.
Ahora veremos cómo ejecutarlas desde la terminal.
# LABORATORIO PYTEST - TUCODIGOCOTIDIANO
# Ejecutar dentro de la carpeta del proyecto.
# 1. Comprobar la version de Python
python --version
# 2. Instalar las dependencias del laboratorio
# Si ya estan instaladas, pip lo indicara.
python -m pip install -r requirements.txt
# 3. Consultar la version de pytest
python -m pytest --version
# 4. Ejecutar el programa normalmente
python demo.py
# 5. Ejecutar todas las pruebas con detalles
python -m pytest -v
# 6. Obtener un resumen mas compacto
python -m pytest -q
platform win32 -- Python 3.13.15, pytest-9.0.2
collected 15 items
15 passed in 0.09s
¿Cómo encuentra pytest las pruebas de nuestro programa?
Cuando ejecutamos
python -m pytest,
no necesitamos indicarle
manualmente cada función de prueba.
pytest utiliza convenciones de nombres y opciones de configuración para identificar los archivos que debe examinar y las comprobaciones que debe ejecutar.
Conozcamos la organización de nuestro laboratorio
Contiene la función calcular_envio(), responsable de aplicar las reglas del costo de envío.
Ejecuta varios ejemplos e imprime sus resultados. No es el archivo que pytest utiliza para descubrir nuestras pruebas.
Contiene las funciones que comprueban los diferentes comportamientos de calcular_envio().
Define opciones de pytest, como el directorio donde buscamos las pruebas y el patrón de sus archivos.
Dos convenciones que debes recordar
pytest reconoce de forma predeterminada nombres como test_envios.py o test_calculos.py.
En nuestro laboratorio, pytest.ini configura el patrón test_*.py.
Dentro de esos archivos, las funciones normales cuyos nombres comienzan con test_ se reconocen como pruebas.
Un ejemplo real de nuestro laboratorio es test_un_peso_antes_del_umbral_paga_envio.
¿Por qué aparecieron 15 pruebas?
Nuestro archivo test_envios.py contiene distintas funciones que comprueban pedidos normales, urgentes, importes negativos y valores límite.
Algunas de esas funciones utilizan parametrización. Esto significa que una misma función de prueba puede ejecutarse varias veces con datos diferentes.
Por esa razón, el número de pruebas ejecutadas puede ser superior al número de funciones que escribimos.
Significa que pytest identificó 15 casos de prueba para ejecutar.
En nuestro laboratorio, todos se completaron correctamente y la terminal mostró 15 passed.
Más adelante explicaremos detalladamente la parametrización y el uso de fixtures.
Por ahora, lo importante es comprender que el programa y sus pruebas tienen responsabilidades diferentes.
El programa realiza las operaciones; las pruebas comprueban los resultados.
Veamos ahora el código real de la función que estamos evaluando.
# ==========================================================
# BLOQUE 09 — CODE
# Archivo: envios.py
# Guía: Pruebas con pytest: demuestra que tu código funciona
# TuCódigoCotidiano
# ==========================================================
"""Reglas ficticias de envíos para aprender pruebas con pytest.
Los importes se expresan en pesos colombianos (COP) y son enteros.
"""
def calcular_envio(total: int, urgente: bool = False) -> int:
"""Devuelve el costo del envío para un pedido.
Reglas didácticas:
- El total negativo no es válido y produce ValueError.
- El envío urgente cuesta 20.000 COP sin importar el total.
- El envío normal es gratis desde 100.000 COP (inclusive).
- El envío normal cuesta 10.000 COP por debajo de ese límite.
"""
if total < 0:
raise ValueError("El total del pedido no puede ser negativo")
if urgente:
return 20_000
if total >= 100_000:
return 0
return 10_000
De una función a una prueba: cómo funciona assert
Ya conocemos la función calcular_envio() y las reglas que debe cumplir.
Ahora necesitamos transformar una de esas reglas en una comprobación automática.
Para hacerlo utilizaremos
la instrucción
assert
de Python.
¿Qué significa assert?
assert evalúa una expresión. Si es verdadera, la ejecución continúa.
Si es falsa, Python genera un AssertionError. pytest utiliza ese comportamiento para determinar si una comprobación ha fallado.
La condición es verdadera, por lo que esta aserción no produce un error.
CONDICIÓN CUMPLIDALa condición es falsa. Python genera un AssertionError.
CONDICIÓN INCUMPLIDALas tres partes de una prueba
Para comprender nuestras pruebas, podemos dividirlas mentalmente en tres momentos: preparar, ejecutar y comprobar.
Elegimos los datos que queremos evaluar. Por ejemplo, un pedido de exactamente 100.000 pesos.
Llamamos a calcular_envio() utilizando ese importe.
La función aplica las reglas que definimos en envios.py.
Verificamos que el resultado sea cero, porque el envío normal debe ser gratuito desde los 100.000 pesos.
¿Por qué es importante elegir bien los datos?
Imagina que una función devuelve correctamente el costo de envío para un pedido de 50.000 pesos.
Esa comprobación no garantiza que también funcione cuando el pedido alcanza los 100.000 pesos.
Precisamente en ese valor cambia una de nuestras reglas: el envío normal pasa a ser gratuito.
No basta con ejecutar una función y observar que no produce errores.
Debemos conocer qué resultado esperamos y comprobarlo expresamente.
Veamos cómo escribimos esa comprobación en nuestro archivo de pruebas real.
# ==========================================================
# BLOQUE 11 — CODE
# Archivo: tests/test_envios.py
# Guía: Pruebas con pytest: demuestra que tu código funciona
# TuCódigoCotidiano
# ==========================================================
from envios import calcular_envio
def test_total_justo_en_el_umbral_tiene_envio_gratis():
assert calcular_envio(100_000) == 0
python -m pytest tests/test_envios.py::test_total_justo_en_el_umbral_tiene_envio_gratis -v
¿Qué sucede cuando una prueba falla?
Acabamos de comprobar que nuestra función calcula correctamente un envío gratuito para un pedido de exactamente 100.000 pesos.
Pero una de las razones para utilizar pruebas automatizadas es que también puedan advertirnos cuando una modificación introduce un comportamiento incorrecto.
Para observar esa situación, realizamos un experimento controlado sobre una copia del programa original.
Introducimos un error en una condición
Nuestra regla establece que un pedido normal tiene envío gratuito cuando alcanza o supera los 100.000 pesos.
En la implementación correcta, utilizamos el operador de comparación mayor o igual.
Mayor o igual
La expresión
total >= 100_000
incluye los pedidos
de exactamente 100.000 pesos.
Por eso, la función devuelve cero para ese importe.
Solamente mayor
Si cambiamos
la condición a
total > 100_000,
el valor de exactamente
100.000 queda excluido.
Entonces, la función devuelve incorrectamente una tarifa de 10.000 pesos.
¿Qué encontró pytest?
Cuando ejecutamos la prueba sobre la copia que contenía el error, la comprobación falló.
El reporte mostró que el resultado obtenido fue 10000, aunque esperábamos cero.
La comprobación incumplida
apareció en el reporte como
assert 10000 == 0.
Esto nos indicó que el programa estaba cobrando un envío que, según nuestras reglas, debía ser gratuito.
¿Cómo corregimos el problema?
Restauramos el operador mayor o igual para que el importe de 100.000 pesos volviera a estar incluido en la condición.
Después comprobamos que el código original continuaba superando las 15 pruebas de nuestro laboratorio.
La prueba detectó la condición incorrecta.
FALLO DETECTADOEl laboratorio original cumplió las comprobaciones definidas.
PRUEBAS APROBADAS¿Significa que pytest encontró la solución?
No. pytest detectó que el resultado incumplía una expectativa.
Después nosotros analizamos la condición, identificamos el error y corregimos la implementación.
Las pruebas nos ayudan a descubrir comportamientos incorrectos, pero comprender y solucionar sus causas sigue siendo parte del trabajo de programación.
Para comprender mejor esta diferencia, compararemos visualmente el reporte fallido y el resultado del código corregido.
Casos normales y casos límite: por qué una sola prueba no es suficiente
Nuestra primera prueba comprobó que un pedido de exactamente 100.000 pesos tiene envío gratuito.
Pero una función puede producir el resultado correcto para una entrada y fallar con otra muy parecida.
Por eso, aprender a probar también significa aprender a seleccionar los datos que vamos a utilizar.
¿Qué es un caso normal?
Un caso normal representa una situación habitual para la que el programa fue diseñado.
En nuestro ejemplo, un pedido de 50.000 pesos constituye un caso normal: el envío debe costar 10.000 pesos.
¿Qué es un caso límite?
Un caso límite utiliza un valor cercano al punto donde cambia el comportamiento de una función.
En nuestro laboratorio, ese punto es el importe de 100.000 pesos.
El pedido todavía no alcanza el importe necesario para obtener envío gratuito.
Resultado esperado: 10.000 COP.
El pedido cumple la condición establecida para el envío gratuito.
Resultado esperado: 0 COP.
¿Por qué probar estos dos valores?
Porque una equivocación entre los operadores mayor que y mayor o igual puede cambiar precisamente el comportamiento de ese valor límite.
Es el error que detectamos en nuestro experimento anterior.
¿Qué ocurre con un pedido pequeño? ¿Qué sucede justo antes del límite? ¿Y exactamente en el límite?
¿Qué ocurre si el usuario solicita un envío urgente o proporciona un importe negativo?
Cada pregunta puede convertirse en una comprobación automatizada.
Veamos dos pruebas reales de nuestro laboratorio que comprueban ambos lados del límite de envío gratuito.
# ==========================================================
# BLOQUE 15 — CODE
# Archivo: tests/test_envios.py
# Guía: Pruebas con pytest: demuestra que tu código funciona
# TuCódigoCotidiano
# ==========================================================
from envios import calcular_envio
def test_total_justo_en_el_umbral_tiene_envio_gratis():
assert calcular_envio(100_000) == 0
def test_un_peso_antes_del_umbral_paga_envio():
assert calcular_envio(99_999) == 10_000
test_total_justo_en_el_umbral_tiene_envio_gratis PASSED
test_un_peso_antes_del_umbral_paga_envio PASSED
2 passed
¿Cómo comprobamos que una función produce el error esperado?
Hasta ahora hemos utilizado assert para comprobar resultados numéricos.
Sin embargo, no todas las funciones deben devolver un resultado para cualquier entrada que reciban.
Algunas entradas son inválidas y deben rechazarse.
Por ejemplo, nuestra función calcular_envio() no permite pedidos con importes negativos.
¿Qué debería ocurrir?
Si alguien proporciona un total de -1 peso, la función debe generar una excepción ValueError.
Esto no representa un fallo inesperado. Es el comportamiento que definimos para los pedidos inválidos.
La función debe devolver el costo correspondiente del envío.
RESULTADO NUMÉRICOLa función debe rechazar el importe negativo mediante una excepción.
VALUEERROR ESPERADO¿Para qué sirve pytest.raises()?
pytest incluye una herramienta
llamada
pytest.raises()
que permite comprobar
que determinada operación
genera una excepción.
La utilizamos dentro de una instrucción with e indicamos qué tipo de excepción esperamos.
En nuestro caso, esperamos ValueError.
Si la función genera la excepción correcta dentro del bloque de pytest.raises(), la comprobación se cumple.
Si no genera la excepción esperada, la prueba falla.
También podemos comprobar el mensaje
El argumento match permite verificar que el mensaje de la excepción coincide con un patrón determinado.
Nuestro programa utiliza el mensaje: "El total del pedido no puede ser negativo".
Podemos comprobar que contiene la expresión "no puede ser negativo".
match utiliza expresiones regulares. En nuestro ejemplo, comprobamos una frase sencilla sin caracteres especiales de ese lenguaje.
Ahora veremos cómo convertimos esta regla en una prueba automatizada real.
# ==========================================================
# BLOQUE 17 — CODE
# Archivo: tests/test_envios.py
# Guía: Pruebas con pytest: demuestra que tu código funciona
# TuCódigoCotidiano
# ==========================================================
import pytest
from envios import calcular_envio
@pytest.mark.parametrize("total", [-1, -10_000])
def test_importes_negativos_producen_value_error(total):
with pytest.raises(
ValueError,
match="no puede ser negativo"
):
calcular_envio(total)
test_importes_negativos_producen_value_error[-1] PASSED
test_importes_negativos_producen_value_error[-10000] PASSED
2 passed
Parametrización: probar muchos casos sin repetir el mismo código
Imaginemos que queremos comprobar seis valores diferentes de pedidos.
Una posibilidad sería escribir seis funciones de prueba independientes, cada una con su propia instrucción assert.
Esa estrategia funciona, pero puede generar código repetitivo.
pytest ofrece una alternativa: la parametrización.
¿Qué significa parametrizar una prueba?
Significa ejecutar la misma función de prueba varias veces, proporcionando distintos conjuntos de datos.
Para ello utilizamos
el decorador
@pytest.mark.parametrize
.
Escribimos una prueba para cada importe, repitiendo una estructura muy parecida.
Definimos los valores de entrada y sus resultados esperados en una colección.
pytest ejecuta la prueba una vez por cada conjunto de parámetros.
¿Qué datos proporcionamos?
En nuestro laboratorio utilizamos dos parámetros: total y esperado.
total representa el valor del pedido que recibe calcular_envio().
esperado representa el costo de envío que debería devolver la función.
Por ejemplo, 0, 50.000, 99.999, 100.000 y 150.000 pesos.
Para cada total, definimos si el envío cuesta 10.000 pesos o es gratuito.
Aunque escribimos una sola función de prueba, pytest genera una ejecución por cada conjunto de datos.
Si una función está parametrizada con seis conjuntos de datos, pytest genera seis casos de prueba independientes.
Por eso nuestro laboratorio pudo recopilar 15 pruebas utilizando menos de 15 funciones de prueba.
La parametrización resulta útil cuando queremos comprobar una misma regla con distintos valores.
Ahora utilizaremos los seis casos reales definidos en nuestro laboratorio para el envío normal.
Comentarios y valoraciones
No hay comentarios aún. ¡Sé el primero en opinar!