El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Cobertura de Pruebas

Siguiente ►
►

La cobertura de pruebas es una métrica que indica qué tan bien están cubiertos los diferentes aspectos de tu código por las pruebas. En otras palabras, mide el porcentaje de tu código que es ejecutado durante las pruebas. Una alta cobertura de pruebas puede ayudar a identificar áreas del código que no están siendo probadas y que podrían contener errores.

Conceptos Clave

  1. Cobertura de Código: Es el porcentaje de líneas de código que son ejecutadas durante las pruebas.
  2. Cobertura de Ramas: Mide si todas las ramas de las estructuras de control (como if-else) han sido ejecutadas.
  3. Cobertura de Funciones: Indica qué porcentaje de las funciones han sido llamadas durante las pruebas.
  4. Cobertura de Condiciones: Verifica si todas las condiciones booleanas han sido evaluadas tanto a verdadero como a falso.

Herramientas para Medir la Cobertura de Pruebas

En el ecosistema de Python, hay varias herramientas que puedes utilizar para medir la cobertura de pruebas. Algunas de las más populares son:

  • Coverage.py: Es una herramienta que mide la cobertura de código en Python.
  • pytest-cov: Es un plugin para pytest que utiliza Coverage.py para medir la cobertura de pruebas.

Instalación de Coverage.py

Para instalar Coverage.py, puedes usar pip:

pip install coverage

Uso Básico de Coverage.py

A continuación, se muestra cómo puedes usar Coverage.py para medir la cobertura de pruebas en tu proyecto Flask.

  1. Ejecutar las Pruebas con Coverage

Primero, debes ejecutar tus pruebas utilizando Coverage.py. Supongamos que tienes un archivo de pruebas llamado test_app.py:

coverage run -m pytest test_app.py

  1. Generar un Informe de Cobertura

Después de ejecutar las pruebas, puedes generar un informe de cobertura:

coverage report

Este comando mostrará un resumen en la terminal con el porcentaje de cobertura de cada archivo.

  1. Generar un Informe HTML

Para una visualización más detallada, puedes generar un informe en formato HTML:

coverage html

Este comando creará una carpeta llamada htmlcov que contiene un informe detallado. Puedes abrir el archivo index.html en tu navegador para ver el informe.

Ejemplo Práctico

Supongamos que tienes una aplicación Flask simple con el siguiente código en app.py:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify(message="Hello, World!")

@app.route('/about')
def about():
    return jsonify(message="About Page")

if __name__ == '__main__':
    app.run(debug=True)

Y tienes un archivo de pruebas test_app.py:

import unittest
from app import app

class BasicTests(unittest.TestCase):

    def setUp(self):
        self.app = app.test_client()
        self.app.testing = True

    def test_home(self):
        response = self.app.get('/')
        self.assertEqual(response.status_code, 200)
        self.assertIn(b'Hello, World!', response.data)

    def test_about(self):
        response = self.app.get('/about')
        self.assertEqual(response.status_code, 200)
        self.assertIn(b'About Page', response.data)

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

Para medir la cobertura de pruebas, ejecuta los siguientes comandos:

coverage run -m unittest test_app.py
coverage report
coverage html

Ejercicio Práctico

Ejercicio

  1. Crea una nueva ruta en tu aplicación Flask llamada /contact que devuelva un mensaje JSON con el texto "Contact Page".
  2. Escribe una prueba unitaria para la nueva ruta /contact.
  3. Mide la cobertura de pruebas utilizando Coverage.py y genera un informe HTML.
  4. Verifica que la cobertura de código sea del 100%.

Solución

Paso 1: Añadir la nueva ruta en app.py

@app.route('/contact')
def contact():
    return jsonify(message="Contact Page")

Paso 2: Añadir la prueba unitaria en test_app.py

def test_contact(self):
    response = self.app.get('/contact')
    self.assertEqual(response.status_code, 200)
    self.assertIn(b'Contact Page', response.data)

Paso 3 y 4: Ejecutar Coverage.py y verificar la cobertura

coverage run -m unittest test_app.py
coverage report
coverage html

Abre el archivo htmlcov/index.html en tu navegador y verifica que la cobertura de código sea del 100%.

Conclusión

La cobertura de pruebas es una herramienta esencial para garantizar la calidad y la fiabilidad de tu código. Utilizando herramientas como Coverage.py, puedes identificar áreas no probadas de tu aplicación y mejorar la robustez de tu código. Asegúrate de mantener una alta cobertura de pruebas para minimizar errores y asegurar un desarrollo más seguro y eficiente.

◄ Anterior
◄
Siguiente ►
►

Curso de Desarrollo Web con Flask

Módulo 1: Introducción a Flask

Módulo 2: Conceptos Básicos de Flask

Módulo 3: Formularios y Entrada de Usuario

Módulo 4: Integración de Bases de Datos

Módulo 5: Autenticación de Usuarios

Módulo 6: Conceptos Avanzados de Flask

Módulo 7: APIs RESTful con Flask

Módulo 8: Despliegue y Producción

Módulo 9: Pruebas y Mejores Prácticas

Módulo 10: Extensiones y Ecosistema de Flask

El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados