Добавлено: - 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 новых)
594 lines
24 KiB
Python
594 lines
24 KiB
Python
"""
|
||
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") |