Pruebas de caja negra

Clase 25 de 31 • Curso de Introducción al Pensamiento Computacional con Python

Resumen

En el camino hacia la maestría en la generación de programas y la implementación de algoritmos en código, un escollo ineludible son los errores o "bugs". Enfrentarlos es parte integral del proceso de desarrollo de software y, lejos de ser motivo de preocupación, ofrecen una oportunidad valiosa para mejorar y fortalecer nuestras habilidades. El arte de depuración y la construcción de pruebas de software constituyen un pilar esencial en esta tarea. Este artículo profundizará en el cómo de esta práctica, ofreciéndote técnicas efectivas para detectar y corregir bugs, así como para implementar pruebas que garanticen el funcionamiento esperado de tu código.

¿Qué son las pruebas de caja negra?

Las pruebas de caja negra constituyen una técnica de testing en la que el funcionamiento de una función o programa se verifica exclusivamente a través de sus salidas basadas en entradas específicas, sin considerar la implementación interna. A continuación, exploraremos más sobre este método y por qué es crucial en el desarrollo de software.

¿Por qué son importantes las pruebas unitarias y de integración?

Las pruebas unitarias y de integración son dos sub-disciplinas críticas dentro del testing para garantizar la calidad del software:

Las pruebas unitarias se centran en validar que cada componente o función del código funcione de manera aislada correctamente.
Las pruebas de integración aseguran que, al combinar diferentes módulos, el sistema completo opera sin fallos.

Ambas pruebas son análogas a asegurar primero que cada LED de una serie enciende correctamente (pruebas unitarias) y luego que el árbol de Navidad en su totalidad ilumina como se espera (pruebas de integración).

¿Cómo se generan pruebas unitarias en Python?

La generación de pruebas unitarias en Python puede llevarse a cabo con el módulo unittest. A continuación, ilustramos los pasos clave para implementarlas de un modo sencillo y práctico:

Se comienza por importar el módulo unittest y declarar una clase de pruebas, heredada de unittest.TestCase.
Se adopta un enfoque de desarrollo guiado por pruebas o TDD (Test-Driven Development), escribiendo primero las pruebas y luego el código que satisfará dichas pruebas.
Se definen diferentes métodos de prueba dentro de la clase para escenarios específicos, como sumar dos números negativos o positivos.
Cada prueba verificará si la salida obtenida corresponde a la salida esperada para las entradas dadas.

¿Qué beneficios ofrece la técnica de Test Driven Development?

El Test Driven Development ofrece una serie de ventajas fundamentales en el proceso de desarrollo:

Ayuda a definir claramente los requisitos antes de comenzar a escribir el código.
Facilita la detección temprana de errores, permitiendo correcciones antes de que el código avance.
Garantiza que el código cumple con las expectativas antes de ser integrado, evitando sorpresas en etapas posteriores.

¿Qué se debe hacer si surge un error durante las pruebas?

Cuando surge un error durante las pruebas, es un indicador de que algo no está funcionando como se esperaba. Los pasos a seguir deberían ser:

Analizar el mensaje de error para identificar la causa raíz del problema.
Corregir la implementación del código para resolver el error específico.
Re-ejecutar las pruebas hasta que todas se completen con éxito, garantizando así que el cambio haya solucionado el problema sin introducir nuevos errores.

En resumen, las pruebas de caja negra, junto con las unitarias y de integración, son esenciales para un desarrollo de software robusto y confiable. Al adoptar prácticas como TDD y el uso diligente del módulo unittest en Python, la depuración y validación de programas se convierten en un proceso más sistemático y controlado. Si en algún momento te encuentras en un punto muerto o surgen dudas en tu código, no dudes en buscar apoyo en la comunidad de desarrollo; compartir problemas y soluciones fomenta el aprendizaje y la mejora constante. Recuerda, el camino hacia la excelencia en programación está pavimentado con práctica continua y aprendizaje colaborativo. ¡Continúa aprendiendo y mejorando tus habilidades de depuración y prueba de software!

René Sanchez

student•

❤

import unittest

