Files
filwordspl-backend/tests/test_smoke.py
T
Drobysh b883cd50bf 🧪 Smoke-test: волна 2 — +7 сценариев (wordquiz, bubblewords, sentences, typing, users, achievements)
Добавлено:
- wordquiz_correct_answer — total_score растёт при правильном ответе
- wordquiz_wrong_answer — current_mistakes растёт при неверном
- bubblewords_complete_flow — levels_completed + total_score растут
- sentences_check_wrong — неверный ответ НЕ начисляет очки
- typing_progress_flow — typing_progress.completed_at записан
- users_set_language — app_language меняется
- achievements_track_login — daily_logins.login_date записан

Покрытие: 10 сценариев (3 базовых + 7 новых)
2026-09-26 09:09:21 +00:00

594 lines
24 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""
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")