def create_order(user_id, items):
    user = db.users.find_one(user_id)
    if user.balance < total_cost(items): raise "Не хватает средств"
    db.users.update_one(user_id, {"$inc": {"balance": -total_cost(items)}})
    order_id = db.orders.insert_one({"user": user_id, "items": items})
    requests.post("http://courier-system/api/assign", json={"order": order_id})
    return order_id

def create_order(user_id, items):
    with db.transaction():
        # проверка и списание
        user = db.users.find_one(user_id)
        if user.balance < total_cost(items): raise
        db.users.update_one(user_id, {"$inc": {"balance": -total_cost(items)}})
        order_id = db.orders.insert_one({"user": user_id, "items": items})
        kafka.produce("order_created", {"order_id": order_id})  # событие
    return order_id

public AccountInfo getAccount(String userId) {
    return jdbc.query("SELECT * FROM accounts WHERE user_id = ?", userId);
}

public AccountInfo getAccount(String userId) {
    AccountInfo cached = redis.get("account:" + userId);
    if (cached != null) return cached;
    AccountInfo fromDb = jdbc.query(...);
    redis.setex("account:" + userId, 60, fromDb); // TTL 60 сек
    return fromDb;
}

def start_movie(user_id, movie_id):
    check_subscription(user_id)
    deduct_credit(user_id)
    recommendations.update(user_id, movie_id)  # тормозит — пользователь ждёт
    return "ok"

def start_movie(user_id, movie_id):
    check_subscription(user_id)
    deduct_credit(user_id)
    kafka.produce("movie_started", {"user": user_id, "movie": movie_id})  # не ждём
    return "ok"

CREATE TABLE access_logs (user_id INT, accessed_at TIMESTAMP, ip VARCHAR(45));
Штраф: €20 млн за нарушение GDPR.

db.logs.insert_one({
    "user_id": user_id,
    "ip_hash": hashlib.sha256(ip.encode()).hexdigest(),
    "expire_at": datetime.utcnow() + timedelta(days=90)
})
db.logs.create_index("expire_at", expireAfterSeconds=0)  # автоудаление

```python
import requests
import time

def test_payment_retry():
    url = "https://payment-gateway/api/pay"
    payload = {"order_id": 123, "amount": 1000}
    
    for attempt in range(3):
        response = requests.post(url, json=payload)
        if response.status_code == 503:
            wait_time = 2 ** attempt  # 1, 2, 4 секунды
            print(f"Попытка {attempt+1} не удалась, ждём {wait_time}с")
            time.sleep(wait_time)
        else:
            assert response.status_code == 200
            print("Успех!")
            return
    assert False, "Все попытки исчерпаны"

import pytest

def validate_quantity(q):
    return 1 <= q <= 999

@pytest.mark.parametrize("input,expected", [
    (0, False),      # граница снизу
    (1, True),       # минимальное допустимое
    (500, True),     # среднее значение
    (999, True),     # максимальное допустимое
    (1000, False),   # граница сверху
    (-5, False),     # отрицательное
    ("abc", False)   # не число
])
def test_quantity_validation(input, expected):
    assert validate_quantity(input) == expected

def test_balance_after_purchase():
    # Данные тестового пользователя
    user_id = 999
    initial_balance = get_balance(user_id)  # предположим, 1000
    
    # Покупаем товар за 300
    purchase(user_id, 300)
    
    # Проверяем новый баланс
    new_balance = get_balance(user_id)
    expected = initial_balance - 300
    
    assert new_balance == expected, f"Ожидалось {expected}, получено {new_balance}"
    print("Баланс обновился корректно")

Feature: Бонусы за регистрацию
  Scenario: Новый пользователь получает 500 бонусов
    Given пользователь не зарегистрирован
    When он регистрируется с телефоном "+79991234567"
    Then его бонусный счёт равен 500

SELECT 
    DATE(created_at) as reg_date,
    COUNT(user_id) as total_users,
    COUNT(bonus_id) as users_with_bonus,
    ROUND(COUNT(bonus_id) * 100.0 / COUNT(user_id), 2) as percent
FROM users
LEFT JOIN bonuses ON users.user_id = bonuses.user_id
WHERE created_at >= '2024-10-01'
GROUP BY reg_date
ORDER BY reg_date;

SELECT 
    DATE_TRUNC('hour', order_time) as hour,
    COUNT(order_id) as orders,
    SUM(amount) as revenue
FROM orders
WHERE order_time >= CURRENT_DATE - INTERVAL '2 days'
GROUP BY hour
ORDER BY hour;

SELECT 
    product_category,
    COUNT(order_id) as orders
FROM orders
WHERE order_time BETWEEN '2024-10-15 14:00' AND '2024-10-15 15:00'
GROUP BY product_category;

SELECT 
    user_id,
    COUNT(order_id) as order_count,
    SUM(amount) as total_spent
FROM orders
GROUP BY user_id
HAVING COUNT(order_id) >= 10
ORDER BY order_count DESC
LIMIT 20;

UPDATE customers
SET is_vip = TRUE
WHERE customer_id IN (
    SELECT customer_id
    FROM orders
    GROUP BY customer_id
    HAVING SUM(amount) > 1000000
);

def test_discount():
    assert apply_discount(1000) == 1000   # 0% или 10%?
    assert apply_discount(1001) == 900.9  # должно быть 10%
    assert apply_discount(500) == 500     # без скидки

Feature: Скидка на заказ
  Scenario: Сумма ровно 1000
    Given сумма заказа 1000 рублей
    When рассчитывается скидка
    Then скидка не применяется (0%)   # или применяется? Надо решить!

[!@#$%^&*(),.?":{}|<>]

import pytest

def validate_password(password):
    # минимальная проверка для примера
    return any(c in "!@#$%^&*" for c in password)

@pytest.mark.parametrize("pwd,expected", [
    ("pass!", True),      # содержит !
    ("pass", False),      # нет спецсимвола
    ("pass©", False),     # © не в наборе
    ("pass#", True),      # содержит #
])
def test_special_char(pwd, expected):
    assert validate_password(pwd) == expected

# Плохо
if date >= "2025-10-01" and date <= "2025-10-31":
    apply_discount()

# Хорошо — параметры в конфиге или БД
promo = get_promo("october_electronics")
if promo.is_active(date):
    apply_discount()

def test_promo_flexible():
    set_promo_dates("2025-10-01", "2025-10-31")
    assert is_promo_active("2025-10-15") == True
    assert is_promo_active("2025-11-01") == False
    set_promo_dates("2025-10-01", "2025-11-05")
    assert is_promo_active("2025-11-01") == True

def send_order(order, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post("https://crm/orders", json=order, timeout=5)
            if response.status_code == 200:
                return True
            time.sleep(2 ** attempt)
        except:
            time.sleep(2 ** attempt)
    save_to_dlq(order)  # в отдельную очередь
    return False

key = hashlib.sha256(f"{order_id}_{amount}".encode()).hexdigest()
if redis.exists(key):
    return {"status": "duplicate"}  # уже обработали
redis.setex(key, 86400, "processed")
process_payment(payload)

@pytest.mark.parametrize("date,format,ok", [
    ("15.03.2025", "%d.%m.%Y", True),
    ("2025-03-15", "%Y-%m-%d", True),
])
def test_date_format(date, format, ok):
    assert validate_date(date, format) == ok

async with timeout(2):
    result = await session.get(url)
if timeout:
    return get_cached_data()  # запасной вариант