Pruebas unitarias con GitHub Copilot

8. Pruebas unitarias con GitHub Copilot

Prompts

Testing de tu código en segundos

# DAME UN SCRIPT PARA HACER UNIT TEST A LA FUNCION GET_TWEETS
## genera un script para hacer unit test de la funcion calcular_media

import unittest
from unittest.mock import Mock, patch
import mi_modulo # Asegúrate de importar el módulo que contiene tus funciones

class TestMiModulo(unittest.TestCase):

@patch('mi_modulo.openai')
def test_return_productos(self, mock_openai):
    mock_response = {
        'choices': [{'message': {'content': '{"Descripcion": "Descripción de prueba", "compañia": "Empresa de prueba"}'}}]
    }
    mock_openai.ChatCompletion.create.return_value = Mock(**mock_response)

    result = mi_modulo.return_productos('prueba')

    self.assertEqual(result['Descripcion'], 'Descripción de prueba')
    self.assertEqual(result['compañia'], 'Empresa de prueba')

def test_split_json(self):
    sample_df = pd.DataFrame({'producto': ['silla'], 'descripciones': [{'Descripcion': 'Descripción', 'compañia': 'Empresa'}]})
    
    result_df = mi_modulo.split_json(sample_df)

    self.assertEqual(result_df['Descripcion'][0], 'Descripción')
    self.assertEqual(result_df['compañia'][0], 'Empresa')

if name == ‘main’:
unittest.main()

Realizar pruebas unitarias antes de enviar el código al equipo de pruebas es una práctica recomendable. Esto nos permite verificar si nuestro código funciona correctamente.

Las pruebas unitarias son esenciales para asegurar que tu código funciona correctamente. GitHub Copilot puede ayudarte a generar código para pruebas unitarias, lo que puede agilizar el proceso de escritura de pruebas y asegurar que tu aplicación sea robusta. A continuación te muestro cómo utilizar GitHub Copilot para escribir pruebas unitarias en Python, específicamente utilizando `unittest`, una de las bibliotecas estándar para pruebas unitarias en Python. \### Paso 1: Instalación de Herramientas Si aún no tienes GitHub Copilot, asegúrate de tenerlo configurado en tu entorno de desarrollo. Para las pruebas unitarias en Python, necesitas `unittest`, que ya está incluido en la biblioteca estándar de Python. Sin embargo, si usas bibliotecas adicionales para pruebas como `pytest`, puedes instalarlas con: ```bash pip install pytest ``` \### Paso 2: Crear el Archivo de Pruebas Normalmente, colocas las pruebas unitarias en un archivo separado. Supongamos que tienes una función en un archivo llamado `funciones.py` que deseas probar. Primero, crea un archivo de pruebas, por ejemplo, `test\_funciones.py`. \### Ejemplo de Código a Probar ```python \# funciones.py def suma(a, b): return a + b def resta(a, b): return a - b ``` \### Ejemplo de Pruebas Unitarias Aquí te muestro cómo escribir pruebas unitarias para el código anterior utilizando `unittest`. GitHub Copilot puede sugerir fragmentos de código mientras escribes, pero aquí tienes un ejemplo básico: ```python \# test\_funciones.py import unittest from funciones import suma, resta class TestFunciones(unittest.TestCase): def test\_suma(self): \# Prueba de la función suma resultado = suma(5, 3) self.assertEqual(resultado, 8) def test\_resta(self): \# Prueba de la función resta resultado = resta(5, 3) self.assertEqual(resultado, 2) def test\_suma\_negativos(self): \# Prueba de la función suma con números negativos resultado = suma(-5, -3) self.assertEqual(resultado, -8) def test\_resta\_negativos(self): \# Prueba de la función resta con números negativos resultado = resta(-5, -3) self.assertEqual(resultado, -2) if \_\_name\_\_ == '\_\_main\_\_': unittest.main() ``` \### Cómo Utilizar GitHub Copilot 1\. \*\*Escribe un Comentario Descriptivo\*\*: Puedes empezar escribiendo comentarios descriptivos sobre lo que quieres probar. Copilot generará código basado en estos comentarios. ```python \# test\_funciones.py import unittest from funciones import suma, resta class TestFunciones(unittest.TestCase): def test\_suma(self): \# Completar con sugerencias de Copilot ``` 2\. \*\*Completa con Sugerencias\*\*: A medida que escribes el código de prueba, GitHub Copilot te sugerirá implementaciones basadas en el patrón que estás siguiendo. Acepta o ajusta las sugerencias según sea necesario. Ejemplo de uso: ```python def test\_suma(self): resultado = suma(5, 3) self.assertEqual(resultado, 8) # Copilot puede sugerir este código ``` 3\. \*\*Revisa y Ajusta\*\*: Asegúrate de revisar el código generado por Copilot para verificar que cumpla con tus requisitos. Ajusta cualquier parte según sea necesario para que las pruebas sean precisas y relevantes. \### Ejecutar las Pruebas Para ejecutar las pruebas unitarias escritas con `unittest`, usa el siguiente comando: ```bash python -m unittest test\_funciones.py ``` Si estás usando `pytest`, puedes ejecutar las pruebas con: ```bash pytest test\_funciones.py ``` \### Ejemplo de Uso de `pytest` Si prefieres usar `pytest`, el código de prueba puede ser similar, pero a menudo es más flexible y proporciona informes más detallados. Aquí hay un ejemplo básico usando `pytest`: ```python \# test\_funciones.py import pytest from funciones import suma, resta def test\_suma(): assert suma(5, 3) == 8 def test\_resta(): assert resta(5, 3) == 2 def test\_suma\_negativos(): assert suma(-5, -3) == -8 def test\_resta\_negativos(): assert resta(-5, -3) == -2 ``` Y puedes ejecutar las pruebas con: ```bash pytest ``` \### Conclusión GitHub Copilot puede ser muy útil para acelerar el proceso de escritura de pruebas unitarias al proporcionar sugerencias basadas en el código que ya has escrito. Asegúrate de revisar y ajustar el código generado para que cumpla con los requisitos específicos de tu proyecto. Si necesitas ayuda con casos específicos o más ejemplos, ¡déjame saber!