def suma(num1, num2):
    # Si hacemos un cambio en el return donde queremos obtener el numero absoluto abs(num1) esto provocara un error en el test para sumar negativos, al hacer un cambio y tener casos de prueba para validar el funcionamiento correcto esto provoca que lo solucionemos inmediatamente conjunto a prever el desconocimiento de donde ocurre o ocurra este error
    return num1 + num2
# Esta creacion del objeto crea automaticamente los testeo dentro del modulo de python
class CajaNegraTest(unittest.TestCase):
    # Las pruebas desde funciones
    def test_suma_dos_positivos(self):
        num_1 = 10
        num_2 = 5

        resultado = suma(num_1, num_2)

        # Esto funciona asi:
        # (valor, valorQuerido) = valor == valorQuerido (Nos devuelve un true o false)
        self.assertEqual(resultado, 15)
        # Esto funciona asi:
        #  (valor, valorQuerido) = valor &gt; valorQuerido (Nos devuelve un true o false)
        self.assertGreater(resultado, 14)
        # Esto funciona asi:
        #  (valor, valorQuerido) = valor &gt;= valorQuerido (Nos devuelve un true o false)
        self.assertGreaterEqual(resultado, 15)
        # Esto funciona asi:
        #  (valor, valorQuerido) = valor &lt; valorQuerido (Nos devuelve un true o false)
        self.assertLess(resultado, 16)
        # Esto funciona asi:
        #  (valor, valorQuerido) = valor &lt;= valorQuerido (Nos devuelve un true o false)
        self.assertLessEqual(resultado, 15)
    
    def test_suma_dos_negativos(self):
        num_1 = -10
        num_2 = -7

        resultado = suma(num_1, num_2)

        self.assertEqual(resultado, -17)
    

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

Felipe Cortés

student•

Excelente para complementar

Javier Roma Corrales

student•

Gracias a ti y a compañeros como tu que aclaran ciertas cosas.

Karl Behrens Gil

student•

Pruebas de caja negra

Las pruebas de caja negra se basan en la especificación de la función o el programa, aquí debemos probas sus inputs y validar los outputs. Se llama caja negra por que no necesitamos saber necesariamente los procesos internos del programa, solo contrastar sus resultados.

Estos tipos de pruebas son muy importantes para 2 tipos de test:

Unit testing: se realizan pruebas a cada uno de los módulos para determinar su correcto funcionamiento.
Integration testing: es cuando vemos que todos los módulos funcionan entre sí.

Es una buena práctica realizar los test antes de crear tus lineas de código, esto es por que cualquier cambio que se realice a futuro los test estaran incorporados para determinar si los cambios cumplen lo esperado.

En Python existe la posibilidad de realizar test gracias a la libreria unittest. Puede ser que el siguiente código no lo entiendas en su totalidad, pero en una próxima guía detallare mas el tema de clases en programación. Por ahora te mostrare como se realizan estos test.

"""Importamos la libreria de unittest."""
import unittest

"""Creamos una clase para los test, en este caso se llamara
CajaNegraTest, y como parámetro."""
class CajaNegraTest(unittest.TestCase):

    """Definimos la funcion que generara el test."""
    def test_suma_dos_positivos(self):

        "Para nuestro ejemplo usaremos 2 parametros."""
        num_1 = 10
        num_2 = 5

        """Y dentro de la variable resultado
        guardaremos lo que nos retornara la función suma."""
        resultado = suma(num_1, num_2)

        """Y para terminar definimos la variable resultado
        y cual es el valor esperado."""
        self.assertEqual(resultado, 15)


"""Para definir el módulo de Python escribimos lo siguiente."""
if __name__ == '__main__':
    unittest.main()

Luego de escribir nuestro archivo iremos a la consola y ejecutaremos el test

python3 caja_negra.py

E   # Obtenemos un error en nuestro test
======================================================================
ERROR: test_suma_dos_positivos (__main__.CajaNegraTest) # Veremos aqui el test con error
----------------------------------------------------------------------
Traceback (most recent call last):
  File "caja_negra.py", line 9, in test_suma_dos_positivos
    resultado = suma(num_1, num_2)
