Análisis de Métricas de Prueba con IA: Análisis Inteligente de Métricas QA

import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
import numpy as np

class TestMetricPredictor:
    def __init__(self, degree=2):
        self.poly_features = PolynomialFeatures(degree=degree)
        self.model = LinearRegression()

    def train(self (como se discute en [AI-powered Test Generation: The Future Is Already Here](/blog/ai-powered-test-generation)), historical_data):
        """
        Entrenar con métricas de prueba históricas
        historical_data: DataFrame con columnas ['date', 'test_failures',
                         'code_complexity', 'team_velocity']
        """
        X = historical_data[['code_complexity', 'team_velocity']].values
        y = historical_data['test_failures'] (como se discute en [AI Code Smell Detection: Finding Problems in Test Automation with ML](/blog/ai-code-smell-detection)).values

        X_poly = self.poly_features.fit_transform(X)
        self.model.fit(X_poly, y)

    def predict_failures(self (como se discute en [AI-Powered Security Testing: Finding Vulnerabilities Faster](/blog/ai-security-testing)), code_complexity, team_velocity):
        """Predecir fallos de prueba esperados para el próximo sprint"""
        X_new = np.array([[code_complexity, team_velocity]])
        X_poly = self.poly_features.transform(X_new)
        return self.model.predict(X_poly)[0]

    def calculate_risk_score(self, predicted_failures, threshold=10):
        """Convertir predicción a puntaje de riesgo (0-100)"""
        risk = min((predicted_failures / threshold) * 100, 100)
        return round(risk, 2)

# Ejemplo de uso
predictor = TestMetricPredictor()
predictor.train(historical_metrics_df)

# Predecir para el próximo sprint
next_sprint_failures = predictor.predict_failures(
    code_complexity=245,
    team_velocity=32
)
risk_score = predictor.calculate_risk_score(next_sprint_failures)

print(f"Fallos predichos: {next_sprint_failures:.1f}")
print(f"Puntaje de riesgo: {risk_score}%")

from sklearn.ensemble import IsolationForest
import pandas as pd

class MetricsAnomalyDetector:
    def __init__(self, contamination=0.1):
        self.detector = IsolationForest(
            contamination=contamination,
            random_state=42
        )

    def fit_and_detect(self, metrics_data):
        """
        Detectar anomalías en métricas de prueba
        metrics_data: DataFrame con métricas normalizadas
        """
        features = metrics_data[[
            'test_duration',
            'failure_rate',
            'flaky_test_percentage',
            'coverage_drop'
        ]].values

        # Entrenar y predecir
        predictions = self.detector.fit_predict(features)

        # Agregar columna de anomalía (-1 = anomalía, 1 = normal)
        metrics_data['is_anomaly'] = predictions
        metrics_data['anomaly_score'] = self.detector.score_samples(features)

        return metrics_data

    def get_anomalies(self, metrics_data):
        """Devolver solo registros anómalos"""
        detected = self.fit_and_detect(metrics_data)
        return detected[detected['is_anomaly'] == -1].sort_values(
            'anomaly_score'
        )

# Uso
detector = MetricsAnomalyDetector()
anomalies = detector.get_anomalies(daily_metrics_df)

for idx, row in anomalies.iterrows():
    print(f"Anomalía detectada el {row['date']}:")
    print(f"  - Duración de prueba: {row['test_duration']}s (usual: ~300s)")
    print(f"  - Tasa de fallos: {row['failure_rate']}% (usual: ~2%)")
    print(f"  - Puntaje de anomalía: {row['anomaly_score']:.3f}\n")

import openai
import json

