Documentación de Frameworks de Automatización de Pruebas: Guía Completa

Arquitectura del Framework:
  Capa de Presentación:
    - Informes de Pruebas (HTML/JSON)
    - Integración de Dashboard
    - Retroalimentación CI/CD

  Capa de Pruebas:
    - Escenarios de Prueba
    - Suites de Prueba
    - Pruebas Basadas en Datos

  Capa de Negocio:
    - Page Objects
    - Componentes de Lógica de Negocio
    - Wrappers de Servicios

  Capa Core del Framework:
    - Gestor de WebDriver
    - Manejador de Configuración
    - Servicio de Logger
    - Conector de Base de Datos
    - Cliente API

  Capa de Infraestructura:
    - Repositorio de Datos de Prueba
    - Configuración de Entorno
    - Pipeline CI/CD
    - Control de Versiones

# Ejemplo: Interacción de Componentes del Framework
class TestFrameworkCore:
    """
    Orquestador central del framework que gestiona las interacciones de componentes.

    Dependencias de Componentes:
    - ConfigManager: Carga configuraciones específicas del entorno
    - DriverFactory: Crea y gestiona instancias del navegador
    - LoggerService: Logging centralizado
    - ReportGenerator: Informes de ejecución de pruebas
    """

    def __init__(self):
        self.config = ConfigManager()
        self.driver_factory = DriverFactory(self.config)
        self.logger = LoggerService()
        self.reporter = ReportGenerator()

    def initialize_test_environment(self, env='staging'):
        """
        Inicializa el entorno de pruebas completo.

        Args:
            env (str): Entorno objetivo (dev/staging/prod)

        Returns:
            dict: Componentes inicializados
        """
        self.logger.info(f"Inicializando framework para {env}")
        driver = self.driver_factory.create_driver()
        test_data = self.config.load_test_data(env)

        return {
            'driver': driver,
            'config': self.config,
            'data': test_data,
            'logger': self.logger
        }

# Patrón Base de Page Object
class BasePage:
    """
    Page object base que proporciona funcionalidad común.

    Todos los page objects heredan de esta clase para garantizar
    implementación consistente de métodos centrales.
    """

    def __init__(self, driver):
        self.driver = driver
        self.wait = WebDriverWait(driver, 10)
        self.logger = LoggerService()

    def find_element(self, locator):
        """
        Buscador inteligente de elementos con espera automática.

        Args:
            locator (tuple): Estrategia de localización (By.ID, 'element_id')

        Returns:
            WebElement: Elemento encontrado
        """
        self.logger.debug(f"Buscando elemento: {locator}")
        return self.wait.until(EC.presence_of_element_located(locator))

    def click_element(self, locator):
        """Click en elemento con espera de clickabilidad."""
        element = self.wait.until(EC.element_to_be_clickable(locator))
        self.logger.info(f"Haciendo click: {locator}")
        element.click()

# Page Object Específico
class LoginPage(BasePage):
    """
    Page object de página de login representando interfaz de autenticación.

    Localizadores:
        - USERNAME_FIELD: Campo de entrada de nombre de usuario
        - PASSWORD_FIELD: Campo de entrada de contraseña
        - LOGIN_BUTTON: Botón de envío
    """

    # Localizadores
    USERNAME_FIELD = (By.ID, "username")
    PASSWORD_FIELD = (By.ID, "password")
    LOGIN_BUTTON = (By.XPATH, "//button[@type='submit']")
    ERROR_MESSAGE = (By.CLASS_NAME, "error-message")

    def login(self, username, password):
        """
        Realiza operación de login.

        Args:
            username (str): Credenciales de usuario
            password (str): Contraseña de usuario

        Returns:
            bool: Estado de éxito del login
        """
        self.find_element(self.USERNAME_FIELD).send_keys(username)
        self.find_element(self.PASSWORD_FIELD).send_keys(password)
        self.click_element(self.LOGIN_BUTTON)

        return self.is_login_successful()

    def is_login_successful(self):
        """Verifica login exitoso comprobando cambio de URL."""
        return "dashboard" in self.driver.current_url

class DriverFactory:
    """
    Patrón factory para creación de drivers de navegador.

    Soporta múltiples navegadores con configuración consistente
    y manejo automático de limpieza.
    """

    BROWSER_CONFIG = {
        'chrome': {
            'options': ['--start-maximized', '--disable-extensions'],
            'capabilities': {'browserName': 'chrome'}
        },
        'firefox': {
            'options': ['-private'],
            'capabilities': {'browserName': 'firefox'}
        },
        'headless': {
            'options': ['--headless', '--no-sandbox'],
            'capabilities': {'browserName': 'chrome'}
        }
    }

    @staticmethod
    def create_driver(browser='chrome', remote=False):
        """
        Crea instancia de driver de navegador.

        Args:
            browser (str): Tipo de navegador (chrome/firefox/headless)
            remote (bool): Usar Selenium Grid si es True

        Returns:
            WebDriver: Instancia de driver configurado
        """
        if remote:
            return DriverFactory._create_remote_driver(browser)
        return DriverFactory._create_local_driver(browser)

    @staticmethod
    def _create_local_driver(browser):
        """Crea driver de navegador local."""
        config = DriverFactory.BROWSER_CONFIG[browser]

        if browser in ['chrome', 'headless']:
            options = ChromeOptions()
            for opt in config['options']:
                options.add_argument(opt)
            return webdriver.Chrome(options=options)

        elif browser == 'firefox':
            options = FirefoxOptions()
            for opt in config['options']:
                options.add_argument(opt)
            return webdriver.Firefox(options=options)

