OpenSource/python-telegram-bot
OpenSource/python-telegram-bot
1
0
Fork 0
mirror of https://github.com/python-telegram-bot/python-telegram-bot.git synced 2024-12-22 14:35:00 +01:00
Code Issues Projects Releases Packages Wiki Activity

flake8 revamp

Browse source 
- Use pre-commit v1.2.0 flake8
 - Make sure we're running flake8 on examples and tests
 - Fix what had to be fixed
This commit is contained in:
Noam Meltzer 2018-02-19 12:41:38 +02:00
parent 746ae0caf3
commit baec1bb554
44 changed files with 577 additions and 562 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
.pre-commit-config.yaml
View file

@ -6,10 +6,10 @@
args: args:
- --diff - --diff
- repo: git://github.com/pre-commit/pre-commit-hooks - repo: git://github.com/pre-commit/pre-commit-hooks
sha: 78818b90cd694c29333ba54d38f9e60b6359ccfc sha: v1.2.0
hooks: hooks:
- id: flake8 - id: flake8
files: ^telegram/.*\.py$ exclude: ^(setup.py|docs/source/conf.py)$
- repo: git://github.com/pre-commit/mirrors-pylint - repo: git://github.com/pre-commit/mirrors-pylint
sha: v1.7.1 sha: v1.7.1
hooks: hooks:

2
examples/inlinebot.py
View file

@ -18,8 +18,6 @@ bot.
""" """
from uuid import uuid4 from uuid import uuid4
import re
from telegram.utils.helpers import escape_markdown from telegram.utils.helpers import escape_markdown
from telegram import InlineQueryResultArticle, ParseMode, \ from telegram import InlineQueryResultArticle, ParseMode, \

2
telegram/ext/jobqueue.py
View file

@ -283,7 +283,7 @@ class JobQueue(object):
self.logger.debug('Running job %s', job.name) self.logger.debug('Running job %s', job.name)
job.run(self.bot) job.run(self.bot)
except: except Exception:
self.logger.exception('An uncaught error was raised while executing job %s', self.logger.exception('An uncaught error was raised while executing job %s',
job.name) job.name)
else: else:

3
tests/test_bot.py
View file

