Releasing v2.8.7

Handles HTTP Bad Gateway error (503) on request module #63

.codeclimate.yml

@@ -0,0 +1,5 @@
+languages:
+  Python: true
+exclude_paths:
+- "telegram/emoji.py"
+- "tests/*"

.coveragerc

@@ -0,0 +1,5 @@
+[run]
+source = telegram
+
+[report]
+omit = tests/

.gitignore

@@ -43,6 +43,7 @@ htmlcov/
 nosetests.xml
 coverage.xml
 *,cover
+.coveralls.yml
 
 # Translations
 *.mo
@@ -57,3 +58,6 @@ docs/_build/
 # PyBuilder
 target/
 .idea/
+
+# Sublime Text 2
+*.sublime*

.travis.yml

@@ -9,6 +9,6 @@ python:
 install:
   - pip install coveralls
 script:
-  coverage run tests/test_*.py
+  nosetests --with-coverage --cover-package telegram/
 after_success:
   coveralls

AUTHORS.rst

@@ -10,6 +10,7 @@ The following wonderful people contributed directly or indirectly to this projec
 
 - `Avanatiker <https://github.com/Avanatiker>`_
 - `bimmlerd <https://github.com/bimmlerd>`_
+- `ErgoZ Riftbit Vaper <https://github.com/ergoz>`_
 - `franciscod <https://github.com/franciscod>`_
 - `JASON0916 <https://github.com/JASON0916>`_
 - `JRoot3D <https://github.com/JRoot3D>`_

CHANGES.rst

@@ -1,3 +1,57 @@
+2015-10-08
+  Released 2.8.7
+  Type as optional for GroupChat class
+
+
+2015-10-08
+  Released 2.8.6
+  Adds type to User and GroupChat classes (pre-release Telegram feature)
+
+
+2015-09-24
+  Released 2.8.5
+  Handles HTTP Bad Gateway (503) errors on request
+  Fixes regression on Audio and Document for unicode fields
+
+
+2015-09-20
+  Released 2.8.4
+  getFile and File.download is now fully supported
+
+
+2015-09-10
+  Released 2.8.3
+  Moved Bot._requestURL to its own class (telegram.utils.request)
+  Much better, such wow, Telegram Objects tests
+  Add consistency for str properties on Telegram Objects
+  Better design to test if chat_id is invalid
+  Add ability to set custom filename on Bot.sendDocument(..,filename='')
+  Fix Sticker as InputFile
+  Send JSON requests over urlencoded post data
+  Markdown support for Bot.sendMessage(..., parse_mode=ParseMode.MARKDOWN)
+  Refactor of TelegramError class (no more handling IOError or URLError)
+
+
+2015-09-05
+  Released 2.8.2
+  Fix regression on Telegram ReplyMarkup
+  Add certificate to is_inputfile method
+
+
+2015-09-05
+  Released 2.8.1
+  Fix regression on Telegram objects with thumb properties
+
+
+2015-09-04
+  Released 2.8
+  TelegramError when chat_id is empty for send* methods
+  setWebhook now supports sending self-signed certificate
+  Huge redesign of existing Telegram classes
+  Added support for PyPy
+  Added docstring for existing classes
+
+
 2015-08-19
   Released 2.7.1
   Fixed JSON serialization for message

Makefile

@@ -14,7 +14,7 @@ lint:
 	pylint -E telegram
 
 test:
-	@- $(foreach TEST, $(wildcard tests/test_*.py), python $(TEST))
+	nosetests
 
 help:
 	@echo "Available targets:"

README.rst

@@ -2,20 +2,22 @@ Python Telegram Bot
 
 A Python wrapper around the Telegram Bot API.
 
+*Stay tuned for library updates and new releases on our* `Telegram Channel <http://telegram.me/pythontelegrambotchannel>`_.
+
 By `Leandro Toledo <leandrotoledodesouza@gmail.com>`_
 
 .. image:: https://img.shields.io/pypi/v/python-telegram-bot.svg
    :target: https://pypi.python.org/pypi/python-telegram-bot
    :alt: PyPi Package Version
-    
+
 .. image:: https://img.shields.io/pypi/dm/python-telegram-bot.svg
    :target: https://pypi.python.org/pypi/python-telegram-bot
    :alt: PyPi Package Monthly Download
-   
+
 .. image:: https://readthedocs.org/projects/python-telegram-bot/badge/?version=latest
    :target: https://readthedocs.org/projects/python-telegram-bot/?badge=latest
    :alt: Documentation Status
-   
+
 .. image:: https://img.shields.io/github/license/leandrotoledo/python-telegram-bot.svg
    :target: http://www.gnu.org/licenses/lgpl-3.0.html
    :alt: LGPLv3 License
@@ -27,7 +29,7 @@ By `Leandro Toledo <leandrotoledodesouza@gmail.com>`_
 .. image:: https://codeclimate.com/github/leandrotoledo/python-telegram-bot/badges/gpa.svg
    :target: https://codeclimate.com/github/leandrotoledo/python-telegram-bot
    :alt: Code Climate
-   
+
 .. image:: https://coveralls.io/repos/leandrotoledo/python-telegram-bot/badge.svg?branch=master&service=github
    :target: https://coveralls.io/github/leandrotoledo/python-telegram-bot?branch=master
    :alt: Coveralls
@@ -55,7 +57,7 @@ Table of contents
   2. `Logging`_
 
   3. `Examples`_
-  
+
   4. `Documentation`_
 
 - `License`_
@@ -94,6 +96,7 @@ sendLocation              Yes
 sendChatAction            Yes
 getUpdates                Yes
 getUserProfilePhotos      Yes
+getFile                   Yes
 setWebhook                Yes
 ========================= ============
 
@@ -108,6 +111,8 @@ Python Version *Supported?*
 2.7            Yes
 3.3            Yes
 3.4            Yes
+PyPy           Yes
+PyPy3          Yes
 ============== ============
 
 =============
@@ -187,6 +192,10 @@ To post a text message::
 
     >>> bot.sendMessage(chat_id=chat_id, text="I'm sorry Dave I'm afraid I can't do that.")
 
+To post a text message with markdown::
+
+    >>> bot.sendMessage(chat_id=chat_id, text="*bold* _italic_ [link](http://google.com).", parse_mode=telegram.ParseMode.MARKDOWN)
+
 To post an Emoji (special thanks to `Tim Whitlock <http://apps.timwhitlock.info/emoji/tables/unicode>`_)::
 
     >>> bot.sendMessage(chat_id=chat_id, text=telegram.Emoji.PILE_OF_POO)
@@ -214,6 +223,12 @@ To hide `Custom Keyboards <https://core.telegram.org/bots#keyboards>`_::
     >>> reply_markup = telegram.ReplyKeyboardHide()
     >>> bot.sendMessage(chat_id=chat_id, text="I'm back.", reply_markup=reply_markup)
 
+To download a file (you will need its file_id)::
+
+    >>> file_id = message.voice.file_id
+    >>> newFile = bot.getFile(file_id)
+    >>> newFile.download('voice.ogg')
+
 There are many more API methods, to read the full API documentation::
 
     $ pydoc telegram.Bot
@@ -262,9 +277,9 @@ You may copy, distribute and modify the software provided that modifications are
 _`Contact`
 ==========
 
-Feel free to join to our `Telegram group <https://telegram.me/joinchat/00b9c0f802509b94d52953d3fa1ec504>`_.
+Feel free to join to our `Telegram group <https://telegram.me/joinchat/ALnA-AJQm5SEwuAzar3nvw>`_.
 
-*If you face trouble joining in the group please ping me on Telegram (@leandrotoledo), I'll be glad to add you.*
+If you face trouble joining in the group please ping me `via Telegram <https://telegram.me/leandrotoledo>`_, I'll be glad to add you.
 
 =======
 _`TODO`

docs/source/conf.py

@@ -58,9 +58,9 @@ author = u'Leandro Toledo'
 # built documents.
 #
 # The short X.Y version.
-version = '2.5'
+version = '2.8'
 # The full version, including alpha/beta/rc tags.
-release = '2.5.1'
+release = '2.8.7'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

setup.py

@@ -15,12 +15,12 @@ def read(*paths):
 
 setup(
     name='python-telegram-bot',
-    version='2.7.1',
+    version='2.8.7',
     author='Leandro Toledo',
     author_email='leandrotoledodesouza@gmail.com',
     license='LGPLv3',
     url='https://github.com/leandrotoledo/python-telegram-bot',
-    keywords='telegram bot api',
+    keywords='python telegram bot api wrapper',
     description='A Python wrapper around the Telegram Bot API',
     long_description=(read('README.rst')),
     packages=find_packages(exclude=['tests*']),

telegram/__init__.py

@@ -19,7 +19,7 @@
 """A library that provides a Python interface to the Telegram Bot API"""
 
 __author__ = 'leandrotoledodesouza@gmail.com'
-__version__ = '2.7.1'
+__version__ = '2.8.7'
 
 from .base import TelegramObject
 from .user import User
@@ -40,8 +40,10 @@ from .replykeyboardhide import ReplyKeyboardHide
 from .forcereply import ForceReply
 from .error import TelegramError
 from .inputfile import InputFile
+from .file import File
 from .nullhandler import NullHandler
 from .emoji import Emoji
+from .parsemode import ParseMode
 from .message import Message
 from .update import Update
 from .bot import Bot
@@ -49,6 +51,6 @@ from .bot import Bot
 __all__ = ['Bot', 'Emoji', 'TelegramError', 'InputFile', 'ReplyMarkup',
            'ForceReply', 'ReplyKeyboardHide', 'ReplyKeyboardMarkup',
            'UserProfilePhotos', 'ChatAction', 'Location', 'Contact',
-           'Video', 'Sticker', 'Document', 'Audio', 'PhotoSize', 'GroupChat',
-           'Update', 'Message', 'User', 'TelegramObject', 'NullHandler',
-           'Voice']
+           'Video', 'Sticker', 'Document', 'File', 'Audio', 'PhotoSize',
+           'GroupChat', 'Update', 'ParseMode', 'Message', 'User',
+           'TelegramObject', 'NullHandler', 'Voice']

telegram/audio.py

@@ -49,12 +49,12 @@ class Audio(TelegramObject):
                  duration,
                  **kwargs):
         # Required
-        self.file_id = file_id
+        self.file_id = str(file_id)
         self.duration = int(duration)
         # Optionals
         self.performer = kwargs.get('performer', '')
         self.title = kwargs.get('title', '')
