""" 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, которая чистит более короткий список таблиц. Смешивать их — риск ложных срабатываний в обоих наборах тестов. ФИКС (26.09.2026): testclient_asyncpg_conflict — TestClient (starlette) создаёт свой event loop для каждого запроса, а asyncpg-пул привязан к event loop, в котором создан. Второй запрос падал с InterfaceError: cannot perform operation: another operation is in progress. Решение: httpx.AsyncClient с ASGITransport — все запросы идут в том же event loop, что и pool, конфликта нет. РАСШИРЕНО (26.09.2026, вечер): волна 2 — + wordquiz_check_flow (правильный ответ → total_score растёт) + wordquiz_wrong_answer (неверный ответ → current_mistakes растёт) + bubblewords_complete_flow (levels_completed и total_score растут) + sentences_check_wrong (неверный ответ → score НЕ растёт) + typing_progress_flow (check → typing_progress.completed_at записан) + users_set_language (app_language меняется) + achievements_track_login (daily_logins.login_date записан) """ 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 httpx import pytest 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, voice_usage. 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): """Цикл на всю сессию: удалить → зарегистрировать → (тесты) → удалить → отчёт. ФИКС (26.09.2026): testclient_asyncpg_conflict — вместо TestClient используется httpx.AsyncClient с ASGITransport. Все запросы идут в том же event loop, что и asyncpg-пул (smoke_conn), поэтому соединение не «зависает» между запросами. """ await _cleanup(smoke_conn) init_data = _build_init_data(SMOKE_USER_ID, SMOKE_USER_FIRST_NAME, BOT_TOKEN) async with httpx.AsyncClient( transport=httpx.ASGITransport(app=app), base_url="http://test", headers={"Authorization": f"tma {init_data}"}, ) as client: resp = await 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 = await 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/пула" 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 # подтверждено: 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 = await 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}" 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 = await 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 = await 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 = await 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}" # ============================================================ # ВОЛНА 2 — остальные игры # ============================================================ async def test_wordquiz_correct_answer(smoke_user, smoke_conn): """POST /wordquiz/check с правильным ответом → total_score растёт. ВАЖНО: wordquiz.check доверяет клиенту (correct_polish приходит в body). Это by design (см. AI-находку wordquiz_check_trusts_client_correct_polish). Здесь проверяем только ФАКТ начисления очков в БД. """ client = smoke_user before = await smoke_conn.fetchval( "SELECT total_score FROM word_quiz_progress WHERE user_id = $1", SMOKE_USER_ID, ) or 0 resp = await client.post( "/wordquiz/check", json={"correct_polish": "kot", "answer": "kot", "completion_time": 5}, ) ok = resp.status_code == 200 body = resp.json() if ok else {} after = await smoke_conn.fetchval( "SELECT total_score FROM word_quiz_progress WHERE user_id = $1", SMOKE_USER_ID, ) or 0 correct_flag = body.get("correct") is True score_grew = after > before passed = ok and correct_flag and score_grew RESULTS.append(ScenarioResult( "wordquiz_correct_answer", "wordquiz", passed, f"status={resp.status_code}, correct={correct_flag}, total_score {before} → {after}", {"before": before, "after": after, "correct": correct_flag, "status": resp.status_code}, )) assert ok, f"POST /wordquiz/check вернул {resp.status_code}" assert correct_flag, f"API вернул correct=False на правильный ответ: {body}" assert score_grew, f"total_score не вырос: {before} → {after}" async def test_wordquiz_wrong_answer(smoke_user, smoke_conn): """POST /wordquiz/check с неверным ответом → current_mistakes растёт.""" client = smoke_user before = await smoke_conn.fetchval( "SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1", SMOKE_USER_ID, ) or 0 resp = await client.post( "/wordquiz/check", json={"correct_polish": "kot", "answer": "pies", "completion_time": 5}, ) ok = resp.status_code == 200 after = await smoke_conn.fetchval( "SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1", SMOKE_USER_ID, ) or 0 mistakes_grew = after > before passed = ok and mistakes_grew RESULTS.append(ScenarioResult( "wordquiz_wrong_answer", "wordquiz", passed, f"status={resp.status_code}, current_mistakes {before} → {after}", {"before": before, "after": after, "status": resp.status_code}, )) assert ok, f"POST /wordquiz/check вернул {resp.status_code}" assert mistakes_grew, f"current_mistakes не вырос: {before} → {after}" async def test_bubblewords_complete_flow(smoke_user, smoke_conn): """POST /bubblewords/complete → levels_completed и total_score растут. ВАЖНО: complete_bubble_level НЕ принимает hints_used от клиента — читает current_hints_used из БД (см. AI-фикс client_controlled_hints_bubblewords). """ client = smoke_user before = await smoke_conn.fetchrow( "SELECT levels_completed, total_score FROM bubble_words_progress WHERE user_id = $1", SMOKE_USER_ID, ) before_levels = before["levels_completed"] if before else 0 before_score = before["total_score"] if before else 0 resp = await client.post( "/bubblewords/complete", json={"words_count": 3, "completion_time": 30}, ) ok = resp.status_code == 200 body = resp.json() if ok else {} after = await smoke_conn.fetchrow( "SELECT levels_completed, total_score FROM bubble_words_progress WHERE user_id = $1", SMOKE_USER_ID, ) after_levels = after["levels_completed"] if after else 0 after_score = after["total_score"] if after else 0 levels_grew = after_levels > before_levels score_grew = after_score > before_score passed = ok and levels_grew and score_grew RESULTS.append(ScenarioResult( "bubblewords_complete_flow", "bubblewords", passed, f"status={resp.status_code}, levels {before_levels}→{after_levels}, score {before_score}→{after_score}", { "before_levels": before_levels, "after_levels": after_levels, "before_score": before_score, "after_score": after_score, "status": resp.status_code, }, )) assert ok, f"POST /bubblewords/complete вернул {resp.status_code}" assert levels_grew, f"levels_completed не вырос: {before_levels} → {after_levels}" assert score_grew, f"total_score не вырос: {before_score} → {after_score}" async def test_sentences_check_wrong(smoke_user, smoke_conn): """POST /sentences/check с неверными словами → score НЕ растёт. Сложность: правильный порядок слов угадать нельзя. Проверяем негативный сценарий: неверный ответ не должен начислять очки. """ client = smoke_user # Берём первое предложение из базы sentence_row = await smoke_conn.fetchrow( "SELECT id, sentence_pl FROM sentences ORDER BY id LIMIT 1" ) if not sentence_row: RESULTS.append(ScenarioResult( "sentences_check_wrong", "sentences", False, "В таблице sentences нет ни одного предложения", {}, )) pytest.skip("Нет предложений для теста") return sentence_id = sentence_row["id"] before = await smoke_conn.fetchval( "SELECT score FROM sentence_progress WHERE user_id = $1 AND sentence_id = $2", SMOKE_USER_ID, sentence_id, ) or 0 # Отправляем заведомо неверный набор слов resp = await client.post( "/sentences/check", json={ "sentence_id": sentence_id, "words": ["nie", "ma", "takiego", "slowa"], "completion_time": 10, }, ) ok = resp.status_code == 200 after = await smoke_conn.fetchval( "SELECT score FROM sentence_progress WHERE user_id = $1 AND sentence_id = $2", SMOKE_USER_ID, sentence_id, ) or 0 score_unchanged = after == before passed = ok and score_unchanged RESULTS.append(ScenarioResult( "sentences_check_wrong", "sentences", passed, f"status={resp.status_code}, score {before} → {after} (неверный ответ)", {"before": before, "after": after, "status": resp.status_code}, )) assert ok, f"POST /sentences/check вернул {resp.status_code}" assert score_unchanged, f"Очки начислены за неверный ответ: {before} → {after}" async def test_typing_progress_flow(smoke_user, smoke_conn): """GET /typing/next → POST /typing/check → typing_progress.completed_at записан.""" client = smoke_user resp_next = await client.get("/typing/next") if resp_next.status_code != 200: RESULTS.append(ScenarioResult( "typing_progress_flow", "typing", False, f"GET /typing/next вернул {resp_next.status_code}", {"status": resp_next.status_code}, )) pytest.skip(f"GET /typing/next вернул {resp_next.status_code}") return body = resp_next.json() sentence_id = body.get("id") or body.get("sentence_id") sentence_pl = body.get("sentence_pl", "") if not sentence_id or not sentence_pl: RESULTS.append(ScenarioResult( "typing_progress_flow", "typing", False, f"GET /typing/next не вернул id/sentence_pl: {body}", {"body": body}, )) pytest.skip("Нет данных для typing check") return # Отправляем правильный текст (само предложение) resp_check = await client.post( "/typing/check", json={"sentence_id": sentence_id, "text": sentence_pl}, ) ok = resp_check.status_code == 200 row = await smoke_conn.fetchrow( "SELECT completed_at FROM typing_progress WHERE user_id = $1 AND sentence_id = $2", SMOKE_USER_ID, sentence_id, ) recorded = row is not None and row["completed_at"] is not None passed = ok and recorded RESULTS.append(ScenarioResult( "typing_progress_flow", "typing", passed, f"status={resp_check.status_code}, typing_progress записан={recorded}", {"status": resp_check.status_code, "recorded": recorded}, )) assert ok, f"POST /typing/check вернул {resp_check.status_code}" assert recorded, "typing_progress.completed_at не записан в БД" # ============================================================ # ВОЛНА 2 — пользователь и достижения # ============================================================ async def test_users_set_language(smoke_user, smoke_conn): """POST /users/set-language → users.app_language меняется.""" client = smoke_user before = await smoke_conn.fetchval( "SELECT app_language FROM users WHERE telegram_id = $1", SMOKE_USER_ID, ) # Меняем на 'ru' (не 'pl', чтобы гарантированно отличалось) new_lang = "ru" if before != "ru" else "en" resp = await client.post("/users/set-language", json={"language": new_lang}) ok = resp.status_code == 200 after = await smoke_conn.fetchval( "SELECT app_language FROM users WHERE telegram_id = $1", SMOKE_USER_ID, ) lang_changed = after == new_lang passed = ok and lang_changed RESULTS.append(ScenarioResult( "users_set_language", "users", passed, f"status={resp.status_code}, app_language {before} → {after} (ожидали {new_lang})", {"before": before, "after": after, "expected": new_lang, "status": resp.status_code}, )) assert ok, f"POST /users/set-language вернул {resp.status_code}" assert lang_changed, f"app_language не изменился: {before} → {after}" async def test_achievements_track_login(smoke_user, smoke_conn): """POST /achievements/track-login → daily_logins.login_date записан.""" client = smoke_user before_count = await smoke_conn.fetchval( "SELECT COUNT(*) FROM daily_logins WHERE user_id = $1", SMOKE_USER_ID, ) or 0 resp = await client.post("/achievements/track-login") ok = resp.status_code == 200 after_count = await smoke_conn.fetchval( "SELECT COUNT(*) FROM daily_logins WHERE user_id = $1", SMOKE_USER_ID, ) or 0 logins_grew = after_count > before_count passed = ok and logins_grew RESULTS.append(ScenarioResult( "achievements_track_login", "achievements", passed, f"status={resp.status_code}, daily_logins {before_count} → {after_count}", {"before": before_count, "after": after_count, "status": resp.status_code}, )) assert ok, f"POST /achievements/track-login вернул {resp.status_code}" assert logins_grew, f"daily_logins не вырос: {before_count} → {after_count}" # ============ Отчёт ============ 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")