Registro de Riesgos en Testing: Guía Completa de Documentación y Gestión de Riesgos

# Plantilla de Taller de Identificación de Riesgos

## Detalles de la Sesión
- Fecha: 2025-01-15
- Participantes: Líder QA, Líder Dev, Product Manager, Ingeniero DevOps
- Proyecto: Plataforma E-commerce v3.0 Release
- Duración: 90 minutos

## Riesgos Identificados (Ronda de Brainstorming)

### Riesgos Técnicos
1. Complejidad de integración de pasarela de pagos (identificado por: Líder Dev)
2. Rendimiento de base de datos bajo carga de Black Friday (identificado por: DevOps)
3. Limitación de tasa de API de terceros (identificado por: Líder QA)
4. Inconsistencias de renderizado en navegadores móviles (identificado por: Líder QA)

### Riesgos de Cronograma
5. Conflictos de fecha de congelación de funcionalidades con temporada festiva (identificado por: PM)
6. Dependencia de actualizaciones de API de proveedor (identificado por: Líder Dev)
7. Tiempo insuficiente para pruebas de penetración de seguridad (identificado por: Líder QA)

### Riesgos de Recursos
8. Solo un tester familiarizado con pruebas de pagos (identificado por: Líder QA)
9. Acceso limitado a datos de prueba similares a producción (identificado por: DevOps)
10. Sin marco de pruebas de rendimiento automatizadas (identificado por: Líder QA)

# Identificación de riesgos a partir de patrones históricos de defectos
import pandas as pd
import matplotlib.pyplot as plt

def analyze_historical_risks(defect_data_csv):
    """
    Analizar defectos pasados para identificar patrones de riesgo recurrentes
    """
    df = pd.read_csv(defect_data_csv)

    # Identificar módulos de alto riesgo (defectos frecuentes)
    module_risk = df.groupby('module').agg({
        'defect_id': 'count',
        'severity': lambda x: (x == 'Critical').sum()
    }).rename(columns={'defect_id': 'total_defects', 'severity': 'critical_defects'})

    module_risk['risk_score'] = (
        module_risk['total_defects'] * 0.5 +
        module_risk['critical_defects'] * 2
    )

    # Identificar tipos de defectos de alto riesgo
    defect_type_risk = df.groupby('defect_type').size().sort_values(ascending=False)

    # Identificar períodos de tiempo de alto riesgo (crisis pre-lanzamiento)
    df['detection_date'] = pd.to_datetime(df['detection_date'])
    df['days_before_release'] = (df['release_date'] - df['detection_date']).dt.days

    late_defects = df[df['days_before_release'] < 7]

    risk_report = {
        'high_risk_modules': module_risk.sort_values('risk_score', ascending=False).head(5),
        'recurring_defect_types': defect_type_risk.head(10),
        'late_discovery_risk': {
            'percentage': len(late_defects) / len(df) * 100,
            'critical_late_defects': len(late_defects[late_defects['severity'] == 'Critical'])
        }
    }

    return risk_report

# Uso de ejemplo
risks = analyze_historical_risks('defects_2024.csv')

# Generar entradas de registro de riesgos a partir del análisis
print("Riesgos Identificados de Datos Históricos:")
print(f"1. Módulos de alto riesgo que requieren pruebas intensivas: {list(risks['high_risk_modules'].index)}")
print(f"2. Tasa de descubrimiento tardío de defectos: {risks['late_discovery_risk']['percentage']:.1f}%")
print(f"3. Patrones de defectos recurrentes: {list(risks['recurring_defect_types'].index[:3])}")

# Implementación de matriz de evaluación de riesgos
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

