api development

scripts/api_e2e.py

@@ -0,0 +1,417 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import base64
+import json
+import logging
+import os
+import random
+import string
+import sys
+import time
+from dataclasses import dataclass
+from logging.handlers import RotatingFileHandler
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+from urllib.parse import urljoin
+
+import requests
+from faker import Faker
+
+# -------------------------
+# Конфигурация по умолчанию
+# -------------------------
+DEFAULT_BASE_URL = os.getenv("BASE_URL", "http://localhost:8080")
+DEFAULT_PASSWORD = os.getenv("PASS", "secret123")
+DEFAULT_CLIENTS = int(os.getenv("CLIENTS", "2"))
+DEFAULT_EMAIL_DOMAIN = os.getenv("EMAIL_DOMAIN", "agency.dev")
+DEFAULT_LOG_FILE = os.getenv("LOG_FILE", "logs/api.log")
+DEFAULT_TIMEOUT = float(os.getenv("HTTP_TIMEOUT", "10.0"))
+
+# -------------------------
+# Логирование
+# -------------------------
+def setup_logger(path: str) -> logging.Logger:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    logger = logging.getLogger("api_e2e")
+    logger.setLevel(logging.DEBUG)
+
+    # Ротация логов: до 5 файлов по 5 МБ
+    file_handler = RotatingFileHandler(path, maxBytes=5 * 1024 * 1024, backupCount=5, encoding="utf-8")
+    file_handler.setLevel(logging.DEBUG)
+    file_handler.setFormatter(logging.Formatter(
+        fmt="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    ))
+    logger.addHandler(file_handler)
+
+    # Консоль — INFO и короче
+    console = logging.StreamHandler(sys.stdout)
+    console.setLevel(logging.INFO)
+    console.setFormatter(logging.Formatter("%(levelname)s | %(message)s"))
+    logger.addHandler(console)
+    return logger
+
+# -------------------------
+# Утилиты
+# -------------------------
+def b64url_json(token_part: str) -> Dict[str, Any]:
+    """Декодирует часть JWT (payload) без валидации сигнатуры."""
+    s = token_part + "=" * (-len(token_part) % 4)
+    return json.loads(base64.urlsafe_b64decode(s).decode("utf-8"))
+
+def decode_jwt_sub(token: str) -> str:
+    try:
+        payload = b64url_json(token.split(".")[1])
+        return str(payload.get("sub", ""))  # UUID пользователя
+    except Exception:
+        return ""
+
+def mask_token(token: Optional[str]) -> str:
+    if not token:
+        return ""
+    return token[:12] + "..." if len(token) > 12 else token
+
+def now_ms() -> int:
+    return int(time.time() * 1000)
+
+@dataclass
+class UserCreds:
+    id: str
+    email: str
+    access_token: str
+    role: str
+
+# -------------------------
+# Класс-клиент
+# -------------------------
+class APIE2E:
+    
+    def __init__(self, base_url: str, logger: logging.Logger, timeout: float = DEFAULT_TIMEOUT) -> None:
+        self.base_url = base_url.rstrip("/") + "/"
+        self.logger = logger
+        self.timeout = timeout
+        self.sess = requests.Session()
+
+        self.urls = {
+            "auth": urljoin(self.base_url, "auth/"),
+            "profiles": urljoin(self.base_url, "profiles/"),
+            "match": urljoin(self.base_url, "match/"),
+            "chat": urljoin(self.base_url, "chat/"),
+            "payments": urljoin(self.base_url, "payments/"),
+        }
+
+    # --------- низкоуровневый запрос с логированием ----------
+    def req(self, method, url, token=None, body=None, expected=(200,), name=None):
+        headers = {"Accept": "application/json"}
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+
+        log_body = {}
+        if body:
+            log_body = dict(body)
+            for key in list(log_body.keys()):
+                if key.lower() in ("password", "token", "access_token", "refresh_token"):
+                    log_body[key] = "***hidden***"
+
+        started = now_ms()
+        self.logger.debug(
+            f"HTTP {method} {url} | headers={{Authorization: Bearer {mask_token(token)}}} | body={log_body}"
+        )
+
+        try:
+            resp = self.sess.request(method=method, url=url, json=body, timeout=self.timeout)
+        except Exception as e:
+            duration = now_ms() - started
+            self.logger.error(f"{name or url} FAILED transport error: {e} ({duration} ms)")
+            raise
+
+        text = resp.text or ""
+        try:
+            data = resp.json() if text else {}
+        except ValueError:
+            data = {}
+
+        duration = now_ms() - started
+        self.logger.debug(f"← {resp.status_code} in {duration} ms | body={text[:2000]}")
+        if expected and resp.status_code not in expected:
+            msg = f"{name or url} unexpected status {resp.status_code}, expected {list(expected)}; body={text}"
+            self.logger.error(msg)
+            raise RuntimeError(msg)
+        return resp.status_code, data, text
+
+
+    # --------- health ----------
+    def wait_health(self, name: str, url: str, timeout_sec: int = 60) -> None:
+        self.logger.info(f"Waiting {name} health: {url}")
+        deadline = time.time() + timeout_sec
+        while time.time() < deadline:
+            try:
+                code, _, _ = self.req("GET", url, expected=(200,), name=f"{name}/health")
+                if code == 200:
+                    self.logger.info(f"{name} is healthy")
+                    return
+            except Exception:
+                pass
+            time.sleep(1)
+        raise TimeoutError(f"{name} not healthy in time: {url}")
+
+    # --------- auth ----------
+    def login(self, email: str, password: str) -> Tuple[str, str]:
+        url = urljoin(self.urls["auth"], "v1/token")
+        _, data, _ = self.req("POST", url, body={"email": email, "password": password}, expected=(200,), name="login")
+        token = data.get("access_token", "")
+        if not token:
+            raise RuntimeError("access_token is empty")
+        user_id = decode_jwt_sub(token)
+        if not user_id:
+            raise RuntimeError("cannot decode user id (sub) from token")
+        return user_id, token
+
+    def register(self, email: str, password: str, full_name: str, role: str) -> None:
+        url = urljoin(self.urls["auth"], "v1/register")
+        # /register в вашем бэке может возвращать 201/200, а иногда 500 при сериализации —
+        # поэтому не падаем на 500 сразу, а логинимся ниже.
+        try:
+            self.req(
+                "POST",
+                url,
+                body={"email": email, "password": password, "full_name": full_name, "role": role},
+                expected=(200, 201),
+                name="register",
+            )
+        except RuntimeError as e:
+            self.logger.warning(f"register returned non-2xx: {e} — will try login anyway")
+
+    def login_or_register(self, email: str, password: str, full_name: str, role: str) -> UserCreds:
+        # 1) пробуем логин
+        try:
+            uid, token = self.login(email, password)
+            self.logger.info(f"Login OK: {email} -> {uid}")
+            return UserCreds(id=uid, email=email, access_token=token, role=role)
+        except Exception as e:
+            self.logger.info(f"Login failed for {email}: {e}; will try register")
+
+        # 2) регистрируем (не фатально, если вернулся 500)
+        self.register(email, password, full_name, role)
+
+        # 3) снова логин
+        uid, token = self.login(email, password)
+        self.logger.info(f"Registered+Login OK: {email} -> {uid}")
+        return UserCreds(id=uid, email=email, access_token=token, role=role)
+
+    # --------- profiles ----------
+    def get_my_profile(self, token: str) -> Tuple[int, Dict[str, Any]]:
+        url = urljoin(self.urls["profiles"], "v1/profiles/me")
+        code, data, _ = self.req("GET", url, token=token, expected=(200, 404), name="profiles/me")
+        return code, data
+
+    def create_profile(
+        self,
+        token: str,
+        gender: str,
+        city: str,
+        languages: List[str],
+        interests: List[str],
+    ) -> Dict[str, Any]:
+        url = urljoin(self.urls["profiles"], "v1/profiles")
+        _, data, _ = self.req(
+            "POST",
+            url,
+            token=token,
+            body={"gender": gender, "city": city, "languages": languages, "interests": interests},
+            expected=(200, 201),
+            name="profiles/create",
+        )
+        return data
+
+    def ensure_profile(
+        self, token: str, gender: str, city: str, languages: List[str], interests: List[str]
+    ) -> Dict[str, Any]:
+        code, p = self.get_my_profile(token)
+        if code == 200:
+            self.logger.info(f"Profile exists: id={p.get('id')}")
+            return p
+        self.logger.info("Profile not found -> creating")
+        p = self.create_profile(token, gender, city, languages, interests)
+        self.logger.info(f"Profile created: id={p.get('id')}")
+        return p
+
+    # --------- match ----------
+    def create_pair(self, admin_token: str, user_id_a: str, user_id_b: str, score: float, notes: str) -> Dict[str, Any]:
+        url = urljoin(self.urls["match"], "v1/pairs")
+        _, data, _ = self.req(
+            "POST",
+            url,
+            token=admin_token,
+            body={"user_id_a": user_id_a, "user_id_b": user_id_b, "score": score, "notes": notes},
+            expected=(200, 201),
+            name="match/create_pair",
+        )
+        return data
+
+    # --------- chat ----------
+    def create_room(self, admin_token: str, title: str, participants: List[str]) -> Dict[str, Any]:
+        url = urljoin(self.urls["chat"], "v1/rooms")
+        _, data, _ = self.req(
+            "POST",
+            url,
+            token=admin_token,
+            body={"title": title, "participants": participants},
+            expected=(200, 201),
+            name="chat/create_room",
+        )
+        return data
+
+    def send_message(self, admin_token: str, room_id: str, content: str) -> Dict[str, Any]:
+        url = urljoin(self.urls["chat"], f"v1/rooms/{room_id}/messages")
+        _, data, _ = self.req(
+            "POST",
+            url,
+            token=admin_token,
+            body={"content": content},
+            expected=(200, 201),
+            name="chat/send_message",
+        )
+        return data
+
+    # --------- payments ----------
+    def create_invoice(
+        self, admin_token: str, client_id: str, amount: float, currency: str, description: str
+    ) -> Dict[str, Any]:
+        url = urljoin(self.urls["payments"], "v1/invoices")
+        _, data, _ = self.req(
+            "POST",
+            url,
+            token=admin_token,
+            body={"client_id": client_id, "amount": amount, "currency": currency, "description": description},
+            expected=(200, 201),
+            name="payments/create_invoice",
+        )
+        return data
+
+    def mark_invoice_paid(self, admin_token: str, invoice_id: str) -> Dict[str, Any]:
+        url = urljoin(self.urls["payments"], f"v1/invoices/{invoice_id}/mark-paid")
+        _, data, _ = self.req("POST", url, token=admin_token, expected=(200,), name="payments/mark_paid")
+        return data
+
+# -------------------------
+# Генерация данных
+# -------------------------
+GENDERS = ["female", "male", "other"]
+CITIES = [
+    "Moscow", "Saint Petersburg", "Kazan", "Novosibirsk", "Krasnodar",
+    "Yekaterinburg", "Minsk", "Kyiv", "Almaty", "Tbilisi",
+]
+LANG_POOL = ["ru", "en", "de", "fr", "es", "it", "zh", "uk", "kk", "tr", "pl"]
+INTR_POOL = ["music", "travel", "reading", "sports", "movies", "games", "cooking", "yoga", "art", "tech"]
+
+def pick_languages(n: int = 2) -> List[str]:
+    n = max(1, min(n, len(LANG_POOL)))
+    return sorted(random.sample(LANG_POOL, n))
+
+def pick_interests(n: int = 3) -> List[str]:
+    n = max(1, min(n, len(INTR_POOL)))
+    return sorted(random.sample(INTR_POOL, n))
+
+def random_email(prefix: str, domain: str) -> str:
+    suffix = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
+    return f"{prefix}+{int(time.time())}.{suffix}@{domain}"
+
+# -------------------------
+# Основной сценарий
+# -------------------------
+def main():
+    import argparse
+
+    parser = argparse.ArgumentParser(description="E2E тест API брачного агентства с фейковыми анкетами.")
+    parser.add_argument("--base-url", default=DEFAULT_BASE_URL, help="Gateway base URL (по умолчанию http://localhost:8080)")
+    parser.add_argument("--clients", type=int, default=DEFAULT_CLIENTS, help="Количество клиентских аккаунтов (>=2)")
+    parser.add_argument("--password", default=DEFAULT_PASSWORD, help="Пароль для всех тестовых пользователей")
+    parser.add_argument("--email-domain", default=DEFAULT_EMAIL_DOMAIN, help="Домен e-mail для теста (напр. agency.dev)")
+    parser.add_argument("--log-file", default=DEFAULT_LOG_FILE, help="Файл логов (по умолчанию logs/api.log)")
+    parser.add_argument("--seed", type=int, default=42, help="Генератор случайных чисел (seed)")
+    args = parser.parse_args()
+
+    random.seed(args.seed)
+    fake = Faker()
+    logger = setup_logger(args.log_file)
+    logger.info("=== API E2E START ===")
+    logger.info(f"BASE_URL={args.base_url}  clients={args.clients}  domain={args.email_domain}")
+
+    if args.clients < 2:
+        logger.error("Нужно минимум 2 клиента (для пары).")
+        sys.exit(2)
+
+    api = APIE2E(args.base_url, logger)
+
+    # Health checks через gateway
+    api.wait_health("gateway/auth", urljoin(api.urls["auth"], "health"))
+    api.wait_health("profiles", urljoin(api.urls["profiles"], "health"))
+    api.wait_health("match", urljoin(api.urls["match"], "health"))
+    api.wait_health("chat", urljoin(api.urls["chat"], "health"))
+    api.wait_health("payments", urljoin(api.urls["payments"], "health"))
+
+    # Админ
+    admin_email = random_email("admin", args.email_domain)
+    admin_full = fake.name()
+    admin = api.login_or_register(admin_email, args.password, admin_full, role="ADMIN")
+
+    # Клиенты
+    clients: List[UserCreds] = []
+    for i in range(args.clients):
+        email = random_email(f"user{i+1}", args.email_domain)
+        full = fake.name()
+        u = api.login_or_register(email, args.password, full, role="CLIENT")
+        clients.append(u)
+
+    # Профили для всех
+    for i, u in enumerate([admin] + clients, start=1):
+        gender = random.choice(GENDERS)
+        city = random.choice(CITIES)
+        languages = pick_languages(random.choice([1, 2, 3]))
+        interests = pick_interests(random.choice([2, 3, 4]))
+        logger.info(f"[{i}/{1+len(clients)}] Ensure profile for {u.email} (role={u.role})")
+        api.ensure_profile(u.access_token, gender, city, languages, interests)
+
+    # Match‑пара между двумя случайными клиентами
+    a, b = random.sample(clients, 2)
+    score = round(random.uniform(0.6, 0.98), 2)
+    pair = api.create_pair(admin.access_token, a.id, b.id, score, notes="e2e generated")
+    pair_id = str(pair.get("id", ""))
+    logger.info(f"Match pair created: id={pair_id}, {a.email} ↔ {b.email}, score={score}")
+
+    # Чат‑комната и сообщение
+    room = api.create_room(admin.access_token, title=f"{a.email} & {b.email}", participants=[a.id, b.id])
+    room_id = str(room.get("id", ""))
+    msg = api.send_message(admin.access_token, room_id, content="Hello from admin (e2e)")
+    msg_id = str(msg.get("id", ""))
+    logger.info(f"Chat message sent: room={room_id}, msg={msg_id}")
+
+    # Счёт для первого клиента
+    amount = random.choice([99.0, 199.0, 299.0])
+    inv = api.create_invoice(admin.access_token, client_id=a.id, amount=amount, currency="USD",
+                             description="Consultation (e2e)")
+    inv_id = str(inv.get("id", ""))
+    invp = api.mark_invoice_paid(admin.access_token, inv_id)
+    logger.info(f"Invoice paid: id={inv_id}, status={invp.get('status')}")
+
+    # Итог
+    summary = {
+        "admin": {"email": admin.email, "id": admin.id},
+        "clients": [{"email": c.email, "id": c.id} for c in clients],
+        "pair_id": pair_id,
+        "room_id": room_id,
+        "message_id": msg_id,
+        "invoice_id": inv_id,
+        "invoice_status": invp.get("status"),
+    }
+    logger.info("=== SUMMARY ===")
+    logger.info(json.dumps(summary, ensure_ascii=False, indent=2))
+    print(json.dumps(summary, ensure_ascii=False, indent=2))  # на stdout — короткое резюме
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\nInterrupted.", file=sys.stderr)
+        sys.exit(130)