Comprender las pruebas unitarias en Python

Probar su código es una parte vital del ciclo de vida del desarrollo de software y siempre debe realizarse antes de implementar la aplicación en producción. La prueba es crucial porque ayuda a rastrear y encontrar errores en el código.

La prueba es un método para verificar unidades individuales de código fuente para confirmar que funciona de manera óptima antes de enviar el código a producción. Es importante tener en cuenta que la implementación del archivo fuente en producción para los usuarios no es necesaria durante las pruebas unitarias.

Sería mejor si también recordara que las pruebas no son específicas de Python.

Este artículo le enseñará cómo escribir pruebas básicas usando pruebas unitarias de Python para verificar si su código pasa o falla durante la prueba.

requisitos previos

Para completar este tutorial, necesita lo siguiente:

• Conocimiento de escritura de código Python.
• Una instalación de la programa pitón en su máquina local
• Un editor de código de su elección

Empezando

Las pruebas de escritura son programas lógicos que un programador escribe para probar un código base. Durante el desarrollo, un QA debe comprender el proceso para resaltar lo que necesita mejorar en la aplicación antes de enviar el producto al usuario. Para este propósito, escribamos una función que sume dos números y devuelva el resultado.

Para comenzar, cree una carpeta que contenga todos los archivos para escribir la prueba en este tutorial. Agregue un archivo llamado main.py para escribir la función en esta nueva carpeta.

 # main.py # Add the sum of two numbers def add_sum(num1, num2): return int(num1) + int(num2)

Ahora que tenemos el bloque de código anterior, verifiquemos que el código funcione escribiendo una función que permita a los usuarios ingresar el valor deseado a través del indicador de entrada. La función add_sum() toma dos números como parámetros y devuelve el valor usando el operador + signo para obtener la suma. En otro archivo, result.py , copia y pega el siguiente código:

 # result.py from main import add_sum print("Please enter the two values\n") num1 = int(input("Please enter the first number: \n")) num2 = int(input("Please enter the second number: \n")) total = add_sum(num1, num2) print(f"The sum of the values is {total}")

Este bloque de código hace lo siguiente:

• Importa add_sum() desde main.py
• convirtió el valor de solicitud de entrada en un número entero usando el método int
• suma los valores que imprimen su total usando las cadenas f (sintaxis de formato) para obtener la salida

¿Qué son las pruebas unitarias y los casos de prueba?

Python viene con un módulo de biblioteca estándar incorporado llamado unittest, que proporciona herramientas para construir y ejecutar pruebas para su código. El objetivo principal de las pruebas unitarias es verificar si todas las funciones del código funcionan como se espera.

Un caso de prueba es una forma estándar de trabajar con una prueba unitaria, con funcionalidades disponibles en la clase de nombre de prueba. Además, un caso de prueba es esencial en el código del componente para las pruebas de unidades individuales. Utiliza diferentes métodos de aserción para verificar e informar fallas inmediatamente después de ejecutar el código.

pasar una prueba

Esta sección se trata de escribir una serie de pruebas.

Antes de crear el archivo de prueba para escribir todos los casos de prueba para la función add_sum() , actualicemos main.py . Copia y pega el siguiente código:

 # main.py def add_sum(num1, num2): try: return int(num1) + int(num2) except ValueError as err: return err

El bloque de código usa la declaración try/except que maneja las excepciones en su código y le avisa si hay un error en el bloque de excepción. Este método de programación ayuda a detectar errores y le indica el número de línea específico donde ocurrió el error.

Ahora, cree un archivo de prueba en el mismo directorio llamado test.py. En este archivo, copia y pega el siguiente código:

 # test.py import unittest from main import add_sum class MainTest(unittest.TestCase): def test_do_stuff(self): result = add_sum(5, 10) self.assertEqual(result, 15) if __name__ == '__main__': unittest.main()

Como se muestra en el bloque de código anterior, ocurre lo siguiente:

• Importe la prueba unitaria y la función que desea probar (viene de main.py)
• Unittest funciona creando una clase que contiene las pruebas para la función add_sum(), que hereda dentro de la clase lo que da unittest, que es unittest.TestCase
• Defina una función con la palabra clave self en test_do_stuff() que represente la instancia de la clase
• Dentro del método de prueba test_do_stuff(), declare una variable y pase los dos argumentos con diferentes valores
• La última línea utiliza el método de aserción unittest, assertEqual, que verifica que los argumentos que pasa de la variable de resultado coincidan con el resultado que espera recibir.
• Finalmente, ejecute todo el archivo de prueba con unittest.main()

Recuerde comenzar cada método con "test_" ya que test.py se ejecuta automáticamente. **
**

Cada vez que ejecuta una prueba, se espera que todas las comprobaciones pasen con un mensaje OK en la consola, lo que significa que fue exitosa.

 Ran 1 test in 0.000s OK

Reprobar una prueba

Durante el desarrollo y las pruebas, debe haber escenarios de falla. Hacer esto muestra que cada programa tiene vulnerabilidades y errores.

En el mismo archivo, test.py , modifiquemos el código y peguemos lo siguiente:

 # test.py import unittest from main import add_sum class MainTest(unittest.TestCase): # other test def test_do_stuff2(self): result = add_sum("hulu", 5) self.assertEqual(result, 5) if __name__ == '__main__': unittest.main()

El resultado de ejecutar este código se parece a esto:

 FAIL: test_do_stuff2 (__main__.MainTest) ---------------------------------------------------------------------- Traceback (most recent call last): File "test.py", line 11, in test_do_stuff3 self.assertEqual(result, 5) AssertionError: ValueError("invalid literal for int() with base 10: 'hulu'") != 5

A partir del resultado anterior, lo siguiente se puede resolver leyendo el código de error y corrigiendo el código en consecuencia:

• El error ocurrió en un número de línea específico, diciéndole que verifique y resuelva el número de línea.
• El siguiente es el error de aserción, que da un error de valor que significa que la cadena 'hulu' no es un literal válido, sabiendo que en el archivo main.py, los dos valores son del tipo int
• Con este paso, sabe qué corregir para que el código ejecute la prueba correctamente con los valores correctos para pasar para que el código sea exitoso.

Ejecutar el código

Cuando tiene muchos archivos y módulos diferentes creados, y necesita probarlos todos simultáneamente en lugar de probar un solo archivo por defecto, puede usar este comando para ejecutar todas las pruebas simultáneamente.

 python3 -m unittest

Además, para obtener más detalles sobre la prueba, use el comando con el indicador -v (detallado), que le muestra las pruebas que están bien y las que fallaron.

 python3 -m unittest -v

El resultado se parece a esto:

 test_do_stuff (test.MainTest) ... ok test_do_stuff2 (test.MainTest) ... ok ---------------------------------------------------------------------- Ran 2 tests in 0.000s OK

Conclusión

Las pruebas unitarias deben ser una práctica realizada por los QA y los desarrolladores involucrados en la escritura y el envío del código cada vez que se lanza una nueva función antes de que los usuarios puedan usar la aplicación. Hacer pruebas con regularidad o periódicamente no debe ser una ocurrencia tardía, sino generar confianza en la funcionalidad y eficiencia de la aplicación.

Este artículo le dio una descripción general de por qué las pruebas son esenciales en el desarrollo y cómo usar las pruebas unitarias para verificar la función del código y cumplir con una especificación estándar para los usuarios antes de la implementación en producción.

Aprende más

• Documentación de pruebas unitarias