class RiskAssessmentMatrix:
    def __init__(self):
        self.risks = []

    def assess_risk(self, risk_id, name, probability, impact, category):
        """
        Evaluar un riesgo y calcular su puntuación de prioridad
        """
        risk_score = probability * impact

        # Determinar nivel de riesgo
        if risk_score >= 15:
            risk_level = 'Crítico'
            priority = 1
        elif risk_score >= 10:
            risk_level = 'Alto'
            priority = 2
        elif risk_score >= 5:
            risk_level = 'Medio'
            priority = 3
        else:
            risk_level = 'Bajo'
            priority = 4

        risk_entry = {
            'id': risk_id,
            'name': name,
            'probability': probability,
            'impact': impact,
            'score': risk_score,
            'level': risk_level,
            'priority': priority,
            'category': category
        }

        self.risks.append(risk_entry)
        return risk_entry

    def visualize_matrix(self):
        """
        Crear matriz visual de evaluación de riesgos
        """
        fig, ax = plt.subplots(figsize=(12, 8))

        # Crear fondo de matriz
        matrix = np.zeros((5, 5))
        for i in range(5):
            for j in range(5):
                score = (i + 1) * (j + 1)
                if score >= 15:
                    matrix[i, j] = 4  # Crítico
                elif score >= 10:
                    matrix[i, j] = 3  # Alto
                elif score >= 5:
                    matrix[i, j] = 2  # Medio
                else:
                    matrix[i, j] = 1  # Bajo

        # Graficar mapa de calor
        colors = ['#90EE90', '#FFFF99', '#FFB84D', '#FF6B6B']
        sns.heatmap(matrix, annot=False, cmap=colors, cbar=False,
                    xticklabels=['Insignificante', 'Bajo', 'Medio', 'Alto', 'Crítico'],
                    yticklabels=['Muy Baja', 'Baja', 'Media', 'Alta', 'Muy Alta'],
                    ax=ax)

        # Graficar riesgos
        for risk in self.risks:
            ax.plot(risk['impact'] - 0.5, risk['probability'] - 0.5,
                   'o', markersize=15, color='navy', alpha=0.6)
            ax.text(risk['impact'] - 0.5, risk['probability'] - 0.5,
                   risk['id'], ha='center', va='center', color='white',
                   fontweight='bold', fontsize=8)

        ax.set_xlabel('Impacto', fontsize=12, fontweight='bold')
        ax.set_ylabel('Probabilidad', fontsize=12, fontweight='bold')
        ax.set_title('Matriz de Evaluación de Riesgos', fontsize=14, fontweight='bold')

        plt.tight_layout()
        return fig

# Uso de ejemplo
ram = RiskAssessmentMatrix()

# Evaluar múltiples riesgos
ram.assess_risk('R1', 'Fallo de integración de pasarela de pagos', probability=3, impact=5, category='Técnico')
ram.assess_risk('R2', 'Cobertura insuficiente de pruebas móviles', probability=4, impact=3, category='Técnico')
ram.assess_risk('R3', 'Indisponibilidad de tester clave', probability=2, impact=4, category='Recursos')
ram.assess_risk('R4', 'Limitación de tasa de API de terceros', probability=3, impact=3, category='Técnico')
ram.assess_risk('R5', 'Cronograma de pruebas comprimido', probability=5, impact=4, category='Cronograma')

# Generar visualización
fig = ram.visualize_matrix()
plt.savefig('risk_assessment_matrix.png', dpi=300, bbox_inches='tight')

## Riesgo: Fallo de Integración de Pasarela de Pagos (R1)
- **Probabilidad**: Media (3/5)
- **Impacto**: Crítico (5/5)
- **Puntuación de Riesgo**: 15 (Crítico)

### Estrategia de Mitigación: Reducción + Contingencia

#### Medidas Preventivas (Reducir Probabilidad):
1. **Pruebas de Integración Tempranas**
   - Configurar entorno sandbox para Sprint 2
   - Realizar pruebas de integración 3 semanas antes de UAT
   - Pruebas de humo diarias en flujos de pago

2. **Compromiso con Proveedor**
   - Reuniones de sincronización semanales con proveedor de pagos
   - Contacto técnico dedicado para escalamientos
   - Revisión exhaustiva de documentación de integración

