Аналитика Тестовых Метрик с ИИ: Интеллектуальный Анализ 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 (как обсуждается в [AI-powered Test Generation: The Future Is Already Here](/blog/ai-powered-test-generation)), historical_data):
        """
        Обучение на исторических тестовых метриках
        historical_data: DataFrame с колонками ['date', 'test_failures',
                         'code_complexity', 'team_velocity']
        """
        X = historical_data[['code_complexity', 'team_velocity']].values
        y = historical_data['test_failures'] (как обсуждается в [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 (как обсуждается в [AI-Powered Security Testing: Finding Vulnerabilities Faster](/blog/ai-security-testing)), code_complexity, team_velocity):
        """Предсказать ожидаемые падения тестов на следующий спринт"""
        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):
        """Преобразовать предсказание в оценку риска (0-100)"""
        risk = min((predicted_failures / threshold) * 100, 100)
        return round(risk, 2)

# Пример использования
predictor = TestMetricPredictor()
predictor.train(historical_metrics_df)

# Предсказание для следующего спринта
next_sprint_failures = predictor.predict_failures(
    code_complexity=245,
    team_velocity=32
)
risk_score = predictor.calculate_risk_score(next_sprint_failures)

print(f"Предсказанные падения: {next_sprint_failures:.1f}")
print(f"Оценка риска: {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):
        """
        Обнаружить аномалии в тестовых метриках
        metrics_data: DataFrame с нормализованными метриками
        """
        features = metrics_data[[
            'test_duration',
            'failure_rate',
            'flaky_test_percentage',
            'coverage_drop'
        ]].values

        # Обучение и предсказание
        predictions = self.detector.fit_predict(features)

        # Добавление колонки аномалии (-1 = аномалия, 1 = норма)
        metrics_data['is_anomaly'] = predictions
        metrics_data['anomaly_score'] = self.detector.score_samples(features)

        return metrics_data

    def get_anomalies(self, metrics_data):
        """Вернуть только аномальные записи"""
        detected = self.fit_and_detect(metrics_data)
        return detected[detected['is_anomaly'] == -1].sort_values(
            'anomaly_score'
        )

# Использование
detector = MetricsAnomalyDetector()
anomalies = detector.get_anomalies(daily_metrics_df)

for idx, row in anomalies.iterrows():
    print(f"Аномалия обнаружена {row['date']}:")
    print(f"  - Длительность теста: {row['test_duration']}с (обычно: ~300с)")
    print(f"  - Процент падений: {row['failure_rate']}% (обычно: ~2%)")
    print(f"  - Оценка аномалии: {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):
        """
        Генерация инсайтов на естественном языке из метрик
        """
        prompt = f"""
        Проанализируй эти QA-метрики и предоставь 3-5 действенных инсайтов:

        Производительность Тестового Набора:
        - Всего тестов: {metrics_summary['total_tests']}
        - Процент успеха: {metrics_summary['pass_rate']}%
        - Средняя длительность: {metrics_summary['avg_duration']}с
        - Нестабильные тесты: {metrics_summary['flaky_tests']}

        Метрики Дефектов:
        - Найдено багов: {metrics_summary['bugs_found']}
        - Критических багов: {metrics_summary['critical_bugs']}
        - Среднее время устранения: {metrics_summary['avg_resolution_time']} дней

        Качество Кода:
        - Покрытие: {metrics_summary['coverage']}%
        - Изменение кода: {metrics_summary['code_churn']} строк/день
        - Технический долг: {metrics_summary['tech_debt_hours']} часов

        Предоставь инсайты в этом 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": "Ты аналитик QA-метрик."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3
        )

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

    def format_for_dashboard(self, insights):
        """Форматирование инсайтов для отображения на дашборде"""
        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>Действие:</strong> {insight['action']}</div>
            </div>
            """

        dashboard_html += f"""
        <div class='health-score'>
            <h2>Общая Оценка Здоровья: {insights['overall_health_score']}/100</h2>
        </div>
        </div>
        """

        return dashboard_html

# Использование
generator = InsightGenerator(api_key="ваш-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):
        """Создание графика с историческими данными и предсказаниями"""
        historical = self.data_source.get_last_30_days()
        predictions = self.predictor.predict_next_7_days(historical)

        fig = go.Figure()

        # Исторические данные
        fig.add_trace(go.Scatter(
            x=historical['date'],
            y=historical['failure_rate'],
            name='Реальный Процент Падений',
            mode='lines+markers'
        ))

        # Предсказанные данные
        fig.add_trace(go.Scatter(
            x=predictions['date'],
            y=predictions['predicted_failure_rate'],
            name='Предсказанный Процент Падений',
            mode='lines',
            line=dict(dash='dash', color='orange')
        ))

        # Доверительный интервал
        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='Доверительный Интервал'
        ))

        return fig

    def create_anomaly_timeline(self):
        """Визуализация аномалий во времени"""
        data = self.data_source.get_last_90_days()
        anomalies = self.anomaly_detector.get_anomalies(data)

        fig = go.Figure()

        # Нормальные метрики
        normal_data = data[data['is_anomaly'] == 1]
        fig.add_trace(go.Scatter(
            x=normal_data['date'],
            y=normal_data['test_duration'],
            mode='markers',
            name='Норма',
            marker=dict(color='green', size=6)
        ))

        # Аномалии
        fig.add_trace(go.Scatter(
            x=anomalies['date'],
            y=anomalies['test_duration'],
            mode='markers',
            name='Аномалия',
            marker=dict(color='red', size=12, symbol='x')
        ))

        return fig

    def auto_refresh(self):
        """Автоматическое обновление дашборда с новыми инсайтами"""
        def update_dashboard():
            print(f"[{datetime.now()}] Обновление дашборда...")

            # Получение последних данных
            latest_metrics = self.data_source.get_latest()

            # Генерация инсайтов
            insights = self.insight_generator.generate_insights(latest_metrics)

            # Проверка критических проблем
            critical_insights = [i for i in insights['insights']
                               if i['type'] == 'warning']

            if critical_insights:
                self.send_alert(critical_insights)

            # Обновление графиков
            self.update_charts()

            print("Дашборд успешно обновлен")

        # Планирование обновлений каждый час
        schedule.every(1).hours.do(update_dashboard)

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

    def send_alert(self, critical_insights):
        """Отправка алертов для критических проблем"""
        # Интеграция со Slack, email и т.д.
        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):
        """Найти значимые корреляции между метриками"""
        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):
        """Интерпретировать силу корреляции"""
        abs_corr = abs(corr)
        if abs_corr >= 0.7:
            return "Сильная"
        elif abs_corr >= 0.5:
            return "Умеренная"
        else:
            return "Слабая"

    def create_correlation_matrix(self):
        """Генерация визуальной корреляционной матрицы"""
        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-Метрик')
        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):
        """
        Обучение на исторических данных релизов
        Features: тестовые метрики перед релизом
        Target: успех релиза (1) или провал (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):
        """Предсказать готовность к релизу"""
        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]

        # Получение важности признаков
        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):
        """Идентифицировать метрики, увеличивающие риск"""
        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)

# Использование
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"Релиз Готов: {result['ready_for_release']}")
print(f"Уверенность: {result['confidence']}%")
print(f"Факторы Риска: {len(result['risk_factors'])}")