class InsightGenerator:
    def __init__(self, api_key):
        openai.api_key = api_key

    def generate_insights(self, metrics_summary):
        """
        Generar insights en lenguaje natural a partir de métricas
        """
        prompt = f"""
        Analiza estas métricas QA y proporciona 3-5 insights accionables:

        Rendimiento de Suite de Pruebas:
        - Total de pruebas: {metrics_summary['total_tests']}
        - Tasa de éxito: {metrics_summary['pass_rate']}%
        - Duración promedio: {metrics_summary['avg_duration']}s
        - Pruebas inestables: {metrics_summary['flaky_tests']}

        Métricas de Defectos:
        - Bugs encontrados: {metrics_summary['bugs_found']}
        - Bugs críticos: {metrics_summary['critical_bugs']}
        - Tiempo promedio de resolución: {metrics_summary['avg_resolution_time']} días

        Calidad de Código:
        - Cobertura: {metrics_summary['coverage']}%
        - Rotación de código: {metrics_summary['code_churn']} líneas/día
        - Deuda técnica: {metrics_summary['tech_debt_hours']} horas

        Proporciona insights en este formato JSON:
        {{
            "insights": [
                {{"type": "warning|success|info", "title": "...", "description": "...", "action": "..."}}
            ],
            "overall_health_score": 0-100,
            "recommendations": ["...", "..."]
        }}
        """

        response = openai.ChatCompletion.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "Eres un analista de métricas QA."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3
        )

        return json.loads(response.choices[0].message.content)

    def format_for_dashboard(self, insights):
        """Formatear insights para visualización en dashboard"""
        dashboard_html = "<div class='insights-panel'>"

        for insight in insights['insights']:
            icon = {
                'warning': '⚠️',
                'success': '✅',
                'info': 'ℹ️'
            }.get(insight['type'], 'ℹ️')

            dashboard_html += f"""
            <div class='insight-card {insight["type"]}'>
                <h3>{icon} {insight['title']}</h3>
                <p>{insight['description']}</p>
                <div class='action'><strong>Acción:</strong> {insight['action']}</div>
            </div>
            """

        dashboard_html += f"""
        <div class='health-score'>
            <h2>Puntuación General de Salud: {insights['overall_health_score']}/100</h2>
        </div>
        </div>
        """

        return dashboard_html

# Uso
generator = InsightGenerator(api_key="tu-clave-api")
insights = generator.generate_insights(current_metrics)
dashboard_content = generator.format_for_dashboard(insights)

import plotly.graph_objects as go
from datetime import datetime, timedelta
import schedule
import time

class IntelligentDashboard:
    def __init__(self, data_source):
        self.data_source = data_source
        self.predictor = TestMetricPredictor()
        self.anomaly_detector = MetricsAnomalyDetector()
        self.insight_generator = InsightGenerator()

    def create_predictive_chart(self):
        """Crear gráfico con datos históricos y predicciones"""
        historical = self.data_source.get_last_30_days()
        predictions = self.predictor.predict_next_7_days(historical)

        fig = go.Figure()

        # Datos históricos
        fig.add_trace(go.Scatter(
            x=historical['date'],
            y=historical['failure_rate'],
            name='Tasa de Fallos Real',
            mode='lines+markers'
        ))

        # Datos predichos
        fig.add_trace(go.Scatter(
            x=predictions['date'],
            y=predictions['predicted_failure_rate'],
            name='Tasa de Fallos Predicha',
            mode='lines',
            line=dict(dash='dash', color='orange')
        ))

        # Intervalo de confianza
        fig.add_trace(go.Scatter(
            x=predictions['date'].tolist() + predictions['date'].tolist()[::-1],
            y=predictions['upper_bound'].tolist() + predictions['lower_bound'].tolist()[::-1],
            fill='toself',
            fillcolor='rgba(255,165,0,0.2)',
            line=dict(color='rgba(255,255,255,0)'),
            name='Intervalo de Confianza'
        ))

        return fig

    def create_anomaly_timeline(self):
        """Visualizar anomalías a lo largo del tiempo"""
        data = self.data_source.get_last_90_days()
        anomalies = self.anomaly_detector.get_anomalies(data)

        fig = go.Figure()

        # Métricas normales
        normal_data = data[data['is_anomaly'] == 1]
        fig.add_trace(go.Scatter(
            x=normal_data['date'],
            y=normal_data['test_duration'],
            mode='markers',
            name='Normal',
            marker=dict(color='green', size=6)
        ))

        # Anomalías
        fig.add_trace(go.Scatter(
            x=anomalies['date'],
            y=anomalies['test_duration'],
            mode='markers',
            name='Anomalía',
            marker=dict(color='red', size=12, symbol='x')
        ))

        return fig

    def auto_refresh(self):
        """Actualizar automáticamente el dashboard con nuevos insights"""
        def update_dashboard():
            print(f"[{datetime.now()}] Actualizando dashboard...")

            # Obtener datos más recientes
            latest_metrics = self.data_source.get_latest()

            # Generar insights
            insights = self.insight_generator.generate_insights(latest_metrics)

            # Verificar problemas críticos
            critical_insights = [i for i in insights['insights']
                               if i['type'] == 'warning']

            if critical_insights:
                self.send_alert(critical_insights)

            # Actualizar gráficos
            self.update_charts()

            print("Dashboard actualizado exitosamente")

        # Programar actualizaciones cada hora
        schedule.every(1).hours.do(update_dashboard)

        while True:
            schedule.run_pending()
            time.sleep(60)

    def send_alert(self, critical_insights):
        """Enviar alertas para problemas críticos"""
        # Integración con Slack, email, etc.
        pass

import seaborn as sns
import matplotlib.pyplot as plt
from scipy.stats import pearsonr