Este fue el promt que coloque: *Necesito que actues como un especialista en Python y en desarrollo de software. Tengo este codigo para calcular la media de un conjunto de números:* *def calcular\_media(numeros):* *return sum(numeros) / len(numeros)* *Ahora lo que necesito es que genera un script para hacer unit test de la funcion calcular\_media* *¿Puedes hacerlo y al mismo tiempo explicar y documentar cada uno de los pasos del test unitario que vas a realizar?* A lo que me arrojo lo siguiente: **¡Claro! Vamos a crear un script de pruebas unitarias para la función** `calcular_media` **utilizando el módulo** `unittest` **de Python. Aquí tienes un ejemplo:** `import unittest` `def calcular_media(numeros):` ` return sum(numeros) / len(numeros)` `class TestCalcularMedia(unittest.TestCase):` ` def test_media_enteros_positivos(self):` ` resultado = calcular_media([1, 2, 3, 4, 5])` ` self.assertEqual(resultado, 3.0)` ` def test_media_enteros_negativos(self):` ` resultado = calcular_media([-1, -2, -3, -4, -5])` ` self.assertEqual(resultado, -3.0)` ` def test_media_floats(self):` ` resultado = calcular_media([0.5, 1.5, 2.5, 3.5, 4.5])` ` self.assertEqual(resultado, 2.5)` ` def test_media_lista_vacia(self):` ` with self.assertRaises(ZeroDivisionError):` ` calcular_media([])` `if __name__ == '__main__':` ` unittest.main()` Esta fue la respuesta final: **Ahora, explicaré cada paso:** 1. **Importar el módulo** `unittest`**: En la primera línea, importamos el módulo** `unittest` **para utilizar su funcionalidad de pruebas unitarias.** 2. **Definir la función a probar: La función** `calcular_media` **está definida como en tu ejemplo.** 3. **Crear una clase de pruebas (**`TestCalcularMedia`**): Creamos una clase que hereda de** `unittest.TestCase`**. Esta clase contendrá todos nuestros casos de prueba.** 4. **Definir casos de prueba: Cada método dentro de la clase que comienza con** `test_` **representa un caso de prueba. En cada caso, llamamos a** `calcular_media` **con un conjunto específico de datos y usamos los métodos de aserción proporcionados por** `unittest` **para verificar si el resultado es el esperado.** 5. **Manejar casos especiales: En el caso de una lista vacía, utilizamos** `assertRaises` **para asegurarnos de que se lance la excepción** `ZeroDivisionError`**.** 6. **Ejecutar las pruebas: Finalmente, utilizamos** `unittest.main()` **para ejecutar todas las pruebas cuando ejecutamos este script directamente.** **Espero que esto te sea útil. ¿Hay algo en particular que quieras que explique más detalladamente?**

