Python

Pruebas con pytest: demuestra que tu código funciona

Aprende 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 ⌄
PYTHON · PRUEBAS AUTOMATIZADAS

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.

La pregunta que guía esta publicación

¿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.

pytest Pruebas assert Errores 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.

SI ESTÁS COMENZANDO Entender antes de memorizar

Explicaremos cada concepto utilizando situaciones cotidianas, resultados esperados y fragmentos breves de código.

No necesitas experiencia previa escribiendo pruebas automatizadas.

SI YA PROGRAMAS EN PYTHON Aprender a comprobar tu código

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.

COMPRENDER EL PROBLEMA

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

01 · EJECUTAR Observar qué hace el programa

Ejecutamos instrucciones y revisamos los resultados que aparecen en pantalla.

Es una forma directa de comprobar manualmente cómo se comporta nuestro código.

02 · DEPURAR Investigar por qué algo falla

Cuando encontramos un comportamiento inesperado, analizamos su causa.

Podemos inspeccionar variables, revisar condiciones y seguir la ejecución para localizar el problema.

03 · PROBAR Comprobar resultados esperados

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.

Una prueba automatizada convierte una expectativa en una comprobación que podemos repetir.

¿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.

Una distinción importante

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.

NUESTRO CASO DE ESTUDIO

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?

REGLA 01 Envío normal

Cuando el pedido tiene un valor inferior a 100.000 pesos, el envío cuesta 10.000 pesos.

REGLA 02 Envío gratuito

Si el pedido alcanza o supera los 100.000 pesos, el envío normal no tiene costo.

REGLA 03 Envío urgente

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.

REGLA 04 Pedidos inválidos

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.

1
Un pedido de 50.000 pesos

El envío normal debería costar 10.000 pesos.

2
Un pedido de 100.000 pesos

El envío normal debería ser gratuito.

3
Un pedido de 99.999 pesos

El envío normal todavía debería costar 10.000 pesos.

4
Un pedido urgente de 150.000 pesos

El envío debería costar 20.000 pesos, aunque el total supere el límite del envío gratuito.

5
Un pedido con total negativo

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.

15 Pruebas ejecutadas
15 Pruebas aprobadas

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.

¿Por qué utilizamos este ejemplo?

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.

Diagrama de cómo funciona una prueba automatizada con pytest en Python: entrada de datos, ejecución de la función, comparación con el resultado esperado y ejemplos de pruebas aprobadas y fallidas.
Figura 1. pytest permite comprobar automáticamente si una función produce el resultado esperado. Una aserción correcta genera una prueba aprobada (PASSED); una expectativa incumplida produce una prueba fallida (FAILED).
CONOZCAMOS LA HERRAMIENTA

¿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?

01 · DESCUBRIMIENTO Encuentra las pruebas

Podemos organizar las comprobaciones en archivos específicos. pytest identifica las funciones que siguen sus convenciones de nombres.

02 · EJECUCIÓN Ejecuta comprobaciones

Podemos iniciar varias pruebas mediante un solo comando, sin llamar manualmente a cada función de prueba.

03 · RESULTADOS Explica los fallos

Cuando una aserción falla, pytest puede mostrar qué expresión se evaluó y qué valores se obtuvieron.

04 · REUTILIZACIÓN Facilita probar muchos escenarios

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.

No necesitas aprender un lenguaje nuevo

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.

Python
# 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
Texto plano
platform win32 -- Python 3.13.15, pytest-9.0.2

collected 15 items

15 passed in 0.09s
ORGANIZACIÓN DE LAS PRUEBAS

¿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

CÓDIGO DEL PROGRAMA envios.py

Contiene la función calcular_envio(), responsable de aplicar las reglas del costo de envío.

DEMOSTRACIÓN demo.py

Ejecuta varios ejemplos e imprime sus resultados. No es el archivo que pytest utiliza para descubrir nuestras pruebas.

PRUEBAS AUTOMATIZADAS tests/test_envios.py

Contiene las funciones que comprueban los diferentes comportamientos de calcular_envio().

CONFIGURACIÓN pytest.ini

Define opciones de pytest, como el directorio donde buscamos las pruebas y el patrón de sus archivos.

Dos convenciones que debes recordar

1
Archivos de pruebas

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.

2
Funciones de prueba

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.