-        self.mime_type = kwargs.get('mime_type', '')
+        self.mime_type = str(kwargs.get('mime_type', ''))
         self.file_size = int(kwargs.get('file_size', 0))
 
     @staticmethod

telegram/bot.py

@@ -19,26 +19,19 @@
 
 """This module contains a object that represents a Telegram Bot"""
 
-import json
-try:
-    from urllib.parse import urlencode
-    from urllib.request import urlopen, Request
-    from urllib.error import HTTPError, URLError
-except ImportError:
-    from urllib import urlencode
-    from urllib2 import urlopen, Request
-    from urllib2 import HTTPError, URLError
 import functools
 import logging
 
-from telegram import (User, Message, Update, UserProfilePhotos, TelegramError,
-                      ReplyMarkup, InputFile, TelegramObject, NullHandler)
+from telegram import (User, Message, Update, UserProfilePhotos, File,
+                      TelegramError, ReplyMarkup, TelegramObject, NullHandler)
+from telegram.utils import request
 
 H = NullHandler()
 logging.getLogger(__name__).addHandler(H)
 
 
 class Bot(TelegramObject):
+
     """This object represents a Telegram Bot.
 
     Attributes:
@@ -66,6 +59,8 @@ class Bot(TelegramObject):
         else:
             self.base_url = base_url + self.token
 
+        self.base_file_url = 'https://api.telegram.org/file/bot%s' % self.token
+
         self.bot = None
 
         self.logger = logging.getLogger(__name__)
@@ -146,8 +141,8 @@ class Bot(TelegramObject):
             """
             url, data = func(self, *args, **kwargs)
 
-            if not kwargs.get('chat_id'):
-                raise TelegramError('Invalid chat_id.')
+            if not data.get('chat_id'):
+                raise TelegramError('Invalid chat_id')
 
             if kwargs.get('reply_to_message_id'):
                 reply_to_message_id = kwargs.get('reply_to_message_id')
@@ -160,13 +155,12 @@ class Bot(TelegramObject):
                 else:
                     data['reply_markup'] = reply_markup
 
-            json_data = Bot._requestUrl(url, 'POST', data=data)
-            data = Bot._parseAndCheckTelegram(json_data)
+            result = request.post(url, data)
 
-            if data is True:
-                return data
+            if result is True:
+                return result
 
-            return Message.de_json(data)
+            return Message.de_json(result)
         return decorator
 
     @log
@@ -179,10 +173,9 @@ class Bot(TelegramObject):
         """
         url = '%s/getMe' % self.base_url
 
-        json_data = self._requestUrl(url, 'GET')
-        data = self._parseAndCheckTelegram(json_data)
+        result = request.get(url)
 
-        self.bot = User.de_json(data)
+        self.bot = User.de_json(result)
 
         return self.bot
 
@@ -191,6 +184,7 @@ class Bot(TelegramObject):
     def sendMessage(self,
                     chat_id,
                     text,
+                    parse_mode=None,
                     disable_web_page_preview=None,
                     **kwargs):
         """Use this method to send text messages.
@@ -199,6 +193,10 @@ class Bot(TelegramObject):
           chat_id:
             Unique identifier for the message recipient - telegram.User or
             telegram.GroupChat id.
+          parse_mode:
+            Send Markdown, if you want Telegram apps to show bold, italic and
+            inline URLs in your bot's message. For the moment, only Telegram
+            for Android supports this. [Optional]
           text:
             Text of the message to be sent.
           disable_web_page_preview:
@@ -219,6 +217,8 @@ class Bot(TelegramObject):
         data = {'chat_id': chat_id,
                 'text': text}
 
+        if parse_mode:
+            data['parse_mode'] = parse_mode
         if disable_web_page_preview:
             data['disable_web_page_preview'] = disable_web_page_preview
 
@@ -360,6 +360,7 @@ class Bot(TelegramObject):
     def sendDocument(self,
                      chat_id,
                      document,
+                     filename=None,
                      **kwargs):
         """Use this method to send general files.
 
@@ -370,6 +371,9 @@ class Bot(TelegramObject):
             File to send. You can either pass a file_id as String to resend a
             file that is already on the Telegram servers, or upload a new file
             using multipart/form-data.
+          filename:
+            File name that shows in telegram message (it is usefull when you
+            send file generated by temp module, for example). [Optional]
           reply_to_message_id:
             If the message is a reply, ID of the original message. [Optional]
           reply_markup:
@@ -386,6 +390,9 @@ class Bot(TelegramObject):
         data = {'chat_id': chat_id,
                 'document': document}
 
+        if filename:
+            data['filename'] = filename
+
         return url, data
 
     @log
@@ -607,10 +614,36 @@ class Bot(TelegramObject):
         if limit:
             data['limit'] = limit
 
-        json_data = self._requestUrl(url, 'POST', data=data)
-        data = self._parseAndCheckTelegram(json_data)
+        result = request.post(url, data)
 
-        return UserProfilePhotos.de_json(data)
+        return UserProfilePhotos.de_json(result)
+
+    @log
+    def getFile(self,
+                file_id):
+        """Use this method to get basic info about a file and prepare it for
+        downloading. For the moment, bots can download files of up to 20MB in
+        size.
+
+        Args:
+          file_id:
+            File identifier to get info about.
+
+        Returns:
+          Returns a telegram.File object
+        """
+
+        url = '%s/getFile' % self.base_url
+
+        data = {'file_id': file_id}
+
+        result = request.post(url, data)
+
+        if result.get('file_path'):
+            result['file_path'] = '%s/%s' % (self.base_file_url,
+                                             result['file_path'])
+
+        return File.de_json(result)
 
     @log
     def getUpdates(self,
@@ -647,16 +680,15 @@ class Bot(TelegramObject):
         if timeout:
             data['timeout'] = timeout
 
-        json_data = self._requestUrl(url, 'POST', data=data)
-        data = self._parseAndCheckTelegram(json_data)
+        result = request.post(url, data)
 
-        if data:
+        if result:
             self.logger.info(
-                'Getting updates: %s', [u['update_id'] for u in data])
+                'Getting updates: %s', [u['update_id'] for u in result])
         else:
             self.logger.info('No new updates found.')
 
-        return [Update.de_json(x) for x in data]
+        return [Update.de_json(x) for x in result]
 
     @log
     def setWebhook(self,
@@ -684,85 +716,9 @@ class Bot(TelegramObject):
         if certificate:
             data['certificate'] = certificate
 
-        json_data = self._requestUrl(url, 'POST', data=data)
-        data = self._parseAndCheckTelegram(json_data)
+        result = request.post(url, data)
 
-        return data
-
-    @staticmethod
-    def _requestUrl(url,
-                    method,
-                    data=None):
-        """Request an URL.
-
-        Args:
-          url:
-            The web location we want to retrieve.
-          method:
-            Either POST or GET.
-          data:
-            A dict of (str, unicode) key/value pairs.
-
-        Returns:
-          A JSON object.
-        """
-        if method not in ('POST', 'GET'):
-            raise ValueError(
-                "Method '%s' is neither 'POST' nor 'GET'" % method)
-
-        if method == 'POST':
-            try:
-                if InputFile.is_inputfile(data):
-                    data = InputFile(data)
-
-                    request = Request(
-                        url,
-                        data=data.to_form(),
-                        headers=data.headers
-                    )
-
-                    return urlopen(request).read()
-                else:
-                    return urlopen(
-                        url,
-                        urlencode(data).encode()
-                    ).read()
-            except HTTPError as e:
-                raise TelegramError(str(e))
-            except URLError as e:
-                raise TelegramError(str(e))
-            except IOError as e:
-                raise TelegramError(str(e))
-
-        if method == 'GET':
-            try:
-                return urlopen(url).read()
-            except URLError as e:
-                raise TelegramError(str(e))
-
-    @staticmethod
-    def _parseAndCheckTelegram(json_data):
-        """Try and parse the JSON returned from Telegram and return an empty
-        dictionary if there is any error.
-
-        Args:
-          json_data:
-            JSON results from Telegram Bot API.
-
-        Returns:
-          A JSON parsed as Python dict with results.
-        """
-
-        try:
-            data = json.loads(json_data.decode())
-            if not data['ok']:
-                raise TelegramError(data['description'])
-        except ValueError:
-            if '<title>403 Forbidden</title>' in json_data:
-                raise TelegramError({'message': 'API must be authenticated'})
-            raise TelegramError({'message': 'JSON decoding'})
-
-        return data['result']
+        return result
 
     @staticmethod
     def de_json(data):

telegram/contact.py

@@ -45,7 +45,7 @@ class Contact(TelegramObject):
                  first_name,
                  **kwargs):
         # Required
-        self.phone_number = phone_number
+        self.phone_number = str(phone_number)
         self.first_name = first_name
         # Optionals
         self.last_name = kwargs.get('last_name', '')

telegram/document.py

@@ -46,11 +46,11 @@ class Document(TelegramObject):
                  file_id,
                  **kwargs):
         # Required
-        self.file_id = file_id
+        self.file_id = str(file_id)
         # Optionals
         self.thumb = kwargs.get('thumb')
         self.file_name = kwargs.get('file_name', '')
-        self.mime_type = kwargs.get('mime_type', '')
+        self.mime_type = str(kwargs.get('mime_type', ''))
         self.file_size = int(kwargs.get('file_size', 0))
 
     @staticmethod
@@ -65,4 +65,6 @@ class Document(TelegramObject):
         if not data:
             return None
 
+        data['thumb'] = PhotoSize.de_json(data.get('thumb'))
+
         return Document(**data)

telegram/error.py

@@ -18,14 +18,24 @@
 
 """This module contains a object that represents a Telegram Error"""
 
+import re
+
 
 class TelegramError(Exception):
     """This object represents a Telegram Error."""
 
-    @property
-    def message(self):
+    def __init__(self, message):
         """
         Returns:
             str:
         """
-        return self.args[0]
+        super(TelegramError, self).__init__()
+
+        api_error = re.match(r'^Error: (?P<message>.*)', message)
+        if api_error:
+            self.message = api_error.group('message').capitalize()
+        else:
+            self.message = message
+
+    def __str__(self):
+        return '%s' % (self.message)

telegram/file.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents a Telegram File"""
+
+from os.path import basename
+
+from telegram import TelegramObject
+from telegram.utils.request import download as _download
+
+
+class File(TelegramObject):
+
+    """This object represents a Telegram File.
+
+    Attributes:
+        file_id (str):
+        file_size (str):
+        file_path (str):
+
+    Args:
+        file_id (str):
+        **kwargs: Arbitrary keyword arguments.
+
+    Keyword Args:
+        file_size (Optional[int]):
+        file_path (Optional[str]):
+    """
+
+    def __init__(self,
+                 file_id,
+                 **kwargs):
+        # Required
+        self.file_id = str(file_id)
+        # Optionals
+        self.file_size = int(kwargs.get('file_size', 0))
+        self.file_path = str(kwargs.get('file_path', ''))
+
+    @staticmethod
+    def de_json(data):
+        """
+        Args:
+            data (str):
+
+        Returns:
+            telegram.File:
+        """
+        if not data:
+            return None
+
+        return File(**data)
+
+    def download(self,
+                 custom_path=None):
+        """
+        Args:
+            custom_path (str):
+        """
+        url = self.file_path
+
+        if custom_path:
+            filename = basename(custom_path)
+        else:
+            filename = basename(url)
+
+        _download(url, filename)