Esto se compleenta bien con el Curso de Herramientas de Inteligencia Artificial para Developers

Entonces el prompt es Genera un script para hacer pruebas unitaria de la función.

Es importante tener en cuenta que al trabajar con IA, resulta altamente beneficioso ser detallado y específico en nuestras solicitudes.

Cuando utilicemos este tipo de tecnologías como apoyo, es esencial realizar revisiones para asegurarnos de que las acciones que están siendo realizadas tengan coherencia y sentido.

Para explorar las opciones alternativas proporcionadas por Copilot, simplemente debes ubicarte sobre el código generado y observar las diversas alternativas que esta herramienta te ofrece.

Las pruebas unitarias, también conocidas como "unit tests" en inglés, son un tipo de prueba en el desarrollo de software que se centra en evaluar individualmente las unidades más pequeñas de código de un programa. Una unidad de código generalmente se refiere a una función, método o procedimiento específico en un programa. El objetivo principal de las pruebas unitarias es verificar que cada unidad de código funcione correctamente de manera aislada, es decir, que produzca los resultados esperados cuando se le proporcionan entradas específicas. Aquí hay algunas características clave de las pruebas unitarias: 1. **Aislamiento:** Las pruebas unitarias se diseñan para probar una sola unidad de código a la vez, sin depender de otras partes del programa. Cualquier dependencia externa, como bases de datos o servicios web, se simula o se utilizan "dobles" (como mocks o stubs) para garantizar el aislamiento. 2. **Automatización:** Las pruebas unitarias se ejecutan automáticamente mediante herramientas de prueba específicas. Esto permite una rápida detección de errores y facilita la incorporación de pruebas en el proceso de desarrollo continuo. 3. **Rapidez:** Dado que las pruebas unitarias se enfocan en unidades de código pequeñas, generalmente son rápidas de ejecutar. Esto permite una retroalimentación rápida sobre la funcionalidad de las unidades individuales y facilita la detección temprana de problemas. 4. **Repetibilidad:** Las pruebas unitarias deben ser repetibles, lo que significa que deberían dar los mismos resultados cada vez que se ejecuten, siempre que las entradas sean las mismas. 5. **Facilitan la refactorización:** Las pruebas unitarias proporcionan un nivel de seguridad al realizar cambios en el código existente. Si todas las pruebas unitarias siguen pasando después de una refactorización, es más probable que el código siga funcionando correctamente. 6. **Documentación viva:** Las pruebas unitarias también sirven como documentación viva del comportamiento esperado de una unidad de código. Otros desarrolladores pueden revisar las pruebas para comprender cómo se supone que debe funcionar el código. En resumen, las pruebas unitarias son una práctica esencial en el desarrollo de software que ayuda a garantizar la calidad y la fiabilidad del código al verificar que las unidades de código individuales funcionen según lo previsto. Estas pruebas son una parte fundamental de la metodología de desarrollo de software conocida como Desarrollo Basado en Pruebas (Test-Driven Development, TDD) y son una práctica común en la ingeniería de software moderna.

Resultado del Unit Test por Bing con carita feliz incluida y este fue el error que encontro:
“La longitud de train debería ser el 80% del total, no el 70%. Por lo tanto, he cambiado `self.assertEqual(len(train).”

Aquí está el código de prueba unitaria para la función split_data:

import unittest

class TestSplitData(unittest.TestCase):
    def test_split_data(self):
        train, test = split_data(df, test_size=0.2, random_state=42)
        
        # Comprobamos que la longitud total es la misma
        self.assertEqual(len(df), len(train) + len(test))
        
        # Comprobamos que el tamaño del test es el esperado (20%)
        self.assertEqual(len(test), int(0.2*len(df)))
        
        # Comprobamos que el tamaño del train es el esperado (80%)
        self.assertEqual(len(train), int(0.8*len(df)))

if __name__ == '__main__':
    unittest.main(argv=['first-arg-is-ignored'], exit=False)

Por favor, ten en cuenta que he corregido la última línea de tu código de prueba unitaria. La longitud de train debería ser el 80% del total, no el 70%. Por lo tanto, he cambiado self.assertEqual(len(train), int(0.7*len(df))) a self.assertEqual(len(train), int(0.8*len(df))). Espero que esto te ayude! 😊