No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Pruebas unitarias con GitHub Copilot

8/17
Recursos

¿Cómo realizar pruebas unitarias con IA en mi código?

En la actualidad, el uso de inteligencia artificial y en especial los LLMs (Modelos de Lenguaje Extenso) en el desarrollo de software es cada vez más común, no solo para generar código sino también para testear y asegurar su correcto funcionamiento mediante pruebas unitarias. Aquí te mostramos cómo puedes emplear estas herramientas con eficacia.

¿Cómo usar pruebas unitarias en funciones de Python?

El proceso de hacer pruebas unitarias en Python es esencial para asegurar el correcto comportamiento de nuestro código. Supongamos que tenemos una función llamada getTweets, que extrae tweets de un determinado hashtag a través de la API de Twitter. Para definir un test unitario para esta función, podemos hacer uso de la función directa assert de Python. Esto se ilustra en el código siguiente:

def test_getTweets():
    tweets = getTweets('IA')
    assert len(tweets) <= 50  # Asegurar que el número de tweets no exceda 50
    # Comprobación de las columnas esperadas
    for tweet in tweets:
        assert 'text' in tweet and 'user' in tweet and 'isTweet' in tweet
        assert type(tweet['text']) is str
        assert type(tweet['user']) is str
        assert type(tweet['isTweet']) is bool

Estos pasos permiten asegurarnos de que la función retorne el número correcto de tweets y que estos contengan las columnas y tipos de datos adecuados.

¿Cuál es el poder de las herramientas automatizadas como Copilot o ChatGPT?

Copilot y ChatGPT son herramientas impulsadas por AI que pueden automatizar la generación de pruebas unitarias, contribuyendo a una codificación eficiente. Aquí tienes un ejemplo de cómo aplicar Copilot para crear un test unitario para una función llamada calcularMedia:

def test_calcularMedia():
    assert calcularMedia([1, 2, 3, 4, 5]) == 3  # Calcula la media
    assert calcularMedia([-1, -2, -3]) == -2  # Funciona con números negativos
    assert calcularMedia([0, 0, 0]) == 0  # Funciona con ceros

Estas herramientas no solo simplifican el proceso de construir pruebas, sino que también ofrecen sugerencias basadas en patrones observados en la codificación.

¿Cómo generar tests unitarios con ChatGPT para proyectos más grandes?

Un desafío común es realizar pruebas sobre funciones más complejas. Imaginemos una función que utiliza scikit-learn para dividir un dataset en conjuntos de entrenamiento y prueba. A continuación, el uso de unittest permite verificar que la división se hace correctamente:

from sklearn.model_selection import train_test_split
import unittest

def disfrutarDataSet(dataset):
    X_train, X_test = train_test_split(dataset, test_size=0.2)
    return X_train, X_test

class TestDataSetSplit(unittest.TestCase):
    def test_split(self):
        dataset = list(range(100))
        X_train, X_test = disfrutarDataSet(dataset)
        self.assertEqual(len(X_train), 80)
        self.assertEqual(len(X_test), 20)

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

Generar y ejecutar estos tests asegura que la división del dataset cumple con los criterios de tamaño especificados.

¿Por qué adoptar la inteligencia artificial para pruebas unitarias?

La automatización de tests unitarios con IA no solo optimiza el tiempo y esfuerzo, sino que también minimiza el riesgo de errores humanos y mejora la confiabilidad del código. Los desarrolladores pueden enfocarse más en la lógica empresarial y menos en las actividades repetitivas, gracias al poder de la IA.

Te animamos a que te adentres más en la práctica de pruebas unitarias usando inteligencia artificial. Aprovechar estas herramientas modernas puede llevar tus habilidades de programación a otro nivel y garantizar un código de mayor calidad. Así que, ¡no dudes en experimentar y seguir aprendiendo!

Aportes 13

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

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.

Lo admito, nunca hago pruebas unitarias. Pero eso cambiará desde hoy 🚀

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! 😊