From b187ed771de06a90eb9b8bd3897254dff14f9c25 Mon Sep 17 00:00:00 2001 From: Hinrich Mahler Date: Sun, 23 Feb 2020 19:40:25 +0100 Subject: [PATCH] Remove builtin names where possible --- telegram/ext/picklepersistence.py | 16 ++--- tests/test_callbackquery.py | 36 +++++----- tests/test_chat.py | 32 ++++----- tests/test_encryptedpassportelement.py | 10 +-- tests/test_inlinequery.py | 16 ++--- tests/test_inlinequeryresultarticle.py | 18 ++--- tests/test_inlinequeryresultaudio.py | 18 ++--- tests/test_inlinequeryresultcachedaudio.py | 18 ++--- tests/test_inlinequeryresultcacheddocument.py | 18 ++--- tests/test_inlinequeryresultcachedgif.py | 18 ++--- tests/test_inlinequeryresultcachedmpeg4gif.py | 18 ++--- tests/test_inlinequeryresultcachedphoto.py | 18 ++--- tests/test_inlinequeryresultcachedsticker.py | 18 ++--- tests/test_inlinequeryresultcachedvideo.py | 18 ++--- tests/test_inlinequeryresultcachedvoice.py | 18 ++--- tests/test_inlinequeryresultcontact.py | 18 ++--- tests/test_inlinequeryresultdocument.py | 18 ++--- tests/test_inlinequeryresultgame.py | 18 ++--- tests/test_inlinequeryresultgif.py | 18 ++--- tests/test_inlinequeryresultlocation.py | 18 ++--- tests/test_inlinequeryresultmpeg4gif.py | 18 ++--- tests/test_inlinequeryresultphoto.py | 18 ++--- tests/test_inlinequeryresultvenue.py | 18 ++--- tests/test_inlinequeryresultvideo.py | 18 ++--- tests/test_inlinequeryresultvoice.py | 20 +++--- tests/test_inputmedia.py | 40 +++++------ tests/test_location.py | 8 +-- tests/test_message.py | 72 +++++++++---------- tests/test_messageentity.py | 12 ++-- tests/test_messagequeue.py | 2 +- tests/test_passportelementerrordatafield.py | 16 +++-- tests/test_passportelementerrorfile.py | 14 ++-- tests/test_passportelementerrorfiles.py | 14 ++-- tests/test_passportelementerrorfrontside.py | 14 ++-- tests/test_passportelementerrorreverseside.py | 14 ++-- tests/test_passportelementerrorselfie.py | 14 ++-- ...est_passportelementerrortranslationfile.py | 14 ++-- ...st_passportelementerrortranslationfiles.py | 14 ++-- tests/test_passportelementerrorunspecified.py | 14 ++-- tests/test_persistence.py | 10 +-- tests/test_poll.py | 8 +-- tests/test_precheckoutquery.py | 16 ++--- tests/test_shippingoption.py | 14 ++-- tests/test_shippingquery.py | 16 ++--- tests/test_user.py | 20 +++--- 45 files changed, 410 insertions(+), 408 deletions(-) diff --git a/telegram/ext/picklepersistence.py b/telegram/ext/picklepersistence.py index 6747cd4ece8..d235aa71976 100644 --- a/telegram/ext/picklepersistence.py +++ b/telegram/ext/picklepersistence.py @@ -81,12 +81,12 @@ def load_singlefile(self): try: filename = self.filename with open(self.filename, "rb") as f: - all = pickle.load(f) - self.user_data = defaultdict(dict, all['user_data']) - self.chat_data = defaultdict(dict, all['chat_data']) + data = pickle.load(f) + self.user_data = defaultdict(dict, data['user_data']) + self.chat_data = defaultdict(dict, data['chat_data']) # For backwards compatibility with files not containing bot data - self.bot_data = all.get('bot_data', {}) - self.conversations = all['conversations'] + self.bot_data = data.get('bot_data', {}) + self.conversations = data['conversations'] except IOError: self.conversations = {} self.user_data = defaultdict(dict) @@ -110,9 +110,9 @@ def load_file(self, filename): def dump_singlefile(self): with open(self.filename, "wb") as f: - all = {'conversations': self.conversations, 'user_data': self.user_data, - 'chat_data': self.chat_data, 'bot_data': self.bot_data} - pickle.dump(all, f) + data = {'conversations': self.conversations, 'user_data': self.user_data, + 'chat_data': self.chat_data, 'bot_data': self.bot_data} + pickle.dump(data, f) def dump_file(self, filename, data): with open(filename, "wb") as f: diff --git a/tests/test_callbackquery.py b/tests/test_callbackquery.py index 909b4348133..b4d15c0dcf1 100644 --- a/tests/test_callbackquery.py +++ b/tests/test_callbackquery.py @@ -24,7 +24,7 @@ @pytest.fixture(scope='class', params=['message', 'inline']) def callback_query(bot, request): - cbq = CallbackQuery(TestCallbackQuery.id, + cbq = CallbackQuery(TestCallbackQuery.id_, TestCallbackQuery.from_user, TestCallbackQuery.chat_instance, data=TestCallbackQuery.data, @@ -38,7 +38,7 @@ def callback_query(bot, request): class TestCallbackQuery(object): - id = 'id' + id_ = 'id' from_user = User(1, 'test_user', False) chat_instance = 'chat_instance' message = Message(3, User(5, 'bot', False), None, Chat(4, 'private')) @@ -47,7 +47,7 @@ class TestCallbackQuery(object): game_short_name = 'the_game' def test_de_json(self, bot): - json_dict = {'id': self.id, + json_dict = {'id': self.id_, 'from': self.from_user.to_dict(), 'chat_instance': self.chat_instance, 'message': self.message.to_dict(), @@ -57,7 +57,7 @@ def test_de_json(self, bot): 'default_quote': True} callback_query = CallbackQuery.de_json(json_dict, bot) - assert callback_query.id == self.id + assert callback_query.id == self.id_ assert callback_query.from_user == self.from_user assert callback_query.chat_instance == self.chat_instance assert callback_query.message == self.message @@ -92,8 +92,8 @@ def test_edit_message_text(self, monkeypatch, callback_query): def test(*args, **kwargs): text = args[0] == 'test' try: - id = kwargs['inline_message_id'] == callback_query.inline_message_id - return id and text + id_ = kwargs['inline_message_id'] == callback_query.inline_message_id + return id_ and text except KeyError: chat_id = kwargs['chat_id'] == callback_query.message.chat_id message_id = kwargs['message_id'] == callback_query.message.message_id @@ -107,12 +107,12 @@ def test_edit_message_caption(self, monkeypatch, callback_query): def test(*args, **kwargs): caption = kwargs['caption'] == 'new caption' try: - id = kwargs['inline_message_id'] == callback_query.inline_message_id - return id and caption + id_ = kwargs['inline_message_id'] == callback_query.inline_message_id + return id_ and caption except KeyError: - id = kwargs['chat_id'] == callback_query.message.chat_id + id_ = kwargs['chat_id'] == callback_query.message.chat_id message = kwargs['message_id'] == callback_query.message.message_id - return id and message and caption + return id_ and message and caption monkeypatch.setattr(callback_query.bot, 'edit_message_caption', test) assert callback_query.edit_message_caption(caption='new caption') @@ -122,23 +122,23 @@ def test_edit_message_reply_markup(self, monkeypatch, callback_query): def test(*args, **kwargs): reply_markup = kwargs['reply_markup'] == [['1', '2']] try: - id = kwargs['inline_message_id'] == callback_query.inline_message_id - return id and reply_markup + id_ = kwargs['inline_message_id'] == callback_query.inline_message_id + return id_ and reply_markup except KeyError: - id = kwargs['chat_id'] == callback_query.message.chat_id + id_ = kwargs['chat_id'] == callback_query.message.chat_id message = kwargs['message_id'] == callback_query.message.message_id - return id and message and reply_markup + return id_ and message and reply_markup monkeypatch.setattr(callback_query.bot, 'edit_message_reply_markup', test) assert callback_query.edit_message_reply_markup(reply_markup=[['1', '2']]) assert callback_query.edit_message_reply_markup([['1', '2']]) def test_equality(self): - a = CallbackQuery(self.id, self.from_user, 'chat') - b = CallbackQuery(self.id, self.from_user, 'chat') - c = CallbackQuery(self.id, None, '') + a = CallbackQuery(self.id_, self.from_user, 'chat') + b = CallbackQuery(self.id_, self.from_user, 'chat') + c = CallbackQuery(self.id_, None, '') d = CallbackQuery('', None, 'chat') - e = Audio(self.id, 1) + e = Audio(self.id_, 1) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_chat.py b/tests/test_chat.py index f2431ab2d6c..517d9e8ace6 100644 --- a/tests/test_chat.py +++ b/tests/test_chat.py @@ -25,7 +25,7 @@ @pytest.fixture(scope='class') def chat(bot): - return Chat(TestChat.id, TestChat.title, TestChat.type, username=TestChat.username, + return Chat(TestChat.id_, TestChat.title, TestChat.type_, username=TestChat.username, all_members_are_administrators=TestChat.all_members_are_administrators, bot=bot, sticker_set_name=TestChat.sticker_set_name, can_set_sticker_set=TestChat.can_set_sticker_set, @@ -33,9 +33,9 @@ def chat(bot): class TestChat(object): - id = -28767330 + id_ = -28767330 title = 'ToledosPalaceBot - Group' - type = 'group' + type_ = 'group' username = 'username' all_members_are_administrators = False sticker_set_name = 'stickers' @@ -48,9 +48,9 @@ class TestChat(object): def test_de_json(self, bot): json_dict = { - 'id': self.id, + 'id': self.id_, 'title': self.title, - 'type': self.type, + 'type': self.type_, 'username': self.username, 'all_members_are_administrators': self.all_members_are_administrators, 'sticker_set_name': self.sticker_set_name, @@ -59,9 +59,9 @@ def test_de_json(self, bot): } chat = Chat.de_json(json_dict, bot) - assert chat.id == self.id + assert chat.id == self.id_ assert chat.title == self.title - assert chat.type == self.type + assert chat.type == self.type_ assert chat.username == self.username assert chat.all_members_are_administrators == self.all_members_are_administrators assert chat.sticker_set_name == self.sticker_set_name @@ -70,8 +70,8 @@ def test_de_json(self, bot): def test_de_json_default_quote(self, bot): json_dict = { - 'id': self.id, - 'type': self.type, + 'id': self.id_, + 'type': self.type_, 'pinned_message': Message( message_id=123, from_user=None, @@ -102,9 +102,9 @@ def test_link(self, chat): def test_send_action(self, monkeypatch, chat): def test(*args, **kwargs): - id = args[0] == chat.id + id_ = args[0] == chat.id action = kwargs['action'] == ChatAction.TYPING - return id and action + return id_ and action monkeypatch.setattr(chat.bot, 'send_chat_action', test) assert chat.send_action(action=ChatAction.TYPING) @@ -238,11 +238,11 @@ def test(*args, **kwargs): assert chat.send_poll('test_poll') def test_equality(self): - a = Chat(self.id, self.title, self.type) - b = Chat(self.id, self.title, self.type) - c = Chat(self.id, '', '') - d = Chat(0, self.title, self.type) - e = User(self.id, '', False) + a = Chat(self.id_, self.title, self.type_) + b = Chat(self.id_, self.title, self.type_) + c = Chat(self.id_, '', '') + d = Chat(0, self.title, self.type_) + e = User(self.id_, '', False) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_encryptedpassportelement.py b/tests/test_encryptedpassportelement.py index f728ba785e2..7aab1549c52 100644 --- a/tests/test_encryptedpassportelement.py +++ b/tests/test_encryptedpassportelement.py @@ -24,7 +24,7 @@ @pytest.fixture(scope='class') def encrypted_passport_element(): - return EncryptedPassportElement(TestEncryptedPassportElement.type, + return EncryptedPassportElement(TestEncryptedPassportElement.type_, data=TestEncryptedPassportElement.data, phone_number=TestEncryptedPassportElement.phone_number, email=TestEncryptedPassportElement.email, @@ -35,7 +35,7 @@ def encrypted_passport_element(): class TestEncryptedPassportElement(object): - type = 'type' + type_ = 'type' data = 'data' phone_number = 'phone_number' email = 'email' @@ -45,7 +45,7 @@ class TestEncryptedPassportElement(object): selfie = PassportFile('file_id', 50, 0) def test_expected_values(self, encrypted_passport_element): - assert encrypted_passport_element.type == self.type + assert encrypted_passport_element.type == self.type_ assert encrypted_passport_element.data == self.data assert encrypted_passport_element.phone_number == self.phone_number assert encrypted_passport_element.email == self.email @@ -75,8 +75,8 @@ def test_to_dict(self, encrypted_passport_element): == encrypted_passport_element.selfie.to_dict()) def test_equality(self): - a = EncryptedPassportElement(self.type, data=self.data) - b = EncryptedPassportElement(self.type, data=self.data) + a = EncryptedPassportElement(self.type_, data=self.data) + b = EncryptedPassportElement(self.type_, data=self.data) c = EncryptedPassportElement(self.data, '') d = PassportElementError('source', 'type', 'message') diff --git a/tests/test_inlinequery.py b/tests/test_inlinequery.py index 509b110c25d..967c7bf5065 100644 --- a/tests/test_inlinequery.py +++ b/tests/test_inlinequery.py @@ -24,12 +24,12 @@ @pytest.fixture(scope='class') def inline_query(bot): - return InlineQuery(TestInlineQuery.id, TestInlineQuery.from_user, TestInlineQuery.query, + return InlineQuery(TestInlineQuery.id_, TestInlineQuery.from_user, TestInlineQuery.query, TestInlineQuery.offset, location=TestInlineQuery.location, bot=bot) class TestInlineQuery(object): - id = 1234 + id_ = 1234 from_user = User(1, 'First name', False) query = 'query text' offset = 'offset' @@ -37,7 +37,7 @@ class TestInlineQuery(object): def test_de_json(self, bot): json_dict = { - 'id': self.id, + 'id': self.id_, 'from': self.from_user.to_dict(), 'query': self.query, 'offset': self.offset, @@ -45,7 +45,7 @@ def test_de_json(self, bot): } inline_query_json = InlineQuery.de_json(json_dict, bot) - assert inline_query_json.id == self.id + assert inline_query_json.id == self.id_ assert inline_query_json.from_user == self.from_user assert inline_query_json.location == self.location assert inline_query_json.query == self.query @@ -69,11 +69,11 @@ def test(*args, **kwargs): assert inline_query.answer() def test_equality(self): - a = InlineQuery(self.id, User(1, '', False), '', '') - b = InlineQuery(self.id, User(1, '', False), '', '') - c = InlineQuery(self.id, User(0, '', False), '', '') + a = InlineQuery(self.id_, User(1, '', False), '', '') + b = InlineQuery(self.id_, User(1, '', False), '', '') + c = InlineQuery(self.id_, User(0, '', False), '', '') d = InlineQuery(0, User(1, '', False), '', '') - e = Update(self.id) + e = Update(self.id_) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultarticle.py b/tests/test_inlinequeryresultarticle.py index da32c2e2727..ec960648ebd 100644 --- a/tests/test_inlinequeryresultarticle.py +++ b/tests/test_inlinequeryresultarticle.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_article(): return InlineQueryResultArticle( - TestInlineQueryResultArticle.id, + TestInlineQueryResultArticle.id_, TestInlineQueryResultArticle.title, input_message_content=TestInlineQueryResultArticle.input_message_content, reply_markup=TestInlineQueryResultArticle.reply_markup, @@ -39,8 +39,8 @@ def inline_query_result_article(): class TestInlineQueryResultArticle(object): - id = 'id' - type = 'article' + id_ = 'id' + type_ = 'article' title = 'title' input_message_content = InputTextMessageContent('input_message_content') reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) @@ -52,8 +52,8 @@ class TestInlineQueryResultArticle(object): thumb_width = 15 def test_expected_values(self, inline_query_result_article): - assert inline_query_result_article.type == self.type - assert inline_query_result_article.id == self.id + assert inline_query_result_article.type == self.type_ + assert inline_query_result_article.id == self.id_ assert inline_query_result_article.title == self.title assert (inline_query_result_article.input_message_content.to_dict() == self.input_message_content.to_dict()) @@ -88,11 +88,11 @@ def test_to_dict(self, inline_query_result_article): == inline_query_result_article.thumb_width) def test_equality(self): - a = InlineQueryResultArticle(self.id, self.title, self.input_message_content) - b = InlineQueryResultArticle(self.id, self.title, self.input_message_content) - c = InlineQueryResultArticle(self.id, '', self.input_message_content) + a = InlineQueryResultArticle(self.id_, self.title, self.input_message_content) + b = InlineQueryResultArticle(self.id_, self.title, self.input_message_content) + c = InlineQueryResultArticle(self.id_, '', self.input_message_content) d = InlineQueryResultArticle('', self.title, self.input_message_content) - e = InlineQueryResultAudio(self.id, '', '') + e = InlineQueryResultAudio(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultaudio.py b/tests/test_inlinequeryresultaudio.py index 6de9702102f..da3e49167b2 100644 --- a/tests/test_inlinequeryresultaudio.py +++ b/tests/test_inlinequeryresultaudio.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_audio(): return InlineQueryResultAudio( - TestInlineQueryResultAudio.id, + TestInlineQueryResultAudio.id_, TestInlineQueryResultAudio.audio_url, TestInlineQueryResultAudio.title, performer=TestInlineQueryResultAudio.performer, @@ -38,8 +38,8 @@ def inline_query_result_audio(): class TestInlineQueryResultAudio(object): - id = 'id' - type = 'audio' + id_ = 'id' + type_ = 'audio' audio_url = 'audio url' title = 'title' performer = 'performer' @@ -50,8 +50,8 @@ class TestInlineQueryResultAudio(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_audio): - assert inline_query_result_audio.type == self.type - assert inline_query_result_audio.id == self.id + assert inline_query_result_audio.type == self.type_ + assert inline_query_result_audio.id == self.id_ assert inline_query_result_audio.audio_url == self.audio_url assert inline_query_result_audio.title == self.title assert inline_query_result_audio.performer == self.performer @@ -81,11 +81,11 @@ def test_to_dict(self, inline_query_result_audio): == inline_query_result_audio.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultAudio(self.id, self.audio_url, self.title) - b = InlineQueryResultAudio(self.id, self.title, self.title) - c = InlineQueryResultAudio(self.id, '', self.title) + a = InlineQueryResultAudio(self.id_, self.audio_url, self.title) + b = InlineQueryResultAudio(self.id_, self.title, self.title) + c = InlineQueryResultAudio(self.id_, '', self.title) d = InlineQueryResultAudio('', self.audio_url, self.title) - e = InlineQueryResultVoice(self.id, '', '') + e = InlineQueryResultVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultcachedaudio.py b/tests/test_inlinequeryresultcachedaudio.py index 7c6a3eb71cc..400a89a5a40 100644 --- a/tests/test_inlinequeryresultcachedaudio.py +++ b/tests/test_inlinequeryresultcachedaudio.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_cached_audio(): return InlineQueryResultCachedAudio( - TestInlineQueryResultCachedAudio.id, + TestInlineQueryResultCachedAudio.id_, TestInlineQueryResultCachedAudio.audio_file_id, caption=TestInlineQueryResultCachedAudio.caption, parse_mode=TestInlineQueryResultCachedAudio.parse_mode, @@ -35,8 +35,8 @@ def inline_query_result_cached_audio(): class TestInlineQueryResultCachedAudio(object): - id = 'id' - type = 'audio' + id_ = 'id' + type_ = 'audio' audio_file_id = 'audio file id' caption = 'caption' parse_mode = 'HTML' @@ -44,8 +44,8 @@ class TestInlineQueryResultCachedAudio(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_cached_audio): - assert inline_query_result_cached_audio.type == self.type - assert inline_query_result_cached_audio.id == self.id + assert inline_query_result_cached_audio.type == self.type_ + assert inline_query_result_cached_audio.id == self.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.parse_mode == self.parse_mode @@ -73,11 +73,11 @@ def test_to_dict(self, inline_query_result_cached_audio): == inline_query_result_cached_audio.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultCachedAudio(self.id, self.audio_file_id) - b = InlineQueryResultCachedAudio(self.id, self.audio_file_id) - c = InlineQueryResultCachedAudio(self.id, '') + a = InlineQueryResultCachedAudio(self.id_, self.audio_file_id) + b = InlineQueryResultCachedAudio(self.id_, self.audio_file_id) + c = InlineQueryResultCachedAudio(self.id_, '') d = InlineQueryResultCachedAudio('', self.audio_file_id) - e = InlineQueryResultCachedVoice(self.id, '', '') + e = InlineQueryResultCachedVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultcacheddocument.py b/tests/test_inlinequeryresultcacheddocument.py index 1de7ffa0ba7..f8c61f80a3c 100644 --- a/tests/test_inlinequeryresultcacheddocument.py +++ b/tests/test_inlinequeryresultcacheddocument.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_cached_document(): return InlineQueryResultCachedDocument( - TestInlineQueryResultCachedDocument.id, + TestInlineQueryResultCachedDocument.id_, TestInlineQueryResultCachedDocument.title, TestInlineQueryResultCachedDocument.document_file_id, caption=TestInlineQueryResultCachedDocument.caption, @@ -37,8 +37,8 @@ def inline_query_result_cached_document(): class TestInlineQueryResultCachedDocument(object): - id = 'id' - type = 'document' + id_ = 'id' + type_ = 'document' document_file_id = 'document file id' title = 'title' caption = 'caption' @@ -48,8 +48,8 @@ class TestInlineQueryResultCachedDocument(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_cached_document): - assert inline_query_result_cached_document.id == self.id - assert inline_query_result_cached_document.type == self.type + assert inline_query_result_cached_document.id == self.id_ + assert inline_query_result_cached_document.type == self.type_ assert inline_query_result_cached_document.document_file_id == self.document_file_id assert inline_query_result_cached_document.title == self.title assert inline_query_result_cached_document.caption == self.caption @@ -84,11 +84,11 @@ def test_to_dict(self, inline_query_result_cached_document): == inline_query_result_cached_document.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultCachedDocument(self.id, self.title, self.document_file_id) - b = InlineQueryResultCachedDocument(self.id, self.title, self.document_file_id) - c = InlineQueryResultCachedDocument(self.id, self.title, '') + a = InlineQueryResultCachedDocument(self.id_, self.title, self.document_file_id) + b = InlineQueryResultCachedDocument(self.id_, self.title, self.document_file_id) + c = InlineQueryResultCachedDocument(self.id_, self.title, '') d = InlineQueryResultCachedDocument('', self.title, self.document_file_id) - e = InlineQueryResultCachedVoice(self.id, '', '') + e = InlineQueryResultCachedVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultcachedgif.py b/tests/test_inlinequeryresultcachedgif.py index ceff8c06425..7b772c58e3a 100644 --- a/tests/test_inlinequeryresultcachedgif.py +++ b/tests/test_inlinequeryresultcachedgif.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_cached_gif(): return InlineQueryResultCachedGif( - TestInlineQueryResultCachedGif.id, + TestInlineQueryResultCachedGif.id_, TestInlineQueryResultCachedGif.gif_file_id, title=TestInlineQueryResultCachedGif.title, caption=TestInlineQueryResultCachedGif.caption, @@ -36,8 +36,8 @@ def inline_query_result_cached_gif(): class TestInlineQueryResultCachedGif(object): - id = 'id' - type = 'gif' + id_ = 'id' + type_ = 'gif' gif_file_id = 'gif file id' title = 'title' caption = 'caption' @@ -46,8 +46,8 @@ class TestInlineQueryResultCachedGif(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_cached_gif): - assert inline_query_result_cached_gif.type == self.type - assert inline_query_result_cached_gif.id == self.id + assert inline_query_result_cached_gif.type == self.type_ + assert inline_query_result_cached_gif.id == self.id_ assert inline_query_result_cached_gif.gif_file_id == self.gif_file_id assert inline_query_result_cached_gif.title == self.title assert inline_query_result_cached_gif.caption == self.caption @@ -75,11 +75,11 @@ def test_to_dict(self, inline_query_result_cached_gif): == inline_query_result_cached_gif.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultCachedGif(self.id, self.gif_file_id) - b = InlineQueryResultCachedGif(self.id, self.gif_file_id) - c = InlineQueryResultCachedGif(self.id, '') + a = InlineQueryResultCachedGif(self.id_, self.gif_file_id) + b = InlineQueryResultCachedGif(self.id_, self.gif_file_id) + c = InlineQueryResultCachedGif(self.id_, '') d = InlineQueryResultCachedGif('', self.gif_file_id) - e = InlineQueryResultCachedVoice(self.id, '', '') + e = InlineQueryResultCachedVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultcachedmpeg4gif.py b/tests/test_inlinequeryresultcachedmpeg4gif.py index 3235e3ebdce..0a2ec6d956b 100644 --- a/tests/test_inlinequeryresultcachedmpeg4gif.py +++ b/tests/test_inlinequeryresultcachedmpeg4gif.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_cached_mpeg4_gif(): return InlineQueryResultCachedMpeg4Gif( - TestInlineQueryResultCachedMpeg4Gif.id, + TestInlineQueryResultCachedMpeg4Gif.id_, TestInlineQueryResultCachedMpeg4Gif.mpeg4_file_id, title=TestInlineQueryResultCachedMpeg4Gif.title, caption=TestInlineQueryResultCachedMpeg4Gif.caption, @@ -36,8 +36,8 @@ def inline_query_result_cached_mpeg4_gif(): class TestInlineQueryResultCachedMpeg4Gif(object): - id = 'id' - type = 'mpeg4_gif' + id_ = 'id' + type_ = 'mpeg4_gif' mpeg4_file_id = 'mpeg4 file id' title = 'title' caption = 'caption' @@ -46,8 +46,8 @@ class TestInlineQueryResultCachedMpeg4Gif(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_cached_mpeg4_gif): - assert inline_query_result_cached_mpeg4_gif.type == self.type - assert inline_query_result_cached_mpeg4_gif.id == self.id + assert inline_query_result_cached_mpeg4_gif.type == self.type_ + assert inline_query_result_cached_mpeg4_gif.id == self.id_ assert inline_query_result_cached_mpeg4_gif.mpeg4_file_id == self.mpeg4_file_id assert inline_query_result_cached_mpeg4_gif.title == self.title assert inline_query_result_cached_mpeg4_gif.caption == self.caption @@ -79,11 +79,11 @@ def test_to_dict(self, inline_query_result_cached_mpeg4_gif): == inline_query_result_cached_mpeg4_gif.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultCachedMpeg4Gif(self.id, self.mpeg4_file_id) - b = InlineQueryResultCachedMpeg4Gif(self.id, self.mpeg4_file_id) - c = InlineQueryResultCachedMpeg4Gif(self.id, '') + a = InlineQueryResultCachedMpeg4Gif(self.id_, self.mpeg4_file_id) + b = InlineQueryResultCachedMpeg4Gif(self.id_, self.mpeg4_file_id) + c = InlineQueryResultCachedMpeg4Gif(self.id_, '') d = InlineQueryResultCachedMpeg4Gif('', self.mpeg4_file_id) - e = InlineQueryResultCachedVoice(self.id, '', '') + e = InlineQueryResultCachedVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultcachedphoto.py b/tests/test_inlinequeryresultcachedphoto.py index 9384945863d..398df63bbd9 100644 --- a/tests/test_inlinequeryresultcachedphoto.py +++ b/tests/test_inlinequeryresultcachedphoto.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_cached_photo(): return InlineQueryResultCachedPhoto( - TestInlineQueryResultCachedPhoto.id, + TestInlineQueryResultCachedPhoto.id_, TestInlineQueryResultCachedPhoto.photo_file_id, title=TestInlineQueryResultCachedPhoto.title, description=TestInlineQueryResultCachedPhoto.description, @@ -37,8 +37,8 @@ def inline_query_result_cached_photo(): class TestInlineQueryResultCachedPhoto(object): - id = 'id' - type = 'photo' + id_ = 'id' + type_ = 'photo' photo_file_id = 'photo file id' title = 'title' description = 'description' @@ -48,8 +48,8 @@ class TestInlineQueryResultCachedPhoto(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_cached_photo): - assert inline_query_result_cached_photo.type == self.type - assert inline_query_result_cached_photo.id == self.id + assert inline_query_result_cached_photo.type == self.type_ + assert inline_query_result_cached_photo.id == self.id_ assert inline_query_result_cached_photo.photo_file_id == self.photo_file_id assert inline_query_result_cached_photo.title == self.title assert inline_query_result_cached_photo.description == self.description @@ -83,11 +83,11 @@ def test_to_dict(self, inline_query_result_cached_photo): == inline_query_result_cached_photo.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultCachedPhoto(self.id, self.photo_file_id) - b = InlineQueryResultCachedPhoto(self.id, self.photo_file_id) - c = InlineQueryResultCachedPhoto(self.id, '') + a = InlineQueryResultCachedPhoto(self.id_, self.photo_file_id) + b = InlineQueryResultCachedPhoto(self.id_, self.photo_file_id) + c = InlineQueryResultCachedPhoto(self.id_, '') d = InlineQueryResultCachedPhoto('', self.photo_file_id) - e = InlineQueryResultCachedVoice(self.id, '', '') + e = InlineQueryResultCachedVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultcachedsticker.py b/tests/test_inlinequeryresultcachedsticker.py index e9699e89947..7f1cefc0e4d 100644 --- a/tests/test_inlinequeryresultcachedsticker.py +++ b/tests/test_inlinequeryresultcachedsticker.py @@ -27,22 +27,22 @@ @pytest.fixture(scope='class') def inline_query_result_cached_sticker(): return InlineQueryResultCachedSticker( - TestInlineQueryResultCachedSticker.id, + TestInlineQueryResultCachedSticker.id_, TestInlineQueryResultCachedSticker.sticker_file_id, input_message_content=TestInlineQueryResultCachedSticker.input_message_content, reply_markup=TestInlineQueryResultCachedSticker.reply_markup) class TestInlineQueryResultCachedSticker(object): - id = 'id' - type = 'sticker' + id_ = 'id' + type_ = 'sticker' sticker_file_id = 'sticker file id' input_message_content = InputTextMessageContent('input_message_content') reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_cached_sticker): - assert inline_query_result_cached_sticker.type == self.type - assert inline_query_result_cached_sticker.id == self.id + assert inline_query_result_cached_sticker.type == self.type_ + 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.input_message_content.to_dict() == self.input_message_content.to_dict()) @@ -65,11 +65,11 @@ def test_to_dict(self, inline_query_result_cached_sticker): == inline_query_result_cached_sticker.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultCachedSticker(self.id, self.sticker_file_id) - b = InlineQueryResultCachedSticker(self.id, self.sticker_file_id) - c = InlineQueryResultCachedSticker(self.id, '') + a = InlineQueryResultCachedSticker(self.id_, self.sticker_file_id) + b = InlineQueryResultCachedSticker(self.id_, self.sticker_file_id) + c = InlineQueryResultCachedSticker(self.id_, '') d = InlineQueryResultCachedSticker('', self.sticker_file_id) - e = InlineQueryResultCachedVoice(self.id, '', '') + e = InlineQueryResultCachedVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultcachedvideo.py b/tests/test_inlinequeryresultcachedvideo.py index ae229f54230..53c58f1b768 100644 --- a/tests/test_inlinequeryresultcachedvideo.py +++ b/tests/test_inlinequeryresultcachedvideo.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_cached_video(): return InlineQueryResultCachedVideo( - TestInlineQueryResultCachedVideo.id, + TestInlineQueryResultCachedVideo.id_, TestInlineQueryResultCachedVideo.video_file_id, TestInlineQueryResultCachedVideo.title, caption=TestInlineQueryResultCachedVideo.caption, @@ -37,8 +37,8 @@ def inline_query_result_cached_video(): class TestInlineQueryResultCachedVideo(object): - id = 'id' - type = 'video' + id_ = 'id' + type_ = 'video' video_file_id = 'video file id' title = 'title' caption = 'caption' @@ -48,8 +48,8 @@ class TestInlineQueryResultCachedVideo(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_cached_video): - assert inline_query_result_cached_video.type == self.type - assert inline_query_result_cached_video.id == self.id + assert inline_query_result_cached_video.type == self.type_ + assert inline_query_result_cached_video.id == self.id_ assert inline_query_result_cached_video.video_file_id == self.video_file_id assert inline_query_result_cached_video.title == self.title assert inline_query_result_cached_video.description == self.description @@ -83,11 +83,11 @@ def test_to_dict(self, inline_query_result_cached_video): == inline_query_result_cached_video.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultCachedVideo(self.id, self.video_file_id, self.title) - b = InlineQueryResultCachedVideo(self.id, self.video_file_id, self.title) - c = InlineQueryResultCachedVideo(self.id, '', self.title) + a = InlineQueryResultCachedVideo(self.id_, self.video_file_id, self.title) + b = InlineQueryResultCachedVideo(self.id_, self.video_file_id, self.title) + c = InlineQueryResultCachedVideo(self.id_, '', self.title) d = InlineQueryResultCachedVideo('', self.video_file_id, self.title) - e = InlineQueryResultCachedVoice(self.id, '', '') + e = InlineQueryResultCachedVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultcachedvoice.py b/tests/test_inlinequeryresultcachedvoice.py index 7e9f7f170a5..1bb45b9c9a5 100644 --- a/tests/test_inlinequeryresultcachedvoice.py +++ b/tests/test_inlinequeryresultcachedvoice.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_cached_voice(): return InlineQueryResultCachedVoice( - TestInlineQueryResultCachedVoice.id, + TestInlineQueryResultCachedVoice.id_, TestInlineQueryResultCachedVoice.voice_file_id, TestInlineQueryResultCachedVoice.title, caption=TestInlineQueryResultCachedVoice.caption, @@ -36,8 +36,8 @@ def inline_query_result_cached_voice(): class TestInlineQueryResultCachedVoice(object): - id = 'id' - type = 'voice' + id_ = 'id' + type_ = 'voice' voice_file_id = 'voice file id' title = 'title' caption = 'caption' @@ -46,8 +46,8 @@ class TestInlineQueryResultCachedVoice(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_cached_voice): - assert inline_query_result_cached_voice.type == self.type - assert inline_query_result_cached_voice.id == self.id + assert inline_query_result_cached_voice.type == self.type_ + assert inline_query_result_cached_voice.id == self.id_ assert inline_query_result_cached_voice.voice_file_id == self.voice_file_id assert inline_query_result_cached_voice.title == self.title assert inline_query_result_cached_voice.caption == self.caption @@ -78,11 +78,11 @@ def test_to_dict(self, inline_query_result_cached_voice): == inline_query_result_cached_voice.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultCachedVoice(self.id, self.voice_file_id, self.title) - b = InlineQueryResultCachedVoice(self.id, self.voice_file_id, self.title) - c = InlineQueryResultCachedVoice(self.id, '', self.title) + a = InlineQueryResultCachedVoice(self.id_, self.voice_file_id, self.title) + b = InlineQueryResultCachedVoice(self.id_, self.voice_file_id, self.title) + c = InlineQueryResultCachedVoice(self.id_, '', self.title) d = InlineQueryResultCachedVoice('', self.voice_file_id, self.title) - e = InlineQueryResultCachedAudio(self.id, '', '') + e = InlineQueryResultCachedAudio(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultcontact.py b/tests/test_inlinequeryresultcontact.py index 7b835fafe7f..ff5fd199ee2 100644 --- a/tests/test_inlinequeryresultcontact.py +++ b/tests/test_inlinequeryresultcontact.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_contact(): return InlineQueryResultContact( - TestInlineQueryResultContact.id, + TestInlineQueryResultContact.id_, TestInlineQueryResultContact.phone_number, TestInlineQueryResultContact.first_name, last_name=TestInlineQueryResultContact.last_name, @@ -38,8 +38,8 @@ def inline_query_result_contact(): class TestInlineQueryResultContact(object): - id = 'id' - type = 'contact' + id_ = 'id' + type_ = 'contact' phone_number = 'phone_number' first_name = 'first_name' last_name = 'last_name' @@ -50,8 +50,8 @@ class TestInlineQueryResultContact(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_contact): - assert inline_query_result_contact.id == self.id - assert inline_query_result_contact.type == self.type + assert inline_query_result_contact.id == self.id_ + assert inline_query_result_contact.type == self.type_ assert inline_query_result_contact.phone_number == self.phone_number assert inline_query_result_contact.first_name == self.first_name assert inline_query_result_contact.last_name == self.last_name @@ -86,11 +86,11 @@ def test_to_dict(self, inline_query_result_contact): == inline_query_result_contact.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultContact(self.id, self.phone_number, self.first_name) - b = InlineQueryResultContact(self.id, self.phone_number, self.first_name) - c = InlineQueryResultContact(self.id, '', self.first_name) + a = InlineQueryResultContact(self.id_, self.phone_number, self.first_name) + b = InlineQueryResultContact(self.id_, self.phone_number, self.first_name) + c = InlineQueryResultContact(self.id_, '', self.first_name) d = InlineQueryResultContact('', self.phone_number, self.first_name) - e = InlineQueryResultVoice(self.id, '', '') + e = InlineQueryResultVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultdocument.py b/tests/test_inlinequeryresultdocument.py index 6897e7e5d06..56ce5d2ca70 100644 --- a/tests/test_inlinequeryresultdocument.py +++ b/tests/test_inlinequeryresultdocument.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_document(): return InlineQueryResultDocument( - TestInlineQueryResultDocument.id, + TestInlineQueryResultDocument.id_, TestInlineQueryResultDocument.document_url, TestInlineQueryResultDocument.title, TestInlineQueryResultDocument.mime_type, @@ -41,8 +41,8 @@ def inline_query_result_document(): class TestInlineQueryResultDocument(object): - id = 'id' - type = 'document' + id_ = 'id' + type_ = 'document' document_url = 'document url' title = 'title' caption = 'caption' @@ -56,8 +56,8 @@ class TestInlineQueryResultDocument(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_document): - assert inline_query_result_document.id == self.id - assert inline_query_result_document.type == self.type + assert inline_query_result_document.id == self.id_ + assert inline_query_result_document.type == self.type_ assert inline_query_result_document.document_url == self.document_url assert inline_query_result_document.title == self.title assert inline_query_result_document.caption == self.caption @@ -99,13 +99,13 @@ def test_to_dict(self, inline_query_result_document): == inline_query_result_document.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultDocument(self.id, self.document_url, self.title, + a = InlineQueryResultDocument(self.id_, self.document_url, self.title, self.mime_type) - b = InlineQueryResultDocument(self.id, self.document_url, self.title, + b = InlineQueryResultDocument(self.id_, self.document_url, self.title, self.mime_type) - c = InlineQueryResultDocument(self.id, '', self.title, self.mime_type) + c = InlineQueryResultDocument(self.id_, '', self.title, self.mime_type) d = InlineQueryResultDocument('', self.document_url, self.title, self.mime_type) - e = InlineQueryResultVoice(self.id, '', '') + e = InlineQueryResultVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultgame.py b/tests/test_inlinequeryresultgame.py index 685c60057e5..ec9c567497a 100644 --- a/tests/test_inlinequeryresultgame.py +++ b/tests/test_inlinequeryresultgame.py @@ -25,20 +25,20 @@ @pytest.fixture(scope='class') def inline_query_result_game(): - return InlineQueryResultGame(TestInlineQueryResultGame.id, + return InlineQueryResultGame(TestInlineQueryResultGame.id_, TestInlineQueryResultGame.game_short_name, reply_markup=TestInlineQueryResultGame.reply_markup) class TestInlineQueryResultGame(object): - id = 'id' - type = 'game' + id_ = 'id' + type_ = 'game' game_short_name = 'game short name' reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_game): - assert inline_query_result_game.type == self.type - assert inline_query_result_game.id == self.id + assert inline_query_result_game.type == self.type_ + 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.reply_markup.to_dict() == self.reply_markup.to_dict()) @@ -55,11 +55,11 @@ def test_to_dict(self, inline_query_result_game): == inline_query_result_game.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultGame(self.id, self.game_short_name) - b = InlineQueryResultGame(self.id, self.game_short_name) - c = InlineQueryResultGame(self.id, '') + a = InlineQueryResultGame(self.id_, self.game_short_name) + b = InlineQueryResultGame(self.id_, self.game_short_name) + c = InlineQueryResultGame(self.id_, '') d = InlineQueryResultGame('', self.game_short_name) - e = InlineQueryResultVoice(self.id, '', '') + e = InlineQueryResultVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultgif.py b/tests/test_inlinequeryresultgif.py index 87d5c12a03c..1b5e0b31614 100644 --- a/tests/test_inlinequeryresultgif.py +++ b/tests/test_inlinequeryresultgif.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_gif(): return InlineQueryResultGif( - TestInlineQueryResultGif.id, + TestInlineQueryResultGif.id_, TestInlineQueryResultGif.gif_url, TestInlineQueryResultGif.thumb_url, gif_width=TestInlineQueryResultGif.gif_width, @@ -40,8 +40,8 @@ def inline_query_result_gif(): class TestInlineQueryResultGif(object): - id = 'id' - type = 'gif' + id_ = 'id' + type_ = 'gif' gif_url = 'gif url' gif_width = 10 gif_height = 15 @@ -54,8 +54,8 @@ class TestInlineQueryResultGif(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_gif): - assert inline_query_result_gif.type == self.type - assert inline_query_result_gif.id == self.id + assert inline_query_result_gif.type == self.type_ + assert inline_query_result_gif.id == self.id_ assert inline_query_result_gif.gif_url == self.gif_url assert inline_query_result_gif.gif_width == self.gif_width assert inline_query_result_gif.gif_height == self.gif_height @@ -88,11 +88,11 @@ def test_to_dict(self, inline_query_result_gif): == inline_query_result_gif.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultGif(self.id, self.gif_url, self.thumb_url) - b = InlineQueryResultGif(self.id, self.gif_url, self.thumb_url) - c = InlineQueryResultGif(self.id, '', self.thumb_url) + a = InlineQueryResultGif(self.id_, self.gif_url, self.thumb_url) + b = InlineQueryResultGif(self.id_, self.gif_url, self.thumb_url) + c = InlineQueryResultGif(self.id_, '', self.thumb_url) d = InlineQueryResultGif('', self.gif_url, self.thumb_url) - e = InlineQueryResultVoice(self.id, '', '') + e = InlineQueryResultVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultlocation.py b/tests/test_inlinequeryresultlocation.py index 1e266277052..9286e6876a4 100644 --- a/tests/test_inlinequeryresultlocation.py +++ b/tests/test_inlinequeryresultlocation.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_location(): return InlineQueryResultLocation( - TestInlineQueryResultLocation.id, + TestInlineQueryResultLocation.id_, TestInlineQueryResultLocation.latitude, TestInlineQueryResultLocation.longitude, TestInlineQueryResultLocation.title, @@ -39,8 +39,8 @@ def inline_query_result_location(): class TestInlineQueryResultLocation(object): - id = 'id' - type = 'location' + id_ = 'id' + type_ = 'location' latitude = 0.0 longitude = 1.0 title = 'title' @@ -52,8 +52,8 @@ class TestInlineQueryResultLocation(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_location): - assert inline_query_result_location.id == self.id - assert inline_query_result_location.type == self.type + assert inline_query_result_location.id == self.id_ + assert inline_query_result_location.type == self.type_ assert inline_query_result_location.latitude == self.latitude assert inline_query_result_location.longitude == self.longitude assert inline_query_result_location.title == self.title @@ -90,11 +90,11 @@ def test_to_dict(self, inline_query_result_location): == inline_query_result_location.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultLocation(self.id, self.longitude, self.latitude, self.title) - b = InlineQueryResultLocation(self.id, self.longitude, self.latitude, self.title) - c = InlineQueryResultLocation(self.id, 0, self.latitude, self.title) + a = InlineQueryResultLocation(self.id_, self.longitude, self.latitude, self.title) + b = InlineQueryResultLocation(self.id_, self.longitude, self.latitude, self.title) + c = InlineQueryResultLocation(self.id_, 0, self.latitude, self.title) d = InlineQueryResultLocation('', self.longitude, self.latitude, self.title) - e = InlineQueryResultVoice(self.id, '', '') + e = InlineQueryResultVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultmpeg4gif.py b/tests/test_inlinequeryresultmpeg4gif.py index 9a006344778..93fb857c99d 100644 --- a/tests/test_inlinequeryresultmpeg4gif.py +++ b/tests/test_inlinequeryresultmpeg4gif.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_mpeg4_gif(): return InlineQueryResultMpeg4Gif( - TestInlineQueryResultMpeg4Gif.id, + TestInlineQueryResultMpeg4Gif.id_, TestInlineQueryResultMpeg4Gif.mpeg4_url, TestInlineQueryResultMpeg4Gif.thumb_url, mpeg4_width=TestInlineQueryResultMpeg4Gif.mpeg4_width, @@ -40,8 +40,8 @@ def inline_query_result_mpeg4_gif(): class TestInlineQueryResultMpeg4Gif(object): - id = 'id' - type = 'mpeg4_gif' + id_ = 'id' + type_ = 'mpeg4_gif' mpeg4_url = 'mpeg4 url' mpeg4_width = 10 mpeg4_height = 15 @@ -54,8 +54,8 @@ class TestInlineQueryResultMpeg4Gif(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_mpeg4_gif): - assert inline_query_result_mpeg4_gif.type == self.type - assert inline_query_result_mpeg4_gif.id == self.id + assert inline_query_result_mpeg4_gif.type == self.type_ + assert inline_query_result_mpeg4_gif.id == self.id_ assert inline_query_result_mpeg4_gif.mpeg4_url == self.mpeg4_url assert inline_query_result_mpeg4_gif.mpeg4_width == self.mpeg4_width assert inline_query_result_mpeg4_gif.mpeg4_height == self.mpeg4_height @@ -95,11 +95,11 @@ def test_to_dict(self, inline_query_result_mpeg4_gif): == inline_query_result_mpeg4_gif.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultMpeg4Gif(self.id, self.mpeg4_url, self.thumb_url) - b = InlineQueryResultMpeg4Gif(self.id, self.mpeg4_url, self.thumb_url) - c = InlineQueryResultMpeg4Gif(self.id, '', self.thumb_url) + a = InlineQueryResultMpeg4Gif(self.id_, self.mpeg4_url, self.thumb_url) + b = InlineQueryResultMpeg4Gif(self.id_, self.mpeg4_url, self.thumb_url) + c = InlineQueryResultMpeg4Gif(self.id_, '', self.thumb_url) d = InlineQueryResultMpeg4Gif('', self.mpeg4_url, self.thumb_url) - e = InlineQueryResultVoice(self.id, '', '') + e = InlineQueryResultVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultphoto.py b/tests/test_inlinequeryresultphoto.py index 68dc106f8ee..6d6da313b0a 100644 --- a/tests/test_inlinequeryresultphoto.py +++ b/tests/test_inlinequeryresultphoto.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_photo(): return InlineQueryResultPhoto( - TestInlineQueryResultPhoto.id, + TestInlineQueryResultPhoto.id_, TestInlineQueryResultPhoto.photo_url, TestInlineQueryResultPhoto.thumb_url, photo_width=TestInlineQueryResultPhoto.photo_width, @@ -40,8 +40,8 @@ def inline_query_result_photo(): class TestInlineQueryResultPhoto(object): - id = 'id' - type = 'photo' + id_ = 'id' + type_ = 'photo' photo_url = 'photo url' photo_width = 10 photo_height = 15 @@ -54,8 +54,8 @@ class TestInlineQueryResultPhoto(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_photo): - assert inline_query_result_photo.type == self.type - assert inline_query_result_photo.id == self.id + assert inline_query_result_photo.type == self.type_ + assert inline_query_result_photo.id == self.id_ assert inline_query_result_photo.photo_url == self.photo_url assert inline_query_result_photo.photo_width == self.photo_width assert inline_query_result_photo.photo_height == self.photo_height @@ -91,11 +91,11 @@ def test_to_dict(self, inline_query_result_photo): == inline_query_result_photo.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultPhoto(self.id, self.photo_url, self.thumb_url) - b = InlineQueryResultPhoto(self.id, self.photo_url, self.thumb_url) - c = InlineQueryResultPhoto(self.id, '', self.thumb_url) + a = InlineQueryResultPhoto(self.id_, self.photo_url, self.thumb_url) + b = InlineQueryResultPhoto(self.id_, self.photo_url, self.thumb_url) + c = InlineQueryResultPhoto(self.id_, '', self.thumb_url) d = InlineQueryResultPhoto('', self.photo_url, self.thumb_url) - e = InlineQueryResultVoice(self.id, '', '') + e = InlineQueryResultVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultvenue.py b/tests/test_inlinequeryresultvenue.py index f0b7d636094..25f0a7ecd46 100644 --- a/tests/test_inlinequeryresultvenue.py +++ b/tests/test_inlinequeryresultvenue.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_venue(): return InlineQueryResultVenue( - TestInlineQueryResultVenue.id, + TestInlineQueryResultVenue.id_, TestInlineQueryResultVenue.latitude, TestInlineQueryResultVenue.longitude, TestInlineQueryResultVenue.title, @@ -41,8 +41,8 @@ def inline_query_result_venue(): class TestInlineQueryResultVenue(object): - id = 'id' - type = 'venue' + id_ = 'id' + type_ = 'venue' latitude = 'latitude' longitude = 'longitude' title = 'title' @@ -56,8 +56,8 @@ class TestInlineQueryResultVenue(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_venue): - assert inline_query_result_venue.id == self.id - assert inline_query_result_venue.type == self.type + assert inline_query_result_venue.id == self.id_ + assert inline_query_result_venue.type == self.type_ assert inline_query_result_venue.latitude == self.latitude assert inline_query_result_venue.longitude == self.longitude assert inline_query_result_venue.title == self.title @@ -96,14 +96,14 @@ def test_to_dict(self, inline_query_result_venue): == inline_query_result_venue.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultVenue(self.id, self.longitude, self.latitude, self.title, + a = InlineQueryResultVenue(self.id_, self.longitude, self.latitude, self.title, self.address) - b = InlineQueryResultVenue(self.id, self.longitude, self.latitude, self.title, + b = InlineQueryResultVenue(self.id_, self.longitude, self.latitude, self.title, self.address) - c = InlineQueryResultVenue(self.id, '', self.latitude, self.title, self.address) + c = InlineQueryResultVenue(self.id_, '', self.latitude, self.title, self.address) d = InlineQueryResultVenue('', self.longitude, self.latitude, self.title, self.address) - e = InlineQueryResultVoice(self.id, '', '') + e = InlineQueryResultVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultvideo.py b/tests/test_inlinequeryresultvideo.py index 3f805091caa..9a34d995a63 100644 --- a/tests/test_inlinequeryresultvideo.py +++ b/tests/test_inlinequeryresultvideo.py @@ -26,7 +26,7 @@ @pytest.fixture(scope='class') def inline_query_result_video(): return InlineQueryResultVideo( - TestInlineQueryResultVideo.id, + TestInlineQueryResultVideo.id_, TestInlineQueryResultVideo.video_url, TestInlineQueryResultVideo.mime_type, TestInlineQueryResultVideo.thumb_url, @@ -42,8 +42,8 @@ def inline_query_result_video(): class TestInlineQueryResultVideo(object): - id = 'id' - type = 'video' + id_ = 'id' + type_ = 'video' video_url = 'video url' mime_type = 'mime type' video_width = 10 @@ -58,8 +58,8 @@ class TestInlineQueryResultVideo(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_video): - assert inline_query_result_video.type == self.type - assert inline_query_result_video.id == self.id + assert inline_query_result_video.type == self.type_ + assert inline_query_result_video.id == self.id_ assert inline_query_result_video.video_url == self.video_url assert inline_query_result_video.mime_type == self.mime_type assert inline_query_result_video.video_width == self.video_width @@ -100,15 +100,15 @@ def test_to_dict(self, inline_query_result_video): == inline_query_result_video.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultVideo(self.id, self.video_url, self.mime_type, + a = InlineQueryResultVideo(self.id_, self.video_url, self.mime_type, self.thumb_url, self.title) - b = InlineQueryResultVideo(self.id, self.video_url, self.mime_type, + b = InlineQueryResultVideo(self.id_, self.video_url, self.mime_type, self.thumb_url, self.title) - c = InlineQueryResultVideo(self.id, '', self.mime_type, self.thumb_url, + c = InlineQueryResultVideo(self.id_, '', self.mime_type, self.thumb_url, self.title) d = InlineQueryResultVideo('', self.video_url, self.mime_type, self.thumb_url, self.title) - e = InlineQueryResultVoice(self.id, '', '') + e = InlineQueryResultVoice(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inlinequeryresultvoice.py b/tests/test_inlinequeryresultvoice.py index 9ba972d3eb6..946244eeffd 100644 --- a/tests/test_inlinequeryresultvoice.py +++ b/tests/test_inlinequeryresultvoice.py @@ -26,8 +26,8 @@ @pytest.fixture(scope='class') def inline_query_result_voice(): return InlineQueryResultVoice( - type=TestInlineQueryResultVoice.type, - id=TestInlineQueryResultVoice.id, + type=TestInlineQueryResultVoice.type_, + id=TestInlineQueryResultVoice.id_, voice_url=TestInlineQueryResultVoice.voice_url, title=TestInlineQueryResultVoice.title, voice_duration=TestInlineQueryResultVoice.voice_duration, @@ -38,8 +38,8 @@ def inline_query_result_voice(): class TestInlineQueryResultVoice(object): - id = 'id' - type = 'voice' + id_ = 'id' + type_ = 'voice' voice_url = 'voice url' title = 'title' voice_duration = 'voice_duration' @@ -49,8 +49,8 @@ class TestInlineQueryResultVoice(object): reply_markup = InlineKeyboardMarkup([[InlineKeyboardButton('reply_markup')]]) def test_expected_values(self, inline_query_result_voice): - assert inline_query_result_voice.type == self.type - assert inline_query_result_voice.id == self.id + assert inline_query_result_voice.type == self.type_ + assert inline_query_result_voice.id == self.id_ assert inline_query_result_voice.voice_url == self.voice_url assert inline_query_result_voice.title == self.title assert inline_query_result_voice.voice_duration == self.voice_duration @@ -78,11 +78,11 @@ def test_to_dict(self, inline_query_result_voice): == inline_query_result_voice.reply_markup.to_dict()) def test_equality(self): - a = InlineQueryResultVoice(self.id, self.voice_url, self.title) - b = InlineQueryResultVoice(self.id, self.voice_url, self.title) - c = InlineQueryResultVoice(self.id, '', self.title) + a = InlineQueryResultVoice(self.id_, self.voice_url, self.title) + b = InlineQueryResultVoice(self.id_, self.voice_url, self.title) + c = InlineQueryResultVoice(self.id_, '', self.title) d = InlineQueryResultVoice('', self.voice_url, self.title) - e = InlineQueryResultAudio(self.id, '', '') + e = InlineQueryResultAudio(self.id_, '', '') assert a == b assert hash(a) == hash(b) diff --git a/tests/test_inputmedia.py b/tests/test_inputmedia.py index bce3cf95c82..7dd964bf55b 100644 --- a/tests/test_inputmedia.py +++ b/tests/test_inputmedia.py @@ -83,7 +83,7 @@ def input_media_document(class_thumb_file): class TestInputMediaVideo(object): - type = "video" + type_ = "video" media = "NOTAREALFILEID" caption = "My Caption" width = 3 @@ -93,7 +93,7 @@ class TestInputMediaVideo(object): supports_streaming = True def test_expected_values(self, input_media_video): - assert input_media_video.type == self.type + assert input_media_video.type == self.type_ assert input_media_video.media == self.media assert input_media_video.caption == self.caption assert input_media_video.width == self.width @@ -117,7 +117,7 @@ def test_to_dict(self, input_media_video): def test_with_video(self, video): # noqa: F811 # fixture found in test_video input_media_video = InputMediaVideo(video, caption="test 3") - assert input_media_video.type == self.type + assert input_media_video.type == self.type_ assert input_media_video.media == video.file_id assert input_media_video.width == video.width assert input_media_video.height == video.height @@ -127,19 +127,19 @@ def test_with_video(self, video): # noqa: F811 def test_with_video_file(self, video_file): # noqa: F811 # fixture found in test_video input_media_video = InputMediaVideo(video_file, caption="test 3") - assert input_media_video.type == self.type + assert input_media_video.type == self.type_ assert isinstance(input_media_video.media, InputFile) assert input_media_video.caption == "test 3" class TestInputMediaPhoto(object): - type = "photo" + type_ = "photo" media = "NOTAREALFILEID" caption = "My Caption" parse_mode = 'Markdown' def test_expected_values(self, input_media_photo): - assert input_media_photo.type == self.type + assert input_media_photo.type == self.type_ assert input_media_photo.media == self.media assert input_media_photo.caption == self.caption assert input_media_photo.parse_mode == self.parse_mode @@ -154,20 +154,20 @@ def test_to_dict(self, input_media_photo): def test_with_photo(self, photo): # noqa: F811 # fixture found in test_photo input_media_photo = InputMediaPhoto(photo, caption="test 2") - assert input_media_photo.type == self.type + assert input_media_photo.type == self.type_ assert input_media_photo.media == photo.file_id assert input_media_photo.caption == "test 2" def test_with_photo_file(self, photo_file): # noqa: F811 # fixture found in test_photo input_media_photo = InputMediaPhoto(photo_file, caption="test 2") - assert input_media_photo.type == self.type + assert input_media_photo.type == self.type_ assert isinstance(input_media_photo.media, InputFile) assert input_media_photo.caption == "test 2" class TestInputMediaAnimation(object): - type = "animation" + type_ = "animation" media = "NOTAREALFILEID" caption = "My Caption" parse_mode = 'Markdown' @@ -176,7 +176,7 @@ class TestInputMediaAnimation(object): duration = 1 def test_expected_values(self, input_media_animation): - assert input_media_animation.type == self.type + assert input_media_animation.type == self.type_ assert input_media_animation.media == self.media assert input_media_animation.caption == self.caption assert input_media_animation.parse_mode == self.parse_mode @@ -195,20 +195,20 @@ def test_to_dict(self, input_media_animation): def test_with_animation(self, animation): # noqa: F811 # fixture found in test_animation input_media_animation = InputMediaAnimation(animation, caption="test 2") - assert input_media_animation.type == self.type + assert input_media_animation.type == self.type_ assert input_media_animation.media == animation.file_id assert input_media_animation.caption == "test 2" def test_with_animation_file(self, animation_file): # noqa: F811 # fixture found in test_animation input_media_animation = InputMediaAnimation(animation_file, caption="test 2") - assert input_media_animation.type == self.type + assert input_media_animation.type == self.type_ assert isinstance(input_media_animation.media, InputFile) assert input_media_animation.caption == "test 2" class TestInputMediaAudio(object): - type = "audio" + type_ = "audio" media = "NOTAREALFILEID" caption = "My Caption" duration = 3 @@ -217,7 +217,7 @@ class TestInputMediaAudio(object): parse_mode = 'HTML' def test_expected_values(self, input_media_audio): - assert input_media_audio.type == self.type + assert input_media_audio.type == self.type_ assert input_media_audio.media == self.media assert input_media_audio.caption == self.caption assert input_media_audio.duration == self.duration @@ -239,7 +239,7 @@ def test_to_dict(self, input_media_audio): def test_with_audio(self, audio): # noqa: F811 # fixture found in test_audio input_media_audio = InputMediaAudio(audio, caption="test 3") - assert input_media_audio.type == self.type + assert input_media_audio.type == self.type_ assert input_media_audio.media == audio.file_id assert input_media_audio.duration == audio.duration assert input_media_audio.performer == audio.performer @@ -249,19 +249,19 @@ def test_with_audio(self, audio): # noqa: F811 def test_with_audio_file(self, audio_file): # noqa: F811 # fixture found in test_audio input_media_audio = InputMediaAudio(audio_file, caption="test 3") - assert input_media_audio.type == self.type + assert input_media_audio.type == self.type_ assert isinstance(input_media_audio.media, InputFile) assert input_media_audio.caption == "test 3" class TestInputMediaDocument(object): - type = "document" + type_ = "document" media = "NOTAREALFILEID" caption = "My Caption" parse_mode = 'HTML' def test_expected_values(self, input_media_document): - assert input_media_document.type == self.type + assert input_media_document.type == self.type_ assert input_media_document.media == self.media assert input_media_document.caption == self.caption assert input_media_document.parse_mode == self.parse_mode @@ -277,14 +277,14 @@ def test_to_dict(self, input_media_document): def test_with_document(self, document): # noqa: F811 # fixture found in test_document input_media_document = InputMediaDocument(document, caption="test 3") - assert input_media_document.type == self.type + assert input_media_document.type == self.type_ assert input_media_document.media == document.file_id assert input_media_document.caption == "test 3" def test_with_document_file(self, document_file): # noqa: F811 # fixture found in test_document input_media_document = InputMediaDocument(document_file, caption="test 3") - assert input_media_document.type == self.type + assert input_media_document.type == self.type_ assert isinstance(input_media_document.media, InputFile) assert input_media_document.caption == "test 3" diff --git a/tests/test_location.py b/tests/test_location.py index cbac1094f30..0637101c450 100644 --- a/tests/test_location.py +++ b/tests/test_location.py @@ -67,8 +67,8 @@ def test_edit_live_inline_message(self, monkeypatch, bot, location): def test(_, url, data, **kwargs): lat = data['latitude'] == location.latitude lon = data['longitude'] == location.longitude - id = data['inline_message_id'] == 1234 - return lat and lon and id + id_ = data['inline_message_id'] == 1234 + return lat and lon and id_ monkeypatch.setattr('telegram.utils.request.Request.post', test) assert bot.edit_message_live_location(inline_message_id=1234, location=location) @@ -76,8 +76,8 @@ def test(_, url, data, **kwargs): # TODO: Needs improvement with in inline sent live location. def test_stop_live_inline_message(self, monkeypatch, bot): def test(_, url, data, **kwargs): - id = data['inline_message_id'] == 1234 - return id + id_ = data['inline_message_id'] == 1234 + return id_ monkeypatch.setattr('telegram.utils.request.Request.post', test) assert bot.stop_message_live_location(inline_message_id=1234) diff --git a/tests/test_message.py b/tests/test_message.py index 2258d462572..58fb8391a2e 100644 --- a/tests/test_message.py +++ b/tests/test_message.py @@ -28,7 +28,7 @@ @pytest.fixture(scope='class') def message(bot): - return Message(TestMessage.id, TestMessage.from_user, TestMessage.date, TestMessage.chat, + return Message(TestMessage.id_, TestMessage.from_user, TestMessage.date, TestMessage.chat, bot=bot) @@ -107,14 +107,14 @@ def message(bot): 'photo_from_media_group', 'passport_data', 'poll', 'reply_markup', 'default_quote']) def message_params(bot, request): - return Message(message_id=TestMessage.id, + return Message(message_id=TestMessage.id_, from_user=TestMessage.from_user, date=TestMessage.date, chat=TestMessage.chat, bot=bot, **request.param) class TestMessage(object): - id = 1 + id_ = 1 from_user = User(2, 'testuser', False) date = datetime.utcnow() chat = Chat(3, 'private') @@ -345,13 +345,13 @@ def test_effective_attachment(self, message_params): def test_reply_text(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id text = args[1] == 'test' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and text and reply + return id_ and text and reply monkeypatch.setattr(message.bot, 'send_message', test) assert message.reply_text('test') @@ -411,13 +411,13 @@ def test(*args, **kwargs): def test_reply_media_group(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id media = kwargs['media'] == 'reply_media_group' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and media and reply + return id_ and media and reply monkeypatch.setattr(message.bot, 'send_media_group', test) assert message.reply_media_group(media='reply_media_group') @@ -425,13 +425,13 @@ def test(*args, **kwargs): def test_reply_photo(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id photo = kwargs['photo'] == 'test_photo' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and photo and reply + return id_ and photo and reply monkeypatch.setattr(message.bot, 'send_photo', test) assert message.reply_photo(photo='test_photo') @@ -439,13 +439,13 @@ def test(*args, **kwargs): def test_reply_audio(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id audio = kwargs['audio'] == 'test_audio' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and audio and reply + return id_ and audio and reply monkeypatch.setattr(message.bot, 'send_audio', test) assert message.reply_audio(audio='test_audio') @@ -453,13 +453,13 @@ def test(*args, **kwargs): def test_reply_document(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id document = kwargs['document'] == 'test_document' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and document and reply + return id_ and document and reply monkeypatch.setattr(message.bot, 'send_document', test) assert message.reply_document(document='test_document') @@ -467,13 +467,13 @@ def test(*args, **kwargs): def test_reply_animation(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id animation = kwargs['animation'] == 'test_animation' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and animation and reply + return id_ and animation and reply monkeypatch.setattr(message.bot, 'send_animation', test) assert message.reply_animation(animation='test_animation') @@ -481,13 +481,13 @@ def test(*args, **kwargs): def test_reply_sticker(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id sticker = kwargs['sticker'] == 'test_sticker' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and sticker and reply + return id_ and sticker and reply monkeypatch.setattr(message.bot, 'send_sticker', test) assert message.reply_sticker(sticker='test_sticker') @@ -495,13 +495,13 @@ def test(*args, **kwargs): def test_reply_video(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id video = kwargs['video'] == 'test_video' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and video and reply + return id_ and video and reply monkeypatch.setattr(message.bot, 'send_video', test) assert message.reply_video(video='test_video') @@ -509,13 +509,13 @@ def test(*args, **kwargs): def test_reply_video_note(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id video_note = kwargs['video_note'] == 'test_video_note' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and video_note and reply + return id_ and video_note and reply monkeypatch.setattr(message.bot, 'send_video_note', test) assert message.reply_video_note(video_note='test_video_note') @@ -523,13 +523,13 @@ def test(*args, **kwargs): def test_reply_voice(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id voice = kwargs['voice'] == 'test_voice' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and voice and reply + return id_ and voice and reply monkeypatch.setattr(message.bot, 'send_voice', test) assert message.reply_voice(voice='test_voice') @@ -537,13 +537,13 @@ def test(*args, **kwargs): def test_reply_location(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id location = kwargs['location'] == 'test_location' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and location and reply + return id_ and location and reply monkeypatch.setattr(message.bot, 'send_location', test) assert message.reply_location(location='test_location') @@ -551,13 +551,13 @@ def test(*args, **kwargs): def test_reply_venue(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id venue = kwargs['venue'] == 'test_venue' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and venue and reply + return id_ and venue and reply monkeypatch.setattr(message.bot, 'send_venue', test) assert message.reply_venue(venue='test_venue') @@ -565,13 +565,13 @@ def test(*args, **kwargs): def test_reply_contact(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id contact = kwargs['contact'] == 'test_contact' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and contact and reply + return id_ and contact and reply monkeypatch.setattr(message.bot, 'send_contact', test) assert message.reply_contact(contact='test_contact') @@ -579,13 +579,13 @@ def test(*args, **kwargs): def test_reply_poll(self, monkeypatch, message): def test(*args, **kwargs): - id = args[0] == message.chat_id + id_ = args[0] == message.chat_id contact = kwargs['contact'] == 'test_poll' if kwargs.get('reply_to_message_id'): reply = kwargs['reply_to_message_id'] == message.message_id else: reply = True - return id and contact and reply + return id_ and contact and reply monkeypatch.setattr(message.bot, 'send_poll', test) assert message.reply_poll(contact='test_poll') @@ -678,12 +678,12 @@ def test_default_quote(self, message): assert 'reply_to_message_id' in kwargs def test_equality(self): - id = 1 - a = Message(id, self.from_user, self.date, self.chat) - b = Message(id, self.from_user, self.date, self.chat) - c = Message(id, User(0, '', False), self.date, self.chat) + id_ = 1 + a = Message(id_, self.from_user, self.date, self.chat) + b = Message(id_, self.from_user, self.date, self.chat) + c = Message(id_, User(0, '', False), self.date, self.chat) d = Message(0, self.from_user, self.date, self.chat) - e = Update(id) + e = Update(id_) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_messageentity.py b/tests/test_messageentity.py index c0ad89194c9..333675f4020 100644 --- a/tests/test_messageentity.py +++ b/tests/test_messageentity.py @@ -25,31 +25,31 @@ @pytest.fixture(scope="class", params=MessageEntity.ALL_TYPES) def message_entity(request): - type = request.param + type_ = request.param url = None - if type == MessageEntity.TEXT_LINK: + if type_ == MessageEntity.TEXT_LINK: url = 't.me' user = None - if type == MessageEntity.TEXT_MENTION: + if type_ == MessageEntity.TEXT_MENTION: user = User(1, 'test_user', False) return MessageEntity(type, 1, 3, url=url, user=user) class TestMessageEntity(object): - type = 'url' + type_ = 'url' offset = 1 length = 2 url = 'url' def test_de_json(self, bot): json_dict = { - 'type': self.type, + 'type': self.type_, 'offset': self.offset, 'length': self.length } entity = MessageEntity.de_json(json_dict, bot) - assert entity.type == self.type + assert entity.type == self.type_ assert entity.offset == self.offset assert entity.length == self.length diff --git a/tests/test_messagequeue.py b/tests/test_messagequeue.py index d361010324e..47c56f9118f 100644 --- a/tests/test_messagequeue.py +++ b/tests/test_messagequeue.py @@ -43,7 +43,7 @@ def test_delayqueue_limits(self): autostart=True) assert dsp.is_alive() is True - for i in range(self.N): + for _ in range(self.N): dsp(self.call) starttime = mq.curtime() diff --git a/tests/test_passportelementerrordatafield.py b/tests/test_passportelementerrordatafield.py index d5aa03f133c..11ec301360e 100644 --- a/tests/test_passportelementerrordatafield.py +++ b/tests/test_passportelementerrordatafield.py @@ -24,7 +24,7 @@ @pytest.fixture(scope='class') def passport_element_error_data_field(): - return PassportElementErrorDataField(TestPassportElementErrorDataField.type, + return PassportElementErrorDataField(TestPassportElementErrorDataField.type_, TestPassportElementErrorDataField.field_name, TestPassportElementErrorDataField.data_hash, TestPassportElementErrorDataField.message) @@ -32,14 +32,14 @@ def passport_element_error_data_field(): class TestPassportElementErrorDataField(object): source = 'data' - type = 'test_type' + type_ = 'test_type' field_name = 'test_field' data_hash = 'data_hash' message = 'Error message' def test_expected_values(self, passport_element_error_data_field): assert passport_element_error_data_field.source == self.source - assert passport_element_error_data_field.type == self.type + assert passport_element_error_data_field.type == self.type_ assert passport_element_error_data_field.field_name == self.field_name assert passport_element_error_data_field.data_hash == self.data_hash assert passport_element_error_data_field.message == self.message @@ -60,13 +60,15 @@ def test_to_dict(self, passport_element_error_data_field): == passport_element_error_data_field.message) def test_equality(self): - a = PassportElementErrorDataField(self.type, self.field_name, self.data_hash, self.message) - b = PassportElementErrorDataField(self.type, self.field_name, self.data_hash, self.message) - c = PassportElementErrorDataField(self.type, '', '', '') + a = PassportElementErrorDataField(self.type_, self.field_name, self.data_hash, + self.message) + b = PassportElementErrorDataField(self.type_, self.field_name, self.data_hash, + self.message) + c = PassportElementErrorDataField(self.type_, '', '', '') d = PassportElementErrorDataField('', self.field_name, '', '') e = PassportElementErrorDataField('', '', self.data_hash, '') f = PassportElementErrorDataField('', '', '', self.message) - g = PassportElementErrorSelfie(self.type, '', self.message) + g = PassportElementErrorSelfie(self.type_, '', self.message) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_passportelementerrorfile.py b/tests/test_passportelementerrorfile.py index 2688d9fd4f8..8bedc046c72 100644 --- a/tests/test_passportelementerrorfile.py +++ b/tests/test_passportelementerrorfile.py @@ -24,20 +24,20 @@ @pytest.fixture(scope='class') def passport_element_error_file(): - return PassportElementErrorFile(TestPassportElementErrorFile.type, + return PassportElementErrorFile(TestPassportElementErrorFile.type_, TestPassportElementErrorFile.file_hash, TestPassportElementErrorFile.message) class TestPassportElementErrorFile(object): source = 'file' - type = 'test_type' + type_ = 'test_type' file_hash = 'file_hash' message = 'Error message' def test_expected_values(self, passport_element_error_file): assert passport_element_error_file.source == self.source - assert passport_element_error_file.type == self.type + assert passport_element_error_file.type == self.type_ assert passport_element_error_file.file_hash == self.file_hash assert passport_element_error_file.message == self.message @@ -55,12 +55,12 @@ def test_to_dict(self, passport_element_error_file): == passport_element_error_file.message) def test_equality(self): - a = PassportElementErrorFile(self.type, self.file_hash, self.message) - b = PassportElementErrorFile(self.type, self.file_hash, self.message) - c = PassportElementErrorFile(self.type, '', '') + a = PassportElementErrorFile(self.type_, self.file_hash, self.message) + b = PassportElementErrorFile(self.type_, self.file_hash, self.message) + c = PassportElementErrorFile(self.type_, '', '') d = PassportElementErrorFile('', self.file_hash, '') e = PassportElementErrorFile('', '', self.message) - f = PassportElementErrorSelfie(self.type, self.file_hash, self.message) + f = PassportElementErrorSelfie(self.type_, self.file_hash, self.message) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_passportelementerrorfiles.py b/tests/test_passportelementerrorfiles.py index 506967cd231..b519ce06b5a 100644 --- a/tests/test_passportelementerrorfiles.py +++ b/tests/test_passportelementerrorfiles.py @@ -24,20 +24,20 @@ @pytest.fixture(scope='class') def passport_element_error_files(): - return PassportElementErrorFiles(TestPassportElementErrorFiles.type, + return PassportElementErrorFiles(TestPassportElementErrorFiles.type_, TestPassportElementErrorFiles.file_hashes, TestPassportElementErrorFiles.message) class TestPassportElementErrorFiles(object): source = 'files' - type = 'test_type' + type_ = 'test_type' file_hashes = ['hash1', 'hash2'] message = 'Error message' def test_expected_values(self, passport_element_error_files): assert passport_element_error_files.source == self.source - assert passport_element_error_files.type == self.type + assert passport_element_error_files.type == self.type_ assert isinstance(passport_element_error_files.file_hashes, list) assert passport_element_error_files.file_hashes == self.file_hashes assert passport_element_error_files.message == self.message @@ -56,12 +56,12 @@ def test_to_dict(self, passport_element_error_files): == passport_element_error_files.message) def test_equality(self): - a = PassportElementErrorFiles(self.type, self.file_hashes, self.message) - b = PassportElementErrorFiles(self.type, self.file_hashes, self.message) - c = PassportElementErrorFiles(self.type, '', '') + a = PassportElementErrorFiles(self.type_, self.file_hashes, self.message) + b = PassportElementErrorFiles(self.type_, self.file_hashes, self.message) + c = PassportElementErrorFiles(self.type_, '', '') d = PassportElementErrorFiles('', self.file_hashes, '') e = PassportElementErrorFiles('', '', self.message) - f = PassportElementErrorSelfie(self.type, '', self.message) + f = PassportElementErrorSelfie(self.type_, '', self.message) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_passportelementerrorfrontside.py b/tests/test_passportelementerrorfrontside.py index 15f96a174a1..ebca892f3ca 100644 --- a/tests/test_passportelementerrorfrontside.py +++ b/tests/test_passportelementerrorfrontside.py @@ -24,20 +24,20 @@ @pytest.fixture(scope='class') def passport_element_error_front_side(): - return PassportElementErrorFrontSide(TestPassportElementErrorFrontSide.type, + return PassportElementErrorFrontSide(TestPassportElementErrorFrontSide.type_, TestPassportElementErrorFrontSide.file_hash, TestPassportElementErrorFrontSide.message) class TestPassportElementErrorFrontSide(object): source = 'front_side' - type = 'test_type' + type_ = 'test_type' file_hash = 'file_hash' message = 'Error message' def test_expected_values(self, passport_element_error_front_side): assert passport_element_error_front_side.source == self.source - assert passport_element_error_front_side.type == self.type + assert passport_element_error_front_side.type == self.type_ assert passport_element_error_front_side.file_hash == self.file_hash assert passport_element_error_front_side.message == self.message @@ -55,12 +55,12 @@ def test_to_dict(self, passport_element_error_front_side): == passport_element_error_front_side.message) def test_equality(self): - a = PassportElementErrorFrontSide(self.type, self.file_hash, self.message) - b = PassportElementErrorFrontSide(self.type, self.file_hash, self.message) - c = PassportElementErrorFrontSide(self.type, '', '') + a = PassportElementErrorFrontSide(self.type_, self.file_hash, self.message) + b = PassportElementErrorFrontSide(self.type_, self.file_hash, self.message) + c = PassportElementErrorFrontSide(self.type_, '', '') d = PassportElementErrorFrontSide('', self.file_hash, '') e = PassportElementErrorFrontSide('', '', self.message) - f = PassportElementErrorSelfie(self.type, self.file_hash, self.message) + f = PassportElementErrorSelfie(self.type_, self.file_hash, self.message) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_passportelementerrorreverseside.py b/tests/test_passportelementerrorreverseside.py index bf3585ccc47..ca568afb3a7 100644 --- a/tests/test_passportelementerrorreverseside.py +++ b/tests/test_passportelementerrorreverseside.py @@ -24,20 +24,20 @@ @pytest.fixture(scope='class') def passport_element_error_reverse_side(): - return PassportElementErrorReverseSide(TestPassportElementErrorReverseSide.type, + return PassportElementErrorReverseSide(TestPassportElementErrorReverseSide.type_, TestPassportElementErrorReverseSide.file_hash, TestPassportElementErrorReverseSide.message) class TestPassportElementErrorReverseSide(object): source = 'reverse_side' - type = 'test_type' + type_ = 'test_type' file_hash = 'file_hash' message = 'Error message' def test_expected_values(self, passport_element_error_reverse_side): assert passport_element_error_reverse_side.source == self.source - assert passport_element_error_reverse_side.type == self.type + assert passport_element_error_reverse_side.type == self.type_ assert passport_element_error_reverse_side.file_hash == self.file_hash assert passport_element_error_reverse_side.message == self.message @@ -55,12 +55,12 @@ def test_to_dict(self, passport_element_error_reverse_side): == passport_element_error_reverse_side.message) def test_equality(self): - a = PassportElementErrorReverseSide(self.type, self.file_hash, self.message) - b = PassportElementErrorReverseSide(self.type, self.file_hash, self.message) - c = PassportElementErrorReverseSide(self.type, '', '') + a = PassportElementErrorReverseSide(self.type_, self.file_hash, self.message) + b = PassportElementErrorReverseSide(self.type_, self.file_hash, self.message) + c = PassportElementErrorReverseSide(self.type_, '', '') d = PassportElementErrorReverseSide('', self.file_hash, '') e = PassportElementErrorReverseSide('', '', self.message) - f = PassportElementErrorSelfie(self.type, self.file_hash, self.message) + f = PassportElementErrorSelfie(self.type_, self.file_hash, self.message) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_passportelementerrorselfie.py b/tests/test_passportelementerrorselfie.py index 8244a1e50a8..1d3ccb75c11 100644 --- a/tests/test_passportelementerrorselfie.py +++ b/tests/test_passportelementerrorselfie.py @@ -24,20 +24,20 @@ @pytest.fixture(scope='class') def passport_element_error_selfie(): - return PassportElementErrorSelfie(TestPassportElementErrorSelfie.type, + return PassportElementErrorSelfie(TestPassportElementErrorSelfie.type_, TestPassportElementErrorSelfie.file_hash, TestPassportElementErrorSelfie.message) class TestPassportElementErrorSelfie(object): source = 'selfie' - type = 'test_type' + type_ = 'test_type' file_hash = 'file_hash' message = 'Error message' def test_expected_values(self, passport_element_error_selfie): assert passport_element_error_selfie.source == self.source - assert passport_element_error_selfie.type == self.type + assert passport_element_error_selfie.type == self.type_ assert passport_element_error_selfie.file_hash == self.file_hash assert passport_element_error_selfie.message == self.message @@ -55,12 +55,12 @@ def test_to_dict(self, passport_element_error_selfie): == passport_element_error_selfie.message) def test_equality(self): - a = PassportElementErrorSelfie(self.type, self.file_hash, self.message) - b = PassportElementErrorSelfie(self.type, self.file_hash, self.message) - c = PassportElementErrorSelfie(self.type, '', '') + a = PassportElementErrorSelfie(self.type_, self.file_hash, self.message) + b = PassportElementErrorSelfie(self.type_, self.file_hash, self.message) + c = PassportElementErrorSelfie(self.type_, '', '') d = PassportElementErrorSelfie('', self.file_hash, '') e = PassportElementErrorSelfie('', '', self.message) - f = PassportElementErrorDataField(self.type, '', '', self.message) + f = PassportElementErrorDataField(self.type_, '', '', self.message) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_passportelementerrortranslationfile.py b/tests/test_passportelementerrortranslationfile.py index 168f61c86df..c3f9f3d6eb8 100644 --- a/tests/test_passportelementerrortranslationfile.py +++ b/tests/test_passportelementerrortranslationfile.py @@ -24,20 +24,20 @@ @pytest.fixture(scope='class') def passport_element_error_translation_file(): - return PassportElementErrorTranslationFile(TestPassportElementErrorTranslationFile.type, + return PassportElementErrorTranslationFile(TestPassportElementErrorTranslationFile.type_, TestPassportElementErrorTranslationFile.file_hash, TestPassportElementErrorTranslationFile.message) class TestPassportElementErrorTranslationFile(object): source = 'translation_file' - type = 'test_type' + type_ = 'test_type' file_hash = 'file_hash' message = 'Error message' def test_expected_values(self, passport_element_error_translation_file): assert passport_element_error_translation_file.source == self.source - assert passport_element_error_translation_file.type == self.type + assert passport_element_error_translation_file.type == self.type_ assert passport_element_error_translation_file.file_hash == self.file_hash assert passport_element_error_translation_file.message == self.message @@ -56,12 +56,12 @@ def test_to_dict(self, passport_element_error_translation_file): == passport_element_error_translation_file.message) def test_equality(self): - a = PassportElementErrorTranslationFile(self.type, self.file_hash, self.message) - b = PassportElementErrorTranslationFile(self.type, self.file_hash, self.message) - c = PassportElementErrorTranslationFile(self.type, '', '') + a = PassportElementErrorTranslationFile(self.type_, self.file_hash, self.message) + b = PassportElementErrorTranslationFile(self.type_, self.file_hash, self.message) + c = PassportElementErrorTranslationFile(self.type_, '', '') d = PassportElementErrorTranslationFile('', self.file_hash, '') e = PassportElementErrorTranslationFile('', '', self.message) - f = PassportElementErrorDataField(self.type, '', '', self.message) + f = PassportElementErrorDataField(self.type_, '', '', self.message) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_passportelementerrortranslationfiles.py b/tests/test_passportelementerrortranslationfiles.py index 35072af1c8c..5c9139d6a10 100644 --- a/tests/test_passportelementerrortranslationfiles.py +++ b/tests/test_passportelementerrortranslationfiles.py @@ -25,20 +25,20 @@ @pytest.fixture(scope='class') def passport_element_error_translation_files(): return PassportElementErrorTranslationFiles( - TestPassportElementErrorTranslationFiles.type, + TestPassportElementErrorTranslationFiles.type_, TestPassportElementErrorTranslationFiles.file_hashes, TestPassportElementErrorTranslationFiles.message) class TestPassportElementErrorTranslationFiles(object): source = 'translation_files' - type = 'test_type' + type_ = 'test_type' file_hashes = ['hash1', 'hash2'] message = 'Error message' def test_expected_values(self, passport_element_error_translation_files): assert passport_element_error_translation_files.source == self.source - assert passport_element_error_translation_files.type == self.type + assert passport_element_error_translation_files.type == self.type_ assert isinstance(passport_element_error_translation_files.file_hashes, list) assert passport_element_error_translation_files.file_hashes == self.file_hashes assert passport_element_error_translation_files.message == self.message @@ -58,12 +58,12 @@ def test_to_dict(self, passport_element_error_translation_files): == passport_element_error_translation_files.message) def test_equality(self): - a = PassportElementErrorTranslationFiles(self.type, self.file_hashes, self.message) - b = PassportElementErrorTranslationFiles(self.type, self.file_hashes, self.message) - c = PassportElementErrorTranslationFiles(self.type, '', '') + a = PassportElementErrorTranslationFiles(self.type_, self.file_hashes, self.message) + b = PassportElementErrorTranslationFiles(self.type_, self.file_hashes, self.message) + c = PassportElementErrorTranslationFiles(self.type_, '', '') d = PassportElementErrorTranslationFiles('', self.file_hashes, '') e = PassportElementErrorTranslationFiles('', '', self.message) - f = PassportElementErrorSelfie(self.type, '', self.message) + f = PassportElementErrorSelfie(self.type_, '', self.message) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_passportelementerrorunspecified.py b/tests/test_passportelementerrorunspecified.py index 9638cea5f9a..9e9ef7d6c0f 100644 --- a/tests/test_passportelementerrorunspecified.py +++ b/tests/test_passportelementerrorunspecified.py @@ -24,20 +24,20 @@ @pytest.fixture(scope='class') def passport_element_error_unspecified(): - return PassportElementErrorUnspecified(TestPassportElementErrorUnspecified.type, + return PassportElementErrorUnspecified(TestPassportElementErrorUnspecified.type_, TestPassportElementErrorUnspecified.element_hash, TestPassportElementErrorUnspecified.message) class TestPassportElementErrorUnspecified(object): source = 'unspecified' - type = 'test_type' + type_ = 'test_type' element_hash = 'element_hash' message = 'Error message' def test_expected_values(self, passport_element_error_unspecified): assert passport_element_error_unspecified.source == self.source - assert passport_element_error_unspecified.type == self.type + assert passport_element_error_unspecified.type == self.type_ assert passport_element_error_unspecified.element_hash == self.element_hash assert passport_element_error_unspecified.message == self.message @@ -55,12 +55,12 @@ def test_to_dict(self, passport_element_error_unspecified): == passport_element_error_unspecified.message) def test_equality(self): - a = PassportElementErrorUnspecified(self.type, self.element_hash, self.message) - b = PassportElementErrorUnspecified(self.type, self.element_hash, self.message) - c = PassportElementErrorUnspecified(self.type, '', '') + a = PassportElementErrorUnspecified(self.type_, self.element_hash, self.message) + b = PassportElementErrorUnspecified(self.type_, self.element_hash, self.message) + c = PassportElementErrorUnspecified(self.type_, '', '') d = PassportElementErrorUnspecified('', self.element_hash, '') e = PassportElementErrorUnspecified('', '', self.message) - f = PassportElementErrorDataField(self.type, '', '', self.message) + f = PassportElementErrorDataField(self.type_, '', '', self.message) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_persistence.py b/tests/test_persistence.py index ff68a7c1eff..1927e154932 100644 --- a/tests/test_persistence.py +++ b/tests/test_persistence.py @@ -317,8 +317,8 @@ def bad_pickle_files(): @pytest.fixture(scope='function') def good_pickle_files(user_data, chat_data, bot_data, conversations): - all = {'user_data': user_data, 'chat_data': chat_data, - 'bot_data': bot_data, 'conversations': conversations} + data = {'user_data': user_data, 'chat_data': chat_data, + 'bot_data': bot_data, 'conversations': conversations} with open('pickletest_user_data', 'wb') as f: pickle.dump(user_data, f) with open('pickletest_chat_data', 'wb') as f: @@ -328,7 +328,7 @@ def good_pickle_files(user_data, chat_data, bot_data, conversations): with open('pickletest_conversations', 'wb') as f: pickle.dump(conversations, f) with open('pickletest', 'wb') as f: - pickle.dump(all, f) + pickle.dump(data, f) yield True for name in ['pickletest_user_data', 'pickletest_chat_data', 'pickletest_bot_data', 'pickletest_conversations', 'pickletest']: @@ -337,7 +337,7 @@ def good_pickle_files(user_data, chat_data, bot_data, conversations): @pytest.fixture(scope='function') def pickle_files_wo_bot_data(user_data, chat_data, conversations): - all = {'user_data': user_data, 'chat_data': chat_data, 'conversations': conversations} + data = {'user_data': user_data, 'chat_data': chat_data, 'conversations': conversations} with open('pickletest_user_data', 'wb') as f: pickle.dump(user_data, f) with open('pickletest_chat_data', 'wb') as f: @@ -345,7 +345,7 @@ def pickle_files_wo_bot_data(user_data, chat_data, conversations): with open('pickletest_conversations', 'wb') as f: pickle.dump(conversations, f) with open('pickletest', 'wb') as f: - pickle.dump(all, f) + pickle.dump(data, f) yield True for name in ['pickletest_user_data', 'pickletest_chat_data', 'pickletest_conversations', 'pickletest']: diff --git a/tests/test_poll.py b/tests/test_poll.py index 9d7b5a6950a..2d824f930ef 100644 --- a/tests/test_poll.py +++ b/tests/test_poll.py @@ -52,28 +52,28 @@ def test_to_dict(self, poll_option): @pytest.fixture(scope='class') def poll(): - return Poll(TestPoll.id, + return Poll(TestPoll.id_, TestPoll.question, TestPoll.options, TestPoll.is_closed) class TestPoll(object): - id = 'id' + id_ = 'id' question = 'Test?' options = [PollOption('test', 10), PollOption('test2', 11)] is_closed = True def test_de_json(self): json_dict = { - 'id': self.id, + 'id': self.id_, 'question': self.question, 'options': [o.to_dict() for o in self.options], 'is_closed': self.is_closed } poll = Poll.de_json(json_dict, None) - assert poll.id == self.id + assert poll.id == self.id_ assert poll.question == self.question assert poll.options == self.options assert poll.options[0].text == self.options[0].text diff --git a/tests/test_precheckoutquery.py b/tests/test_precheckoutquery.py index 3618e985d76..d167c66e2bc 100644 --- a/tests/test_precheckoutquery.py +++ b/tests/test_precheckoutquery.py @@ -24,7 +24,7 @@ @pytest.fixture(scope='class') def pre_checkout_query(bot): - return PreCheckoutQuery(TestPreCheckoutQuery.id, + return PreCheckoutQuery(TestPreCheckoutQuery.id_, TestPreCheckoutQuery.from_user, TestPreCheckoutQuery.currency, TestPreCheckoutQuery.total_amount, @@ -35,7 +35,7 @@ def pre_checkout_query(bot): class TestPreCheckoutQuery(object): - id = 5 + id_ = 5 invoice_payload = 'invoice_payload' shipping_option_id = 'shipping_option_id' currency = 'EUR' @@ -45,7 +45,7 @@ class TestPreCheckoutQuery(object): def test_de_json(self, bot): json_dict = { - 'id': self.id, + 'id': self.id_, 'invoice_payload': self.invoice_payload, 'shipping_option_id': self.shipping_option_id, 'currency': self.currency, @@ -56,7 +56,7 @@ def test_de_json(self, bot): pre_checkout_query = PreCheckoutQuery.de_json(json_dict, bot) assert pre_checkout_query.bot is bot - assert pre_checkout_query.id == self.id + assert pre_checkout_query.id == self.id_ assert pre_checkout_query.invoice_payload == self.invoice_payload assert pre_checkout_query.shipping_option_id == self.shipping_option_id assert pre_checkout_query.currency == self.currency @@ -83,14 +83,14 @@ def test(*args, **kwargs): assert pre_checkout_query.answer() def test_equality(self): - a = PreCheckoutQuery(self.id, self.from_user, self.currency, self.total_amount, + a = PreCheckoutQuery(self.id_, self.from_user, self.currency, self.total_amount, self.invoice_payload) - b = PreCheckoutQuery(self.id, self.from_user, self.currency, self.total_amount, + b = PreCheckoutQuery(self.id_, self.from_user, self.currency, self.total_amount, self.invoice_payload) - c = PreCheckoutQuery(self.id, None, '', 0, '') + c = PreCheckoutQuery(self.id_, None, '', 0, '') d = PreCheckoutQuery(0, self.from_user, self.currency, self.total_amount, self.invoice_payload) - e = Update(self.id) + e = Update(self.id_) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_shippingoption.py b/tests/test_shippingoption.py index 2917cd85083..f3b685f9867 100644 --- a/tests/test_shippingoption.py +++ b/tests/test_shippingoption.py @@ -24,12 +24,12 @@ @pytest.fixture(scope='class') def shipping_option(): - return ShippingOption(TestShippingOption.id, TestShippingOption.title, + return ShippingOption(TestShippingOption.id_, TestShippingOption.title, TestShippingOption.prices) class TestShippingOption(object): - id = 'id' + id_ = 'id' title = 'title' prices = [ LabeledPrice('Fish Container', 100), @@ -37,7 +37,7 @@ class TestShippingOption(object): ] def test_expected_values(self, shipping_option): - assert shipping_option.id == self.id + assert shipping_option.id == self.id_ assert shipping_option.title == self.title assert shipping_option.prices == self.prices @@ -51,11 +51,11 @@ def test_to_dict(self, shipping_option): assert shipping_option_dict['prices'][1] == shipping_option.prices[1].to_dict() def test_equality(self): - a = ShippingOption(self.id, self.title, self.prices) - b = ShippingOption(self.id, self.title, self.prices) - c = ShippingOption(self.id, '', []) + a = ShippingOption(self.id_, self.title, self.prices) + b = ShippingOption(self.id_, self.title, self.prices) + c = ShippingOption(self.id_, '', []) d = ShippingOption(0, self.title, self.prices) - e = Voice(self.id, 0) + e = Voice(self.id_, 0) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_shippingquery.py b/tests/test_shippingquery.py index 2cfd69f42eb..88ef057a11a 100644 --- a/tests/test_shippingquery.py +++ b/tests/test_shippingquery.py @@ -24,7 +24,7 @@ @pytest.fixture(scope='class') def shipping_query(bot): - return ShippingQuery(TestShippingQuery.id, + return ShippingQuery(TestShippingQuery.id_, TestShippingQuery.from_user, TestShippingQuery.invoice_payload, TestShippingQuery.shipping_address, @@ -32,21 +32,21 @@ def shipping_query(bot): class TestShippingQuery(object): - id = 5 + id_ = 5 invoice_payload = 'invoice_payload' from_user = User(0, '', False) shipping_address = ShippingAddress('GB', '', 'London', '12 Grimmauld Place', '', 'WC1') def test_de_json(self, bot): json_dict = { - 'id': TestShippingQuery.id, + 'id': TestShippingQuery.id_, 'invoice_payload': TestShippingQuery.invoice_payload, 'from': TestShippingQuery.from_user.to_dict(), 'shipping_address': TestShippingQuery.shipping_address.to_dict() } shipping_query = ShippingQuery.de_json(json_dict, bot) - assert shipping_query.id == self.id + assert shipping_query.id == self.id_ assert shipping_query.invoice_payload == self.invoice_payload assert shipping_query.from_user == self.from_user assert shipping_query.shipping_address == self.shipping_address @@ -69,11 +69,11 @@ def test(*args, **kwargs): assert shipping_query.answer() def test_equality(self): - a = ShippingQuery(self.id, self.from_user, self.invoice_payload, self.shipping_address) - b = ShippingQuery(self.id, self.from_user, self.invoice_payload, self.shipping_address) - c = ShippingQuery(self.id, None, '', None) + a = ShippingQuery(self.id_, self.from_user, self.invoice_payload, self.shipping_address) + b = ShippingQuery(self.id_, self.from_user, self.invoice_payload, self.shipping_address) + c = ShippingQuery(self.id_, None, '', None) d = ShippingQuery(0, self.from_user, self.invoice_payload, self.shipping_address) - e = Update(self.id) + e = Update(self.id_) assert a == b assert hash(a) == hash(b) diff --git a/tests/test_user.py b/tests/test_user.py index aa308cb5839..882faf4d8b8 100644 --- a/tests/test_user.py +++ b/tests/test_user.py @@ -24,7 +24,7 @@ @pytest.fixture(scope='function') def json_dict(): return { - 'id': TestUser.id, + 'id': TestUser.id_, 'is_bot': TestUser.is_bot, 'first_name': TestUser.first_name, 'last_name': TestUser.last_name, @@ -35,13 +35,13 @@ def json_dict(): @pytest.fixture(scope='function') def user(bot): - return User(id=TestUser.id, first_name=TestUser.first_name, is_bot=TestUser.is_bot, + return User(id=TestUser.id_, first_name=TestUser.first_name, is_bot=TestUser.is_bot, last_name=TestUser.last_name, username=TestUser.username, language_code=TestUser.language_code, bot=bot) class TestUser(object): - id = 1 + id_ = 1 is_bot = True first_name = u'first\u2022name' last_name = u'last\u2022name' @@ -51,7 +51,7 @@ class TestUser(object): def test_de_json(self, json_dict, bot): user = User.de_json(json_dict, bot) - assert user.id == self.id + assert user.id == self.id_ assert user.is_bot == self.is_bot assert user.first_name == self.first_name assert user.last_name == self.last_name @@ -63,7 +63,7 @@ def test_de_json_without_username(self, json_dict, bot): user = User.de_json(json_dict, bot) - assert user.id == self.id + assert user.id == self.id_ assert user.is_bot == self.is_bot assert user.first_name == self.first_name assert user.last_name == self.last_name @@ -76,7 +76,7 @@ def test_de_json_without_username_and_last_name(self, json_dict, bot): user = User.de_json(json_dict, bot) - assert user.id == self.id + assert user.id == self.id_ assert user.is_bot == self.is_bot assert user.first_name == self.first_name assert user.last_name is None @@ -189,11 +189,11 @@ def test_mention_markdown(self, user): assert user.mention_markdown(user.username) == expected.format(user.username, user.id) def test_equality(self): - a = User(self.id, self.first_name, self.is_bot, self.last_name) - b = User(self.id, self.first_name, self.is_bot, self.last_name) - c = User(self.id, self.first_name, self.is_bot) + a = User(self.id_, self.first_name, self.is_bot, self.last_name) + b = User(self.id_, self.first_name, self.is_bot, self.last_name) + c = User(self.id_, self.first_name, self.is_bot) d = User(0, self.first_name, self.is_bot, self.last_name) - e = Update(self.id) + e = Update(self.id_) assert a == b assert hash(a) == hash(b)