Column width to 90 #259

setup.cfg

@@ -11,3 +11,7 @@ upload-dir = docs/build/html
 
 [flake8]
 max-line-length = 99
+
+[yapf]
+based_on_style = google
+column_limit = 99

tests/base.py

@@ -36,8 +36,8 @@ class BaseTest(object):
     def __init__(self, *args, **kwargs):
         super(BaseTest, self).__init__(*args, **kwargs)
 
-        bot = telegram.Bot(os.environ.get(
+        bot = telegram.Bot(os.environ.get('TOKEN',
-            'TOKEN', '133505823:AAHZFMHno3mzVLErU5b5jJvaeG--qUyLyG0'))
+                                          '133505823:AAHZFMHno3mzVLErU5b5jJvaeG--qUyLyG0'))
         chat_id = os.environ.get('CHAT_ID', '12173560')
 
         self._bot = bot
@@ -61,6 +61,7 @@ class BaseTest(object):
 
 
 class TestTimedOut(AssertionError):
+
     def __init__(self, time_limit, frame):
         super(TestTimedOut, self).__init__('time_limit={0}'.format(time_limit))
         self.time_limit = time_limit
@@ -68,7 +69,9 @@ class TestTimedOut(AssertionError):
 
 
 def timeout(time_limit):
+
     def decorator(func):
+
         def timed_out(_signum, frame):
             raise TestTimedOut(time_limit, frame)
 

tests/test_audio.py

@@ -197,9 +197,9 @@ class AudioTest(BaseTest, unittest.TestCase):
         del (json_dict['file_id'])
         json_dict['audio'] = open(os.devnull, 'rb')
 
-        self.assertRaises(telegram.TelegramError,
+        self.assertRaises(
-                          lambda: self._bot.sendAudio(chat_id=self._chat_id,
+            telegram.TelegramError,
-                                                      **json_dict))
+            lambda: self._bot.sendAudio(chat_id=self._chat_id, **json_dict))
 
     @flaky(3, 1)
     @timeout(10)
@@ -209,9 +209,9 @@ class AudioTest(BaseTest, unittest.TestCase):
         del (json_dict['file_id'])
         json_dict['audio'] = ''
 
-        self.assertRaises(telegram.TelegramError,
+        self.assertRaises(
-                          lambda: self._bot.sendAudio(chat_id=self._chat_id,
+            telegram.TelegramError,
-                                                      **json_dict))
+            lambda: self._bot.sendAudio(chat_id=self._chat_id, **json_dict))
 
     @flaky(3, 1)
     @timeout(10)
@@ -221,9 +221,9 @@ class AudioTest(BaseTest, unittest.TestCase):
         del (json_dict['file_id'])
         del (json_dict['duration'])
 
-        self.assertRaises(TypeError,
+        self.assertRaises(
-                          lambda: self._bot.sendAudio(chat_id=self._chat_id,
+            TypeError,
-                                                      **json_dict))
+            lambda: self._bot.sendAudio(chat_id=self._chat_id, **json_dict))
 
 
 if __name__ == '__main__':

tests/test_bot.py

@@ -54,26 +54,22 @@ class BotTest(BaseTest, unittest.TestCase):
     @flaky(3, 1)
     @timeout(10)
     def testSendMessage(self):
-        message = self._bot.sendMessage(
+        message = self._bot.sendMessage(chat_id=self._chat_id,
-            chat_id=self._chat_id,
+                                        text='Моё судно на воздушной подушке полно угрей')
-            text='Моё судно на воздушной подушке полно угрей')
 
         self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.text,
+        self.assertEqual(message.text, u'Моё судно на воздушной подушке полно угрей')
-                         u'Моё судно на воздушной подушке полно угрей')
         self.assertTrue(isinstance(message.date, datetime))
 
     @flaky(3, 1)
     @timeout(10)
     def testSilentSendMessage(self):
-        message = self._bot.sendMessage(
+        message = self._bot.sendMessage(chat_id=self._chat_id,
-            chat_id=self._chat_id,
+                                        text='Моё судно на воздушной подушке полно угрей',
-            text='Моё судно на воздушной подушке полно угрей',
+                                        disable_notification=True)
-            disable_notification=True)
 
         self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.text,
+        self.assertEqual(message.text, u'Моё судно на воздушной подушке полно угрей')
-                         u'Моё судно на воздушной подушке полно угрей')
         self.assertTrue(isinstance(message.date, datetime))
 
     @flaky(3, 1)
@@ -100,10 +96,9 @@ class BotTest(BaseTest, unittest.TestCase):
     @flaky(3, 1)
     @timeout(10)
     def testSendPhoto(self):
-        message = self._bot.sendPhoto(
+        message = self._bot.sendPhoto(photo=open('tests/data/telegram.png', 'rb'),
-            photo=open('tests/data/telegram.png', 'rb'),
+                                      caption='testSendPhoto',
-            caption='testSendPhoto',
+                                      chat_id=self._chat_id)
-            chat_id=self._chat_id)
 
         self.assertTrue(self.is_json(message.to_json()))
         self.assertEqual(message.photo[0].file_size, 1451)
@@ -112,11 +107,10 @@ class BotTest(BaseTest, unittest.TestCase):
     @flaky(3, 1)
     @timeout(10)
     def testSilentSendPhoto(self):
-        message = self._bot.sendPhoto(
+        message = self._bot.sendPhoto(photo=open('tests/data/telegram.png', 'rb'),
-            photo=open('tests/data/telegram.png', 'rb'),
+                                      caption='testSendPhoto',
-            caption='testSendPhoto',
+                                      chat_id=self._chat_id,
-            chat_id=self._chat_id,
+                                      disable_notification=True)
-            disable_notification=True)
 
         self.assertTrue(self.is_json(message.to_json()))
         self.assertEqual(message.photo[0].file_size, 1451)
@@ -130,9 +124,8 @@ class BotTest(BaseTest, unittest.TestCase):
             chat_id=self._chat_id)
 
         self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(
+        self.assertEqual(message.photo[0].file_id,
-            message.photo[0].file_id,
+                         'AgADAQADyKcxGx8j9Qdp6d-gpUsw4Gja1i8ABEVJsVqQk8LfJ3wAAgI')
-            'AgADAQADyKcxGx8j9Qdp6d-gpUsw4Gja1i8ABEVJsVqQk8LfJ3wAAgI')
 
     @flaky(3, 1)
     @timeout(10)
@@ -177,8 +170,7 @@ class BotTest(BaseTest, unittest.TestCase):
     @flaky(3, 1)
     @timeout(10)
     def testSendChatAction(self):
-        self._bot.sendChatAction(action=telegram.ChatAction.TYPING,
+        self._bot.sendChatAction(action=telegram.ChatAction.TYPING, chat_id=self._chat_id)
-                                 chat_id=self._chat_id)
 
     @flaky(3, 1)
     @timeout(10)
@@ -189,8 +181,7 @@ class BotTest(BaseTest, unittest.TestCase):
         self.assertEqual(upf.photos[0][0].file_size, 12421)
 
     def _test_invalid_token(self, token):
-        self.assertRaisesRegexp(telegram.error.InvalidToken, 'Invalid token',
+        self.assertRaisesRegexp(telegram.error.InvalidToken, 'Invalid token', telegram.Bot, token)
-                                telegram.Bot, token)
 
     def testInvalidToken1(self):
         self._test_invalid_token('123')
@@ -202,14 +193,12 @@ class BotTest(BaseTest, unittest.TestCase):
         self._test_invalid_token('12:')
 
     def testUnauthToken(self):
-        with self.assertRaisesRegexp(telegram.error.Unauthorized,
+        with self.assertRaisesRegexp(telegram.error.Unauthorized, 'Unauthorized'):
-                                     'Unauthorized'):
             bot = telegram.Bot('1234:abcd1234')
             bot.getMe()
 
     def testInvalidSrvResp(self):
