OpenSource/python-telegram-bot
OpenSource/python-telegram-bot
1
0
Fork 0
mirror of https://github.com/python-telegram-bot/python-telegram-bot.git synced 2025-01-05 10:24:48 +01:00
Code Issues Projects Releases Packages Wiki Activity

Some code reformat and minor fixes

Browse source
This commit is contained in:
Leandro Toledo 2016-04-23 23:11:25 -03:00
parent 0d6b3a5411
commit ca1fff25f7
27 changed files with 208 additions and 153 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
tests/base.py
View file

@ -19,11 +19,10 @@
"""This module contains a object that represents a Base class for tests""" """This module contains a object that represents a Base class for tests"""
import os
import sys
import signal import signal
import traceback import sys
import os
from nose.tools import make_decorator from nose.tools import make_decorator
sys.path.append('.') sys.path.append('.')
@ -38,7 +37,8 @@ class BaseTest(object):
def __init__(self, *args, **kwargs): def __init__(self, *args, **kwargs):
super(BaseTest, self).__init__(*args, **kwargs) super(BaseTest, self).__init__(*args, **kwargs)
bot = telegram.Bot(os.environ.get('TOKEN', '133505823:AAHZFMHno3mzVLErU5b5jJvaeG--qUyLyG0')) bot = telegram.Bot(os.environ.get('TOKEN',
'133505823:AAHZFMHno3mzVLErU5b5jJvaeG--qUyLyG0'))
chat_id = os.environ.get('CHAT_ID', '12173560') chat_id = os.environ.get('CHAT_ID', '12173560')
self._bot = bot self._bot = bot
@ -62,7 +62,6 @@ class BaseTest(object):
class TestTimedOut(AssertionError): class TestTimedOut(AssertionError):
def __init__(self, time_limit, frame): def __init__(self, time_limit, frame):
super(TestTimedOut, self).__init__('time_limit={0}'.format(time_limit)) super(TestTimedOut, self).__init__('time_limit={0}'.format(time_limit))
self.time_limit = time_limit self.time_limit = time_limit

14
tests/test_audio.py
View file

