Test Automation con Claude y GPT-4: Casos de Integración Reales e Implementación Práctica

import anthropic
import json
from typing import List, Dict

class ClaudeAPITestGenerator:
    def __init__(self, api_key: str):
        self.client = anthropic.Anthropic(api_key=api_key)

    def generate_api_tests(self, openapi_spec: Dict, endpoint: str) -> str:
        """Generar suite de pruebas pytest desde especificación OpenAPI"""

        prompt = f"""
        Eres un experto en automatización de pruebas de API. Genera una suite completa
        de pruebas pytest para el siguiente endpoint de esta especificación OpenAPI:

        Endpoint: {endpoint}
        Especificación OpenAPI completa: {json.dumps(openapi_spec, indent=2)}

        Genera pruebas que incluyan:

        1. Escenarios happy path con datos válidos
        2. Casos extremos (valores límite, strings vacíos, valores null)
        3. Escenarios de error (401, 403, 404, 422, 500)
        4. Pruebas de seguridad (SQL injection, XSS en parámetros)
        5. Validación de schema usando jsonschema
        6. Assertions de performance (tiempo de respuesta < 2s)

        Usa fixtures pytest para autenticación y datos de prueba reutilizables.
        Incluye docstrings detallados y assertions con mensajes de error significativos.
        """

        message = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=4000,
            messages=[{"role": "user", "content": prompt}]
        )

        return message.content[0].text

from openai import OpenAI
import json

class GPT4TestDataGenerator:
    def __init__(self, api_key: str):
        self.client = OpenAI(api_key=api_key)

    def generate_test_users(self, count: int, requirements: str) -> List[Dict]:
        """Generar datos de usuario de prueba realistas"""

        prompt = f"""
        Genera {count} registros de usuario de prueba realistas para plataforma e-commerce como array JSON.

        Requisitos:
        {requirements}

        Cada usuario debe tener:

        - id (formato UUID)
        - first_name, last_name (nacionalidades diversas, incluir casos extremos como O'Brien, María José)
        - email (formato válido, dominios variados)
        - phone (formatos internacionales: US, UK, India, Brasil)
        - address (incluir direcciones internacionales con formato apropiado)
        - birth_date (edades 18-85, formato ISO)
        - registration_date (dentro de últimos 2 años)
        - total_orders (0-500, peso hacia 1-10)
        - total_spent (0-50000, distribución realista)
        - account_status (active: 80%, suspended: 15%, closed: 5%)
        - preferences (preferencias de compra realistas aleatorias)

        Incluir casos extremos:

        - 5% con nombres muy largos (>50 caracteres)
        - 3% con caracteres Unicode especiales (Chino, Árabe, Emoji)
        - 2% con datos mínimos (recién registrados)

        Devolver solo array JSON válido, sin formato markdown.
        """

        response = self.client.chat.completions.create(
            model="gpt-4-turbo-preview",
            messages=[
                {"role": "system", "content": "Eres experto en generación de datos de prueba."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.8,
            max_tokens=4000
        )

        return json.loads(response.choices[0].message.content)

import anthropic
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException
import base64

class SelfHealingTestRunner:
    def __init__(self, claude_api_key: str):
        self.claude = anthropic.Anthropic(api_key=claude_api_key)
        self.driver = webdriver.Chrome()

    def find_element_with_healing(self, original_selector: str, element_description: str):
        """Intentar encontrar elemento, usar Claude para reparar si selector falla"""

        try:
            return self.driver.find_element(By.CSS_SELECTOR, original_selector)
        except NoSuchElementException:
            print(f"⚠️  Selector falló: {original_selector}")
            print(f"🔧 Intentando auto-reparación...")

            screenshot = self.driver.get_screenshot_as_base64()
            page_source = self.driver.page_source

            new_selector = self._heal_selector(
                original_selector,
                element_description,
                page_source,
                screenshot
            )

            print(f"✨ Selector reparado: {new_selector}")

            element = self.driver.find_element(By.CSS_SELECTOR, new_selector)
            self._log_heal_event(original_selector, new_selector, element_description)

            return element

    def _heal_selector(self, old_selector: str, description: str, html: str, screenshot: str) -> str:
        """Usar Claude para analizar página y sugerir nuevo selector"""

        prompt = f"""
        Un selector de prueba UI se ha roto. Analiza la página actual y sugiere un nuevo selector CSS.

        Selector original (roto): {old_selector}
        Descripción del elemento: {description}

        HTML de página actual (truncado):
        {html[:5000]}

        Tarea: Sugerir el selector CSS más robusto para el elemento que coincida: "{description}"

        Preferir selectores en este orden:

        1. Atributos data-testid
        2. Atributos aria-label
        3. Atributos ID estables
        4. Combinaciones de clases específicas
        5. XPath como último recurso

        Devolver SOLO la cadena del selector, sin explicación.
        """

        message = self.claude.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=200,
            messages=[
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": prompt},
                        {
                            "type": "image",
                            "source": {
                                "type": "base64",
                                "media_type": "image/png",
                                "data": screenshot
                            }
                        }
                    ]
                }
            ]
        )

        return message.content[0].text.strip()

# Después de 1 mes de uso
{
    "total_selector_failures": 127,
    "successful_auto_heals": 98,  # 77% tasa de éxito
    "manual_intervention_needed": 29,
    "time_saved": "~11 horas/semana",
    "maintenance_cost_reduction": "73%"
}

# Malo: Enviar contexto enorme cada vez
def generate_tests_bad(api_spec):  # 50K tokens
    response = claude.messages.create(
        model="claude-3-5-sonnet-20241022",
        messages=[{"role": "user", "content": f"Genera pruebas para {api_spec}"}]
    )
    # Costo: ~$0.60 por llamada

# Bueno: Usar prompt caching (Claude) o embeddings (GPT-4)
def generate_tests_good(api_spec):
    response = claude.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=2000,
        system=[
            {
                "type": "text",
                "text": "Eres experto en pruebas de API.",
                "cache_control": {"type": "ephemeral"}
            },
            {
                "type": "text",
                "text": f"Especificación OpenAPI:\n{api_spec}",
                "cache_control": {"type": "ephemeral"}
            }
        ],
        messages=[{"role": "user", "content": "Genera pruebas para endpoint POST /users"}]
    )
    # Costo: ~$0.06 por llamada (90% ahorro en porción cacheada)