Ningún buen desarrollador despliega código sin realizar pruebas exhaustivas. Las pruebas unitarias son el proceso de probar los módulos individuales de un gran programa.

Este artículo tratará sobre cómo puede realizar pruebas unitarias de su código utilizando el módulo unittest de Python. En primer lugar, entendamos cuáles son los tipos de pruebas.

Cuando se trata de pruebas, existen las pruebas manuales y las pruebas automáticas. La prueba manual es una técnica de prueba en la que los humanos realizan la prueba manualmente una vez finalizado el desarrollo. La prueba automática es una técnica de prueba en la que los programas realizan la prueba automáticamente y nos dan los resultados.

Habrá comprendido que las pruebas manuales llevan mucho tiempo y son difíciles de realizar. Así que los desarrolladores escriben código para realizar las pruebas (pruebas automáticas). Existen diferentes tipos de pruebas en las pruebas automáticas. Algunas de ellas son Pruebas unitarias, Pruebas de integración, Pruebas de extremo a extremo, Pruebas de estrés, etc,

Veamos el flujo estándar de las pruebas.

  • Escribir o Actualizar el código.
  • Escriba o Actualice las pruebas para los diferentes casos de su código.
  • Ejecute las pruebas (manualmente o utilizando un ejecutor de pruebas).
  • Vea los resultados de las pruebas. Si hay algún error, corríjalo y repita los pasos.

Aquí, vamos a discutir el tipo de pruebas más esencial y básico llamado pruebas unitarias. Sin más preámbulos, vamos a sumergirnos en el tutorial propiamente dicho.

¿Qué son las pruebas unitarias?

Las pruebas unitarias son una técnica para probar un pequeño bloque de código independiente. El pequeño bloque de código será una función en la mayoría de los casos. La palabra independiente significa que no depende de otras piezas de código del proyecto.

Supongamos que tenemos que comprobar si una cadena es igual a «Geekflare » o no. Para ello, hemos escrito una función que toma un argumento y devuelve si es igual a » Geekflare » o no.

def es_igual_a_geekflare(cadena):
	return cadena == "Geekflare"

La función anterior no depende de ningún otro código. Por lo tanto, podemos probarla de forma independiente dando diferentes entradas. La pieza de código independiente se puede utilizar en todo el proyecto.

Importancia de las pruebas unitarias

En general, el código de bloques independientes puede utilizarse en todo el proyecto. Por lo tanto, debe estar bien escrito y probado. Las pruebas unitarias son las que se utilizan para probar ese tipo de bloques independientes de código. ¿Qué ocurre si no utilizamos pruebas unitarias en nuestro proyecto?

Supongamos que no probamos pequeños bloques de código que se utilizan en todo el proyecto. Todas las demás pruebas, como las de integración, las de extremo a extremo, etc., que utilizan los otros pequeños bloques de código pueden fallar. Esto rompe la aplicación. Por eso hay que probar bien los bloques básicos del código.

Ahora, conocemos la importancia de las pruebas unitarias y hemos escrito pruebas unitarias para todos los bloques de código independientes. Puesto que hemos realizado pruebas unitarias, otras pruebas como las de integración, las de extremo a extremo, etc., no fallarán por culpa de los bloques de código independientes.

En las próximas secciones, veremos qué es el módulo unittest de Python y cómo utilizamos el módulo unittest para escribir pruebas unitarias en Python.

Nota: Suponemos que está familiarizado con las clases, módulos, etc. de Python. Si no está familiarizado con los conceptos intermedios de Python como clases, módulos, etc., puede que le resulte difícil entender las próximas secciones.

¿Qué es unittest en Python?

Python unittest es un marco de pruebas integrado para probar código Python. Tiene un ejecutor de pruebas, que nos permite ejecutar las pruebas sin mucho esfuerzo. Por lo tanto, podemos utilizar el módulo incorporado unittest para las pruebas sin utilizar los módulos de terceros. Pero, cambia en función de sus necesidades. El módulo unittest incorporado es bueno para iniciarse en las pruebas en Python.

Tenemos que seguir los siguientes pasos para probar el código Python utilizando el módulo unittest.

#1. Escriba el código.

#2. Importe el módulo unittest.

#3. Cree un archivo que comience con la palabra clave test. Por ejemplo test_prime.py. La palabra clave test se utiliza para identificar los archivos de prueba.

#4. Cree una clase que extienda la clase unittest.TestCase.

#5. Escriba métodos (pruebas) dentro de la clase. Cada método contiene diferentes casos de prueba basados en su requerimiento. Debemos nombrar el método comenzando con la palabra clave test.

#6. Ejecute las pruebas. Podemos ejecutar las pruebas de diferentes maneras.

  • Ejecutamos el comando python -m unittest nombre_del_archivo.py.
  • Ejecutamos los archivos de prueba como archivos generales de Python con el comando python nombre_del_archivo.py. Para que este método funcione, necesitamos invocar el método principal del unittest en el archivo de prueba.
  • Y por último, utilizando el discover. Podemos autoejecutar las pruebas utilizando el comando python -m unittest discover sin mencionar el nombre de archivo de la prueba. Encontrará las pruebas utilizando la convención de nomenclatura que hayamos seguido. Por lo tanto, debemos nombrar nuestros archivos de prueba con la palabra clave test en el inicio.

Generalmente, en las pruebas, comparamos la salida del código con la salida esperada. Así que, para comparar las salidas unittest proporciona diferentes métodos. Puede encontrar la lista de funciones de comparación aquí.

Puede entenderlas fácilmente sin ninguna dificultad. Son sencillas.

