Продвинутые Техники Pytest: Мастерство Автоматизации Тестирования на Python

import pytest
from selenium import webdriver
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

@pytest.fixture
def browser():
    """Предоставляет настроенный экземпляр браузера."""
    driver = webdriver.Chrome()
    driver.implicitly_wait(10)
    yield driver
    driver.quit()

@pytest.fixture
def database_session() (как обсуждается в [Cucumber BDD Automation: Complete Guide to Behavior-Driven Development Testing](/blog/cucumber-bdd-automation)):
    """Предоставляет сессию базы данных с автоматическим откатом."""
    engine = create_engine('postgresql://localhost/testdb')
    Session = sessionmaker(bind=engine)
    session = Session()
    yield session
    session.rollback()
    session.close()

@pytest.fixture
def authenticated_api_client(api_client, test_user):
    """Предоставляет аутентифицированный API клиент."""
    api_client.login(test_user.username, test_user.password)
    return api_client

@pytest.fixture(scope="function")
def function_fixture():
    """Выполняется перед каждой тестовой функцией (по умолчанию)."""
    return setup_resource()

@pytest.fixture(scope="class")
def class_fixture():
    """Выполняется один раз на тестовый класс."""
    return setup_expensive_resource()

@pytest.fixture(scope="module")
def module_fixture():
    """Выполняется один раз на тестовый модуль."""
    return setup_very_expensive_resource()

@pytest.fixture(scope="session")
def session_fixture():
    """Выполняется один раз на тестовую сессию."""
    database = setup_database()
    yield database
    teardown_database(database)

@pytest.mark.parametrize("username,password,expected", [
    ("admin", "admin123", True),
    ("user", "user123", True),
    ("invalid", "wrong", False),
    ("", "", False),
])
def test_login(username, password, expected, auth_service):
    result = auth_service.login(username, password)
    assert result.success == expected

import pytest
from decimal import Decimal

# Множественные наборы параметров
@pytest.mark.parametrize("quantity", [1, 5, 10, 100])
@pytest.mark.parametrize("discount", [0, 0.1, 0.25, 0.5])
def test_price_calculation(quantity, discount, pricing_engine):
    """Генерирует 16 тестовых комбинаций (4 x 4)."""
    price = pricing_engine.calculate(quantity, discount)
    assert price > 0
    assert price <= quantity * pricing_engine.base_price

# Параметризация фикстур
@pytest.fixture(params=["chrome", "firefox", "edge"])
def browser(request):
    """Запускает тесты в разных браузерах."""
    driver_name = request.param
    driver = get_driver(driver_name)
    yield driver
    driver.quit()

# Использование pytest.param для пользовательских ID тестов
@pytest.mark.parametrize("test_case", [
    pytest.param({"input": "valid@email.com", "expected": True},
                 id="valid-email"),
    pytest.param({"input": "invalid-email", "expected": False},
                 id="invalid-format"),
    pytest.param({"input": "", "expected": False},
                 id="empty-input"),
])
def test_email_validation(test_case, validator):
    result = validator.validate_email(test_case["input"])
    assert result == test_case["expected"]

@pytest.fixture
def user(request):
    """Создает пользователя на основе параметра."""
    user_type = request.param
    return UserFactory.create(user_type=user_type)

@pytest.mark.parametrize("user", ["admin", "moderator", "regular"],
                         indirect=True)
def test_permissions(user, resource):
    """Тест выполняется три раза с разными типами пользователей."""
    assert user.can_access(resource)

import pytest
import sys

# Условный пропуск тестов
@pytest.mark.skip(reason="Функция не реализована")
def test_future_feature():
    pass

@pytest.mark.skipif(sys.platform == "win32",
                    reason="Тест только для Linux")
def test_linux_specific():
    pass

# Ожидаемые сбои
@pytest.mark.xfail(reason="Известный баг #1234")
def test_known_issue():
    assert buggy_function() == expected_result

# Условный xfail
@pytest.mark.xfail(sys.version_info < (3, 10),
                   reason="Требует Python 3.10+")
def test_new_syntax():
    pass

# pytest.ini или pyproject.toml
"""
[tool.pytest.ini_options]
markers = [
    "slow: отмечает тесты как медленные (отменить выбор с '-m \"not slow\"')",
    "integration: интеграционные тесты, требующие внешних сервисов",
    "smoke: дымовые тесты для быстрой валидации",
    "security: тесты, связанные с безопасностью",
    "regression: набор регрессионных тестов",
]
"""

# Использование пользовательских маркеров
@pytest.mark.slow
@pytest.mark.integration
def test_full_system_integration():
    pass

@pytest.mark.smoke
def test_critical_path():
    pass