# config/environments.yaml
environments:
  development:
    base_url: "https://dev.example.com"
    api_url: "https://api-dev.example.com"
    database:
      host: "dev-db.example.com"
      port: 5432
      name: "test_db"
    timeout: 10
    implicit_wait: 5

  staging:
    base_url: "https://staging.example.com"
    api_url: "https://api-staging.example.com"
    database:
      host: "staging-db.example.com"
      port: 5432
      name: "staging_db"
    timeout: 15
    implicit_wait: 10

  production:
    base_url: "https://example.com"
    api_url: "https://api.example.com"
    # Acceso a base de datos restringido en producción
    timeout: 20
    implicit_wait: 10

browser_settings:
  default_browser: "chrome"
  headless: false
  window_size: "1920x1080"
  screenshot_on_failure: true

logging:
  level: "INFO"
  format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
  file_path: "logs/test_execution.log"

class ConfigManager:
    """
    Gestión centralizada de configuración.

    Carga configuraciones específicas del entorno desde archivos YAML
    y proporciona acceso a valores de configuración.
    """

    def __init__(self, config_file='config/environments.yaml'):
        self.config_file = config_file
        self.config = self._load_config()
        self.environment = os.getenv('TEST_ENV', 'staging')

    def _load_config(self):
        """Carga configuración desde archivo YAML."""
        with open(self.config_file, 'r') as file:
            return yaml.safe_load(file)

    def get(self, key, default=None):
        """
        Recupera valor de configuración para el entorno actual.

        Args:
            key (str): Clave de configuración (soporta notación de punto)
            default: Valor por defecto si no se encuentra la clave

        Returns:
            Valor de configuración

        Ejemplo:
            config.get('database.host')  # Devuelve el host de DB
        """
        env_config = self.config['environments'][self.environment]

        # Soporta claves anidadas con notación de punto
        keys = key.split('.')
        value = env_config

        for k in keys:
            if isinstance(value, dict):
                value = value.get(k)
            else:
                return default

        return value if value is not None else default

# Guía de Configuración del Framework

## Prerequisitos

### Requisitos del Sistema
- Python 3.8 o superior
- pip (gestor de paquetes Python)
- Git para control de versiones
- 4GB RAM mínimo (8GB recomendado)
- 10GB de espacio libre en disco

