322 lines
14 KiB
Python
322 lines
14 KiB
Python
"""Drive real routers with disposable data; never call the Telegram network."""
|
|
import asyncio
|
|
import logging
|
|
from html.parser import HTMLParser
|
|
|
|
from aiogram import Bot
|
|
from sqlalchemy import func, select
|
|
import pytest
|
|
|
|
from src.core.database import async_session_maker
|
|
from src.core.models import Account, Lottery, Participation, User, Winner
|
|
from src.core.services import LotteryService, UserService
|
|
from src.handlers.account_services import AccountParticipationService
|
|
from test_dispatcher import TelegramStub, event
|
|
from test_text_inputs import context
|
|
|
|
ADMIN = 900001
|
|
CLIENT = 960001
|
|
ACCOUNT = "11-22-33-44-55-66-77"
|
|
SECOND = "88-99-00-11-22-33-44"
|
|
|
|
|
|
class TelegramHTML(HTMLParser):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.stack = []
|
|
|
|
def handle_starttag(self, tag, attrs):
|
|
assert tag in {"b", "strong", "i", "em", "u", "ins", "s", "strike", "del", "span",
|
|
"tg-spoiler", "a", "code", "pre", "blockquote", "tg-emoji"}, tag
|
|
self.stack.append(tag)
|
|
|
|
def handle_endtag(self, tag):
|
|
assert self.stack and self.stack.pop() == tag, tag
|
|
|
|
|
|
class CheckedTelegram(TelegramStub):
|
|
async def make_request(self, bot, method, timeout=None):
|
|
text = getattr(method, "text", None)
|
|
if text and method.__api_method__ in {"sendMessage", "editMessageText"}:
|
|
assert len(text.encode("utf-16-le")) // 2 <= 4096, "Telegram text exceeds 4096"
|
|
if getattr(method, "parse_mode", None) == "HTML":
|
|
parser = TelegramHTML()
|
|
parser.feed(text)
|
|
assert not parser.stack
|
|
markup = getattr(method, "reply_markup", None)
|
|
if markup and hasattr(markup, "inline_keyboard"):
|
|
for row in markup.inline_keyboard:
|
|
for button in row:
|
|
if button.callback_data:
|
|
assert 1 <= len(button.callback_data.encode()) <= 64
|
|
return await super().make_request(bot, method, timeout)
|
|
|
|
|
|
async def send(actor=ADMIN, *, text=None, callback=None, stub=None):
|
|
import main
|
|
if not main.dp.sub_routers:
|
|
main.configure_dispatcher()
|
|
transport = stub or CheckedTelegram()
|
|
bot = Bot("123456:TEST_TOKEN_FOR_ISOLATED_TESTS", session=transport)
|
|
await main.dp.feed_update(bot, event(actor, text=text, callback_data=callback))
|
|
return transport.calls
|
|
|
|
|
|
def output(calls):
|
|
return "\n".join(getattr(call, "text", "") or "" for call in calls)
|
|
|
|
|
|
def assert_clean(caplog):
|
|
failures = [r for r in caplog.records if r.levelno >= logging.ERROR]
|
|
assert not failures, [(r.message, str(r.exc_info[1]) if r.exc_info else "") for r in failures]
|
|
|
|
|
|
async def seed(*, title="Test draw", participants=True):
|
|
await context(ADMIN).clear()
|
|
await context(CLIENT).clear()
|
|
await context(900002).clear()
|
|
async with async_session_maker() as session:
|
|
admin = await UserService.get_or_create_user(session, ADMIN, first_name="Admin")
|
|
client = await UserService.get_or_create_user(session, CLIENT, first_name="Client")
|
|
client.club_card_number = "0007"
|
|
client.is_registered = True
|
|
client.verification_code = "TEST1234"
|
|
await session.commit()
|
|
lottery = await LotteryService.create_lottery(session, title, "Description", ["Prize A", "Prize B"], admin.id)
|
|
lottery_id, client_id = lottery.id, client.id
|
|
session.add_all([Account(account_number=ACCOUNT, owner_id=client_id),
|
|
Account(account_number=SECOND, owner_id=client_id)])
|
|
await session.commit()
|
|
if participants:
|
|
await AccountParticipationService.add_accounts_bulk(session, lottery_id, [ACCOUNT, SECOND])
|
|
return lottery_id, client_id
|
|
|
|
|
|
@pytest.mark.parametrize("route", ["detected", "command", "cashier", "bulk"])
|
|
async def test_duplicate_account_reports_and_finishes_dialog(route, caplog):
|
|
lottery_id, _ = await seed(title="Draw <September> & friends")
|
|
actor = 900002 if route == "cashier" else ADMIN
|
|
if route == "detected":
|
|
await send(text=f"0007 {ACCOUNT}")
|
|
await send(callback="account_action:add_to_lottery")
|
|
calls = await send(callback=f"add_accounts_to:{lottery_id}")
|
|
elif route == "command":
|
|
await context(actor).update_data(accounts=[{"account_number": ACCOUNT}])
|
|
calls = await send(callback=f"add_to_lottery_{lottery_id}")
|
|
elif route == "cashier":
|
|
await send(actor, text="/cashier")
|
|
await send(actor, callback=f"cash_add:{lottery_id}")
|
|
calls = await send(actor, text=ACCOUNT)
|
|
else:
|
|
await send(callback=f"admin_bulk_add_accounts_to_{lottery_id}")
|
|
calls = await send(text=ACCOUNT)
|
|
assert_clean(caplog)
|
|
assert "уже участвует" in output(calls)
|
|
assert await context(actor).get_state() is None
|
|
assert not await context(actor).get_data()
|
|
async with async_session_maker() as session:
|
|
assert await session.scalar(select(func.count(Participation.id))) == 2
|
|
|
|
|
|
@pytest.mark.parametrize("callback", [
|
|
"admin_participants_by_lottery", "admin_participants_report", "admin_edit_winner",
|
|
"admin_edit_winner_lottery_{id}", "admin_edit_lottery_select_{id}",
|
|
"admin_lottery_detail_{id}", "admin_participants_{id}", "admin_stats",
|
|
"admin_list_all_participants", "admin_users_list:1", "admin_winners",
|
|
"admin_system_info", "admin_broadcast", "admin_settings",
|
|
])
|
|
async def test_admin_menu_routes(callback, caplog):
|
|
lottery_id, _ = await seed()
|
|
calls = await send(callback=callback.format(id=lottery_id))
|
|
assert_clean(caplog)
|
|
assert calls, callback
|
|
assert "Кнопка устарела" not in output(calls)
|
|
|
|
|
|
async def test_delete_confirmation_executes_instead_of_reopening(caplog):
|
|
lottery_id, _ = await seed()
|
|
await send(callback=f"admin_del_lottery_{lottery_id}")
|
|
await send(callback=f"admin_del_lottery_yes_{lottery_id}")
|
|
assert_clean(caplog)
|
|
async with async_session_maker() as session:
|
|
assert await session.get(Lottery, lottery_id) is None
|
|
|
|
|
|
async def test_redraw_confirmation_reaches_execution(caplog):
|
|
lottery_id, _ = await seed()
|
|
async with async_session_maker() as session:
|
|
await LotteryService.conduct_draw(session, lottery_id)
|
|
calls = await send(callback=f"admin_redraw_confirm_{lottery_id}")
|
|
assert_clean(caplog)
|
|
assert "Нет просроченных" in output(calls)
|
|
|
|
|
|
@pytest.mark.parametrize("callback", ["winner_lottery:1", "winner_place:1", "add_accounts_to:1"])
|
|
async def test_expired_account_buttons_recover_without_error(callback, caplog):
|
|
await seed()
|
|
calls = await send(callback=callback)
|
|
assert_clean(caplog)
|
|
assert calls
|
|
|
|
|
|
async def test_client_account_registration_to_cashier_prize_claim(caplog):
|
|
lottery_id, _ = await seed(participants=False)
|
|
await send(CLIENT, text="/start")
|
|
calls = await send(CLIENT, text="/my_accounts")
|
|
assert ACCOUNT in output(calls)
|
|
await send(900002, callback=f"cash_add:{lottery_id}")
|
|
await send(900002, text=f"0007 {ACCOUNT}\n0007 {SECOND}")
|
|
await send(callback=f"admin_conduct_confirmed_{lottery_id}")
|
|
calls = await send(900002, text=f"/verify_winner TEST1234 {lottery_id}")
|
|
assert "подтвержден" in output(calls)
|
|
assert_clean(caplog)
|
|
async with async_session_maker() as session:
|
|
assert await session.scalar(select(func.count(Winner.id)).where(Winner.is_claimed.is_(True))) == 1
|
|
|
|
|
|
async def test_two_cashiers_share_draw_without_duplicate_tickets(caplog):
|
|
lottery_id, _ = await seed(participants=False)
|
|
async with async_session_maker() as session:
|
|
cashier = await UserService.get_or_create_user(session, 960002)
|
|
cashier.is_cashier = True
|
|
await session.commit()
|
|
for actor in (900002, 960002):
|
|
await send(actor, callback=f"cash_add:{lottery_id}")
|
|
calls = await asyncio.gather(send(900002, text=ACCOUNT), send(960002, text=ACCOUNT), send(CLIENT, text="/start"))
|
|
assert_clean(caplog)
|
|
assert sum("Добавлено: 1" in output(result) for result in calls) == 1
|
|
async with async_session_maker() as session:
|
|
assert await session.scalar(select(func.count(Participation.id))) == 1
|
|
|
|
|
|
async def test_new_card_ticket_is_created_and_visible_to_client(caplog):
|
|
lottery_id, client_id = await seed(participants=False)
|
|
new_account = "01-02-03-04-05-06-07"
|
|
await send(text=f"0007 {new_account}")
|
|
await send(callback="account_action:add_to_lottery")
|
|
calls = await send(callback=f"add_accounts_to:{lottery_id}")
|
|
assert "Добавлено: 1" in output(calls)
|
|
assert new_account in output(await send(CLIENT, text="/my_accounts"))
|
|
async with async_session_maker() as session:
|
|
account = await session.scalar(select(Account).where(Account.account_number == new_account))
|
|
participation = await session.scalar(select(Participation).where(Participation.account_number == new_account))
|
|
assert account.owner_id == participation.user_id == client_id
|
|
assert participation.account_id == account.id
|
|
assert_clean(caplog)
|
|
|
|
|
|
@pytest.mark.parametrize("route", ["admin_add_part_to_{id}", "admin_add_to_{id}", "admin_bulk_add_to_{id}"])
|
|
async def test_existing_user_addition_can_be_repeated(route, caplog):
|
|
lottery_id, _ = await seed()
|
|
for _ in range(2):
|
|
await send(callback=route.format(id=lottery_id))
|
|
await send(text=str(CLIENT))
|
|
assert_clean(caplog)
|
|
|
|
|
|
@pytest.mark.parametrize("action", ["add", "remove"])
|
|
async def test_detail_account_operations_cannot_change_closed_draw(action, caplog):
|
|
lottery_id, _ = await seed()
|
|
async with async_session_maker() as session:
|
|
await LotteryService.conduct_draw(session, lottery_id)
|
|
await send(callback=f"admin_{'add_to' if action == 'add' else 'remove_from'}_{lottery_id}")
|
|
await send(text="01-02-03-04-05-06-07" if action == "add" else ACCOUNT)
|
|
assert_clean(caplog)
|
|
async with async_session_maker() as session:
|
|
assert await session.scalar(select(func.count(Participation.id))) == 2
|
|
|
|
|
|
@pytest.mark.parametrize("callback", [
|
|
"admin_add_part_to_99999", "admin_bulk_add_to_99999", "admin_bulk_remove_from_99999",
|
|
"admin_bulk_add_accounts_to_99999", "admin_bulk_remove_accounts_from_99999",
|
|
"admin_confirm_finish_99999", "admin_confirm_delete_99999", "admin_set_display_99999",
|
|
])
|
|
async def test_deleted_lottery_buttons_recover(callback, caplog):
|
|
await seed()
|
|
assert output(await send(callback=callback))
|
|
assert_clean(caplog)
|
|
|
|
|
|
async def test_anonymous_winner_admin_pages(caplog):
|
|
lottery_id, _ = await seed()
|
|
async with async_session_maker() as session:
|
|
winner = Winner(lottery_id=lottery_id, account_number="01-02-03-04-05-06-07", place=1, prize="Prize")
|
|
session.add(winner)
|
|
await session.commit()
|
|
winner_id = winner.id
|
|
for callback in (f"admin_edit_winner_lottery_{lottery_id}", f"admin_edit_winner_id_{winner_id}",
|
|
f"admin_remove_winner_lottery_{lottery_id}", f"admin_confirm_remove_winner_{winner_id}",
|
|
f"admin_do_remove_winner_{winner_id}"):
|
|
await send(callback=callback)
|
|
assert_clean(caplog)
|
|
|
|
|
|
async def test_manual_winner_preserves_exact_account_and_rejects_second_place(caplog):
|
|
lottery_id, _ = await seed()
|
|
await send(text=f"0007 {SECOND}")
|
|
await send(callback="account_action:set_as_winner")
|
|
await send(callback=f"winner_lottery:{lottery_id}")
|
|
await send(callback="winner_place:1")
|
|
await send(text=f"0007 {SECOND}")
|
|
await send(callback="account_action:set_as_winner")
|
|
await send(callback=f"winner_lottery:{lottery_id}")
|
|
calls = await send(callback="winner_place:2")
|
|
assert "другое призовое место" in output(calls)
|
|
await send(callback=f"admin_conduct_confirmed_{lottery_id}")
|
|
assert_clean(caplog)
|
|
async with async_session_maker() as session:
|
|
winner = await session.scalar(select(Winner).where(Winner.place == 1))
|
|
assert winner.account_number == SECOND
|
|
|
|
|
|
async def test_registered_card_cannot_take_another_owner_account(caplog):
|
|
lottery_id, _ = await seed(participants=False)
|
|
async with async_session_maker() as session:
|
|
user = await UserService.get_or_create_user(session, 960003)
|
|
user.club_card_number = "0008"
|
|
await session.commit()
|
|
await send(text=f"0008 {ACCOUNT}")
|
|
await send(callback="account_action:add_to_lottery")
|
|
calls = await send(callback=f"add_accounts_to:{lottery_id}")
|
|
assert "не соответствует" in output(calls)
|
|
assert_clean(caplog)
|
|
async with async_session_maker() as session:
|
|
assert await session.scalar(select(func.count(Participation.id))) == 0
|
|
|
|
|
|
async def test_malformed_callback_ids_do_not_reach_database(caplog):
|
|
await seed()
|
|
for prefix in ("admin_participants_", "admin_edit_", "admin_del_lottery_", "admin_redraw_",
|
|
"add_accounts_to:", "winner_lottery:", "add_to_lottery_", "cash_add:",
|
|
"admin_users_list:", "admin_user_view:", "admin_message_delete_"):
|
|
for bad_id in ("abc", "-1", "0", "9" * 30):
|
|
calls = await send(callback=prefix + bad_id)
|
|
assert "Кнопка устарела" in output(calls)
|
|
assert_clean(caplog)
|
|
|
|
|
|
async def test_long_detected_account_list_keeps_action_buttons(caplog):
|
|
await seed(participants=False)
|
|
records = ["0007 " + "-".join(f"{i:014d}"[j:j+2] for j in range(0, 14, 2)) for i in range(120)]
|
|
calls = await send(text="\n".join(records))
|
|
pages = [call for call in calls if call.__api_method__ == "sendMessage"]
|
|
assert len(pages) > 1 and pages[-1].reply_markup
|
|
assert_clean(caplog)
|
|
|
|
|
|
async def test_new_account_race_between_different_lotteries():
|
|
lottery_id, _ = await seed(participants=False)
|
|
async with async_session_maker() as session:
|
|
admin_id = await session.scalar(select(User.id).where(User.telegram_id == ADMIN))
|
|
other = await LotteryService.create_lottery(session, "Second draw", "", ["Prize"], admin_id)
|
|
other_id = other.id
|
|
account = "01-02-03-04-05-06-07"
|
|
async def add(draw_id):
|
|
async with async_session_maker() as session:
|
|
return await AccountParticipationService.add_account_to_lottery(session, draw_id, "0007 " + account)
|
|
results = await asyncio.gather(add(lottery_id), add(other_id))
|
|
assert all(result["success"] for result in results)
|
|
async with async_session_maker() as session:
|
|
assert await session.scalar(select(func.count(Account.id)).where(Account.account_number == account)) == 1
|
|
assert await session.scalar(select(func.count(Participation.id))) == 2
|