telegram/forcereply.py

@@ -57,4 +57,3 @@ class ForceReply(ReplyMarkup):
             return None
 
         return ForceReply(**data)
-        

telegram/groupchat.py

@@ -28,18 +28,26 @@ class GroupChat(TelegramObject):
     Attributes:
         id (int):
         title (str):
+        type (str):
 
     Args:
         id (int):
         title (str):
+        **kwargs: Arbitrary keyword arguments.
+
+    Keyword Args:
+        type (Optional[str]):
     """
 
     def __init__(self,
                  id,
-                 title):
+                 title,
+                 **kwargs):
         # Required
         self.id = int(id)
         self.title = title
+        # Optionals
+        self.type = kwargs.get('type', '')
 
     @staticmethod
     def de_json(data):

telegram/inputfile.py

@@ -55,6 +55,9 @@ class InputFile(object):
         if 'photo' in data:
             self.input_name = 'photo'
             self.input_file = data.pop('photo')
+        if 'sticker' in data:
+            self.input_name = 'sticker'
+            self.input_file = data.pop('sticker')
         if 'video' in data:
             self.input_name = 'video'
             self.input_file = data.pop('video')
@@ -67,7 +70,10 @@ class InputFile(object):
 
         if isinstance(self.input_file, file):
             self.input_file_content = self.input_file.read()
-            self.filename = os.path.basename(self.input_file.name)
+            if 'filename' in data:
+                self.filename = self.data.pop('filename')
+            else:
+                self.filename = os.path.basename(self.input_file.name)
             self.mimetype = mimetypes.guess_type(self.filename)[0] or \
                 DEFAULT_MIME_TYPE
 
@@ -158,7 +164,7 @@ class InputFile(object):
         if image:
             return 'image/%s' % image
 
-        raise TelegramError({'message': 'Could not parse file content'})
+        raise TelegramError('Could not parse file content')
 
     @staticmethod
     def is_inputfile(data):
@@ -171,7 +177,8 @@ class InputFile(object):
             bool
         """
         if data:
-            file_types = ['audio', 'document', 'photo', 'video', 'voice']
+            file_types = ['audio', 'document', 'photo', 'sticker', 'video',
+                          'voice', 'certificate']
             file_type = [i for i in list(data.keys()) if i in file_types]
 
             if file_type:

telegram/message.py

@@ -171,6 +171,12 @@ class Message(TelegramObject):
 
         return Message(**data)
 
+    def __getitem__(self, item):
+        if item in self.__dict__.keys():
+            return self.__dict__[item]
+        elif item == 'chat_id':
+            return self.chat.id
+
     def to_dict(self):
         """
         Returns:

telegram/parsemode.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+# pylint: disable=R0903
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents a Telegram Message Parse Modes"""
+
+
+class ParseMode(object):
+    """This object represents a Telegram Message Parse Modes."""
+
+    MARKDOWN = 'Markdown'

telegram/replymarkup.py

@@ -27,6 +27,3 @@ class ReplyMarkup(TelegramObject):
     @staticmethod
     def de_json(data):
         pass
-
-    def to_dict(self):
-        pass

telegram/sticker.py

@@ -48,7 +48,7 @@ class Sticker(TelegramObject):
                  height,
                  **kwargs):
         # Required
-        self.file_id = file_id
+        self.file_id = str(file_id)
         self.width = int(width)
         self.height = int(height)
         # Optionals
@@ -67,4 +67,6 @@ class Sticker(TelegramObject):
         if not data:
             return None
 
+        data['thumb'] = PhotoSize.de_json(data.get('thumb'))
+
         return Sticker(**data)

telegram/update.py

@@ -39,7 +39,7 @@ class Update(TelegramObject):
                  update_id,
                  **kwargs):
         # Required
-        self.update_id = update_id
+        self.update_id = int(update_id)
         # Optionals
         self.message = kwargs.get('message')
 

telegram/user.py

@@ -23,13 +23,14 @@ from telegram import TelegramObject
 
 
 class User(TelegramObject):
-    """This object represents a Telegram Sticker.
+    """This object represents a Telegram User.
 
     Attributes:
         id (int):
         first_name (str):
         last_name (str):
         username (str):
+        type (str):
 
     Args:
         id (int):
@@ -37,6 +38,7 @@ class User(TelegramObject):
         **kwargs: Arbitrary keyword arguments.
 
     Keyword Args:
+        type (Optional[str]):
         last_name (Optional[str]):
         username (Optional[str]):
     """
@@ -49,6 +51,7 @@ class User(TelegramObject):
         self.id = int(id)
         self.first_name = first_name
         # Optionals
+        self.type = kwargs.get('type', '')
         self.last_name = kwargs.get('last_name', '')
         self.username = kwargs.get('username', '')
 

telegram/utils/request.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+# pylint: disable=no-name-in-module,unused-import
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser Public License for more details.
+#
+# You should have received a copy of the GNU Lesser Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains methods to make POST and GET requests"""
+
+import json
+
+try:
+    from urllib.parse import urlencode
+    from urllib.request import urlopen, urlretrieve, Request
+    from urllib.error import HTTPError, URLError
+except ImportError:
+    from urllib import urlencode, urlretrieve
+    from urllib2 import urlopen, Request
+    from urllib2 import HTTPError, URLError
+
+from telegram import (InputFile, TelegramError)
+
+
+def _parse(json_data):
+    """Try and parse the JSON returned from Telegram and return an empty
+    dictionary if there is any error.
+
+    Args:
+      url:
+        urllib.urlopen object
+
+    Returns:
+      A JSON parsed as Python dict with results.
+    """
+    data = json.loads(json_data.decode())
+
+    if not data.get('ok') and data.get('description'):
+        return data['description']
+
+    return data['result']
+
+
+def get(url):
+    """Request an URL.
+    Args:
+      url:
+        The web location we want to retrieve.
+
+    Returns:
+      A JSON object.
+    """
+    result = urlopen(url).read()
+
+    return _parse(result)
+
+
+def post(url,
+         data):
+    """Request an URL.
+    Args:
+      url:
+        The web location we want to retrieve.
+      data:
+        A dict of (str, unicode) key/value pairs.
+
+    Returns:
+      A JSON object.
+    """
+    try:
+        if InputFile.is_inputfile(data):
+            data = InputFile(data)
+            request = Request(url,
+                              data=data.to_form(),
+                              headers=data.headers)
+        else:
+            data = json.dumps(data)
+            request = Request(url,
+                              data=data.encode(),
+                              headers={'Content-Type': 'application/json'})
+
+        result = urlopen(request).read()
+    except HTTPError as error:
+        if error.getcode() == 403:
+            raise TelegramError('Unauthorized')
+        if error.getcode() == 502:
+            raise TelegramError('Bad Gateway')
+
+        message = _parse(error.read())
+        raise TelegramError(message)
+
+    return _parse(result)
+
+
+def download(url,
+             filename):
+    """Download a file by its URL.
+    Args:
+      url:
+        The web location we want to retrieve.
+
+      filename:
+        The filename wihtin the path to download the file.
+    """
+
+    urlretrieve(url, filename)

telegram/video.py

@@ -53,13 +53,13 @@ class Video(TelegramObject):
                  duration,
                  **kwargs):
         # Required
-        self.file_id = file_id
+        self.file_id = str(file_id)
         self.width = int(width)
         self.height = int(height)
         self.duration = int(duration)
         # Optionals
         self.thumb = kwargs.get('thumb')
-        self.mime_type = kwargs.get('mime_type', '')
+        self.mime_type = str(kwargs.get('mime_type', ''))
         self.file_size = int(kwargs.get('file_size', 0))
 
     @staticmethod
@@ -74,4 +74,6 @@ class Video(TelegramObject):
         if not data:
             return None
 
+        data['thumb'] = PhotoSize.de_json(data.get('thumb'))
+
         return Video(**data)

telegram/voice.py

@@ -44,10 +44,10 @@ class Voice(TelegramObject):
                  file_id,
                  **kwargs):
         # Required
-        self.file_id = file_id
+        self.file_id = str(file_id)
         # Optionals
         self.duration = int(kwargs.get('duration', 0))
-        self.mime_type = kwargs.get('mime_type', '')
+        self.mime_type = str(kwargs.get('mime_type', ''))
         self.file_size = int(kwargs.get('file_size', 0))
 
     @staticmethod