¿Qué significa collected 15 items?

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.

Python
# ==========================================================
# 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
NUESTRA PRIMERA COMPROBACIÓN

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.

EXPRESIÓN VERDADERA assert 2 + 2 == 4

La condición es verdadera, por lo que esta aserción no produce un error.

CONDICIÓN CUMPLIDA
EXPRESIÓN FALSA assert 2 + 2 == 5

La condición es falsa. Python genera un AssertionError.

CONDICIÓN INCUMPLIDA

Las tres partes de una prueba

Para comprender nuestras pruebas, podemos dividirlas mentalmente en tres momentos: preparar, ejecutar y comprobar.

1
Preparar

Elegimos los datos que queremos evaluar. Por ejemplo, un pedido de exactamente 100.000 pesos.

2
Ejecutar

Llamamos a calcular_envio() utilizando ese importe.

La función aplica las reglas que definimos en envios.py.

3
Comprobar

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.

Una buena prueba comprueba una expectativa concreta

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.

Python
# ==========================================================
# 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
PowerShell
python -m pytest tests/test_envios.py::test_total_justo_en_el_umbral_tiene_envio_gratis -v
COMPRENDER LOS RESULTADOS

¿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.

CONDICIÓN CORRECTA

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.

ERROR INTENCIONAL

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.

0 Resultado esperado
10000 Resultado obtenido
El mensaje que permitió identificar el problema

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.

COPIA CON ERROR 1 failed

La prueba detectó la condición incorrecta.

FALLO DETECTADO
CÓDIGO CORRECTO 15 passed

El 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.

Una prueba fallida puede ser una buena noticia: ha detectado un problema antes de que pase inadvertido.

Para comprender mejor esta diferencia, compararemos visualmente el reporte fallido y el resultado del código corregido.

Comparación de resultados de pytest: una prueba falla porque calcular_envio devuelve 10000 en lugar de 0 para un pedido de 100000 pesos; tras corregir la condición, las 15 pruebas del laboratorio pasa
Figura 2. pytest detectó un error introducido deliberadamente en el cálculo del envío gratuito. La prueba fallida mostró la diferencia entre el resultado esperado y el obtenido; el laboratorio original conservó sus 15 pruebas aprobadas.
APRENDER A ELEGIR LAS PRUEBAS

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.

JUSTO ANTES DEL LÍMITE 99.999 COP

El pedido todavía no alcanza el importe necesario para obtener envío gratuito.

Resultado esperado: 10.000 COP.

EXACTAMENTE EN EL LÍMITE 100.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.

Probar también es formular preguntas

¿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.

Python
# ==========================================================
# 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
Texto plano
test_total_justo_en_el_umbral_tiene_envio_gratis PASSED
test_un_peso_antes_del_umbral_paga_envio PASSED

2 passed
CUANDO LO CORRECTO ES RECHAZAR UNA ENTRADA

¿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.

PEDIDO VÁLIDO 50.000 COP

La función debe devolver el costo correspondiente del envío.

RESULTADO NUMÉRICO
PEDIDO INVÁLIDO -1 COP

La 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.

Una excepción esperada puede producir una prueba aprobada

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.

Python
# ==========================================================
# 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)
Texto plano
test_importes_negativos_producen_value_error[-1] PASSED
test_importes_negativos_producen_value_error[-10000] PASSED

2 passed
PRUEBAS CON DIFERENTES ENTRADAS

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 .

SIN PARAMETRIZACIÓN Varias funciones similares

Escribimos una prueba para cada importe, repitiendo una estructura muy parecida.

CON PARAMETRIZACIÓN Una función, varios casos

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.

1
Definimos las entradas

Por ejemplo, 0, 50.000, 99.999, 100.000 y 150.000 pesos.

2
Indicamos los resultados esperados

Para cada total, definimos si el envío cuesta 10.000 pesos o es gratuito.

3
pytest ejecuta cada caso

Aunque escribimos una sola función de prueba, pytest genera una ejecución por cada conjunto de datos.

Una función de prueba no siempre equivale a una única prueba ejecutada

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.

Estás viendo solo el 60% del contenido. Hazte Premium para acceder a la guía completa.

Comunidad

Comentarios y valoraciones

No hay comentarios aún. ¡Sé el primero en opinar!