Reporte de Cobertura de Pruebas: Guía Completa de Análisis y Visualización de Cobertura

# Cobertura de código Python con pytest-cov
# Configuración pytest.ini
[pytest]
addopts = --cov=src --cov-report=html --cov-report=term --cov-report=xml

# Ejecutar pruebas con cobertura
# pytest --cov=myapp tests/

# Ejemplo de prueba con análisis de cobertura
import pytest
from myapp.calculator import Calculator

class TestCalculator:
    def test_addition(self):
        calc = Calculator()
        assert calc.add(2, 3) == 5

    def test_division(self):
        calc = Calculator()
        assert calc.divide(10, 2) == 5

    def test_division_by_zero(self):
        calc = Calculator()
        with pytest.raises(ZeroDivisionError):
            calc.divide(10, 0)

    def test_complex_calculation(self):
        calc = Calculator()
        # Prueba cobertura de ramas para operaciones multi-paso
        result = calc.calculate("(5 + 3) * 2")
        assert result == 16

// Configuración de Jest - jest.config.js
module.exports = {
  collectCoverage: true,
  coverageDirectory: 'coverage',
  coverageReporters: ['text', 'html', 'lcov', 'json'],
  coverageThreshold: {
    global: {
      statements: 80,
      branches: 75,
      functions: 80,
      lines: 80
    },
    './src/critical/': {
      statements: 95,
      branches: 90,
      functions: 95,
      lines: 95
    }
  },
  collectCoverageFrom: [
    'src/**/*.{js,jsx,ts,tsx}',
    '!src/**/*.test.{js,jsx,ts,tsx}',
    '!src/**/index.{js,ts}'
  ]
};

// Ejemplo de prueba con cobertura de ramas
describe('UserAuthentication', () => {
  it('should authenticate valid user', async () => {
    const result = await authenticate('user@example.com', 'password123');
    expect(result.success).toBe(true);
  });

  it('should reject invalid credentials', async () => {
    const result = await authenticate('user@example.com', 'wrongpass');
    expect(result.success).toBe(false);
    expect(result.error).toBe('Invalid credentials');
  });

  it('should handle account lockout', async () => {
    // Probar cobertura de ramas para lógica de seguridad
    for (let i = 0; i < 5; i++) {
      await authenticate('user@example.com', 'wrongpass');
    }
    const result = await authenticate('user@example.com', 'password123');
    expect(result.locked).toBe(true);
  });
});

# Analizador de cobertura de requisitos
import json
from collections import defaultdict

class RequirementsCoverageAnalyzer:
    def __init__(self, requirements_file, test_results_file):
        self.requirements = self.load_requirements(requirements_file)
        self.test_results = self.load_test_results(test_results_file)

    def load_requirements(self, file_path):
        with open(file_path, 'r') as f:
            return json.load(f)

    def load_test_results(self, file_path):
        with open(file_path, 'r') as f:
            return json.load(f)

    def calculate_coverage(self):
        coverage_map = defaultdict(lambda: {
            'requirement': None,
            'test_cases': [],
            'status': 'No Cubierto',
            'priority': None
        })

        # Mapear requisitos a casos de prueba
        for req in self.requirements:
            req_id = req['id']
            coverage_map[req_id]['requirement'] = req['description']
            coverage_map[req_id]['priority'] = req['priority']

        # Vincular casos de prueba a requisitos
        for test in self.test_results:
            for req_id in test.get('covers_requirements', []):
                if req_id in coverage_map:
                    coverage_map[req_id]['test_cases'].append({
                        'id': test['id'],
                        'name': test['name'],
                        'status': test['status']
                    })

        # Determinar estado de cobertura
        for req_id, data in coverage_map.items():
            if not data['test_cases']:
                data['status'] = 'No Cubierto'
            elif all(tc['status'] == 'PASSED' for tc in data['test_cases']):
                data['status'] = 'Cubierto'
            elif any(tc['status'] == 'FAILED' for tc in data['test_cases']):
                data['status'] = 'Fallido'
            else:
                data['status'] = 'Parcial'

        return coverage_map

    def generate_report(self):
        coverage = self.calculate_coverage()

        total_reqs = len(coverage)
        covered_reqs = sum(1 for v in coverage.values() if v['status'] == 'Cubierto')
        partial_reqs = sum(1 for v in coverage.values() if v['status'] == 'Parcial')
        not_covered_reqs = sum(1 for v in coverage.values() if v['status'] == 'No Cubierto')

        report = {
            'summary': {
                'total_requirements': total_reqs,
                'covered': covered_reqs,
                'partial': partial_reqs,
                'not_covered': not_covered_reqs,
                'coverage_percentage': (covered_reqs / total_reqs * 100) if total_reqs > 0 else 0
            },
            'details': coverage,
            'gaps': [
                {
                    'req_id': req_id,
                    'description': data['requirement'],
                    'priority': data['priority']
                }
                for req_id, data in coverage.items()
                if data['status'] == 'No Cubierto' and data['priority'] in ['Crítico', 'Alto']
            ]
        }

        return report

