Тестирование Серого Ящика: Лучшее из Двух Миров

# Тестировщик серого ящика знает:
# - AuthService валидирует учётные данные
# - UserService управляет данными пользователя
# - EmailService отправляет уведомления
# - Redis кэширует пользовательские сессии

def test_user_registration_flow():
    """Тест полной регистрации со знанием архитектуры системы"""

    # 1. Зарегистрировать нового пользователя (UserService)
    response = api.post("/register", {
        "email": "новыйпользователь@example.com",
        "password": "БезопасныйПароль123"
    })
    assert response.status_code == 201
    user_id = response.json()["id"]

    # 2. Проверить запись пользователя в базе данных
    # (Серый ящик: знает структуру базы данных)
    user = db.query("SELECT * FROM users WHERE id = ?", user_id)
    assert user["email"] == "новыйпользователь@example.com"
    assert user["status"] == "pending_verification"

    # 3. Проверить отправку приветственного письма (EmailService)
    # (Серый ящик: знает, что существует очередь email)
    email_queue = redis (как обсуждается в [Test Environment Setup: Complete Configuration Guide](/blog/test-environment-setup)).lrange("email_queue", 0, -1)
    assert any("новыйпользователь@example.com" in email for email in email_queue)

    # 4. Проверить, что сессия ещё не создана (Redis)
    # (Серый ящик: знает механизм хранения сессий)
    session_key = f"session:{user_id}"
    assert redis.get(session_key) is None

def test_order_processing_data_integrity():
    """Тест обработки заказа со знанием базы данных"""

    # Создать тестовый заказ
    order_data = {
        "user_id": 100,
        "items": [
            {"product_id": 1, "quantity": 2, "price": 50.00},
            {"product_id": 2, "quantity": 1, "price": 30.00}
        ],
        "discount_code": "СКИДКА10"
    }

    response = api.post("/orders", order_data)
    order_id = response.json()["order_id"]

    # Валидация серого ящика: Проверить состояние базы данных
    # 1. Запись заказа создана правильно
    order = db.query("SELECT * FROM orders WHERE id = ?", order_id)
    assert order["user_id"] == 100
    assert order["status"] == "pending"
    assert order["total"] == 117.00  # (130 - 13 скидка)

    # 2. Элементы заказа сохранены
    items = db.query("SELECT * FROM order_items WHERE order_id = ?", order_id)
    assert len(items) == 2

    # 3. Инвентарь уменьшен
    product1_stock = db.query("SELECT stock FROM products WHERE id = 1")
    # Проверить, что запас уменьшен на 2

    # 4. Использование кода скидки отслежено
    discount_usage = db.query(
        "SELECT * FROM discount_usages WHERE code = ? AND user_id = ?",
        "СКИДКА10", 100
    )
    assert discount_usage is not None

    # 5. Создан журнал аудита
    logs = db.query("SELECT * FROM audit_logs WHERE entity_id = ?", order_id)
    assert len(logs) > 0

def test_api_with_architectural_knowledge():
    """Тест REST API со знанием структуры бэкенда"""

    # Знание серого ящика:
    # - API использует JWT для аутентификации
    # - Ограничение скорости: 100 запросов/минуту на пользователя
    # - Ответ кэшируется на 5 минут
    # - Фоновые задачи для тяжёлых операций

    # 1. Поток аутентификации
    auth_response = api.post("/auth/login", {
        "email": "пользователь@example.com",
        "password": "пароль"
    })

    token = auth_response.json()["access_token"]

    # Валидировать структуру JWT (серый ящик: знает формат токена)
    import jwt
    decoded = jwt.decode(token, options={"verify_signature": False})
    assert decoded["user_id"] is not None
    assert decoded["exp"] > time.time()  # Не истёк

    # 2. Тест ограничения скорости
    # (Серый ящик: знает, что лимит 100/минуту)
    headers = {"Authorization": f"Bearer {token}"}

    for i in range(100):
        response = api.get("/api/data", headers=headers)
        assert response.status_code == 200

    # 101-й запрос должен быть ограничен
    response = api.get("/api/data", headers=headers)
    assert response.status_code == 429  # Слишком Много Запросов

    # 3. Тест поведения кэша
    # (Серый ящик: знает 5-минутный кэш)
    response1 = api.get("/api/products/1", headers=headers)
    cache_header1 = response1.headers.get("X-Cache")

    # Второй немедленный запрос должен попасть в кэш
    response2 = api.get("/api/products/1", headers=headers)
    cache_header2 = response2.headers.get("X-Cache")
    assert cache_header2 == "HIT"

    # 4. Тест создания асинхронной задачи
    # (Серый ящик: знает, что тяжёлые операции ставятся в очередь)
    response = api.post("/api/reports/generate", {
        "type": "annual",
        "format": "pdf"
    }, headers=headers)

    assert response.status_code == 202  # Принято
    job_id = response.json()["job_id"]

    # Проверить очередь задач (серый ящик: знает расположение очереди)
    job = redis.hget("jobs", job_id)
    assert job is not None
    assert json.loads(job)["status"] == "queued"