tests/base.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents a Base class for tests"""
+
+import os
+import sys
+sys.path.append('.')
+
+import json
+import telegram
+
+
+class BaseTest(object):
+    """This object represents a Base test and its sets of functions."""
+
+    def __init__(self, *args, **kwargs):
+        super(BaseTest, self).__init__(*args, **kwargs)
+
+        bot = telegram.Bot(os.environ.get('TOKEN'))
+        chat_id = os.environ.get('CHAT_ID')
+
+        self._bot = bot
+        self._chat_id = chat_id
+
+    @staticmethod
+    def is_json(string):
+        try:
+            json.loads(string)
+        except ValueError:
+            return False
+
+        return True
+
+    @staticmethod
+    def is_dict(dictionary):
+        if isinstance(dictionary, dict):
+            return True
+
+        return False

tests/test_audio.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram Audio"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class AudioTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram Audio."""
+
+    def setUp(self):
+        self.audio_file = open('tests/data/telegram.mp3', 'rb')
+        self.audio_file_id = 'BQADAQADDwADHyP1B6PSPq2HjX8kAg'
+        self.duration = 4
+        self.performer = 'Leandro Toledo'
+        self.title = 'Teste'
+        self.mime_type = 'audio/mpeg'
+        self.file_size = 28232
+
+        self.json_dict = {
+            'file_id': self.audio_file_id,
+            'duration': self.duration,
+            'performer': self.performer,
+            'title': self.title,
+            'mime_type': self.mime_type,
+            'file_size': self.file_size
+        }
+
+    def test_send_audio_required_args_only(self):
+        """Test telegram.Bot sendAudio method"""
+        print('Testing bot.sendAudio - With required arguments only')
+
+        message = self._bot.sendAudio(self._chat_id,
+                                      self.audio_file)
+
+        audio = message.audio
+
+        self.assertTrue(isinstance(audio.file_id, str))
+        self.assertNotEqual(audio.file_id, '')
+        self.assertEqual(audio.duration, 4)
+        self.assertEqual(audio.performer, '')
+        self.assertEqual(audio.title, '')
+        self.assertEqual(audio.mime_type, self.mime_type)
+        self.assertEqual(audio.file_size, self.file_size)
+
+    def test_send_audio_all_args(self):
+        """Test telegram.Bot sendAudio method"""
+        print('Testing bot.sendAudio - With all arguments')
+
+        message = self._bot.sendAudio(self._chat_id,
+                                      self.audio_file,
+                                      duration=self.duration,
+                                      performer=self.performer,
+                                      title=self.title,
+                                      mime_type=self.mime_type,
+                                      file_size=self.file_size)
+
+        audio = message.audio
+
+        self.assertTrue(isinstance(audio.file_id, str))
+        self.assertNotEqual(audio.file_id, '')
+        self.assertEqual(audio.duration, self.duration)
+        self.assertEqual(audio.performer, self.performer)
+        self.assertEqual(audio.title, self.title)
+        self.assertEqual(audio.mime_type, self.mime_type)
+        self.assertEqual(audio.file_size, self.file_size)
+
+    def test_send_audio_mp3_file(self):
+        """Test telegram.Bot sendAudio method"""
+        print('Testing bot.sendAudio - MP3 File')
+
+        message = self._bot.sendAudio(chat_id=self._chat_id,
+                                      audio=self.audio_file,
+                                      duration=self.duration,
+                                      performer=self.performer,
+                                      title=self.title)
+
+        audio = message.audio
+
+        self.assertTrue(isinstance(audio.file_id, str))
+        self.assertNotEqual(audio.file_id, '')
+        self.assertEqual(audio.duration, self.duration)
+        self.assertEqual(audio.performer, self.performer)
+        self.assertEqual(audio.title, self.title)
+        self.assertEqual(audio.mime_type, self.mime_type)
+        self.assertEqual(audio.file_size, self.file_size)
+
+    def test_send_audio_mp3_file_custom_filename(self):
+        """Test telegram.Bot sendAudio method"""
+        print('Testing bot.sendAudio - MP3 File with custom filename')
+
+        message = self._bot.sendAudio(chat_id=self._chat_id,
+                                      audio=self.audio_file,
+                                      duration=self.duration,
+                                      performer=self.performer,
+                                      title=self.title,
+                                      filename='telegram_custom.mp3')
+
+        audio = message.audio
+
+        self.assertTrue(isinstance(audio.file_id, str))
+        self.assertNotEqual(audio.file_id, '')
+        self.assertEqual(audio.duration, self.duration)
+        self.assertEqual(audio.performer, self.performer)
+        self.assertEqual(audio.title, self.title)
+        self.assertEqual(audio.mime_type, self.mime_type)
+        self.assertEqual(audio.file_size, self.file_size)
+
+    def test_send_audio_resend(self):
+        """Test telegram.Bot sendAudio method"""
+        print('Testing bot.sendAudio - Resend by file_id')
+
+        message = self._bot.sendAudio(chat_id=self._chat_id,
+                                      audio=self.audio_file_id,
+                                      duration=self.duration,
+                                      performer=self.performer,
+                                      title=self.title)
+
+        audio = message.audio
+
+        self.assertEqual(audio.file_id, self.audio_file_id)
+        self.assertEqual(audio.duration, self.duration)
+        self.assertEqual(audio.performer, self.performer)
+        self.assertEqual(audio.title, self.title)
+        self.assertEqual(audio.mime_type, self.mime_type)
+
+    def test_audio_de_json(self):
+        """Test Audio.de_json() method"""
+        print('Testing Audio.de_json()')
+
+        audio = telegram.Audio.de_json(self.json_dict)
+
+        self.assertEqual(audio.file_id, self.audio_file_id)
+        self.assertEqual(audio.duration, self.duration)
+        self.assertEqual(audio.performer, self.performer)
+        self.assertEqual(audio.title, self.title)
+        self.assertEqual(audio.mime_type, self.mime_type)
+        self.assertEqual(audio.file_size, self.file_size)
+
+    def test_audio_to_json(self):
+        """Test Audio.to_json() method"""
+        print('Testing Audio.to_json()')
+
+        audio = telegram.Audio.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(audio.to_json()))
+
+    def test_audio_to_dict(self):
+        """Test Audio.to_dict() method"""
+        print('Testing Audio.to_dict()')
+
+        audio = telegram.Audio.de_json(self.json_dict)
+
+        self.assertTrue(self.is_dict(audio.to_dict()))
+        self.assertEqual(audio['file_id'], self.audio_file_id)
+        self.assertEqual(audio['duration'], self.duration)
+        self.assertEqual(audio['performer'], self.performer)
+        self.assertEqual(audio['title'], self.title)
+        self.assertEqual(audio['mime_type'], self.mime_type)
+        self.assertEqual(audio['file_size'], self.file_size)
+
+    def test_error_send_audio_empty_file(self):
+        print('Testing bot.sendAudio - Null file')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        json_dict['audio'] = open(os.devnull, 'rb')
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendAudio(chat_id=self._chat_id,
+                                                      **json_dict))
+
+    def test_error_send_audio_empty_file_id(self):
+        print('Testing bot.sendAudio - Empty file_id')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        json_dict['audio'] = ''
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendAudio(chat_id=self._chat_id,
+                                                      **json_dict))
+
+    def test_error_audio_without_required_args(self):
+        print('Testing bot.sendAudio - Without required arguments')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        del(json_dict['duration'])
+
+        self.assertRaises(TypeError,
+                          lambda: self._bot.sendAudio(chat_id=self._chat_id,
+                                                      **json_dict))
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_bot.py