@ -19,9 +19,10 @@
"""This module contains a object that represents Tests for Telegram Audio""" """This module contains a object that represents Tests for Telegram Audio"""
import os
import unittest
import sys import sys
import unittest
import os
from flaky import flaky from flaky import flaky
sys.path.append('.') sys.path.append('.')
@ -195,7 +196,7 @@ class AudioTest(BaseTest, unittest.TestCase):
def test_error_send_audio_empty_file(self): def test_error_send_audio_empty_file(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['audio'] = open(os.devnull, 'rb') json_dict['audio'] = open(os.devnull, 'rb')
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -207,7 +208,7 @@ class AudioTest(BaseTest, unittest.TestCase):
def test_error_send_audio_empty_file_id(self): def test_error_send_audio_empty_file_id(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['audio'] = '' json_dict['audio'] = ''
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -219,12 +220,13 @@ class AudioTest(BaseTest, unittest.TestCase):
def test_error_audio_without_required_args(self): def test_error_audio_without_required_args(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
del(json_dict['duration']) del (json_dict['duration'])
self.assertRaises(TypeError, self.assertRaises(TypeError,
lambda: self._bot.sendAudio(chat_id=self._chat_id, lambda: self._bot.sendAudio(chat_id=self._chat_id,
**json_dict)) **json_dict))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

42
tests/test_bot.py
View file

@ -20,10 +20,10 @@
"""This module contains a object that represents Tests for Telegram Bot""" """This module contains a object that represents Tests for Telegram Bot"""
import io
import os
from datetime import datetime
import sys import sys
from datetime import datetime
import io
from flaky import flaky from flaky import flaky
if sys.version_info[0:2] == (2, 6): if sys.version_info[0:2] == (2, 6):
@ -59,7 +59,8 @@ class BotTest(BaseTest, unittest.TestCase):
text='Моё судно на воздушной подушке полно угрей') text='Моё судно на воздушной подушке полно угрей')
self.assertTrue(self.is_json(message.to_json())) self.assertTrue(self.is_json(message.to_json()))
self.assertEqual(message.text, u'Моё судно на воздушной подушке полно угрей') self.assertEqual(message.text,
u'Моё судно на воздушной подушке полно угрей')
self.assertTrue(isinstance(message.date, datetime)) self.assertTrue(isinstance(message.date, datetime))
@flaky(3, 1) @flaky(3, 1)
@ -70,7 +71,8 @@ class BotTest(BaseTest, unittest.TestCase):
disable_notification=True) disable_notification=True)
self.assertTrue(self.is_json(message.to_json())) self.assertTrue(self.is_json(message.to_json()))
self.assertEqual(message.text, u'Моё судно на воздушной подушке полно угрей') self.assertEqual(message.text,
u'Моё судно на воздушной подушке полно угрей')
self.assertTrue(isinstance(message.date, datetime)) self.assertTrue(isinstance(message.date, datetime))
@flaky(3, 1) @flaky(3, 1)
@ -97,7 +99,8 @@ class BotTest(BaseTest, unittest.TestCase):
@flaky(3, 1) @flaky(3, 1)
@timeout(10) @timeout(10)
def testSendPhoto(self): def testSendPhoto(self):
message = self._bot.sendPhoto(photo=open('tests/data/telegram.png', 'rb'), message = self._bot.sendPhoto(
photo=open('tests/data/telegram.png', 'rb'),
caption='testSendPhoto', caption='testSendPhoto',
chat_id=self._chat_id) chat_id=self._chat_id)
@ -108,7 +111,8 @@ class BotTest(BaseTest, unittest.TestCase):
@flaky(3, 1) @flaky(3, 1)
@timeout(10) @timeout(10)
def testSilentSendPhoto(self): def testSilentSendPhoto(self):
message = self._bot.sendPhoto(photo=open('tests/data/telegram.png', 'rb'), message = self._bot.sendPhoto(
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)
@ -120,16 +124,19 @@ class BotTest(BaseTest, unittest.TestCase):
@flaky(3, 1) @flaky(3, 1)
@timeout(10) @timeout(10)
def testResendPhoto(self): def testResendPhoto(self):
message = self._bot.sendPhoto(photo='AgADAQADyKcxGx8j9Qdp6d-gpUsw4Gja1i8ABEVJsVqQk8LfJ3wAAgI', message = self._bot.sendPhoto(
photo='AgADAQADyKcxGx8j9Qdp6d-gpUsw4Gja1i8ABEVJsVqQk8LfJ3wAAgI',
chat_id=self._chat_id) chat_id=self._chat_id)
self.assertTrue(self.is_json(message.to_json())) self.assertTrue(self.is_json(message.to_json()))
self.assertEqual(message.photo[0].file_id, 'AgADAQADyKcxGx8j9Qdp6d-gpUsw4Gja1i8ABEVJsVqQk8LfJ3wAAgI') self.assertEqual(message.photo[0].file_id,
'AgADAQADyKcxGx8j9Qdp6d-gpUsw4Gja1i8ABEVJsVqQk8LfJ3wAAgI')
@flaky(3, 1) @flaky(3, 1)
@timeout(10) @timeout(10)
def testSendJPGURLPhoto(self): def testSendJPGURLPhoto(self):
message = self._bot.sendPhoto(photo='http://dummyimage.com/600x400/000/fff.jpg&text=telegram', message = self._bot.sendPhoto(
photo='http://dummyimage.com/600x400/000/fff.jpg&text=telegram',
chat_id=self._chat_id) chat_id=self._chat_id)
self.assertTrue(self.is_json(message.to_json())) self.assertTrue(self.is_json(message.to_json()))
@ -138,7 +145,8 @@ class BotTest(BaseTest, unittest.TestCase):
@flaky(3, 1) @flaky(3, 1)
@timeout(10) @timeout(10)
def testSendPNGURLPhoto(self): def testSendPNGURLPhoto(self):
message = self._bot.sendPhoto(photo='http://dummyimage.com/600x400/000/fff.png&text=telegram', message = self._bot.sendPhoto(
photo='http://dummyimage.com/600x400/000/fff.png&text=telegram',
chat_id=self._chat_id) chat_id=self._chat_id)
self.assertTrue(self.is_json(message.to_json())) self.assertTrue(self.is_json(message.to_json()))
@ -147,7 +155,8 @@ class BotTest(BaseTest, unittest.TestCase):
@flaky(3, 1) @flaky(3, 1)
@timeout(10) @timeout(10)
def testSendGIFURLPhoto(self): def testSendGIFURLPhoto(self):
message = self._bot.sendPhoto(photo='http://dummyimage.com/600x400/000/fff.gif&text=telegram', message = self._bot.sendPhoto(
photo='http://dummyimage.com/600x400/000/fff.gif&text=telegram',
chat_id=self._chat_id) chat_id=self._chat_id)
self.assertTrue(self.is_json(message.to_json())) self.assertTrue(self.is_json(message.to_json()))
@ -179,7 +188,8 @@ class BotTest(BaseTest, unittest.TestCase):
self.assertEqual(upf.photos[0][0].file_size, 12421) self.assertEqual(upf.photos[0][0].file_size, 12421)
def _test_invalid_token(self, token): def _test_invalid_token(self, token):
self.assertRaisesRegexp(telegram.error.InvalidToken, 'Invalid token', telegram.Bot, token) self.assertRaisesRegexp(telegram.error.InvalidToken, 'Invalid token',
telegram.Bot, token)
def testInvalidToken1(self): def testInvalidToken1(self):
self._test_invalid_token('123') self._test_invalid_token('123')
@ -191,12 +201,14 @@ class BotTest(BaseTest, unittest.TestCase):
self._test_invalid_token('12:') self._test_invalid_token('12:')
def testUnauthToken(self): def testUnauthToken(self):
with self.assertRaisesRegexp(telegram.error.Unauthorized, 'Unauthorized'): with self.assertRaisesRegexp(telegram.error.Unauthorized,
'Unauthorized'):
bot = telegram.Bot('1234:abcd1234') bot = telegram.Bot('1234:abcd1234')
bot.getMe() bot.getMe()
def testInvalidSrvResp(self): def testInvalidSrvResp(self):
with self.assertRaisesRegexp(telegram.TelegramError, 'Invalid server response'): with self.assertRaisesRegexp(telegram.TelegramError,
'Invalid server response'):
# bypass the valid token check # bypass the valid token check
bot = telegram.Bot.__new__(telegram.Bot) bot = telegram.Bot.__new__(telegram.Bot)
bot.base_url = 'https://api.telegram.org/bot{0}'.format('12') bot.base_url = 'https://api.telegram.org/bot{0}'.format('12')

6
tests/test_botan.py
View file

@ -2,9 +2,10 @@
"""This module contains a object that represents Tests for Botan analytics integration""" """This module contains a object that represents Tests for Botan analytics integration"""
import os
import unittest
import sys import sys
import unittest
import os
from flaky import flaky from flaky import flaky
sys.path.append('.') sys.path.append('.')
@ -56,5 +57,6 @@ class BotanTest(BaseTest, unittest.TestCase):
result = botan.track(message, 'named event') result = botan.track(message, 'named event')
self.assertFalse(result) self.assertFalse(result)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

7
tests/test_chat.py
View file

@ -1,4 +1,4 @@
#!/usr/bin/env python # !/usr/bin/env python
# #
# A library that provides a Python interface to the Telegram Bot API # A library that provides a Python interface to the Telegram Bot API
# Copyright (C) 2015-2016 # Copyright (C) 2015-2016
@ -19,9 +19,9 @@
"""This module contains a object that represents Tests for Telegram Chat""" """This module contains a object that represents Tests for Telegram Chat"""
import os
import unittest
import sys import sys
import unittest
sys.path.append('.') sys.path.append('.')
import telegram import telegram
@ -67,5 +67,6 @@ class ChatTest(BaseTest, unittest.TestCase):
self.assertEqual(group_chat['title'], self.title) self.assertEqual(group_chat['title'], self.title)
self.assertEqual(group_chat['type'], self.type) self.assertEqual(group_chat['type'], self.type)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

1
tests/test_choseninlineresult.py
View file

@ -37,7 +37,6 @@ class ChosenInlineResultTest(BaseTest, unittest.TestCase):
"""This object represents Tests for Telegram ChosenInlineResult.""" """This object represents Tests for Telegram ChosenInlineResult."""
def setUp(self): def setUp(self):
user = telegram.User(1, 'First name') user = telegram.User(1, 'First name')
self.result_id = 'result id' self.result_id = 'result id'

7
tests/test_contact.py
View file

@ -1,4 +1,4 @@
#!/usr/bin/env python # !/usr/bin/env python
# #
# A library that provides a Python interface to the Telegram Bot API # A library that provides a Python interface to the Telegram Bot API
# Copyright (C) 2015-2016 # Copyright (C) 2015-2016
@ -19,9 +19,9 @@
"""This module contains a object that represents Tests for Telegram Contact""" """This module contains a object that represents Tests for Telegram Contact"""
import os
import unittest
import sys import sys
import unittest
sys.path.append('.') sys.path.append('.')
import telegram import telegram
@ -66,5 +66,6 @@ class ContactTest(BaseTest, unittest.TestCase):
self.assertEqual(contact['last_name'], self.last_name) self.assertEqual(contact['last_name'], self.last_name)
self.assertEqual(contact['user_id'], self.user_id) self.assertEqual(contact['user_id'], self.user_id)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

12
tests/test_document.py
View file

@ -19,9 +19,10 @@
"""This module contains a object that represents Tests for Telegram Document""" """This module contains a object that represents Tests for Telegram Document"""
import os
import unittest
import sys import sys
import unittest
import os
from flaky import flaky from flaky import flaky
sys.path.append('.') sys.path.append('.')
@ -141,7 +142,7 @@ class DocumentTest(BaseTest, unittest.TestCase):
def test_error_send_document_empty_file(self): def test_error_send_document_empty_file(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['document'] = open(os.devnull, 'rb') json_dict['document'] = open(os.devnull, 'rb')
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -153,7 +154,7 @@ class DocumentTest(BaseTest, unittest.TestCase):
def test_error_send_document_empty_file_id(self): def test_error_send_document_empty_file_id(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['document'] = '' json_dict['document'] = ''
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -165,11 +166,12 @@ class DocumentTest(BaseTest, unittest.TestCase):
def test_error_document_without_required_args(self): def test_error_document_without_required_args(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
self.assertRaises(TypeError, self.assertRaises(TypeError,
lambda: self._bot.sendDocument(chat_id=self._chat_id, lambda: self._bot.sendDocument(chat_id=self._chat_id,
**json_dict)) **json_dict))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

5
tests/test_emoji.py
View file

@ -19,12 +19,11 @@
"""This module contains a object that represents Tests for Telegram Emoji""" """This module contains a object that represents Tests for Telegram Emoji"""
import os
import unittest
import sys import sys
import unittest
sys.path.append('.') sys.path.append('.')
import telegram
from telegram.emoji import Emoji from telegram.emoji import Emoji
from tests.base import BaseTest from tests.base import BaseTest

18
tests/test_file.py
View file

@ -19,9 +19,11 @@
"""This module contains a object that represents Tests for Telegram File""" """This module contains a object that represents Tests for Telegram File"""
import os
import unittest
import sys import sys
import unittest
import os
sys.path.append('.') sys.path.append('.')
import telegram import telegram
@ -38,7 +40,6 @@ class FileTest(BaseTest, unittest.TestCase):
self.video_file_id = 'BAADAQADXwADHyP1BwJFTcmY2RYCAg' self.video_file_id = 'BAADAQADXwADHyP1BwJFTcmY2RYCAg'
self.voice_file_id = 'AwADAQADTgADHyP1B_mbw34svXPHAg' self.voice_file_id = 'AwADAQADTgADHyP1B_mbw34svXPHAg'
self.json_dict = { self.json_dict = {
'file_id': self.audio_file_id, 'file_id': self.audio_file_id,
'file_path': 'https://api.telegram.org/file/bot133505823:AAHZFMHno3mzVLErU5b5jJvaeG--qUyLyG0/document/file_3', 'file_path': 'https://api.telegram.org/file/bot133505823:AAHZFMHno3mzVLErU5b5jJvaeG--qUyLyG0/document/file_3',
@ -123,8 +124,8 @@ class FileTest(BaseTest, unittest.TestCase):
def test_error_get_empty_file_id(self): def test_error_get_empty_file_id(self):
json_dict = self.json_dict json_dict = self.json_dict
json_dict['file_id'] = '' json_dict['file_id'] = ''
del(json_dict['file_path']) del (json_dict['file_path'])
del(json_dict['file_size']) 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))
@ -132,12 +133,13 @@ class FileTest(BaseTest, unittest.TestCase):
def test_error_file_without_required_args(self): def test_error_file_without_required_args(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
del(json_dict['file_path']) del (json_dict['file_path'])
del(json_dict['file_size']) del (json_dict['file_size'])
self.assertRaises(TypeError, self.assertRaises(TypeError,
lambda: self._bot.getFile(**json_dict)) lambda: self._bot.getFile(**json_dict))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

10
tests/test_forcereply.py
View file

@ -20,8 +20,9 @@
"""This module contains a object that represents Tests for Telegram ForceReply""" """This module contains a object that represents Tests for Telegram ForceReply"""
import unittest
import sys import sys
import unittest
sys.path.append('.') sys.path.append('.')
import telegram import telegram
@ -43,10 +44,12 @@ class ForceReplyTest(BaseTest, unittest.TestCase):
def test_send_message_with_force_reply(self): def test_send_message_with_force_reply(self):
message = self._bot.sendMessage(self._chat_id, message = self._bot.sendMessage(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.assertTrue(self.is_json(message.to_json()))
self.assertEqual(message.text, u'Моё судно на воздушной подушке полно угрей') self.assertEqual(message.text,
u'Моё судно на воздушной подушке полно угрей')
def test_force_reply_de_json(self): def test_force_reply_de_json(self):
force_reply = telegram.ForceReply.de_json(self.json_dict) force_reply = telegram.ForceReply.de_json(self.json_dict)
@ -65,5 +68,6 @@ class ForceReplyTest(BaseTest, unittest.TestCase):
self.assertEqual(force_reply['force_reply'], self.force_reply) self.assertEqual(force_reply['force_reply'], self.force_reply)
self.assertEqual(force_reply['selective'], self.selective) self.assertEqual(force_reply['selective'], self.selective)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

1
tests/test_inlinequery.py
View file

@ -37,7 +37,6 @@ class InlineQueryTest(BaseTest, unittest.TestCase):
"""This object represents Tests for Telegram InlineQuery.""" """This object represents Tests for Telegram InlineQuery."""
def setUp(self): def setUp(self):
user = telegram.User(1, 'First name') user = telegram.User(1, 'First name')
self.id = 'id' self.id = 'id'

1
tests/test_inlinequeryresultcacheddocument.py
View file

@ -59,7 +59,6 @@ class InlineQueryResultCachedDocumentTest(BaseTest, unittest.TestCase):
'reply_markup': self.reply_markup.to_dict(), 'reply_markup': self.reply_markup.to_dict(),
} }
def test_document_de_json(self): def test_document_de_json(self):
document = telegram.InlineQueryResultCachedDocument.de_json( document = telegram.InlineQueryResultCachedDocument.de_json(
self.json_dict) self.json_dict)

1
tests/test_inlinequeryresultdocument.py
View file

@ -66,7 +66,6 @@ class InlineQueryResultDocumentTest(BaseTest, unittest.TestCase):
'reply_markup': self.reply_markup.to_dict(), 'reply_markup': self.reply_markup.to_dict(),
} }
def test_document_de_json(self): def test_document_de_json(self):
document = telegram.InlineQueryResultDocument.de_json(self.json_dict) document = telegram.InlineQueryResultDocument.de_json(self.json_dict)

2
tests/test_inlinequeryresultvenue.py
View file

@ -42,7 +42,7 @@ class InlineQueryResultVenueTest(BaseTest, unittest.TestCase):
self.latitude = 'latitude' self.latitude = 'latitude'
self.longitude = 'longitude' self.longitude = 'longitude'
self.title = 'title' self.title = 'title'
self._address = 'address' self._address = 'address' # nose binds self.address for testing
self.foursquare_id = 'foursquare id' self.foursquare_id = 'foursquare id'
self.thumb_url = 'thumb url' self.thumb_url = 'thumb url'
self.thumb_width = 10 self.thumb_width = 10

4
tests/test_jobqueue.py
View file

@ -46,7 +46,8 @@ root.setLevel(logging.INFO)
ch = logging.StreamHandler(sys.stdout) ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.WARN) ch.setLevel(logging.WARN)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter) ch.setFormatter(formatter)
root.addHandler(ch) root.addHandler(ch)
@ -111,5 +112,6 @@ class JobQueueTest(BaseTest, unittest.TestCase):
sleep(2) sleep(2)
self.assertEqual(1, self.result) self.assertEqual(1, self.result)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

9
tests/test_location.py
View file

@ -19,9 +19,9 @@
"""This module contains a object that represents Tests for Telegram Location""" """This module contains a object that represents Tests for Telegram Location"""
import os
import unittest
import sys import sys
import unittest
sys.path.append('.') sys.path.append('.')
import telegram import telegram
@ -90,12 +90,13 @@ class LocationTest(BaseTest, unittest.TestCase):
def test_error_location_without_required_args(self): def test_error_location_without_required_args(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['latitude']) del (json_dict['latitude'])
del(json_dict['longitude']) del (json_dict['longitude'])
self.assertRaises(TypeError, self.assertRaises(TypeError,
lambda: self._bot.sendLocation(chat_id=self._chat_id, lambda: self._bot.sendLocation(chat_id=self._chat_id,
**json_dict)) **json_dict))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

5
tests/test_parsemode.py
View file

@ -20,13 +20,15 @@
"""This module contains a object that represents Tests for Telegram ParseMode""" """This module contains a object that represents Tests for Telegram ParseMode"""
import unittest
import sys import sys
import unittest
sys.path.append('.') sys.path.append('.')
import telegram import telegram
from tests.base import BaseTest from tests.base import BaseTest
class ParseMode(BaseTest, unittest.TestCase): class ParseMode(BaseTest, unittest.TestCase):
"""This object represents Tests for Telegram ParseMode.""" """This object represents Tests for Telegram ParseMode."""
@ -51,5 +53,6 @@ class ParseMode(BaseTest, unittest.TestCase):
self.assertTrue(self.is_json(message.to_json())) self.assertTrue(self.is_json(message.to_json()))
self.assertEqual(message.text, self.formatted_text_formatted) self.assertEqual(message.text, self.formatted_text_formatted)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

16
tests/test_photo.py
View file

@ -19,9 +19,10 @@
"""This module contains a object that represents Tests for Telegram Photo""" """This module contains a object that represents Tests for Telegram Photo"""
import os
import unittest
import sys import sys
import unittest
import os
from flaky import flaky from flaky import flaky
sys.path.append('.') sys.path.append('.')
@ -171,7 +172,7 @@ class PhotoTest(BaseTest, unittest.TestCase):
def test_error_send_photo_empty_file(self): def test_error_send_photo_empty_file(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['photo'] = open(os.devnull, 'rb') json_dict['photo'] = open(os.devnull, 'rb')
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -183,7 +184,7 @@ class PhotoTest(BaseTest, unittest.TestCase):
def test_error_send_photo_empty_file_id(self): def test_error_send_photo_empty_file_id(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['photo'] = '' json_dict['photo'] = ''
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -195,13 +196,14 @@ class PhotoTest(BaseTest, unittest.TestCase):
def test_error_photo_without_required_args(self): def test_error_photo_without_required_args(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
del(json_dict['width']) del (json_dict['width'])
del(json_dict['height']) del (json_dict['height'])
self.assertRaises(TypeError, self.assertRaises(TypeError,
lambda: self._bot.sendPhoto(chat_id=self._chat_id, lambda: self._bot.sendPhoto(chat_id=self._chat_id,
**json_dict)) **json_dict))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

22
tests/test_replykeyboardhide.py
View file

@ -20,8 +20,9 @@
"""This module contains a object that represents Tests for Telegram ReplyKeyboardHide""" """This module contains a object that represents Tests for Telegram ReplyKeyboardHide"""
import unittest
import sys import sys
import unittest
sys.path.append('.') sys.path.append('.')
import telegram import telegram
@ -43,27 +44,34 @@ class ReplyKeyboardHideTest(BaseTest, unittest.TestCase):
def test_send_message_with_reply_keyboard_hide(self): def test_send_message_with_reply_keyboard_hide(self):
message = self._bot.sendMessage(self._chat_id, message = self._bot.sendMessage(self._chat_id,
'Моё судно на воздушной подушке полно угрей', 'Моё судно на воздушной подушке полно угрей',
reply_markup=telegram.ReplyKeyboardHide.de_json(self.json_dict)) reply_markup=telegram.ReplyKeyboardHide.de_json(
self.json_dict))
self.assertTrue(self.is_json(message.to_json())) self.assertTrue(self.is_json(message.to_json()))
self.assertEqual(message.text, u'Моё судно на воздушной подушке полно угрей') self.assertEqual(message.text,
u'Моё судно на воздушной подушке полно угрей')
def test_reply_keyboard_hide_de_json(self): def test_reply_keyboard_hide_de_json(self):
reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(self.json_dict) reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(
self.json_dict)
self.assertEqual(reply_keyboard_hide.hide_keyboard, self.hide_keyboard) self.assertEqual(reply_keyboard_hide.hide_keyboard, self.hide_keyboard)
self.assertEqual(reply_keyboard_hide.selective, self.selective) self.assertEqual(reply_keyboard_hide.selective, self.selective)
def test_reply_keyboard_hide_to_json(self): def test_reply_keyboard_hide_to_json(self):
reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(self.json_dict) reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(
self.json_dict)
self.assertTrue(self.is_json(reply_keyboard_hide.to_json())) self.assertTrue(self.is_json(reply_keyboard_hide.to_json()))
def test_reply_keyboard_hide_to_dict(self): def test_reply_keyboard_hide_to_dict(self):
reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(self.json_dict) reply_keyboard_hide = telegram.ReplyKeyboardHide.de_json(
self.json_dict)
self.assertEqual(reply_keyboard_hide['hide_keyboard'], self.hide_keyboard) self.assertEqual(reply_keyboard_hide['hide_keyboard'],
self.hide_keyboard)
self.assertEqual(reply_keyboard_hide['selective'], self.selective) self.assertEqual(reply_keyboard_hide['selective'], self.selective)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

31
tests/test_replykeyboardmarkup.py
View file

@ -20,8 +20,9 @@
"""This module contains a object that represents Tests for Telegram ReplyKeyboardMarkup""" """This module contains a object that represents Tests for Telegram ReplyKeyboardMarkup"""
import unittest
import sys import sys
import unittest
sys.path.append('.') sys.path.append('.')
import telegram import telegram
@ -49,35 +50,45 @@ class ReplyKeyboardMarkupTest(BaseTest, unittest.TestCase):
def test_send_message_with_reply_keyboard_markup(self): def test_send_message_with_reply_keyboard_markup(self):
message = self._bot.sendMessage(self._chat_id, message = self._bot.sendMessage(self._chat_id,
'Моё судно на воздушной подушке полно угрей', 'Моё судно на воздушной подушке полно угрей',
reply_markup=telegram.ReplyKeyboardMarkup.de_json(self.json_dict)) reply_markup=telegram.ReplyKeyboardMarkup.de_json(
self.json_dict))
self.assertTrue(self.is_json(message.to_json())) self.assertTrue(self.is_json(message.to_json()))
self.assertEqual(message.text, u'Моё судно на воздушной подушке полно угрей') self.assertEqual(message.text,
u'Моё судно на воздушной подушке полно угрей')
def test_reply_keyboard_markup_de_json(self): def test_reply_keyboard_markup_de_json(self):
reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(self.json_dict) reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(
self.json_dict)
self.assertTrue(isinstance(reply_keyboard_markup.keyboard, list)) 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) self.assertEqual(reply_keyboard_markup.selective, self.selective)
def test_reply_keyboard_markup_to_json(self): def test_reply_keyboard_markup_to_json(self):
reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(self.json_dict) reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(
self.json_dict)
self.assertTrue(self.is_json(reply_keyboard_markup.to_json())) self.assertTrue(self.is_json(reply_keyboard_markup.to_json()))
def test_reply_keyboard_markup_to_dict(self): def test_reply_keyboard_markup_to_dict(self):
reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(self.json_dict) reply_keyboard_markup = telegram.ReplyKeyboardMarkup.de_json(
self.json_dict)
self.assertTrue(isinstance(reply_keyboard_markup.keyboard, list)) 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) self.assertEqual(reply_keyboard_markup['selective'], self.selective)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

12
tests/test_sticker.py
View file

@ -19,9 +19,10 @@
"""This module contains a object that represents Tests for Telegram Sticker""" """This module contains a object that represents Tests for Telegram Sticker"""
import os
import unittest
import sys import sys
import unittest
import os
from flaky import flaky from flaky import flaky
sys.path.append('.') sys.path.append('.')
@ -98,7 +99,7 @@ class StickerTest(BaseTest, unittest.TestCase):
def test_error_send_sticker_empty_file(self): def test_error_send_sticker_empty_file(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['sticker'] = open(os.devnull, 'rb') json_dict['sticker'] = open(os.devnull, 'rb')
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -110,7 +111,7 @@ class StickerTest(BaseTest, unittest.TestCase):
def test_error_send_sticker_empty_file_id(self): def test_error_send_sticker_empty_file_id(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['sticker'] = '' json_dict['sticker'] = ''
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -122,11 +123,12 @@ class StickerTest(BaseTest, unittest.TestCase):
def test_error_sticker_without_required_args(self): def test_error_sticker_without_required_args(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
self.assertRaises(TypeError, self.assertRaises(TypeError,
lambda: self._bot.sendSticker(chat_id=self._chat_id, lambda: self._bot.sendSticker(chat_id=self._chat_id,
**json_dict)) **json_dict))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

7
tests/test_update.py
View file

@ -1,4 +1,4 @@
#!/usr/bin/env python # !/usr/bin/env python
# #
# A library that provides a Python interface to the Telegram Bot API # A library that provides a Python interface to the Telegram Bot API
# Copyright (C) 2015-2016 # Copyright (C) 2015-2016
@ -19,9 +19,9 @@
"""This module contains a object that represents Tests for Telegram Update""" """This module contains a object that represents Tests for Telegram Update"""
import os
import unittest
import sys import sys
import unittest
sys.path.append('.') sys.path.append('.')
import telegram import telegram
@ -69,5 +69,6 @@ class UpdateTest(BaseTest, unittest.TestCase):
self.assertEqual(update['update_id'], self.update_id) self.assertEqual(update['update_id'], self.update_id)
self.assertTrue(isinstance(update['message'], telegram.Message)) self.assertTrue(isinstance(update['message'], telegram.Message))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

14
tests/test_updater.py
View file

@ -23,14 +23,15 @@ This module contains a object that represents Tests for Updater, Dispatcher,
WebhookServer and WebhookHandler WebhookServer and WebhookHandler
""" """
import logging import logging
import sys
import re
import os
import signal import signal
from random import randrange import sys
from time import sleep
from datetime import datetime from datetime import datetime
from time import sleep
import os
import re
from future.builtins import bytes from future.builtins import bytes
from random import randrange
if sys.version_info[0:2] == (2, 6): if sys.version_info[0:2] == (2, 6):
import unittest2 as unittest import unittest2 as unittest
@ -570,7 +571,6 @@ class UpdaterTest(BaseTest, unittest.TestCase):
req = Request(url, data=payload, headers=headers) req = Request(url, data=payload, headers=headers)
if get_method is not None: if get_method is not None:
req.get_method = get_method req.get_method = get_method
@ -602,7 +602,6 @@ class UpdaterTest(BaseTest, unittest.TestCase):
class MockBot(object): class MockBot(object):
def __init__(self, text, messages=1, raise_error=False, def __init__(self, text, messages=1, raise_error=False,
bootstrap_retries=None, bootstrap_err=TelegramError('test')): bootstrap_retries=None, bootstrap_err=TelegramError('test')):
self.text = text self.text = text
@ -646,5 +645,6 @@ class MockBot(object):
else: else:
return [] return []
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

17
tests/test_user.py
View file

@ -1,4 +1,4 @@
#!/usr/bin/env python # !/usr/bin/env python
# #
# A library that provides a Python interface to the Telegram Bot API # A library that provides a Python interface to the Telegram Bot API
# Copyright (C) 2015-2016 # Copyright (C) 2015-2016
@ -19,9 +19,9 @@
"""This module contains a object that represents Tests for Telegram User""" """This module contains a object that represents Tests for Telegram User"""
import os
import unittest
import sys import sys
import unittest
sys.path.append('.') sys.path.append('.')
import telegram import telegram
@ -60,7 +60,7 @@ class UserTest(BaseTest, unittest.TestCase):
def test_user_de_json_without_username(self): def test_user_de_json_without_username(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['username']) del (json_dict['username'])
user = telegram.User.de_json(self.json_dict) user = telegram.User.de_json(self.json_dict)
@ -69,14 +69,14 @@ class UserTest(BaseTest, unittest.TestCase):
self.assertEqual(user.last_name, self.last_name) self.assertEqual(user.last_name, self.last_name)
self.assertEqual(user.type, self.type) self.assertEqual(user.type, self.type)
self.assertEqual(user.name, '%s %s' % (self.first_name, self.last_name)) self.assertEqual(user.name,
'%s %s' % (self.first_name, self.last_name))
def test_user_de_json_without_username_and_lastname(self): def test_user_de_json_without_username_and_lastname(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['username']) del (json_dict['username'])
del(json_dict['last_name']) del (json_dict['last_name'])
user = telegram.User.de_json(self.json_dict) user = telegram.User.de_json(self.json_dict)
@ -100,5 +100,6 @@ class UserTest(BaseTest, unittest.TestCase):
self.assertEqual(user['username'], self.username) self.assertEqual(user['username'], self.username)
self.assertEqual(user['type'], self.type) self.assertEqual(user['type'], self.type)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

14
tests/test_video.py
View file

@ -19,9 +19,10 @@
"""This module contains a object that represents Tests for Telegram Video""" """This module contains a object that represents Tests for Telegram Video"""
import os
import unittest
import sys import sys
import unittest
import os
from flaky import flaky from flaky import flaky
sys.path.append('.') sys.path.append('.')
@ -217,7 +218,7 @@ class VideoTest(BaseTest, unittest.TestCase):
def test_error_send_video_empty_file(self): def test_error_send_video_empty_file(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['video'] = open(os.devnull, 'rb') json_dict['video'] = open(os.devnull, 'rb')
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -230,7 +231,7 @@ class VideoTest(BaseTest, unittest.TestCase):
def test_error_send_video_empty_file_id(self): def test_error_send_video_empty_file_id(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['video'] = '' json_dict['video'] = ''
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -243,13 +244,14 @@ class VideoTest(BaseTest, unittest.TestCase):
def test_error_video_without_required_args(self): def test_error_video_without_required_args(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
del(json_dict['duration']) del (json_dict['duration'])
self.assertRaises(TypeError, self.assertRaises(TypeError,
lambda: self._bot.sendVideo(chat_id=self._chat_id, lambda: self._bot.sendVideo(chat_id=self._chat_id,
timeout=10, timeout=10,
**json_dict)) **json_dict))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()

14
tests/test_voice.py
View file

@ -19,9 +19,10 @@
"""This module contains a object that represents Tests for Telegram Voice""" """This module contains a object that represents Tests for Telegram Voice"""
import os
import unittest
import sys import sys
import unittest
import os
from flaky import flaky from flaky import flaky
sys.path.append('.') sys.path.append('.')
@ -165,7 +166,7 @@ class VoiceTest(BaseTest, unittest.TestCase):
def test_error_send_voice_empty_file(self): def test_error_send_voice_empty_file(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['voice'] = open(os.devnull, 'rb') json_dict['voice'] = open(os.devnull, 'rb')
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -177,7 +178,7 @@ class VoiceTest(BaseTest, unittest.TestCase):
def test_error_send_voice_empty_file_id(self): def test_error_send_voice_empty_file_id(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
json_dict['voice'] = '' json_dict['voice'] = ''
self.assertRaises(telegram.TelegramError, self.assertRaises(telegram.TelegramError,
@ -189,12 +190,13 @@ class VoiceTest(BaseTest, unittest.TestCase):
def test_error_voice_without_required_args(self): def test_error_voice_without_required_args(self):
json_dict = self.json_dict json_dict = self.json_dict
del(json_dict['file_id']) del (json_dict['file_id'])
del(json_dict['duration']) del (json_dict['duration'])
self.assertRaises(TypeError, self.assertRaises(TypeError,
lambda: self._bot.sendVoice(chat_id=self._chat_id, lambda: self._bot.sendVoice(chat_id=self._chat_id,
**json_dict)) **json_dict))
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()