AI Test Metrics Analytics: Intelligent Analysis of QA Metrics

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, historical_data):
        """
        Train on historical test metrics
        historical_data: DataFrame with columns ['date', 'test_failures',
                         'code_complexity', 'team_velocity']
        """
        X = historical_data[['code_complexity', 'team_velocity']].values
        y = historical_data['test_failures'].values

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

    def predict_failures(self, code_complexity, team_velocity):
        """Predict expected test failures for next 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):
        """Convert prediction to risk score (0-100)"""
        risk = min((predicted_failures / threshold) * 100, 100)
        return round(risk, 2)

# Usage example
predictor = TestMetricPredictor()
predictor.train(historical_metrics_df)

# Predict for upcoming sprint
next_sprint_failures = predictor.predict_failures(
    code_complexity=245,
    team_velocity=32
)
risk_score = predictor.calculate_risk_score(next_sprint_failures)

print(f"Predicted failures: {next_sprint_failures:.1f}")
print(f"Risk score: {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):
        """
        Detect anomalies in test metrics
        metrics_data: DataFrame with normalized metrics
        """
        features = metrics_data[[
            'test_duration',
            'failure_rate',
            'flaky_test_percentage',
            'coverage_drop'
        ]].values

        # Train and predict
        predictions = self.detector.fit_predict(features)

        # Add anomaly column (-1 = anomaly, 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):
        """Return only anomalous records"""
        detected = self.fit_and_detect(metrics_data)
        return detected[detected['is_anomaly'] == -1].sort_values(
            'anomaly_score'
        )

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

for idx, row in anomalies.iterrows():
    print(f"Anomaly detected on {row['date']}:")
    print(f"  - Test duration: {row['test_duration']}s (usual: ~300s)")
    print(f"  - Failure rate: {row['failure_rate']}% (usual: ~2%)")
    print(f"  - Anomaly score: {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):
        """
        Generate natural language insights from metrics
        """
        prompt = f"""
        Analyze these QA metrics and provide 3-5 actionable insights:

        Test Suite Performance:
        - Total tests: {metrics_summary['total_tests']}
        - Pass rate: {metrics_summary['pass_rate']}%
        - Average duration: {metrics_summary['avg_duration']}s
        - Flaky tests: {metrics_summary['flaky_tests']}

        Defect Metrics:
        - Bugs found: {metrics_summary['bugs_found']}
        - Critical bugs: {metrics_summary['critical_bugs']}
        - Average resolution time: {metrics_summary['avg_resolution_time']} days

        Code Quality:
        - Coverage: {metrics_summary['coverage']}%
        - Code churn: {metrics_summary['code_churn']} lines/day
        - Technical debt: {metrics_summary['tech_debt_hours']} hours

        Provide insights in this JSON format:
        {{
            "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": "You are a QA metrics analyst."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3
        )

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

    def format_for_dashboard(self, insights):
        """Format insights for dashboard display"""
        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>Action:</strong> {insight['action']}</div>
            </div>
            """

        dashboard_html += f"""
        <div class='health-score'>
            <h2>Overall Health Score: {insights['overall_health_score']}/100</h2>
        </div>
        </div>
        """

        return dashboard_html

# Usage
generator = InsightGenerator(api_key="your-api-key")
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):
        """Create chart with historical data and predictions"""
        historical = self.data_source.get_last_30_days()
        predictions = self.predictor.predict_next_7_days(historical)

        fig = go.Figure()

        # Historical data
        fig.add_trace(go.Scatter(
            x=historical['date'],
            y=historical['failure_rate'],
            name='Actual Failure Rate',
            mode='lines+markers'
        ))

        # Predicted data
        fig.add_trace(go.Scatter(
            x=predictions['date'],
            y=predictions['predicted_failure_rate'],
            name='Predicted Failure Rate',
            mode='lines',
            line=dict(dash='dash', color='orange')
        ))

        # Confidence interval
        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='Confidence Interval'
        ))

        return fig

    def create_anomaly_timeline(self):
        """Visualize anomalies over time"""
        data = self.data_source.get_last_90_days()
        anomalies = self.anomaly_detector.get_anomalies(data)

        fig = go.Figure()

        # Normal metrics
        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)
        ))

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

        return fig

    def auto_refresh(self):
        """Automatically refresh dashboard with new insights"""
        def update_dashboard():
            print(f"[{datetime.now()}] Refreshing dashboard...")

            # Fetch latest data
            latest_metrics = self.data_source.get_latest()

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

            # Check for critical issues
            critical_insights = [i for i in insights['insights']
                               if i['type'] == 'warning']

            if critical_insights:
                self.send_alert(critical_insights)

            # Update charts
            self.update_charts()

            print("Dashboard updated successfully")

        # Schedule updates every hour
        schedule.every(1).hours.do(update_dashboard)

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

    def send_alert(self, critical_insights):
        """Send alerts for critical issues"""
        # Integration with 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):
        """Find significant correlations between metrics"""
        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):
        """Interpret correlation strength"""
        abs_corr = abs(corr)
        if abs_corr >= 0.7:
            return "Strong"
        elif abs_corr >= 0.5:
            return "Moderate"
        else:
            return "Weak"

    def create_correlation_matrix(self):
        """Generate visual correlation matrix"""
        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('QA Metrics Correlation Matrix')
        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):
        """
        Train on historical release data
        Features: test metrics before release
        Target: release success (1) or failure (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):
        """Predict if release is ready"""
        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]

        # Get feature importance
        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):
        """Identify metrics that increase risk"""
        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)

# Usage
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 Ready: {result['ready_for_release']}")
print(f"Confidence: {result['confidence']}%")
print(f"Risk Factors: {len(result['risk_factors'])}")