def de_json(data):
"""
Args:
data (dict):
Returns:
telegram.Message:
"""
if not data:
return None
data['from_user'] = User.de_json(data.get('from'))
data['date'] = datetime.fromtimestamp(data['date'])
data['chat'] = Chat.de_json(data.get('chat'))
data['entities'] = MessageEntity.de_list(data.get('entities'))
data['forward_from'] = User.de_json(data.get('forward_from'))
data['forward_date'] = Message._fromtimestamp(data.get('forward_date'))
data['reply_to_message'] = \
Message.de_json(data.get('reply_to_message'))
data['audio'] = Audio.de_json(data.get('audio'))
data['document'] = Document.de_json(data.get('document'))
data['photo'] = PhotoSize.de_list(data.get('photo'))
data['sticker'] = Sticker.de_json(data.get('sticker'))
data['video'] = Video.de_json(data.get('video'))
data['voice'] = Voice.de_json(data.get('voice'))
data['contact'] = Contact.de_json(data.get('contact'))
data['location'] = Location.de_json(data.get('location'))
data['venue'] = Venue.de_json(data.get('venue'))
data['new_chat_member'] = User.de_json(data.get('new_chat_member'))
data['left_chat_member'] = User.de_json(data.get('left_chat_member'))
data['new_chat_photo'] = PhotoSize.de_list(data.get('new_chat_photo'))
data['pinned_message'] = Message.de_json(data.get('pinned_message'))
return Message(**data)
def de_json(cls, data, bot):
if not data:
return None
data = super(Message, cls).de_json(data, bot)
data['from_user'] = User.de_json(data.get('from'), bot)
data['date'] = from_timestamp(data['date'])
data['chat'] = Chat.de_json(data.get('chat'), bot)
data['entities'] = MessageEntity.de_list(data.get('entities'), bot)
data['forward_from'] = User.de_json(data.get('forward_from'), bot)
data['forward_from_chat'] = Chat.de_json(data.get('forward_from_chat'), bot)
data['forward_date'] = from_timestamp(data.get('forward_date'))
data['reply_to_message'] = Message.de_json(data.get('reply_to_message'), bot)
data['edit_date'] = from_timestamp(data.get('edit_date'))
data['audio'] = Audio.de_json(data.get('audio'), bot)
data['document'] = Document.de_json(data.get('document'), bot)
data['game'] = Game.de_json(data.get('game'), bot)
data['photo'] = PhotoSize.de_list(data.get('photo'), bot)
data['sticker'] = Sticker.de_json(data.get('sticker'), bot)
data['video'] = Video.de_json(data.get('video'), bot)
data['voice'] = Voice.de_json(data.get('voice'), bot)
data['video_note'] = VideoNote.de_json(data.get('video_note'), bot)
data['contact'] = Contact.de_json(data.get('contact'), bot)
data['location'] = Location.de_json(data.get('location'), bot)
data['venue'] = Venue.de_json(data.get('venue'), bot)
data['new_chat_member'] = User.de_json(data.get('new_chat_member'), bot)
data['new_chat_members'] = User.de_list(data.get('new_chat_members'), bot)
data['left_chat_member'] = User.de_json(data.get('left_chat_member'), bot)
data['new_chat_photo'] = PhotoSize.de_list(data.get('new_chat_photo'), bot)
data['pinned_message'] = Message.de_json(data.get('pinned_message'), bot)
data['invoice'] = Invoice.de_json(data.get('invoice'), bot)
data['successful_payment'] = SuccessfulPayment.de_json(data.get('successful_payment'), bot)
return cls(bot=bot, **data)
def de_json(data):
"""
Args:
data (str):
Returns:
telegram.Message:
"""
if not data:
return None
data['from_user'] = User.de_json(data.get('from'))
data['date'] = datetime.fromtimestamp(data['date'])
if 'first_name' in data.get('chat', ''):
data['chat'] = User.de_json(data.get('chat'))
elif 'title' in data.get('chat', ''):
data['chat'] = GroupChat.de_json(data.get('chat'))
data['forward_from'] = \
User.de_json(data.get('forward_from'))
data['forward_date'] = \
Message._fromtimestamp(data.get('forward_date'))
data['reply_to_message'] = \
Message.de_json(data.get('reply_to_message'))
data['audio'] = \
Audio.de_json(data.get('audio'))
data['document'] = \
Document.de_json(data.get('document'))
data['photo'] = \
PhotoSize.de_list(data.get('photo'))
data['sticker'] = \
Sticker.de_json(data.get('sticker'))
data['video'] = \
Video.de_json(data.get('video'))
data['voice'] = \
Voice.de_json(data.get('voice'))
data['contact'] = \
Contact.de_json(data.get('contact'))
data['location'] = \
Location.de_json(data.get('location'))
data['new_chat_participant'] = \
User.de_json(data.get('new_chat_participant'))
data['left_chat_participant'] = \
User.de_json(data.get('left_chat_participant'))
data['new_chat_photo'] = \
PhotoSize.de_list(data.get('new_chat_photo'))
return Message(**data)
def de_json(data):
if not data:
return None
data['from_user'] = User.de_json(data.get('from'))
data['message'] = Message.de_json(data.get('message'))
return CallbackQuery(**data)
def test_de_json(self, json_dict, bot):
user = User.de_json(json_dict, bot)
assert user.id == self.id
assert user.is_bot == self.is_bot
assert user.first_name == self.first_name
assert user.last_name == self.last_name
assert user.username == self.username
assert user.language_code == self.language_code
def de_json(cls, data, bot):
data = super(MessageEntity, cls).de_json(data, bot)
if not data:
return None
data['user'] = User.de_json(data.get('user'), bot)
return cls(**data)
def de_json(cls, data, bot):
if not data:
return None
data = super(GameHighScore, cls).de_json(data, bot)
data['user'] = User.de_json(data.get('user'), bot)
return cls(**data)
def de_json(cls, data, bot):
data = super(InlineQuery, cls).de_json(data, bot)
if not data:
return None
data['from_user'] = User.de_json(data.get('from'), bot)
data['location'] = Location.de_json(data.get('location'), bot)
return cls(bot=bot, **data)
def de_json(cls, data, bot):
if not data:
return None
data = super(PreCheckoutQuery, cls).de_json(data, bot)
data['from_user'] = User.de_json(data.pop('from'), bot)
data['order_info'] = OrderInfo.de_json(data.get('order_info'), bot)
return cls(**data)
def de_json(cls, data, bot):
if not data:
return None
data = super(ChatMember, cls).de_json(data, bot)
data['user'] = User.de_json(data.get('user'), bot)
data['until_date'] = from_timestamp(data.get('until_date', None))
return cls(**data)
def de_json(cls, data, bot):
if not data:
return None
data = super(ShippingQuery, cls).de_json(data, bot)
data['from_user'] = User.de_json(data.pop('from'), bot)
data['shipping_address'] = ShippingAddress.de_json(data.get('shipping_address'), bot)
return cls(**data)
def de_json(cls, data, bot):
if not data:
return None
data = super(CallbackQuery, cls).de_json(data, bot)
data['from_user'] = User.de_json(data.get('from'), bot)
data['message'] = Message.de_json(data.get('message'), bot)
return cls(bot=bot, **data)
def de_json(cls, data, bot):
if not data:
return None
data = super(ChosenInlineResult, cls).de_json(data, bot)
# Required
data['from_user'] = User.de_json(data.pop('from'), bot)
# Optionals
data['location'] = Location.de_json(data.get('location'), bot)
return cls(**data)
def test_de_json_without_username(self, json_dict, bot):
del json_dict['username']
user = User.de_json(json_dict, bot)
assert user.id == self.id
assert user.is_bot == self.is_bot
assert user.first_name == self.first_name
assert user.last_name == self.last_name
assert user.username is None
assert user.language_code == self.language_code
def getMe(self):
"""A simple method for testing your bot's auth token.
Returns:
A telegram.User instance representing that bot if the
credentials are valid, None otherwise.
"""
url = "%s/getMe" % (self.base_url)
json_data = self._requestUrl(url, "GET")
data = self._parseAndCheckTelegram(json_data.decode())
return User.de_json(data)
def getMe(self):
"""A simple method for testing your bot's auth token.
Returns:
A telegram.User instance representing that bot if the
credentials are valid, None otherwise.
"""
url = '%s/getMe' % self.base_url
result = request.get(url)
self.bot = User.de_json(result)
return self.bot
def de_json(data):
"""
Args:
data (dict):
Returns:
telegram.InlineQuery:
"""
if not data:
return None
data = data.copy()
data['from_user'] = User.de_json(data.pop('from'))
return InlineQuery(**data)
def de_json(data):
"""
Args:
data (dict):
Returns:
telegram.ChatMember:
"""
if not data:
return None
data['user'] = User.de_json(data.get('user'))
return ChatMember(**data)
def de_json(data):
"""
Args:
data (dict):
Returns:
telegram.ChosenInlineResult:
"""
if not data:
return None
data = data.copy()
data['from_user'] = User.de_json(data.pop('from'))
return ChosenInlineResult(**data)
def de_json(data, bot):
"""
Args:
data (dict):
bot (telegram.Bot):
Returns:
telegram.Game:
"""
if not data:
return None
data['user'] = User.de_json(data.get('user'), bot)
return GameHighScore(**data)
def de_json(data, bot):
"""
Args:
data (dict):
bot (telegram.Bot):
Returns:
telegram.ChatMember:
"""
if not data:
return None
data["user"] = User.de_json(data.get("user"), bot)
return ChatMember(**data)
def de_json(data):
"""
Args:
data (dict):
Returns:
telegram.InlineQuery:
"""
data = super(InlineQuery, InlineQuery).de_json(data)
if not data:
return None
data['from_user'] = User.de_json(data.get('from'))
data['location'] = Location.de_json(data.get('location'))
return InlineQuery(**data)
def de_json(data):
"""
Args:
data (dict):
Returns:
telegram.ChosenInlineResult:
"""
if not data:
return None
# Required
data['from_user'] = User.de_json(data.pop('from'))
# Optionals
data['location'] = Location.de_json(data.get('location'))
return ChosenInlineResult(**data)
def de_json(data, bot):
"""
Args:
data (dict):
bot (telegram.Bot):
Returns:
telegram.CallbackQuery:
"""
if not data:
return None
data['from_user'] = User.de_json(data.get('from'), bot)
data['message'] = Message.de_json(data.get('message'), bot)
return CallbackQuery(bot=bot, **data)
def de_json(data, bot):
"""
Args:
data (dict):
bot (telegram.Bot):
Returns:
telegram.PreCheckoutQuery:
"""
if not data:
return None
data = super(PreCheckoutQuery, PreCheckoutQuery).de_json(data, bot)
data['from_user'] = User.de_json(data.pop('from'), bot)
data['order_info'] = OrderInfo.de_json(data.get('order_info'), bot)
return PreCheckoutQuery(**data)
def de_json(data, bot):
"""
Args:
data (dict):
bot (telegram.Bot):
Returns:
telegram.ShippingQuery:
"""
if not data:
return None
data = super(ShippingQuery, ShippingQuery).de_json(data, bot)
data['from_user'] = User.de_json(data.pop('from'), bot)
data['shipping_address'] = ShippingAddress.de_json(data.get('shipping_address'), bot)
return ShippingQuery(**data)
def de_json(data, bot):
"""
Args:
data (dict):
bot (telegram.Bot):
Returns:
telegram.ChosenInlineResult:
"""
if not data:
return None
data = super(ChosenInlineResult, ChosenInlineResult).de_json(data, bot)
# Required
data['from_user'] = User.de_json(data.pop('from'), bot)
# Optionals
data['location'] = Location.de_json(data.get('location'), bot)
return ChosenInlineResult(**data)
def getMe(self):
"""A simple method for testing your bot's auth token.
Returns:
:class:`telegram.User`: A :class:`telegram.User` instance
representing that bot if the credentials are valid, `None`
otherwise.
Raises:
:class:`telegram.TelegramError`
"""
url = '{0}/getMe'.format(self.base_url)
result = request.get(url)
self.bot = User.de_json(result)
return self.bot
def test_persisting_no_user_no_chat(self, cdp):
class OwnPersistence(BasePersistence):
def __init__(self):
super().__init__()
self.store_user_data = True
self.store_chat_data = True
self.store_bot_data = True
self.test_flag_bot_data = False
self.test_flag_chat_data = False
self.test_flag_user_data = False
def update_bot_data(self, data):
self.test_flag_bot_data = True
def update_chat_data(self, chat_id, data):
self.test_flag_chat_data = True
def update_user_data(self, user_id, data):
self.test_flag_user_data = True
def update_conversation(self, name, key, new_state):
pass
def get_conversations(self, name):
pass
def get_user_data(self):
pass
def get_bot_data(self):
pass
def get_chat_data(self):
pass
def callback(update, context):
pass
handler = MessageHandler(Filters.all, callback)
cdp.add_handler(handler)
cdp.persistence = OwnPersistence()
update = Update(1,
message=Message(1,
None,
None,
from_user=User(1, '', False),
text='Text'))
cdp.process_update(update)
assert cdp.persistence.test_flag_bot_data
assert cdp.persistence.test_flag_user_data
assert not cdp.persistence.test_flag_chat_data
cdp.persistence.test_flag_bot_data = False
cdp.persistence.test_flag_user_data = False
cdp.persistence.test_flag_chat_data = False
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=None,
text='Text'))
cdp.process_update(update)
assert cdp.persistence.test_flag_bot_data
assert not cdp.persistence.test_flag_user_data
assert cdp.persistence.test_flag_chat_data
def test_webhook(self):
print('Testing Webhook')
bot = MockBot('', messages=0)
self.updater.bot = bot
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
# Select random port for travis
port = randrange(1024, 49152)
self.updater.start_webhook('127.0.0.1',
port,
'./tests/test_updater.py',
'./tests/test_updater.py',
listen='127.0.0.1')
sleep(0.5)
# SSL-Wrapping will fail, so we start the server without SSL
Thread(target=self.updater.httpd.serve_forever).start()
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester"), datetime.now(),
GroupChat(1, "Test Group"))
message.text = "Webhook Test"
update = Update(1)
update.message = message
try:
payload = bytes(update.to_json(), encoding='utf-8')
except TypeError:
payload = bytes(update.to_json())
header = {
'content-type': 'application/json',
'content-length': str(len(payload))
}
r = Request('http://127.0.0.1:%d/TOKEN' % port,
data=payload,
headers=header)
urlopen(r)
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test')
print("Test other webhook server functionalites...")
request = Request('http://localhost:%d/webookhandler.py' % port)
response = urlopen(request)
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
request.get_method = lambda: 'HEAD'
response = urlopen(request)
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
# Test multiple shutdown() calls
self.updater.httpd.shutdown()
self.updater.httpd.shutdown()
self.assertTrue(True)
def de_json(data, bot):
data = super(MessageEntity, MessageEntity).de_json(data, bot)
data['user'] = User.de_json(data.get('user'), bot)
return MessageEntity(**data)
class TestDispatcher:
message_update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=User(1, '', False),
text='Text'))
received = None
count = 0
@pytest.fixture(autouse=True, name='reset')
def reset_fixture(self):
self.reset()
def reset(self):
self.received = None
self.count = 0
def error_handler(self, bot, update, error):
self.received = error.message
def error_handler_context(self, update, context):
self.received = context.error.message
def error_handler_raise_error(self, bot, update, error):
raise Exception('Failing bigly')
def callback_increase_count(self, bot, update):
self.count += 1
def callback_set_count(self, count):
def callback(bot, update):
self.count = count
return callback
def callback_raise_error(self, bot, update):
if isinstance(bot, Bot):
raise TelegramError(update.message.text)
raise TelegramError(bot.message.text)
def callback_if_not_update_queue(self, bot, update, update_queue=None):
if update_queue is not None:
self.received = update.message
def callback_context(self, update, context):
if (isinstance(context, CallbackContext)
and isinstance(context.bot, Bot)
and isinstance(context.update_queue, Queue)
and isinstance(context.job_queue, JobQueue)
and isinstance(context.error, TelegramError)):
self.received = context.error.message
def test_one_context_per_update(self, cdp):
def one(update, context):
if update.message.text == 'test':
context.my_flag = True
def two(update, context):
if update.message.text == 'test':
if not hasattr(context, 'my_flag'):
pytest.fail()
else:
if hasattr(context, 'my_flag'):
pytest.fail()
cdp.add_handler(MessageHandler(Filters.regex('test'), one), group=1)
cdp.add_handler(MessageHandler(None, two), group=2)
u = Update(1, Message(1, None, None, None, text='test'))
cdp.process_update(u)
u.message.text = 'something'
cdp.process_update(u)
def test_error_handler(self, dp):
dp.add_error_handler(self.error_handler)
error = TelegramError('Unauthorized.')
dp.update_queue.put(error)
sleep(0.1)
assert self.received == 'Unauthorized.'
# Remove handler
dp.remove_error_handler(self.error_handler)
self.reset()
dp.update_queue.put(error)
sleep(0.1)
assert self.received is None
def test_double_add_error_handler(self, dp, caplog):
dp.add_error_handler(self.error_handler)
with caplog.at_level(logging.DEBUG):
dp.add_error_handler(self.error_handler)
assert len(caplog.records) == 1
assert caplog.records[-1].getMessage().startswith(
'The callback is already registered')
def test_construction_with_bad_persistence(self, caplog, bot):
class my_per:
def __init__(self):
self.store_user_data = False
self.store_chat_data = False
self.store_bot_data = False
with pytest.raises(
TypeError,
match=
'persistence must be based on telegram.ext.BasePersistence'):
Dispatcher(bot, None, persistence=my_per())
def test_error_handler_that_raises_errors(self, dp):
"""
Make sure that errors raised in error handlers don't break the main loop of the dispatcher
"""
handler_raise_error = MessageHandler(Filters.all,
self.callback_raise_error)
handler_increase_count = MessageHandler(Filters.all,
self.callback_increase_count)
error = TelegramError('Unauthorized.')
dp.add_error_handler(self.error_handler_raise_error)
# From errors caused by handlers
dp.add_handler(handler_raise_error)
dp.update_queue.put(self.message_update)
sleep(0.1)
# From errors in the update_queue
dp.remove_handler(handler_raise_error)
dp.add_handler(handler_increase_count)
dp.update_queue.put(error)
dp.update_queue.put(self.message_update)
sleep(0.1)
assert self.count == 1
@pytest.mark.parametrize(['run_async', 'expected_output'], [(True, 5),
(False, 0)])
def test_default_run_async_error_handler(self, dp, monkeypatch, run_async,
expected_output):
def mock_async_err_handler(*args, **kwargs):
self.count = 5
# set defaults value to dp.bot
dp.bot.defaults = Defaults(run_async=run_async)
try:
dp.add_handler(
MessageHandler(Filters.all, self.callback_raise_error))
dp.add_error_handler(self.error_handler)
monkeypatch.setattr(dp, 'run_async', mock_async_err_handler)
dp.process_update(self.message_update)
assert self.count == expected_output
finally:
# reset dp.bot.defaults values
dp.bot.defaults = None
@pytest.mark.parametrize(['run_async', 'expected_output'],
[(True, 'running async'), (False, None)])
def test_default_run_async(self, monkeypatch, dp, run_async,
expected_output):
def mock_run_async(*args, **kwargs):
self.received = 'running async'
# set defaults value to dp.bot
dp.bot.defaults = Defaults(run_async=run_async)
try:
dp.add_handler(MessageHandler(Filters.all, lambda u, c: None))
monkeypatch.setattr(dp, 'run_async', mock_run_async)
dp.process_update(self.message_update)
assert self.received == expected_output
finally:
# reset defaults value
dp.bot.defaults = None
def test_run_async_multiple(self, bot, dp, dp2):
def get_dispatcher_name(q):
q.put(current_thread().name)
q1 = Queue()
q2 = Queue()
dp.run_async(get_dispatcher_name, q1)
dp2.run_async(get_dispatcher_name, q2)
sleep(0.1)
name1 = q1.get()
name2 = q2.get()
assert name1 != name2
def test_multiple_run_async_decorator(self, dp, dp2):
# Make sure we got two dispatchers and that they are not the same
assert isinstance(dp, Dispatcher)
assert isinstance(dp2, Dispatcher)
assert dp is not dp2
@run_async
def must_raise_runtime_error():
pass
with pytest.raises(RuntimeError):
must_raise_runtime_error()
def test_run_async_with_args(self, dp):
dp.add_handler(
MessageHandler(Filters.all,
run_async(self.callback_if_not_update_queue),
pass_update_queue=True))
dp.update_queue.put(self.message_update)
sleep(0.1)
assert self.received == self.message_update.message
def test_multiple_run_async_deprecation(self, dp):
assert isinstance(dp, Dispatcher)
@run_async
def callback(update, context):
pass
dp.add_handler(MessageHandler(Filters.all, callback))
with pytest.warns(TelegramDeprecationWarning,
match='@run_async decorator'):
dp.process_update(self.message_update)
def test_async_raises_dispatcher_handler_stop(self, dp, caplog):
@run_async
def callback(update, context):
raise DispatcherHandlerStop()
dp.add_handler(MessageHandler(Filters.all, callback))
with caplog.at_level(logging.WARNING):
dp.update_queue.put(self.message_update)
sleep(0.1)
assert len(caplog.records) == 1
assert (caplog.records[-1].getMessage().startswith(
'DispatcherHandlerStop is not supported '
'with async functions'))
def test_async_raises_exception(self, dp, caplog):
@run_async
def callback(update, context):
raise RuntimeError('async raising exception')
dp.add_handler(MessageHandler(Filters.all, callback))
with caplog.at_level(logging.WARNING):
dp.update_queue.put(self.message_update)
sleep(0.1)
assert len(caplog.records) == 1
assert (caplog.records[-1].getMessage().startswith(
'A promise with deactivated error handling'))
def test_add_async_handler(self, dp):
dp.add_handler(
MessageHandler(
Filters.all,
self.callback_if_not_update_queue,
pass_update_queue=True,
run_async=True,
))
dp.update_queue.put(self.message_update)
sleep(0.1)
assert self.received == self.message_update.message
def test_run_async_no_error_handler(self, dp, caplog):
def func():
raise RuntimeError('Async Error')
with caplog.at_level(logging.ERROR):
dp.run_async(func)
sleep(0.1)
assert len(caplog.records) == 1
assert caplog.records[-1].getMessage().startswith(
'No error handlers are registered')
def test_async_handler_error_handler(self, dp):
dp.add_handler(
MessageHandler(Filters.all,
self.callback_raise_error,
run_async=True))
dp.add_error_handler(self.error_handler)
dp.update_queue.put(self.message_update)
sleep(0.1)
assert self.received == self.message_update.message.text
def test_async_handler_async_error_handler_context(self, cdp):
cdp.add_handler(
MessageHandler(Filters.all,
self.callback_raise_error,
run_async=True))
cdp.add_error_handler(self.error_handler_context, run_async=True)
cdp.update_queue.put(self.message_update)
sleep(2)
assert self.received == self.message_update.message.text
def test_async_handler_error_handler_that_raises_error(self, dp, caplog):
handler = MessageHandler(Filters.all,
self.callback_raise_error,
run_async=True)
dp.add_handler(handler)
dp.add_error_handler(self.error_handler_raise_error, run_async=False)
with caplog.at_level(logging.ERROR):
dp.update_queue.put(self.message_update)
sleep(0.1)
assert len(caplog.records) == 1
assert caplog.records[-1].getMessage().startswith(
'An uncaught error was raised')
# Make sure that the main loop still runs
dp.remove_handler(handler)
dp.add_handler(
MessageHandler(Filters.all,
self.callback_increase_count,
run_async=True))
dp.update_queue.put(self.message_update)
sleep(0.1)
assert self.count == 1
def test_async_handler_async_error_handler_that_raises_error(
self, dp, caplog):
handler = MessageHandler(Filters.all,
self.callback_raise_error,
run_async=True)
dp.add_handler(handler)
dp.add_error_handler(self.error_handler_raise_error, run_async=True)
with caplog.at_level(logging.ERROR):
dp.update_queue.put(self.message_update)
sleep(0.1)
assert len(caplog.records) == 1
assert caplog.records[-1].getMessage().startswith(
'An uncaught error was raised')
# Make sure that the main loop still runs
dp.remove_handler(handler)
dp.add_handler(
MessageHandler(Filters.all,
self.callback_increase_count,
run_async=True))
dp.update_queue.put(self.message_update)
sleep(0.1)
assert self.count == 1
def test_error_in_handler(self, dp):
dp.add_handler(MessageHandler(Filters.all, self.callback_raise_error))
dp.add_error_handler(self.error_handler)
dp.update_queue.put(self.message_update)
sleep(0.1)
assert self.received == self.message_update.message.text
def test_add_remove_handler(self, dp):
handler = MessageHandler(Filters.all, self.callback_increase_count)
dp.add_handler(handler)
dp.update_queue.put(self.message_update)
sleep(0.1)
assert self.count == 1
dp.remove_handler(handler)
dp.update_queue.put(self.message_update)
assert self.count == 1
def test_add_remove_handler_non_default_group(self, dp):
handler = MessageHandler(Filters.all, self.callback_increase_count)
dp.add_handler(handler, group=2)
with pytest.raises(KeyError):
dp.remove_handler(handler)
dp.remove_handler(handler, group=2)
def test_error_start_twice(self, dp):
assert dp.running
dp.start()
def test_handler_order_in_group(self, dp):
dp.add_handler(
MessageHandler(Filters.photo, self.callback_set_count(1)))
dp.add_handler(MessageHandler(Filters.all, self.callback_set_count(2)))
dp.add_handler(MessageHandler(Filters.text,
self.callback_set_count(3)))
dp.update_queue.put(self.message_update)
sleep(0.1)
assert self.count == 2
def test_groups(self, dp):
dp.add_handler(
MessageHandler(Filters.all, self.callback_increase_count))
dp.add_handler(MessageHandler(Filters.all,
self.callback_increase_count),
group=2)
dp.add_handler(MessageHandler(Filters.all,
self.callback_increase_count),
group=-1)
dp.update_queue.put(self.message_update)
sleep(0.1)
assert self.count == 3
def test_add_handler_errors(self, dp):
handler = 'not a handler'
with pytest.raises(TypeError, match='handler is not an instance of'):
dp.add_handler(handler)
handler = MessageHandler(Filters.photo, self.callback_set_count(1))
with pytest.raises(TypeError, match='group is not int'):
dp.add_handler(handler, 'one')
def test_flow_stop(self, dp, bot):
passed = []
def start1(b, u):
passed.append('start1')
raise DispatcherHandlerStop
def start2(b, u):
passed.append('start2')
def start3(b, u):
passed.append('start3')
def error(b, u, e):
passed.append('error')
passed.append(e)
update = Update(
1,
message=Message(
1,
None,
None,
None,
text='/start',
entities=[
MessageEntity(type=MessageEntity.BOT_COMMAND,
offset=0,
length=len('/start'))
],
bot=bot,
),
)
# If Stop raised handlers in other groups should not be called.
passed = []
dp.add_handler(CommandHandler('start', start1), 1)
dp.add_handler(CommandHandler('start', start3), 1)
dp.add_handler(CommandHandler('start', start2), 2)
dp.process_update(update)
assert passed == ['start1']
def test_exception_in_handler(self, dp, bot):
passed = []
err = Exception('General exception')
def start1(b, u):
passed.append('start1')
raise err
def start2(b, u):
passed.append('start2')
def start3(b, u):
passed.append('start3')
def error(b, u, e):
passed.append('error')
passed.append(e)
update = Update(
1,
message=Message(
1,
None,
None,
None,
text='/start',
entities=[
MessageEntity(type=MessageEntity.BOT_COMMAND,
offset=0,
length=len('/start'))
],
bot=bot,
),
)
# If an unhandled exception was caught, no further handlers from the same group should be
# called. Also, the error handler should be called and receive the exception
passed = []
dp.add_handler(CommandHandler('start', start1), 1)
dp.add_handler(CommandHandler('start', start2), 1)
dp.add_handler(CommandHandler('start', start3), 2)
dp.add_error_handler(error)
dp.process_update(update)
assert passed == ['start1', 'error', err, 'start3']
def test_telegram_error_in_handler(self, dp, bot):
passed = []
err = TelegramError('Telegram error')
def start1(b, u):
passed.append('start1')
raise err
def start2(b, u):
passed.append('start2')
def start3(b, u):
passed.append('start3')
def error(b, u, e):
passed.append('error')
passed.append(e)
update = Update(
1,
message=Message(
1,
None,
None,
None,
text='/start',
entities=[
MessageEntity(type=MessageEntity.BOT_COMMAND,
offset=0,
length=len('/start'))
],
bot=bot,
),
)
# If a TelegramException was caught, an error handler should be called and no further
# handlers from the same group should be called.
dp.add_handler(CommandHandler('start', start1), 1)
dp.add_handler(CommandHandler('start', start2), 1)
dp.add_handler(CommandHandler('start', start3), 2)
dp.add_error_handler(error)
dp.process_update(update)
assert passed == ['start1', 'error', err, 'start3']
assert passed[2] is err
def test_error_while_saving_chat_data(self, bot):
increment = []
class OwnPersistence(BasePersistence):
def __init__(self):
super().__init__()
self.store_user_data = True
self.store_chat_data = True
self.store_bot_data = True
def get_bot_data(self):
return dict()
def update_bot_data(self, data):
raise Exception
def get_chat_data(self):
return defaultdict(dict)
def update_chat_data(self, chat_id, data):
raise Exception
def get_user_data(self):
return defaultdict(dict)
def update_user_data(self, user_id, data):
raise Exception
def get_conversations(self, name):
pass
def update_conversation(self, name, key, new_state):
pass
def start1(b, u):
pass
def error(b, u, e):
increment.append("error")
# If updating a user_data or chat_data from a persistence object throws an error,
# the error handler should catch it
update = Update(
1,
message=Message(
1,
None,
Chat(1, "lala"),
from_user=User(1, "Test", False),
text='/start',
entities=[
MessageEntity(type=MessageEntity.BOT_COMMAND,
offset=0,
length=len('/start'))
],
bot=bot,
),
)
my_persistence = OwnPersistence()
dp = Dispatcher(bot,
None,
persistence=my_persistence,
use_context=False)
dp.add_handler(CommandHandler('start', start1))
dp.add_error_handler(error)
dp.process_update(update)
assert increment == ["error", "error", "error"]
def test_flow_stop_in_error_handler(self, dp, bot):
passed = []
err = TelegramError('Telegram error')
def start1(b, u):
passed.append('start1')
raise err
def start2(b, u):
passed.append('start2')
def start3(b, u):
passed.append('start3')
def error(b, u, e):
passed.append('error')
passed.append(e)
raise DispatcherHandlerStop
update = Update(
1,
message=Message(
1,
None,
None,
None,
text='/start',
entities=[
MessageEntity(type=MessageEntity.BOT_COMMAND,
offset=0,
length=len('/start'))
],
bot=bot,
),
)
# If a TelegramException was caught, an error handler should be called and no further
# handlers from the same group should be called.
dp.add_handler(CommandHandler('start', start1), 1)
dp.add_handler(CommandHandler('start', start2), 1)
dp.add_handler(CommandHandler('start', start3), 2)
dp.add_error_handler(error)
dp.process_update(update)
assert passed == ['start1', 'error', err]
assert passed[2] is err
def test_error_handler_context(self, cdp):
cdp.add_error_handler(self.callback_context)
error = TelegramError('Unauthorized.')
cdp.update_queue.put(error)
sleep(0.1)
assert self.received == 'Unauthorized.'
def test_sensible_worker_thread_names(self, dp2):
thread_names = [
thread.name
for thread in getattr(dp2, '_Dispatcher__async_threads')
]
print(thread_names)
for thread_name in thread_names:
assert thread_name.startswith(f"Bot:{dp2.bot.id}:worker:")
def test_non_context_deprecation(self, dp):
with pytest.warns(TelegramDeprecationWarning):
Dispatcher(dp.bot,
dp.update_queue,
job_queue=dp.job_queue,
workers=0,
use_context=False)
def test_error_while_persisting(self, cdp, monkeypatch):
class OwnPersistence(BasePersistence):
def __init__(self):
super().__init__()
self.store_user_data = True
self.store_chat_data = True
self.store_bot_data = True
def update(self, data):
raise Exception('PersistenceError')
def update_bot_data(self, data):
self.update(data)
def update_chat_data(self, chat_id, data):
self.update(data)
def update_user_data(self, user_id, data):
self.update(data)
def get_chat_data(self):
pass
def get_bot_data(self):
pass
def get_user_data(self):
pass
def get_conversations(self, name):
pass
def update_conversation(self, name, key, new_state):
pass
def callback(update, context):
pass
test_flag = False
def error(update, context):
nonlocal test_flag
test_flag = str(context.error) == 'PersistenceError'
raise Exception('ErrorHandlingError')
def logger(message):
assert 'uncaught error was raised while handling' in message
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=User(1, '', False),
text='Text'))
handler = MessageHandler(Filters.all, callback)
cdp.add_handler(handler)
cdp.add_error_handler(error)
monkeypatch.setattr(cdp.logger, 'exception', logger)
cdp.persistence = OwnPersistence()
cdp.process_update(update)
assert test_flag
def test_persisting_no_user_no_chat(self, cdp):
class OwnPersistence(BasePersistence):
def __init__(self):
super().__init__()
self.store_user_data = True
self.store_chat_data = True
self.store_bot_data = True
self.test_flag_bot_data = False
self.test_flag_chat_data = False
self.test_flag_user_data = False
def update_bot_data(self, data):
self.test_flag_bot_data = True
def update_chat_data(self, chat_id, data):
self.test_flag_chat_data = True
def update_user_data(self, user_id, data):
self.test_flag_user_data = True
def update_conversation(self, name, key, new_state):
pass
def get_conversations(self, name):
pass
def get_user_data(self):
pass
def get_bot_data(self):
pass
def get_chat_data(self):
pass
def callback(update, context):
pass
handler = MessageHandler(Filters.all, callback)
cdp.add_handler(handler)
cdp.persistence = OwnPersistence()
update = Update(1,
message=Message(1,
None,
None,
from_user=User(1, '', False),
text='Text'))
cdp.process_update(update)
assert cdp.persistence.test_flag_bot_data
assert cdp.persistence.test_flag_user_data
assert not cdp.persistence.test_flag_chat_data
cdp.persistence.test_flag_bot_data = False
cdp.persistence.test_flag_user_data = False
cdp.persistence.test_flag_chat_data = False
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=None,
text='Text'))
cdp.process_update(update)
assert cdp.persistence.test_flag_bot_data
assert not cdp.persistence.test_flag_user_data
assert cdp.persistence.test_flag_chat_data
def test_update_persistence_once_per_update(self, monkeypatch, dp):
def update_persistence(*args, **kwargs):
self.count += 1
def dummy_callback(*args):
pass
monkeypatch.setattr(dp, 'update_persistence', update_persistence)
for group in range(5):
dp.add_handler(MessageHandler(Filters.text, dummy_callback),
group=group)
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=None,
text=None))
dp.process_update(update)
assert self.count == 0
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=None,
text='text'))
dp.process_update(update)
assert self.count == 1
def test_update_persistence_all_async(self, monkeypatch, dp):
def update_persistence(*args, **kwargs):
self.count += 1
def dummy_callback(*args, **kwargs):
pass
monkeypatch.setattr(dp, 'update_persistence', update_persistence)
monkeypatch.setattr(dp, 'run_async', dummy_callback)
for group in range(5):
dp.add_handler(MessageHandler(Filters.text,
dummy_callback,
run_async=True),
group=group)
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=None,
text='Text'))
dp.process_update(update)
assert self.count == 0
dp.bot.defaults = Defaults(run_async=True)
try:
for group in range(5):
dp.add_handler(MessageHandler(Filters.text, dummy_callback),
group=group)
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=None,
text='Text'))
dp.process_update(update)
assert self.count == 0
finally:
dp.bot.defaults = None
@pytest.mark.parametrize('run_async', [DEFAULT_FALSE, False])
def test_update_persistence_one_sync(self, monkeypatch, dp, run_async):
def update_persistence(*args, **kwargs):
self.count += 1
def dummy_callback(*args, **kwargs):
pass
monkeypatch.setattr(dp, 'update_persistence', update_persistence)
monkeypatch.setattr(dp, 'run_async', dummy_callback)
for group in range(5):
dp.add_handler(MessageHandler(Filters.text,
dummy_callback,
run_async=True),
group=group)
dp.add_handler(MessageHandler(Filters.text,
dummy_callback,
run_async=run_async),
group=5)
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=None,
text='Text'))
dp.process_update(update)
assert self.count == 1
@pytest.mark.parametrize('run_async,expected', [(DEFAULT_FALSE, 1),
(False, 1), (True, 0)])
def test_update_persistence_defaults_async(self, monkeypatch, dp,
run_async, expected):
def update_persistence(*args, **kwargs):
self.count += 1
def dummy_callback(*args, **kwargs):
pass
monkeypatch.setattr(dp, 'update_persistence', update_persistence)
monkeypatch.setattr(dp, 'run_async', dummy_callback)
dp.bot.defaults = Defaults(run_async=run_async)
try:
for group in range(5):
dp.add_handler(MessageHandler(Filters.text, dummy_callback),
group=group)
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=None,
text='Text'))
dp.process_update(update)
assert self.count == expected
finally:
dp.bot.defaults = None
class TestMessage(object):
id_ = 1
from_user = User(2, 'testuser', False)
date = datetime.utcnow()
chat = Chat(3, 'private')
test_entities = [{'length': 4, 'offset': 10, 'type': 'bold'},
{'length': 3, 'offset': 16, 'type': 'italic'},
{'length': 3, 'offset': 20, 'type': 'italic'},
{'length': 4, 'offset': 25, 'type': 'code'},
{'length': 5, 'offset': 31, 'type': 'text_link',
'url': 'http://github.com/ab_'},
{'length': 12, 'offset': 38, 'type': 'text_mention',
'user': User(123456789, 'mentioned user', False)},
{'length': 3, 'offset': 55, 'type': 'pre', 'language': 'python'},
{'length': 21, 'offset': 60, 'type': 'url'}]
test_text = 'Test for <bold, ita_lic, code, links, text-mention and pre. http://google.com/ab_'
test_entities_v2 = [{'length': 4, 'offset': 0, 'type': 'underline'},
{'length': 4, 'offset': 10, 'type': 'bold'},
{'length': 7, 'offset': 16, 'type': 'italic'},
{'length': 6, 'offset': 25, 'type': 'code'},
{'length': 5, 'offset': 33, 'type': 'text_link',
'url': 'http://github.com/abc\)def'},
{'length': 12, 'offset': 40, 'type': 'text_mention',
'user': User(123456789, 'mentioned user', False)},
{'length': 5, 'offset': 57, 'type': 'pre'},
{'length': 17, 'offset': 64, 'type': 'url'},
{'length': 36, 'offset': 86, 'type': 'italic'},
{'length': 24, 'offset': 91, 'type': 'bold'},
{'length': 4, 'offset': 101, 'type': 'strikethrough'},
{'length': 10, 'offset': 124, 'type': 'pre', 'language': 'python'}]
test_text_v2 = ('Test for <bold, ita_lic, \`code, links, text-mention and `\pre. '
'http://google.com and bold nested in strk nested in italic. Python pre.')
test_message = Message(message_id=1,
from_user=None,
date=None,
chat=None,
text=test_text,
entities=[MessageEntity(**e) for e in test_entities],
caption=test_text,
caption_entities=[MessageEntity(**e) for e in test_entities])
test_message_v2 = Message(message_id=1,
from_user=None,
date=None,
chat=None,
text=test_text_v2,
entities=[MessageEntity(**e) for e in test_entities_v2],
caption=test_text_v2,
caption_entities=[
MessageEntity(**e) for e in test_entities_v2
])
def test_all_posibilities_de_json_and_to_dict(self, bot, message_params):
new = Message.de_json(message_params.to_dict(), bot)
assert new.to_dict() == message_params.to_dict()
def test_dict_approach(self, message):
assert message['date'] == message.date
assert message['chat_id'] == message.chat_id
assert message['no_key'] is None
def test_parse_entity(self):
text = (b'\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467'
b'\\u200d\\U0001f467\\U0001f431http://google.com').decode('unicode-escape')
entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)
message = Message(1, self.from_user, self.date, self.chat, text=text, entities=[entity])
assert message.parse_entity(entity) == 'http://google.com'
def test_parse_caption_entity(self):
caption = (b'\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467'
b'\\u200d\\U0001f467\\U0001f431http://google.com').decode('unicode-escape')
entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)
message = Message(1, self.from_user, self.date, self.chat, caption=caption,
caption_entities=[entity])
assert message.parse_caption_entity(entity) == 'http://google.com'
def test_parse_entities(self):
text = (b'\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467'
b'\\u200d\\U0001f467\\U0001f431http://google.com').decode('unicode-escape')
entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)
entity_2 = MessageEntity(type=MessageEntity.BOLD, offset=13, length=1)
message = Message(1, self.from_user, self.date, self.chat,
text=text, entities=[entity_2, entity])
assert message.parse_entities(MessageEntity.URL) == {entity: 'http://google.com'}
assert message.parse_entities() == {entity: 'http://google.com', entity_2: 'h'}
def test_parse_caption_entities(self):
text = (b'\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467'
b'\\u200d\\U0001f467\\U0001f431http://google.com').decode('unicode-escape')
entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)
entity_2 = MessageEntity(type=MessageEntity.BOLD, offset=13, length=1)
message = Message(1, self.from_user, self.date, self.chat,
caption=text, caption_entities=[entity_2, entity])
assert message.parse_caption_entities(MessageEntity.URL) == {entity: 'http://google.com'}
assert message.parse_caption_entities() == {entity: 'http://google.com', entity_2: 'h'}
def test_text_html_simple(self):
test_html_string = ('<u>Test</u> for <<b>bold</b>, <i>ita_lic</i>, <code>\`code</code>,'
' <a href="http://github.com/abc\)def">links</a>, '
'<a href="tg://user?id=123456789">text-mention</a> and '
'<pre>`\pre</pre>. http://google.com '
'and <i>bold <b>nested in <s>strk</s> nested in</b> italic</i>. '
'<pre><code class="python">Python pre</code></pre>.')
text_html = self.test_message_v2.text_html
assert text_html == test_html_string
def test_text_html_empty(self, message):
message.text = None
message.caption = "test"
assert message.text_html is None
def test_text_html_urled(self):
test_html_string = ('<u>Test</u> for <<b>bold</b>, <i>ita_lic</i>, <code>\`code</code>,'
' <a href="http://github.com/abc\)def">links</a>, '
'<a href="tg://user?id=123456789">text-mention</a> and '
'<pre>`\pre</pre>. <a href="http://google.com">http://google.com</a> '
'and <i>bold <b>nested in <s>strk</s> nested in</b> italic</i>. '
'<pre><code class="python">Python pre</code></pre>.')
text_html = self.test_message_v2.text_html_urled
assert text_html == test_html_string
def test_text_markdown_simple(self):
test_md_string = ('Test for <*bold*, _ita_\__lic_, `code`, [links](http://github.com/ab_),'
' [text-mention](tg://user?id=123456789) and ```python\npre```. '
'http://google.com/ab\_')
text_markdown = self.test_message.text_markdown
assert text_markdown == test_md_string
def test_text_markdown_v2_simple(self):
test_md_string = (r'__Test__ for <*bold*, _ita\_lic_, `\\\`code`, '
'[links](http://github.com/abc\\\\\)def), '
'[text\-mention](tg://user?id=123456789) and ```\`\\\\pre```\. '
'http://google\.com and _bold *nested in ~strk~ nested in* italic_\. '
'```python\nPython pre```\.')
text_markdown = self.test_message_v2.text_markdown_v2
assert text_markdown == test_md_string
def test_text_markdown_new_in_v2(self, message):
message.text = 'test'
message.entities = [MessageEntity(MessageEntity.BOLD, offset=0, length=4),
MessageEntity(MessageEntity.ITALIC, offset=0, length=4)]
with pytest.raises(ValueError):
assert message.text_markdown
message.entities = [MessageEntity(MessageEntity.UNDERLINE, offset=0, length=4)]
with pytest.raises(ValueError):
message.text_markdown
message.entities = [MessageEntity(MessageEntity.STRIKETHROUGH, offset=0, length=4)]
with pytest.raises(ValueError):
message.text_markdown
message.entities = []
def test_text_markdown_empty(self, message):
message.text = None
message.caption = "test"
assert message.text_markdown is None
assert message.text_markdown_v2 is None
def test_text_markdown_urled(self):
test_md_string = ('Test for <*bold*, _ita_\__lic_, `code`, [links](http://github.com/ab_),'
' [text-mention](tg://user?id=123456789) and ```python\npre```. '
'[http://google.com/ab_](http://google.com/ab_)')
text_markdown = self.test_message.text_markdown_urled
assert text_markdown == test_md_string
def test_text_markdown_v2_urled(self):
test_md_string = (r'__Test__ for <*bold*, _ita\_lic_, `\\\`code`, '
'[links](http://github.com/abc\\\\\)def), '
'[text\-mention](tg://user?id=123456789) and ```\`\\\\pre```\. '
'[http://google\.com](http://google.com) and _bold *nested in ~strk~ '
'nested in* italic_\. ```python\nPython pre```\.')
text_markdown = self.test_message_v2.text_markdown_v2_urled
assert text_markdown == test_md_string
def test_text_html_emoji(self):
text = b'\\U0001f469\\u200d\\U0001f469\\u200d ABC'.decode('unicode-escape')
expected = b'\\U0001f469\\u200d\\U0001f469\\u200d <b>ABC</b>'.decode('unicode-escape')
bold_entity = MessageEntity(type=MessageEntity.BOLD, offset=7, length=3)
message = Message(1, self.from_user, self.date, self.chat,
text=text, entities=[bold_entity])
assert expected == message.text_html
def test_text_markdown_emoji(self):
text = b'\\U0001f469\\u200d\\U0001f469\\u200d ABC'.decode('unicode-escape')
expected = b'\\U0001f469\\u200d\\U0001f469\\u200d *ABC*'.decode('unicode-escape')
bold_entity = MessageEntity(type=MessageEntity.BOLD, offset=7, length=3)
message = Message(1, self.from_user, self.date, self.chat,
text=text, entities=[bold_entity])
assert expected == message.text_markdown
def test_caption_html_simple(self):
test_html_string = ('<u>Test</u> for <<b>bold</b>, <i>ita_lic</i>, <code>\`code</code>,'
' <a href="http://github.com/abc\)def">links</a>, '
'<a href="tg://user?id=123456789">text-mention</a> and '
'<pre>`\pre</pre>. http://google.com '
'and <i>bold <b>nested in <s>strk</s> nested in</b> italic</i>. '
'<pre><code class="python">Python pre</code></pre>.')
caption_html = self.test_message_v2.caption_html
assert caption_html == test_html_string
def test_caption_html_empty(self, message):
message.text = "test"
message.caption = None
assert message.caption_html is None
def test_caption_html_urled(self):
test_html_string = ('<u>Test</u> for <<b>bold</b>, <i>ita_lic</i>, <code>\`code</code>,'
' <a href="http://github.com/abc\)def">links</a>, '
'<a href="tg://user?id=123456789">text-mention</a> and '
'<pre>`\pre</pre>. <a href="http://google.com">http://google.com</a> '
'and <i>bold <b>nested in <s>strk</s> nested in</b> italic</i>. '
'<pre><code class="python">Python pre</code></pre>.')
caption_html = self.test_message_v2.caption_html_urled
assert caption_html == test_html_string
def test_caption_markdown_simple(self):
test_md_string = ('Test for <*bold*, _ita_\__lic_, `code`, [links](http://github.com/ab_),'
' [text-mention](tg://user?id=123456789) and ```python\npre```. '
'http://google.com/ab\_')
caption_markdown = self.test_message.caption_markdown
assert caption_markdown == test_md_string
def test_caption_markdown_v2_simple(self):
test_md_string = (r'__Test__ for <*bold*, _ita\_lic_, `\\\`code`, '
'[links](http://github.com/abc\\\\\\)def), '
'[text\-mention](tg://user?id=123456789) and ```\`\\\\pre```\. '
'http://google\.com and _bold *nested in ~strk~ nested in* italic_\. '
'```python\nPython pre```\.')
caption_markdown = self.test_message_v2.caption_markdown_v2
assert caption_markdown == test_md_string
def test_caption_markdown_empty(self, message):
message.text = "test"
message.caption = None
assert message.caption_markdown is None
assert message.caption_markdown_v2 is None
def test_caption_markdown_urled(self):
test_md_string = ('Test for <*bold*, _ita_\__lic_, `code`, [links](http://github.com/ab_),'
' [text-mention](tg://user?id=123456789) and ```python\npre```. '
'[http://google.com/ab_](http://google.com/ab_)')
caption_markdown = self.test_message.caption_markdown_urled
assert caption_markdown == test_md_string
def test_caption_markdown_v2_urled(self):
test_md_string = (r'__Test__ for <*bold*, _ita\_lic_, `\\\`code`, '
'[links](http://github.com/abc\\\\\\)def), '
'[text\-mention](tg://user?id=123456789) and ```\`\\\\pre```\. '
'[http://google\.com](http://google.com) and _bold *nested in ~strk~ '
'nested in* italic_\. ```python\nPython pre```\.')
caption_markdown = self.test_message_v2.caption_markdown_v2_urled
assert caption_markdown == test_md_string
def test_caption_html_emoji(self):
caption = b'\\U0001f469\\u200d\\U0001f469\\u200d ABC'.decode('unicode-escape')
expected = b'\\U0001f469\\u200d\\U0001f469\\u200d <b>ABC</b>'.decode('unicode-escape')
bold_entity = MessageEntity(type=MessageEntity.BOLD, offset=7, length=3)
message = Message(1, self.from_user, self.date, self.chat,
caption=caption, caption_entities=[bold_entity])
assert expected == message.caption_html
def test_caption_markdown_emoji(self):
caption = b'\\U0001f469\\u200d\\U0001f469\\u200d ABC'.decode('unicode-escape')
expected = b'\\U0001f469\\u200d\\U0001f469\\u200d *ABC*'.decode('unicode-escape')
bold_entity = MessageEntity(type=MessageEntity.BOLD, offset=7, length=3)
message = Message(1, self.from_user, self.date, self.chat,
caption=caption, caption_entities=[bold_entity])
assert expected == message.caption_markdown
def test_parse_entities_url_emoji(self):
url = b'http://github.com/?unicode=\\u2713\\U0001f469'.decode('unicode-escape')
text = 'some url'
link_entity = MessageEntity(type=MessageEntity.URL, offset=0, length=8, url=url)
message = Message(1, self.from_user, self.date, self.chat,
text=text, entities=[link_entity])
assert message.parse_entities() == {link_entity: text}
assert next(iter(message.parse_entities())).url == url
def test_chat_id(self, message):
assert message.chat_id == message.chat.id
@pytest.mark.parametrize('type', argvalues=[Chat.SUPERGROUP, Chat.CHANNEL])
def test_link_with_username(self, message, type):
message.chat.username = '******'
message.chat.type = type
assert message.link == 'https://t.me/{}/{}'.format(message.chat.username,
message.message_id)
@pytest.mark.parametrize('type, id', argvalues=[
(Chat.CHANNEL, -1003), (Chat.SUPERGROUP, -1003)])
def test_link_with_id(self, message, type, id):
message.chat.username = None
message.chat.id = id
message.chat.type = type
# The leading - for group ids/ -100 for supergroup ids isn't supposed to be in the link
assert message.link == 'https://t.me/c/{}/{}'.format(3, message.message_id)
@pytest.mark.parametrize('id, username', argvalues=[
(None, 'username'), (-3, None)
])
def test_link_private_chats(self, message, id, username):
message.chat.type = Chat.PRIVATE
message.chat.id = id
message.chat.username = username
assert message.link is None
message.chat.type = Chat.GROUP
assert message.link is None
def test_effective_attachment(self, message_params):
for i in ('audio', 'game', 'document', 'animation', 'photo', 'sticker', 'video', 'voice',
'video_note', 'contact', 'location', 'venue', 'invoice', 'invoice',
'successful_payment'):
item = getattr(message_params, i, None)
if item:
break
else:
item = None
assert message_params.effective_attachment == item
def test_reply_text(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
text = args[1] == 'test'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and text and reply
monkeypatch.setattr(message.bot, 'send_message', test)
assert message.reply_text('test')
assert message.reply_text('test', quote=True)
assert message.reply_text('test', reply_to_message_id=message.message_id, quote=True)
def test_reply_markdown(self, monkeypatch, message):
test_md_string = ('Test for <*bold*, _ita_\__lic_, `code`, [links](http://github.com/ab_),'
' [text-mention](tg://user?id=123456789) and ```python\npre```. '
'http://google.com/ab\_')
def test(*args, **kwargs):
cid = args[0] == message.chat_id
markdown_text = args[1] == test_md_string
markdown_enabled = kwargs['parse_mode'] == ParseMode.MARKDOWN
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return all([cid, markdown_text, reply, markdown_enabled])
text_markdown = self.test_message.text_markdown
assert text_markdown == test_md_string
monkeypatch.setattr(message.bot, 'send_message', test)
assert message.reply_markdown(self.test_message.text_markdown)
assert message.reply_markdown(self.test_message.text_markdown, quote=True)
assert message.reply_markdown(self.test_message.text_markdown,
reply_to_message_id=message.message_id,
quote=True)
def test_reply_markdown_v2(self, monkeypatch, message):
test_md_string = (r'__Test__ for <*bold*, _ita\_lic_, `\\\`code`, '
'[links](http://github.com/abc\\\\\)def), '
'[text\-mention](tg://user?id=123456789) and ```\`\\\\pre```\. '
'http://google\.com and _bold *nested in ~strk~ nested in* italic_\. '
'```python\nPython pre```\.')
def test(*args, **kwargs):
cid = args[0] == message.chat_id
markdown_text = args[1] == test_md_string
markdown_enabled = kwargs['parse_mode'] == ParseMode.MARKDOWN_V2
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return all([cid, markdown_text, reply, markdown_enabled])
text_markdown = self.test_message_v2.text_markdown_v2
assert text_markdown == test_md_string
monkeypatch.setattr(message.bot, 'send_message', test)
assert message.reply_markdown_v2(self.test_message_v2.text_markdown_v2)
assert message.reply_markdown_v2(self.test_message_v2.text_markdown_v2, quote=True)
assert message.reply_markdown_v2(self.test_message_v2.text_markdown_v2,
reply_to_message_id=message.message_id,
quote=True)
def test_reply_html(self, monkeypatch, message):
test_html_string = ('<u>Test</u> for <<b>bold</b>, <i>ita_lic</i>, <code>\`code</code>,'
' <a href="http://github.com/abc\)def">links</a>, '
'<a href="tg://user?id=123456789">text-mention</a> and '
'<pre>`\pre</pre>. http://google.com '
'and <i>bold <b>nested in <s>strk</s> nested in</b> italic</i>. '
'<pre><code class="python">Python pre</code></pre>.')
def test(*args, **kwargs):
cid = args[0] == message.chat_id
html_text = args[1] == test_html_string
html_enabled = kwargs['parse_mode'] == ParseMode.HTML
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return all([cid, html_text, reply, html_enabled])
text_html = self.test_message_v2.text_html
assert text_html == test_html_string
monkeypatch.setattr(message.bot, 'send_message', test)
assert message.reply_html(self.test_message_v2.text_html)
assert message.reply_html(self.test_message_v2.text_html, quote=True)
assert message.reply_html(self.test_message_v2.text_html,
reply_to_message_id=message.message_id,
quote=True)
def test_reply_media_group(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
media = kwargs['media'] == 'reply_media_group'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and media and reply
monkeypatch.setattr(message.bot, 'send_media_group', test)
assert message.reply_media_group(media='reply_media_group')
assert message.reply_media_group(media='reply_media_group', quote=True)
def test_reply_photo(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
photo = kwargs['photo'] == 'test_photo'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and photo and reply
monkeypatch.setattr(message.bot, 'send_photo', test)
assert message.reply_photo(photo='test_photo')
assert message.reply_photo(photo='test_photo', quote=True)
def test_reply_audio(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
audio = kwargs['audio'] == 'test_audio'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and audio and reply
monkeypatch.setattr(message.bot, 'send_audio', test)
assert message.reply_audio(audio='test_audio')
assert message.reply_audio(audio='test_audio', quote=True)
def test_reply_document(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
document = kwargs['document'] == 'test_document'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and document and reply
monkeypatch.setattr(message.bot, 'send_document', test)
assert message.reply_document(document='test_document')
assert message.reply_document(document='test_document', quote=True)
def test_reply_animation(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
animation = kwargs['animation'] == 'test_animation'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and animation and reply
monkeypatch.setattr(message.bot, 'send_animation', test)
assert message.reply_animation(animation='test_animation')
assert message.reply_animation(animation='test_animation', quote=True)
def test_reply_sticker(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
sticker = kwargs['sticker'] == 'test_sticker'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and sticker and reply
monkeypatch.setattr(message.bot, 'send_sticker', test)
assert message.reply_sticker(sticker='test_sticker')
assert message.reply_sticker(sticker='test_sticker', quote=True)
def test_reply_video(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
video = kwargs['video'] == 'test_video'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and video and reply
monkeypatch.setattr(message.bot, 'send_video', test)
assert message.reply_video(video='test_video')
assert message.reply_video(video='test_video', quote=True)
def test_reply_video_note(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
video_note = kwargs['video_note'] == 'test_video_note'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and video_note and reply
monkeypatch.setattr(message.bot, 'send_video_note', test)
assert message.reply_video_note(video_note='test_video_note')
assert message.reply_video_note(video_note='test_video_note', quote=True)
def test_reply_voice(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
voice = kwargs['voice'] == 'test_voice'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and voice and reply
monkeypatch.setattr(message.bot, 'send_voice', test)
assert message.reply_voice(voice='test_voice')
assert message.reply_voice(voice='test_voice', quote=True)
def test_reply_location(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
location = kwargs['location'] == 'test_location'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and location and reply
monkeypatch.setattr(message.bot, 'send_location', test)
assert message.reply_location(location='test_location')
assert message.reply_location(location='test_location', quote=True)
def test_reply_venue(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
venue = kwargs['venue'] == 'test_venue'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and venue and reply
monkeypatch.setattr(message.bot, 'send_venue', test)
assert message.reply_venue(venue='test_venue')
assert message.reply_venue(venue='test_venue', quote=True)
def test_reply_contact(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
contact = kwargs['contact'] == 'test_contact'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and contact and reply
monkeypatch.setattr(message.bot, 'send_contact', test)
assert message.reply_contact(contact='test_contact')
assert message.reply_contact(contact='test_contact', quote=True)
def test_reply_poll(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
contact = kwargs['question'] == 'test_poll'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and contact and reply
monkeypatch.setattr(message.bot, 'send_poll', test)
assert message.reply_poll(question='test_poll')
assert message.reply_poll(question='test_poll', quote=True)
def test_reply_dice(self, monkeypatch, message):
def test(*args, **kwargs):
id_ = args[0] == message.chat_id
contact = kwargs['disable_notification'] is True
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id_ and contact and reply
monkeypatch.setattr(message.bot, 'send_dice', test)
assert message.reply_dice(disable_notification=True)
assert message.reply_dice(disable_notification=True, quote=True)
def test_forward(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == 123456
from_chat = kwargs['from_chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
if kwargs.get('disable_notification'):
notification = kwargs['disable_notification'] is True
else:
notification = True
return chat_id and from_chat and message_id and notification
monkeypatch.setattr(message.bot, 'forward_message', test)
assert message.forward(123456)
assert message.forward(123456, disable_notification=True)
assert not message.forward(635241)
def test_edit_text(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
text = kwargs['text'] == 'test'
return chat_id and message_id and text
monkeypatch.setattr(message.bot, 'edit_message_text', test)
assert message.edit_text(text='test')
def test_edit_caption(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
caption = kwargs['caption'] == 'new caption'
return chat_id and message_id and caption
monkeypatch.setattr(message.bot, 'edit_message_caption', test)
assert message.edit_caption(caption='new caption')
def test_edit_media(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
media = kwargs['media'] == 'my_media'
return chat_id and message_id and media
monkeypatch.setattr(message.bot, 'edit_message_media', test)
assert message.edit_media('my_media')
def test_edit_reply_markup(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
reply_markup = kwargs['reply_markup'] == [['1', '2']]
return chat_id and message_id and reply_markup
monkeypatch.setattr(message.bot, 'edit_message_reply_markup', test)
assert message.edit_reply_markup(reply_markup=[['1', '2']])
def test_delete(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
return chat_id and message_id
monkeypatch.setattr(message.bot, 'delete_message', test)
assert message.delete()
def test_default_quote(self, message):
kwargs = {}
message.default_quote = False
message._quote(kwargs)
assert 'reply_to_message_id' not in kwargs
message.default_quote = True
message._quote(kwargs)
assert 'reply_to_message_id' in kwargs
kwargs = {}
message.default_quote = None
message.chat.type = Chat.PRIVATE
message._quote(kwargs)
assert 'reply_to_message_id' not in kwargs
message.chat.type = Chat.GROUP
message._quote(kwargs)
assert 'reply_to_message_id' in kwargs
def test_equality(self):
id_ = 1
a = Message(id_, self.from_user, self.date, self.chat)
b = Message(id_, self.from_user, self.date, self.chat)
c = Message(id_, User(0, '', False), self.date, self.chat)
d = Message(0, self.from_user, self.date, self.chat)
e = Update(id_)
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a == c
assert hash(a) == hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
def update():
return Update(
0,
Message(0, User(0, 'Testuser', False), datetime.datetime.utcnow(),
Chat(0, 'private')))
def message():
return Message(0, User(0, 'Testuser', False), datetime.datetime.now(),
Chat(0, 'private'))
def callback_query(bot):
return Update(0,
callback_query=CallbackQuery(2,
User(1, '', False),
None,
data='test data'))
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser Public License for more details.
#
# You should have received a copy of the GNU Lesser Public License
# along with this program. If not, see [http://www.gnu.org/licenses/].
import pytest
from telegram import (Message, Update, Chat, Bot, User, CallbackQuery,
InlineQuery, ChosenInlineResult, ShippingQuery,
PreCheckoutQuery)
from telegram.ext import CommandHandler, Filters, BaseFilter
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)
class TestDispatcher(object):
message_update = Update(1,
message=Message(1,
User(1, '', False),
None,
Chat(1, ''),
text='Text'))
received = None
count = 0
@pytest.fixture(autouse=True)
def reset(self):
self.received = None
self.count = 0
def error_handler(self, bot, update, error):
self.received = error.message
def error_handler_raise_error(self, bot, update, error):
raise Exception('Failing bigly')
def callback_increase_count(self, bot, update):
self.count += 1
def callback_set_count(self, count):
def callback(bot, update):
self.count = count
return callback
def callback_raise_error(self, bot, update):
raise TelegramError(update.message.text)
def callback_if_not_update_queue(self, bot, update, update_queue=None):
if update_queue is not None:
self.received = update.message
def test_error_handler(self, dp):
dp.add_error_handler(self.error_handler)
error = TelegramError('Unauthorized.')
dp.update_queue.put(error)
sleep(.1)
assert self.received == 'Unauthorized.'
# Remove handler
dp.remove_error_handler(self.error_handler)
self.reset()
dp.update_queue.put(error)
sleep(.1)
assert self.received is None
def test_error_handler_that_raises_errors(self, dp):
"""
Make sure that errors raised in error handlers don't break the main loop of the dispatcher
"""
handler_raise_error = MessageHandler(Filters.all,
self.callback_raise_error)
handler_increase_count = MessageHandler(Filters.all,
self.callback_increase_count)
error = TelegramError('Unauthorized.')
dp.add_error_handler(self.error_handler_raise_error)
# From errors caused by handlers
dp.add_handler(handler_raise_error)
dp.update_queue.put(self.message_update)
sleep(.1)
# From errors in the update_queue
dp.remove_handler(handler_raise_error)
dp.add_handler(handler_increase_count)
dp.update_queue.put(error)
dp.update_queue.put(self.message_update)
sleep(.1)
assert self.count == 1
def test_run_async_multiple(self, bot, dp, dp2):
def get_dispatcher_name(q):
q.put(current_thread().name)
q1 = Queue()
q2 = Queue()
dp.run_async(get_dispatcher_name, q1)
dp2.run_async(get_dispatcher_name, q2)
sleep(.1)
name1 = q1.get()
name2 = q2.get()
assert name1 != name2
def test_multiple_run_async_decorator(self, dp, dp2):
# Make sure we got two dispatchers and that they are not the same
assert isinstance(dp, Dispatcher)
assert isinstance(dp2, Dispatcher)
assert dp is not dp2
@run_async
def must_raise_runtime_error():
pass
with pytest.raises(RuntimeError):
must_raise_runtime_error()
def test_run_async_with_args(self, dp):
dp.add_handler(
MessageHandler(Filters.all,
run_async(self.callback_if_not_update_queue),
pass_update_queue=True))
dp.update_queue.put(self.message_update)
sleep(.1)
assert self.received == self.message_update.message
def test_error_in_handler(self, dp):
dp.add_handler(MessageHandler(Filters.all, self.callback_raise_error))
dp.add_error_handler(self.error_handler)
dp.update_queue.put(self.message_update)
sleep(.1)
assert self.received == self.message_update.message.text
def test_add_remove_handler(self, dp):
handler = MessageHandler(Filters.all, self.callback_increase_count)
dp.add_handler(handler)
dp.update_queue.put(self.message_update)
sleep(.1)
assert self.count == 1
dp.remove_handler(handler)
dp.update_queue.put(self.message_update)
assert self.count == 1
def test_add_remove_handler_non_default_group(self, dp):
handler = MessageHandler(Filters.all, self.callback_increase_count)
dp.add_handler(handler, group=2)
with pytest.raises(KeyError):
dp.remove_handler(handler)
dp.remove_handler(handler, group=2)
def test_error_start_twice(self, dp):
assert dp.running
dp.start()
def test_handler_order_in_group(self, dp):
dp.add_handler(
MessageHandler(Filters.photo, self.callback_set_count(1)))
dp.add_handler(MessageHandler(Filters.all, self.callback_set_count(2)))
dp.add_handler(MessageHandler(Filters.text,
self.callback_set_count(3)))
dp.update_queue.put(self.message_update)
sleep(.1)
assert self.count == 2
def test_groups(self, dp):
dp.add_handler(
MessageHandler(Filters.all, self.callback_increase_count))
dp.add_handler(MessageHandler(Filters.all,
self.callback_increase_count),
group=2)
dp.add_handler(MessageHandler(Filters.all,
self.callback_increase_count),
group=-1)
dp.update_queue.put(self.message_update)
sleep(.1)
assert self.count == 3
def test_add_handler_errors(self, dp):
handler = 'not a handler'
with pytest.raises(TypeError, match='handler is not an instance of'):
dp.add_handler(handler)
handler = MessageHandler(Filters.photo, self.callback_set_count(1))
with pytest.raises(TypeError, match='group is not int'):
dp.add_handler(handler, 'one')
def test_flow_stop(self, dp, bot):
passed = []
def start1(b, u):
passed.append('start1')
raise DispatcherHandlerStop
def start2(b, u):
passed.append('start2')
def start3(b, u):
passed.append('start3')
def error(b, u, e):
passed.append('error')
passed.append(e)
update = Update(1,
message=Message(1,
None,
None,
None,
text='/start',
bot=bot))
# If Stop raised handlers in other groups should not be called.
passed = []
dp.add_handler(CommandHandler('start', start1), 1)
dp.add_handler(CommandHandler('start', start3), 1)
dp.add_handler(CommandHandler('start', start2), 2)
dp.process_update(update)
assert passed == ['start1']
def test_exception_in_handler(self, dp, bot):
passed = []
def start1(b, u):
passed.append('start1')
raise Exception('General exception')
def start2(b, u):
passed.append('start2')
def start3(b, u):
passed.append('start3')
def error(b, u, e):
passed.append('error')
passed.append(e)
update = Update(1,
message=Message(1,
None,
None,
None,
text='/start',
bot=bot))
# If an unhandled exception was caught, no further handlers from the same group should be
# called.
passed = []
dp.add_handler(CommandHandler('start', start1), 1)
dp.add_handler(CommandHandler('start', start2), 1)
dp.add_handler(CommandHandler('start', start3), 2)
dp.add_error_handler(error)
dp.process_update(update)
assert passed == ['start1', 'start3']
def test_telegram_error_in_handler(self, dp, bot):
passed = []
err = TelegramError('Telegram error')
def start1(b, u):
passed.append('start1')
raise err
def start2(b, u):
passed.append('start2')
def start3(b, u):
passed.append('start3')
def error(b, u, e):
passed.append('error')
passed.append(e)
update = Update(1,
message=Message(1,
None,
None,
None,
text='/start',
bot=bot))
# If a TelegramException was caught, an error handler should be called and no further
# handlers from the same group should be called.
dp.add_handler(CommandHandler('start', start1), 1)
dp.add_handler(CommandHandler('start', start2), 1)
dp.add_handler(CommandHandler('start', start3), 2)
dp.add_error_handler(error)
dp.process_update(update)
assert passed == ['start1', 'error', err, 'start3']
assert passed[2] is err
def test_flow_stop_in_error_handler(self, dp, bot):
passed = []
err = TelegramError('Telegram error')
def start1(b, u):
passed.append('start1')
raise err
def start2(b, u):
passed.append('start2')
def start3(b, u):
passed.append('start3')
def error(b, u, e):
passed.append('error')
passed.append(e)
raise DispatcherHandlerStop
update = Update(1,
message=Message(1,
None,
None,
None,
text='/start',
bot=bot))
# If a TelegramException was caught, an error handler should be called and no further
# handlers from the same group should be called.
dp.add_handler(CommandHandler('start', start1), 1)
dp.add_handler(CommandHandler('start', start2), 1)
dp.add_handler(CommandHandler('start', start3), 2)
dp.add_error_handler(error)
dp.process_update(update)
assert passed == ['start1', 'error', err]
assert passed[2] is err
#
# You should have received a copy of the GNU Lesser Public License
# along with this program. If not, see [http://www.gnu.org/licenses/].
from queue import Queue
import pytest
from telegram import (Update, CallbackQuery, Bot, Message, User, Chat,
InlineQuery, ChosenInlineResult, ShippingQuery,
PreCheckoutQuery)
from telegram.ext import CallbackQueryHandler, CallbackContext, JobQueue
message = Message(1,
None,
Chat(1, ''),
from_user=User(1, '', False),
text='Text')
params = [{
'message': message
}, {
'edited_message': message
}, {
'channel_post': message
}, {
'edited_channel_post': message
}, {
'inline_query': InlineQuery(1, User(1, '', False), '', '')
}, {
'chosen_inline_result':
ChosenInlineResult('id', User(1, '', False), '')
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser Public License for more details.
#
# You should have received a copy of the GNU Lesser Public License
# along with this program. If not, see [http://www.gnu.org/licenses/].
import pytest
from telegram import (Message, Update, Chat, Bot, User, CallbackQuery, InlineQuery,
ChosenInlineResult, ShippingQuery, PreCheckoutQuery)
from telegram.ext import CommandHandler, Filters
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',)
class TestCallbackQuery(object):
id = 'id'
from_user = User(1, 'test_user', False)
chat_instance = 'chat_instance'
message = Message(3, User(5, 'bot', False), None, Chat(4, 'private'))
data = 'data'
inline_message_id = 'inline_message_id'
game_short_name = 'the_game'
def test_de_json(self, bot):
json_dict = {
'id': self.id,
'from': self.from_user.to_dict(),
'chat_instance': self.chat_instance,
'message': self.message.to_dict(),
'data': self.data,
'inline_message_id': self.inline_message_id,
'game_short_name': self.game_short_name
}
callback_query = CallbackQuery.de_json(json_dict, bot)
assert callback_query.id == self.id
assert callback_query.from_user == self.from_user
assert callback_query.chat_instance == self.chat_instance
assert callback_query.message == self.message
assert callback_query.data == self.data
assert callback_query.inline_message_id == self.inline_message_id
assert callback_query.game_short_name == self.game_short_name
def test_to_dict(self, callback_query):
callback_query_dict = callback_query.to_dict()
assert isinstance(callback_query_dict, dict)
assert callback_query_dict['id'] == callback_query.id
assert callback_query_dict['from'] == callback_query.from_user.to_dict(
)
assert callback_query_dict[
'chat_instance'] == callback_query.chat_instance
if callback_query.message:
assert callback_query_dict[
'message'] == callback_query.message.to_dict()
else:
assert callback_query_dict[
'inline_message_id'] == callback_query.inline_message_id
assert callback_query_dict['data'] == callback_query.data
assert callback_query_dict[
'game_short_name'] == callback_query.game_short_name
def test_answer(self, monkeypatch, callback_query):
def test(*args, **kwargs):
return args[1] == callback_query.id
monkeypatch.setattr('telegram.Bot.answerCallbackQuery', test)
# TODO: PEP8
assert callback_query.answer()
def test_edit_message_text(self, monkeypatch, callback_query):
def test(*args, **kwargs):
try:
id = kwargs[
'inline_message_id'] == callback_query.inline_message_id
text = kwargs['text'] == 'test'
return id and text
except KeyError:
chat_id = kwargs['chat_id'] == callback_query.message.chat_id
message_id = kwargs[
'message_id'] == callback_query.message.message_id
text = kwargs['text'] == 'test'
return chat_id and message_id and text
monkeypatch.setattr('telegram.Bot.edit_message_text', test)
assert callback_query.edit_message_text(text='test')
def test_edit_message_caption(self, monkeypatch, callback_query):
def test(*args, **kwargs):
try:
id = kwargs[
'inline_message_id'] == callback_query.inline_message_id
caption = kwargs['caption'] == 'new caption'
return id and caption
except KeyError:
id = kwargs['chat_id'] == callback_query.message.chat_id
message = kwargs[
'message_id'] == callback_query.message.message_id
caption = kwargs['caption'] == 'new caption'
return id and message and caption
monkeypatch.setattr('telegram.Bot.edit_message_caption', test)
assert callback_query.edit_message_caption(caption='new caption')
def test_edit_message_reply_markup(self, monkeypatch, callback_query):
def test(*args, **kwargs):
try:
id = kwargs[
'inline_message_id'] == callback_query.inline_message_id
reply_markup = kwargs['reply_markup'] == [['1', '2']]
return id and reply_markup
except KeyError:
id = kwargs['chat_id'] == callback_query.message.chat_id
message = kwargs[
'message_id'] == callback_query.message.message_id
reply_markup = kwargs['reply_markup'] == [['1', '2']]
return id and message and reply_markup
monkeypatch.setattr('telegram.Bot.edit_message_reply_markup', test)
assert callback_query.edit_message_reply_markup(
reply_markup=[['1', '2']])
def test_equality(self):
a = CallbackQuery(self.id, self.from_user, 'chat')
b = CallbackQuery(self.id, self.from_user, 'chat')
c = CallbackQuery(self.id, None, '')
d = CallbackQuery('', None, 'chat')
e = Audio(self.id, 1)
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a == c
assert hash(a) == hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
def test_guess_member(self, monkeypatch):
monkeypatch.setattr(Photon, 'geocode', get_address_from_cache)
Member.set_akadressen_credentials('http://all', 'http://active', '',
'')
with open(check_file_path('tests/data/akadressen.pdf'),
'rb') as akadressen:
responses.add(
responses.GET,
'http://all',
body=akadressen.read(),
stream=True,
status=200,
adding_headers={'Transfer-Encoding': 'chunked'},
)
with open(check_file_path('tests/data/akadressen-active.pdf'),
'rb') as akadressen_active:
responses.add(
responses.GET,
'http://active',
body=akadressen_active.read(),
stream=True,
status=200,
adding_headers={'Transfer-Encoding': 'chunked'},
)
assert Member._AKADRESSEN_CACHE_TIME is None
assert Member._AKADRESSEN is None
user_1 = User(1, is_bot=False, first_name='John', last_name='Doe')
members = Member.guess_member(user_1)
assert Member._AKADRESSEN_CACHE_TIME == dt.date.today()
assert isinstance(Member._AKADRESSEN, pd.DataFrame)
assert len(members) == 1
member = members[0]
assert member.user_id == 1
assert member.last_name == 'Doe'
assert member.first_name == 'John'
assert member.nickname == 'Jonny'
assert member.date_of_birth == dt.date(2000, 1, 1)
assert member.instruments == [instruments.Trumpet()]
assert member.address == 'Münzstraße 5, 38100 Braunschweig'
assert member.joined == 2004
Member._AKADRESSEN = None
user_2 = User(2, is_bot=False, first_name='Marcel', last_name='Marcel')
members = Member.guess_member(user_2)
assert Member._AKADRESSEN_CACHE_TIME == dt.date.today()
assert isinstance(Member._AKADRESSEN, pd.DataFrame)
assert len(members) == 1
member = members[0]
assert member.user_id == 2
assert member.last_name == 'Marcel'
assert member.first_name == 'Marcel'
assert member.nickname is None
assert member.date_of_birth == dt.date(2000, 5, 1)
assert member.instruments == []
assert member.address == 'Universitätsplatz 2, 38106 Braunschweig'
assert member.joined == 2005
test_flag = False
def _get_akadressen(*args, **kwargs):
nonlocal test_flag
test_flag = True
monkeypatch.setattr(Member, '_get_akadressen', _get_akadressen)
user_3 = User(3, is_bot=False, first_name='Test', username='******')
members = Member.guess_member(user_3)
assert Member._AKADRESSEN_CACHE_TIME == dt.date.today()
assert isinstance(Member._AKADRESSEN, pd.DataFrame)
assert not test_flag
assert len(members) == 1
member = members[0]
assert member.user_id == 3
assert member.last_name == 'Zufall'
assert member.first_name == 'Rainer'
assert member.nickname == 'Das Brot'
assert member.date_of_birth == dt.date(2007, 7, 5)
assert member.instruments == [instruments.Flute()]
assert member.address == 'Bültenweg 74-75, 38106 Braunschweig'
assert member.joined is None
user_4 = User(1, is_bot=False, first_name=None)
assert Member.guess_member(user_4) is None
def test_dispatcher_integration_handlers(self, caplog, bot,
base_persistence, chat_data,
user_data):
def get_user_data():
return user_data
def get_chat_data():
return chat_data
base_persistence.get_user_data = get_user_data
base_persistence.get_chat_data = get_chat_data
# base_persistence.update_chat_data = lambda x: x
# base_persistence.update_user_data = lambda x: x
updater = Updater(bot=bot,
persistence=base_persistence,
use_context=True)
dp = updater.dispatcher
def callback_known_user(update, context):
if not context.user_data['test1'] == 'test2':
pytest.fail('user_data corrupt')
def callback_known_chat(update, context):
if not context.chat_data['test3'] == 'test4':
pytest.fail('chat_data corrupt')
def callback_unknown_user_or_chat(update, context):
if not context.user_data == {}:
pytest.fail('user_data corrupt')
if not context.chat_data == {}:
pytest.fail('chat_data corrupt')
context.user_data[1] = 'test7'
context.chat_data[2] = 'test8'
known_user = MessageHandler(Filters.user(user_id=12345),
callback_known_user,
pass_chat_data=True,
pass_user_data=True)
known_chat = MessageHandler(Filters.chat(chat_id=-67890),
callback_known_chat,
pass_chat_data=True,
pass_user_data=True)
unknown = MessageHandler(Filters.all,
callback_unknown_user_or_chat,
pass_chat_data=True,
pass_user_data=True)
dp.add_handler(known_user)
dp.add_handler(known_chat)
dp.add_handler(unknown)
user1 = User(id=12345, first_name='test user', is_bot=False)
user2 = User(id=54321, first_name='test user', is_bot=False)
chat1 = Chat(id=-67890, type='group')
chat2 = Chat(id=-987654, type='group')
m = Message(1, user1, None, chat2)
u = Update(0, m)
with caplog.at_level(logging.ERROR):
dp.process_update(u)
rec = caplog.records[-1]
assert rec.msg == 'Saving user data raised an error'
assert rec.levelname == 'ERROR'
rec = caplog.records[-2]
assert rec.msg == 'Saving chat data raised an error'
assert rec.levelname == 'ERROR'
m.from_user = user2
m.chat = chat1
u = Update(1, m)
dp.process_update(u)
m.chat = chat2
u = Update(2, m)
def save_chat_data(data):
if -987654 not in data:
pytest.fail()
def save_user_data(data):
if 54321 not in data:
pytest.fail()
base_persistence.update_chat_data = save_chat_data
base_persistence.update_user_data = save_user_data
dp.process_update(u)
assert dp.user_data[54321][1] == 'test7'
assert dp.chat_data[-987654][2] == 'test8'
def de_json(data, bot):
data = super(MessageEntity, MessageEntity).de_json(data, bot)
data['user'] = User.de_json(data.get('user'), bot)
return MessageEntity(**data)
def test_error_while_persisting(self, cdp, monkeypatch):
class OwnPersistence(BasePersistence):
def __init__(self):
super().__init__()
self.store_user_data = True
self.store_chat_data = True
self.store_bot_data = True
def update(self, data):
raise Exception('PersistenceError')
def update_bot_data(self, data):
self.update(data)
def update_chat_data(self, chat_id, data):
self.update(data)
def update_user_data(self, user_id, data):
self.update(data)
def get_chat_data(self):
pass
def get_bot_data(self):
pass
def get_user_data(self):
pass
def get_conversations(self, name):
pass
def update_conversation(self, name, key, new_state):
pass
def callback(update, context):
pass
test_flag = False
def error(update, context):
nonlocal test_flag
test_flag = str(context.error) == 'PersistenceError'
raise Exception('ErrorHandlingError')
def logger(message):
assert 'uncaught error was raised while handling' in message
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=User(1, '', False),
text='Text'))
handler = MessageHandler(Filters.all, callback)
cdp.add_handler(handler)
cdp.add_error_handler(error)
monkeypatch.setattr(cdp.logger, 'exception', logger)
cdp.persistence = OwnPersistence()
cdp.process_update(update)
assert test_flag
def setUp(self):
self.message = Message(0, User(0, "Testuser"), datetime.now(),
Chat(0, 'private'))
self.e = functools.partial(MessageEntity, offset=0, length=0)
def test_error_while_saving_chat_data(self, bot):
increment = []
class OwnPersistence(BasePersistence):
def __init__(self):
super().__init__()
self.store_user_data = True
self.store_chat_data = True
self.store_bot_data = True
def get_bot_data(self):
return dict()
def update_bot_data(self, data):
raise Exception
def get_chat_data(self):
return defaultdict(dict)
def update_chat_data(self, chat_id, data):
raise Exception
def get_user_data(self):
return defaultdict(dict)
def update_user_data(self, user_id, data):
raise Exception
def get_conversations(self, name):
pass
def update_conversation(self, name, key, new_state):
pass
def start1(b, u):
pass
def error(b, u, e):
increment.append("error")
# If updating a user_data or chat_data from a persistence object throws an error,
# the error handler should catch it
update = Update(
1,
message=Message(
1,
None,
Chat(1, "lala"),
from_user=User(1, "Test", False),
text='/start',
entities=[
MessageEntity(type=MessageEntity.BOT_COMMAND,
offset=0,
length=len('/start'))
],
bot=bot,
),
)
my_persistence = OwnPersistence()
dp = Dispatcher(bot,
None,
persistence=my_persistence,
use_context=False)
dp.add_handler(CommandHandler('start', start1))
dp.add_error_handler(error)
dp.process_update(update)
assert increment == ["error", "error", "error"]
SuccessfulPayment)
@pytest.fixture(scope='class')
def message(bot):
return Message(TestMessage.id,
TestMessage.from_user,
TestMessage.date,
TestMessage.chat,
bot=bot)
@pytest.fixture(
scope='function',
params=[{
'forward_from': User(99, 'forward_user', False),
'forward_date': datetime.now()
}, {
'forward_from_chat': Chat(-23, 'channel'),
'forward_from_message_id': 101,
'forward_date': datetime.now()
}, {
'reply_to_message': Message(50, None, None, None)
}, {
'edit_date': datetime.now()
}, {
'text':
'a text message',
'enitites':
[MessageEntity('bold', 10, 4),
MessageEntity('italic', 16, 7)]
class TestMessage(object):
id = 1
from_user = User(2, 'testuser', False)
date = datetime.now()
chat = Chat(3, 'private')
test_entities = [{
'length': 4,
'offset': 10,
'type': 'bold'
}, {
'length': 7,
'offset': 16,
'type': 'italic'
}, {
'length': 4,
'offset': 25,
'type': 'code'
}, {
'length': 5,
'offset': 31,
'type': 'text_link',
'url': 'http://github.com/'
}, {
'length': 3,
'offset': 41,
'type': 'pre'
}, {
'length': 17,
'offset': 46,
'type': 'url'
}]
test_text = 'Test for <bold, ita_lic, code, links and pre. http://google.com'
test_message = Message(
message_id=1,
from_user=None,
date=None,
chat=None,
text=test_text,
entities=[MessageEntity(**e) for e in test_entities],
caption=test_text,
caption_entities=[MessageEntity(**e) for e in test_entities])
def test_all_posibilities_de_json_and_to_dict(self, bot, message_params):
new = Message.de_json(message_params.to_dict(), bot)
assert new.to_dict() == message_params.to_dict()
def test_dict_approach(self, message):
assert message['date'] == message.date
assert message['chat_id'] == message.chat_id
assert message['no_key'] is None
def test_parse_entity(self):
text = (b'\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467'
b'\\u200d\\U0001f467\\U0001f431http://google.com'
).decode('unicode-escape')
entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)
message = Message(1,
self.from_user,
self.date,
self.chat,
text=text,
entities=[entity])
assert message.parse_entity(entity) == 'http://google.com'
def test_parse_caption_entity(self):
caption = (b'\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467'
b'\\u200d\\U0001f467\\U0001f431http://google.com'
).decode('unicode-escape')
entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)
message = Message(1,
self.from_user,
self.date,
self.chat,
caption=caption,
caption_entities=[entity])
assert message.parse_caption_entity(entity) == 'http://google.com'
def test_parse_entities(self):
text = (b'\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467'
b'\\u200d\\U0001f467\\U0001f431http://google.com'
).decode('unicode-escape')
entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)
entity_2 = MessageEntity(type=MessageEntity.BOLD, offset=13, length=1)
message = Message(1,
self.from_user,
self.date,
self.chat,
text=text,
entities=[entity_2, entity])
assert message.parse_entities(MessageEntity.URL) == {
entity: 'http://google.com'
}
assert message.parse_entities() == {
entity: 'http://google.com',
entity_2: 'h'
}
def test_parse_caption_entities(self):
text = (b'\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467'
b'\\u200d\\U0001f467\\U0001f431http://google.com'
).decode('unicode-escape')
entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)
entity_2 = MessageEntity(type=MessageEntity.BOLD, offset=13, length=1)
message = Message(1,
self.from_user,
self.date,
self.chat,
caption=text,
caption_entities=[entity_2, entity])
assert message.parse_caption_entities(MessageEntity.URL) == {
entity: 'http://google.com'
}
assert message.parse_caption_entities() == {
entity: 'http://google.com',
entity_2: 'h'
}
def test_text_html_simple(self):
test_html_string = (
'Test for <<b>bold</b>, <i>ita_lic</i>, <code>code</code>, '
'<a href="http://github.com/">links</a> and <pre>pre</pre>. '
'http://google.com')
text_html = self.test_message.text_html
assert text_html == test_html_string
def test_text_html_urled(self):
test_html_string = (
'Test for <<b>bold</b>, <i>ita_lic</i>, <code>code</code>, '
'<a href="http://github.com/">links</a> and <pre>pre</pre>. '
'<a href="http://google.com">http://google.com</a>')
text_html = self.test_message.text_html_urled
assert text_html == test_html_string
def test_text_markdown_simple(self):
test_md_string = (
'Test for <*bold*, _ita\_lic_, `code`, [links](http://github.com/) and '
'```pre```. http://google.com')
text_markdown = self.test_message.text_markdown
assert text_markdown == test_md_string
def test_text_markdown_urled(self):
test_md_string = (
'Test for <*bold*, _ita\_lic_, `code`, [links](http://github.com/) and '
'```pre```. [http://google.com](http://google.com)')
text_markdown = self.test_message.text_markdown_urled
assert text_markdown == test_md_string
def test_text_html_emoji(self):
text = b'\\U0001f469\\u200d\\U0001f469\\u200d ABC'.decode(
'unicode-escape')
expected = b'\\U0001f469\\u200d\\U0001f469\\u200d <b>ABC</b>'.decode(
'unicode-escape')
bold_entity = MessageEntity(type=MessageEntity.BOLD,
offset=7,
length=3)
message = Message(1,
self.from_user,
self.date,
self.chat,
text=text,
entities=[bold_entity])
assert expected == message.text_html
def test_text_markdown_emoji(self):
text = b'\\U0001f469\\u200d\\U0001f469\\u200d ABC'.decode(
'unicode-escape')
expected = b'\\U0001f469\\u200d\\U0001f469\\u200d *ABC*'.decode(
'unicode-escape')
bold_entity = MessageEntity(type=MessageEntity.BOLD,
offset=7,
length=3)
message = Message(1,
self.from_user,
self.date,
self.chat,
text=text,
entities=[bold_entity])
assert expected == message.text_markdown
def test_caption_html_simple(self):
test_html_string = (
'Test for <<b>bold</b>, <i>ita_lic</i>, <code>code</code>, '
'<a href="http://github.com/">links</a> and <pre>pre</pre>. '
'http://google.com')
caption_html = self.test_message.caption_html
assert caption_html == test_html_string
def test_caption_html_urled(self):
test_html_string = (
'Test for <<b>bold</b>, <i>ita_lic</i>, <code>code</code>, '
'<a href="http://github.com/">links</a> and <pre>pre</pre>. '
'<a href="http://google.com">http://google.com</a>')
caption_html = self.test_message.caption_html_urled
assert caption_html == test_html_string
def test_caption_markdown_simple(self):
test_md_string = (
'Test for <*bold*, _ita\_lic_, `code`, [links](http://github.com/) and '
'```pre```. http://google.com')
caption_markdown = self.test_message.caption_markdown
assert caption_markdown == test_md_string
def test_caption_markdown_urled(self):
test_md_string = (
'Test for <*bold*, _ita\_lic_, `code`, [links](http://github.com/) and '
'```pre```. [http://google.com](http://google.com)')
caption_markdown = self.test_message.caption_markdown_urled
assert caption_markdown == test_md_string
def test_caption_html_emoji(self):
caption = b'\\U0001f469\\u200d\\U0001f469\\u200d ABC'.decode(
'unicode-escape')
expected = b'\\U0001f469\\u200d\\U0001f469\\u200d <b>ABC</b>'.decode(
'unicode-escape')
bold_entity = MessageEntity(type=MessageEntity.BOLD,
offset=7,
length=3)
message = Message(1,
self.from_user,
self.date,
self.chat,
caption=caption,
caption_entities=[bold_entity])
assert expected == message.caption_html
def test_caption_markdown_emoji(self):
caption = b'\\U0001f469\\u200d\\U0001f469\\u200d ABC'.decode(
'unicode-escape')
expected = b'\\U0001f469\\u200d\\U0001f469\\u200d *ABC*'.decode(
'unicode-escape')
bold_entity = MessageEntity(type=MessageEntity.BOLD,
offset=7,
length=3)
message = Message(1,
self.from_user,
self.date,
self.chat,
caption=caption,
caption_entities=[bold_entity])
assert expected == message.caption_markdown
def test_parse_entities_url_emoji(self):
url = b'http://github.com/?unicode=\\u2713\\U0001f469'.decode(
'unicode-escape')
text = 'some url'
link_entity = MessageEntity(type=MessageEntity.URL,
offset=0,
length=8,
url=url)
message = Message(1,
self.from_user,
self.date,
self.chat,
text=text,
entities=[link_entity])
assert message.parse_entities() == {link_entity: text}
assert next(iter(message.parse_entities())).url == url
def test_chat_id(self, message):
assert message.chat_id == message.chat.id
def test_effective_attachment(self, message_params):
for i in ('audio', 'game', 'document', 'photo', 'sticker', 'video',
'voice', 'video_note', 'contact', 'location', 'venue',
'invoice', 'invoice', 'successful_payment'):
item = getattr(message_params, i, None)
if item:
break
else:
item = None
assert message_params.effective_attachment == item
def test_reply_text(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
text = args[2] == 'test'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and text and reply
monkeypatch.setattr('telegram.Bot.send_message', test)
assert message.reply_text('test')
assert message.reply_text('test', quote=True)
assert message.reply_text('test',
reply_to_message_id=message.message_id,
quote=True)
def test_reply_markdown(self, monkeypatch, message):
test_md_string = (
'Test for <*bold*, _ita\_lic_, `code`, [links](http://github.com/) and '
'```pre```. http://google.com')
def test(*args, **kwargs):
cid = args[1] == message.chat_id
markdown_text = args[2] == test_md_string
markdown_enabled = kwargs['parse_mode'] == ParseMode.MARKDOWN
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return all([cid, markdown_text, reply, markdown_enabled])
text_markdown = self.test_message.text_markdown
assert text_markdown == test_md_string
monkeypatch.setattr('telegram.Bot.send_message', test)
assert message.reply_markdown(self.test_message.text_markdown)
assert message.reply_markdown(self.test_message.text_markdown,
quote=True)
assert message.reply_markdown(self.test_message.text_markdown,
reply_to_message_id=message.message_id,
quote=True)
def test_reply_html(self, monkeypatch, message):
test_html_string = (
'Test for <<b>bold</b>, <i>ita_lic</i>, <code>code</code>, '
'<a href="http://github.com/">links</a> and <pre>pre</pre>. '
'http://google.com')
def test(*args, **kwargs):
cid = args[1] == message.chat_id
html_text = args[2] == test_html_string
html_enabled = kwargs['parse_mode'] == ParseMode.HTML
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return all([cid, html_text, reply, html_enabled])
text_html = self.test_message.text_html
assert text_html == test_html_string
monkeypatch.setattr('telegram.Bot.send_message', test)
assert message.reply_html(self.test_message.text_html)
assert message.reply_html(self.test_message.text_html, quote=True)
assert message.reply_html(self.test_message.text_html,
reply_to_message_id=message.message_id,
quote=True)
def test_reply_media_group(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
media = kwargs['media'] == 'reply_media_group'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and media and reply
monkeypatch.setattr('telegram.Bot.send_media_group', test)
assert message.reply_media_group(media='reply_media_group')
assert message.reply_media_group(media='reply_media_group', quote=True)
def test_reply_photo(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
photo = kwargs['photo'] == 'test_photo'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and photo and reply
monkeypatch.setattr('telegram.Bot.send_photo', test)
assert message.reply_photo(photo='test_photo')
assert message.reply_photo(photo='test_photo', quote=True)
def test_reply_audio(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
audio = kwargs['audio'] == 'test_audio'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and audio and reply
monkeypatch.setattr('telegram.Bot.send_audio', test)
assert message.reply_audio(audio='test_audio')
assert message.reply_audio(audio='test_audio', quote=True)
def test_reply_document(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
document = kwargs['document'] == 'test_document'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and document and reply
monkeypatch.setattr('telegram.Bot.send_document', test)
assert message.reply_document(document='test_document')
assert message.reply_document(document='test_document', quote=True)
def test_reply_sticker(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
sticker = kwargs['sticker'] == 'test_sticker'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and sticker and reply
monkeypatch.setattr('telegram.Bot.send_sticker', test)
assert message.reply_sticker(sticker='test_sticker')
assert message.reply_sticker(sticker='test_sticker', quote=True)
def test_reply_video(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
video = kwargs['video'] == 'test_video'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and video and reply
monkeypatch.setattr('telegram.Bot.send_video', test)
assert message.reply_video(video='test_video')
assert message.reply_video(video='test_video', quote=True)
def test_reply_video_note(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
video_note = kwargs['video_note'] == 'test_video_note'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and video_note and reply
monkeypatch.setattr('telegram.Bot.send_video_note', test)
assert message.reply_video_note(video_note='test_video_note')
assert message.reply_video_note(video_note='test_video_note',
quote=True)
def test_reply_voice(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
voice = kwargs['voice'] == 'test_voice'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and voice and reply
monkeypatch.setattr('telegram.Bot.send_voice', test)
assert message.reply_voice(voice='test_voice')
assert message.reply_voice(voice='test_voice', quote=True)
def test_reply_location(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
location = kwargs['location'] == 'test_location'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and location and reply
monkeypatch.setattr('telegram.Bot.send_location', test)
assert message.reply_location(location='test_location')
assert message.reply_location(location='test_location', quote=True)
def test_reply_venue(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
venue = kwargs['venue'] == 'test_venue'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and venue and reply
monkeypatch.setattr('telegram.Bot.send_venue', test)
assert message.reply_venue(venue='test_venue')
assert message.reply_venue(venue='test_venue', quote=True)
def test_reply_contact(self, monkeypatch, message):
def test(*args, **kwargs):
id = args[1] == message.chat_id
contact = kwargs['contact'] == 'test_contact'
if kwargs.get('reply_to_message_id'):
reply = kwargs['reply_to_message_id'] == message.message_id
else:
reply = True
return id and contact and reply
monkeypatch.setattr('telegram.Bot.send_contact', test)
assert message.reply_contact(contact='test_contact')
assert message.reply_contact(contact='test_contact', quote=True)
def test_forward(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == 123456
from_chat = kwargs['from_chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
if kwargs.get('disable_notification'):
notification = kwargs['disable_notification'] is True
else:
notification = True
return chat_id and from_chat and message_id and notification
monkeypatch.setattr('telegram.Bot.forward_message', test)
assert message.forward(123456)
assert message.forward(123456, disable_notification=True)
assert not message.forward(635241)
def test_edit_text(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
text = kwargs['text'] == 'test'
return chat_id and message_id and text
monkeypatch.setattr('telegram.Bot.edit_message_text', test)
assert message.edit_text(text='test')
def test_edit_caption(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
caption = kwargs['caption'] == 'new caption'
return chat_id and message_id and caption
monkeypatch.setattr('telegram.Bot.edit_message_caption', test)
assert message.edit_caption(caption='new caption')
def test_edit_reply_markup(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
reply_markup = kwargs['reply_markup'] == [['1', '2']]
return chat_id and message_id and reply_markup
monkeypatch.setattr('telegram.Bot.edit_message_reply_markup', test)
assert message.edit_reply_markup(reply_markup=[['1', '2']])
def test_delete(self, monkeypatch, message):
def test(*args, **kwargs):
chat_id = kwargs['chat_id'] == message.chat_id
message_id = kwargs['message_id'] == message.message_id
return chat_id and message_id
monkeypatch.setattr('telegram.Bot.delete_message', test)
assert message.delete()
def test_equality(self):
id = 1
a = Message(id, self.from_user, self.date, self.chat)
b = Message(id, self.from_user, self.date, self.chat)
c = Message(id, User(0, '', False), self.date, self.chat)
d = Message(0, self.from_user, self.date, self.chat)
e = Update(id)
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a == c
assert hash(a) == hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
def update(bot):
user = User(id=321, first_name='test_user', is_bot=False)
chat = Chat(id=123, type='group')
message = Message(1, user, None, chat, text="Hi there", bot=bot)
return Update(0, message=message)
def user(bot):
return User(id=TestUser.id, first_name=TestUser.first_name, is_bot=TestUser.is_bot,
last_name=TestUser.last_name, username=TestUser.username,
language_code=TestUser.language_code, bot=bot)
class TestShippingQuery:
id_ = 5
invoice_payload = 'invoice_payload'
from_user = User(0, '', False)
shipping_address = ShippingAddress('GB', '', 'London',
'12 Grimmauld Place', '', 'WC1')
def test_de_json(self, bot):
json_dict = {
'id': TestShippingQuery.id_,
'invoice_payload': TestShippingQuery.invoice_payload,
'from': TestShippingQuery.from_user.to_dict(),
'shipping_address': TestShippingQuery.shipping_address.to_dict(),
}
shipping_query = ShippingQuery.de_json(json_dict, bot)
assert shipping_query.id == self.id_
assert shipping_query.invoice_payload == self.invoice_payload
assert shipping_query.from_user == self.from_user
assert shipping_query.shipping_address == self.shipping_address
assert shipping_query.bot is bot
def test_to_dict(self, shipping_query):
shipping_query_dict = shipping_query.to_dict()
assert isinstance(shipping_query_dict, dict)
assert shipping_query_dict['id'] == shipping_query.id
assert shipping_query_dict[
'invoice_payload'] == shipping_query.invoice_payload
assert shipping_query_dict['from'] == shipping_query.from_user.to_dict(
)
assert shipping_query_dict[
'shipping_address'] == shipping_query.shipping_address.to_dict()
def test_answer(self, monkeypatch, shipping_query):
answer_shipping_query = shipping_query.bot.answer_shipping_query
def make_assertion(*_, **kwargs):
return kwargs[
'shipping_query_id'] == shipping_query.id and check_shortcut_call(
kwargs, answer_shipping_query)
assert check_shortcut_signature(ShippingQuery.answer,
Bot.answer_shipping_query,
['shipping_query_id'], [])
monkeypatch.setattr(shipping_query.bot, 'answer_shipping_query',
make_assertion)
assert shipping_query.answer(ok=True)
def test_equality(self):
a = ShippingQuery(self.id_, self.from_user, self.invoice_payload,
self.shipping_address)
b = ShippingQuery(self.id_, self.from_user, self.invoice_payload,
self.shipping_address)
c = ShippingQuery(self.id_, None, '', None)
d = ShippingQuery(0, self.from_user, self.invoice_payload,
self.shipping_address)
e = Update(self.id_)
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a == c
assert hash(a) == hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
def user2():
return User(first_name='Mister Test', id=124, is_bot=False)
def user():
return User(1, 'First name', False)
def user1():
return User(first_name='Misses Test', id=123, is_bot=False)
def message(bot):
return Message(1, User(1, '', False), None, Chat(1, ''), bot=bot)
class TestShippingQuery(object):
id = 5
invoice_payload = 'invoice_payload'
from_user = User(0, '', False)
shipping_address = ShippingAddress('GB', '', 'London',
'12 Grimmauld Place', '', 'WC1')
def test_de_json(self, bot):
json_dict = {
'id': TestShippingQuery.id,
'invoice_payload': TestShippingQuery.invoice_payload,
'from': TestShippingQuery.from_user.to_dict(),
'shipping_address': TestShippingQuery.shipping_address.to_dict()
}
shipping_query = ShippingQuery.de_json(json_dict, bot)
assert shipping_query.id == self.id
assert shipping_query.invoice_payload == self.invoice_payload
assert shipping_query.from_user == self.from_user
assert shipping_query.shipping_address == self.shipping_address
@staticmethod
def test_to_dict(shipping_query):
shipping_query_dict = shipping_query.to_dict()
assert isinstance(shipping_query_dict, dict)
assert shipping_query_dict['id'] == shipping_query.id
assert shipping_query_dict[
'invoice_payload'] == shipping_query.invoice_payload
assert shipping_query_dict['from'] == shipping_query.from_user.to_dict(
)
assert shipping_query_dict[
'shipping_address'] == shipping_query.shipping_address.to_dict()
@staticmethod
def test_answer(monkeypatch, shipping_query):
def test(*args, **kwargs):
return args[1] == shipping_query.id
monkeypatch.setattr('telegram.Bot.answer_shipping_query', test)
assert shipping_query.answer()
def test_equality(self):
a = ShippingQuery(self.id, self.from_user, self.invoice_payload,
self.shipping_address)
b = ShippingQuery(self.id, self.from_user, self.invoice_payload,
self.shipping_address)
c = ShippingQuery(self.id, None, '', None)
d = ShippingQuery(0, self.from_user, self.invoice_payload,
self.shipping_address)
e = Update(self.id)
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a == c
assert hash(a) == hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
def setUp(self):
self.message = Message(0, User(0, "Testuser"), datetime.now(),
Chat(0, 'private'))
self.update = Update(0, message=self.message)
def de_json(data):
if 'from' in data: # from is a reserved word, use from_user instead.
from telegram import User
from_user = User.de_json(data['from'])
else:
from_user = None
if 'date' in data:
date = datetime.fromtimestamp(data['date'])
else:
date = None
if 'chat' in data:
if 'first_name' in data['chat']:
from telegram import User
chat = User.de_json(data['chat'])
if 'title' in data['chat']:
from telegram import GroupChat
chat = GroupChat.de_json(data['chat'])
else:
chat = None
if 'forward_from' in data:
from telegram import User
forward_from = User.de_json(data['forward_from'])
else:
forward_from = None
if 'forward_date' in data:
forward_date = datetime.fromtimestamp(data['forward_date'])
else:
forward_date = None
if 'reply_to_message' in data:
reply_to_message = Message.de_json(data['reply_to_message'])
else:
reply_to_message = None
if 'audio' in data:
from telegram import Audio
audio = Audio.de_json(data['audio'])
else:
audio = None
if 'document' in data:
from telegram import Document
document = Document.de_json(data['document'])
else:
document = None
if 'photo' in data:
from telegram import PhotoSize
photo = [PhotoSize.de_json(x) for x in data['photo']]
else:
photo = None
if 'sticker' in data:
from telegram import Sticker
sticker = Sticker.de_json(data['sticker'])
else:
sticker = None
if 'video' in data:
from telegram import Video
video = Video.de_json(data['video'])
else:
video = None
if 'voice' in data:
from telegram import Voice
voice = Voice.de_json(data['voice'])
else:
voice = None
if 'contact' in data:
from telegram import Contact
contact = Contact.de_json(data['contact'])
else:
contact = None
if 'location' in data:
from telegram import Location
location = Location.de_json(data['location'])
else:
location = None
if 'new_chat_participant' in data:
from telegram import User
new_chat_participant = User.de_json(data['new_chat_participant'])
else:
new_chat_participant = None
if 'left_chat_participant' in data:
from telegram import User
left_chat_participant = User.de_json(data['left_chat_participant'])
else:
left_chat_participant = None
if 'new_chat_photo' in data:
from telegram import PhotoSize
new_chat_photo = \
[PhotoSize.de_json(x) for x in data['new_chat_photo']]
else:
new_chat_photo = None
return Message(message_id=data.get('message_id', None),
from_user=from_user,
date=date,
chat=chat,
forward_from=forward_from,
forward_date=forward_date,
reply_to_message=reply_to_message,
text=data.get('text', ''),
audio=audio,
document=document,
photo=photo,
sticker=sticker,
video=video,
voice=voice,
caption=data.get('caption', ''),
contact=contact,
location=location,
new_chat_participant=new_chat_participant,
left_chat_participant=left_chat_participant,
new_chat_title=data.get('new_chat_title', None),
new_chat_photo=new_chat_photo,
delete_chat_photo=data.get('delete_chat_photo', None),
group_chat_created=data.get('group_chat_created', None))
class TestPreCheckoutQuery(object):
id = 5
invoice_payload = 'invoice_payload'
shipping_option_id = 'shipping_option_id'
currency = 'EUR'
total_amount = 100
from_user = User(0, '')
order_info = OrderInfo()
def test_de_json(self, bot):
json_dict = {
'id': self.id,
'invoice_payload': self.invoice_payload,
'shipping_option_id': self.shipping_option_id,
'currency': self.currency,
'total_amount': self.total_amount,
'from': self.from_user.to_dict(),
'order_info': self.order_info.to_dict()
}
pre_checkout_query = PreCheckoutQuery.de_json(json_dict, bot)
assert pre_checkout_query.id == self.id
assert pre_checkout_query.invoice_payload == self.invoice_payload
assert pre_checkout_query.shipping_option_id == self.shipping_option_id
assert pre_checkout_query.currency == self.currency
assert pre_checkout_query.from_user == self.from_user
assert pre_checkout_query.order_info == self.order_info
def test_to_dict(self, pre_checkout_query):
pre_checkout_query_dict = pre_checkout_query.to_dict()
assert isinstance(pre_checkout_query_dict, dict)
assert pre_checkout_query_dict['id'] == pre_checkout_query.id
assert pre_checkout_query_dict['invoice_payload'] == pre_checkout_query.invoice_payload
assert pre_checkout_query_dict['shipping_option_id'] == \
pre_checkout_query.shipping_option_id
assert pre_checkout_query_dict['currency'] == pre_checkout_query.currency
assert pre_checkout_query_dict['from'] == pre_checkout_query.from_user.to_dict()
assert pre_checkout_query_dict['order_info'] == pre_checkout_query.order_info.to_dict()
def test_answer(self, monkeypatch, pre_checkout_query):
def test(*args, **kwargs):
return args[1] == pre_checkout_query.id
monkeypatch.setattr('telegram.Bot.answer_pre_checkout_query', test)
assert pre_checkout_query.answer()
def test_equality(self):
a = PreCheckoutQuery(self.id, self.from_user, self.currency, self.total_amount,
self.invoice_payload)
b = PreCheckoutQuery(self.id, self.from_user, self.currency, self.total_amount,
self.invoice_payload)
c = PreCheckoutQuery(self.id, None, '', 0, '')
d = PreCheckoutQuery(0, self.from_user, self.currency, self.total_amount,
self.invoice_payload)
e = Update(self.id)
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a == c
assert hash(a) == hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
