def test_send_message(self, mocked_next_update_id: Mock,
mocked_next_message_id: Mock, mocked_now: Mock,
mocked_dispatcher: Mock):
now = timezone.datetime(2000, 1, 1, tzinfo=timezone.utc)
mocked_now.return_value = now
mocked_next_message_id.return_value = 42
mocked_next_update_id.return_value = 142
test_user = MockUser(bot=self.bot, username='******')
test_user.send_message("Help")
user = types.User(id=START_USER_ID,
is_bot=False,
username='******',
first_name='u',
last_name='u')
chat = types.Chat(id=START_USER_ID,
type='private',
username='******',
first_name='u',
last_name='u')
message = types.Message(message_id=42,
date=now,
chat=chat,
from_user=user,
text='Help')
update = types.Update(update_id=142, message=message)
update_data = update.to_dict(date_as_timestamp=True)
mocked_dispatcher.return_value.dispatch.assert_called_with(
update_data=update_data)
def send_message(
self,
chat_id: int,
text: str,
parse_mode: str = None,
entities: List[types.MessageEntity] = None,
disable_web_page_preview: bool = False,
disable_notification: bool = False,
reply_to_message_id: int = None,
allow_sending_without_reply: bool = True,
reply_markup: Union[types.ForceReply, types.InlineKeyboardMarkup,
types.ReplyKeyboardMarkup,
types.ReplyKeyboardRemove, ] = None,
) -> types.Message:
"""Use this method to send text messages."""
last_message = Message.objects.order_by("-message_id").first()
user = types.User(id=1, is_bot=True, username="******")
telegram_chat = types.Chat(id=chat_id, type="private")
message = types.Message(
message_id=last_message.message_id + 1,
date=timezone.now(),
chat=telegram_chat,
from_user=user,
text=text,
entities=entities,
reply_markup=reply_markup,
)
return message
def send_callback_query(self, data: str, markup_message: Message = None):
if markup_message is None:
last = self.messages().first()
if last is None or last.reply_markup is None:
raise ValueError("No ReplyMarkup to response")
else:
markup_message = last
callback_query = types.CallbackQuery(
id=self._next_callback_query_id(),
from_user=self._telegram_user(),
chat_instance=self._next_callback_query_id(),
message=types.Message(
message_id=markup_message.message_id,
chat=self._telegram_chat(),
date=markup_message.date,
),
data=data,
)
update = types.Update(
update_id=self._next_update_id(),
callback_query=callback_query,
)
self.dispatcher.dispatch(
update_data=update.to_dict(date_as_timestamp=True)
)
def test_send_callback_query_default_message(
self,
mocked_next_update_id: Mock,
mocked_next_message_id: Mock,
mocked_now: Mock,
mocked_dispatcher: Mock,
):
now = timezone.datetime(2000, 1, 1, tzinfo=timezone.utc)
mocked_now.return_value = now
mocked_next_message_id.return_value = 42
mocked_next_update_id.return_value = 142
test_user = ClientUser(self.bot, username="******")
message = Message.objects.create(
chat=test_user.chat,
date=timezone.now(),
message_id=test_user._next_message_id(),
text="Yes of No?",
_reply_markup=types.InlineKeyboardMarkup(inline_keyboard=[
[types.InlineKeyboardButton("Yes", callback_data="yes")],
[types.InlineKeyboardButton("No", callback_data="no")],
]).to_dict(),
)
test_user.send_callback_query(data="yes")
user = types.User(id=START_USER_ID,
is_bot=False,
username="******",
first_name="u",
last_name="u")
chat = types.Chat(
id=START_USER_ID,
type="private",
username="******",
first_name="u",
last_name="u",
)
message = types.Message(
message_id=message.message_id,
date=message.date,
chat=chat,
)
callback_query = types.CallbackQuery(id="1",
from_user=user,
chat_instance="1",
message=message,
data="yes")
update = types.Update(update_id=142, callback_query=callback_query)
update_data = update.to_dict(date_as_timestamp=True)
test_user.dispatcher.dispatch.assert_called_with(
update_data=update_data)
def send_message(self, message_text: str):
"""Simulate sending message to bot by the user."""
message = types.Message(
message_id=self._next_message_id(),
date=timezone.now(),
chat=self._telegram_chat(),
from_user=self._telegram_user(),
text=message_text,
entities=self._extract_entities(message_text),
)
update = types.Update(
update_id=self._next_update_id(),
message=message,
)
self.dispatcher.dispatch(update_data=update.to_dict(
date_as_timestamp=True))
def send_message_patch(self,
chat_id: int,
text: str,
parse_mode: str = None,
entities: List[types.MessageEntity] = None,
disable_web_page_preview: bool = False,
disable_notification: bool = False,
reply_to_message_id: int = None,
allow_sending_without_reply: bool = True,
reply_markup: Union[
types.ForceReply,
types.InlineKeyboardMarkup,
types.ReplyKeyboardMarkup,
types.ReplyKeyboardRemove,
] = None
) -> types.Message:
"""Use this method to send text messages.
"""
log.warning("send_message IS PATCHED!!!")
params = {
'chat_id': chat_id,
'text': text,
'entities': entities,
'parse_mode': parse_mode,
'disable_web_page_preview': disable_web_page_preview,
'disable_notification': disable_notification,
'reply_to_message_id': reply_to_message_id,
'allow_sending_without_reply': allow_sending_without_reply,
'reply_markup': reply_markup,
}
self.sent_messages.append(params)
last_message = Message.objects.order_by('-message_id').first()
user = types.User(id=1, is_bot=True, username="******")
telegram_chat = types.Chat(id=chat_id, type="private")
message = types.Message(
message_id=last_message.message_id + 1,
date=timezone.now(),
chat=telegram_chat,
from_user=user,
text=text,
entities=entities,
reply_markup=reply_markup,
)
return message
def test_send_message__with_commands(
self,
mocked_next_update_id: Mock,
mocked_next_message_id: Mock,
mocked_now: Mock,
mocked_dispatcher: Mock,
):
now = timezone.datetime(2000, 1, 1, tzinfo=timezone.utc)
mocked_now.return_value = now
mocked_next_message_id.return_value = 42
mocked_next_update_id.return_value = 142
test_user = ClientUser(bot=self.bot, username="******")
test_user.send_message("/start /help")
user = types.User(id=START_USER_ID,
is_bot=False,
username="******",
first_name="u",
last_name="u")
chat = types.Chat(
id=START_USER_ID,
type="private",
username="******",
first_name="u",
last_name="u",
)
message = types.Message(
message_id=42,
date=now,
chat=chat,
from_user=user,
text="/start /help",
entities=[
types.MessageEntity(type="bot_command", offset=0, length=6),
types.MessageEntity(type="bot_command", offset=7, length=5),
],
)
update = types.Update(update_id=142, message=message)
update_data = update.to_dict(date_as_timestamp=True)
test_user.dispatcher.dispatch.assert_called_with(
update_data=update_data)
def edit_message_text(
self,
text: str,
chat_id: Union[int, str] = None,
message_id: int = None,
inline_message_id: str = None,
parse_mode: str = None,
entities: List[types.MessageEntity] = None,
disable_web_page_preview: bool = False,
reply_markup: types.InlineKeyboardMarkup = None,
) -> types.Message:
"""Use this method to send text messages."""
user = types.User(id=1, is_bot=True, username="******")
telegram_chat = types.Chat(id=chat_id, type="private")
message = types.Message(
message_id=message_id,
date=timezone.now(),
chat=telegram_chat,
from_user=user,
text=text,
entities=entities,
reply_markup=reply_markup,
)
return message