class CorrelationAnalyzer:
    def __init__(self, metrics_data):
        self.data = metrics_data

    def find_correlations(self, threshold=0.5):
        """Encontrar correlaciones significativas entre métricas"""
        metrics_cols = [
            'test_failures',
            'code_complexity',
            'team_velocity',
            'coverage',
            'deployment_frequency',
            'lead_time',
            'mttr'
        ]

        correlations = []

        for i, metric1 in enumerate(metrics_cols):
            for metric2 in metrics_cols[i+1:]:
                corr, p_value = pearsonr(
                    self.data[metric1],
                    self.data[metric2]
                )

                if abs(corr) >= threshold and p_value < 0.05:
                    correlations.append({
                        'metric1': metric1,
                        'metric2': metric2,
                        'correlation': corr,
                        'p_value': p_value,
                        'strength': self._interpret_correlation(corr)
                    })

        return sorted(correlations,
                     key=lambda x: abs(x['correlation']),
                     reverse=True)

    def _interpret_correlation(self, corr):
        """Interpretar la fuerza de correlación"""
        abs_corr = abs(corr)
        if abs_corr >= 0.7:
            return "Fuerte"
        elif abs_corr >= 0.5:
            return "Moderada"
        else:
            return "Débil"

    def create_correlation_matrix(self):
        """Generar matriz de correlación visual"""
        plt.figure(figsize=(12, 10))
        correlation_matrix = self.data.corr()

        sns.heatmap(
            correlation_matrix,
            annot=True,
            cmap='coolwarm',
            center=0,
            square=True,
            linewidths=1
        )

        plt.title('Matriz de Correlación de Métricas QA')
        return plt

from sklearn.ensemble import RandomForestClassifier
import numpy as np

class ReleaseReadinessPredictor:
    def __init__(self):
        self.model = RandomForestClassifier(n_estimators=100)

    def train(self, historical_releases):
        """
        Entrenar con datos históricos de releases
        Features: métricas de prueba antes del release
        Target: éxito del release (1) o fracaso (0)
        """
        features = historical_releases[[
            'test_pass_rate',
            'critical_bugs_open',
            'coverage_percentage',
            'average_test_duration',
            'flaky_test_count',
            'code_churn_last_week',
            'deployment_test_success_rate'
        ]].values

        targets = historical_releases['release_success'].values

        self.model.fit(features, targets)

    def predict_release_success(self, current_metrics):
        """Predecir si el release está listo"""
        features = np.array([[
            current_metrics['test_pass_rate'],
            current_metrics['critical_bugs_open'],
            current_metrics['coverage_percentage'],
            current_metrics['average_test_duration'],
            current_metrics['flaky_test_count'],
            current_metrics['code_churn_last_week'],
            current_metrics['deployment_test_success_rate']
        ]])

        probability = self.model.predict_proba(features)[0][1]
        prediction = self.model.predict(features)[0]

        # Obtener importancia de características
        importance = dict(zip(
            current_metrics.keys(),
            self.model.feature_importances_
        ))

        return {
            'ready_for_release': bool(prediction),
            'confidence': round(probability * 100, 2),
            'risk_factors': self._identify_risk_factors(
                current_metrics,
                importance
            )
        }

    def _identify_risk_factors(self, metrics, importance):
        """Identificar métricas que aumentan el riesgo"""
        risk_factors = []

        thresholds = {
            'test_pass_rate': 95,
            'critical_bugs_open': 0,
            'coverage_percentage': 80,
            'flaky_test_count': 5
        }

        for metric, threshold in thresholds.items():
            if metric in metrics:
                if metric in ['test_pass_rate', 'coverage_percentage']:
                    if metrics[metric] < threshold:
                        risk_factors.append({
                            'metric': metric,
                            'current': metrics[metric],
                            'threshold': threshold,
                            'importance': importance.get(metric, 0)
                        })
                else:
                    if metrics[metric] > threshold:
                        risk_factors.append({
                            'metric': metric,
                            'current': metrics[metric],
                            'threshold': threshold,
                            'importance': importance.get(metric, 0)
                        })

        return sorted(risk_factors,
                     key=lambda x: x['importance'],
                     reverse=True)

# Uso
predictor = ReleaseReadinessPredictor()
predictor.train(historical_releases_df)

current_state = {
    'test_pass_rate': 96.5,
    'critical_bugs_open': 2,
    'coverage_percentage': 82.3,
    'average_test_duration': 420,
    'flaky_test_count': 8,
    'code_churn_last_week': 1250,
    'deployment_test_success_rate': 94.0
}

result = predictor.predict_release_success(current_state)
print(f"Release Listo: {result['ready_for_release']}")
print(f"Confianza: {result['confidence']}%")
print(f"Factores de Riesgo: {len(result['risk_factors'])}")