3. **Pruebas Incrementales**
   - Probar métodos de pago individuales por separado
   - Validar escenarios de manejo de errores
   - Pruebas de rendimiento de procesamiento de pagos bajo carga

#### Medidas de Reducción de Impacto:
1. **Opciones de Pago de Respaldo**
   - Mantener integración de proveedor de pago alternativo
   - Capacidad de procesamiento de pago manual como respaldo
   - Comunicación clara al usuario para problemas de pago

2. **Monitoreo y Alertas**
   - Monitoreo en tiempo real de tasa de fallo de pagos
   - Alertas automatizadas para errores de transacción
   - Panel de métricas de salud de pagos

### Plan de Contingencia:
**Disparador**: Tasa de éxito de pagos cae por debajo del 95%
**Acciones**:
1. Activar equipo de respuesta a incidentes (dentro de 15 minutos)
2. Cambiar a proveedor de pago de respaldo (dentro de 1 hora)
3. Comunicar estado a stakeholders
4. Análisis de causa raíz dentro de 24 horas
5. Línea de tiempo de implementación de solución permanente acordada

### Propietario: Líder QA (Sarah Johnson)
### Frecuencia de Revisión: Semanal durante fase de integración, Diaria durante UAT
### Estado: Activo | Última Actualización: 2025-01-15

# Mitigación automatizada de riesgos: Seguimiento de distribución de conocimiento
class KnowledgeRiskMitigator:
    def __init__(self, team_skills_matrix):
        self.skills_matrix = team_skills_matrix

    def assess_knowledge_concentration_risk(self):
        """
        Identificar puntos únicos de falla en conocimiento del equipo
        """
        risks = []

        for skill, team_members in self.skills_matrix.items():
            experts = [m for m in team_members if m['proficiency'] >= 4]

            if len(experts) == 1:
                # Alto riesgo: solo un experto
                risks.append({
                    'skill': skill,
                    'risk_level': 'Crítico',
                    'experts': [experts[0]['name']],
                    'mitigation': 'Capacitación cruzada requerida inmediatamente'
                })
            elif len(experts) == 2:
                # Riesgo medio: dos expertos
                risks.append({
                    'skill': skill,
                    'risk_level': 'Medio',
                    'experts': [e['name'] for e in experts],
                    'mitigation': 'Expandir conocimiento a 1-2 miembros más del equipo'
                })

        return risks

    def generate_training_plan(self, risks):
        """
        Crear plan de mitigación mediante transferencia de conocimiento
        """
        training_plan = []

        for risk in risks:
            if risk['risk_level'] == 'Crítico':
                training_plan.append({
                    'skill': risk['skill'],
                    'trainers': risk['experts'],
                    'trainees': self.find_suitable_trainees(risk['skill']),
                    'timeline': '2 semanas',
                    'format': 'Pruebas en pareja + documentación',
                    'success_criteria': 'Aprendiz alcanza nivel de competencia 3'
                })

        return training_plan

# Uso de ejemplo
team_skills = {
    'Pruebas de Pago': [
        {'name': 'Alice', 'proficiency': 5},
        {'name': 'Bob', 'proficiency': 2}
    ],
    'Automatización Móvil': [
        {'name': 'Charlie', 'proficiency': 4},
        {'name': 'Diana', 'proficiency': 4},
        {'name': 'Eve', 'proficiency': 3}
    ],
    'Pruebas de Seguridad': [
        {'name': 'Frank', 'proficiency': 5}
    ]
}

mitigator = KnowledgeRiskMitigator(team_skills)
knowledge_risks = mitigator.assess_knowledge_concentration_risk()
training_plan = mitigator.generate_training_plan(knowledge_risks)

print("Plan de Mitigación de Riesgo de Conocimiento:")
for item in training_plan:
    print(f"Habilidad: {item['skill']}, Capacitadores: {item['trainers']}, Plazo: {item['timeline']}")

