PyCharm Pruebas unitarias

Las pruebas unitarias son un medio fundamental para garantizar la calidad del código; verifican si el comportamiento de la unidad más pequeña comprobable del programa se ajusta a lo esperado.

Escribir y ejecutar pruebas unitarias en PyCharm es muy conveniente; el IDE ofrece un flujo de trabajo completo que va desde la creación de pruebas hasta su ejecución y el análisis de resultados.

PyCharm incluye soporte integrado para tres marcos de pruebas principales de Python:unittest、pytestynose。

Escribir ejemplos de pruebas

A continuación, mediante un ejemplo completo, se muestra cómo escribir pruebas unitarias en PyCharm.

Primero creamos unaCarclase simple y luego escribimos casos de prueba para ella.

Código bajo prueba: car.py

Ejemplo

# car.py - una clase Car simple para demostrar la escritura de pruebas unitarias
class Car:
    """Clase que simula un automóvil, con funciones de aceleración y frenado."""

    def __init__(self, make="ejemplo", model="EJEMPLO-X1"):
        # Inicializa la marca y el modelo del automóvil
        self.make = make
        self.model = model
        # La velocidad inicial es 0
        self.speed = 0

    def accelerate(self, increment):
        """Método de aceleración
Parámetros:
increment: incremento de velocidad, debe ser un entero positivo
Devuelve:
La velocidad actual después de acelerar
Excepciones:
ValueError: se lanza cuando increment es negativo o cero
        """
        if increment <= 0:
            raise ValueError("El incremento de aceleración debe ser un número positivo")
        self.speed += increment
        return self.speed

    def brake(self, decrement):
        """Método de frenado
Parámetros:
decrement: cantidad de desaceleración, debe ser un entero positivo
Devuelve:
La velocidad actual después de frenar, como mínimo 0
Excepciones:
ValueError: se lanza cuando decrement es negativo o cero
        """
        if decrement <= 0:
            raise ValueError("La cantidad de desaceleración debe ser un número positivo")
        self.speed = max(0, self.speed - decrement)
        return self.speed

Código de prueba: test_car.py

Ejemplo

# test_car.py - Pruebas unitarias de la clase Car
# Casos de prueba escritos con el marco unittest
import unittest
from car import Car


class TestCar(unittest.TestCase):
    """Suite de pruebas de la clase Car"""

    def setUp(self):
        """Antes de cada método de prueba se llama a setUp, que crea una instancia nueva de Car"""
        self.car = Car()

    def test_initial_speed(self):
        """Comprueba si la velocidad inicial es 0"""
        self.assertEqual(self.car.speed, 0,
                         "La velocidad inicial de un coche nuevo debe ser 0")

    def test_accelerate_normal(self):
        """Prueba el escenario de aceleración normal"""
        # Acelerar 50
        result = self.car.accelerate(50)
        # Verificar el valor de retorno
        self.assertEqual(result, 50,
                         "La velocidad después de acelerar debe ser 50")
        # Verificar el estado del objeto
        self.assertEqual(self.car.speed, 50,
                         "El atributo car.speed debe actualizarse a 50")

    def test_accelerate_multiple_times(self):
        """Prueba el efecto acumulado de varias aceleraciones"""
        # Primera aceleración de 30
        self.car.accelerate(30)
        # Segunda aceleración de 20
        result = self.car.accelerate(20)
        # La velocidad total debería ser 50
        self.assertEqual(result, 50,
                         "Después de dos aceleraciones, la velocidad debe ser 50")

    def test_accelerate_with_zero(self):
        """Prueba que se lanza una excepción cuando el incremento de aceleración es 0"""
        with self.assertRaises(ValueError,
                               msg="Si el incremento de aceleración es 0, debe lanzarse ValueError"):
            self.car.accelerate(0)

    def test_accelerate_negative(self):
        """Prueba que se lanza una excepción cuando el incremento de aceleración es negativo"""
        with self.assertRaises(ValueError,
                               msg="Si el incremento de aceleración es negativo, debe lanzarse ValueError"):
            self.car.accelerate(-10)

    def test_brake_normal(self):
        """Prueba el escenario de frenado normal"""
        # Primero acelerar a 80
        self.car.accelerate(80)
        # Frenar 30
        result = self.car.brake(30)
        # Verificar la velocidad
        self.assertEqual(result, 50,
                         "Después de frenar, la velocidad debe ser 50")

    def test_brake_below_zero(self):
        """Prueba que el frenado no hace que la velocidad baje de 0"""
        # Primero acelerar a 20
        self.car.accelerate(20)
        # Frenar 50, la velocidad debería limitarse a 0
        result = self.car.brake(50)
        self.assertEqual(result, 0,
                         "La velocidad no debe ser inferior a 0")

    def test_brake_with_zero(self):
        """Prueba que se lanza una excepción cuando la cantidad de desaceleración es 0"""
        with self.assertRaises(ValueError,
                               msg="Si la cantidad de desaceleración es 0, debe lanzarse ValueError"):
            self.car.brake(0)


# Ejecutar las pruebas cuando el script se ejecute directamente
if __name__ == "__main__":
    unittest.main()

PyCharm puede identificar automáticamente las clases y métodos de prueba. Los nombres de las clases de prueba usan como prefijoTesty los nombres de los métodos de prueba usan como prefijotest_. Esta es la convención de nomenclatura de las pruebas en Python.

Ejecutar pruebas

Una vez escrito el código de las pruebas, hay varias formas de ejecutarlas.

Método 1: hacer clic en el icono verde de ejecución

PyCharm muestra en el área Gutter, a la izquierda de la clase de prueba y de cada método de prueba, unicono verde de ejecución。

Al hacer clic en el icono verde junto al nombre de la clase se ejecutan todas las pruebas de esa clase; al hacer clic en el icono junto a un método se ejecuta solo esa prueba.

También se puede hacer clic derecho en el archivo de prueba y, en el menú, seleccionarRun 'test_car'。

Método 2: usar atajos de teclado

Coloque el cursor dentro de la clase o método de prueba y presioneCtrl + Shift + F10para ejecutar la prueba actual.

Ver resultados de las pruebas

Cuando la ejecución de las pruebas finaliza, PyCharm muestra en la parte inferior, en laRunventana de herramientasuna vista de árbolde los resultados de las pruebas.

Las pruebas que pasan se marcan con una marca de verificación verde, las que fallan con una cruz roja, junto con información detallada del error y la traza de pila.

Al hacer clic en un elemento de prueba fallido, PyCharm salta directamente a la línea de código con el error, lo que facilita localizar rápidamente el problema.

Cambiar el marco de pruebas

PyCharm usa por defectounittestcomo ejecutor de pruebas, pero puede cambiar fácilmente a otros marcos.

Pasos de configuración

  1. AbraConfiguración(atajo Ctrl + Alt + S; en macOS, Command + ,).
  2. Navegue a Python。
  3. EnHerramientas integradasy, en el área, busque elmenú desplegable dePruebas.
  4. desdeUnittests、pytest、NosetestsSeleccione el marco que necesite.
  5. Haga clic enAceptarpara guardar la configuración.

Si elige pytest como ejecutor de pruebas, asegúrese de haber instaladopip install pytestel paquete pytest.

Sugerencias de desarrollo guiado por pruebas

Las pruebas unitarias no solo sirven para verificar el código existente, sino que sondesarrollo guiado por pruebas (TDD)la práctica central.

El flujo de desarrollo recomendado es: escribir primero los casos de prueba, luego el código de implementación y, por último, verificar mediante las pruebas.

Adquiera el hábito de escribir pruebas; la calidad de su código mejorará notablemente.

Otras extensiones