# along with this program. If not, see [http://www.gnu.org/licenses/].
import re
from queue import Queue
import pytest
from telegram.utils.deprecate import TelegramDeprecationWarning
from telegram import (Message, Update, Chat, Bot, User, CallbackQuery, InlineQuery,
ChosenInlineResult, ShippingQuery, PreCheckoutQuery, MessageEntity)
from telegram.ext import CommandHandler, Filters, BaseFilter, CallbackContext, JobQueue, \
PrefixHandler
message = Message(1, User(1, '', False), None, Chat(1, ''), text='test')
params = [
{'callback_query': CallbackQuery(1, User(1, '', False), 'chat', message=message)},
{'channel_post': message},
{'edited_channel_post': message},
{'inline_query': InlineQuery(1, User(1, '', False), '', '')},
{'chosen_inline_result': ChosenInlineResult('id', User(1, '', False), '')},
{'shipping_query': ShippingQuery('id', User(1, '', False), '', None)},
{'pre_checkout_query': PreCheckoutQuery('id', User(1, '', False), '', 0, '')},
{'callback_query': CallbackQuery(1, User(1, '', False), 'chat')}
]
ids = ('callback_query', 'channel_post', 'edited_channel_post', 'inline_query',
'chosen_inline_result', 'shipping_query', 'pre_checkout_query',
'callback_query_without_message',)
@pytest.fixture(scope='class', params=params, ids=ids)
chat=Chat(1, Chat.SUPERGROUP),
from_user=User(1, "first_name", False),
date=from_timestamp(int(time.time())),
bio="bio",
)
params = [
{
"message": message
},
{
"edited_message": message
},
{
"callback_query":
CallbackQuery(1, User(1, "", False), "chat", message=message)
},
{
"channel_post": message
},
{
"edited_channel_post": message
},
{
"inline_query": InlineQuery(1, User(1, "", False), "", "")
},
{
"chosen_inline_result": ChosenInlineResult("id", User(1, "", False),
"")
},
{
def callback_query(bot):
return Update(0,
callback_query=CallbackQuery(2, None, None,
data='test data'))
def callback_query(bot):
return Update(0,
callback_query=CallbackQuery(2,
User(1, '', False),
None,
data='test data'))
def test_process_callback_query(self, callback_data_cache, data, message,
invalid):
"""This also tests large parts of process_message"""
changing_button_1 = InlineKeyboardButton('changing',
callback_data='some data 1')
changing_button_2 = InlineKeyboardButton('changing',
callback_data='some data 2')
non_changing_button = InlineKeyboardButton('non-changing',
url='https://ptb.org')
reply_markup = InlineKeyboardMarkup.from_row(
[non_changing_button, changing_button_1, changing_button_2])
out = callback_data_cache.process_keyboard(reply_markup)
if invalid:
callback_data_cache.clear_callback_data()
effective_message = Message(message_id=1,
date=None,
chat=None,
reply_markup=out)
effective_message.reply_to_message = deepcopy(effective_message)
effective_message.pinned_message = deepcopy(effective_message)
cq_id = uuid4().hex
callback_query = CallbackQuery(
cq_id,
from_user=None,
chat_instance=None,
# not all CallbackQueries have callback_data
data=out.inline_keyboard[0][1].callback_data if data else None,
# CallbackQueries from inline messages don't have the message attached, so we test that
message=effective_message if message else None,
)
callback_data_cache.process_callback_query(callback_query)
if not invalid:
if data:
assert callback_query.data == 'some data 1'
# make sure that we stored the mapping CallbackQuery.id -> keyboard_uuid correctly
assert len(callback_data_cache._keyboard_data) == 1
assert (callback_data_cache._callback_queries[cq_id] == list(
callback_data_cache._keyboard_data.keys())[0])
else:
assert callback_query.data is None
if message:
for msg in (
callback_query.message,
callback_query.message.reply_to_message,
callback_query.message.pinned_message,
):
assert msg.reply_markup == reply_markup
else:
if data:
assert isinstance(callback_query.data, InvalidCallbackData)
else:
assert callback_query.data is None
if message:
for msg in (
callback_query.message,
callback_query.message.reply_to_message,
callback_query.message.pinned_message,
):
assert isinstance(
msg.reply_markup.inline_keyboard[0][1].callback_data,
InvalidCallbackData,
)
assert isinstance(
msg.reply_markup.inline_keyboard[0][2].callback_data,
InvalidCallbackData,
)
def callback_query(bot):
return Update(0,
callback_query=CallbackQuery(2,
User(1, "", False),
None,
data="test data"))
import pytest
from telegram import (Update, Chat, Bot, ChosenInlineResult, User, Message,
CallbackQuery, InlineQuery, ShippingQuery,
PreCheckoutQuery)
from telegram.ext import PreCheckoutQueryHandler
message = Message(1, User(1, ''), None, Chat(1, ''), text='Text')
params = [{
'message': message
}, {
'edited_message': message
}, {
'callback_query':
CallbackQuery(1, User(1, ''), 'chat', message=message)
}, {
'channel_post': message
}, {
'edited_channel_post': message
}, {
'inline_query': InlineQuery(1, User(1, ''), '', '')
}, {
'chosen_inline_result': ChosenInlineResult('id', User(1, ''), '')
}, {
'shipping_query': ShippingQuery('id', User(1, ''), '', None)
}, {
'callback_query': CallbackQuery(1, User(1, ''), 'chat')
}]
ids = ('message', 'edited_message', 'callback_query', 'channel_post',
def test_per_chat_message_without_chat(self, bot, user1):
handler = ConversationHandler(
entry_points=[CommandHandler('start', self.start_end)], states={}, fallbacks=[])
cbq = CallbackQuery(0, user1, None, None, bot=bot)
update = Update(0, callback_query=cbq)
assert not handler.check_update(update)
def test_addConversationHandlerPerMessage(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
user = User(first_name="Misses Test", id=123)
second_user = User(first_name="Mister Test", id=124)
def entry(bot, update):
return 1
def one(bot, update):
return 2
def two(bot, update):
return ConversationHandler.END
handler = ConversationHandler(
entry_points=[CallbackQueryHandler(entry)],
states={
1: [CallbackQueryHandler(one)],
2: [CallbackQueryHandler(two)]
},
fallbacks=[],
per_message=True)
d.add_handler(handler)
queue = self.updater.start_polling(0.01)
# User one, starts the state machine.
message = Message(0,
user,
None,
self.group,
text="msg w/ inlinekeyboard",
bot=self.bot)
cbq = CallbackQuery(0,
user,
None,
message=message,
data='data',
bot=self.bot)
queue.put(Update(update_id=0, callback_query=cbq))
sleep(.1)
self.assertEquals(
handler.conversations[(self.group.id, user.id,
message.message_id)], 1)
cbq = CallbackQuery(0,
user,
None,
message=message,
data='data',
bot=self.bot)
queue.put(Update(update_id=0, callback_query=cbq))
sleep(.1)
self.assertEquals(
handler.conversations[(self.group.id, user.id,
message.message_id)], 2)
# Let's now verify that for a different user in the same group, the state will not be
# updated
cbq = CallbackQuery(0,
second_user,
None,
message=message,
data='data',
bot=self.bot)
queue.put(Update(update_id=0, callback_query=cbq))
sleep(.1)
self.assertEquals(
handler.conversations[(self.group.id, user.id,
message.message_id)], 2)
