Тест-автоматизация с Claude и GPT-4: Реальные кейсы интеграции и практическая реализация

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:
        """Генерация pytest (как обсуждается в [Voice Interface Testing: QA for the Conversational Era](/blog/voice-interface-testing)) test suite из OpenAPI спецификации"""

        prompt = f"""
        Ты эксперт в автоматизации API-тестирования. Сгенерируй комплексную
        pytest test suite для следующего эндпоинта из этой OpenAPI спецификации:

        Эндпоинт: {endpoint}
        Полная OpenAPI спецификация: {json.dumps(openapi_spec, indent=2)}

        Сгенерируй тесты, включающие:
        1. Happy path сценарии с валидными данными
        2. Граничные случаи (boundary values, пустые строки, null значения)
        3. Сценарии ошибок (401, 403, 404, 422, 500)
        4. Тесты безопасности (SQL (как обсуждается в [AI-Powered Security Testing: Finding Vulnerabilities Faster](/blog/ai-security-testing)) injection, XSS в параметрах)
        5. Валидация схемы с использованием jsonschema
        6. Performance assertions (время ответа < 2s)

        Используй pytest fixtures для аутентификации и переиспользуемых тестовых данных.
        Включи детальные docstrings и assertions с понятными сообщениями об ошибках.
        """

        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]:
        """Генерация реалистичных данных тестовых пользователей"""

        prompt = f"""
        Сгенерируй {count} реалистичных записей тестовых пользователей для e-commerce платформы в формате JSON array.

        Требования:
        {requirements}

        Каждый пользователь должен иметь:
        - id (формат UUID)
        - first_name, last_name (разные национальности, включить граничные случаи типа O'Brien, María José)
        - email (валидный формат, разные домены)
        - phone (международные форматы: US, UK, Индия, Бразилия)
        - address (включить международные адреса с правильным форматированием)
        - birth_date (возраст 18-85, ISO формат)
        - registration_date (в пределах последних 2 лет)
        - total_orders (0-500, вес к 1-10)
        - total_spent (0-50000, реалистичное распределение)
        - account_status (active: 80%, suspended: 15%, closed: 5%)
        - preferences (случайные реалистичные покупательские предпочтения)

        Включить граничные случаи:
        - 5% с очень длинными именами (>50 символов)
        - 3% со специальными Unicode символами (Китайский, Арабский, Emoji)
        - 2% с минимальными данными (только что зарегистрированные)

        Вернуть только валидный JSON array, без markdown форматирования.
        """

        response = self.client.chat.completions.create(
            model="gpt-4-turbo-preview",
            messages=[
                {"role": "system", "content": "Ты эксперт в генерации тестовых данных."},
                {"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):
        """Попытка найти элемент, использовать Claude для восстановления при сбое селектора"""

        try:
            return self.driver.find_element(By.CSS_SELECTOR, original_selector)
        except NoSuchElementException:
            print(f"⚠️  Селектор не сработал: {original_selector}")
            print(f"🔧 Попытка само-восстановления...")

            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"✨ Восстановленный селектор: {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:
        """Использовать Claude для анализа страницы и предложения нового селектора"""

        prompt = f"""
        UI-тестовый селектор сломался. Проанализируй текущую страницу и предложи новый CSS селектор.

        Оригинальный (сломанный) селектор: {old_selector}
        Описание элемента: {description}

        HTML текущей страницы (обрезанный):
        {html[:5000]}

        Задача: Предложить наиболее надежный CSS селектор для элемента, соответствующего: "{description}"

        Предпочитать селекторы в этом порядке:
        1. Атрибуты data-testid
        2. Атрибуты aria-label
        3. Стабильные ID атрибуты
        4. Специфичные комбинации классов
        5. XPath как последний вариант

        Вернуть ТОЛЬКО строку селектора, без объяснений.
        """

        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()

# После 1 месяца использования
{
    "total_selector_failures": 127,
    "successful_auto_heals": 98,  # 77% успешности
    "manual_intervention_needed": 29,
    "time_saved": "~11 часов/неделю",
    "maintenance_cost_reduction": "73%"
}

# Плохо: Отправка огромного контекста каждый раз
def generate_tests_bad(api_spec):  # 50K токенов
    response = claude.messages.create(
        model="claude-3-5-sonnet-20241022",
        messages=[{"role": "user", "content": f"Сгенерируй тесты для {api_spec}"}]
    )
    # Стоимость: ~$0.60 за вызов

# Хорошо: Использовать prompt caching (Claude) или 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": "Ты эксперт в API-тестировании.",
                "cache_control": {"type": "ephemeral"}
            },
            {
                "type": "text",
                "text": f"OpenAPI спецификация:\n{api_spec}",
                "cache_control": {"type": "ephemeral"}
            }
        ],
        messages=[{"role": "user", "content": "Сгенерируй тесты для POST /users эндпоинта"}]
    )
    # Стоимость: ~$0.06 за вызов (90% экономия на кешированной части)