@ -18,7 +18,7 @@
# along with this program. If not, see [http://www.gnu.org/licenses/]. # along with this program. If not, see [http://www.gnu.org/licenses/].
import os import os
import time import time
from datetime import datetime, timedelta from datetime import datetime
from platform import python_implementation from platform import python_implementation
import pytest import pytest
@ -552,7 +552,6 @@ class TestBot(object):
def test_restrict_chat_member(self, bot, channel_id): def test_restrict_chat_member(self, bot, channel_id):
# TODO: Add bot to supergroup so this can be tested properly # TODO: Add bot to supergroup so this can be tested properly
with pytest.raises(BadRequest, match='Method is available only for supergroups'): with pytest.raises(BadRequest, match='Method is available only for supergroups'):
until = datetime.now() + timedelta(seconds=30)
assert bot.restrict_chat_member(channel_id, assert bot.restrict_chat_member(channel_id,
95205500, 95205500,
until_date=datetime.now(), until_date=datetime.now(),

2
tests/test_constants.py
View file

@ -44,4 +44,4 @@ class TestConstants(object):
bad_caption = good_caption + 'Z' bad_caption = good_caption + 'Z'
with pytest.raises(BadRequest, message="Media_caption_too_long"): with pytest.raises(BadRequest, message="Media_caption_too_long"):
with open('tests/data/telegram.png', 'rb') as f: with open('tests/data/telegram.png', 'rb') as f:
bad_message = bot.send_photo(photo=f, caption=bad_caption, chat_id=chat_id) bot.send_photo(photo=f, caption=bad_caption, chat_id=chat_id)

2
tests/test_conversationhandler.py
View file

@ -88,7 +88,7 @@ class TestConversationHandler(object):
# Tests # Tests
def test_per_all_false(self): def test_per_all_false(self):
with pytest.raises(ValueError, match="can't all be 'False'"): with pytest.raises(ValueError, match="can't all be 'False'"):
handler = ConversationHandler(self.entry_points, self.states, self.fallbacks, ConversationHandler(self.entry_points, self.states, self.fallbacks,
per_chat=False, per_user=False, per_message=False) per_chat=False, per_user=False, per_message=False)
def test_conversation_handler(self, dp, bot, user1, user2): def test_conversation_handler(self, dp, bot, user1, user2):

3
tests/test_dispatcher.py
View file

@ -35,7 +35,8 @@ def dp2(bot):
class TestDispatcher(object): class TestDispatcher(object):
message_update = Update(1, message=Message(1, User(1, '', False), None, Chat(1, ''), text='Text')) message_update = Update(1,
message=Message(1, User(1, '', False), None, Chat(1, ''), text='Text'))
received = None received = None
count = 0 count = 0

12
tests/test_inlinekeyboardbutton.py
View file

@ -48,8 +48,8 @@ class TestInlineKeyboardButton(object):
assert inline_keyboard_button.url == self.url assert inline_keyboard_button.url == self.url
assert inline_keyboard_button.callback_data == self.callback_data assert inline_keyboard_button.callback_data == self.callback_data
assert inline_keyboard_button.switch_inline_query == self.switch_inline_query assert inline_keyboard_button.switch_inline_query == self.switch_inline_query
assert inline_keyboard_button.switch_inline_query_current_chat == \ assert (inline_keyboard_button.switch_inline_query_current_chat ==
self.switch_inline_query_current_chat self.switch_inline_query_current_chat)
assert inline_keyboard_button.callback_game == self.callback_game assert inline_keyboard_button.callback_game == self.callback_game
assert inline_keyboard_button.pay == self.pay assert inline_keyboard_button.pay == self.pay
@ -60,9 +60,9 @@ class TestInlineKeyboardButton(object):
assert inline_keyboard_button_dict['text'] == inline_keyboard_button.text assert inline_keyboard_button_dict['text'] == inline_keyboard_button.text
assert inline_keyboard_button_dict['url'] == inline_keyboard_button.url assert inline_keyboard_button_dict['url'] == inline_keyboard_button.url
assert inline_keyboard_button_dict['callback_data'] == inline_keyboard_button.callback_data assert inline_keyboard_button_dict['callback_data'] == inline_keyboard_button.callback_data
assert inline_keyboard_button_dict['switch_inline_query'] == \ assert (inline_keyboard_button_dict['switch_inline_query'] ==
inline_keyboard_button.switch_inline_query inline_keyboard_button.switch_inline_query)
assert inline_keyboard_button_dict['switch_inline_query_current_chat'] == \ assert (inline_keyboard_button_dict['switch_inline_query_current_chat'] ==
inline_keyboard_button.switch_inline_query_current_chat inline_keyboard_button.switch_inline_query_current_chat)
assert inline_keyboard_button_dict['callback_game'] == inline_keyboard_button.callback_game assert inline_keyboard_button_dict['callback_game'] == inline_keyboard_button.callback_game
assert inline_keyboard_button_dict['pay'] == inline_keyboard_button.pay assert inline_keyboard_button_dict['pay'] == inline_keyboard_button.pay

31
tests/test_inlinequeryresultarticle.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineKeyboardMarkup, InlineQueryResultAudio, InlineQueryR
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_article(): def inline_query_result_article():
return InlineQueryResultArticle(TestInlineQueryResultArticle.id, return InlineQueryResultArticle(
TestInlineQueryResultArticle.id,
TestInlineQueryResultArticle.title, TestInlineQueryResultArticle.title,
input_message_content=TestInlineQueryResultArticle.input_message_content, input_message_content=TestInlineQueryResultArticle.input_message_content,
reply_markup=TestInlineQueryResultArticle.reply_markup, reply_markup=TestInlineQueryResultArticle.reply_markup,
@ -54,8 +55,8 @@ class TestInlineQueryResultArticle(object):
assert inline_query_result_article.type == self.type assert inline_query_result_article.type == self.type
assert inline_query_result_article.id == self.id assert inline_query_result_article.id == self.id
assert inline_query_result_article.title == self.title assert inline_query_result_article.title == self.title
assert inline_query_result_article.input_message_content.to_dict() == \ assert (inline_query_result_article.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_article.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_article.reply_markup.to_dict() == self.reply_markup.to_dict()
assert inline_query_result_article.url == self.url assert inline_query_result_article.url == self.url
assert inline_query_result_article.hide_url == self.hide_url assert inline_query_result_article.hide_url == self.hide_url
@ -71,20 +72,20 @@ class TestInlineQueryResultArticle(object):
assert inline_query_result_article_dict['type'] == inline_query_result_article.type assert inline_query_result_article_dict['type'] == inline_query_result_article.type
assert inline_query_result_article_dict['id'] == inline_query_result_article.id assert inline_query_result_article_dict['id'] == inline_query_result_article.id
assert inline_query_result_article_dict['title'] == inline_query_result_article.title assert inline_query_result_article_dict['title'] == inline_query_result_article.title
assert inline_query_result_article_dict['input_message_content'] == \ assert (inline_query_result_article_dict['input_message_content'] ==
inline_query_result_article.input_message_content.to_dict() inline_query_result_article.input_message_content.to_dict())
assert inline_query_result_article_dict['reply_markup'] == \ assert (inline_query_result_article_dict['reply_markup'] ==
inline_query_result_article.reply_markup.to_dict() inline_query_result_article.reply_markup.to_dict())
assert inline_query_result_article_dict['url'] == inline_query_result_article.url assert inline_query_result_article_dict['url'] == inline_query_result_article.url
assert inline_query_result_article_dict['hide_url'] == inline_query_result_article.hide_url assert inline_query_result_article_dict['hide_url'] == inline_query_result_article.hide_url
assert inline_query_result_article_dict['description'] == \ assert (inline_query_result_article_dict['description'] ==
inline_query_result_article.description inline_query_result_article.description)
assert inline_query_result_article_dict['thumb_url'] == \ assert (inline_query_result_article_dict['thumb_url'] ==
inline_query_result_article.thumb_url inline_query_result_article.thumb_url)
assert inline_query_result_article_dict['thumb_height'] == \ assert (inline_query_result_article_dict['thumb_height'] ==
inline_query_result_article.thumb_height inline_query_result_article.thumb_height)
assert inline_query_result_article_dict['thumb_width'] == \ assert (inline_query_result_article_dict['thumb_width'] ==
inline_query_result_article.thumb_width inline_query_result_article.thumb_width)
def test_equality(self): def test_equality(self):
a = InlineQueryResultArticle(self.id, self.title, self.input_message_content) a = InlineQueryResultArticle(self.id, self.title, self.input_message_content)

19
tests/test_inlinequeryresultaudio.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineKeyboardMarkup, InlineKeyboardButton, InlineQueryRes
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_audio(): def inline_query_result_audio():
return InlineQueryResultAudio(TestInlineQueryResultAudio.id, return InlineQueryResultAudio(
TestInlineQueryResultAudio.id,
TestInlineQueryResultAudio.audio_url, TestInlineQueryResultAudio.audio_url,
TestInlineQueryResultAudio.title, TestInlineQueryResultAudio.title,
performer=TestInlineQueryResultAudio.performer, performer=TestInlineQueryResultAudio.performer,
@ -57,8 +58,8 @@ class TestInlineQueryResultAudio(object):
assert inline_query_result_audio.audio_duration == self.audio_duration assert inline_query_result_audio.audio_duration == self.audio_duration
assert inline_query_result_audio.caption == self.caption assert inline_query_result_audio.caption == self.caption
assert inline_query_result_audio.parse_mode == self.parse_mode assert inline_query_result_audio.parse_mode == self.parse_mode
assert inline_query_result_audio.input_message_content.to_dict() == \ assert (inline_query_result_audio.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_audio.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_audio.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_audio): def test_to_dict(self, inline_query_result_audio):
@ -70,14 +71,14 @@ class TestInlineQueryResultAudio(object):
assert inline_query_result_audio_dict['audio_url'] == inline_query_result_audio.audio_url assert inline_query_result_audio_dict['audio_url'] == inline_query_result_audio.audio_url
assert inline_query_result_audio_dict['title'] == inline_query_result_audio.title assert inline_query_result_audio_dict['title'] == inline_query_result_audio.title
assert inline_query_result_audio_dict['performer'] == inline_query_result_audio.performer assert inline_query_result_audio_dict['performer'] == inline_query_result_audio.performer
assert inline_query_result_audio_dict['audio_duration'] == \ assert (inline_query_result_audio_dict['audio_duration'] ==
inline_query_result_audio.audio_duration inline_query_result_audio.audio_duration)
assert inline_query_result_audio_dict['caption'] == inline_query_result_audio.caption assert inline_query_result_audio_dict['caption'] == inline_query_result_audio.caption
assert inline_query_result_audio_dict['parse_mode'] == inline_query_result_audio.parse_mode assert inline_query_result_audio_dict['parse_mode'] == inline_query_result_audio.parse_mode
assert inline_query_result_audio_dict['input_message_content'] == \ assert (inline_query_result_audio_dict['input_message_content'] ==
inline_query_result_audio.input_message_content.to_dict() inline_query_result_audio.input_message_content.to_dict())
assert inline_query_result_audio_dict['reply_markup'] == \ assert (inline_query_result_audio_dict['reply_markup'] ==
inline_query_result_audio.reply_markup.to_dict() inline_query_result_audio.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultAudio(self.id, self.audio_url, self.title) a = InlineQueryResultAudio(self.id, self.audio_url, self.title)

35
tests/test_inlinequeryresultcachedaudio.py
View file

@ -25,7 +25,8 @@ from telegram import (InputTextMessageContent, InlineQueryResultCachedAudio, Inl
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_cached_audio(): def inline_query_result_cached_audio():
return InlineQueryResultCachedAudio(TestInlineQueryResultCachedAudio.id, return InlineQueryResultCachedAudio(
TestInlineQueryResultCachedAudio.id,
TestInlineQueryResultCachedAudio.audio_file_id, TestInlineQueryResultCachedAudio.audio_file_id,
caption=TestInlineQueryResultCachedAudio.caption, caption=TestInlineQueryResultCachedAudio.caption,
parse_mode=TestInlineQueryResultCachedAudio.parse_mode, parse_mode=TestInlineQueryResultCachedAudio.parse_mode,
@ -48,28 +49,28 @@ class TestInlineQueryResultCachedAudio(object):
assert inline_query_result_cached_audio.audio_file_id == self.audio_file_id assert inline_query_result_cached_audio.audio_file_id == self.audio_file_id
assert inline_query_result_cached_audio.caption == self.caption assert inline_query_result_cached_audio.caption == self.caption
assert inline_query_result_cached_audio.parse_mode == self.parse_mode assert inline_query_result_cached_audio.parse_mode == self.parse_mode
assert inline_query_result_cached_audio.input_message_content.to_dict() == \ assert (inline_query_result_cached_audio.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_cached_audio.reply_markup.to_dict() == \ assert (inline_query_result_cached_audio.reply_markup.to_dict() ==
self.reply_markup.to_dict() self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_cached_audio): def test_to_dict(self, inline_query_result_cached_audio):
inline_query_result_cached_audio_dict = inline_query_result_cached_audio.to_dict() inline_query_result_cached_audio_dict = inline_query_result_cached_audio.to_dict()
assert isinstance(inline_query_result_cached_audio_dict, dict) assert isinstance(inline_query_result_cached_audio_dict, dict)
assert inline_query_result_cached_audio_dict['type'] == \ assert (inline_query_result_cached_audio_dict['type'] ==
inline_query_result_cached_audio.type inline_query_result_cached_audio.type)
assert inline_query_result_cached_audio_dict['id'] == inline_query_result_cached_audio.id assert inline_query_result_cached_audio_dict['id'] == inline_query_result_cached_audio.id
assert inline_query_result_cached_audio_dict['audio_file_id'] == \ assert (inline_query_result_cached_audio_dict['audio_file_id'] ==
inline_query_result_cached_audio.audio_file_id inline_query_result_cached_audio.audio_file_id)
assert inline_query_result_cached_audio_dict['caption'] == \ assert (inline_query_result_cached_audio_dict['caption'] ==
inline_query_result_cached_audio.caption inline_query_result_cached_audio.caption)
assert inline_query_result_cached_audio_dict['parse_mode'] == \ assert (inline_query_result_cached_audio_dict['parse_mode'] ==
inline_query_result_cached_audio.parse_mode inline_query_result_cached_audio.parse_mode)
assert inline_query_result_cached_audio_dict['input_message_content'] == \ assert (inline_query_result_cached_audio_dict['input_message_content'] ==
inline_query_result_cached_audio.input_message_content.to_dict() inline_query_result_cached_audio.input_message_content.to_dict())
assert inline_query_result_cached_audio_dict['reply_markup'] == \ assert (inline_query_result_cached_audio_dict['reply_markup'] ==
inline_query_result_cached_audio.reply_markup.to_dict() inline_query_result_cached_audio.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultCachedAudio(self.id, self.audio_file_id) a = InlineQueryResultCachedAudio(self.id, self.audio_file_id)

47
tests/test_inlinequeryresultcacheddocument.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineQueryResultCachedDocument, InlineKeyboardButton, Inl
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_cached_document(): def inline_query_result_cached_document():
return InlineQueryResultCachedDocument(TestInlineQueryResultCachedDocument.id, return InlineQueryResultCachedDocument(
TestInlineQueryResultCachedDocument.id,
TestInlineQueryResultCachedDocument.title, TestInlineQueryResultCachedDocument.title,
TestInlineQueryResultCachedDocument.document_file_id, TestInlineQueryResultCachedDocument.document_file_id,
caption=TestInlineQueryResultCachedDocument.caption, caption=TestInlineQueryResultCachedDocument.caption,
@ -54,33 +55,33 @@ class TestInlineQueryResultCachedDocument(object):
assert inline_query_result_cached_document.caption == self.caption assert inline_query_result_cached_document.caption == self.caption
assert inline_query_result_cached_document.parse_mode == self.parse_mode assert inline_query_result_cached_document.parse_mode == self.parse_mode
assert inline_query_result_cached_document.description == self.description assert inline_query_result_cached_document.description == self.description
assert inline_query_result_cached_document.input_message_content.to_dict() == \ assert (inline_query_result_cached_document.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_cached_document.reply_markup.to_dict() == \ assert (inline_query_result_cached_document.reply_markup.to_dict() ==
self.reply_markup.to_dict() self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_cached_document): def test_to_dict(self, inline_query_result_cached_document):
inline_query_result_cached_document_dict = inline_query_result_cached_document.to_dict() inline_query_result_cached_document_dict = inline_query_result_cached_document.to_dict()
assert isinstance(inline_query_result_cached_document_dict, dict) assert isinstance(inline_query_result_cached_document_dict, dict)
assert inline_query_result_cached_document_dict['id'] == \ assert (inline_query_result_cached_document_dict['id'] ==
inline_query_result_cached_document.id inline_query_result_cached_document.id)
assert inline_query_result_cached_document_dict['type'] == \ assert (inline_query_result_cached_document_dict['type'] ==
inline_query_result_cached_document.type inline_query_result_cached_document.type)
assert inline_query_result_cached_document_dict['document_file_id'] == \ assert (inline_query_result_cached_document_dict['document_file_id'] ==
inline_query_result_cached_document.document_file_id inline_query_result_cached_document.document_file_id)
assert inline_query_result_cached_document_dict['title'] == \ assert (inline_query_result_cached_document_dict['title'] ==
inline_query_result_cached_document.title inline_query_result_cached_document.title)
assert inline_query_result_cached_document_dict['caption'] == \ assert (inline_query_result_cached_document_dict['caption'] ==
inline_query_result_cached_document.caption inline_query_result_cached_document.caption)
assert inline_query_result_cached_document_dict['parse_mode'] == \ assert (inline_query_result_cached_document_dict['parse_mode'] ==
inline_query_result_cached_document.parse_mode inline_query_result_cached_document.parse_mode)
assert inline_query_result_cached_document_dict['description'] == \ assert (inline_query_result_cached_document_dict['description'] ==
inline_query_result_cached_document.description inline_query_result_cached_document.description)
assert inline_query_result_cached_document_dict['input_message_content'] == \ assert (inline_query_result_cached_document_dict['input_message_content'] ==
inline_query_result_cached_document.input_message_content.to_dict() inline_query_result_cached_document.input_message_content.to_dict())
assert inline_query_result_cached_document_dict['reply_markup'] == \ assert (inline_query_result_cached_document_dict['reply_markup'] ==
inline_query_result_cached_document.reply_markup.to_dict() inline_query_result_cached_document.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultCachedDocument(self.id, self.title, self.document_file_id) a = InlineQueryResultCachedDocument(self.id, self.title, self.document_file_id)

27
tests/test_inlinequeryresultcachedgif.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineKeyboardButton, InputTextMessageContent, InlineQuery
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_cached_gif(): def inline_query_result_cached_gif():
return InlineQueryResultCachedGif(TestInlineQueryResultCachedGif.id, return InlineQueryResultCachedGif(
TestInlineQueryResultCachedGif.id,
TestInlineQueryResultCachedGif.gif_file_id, TestInlineQueryResultCachedGif.gif_file_id,
title=TestInlineQueryResultCachedGif.title, title=TestInlineQueryResultCachedGif.title,
caption=TestInlineQueryResultCachedGif.caption, caption=TestInlineQueryResultCachedGif.caption,
@ -51,8 +52,8 @@ class TestInlineQueryResultCachedGif(object):
assert inline_query_result_cached_gif.title == self.title assert inline_query_result_cached_gif.title == self.title
assert inline_query_result_cached_gif.caption == self.caption assert inline_query_result_cached_gif.caption == self.caption
assert inline_query_result_cached_gif.parse_mode == self.parse_mode assert inline_query_result_cached_gif.parse_mode == self.parse_mode
assert inline_query_result_cached_gif.input_message_content.to_dict() == \ assert (inline_query_result_cached_gif.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_cached_gif.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_cached_gif.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_cached_gif): def test_to_dict(self, inline_query_result_cached_gif):
@ -61,17 +62,17 @@ class TestInlineQueryResultCachedGif(object):
assert isinstance(inline_query_result_cached_gif_dict, dict) assert isinstance(inline_query_result_cached_gif_dict, dict)
assert inline_query_result_cached_gif_dict['type'] == inline_query_result_cached_gif.type assert inline_query_result_cached_gif_dict['type'] == inline_query_result_cached_gif.type
assert inline_query_result_cached_gif_dict['id'] == inline_query_result_cached_gif.id assert inline_query_result_cached_gif_dict['id'] == inline_query_result_cached_gif.id
assert inline_query_result_cached_gif_dict['gif_file_id'] == \ assert (inline_query_result_cached_gif_dict['gif_file_id'] ==
inline_query_result_cached_gif.gif_file_id inline_query_result_cached_gif.gif_file_id)
assert inline_query_result_cached_gif_dict['title'] == inline_query_result_cached_gif.title assert inline_query_result_cached_gif_dict['title'] == inline_query_result_cached_gif.title
assert inline_query_result_cached_gif_dict['caption'] == \ assert (inline_query_result_cached_gif_dict['caption'] ==
inline_query_result_cached_gif.caption inline_query_result_cached_gif.caption)
assert inline_query_result_cached_gif_dict['parse_mode'] == \ assert (inline_query_result_cached_gif_dict['parse_mode'] ==
inline_query_result_cached_gif.parse_mode inline_query_result_cached_gif.parse_mode)
assert inline_query_result_cached_gif_dict['input_message_content'] == \ assert (inline_query_result_cached_gif_dict['input_message_content'] ==
inline_query_result_cached_gif.input_message_content.to_dict() inline_query_result_cached_gif.input_message_content.to_dict())
assert inline_query_result_cached_gif_dict['reply_markup'] == \ assert (inline_query_result_cached_gif_dict['reply_markup'] ==
inline_query_result_cached_gif.reply_markup.to_dict() inline_query_result_cached_gif.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultCachedGif(self.id, self.gif_file_id) a = InlineQueryResultCachedGif(self.id, self.gif_file_id)

43
tests/test_inlinequeryresultcachedmpeg4gif.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineQueryResultCachedMpeg4Gif, InlineKeyboardButton,
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_cached_mpeg4_gif(): def inline_query_result_cached_mpeg4_gif():
return InlineQueryResultCachedMpeg4Gif(TestInlineQueryResultCachedMpeg4Gif.id, return InlineQueryResultCachedMpeg4Gif(
TestInlineQueryResultCachedMpeg4Gif.id,
TestInlineQueryResultCachedMpeg4Gif.mpeg4_file_id, TestInlineQueryResultCachedMpeg4Gif.mpeg4_file_id,
title=TestInlineQueryResultCachedMpeg4Gif.title, title=TestInlineQueryResultCachedMpeg4Gif.title,
caption=TestInlineQueryResultCachedMpeg4Gif.caption, caption=TestInlineQueryResultCachedMpeg4Gif.caption,
@ -51,31 +52,31 @@ class TestInlineQueryResultCachedMpeg4Gif(object):
assert inline_query_result_cached_mpeg4_gif.title == self.title assert inline_query_result_cached_mpeg4_gif.title == self.title
assert inline_query_result_cached_mpeg4_gif.caption == self.caption assert inline_query_result_cached_mpeg4_gif.caption == self.caption
assert inline_query_result_cached_mpeg4_gif.parse_mode == self.parse_mode assert inline_query_result_cached_mpeg4_gif.parse_mode == self.parse_mode
assert inline_query_result_cached_mpeg4_gif.input_message_content.to_dict() == \ assert (inline_query_result_cached_mpeg4_gif.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_cached_mpeg4_gif.reply_markup.to_dict() == \ assert (inline_query_result_cached_mpeg4_gif.reply_markup.to_dict() ==
self.reply_markup.to_dict() self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_cached_mpeg4_gif): def test_to_dict(self, inline_query_result_cached_mpeg4_gif):
inline_query_result_cached_mpeg4_gif_dict = inline_query_result_cached_mpeg4_gif.to_dict() inline_query_result_cached_mpeg4_gif_dict = inline_query_result_cached_mpeg4_gif.to_dict()
assert isinstance(inline_query_result_cached_mpeg4_gif_dict, dict) assert isinstance(inline_query_result_cached_mpeg4_gif_dict, dict)
assert inline_query_result_cached_mpeg4_gif_dict['type'] == \ assert (inline_query_result_cached_mpeg4_gif_dict['type'] ==
inline_query_result_cached_mpeg4_gif.type inline_query_result_cached_mpeg4_gif.type)
assert inline_query_result_cached_mpeg4_gif_dict['id'] == \ assert (inline_query_result_cached_mpeg4_gif_dict['id'] ==
inline_query_result_cached_mpeg4_gif.id inline_query_result_cached_mpeg4_gif.id)
assert inline_query_result_cached_mpeg4_gif_dict['mpeg4_file_id'] == \ assert (inline_query_result_cached_mpeg4_gif_dict['mpeg4_file_id'] ==
inline_query_result_cached_mpeg4_gif.mpeg4_file_id inline_query_result_cached_mpeg4_gif.mpeg4_file_id)
assert inline_query_result_cached_mpeg4_gif_dict['title'] == \ assert (inline_query_result_cached_mpeg4_gif_dict['title'] ==
inline_query_result_cached_mpeg4_gif.title inline_query_result_cached_mpeg4_gif.title)
assert inline_query_result_cached_mpeg4_gif_dict['caption'] == \ assert (inline_query_result_cached_mpeg4_gif_dict['caption'] ==
inline_query_result_cached_mpeg4_gif.caption inline_query_result_cached_mpeg4_gif.caption)
assert inline_query_result_cached_mpeg4_gif_dict['parse_mode'] == \ assert (inline_query_result_cached_mpeg4_gif_dict['parse_mode'] ==
inline_query_result_cached_mpeg4_gif.parse_mode inline_query_result_cached_mpeg4_gif.parse_mode)
assert inline_query_result_cached_mpeg4_gif_dict['input_message_content'] == \ assert (inline_query_result_cached_mpeg4_gif_dict['input_message_content'] ==
inline_query_result_cached_mpeg4_gif.input_message_content.to_dict() inline_query_result_cached_mpeg4_gif.input_message_content.to_dict())
assert inline_query_result_cached_mpeg4_gif_dict['reply_markup'] == \ assert (inline_query_result_cached_mpeg4_gif_dict['reply_markup'] ==
inline_query_result_cached_mpeg4_gif.reply_markup.to_dict() inline_query_result_cached_mpeg4_gif.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultCachedMpeg4Gif(self.id, self.mpeg4_file_id) a = InlineQueryResultCachedMpeg4Gif(self.id, self.mpeg4_file_id)

43
tests/test_inlinequeryresultcachedphoto.py
View file

@ -25,7 +25,8 @@ from telegram import (InputTextMessageContent, InlineQueryResultCachedPhoto, Inl
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_cached_photo(): def inline_query_result_cached_photo():
return InlineQueryResultCachedPhoto(TestInlineQueryResultCachedPhoto.id, return InlineQueryResultCachedPhoto(
TestInlineQueryResultCachedPhoto.id,
TestInlineQueryResultCachedPhoto.photo_file_id, TestInlineQueryResultCachedPhoto.photo_file_id,
title=TestInlineQueryResultCachedPhoto.title, title=TestInlineQueryResultCachedPhoto.title,
description=TestInlineQueryResultCachedPhoto.description, description=TestInlineQueryResultCachedPhoto.description,
@ -54,32 +55,32 @@ class TestInlineQueryResultCachedPhoto(object):
assert inline_query_result_cached_photo.description == self.description assert inline_query_result_cached_photo.description == self.description
assert inline_query_result_cached_photo.caption == self.caption assert inline_query_result_cached_photo.caption == self.caption
assert inline_query_result_cached_photo.parse_mode == self.parse_mode assert inline_query_result_cached_photo.parse_mode == self.parse_mode
assert inline_query_result_cached_photo.input_message_content.to_dict() == \ assert (inline_query_result_cached_photo.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_cached_photo.reply_markup.to_dict() == \ assert (inline_query_result_cached_photo.reply_markup.to_dict() ==
self.reply_markup.to_dict() self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_cached_photo): def test_to_dict(self, inline_query_result_cached_photo):
inline_query_result_cached_photo_dict = inline_query_result_cached_photo.to_dict() inline_query_result_cached_photo_dict = inline_query_result_cached_photo.to_dict()
assert isinstance(inline_query_result_cached_photo_dict, dict) assert isinstance(inline_query_result_cached_photo_dict, dict)
assert inline_query_result_cached_photo_dict['type'] == \ assert (inline_query_result_cached_photo_dict['type'] ==
inline_query_result_cached_photo.type inline_query_result_cached_photo.type)
assert inline_query_result_cached_photo_dict['id'] == inline_query_result_cached_photo.id assert inline_query_result_cached_photo_dict['id'] == inline_query_result_cached_photo.id
assert inline_query_result_cached_photo_dict['photo_file_id'] == \ assert (inline_query_result_cached_photo_dict['photo_file_id'] ==
inline_query_result_cached_photo.photo_file_id inline_query_result_cached_photo.photo_file_id)
assert inline_query_result_cached_photo_dict['title'] == \ assert (inline_query_result_cached_photo_dict['title'] ==
inline_query_result_cached_photo.title inline_query_result_cached_photo.title)
assert inline_query_result_cached_photo_dict['description'] == \ assert (inline_query_result_cached_photo_dict['description'] ==
inline_query_result_cached_photo.description inline_query_result_cached_photo.description)
assert inline_query_result_cached_photo_dict['caption'] == \ assert (inline_query_result_cached_photo_dict['caption'] ==
inline_query_result_cached_photo.caption inline_query_result_cached_photo.caption)
assert inline_query_result_cached_photo_dict['parse_mode'] == \ assert (inline_query_result_cached_photo_dict['parse_mode'] ==
inline_query_result_cached_photo.parse_mode inline_query_result_cached_photo.parse_mode)
assert inline_query_result_cached_photo_dict['input_message_content'] == \ assert (inline_query_result_cached_photo_dict['input_message_content'] ==
inline_query_result_cached_photo.input_message_content.to_dict() inline_query_result_cached_photo.input_message_content.to_dict())
assert inline_query_result_cached_photo_dict['reply_markup'] == \ assert (inline_query_result_cached_photo_dict['reply_markup'] ==
inline_query_result_cached_photo.reply_markup.to_dict() inline_query_result_cached_photo.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultCachedPhoto(self.id, self.photo_file_id) a = InlineQueryResultCachedPhoto(self.id, self.photo_file_id)

31
tests/test_inlinequeryresultcachedsticker.py
View file

@ -26,7 +26,8 @@ from telegram import (InputTextMessageContent, InlineKeyboardButton,
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_cached_sticker(): def inline_query_result_cached_sticker():
return InlineQueryResultCachedSticker(TestInlineQueryResultCachedSticker.id, return InlineQueryResultCachedSticker(
TestInlineQueryResultCachedSticker.id,
TestInlineQueryResultCachedSticker.sticker_file_id, TestInlineQueryResultCachedSticker.sticker_file_id,
input_message_content=TestInlineQueryResultCachedSticker.input_message_content, input_message_content=TestInlineQueryResultCachedSticker.input_message_content,
reply_markup=TestInlineQueryResultCachedSticker.reply_markup) reply_markup=TestInlineQueryResultCachedSticker.reply_markup)
@ -43,25 +44,25 @@ class TestInlineQueryResultCachedSticker(object):
assert inline_query_result_cached_sticker.type == self.type assert inline_query_result_cached_sticker.type == self.type
assert inline_query_result_cached_sticker.id == self.id assert inline_query_result_cached_sticker.id == self.id
assert inline_query_result_cached_sticker.sticker_file_id == self.sticker_file_id assert inline_query_result_cached_sticker.sticker_file_id == self.sticker_file_id
assert inline_query_result_cached_sticker.input_message_content.to_dict() == \ assert (inline_query_result_cached_sticker.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_cached_sticker.reply_markup.to_dict() == \ assert (inline_query_result_cached_sticker.reply_markup.to_dict() ==
self.reply_markup.to_dict() self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_cached_sticker): def test_to_dict(self, inline_query_result_cached_sticker):
inline_query_result_cached_sticker_dict = inline_query_result_cached_sticker.to_dict() inline_query_result_cached_sticker_dict = inline_query_result_cached_sticker.to_dict()
assert isinstance(inline_query_result_cached_sticker_dict, dict) assert isinstance(inline_query_result_cached_sticker_dict, dict)
assert inline_query_result_cached_sticker_dict['type'] == \ assert (inline_query_result_cached_sticker_dict['type'] ==
inline_query_result_cached_sticker.type inline_query_result_cached_sticker.type)
assert inline_query_result_cached_sticker_dict['id'] == \ assert (inline_query_result_cached_sticker_dict['id'] ==
inline_query_result_cached_sticker.id inline_query_result_cached_sticker.id)
assert inline_query_result_cached_sticker_dict['sticker_file_id'] == \ assert (inline_query_result_cached_sticker_dict['sticker_file_id'] ==
inline_query_result_cached_sticker.sticker_file_id inline_query_result_cached_sticker.sticker_file_id)
assert inline_query_result_cached_sticker_dict['input_message_content'] == \ assert (inline_query_result_cached_sticker_dict['input_message_content'] ==
inline_query_result_cached_sticker.input_message_content.to_dict() inline_query_result_cached_sticker.input_message_content.to_dict())
assert inline_query_result_cached_sticker_dict['reply_markup'] == \ assert (inline_query_result_cached_sticker_dict['reply_markup'] ==
inline_query_result_cached_sticker.reply_markup.to_dict() inline_query_result_cached_sticker.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultCachedSticker(self.id, self.sticker_file_id) a = InlineQueryResultCachedSticker(self.id, self.sticker_file_id)

43
tests/test_inlinequeryresultcachedvideo.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineKeyboardMarkup, InlineKeyboardButton, InputTextMessa
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_cached_video(): def inline_query_result_cached_video():
return InlineQueryResultCachedVideo(TestInlineQueryResultCachedVideo.id, return InlineQueryResultCachedVideo(
TestInlineQueryResultCachedVideo.id,
TestInlineQueryResultCachedVideo.video_file_id, TestInlineQueryResultCachedVideo.video_file_id,
TestInlineQueryResultCachedVideo.title, TestInlineQueryResultCachedVideo.title,
caption=TestInlineQueryResultCachedVideo.caption, caption=TestInlineQueryResultCachedVideo.caption,
@ -54,32 +55,32 @@ class TestInlineQueryResultCachedVideo(object):
assert inline_query_result_cached_video.description == self.description assert inline_query_result_cached_video.description == self.description
assert inline_query_result_cached_video.caption == self.caption assert inline_query_result_cached_video.caption == self.caption
assert inline_query_result_cached_video.parse_mode == self.parse_mode assert inline_query_result_cached_video.parse_mode == self.parse_mode
assert inline_query_result_cached_video.input_message_content.to_dict() == \ assert (inline_query_result_cached_video.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_cached_video.reply_markup.to_dict() == \ assert (inline_query_result_cached_video.reply_markup.to_dict() ==
self.reply_markup.to_dict() self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_cached_video): def test_to_dict(self, inline_query_result_cached_video):
inline_query_result_cached_video_dict = inline_query_result_cached_video.to_dict() inline_query_result_cached_video_dict = inline_query_result_cached_video.to_dict()
assert isinstance(inline_query_result_cached_video_dict, dict) assert isinstance(inline_query_result_cached_video_dict, dict)
assert inline_query_result_cached_video_dict['type'] == \ assert (inline_query_result_cached_video_dict['type'] ==
inline_query_result_cached_video.type inline_query_result_cached_video.type)
assert inline_query_result_cached_video_dict['id'] == inline_query_result_cached_video.id assert inline_query_result_cached_video_dict['id'] == inline_query_result_cached_video.id
assert inline_query_result_cached_video_dict['video_file_id'] == \ assert (inline_query_result_cached_video_dict['video_file_id'] ==
inline_query_result_cached_video.video_file_id inline_query_result_cached_video.video_file_id)
assert inline_query_result_cached_video_dict['title'] == \ assert (inline_query_result_cached_video_dict['title'] ==
inline_query_result_cached_video.title inline_query_result_cached_video.title)
assert inline_query_result_cached_video_dict['description'] == \ assert (inline_query_result_cached_video_dict['description'] ==
inline_query_result_cached_video.description inline_query_result_cached_video.description)
assert inline_query_result_cached_video_dict['caption'] == \ assert (inline_query_result_cached_video_dict['caption'] ==
inline_query_result_cached_video.caption inline_query_result_cached_video.caption)
assert inline_query_result_cached_video_dict['parse_mode'] == \ assert (inline_query_result_cached_video_dict['parse_mode'] ==
inline_query_result_cached_video.parse_mode inline_query_result_cached_video.parse_mode)
assert inline_query_result_cached_video_dict['input_message_content'] == \ assert (inline_query_result_cached_video_dict['input_message_content'] ==
inline_query_result_cached_video.input_message_content.to_dict() inline_query_result_cached_video.input_message_content.to_dict())
assert inline_query_result_cached_video_dict['reply_markup'] == \ assert (inline_query_result_cached_video_dict['reply_markup'] ==
inline_query_result_cached_video.reply_markup.to_dict() inline_query_result_cached_video.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultCachedVideo(self.id, self.video_file_id, self.title) a = InlineQueryResultCachedVideo(self.id, self.video_file_id, self.title)

39
tests/test_inlinequeryresultcachedvoice.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineQueryResultCachedVoice, InlineKeyboardButton, Inline
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_cached_voice(): def inline_query_result_cached_voice():
return InlineQueryResultCachedVoice(TestInlineQueryResultCachedVoice.id, return InlineQueryResultCachedVoice(
TestInlineQueryResultCachedVoice.id,
TestInlineQueryResultCachedVoice.voice_file_id, TestInlineQueryResultCachedVoice.voice_file_id,
TestInlineQueryResultCachedVoice.title, TestInlineQueryResultCachedVoice.title,
caption=TestInlineQueryResultCachedVoice.caption, caption=TestInlineQueryResultCachedVoice.caption,
@ -51,30 +52,30 @@ class TestInlineQueryResultCachedVoice(object):
assert inline_query_result_cached_voice.title == self.title assert inline_query_result_cached_voice.title == self.title
assert inline_query_result_cached_voice.caption == self.caption assert inline_query_result_cached_voice.caption == self.caption
assert inline_query_result_cached_voice.parse_mode == self.parse_mode assert inline_query_result_cached_voice.parse_mode == self.parse_mode
assert inline_query_result_cached_voice.input_message_content.to_dict() == \ assert (inline_query_result_cached_voice.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_cached_voice.reply_markup.to_dict() == \ assert (inline_query_result_cached_voice.reply_markup.to_dict() ==
self.reply_markup.to_dict() self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_cached_voice): def test_to_dict(self, inline_query_result_cached_voice):
inline_query_result_cached_voice_dict = inline_query_result_cached_voice.to_dict() inline_query_result_cached_voice_dict = inline_query_result_cached_voice.to_dict()
assert isinstance(inline_query_result_cached_voice_dict, dict) assert isinstance(inline_query_result_cached_voice_dict, dict)
assert inline_query_result_cached_voice_dict['type'] == \ assert (inline_query_result_cached_voice_dict['type'] ==
inline_query_result_cached_voice.type inline_query_result_cached_voice.type)
assert inline_query_result_cached_voice_dict['id'] == inline_query_result_cached_voice.id assert inline_query_result_cached_voice_dict['id'] == inline_query_result_cached_voice.id
assert inline_query_result_cached_voice_dict['voice_file_id'] == \ assert (inline_query_result_cached_voice_dict['voice_file_id'] ==
inline_query_result_cached_voice.voice_file_id inline_query_result_cached_voice.voice_file_id)
assert inline_query_result_cached_voice_dict['title'] == \ assert (inline_query_result_cached_voice_dict['title'] ==
inline_query_result_cached_voice.title inline_query_result_cached_voice.title)
assert inline_query_result_cached_voice_dict['caption'] == \ assert (inline_query_result_cached_voice_dict['caption'] ==
inline_query_result_cached_voice.caption inline_query_result_cached_voice.caption)
assert inline_query_result_cached_voice_dict['parse_mode'] == \ assert (inline_query_result_cached_voice_dict['parse_mode'] ==
inline_query_result_cached_voice.parse_mode inline_query_result_cached_voice.parse_mode)
assert inline_query_result_cached_voice_dict['input_message_content'] == \ assert (inline_query_result_cached_voice_dict['input_message_content'] ==
inline_query_result_cached_voice.input_message_content.to_dict() inline_query_result_cached_voice.input_message_content.to_dict())
assert inline_query_result_cached_voice_dict['reply_markup'] == \ assert (inline_query_result_cached_voice_dict['reply_markup'] ==
inline_query_result_cached_voice.reply_markup.to_dict() inline_query_result_cached_voice.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultCachedVoice(self.id, self.voice_file_id, self.title) a = InlineQueryResultCachedVoice(self.id, self.voice_file_id, self.title)

39
tests/test_inlinequeryresultcontact.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineQueryResultVoice, InputTextMessageContent, InlineKey
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_contact(): def inline_query_result_contact():
return InlineQueryResultContact(TestInlineQueryResultContact.id, return InlineQueryResultContact(
TestInlineQueryResultContact.id,
TestInlineQueryResultContact.phone_number, TestInlineQueryResultContact.phone_number,
TestInlineQueryResultContact.first_name, TestInlineQueryResultContact.first_name,
last_name=TestInlineQueryResultContact.last_name, last_name=TestInlineQueryResultContact.last_name,
@ -57,8 +58,8 @@ class TestInlineQueryResultContact(object):
assert inline_query_result_contact.thumb_url == self.thumb_url assert inline_query_result_contact.thumb_url == self.thumb_url
assert inline_query_result_contact.thumb_width == self.thumb_width assert inline_query_result_contact.thumb_width == self.thumb_width
assert inline_query_result_contact.thumb_height == self.thumb_height assert inline_query_result_contact.thumb_height == self.thumb_height
assert inline_query_result_contact.input_message_content.to_dict() == \ assert (inline_query_result_contact.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_contact.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_contact.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_contact): def test_to_dict(self, inline_query_result_contact):
@ -67,22 +68,22 @@ class TestInlineQueryResultContact(object):
assert isinstance(inline_query_result_contact_dict, dict) assert isinstance(inline_query_result_contact_dict, dict)
assert inline_query_result_contact_dict['id'] == inline_query_result_contact.id assert inline_query_result_contact_dict['id'] == inline_query_result_contact.id
assert inline_query_result_contact_dict['type'] == inline_query_result_contact.type assert inline_query_result_contact_dict['type'] == inline_query_result_contact.type
assert inline_query_result_contact_dict['phone_number'] == \ assert (inline_query_result_contact_dict['phone_number'] ==
inline_query_result_contact.phone_number inline_query_result_contact.phone_number)
assert inline_query_result_contact_dict['first_name'] == \ assert (inline_query_result_contact_dict['first_name'] ==
inline_query_result_contact.first_name inline_query_result_contact.first_name)
assert inline_query_result_contact_dict['last_name'] == \ assert (inline_query_result_contact_dict['last_name'] ==
inline_query_result_contact.last_name inline_query_result_contact.last_name)
assert inline_query_result_contact_dict['thumb_url'] == \ assert (inline_query_result_contact_dict['thumb_url'] ==
inline_query_result_contact.thumb_url inline_query_result_contact.thumb_url)
assert inline_query_result_contact_dict['thumb_width'] == \ assert (inline_query_result_contact_dict['thumb_width'] ==
inline_query_result_contact.thumb_width inline_query_result_contact.thumb_width)
assert inline_query_result_contact_dict['thumb_height'] == \ assert (inline_query_result_contact_dict['thumb_height'] ==
inline_query_result_contact.thumb_height inline_query_result_contact.thumb_height)
assert inline_query_result_contact_dict['input_message_content'] == \ assert (inline_query_result_contact_dict['input_message_content'] ==
inline_query_result_contact.input_message_content.to_dict() inline_query_result_contact.input_message_content.to_dict())
assert inline_query_result_contact_dict['reply_markup'] == \ assert (inline_query_result_contact_dict['reply_markup'] ==
inline_query_result_contact.reply_markup.to_dict() inline_query_result_contact.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultContact(self.id, self.phone_number, self.first_name) a = InlineQueryResultContact(self.id, self.phone_number, self.first_name)

43
tests/test_inlinequeryresultdocument.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineKeyboardButton, InputTextMessageContent, InlineQuery
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_document(): def inline_query_result_document():
return InlineQueryResultDocument(TestInlineQueryResultDocument.id, return InlineQueryResultDocument(
TestInlineQueryResultDocument.id,
TestInlineQueryResultDocument.document_url, TestInlineQueryResultDocument.document_url,
TestInlineQueryResultDocument.title, TestInlineQueryResultDocument.title,
TestInlineQueryResultDocument.mime_type, TestInlineQueryResultDocument.mime_type,
@ -66,8 +67,8 @@ class TestInlineQueryResultDocument(object):
assert inline_query_result_document.thumb_url == self.thumb_url assert inline_query_result_document.thumb_url == self.thumb_url
assert inline_query_result_document.thumb_width == self.thumb_width assert inline_query_result_document.thumb_width == self.thumb_width
assert inline_query_result_document.thumb_height == self.thumb_height assert inline_query_result_document.thumb_height == self.thumb_height
assert inline_query_result_document.input_message_content.to_dict() == \ assert (inline_query_result_document.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_document.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_document.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_document): def test_to_dict(self, inline_query_result_document):
@ -76,26 +77,26 @@ class TestInlineQueryResultDocument(object):
assert isinstance(inline_query_result_document_dict, dict) assert isinstance(inline_query_result_document_dict, dict)
assert inline_query_result_document_dict['id'] == inline_query_result_document.id assert inline_query_result_document_dict['id'] == inline_query_result_document.id
assert inline_query_result_document_dict['type'] == inline_query_result_document.type assert inline_query_result_document_dict['type'] == inline_query_result_document.type
assert inline_query_result_document_dict['document_url'] == \ assert (inline_query_result_document_dict['document_url'] ==
inline_query_result_document.document_url inline_query_result_document.document_url)
assert inline_query_result_document_dict['title'] == inline_query_result_document.title assert inline_query_result_document_dict['title'] == inline_query_result_document.title
assert inline_query_result_document_dict['caption'] == inline_query_result_document.caption assert inline_query_result_document_dict['caption'] == inline_query_result_document.caption
assert inline_query_result_document_dict['parse_mode'] == \ assert (inline_query_result_document_dict['parse_mode'] ==
inline_query_result_document.parse_mode inline_query_result_document.parse_mode)
assert inline_query_result_document_dict['mime_type'] == \ assert (inline_query_result_document_dict['mime_type'] ==
inline_query_result_document.mime_type inline_query_result_document.mime_type)
assert inline_query_result_document_dict['description'] == \ assert (inline_query_result_document_dict['description'] ==
inline_query_result_document.description inline_query_result_document.description)
assert inline_query_result_document_dict['thumb_url'] == \ assert (inline_query_result_document_dict['thumb_url'] ==
inline_query_result_document.thumb_url inline_query_result_document.thumb_url)
assert inline_query_result_document_dict['thumb_width'] == \ assert (inline_query_result_document_dict['thumb_width'] ==
inline_query_result_document.thumb_width inline_query_result_document.thumb_width)
assert inline_query_result_document_dict['thumb_height'] == \ assert (inline_query_result_document_dict['thumb_height'] ==
inline_query_result_document.thumb_height inline_query_result_document.thumb_height)
assert inline_query_result_document_dict['input_message_content'] == \ assert (inline_query_result_document_dict['input_message_content'] ==
inline_query_result_document.input_message_content.to_dict() inline_query_result_document.input_message_content.to_dict())
assert inline_query_result_document_dict['reply_markup'] == \ assert (inline_query_result_document_dict['reply_markup'] ==
inline_query_result_document.reply_markup.to_dict() inline_query_result_document.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultDocument(self.id, self.document_url, self.title, a = InlineQueryResultDocument(self.id, self.document_url, self.title,

12
tests/test_inlinequeryresultgame.py
View file

@ -40,8 +40,8 @@ class TestInlineQueryResultGame(object):
assert inline_query_result_game.type == self.type assert inline_query_result_game.type == self.type
assert inline_query_result_game.id == self.id assert inline_query_result_game.id == self.id
assert inline_query_result_game.game_short_name == self.game_short_name assert inline_query_result_game.game_short_name == self.game_short_name
assert inline_query_result_game.reply_markup.to_dict() == \ assert (inline_query_result_game.reply_markup.to_dict() ==
self.reply_markup.to_dict() self.reply_markup.to_dict())
def test_to_dict(self, inline_query_result_game): def test_to_dict(self, inline_query_result_game):
inline_query_result_game_dict = inline_query_result_game.to_dict() inline_query_result_game_dict = inline_query_result_game.to_dict()
@ -49,10 +49,10 @@ class TestInlineQueryResultGame(object):
assert isinstance(inline_query_result_game_dict, dict) assert isinstance(inline_query_result_game_dict, dict)
assert inline_query_result_game_dict['type'] == inline_query_result_game.type assert inline_query_result_game_dict['type'] == inline_query_result_game.type
assert inline_query_result_game_dict['id'] == inline_query_result_game.id assert inline_query_result_game_dict['id'] == inline_query_result_game.id
assert inline_query_result_game_dict['game_short_name'] == \ assert (inline_query_result_game_dict['game_short_name'] ==
inline_query_result_game.game_short_name inline_query_result_game.game_short_name)
assert inline_query_result_game_dict['reply_markup'] == \ assert (inline_query_result_game_dict['reply_markup'] ==
inline_query_result_game.reply_markup.to_dict() inline_query_result_game.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultGame(self.id, self.game_short_name) a = InlineQueryResultGame(self.id, self.game_short_name)

15
tests/test_inlinequeryresultgif.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineKeyboardButton, InputTextMessageContent, InlineQuery
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_gif(): def inline_query_result_gif():
return InlineQueryResultGif(TestInlineQueryResultGif.id, return InlineQueryResultGif(
TestInlineQueryResultGif.id,
TestInlineQueryResultGif.gif_url, TestInlineQueryResultGif.gif_url,
TestInlineQueryResultGif.thumb_url, TestInlineQueryResultGif.thumb_url,
gif_width=TestInlineQueryResultGif.gif_width, gif_width=TestInlineQueryResultGif.gif_width,
@ -63,8 +64,8 @@ class TestInlineQueryResultGif(object):
assert inline_query_result_gif.title == self.title assert inline_query_result_gif.title == self.title
assert inline_query_result_gif.caption == self.caption assert inline_query_result_gif.caption == self.caption
assert inline_query_result_gif.parse_mode == self.parse_mode assert inline_query_result_gif.parse_mode == self.parse_mode
assert inline_query_result_gif.input_message_content.to_dict() == \ assert (inline_query_result_gif.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_gif.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_gif.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_gif): def test_to_dict(self, inline_query_result_gif):
@ -81,10 +82,10 @@ class TestInlineQueryResultGif(object):
assert inline_query_result_gif_dict['title'] == inline_query_result_gif.title assert inline_query_result_gif_dict['title'] == inline_query_result_gif.title
assert inline_query_result_gif_dict['caption'] == inline_query_result_gif.caption assert inline_query_result_gif_dict['caption'] == inline_query_result_gif.caption
assert inline_query_result_gif_dict['parse_mode'] == inline_query_result_gif.parse_mode assert inline_query_result_gif_dict['parse_mode'] == inline_query_result_gif.parse_mode
assert inline_query_result_gif_dict['input_message_content'] == \ assert (inline_query_result_gif_dict['input_message_content'] ==
inline_query_result_gif.input_message_content.to_dict() inline_query_result_gif.input_message_content.to_dict())
assert inline_query_result_gif_dict['reply_markup'] == \ assert (inline_query_result_gif_dict['reply_markup'] ==
inline_query_result_gif.reply_markup.to_dict() inline_query_result_gif.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultGif(self.id, self.gif_url, self.thumb_url) a = InlineQueryResultGif(self.id, self.gif_url, self.thumb_url)

39
tests/test_inlinequeryresultlocation.py
View file

@ -25,7 +25,8 @@ from telegram import (InputTextMessageContent, InlineQueryResultLocation, Inline
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_location(): def inline_query_result_location():
return InlineQueryResultLocation(TestInlineQueryResultLocation.id, return InlineQueryResultLocation(
TestInlineQueryResultLocation.id,
TestInlineQueryResultLocation.latitude, TestInlineQueryResultLocation.latitude,
TestInlineQueryResultLocation.longitude, TestInlineQueryResultLocation.longitude,
TestInlineQueryResultLocation.title, TestInlineQueryResultLocation.title,
@ -60,8 +61,8 @@ class TestInlineQueryResultLocation(object):
assert inline_query_result_location.thumb_url == self.thumb_url assert inline_query_result_location.thumb_url == self.thumb_url
assert inline_query_result_location.thumb_width == self.thumb_width assert inline_query_result_location.thumb_width == self.thumb_width
assert inline_query_result_location.thumb_height == self.thumb_height assert inline_query_result_location.thumb_height == self.thumb_height
assert inline_query_result_location.input_message_content.to_dict() == \ assert (inline_query_result_location.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_location.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_location.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_location): def test_to_dict(self, inline_query_result_location):
@ -70,23 +71,23 @@ class TestInlineQueryResultLocation(object):
assert isinstance(inline_query_result_location_dict, dict) assert isinstance(inline_query_result_location_dict, dict)
assert inline_query_result_location_dict['id'] == inline_query_result_location.id assert inline_query_result_location_dict['id'] == inline_query_result_location.id
assert inline_query_result_location_dict['type'] == inline_query_result_location.type assert inline_query_result_location_dict['type'] == inline_query_result_location.type
assert inline_query_result_location_dict['latitude'] == \ assert (inline_query_result_location_dict['latitude'] ==
inline_query_result_location.latitude inline_query_result_location.latitude)
assert inline_query_result_location_dict['longitude'] == \ assert (inline_query_result_location_dict['longitude'] ==
inline_query_result_location.longitude inline_query_result_location.longitude)
assert inline_query_result_location_dict['title'] == inline_query_result_location.title assert inline_query_result_location_dict['title'] == inline_query_result_location.title
assert inline_query_result_location_dict[ assert (inline_query_result_location_dict['live_period'] ==
'live_period'] == inline_query_result_location.live_period inline_query_result_location.live_period)
assert inline_query_result_location_dict['thumb_url'] == \ assert (inline_query_result_location_dict['thumb_url'] ==
inline_query_result_location.thumb_url inline_query_result_location.thumb_url)
assert inline_query_result_location_dict['thumb_width'] == \ assert (inline_query_result_location_dict['thumb_width'] ==
inline_query_result_location.thumb_width inline_query_result_location.thumb_width)
assert inline_query_result_location_dict['thumb_height'] == \ assert (inline_query_result_location_dict['thumb_height'] ==
inline_query_result_location.thumb_height inline_query_result_location.thumb_height)
assert inline_query_result_location_dict['input_message_content'] == \ assert (inline_query_result_location_dict['input_message_content'] ==
inline_query_result_location.input_message_content.to_dict() inline_query_result_location.input_message_content.to_dict())
assert inline_query_result_location_dict['reply_markup'] == \ assert (inline_query_result_location_dict['reply_markup'] ==
inline_query_result_location.reply_markup.to_dict() inline_query_result_location.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultLocation(self.id, self.longitude, self.latitude, self.title) a = InlineQueryResultLocation(self.id, self.longitude, self.latitude, self.title)

43
tests/test_inlinequeryresultmpeg4gif.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineQueryResultMpeg4Gif, InlineKeyboardButton, InlineQue
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_mpeg4_gif(): def inline_query_result_mpeg4_gif():
return InlineQueryResultMpeg4Gif(TestInlineQueryResultMpeg4Gif.id, return InlineQueryResultMpeg4Gif(
TestInlineQueryResultMpeg4Gif.id,
TestInlineQueryResultMpeg4Gif.mpeg4_url, TestInlineQueryResultMpeg4Gif.mpeg4_url,
TestInlineQueryResultMpeg4Gif.thumb_url, TestInlineQueryResultMpeg4Gif.thumb_url,
mpeg4_width=TestInlineQueryResultMpeg4Gif.mpeg4_width, mpeg4_width=TestInlineQueryResultMpeg4Gif.mpeg4_width,
@ -63,8 +64,8 @@ class TestInlineQueryResultMpeg4Gif(object):
assert inline_query_result_mpeg4_gif.title == self.title assert inline_query_result_mpeg4_gif.title == self.title
assert inline_query_result_mpeg4_gif.caption == self.caption assert inline_query_result_mpeg4_gif.caption == self.caption
assert inline_query_result_mpeg4_gif.parse_mode == self.parse_mode assert inline_query_result_mpeg4_gif.parse_mode == self.parse_mode
assert inline_query_result_mpeg4_gif.input_message_content.to_dict() == \ assert (inline_query_result_mpeg4_gif.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_mpeg4_gif.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_mpeg4_gif.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_mpeg4_gif): def test_to_dict(self, inline_query_result_mpeg4_gif):
@ -73,25 +74,25 @@ class TestInlineQueryResultMpeg4Gif(object):
assert isinstance(inline_query_result_mpeg4_gif_dict, dict) assert isinstance(inline_query_result_mpeg4_gif_dict, dict)
assert inline_query_result_mpeg4_gif_dict['type'] == inline_query_result_mpeg4_gif.type assert inline_query_result_mpeg4_gif_dict['type'] == inline_query_result_mpeg4_gif.type
assert inline_query_result_mpeg4_gif_dict['id'] == inline_query_result_mpeg4_gif.id assert inline_query_result_mpeg4_gif_dict['id'] == inline_query_result_mpeg4_gif.id
assert inline_query_result_mpeg4_gif_dict['mpeg4_url'] == \ assert (inline_query_result_mpeg4_gif_dict['mpeg4_url'] ==
inline_query_result_mpeg4_gif.mpeg4_url inline_query_result_mpeg4_gif.mpeg4_url)
assert inline_query_result_mpeg4_gif_dict['mpeg4_width'] == \ assert (inline_query_result_mpeg4_gif_dict['mpeg4_width'] ==
inline_query_result_mpeg4_gif.mpeg4_width inline_query_result_mpeg4_gif.mpeg4_width)
assert inline_query_result_mpeg4_gif_dict['mpeg4_height'] == \ assert (inline_query_result_mpeg4_gif_dict['mpeg4_height'] ==
inline_query_result_mpeg4_gif.mpeg4_height inline_query_result_mpeg4_gif.mpeg4_height)
assert inline_query_result_mpeg4_gif_dict['mpeg4_duration'] == \ assert (inline_query_result_mpeg4_gif_dict['mpeg4_duration'] ==
inline_query_result_mpeg4_gif.mpeg4_duration inline_query_result_mpeg4_gif.mpeg4_duration)
assert inline_query_result_mpeg4_gif_dict['thumb_url'] == \ assert (inline_query_result_mpeg4_gif_dict['thumb_url'] ==
inline_query_result_mpeg4_gif.thumb_url inline_query_result_mpeg4_gif.thumb_url)
assert inline_query_result_mpeg4_gif_dict['title'] == inline_query_result_mpeg4_gif.title assert inline_query_result_mpeg4_gif_dict['title'] == inline_query_result_mpeg4_gif.title
assert inline_query_result_mpeg4_gif_dict['caption'] == \ assert (inline_query_result_mpeg4_gif_dict['caption'] ==
inline_query_result_mpeg4_gif.caption inline_query_result_mpeg4_gif.caption)
assert inline_query_result_mpeg4_gif_dict['parse_mode'] == \ assert (inline_query_result_mpeg4_gif_dict['parse_mode'] ==
inline_query_result_mpeg4_gif.parse_mode inline_query_result_mpeg4_gif.parse_mode)
assert inline_query_result_mpeg4_gif_dict['input_message_content'] == \ assert (inline_query_result_mpeg4_gif_dict['input_message_content'] ==
inline_query_result_mpeg4_gif.input_message_content.to_dict() inline_query_result_mpeg4_gif.input_message_content.to_dict())
assert inline_query_result_mpeg4_gif_dict['reply_markup'] == \ assert (inline_query_result_mpeg4_gif_dict['reply_markup'] ==
inline_query_result_mpeg4_gif.reply_markup.to_dict() inline_query_result_mpeg4_gif.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultMpeg4Gif(self.id, self.mpeg4_url, self.thumb_url) a = InlineQueryResultMpeg4Gif(self.id, self.mpeg4_url, self.thumb_url)

27
tests/test_inlinequeryresultphoto.py
View file

@ -25,7 +25,8 @@ from telegram import (InputTextMessageContent, InlineKeyboardButton, InlineKeybo
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_photo(): def inline_query_result_photo():
return InlineQueryResultPhoto(TestInlineQueryResultPhoto.id, return InlineQueryResultPhoto(
TestInlineQueryResultPhoto.id,
TestInlineQueryResultPhoto.photo_url, TestInlineQueryResultPhoto.photo_url,
TestInlineQueryResultPhoto.thumb_url, TestInlineQueryResultPhoto.thumb_url,
photo_width=TestInlineQueryResultPhoto.photo_width, photo_width=TestInlineQueryResultPhoto.photo_width,
@ -63,8 +64,8 @@ class TestInlineQueryResultPhoto(object):
assert inline_query_result_photo.description == self.description assert inline_query_result_photo.description == self.description
assert inline_query_result_photo.caption == self.caption assert inline_query_result_photo.caption == self.caption
assert inline_query_result_photo.parse_mode == self.parse_mode assert inline_query_result_photo.parse_mode == self.parse_mode
assert inline_query_result_photo.input_message_content.to_dict() == \ assert (inline_query_result_photo.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_photo.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_photo.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_photo): def test_to_dict(self, inline_query_result_photo):
@ -74,20 +75,20 @@ class TestInlineQueryResultPhoto(object):
assert inline_query_result_photo_dict['type'] == inline_query_result_photo.type assert inline_query_result_photo_dict['type'] == inline_query_result_photo.type
assert inline_query_result_photo_dict['id'] == inline_query_result_photo.id assert inline_query_result_photo_dict['id'] == inline_query_result_photo.id
assert inline_query_result_photo_dict['photo_url'] == inline_query_result_photo.photo_url assert inline_query_result_photo_dict['photo_url'] == inline_query_result_photo.photo_url
assert inline_query_result_photo_dict['photo_width'] == \ assert (inline_query_result_photo_dict['photo_width'] ==
inline_query_result_photo.photo_width inline_query_result_photo.photo_width)
assert inline_query_result_photo_dict['photo_height'] == \ assert (inline_query_result_photo_dict['photo_height'] ==
inline_query_result_photo.photo_height inline_query_result_photo.photo_height)
assert inline_query_result_photo_dict['thumb_url'] == inline_query_result_photo.thumb_url assert inline_query_result_photo_dict['thumb_url'] == inline_query_result_photo.thumb_url
assert inline_query_result_photo_dict['title'] == inline_query_result_photo.title assert inline_query_result_photo_dict['title'] == inline_query_result_photo.title
assert inline_query_result_photo_dict['description'] == \ assert (inline_query_result_photo_dict['description'] ==
inline_query_result_photo.description inline_query_result_photo.description)
assert inline_query_result_photo_dict['caption'] == inline_query_result_photo.caption assert inline_query_result_photo_dict['caption'] == inline_query_result_photo.caption
assert inline_query_result_photo_dict['parse_mode'] == inline_query_result_photo.parse_mode assert inline_query_result_photo_dict['parse_mode'] == inline_query_result_photo.parse_mode
assert inline_query_result_photo_dict['input_message_content'] == \ assert (inline_query_result_photo_dict['input_message_content'] ==
inline_query_result_photo.input_message_content.to_dict() inline_query_result_photo.input_message_content.to_dict())
assert inline_query_result_photo_dict['reply_markup'] == \ assert (inline_query_result_photo_dict['reply_markup'] ==
inline_query_result_photo.reply_markup.to_dict() inline_query_result_photo.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultPhoto(self.id, self.photo_url, self.thumb_url) a = InlineQueryResultPhoto(self.id, self.photo_url, self.thumb_url)

27
tests/test_inlinequeryresultvenue.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineQueryResultVoice, InputTextMessageContent, InlineKey
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_venue(): def inline_query_result_venue():
return InlineQueryResultVenue(TestInlineQueryResultVenue.id, return InlineQueryResultVenue(
TestInlineQueryResultVenue.id,
TestInlineQueryResultVenue.latitude, TestInlineQueryResultVenue.latitude,
TestInlineQueryResultVenue.longitude, TestInlineQueryResultVenue.longitude,
TestInlineQueryResultVenue.title, TestInlineQueryResultVenue.title,
@ -63,8 +64,8 @@ class TestInlineQueryResultVenue(object):
assert inline_query_result_venue.thumb_url == self.thumb_url assert inline_query_result_venue.thumb_url == self.thumb_url
assert inline_query_result_venue.thumb_width == self.thumb_width assert inline_query_result_venue.thumb_width == self.thumb_width
assert inline_query_result_venue.thumb_height == self.thumb_height assert inline_query_result_venue.thumb_height == self.thumb_height
assert inline_query_result_venue.input_message_content.to_dict() == \ assert (inline_query_result_venue.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_venue.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_venue.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_venue): def test_to_dict(self, inline_query_result_venue):
@ -77,17 +78,17 @@ class TestInlineQueryResultVenue(object):
assert inline_query_result_venue_dict['longitude'] == inline_query_result_venue.longitude assert inline_query_result_venue_dict['longitude'] == inline_query_result_venue.longitude
assert inline_query_result_venue_dict['title'] == inline_query_result_venue.title assert inline_query_result_venue_dict['title'] == inline_query_result_venue.title
assert inline_query_result_venue_dict['address'] == inline_query_result_venue.address assert inline_query_result_venue_dict['address'] == inline_query_result_venue.address
assert inline_query_result_venue_dict['foursquare_id'] == \ assert (inline_query_result_venue_dict['foursquare_id'] ==
inline_query_result_venue.foursquare_id inline_query_result_venue.foursquare_id)
assert inline_query_result_venue_dict['thumb_url'] == inline_query_result_venue.thumb_url assert inline_query_result_venue_dict['thumb_url'] == inline_query_result_venue.thumb_url
assert inline_query_result_venue_dict['thumb_width'] == \ assert (inline_query_result_venue_dict['thumb_width'] ==
inline_query_result_venue.thumb_width inline_query_result_venue.thumb_width)
assert inline_query_result_venue_dict['thumb_height'] == \ assert (inline_query_result_venue_dict['thumb_height'] ==
inline_query_result_venue.thumb_height inline_query_result_venue.thumb_height)
assert inline_query_result_venue_dict['input_message_content'] == \ assert (inline_query_result_venue_dict['input_message_content'] ==
inline_query_result_venue.input_message_content.to_dict() inline_query_result_venue.input_message_content.to_dict())
assert inline_query_result_venue_dict['reply_markup'] == \ assert (inline_query_result_venue_dict['reply_markup'] ==
inline_query_result_venue.reply_markup.to_dict() inline_query_result_venue.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultVenue(self.id, self.longitude, self.latitude, self.title, a = InlineQueryResultVenue(self.id, self.longitude, self.latitude, self.title,

31
tests/test_inlinequeryresultvideo.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineKeyboardButton, InputTextMessageContent, InlineQuery
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_video(): def inline_query_result_video():
return InlineQueryResultVideo(TestInlineQueryResultVideo.id, return InlineQueryResultVideo(
TestInlineQueryResultVideo.id,
TestInlineQueryResultVideo.video_url, TestInlineQueryResultVideo.video_url,
TestInlineQueryResultVideo.mime_type, TestInlineQueryResultVideo.mime_type,
TestInlineQueryResultVideo.thumb_url, TestInlineQueryResultVideo.thumb_url,
@ -69,8 +70,8 @@ class TestInlineQueryResultVideo(object):
assert inline_query_result_video.description == self.description assert inline_query_result_video.description == self.description
assert inline_query_result_video.caption == self.caption assert inline_query_result_video.caption == self.caption
assert inline_query_result_video.parse_mode == self.parse_mode assert inline_query_result_video.parse_mode == self.parse_mode
assert inline_query_result_video.input_message_content.to_dict() == \ assert (inline_query_result_video.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_video.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_video.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_video): def test_to_dict(self, inline_query_result_video):
@ -81,22 +82,22 @@ class TestInlineQueryResultVideo(object):
assert inline_query_result_video_dict['id'] == inline_query_result_video.id assert inline_query_result_video_dict['id'] == inline_query_result_video.id
assert inline_query_result_video_dict['video_url'] == inline_query_result_video.video_url assert inline_query_result_video_dict['video_url'] == inline_query_result_video.video_url
assert inline_query_result_video_dict['mime_type'] == inline_query_result_video.mime_type assert inline_query_result_video_dict['mime_type'] == inline_query_result_video.mime_type
assert inline_query_result_video_dict['video_width'] == \ assert (inline_query_result_video_dict['video_width'] ==
inline_query_result_video.video_width inline_query_result_video.video_width)
assert inline_query_result_video_dict['video_height'] == \ assert (inline_query_result_video_dict['video_height'] ==
inline_query_result_video.video_height inline_query_result_video.video_height)
assert inline_query_result_video_dict['video_duration'] == \ assert (inline_query_result_video_dict['video_duration'] ==
inline_query_result_video.video_duration inline_query_result_video.video_duration)
assert inline_query_result_video_dict['thumb_url'] == inline_query_result_video.thumb_url assert inline_query_result_video_dict['thumb_url'] == inline_query_result_video.thumb_url
assert inline_query_result_video_dict['title'] == inline_query_result_video.title assert inline_query_result_video_dict['title'] == inline_query_result_video.title
assert inline_query_result_video_dict['description'] == \ assert (inline_query_result_video_dict['description'] ==
inline_query_result_video.description inline_query_result_video.description)
assert inline_query_result_video_dict['caption'] == inline_query_result_video.caption assert inline_query_result_video_dict['caption'] == inline_query_result_video.caption
assert inline_query_result_video_dict['parse_mode'] == inline_query_result_video.parse_mode assert inline_query_result_video_dict['parse_mode'] == inline_query_result_video.parse_mode
assert inline_query_result_video_dict['input_message_content'] == \ assert (inline_query_result_video_dict['input_message_content'] ==
inline_query_result_video.input_message_content.to_dict() inline_query_result_video.input_message_content.to_dict())
assert inline_query_result_video_dict['reply_markup'] == \ assert (inline_query_result_video_dict['reply_markup'] ==
inline_query_result_video.reply_markup.to_dict() inline_query_result_video.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultVideo(self.id, self.video_url, self.mime_type, a = InlineQueryResultVideo(self.id, self.video_url, self.mime_type,

19
tests/test_inlinequeryresultvoice.py
View file

@ -25,7 +25,8 @@ from telegram import (InlineKeyboardButton, InputTextMessageContent, InlineQuery
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def inline_query_result_voice(): def inline_query_result_voice():
return InlineQueryResultVoice(type=TestInlineQueryResultVoice.type, return InlineQueryResultVoice(
type=TestInlineQueryResultVoice.type,
id=TestInlineQueryResultVoice.id, id=TestInlineQueryResultVoice.id,
voice_url=TestInlineQueryResultVoice.voice_url, voice_url=TestInlineQueryResultVoice.voice_url,
title=TestInlineQueryResultVoice.title, title=TestInlineQueryResultVoice.title,
@ -55,8 +56,8 @@ class TestInlineQueryResultVoice(object):
assert inline_query_result_voice.voice_duration == self.voice_duration assert inline_query_result_voice.voice_duration == self.voice_duration
assert inline_query_result_voice.caption == self.caption assert inline_query_result_voice.caption == self.caption
assert inline_query_result_voice.parse_mode == self.parse_mode assert inline_query_result_voice.parse_mode == self.parse_mode
assert inline_query_result_voice.input_message_content.to_dict() == \ assert (inline_query_result_voice.input_message_content.to_dict() ==
self.input_message_content.to_dict() self.input_message_content.to_dict())
assert inline_query_result_voice.reply_markup.to_dict() == self.reply_markup.to_dict() assert inline_query_result_voice.reply_markup.to_dict() == self.reply_markup.to_dict()
def test_to_dict(self, inline_query_result_voice): def test_to_dict(self, inline_query_result_voice):
@ -67,14 +68,14 @@ class TestInlineQueryResultVoice(object):
assert inline_query_result_voice_dict['id'] == inline_query_result_voice.id assert inline_query_result_voice_dict['id'] == inline_query_result_voice.id
assert inline_query_result_voice_dict['voice_url'] == inline_query_result_voice.voice_url assert inline_query_result_voice_dict['voice_url'] == inline_query_result_voice.voice_url
assert inline_query_result_voice_dict['title'] == inline_query_result_voice.title assert inline_query_result_voice_dict['title'] == inline_query_result_voice.title
assert inline_query_result_voice_dict['voice_duration'] == \ assert (inline_query_result_voice_dict['voice_duration'] ==
inline_query_result_voice.voice_duration inline_query_result_voice.voice_duration)
assert inline_query_result_voice_dict['caption'] == inline_query_result_voice.caption assert inline_query_result_voice_dict['caption'] == inline_query_result_voice.caption
assert inline_query_result_voice_dict['parse_mode'] == inline_query_result_voice.parse_mode assert inline_query_result_voice_dict['parse_mode'] == inline_query_result_voice.parse_mode
assert inline_query_result_voice_dict['input_message_content'] == \ assert (inline_query_result_voice_dict['input_message_content'] ==
inline_query_result_voice.input_message_content.to_dict() inline_query_result_voice.input_message_content.to_dict())
assert inline_query_result_voice_dict['reply_markup'] == \ assert (inline_query_result_voice_dict['reply_markup'] ==
inline_query_result_voice.reply_markup.to_dict() inline_query_result_voice.reply_markup.to_dict())
def test_equality(self): def test_equality(self):
a = InlineQueryResultVoice(self.id, self.voice_url, self.title) a = InlineQueryResultVoice(self.id, self.voice_url, self.title)

12
tests/test_inputcontactmessagecontent.py
View file

@ -43,9 +43,9 @@ class TestInputContactMessageContent(object):
input_contact_message_content_dict = input_contact_message_content.to_dict() input_contact_message_content_dict = input_contact_message_content.to_dict()
assert isinstance(input_contact_message_content_dict, dict) assert isinstance(input_contact_message_content_dict, dict)
assert input_contact_message_content_dict['phone_number'] == \ assert (input_contact_message_content_dict['phone_number'] ==
input_contact_message_content.phone_number input_contact_message_content.phone_number)
assert input_contact_message_content_dict['first_name'] == \ assert (input_contact_message_content_dict['first_name'] ==
input_contact_message_content.first_name input_contact_message_content.first_name)
assert input_contact_message_content_dict['last_name'] == \ assert (input_contact_message_content_dict['last_name'] ==
input_contact_message_content.last_name input_contact_message_content.last_name)

12
tests/test_inputlocationmessagecontent.py
View file

@ -43,9 +43,9 @@ class TestInputLocationMessageContent(object):
input_location_message_content_dict = input_location_message_content.to_dict() input_location_message_content_dict = input_location_message_content.to_dict()
assert isinstance(input_location_message_content_dict, dict) assert isinstance(input_location_message_content_dict, dict)
assert input_location_message_content_dict['latitude'] == \ assert (input_location_message_content_dict['latitude'] ==
input_location_message_content.latitude input_location_message_content.latitude)
assert input_location_message_content_dict['longitude'] == \ assert (input_location_message_content_dict['longitude'] ==
input_location_message_content.longitude input_location_message_content.longitude)
assert input_location_message_content_dict[ assert (input_location_message_content_dict['live_period'] ==
'live_period'] == input_location_message_content.live_period input_location_message_content.live_period)

14
tests/test_inputmedia.py
View file

@ -20,8 +20,8 @@ import pytest
from flaky import flaky from flaky import flaky
from telegram import InputMediaVideo, InputMediaPhoto, Message from telegram import InputMediaVideo, InputMediaPhoto, Message
from .test_video import video, video_file from .test_video import video, video_file # noqa: F401
from .test_photo import _photo, photo_file, photo, thumb from .test_photo import _photo, photo_file, photo, thumb # noqa: F401
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
@ -73,7 +73,7 @@ class TestInputMediaVideo(object):
assert input_media_video_dict['parse_mode'] == input_media_video.parse_mode assert input_media_video_dict['parse_mode'] == input_media_video.parse_mode
assert input_media_video_dict['supports_streaming'] == input_media_video.supports_streaming assert input_media_video_dict['supports_streaming'] == input_media_video.supports_streaming
def test_with_video(self, video): def test_with_video(self, video): # noqa: F811
# fixture found in test_video # fixture found in test_video
input_media_video = InputMediaVideo(video, caption="test 3") input_media_video = InputMediaVideo(video, caption="test 3")
assert input_media_video.type == self.type assert input_media_video.type == self.type
@ -83,7 +83,7 @@ class TestInputMediaVideo(object):
assert input_media_video.duration == video.duration assert input_media_video.duration == video.duration
assert input_media_video.caption == "test 3" assert input_media_video.caption == "test 3"
def test_error_with_file(self, video_file): def test_error_with_file(self, video_file): # noqa: F811
# fixture found in test_video # fixture found in test_video
with pytest.raises(ValueError, match="file_id, url or Video"): with pytest.raises(ValueError, match="file_id, url or Video"):
InputMediaVideo(video_file) InputMediaVideo(video_file)
@ -108,20 +108,20 @@ class TestInputMediaPhoto(object):
assert input_media_photo_dict['caption'] == input_media_photo.caption assert input_media_photo_dict['caption'] == input_media_photo.caption
assert input_media_photo_dict['parse_mode'] == input_media_photo.parse_mode assert input_media_photo_dict['parse_mode'] == input_media_photo.parse_mode
def test_with_photo(self, photo): def test_with_photo(self, photo): # noqa: F811
# fixture found in test_photo # fixture found in test_photo
imp = InputMediaPhoto(photo, caption="test 2") imp = InputMediaPhoto(photo, caption="test 2")
assert imp.type == self.type assert imp.type == self.type
assert imp.media == photo.file_id assert imp.media == photo.file_id
assert imp.caption == "test 2" assert imp.caption == "test 2"
def test_error_with_file(self, photo_file): def test_error_with_file(self, photo_file): # noqa: F811
# fixture found in test_photo # fixture found in test_photo
with pytest.raises(ValueError, match="file_id, url or PhotoSize"): with pytest.raises(ValueError, match="file_id, url or PhotoSize"):
InputMediaPhoto(photo_file) InputMediaPhoto(photo_file)
@pytest.fixture(scope='function') @pytest.fixture(scope='function') # noqa: F811
def media_group(photo, thumb): def media_group(photo, thumb):
return [InputMediaPhoto(photo, caption='photo `1`', parse_mode='Markdown'), return [InputMediaPhoto(photo, caption='photo `1`', parse_mode='Markdown'),
InputMediaPhoto(thumb, caption='<b>photo</b> 2', parse_mode='HTML')] InputMediaPhoto(thumb, caption='<b>photo</b> 2', parse_mode='HTML')]

15
tests/test_inputtextmessagecontent.py
View file

@ -24,7 +24,8 @@ from telegram import InputTextMessageContent, ParseMode
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def input_text_message_content(): def input_text_message_content():
return InputTextMessageContent(TestInputTextMessageContent.message_text, return InputTextMessageContent(
TestInputTextMessageContent.message_text,
parse_mode=TestInputTextMessageContent.parse_mode, parse_mode=TestInputTextMessageContent.parse_mode,
disable_web_page_preview=TestInputTextMessageContent.disable_web_page_preview) disable_web_page_preview=TestInputTextMessageContent.disable_web_page_preview)
@ -43,9 +44,9 @@ class TestInputTextMessageContent(object):
input_text_message_content_dict = input_text_message_content.to_dict() input_text_message_content_dict = input_text_message_content.to_dict()
assert isinstance(input_text_message_content_dict, dict) assert isinstance(input_text_message_content_dict, dict)
assert input_text_message_content_dict['message_text'] == \ assert (input_text_message_content_dict['message_text'] ==
input_text_message_content.message_text input_text_message_content.message_text)
assert input_text_message_content_dict['parse_mode'] == \ assert (input_text_message_content_dict['parse_mode'] ==
input_text_message_content.parse_mode input_text_message_content.parse_mode)
assert input_text_message_content_dict['disable_web_page_preview'] == \ assert (input_text_message_content_dict['disable_web_page_preview'] ==
input_text_message_content.disable_web_page_preview input_text_message_content.disable_web_page_preview)

12
tests/test_inputvenuemessagecontent.py
View file

@ -49,11 +49,11 @@ class TestInputVenueMessageContent(object):
input_venue_message_content_dict = input_venue_message_content.to_dict() input_venue_message_content_dict = input_venue_message_content.to_dict()
assert isinstance(input_venue_message_content_dict, dict) assert isinstance(input_venue_message_content_dict, dict)
assert input_venue_message_content_dict['latitude'] == \ assert (input_venue_message_content_dict['latitude'] ==
input_venue_message_content.latitude input_venue_message_content.latitude)
assert input_venue_message_content_dict['longitude'] == \ assert (input_venue_message_content_dict['longitude'] ==
input_venue_message_content.longitude input_venue_message_content.longitude)
assert input_venue_message_content_dict['title'] == input_venue_message_content.title assert input_venue_message_content_dict['title'] == input_venue_message_content.title
assert input_venue_message_content_dict['address'] == input_venue_message_content.address assert input_venue_message_content_dict['address'] == input_venue_message_content.address
assert input_venue_message_content_dict['foursquare_id'] == \ assert (input_venue_message_content_dict['foursquare_id'] ==
input_venue_message_content.foursquare_id input_venue_message_content.foursquare_id)

2
tests/test_messagehandler.py
View file

@ -119,7 +119,7 @@ class TestMessageHandler(object):
def test_none_allowed(self): def test_none_allowed(self):
with pytest.raises(ValueError, match='are all False'): with pytest.raises(ValueError, match='are all False'):
handler = MessageHandler(None, self.callback_basic, message_updates=False, MessageHandler(None, self.callback_basic, message_updates=False,
channel_post_updates=False, edited_updates=False) channel_post_updates=False, edited_updates=False)
def test_with_filter(self, message): def test_with_filter(self, message):

5
tests/test_official.py
View file

@ -18,15 +18,12 @@
# along with this program. If not, see [http://www.gnu.org/licenses/]. # along with this program. If not, see [http://www.gnu.org/licenses/].
import inspect import inspect
import sys import sys
from collections import namedtuple
from platform import python_implementation from platform import python_implementation
import certifi import certifi
import pytest import pytest
from bs4 import BeautifulSoup from bs4 import BeautifulSoup
sys.path.append('.')
from telegram.vendor.ptb_urllib3 import urllib3 from telegram.vendor.ptb_urllib3 import urllib3
import telegram import telegram
@ -50,8 +47,6 @@ def parse_table(h4):
table = find_next_sibling_until(h4, 'table', h4.find_next_sibling('h4')) table = find_next_sibling_until(h4, 'table', h4.find_next_sibling('h4'))
if not table: if not table:
return [] return []
head = [td.text for td in table.tr.find_all('td')]
# row = namedtuple('{}TableRow'.format(h4.text), ','.join(head))
t = [] t = []
for tr in table.find_all('tr')[1:]: for tr in table.find_all('tr')[1:]:
t.append([td.text for td in tr.find_all('td')]) t.append([td.text for td in tr.find_all('td')])

4
tests/test_precheckoutquery.py
View file

@ -69,8 +69,8 @@ class TestPreCheckoutQuery(object):
assert isinstance(pre_checkout_query_dict, dict) assert isinstance(pre_checkout_query_dict, dict)
assert pre_checkout_query_dict['id'] == pre_checkout_query.id 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['invoice_payload'] == pre_checkout_query.invoice_payload
assert pre_checkout_query_dict['shipping_option_id'] == \ assert (pre_checkout_query_dict['shipping_option_id'] ==
pre_checkout_query.shipping_option_id pre_checkout_query.shipping_option_id)
assert pre_checkout_query_dict['currency'] == pre_checkout_query.currency 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['from'] == pre_checkout_query.from_user.to_dict()
assert pre_checkout_query_dict['order_info'] == pre_checkout_query.order_info.to_dict() assert pre_checkout_query_dict['order_info'] == pre_checkout_query.order_info.to_dict()

5
tests/test_precheckoutqueryhandler.py
View file

@ -49,8 +49,9 @@ def false_update(request):
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def pre_checkout_query(): def pre_checkout_query():
return Update(1, pre_checkout_query=PreCheckoutQuery('id', User(1, 'test user', False), 'EUR', 223, return Update(1,
'invoice_payload')) pre_checkout_query=PreCheckoutQuery('id', User(1, 'test user', False),
'EUR', 223, 'invoice_payload'))
class TestPreCheckoutQueryHandler(object): class TestPreCheckoutQueryHandler(object):

2
tests/test_regexhandler.py
View file

@ -150,7 +150,7 @@ class TestRegexHandler(object):
def test_none_allowed(self): def test_none_allowed(self):
with pytest.raises(ValueError, match='are all False'): with pytest.raises(ValueError, match='are all False'):
handler = RegexHandler('.*', self.callback_basic, message_updates=False, RegexHandler('.*', self.callback_basic, message_updates=False,
channel_post_updates=False, edited_updates=False) channel_post_updates=False, edited_updates=False)
def test_pass_user_or_chat_data(self, dp, message): def test_pass_user_or_chat_data(self, dp, message):

16
tests/test_replykeyboardmarkup.py
View file

@ -63,12 +63,12 @@ class TestReplyKeyboardMarkup(object):
reply_keyboard_markup_dict = reply_keyboard_markup.to_dict() reply_keyboard_markup_dict = reply_keyboard_markup.to_dict()
assert isinstance(reply_keyboard_markup_dict, dict) assert isinstance(reply_keyboard_markup_dict, dict)
assert reply_keyboard_markup_dict['keyboard'][0][0] == \ assert (reply_keyboard_markup_dict['keyboard'][0][0] ==
reply_keyboard_markup.keyboard[0][0].to_dict() reply_keyboard_markup.keyboard[0][0].to_dict())
assert reply_keyboard_markup_dict['keyboard'][0][1] == \ assert (reply_keyboard_markup_dict['keyboard'][0][1] ==
reply_keyboard_markup.keyboard[0][1].to_dict() reply_keyboard_markup.keyboard[0][1].to_dict())
assert reply_keyboard_markup_dict['resize_keyboard'] == \ assert (reply_keyboard_markup_dict['resize_keyboard'] ==
reply_keyboard_markup.resize_keyboard reply_keyboard_markup.resize_keyboard)
assert reply_keyboard_markup_dict['one_time_keyboard'] == \ assert (reply_keyboard_markup_dict['one_time_keyboard'] ==
reply_keyboard_markup.one_time_keyboard reply_keyboard_markup.one_time_keyboard)
assert reply_keyboard_markup_dict['selective'] == reply_keyboard_markup.selective assert reply_keyboard_markup_dict['selective'] == reply_keyboard_markup.selective

4
tests/test_replykeyboardremove.py
View file

@ -43,6 +43,6 @@ class TestReplyKeyboardRemove(object):
def test_to_dict(self, reply_keyboard_remove): def test_to_dict(self, reply_keyboard_remove):
reply_keyboard_remove_dict = reply_keyboard_remove.to_dict() reply_keyboard_remove_dict = reply_keyboard_remove.to_dict()
assert reply_keyboard_remove_dict['remove_keyboard'] == \ assert (reply_keyboard_remove_dict['remove_keyboard'] ==
reply_keyboard_remove.remove_keyboard reply_keyboard_remove.remove_keyboard)
assert reply_keyboard_remove_dict['selective'] == reply_keyboard_remove.selective assert reply_keyboard_remove_dict['selective'] == reply_keyboard_remove.selective

3
tests/test_shippingqueryhandler.py
View file

@ -49,7 +49,8 @@ def false_update(request):
@pytest.fixture(scope='class') @pytest.fixture(scope='class')
def shiping_query(): def shiping_query():
return Update(1, shipping_query=ShippingQuery(42, User(1, 'test user', False), 'invoice_payload', return Update(1,
shipping_query=ShippingQuery(42, User(1, 'test user', False), 'invoice_payload',
ShippingAddress('EN', 'my_state', 'my_city', ShippingAddress('EN', 'my_state', 'my_city',
'steer_1', '', 'post_code'))) 'steer_1', '', 'post_code')))

12
tests/test_successfulpayment.py
View file

@ -66,14 +66,14 @@ class TestSuccessfulPayment(object):
assert isinstance(successful_payment_dict, dict) assert isinstance(successful_payment_dict, dict)
assert successful_payment_dict['invoice_payload'] == successful_payment.invoice_payload assert successful_payment_dict['invoice_payload'] == successful_payment.invoice_payload
assert successful_payment_dict['shipping_option_id'] == \ assert (successful_payment_dict['shipping_option_id'] ==
successful_payment.shipping_option_id successful_payment.shipping_option_id)
assert successful_payment_dict['currency'] == successful_payment.currency assert successful_payment_dict['currency'] == successful_payment.currency
assert successful_payment_dict['order_info'] == successful_payment.order_info.to_dict() assert successful_payment_dict['order_info'] == successful_payment.order_info.to_dict()
assert successful_payment_dict['telegram_payment_charge_id'] == \ assert (successful_payment_dict['telegram_payment_charge_id'] ==
successful_payment.telegram_payment_charge_id successful_payment.telegram_payment_charge_id)
assert successful_payment_dict['provider_payment_charge_id'] == \ assert (successful_payment_dict['provider_payment_charge_id'] ==
successful_payment.provider_payment_charge_id successful_payment.provider_payment_charge_id)
def test_equality(self): def test_equality(self):
a = SuccessfulPayment(self.currency, self.total_amount, self.invoice_payload, a = SuccessfulPayment(self.currency, self.total_amount, self.invoice_payload,

14
tests/test_updater.py
View file

@ -105,7 +105,8 @@ class TestUpdater(object):
try: try:
# Now, we send an update to the server via urlopen # Now, we send an update to the server via urlopen
update = Update(1, message=Message(1, User(1, '', False), None, Chat(1, ''), text='Webhook')) update = Update(1, message=Message(1, User(1, '', False), None, Chat(1, ''),
text='Webhook'))
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN') self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(.2) sleep(.2)
assert q.get(False) == update assert q.get(False) == update
@ -138,7 +139,8 @@ class TestUpdater(object):
sleep(.2) sleep(.2)
# Now, we send an update to the server via urlopen # Now, we send an update to the server via urlopen
update = Update(1, message=Message(1, User(1, '', False), None, Chat(1, ''), text='Webhook 2')) update = Update(1, message=Message(1, User(1, '', False), None, Chat(1, ''),
text='Webhook 2'))
self._send_webhook_msg(ip, port, update.to_json()) self._send_webhook_msg(ip, port, update.to_json())
sleep(.2) sleep(.2)
assert q.get(False) == update assert q.get(False) == update
@ -157,11 +159,9 @@ class TestUpdater(object):
assert self.attempts == retries assert self.attempts == retries
@pytest.mark.parametrize(('error', 'attempts'), @pytest.mark.parametrize(('error', 'attempts'),
argvalues=[ argvalues=[(TelegramError(''), 2),
(TelegramError(''), 2),
(Unauthorized(''), 1), (Unauthorized(''), 1),
(InvalidToken(), 1) (InvalidToken(), 1)],
],
ids=('TelegramError', 'Unauthorized', 'InvalidToken')) ids=('TelegramError', 'Unauthorized', 'InvalidToken'))
def test_bootstrap_retries_error(self, monkeypatch, updater, error, attempts): def test_bootstrap_retries_error(self, monkeypatch, updater, error, attempts):
retries = 1 retries = 1
@ -201,7 +201,7 @@ class TestUpdater(object):
# self._send_webhook_msg(ip, port, 'dummy-payload', content_len=None) # self._send_webhook_msg(ip, port, 'dummy-payload', content_len=None)
# assert excinfo.value.code == 411 # assert excinfo.value.code == 411
with pytest.raises(HTTPError) as ctx: with pytest.raises(HTTPError):
self._send_webhook_msg(ip, port, 'dummy-payload', content_len='not-a-number') self._send_webhook_msg(ip, port, 'dummy-payload', content_len='not-a-number')
assert excinfo.value.code == 403 assert excinfo.value.code == 403