367 lines
15 KiB
Python
367 lines
15 KiB
Python
"""Tests for refactored private handlers"""
|
||
|
||
from unittest.mock import AsyncMock, MagicMock, Mock, patch
|
||
|
||
import pytest
|
||
from aiogram import types
|
||
from aiogram.fsm.context import FSMContext
|
||
from helper_bot.handlers.private.constants import BUTTON_TEXTS, FSM_STATES
|
||
from helper_bot.handlers.private.private_handlers import (
|
||
PrivateHandlers,
|
||
create_private_handlers,
|
||
)
|
||
from helper_bot.handlers.private.services import BotSettings
|
||
|
||
|
||
class TestPrivateHandlers:
|
||
"""Test class for PrivateHandlers"""
|
||
|
||
@pytest.fixture
|
||
def mock_db(self):
|
||
"""Mock database"""
|
||
db = Mock()
|
||
db.user_exists = AsyncMock(return_value=False)
|
||
db.add_user = AsyncMock()
|
||
db.update_user_date = AsyncMock()
|
||
db.update_stickers_info = AsyncMock()
|
||
db.add_post = AsyncMock()
|
||
db.add_message = AsyncMock()
|
||
db.update_helper_message = AsyncMock()
|
||
db.update_user_activity = AsyncMock()
|
||
db.get_user_posts_stats = AsyncMock(return_value=(5, 2, 3))
|
||
db.get_last_post_by_author = AsyncMock(return_value="Last post text")
|
||
db.get_user_by_id = AsyncMock(return_value=Mock(date_added=1704067200))
|
||
db.get_user_ban_count = AsyncMock(return_value=0)
|
||
db.get_last_ban_info = AsyncMock(return_value=None)
|
||
return db
|
||
|
||
@pytest.fixture
|
||
def mock_settings(self):
|
||
"""Mock bot settings"""
|
||
return BotSettings(
|
||
group_for_posts="test_posts",
|
||
group_for_message="test_message",
|
||
main_public="test_public",
|
||
group_for_logs="test_logs",
|
||
important_logs="test_important",
|
||
preview_link="test_link",
|
||
logs="test_logs_setting",
|
||
test="test_test_setting",
|
||
)
|
||
|
||
@pytest.fixture
|
||
def mock_message(self):
|
||
"""Mock Telegram message"""
|
||
message = Mock(spec=types.Message)
|
||
# Создаем мок для from_user
|
||
from_user = Mock()
|
||
from_user.id = 12345
|
||
from_user.full_name = "Test User"
|
||
from_user.username = "testuser"
|
||
from_user.is_bot = False
|
||
from_user.language_code = "ru"
|
||
message.from_user = from_user
|
||
|
||
message.text = "test message"
|
||
message.message_id = 1
|
||
|
||
# Создаем мок для chat
|
||
chat = Mock()
|
||
chat.id = 12345
|
||
message.chat = chat
|
||
|
||
message.bot = Mock()
|
||
message.bot.send_message = AsyncMock()
|
||
message.forward = AsyncMock()
|
||
message.answer = AsyncMock()
|
||
message.answer_sticker = AsyncMock()
|
||
return message
|
||
|
||
@pytest.fixture
|
||
def mock_state(self):
|
||
"""Mock FSM state"""
|
||
state = Mock(spec=FSMContext)
|
||
state.set_state = AsyncMock()
|
||
state.get_state = AsyncMock(return_value=FSM_STATES["START"])
|
||
return state
|
||
|
||
def test_create_private_handlers(self, mock_db, mock_settings):
|
||
"""Test creating private handlers instance"""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
assert isinstance(handlers, PrivateHandlers)
|
||
assert handlers.db == mock_db
|
||
assert handlers.settings == mock_settings
|
||
|
||
def test_private_handlers_initialization(self, mock_db, mock_settings):
|
||
"""Test PrivateHandlers initialization"""
|
||
handlers = PrivateHandlers(mock_db, mock_settings)
|
||
assert handlers.db == mock_db
|
||
assert handlers.settings == mock_settings
|
||
assert handlers.user_service is not None
|
||
assert handlers.post_service is not None
|
||
assert handlers.sticker_service is not None
|
||
assert handlers.router is not None
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_handle_emoji_message(
|
||
self, mock_db, mock_settings, mock_message, mock_state
|
||
):
|
||
"""Test emoji message handler"""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
|
||
# Mock the check_user_emoji function
|
||
with pytest.MonkeyPatch().context() as m:
|
||
mock_check_emoji = AsyncMock(return_value="😊")
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.check_user_emoji",
|
||
mock_check_emoji,
|
||
)
|
||
|
||
# Test the handler
|
||
await handlers.handle_emoji_message(mock_message, mock_state)
|
||
|
||
# Verify state was set
|
||
mock_state.set_state.assert_called_once_with(FSM_STATES["START"])
|
||
|
||
# Verify message was logged
|
||
mock_message.forward.assert_called_once_with(
|
||
chat_id=mock_settings.group_for_logs
|
||
)
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_handle_emoji_message_no_emoji(
|
||
self, mock_db, mock_settings, mock_message, mock_state
|
||
):
|
||
"""handle_emoji_message при user_emoji=None не отправляет ответ с эмодзи."""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
with pytest.MonkeyPatch().context() as m:
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.check_user_emoji",
|
||
AsyncMock(return_value=None),
|
||
)
|
||
await handlers.handle_emoji_message(mock_message, mock_state)
|
||
mock_state.set_state.assert_called_once_with(FSM_STATES["START"])
|
||
mock_message.answer.assert_not_called()
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_handle_start_message(
|
||
self, mock_db, mock_settings, mock_message, mock_state
|
||
):
|
||
"""Test start message handler"""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
|
||
# Mock the get_first_name and messages functions
|
||
with pytest.MonkeyPatch().context() as m:
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.get_first_name",
|
||
lambda x: "Test",
|
||
)
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.messages.get_message",
|
||
lambda x, y: "Hello Test!",
|
||
)
|
||
mock_keyboard = AsyncMock(return_value=Mock())
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.get_reply_keyboard",
|
||
mock_keyboard,
|
||
)
|
||
|
||
# Test the handler
|
||
await handlers.handle_start_message(mock_message, mock_state)
|
||
|
||
# Verify state was set
|
||
mock_state.set_state.assert_called_once_with(FSM_STATES["START"])
|
||
|
||
# Verify user was ensured to exist
|
||
mock_db.add_user.assert_called_once()
|
||
mock_db.update_user_date.assert_called_once()
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_handle_restart_message(
|
||
self, mock_db, mock_settings, mock_message, mock_state
|
||
):
|
||
"""handle_restart_message перезапускает состояние и отправляет сообщение."""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
with pytest.MonkeyPatch().context() as m:
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.get_reply_keyboard",
|
||
AsyncMock(return_value=Mock()),
|
||
)
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.update_user_info",
|
||
AsyncMock(),
|
||
)
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.check_user_emoji",
|
||
AsyncMock(),
|
||
)
|
||
await handlers.handle_restart_message(mock_message, mock_state)
|
||
mock_state.set_state.assert_called_once_with(FSM_STATES["START"])
|
||
mock_message.answer.assert_called_once()
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_suggest_post(self, mock_db, mock_settings, mock_message, mock_state):
|
||
"""suggest_post переводит в состояние SUGGEST и отправляет текст."""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
with pytest.MonkeyPatch().context() as m:
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.messages.get_message",
|
||
lambda x, y: "Suggest text",
|
||
)
|
||
await handlers.suggest_post(mock_message, mock_state)
|
||
mock_state.set_state.assert_called_once_with(FSM_STATES["SUGGEST"])
|
||
mock_message.answer.assert_called_once()
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_end_message(self, mock_db, mock_settings, mock_message, mock_state):
|
||
"""end_message отправляет прощание и переводит в START."""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
with pytest.MonkeyPatch().context() as m:
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.messages.get_message",
|
||
lambda x, y: "Bye",
|
||
)
|
||
await handlers.end_message(mock_message, mock_state)
|
||
mock_state.set_state.assert_called_once_with(FSM_STATES["START"])
|
||
assert mock_message.answer.await_count >= 1
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_stickers(self, mock_db, mock_settings, mock_message, mock_state):
|
||
"""stickers обновляет инфо о стикерах и отправляет ссылку."""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
with pytest.MonkeyPatch().context() as m:
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.get_reply_keyboard",
|
||
AsyncMock(return_value=Mock()),
|
||
)
|
||
await handlers.stickers(mock_message, mock_state)
|
||
mock_db.update_stickers_info.assert_awaited_once_with(mock_message.from_user.id)
|
||
mock_state.set_state.assert_called_once_with(FSM_STATES["START"])
|
||
mock_message.answer.assert_called_once()
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_connect_with_admin(
|
||
self, mock_db, mock_settings, mock_message, mock_state
|
||
):
|
||
"""connect_with_admin переводит в PRE_CHAT и отправляет сообщение."""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
with pytest.MonkeyPatch().context() as m:
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.messages.get_message",
|
||
lambda x, y: "Admin contact",
|
||
)
|
||
await handlers.connect_with_admin(mock_message, mock_state)
|
||
mock_state.set_state.assert_called_once_with(FSM_STATES["PRE_CHAT"])
|
||
mock_message.answer.assert_called_once()
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_resend_message_in_group_pre_chat(
|
||
self, mock_db, mock_settings, mock_message, mock_state
|
||
):
|
||
"""resend_message_in_group при PRE_CHAT переводит в START и отправляет question."""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
mock_state.get_state = AsyncMock(return_value=FSM_STATES["PRE_CHAT"])
|
||
mock_message.bot.send_message = AsyncMock(return_value=Mock(message_id=100))
|
||
with pytest.MonkeyPatch().context() as m:
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.get_reply_keyboard",
|
||
AsyncMock(return_value=Mock()),
|
||
)
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.messages.get_message",
|
||
lambda x, y: "Question?",
|
||
)
|
||
await handlers.resend_message_in_group_for_message(mock_message, mock_state)
|
||
mock_message.bot.send_message.assert_called_once()
|
||
mock_state.set_state.assert_called_once_with(FSM_STATES["START"])
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_resend_message_in_group_chat(
|
||
self, mock_db, mock_settings, mock_message, mock_state
|
||
):
|
||
"""resend_message_in_group при CHAT оставляет в CHAT и отправляет question с leave markup."""
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
mock_state.get_state = AsyncMock(return_value=FSM_STATES["CHAT"])
|
||
mock_message.bot.send_message = AsyncMock(return_value=Mock(message_id=100))
|
||
with pytest.MonkeyPatch().context() as m:
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.get_reply_keyboard_leave_chat",
|
||
lambda: Mock(),
|
||
)
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.messages.get_message",
|
||
lambda x, y: "Question?",
|
||
)
|
||
await handlers.resend_message_in_group_for_message(mock_message, mock_state)
|
||
mock_message.bot.send_message.assert_called_once()
|
||
mock_message.answer.assert_called()
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_suggest_router_answers_and_schedules_background(
|
||
self, mock_db, mock_settings, mock_message, mock_state
|
||
):
|
||
"""suggest_router сразу отвечает и планирует фоновую обработку."""
|
||
mock_message.media_group_id = None
|
||
handlers = create_private_handlers(mock_db, mock_settings)
|
||
with pytest.MonkeyPatch().context() as m:
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.get_reply_keyboard",
|
||
AsyncMock(return_value=Mock()),
|
||
)
|
||
m.setattr(
|
||
"helper_bot.handlers.private.private_handlers.messages.get_message",
|
||
lambda x, y: "Success",
|
||
)
|
||
with patch.object(
|
||
handlers.post_service, "process_post", new_callable=AsyncMock
|
||
):
|
||
await handlers.suggest_router(mock_message, mock_state)
|
||
mock_state.set_state.assert_called_once_with(FSM_STATES["START"])
|
||
mock_message.answer.assert_called_once()
|
||
|
||
|
||
class TestBotSettings:
|
||
"""Test class for BotSettings dataclass"""
|
||
|
||
def test_bot_settings_creation(self):
|
||
"""Test creating BotSettings instance"""
|
||
settings = BotSettings(
|
||
group_for_posts="posts",
|
||
group_for_message="message",
|
||
main_public="public",
|
||
group_for_logs="logs",
|
||
important_logs="important",
|
||
preview_link="link",
|
||
logs="logs_setting",
|
||
test="test_setting",
|
||
)
|
||
|
||
assert settings.group_for_posts == "posts"
|
||
assert settings.group_for_message == "message"
|
||
assert settings.main_public == "public"
|
||
assert settings.group_for_logs == "logs"
|
||
assert settings.important_logs == "important"
|
||
assert settings.preview_link == "link"
|
||
assert settings.logs == "logs_setting"
|
||
assert settings.test == "test_setting"
|
||
|
||
|
||
class TestConstants:
|
||
"""Test class for constants"""
|
||
|
||
def test_fsm_states(self):
|
||
"""Test FSM states constants"""
|
||
assert FSM_STATES["START"] == "START"
|
||
assert FSM_STATES["SUGGEST"] == "SUGGEST"
|
||
assert FSM_STATES["PRE_CHAT"] == "PRE_CHAT"
|
||
assert FSM_STATES["CHAT"] == "CHAT"
|
||
|
||
def test_button_texts(self):
|
||
"""Test button text constants"""
|
||
assert BUTTON_TEXTS["SUGGEST_POST"] == "📢Предложить свой пост"
|
||
assert BUTTON_TEXTS["SAY_GOODBYE"] == "👋🏼Сказать пока!"
|
||
assert BUTTON_TEXTS["LEAVE_CHAT"] == "Выйти из чата"
|
||
assert BUTTON_TEXTS["RETURN_TO_BOT"] == "Вернуться в бота"
|
||
assert BUTTON_TEXTS["WANT_STICKERS"] == "🤪Хочу стикеры"
|
||
assert BUTTON_TEXTS["CONNECT_ADMIN"] == "📩Связаться с админами"
|