@@ -17,33 +17,20 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see [http://www.gnu.org/licenses/].
 
+"""This module contains a object that represents Tests for Telegram Bot"""
 
 import os
-import sys
-sys.path.append('.')
-import json
-import telegram
 import unittest
 from datetime import datetime
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
 
 
-class BotTest(unittest.TestCase):
-    @staticmethod
-    def is_json(string):
-        try:
-            json.loads(string)
-        except ValueError:
-            return False
-        return True
-
-    def setUp(self):
-        bot = telegram.Bot(token=os.environ.get('TOKEN'))
-        chat_id = os.environ.get('CHAT_ID')
-
-        self._bot = bot
-        self._chat_id = chat_id
-
-        print('Testing the Bot API class')
+class BotTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram Bot."""
 
     def testGetMe(self):
         '''Test the telegram.Bot getMe method'''
@@ -51,11 +38,11 @@ class BotTest(unittest.TestCase):
         bot = self._bot.getMe()
 
         self.assertTrue(self.is_json(bot.to_json()))
-        self.assertEqual(bot.id, 120405045)
-        self.assertEqual(bot.first_name, 'Toledo\'s Palace Bot')
+        self.assertEqual(bot.id, 133505823)
+        self.assertEqual(bot.first_name, 'PythonTelegramBot')
         self.assertEqual(bot.last_name, '')
-        self.assertEqual(bot.username, 'ToledosPalaceBot')
-        self.assertEqual(bot.name, '@ToledosPalaceBot')
+        self.assertEqual(bot.username, 'PythonTelegramBot')
+        self.assertEqual(bot.name, '@PythonTelegramBot')
 
     def testSendMessage(self):
         '''Test the telegram.Bot sendMessage method'''
@@ -81,10 +68,10 @@ class BotTest(unittest.TestCase):
         print('Testing forwardMessage')
         message = self._bot.forwardMessage(chat_id=self._chat_id,
                                            from_chat_id=self._chat_id,
-                                           message_id=138)
+                                           message_id=2398)
 
         self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.text, 'Oi')
+        self.assertEqual(message.text, 'teste')
         self.assertEqual(message.forward_from.username, 'leandrotoledo')
         self.assertTrue(isinstance(message.forward_date, datetime))
 
@@ -102,11 +89,11 @@ class BotTest(unittest.TestCase):
     def testResendPhoto(self):
         '''Test the telegram.Bot sendPhoto method'''
         print('Testing sendPhoto - Resend')
-        message = self._bot.sendPhoto(photo='AgADAQADr6cxGzU8LQe6q0dMJD2rHYkP2ykABFymiQqJgjxRGGMAAgI',
+        message = self._bot.sendPhoto(photo='AgADAQADyKcxGx8j9Qdp6d-gpUsw4Gja1i8ABEVJsVqQk8LfJ3wAAgI',
                                       chat_id=self._chat_id)
 
         self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.photo[0].file_id, 'AgADAQADr6cxGzU8LQe6q0dMJD2rHYkP2ykABFymiQqJgjxRGGMAAgI')
+        self.assertEqual(message.photo[0].file_id, 'AgADAQADyKcxGx8j9Qdp6d-gpUsw4Gja1i8ABEVJsVqQk8LfJ3wAAgI')
 
     def testSendJPGURLPhoto(self):
         '''Test the telegram.Bot sendPhoto method'''
@@ -135,115 +122,6 @@ class BotTest(unittest.TestCase):
         self.assertTrue(self.is_json(message.to_json()))
         self.assertEqual(message.photo[0].file_size, 684)
 
-    def testSendAudio(self):
-        '''Test the telegram.Bot sendAudio method'''
-        print('Testing sendAudio - File')
-        message = self._bot.sendAudio(audio=open('tests/data/telegram.mp3', 'rb'),
-                                      chat_id=self._chat_id,
-                                      performer='Leandro Toledo',
-                                      title='Teste')
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.audio.file_size, 28232)
-        self.assertEqual(message.audio.performer, 'Leandro Toledo')
-        self.assertEqual(message.audio.title, 'Teste')
-
-    def testResendAudio(self):
-        '''Test the telegram.Bot sendAudio method'''
-        print('Testing sendAudio - Resend')
-        message = self._bot.sendAudio(audio='BQADAQADwwcAAjU8LQdBRsl3_qD2TAI',
-                                      chat_id=self._chat_id,
-                                      performer='Leandro Toledo',   # Bug #39
-                                      title='Teste')                # Bug #39
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.audio.file_id, 'BQADAQADwwcAAjU8LQdBRsl3_qD2TAI')
-
-    def testSendVoice(self):
-        '''Test the telegram.Bot sendVoice method'''
-        print('Testing sendVoice - File')
-        message = self._bot.sendVoice(voice=open('tests/data/telegram.ogg', 'rb'),
-                                      chat_id=self._chat_id)
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.voice.file_size, 9199)
-
-    def testResendVoice(self):
-        '''Test the telegram.Bot sendVoice method'''
-        print('Testing sendVoice - Resend')
-        message = self._bot.sendVoice(voice='AwADAQADIQEAAvjAuQABSAXg_GhkhZcC',
-                                      chat_id=self._chat_id)
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.voice.file_id, 'AwADAQADIQEAAvjAuQABSAXg_GhkhZcC')
-
-    def testSendDocument(self):
-        '''Test the telegram.Bot sendDocument method'''
-        print('Testing sendDocument - File')
-        message = self._bot.sendDocument(document=open('tests/data/telegram.png', 'rb'),
-                                         chat_id=self._chat_id)
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.document.file_size, 12948)
-
-    def testSendGIFURLDocument(self):
-        '''Test the telegram.Bot sendDocument method'''
-        print('Testing sendDocument - File')
-        message = self._bot.sendPhoto(photo='http://dummyimage.com/600x400/000/fff.gif&text=telegram',
-                                      chat_id=self._chat_id)
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.photo[0].file_size, 684)
-
-    def testResendDocument(self):
-        '''Test the telegram.Bot sendDocument method'''
-        print('Testing sendDocument - Resend')
-        message = self._bot.sendDocument(document='BQADAQADHAADNTwtBxZxUGKyxYbYAg',
-                                         chat_id=self._chat_id)
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.document.file_id, 'BQADAQADHAADNTwtBxZxUGKyxYbYAg')
-
-    def testSendVideo(self):
-        '''Test the telegram.Bot sendVideo method'''
-        print('Testing sendVideo - File')
-        message = self._bot.sendVideo(video=open('tests/data/telegram.mp4', 'rb'),
-                                      caption='testSendVideo',
-                                      chat_id=self._chat_id)
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.video.file_size, 326534)
-        self.assertEqual(message.caption, 'testSendVideo')
-
-    def testResendVideo(self):
-        '''Test the telegram.Bot sendVideo method'''
-        print('Testing sendVideo - Resend')
-        message = self._bot.sendVideo(video='BAADAQADIgEAAvjAuQABOuTB937fPTgC',
-                                      chat_id=self._chat_id)
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.video.duration, 4)
-
-    def testResendSticker(self):
-        '''Test the telegram.Bot sendSticker method'''
-        print('Testing sendSticker - Resend')
-        message = self._bot.sendSticker(sticker='BQADAQADHAADyIsGAAFZfq1bphjqlgI',
-                                        chat_id=self._chat_id)
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.sticker.file_size, 39518)
-
-    def testSendLocation(self):
-        '''Test the telegram.Bot sendLocation method'''
-        print('Testing sendLocation')
-        message = self._bot.sendLocation(latitude=-23.558873,
-                                         longitude=-46.659732,
-                                         chat_id=self._chat_id)
-
-        self.assertTrue(self.is_json(message.to_json()))
-        self.assertEqual(message.location.latitude, -23.558873)
-        self.assertEqual(message.location.longitude, -46.659732)
-
     def testSendChatAction(self):
         '''Test the telegram.Bot sendChatAction method'''
         print('Testing sendChatAction - ChatAction.TYPING')
@@ -259,4 +137,5 @@ class BotTest(unittest.TestCase):
         self.assertTrue(self.is_json(upf.to_json()))
         self.assertEqual(upf.photos[0][0].file_size, 6547)
 
-unittest.main()
+if __name__ == '__main__':
+    unittest.main()

tests/test_contact.py

@@ -0,0 +1,78 @@
+  #!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram Contact"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class ContactTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram Contact."""
+
+    def setUp(self):
+        self.phone_number = '+11234567890'
+        self.first_name = 'Leandro Toledo'
+        self.last_name = ''
+        self.user_id = 0
+
+        self.json_dict = {
+            'phone_number': self.phone_number,
+            'first_name': self.first_name,
+            'last_name': self.last_name,
+            'user_id': self.user_id
+        }
+
+    def test_contact_de_json(self):
+        """Test Contact.de_json() method"""
+        print('Testing Contact.de_json()')
+
+        contact = telegram.Contact.de_json(self.json_dict)
+
+        self.assertEqual(contact.phone_number, self.phone_number)
+        self.assertEqual(contact.first_name, self.first_name)
+        self.assertEqual(contact.last_name, self.last_name)
+        self.assertEqual(contact.user_id, self.user_id)
+
+    def test_contact_to_json(self):
+        """Test Contact.to_json() method"""
+        print('Testing Contact.to_json()')
+
+        contact = telegram.Contact.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(contact.to_json()))
+
+    def test_contact_to_dict(self):
+        """Test Contact.to_dict() method"""
+        print('Testing Contact.to_dict()')
+
+        contact = telegram.Contact.de_json(self.json_dict)
+
+        self.assertTrue(self.is_dict(contact.to_dict()))
+        self.assertEqual(contact['phone_number'], self.phone_number)
+        self.assertEqual(contact['first_name'], self.first_name)
+        self.assertEqual(contact['last_name'], self.last_name)
+        self.assertEqual(contact['user_id'], self.user_id)
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_document.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram Document"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class DocumentTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram Document."""
+
+    def setUp(self):
+        self.document_file = open('tests/data/telegram.png', 'rb')
+        self.document_file_id = 'BQADAQADpAADHyP1B04ipZxJTe2BAg'
+        self.document_file_url = 'http://dummyimage.com/600x400/000/fff.gif&text=telegram'
+        self.thumb = {'width': 90,
+                      'height': 90,
+                      'file_id': 'BQADAQADoQADHyP1B0mzJMVyzcB0Ag',
+                      'file_size': 2364}
+        self.file_name = 'telegram.png'
+        self.mime_type = 'image/png'
+        self.file_size = 12948
+
+        self.json_dict = {
+            'file_id': self.document_file_id,
+            'thumb': self.thumb,
+            'file_name': self.file_name,
+            'mime_type': self.mime_type,
+            'file_size': self.file_size
+        }
+
+    def test_send_document_png_file(self):
+        """Test telegram.Bot sendDocument method"""
+        print('Testing bot.sendDocument - PNG File')
+
+        message = self._bot.sendDocument(self._chat_id,
+                                         self.document_file)
+
+        document = message.document
+
+        self.assertTrue(isinstance(document.file_id, str))
+        self.assertNotEqual(document.file_id, '')
+        self.assertTrue(isinstance(document.thumb, telegram.PhotoSize))
+        self.assertEqual(document.file_name, self.file_name)
+        self.assertEqual(document.mime_type, self.mime_type)
+        self.assertEqual(document.file_size, self.file_size)
+
+    def test_send_document_png_file_with_custom_file_name(self):
+        """Test telegram.Bot sendDocument method"""
+        print('Testing bot.sendDocument - PNG File with custom filename')
+
+        message = self._bot.sendDocument(self._chat_id,
+                                         self.document_file,
+                                         filename='telegram_custom.png')
+
+        document = message.document
+
+        self.assertTrue(isinstance(document.file_id, str))
+        self.assertNotEqual(document.file_id, '')
+        self.assertTrue(isinstance(document.thumb, telegram.PhotoSize))
+        self.assertEqual(document.file_name, 'telegram_custom.png')
+        self.assertEqual(document.mime_type, self.mime_type)
+        self.assertEqual(document.file_size, self.file_size)
+
+    def test_send_document_url_gif_file(self):
+        """Test telegram.Bot sendDocument method"""
+        print('Testing bot.sendDocument - GIF File by URL')
+
+        message = self._bot.sendDocument(self._chat_id,
+                                         self.document_file_url)
+
+        document = message.document
+
+        self.assertTrue(isinstance(document.file_id, str))
+        self.assertNotEqual(document.file_id, '')
+        self.assertTrue(isinstance(document.thumb, telegram.PhotoSize))
+        self.assertEqual(document.file_name, 'image.gif')
+        self.assertEqual(document.mime_type, 'image/gif')
+        self.assertEqual(document.file_size, 3878)
+
+    def test_send_document_resend(self):
+        """Test telegram.Bot sendDocument method"""
+        print('Testing bot.sendDocument - Resend by file_id')
+
+        message = self._bot.sendDocument(chat_id=self._chat_id,
+                                         document=self.document_file_id)
+
+        document = message.document
+
+        self.assertEqual(document.file_id, self.document_file_id)
+        self.assertTrue(isinstance(document.thumb, telegram.PhotoSize))
+        self.assertEqual(document.file_name, self.file_name)
+        self.assertEqual(document.mime_type, self.mime_type)
+
+    def test_document_de_json(self):
+        """Test Document.de_json() method"""
+        print('Testing Document.de_json()')
+
+        document = telegram.Document.de_json(self.json_dict)
+
+        self.assertEqual(document.file_id, self.document_file_id)
+        self.assertTrue(isinstance(document.thumb, telegram.PhotoSize))
+        self.assertEqual(document.file_name, self.file_name)
+        self.assertEqual(document.mime_type, self.mime_type)
+        self.assertEqual(document.file_size, self.file_size)
+
+    def test_document_to_json(self):
+        """Test Document.to_json() method"""
+        print('Testing Document.to_json()')
+
+        document = telegram.Document.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(document.to_json()))
+
+    def test_document_to_dict(self):
+        """Test Document.to_dict() method"""
+        print('Testing Document.to_dict()')
+
+        document = telegram.Document.de_json(self.json_dict)
+
+        self.assertTrue(self.is_dict(document.to_dict()))
+        self.assertEqual(document['file_id'], self.document_file_id)
+        self.assertTrue(isinstance(document['thumb'], telegram.PhotoSize))
+        self.assertEqual(document['file_name'], self.file_name)
+        self.assertEqual(document['mime_type'], self.mime_type)
+        self.assertEqual(document['file_size'], self.file_size)
+
+    def test_error_send_document_empty_file(self):
+        print('Testing bot.sendDocument - Null file')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        json_dict['document'] = open(os.devnull, 'rb')
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendDocument(chat_id=self._chat_id,
+                                                         **json_dict))
+
+    def test_error_send_document_empty_file_id(self):
+        print('Testing bot.sendDocument - Empty file_id')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        json_dict['document'] = ''
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendDocument(chat_id=self._chat_id,
+                                                         **json_dict))
+
+    def test_error_document_without_required_args(self):
+        print('Testing bot.sendDocument - Without required arguments')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+
+        self.assertRaises(TypeError,
+                          lambda: self._bot.sendDocument(chat_id=self._chat_id,
+                                                         **json_dict))
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_file.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram File"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class FileTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram File."""
+
+    def setUp(self):
+        self.audio_file_id = 'BQADAQADDwADHyP1B6PSPq2HjX8kAg'
+        self.document_file_id = 'BQADAQADpAADHyP1B04ipZxJTe2BAg'
+        self.sticker_file_id = 'BQADAQADHAADyIsGAAFZfq1bphjqlgI'
+        self.video_file_id = 'BAADAQADXwADHyP1BwJFTcmY2RYCAg'
+        self.voice_file_id = 'AwADAQADTgADHyP1B_mbw34svXPHAg'
+
+
+        self.json_dict = {
+            'file_id': self.audio_file_id,
+            'file_path': 'https://api.telegram.org/file/bot133505823:AAHZFMHno3mzVLErU5b5jJvaeG--qUyLyG0/document/file_3',
+            'file_size': 28232
+        }
+
+    def test_get_and_download_file_audio(self):
+        """Test telegram.Bot getFile method - Audio"""
+        print('Testing bot.getFile - With Audio.file_id')
+
+        newFile = self._bot.getFile(self.audio_file_id)
+
+        self.assertEqual(newFile.file_size, 28232)
+        self.assertEqual(newFile.file_id, self.audio_file_id)
+        self.assertTrue(newFile.file_path.startswith('https://'))
+
+        newFile.download('telegram.mp3')
+
+        self.assertTrue(os.path.isfile('telegram.mp3'))
+
+    def test_get_and_download_file_document(self):
+        """Test telegram.Bot getFile method - Document"""
+        print('Testing bot.getFile - With Document.file_id')
+
+        newFile = self._bot.getFile(self.document_file_id)
+
+        self.assertEqual(newFile.file_size, 12948)
+        self.assertEqual(newFile.file_id, self.document_file_id)
+        self.assertTrue(newFile.file_path.startswith('https://'))
+
+        newFile.download('telegram.png')
+
+        self.assertTrue(os.path.isfile('telegram.png'))
+
+    def test_get_and_download_file_sticker(self):
+        """Test telegram.Bot getFile method - Sticker"""
+        print('Testing bot.getFile - With Sticker.file_id')
+
+        newFile = self._bot.getFile(self.sticker_file_id)
+
+        self.assertEqual(newFile.file_size, 39518)
+        self.assertEqual(newFile.file_id, self.sticker_file_id)
+        self.assertTrue(newFile.file_path.startswith('https://'))
+
+        newFile.download('telegram.webp')
+
+        self.assertTrue(os.path.isfile('telegram.webp'))
+
+    def test_get_and_download_file_video(self):
+        """Test telegram.Bot getFile method - Video"""
+        print('Testing bot.getFile - With Video.file_id')
+
+        newFile = self._bot.getFile(self.video_file_id)
+
+        self.assertEqual(newFile.file_size, 326534)
+        self.assertEqual(newFile.file_id, self.video_file_id)
+        self.assertTrue(newFile.file_path.startswith('https://'))
+
+        newFile.download('telegram.mp4')
+
+        self.assertTrue(os.path.isfile('telegram.mp4'))
+
+    def test_get_and_download_file_voice(self):
+        """Test telegram.Bot getFile method - Voice"""
+        print('Testing bot.getFile - With Voice.file_id')
+
+        newFile = self._bot.getFile(self.voice_file_id)
+
+        self.assertEqual(newFile.file_size, 9199)
+        self.assertEqual(newFile.file_id, self.voice_file_id)
+        self.assertTrue(newFile.file_path.startswith('https://'))
+
+        newFile.download('telegram.ogg')
+
+        self.assertTrue(os.path.isfile('telegram.ogg'))
+
+    def test_file_de_json(self):
+        """Test File.de_json() method"""
+        print('Testing File.de_json()')
+
+        newFile = telegram.File.de_json(self.json_dict)
+
+        self.assertEqual(newFile.file_id, self.json_dict['file_id'])
+        self.assertEqual(newFile.file_path, self.json_dict['file_path'])
+        self.assertEqual(newFile.file_size, self.json_dict['file_size'])
+
+    def test_file_to_json(self):
+        """Test File.to_json() method"""
+        print('Testing File.to_json()')
+
+        newFile = telegram.File.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(newFile.to_json()))
+
+    def test_file_to_dict(self):
+        """Test File.to_dict() method"""
+        print('Testing File.to_dict()')
+
+        newFile = telegram.File.de_json(self.json_dict)
+
+        self.assertTrue(self.is_dict(newFile.to_dict()))
+        self.assertEqual(newFile['file_id'], self.json_dict['file_id'])
+        self.assertEqual(newFile['file_path'], self.json_dict['file_path'])
+        self.assertEqual(newFile['file_size'], self.json_dict['file_size'])
+
+    def test_error_get_empty_file_id(self):
+        print('Testing bot.getFile - Null file_id')
+
+        json_dict = self.json_dict
+
+        json_dict['file_id'] = ''
+        del(json_dict['file_path'])
+        del(json_dict['file_size'])
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.getFile(**json_dict))
+
+    def test_error_file_without_required_args(self):
+        print('Testing bot.getFile - Without required arguments')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        del(json_dict['file_path'])
+        del(json_dict['file_size'])
+
+        self.assertRaises(TypeError,
+                          lambda: self._bot.getFile(**json_dict))
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_groupchat.py

