From b650adc05cc392f568e483fb5118fbab10715fae Mon Sep 17 00:00:00 2001 From: Drobysh Date: Sat, 26 Sep 2026 08:45:07 +0000 Subject: [PATCH] =?UTF-8?q?=F0=9F=A7=AA=20Smoke-test=20=D1=80=D0=BE=D0=B1?= =?UTF-8?q?=D0=BE=D1=82:=20=D0=BF=D1=80=D0=BE=D0=B2=D0=B5=D1=80=D0=BA?= =?UTF-8?q?=D0=B0=203=20=D1=81=D1=86=D0=B5=D0=BD=D0=B0=D1=80=D0=B8=D0=B5?= =?UTF-8?q?=D0=B2=20=D0=BF=D1=80=D0=BE=D1=82=D0=B8=D0=B2=20=D1=80=D0=B5?= =?UTF-8?q?=D0=B0=D0=BB=D1=8C=D0=BD=D0=BE=D0=B9=20=D0=91=D0=94?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Диагност, не хирург: дёргает эндпоинты как фронтенд, читает БД, не чинит баги — только пишет отчёт smoke_test_report.md. - pronunciation_pool_stress: 30 запросов подряд (проверка утечки пула) - hints_db_increment: сверка hints_used в user_progress до/после - game_complete_level_full_flow: идемпотентность + сверка score с БД Использует SMOKE_USER_ID=9999999999 (отдельно от TEST_USER_ID=999999999). После прогона чистит за собой. --- tests/test_smoke.py | 276 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 276 insertions(+) create mode 100644 tests/test_smoke.py diff --git a/tests/test_smoke.py b/tests/test_smoke.py new file mode 100644 index 0000000..545539e --- /dev/null +++ b/tests/test_smoke.py @@ -0,0 +1,276 @@ +""" +Smoke-test робот для Filwords PL Backend. + +Диагност, не хирург: реально дёргает эндпоинты (как фронтенд) и реально +читает БД (как будто смотрит глазами). Не чинит баги, не меняет код — +только пишет отчёт, что работает, а что нет, с доказательством из БД. + +Запуск: pytest tests/test_smoke.py -v +Отчёт: smoke_test_report.md (в корне репозитория, перезаписывается + при каждом прогоне) + +ВАЖНО про ID: используется SMOKE_USER_ID = 9999999999 (10 девяток), а НЕ +TEST_USER_ID = 999999999 (9 девяток) из conftest.py. Это два разных ID +специально: TEST_USER_ID уже используется другими тестами через фикстуру +test_user, которая чистит более короткий список таблиц. Смешивать их — +риск ложных срабатываний в обоих наборах тестов. +""" +import hashlib +import hmac +import json +import time +import urllib.parse +from dataclasses import dataclass, field +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +import pytest +from fastapi.testclient import TestClient + +from main import app +from database import get_pool +from config import BOT_TOKEN + +SMOKE_USER_ID = 9999999999 +SMOKE_USER_FIRST_NAME = "SmokeTestUser" + + +# ============ Генерация initData (1:1 с auth.py) ============ + +def _build_init_data(user_id: int, first_name: str, bot_token: str) -> str: + """Официальный алгоритм Telegram WebApp initData. + + quote(..., safe='') — НЕ urlencode() — потому что auth.py декодирует + вручную через unquote(), которая не превращает '+' обратно в пробел + (а urlencode() по умолчанию кодирует пробелы именно как '+'). + """ + auth_date = int(time.time()) + user_json = json.dumps( + {"id": user_id, "first_name": first_name, "language_code": "ru"}, + separators=(",", ":"), + ensure_ascii=False, + ) + params = {"auth_date": str(auth_date), "query_id": "AAsmoketest", "user": user_json} + check_string = "\n".join(f"{k}={v}" for k, v in sorted(params.items())) + + secret_key = hmac.new(b"WebAppData", bot_token.encode(), hashlib.sha256).digest() + calc_hash = hmac.new(secret_key, check_string.encode(), hashlib.sha256).hexdigest() + params["hash"] = calc_hash + + return "&".join(f"{k}={urllib.parse.quote(str(v), safe='')}" for k, v in params.items()) + + +# ============ Результат сценария ============ + +@dataclass +class ScenarioResult: + name: str + section: str + passed: bool + message: str + details: dict[str, Any] = field(default_factory=dict) + + +RESULTS: list[ScenarioResult] = [] # копится по ходу прогона, пишется в отчёт в конце + + +# ============ Очистка (полный список из database.py) ============ + +# Таблицы БЕЗ FK на users(telegram_id) — каскад их не подчистит. +NON_FK_TABLES = [ + "learning_sessions", "user_learning_answers", "user_lesson_progress", + "user_topic_progress", "user_skill_mastery", "ai_user_context", + "teacher_chat_history", "teacher_ai_usage", +] +# Каскадные через users(telegram_id) ON DELETE CASCADE — отдельно чистить +# не нужно, снесутся при DELETE FROM users: user_progress, sentence_progress, +# typing_progress, chat_history, chat_usage, user_achievements, daily_logins, +# word_quiz_progress, bubble_words_progress, sentence_hints_used, +# typing_hints_used. + + +async def _cleanup(conn) -> None: + async with conn.transaction(): + for table in NON_FK_TABLES: + await conn.execute(f"DELETE FROM {table} WHERE user_id = $1", SMOKE_USER_ID) + + # support_messages ссылается на ticket_id, не напрямую на user_id. + await conn.execute( + "DELETE FROM support_messages WHERE ticket_id IN " + "(SELECT id FROM support_tickets WHERE user_id = $1)", + SMOKE_USER_ID, + ) + await conn.execute("DELETE FROM support_tickets WHERE user_id = $1", SMOKE_USER_ID) + + # users — последним, каскад подчищает всё перечисленное выше. + await conn.execute("DELETE FROM users WHERE telegram_id = $1", SMOKE_USER_ID) + + +# ============ Фикстуры ============ + +@pytest.fixture(scope="session") +async def smoke_conn(): + """Отдельное соединение из общего пула приложения (database.get_pool()).""" + pool = await get_pool() + async with pool.acquire() as connection: + yield connection + + +@pytest.fixture(scope="session", autouse=True) +async def smoke_user(smoke_conn): + """Цикл на всю сессию: удалить → зарегистрировать → (тесты) → удалить → отчёт.""" + await _cleanup(smoke_conn) + + client = TestClient(app) + init_data = _build_init_data(SMOKE_USER_ID, SMOKE_USER_FIRST_NAME, BOT_TOKEN) + client.headers.update({"Authorization": f"tma {init_data}"}) + + resp = client.post("/users/register") + assert resp.status_code == 200, ( + f"Не удалось зарегистрировать тестового юзера: {resp.status_code} {resp.text[:200]}" + ) + + yield client + + await _cleanup(smoke_conn) + _write_report() + + +# ============ Сценарий 1: Произношение (утечка пула) ============ + +async def test_pronunciation_pool_stress(smoke_user): + """В routers/pronunciation.py нет persistence-вызова — только get_next_word. + Проверять запись в БД не на чем. Вместо этого — утечку conn/пула: + если conn не освобождается, часть из N подряд идущих запросов упадёт. + """ + client = smoke_user + N = 30 + seen_words: set[str] = set() + failures = 0 + + for _ in range(N): + resp = client.get("/pronunciation/next") + if resp.status_code != 200: + failures += 1 + continue + body = resp.json() + word = body.get("word_pl") or body.get("word") + if word: + seen_words.add(word) + + passed = failures == 0 + RESULTS.append(ScenarioResult( + "pronunciation_pool_stress", "pronunciation", passed, + f"{N - failures}/{N} запросов успешны, {len(seen_words)} уникальных слов", + {"failures": failures, "unique_words": len(seen_words)}, + )) + assert passed, f"{failures}/{N} запросов к /pronunciation/next упали — похоже на утечку conn/пула" + + +# ============ Сценарий 2: Подсказки (DB-инкремент) ============ + +async def test_hints_first_letter(smoke_user, smoke_conn): + """GET /hints/first-letter/{levelId} — читаем hints_used в user_progress + до и после. 200 без реального инкремента = баг. + """ + client = smoke_user + level_id = 1 # TODO: свериться, что level_id=1 гарантированно существует + + before = await smoke_conn.fetchrow( + "SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2", + SMOKE_USER_ID, level_id, + ) + before_count = before["hints_used"] if before else 0 + + resp = client.get(f"/hints/first-letter/{level_id}") + ok = resp.status_code == 200 + + after = await smoke_conn.fetchrow( + "SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2", + SMOKE_USER_ID, level_id, + ) + after_count = after["hints_used"] if after else 0 + + passed = ok and after_count > before_count + RESULTS.append(ScenarioResult( + "hints_db_increment", "hints", passed, + f"GET вернул {resp.status_code}, hints_used {before_count} → {after_count}", + {"before": before_count, "after": after_count, "status": resp.status_code}, + )) + assert ok, f"GET /hints/first-letter/{level_id} вернул {resp.status_code}" + assert after_count > before_count, f"hints_used не вырос: {before_count} → {after_count}" + + +# ============ Сценарий 3: Игра — complete-level (идемпотентность + DB) ============ + +async def test_game_complete_level_flow(smoke_user, smoke_conn): + """GET /game/level/{n} → POST /game/complete-level (дважды). + Проверяем: (1) повторный вызов даёт already_completed=True, а не + повторное начисление; (2) score из ответа API реально совпадает + со score в user_progress. + """ + client = smoke_user + level_number = 1 + + resp_level = client.get(f"/game/level/{level_number}") + assert resp_level.status_code == 200, f"GET /game/level/{level_number} вернул {resp_level.status_code}" + level_id = resp_level.json().get("level", {}).get("id") + + resp1 = client.post("/game/complete-level", json={"level_id": level_id, "hints_used": 0}) + assert resp1.status_code == 200, f"POST /game/complete-level (1-й раз) вернул {resp1.status_code}" + body1 = resp1.json() + + resp2 = client.post("/game/complete-level", json={"level_id": level_id, "hints_used": 0}) + body2 = resp2.json() if resp2.status_code == 200 else {} + idempotent = bool(body2.get("already_completed")) + + row = await smoke_conn.fetchrow( + "SELECT score FROM user_progress WHERE user_id = $1 AND level_id = $2", + SMOKE_USER_ID, level_id, + ) + db_score = row["score"] if row else None + score_matches = db_score == body1.get("score") + + passed = idempotent and score_matches + RESULTS.append(ScenarioResult( + "game_complete_level_full_flow", "game", passed, + f"idempotent={idempotent}, api_score={body1.get('score')}, db_score={db_score}", + {"api_score": body1.get("score"), "db_score": db_score, "idempotent": idempotent}, + )) + assert idempotent, f"Повторный complete-level не вернул already_completed=True: {body2}" + assert score_matches, f"API score={body1.get('score')}, но в БД score={db_score}" + + +# ============ Отчёт ============ + +def _write_report() -> None: + date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC") + passed = [r for r in RESULTS if r.passed] + failed = [r for r in RESULTS if not r.passed] + + lines = [ + "# 🧪 Smoke-test отчёт (реальный юзер, реальная БД)", + "", + f"**Дата:** {date_str}", + f"**Итого:** {len(passed)}/{len(RESULTS)} сценариев прошли", + "", + ] + + if failed: + lines += ["## ❌ Не работает — нужно чинить", ""] + for r in failed: + lines += [ + f"### {r.name} ({r.section})", + f"- **Проблема:** {r.message}", + f"- **Детали:** `{r.details}`", + "", + ] + + if passed: + lines += ["## ✅ Подтверждено рабочим", ""] + for r in passed: + lines.append(f"- **{r.name}** ({r.section}) — {r.message}") + lines.append("") + + Path("smoke_test_report.md").write_text("\n".join(lines), encoding="utf-8") \ No newline at end of file