def test_security_with_architectural_knowledge():
    """Тестирование безопасности со знанием дизайна системы"""

    # Знание серого ящика:
    # - Пароли хэшируются с помощью bcrypt
    # - Токены CSRF требуются для операций, изменяющих состояние
    # - Загрузки файлов хранятся в S3
    # - Используется параметризация SQL

    # 1. Тест хранения паролей
    # (Серый ящик: знает алгоритм хэширования)
    api.post("/register", {
        "email": "безопасность@example.com",
        "password": "ТестовыйПароль123"
    })

    # Проверить базу данных - пароль должен быть хэширован
    user = db.query(
        "SELECT password_hash FROM users WHERE email = ?",
        "безопасность@example.com"
    )
    # Должен быть хэш bcrypt (начинается с $2b$ или $2a$)
    assert user["password_hash"].startswith("$2")
    assert len(user["password_hash"]) == 60  # длина хэша bcrypt

    # 2. Тест защиты CSRF
    # (Серый ящик: знает реализацию CSRF)
    session = requests.Session()
    session.post("/login", {
        "email": "безопасность@example.com",
        "password": "ТестовыйПароль123"
    })

    # Запрос без токена CSRF должен не пройти
    response = session.post("/api/sensitive-action", {
        "action": "delete_account"
    })
    assert response.status_code == 403  # Запрещено

    # Запрос с токеном CSRF должен успешно пройти
    csrf_token = session.get("/api/csrf-token").json()["token"]
    response = session.post("/api/sensitive-action", {
        "action": "delete_account",
        "csrf_token": csrf_token
    })
    assert response.status_code in [200, 204]

# test_architecture.yml
system_architecture:
  authentication:
    method: JWT
    token_expiry: 3600  # секунды
    refresh_enabled: true

  database:
    type: PostgreSQL
    connection_pool: 20
    key_tables:
      - users (id, email, password_hash, created_at)
      - orders (id, user_id, total, status, created_at)
      - sessions (id, user_id, token, expires_at)

  caching:
    provider: Redis
    ttl: 300  # секунды
    cached_endpoints:
      - /api/products
      - /api/categories

class UserAPITestSuite:
    """Сбалансированный подход тестирования серого ящика"""

    def test_user_registration_black_box_view(self):
        """Тест с точки зрения конечного пользователя"""
        # Чистый чёрный ящик: только тестировать контракт API
        response = api.post("/register", {
            "email": "пользователь@example.com",
            "password": "БезопасныйПароль123"
        })

        assert response.status_code == 201
        assert "id" in response.json()
        assert "email" in response.json()

    def test_user_registration_grey_box_validation(self):
        """Тест с архитектурным знанием"""
        response = api.post("/register", {
            "email": "пользователь@example.com",
            "password": "БезопасныйПароль123"
        })

        user_id = response.json()["id"]

        # Серый ящик: проверить внутреннее состояние
        user = db.query("SELECT * FROM users WHERE id = ?", user_id)
        assert user["email_verified"] == False
        assert user["status"] == "pending"

        # Проверить побочные эффекты
        assert email_sent_to("пользователь@example.com", subject="Подтвердите email")