Для чего нужны тестовые данные в начале разработки?

Для чего нужны тестовые данные в начале разработки

Тестовые данные (fixtures, seed data) - это не просто удобство, а критическая часть процесса разработки. Правильное использование тестовых данных экономит недели работы и предотвращает множество багов.

Основные причины использования тестовых данных

1. Быстрая валидация функциональности

Не нужно ручной вводить данные через интерфейс каждый раз. Можно сразу проверить логику.

# Без тестовых данных - много ручной работы
# - Заходим в приложение
# - Регистрируемся
# - Заполняем профиль
# - Создаём несколько постов
# - Ждём загрузки
# - Проверяем функцию

# С тестовыми данными - мгновенная готовность
import pytest
from sqlalchemy.orm import Session

@pytest.fixture
def db_with_data(db_session: Session):
    """Фикстура с готовыми тестовыми данными"""
    # Создаём пользователей
    users = [
        User(id=1, email="alice@example.com", name="Alice"),
        User(id=2, email="bob@example.com", name="Bob"),
        User(id=3, email="charlie@example.com", name="Charlie"),
    ]
    db_session.add_all(users)
    
    # Создаём посты
    posts = [
        Post(id=1, author_id=1, title="First Post", content="Hello world"),
        Post(id=2, author_id=1, title="Second Post", content="Another post"),
        Post(id=3, author_id=2, title="Bob's Post", content="Bob here"),
    ]
    db_session.add_all(posts)
    
    db_session.commit()
    return db_session

def test_get_user_posts(db_with_data):
    """Тест готовой функции сразу с нужными данными"""
    user = db_with_data.query(User).filter_by(id=1).first()
    posts = user.posts
    assert len(posts) == 2
    assert posts[0].title == "First Post"

2. Реалистичное тестирование сложных сценариев

Тестовые данные позволяют воспроизвести реальные ситуации, которые сложно генерировать вручную.

# Реалистичный сценарий e-commerce
@pytest.fixture
def ecommerce_setup(db_session: Session):
    """Полный сценарий с товарами, пользователями, заказами"""
    # Создаём товары разных категорий
    electronics = Category(name="Electronics")
    clothing = Category(name="Clothing")
    db_session.add_all([electronics, clothing])
    
    products = [
        Product(id=1, name="Laptop", price=999.99, category=electronics, stock=5),
        Product(id=2, name="Phone", price=599.99, category=electronics, stock=10),
        Product(id=3, name="T-Shirt", price=19.99, category=clothing, stock=50),
    ]
    db_session.add_all(products)
    
    # Создаём пользователей с разной историей покупок
    users = [
        User(id=1, email="vip@example.com", is_premium=True),
        User(id=2, email="regular@example.com", is_premium=False),
    ]
    db_session.add_all(users)
    
    # Создаём заказы
    orders = [
        Order(id=1, user_id=1, status="completed", total=1599.98),
        Order(id=2, user_id=1, status="pending", total=19.99),
        Order(id=3, user_id=2, status="completed", total=599.99),
    ]
    db_session.add_all(orders)
    
    db_session.commit()
    return db_session

def test_discount_calculation(ecommerce_setup):
    """Проверяем скидки на основе сложной логики"""
    user = ecommerce_setup.query(User).get(1)
    cart = Cart(user=user, items=[
        CartItem(product_id=1, quantity=2),
        CartItem(product_id=3, quantity=1),
    ])
    
    discount = calculate_discount(cart, user)
    # VIP пользователи получают 15% скидку
    assert discount == 0.15

3. Обнаружение edge cases и граничных случаев

Тестовые данные позволяют создавать сценарии, которые сложно найти в коде логики.

@pytest.fixture
def edge_cases(db_session: Session):
    """Граничные случаи для тестирования"""
    users = [
        User(id=1, email="normal@example.com", created_at=datetime.now()),
        User(id=2, email="old_user@example.com", created_at=datetime(2015, 1, 1)),
        User(id=3, email="deleted@example.com", is_deleted=True),
        User(id=4, email="", name=""),  # Пустые значения
    ]
    db_session.add_all(users)
    db_session.commit()
    return db_session

def test_user_sorting_with_edge_cases(edge_cases):
    """Тест сортировки с граничными случаями"""
    result = sort_active_users_by_age()
    # Удалённые пользователи не должны быть в результатах
    assert all(u.is_deleted is False for u in result)
    # Старый пользователь должен быть в начале
    assert result[0].created_at.year == 2015

4. Ускорение разработки интеграционных тестов

Без тестовых данных интеграционные тесты требуют сложной настройки.

# ПЛОХО - сложная подготовка в каждом тесте
def test_user_profile_api():
    # Создаём пользователя
    user = create_user("test@example.com", "Test User")
    # Создаём посты
    post1 = create_post(user.id, "Title 1", "Content 1")
    post2 = create_post(user.id, "Title 2", "Content 2")
    # Создаём комментарии
    comment1 = create_comment(post1.id, "Great post!", user.id)
    comment2 = create_comment(post1.id, "Thanks", user.id)
    
    # Наконец, тестируем
    response = client.get(f"/api/users/{user.id}/profile")
    assert response.status_code == 200