@pytest.mark.security
@pytest.mark.parametrize("payload", malicious_payloads)
def test_sql_injection(payload, database):
    with pytest.raises(SecurityException):
        database.execute(payload)

# Запустить только дымовые тесты
pytest -m smoke

# Исключить медленные тесты
pytest -m "not slow"

# Запустить дымовые ИЛИ интеграционные тесты
pytest -m "smoke or integration"

# Запустить тесты безопасности И регрессии
pytest -m "security and regression"

# Сложный выбор
pytest -m "smoke and not slow"

# tests/conftest.py
import pytest
from pathlib import Path

def pytest_configure(config):
    """Регистрация пользовательских маркеров."""
    config.addinivalue_line(
        "markers", "slow: отмечает тесты как медленные"
    )

@pytest.fixture(scope="session")
def test_data_dir():
    """Предоставляет путь к директории тестовых данных."""
    return Path(__file__).parent / "data"

@pytest.fixture(scope="session")
def config():
    """Загружает конфигурацию тестов."""
    return load_test_config()

@pytest.fixture(autouse=True)
def reset_database(database):
    """Автоматически сбрасывает базу данных перед каждым тестом."""
    database.reset()
    yield
    # Очистка при необходимости

def pytest_collection_modifyitems(config, items):
    """Автоматически отмечает медленные тесты."""
    for item in items:
        if "integration" in item.nodeid:
            item.add_marker(pytest.mark.slow)

# tests/integration/conftest.py
import pytest
import docker

@pytest.fixture(scope="module")
def docker_services():
    """Запускает Docker контейнеры для интеграционных тестов."""
    client = docker.from_env()

    # Запуск PostgreSQL
    postgres = client.containers.run(
        "postgres:15",
        environment={"POSTGRES_PASSWORD": "test"},
        ports={"5432/tcp": 5432},
        detach=True
    )

    # Запуск Redis
    redis = client.containers.run(
        "redis:7",
        ports={"6379/tcp": 6379},
        detach=True
    )

    # Ожидание готовности сервисов
    wait_for_postgres(postgres)
    wait_for_redis(redis)

    yield {"postgres": postgres, "redis": redis}

    # Очистка
    postgres.stop()
    redis.stop()
    postgres.remove()
    redis.remove()

@pytest.fixture
def api_client(docker_services, config):
    """Предоставляет настроенный API клиент."""
    from myapp.client import APIClient
    return APIClient(base_url=config.api_url)

# requirements-test.txt
pytest==7.4.3
pytest-cov==4.1.0           # Отчеты о покрытии
pytest-xdist==3.5.0         # Параллельное выполнение
pytest-timeout==2.2.0       # Таймауты тестов
pytest-mock==3.12.0         # Утилиты для мокирования
pytest-asyncio==0.23.2      # Поддержка async тестов
pytest-django==4.7.0        # Интеграция с Django
pytest-flask==1.3.0         # Интеграция с Flask
pytest-bdd==7.0.1           # Поддержка BDD
pytest-html==4.1.1          # HTML отчеты
pytest-json-report==1.5.0   # JSON отчеты

# Запустить тесты на 4 ядрах CPU
pytest -n 4

# Автоопределение количества CPU
pytest -n auto

# Распределение по файлам (лучше для интеграционных тестов)
pytest -n 4 --dist loadfile

# Распределение по тестам (лучше для модульных тестов)
pytest -n 4 --dist loadscope

# Генерация отчета о покрытии
pytest --cov=myapp --cov-report=html

# Провалить, если покрытие ниже порога
pytest --cov=myapp --cov-fail-under=80

# Показать пропущенные строки
pytest --cov=myapp --cov-report=term-missing

# conftest.py или custom_plugin.py
import pytest
import time

class PerformancePlugin:
    """Отслеживает время выполнения тестов."""

    def __init__(self):
        self.test_times = {}

    @pytest.hookimpl(hookwrapper=True)
    def pytest_runtest_call(self, item):
        """Измеряет время выполнения теста."""
        start = time.time()
        outcome = yield
        duration = time.time() - start

        self.test_times[item.nodeid] = duration

        if duration > 5.0:
            print(f"\nМедленный тест: {item.nodeid} ({duration:.2f}s)")

    def pytest_terminal_summary(self, terminalreporter):
        """Отображает самые медленные тесты."""
        terminalreporter.section("Самые Медленные Тесты")
        sorted_tests = sorted(
            self.test_times.items(),
            key=lambda x: x[1],
            reverse=True
        )[:10]

        for test, duration in sorted_tests:
            terminalreporter.write_line(
                f"{test}: {duration:.2f}s"
            )

def pytest_configure(config):
    """Регистрация плагина."""
    config.pluginmanager.register(PerformancePlugin())

