Журнал Выполнения Тестов: Полное Руководство по Документированию и Сбору Доказательств

{
  "executionId": "EXEC-20250108-001",
  "testCaseId": "TC-AUTH-015",
  "testCaseName": "Вход Пользователя с Валидными Учетными Данными",
  "executionTime": {
    "start": "2025-01-08T10:30:00Z",
    "end": "2025-01-08T10:32:15Z",
    "duration": 135
  },
  "executor": {
    "name": "Сара Джонсон",
    "role": "QA Инженер",
    "id": "sjohnson@company.com"
  },
  "environment": {
    "name": "Staging",
    "url": "https://staging.app.com",
    "buildVersion": "v2.4.1-RC3",
    "os": "Windows 11 Pro",
    "browser": "Chrome 120.0.6099.109"
  },
  "status": "PASSED",
  "steps": [
    {
      "stepNumber": 1,
      "description": "Перейти на страницу входа",
      "expected": "Форма входа отображена",
      "actual": "Форма входа отображена корректно",
      "status": "PASSED",
      "screenshot": "step1_login_page.png"
    },
    {
      "stepNumber": 2,
      "description": "Ввести имя пользователя 'testuser@example.com'",
      "expected": "Поле имени пользователя заполнено",
      "actual": "Поле имени пользователя заполнено",
      "status": "PASSED"
    },
    {
      "stepNumber": 3,
      "description": "Ввести пароль",
      "expected": "Пароль замаскирован точками",
      "actual": "Пароль замаскирован точками",
      "status": "PASSED"
    },
    {
      "stepNumber": 4,
      "description": "Нажать кнопку 'Войти'",
      "expected": "Перенаправление на панель управления в течение 2 секунд",
      "actual": "Перенаправлен на панель управления за 1.3 секунды",
      "status": "PASSED",
      "screenshot": "step4_dashboard.png",
      "performanceMetric": 1.3
    }
  ],
  "evidence": {
    "screenshots": ["step1_login_page.png", "step4_dashboard.png"],
    "videos": ["full_execution.mp4"],
    "logs": ["browser_console.log", "network_traffic.har"]
  },
  "notes": "Выполнение завершено без проблем. Производительность в пределах допустимого диапазона."
}

# Пример скриншота с Selenium WebDriver
from selenium import webdriver
from datetime import datetime
import os

def capture_evidence_screenshot(driver, execution_id, step_number, description):
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"{execution_id}_step{step_number}_{description}_{timestamp}.png"
    filepath = os.path.join("evidence", "screenshots", filename)

    # Убедиться, что директория существует
    os.makedirs(os.path.dirname(filepath), exist_ok=True)

    # Захватить полностраничный скриншот
    driver.save_screenshot(filepath)

    # Записать метаданные скриншота
    metadata = {
        "filename": filename,
        "timestamp": timestamp,
        "viewport": driver.get_window_size(),
        "url": driver.current_url,
        "step": step_number
    }

    return filepath, metadata

# Использование в тесте
driver = webdriver.Chrome()
driver.get("https://example.com/login")
screenshot_path, metadata = capture_evidence_screenshot(
    driver, "EXEC-001", 1, "login_page"
)

# Плагин Pytest для автоматической видеозаписи
import pytest
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

@pytest.fixture
def video_recording_driver(request):
    chrome_options = Options()
    chrome_options.add_argument("--disable-dev-shm-usage")

    # Включить видеозапись через возможности браузера
    chrome_options.set_capability("goog:loggingPrefs", {"performance": "ALL"})

    driver = webdriver.Chrome(options=chrome_options)

    # Начать запись экрана
    test_name = request.node.name
    video_path = f"evidence/videos/{test_name}.webm"

    yield driver

    # Сохранить запись при завершении теста
    driver.quit()

    # Архивировать видео с результатом теста
    if request.node.rep_call.failed:
        # Сохранить видео для неудачных тестов
        print(f"Тест провален - видео сохранено: {video_path}")
    else:
        # Опционально: удалить видео успешных тестов для экономии места
        pass

def test_checkout_process(video_recording_driver):
    driver = video_recording_driver
    # Реализация теста
    pass

# Комплексный сбор логов
def collect_execution_evidence(driver, execution_id):
    evidence = {
        "browser_console": [],
        "network_traffic": None,
        "performance_metrics": {}
    }

    # Собрать логи консоли браузера
    for entry in driver.get_log('browser'):
        evidence["browser_console"].append({
            "timestamp": entry['timestamp'],
            "level": entry['level'],
            "message": entry['message']
        })

    # Собрать метрики производительности
    navigation_timing = driver.execute_script(
        "return window.performance.timing"
    )
    evidence["performance_metrics"] = {
        "page_load_time": navigation_timing['loadEventEnd'] - navigation_timing['navigationStart'],
        "dom_content_loaded": navigation_timing['domContentLoadedEventEnd'] - navigation_timing['navigationStart'],
        "first_paint": navigation_timing['responseStart'] - navigation_timing['navigationStart']
    }

    # Экспортировать сетевой трафик (требуется Chrome DevTools Protocol)
    # Использование Chrome DevTools Protocol для экспорта HAR
    evidence["network_traffic"] = export_network_har(driver)

    # Сохранить пакет доказательств
    evidence_path = f"evidence/{execution_id}/logs.json"
    with open(evidence_path, 'w') as f:
        json.dump(evidence, f, indent=2)

    return evidence