# ХОРОШО - готовые данные из фикстуры
@pytest.fixture
def user_with_posts(db_session):
    """Готовый пользователь с постами и комментариями"""
    user = User(email="test@example.com", name="Test User")
    db_session.add(user)
    db_session.flush()
    
    post1 = Post(user_id=user.id, title="Title 1", content="Content 1")
    post2 = Post(user_id=user.id, title="Title 2", content="Content 2")
    db_session.add_all([post1, post2])
    db_session.flush()
    
    comment1 = Comment(post_id=post1.id, text="Great!", user_id=user.id)
    comment2 = Comment(post_id=post1.id, text="Thanks", user_id=user.id)
    db_session.add_all([comment1, comment2])
    db_session.commit()
    
    return user

def test_user_profile_api(user_with_posts, client):
    """Чистый тест, все данные готовы"""
    response = client.get(f"/api/users/{user_with_posts.id}/profile")
    assert response.status_code == 200
    assert len(response.json()['posts']) == 2
    assert len(response.json()['posts'][0]['comments']) == 2

5. Воспроизведение и отладка багов

Когда отчитаны баги, тестовые данные помогают их воспроизвести.

# Баг отчитан: "Пользователи с спецсимволами в имени вызывают ошибку"

@pytest.fixture
def special_chars_user(db_session):
    """Тестовые данные для воспроизведения бага"""
    users = [
        User(email="normal@example.com", name="John Doe"),
        User(email="special@example.com", name="José García"),
        User(email="unicode@example.com", name="李明"),
        User(email="symbols@example.com", name="John (O'Brien)"),
    ]
    db_session.add_all(users)
    db_session.commit()
    return users

def test_special_chars_in_names(special_chars_user):
    """Проверяем, что спецсимволы обрабатываются корректно"""
    for user in special_chars_user:
        # Должны быть сохранены правильно
        retrieved = db_session.query(User).filter_by(id=user.id).first()
        assert retrieved.name == user.name
        
        # API должна вернуть их корректно
        response = client.get(f"/api/users/{user.id}")
        assert response.json()['name'] == user.name

6. Производительность и нагрузочное тестирование

Тестовые данные в большом количестве помогают проверить производительность.

import pytest

@pytest.fixture(scope="session")
def large_dataset(db_session):
    """Большой набор данных для performance тестов"""
    # Создаём 10,000 пользователей
    users = [
        User(email=f"user{i}@example.com", name=f"User {i}")
        for i in range(10000)
    ]
    db_session.add_all(users)
    db_session.commit()
    return users

def test_search_performance(large_dataset):
    """Проверяем, что поиск быстрый даже на большом объёме"""
    import time
    
    start = time.time()
    result = db_session.query(User).filter(
        User.name.like("%User 999%")
    ).all()
    duration = time.time() - start
    
    assert len(result) > 0
    assert duration < 0.1  # Должно выполниться за 100ms

Лучшие практики создания тестовых данных

1. Используйте фабрики для удобства

from factory import Factory, Faker, SubFactory

class UserFactory(Factory):
    class Meta:
        model = User
    
    email = Faker('email')
    name = Faker('name')
    is_active = True

class PostFactory(Factory):
    class Meta:
        model = Post
    
    author = SubFactory(UserFactory)
    title = Faker('sentence')
    content = Faker('text')

# Просто и понятно
user = UserFactory()
posts = [PostFactory(author=user) for _ in range(5)]

2. Делайте данные реалистичными

from faker import Faker

faker = Faker()

users = [
    User(
        email=faker.email(),
        name=faker.name(),
        phone=faker.phone_number(),
        address=faker.address(),
    )
    for _ in range(100)
]

3. Организуйте фикстуры иерархически

@pytest.fixture
def admin_user(db_session):
    user = User(email="admin@example.com", role="admin")
    db_session.add(user)
    db_session.commit()
    return user

@pytest.fixture
def user_with_admin(admin_user, db_session):
    """Зависит от admin_user"""
    regular_user = User(email="user@example.com", created_by=admin_user.id)
    db_session.add(regular_user)
    db_session.commit()
    return regular_user

Когда создавать тестовые данные

В начале разработки:

• ✓ Когда планируете разработку нескольких features
• ✓ Когда разработка будет длительной (>1 недели)
• ✓ Когда нужна работа с реалистичными данными

Во время разработки:

• ✓ Когда находите новый edge case
• ✓ Когда нужно воспроизвести баг
• ✓ Когда делаете интеграционные тесты

Итоговые преимущества

Вывод: Правильные тестовые данные - это инвестиция в качество и скорость разработки. Потратьте часа 2-3 на подготовку, сэкономьте недели на отладке и тестировании.