@@ -0,0 +1,82 @@
+  #!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram GroupChat"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class GroupChatTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram GroupChat."""
+
+    def setUp(self):
+        self.id = -28767330
+        self.title = 'ToledosPalaceBot - Group'
+        self.type = 'group'
+
+        self.json_dict = {
+            'id': self.id,
+            'title': self.title,
+            'type': self.type
+        }
+
+    def test_group_chat_de_json_empty_json(self):
+        """Test GroupChat.de_json() method"""
+        print('Testing GroupChat.de_json() - Empty JSON')
+
+        group_chat = telegram.GroupChat.de_json({})
+
+        self.assertEqual(group_chat, None)
+
+    def test_group_chat_de_json(self):
+        """Test GroupChat.de_json() method"""
+        print('Testing GroupChat.de_json()')
+
+        group_chat = telegram.GroupChat.de_json(self.json_dict)
+
+        self.assertEqual(group_chat.id, self.id)
+        self.assertEqual(group_chat.title, self.title)
+        self.assertEqual(group_chat.type, self.type)
+
+    def test_group_chat_to_json(self):
+        """Test GroupChat.to_json() method"""
+        print('Testing GroupChat.to_json()')
+
+        group_chat = telegram.GroupChat.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(group_chat.to_json()))
+
+    def test_group_chat_to_dict(self):
+        """Test GroupChat.to_dict() method"""
+        print('Testing GroupChat.to_dict()')
+
+        group_chat = telegram.GroupChat.de_json(self.json_dict)
+
+        self.assertTrue(self.is_dict(group_chat.to_dict()))
+        self.assertEqual(group_chat['id'], self.id)
+        self.assertEqual(group_chat['title'], self.title)
+        self.assertEqual(group_chat['type'], self.type)
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_location.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram Location"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class LocationTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram Location."""
+
+    def setUp(self):
+        self.latitude = -23.691288
+        self.longitude = -46.788279
+
+        self.json_dict = {
+            'latitude': self.latitude,
+            'longitude': self.longitude
+        }
+
+    def test_send_location_implicit_args(self):
+        """Test telegram.Bot sendLocation method"""
+        print('Testing bot.sendLocation - Implicit arguments')
+
+        message = self._bot.sendLocation(self._chat_id,
+                                         self.latitude,
+                                         self.longitude)
+
+        location = message.location
+
+        self.assertEqual(location.latitude, self.latitude)
+        self.assertEqual(location.longitude, self.longitude)
+
+    def test_send_location_explicit_args(self):
+        """Test telegram.Bot sendLocation method"""
+        print('Testing bot.sendLocation - Explicit arguments')
+
+        message = self._bot.sendLocation(chat_id=self._chat_id,
+                                         latitude=self.latitude,
+                                         longitude=self.longitude)
+
+        location = message.location
+
+        self.assertEqual(location.latitude, self.latitude)
+        self.assertEqual(location.longitude, self.longitude)
+
+    def test_location_de_json(self):
+        """Test Location.de_json() method"""
+        print('Testing Location.de_json()')
+
+        location = telegram.Location.de_json(self.json_dict)
+
+        self.assertEqual(location.latitude, self.latitude)
+        self.assertEqual(location.longitude, self.longitude)
+
+    def test_location_to_json(self):
+        """Test Location.to_json() method"""
+        print('Testing Location.to_json()')
+
+        location = telegram.Location.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(location.to_json()))
+
+    def test_location_to_dict(self):
+        """Test Location.to_dict() method"""
+        print('Testing Location.to_dict()')
+
+        location = telegram.Location.de_json(self.json_dict)
+
+        self.assertEqual(location['latitude'], self.latitude)
+        self.assertEqual(location['longitude'], self.longitude)
+
+    def test_error_send_location_empty_args(self):
+        print('Testing bot.sendLocation - Empty arguments')
+
+        json_dict = self.json_dict
+
+        json_dict['latitude'] = ''
+        json_dict['longitude'] = ''
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendLocation(chat_id=self._chat_id,
+                                                         **json_dict))
+
+    def test_error_location_without_required_args(self):
+        print('Testing bot.sendLocation - Without required arguments')
+
+        json_dict = self.json_dict
+
+        del(json_dict['latitude'])
+        del(json_dict['longitude'])
+
+        self.assertRaises(TypeError,
+                          lambda: self._bot.sendLocation(chat_id=self._chat_id,
+                                                         **json_dict))
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_sticker.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram Sticker"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class StickerTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram Sticker."""
+
+    def setUp(self):
+        self.sticker_file_id = 'BQADAQADHAADyIsGAAFZfq1bphjqlgI'
+        self.width = 510
+        self.height = 512
+        self.thumb = {'width': 90,
+                      'height': 90,
+                      'file_id': 'BQADAQADoQADHyP1B0mzJMVyzcB0Ag',
+                      'file_size': 2364}
+        self.file_size = 39518
+
+        self.json_dict = {
+            'file_id': self.sticker_file_id,
+            'width': self.width,
+            'height': self.height,
+            'thumb': self.thumb,
+            'file_size': self.file_size
+        }
+
+    def test_send_sticker_file(self):
+        pass
+
+    def test_send_sticker_resend(self):
+        """Test telegram.Bot sendSticker method"""
+        print('Testing bot.sendSticker - Resend by file_id')
+
+        message = self._bot.sendSticker(chat_id=self._chat_id,
+                                         sticker=self.sticker_file_id)
+
+        sticker = message.sticker
+
+        self.assertEqual(sticker.file_id, self.sticker_file_id)
+        self.assertEqual(sticker.width, self.width)
+        self.assertEqual(sticker.height, self.height)
+        self.assertTrue(isinstance(sticker.thumb, telegram.PhotoSize))
+        self.assertEqual(sticker.file_size, self.file_size)
+
+    def test_sticker_de_json(self):
+        """Test Sticker.de_json() method"""
+        print('Testing Sticker.de_json()')
+
+        sticker = telegram.Sticker.de_json(self.json_dict)
+
+        self.assertEqual(sticker.file_id, self.sticker_file_id)
+        self.assertEqual(sticker.width, self.width)
+        self.assertEqual(sticker.height, self.height)
+        self.assertTrue(isinstance(sticker.thumb, telegram.PhotoSize))
+        self.assertEqual(sticker.file_size, self.file_size)
+
+    def test_sticker_to_json(self):
+        """Test Sticker.to_json() method"""
+        print('Testing Sticker.to_json()')
+
+        sticker = telegram.Sticker.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(sticker.to_json()))
+
+    def test_sticker_to_dict(self):
+        """Test Sticker.to_dict() method"""
+        print('Testing Sticker.to_dict()')
+
+        sticker = telegram.Sticker.de_json(self.json_dict)
+
+        self.assertEqual(sticker['file_id'], self.sticker_file_id)
+        self.assertEqual(sticker['width'], self.width)
+        self.assertEqual(sticker['height'], self.height)
+        self.assertTrue(isinstance(sticker['thumb'], telegram.PhotoSize))
+        self.assertEqual(sticker['file_size'], self.file_size)
+
+    def test_error_send_sticker_empty_file(self):
+        print('Testing bot.sendSticker - Null file')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        json_dict['sticker'] = open(os.devnull, 'rb')
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendSticker(chat_id=self._chat_id,
+                                                        **json_dict))
+
+    def test_error_send_sticker_empty_file_id(self):
+        print('Testing bot.sendSticker - Empty file_id')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        json_dict['sticker'] = ''
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendSticker(chat_id=self._chat_id,
+                                                         **json_dict))
+
+    def test_error_sticker_without_required_args(self):
+        print('Testing bot.sendSticker - Without required arguments')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+
+        self.assertRaises(TypeError,
+                          lambda: self._bot.sendSticker(chat_id=self._chat_id,
+                                                         **json_dict))
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_update.py