# Uso de ejemplo
analyzer = RequirementsCoverageAnalyzer('requirements.json', 'test_results.json')
coverage_report = analyzer.generate_report()

print(f"Cobertura de Requisitos: {coverage_report['summary']['coverage_percentage']:.1f}%")
print(f"Brechas Críticas/Altas: {len(coverage_report['gaps'])}")

# Matriz de cobertura de riesgos
class RiskCoverageMatrix:
    def __init__(self, risk_register, test_plan):
        self.risks = risk_register
        self.tests = test_plan

    def analyze_risk_coverage(self):
        risk_coverage = []

        for risk in self.risks:
            # Encontrar pruebas que abordan este riesgo
            mitigating_tests = [
                test for test in self.tests
                if risk['id'] in test.get('mitigates_risks', [])
            ]

            # Calcular puntuación de cobertura de riesgo
            if not mitigating_tests:
                coverage_score = 0
                status = 'No Cubierto'
            else:
                # Ponderar por tipo de prueba y estado de ejecución
                test_weight = {
                    'unit': 0.3,
                    'integration': 0.5,
                    'e2e': 0.8,
                    'manual': 0.6
                }

                total_weight = sum(
                    test_weight.get(test['type'], 0.5) *
                    (1.0 if test['status'] == 'PASSED' else 0.5)
                    for test in mitigating_tests
                )

                # Normalizar a escala 0-100
                coverage_score = min(100, total_weight * 50)

                if coverage_score >= 80:
                    status = 'Bien Cubierto'
                elif coverage_score >= 50:
                    status = 'Adecuadamente Cubierto'
                else:
                    status = 'Insuficientemente Cubierto'

            risk_coverage.append({
                'risk_id': risk['id'],
                'risk_title': risk['title'],
                'risk_score': risk['risk_score'],
                'risk_level': risk['level'],
                'mitigating_tests': len(mitigating_tests),
                'coverage_score': coverage_score,
                'coverage_status': status
            })

        return risk_coverage

    def identify_coverage_gaps(self, risk_coverage):
        """
        Identificar elementos de alto riesgo con cobertura insuficiente
        """
        gaps = [
            item for item in risk_coverage
            if item['risk_level'] in ['Crítico', 'Alto']
            and item['coverage_status'] in ['No Cubierto', 'Insuficientemente Cubierto']
        ]

        # Ordenar por puntuación de riesgo (mayor primero)
        gaps.sort(key=lambda x: x['risk_score'], reverse=True)

        return gaps

# Uso de ejemplo
rcm = RiskCoverageMatrix(risks, test_cases)
coverage = rcm.analyze_risk_coverage()
gaps = rcm.identify_coverage_gaps(coverage)

print(f"Brechas de cobertura de alto riesgo: {len(gaps)}")
for gap in gaps[:5]:  # Top 5 brechas
    print(f"  {gap['risk_id']}: {gap['risk_title']} (Cobertura: {gap['coverage_score']:.0f}%)")

# Panel de cobertura completo con Plotly
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import pandas as pd
from datetime import datetime, timedelta