NameError: name 'suma' is not defined   # La función suma no esta definida

----------------------------------------------------------------------
Ran 1 test in 0.000s

FAILED (errors=1)

Como vimos en el recuadro anterior no definimos la función suma, para ello vamos a crearla.

import unittest

def suma(num_1, num_2):
    return num_1 + num_2

class CajaNegraTest(unittest.TestCase):

    def test_suma_dos_positivos(self):
        num_1 = 10
        num_2 = 5

        resultado = suma(num_1, num_2)

        self.assertEqual(resultado, 15)

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

Ahora ejecutaremos denuevo nuestro test en la terminal.

python3 caja_negra.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK

David Vergara

student•

Gracias por los apuntes

Jaime Jesús González Muñoz

student•

Gracias por los apuntes

Diego Gabriel Barrionuevo

student•

cuando nosotros estamos "fumando dos numeros" 04:05 min

José María Rodríguez García

teacher•

Jajajajajja le pause y me empece a reir.....

Sebastian Cifuentes

student•

Jajajaja lo devolví para saber si yo había escuchado mal.

Misael Yered Ruiz Zamora

student•

NOTA: El nombre de los métodos debe empezar con TEST para que sean reconocidos (como en test_suma_dos_positivos) de lo contrario unittest no va a reconocer nada. A mi no me funcionaba nada y me dí cuenta que había escrito TEXT en vez de TEST.

Aaron Joel Limachi Quispe

student•

No encontraba mi error, gracias por tu aporte

Juan David Cepeda López

student•

Nunca pense en eso, lei este comentario, probe cambiando la palabra test de las funciones, y al ejecutarlo quede como :O :O Increíble, sin la palabra test, no funciona.

Fredy Alberto Orozco Loaiza

student•

Sinceramente si me voy a dedicar al mundo digital

Axel Yaguana

Team Platzi•

x2 Pasaré de ingeniería civil a data science.

Alejandro Picado Brenes

student•

Adelante, muchos éxitos

Daniel Guarín García

student•

La verdad se entiende muy poco el tema de class, import, self. Sin embargo, el contexto de caja negra se logra entender, espero que mas adelante se profundice en esos temas. Como recomendación, podrían colocar una especie de "favoritos", para que uno pueda tener un marcador de vídeos que considera importante y pueda ingresar fácilmente a estos.

Miguel Angel Reyes Moreno

student•

El tema de class y self lo verás en programación orientada a objetos. Import es como decirle a python: Oye, voy a necesitar esa herramienta para este programa, úsala por favor

Oliver Piña

student•

Con import, primero hay que recordar que es un modulo. Los modulos son divisiones de programas "largos", permiten una organizacion y division logica del codigo. Ahora, para poder utilizar ese programa se utiliza la palabra clave "import" seguido del nombre del modulo. ejemp: Import time

Manuel Alejandro Hermoso

student•

Si todavía te estás preguntando porque se usa

<self>

y no quieres esperar para entenderlo tienes que mirar este vídeo:

https://youtu.be/ic6wdPxcHc0

Jorge Luis Tancara Nina

student•

In english

Miguel Angel Reyes Moreno

student•

Es un apuntador para la variable en la que mandemos a llamar un método definido en la clase.

Leonardo Matías Windey

student•

Observación: Si la función a la que le realizaremos la prueba, no comienza con la palabra test no contará como tal, por ende, no figurará en consola al ejecutar nuestro programa. Por ej:

class CajaNegraTest (unittest.TestCase):

	def test_suma (self):
		...
	def test_operacion_mat (self):
		...
	def test_nombre (self):
		...

Espero esta observación les sea de utilidad.

Cristhian Julian Astoquilca Romero

student•

Tienes razón :0 . Gracias por el aporte. Ahora queda averiguar el por qué :) .

Leonardo Matías Windey

student•

Porque es una palabra reservada del lenguaje, está dentro de su biblioteca.

Juan Rodriguez

student•

Lo tendré en cuenta para cuando me haya casado y me vaya de luna de miel no vaya a joder mi lindo codigo de hoy.

