Crear pruebas unitarias

Completados

Crear pruebas unitarias

Supongamos que escribe una función que calcula un descuento y la prueba a mano. Más adelante, refactorizarás la función. Tienes que probarlo de nuevo a mano, y es fácil olvidarlo.

Las pruebas unitarias son comprobaciones automatizadas que comprueban que el código funciona correctamente. Las escribes una vez y las ejecutas cada vez que cambia el código.

Escribir una prueba sencilla

El código siguiente define una función y una prueba para ella:

def calculate_discount(price: float, discount_percent: float) -> float:
    """Calculate price after applying a discount."""
    return price * (1 - discount_percent / 100)

# Test it
def test_calculate_discount():
    # No discount should return original price
    result = calculate_discount(100, 0)
    assert result == 100, "No discount should return original price"
    
    # 50% discount should return half price
    result = calculate_discount(100, 50)
    assert result == 50, "50% discount should return half price"
    
    print("All tests passed!")

# Run the test
test_calculate_discount()
All tests passed!

La assert instrucción comprueba que una condición es verdadera. Si la condición es false, Python genera un AssertionError con el mensaje. Por ejemplo, si calculate_discount(100, 50) devolviera 60, el programa se detendría con:

Traceback (most recent call last):
  ...
AssertionError: 50% discount should return half price

La prueba comprueba el resultado por usted, por lo que no tiene que comprobarlo a mano cada vez.

Estas comprobaciones comparan exactamente los números, lo cual funciona aquí porque los resultados son números enteros. Para los resultados decimales, compare con una tolerancia, como math.isclose(result, expected), porque las pequeñas diferencias de redondeo pueden hacer que una comparación exacta falle.

Note

Python ignora las instrucciones assert cuando se ejecuta con la opción -O. Usa assert en pruebas. Utiliza if y raise para validar las entradas en tu programa, tal y como aprendiste en la unidad anterior.

¿Por qué importan las pruebas?

Las pruebas proporcionan tres ventajas:

  1. Confianza: cuando las pruebas se superan, el código funciona en los casos que has probado.
  2. Seguridad: cuando refactorizas el código, las pruebas muestran si has estropeado algo.
  3. Documentación: las pruebas muestran cómo usar las funciones.

Ejecutar varias pruebas

Cuando tengas varias funciones, utiliza el unittest marco de trabajo de Python para organizar y ejecutar tus pruebas. Coloca las funciones en calculator.py:

# calculator.py
def add(a: float, b: float) -> float:
    """Return the sum of a and b."""
    return a + b

def subtract(a: float, b: float) -> float:
    """Return a minus b."""
    return a - b

def divide(a: float, b: float) -> float:
    """Return a divided by b. Raise ValueError if b is zero."""
    if b == 0:
        raise ValueError("b must not be zero")
    return a / b

Coloca las pruebas en test_calculator.py:

# test_calculator.py
import unittest
from calculator import add, subtract, divide

class TestCalculator(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)

    def test_divide(self):
        self.assertEqual(divide(10, 4), 2.5)

    def test_divide_by_zero(self):
        with self.assertRaises(ValueError):
            divide(10, 0)

    def test_subtract(self):
        self.assertEqual(subtract(5, 2), 3)

La TestCase clase proporciona métodos de aserción como assertEqual, que comprueba que dos valores son iguales y assertRaises, que comprueba que el código genera una excepción específica.

La divide(10, 0) prueba cubre un caso límite, una entrada con la que es fácil equivocarse. También confirma que la validación en divide funciona.

En la carpeta que contiene ambos archivos, ejecute:

python -m unittest test_calculator -v
test_add (test_calculator.TestCalculator.test_add) ... ok
test_divide (test_calculator.TestCalculator.test_divide) ... ok
test_divide_by_zero (test_calculator.TestCalculator.test_divide_by_zero) ... ok
test_subtract (test_calculator.TestCalculator.test_subtract) ... ok

----------------------------------------------------------------------
Ran 4 tests in 0.001s

OK

Note

Esta salida usa el formato Python 3.11 y versiones posteriores. Las versiones anteriores muestran test_add (test_calculator.TestCalculator) en su lugar.

Cuando falla una prueba, unittest muestra los valores esperados y reales. En este ejemplo, 4 devuelve subtract(5, 2) pero la prueba espera 3:

======================================================================
FAIL: test_subtract (test_calculator.TestCalculator.test_subtract)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_calculator.py", line 17, in test_subtract
    self.assertEqual(subtract(5, 2), 3)
AssertionError: 4 != 3

O bien el código o bien la prueba son incorrectos. Comprobar ambos.

Escribir pruebas primero (opcional)

En el desarrollo basado en pruebas, escribes la prueba antes que la función. Empiece con la prueba:

def test_is_even():
    assert is_even(2)
    assert not is_even(3)
    assert is_even(0)

test_is_even()

Ejecute la prueba. Falla porque is_even aún no existe:

NameError: name 'is_even' is not defined

A continuación, escriba is_even encima del test:

def is_even(number):
    return number % 2 == 0

Vuelva a ejecutar la prueba. Pasa. Escribir la prueba primero le obliga a decidir qué debe hacer la función antes de escribirla.

Comience las pruebas

Siga estos pasos:

  1. Escriba una función.
  2. Pruebe el flujo principal, el caso normal.
  3. Pruebe los casos límite, como la entrada vacía, cero, números negativos y valores no válidos.
  4. Ejecute las pruebas después de cada cambio.

Las pruebas te dan una red de seguridad. Al refactorizar, es probable que detecten los errores.