import platform
import psutil
import subprocess

def capture_environment_details():
    env_details = {
        "system": {
            "os": platform.system(),
            "os_version": platform.version(),
            "architecture": platform.machine(),
            "processor": platform.processor(),
            "python_version": platform.python_version()
        },
        "hardware": {
            "cpu_cores": psutil.cpu_count(logical=False),
            "cpu_threads": psutil.cpu_count(logical=True),
            "memory_total_gb": round(psutil.virtual_memory().total / (1024**3), 2),
            "memory_available_gb": round(psutil.virtual_memory().available / (1024**3), 2)
        },
        "network": {
            "hostname": platform.node(),
            "ip_addresses": get_ip_addresses()
        },
        "dependencies": get_installed_packages(),
        "browser_versions": get_browser_versions()
    }

    return env_details

def get_browser_versions():
    versions = {}

    # Версия Chrome
    try:
        result = subprocess.run(
            ['google-chrome', '--version'],
            capture_output=True,
            text=True
        )
        versions['chrome'] = result.stdout.strip()
    except:
        versions['chrome'] = 'Не установлен'

    # Версия Firefox
    try:
        result = subprocess.run(
            ['firefox', '--version'],
            capture_output=True,
            text=True
        )
        versions['firefox'] = result.stdout.strip()
    except:
        versions['firefox'] = 'Не установлен'

    return versions

# Руководство по Воспроизводимости Теста: EXEC-20250108-001

## Предварительные Требования
1. Окружение: Staging (https://staging.app.com)
2. Версия Сборки: v2.4.1-RC3
3. Тестовые Данные: Аккаунт пользователя testuser@example.com (пароль в vault)
4. Состояние БД: Запустить скрипт заполнения `db/seeds/auth_test_data.sql`

## Настройка Окружения
```bash
# Клонировать репозиторий
git clone https://github.com/company/app.git
cd app
git checkout v2.4.1-RC3

# Установить зависимости
npm install

# Настроить окружение
cp .env.staging .env
# Обновить DATABASE_URL в .env

# Заполнить тестовые данные
psql -U postgres -d app_staging -f db/seeds/auth_test_data.sql

# Удалить тестовые данные
psql -U postgres -d app_staging -f db/seeds/cleanup_auth_test_data.sql

# Система сохранения и архивирования логов
from datetime import datetime, timedelta
import boto3
import json

class ExecutionLogManager:
    def __init__(self):
        self.db = DatabaseConnection()
        self.s3 = boto3.client('s3')
        self.bucket = 'test-execution-logs'

    def store_execution_log(self, execution_log):
        # Сохранить в горячий уровень (база данных) для недавнего доступа
        self.db.insert('execution_logs', execution_log)

        # Также резервное копирование в S3 для надежности
        s3_key = f"logs/{execution_log['executionId']}.json"
        self.s3.put_object(
            Bucket=self.bucket,
            Key=s3_key,
            Body=json.dumps(execution_log),
            StorageClass='STANDARD'
        )

    def archive_old_logs(self):
        # Переместить логи старше 30 дней на теплый уровень
        cutoff_date = datetime.now() - timedelta(days=30)
        old_logs = self.db.query(
            'SELECT * FROM execution_logs WHERE execution_time < %s',
            (cutoff_date,)
        )

        for log in old_logs:
            # Переход на STANDARD_IA (теплый уровень)
            s3_key = f"logs/{log['executionId']}.json"
            self.s3.copy_object(
                Bucket=self.bucket,
                CopySource={'Bucket': self.bucket, 'Key': s3_key},
                Key=s3_key,
                StorageClass='STANDARD_IA'
            )

            # Удалить из горячей базы данных
            self.db.delete('execution_logs', {'executionId': log['executionId']})

    def archive_compliance_logs(self):
        # Переместить логи старше 90 дней на холодный уровень (Glacier)
        cutoff_date = datetime.now() - timedelta(days=90)

        # Переход на GLACIER для долгосрочного хранения
        lifecycle_policy = {
            'Rules': [{
                'Id': 'ArchiveOldLogs',
                'Status': 'Enabled',
                'Prefix': 'logs/',
                'Transitions': [{
                    'Days': 90,
                    'StorageClass': 'GLACIER'
                }],
                'Expiration': {
                    'Days': 2555  # 7 лет для compliance
                }
            }]
        }

        self.s3.put_bucket_lifecycle_configuration(
            Bucket=self.bucket,
            LifecycleConfiguration=lifecycle_policy
        )