Esteban Ramírez García

student•

Aqui dejo una tabla extraída de la documentación de python donde se explica esencialmente que evalúan los métodos de este framework de unit testing

Andrés Felipe Díaz Rodríguez

student•

hola quiero aclarar que hice el programa y note que si no llamamos los métodos con test al inicio la clase no los incluye en el test.

Josué Alfredo Tomas Machaca Fajardo

student•

Tengo que revisar este contenido en el futuro.

Miguel Torres

student•

He visto la verdad! Ahora soy NEO en la matrix

Muchas cosas de este curso son así. :O

José Vásquez

student•

Para las funciones que no retornan un valor, como se realizan las pruebas?

Josue Noha Valdivia

student•

ummh interesante dejare mi comentario aqui y esperare las respuestas xD... Lo unico que se me ocurre es testearlas manualmente en puntos criticos (donde pueda que se genere un error)

José Vásquez

student•

Yo creo que se hacen las pruebas de cristal, ya que al principio dice que las pruebas cajas negras son para validar inputs y outputs. Pero lo que me llena un poco de dudas es que por ejemplo, una forma de programación defensiva es validar que los output tengan el tipo correcto y si no se levanta un excepción.

Luis Ruiz Ramos

student•

Entendí muy poco de lo que tiene el código pero la explicación está perfecta.

Jose Antonio Rojas Ollarves

student•

self:

Es un parametro de referencia a la instancia actual, de la clase y se usa para acceder a las variables que pertenecern a la clase. "self" Es simplemente un estandar puedes llamarlo como gustes, pero tiene que ser el primer parametro en cualquier funcion de la clase, ejemplo:


class Person:
  def __init__(self, name, age):
    self.name = name
    self.age = age


  def myfunc(abc):
    print("Hello my name is " + abc.name)

p1 = Person("Jose", 20)
p1.myfunc()
-----------

Puedes cambiarle el nombre a self, como por ejemplo objeto y dara el mismo resultado, pero es un standar que se utiliza para hacer el codigo mas limpio y legible

Marcos Monteverde

student•

Gracias!!

Melido Enrique Bello Navarro

student•

Las pruebas de caja negra son una chuleria

Aprendizaje del video

#Caja negra

#¿Qué es la prueba de caja negra?
#Es la forma para que un module funcione solo y en conjunto con otros modulos.

#¿Qué se necesita para usar la prueba de caja negra? importar el unittest module y poner una clase con unittest.TestCase como parametro.
#Definir la función que queremos probar. Y usar self.assertEqual(El valor de la funcion, El valor que queremos obtener).
#Ya luego poner unittest.main() en un if __name__=='__main__' para inicializarlo.

#Ejemplo:

import unittest


def suma(num_1, num_2):
    return num_1 + num_2


class CajaNegraTest(unittest.TestCase):
    def test_suma_dos_positivos(self):
        num_1 = 10
        num_2 = 5
        
        resultado = suma(num_1, num_2)
        self.assertEqual(resultado, 15)
    
    def test_suma_dos_negativos(self):
        num_1 = -10
        num_2 = -5
        
        resultado = suma(num_1, num_2)
        self.assertEqual(resultado, -15)
        
if __name__=='__main__':
    unittest.main()

Ejercicio personal:

#Ejercicio Personal: Repetir el proceso de caja negra con modulus, una operación algo confusa para mi. Todo con el objetivo de obtener los valores primos de una lista y sumarlos.

import unittest



def lista(inicio, final):
    my_list = list(range(inicio, final+1)) #Esta es la forma usada anteriormente de crear una lista con 100 numeros.
    return my_list

    
def filtrar_enteros():
    enteros = [i for i in lista(int(input('El numero en el que empezará su lista: ')), int(input('El numero en que acabará su lista: '))) if i % 2 == 0]
    return enteros


def sumar_lista():
    empezar = 0
    for i in filtrar_enteros():
        empezar += i    
    return empezar


class CajaNegraTest(unittest.TestCase):
    
    def test_filtrar_valores_primos_de_una_lista(self):
        resultado = sumar_lista()
        print(resultado)
        self.assertEqual(resultado, resultado)

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