class CoverageDashboard:
    def __init__(self, code_coverage, req_coverage, risk_coverage, historical_data):
        self.code_cov = code_coverage
        self.req_cov = req_coverage
        self.risk_cov = risk_coverage
        self.history = historical_data

    def create_dashboard(self):
        fig = make_subplots(
            rows=3, cols=2,
            subplot_titles=(
                'Resumen de Cobertura de Código',
                'Estado de Cobertura de Requisitos',
                'Tendencia de Cobertura (Últimos 30 Días)',
                'Distribución de Cobertura de Riesgos',
                'Brechas Críticas',
                'Cobertura por Módulo'
            ),
            specs=[
                [{'type': 'indicator'}, {'type': 'pie'}],
                [{'type': 'scatter'}, {'type': 'bar'}],
                [{'type': 'table'}, {'type': 'bar'}]
            ],
            row_heights=[0.3, 0.35, 0.35]
        )

        # 1. Indicador de cobertura de código
        overall_coverage = self.code_cov['summary']['overall']
        fig.add_trace(
            go.Indicator(
                mode="gauge+number+delta",
                value=overall_coverage,
                delta={'reference': 80, 'increasing': {'color': "green"}},
                gauge={
                    'axis': {'range': [None, 100]},
                    'bar': {'color': self._get_color(overall_coverage)},
                    'steps': [
                        {'range': [0, 50], 'color': "lightgray"},
                        {'range': [50, 80], 'color': "lightyellow"},
                        {'range': [80, 100], 'color': "lightgreen"}
                    ],
                    'threshold': {
                        'line': {'color': "red", 'width': 4},
                        'thickness': 0.75,
                        'value': 80
                    }
                },
                title={'text': "Cobertura General de Código"}
            ),
            row=1, col=1
        )

        # 2. Gráfico circular de cobertura de requisitos
        req_status = self.req_cov['summary']
        fig.add_trace(
            go.Pie(
                labels=['Cubierto', 'Parcial', 'No Cubierto'],
                values=[
                    req_status['covered'],
                    req_status['partial'],
                    req_status['not_covered']
                ],
                marker=dict(colors=['#28a745', '#ffc107', '#dc3545']),
                hole=0.4
            ),
            row=1, col=2
        )

        # 3. Tendencia de cobertura
        dates = [datetime.now() - timedelta(days=x) for x in range(30, 0, -1)]
        fig.add_trace(
            go.Scatter(
                x=dates,
                y=self.history['code_coverage'],
                mode='lines+markers',
                name='Cobertura de Código',
                line=dict(color='#007bff', width=3)
            ),
            row=2, col=1
        )
        fig.add_trace(
            go.Scatter(
                x=dates,
                y=self.history['req_coverage'],
                mode='lines+markers',
                name='Cobertura de Requisitos',
                line=dict(color='#28a745', width=3)
            ),
            row=2, col=1
        )

        # Agregar línea objetivo
        fig.add_hline(y=80, line_dash="dash", line_color="red",
                     annotation_text="Objetivo: 80%", row=2, col=1)

        # 4. Distribución de cobertura de riesgos
        risk_dist = pd.DataFrame(self.risk_cov).groupby('coverage_status').size()
        fig.add_trace(
            go.Bar(
                x=risk_dist.index,
                y=risk_dist.values,
                marker=dict(color=['#28a745', '#ffc107', '#dc3545'])
            ),
            row=2, col=2
        )

        # 5. Tabla de brechas críticas
        gaps = self._get_critical_gaps()
        fig.add_trace(
            go.Table(
                header=dict(
                    values=['Tipo', 'ID', 'Descripción', 'Prioridad'],
                    fill_color='paleturquoise',
                    align='left'
                ),
                cells=dict(
                    values=[
                        gaps['type'],
                        gaps['id'],
                        gaps['description'],
                        gaps['priority']
                    ],
                    fill_color='lavender',
                    align='left'
                )
            ),
            row=3, col=1
        )

        # 6. Cobertura por módulo
        modules = list(self.code_cov['by_module'].keys())
        coverage_values = list(self.code_cov['by_module'].values())
        fig.add_trace(
            go.Bar(
                x=modules,
                y=coverage_values,
                marker=dict(
                    color=coverage_values,
                    colorscale='RdYlGn',
                    cmin=0,
                    cmax=100,
                    showscale=True
                ),
                text=[f"{v:.1f}%" for v in coverage_values],
                textposition='outside'
            ),
            row=3, col=2
        )

        # Actualizar diseño
        fig.update_layout(
            title_text="Panel de Cobertura de Pruebas",
            showlegend=True,
            height=1200,
            hovermode='closest'
        )

        return fig

    def _get_color(self, coverage):
        if coverage >= 80:
            return "#28a745"  # Verde
        elif coverage >= 50:
            return "#ffc107"  # Amarillo
        else:
            return "#dc3545"  # Rojo

    def _get_critical_gaps(self):
        """Extraer brechas críticas de cobertura"""
        gaps = {
            'type': [],
            'id': [],
            'description': [],
            'priority': []
        }

        # Agregar brechas de requisitos
        for gap in self.req_cov.get('gaps', [])[:3]:
            gaps['type'].append('Requisito')
            gaps['id'].append(gap['req_id'])
            gaps['description'].append(gap['description'][:50] + '...')
            gaps['priority'].append(gap['priority'])

        # Agregar brechas de riesgos
        for item in self.risk_cov[:3]:
            if item['coverage_status'] == 'No Cubierto':
                gaps['type'].append('Riesgo')
                gaps['id'].append(item['risk_id'])
                gaps['description'].append(item['risk_title'][:50] + '...')
                gaps['priority'].append(item['risk_level'])

        return gaps