{
  "riskRegisterId": "RR-2025-Q1-ECOM",
  "project": "Plataforma E-commerce v3.0",
  "owner": "Sarah Johnson (Líder QA)",
  "lastUpdated": "2025-01-15T14:30:00Z",
  "risks": [
    {
      "riskId": "R001",
      "category": "Técnico",
      "title": "Fallo de Integración de Pasarela de Pagos",
      "description": "La integración del proveedor de pagos de terceros puede fallar o exhibir errores en entorno de producción",
      "identifiedDate": "2025-01-10",
      "identifiedBy": "Líder Dev",
      "probability": 3,
      "impact": 5,
      "riskScore": 15,
      "riskLevel": "Crítico",
      "status": "Activo",
      "mitigationStrategy": "Reducción + Contingencia",
      "mitigationActions": [
        "Pruebas de integración tempranas en sandbox",
        "Reuniones de sincronización semanales con proveedor",
        "Integración de proveedor de pago de respaldo",
        "Monitoreo y alertas en tiempo real"
      ],
      "contingencyPlan": {
        "trigger": "Tasa de éxito de pagos < 95%",
        "actions": [
          "Activar respuesta a incidentes (15 min)",
          "Cambiar a proveedor de respaldo (1 hora)",
          "Comunicación a stakeholders",
          "Análisis de causa raíz (24 horas)"
        ]
      },
      "owner": "Líder QA",
      "reviewDate": "2025-01-22",
      "residualRisk": {
        "probability": 1,
        "impact": 3,
        "score": 3,
        "level": "Bajo"
      },
      "actualizations": [],
      "lessons": null
    }
  ]
}

# Implementación de panel de seguimiento de riesgos
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import pandas as pd

class RiskDashboard:
    def __init__(self, risk_register_json):
        self.risks_df = pd.DataFrame(risk_register_json['risks'])

    def generate_dashboard(self):
        """
        Crear panel interactivo de seguimiento de riesgos
        """
        fig = make_subplots(
            rows=2, cols=2,
            subplot_titles=('Distribución de Riesgos por Nivel',
                          'Resumen de Estado de Riesgos',
                          'Tendencia de Puntuación de Riesgos',
                          'Top 5 Riesgos por Puntuación'),
            specs=[[{'type': 'pie'}, {'type': 'bar'}],
                   [{'type': 'scatter'}, {'type': 'bar'}]]
        )

        # 1. Distribución de riesgos por nivel
        risk_counts = self.risks_df['riskLevel'].value_counts()
        fig.add_trace(
            go.Pie(labels=risk_counts.index, values=risk_counts.values,
                  marker=dict(colors=['#FF6B6B', '#FFB84D', '#FFFF99', '#90EE90'])),
            row=1, col=1
        )

        # 2. Resumen de estado de riesgos
        status_counts = self.risks_df['status'].value_counts()
        fig.add_trace(
            go.Bar(x=status_counts.index, y=status_counts.values,
                  marker=dict(color='#4A90E2')),
            row=1, col=2
        )

        # 3. Tendencia de puntuación de riesgos (si hay datos históricos disponibles)
        # Marcador de posición para análisis de tendencias
        fig.add_trace(
            go.Scatter(x=['Semana 1', 'Semana 2', 'Semana 3', 'Semana 4'],
                      y=[45, 38, 32, 28],
                      mode='lines+markers',
                      name='Puntuación Total de Riesgos',
                      line=dict(color='#E74C3C', width=3)),
            row=2, col=1
        )

        # 4. Top 5 riesgos
        top_risks = self.risks_df.nlargest(5, 'riskScore')
        fig.add_trace(
            go.Bar(x=top_risks['title'], y=top_risks['riskScore'],
                  marker=dict(color=top_risks['riskScore'],
                            colorscale='Reds',
                            showscale=True)),
            row=2, col=2
        )

        fig.update_layout(
            title_text="Panel de Registro de Riesgos de Testing",
            showlegend=False,
            height=800
        )

        return fig