### Software Requerido
1. **Dependencias de Python**
   ```bash
   pip install -r requirements.txt

git clone https://github.com/yourcompany/test-framework.git
cd test-framework

python -m venv venv
source venv/bin/activate  # En Windows: venv\Scripts\activate

pip install -r requirements.txt

cp config/environments.yaml.example config/environments.yaml
# Editar environments.yaml con sus configuraciones

pytest tests/smoke/ --html=report.html

export TEST_ENV=staging          # Entorno objetivo
export BROWSER=chrome            # Selección de navegador
export HEADLESS=true             # Modo headless
export REPORT_PATH=./reports     # Directorio de salida de informes

# Ejecutar prueba individual
pytest tests/login_test.py

# Ejecutar con marcadores específicos
pytest -m smoke

# Ejecutar con cobertura
pytest --cov=framework tests/

class TestReportGenerator:
    """
    Genera informes completos de ejecución de pruebas.

    Soporta múltiples formatos de salida:
    - HTML con capturas de pantalla
    - JSON para integración CI/CD
    - JUnit XML para Jenkins
    """

    def __init__(self, output_dir='reports'):
        self.output_dir = output_dir
        self.results = []
        self.start_time = None
        self.end_time = None

    def add_test_result(self, test_name, status, duration,
                       screenshot=None, error=None):
        """
        Agrega resultado de prueba al informe.

        Args:
            test_name (str): Identificador de prueba
            status (str): passed/failed/skipped
            duration (float): Tiempo de ejecución en segundos
            screenshot (str): Ruta a captura de pantalla si está disponible
            error (str): Mensaje de error si falló
        """
        result = {
            'name': test_name,
            'status': status,
            'duration': duration,
            'timestamp': datetime.now().isoformat(),
            'screenshot': screenshot,
            'error': error
        }
        self.results.append(result)

    def generate_html_report(self):
        """Genera informe HTML con estadísticas."""
        total = len(self.results)
        passed = sum(1 for r in self.results if r['status'] == 'passed')
        failed = sum(1 for r in self.results if r['status'] == 'failed')

        html_content = f"""
        <html>
        <head>
            <title>Informe de Ejecución de Pruebas</title>
            <style>
                body {{ font-family: Arial, sans-serif; margin: 20px; }}
                .summary {{ background: #f0f0f0; padding: 15px; }}
                .passed {{ color: green; }}
                .failed {{ color: red; }}
                table {{ width: 100%; border-collapse: collapse; }}
                th, td {{ border: 1px solid #ddd; padding: 8px; }}
            </style>
        </head>
        <body>
            <h1>Informe de Ejecución de Pruebas</h1>
            <div class="summary">
                <h2>Resumen</h2>
                <p>Total de Pruebas: {total}</p>
                <p class="passed">Pasadas: {passed}</p>
                <p class="failed">Fallidas: {failed}</p>
                <p>Tasa de Éxito: {(passed/total*100):.2f}%</p>
            </div>

            <h2>Resultados de Pruebas</h2>
            <table>
                <tr>
                    <th>Nombre de Prueba</th>
                    <th>Estado</th>
                    <th>Duración</th>
                    <th>Captura de Pantalla</th>
                </tr>
                {self._generate_table_rows()}
            </table>
        </body>
        </html>
        """

        report_path = os.path.join(self.output_dir, 'report.html')
        with open(report_path, 'w') as file:
            file.write(html_content)

        return report_path

# Estructura de requirements.txt
selenium==4.15.0              # Core WebDriver
pytest==7.4.3                 # Framework de testing
pytest-html==4.1.1            # Informes HTML
pytest-xdist==3.5.0          # Ejecución paralela
requests==2.31.0              # Testing API
PyYAML==6.0.1                # Gestión de configuración
webdriver-manager==4.0.1      # Gestión automática de drivers
allure-pytest==2.13.2        # Informes avanzados
python-dotenv==1.0.0         # Variables de entorno

# Dependencias de desarrollo
pytest-cov==4.1.0            # Cobertura de código
black==23.12.0               # Formateo de código
flake8==6.1.0                # Linting
mypy==1.7.1                  # Verificación de tipos

## Lista de Verificación Semanal de Mantenimiento

- [ ] Actualizar drivers de navegador a últimas versiones
- [ ] Revisar y mergear pull requests de dependabot
- [ ] Verificar salud del pipeline CI/CD
- [ ] Revisar tendencias de pruebas fallidas
- [ ] Actualizar datos de prueba si es necesario

## Tareas de Mantenimiento Mensual

- [ ] Auditoría de seguridad de dependencias (`pip audit`)
- [ ] Análisis de rendimiento de ejecución de pruebas
- [ ] Revisar y refactorizar pruebas inestables
- [ ] Actualizar documentación del framework
- [ ] Limpiar informes y logs antiguos
- [ ] Planificación de release de versión del framework

## Revisiones Trimestrales

- [ ] Revisión de arquitectura para escalabilidad
- [ ] Capacitación del equipo en nuevas características
- [ ] Evaluación del stack tecnológico
- [ ] Análisis de cobertura de pruebas
- [ ] Planificación de roadmap del framework

class FrameworkDiagnostics:
    """
    Utilidades de diagnóstico para resolución de problemas del framework.

    Ayuda a identificar y resolver problemas comunes del framework.
    """

    @staticmethod
    def check_driver_compatibility():
        """Verifica compatibilidad de navegador y driver."""
        checks = {
            'chrome_installed': False,
            'chromedriver_version': None,
            'selenium_version': None,
            'python_version': sys.version
        }

        try:
            driver = webdriver.Chrome()
            checks['chrome_installed'] = True
            checks['chromedriver_version'] = driver.capabilities['chrome']['chromedriverVersion']
            driver.quit()
        except Exception as e:
            checks['error'] = str(e)

        checks['selenium_version'] = selenium.__version__

        return checks

    @staticmethod
    def validate_configuration():
        """Valida configuración del framework."""
        config = ConfigManager()

        required_keys = [
            'base_url',
            'timeout',
            'browser_settings.default_browser'
        ]

        issues = []
        for key in required_keys:
            if config.get(key) is None:
                issues.append(f"Configuración faltante: {key}")

        return {
            'valid': len(issues) == 0,
            'issues': issues
        }

pipeline {
    agent any

    environment {
        TEST_ENV = 'staging'
        BROWSER = 'headless'
        REPORT_PATH = 'reports'
    }

    stages {
        stage('Setup') {
            steps {
                sh 'python -m venv venv'
                sh '. venv/bin/activate && pip install -r requirements.txt'
            }
        }

        stage('Run Tests') {
            steps {
                sh '''
                    . venv/bin/activate
                    pytest tests/ \
                        --junitxml=results.xml \
                        --html=report.html \
                        --self-contained-html
                '''
            }
        }

        stage('Publish Results') {
            steps {
                junit 'results.xml'
                publishHTML([
                    reportDir: '.',
                    reportFiles: 'report.html',
                    reportName: 'Test Report'
                ])
            }
        }
    }

    post {
        always {
            cleanWs()
        }
    }
}