Eso es mucha teoría. Ahora debemos entrar en la codificación.

Nota: Si tiene alguna duda sobre el módulo unittest, puede acudir a la documentación y aclarar sus dudas. Sin más dilación, vamos a utilizar el módulo unittest.

Pruebas unitarias en Python utilizando unittest

Primero escribiremos algunas funciones y después nos centraremos en escribir las pruebas. En primer lugar, abra una carpeta en su editor de código favorito. Y cree un archivo llamado utils.py. Pegue el siguiente código en el archivo.

importar math


def es_primo(n):
    if n < 0
        return 'Los números negativos no están permitidos'

    si n <= 1
        return False

    si n == 2
        return True

    si n % 2 == 0
        return False

    for i in range(2, int(math.sqrt(n)) 1):
        si n % i == 0
            return False
    devolver True


def cúbico(a):
    return a * a * a


def decir_hola(nombre):
    return "Hola, " nombre

Tenemos tres funciones diferentes en el archivo utils.py. Ahora, tenemos que probar cada función con diferentes casos de prueba. Escribamos las pruebas para la primera función es_primo.

#1. Cree un archivo llamado test_utils.py en la carpeta de ejemplo como utils.py.

#2. Importe el módulo utils y unittest.

#3. Cree una clase con el nombre TestUtils que extienda la clase unittest.TestCase. El nombre de la clase puede ser cualquier cosa. Trate de dar a la clase un nombre significativo.

#4. Dentro de la clase, escriba un método llamado test_is_prime que acepte self como argumento.

#5. Escriba diferentes casos de prueba con argumentos para is_prime y compare la salida con la salida esperada.

#6. Ejemplo de caso de prueba self.assertFalse(utils.is_prime(1)).

#7. Esperamos que la salida de is_prime( 1) sea falsa en el caso anterior.

#8. Similar al caso anterior, haremos diferentes pruebas de casos basados en la función que estamos probando.

Veamos las pruebas.

importar unittest

import utils


class TestUtils(unittest.TestCase):
    def prueba_es_primo(self):
        self.assertFalse(utils.is_prime(4))
        self.assertTrue(utils.es_primo(2))
        self.assertTrue(utils.es_primo(3))
        self.assertFalse(utilidades.es_primo(8))
        auto.assertFalse(utilidades.es_primo(10))
        self.assertTrue(utilidades.es_primo(7))
        self.assertEqual(utils.es_primo(-3),
                         "Los números negativos no están permitidos")


if __name__ == '__main__':
    unittest.main()

Estamos invocando el método main de unittest el módulo para ejecutar las pruebas utilizando python filename.py el comando. Ahora, ejecute las pruebas.

Usted verá la salida similar a la salida de abajo.

$ python prueba_utils.py 
.
----------------------------------------------------------------------
Ejecutó 1 prueba en 0,001s

OK

Ahora, intente escribir también los casos de prueba para otras funciones. Piense en diferentes casos para las funciones y escriba pruebas para ellos. Eche un vistazo a las siguientes pruebas que se añaden a la clase anterior.

...


clase TestUtils(unittest.TestCase):
    def prueba_es_primo(self):
        ...

    def prueba_cubica(self):
        self.assertEqual(utils.cubic(2), 8)
        self.assertEqual(utils.cubic(-2), -8)
        self.assertNotEqual(utils.cubic(2), 4)
        auto.assertNotEqual(utils.cubic(-3), 27)

    def prueba_saludar(self):
        self.assertEqual(utils.say_hello("Geekflare"), "Hola, Geekflare")
        self.assertEqual(utils.say_hello("Chandan"), "Hola, Chandan")
        self.assertNotEqual(utils.say_hello("Chandan"), "Hola, Chandan")
        self.assertNotEqual(utils.say_hello("Hafeez"), "Hola, Hafeez")


...

Hemos utilizado sólo algunas de las funciones de comparación del módulo unittest. Puede encontrar la lista completa aquí.

Hemos aprendido a escribir pruebas unitarias utilizando el módulo unittest. Ahora, es el momento de ver diferentes formas de ejecutar las pruebas.

Cómo ejecutar pruebas utilizando unittest

Ya hemos visto una forma de ejecutar los casos de prueba en la sección anterior. Veamos las otras dos formas de ejecutar las pruebas utilizando el módulo unittest.

#1. Utilizando el nombre del archivo y el módulo unittest.

En este método, utilizaremos el módulo unittest y el nombre del archivo para ejecutar las pruebas. El comando para ejecutar las pruebas es python -m unittest nombrearchivo .py. En nuestro caso, el comando para ejecutar las pruebas es python -m unittest test_utils.py.

#2. Utilizar el método discover

Utilizaremos el método discover del módulo unittest para autodetectar todos los archivos de prueba y ejecutarlos. Para autodetectar los archivos de prueba, necesitamos nombrarlos comenzando con la palabra clave test.

La orden para ejecutar las pruebas utilizando el método discover es python -m unittest discover. El comando detectará todos los archivos cuyos nombres empiecen por test y los ejecutará.

Conclusión 👩‍💻

Las pruebas unitarias son pruebas básicas en el mundo de la programación. Hay muchas otras pruebas en el mundo real. Intente aprenderlas una a una. Espero que este tutorial le ayude a escribir pruebas básicas en Python utilizando el módulo unittest. Existen bibliotecas de terceros como pytest, Robot Framework, nose, nose2, slash, etc. Puede explorarlas en función de los requisitos de su proyecto.

Felices pruebas 😎

Puede que también le interese Preguntas y respuestas de entrevistas sobre Python.