# Uso de ejemplo
dashboard = RiskDashboard(risk_register_data)
fig = dashboard.generate_dashboard()
fig.write_html('risk_dashboard.html')

# Aviso de Escalamiento de Riesgo

## Nivel de Escalamiento: 2 (Project Manager)
## Fecha: 2025-01-18
## Escalado Por: Sarah Johnson (Líder QA)

### Detalles del Riesgo
- **ID de Riesgo**: R001
- **Título del Riesgo**: Fallo de Integración de Pasarela de Pagos
- **Puntuación Actual de Riesgo**: 15 → 20 (aumentado)
- **Nivel de Riesgo**: Crítico

### Razón de Escalamiento
La estrategia de mitigación primaria (pruebas tempranas en sandbox) reveló problemas críticos de compatibilidad de API. La incompatibilidad de versión de API del proveedor de pagos causa fallos de transacción en 30% de casos de prueba.

### Situación Actual
- Pruebas en sandbox iniciadas Semana -3 (según lo planeado)
- Descubierta incompatibilidad de API v2.0 en Día 2
- Proveedor requiere cronograma de 2 semanas para actualización de API
- El cronograma actual del proyecto no acomoda retraso

### Evaluación de Impacto
- **Cronograma**: UAT retrasado por mínimo 2 semanas
- **Presupuesto**: Tarifas adicionales de proveedor: $15,000
- **Calidad**: No se puede proceder a UAT sin integración de pago estable
- **Cliente**: Fecha de lanzamiento en riesgo

### Acciones Solicitadas
1. **Inmediato**: Aprobación para contratar proveedor de pago alternativo (Costo: $20,000 configuración)
2. **Corto plazo**: Negociar corrección acelerada de API con proveedor actual
3. **Largo plazo**: Re-establecer línea base de cronograma del proyecto

### Reunión de Escalamiento Solicitada
- **Fecha**: 2025-01-19 (Mañana)
- **Hora**: 10:00 AM
- **Asistentes**: PM, Líder Dev, Líder QA, Gerente de Cuenta de Proveedor
- **Duración**: 60 minutos

### Documentación de Soporte
- Análisis técnico: [enlace a documento]
- Registro de comunicación con proveedor: [enlace a documento]
- Comparación de proveedor alternativo: [enlace a hoja de cálculo]

# Planificación de pruebas basada en riesgos
class RiskBasedTestPlanner:
    def __init__(self, risk_register, test_inventory):
        self.risks = risk_register
        self.tests = test_inventory

    def prioritize_test_execution(self):
        """
        Priorizar pruebas basadas en niveles de riesgo asociados
        """
        test_priority = []

        for test in self.tests:
            # Encontrar riesgos asociados
            related_risks = [r for r in self.risks if test['feature'] in r['affectedFeatures']]

            if not related_risks:
                priority_score = 1  # Prioridad base
            else:
                # El riesgo más alto determina la prioridad de prueba
                max_risk_score = max([r['riskScore'] for r in related_risks])
                priority_score = max_risk_score

            test_priority.append({
                'testId': test['id'],
                'testName': test['name'],
                'priorityScore': priority_score,
                'relatedRisks': [r['riskId'] for r in related_risks],
                'executionOrder': None
            })

        # Ordenar por prioridad
        test_priority.sort(key=lambda x: x['priorityScore'], reverse=True)

        # Asignar orden de ejecución
        for idx, test in enumerate(test_priority, start=1):
            test['executionOrder'] = idx

        return test_priority

# Uso de ejemplo
test_plan = RiskBasedTestPlanner(risk_register, test_cases)
prioritized_tests = test_plan.prioritize_test_execution()

print("Orden de Ejecución de Pruebas Basado en Riesgos:")
for test in prioritized_tests[:10]:  # Top 10 pruebas prioritarias
    print(f"{test['executionOrder']}. {test['testName']} (Prioridad: {test['priorityScore']})")