Отчет о Покрытии Тестами: Полное Руководство по Анализу и Визуализации Покрытия

# Покрытие кода Python с pytest-cov
# Конфигурация pytest.ini
[pytest]
addopts = --cov=src --cov-report=html --cov-report=term --cov-report=xml

# Запуск тестов с покрытием
# pytest --cov=myapp tests/

# Пример теста с анализом покрытия
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()
        # Тестирует покрытие ветвей для многошаговых операций
        result = calc.calculate("(5 + 3) * 2")
        assert result == 16

// Конфигурация 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}'
  ]
};

// Пример теста с покрытием ветвей
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 () => {
    // Тестирование покрытия ветвей для логики безопасности
    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);
  });
});

# Анализатор покрытия требований
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': 'Не Покрыто',
            'priority': None
        })

        # Связать требования с тест-кейсами
        for req in self.requirements:
            req_id = req['id']
            coverage_map[req_id]['requirement'] = req['description']
            coverage_map[req_id]['priority'] = req['priority']

        # Связать тест-кейсы с требованиями
        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']
                    })

        # Определить статус покрытия
        for req_id, data in coverage_map.items():
            if not data['test_cases']:
                data['status'] = 'Не Покрыто'
            elif all(tc['status'] == 'PASSED' for tc in data['test_cases']):
                data['status'] = 'Покрыто'
            elif any(tc['status'] == 'FAILED' for tc in data['test_cases']):
                data['status'] = 'Провалено'
            else:
                data['status'] = 'Частично'

        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'] == 'Покрыто')
        partial_reqs = sum(1 for v in coverage.values() if v['status'] == 'Частично')
        not_covered_reqs = sum(1 for v in coverage.values() if v['status'] == 'Не Покрыто')

        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'] == 'Не Покрыто' and data['priority'] in ['Критический', 'Высокий']
            ]
        }

        return report

# Пример использования
analyzer = RequirementsCoverageAnalyzer('requirements.json', 'test_results.json')
coverage_report = analyzer.generate_report()

print(f"Покрытие Требований: {coverage_report['summary']['coverage_percentage']:.1f}%")
print(f"Критические/Высокие пробелы: {len(coverage_report['gaps'])}")

# Матрица покрытия рисков
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:
            # Найти тесты, адресующие этот риск
            mitigating_tests = [
                test for test in self.tests
                if risk['id'] in test.get('mitigates_risks', [])
            ]

            # Рассчитать оценку покрытия риска
            if not mitigating_tests:
                coverage_score = 0
                status = 'Не Покрыто'
            else:
                # Взвешивание по типу теста и статусу выполнения
                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
                )

                # Нормализовать к шкале 0-100
                coverage_score = min(100, total_weight * 50)

                if coverage_score >= 80:
                    status = 'Хорошо Покрыто'
                elif coverage_score >= 50:
                    status = 'Адекватно Покрыто'
                else:
                    status = 'Недостаточно Покрыто'

            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):
        """
        Выявить элементы высокого риска с недостаточным покрытием
        """
        gaps = [
            item for item in risk_coverage
            if item['risk_level'] in ['Критический', 'Высокий']
            and item['coverage_status'] in ['Не Покрыто', 'Недостаточно Покрыто']
        ]

        # Сортировать по оценке риска (наивысшие первыми)
        gaps.sort(key=lambda x: x['risk_score'], reverse=True)

        return gaps

# Пример использования
rcm = RiskCoverageMatrix(risks, test_cases)
coverage = rcm.analyze_risk_coverage()
gaps = rcm.identify_coverage_gaps(coverage)

print(f"Пробелы покрытия высокого риска: {len(gaps)}")
for gap in gaps[:5]:  # Топ-5 пробелов
    print(f"  {gap['risk_id']}: {gap['risk_title']} (Покрытие: {gap['coverage_score']:.0f}%)")