# Generar panel
dashboard = CoverageDashboard(code_cov_data, req_cov_data, risk_cov_data, historical_trends)
fig = dashboard.create_dashboard()
fig.write_html('coverage_dashboard.html')
fig.show()

# Mapa de calor de cobertura para análisis a nivel de módulo
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

def create_coverage_heatmap(coverage_data):
    """
    Crear mapa de calor mostrando cobertura a través de módulos y tipos de cobertura
    """
    # Preparar matriz de datos
    modules = list(coverage_data.keys())
    metrics = ['Sentencias', 'Ramas', 'Funciones', 'Líneas']

    data_matrix = []
    for module in modules:
        row = [
            coverage_data[module].get('statement', 0),
            coverage_data[module].get('branch', 0),
            coverage_data[module].get('function', 0),
            coverage_data[module].get('line', 0)
        ]
        data_matrix.append(row)

    data_matrix = np.array(data_matrix)

    # Crear mapa de calor
    plt.figure(figsize=(12, 8))
    sns.heatmap(
        data_matrix,
        annot=True,
        fmt='.1f',
        cmap='RdYlGn',
        xticklabels=metrics,
        yticklabels=modules,
        vmin=0,
        vmax=100,
        cbar_kws={'label': 'Cobertura %'}
    )

    plt.title('Mapa de Calor de Cobertura de Código por Módulo', fontsize=16, fontweight='bold')
    plt.xlabel('Métrica de Cobertura', fontsize=12)
    plt.ylabel('Módulo', fontsize=12)
    plt.tight_layout()

    return plt

# Uso de ejemplo
coverage_by_module = {
    'Autenticación': {'statement': 92, 'branch': 85, 'function': 95, 'line': 90},
    'Pago': {'statement': 88, 'branch': 80, 'function': 90, 'line': 87},
    'PerfilUsuario': {'statement': 75, 'branch': 70, 'function': 80, 'line': 74},
    'Panel': {'statement': 65, 'branch': 60, 'function': 70, 'line': 64},
    'Reportes': {'statement': 45, 'branch': 40, 'function': 50, 'line': 43}
}

heatmap = create_coverage_heatmap(coverage_by_module)
heatmap.savefig('coverage_heatmap.png', dpi=300, bbox_inches='tight')

# Calcular puntuación de cobertura ponderada basada en criticidad
class WeightedCoverageCalculator:
    def __init__(self, coverage_data, weights):
        self.coverage = coverage_data
        self.weights = weights

    def calculate_weighted_score(self):
        """
        Calcular puntuación general de cobertura con componentes ponderados
        """
        weighted_sum = 0
        total_weight = 0

        for component, data in self.coverage.items():
            weight = self.weights.get(component, 1.0)
            coverage_pct = data['coverage_percentage']

            weighted_sum += coverage_pct * weight
            total_weight += weight

        weighted_score = weighted_sum / total_weight if total_weight > 0 else 0

        return {
            'weighted_score': weighted_score,
            'components': {
                comp: {
                    'coverage': data['coverage_percentage'],
                    'weight': self.weights.get(comp, 1.0),
                    'contribution': data['coverage_percentage'] * self.weights.get(comp, 1.0)
                }
                for comp, data in self.coverage.items()
            }
        }

# Uso de ejemplo
coverage_components = {
    'code_coverage': {'coverage_percentage': 85.0},
    'requirements_coverage': {'coverage_percentage': 92.0},
    'risk_coverage': {'coverage_percentage': 78.0},
    'api_coverage': {'coverage_percentage': 88.0},
    'ui_coverage': {'coverage_percentage': 75.0}
}