Andres Troaños

student•

Entonces, estos test son lo primero que se hace? y si todo sale bien, lo boro y continuo con mi código o en que momento puedo borrar esto ?

Sebastian Cifuentes

student•

Por lo que entiendó estas pruebas siempre deberían estar pero solamente en desarrollo, en producción no deberían de salir.

María Fernanda Magallanes Z

student•

Deberías tener los tests aparte. Generalmente estos test de caja negra los haces cuando programas con TDD, googlea sobre TDD, es súper interesante. Pero la idea no es borrar los test sino más bien tenerlos ahí por si después vas a actualizar algo pero no quieres dañar funcionalidades que ya sabes que funcionan y necesitas.

Royer Guerrero Pinilla

student•

Probablemente ya sepas que son los bugs (Errores) pero si quieres saber porque se le dice así bug y no error en este articulo lo explican Artículo sobre bug Bug literalmente traducido al español es Insecto 🐞

Alejandro Picado Brenes

student•

Muy interesante

Sebastián Andrade

student•

Una pregunta a ver si entendí ¿debemos primero escribir la funcion "mal" aposta para ver los posibles errores que peude traer y poco a poco ir escribirendola "bien"?¿o fue solo el profesor para enseñarnos como muestra los errores el modulo?

Aaron Joel Limachi Quispe

student•

No entiendo que es "aposta" pero imagino que es similar a decir "a propósito". En ese sentido el profesor no se refería a hacer mal la función sino a ir mejorando de a poco hasta obtener los resultados esperados. En los ejemplos simples parece absurdo pero en proyectos más grandes cobra mayor sentido.

Sebastián Andrade

student•

Ah, ya entendi, gracias. Y si entendiste bien "aposta" significa a proposito xdd

import unittest

def suma(num1, num2):
    # Si hacemos un cambio en el return donde queremos obtener el numero absoluto abs(num1) esto provocara un error en el test para sumar negativos, al hacer un cambio y tener casos de prueba para validar el funcionamiento correcto esto provoca que lo solucionemos inmediatamente conjunto a prever el desconocimiento de donde ocurre o ocurra este error
    return num1 + num2
# Esta creacion del objeto crea automaticamente los testeo dentro del modulo de python
class CajaNegraTest(unittest.TestCase):
    # Las pruebas desde funciones
    def test_suma_dos_positivos(self):
        num_1 = 10
        num_2 = 5

        resultado = suma(num_1, num_2)

        # Esto funciona asi:
        # (valor, valorQuerido) = valor == valorQuerido (Nos devuelve un true o false)
        self.assertEqual(resultado, 15)
        # Esto funciona asi:
        #  (valor, valorQuerido) = valor &gt; valorQuerido (Nos devuelve un true o false)
        self.assertGreater(resultado, 14)
        # Esto funciona asi:
        #  (valor, valorQuerido) = valor &gt;= valorQuerido (Nos devuelve un true o false)
        self.assertGreaterEqual(resultado, 15)
        # Esto funciona asi:
        #  (valor, valorQuerido) = valor &lt; valorQuerido (Nos devuelve un true o false)
        self.assertLess(resultado, 16)
        # Esto funciona asi:
        #  (valor, valorQuerido) = valor &lt;= valorQuerido (Nos devuelve un true o false)
        self.assertLessEqual(resultado, 15)
    
    def test_suma_dos_negativos(self):
        num_1 = -10
        num_2 = -7

        resultado = suma(num_1, num_2)

        self.assertEqual(resultado, -17)
    

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

"""Importamos la libreria de unittest."""
import unittest

"""Creamos una clase para los test, en este caso se llamara
CajaNegraTest, y como parámetro."""
class CajaNegraTest(unittest.TestCase):

    """Definimos la funcion que generara el test."""
    def test_suma_dos_positivos(self):

        "Para nuestro ejemplo usaremos 2 parametros."""
        num_1 = 10
        num_2 = 5

        """Y dentro de la variable resultado
        guardaremos lo que nos retornara la función suma."""
        resultado = suma(num_1, num_2)

        """Y para terminar definimos la variable resultado
        y cual es el valor esperado."""
        self.assertEqual(resultado, 15)


"""Para definir el módulo de Python escribimos lo siguiente."""
if __name__ == '__main__':
    unittest.main()

python3 caja_negra.py

E   # Obtenemos un error en nuestro test
======================================================================
ERROR: test_suma_dos_positivos (__main__.CajaNegraTest) # Veremos aqui el test con error
----------------------------------------------------------------------
Traceback (most recent call last):
  File "caja_negra.py", line 9, in test_suma_dos_positivos
    resultado = suma(num_1, num_2)
NameError: name 'suma' is not defined   # La función suma no esta definida

----------------------------------------------------------------------
Ran 1 test in 0.000s

FAILED (errors=1)

import unittest

def suma(num_1, num_2):
    return num_1 + num_2

class CajaNegraTest(unittest.TestCase):

    def test_suma_dos_positivos(self):
        num_1 = 10
        num_2 = 5

        resultado = suma(num_1, num_2)

        self.assertEqual(resultado, 15)

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

#Caja negra

#¿Qué es la prueba de caja negra?
#Es la forma para que un module funcione solo y en conjunto con otros modulos.

#¿Qué se necesita para usar la prueba de caja negra? importar el unittest module y poner una clase con unittest.TestCase como parametro.
#Definir la función que queremos probar. Y usar self.assertEqual(El valor de la funcion, El valor que queremos obtener).
#Ya luego poner unittest.main() en un if __name__=='__main__' para inicializarlo.

#Ejemplo:

import unittest


def suma(num_1, num_2):
    return num_1 + num_2


class CajaNegraTest(unittest.TestCase):
    def test_suma_dos_positivos(self):
        num_1 = 10
        num_2 = 5
        
        resultado = suma(num_1, num_2)
        self.assertEqual(resultado, 15)
    
    def test_suma_dos_negativos(self):
        num_1 = -10
        num_2 = -5
        
        resultado = suma(num_1, num_2)
        self.assertEqual(resultado, -15)
        
if __name__=='__main__':
    unittest.main()

#Ejercicio Personal: Repetir el proceso de caja negra con modulus, una operación algo confusa para mi. Todo con el objetivo de obtener los valores primos de una lista y sumarlos.

import unittest



def lista(inicio, final):
    my_list = list(range(inicio, final+1)) #Esta es la forma usada anteriormente de crear una lista con 100 numeros.
    return my_list

    
def filtrar_enteros():
    enteros = [i for i in lista(int(input('El numero en el que empezará su lista: ')), int(input('El numero en que acabará su lista: '))) if i % 2 == 0]
    return enteros


def sumar_lista():
    empezar = 0
    for i in filtrar_enteros():
        empezar += i    
    return empezar


class CajaNegraTest(unittest.TestCase):
    
    def test_filtrar_valores_primos_de_una_lista(self):
        resultado = sumar_lista()
        print(resultado)
        self.assertEqual(resultado, resultado)

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

Pruebas de caja negra

Introducción al pensamiento computacional

Introducción al pensamiento computacional

Introducción al cómputo

Introducción a los lenguajes de programación

Introducción a Python

Preparación de tu computadora

Elementos básicos de Python

Asignación de variables

Cadenas y entradas

Programas ramificados

Iteraciones

Bucles for

Programas numéricos

Representación de flotantes

Enumeración exhaustiva

Aproximación de soluciones

Búsqueda Binaria

Funciones, alcance y abstracción

Funciones y abstracción

Scope o Alcance

Especificaciones del código

Recursividad

Fibonnacci y la Recursividad

Tipos estructurados, mutabilidad y funciones de alto nivel

Funciones como objetos

Tuplas

Rangos

Listas y mutabilidad

Diccionarios

Pruebas y debugging

Pruebas de caja negra

Pruebas de caja de cristal

Debugging

Excepciones y afirmaciones

Manejo de excepciones

Excepciones y control de flujo

Afirmaciones

Conclusiones