Registro de Ejecución de Pruebas: Guía Completa de Documentación y Recopilación de Evidencias

{
  "executionId": "EXEC-20250108-001",
  "testCaseId": "TC-AUTH-015",
  "testCaseName": "Inicio de Sesión de Usuario con Credenciales Válidas",
  "executionTime": {
    "start": "2025-01-08T10:30:00Z",
    "end": "2025-01-08T10:32:15Z",
    "duration": 135
  },
  "executor": {
    "name": "Sarah Johnson",
    "role": "Ingeniera 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": "Navegar a la página de inicio de sesión",
      "expected": "Formulario de inicio de sesión mostrado",
      "actual": "Formulario de inicio de sesión mostrado correctamente",
      "status": "PASSED",
      "screenshot": "step1_login_page.png"
    },
    {
      "stepNumber": 2,
      "description": "Ingresar nombre de usuario 'testuser@example.com'",
      "expected": "Campo de nombre de usuario poblado",
      "actual": "Campo de nombre de usuario poblado",
      "status": "PASSED"
    },
    {
      "stepNumber": 3,
      "description": "Ingresar contraseña",
      "expected": "Contraseña enmascarada con puntos",
      "actual": "Contraseña enmascarada con puntos",
      "status": "PASSED"
    },
    {
      "stepNumber": 4,
      "description": "Hacer clic en botón 'Iniciar Sesión'",
      "expected": "Redirección al panel en 2 segundos",
      "actual": "Redirigido al panel en 1.3 segundos",
      "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": "Ejecución completada sin problemas. Rendimiento dentro del rango aceptable."
}

# Ejemplo de captura de pantalla con 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)

    # Asegurar que el directorio existe
    os.makedirs(os.path.dirname(filepath), exist_ok=True)

    # Capturar captura de pantalla de página completa
    driver.save_screenshot(filepath)

    # Registrar metadatos de captura de pantalla
    metadata = {
        "filename": filename,
        "timestamp": timestamp,
        "viewport": driver.get_window_size(),
        "url": driver.current_url,
        "step": step_number
    }

    return filepath, metadata

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

# Plugin de Pytest para grabación de video automática
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")

    # Habilitar grabación de video a través de capacidades del navegador
    chrome_options.set_capability("goog:loggingPrefs", {"performance": "ALL"})

    driver = webdriver.Chrome(options=chrome_options)

    # Iniciar grabación de pantalla
    test_name = request.node.name
    video_path = f"evidence/videos/{test_name}.webm"

    yield driver

    # Guardar grabación al completar la prueba
    driver.quit()

    # Archivar video con resultado de prueba
    if request.node.rep_call.failed:
        # Mantener video para pruebas fallidas
        print(f"Prueba fallida - video guardado: {video_path}")
    else:
        # Opcional: eliminar videos de pruebas pasadas para ahorrar espacio
        pass

def test_checkout_process(video_recording_driver):
    driver = video_recording_driver
    # Implementación de prueba
    pass

# Recopilación completa de registros
def collect_execution_evidence(driver, execution_id):
    evidence = {
        "browser_console": [],
        "network_traffic": None,
        "performance_metrics": {}
    }

    # Recopilar registros de consola del navegador
    for entry in driver.get_log('browser'):
        evidence["browser_console"].append({
            "timestamp": entry['timestamp'],
            "level": entry['level'],
            "message": entry['message']
        })

    # Recopilar métricas de rendimiento
    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']
    }

    # Exportar tráfico de red (requiere Chrome DevTools Protocol)
    # Usando Chrome DevTools Protocol para exportación HAR
    evidence["network_traffic"] = export_network_har(driver)

    # Guardar paquete de evidencias
    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 = {}

    # Versión de Chrome
    try:
        result = subprocess.run(
            ['google-chrome', '--version'],
            capture_output=True,
            text=True
        )
        versions['chrome'] = result.stdout.strip()
    except:
        versions['chrome'] = 'No instalado'

    # Versión de Firefox
    try:
        result = subprocess.run(
            ['firefox', '--version'],
            capture_output=True,
            text=True
        )
        versions['firefox'] = result.stdout.strip()
    except:
        versions['firefox'] = 'No instalado'

    return versions

# Guía de Reproducibilidad de Prueba: EXEC-20250108-001

## Requisitos Previos
1. Entorno: Staging (https://staging.app.com)
2. Versión de Compilación: v2.4.1-RC3
3. Datos de Prueba: Cuenta de usuario testuser@example.com (contraseña en vault)
4. Estado de Base de Datos: Ejecutar script de poblamiento `db/seeds/auth_test_data.sql`

## Configuración del Entorno
```bash
# Clonar repositorio
git clone https://github.com/company/app.git
cd app
git checkout v2.4.1-RC3

# Instalar dependencias
npm install

# Configurar entorno
cp .env.staging .env
# Actualizar DATABASE_URL en .env

# Poblar datos de prueba
psql -U postgres -d app_staging -f db/seeds/auth_test_data.sql

# Eliminar datos de prueba
psql -U postgres -d app_staging -f db/seeds/cleanup_auth_test_data.sql

# Sistema de retención y archivo de registros
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):
        # Almacenar en nivel caliente (base de datos) para acceso reciente
        self.db.insert('execution_logs', execution_log)

        # También respaldar en S3 para durabilidad
        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):
        # Mover registros con más de 30 días a nivel templado
        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:
            # Transición a STANDARD_IA (nivel templado)
            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'
            )

            # Eliminar de base de datos caliente
            self.db.delete('execution_logs', {'executionId': log['executionId']})

    def archive_compliance_logs(self):
        # Mover registros con más de 90 días a nivel frío (Glacier)
        cutoff_date = datetime.now() - timedelta(days=90)

        # Transición a GLACIER para retención a largo plazo
        lifecycle_policy = {
            'Rules': [{
                'Id': 'ArchiveOldLogs',
                'Status': 'Enabled',
                'Prefix': 'logs/',
                'Transitions': [{
                    'Days': 90,
                    'StorageClass': 'GLACIER'
                }],
                'Expiration': {
                    'Days': 2555  # 7 años para cumplimiento
                }
            }]
        }

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