# Комплексный дашборд покрытия с 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=(
                'Обзор Покрытия Кода',
                'Статус Покрытия Требований',
                'Тренд Покрытия (Последние 30 Дней)',
                'Распределение Покрытия Рисков',
                'Критические Пробелы',
                'Покрытие по Модулям'
            ),
            specs=[
                [{'type': 'indicator'}, {'type': 'pie'}],
                [{'type': 'scatter'}, {'type': 'bar'}],
                [{'type': 'table'}, {'type': 'bar'}]
            ],
            row_heights=[0.3, 0.35, 0.35]
        )

        # 1. Индикатор покрытия кода
        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': "Общее Покрытие Кода"}
            ),
            row=1, col=1
        )

        # 2. Круговая диаграмма покрытия требований
        req_status = self.req_cov['summary']
        fig.add_trace(
            go.Pie(
                labels=['Покрыто', 'Частично', 'Не Покрыто'],
                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. Тренд покрытия
        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='Покрытие Кода',
                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='Покрытие Требований',
                line=dict(color='#28a745', width=3)
            ),
            row=2, col=1
        )

        # Добавить линию цели
        fig.add_hline(y=80, line_dash="dash", line_color="red",
                     annotation_text="Цель: 80%", row=2, col=1)

        # 4. Распределение покрытия рисков
        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. Таблица критических пробелов
        gaps = self._get_critical_gaps()
        fig.add_trace(
            go.Table(
                header=dict(
                    values=['Тип', 'ID', 'Описание', 'Приоритет'],
                    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. Покрытие по модулям
        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
        )

        # Обновить макет
        fig.update_layout(
            title_text="Дашборд Покрытия Тестами",
            showlegend=True,
            height=1200,
            hovermode='closest'
        )

        return fig

    def _get_color(self, coverage):
        if coverage >= 80:
            return "#28a745"  # Зеленый
        elif coverage >= 50:
            return "#ffc107"  # Желтый
        else:
            return "#dc3545"  # Красный

    def _get_critical_gaps(self):
        """Извлечь критические пробелы покрытия"""
        gaps = {
            'type': [],
            'id': [],
            'description': [],
            'priority': []
        }

        # Добавить пробелы требований
        for gap in self.req_cov.get('gaps', [])[:3]:
            gaps['type'].append('Требование')
            gaps['id'].append(gap['req_id'])
            gaps['description'].append(gap['description'][:50] + '...')
            gaps['priority'].append(gap['priority'])

        # Добавить пробелы рисков
        for item in self.risk_cov[:3]:
            if item['coverage_status'] == 'Не Покрыто':
                gaps['type'].append('Риск')
                gaps['id'].append(item['risk_id'])
                gaps['description'].append(item['risk_title'][:50] + '...')
                gaps['priority'].append(item['risk_level'])

        return gaps

# Генерировать дашборд
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()

# Тепловая карта покрытия для анализа на уровне модулей
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as np

def create_coverage_heatmap(coverage_data):
    """
    Создать тепловую карту, показывающую покрытие по модулям и типам покрытия
    """
    # Подготовить матрицу данных
    modules = list(coverage_data.keys())
    metrics = ['Операторы', 'Ветви', 'Функции', 'Строки']

    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)

    # Создать тепловую карту
    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': 'Покрытие %'}
    )

    plt.title('Тепловая Карта Покрытия Кода по Модулям', fontsize=16, fontweight='bold')
    plt.xlabel('Метрика Покрытия', fontsize=12)
    plt.ylabel('Модуль', fontsize=12)
    plt.tight_layout()

    return plt

# Пример использования
coverage_by_module = {
    'Аутентификация': {'statement': 92, 'branch': 85, 'function': 95, 'line': 90},
    'Платежи': {'statement': 88, 'branch': 80, 'function': 90, 'line': 87},
    'ПрофильПользователя': {'statement': 75, 'branch': 70, 'function': 80, 'line': 74},
    'Панель': {'statement': 65, 'branch': 60, 'function': 70, 'line': 64},
    'Отчеты': {'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')

# Расчет взвешенной оценки покрытия на основе критичности
class WeightedCoverageCalculator:
    def __init__(self, coverage_data, weights):
        self.coverage = coverage_data
        self.weights = weights

    def calculate_weighted_score(self):
        """
        Рассчитать общую оценку покрытия с взвешенными компонентами
        """
        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()
            }
        }

# Пример использования
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,  # Более высокий приоритет
    'risk_coverage': 2.5,  # Наивысший приоритет
    'api_coverage': 1.5,
    'ui_coverage': 1.0
}

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

print(f"Взвешенная Оценка Покрытия: {result['weighted_score']:.1f}%")
print("\nВклад Компонентов:")
for comp, details in result['components'].items():
    print(f"  {comp}: {details['coverage']:.1f}% × {details['weight']} = {details['contribution']:.1f}")

# GitHub Actions workflow для отчета о покрытии
name: Отчет о Покрытии Тестами

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

jobs:
  coverage:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Настроить Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Установить зависимости
        run: |
          pip install -r requirements.txt
          pip install pytest pytest-cov

      - name: Запустить тесты с покрытием
        run: |
          pytest --cov=src --cov-report=xml --cov-report=html --cov-report=term

      - name: Загрузить покрытие в Codecov
        uses: codecov/codecov-action@v3
        with:
          file: ./coverage.xml
          fail_ci_if_error: true

      - name: Комментарий покрытия
        uses: py-cov-action/python-coverage-comment-action@v3
        with:
          GITHUB_TOKEN: ${{ github.token }}
          MINIMUM_GREEN: 80
          MINIMUM_ORANGE: 70

      - name: Проверить порог покрытия
        run: |
          python scripts/check_coverage_threshold.py --threshold 80

      - name: Сгенерировать значок покрытия
        run: |
          coverage-badge -o coverage.svg -f

      - name: Архивировать артефакты покрытия
        uses: actions/upload-artifact@v3
        with:
          name: coverage-report
          path: htmlcov/

# Скрипт применения порогов покрытия
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 = []

        # Проверить общее покрытие
        overall = self.coverage_data['totals']['percent_covered']
        if overall < self.thresholds['overall']:
            violations.append({
                'type': 'Общее Покрытие',
                'actual': overall,
                'threshold': self.thresholds['overall'],
                'deficit': self.thresholds['overall'] - overall
            })

        # Проверить покрытие по файлам
        for file_path, data in self.coverage_data['files'].items():
            file_coverage = data['summary']['percent_covered']

            # Критические файлы имеют более строгие пороги
            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': 'Покрытие Файла',
                    '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("✅ Все пороги покрытия выполнены!")
            return True

        print("❌ Обнаружены нарушения порогов покрытия:\n")
        for v in violations:
            if v['type'] == 'Общее Покрытие':
                print(f"  Общее: {v['actual']:.1f}% (порог: {v['threshold']}%, дефицит: {v['deficit']:.1f}%)")
            else:
                print(f"  {v['file']}: {v['actual']:.1f}% (порог: {v['threshold']}%, дефицит: {v['deficit']:.1f}%)")

        return False

# Использование в 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)