weights = {
    'code_coverage': 1.0,
    'requirements_coverage': 2.0,  # Mayor prioridad
    'risk_coverage': 2.5,  # Máxima prioridad
    'api_coverage': 1.5,
    'ui_coverage': 1.0
}

calculator = WeightedCoverageCalculator(coverage_components, weights)
result = calculator.calculate_weighted_score()

print(f"Puntuación de Cobertura Ponderada: {result['weighted_score']:.1f}%")
print("\nContribuciones de Componentes:")
for comp, details in result['components'].items():
    print(f"  {comp}: {details['coverage']:.1f}% × {details['weight']} = {details['contribution']:.1f}")

# Flujo de trabajo de GitHub Actions para reporte de cobertura
name: Reporte de Cobertura de Pruebas

on:
  pull_request:
    branches: [main, develop]
  push:
    branches: [main]

jobs:
  coverage:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Configurar Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Instalar dependencias
        run: |
          pip install -r requirements.txt
          pip install pytest pytest-cov

      - name: Ejecutar pruebas con cobertura
        run: |
          pytest --cov=src --cov-report=xml --cov-report=html --cov-report=term

      - name: Subir cobertura a Codecov
        uses: codecov/codecov-action@v3
        with:
          file: ./coverage.xml
          fail_ci_if_error: true

      - name: Comentario de cobertura
        uses: py-cov-action/python-coverage-comment-action@v3
        with:
          GITHUB_TOKEN: ${{ github.token }}
          MINIMUM_GREEN: 80
          MINIMUM_ORANGE: 70

      - name: Verificar umbral de cobertura
        run: |
          python scripts/check_coverage_threshold.py --threshold 80

      - name: Generar insignia de cobertura
        run: |
          coverage-badge -o coverage.svg -f

      - name: Archivar artefactos de cobertura
        uses: actions/upload-artifact@v3
        with:
          name: coverage-report
          path: htmlcov/

# Script de aplicación de umbral de cobertura
import json
import sys
from pathlib import Path

class CoverageThresholdEnforcer:
    def __init__(self, coverage_file, thresholds):
        self.coverage_data = self._load_coverage(coverage_file)
        self.thresholds = thresholds

    def _load_coverage(self, file_path):
        with open(file_path, 'r') as f:
            return json.load(f)

    def check_thresholds(self):
        violations = []

        # Verificar cobertura general
        overall = self.coverage_data['totals']['percent_covered']
        if overall < self.thresholds['overall']:
            violations.append({
                'type': 'Cobertura General',
                'actual': overall,
                'threshold': self.thresholds['overall'],
                'deficit': self.thresholds['overall'] - overall
            })

        # Verificar cobertura por archivo
        for file_path, data in self.coverage_data['files'].items():
            file_coverage = data['summary']['percent_covered']

            # Archivos críticos tienen umbrales más estrictos
            if self._is_critical_file(file_path):
                threshold = self.thresholds.get('critical_files', 95)
            else:
                threshold = self.thresholds.get('per_file', 70)

            if file_coverage < threshold:
                violations.append({
                    'type': 'Cobertura de Archivo',
                    'file': file_path,
                    'actual': file_coverage,
                    'threshold': threshold,
                    'deficit': threshold - file_coverage
                })

        return violations

    def _is_critical_file(self, file_path):
        critical_patterns = ['auth', 'payment', 'security', 'core']
        return any(pattern in file_path.lower() for pattern in critical_patterns)

    def report_violations(self, violations):
        if not violations:
            print("✅ ¡Todos los umbrales de cobertura cumplidos!")
            return True

        print("❌ Violaciones de umbral de cobertura encontradas:\n")
        for v in violations:
            if v['type'] == 'Cobertura General':
                print(f"  General: {v['actual']:.1f}% (umbral: {v['threshold']}%, déficit: {v['deficit']:.1f}%)")
            else:
                print(f"  {v['file']}: {v['actual']:.1f}% (umbral: {v['threshold']}%, déficit: {v['deficit']:.1f}%)")

        return False

# Uso en CI/CD
if __name__ == '__main__':
    thresholds = {
        'overall': 80,
        'critical_files': 95,
        'per_file': 70
    }

    enforcer = CoverageThresholdEnforcer('coverage.json', thresholds)
    violations = enforcer.check_thresholds()
    success = enforcer.report_violations(violations)

    sys.exit(0 if success else 1)