-        with self.assertRaisesRegexp(telegram.TelegramError,
+        with self.assertRaisesRegexp(telegram.TelegramError, 'Invalid server response'):
-                                     'Invalid server response'):
             # bypass the valid token check
             bot = telegram.Bot.__new__(telegram.Bot)
             bot.base_url = 'https://api.telegram.org/bot{0}'.format('12')

tests/test_chat.py

@@ -34,11 +34,7 @@ class ChatTest(BaseTest, unittest.TestCase):
         self.title = 'ToledosPalaceBot - Group'
         self.type = 'group'
 
-        self.json_dict = {
+        self.json_dict = {'id': self.id, 'title': self.title, 'type': self.type}
-            'id': self.id,
-            'title': self.title,
-            'type': self.type
-        }
 
     def test_group_chat_de_json_empty_json(self):
         group_chat = telegram.Chat.de_json({})

tests/test_choseninlineresult.py

@@ -52,8 +52,7 @@ class ChosenInlineResultTest(BaseTest, unittest.TestCase):
         result = telegram.ChosenInlineResult.de_json(self.json_dict)
 
         self.assertEqual(result.result_id, self.result_id)
-        self.assertDictEqual(result.from_user.to_dict(),
+        self.assertDictEqual(result.from_user.to_dict(), self.from_user.to_dict())
-                             self.from_user.to_dict())
         self.assertEqual(result.query, self.query)
 
     def test_choseninlineresult_to_json(self):

tests/test_document.py

@@ -100,8 +100,7 @@ class DocumentTest(BaseTest, unittest.TestCase):
     @flaky(3, 1)
     @timeout(10)
     def test_send_document_resend(self):
-        message = self._bot.sendDocument(chat_id=self._chat_id,
+        message = self._bot.sendDocument(chat_id=self._chat_id, document=self.document_file_id)
-                                         document=self.document_file_id)
 
         document = message.document
 

tests/test_file.py

@@ -126,8 +126,7 @@ class FileTest(BaseTest, unittest.TestCase):
         del (json_dict['file_path'])
         del (json_dict['file_size'])
 
-        self.assertRaises(telegram.TelegramError,
+        self.assertRaises(telegram.TelegramError, lambda: self._bot.getFile(**json_dict))
-                          lambda: self._bot.getFile(**json_dict))
 
     def test_error_file_without_required_args(self):
         json_dict = self.json_dict

tests/test_filters.py

@@ -35,8 +35,7 @@ class FiltersTest(BaseTest, unittest.TestCase):
     """This object represents Tests for MessageHandler.Filters"""
 
     def setUp(self):
-        self.message = Message(0, User(0, "Testuser"), datetime.now(),
+        self.message = Message(0, User(0, "Testuser"), datetime.now(), Chat(0, 'private'))
-                               Chat(0, 'private'))
         self.update = Update(0, message=self.message)
 
     def test_filters_text(self):

tests/test_forcereply.py

@@ -35,20 +35,15 @@ class ForceReplyTest(BaseTest, unittest.TestCase):
         self.force_reply = True
         self.selective = True
 
-        self.json_dict = {
+        self.json_dict = {'force_reply': self.force_reply, 'selective': self.selective,}
-            'force_reply': self.force_reply,
-            'selective': self.selective,
-        }
 
     def test_send_message_with_force_reply(self):
-        message = self._bot.sendMessage(
+        message = self._bot.sendMessage(self._chat_id,
-            self._chat_id,
+                                        'Моё судно на воздушной подушке полно угрей',
-            'Моё судно на воздушной подушке полно угрей',
+                                        reply_markup=telegram.ForceReply.de_json(self.json_dict))
-            reply_markup=telegram.ForceReply.de_json(self.json_dict))
 
         self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.text,
+        self.assertEqual(message.text, u'Моё судно на воздушной подушке полно угрей')
-                         u'Моё судно на воздушной подушке полно угрей')
 
     def test_force_reply_de_json(self):
         force_reply = telegram.ForceReply.de_json(self.json_dict)

tests/test_inlinekeyboardbutton.py

@@ -49,15 +49,12 @@ class InlineKeyboardButtonTest(BaseTest, unittest.TestCase):
         }
 
     def test_inline_keyboard_button_de_json(self):