@@ -0,0 +1,80 @@
+  #!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram Update"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class UpdateTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram Update."""
+
+    def setUp(self):
+        self.update_id = 868573637
+        self.message = {'message_id': 319,
+                        'from': {'id': 12173560,
+                                 'first_name': "Leandro",
+                                 'last_name': "S.",
+                                 'username': "leandrotoledo"},
+                        'chat': {'id': 12173560,
+                                 'first_name': "Leandro",
+                                 'last_name': "S.",
+                                 'username': "leandrotoledo"},
+                        'date': 1441644592,
+                        'text': "Update Test"}
+
+        self.json_dict = {
+            'update_id': self.update_id,
+            'message': self.message
+        }
+
+    def test_update_de_json(self):
+        """Test Update.de_json() method"""
+        print('Testing Update.de_json()')
+
+        update = telegram.Update.de_json(self.json_dict)
+
+        self.assertEqual(update.update_id, self.update_id)
+        self.assertTrue(isinstance(update.message, telegram.Message))
+
+    def test_update_to_json(self):
+        """Test Update.to_json() method"""
+        print('Testing Update.to_json()')
+
+        update = telegram.Update.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(update.to_json()))
+
+    def test_update_to_dict(self):
+        """Test Update.to_dict() method"""
+        print('Testing Update.to_dict()')
+
+        update = telegram.Update.de_json(self.json_dict)
+
+        self.assertTrue(self.is_dict(update.to_dict()))
+        self.assertEqual(update['update_id'], self.update_id)
+        self.assertTrue(isinstance(update['message'], telegram.Message))
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_user.py

