Test Execution Log: Complete Guide to Documentation and Evidence Collection

{
  "executionId": "EXEC-20250108-001",
  "testCaseId": "TC-AUTH-015",
  "testCaseName": "User Login with Valid Credentials",
  "executionTime": {
    "start": "2025-01-08T10:30:00Z",
    "end": "2025-01-08T10:32:15Z",
    "duration": 135
  },
  "executor": {
    "name": "Sarah Johnson",
    "role": "QA Engineer",
    "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": "Navigate to login page",
      "expected": "Login form displayed",
      "actual": "Login form displayed correctly",
      "status": "PASSED",
      "screenshot": "step1_login_page.png"
    },
    {
      "stepNumber": 2,
      "description": "Enter username 'testuser@example.com'",
      "expected": "Username field populated",
      "actual": "Username field populated",
      "status": "PASSED"
    },
    {
      "stepNumber": 3,
      "description": "Enter password",
      "expected": "Password masked with dots",
      "actual": "Password masked with dots",
      "status": "PASSED"
    },
    {
      "stepNumber": 4,
      "description": "Click 'Sign In' button",
      "expected": "Redirect to dashboard within 2 seconds",
      "actual": "Redirected to dashboard in 1.3 seconds",
      "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": "Execution completed without issues. Performance within acceptable range."
}

# Selenium WebDriver screenshot example
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)

    # Ensure directory exists
    os.makedirs(os.path.dirname(filepath), exist_ok=True)

    # Capture full page screenshot
    driver.save_screenshot(filepath)

    # Log screenshot metadata
    metadata = {
        "filename": filename,
        "timestamp": timestamp,
        "viewport": driver.get_window_size(),
        "url": driver.current_url,
        "step": step_number
    }

    return filepath, metadata

# Usage in test
driver = webdriver.Chrome()
driver.get("https://example.com/login")
screenshot_path, metadata = capture_evidence_screenshot(
    driver, "EXEC-001", 1, "login_page"
)

# Pytest plugin for automatic video recording
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")

    # Enable video recording through browser capabilities
    chrome_options.set_capability("goog:loggingPrefs", {"performance": "ALL"})

    driver = webdriver.Chrome(options=chrome_options)

    # Start screen recording
    test_name = request.node.name
    video_path = f"evidence/videos/{test_name}.webm"

    yield driver

    # Save recording on test completion
    driver.quit()

    # Archive video with test result
    if request.node.rep_call.failed:
        # Keep video for failed tests
        print(f"Test failed - video saved: {video_path}")
    else:
        # Optional: delete passed test videos to save space
        pass

def test_checkout_process(video_recording_driver):
    driver = video_recording_driver
    # Test implementation
    pass

# Comprehensive log collection
def collect_execution_evidence(driver, execution_id):
    evidence = {
        "browser_console": [],
        "network_traffic": None,
        "performance_metrics": {}
    }

    # Collect browser console logs
    for entry in driver.get_log('browser'):
        evidence["browser_console"].append({
            "timestamp": entry['timestamp'],
            "level": entry['level'],
            "message": entry['message']
        })

    # Collect performance metrics
    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']
    }

    # Export network traffic (requires browser DevTools Protocol)
    # Using Chrome DevTools Protocol for HAR export
    evidence["network_traffic"] = export_network_har(driver)

    # Save evidence bundle
    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 version
    try:
        result = subprocess.run(
            ['google-chrome', '--version'],
            capture_output=True,
            text=True
        )
        versions['chrome'] = result.stdout.strip()
    except:
        versions['chrome'] = 'Not installed'

    # Firefox version
    try:
        result = subprocess.run(
            ['firefox', '--version'],
            capture_output=True,
            text=True
        )
        versions['firefox'] = result.stdout.strip()
    except:
        versions['firefox'] = 'Not installed'

    return versions

# Test Reproducibility Guide: EXEC-20250108-001

## Prerequisites
1. Environment: Staging (https://staging.app.com)
2. Build Version: v2.4.1-RC3
3. Test Data: User account testuser@example.com (password in vault)
4. Database State: Run seed script `db/seeds/auth_test_data.sql`

## Environment Setup
```bash
# Clone repository
git clone https://github.com/company/app.git
cd app
git checkout v2.4.1-RC3

# Install dependencies
npm install

# Configure environment
cp .env.staging .env
# Update DATABASE_URL in .env

# Seed test data
psql -U postgres -d app_staging -f db/seeds/auth_test_data.sql

# Remove test data
psql -U postgres -d app_staging -f db/seeds/cleanup_auth_test_data.sql

# Log retention and archival system
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):
        # Store in hot tier (database) for recent access
        self.db.insert('execution_logs', execution_log)

        # Also backup to S3 for durability
        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):
        # Move logs older than 30 days to warm tier
        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:
            # Transition to STANDARD_IA (warm tier)
            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'
            )

            # Remove from hot database
            self.db.delete('execution_logs', {'executionId': log['executionId']})

    def archive_compliance_logs(self):
        # Move logs older than 90 days to cold tier (Glacier)
        cutoff_date = datetime.now() - timedelta(days=90)

        # Transition to GLACIER for long-term retention
        lifecycle_policy = {
            'Rules': [{
                'Id': 'ArchiveOldLogs',
                'Status': 'Enabled',
                'Prefix': 'logs/',
                'Transitions': [{
                    'Days': 90,
                    'StorageClass': 'GLACIER'
                }],
                'Expiration': {
                    'Days': 2555  # 7 years for compliance
                }
            }]
        }

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