# Хорошо: Описательные имена тестов
def test_user_registration_requires_valid_email():
    pass

def test_user_registration_rejects_duplicate_email():
    pass

# Плохо: Расплывчатые имена тестов
def test_registration():
    pass

def test_user_1():
    pass

# Хорошо: Фикстуры с единой ответственностью
@pytest.fixture
def user():
    return User(username="testuser")

@pytest.fixture
def authenticated_session(user):
    return create_session(user)

# Плохо: Божественная фикстура, делающая все
@pytest.fixture
def everything():
    user = create_user()
    session = login(user)
    db = setup_database()
    api = create_api_client()
    return user, session, db, api

# Хорошо: Конкретные утверждения с сообщениями
def test_discount_calculation():
    price = calculate_price(quantity=10, discount=0.2)
    assert price == 80.0, f"Ожидалось 80.0, получено {price}"
    assert isinstance(price, Decimal), "Цена должна быть Decimal"

# Хорошо: Множественные сфокусированные утверждения
def test_user_creation():
    user = create_user(username="test")
    assert user.username == "test"
    assert user.is_active is True
    assert user.created_at is not None

# Плохо: Try-except скрывает провалы
def test_api_call():
    try:
        result = api.call()
        assert result.status == 200
    except Exception:
        pass  # Никогда так не делайте!

# Хорошо: Паттерн фабрики для тестовых данных
class UserFactory:
    @staticmethod
    def create(username=None, email=None, **kwargs):
        return User(
            username=username or f"user_{uuid.uuid4().hex[:8]}",
            email=email or f"test_{uuid.uuid4().hex[:8]}@example.com",
            **kwargs
        )

@pytest.fixture
def user():
    return UserFactory.create()

@pytest.fixture
def admin_user():
    return UserFactory.create(role="admin")

# Хорошо: Использование faker для реалистичных данных
from faker import Faker

@pytest.fixture
def fake():
    return Faker()

def test_user_profile(fake):
    user = User(
        name=fake.name(),
        email=fake.email(),
        address=fake.address()
    )
    assert user.save()

# До: Медленно (создает новую базу данных на тест)
@pytest.fixture
def database():
    db = create_database()
    yield db
    db.drop()

def test_query_1(database):
    assert database.query("SELECT 1")

def test_query_2(database):
    assert database.query("SELECT 2")

# После: Быстро (переиспользует базу данных, сбрасывает состояние)
@pytest.fixture(scope="session")
def database():
    db = create_database()
    yield db
    db.drop()

@pytest.fixture(autouse=True)
def reset_db_state(database):
    database.truncate_all_tables()

def test_query_1(database):
    assert database.query("SELECT 1")

def test_query_2(database):
    assert database.query("SELECT 2")

# conftest.py
import pytest
from decimal import Decimal

@pytest.fixture(scope="session")
def database():
    """База данных с областью сессии."""
    db = create_test_database()
    yield db
    db.drop()

@pytest.fixture(autouse=True)
def clean_database(database):
    """Авто-очистка между тестами."""
    database.truncate_all()

@pytest.fixture
def product_factory(database):
    """Фабрика для создания тестовых продуктов."""
    class ProductFactory:
        @staticmethod
        def create(name=None, price=None, stock=10):
            return database.products.insert(
                name=name or f"Product {uuid.uuid4().hex[:8]}",
                price=price or Decimal("99.99"),
                stock=stock
            )
    return ProductFactory

@pytest.fixture
def cart_service(database):
    """Сервис корзины покупок."""
    from myapp.services import CartService
    return CartService(database)

# test_shopping_cart.py
@pytest.mark.parametrize("quantity,expected_total", [
    (1, Decimal("99.99")),
    (2, Decimal("199.98")),
    (5, Decimal("499.95")),
])
def test_cart_total_calculation(quantity, expected_total,
                               cart_service, product_factory):
    """Проверка расчета итога корзины."""
    product = product_factory.create(price=Decimal("99.99"))
    cart = cart_service.create()
    cart_service.add_item(cart.id, product.id, quantity)

    assert cart.total == expected_total

@pytest.mark.integration
@pytest.mark.slow
def test_checkout_process(cart_service, product_factory,
                         payment_gateway):
    """Интеграционный тест полного процесса оформления заказа."""
    # Настройка
    product = product_factory.create(price=Decimal("50.00"), stock=10)
    cart = cart_service.create()
    cart_service.add_item(cart.id, product.id, 2)

    # Выполнение оформления
    order = cart_service.checkout(
        cart.id,
        payment_method="credit_card",
        shipping_address=test_address
    )

    # Проверка
    assert order.status == "confirmed"
    assert order.total == Decimal("100.00")
    assert product.reload().stock == 8
    assert payment_gateway.captured_amount == Decimal("100.00")