@@ -0,0 +1,118 @@
+  #!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram User"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class UserTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram User."""
+
+    def setUp(self):
+        self.id = 12173560
+        self.first_name = "Leandro"
+        self.last_name = "S."
+        self.username = "leandrotoledo"
+        self.type = "private"
+
+        self.json_dict = {
+            'id': self.id,
+            'first_name': self.first_name,
+            'last_name': self.last_name,
+            'username': self.username,
+            'type': self.type
+        }
+
+    def test_user_de_json(self):
+        """Test User.de_json() method"""
+        print('Testing User.de_json()')
+
+        user = telegram.User.de_json(self.json_dict)
+
+        self.assertEqual(user.id, self.id)
+        self.assertEqual(user.first_name, self.first_name)
+        self.assertEqual(user.last_name, self.last_name)
+        self.assertEqual(user.username, self.username)
+        self.assertEqual(user.type, self.type)
+
+        self.assertEqual(user.name, '@leandrotoledo')
+
+    def test_user_de_json_without_username(self):
+        """Test User.de_json() method"""
+        print('Testing User.de_json() - Without username')
+
+        json_dict = self.json_dict
+
+        del(json_dict['username'])
+
+        user = telegram.User.de_json(self.json_dict)
+
+        self.assertEqual(user.id, self.id)
+        self.assertEqual(user.first_name, self.first_name)
+        self.assertEqual(user.last_name, self.last_name)
+        self.assertEqual(user.type, self.type)
+
+        self.assertEqual(user.name, '%s %s' % (self.first_name, self.last_name))
+
+
+    def test_user_de_json_without_username_and_lastname(self):
+        """Test User.de_json() method"""
+        print('Testing User.de_json() - Without username and last_name')
+
+        json_dict = self.json_dict
+
+        del(json_dict['username'])
+        del(json_dict['last_name'])
+
+        user = telegram.User.de_json(self.json_dict)
+
+        self.assertEqual(user.id, self.id)
+        self.assertEqual(user.first_name, self.first_name)
+
+        self.assertEqual(user.name, self.first_name)
+
+    def test_user_to_json(self):
+        """Test User.to_json() method"""
+        print('Testing User.to_json()')
+
+        user = telegram.User.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(user.to_json()))
+
+    def test_user_to_dict(self):
+        """Test User.to_dict() method"""
+        print('Testing User.to_dict()')
+
+        user = telegram.User.de_json(self.json_dict)
+
+        self.assertTrue(self.is_dict(user.to_dict()))
+        self.assertEqual(user['id'], self.id)
+        self.assertEqual(user['first_name'], self.first_name)
+        self.assertEqual(user['last_name'], self.last_name)
+        self.assertEqual(user['username'], self.username)
+        self.assertEqual(user['type'], self.type)
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_video.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram Video"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class VideoTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram Video."""
+
+    def setUp(self):
+        self.video_file = open('tests/data/telegram.mp4', 'rb')
+        self.video_file_id = 'BAADAQADXwADHyP1BwJFTcmY2RYCAg'
+        self.width = 360
+        self.height = 640
+        self.duration = 4
+        self.thumb = telegram.PhotoSize.de_json({})
+        self.mime_type = 'video/mp4'
+        self.file_size = 326534
+
+        # caption is part of sendVideo method but not Video object
+        self.caption = u'VideoTest - Caption'
+
+        self.json_dict = {
+            'file_id': self.video_file_id,
+            'width': self.width,
+            'height': self.height,
+            'duration': self.duration,
+            'thumb': self.thumb,
+            'mime_type': self.mime_type,
+            'file_size': self.file_size
+        }
+
+    def test_send_video_required_args_only(self):
+        """Test telegram.Bot sendVideo method"""
+        print('Testing bot.sendVideo - With required arguments only')
+
+        message = self._bot.sendVideo(self._chat_id,
+                                      self.video_file)
+
+        video = message.video
+
+        self.assertTrue(isinstance(video.file_id, str))
+        self.assertNotEqual(video.file_id, '')
+        self.assertEqual(video.width, 0)
+        self.assertEqual(video.height, 0)
+        self.assertEqual(video.duration, 0)
+        self.assertEqual(video.thumb, None)
+        self.assertEqual(video.mime_type, '')
+        self.assertEqual(video.file_size, self.file_size)
+
+    def test_send_video_all_args(self):
+        """Test telegram.Bot sendAudio method"""
+        print('Testing bot.sendVideo - With all arguments')
+
+        message = self._bot.sendVideo(self._chat_id,
+                                      self.video_file,
+                                      duration=self.duration,
+                                      caption=self.caption)
+
+        video = message.video
+
+        self.assertTrue(isinstance(video.file_id, str))
+        self.assertNotEqual(video.file_id, '')
+        self.assertEqual(video.width, 0)
+        self.assertEqual(video.height, 0)
+        self.assertEqual(video.duration, self.duration)
+        self.assertEqual(video.thumb, None)
+        self.assertEqual(video.mime_type, '')
+        self.assertEqual(video.file_size, self.file_size)
+
+        self.assertEqual(message.caption, self.caption)
+
+    def test_send_video_mp4_file(self):
+        """Test telegram.Bot sendVideo method"""
+        print('Testing bot.sendVideo - MP4 File')
+
+        message = self._bot.sendVideo(chat_id=self._chat_id,
+                                      video=self.video_file,
+                                      duration=self.duration,
+                                      caption=self.caption)
+
+        video = message.video
+
+        self.assertTrue(isinstance(video.file_id, str))
+        self.assertNotEqual(video.file_id, '')
+        self.assertEqual(video.width, 0)
+        self.assertEqual(video.height, 0)
+        self.assertEqual(video.duration, self.duration)
+        self.assertEqual(video.thumb, None)
+        self.assertEqual(video.mime_type, '')
+        self.assertEqual(video.file_size, self.file_size)
+
+        self.assertEqual(message.caption, self.caption)
+
+    def test_send_video_mp4_file_with_custom_filename(self):
+        """Test telegram.Bot sendVideo method"""
+        print('Testing bot.sendVideo - MP4 File with custom filename')
+
+        message = self._bot.sendVideo(chat_id=self._chat_id,
+                                      video=self.video_file,
+                                      duration=self.duration,
+                                      caption=self.caption,
+                                      filename='telegram_custom.mp4')
+
+        video = message.video
+
+        self.assertTrue(isinstance(video.file_id, str))
+        self.assertNotEqual(video.file_id, '')
+        self.assertEqual(video.width, 0)
+        self.assertEqual(video.height, 0)
+        self.assertEqual(video.duration, self.duration)
+        self.assertEqual(video.thumb, None)
+        self.assertEqual(video.mime_type, '')
+        self.assertEqual(video.file_size, self.file_size)
+
+        self.assertEqual(message.caption, self.caption)
+
+    def test_send_video_resend(self):
+        """Test telegram.Bot sendVideo method"""
+        print('Testing bot.sendVideo - Resend by file_id')
+
+        message = self._bot.sendVideo(chat_id=self._chat_id,
+                                      video=self.video_file_id,
+                                      duration=self.duration,
+                                      caption=self.caption)
+
+        video = message.video
+
+        self.assertEqual(video.file_id, self.video_file_id)
+        self.assertEqual(video.duration, 0)
+        self.assertEqual(video.thumb, None)
+        self.assertEqual(video.mime_type, '')
+
+        self.assertEqual(message.caption, self.caption)
+
+    def test_video_de_json(self):
+        """Test Video.de_json() method"""
+        print('Testing Video.de_json()')
+
+        video = telegram.Video.de_json(self.json_dict)
+
+        self.assertEqual(video.file_id, self.video_file_id)
+        self.assertEqual(video.width, self.width)
+        self.assertEqual(video.height, self.height)
+        self.assertEqual(video.duration, self.duration)
+        self.assertEqual(video.thumb, None)
+        self.assertEqual(video.mime_type, self.mime_type)
+        self.assertEqual(video.file_size, self.file_size)
+
+    def test_video_to_json(self):
+        """Test Video.to_json() method"""
+        print('Testing Video.to_json()')
+
+        video = telegram.Video.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(video.to_json()))
+
+    def test_video_to_dict(self):
+        """Test Video.to_dict() method"""
+        print('Testing Video.to_dict()')
+
+        video = telegram.Video.de_json(self.json_dict)
+
+        self.assertTrue(self.is_dict(video.to_dict()))
+        self.assertEqual(video['file_id'], self.video_file_id)
+        self.assertEqual(video['width'], self.width)
+        self.assertEqual(video['height'], self.height)
+        self.assertEqual(video['duration'], self.duration)
+        self.assertEqual(video['mime_type'], self.mime_type)
+        self.assertEqual(video['file_size'], self.file_size)
+
+    def test_error_send_video_empty_file(self):
+        print('Testing bot.sendVideo - Null file')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        json_dict['video'] = open(os.devnull, 'rb')
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendVideo(chat_id=self._chat_id,
+                                                      **json_dict))
+
+    def test_error_send_video_empty_file_id(self):
+        print('Testing bot.sendVideo - Empty file_id')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        json_dict['video'] = ''
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendVideo(chat_id=self._chat_id,
+                                                      **json_dict))
+
+    def test_error_video_without_required_args(self):
+        print('Testing bot.sendVideo - Without required arguments')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        del(json_dict['duration'])
+
+        self.assertRaises(TypeError,
+                          lambda: self._bot.sendVideo(chat_id=self._chat_id,
+                                                      **json_dict))
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_voice.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python
+#
+# A library that provides a Python interface to the Telegram Bot API
+# Copyright (C) 2015 Leandro Toledo de Souza <leandrotoeldodesouza@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see [http://www.gnu.org/licenses/].
+
+"""This module contains a object that represents Tests for Telegram Voice"""
+
+import os
+import unittest
+import sys
+sys.path.append('.')
+
+import telegram
+from tests.base import BaseTest
+
+
+class VoiceTest(BaseTest, unittest.TestCase):
+    """This object represents Tests for Telegram Voice."""
+
+    def setUp(self):
+        self.voice_file = open('tests/data/telegram.ogg', 'rb')
+        self.voice_file_id = 'AwADAQADTgADHyP1B_mbw34svXPHAg'
+        self.duration = 0
+        self.mime_type = 'audio/ogg'
+        self.file_size = 9199
+
+        self.json_dict = {
+            'file_id': self.voice_file_id,
+            'duration': self.duration,
+            'mime_type': self.mime_type,
+            'file_size': self.file_size
+        }
+
+    def test_send_voice_required_args_only(self):
+        """Test telegram.Bot sendVoice method"""
+        print('Testing bot.sendVoice - With required arguments only')
+
+        message = self._bot.sendVoice(self._chat_id,
+                                      self.voice_file)
+
+        voice = message.voice
+
+        self.assertTrue(isinstance(voice.file_id, str))
+        self.assertNotEqual(voice.file_id, '')
+        self.assertEqual(voice.duration, self.duration)
+        self.assertEqual(voice.mime_type, self.mime_type)
+        self.assertEqual(voice.file_size, self.file_size)
+
+    def test_send_voice_all_args(self):
+        """Test telegram.Bot sendAudio method"""
+        print('Testing bot.sendVoice - With all arguments')
+
+        message = self._bot.sendVoice(self._chat_id,
+                                      self.voice_file,
+                                      self.duration,
+                                      mime_type=self.mime_type,
+                                      file_size=self.file_size)
+
+        voice = message.voice
+
+        self.assertTrue(isinstance(voice.file_id, str))
+        self.assertNotEqual(voice.file_id, '')
+        self.assertEqual(voice.duration, self.duration)
+        self.assertEqual(voice.mime_type, self.mime_type)
+        self.assertEqual(voice.file_size, self.file_size)
+
+    def test_send_voice_ogg_file(self):
+        """Test telegram.Bot sendVoice method"""
+        print('Testing bot.sendVoice - Ogg File')
+
+        message = self._bot.sendVoice(chat_id=self._chat_id,
+                                      voice=self.voice_file,
+                                      duration=self.duration)
+
+        voice = message.voice
+
+        self.assertTrue(isinstance(voice.file_id, str))
+        self.assertNotEqual(voice.file_id, '')
+        self.assertEqual(voice.duration, self.duration)
+        self.assertEqual(voice.mime_type, self.mime_type)
+        self.assertEqual(voice.file_size, self.file_size)
+
+    def test_send_voice_ogg_file_with_custom_filename(self):
+        """Test telegram.Bot sendVoice method"""
+        print('Testing bot.sendVoice - Ogg File with custom filename')
+
+        message = self._bot.sendVoice(chat_id=self._chat_id,
+                                      voice=self.voice_file,
+                                      duration=self.duration,
+                                      filename='telegram_custom.ogg')
+
+        voice = message.voice
+
+        self.assertTrue(isinstance(voice.file_id, str))
+        self.assertNotEqual(voice.file_id, '')
+        self.assertEqual(voice.duration, self.duration)
+        self.assertEqual(voice.mime_type, self.mime_type)
+        self.assertEqual(voice.file_size, self.file_size)
+
+    def test_send_voice_resend(self):
+        """Test telegram.Bot sendVoice method"""
+        print('Testing bot.sendVoice - Resend by file_id')
+
+        message = self._bot.sendVoice(chat_id=self._chat_id,
+                                      voice=self.voice_file_id,
+                                      duration=self.duration)
+
+        voice = message.voice
+
+        self.assertEqual(voice.file_id, self.voice_file_id)
+        self.assertEqual(voice.duration, self.duration)
+        self.assertEqual(voice.mime_type, self.mime_type)
+
+    def test_voice_de_json(self):
+        """Test Voice.de_json() method"""
+        print('Testing Voice.de_json()')
+
+        voice = telegram.Voice.de_json(self.json_dict)
+
+        self.assertEqual(voice.file_id, self.voice_file_id)
+        self.assertEqual(voice.duration, self.duration)
+        self.assertEqual(voice.mime_type, self.mime_type)
+        self.assertEqual(voice.file_size, self.file_size)
+
+    def test_voice_to_json(self):
+        """Test Voice.to_json() method"""
+        print('Testing Voice.to_json()')
+
+        voice = telegram.Voice.de_json(self.json_dict)
+
+        self.assertTrue(self.is_json(voice.to_json()))
+
+    def test_voice_to_dict(self):
+        """Test Voice.to_dict() method"""
+        print('Testing Voice.to_dict()')
+
+        voice = telegram.Voice.de_json(self.json_dict)
+
+        self.assertTrue(self.is_dict(voice.to_dict()))
+        self.assertEqual(voice['file_id'], self.voice_file_id)
+        self.assertEqual(voice['duration'], self.duration)
+        self.assertEqual(voice['mime_type'], self.mime_type)
+        self.assertEqual(voice['file_size'], self.file_size)
+
+    def test_error_send_voice_empty_file(self):
+        print('Testing bot.sendVoice - Null file')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        json_dict['voice'] = open(os.devnull, 'rb')
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendVoice(chat_id=self._chat_id,
+                                                      **json_dict))
+
+    def test_error_send_voice_empty_file_id(self):
+        print('Testing bot.sendVoice - Empty file_id')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        json_dict['voice'] = ''
+
+        self.assertRaises(telegram.TelegramError,
+                          lambda: self._bot.sendVoice(chat_id=self._chat_id,
+                                                      **json_dict))
+
+    def test_error_voice_without_required_args(self):
+        print('Testing bot.sendVoice - Without required arguments')
+
+        json_dict = self.json_dict
+
+        del(json_dict['file_id'])
+        del(json_dict['duration'])
+
+        self.assertRaises(TypeError,
+                          lambda: self._bot.sendVoice(chat_id=self._chat_id,
+                                                      **json_dict))
+
+if __name__ == '__main__':
+    unittest.main()