-        inline_keyboard_button = telegram.InlineKeyboardButton.de_json(
+        inline_keyboard_button = telegram.InlineKeyboardButton.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertEqual(inline_keyboard_button.text, self.text)
         self.assertEqual(inline_keyboard_button.url, self.url)
-        self.assertEqual(inline_keyboard_button.callback_data,
+        self.assertEqual(inline_keyboard_button.callback_data, self.callback_data)
-                         self.callback_data)
+        self.assertEqual(inline_keyboard_button.switch_inline_query, self.switch_inline_query)
-        self.assertEqual(inline_keyboard_button.switch_inline_query,
-                         self.switch_inline_query)
 
     def test_inline_keyboard_button_de_json_empty(self):
         inline_keyboard_button = telegram.InlineKeyboardButton.de_json(None)
@@ -70,14 +67,12 @@ class InlineKeyboardButtonTest(BaseTest, unittest.TestCase):
         self.assertFalse(inline_keyboard_button)
 
     def test_inline_keyboard_button_to_json(self):
-        inline_keyboard_button = telegram.InlineKeyboardButton.de_json(
+        inline_keyboard_button = telegram.InlineKeyboardButton.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertTrue(self.is_json(inline_keyboard_button.to_json()))
 
     def test_inline_keyboard_button_to_dict(self):
-        inline_keyboard_button = telegram.InlineKeyboardButton.de_json(
+        inline_keyboard_button = telegram.InlineKeyboardButton.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(inline_keyboard_button))
         self.assertDictEqual(self.json_dict, inline_keyboard_button)

tests/test_inlinekeyboardmarkup.py

@@ -32,10 +32,10 @@ class InlineKeyboardMarkupTest(BaseTest, unittest.TestCase):
     """This object represents Tests for Telegram KeyboardButton."""
 
     def setUp(self):
-        self.inline_keyboard = [[telegram.InlineKeyboardButton(
+        self.inline_keyboard = [[telegram.InlineKeyboardButton(text='button1',
-            text='button1',
+                                                               callback_data='data1'),
-            callback_data='data1'), telegram.InlineKeyboardButton(
+                                 telegram.InlineKeyboardButton(text='button2',
-                text='button2', callback_data='data2')]]
+                                                               callback_data='data2')]]
 
         self.json_dict = {
             'inline_keyboard': [[self.inline_keyboard[0][0].to_dict(),
@@ -57,26 +57,21 @@ class InlineKeyboardMarkupTest(BaseTest, unittest.TestCase):
         self.assertFalse(inline_keyboard_markup)
 
     def test_inline_keyboard_markup_de_json(self):
-        inline_keyboard_markup = telegram.InlineKeyboardMarkup.de_json(
+        inline_keyboard_markup = telegram.InlineKeyboardMarkup.de_json(self.json_dict)
-            self.json_dict)
 
-        self.assertTrue(isinstance(inline_keyboard_markup.inline_keyboard,
+        self.assertTrue(isinstance(inline_keyboard_markup.inline_keyboard, list))
-                                   list))
         self.assertTrue(isinstance(inline_keyboard_markup.inline_keyboard[0][
             0], telegram.InlineKeyboardButton))
 
     def test_inline_keyboard_markup_to_json(self):
-        inline_keyboard_markup = telegram.InlineKeyboardMarkup.de_json(
+        inline_keyboard_markup = telegram.InlineKeyboardMarkup.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertTrue(self.is_json(inline_keyboard_markup.to_json()))
 
     def test_inline_keyboard_markup_to_dict(self):
-        inline_keyboard_markup = telegram.InlineKeyboardMarkup.de_json(
+        inline_keyboard_markup = telegram.InlineKeyboardMarkup.de_json(self.json_dict)
-            self.json_dict)
 
-        self.assertTrue(isinstance(inline_keyboard_markup.inline_keyboard,
+        self.assertTrue(isinstance(inline_keyboard_markup.inline_keyboard, list))
-                                   list))
         self.assertTrue(isinstance(inline_keyboard_markup.inline_keyboard[0][
             0], telegram.InlineKeyboardButton))
 

tests/test_inlinequery.py

@@ -57,10 +57,8 @@ class InlineQueryTest(BaseTest, unittest.TestCase):
         inlinequery = telegram.InlineQuery.de_json(self.json_dict)
 
         self.assertEqual(inlinequery.id, self.id)
-        self.assertDictEqual(inlinequery.from_user.to_dict(),
+        self.assertDictEqual(inlinequery.from_user.to_dict(), self.from_user.to_dict())
-                             self.from_user.to_dict())
+        self.assertDictEqual(inlinequery.location.to_dict(), self.location.to_dict())
-        self.assertDictEqual(inlinequery.location.to_dict(),
-                             self.location.to_dict())
         self.assertEqual(inlinequery.query, self.query)
         self.assertEqual(inlinequery.offset, self.offset)
 

tests/test_inlinequeryresultarticle.py

@@ -39,8 +39,7 @@ class InlineQueryResultArticleTest(BaseTest, unittest.TestCase):
         self.id = 'id'
         self.type = 'article'
         self.title = 'title'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -73,8 +72,7 @@ class InlineQueryResultArticleTest(BaseTest, unittest.TestCase):
         self.assertEqual(article.title, self.title)
         self.assertDictEqual(article.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(article.reply_markup.to_dict(),
+        self.assertDictEqual(article.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
         self.assertEqual(article.url, self.url)
         self.assertEqual(article.hide_url, self.hide_url)
         self.assertEqual(article.description, self.description)
@@ -88,8 +86,7 @@ class InlineQueryResultArticleTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(article.to_json()))
 
     def test_article_to_dict(self):
-        article = telegram.InlineQueryResultArticle.de_json(
+        article = telegram.InlineQueryResultArticle.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(article))
         self.assertDictEqual(self.json_dict, article)

tests/test_inlinequeryresultaudio.py

@@ -42,8 +42,7 @@ class InlineQueryResultAudioTest(BaseTest, unittest.TestCase):
         self.title = 'title'
         self.performer = 'performer'
         self.audio_duration = 'audio_duration'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -70,8 +69,7 @@ class InlineQueryResultAudioTest(BaseTest, unittest.TestCase):
         self.assertEqual(audio.audio_duration, self.audio_duration)
         self.assertDictEqual(audio.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(audio.reply_markup.to_dict(),
+        self.assertDictEqual(audio.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_audio_to_json(self):
         audio = telegram.InlineQueryResultAudio.de_json(self.json_dict)
@@ -79,8 +77,7 @@ class InlineQueryResultAudioTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(audio.to_json()))
 
     def test_audio_to_dict(self):
-        audio = telegram.InlineQueryResultAudio.de_json(
+        audio = telegram.InlineQueryResultAudio.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(audio))
         self.assertDictEqual(self.json_dict, audio)

tests/test_inlinequeryresultcachedaudio.py

@@ -40,8 +40,7 @@ class InlineQueryResultCachedAudioTest(BaseTest, unittest.TestCase):
         self.id = 'id'
         self.type = 'audio'
         self.audio_file_id = 'audio file id'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -62,8 +61,7 @@ class InlineQueryResultCachedAudioTest(BaseTest, unittest.TestCase):
         self.assertEqual(audio.audio_file_id, self.audio_file_id)
         self.assertDictEqual(audio.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(audio.reply_markup.to_dict(),
+        self.assertDictEqual(audio.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_audio_to_json(self):
         audio = telegram.InlineQueryResultCachedAudio.de_json(self.json_dict)
@@ -71,8 +69,7 @@ class InlineQueryResultCachedAudioTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(audio.to_json()))
 
     def test_audio_to_dict(self):
-        audio = telegram.InlineQueryResultCachedAudio.de_json(
+        audio = telegram.InlineQueryResultCachedAudio.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(audio))
         self.assertDictEqual(self.json_dict, audio)

tests/test_inlinequeryresultcacheddocument.py

@@ -43,8 +43,7 @@ class InlineQueryResultCachedDocumentTest(BaseTest, unittest.TestCase):
         self.title = 'title'
         self.caption = 'caption'
         self.description = 'description'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -60,8 +59,7 @@ class InlineQueryResultCachedDocumentTest(BaseTest, unittest.TestCase):
         }
 
     def test_document_de_json(self):
-        document = telegram.InlineQueryResultCachedDocument.de_json(
+        document = telegram.InlineQueryResultCachedDocument.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertEqual(document.id, self.id)
         self.assertEqual(document.type, self.type)
@@ -71,18 +69,15 @@ class InlineQueryResultCachedDocumentTest(BaseTest, unittest.TestCase):
         self.assertEqual(document.description, self.description)
         self.assertDictEqual(document.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(document.reply_markup.to_dict(),
+        self.assertDictEqual(document.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_document_to_json(self):
-        document = telegram.InlineQueryResultCachedDocument.de_json(
+        document = telegram.InlineQueryResultCachedDocument.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertTrue(self.is_json(document.to_json()))
 
     def test_document_to_dict(self):
-        document = telegram.InlineQueryResultCachedDocument.de_json(
+        document = telegram.InlineQueryResultCachedDocument.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(document))
         self.assertDictEqual(self.json_dict, document)

tests/test_inlinequeryresultcachedgif.py

@@ -41,8 +41,7 @@ class InlineQueryResultCachedGifTest(BaseTest, unittest.TestCase):
         self.gif_file_id = 'gif file id'
         self.title = 'title'
         self.caption = 'caption'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -67,8 +66,7 @@ class InlineQueryResultCachedGifTest(BaseTest, unittest.TestCase):
         self.assertEqual(gif.caption, self.caption)
         self.assertDictEqual(gif.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(gif.reply_markup.to_dict(),
+        self.assertDictEqual(gif.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_gif_to_json(self):
         gif = telegram.InlineQueryResultCachedGif.de_json(self.json_dict)
@@ -76,8 +74,7 @@ class InlineQueryResultCachedGifTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(gif.to_json()))
 
     def test_gif_to_dict(self):
-        gif = telegram.InlineQueryResultCachedGif.de_json(
+        gif = telegram.InlineQueryResultCachedGif.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(gif))
         self.assertDictEqual(self.json_dict, gif)

tests/test_inlinequeryresultcachedmpeg4gif.py

@@ -42,8 +42,7 @@ class InlineQueryResultCachedMpeg4GifTest(BaseTest, unittest.TestCase):
         self.mpeg4_file_id = 'mpeg4 file id'
         self.title = 'title'
         self.caption = 'caption'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -59,8 +58,7 @@ class InlineQueryResultCachedMpeg4GifTest(BaseTest, unittest.TestCase):
         }
 
     def test_mpeg4_de_json(self):
-        mpeg4 = telegram.InlineQueryResultCachedMpeg4Gif.de_json(
+        mpeg4 = telegram.InlineQueryResultCachedMpeg4Gif.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertEqual(mpeg4.type, self.type)
         self.assertEqual(mpeg4.id, self.id)
@@ -69,18 +67,15 @@ class InlineQueryResultCachedMpeg4GifTest(BaseTest, unittest.TestCase):
         self.assertEqual(mpeg4.caption, self.caption)
         self.assertDictEqual(mpeg4.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(mpeg4.reply_markup.to_dict(),
+        self.assertDictEqual(mpeg4.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_mpeg4_to_json(self):
-        mpeg4 = telegram.InlineQueryResultCachedMpeg4Gif.de_json(
+        mpeg4 = telegram.InlineQueryResultCachedMpeg4Gif.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertTrue(self.is_json(mpeg4.to_json()))
 
     def test_mpeg4_to_dict(self):
-        mpeg4 = telegram.InlineQueryResultCachedMpeg4Gif.de_json(
+        mpeg4 = telegram.InlineQueryResultCachedMpeg4Gif.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(mpeg4))
         self.assertDictEqual(self.json_dict, mpeg4)

tests/test_inlinequeryresultcachedphoto.py

@@ -43,8 +43,7 @@ class InlineQueryResultCachedPhotoTest(BaseTest, unittest.TestCase):
         self.title = 'title'
         self.description = 'description'
         self.caption = 'caption'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -71,8 +70,7 @@ class InlineQueryResultCachedPhotoTest(BaseTest, unittest.TestCase):
         self.assertEqual(photo.caption, self.caption)
         self.assertDictEqual(photo.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(photo.reply_markup.to_dict(),
+        self.assertDictEqual(photo.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_photo_to_json(self):
         photo = telegram.InlineQueryResultCachedPhoto.de_json(self.json_dict)
@@ -80,8 +78,7 @@ class InlineQueryResultCachedPhotoTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(photo.to_json()))
 
     def test_photo_to_dict(self):
-        photo = telegram.InlineQueryResultCachedPhoto.de_json(
+        photo = telegram.InlineQueryResultCachedPhoto.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(photo))
         self.assertDictEqual(self.json_dict, photo)

tests/test_inlinequeryresultcachedsticker.py

@@ -40,8 +40,7 @@ class InlineQueryResultCachedStickerTest(BaseTest, unittest.TestCase):
         self.id = 'id'
         self.type = 'sticker'
         self.sticker_file_id = 'sticker file id'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -55,26 +54,22 @@ class InlineQueryResultCachedStickerTest(BaseTest, unittest.TestCase):
         }
 
     def test_sticker_de_json(self):
-        sticker = telegram.InlineQueryResultCachedSticker.de_json(
+        sticker = telegram.InlineQueryResultCachedSticker.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertEqual(sticker.type, self.type)
         self.assertEqual(sticker.id, self.id)
         self.assertEqual(sticker.sticker_file_id, self.sticker_file_id)
         self.assertDictEqual(sticker.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(sticker.reply_markup.to_dict(),
+        self.assertDictEqual(sticker.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_sticker_to_json(self):
-        sticker = telegram.InlineQueryResultCachedSticker.de_json(
+        sticker = telegram.InlineQueryResultCachedSticker.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertTrue(self.is_json(sticker.to_json()))
 
     def test_sticker_to_dict(self):
-        sticker = telegram.InlineQueryResultCachedSticker.de_json(
+        sticker = telegram.InlineQueryResultCachedSticker.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(sticker))
         self.assertDictEqual(self.json_dict, sticker)

tests/test_inlinequeryresultcachedvideo.py

@@ -43,8 +43,7 @@ class InlineQueryResultCachedVideoTest(BaseTest, unittest.TestCase):
         self.title = 'title'
         self.caption = 'caption'
         self.description = 'description'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -71,8 +70,7 @@ class InlineQueryResultCachedVideoTest(BaseTest, unittest.TestCase):
         self.assertEqual(video.caption, self.caption)
         self.assertDictEqual(video.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(video.reply_markup.to_dict(),
+        self.assertDictEqual(video.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_video_to_json(self):
         video = telegram.InlineQueryResultCachedVideo.de_json(self.json_dict)
@@ -80,8 +78,7 @@ class InlineQueryResultCachedVideoTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(video.to_json()))
 
     def test_video_to_dict(self):
-        video = telegram.InlineQueryResultCachedVideo.de_json(
+        video = telegram.InlineQueryResultCachedVideo.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(video))
         self.assertDictEqual(self.json_dict, video)

tests/test_inlinequeryresultcachedvoice.py

@@ -42,8 +42,7 @@ class InlineQueryResultCachedVoiceTest(BaseTest, unittest.TestCase):
         self.voice_file_id = 'voice file id'
         self.title = 'title'
         self.description = 'description'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -68,8 +67,7 @@ class InlineQueryResultCachedVoiceTest(BaseTest, unittest.TestCase):
         self.assertEqual(voice.description, self.description)
         self.assertDictEqual(voice.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(voice.reply_markup.to_dict(),
+        self.assertDictEqual(voice.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_voice_to_json(self):
         voice = telegram.InlineQueryResultCachedVoice.de_json(self.json_dict)
@@ -77,8 +75,7 @@ class InlineQueryResultCachedVoiceTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(voice.to_json()))
 
     def test_voice_to_dict(self):
-        voice = telegram.InlineQueryResultCachedVoice.de_json(
+        voice = telegram.InlineQueryResultCachedVoice.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(voice))
         self.assertDictEqual(self.json_dict, voice)

tests/test_inlinequeryresultcontact.py

@@ -44,8 +44,7 @@ class InlineQueryResultContactTest(BaseTest, unittest.TestCase):
         self.thumb_url = 'thumb url'
         self.thumb_width = 10
         self.thumb_height = 15
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -75,8 +74,7 @@ class InlineQueryResultContactTest(BaseTest, unittest.TestCase):
         self.assertEqual(contact.thumb_height, self.thumb_height)
         self.assertDictEqual(contact.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(contact.reply_markup.to_dict(),
+        self.assertDictEqual(contact.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_contact_to_json(self):
         contact = telegram.InlineQueryResultContact.de_json(self.json_dict)
@@ -84,8 +82,7 @@ class InlineQueryResultContactTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(contact.to_json()))
 
     def test_contact_to_dict(self):
-        contact = telegram.InlineQueryResultContact.de_json(
+        contact = telegram.InlineQueryResultContact.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(contact))
         self.assertDictEqual(self.json_dict, contact)

tests/test_inlinequeryresultdocument.py

@@ -46,8 +46,7 @@ class InlineQueryResultDocumentTest(BaseTest, unittest.TestCase):
         self.thumb_url = 'thumb url'
         self.thumb_width = 10
         self.thumb_height = 15
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -81,8 +80,7 @@ class InlineQueryResultDocumentTest(BaseTest, unittest.TestCase):
         self.assertEqual(document.thumb_height, self.thumb_height)
         self.assertDictEqual(document.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(document.reply_markup.to_dict(),
+        self.assertDictEqual(document.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_document_to_json(self):
         document = telegram.InlineQueryResultDocument.de_json(self.json_dict)
@@ -90,8 +88,7 @@ class InlineQueryResultDocumentTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(document.to_json()))
 
     def test_document_to_dict(self):
-        document = telegram.InlineQueryResultDocument.de_json(
+        document = telegram.InlineQueryResultDocument.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(document))
         self.assertDictEqual(self.json_dict, document)

tests/test_inlinequeryresultgif.py

@@ -44,8 +44,7 @@ class InlineQueryResultGifTest(BaseTest, unittest.TestCase):
         self.thumb_url = 'thumb url'
         self.title = 'title'
         self.caption = 'caption'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -76,8 +75,7 @@ class InlineQueryResultGifTest(BaseTest, unittest.TestCase):
         self.assertEqual(gif.caption, self.caption)
         self.assertDictEqual(gif.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(gif.reply_markup.to_dict(),
+        self.assertDictEqual(gif.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_gif_to_json(self):
         gif = telegram.InlineQueryResultGif.de_json(self.json_dict)

tests/test_inlinequeryresultlocation.py

@@ -44,8 +44,7 @@ class InlineQueryResultLocationTest(BaseTest, unittest.TestCase):
         self.thumb_url = 'thumb url'
         self.thumb_width = 10
         self.thumb_height = 15
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -75,8 +74,7 @@ class InlineQueryResultLocationTest(BaseTest, unittest.TestCase):
         self.assertEqual(location.thumb_height, self.thumb_height)
         self.assertDictEqual(location.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(location.reply_markup.to_dict(),
+        self.assertDictEqual(location.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_location_to_json(self):
         location = telegram.InlineQueryResultLocation.de_json(self.json_dict)
@@ -84,8 +82,7 @@ class InlineQueryResultLocationTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(location.to_json()))
 
     def test_location_to_dict(self):
-        location = telegram.InlineQueryResultLocation.de_json(
+        location = telegram.InlineQueryResultLocation.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(location))
         self.assertDictEqual(self.json_dict, location)

tests/test_inlinequeryresultmpeg4gif.py

@@ -44,8 +44,7 @@ class InlineQueryResultMpeg4GifTest(BaseTest, unittest.TestCase):
         self.thumb_url = 'thumb url'
         self.title = 'title'
         self.caption = 'caption'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -76,8 +75,7 @@ class InlineQueryResultMpeg4GifTest(BaseTest, unittest.TestCase):
         self.assertEqual(mpeg4.caption, self.caption)
         self.assertDictEqual(mpeg4.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(mpeg4.reply_markup.to_dict(),
+        self.assertDictEqual(mpeg4.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_mpeg4_to_json(self):
         mpeg4 = telegram.InlineQueryResultMpeg4Gif.de_json(self.json_dict)
@@ -85,8 +83,7 @@ class InlineQueryResultMpeg4GifTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(mpeg4.to_json()))
 
     def test_mpeg4_to_dict(self):
-        mpeg4 = telegram.InlineQueryResultMpeg4Gif.de_json(
+        mpeg4 = telegram.InlineQueryResultMpeg4Gif.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(mpeg4))
         self.assertDictEqual(self.json_dict, mpeg4)

tests/test_inlinequeryresultphoto.py

@@ -45,8 +45,7 @@ class InlineQueryResultPhotoTest(BaseTest, unittest.TestCase):
         self.title = 'title'
         self.description = 'description'
         self.caption = 'caption'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -79,8 +78,7 @@ class InlineQueryResultPhotoTest(BaseTest, unittest.TestCase):
         self.assertEqual(photo.caption, self.caption)
         self.assertDictEqual(photo.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(photo.reply_markup.to_dict(),
+        self.assertDictEqual(photo.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_photo_to_json(self):
         photo = telegram.InlineQueryResultPhoto.de_json(self.json_dict)
@@ -88,8 +86,7 @@ class InlineQueryResultPhotoTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(photo.to_json()))
 
     def test_photo_to_dict(self):
-        photo = telegram.InlineQueryResultPhoto.de_json(
+        photo = telegram.InlineQueryResultPhoto.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(photo))
         self.assertDictEqual(self.json_dict, photo)

tests/test_inlinequeryresultvenue.py

@@ -46,8 +46,7 @@ class InlineQueryResultVenueTest(BaseTest, unittest.TestCase):
         self.thumb_url = 'thumb url'
         self.thumb_width = 10
         self.thumb_height = 15
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -81,8 +80,7 @@ class InlineQueryResultVenueTest(BaseTest, unittest.TestCase):
         self.assertEqual(venue.thumb_height, self.thumb_height)
         self.assertDictEqual(venue.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(venue.reply_markup.to_dict(),
+        self.assertDictEqual(venue.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_venue_to_json(self):
         venue = telegram.InlineQueryResultVenue.de_json(self.json_dict)
@@ -90,8 +88,7 @@ class InlineQueryResultVenueTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(venue.to_json()))
 
     def test_venue_to_dict(self):
-        venue = telegram.InlineQueryResultVenue.de_json(
+        venue = telegram.InlineQueryResultVenue.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(venue))
         self.assertDictEqual(self.json_dict, venue)

tests/test_inlinequeryresultvideo.py

@@ -47,8 +47,7 @@ class InlineQueryResultVideoTest(BaseTest, unittest.TestCase):
         self.title = 'title'
         self.caption = 'caption'
         self.description = 'description'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -85,8 +84,7 @@ class InlineQueryResultVideoTest(BaseTest, unittest.TestCase):
         self.assertEqual(video.caption, self.caption)
         self.assertDictEqual(video.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(video.reply_markup.to_dict(),
+        self.assertDictEqual(video.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_video_to_json(self):
         video = telegram.InlineQueryResultVideo.de_json(self.json_dict)
@@ -94,8 +92,7 @@ class InlineQueryResultVideoTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(video.to_json()))
 
     def test_video_to_dict(self):
-        video = telegram.InlineQueryResultVideo.de_json(
+        video = telegram.InlineQueryResultVideo.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(video))
         self.assertDictEqual(self.json_dict, video)

tests/test_inlinequeryresultvoice.py

@@ -41,8 +41,7 @@ class InlineQueryResultVoiceTest(BaseTest, unittest.TestCase):
         self.voice_url = 'voice url'
         self.title = 'title'
         self.voice_duration = 'voice_duration'
-        self.input_message_content = telegram.InputTextMessageContent(
+        self.input_message_content = telegram.InputTextMessageContent('input_message_content')
-            'input_message_content')
         self.reply_markup = telegram.InlineKeyboardMarkup([[
             telegram.InlineKeyboardButton('reply_markup')
         ]])
@@ -67,8 +66,7 @@ class InlineQueryResultVoiceTest(BaseTest, unittest.TestCase):
         self.assertEqual(voice.voice_duration, self.voice_duration)
         self.assertDictEqual(voice.input_message_content.to_dict(),
                              self.input_message_content.to_dict())
-        self.assertDictEqual(voice.reply_markup.to_dict(),
+        self.assertDictEqual(voice.reply_markup.to_dict(), self.reply_markup.to_dict())
-                             self.reply_markup.to_dict())
 
     def test_voice_to_json(self):
         voice = telegram.InlineQueryResultVoice.de_json(self.json_dict)
@@ -76,8 +74,7 @@ class InlineQueryResultVoiceTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(voice.to_json()))
 
     def test_voice_to_dict(self):
-        voice = telegram.InlineQueryResultVoice.de_json(
+        voice = telegram.InlineQueryResultVoice.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(voice))
         self.assertDictEqual(self.json_dict, voice)

tests/test_inputcontactmessagecontent.py

@@ -74,8 +74,7 @@ class InputContactMessageContentTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(icmc.to_json()))
 
     def test_icmc_to_dict(self):
-        icmc = telegram.InputContactMessageContent.de_json(
+        icmc = telegram.InputContactMessageContent.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(icmc))
         self.assertDictEqual(self.json_dict, icmc)

tests/test_inputlocationmessagecontent.py

@@ -39,10 +39,7 @@ class InputLocationMessageContentTest(BaseTest, unittest.TestCase):
         self.latitude = 1.
         self.longitude = 2.
 
-        self.json_dict = {
+        self.json_dict = {'longitude': self.longitude, 'latitude': self.latitude,}
-            'longitude': self.longitude,
-            'latitude': self.latitude,
-        }
 
     def test_ilmc_de_json(self):
         ilmc = telegram.InputLocationMessageContent.de_json(self.json_dict)
@@ -72,8 +69,7 @@ class InputLocationMessageContentTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(ilmc.to_json()))
 
     def test_ilmc_to_dict(self):
-        ilmc = telegram.InputLocationMessageContent.de_json(
+        ilmc = telegram.InputLocationMessageContent.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(ilmc))
         self.assertDictEqual(self.json_dict, ilmc)

tests/test_inputtextmessagecontent.py

@@ -51,8 +51,7 @@ class InputTextMessageContentTest(BaseTest, unittest.TestCase):
 
         self.assertEqual(itmc.parse_mode, self.parse_mode)
         self.assertEqual(itmc.message_text, self.message_text)
-        self.assertEqual(itmc.disable_web_page_preview,
+        self.assertEqual(itmc.disable_web_page_preview, self.disable_web_page_preview)
-                         self.disable_web_page_preview)
 
     def test_itmc_de_json_factory(self):
         itmc = telegram.InputMessageContent.de_json(self.json_dict)
@@ -74,8 +73,7 @@ class InputTextMessageContentTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(itmc.to_json()))
 
     def test_itmc_to_dict(self):
-        itmc = telegram.InputTextMessageContent.de_json(
+        itmc = telegram.InputTextMessageContent.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(itmc))
         self.assertDictEqual(self.json_dict, itmc)

tests/test_inputvenuemessagecontent.py

@@ -82,8 +82,7 @@ class InputVenueMessageContentTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(ivmc.to_json()))
 
     def test_ivmc_to_dict(self):
-        ivmc = telegram.InputVenueMessageContent.de_json(
+        ivmc = telegram.InputVenueMessageContent.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(ivmc))
         self.assertDictEqual(self.json_dict, ivmc)

tests/test_jobqueue.py

@@ -40,8 +40,7 @@ root.setLevel(logging.INFO)
 
 ch = logging.StreamHandler(sys.stdout)
 ch.setLevel(logging.WARN)
-formatter = logging.Formatter(
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 ch.setFormatter(formatter)
 root.addHandler(ch)
 

tests/test_keyboardbutton.py

@@ -51,8 +51,7 @@ class KeyboardButtonTest(BaseTest, unittest.TestCase):
         keyboard_button = telegram.KeyboardButton.de_json(self.json_dict)
 
         self.assertEqual(keyboard_button.text, self.text)
-        self.assertEqual(keyboard_button.request_location,
+        self.assertEqual(keyboard_button.request_location, self.request_location)
-                         self.request_location)
         self.assertEqual(keyboard_button.request_contact, self.request_contact)
 
     def test_keyboard_button_de_json_empty(self):
@@ -71,8 +70,7 @@ class KeyboardButtonTest(BaseTest, unittest.TestCase):
         self.assertTrue(self.is_json(keyboard_button.to_json()))
 
     def test_keyboard_button_to_dict(self):
-        keyboard_button = telegram.KeyboardButton.de_json(
+        keyboard_button = telegram.KeyboardButton.de_json(self.json_dict).to_dict()
-            self.json_dict).to_dict()
 
         self.assertTrue(self.is_dict(keyboard_button))
         self.assertDictEqual(self.json_dict, keyboard_button)

tests/test_location.py

@@ -33,14 +33,10 @@ class LocationTest(BaseTest, unittest.TestCase):
         self.latitude = -23.691288
         self.longitude = -46.788279
 
-        self.json_dict = {
+        self.json_dict = {'latitude': self.latitude, 'longitude': self.longitude}
-            'latitude': self.latitude,
-            'longitude': self.longitude
-        }
 
     def test_send_location_implicit_args(self):
-        message = self._bot.sendLocation(self._chat_id, self.latitude,
+        message = self._bot.sendLocation(self._chat_id, self.latitude, self.longitude)
-                                         self.longitude)
 
         location = message.location
 

tests/test_photo.py

@@ -61,9 +61,7 @@ class PhotoTest(BaseTest, unittest.TestCase):
     @flaky(3, 1)
     @timeout(10)
     def test_sendphotoo_all_args(self):
-        message = self._bot.sendPhoto(self._chat_id,
+        message = self._bot.sendPhoto(self._chat_id, self.photo_file, caption=self.caption)
-                                      self.photo_file,
-                                      caption=self.caption)
 
         thumb, photo = message.photo
 
@@ -128,8 +126,7 @@ class PhotoTest(BaseTest, unittest.TestCase):
     @flaky(3, 1)
     @timeout(10)
     def test_send_photo_resend(self):
-        message = self._bot.sendPhoto(chat_id=self._chat_id,
+        message = self._bot.sendPhoto(chat_id=self._chat_id, photo=self.photo_file_id)
-                                      photo=self.photo_file_id)
 
         thumb, photo = message.photo
 
@@ -175,9 +172,9 @@ class PhotoTest(BaseTest, unittest.TestCase):
         del (json_dict['file_id'])
         json_dict['photo'] = open(os.devnull, 'rb')
 
-        self.assertRaises(telegram.TelegramError,
+        self.assertRaises(
-                          lambda: self._bot.sendPhoto(chat_id=self._chat_id,
+            telegram.TelegramError,
-                                                      **json_dict))
+            lambda: self._bot.sendPhoto(chat_id=self._chat_id, **json_dict))
 
     @flaky(3, 1)
     @timeout(10)
@@ -187,9 +184,9 @@ class PhotoTest(BaseTest, unittest.TestCase):
         del (json_dict['file_id'])
         json_dict['photo'] = ''
 
-        self.assertRaises(telegram.TelegramError,
+        self.assertRaises(
-                          lambda: self._bot.sendPhoto(chat_id=self._chat_id,
+            telegram.TelegramError,
-                                                      **json_dict))
+            lambda: self._bot.sendPhoto(chat_id=self._chat_id, **json_dict))
 
     @flaky(3, 1)
     @timeout(10)
@@ -200,9 +197,9 @@ class PhotoTest(BaseTest, unittest.TestCase):
         del (json_dict['width'])
         del (json_dict['height'])
 
-        self.assertRaises(TypeError,
+        self.assertRaises(
-                          lambda: self._bot.sendPhoto(chat_id=self._chat_id,
+            TypeError,
-                                                      **json_dict))
+            lambda: self._bot.sendPhoto(chat_id=self._chat_id, **json_dict))
 
 
 if __name__ == '__main__':

tests/test_replykeyboardhide.py

@@ -35,10 +35,7 @@ class ReplyKeyboardHideTest(BaseTest, unittest.TestCase):
         self.hide_keyboard = True
         self.selective = True
 
-        self.json_dict = {
+        self.json_dict = {'hide_keyboard': self.hide_keyboard, 'selective': self.selective,}
-            'hide_keyboard': self.hide_keyboard,
-            'selective': self.selective,
-        }
 
     def test_send_message_with_reply_keyboard_hide(self):
         message = self._bot.sendMessage(
@@ -47,12 +44,10 @@ class ReplyKeyboardHideTest(BaseTest, unittest.TestCase):
             reply_markup=telegram.ReplyKeyboardHide.de_json(self.json_dict))
 
         self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.text,
+        self.assertEqual(message.text, u'Моё судно на воздушной подушке полно угрей')
-                         u'Моё судно на воздушной подушке полно угрей')
 
     def test_reply_keyboard_hide_de_json(self):
-        reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(
+        reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertEqual(reply_keyboard_hide.hide_keyboard, self.hide_keyboard)
         self.assertEqual(reply_keyboard_hide.selective, self.selective)
@@ -63,17 +58,14 @@ class ReplyKeyboardHideTest(BaseTest, unittest.TestCase):
         self.assertFalse(reply_keyboard_hide)
 
     def test_reply_keyboard_hide_to_json(self):
-        reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(
+        reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertTrue(self.is_json(reply_keyboard_hide.to_json()))
 
     def test_reply_keyboard_hide_to_dict(self):
-        reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(
+        reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(self.json_dict)
-            self.json_dict)
 
-        self.assertEqual(reply_keyboard_hide['hide_keyboard'],
+        self.assertEqual(reply_keyboard_hide['hide_keyboard'], self.hide_keyboard)
-                         self.hide_keyboard)
         self.assertEqual(reply_keyboard_hide['selective'], self.selective)
 
 

tests/test_replykeyboardmarkup.py

@@ -32,15 +32,13 @@ class ReplyKeyboardMarkupTest(BaseTest, unittest.TestCase):
     """This object represents Tests for Telegram ReplyKeyboardMarkup."""
 
     def setUp(self):
-        self.keyboard = [[telegram.KeyboardButton('button1'),
+        self.keyboard = [[telegram.KeyboardButton('button1'), telegram.KeyboardButton('button2')]]
-                          telegram.KeyboardButton('button2')]]
         self.resize_keyboard = True
         self.one_time_keyboard = True
         self.selective = True
 
         self.json_dict = {
-            'keyboard': [[self.keyboard[0][0].to_dict(),
+            'keyboard': [[self.keyboard[0][0].to_dict(), self.keyboard[0][1].to_dict()]],
-                          self.keyboard[0][1].to_dict()]],
             'resize_keyboard': self.resize_keyboard,
             'one_time_keyboard': self.one_time_keyboard,
             'selective': self.selective,
@@ -53,8 +51,7 @@ class ReplyKeyboardMarkupTest(BaseTest, unittest.TestCase):
             reply_markup=telegram.ReplyKeyboardMarkup.de_json(self.json_dict))
 
         self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.text,
+        self.assertEqual(message.text, u'Моё судно на воздушной подушке полно угрей')
-                         u'Моё судно на воздушной подушке полно угрей')
 
     def test_reply_markup_empty_de_json_empty(self):
         reply_markup_empty = telegram.ReplyKeyboardMarkup.de_json(None)
@@ -62,35 +59,26 @@ class ReplyKeyboardMarkupTest(BaseTest, unittest.TestCase):
         self.assertFalse(reply_markup_empty)
 
     def test_reply_keyboard_markup_de_json(self):
-        reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(
+        reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertTrue(isinstance(reply_keyboard_markup.keyboard, list))
-        self.assertTrue(isinstance(reply_keyboard_markup.keyboard[0][0],
+        self.assertTrue(isinstance(reply_keyboard_markup.keyboard[0][0], telegram.KeyboardButton))
-                                   telegram.KeyboardButton))
+        self.assertEqual(reply_keyboard_markup.resize_keyboard, self.resize_keyboard)
-        self.assertEqual(reply_keyboard_markup.resize_keyboard,
+        self.assertEqual(reply_keyboard_markup.one_time_keyboard, self.one_time_keyboard)
-                         self.resize_keyboard)
-        self.assertEqual(reply_keyboard_markup.one_time_keyboard,
-                         self.one_time_keyboard)
         self.assertEqual(reply_keyboard_markup.selective, self.selective)
 
     def test_reply_keyboard_markup_to_json(self):
-        reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(
+        reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertTrue(self.is_json(reply_keyboard_markup.to_json()))
 
     def test_reply_keyboard_markup_to_dict(self):
-        reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(
+        reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(self.json_dict)
-            self.json_dict)
 
         self.assertTrue(isinstance(reply_keyboard_markup.keyboard, list))
-        self.assertTrue(isinstance(reply_keyboard_markup.keyboard[0][0],
+        self.assertTrue(isinstance(reply_keyboard_markup.keyboard[0][0], telegram.KeyboardButton))
-                                   telegram.KeyboardButton))
+        self.assertEqual(reply_keyboard_markup['resize_keyboard'], self.resize_keyboard)
-        self.assertEqual(reply_keyboard_markup['resize_keyboard'],
+        self.assertEqual(reply_keyboard_markup['one_time_keyboard'], self.one_time_keyboard)
-                         self.resize_keyboard)
-        self.assertEqual(reply_keyboard_markup['one_time_keyboard'],
-                         self.one_time_keyboard)
         self.assertEqual(reply_keyboard_markup['selective'], self.selective)
 
 

tests/test_sticker.py

@@ -62,8 +62,7 @@ class StickerTest(BaseTest, unittest.TestCase):
     @flaky(3, 1)
     @timeout(10)
     def test_send_sticker_resend(self):
-        message = self._bot.sendSticker(chat_id=self._chat_id,
+        message = self._bot.sendSticker(chat_id=self._chat_id, sticker=self.sticker_file_id)
-                                        sticker=self.sticker_file_id)
 
         sticker = message.sticker
 
@@ -110,9 +109,9 @@ class StickerTest(BaseTest, unittest.TestCase):
         del (json_dict['file_id'])
         json_dict['sticker'] = open(os.devnull, 'rb')
 
-        self.assertRaises(telegram.TelegramError,
+        self.assertRaises(
-                          lambda: self._bot.sendSticker(chat_id=self._chat_id,
+            telegram.TelegramError,
-                                                        **json_dict))
+            lambda: self._bot.sendSticker(chat_id=self._chat_id, **json_dict))
 
     @flaky(3, 1)
     @timeout(10)
@@ -122,9 +121,9 @@ class StickerTest(BaseTest, unittest.TestCase):
         del (json_dict['file_id'])
         json_dict['sticker'] = ''
 
-        self.assertRaises(telegram.TelegramError,
+        self.assertRaises(
-                          lambda: self._bot.sendSticker(chat_id=self._chat_id,
+            telegram.TelegramError,
-                                                        **json_dict))
+            lambda: self._bot.sendSticker(chat_id=self._chat_id, **json_dict))
 
     @flaky(3, 1)
     @timeout(10)
@@ -133,9 +132,9 @@ class StickerTest(BaseTest, unittest.TestCase):
 
         del (json_dict['file_id'])
 
-        self.assertRaises(TypeError,
+        self.assertRaises(
-                          lambda: self._bot.sendSticker(chat_id=self._chat_id,
+            TypeError,
-                                                        **json_dict))
+            lambda: self._bot.sendSticker(chat_id=self._chat_id, **json_dict))
 
 
 if __name__ == '__main__':

tests/test_updater.py

@@ -60,8 +60,7 @@ root.setLevel(logging.INFO)
 
 ch = logging.StreamHandler(sys.stdout)
 ch.setLevel(logging.WARN)
-formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s '
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s ' '- %(message)s')
-                              '- %(message)s')
 ch.setFormatter(formatter)
 root.addHandler(ch)
 
@@ -95,8 +94,7 @@ class UpdaterTest(BaseTest, unittest.TestCase):
         self.message_count += 1
 
     def telegramInlineHandlerTest(self, bot, update):
-        self.received_message = (update.inline_query,
+        self.received_message = (update.inline_query, update.chosen_inline_result)
-                                 update.chosen_inline_result)
         self.message_count += 1
 
     def telegramCallbackHandlerTest(self, bot, update):
@@ -161,8 +159,7 @@ class UpdaterTest(BaseTest, unittest.TestCase):
 
     def test_addTelegramMessageHandlerMultipleMessages(self):
         self._setup_updater('Multiple', 100)
-        self.updater.dispatcher.addHandler(MessageHandler(
+        self.updater.dispatcher.addHandler(MessageHandler([], self.telegramHandlerTest))
-            [], self.telegramHandlerTest))
         self.updater.start_polling(0.0)
         sleep(2)
         self.assertEqual(self.received_message, 'Multiple')
@@ -394,9 +391,7 @@ class UpdaterTest(BaseTest, unittest.TestCase):
     def test_runAsyncWithAdditionalArgs(self):
         self._setup_updater('Test6', messages=2)
         d = self.updater.dispatcher
-        handler = MessageHandler([],
+        handler = MessageHandler([], self.asyncAdditionalHandlerTest, pass_update_queue=True)
-                                 self.asyncAdditionalHandlerTest,
-                                 pass_update_queue=True)
         d.addHandler(handler)
         self.updater.start_polling(0.01)
         sleep(1.2)
@@ -442,8 +437,7 @@ class UpdaterTest(BaseTest, unittest.TestCase):
         self.assertEqual(200, response.code)
 
         response = self._send_webhook_msg(
-            ip, port,
+            ip, port, None, 'webookhandler.py',
-            None, 'webookhandler.py',
             get_method=lambda: 'HEAD')
 
         self.assertEqual(b'', response.read())
@@ -494,32 +488,28 @@ class UpdaterTest(BaseTest, unittest.TestCase):
 
     def test_bootstrap_retries_unauth(self):
         retries = 3
-        self._setup_updater('',
+        self._setup_updater(
-                            messages=0,
+            '', messages=0, bootstrap_retries=retries,
-                            bootstrap_retries=retries,
+            bootstrap_err=Unauthorized())
-                            bootstrap_err=Unauthorized())
 
-        self.assertRaises(Unauthorized, self.updater._bootstrap, retries,
+        self.assertRaises(Unauthorized, self.updater._bootstrap, retries, False, 'path', None)
-                          False, 'path', None)
         self.assertEqual(self.updater.bot.bootstrap_attempts, 1)
 
     def test_bootstrap_retries_invalid_token(self):
         retries = 3
-        self._setup_updater('',
+        self._setup_updater(
-                            messages=0,
+            '', messages=0, bootstrap_retries=retries,
-                            bootstrap_retries=retries,
+            bootstrap_err=InvalidToken())
-                            bootstrap_err=InvalidToken())
 
-        self.assertRaises(InvalidToken, self.updater._bootstrap, retries,
+        self.assertRaises(InvalidToken, self.updater._bootstrap, retries, False, 'path', None)
-                          False, 'path', None)
         self.assertEqual(self.updater.bot.bootstrap_attempts, 1)
 
     def test_bootstrap_retries_fail(self):
         retries = 1
         self._setup_updater('', messages=0, bootstrap_retries=retries)
 
-        self.assertRaisesRegexp(TelegramError, 'test', self.updater._bootstrap,
+        self.assertRaisesRegexp(TelegramError, 'test', self.updater._bootstrap, retries - 1, False,
-                                retries - 1, False, 'path', None)
+                                'path', None)
         self.assertEqual(self.updater.bot.bootstrap_attempts, 1)
 
     def test_webhook_invalid_posts(self):
@@ -542,9 +532,7 @@ class UpdaterTest(BaseTest, unittest.TestCase):
             self.assertEqual(ctx.exception.code, 403)
 
             with self.assertRaises(HTTPError) as ctx:
-                self._send_webhook_msg(
+                self._send_webhook_msg(ip, port, 'dummy-payload', content_len=-2)
-                    ip, port, 'dummy-payload',
-                    content_len=-2)
             self.assertEqual(ctx.exception.code, 403)
 
             # TODO: prevent urllib or the underlying from adding content-length
@@ -554,10 +542,7 @@ class UpdaterTest(BaseTest, unittest.TestCase):
             # self.assertEqual(ctx.exception.code, 411)
 
             with self.assertRaises(HTTPError) as ctx:
-                self._send_webhook_msg(ip,
+                self._send_webhook_msg(ip, port, 'dummy-payload', content_len='not-a-number')
-                                       port,
-                                       'dummy-payload',
-                                       content_len='not-a-number')
             self.assertEqual(ctx.exception.code, 403)
 
         finally:
@@ -572,7 +557,7 @@ class UpdaterTest(BaseTest, unittest.TestCase):
                           content_len=-1,
                           content_type='application/json',
                           get_method=None):
-        headers = {'content-type': content_type, }
+        headers = {'content-type': content_type,}
 
         if not payload_str:
             content_len = None
@@ -586,8 +571,7 @@ class UpdaterTest(BaseTest, unittest.TestCase):
         if content_len is not None:
             headers['content-length'] = str(content_len)
 
-        url = 'http://{ip}:{port}/{path}'.format(
+        url = 'http://{ip}:{port}/{path}'.format(ip=ip, port=port, path=url_path)
-            ip=ip, port=port, path=url_path)
 
         req = Request(url, data=payload, headers=headers)
 
@@ -622,6 +606,7 @@ class UpdaterTest(BaseTest, unittest.TestCase):
 
 
 class MockBot(object):
+
     def __init__(self,
                  text,
                  messages=1,

tests/test_user.py

@@ -67,8 +67,7 @@ class UserTest(BaseTest, unittest.TestCase):
         self.assertEqual(user.last_name, self.last_name)
         self.assertEqual(user.type, self.type)
 
-        self.assertEqual(user.name, '%s %s' %
+        self.assertEqual(user.name, '%s %s' % (self.first_name, self.last_name))
-                         (self.first_name, self.last_name))
 
     def test_user_de_json_without_username_and_lastname(self):
         json_dict = self.json_dict

tests/test_video.py

@@ -40,11 +40,10 @@ class VideoTest(BaseTest, unittest.TestCase):
         self.width = 360
         self.height = 640
         self.duration = 5
-        self.thumb = telegram.PhotoSize.de_json(
+        self.thumb = telegram.PhotoSize.de_json({'file_id': 'AAQBABOMsecvAAQqqoY1Pee_MqcyAAIC',
-            {'file_id': 'AAQBABOMsecvAAQqqoY1Pee_MqcyAAIC',
+                                                 'file_size': 645,
-             'file_size': 645,
+                                                 'height': 90,
-             'height': 90,
+                                                 'width': 51})
-             'width': 51})
         self.mime_type = 'video/mp4'
         self.file_size = 326534
 
@@ -64,9 +63,7 @@ class VideoTest(BaseTest, unittest.TestCase):
     @flaky(3, 1)
     @timeout(10)
     def test_send_video_required_args_only(self):
-        message = self._bot.sendVideo(self._chat_id,
+        message = self._bot.sendVideo(self._chat_id, self.video_file, timeout=10)
-                                      self.video_file,
-                                      timeout=10)
 
         video = message.video
 

tests/test_voice.py

@@ -167,9 +167,9 @@ class VoiceTest(BaseTest, unittest.TestCase):
         del (json_dict['file_id'])
         json_dict['voice'] = open(os.devnull, 'rb')
 
-        self.assertRaises(telegram.TelegramError,
+        self.assertRaises(
-                          lambda: self._bot.sendVoice(chat_id=self._chat_id,
+            telegram.TelegramError,
-                                                      **json_dict))
+            lambda: self._bot.sendVoice(chat_id=self._chat_id, **json_dict))
 
     @flaky(3, 1)
     @timeout(10)
@@ -179,9 +179,9 @@ class VoiceTest(BaseTest, unittest.TestCase):
         del (json_dict['file_id'])
         json_dict['voice'] = ''
 
-        self.assertRaises(telegram.TelegramError,
+        self.assertRaises(
-                          lambda: self._bot.sendVoice(chat_id=self._chat_id,
+            telegram.TelegramError,
-                                                      **json_dict))
+            lambda: self._bot.sendVoice(chat_id=self._chat_id, **json_dict))
 
     @flaky(3, 1)
     @timeout(10)
@@ -191,9 +191,9 @@ class VoiceTest(BaseTest, unittest.TestCase):
         del (json_dict['file_id'])
         del (json_dict['duration'])
 
-        self.assertRaises(TypeError,
+        self.assertRaises(
-                          lambda: self._bot.sendVoice(chat_id=self._chat_id,
+            TypeError,
-                                                      **json_dict))
+            lambda: self._bot.sendVoice(chat_id=self._chat_id, **json_dict))
 
 
 if __name__ == '__main__':