def de_json(data, bot):
        """
        Args:
            data (dict):
            bot (telegram.Bot):

        Returns:
            telegram.Update:
        """
        if not data:
            return None

        data = super(Update, Update).de_json(data, bot)

        data['message'] = Message.de_json(data.get('message'), bot)
        data['edited_message'] = Message.de_json(data.get('edited_message'), bot)
        data['inline_query'] = InlineQuery.de_json(data.get('inline_query'), bot)
        data['chosen_inline_result'] = ChosenInlineResult.de_json(
            data.get('chosen_inline_result'), bot)
        data['callback_query'] = CallbackQuery.de_json(data.get('callback_query'), bot)
        data['shipping_query'] = ShippingQuery.de_json(data.get('shipping_query'), bot)
        data['pre_checkout_query'] = PreCheckoutQuery.de_json(data.get('pre_checkout_query'), bot)
        data['channel_post'] = Message.de_json(data.get('channel_post'), bot)
        data['edited_channel_post'] = Message.de_json(data.get('edited_channel_post'), bot)

        return Update(**data)
Esempio n. 2
0
    def get_inline_query(self,
                         user=None,
                         query=None,
                         offset=None,
                         location=None):
        """

        Returns a telegram.Update object containing a inline_query.


        Parameters:
            location (Optional[telegram.Location or True]): simulates a location
            offset (Optional[str]):
            query (Optional[str]):
            user (Optional[telegram.User): If omitted will be randomly generated

        Returns:
            telegram.Update: an update containing a :py:class:`telegram.InlineQuery`

        """

        if user:
            if not isinstance(user, User):
                raise BadUserException
        else:
            user = self.ug.get_user()

        if query:
            if not isinstance(query, str):
                raise AttributeError("query must be string")

        if offset:
            if not isinstance(offset, str):
                raise AttributeError("offset must be string")

        if location:
            if isinstance(location, Location):
                pass
            elif isinstance(location, bool):
                import random
                location = Location(random.uniform(-180, 180),
                                    random.uniform(-90, 90))
            else:
                raise AttributeError(
                    "Location must be either telegram.Location or True")

        return InlineQuery(self._gen_id(),
                           from_user=user,
                           query=query,
                           offset=offset,
                           location=location,
                           bot=self.bot)
Esempio n. 3
0
def get_false_update_fixture_decorator_params():
    message = Message(1, DATE, Chat(1, ''), from_user=User(1, '', False), text='test')
    params = [
        {'callback_query': CallbackQuery(1, User(1, '', False), 'chat', message=message)},
        {'channel_post': message},
        {'edited_channel_post': message},
        {'inline_query': InlineQuery(1, User(1, '', False), '', '')},
        {'chosen_inline_result': ChosenInlineResult('id', User(1, '', False), '')},
        {'shipping_query': ShippingQuery('id', User(1, '', False), '', None)},
        {'pre_checkout_query': PreCheckoutQuery('id', User(1, '', False), '', 0, '')},
        {'callback_query': CallbackQuery(1, User(1, '', False), 'chat')},
    ]
    ids = tuple(key for kwargs in params for key in kwargs)
    return {'params': params, 'ids': ids}
    def test_de_json(self, bot):
        json_dict = {
            'id': self.id,
            'from': self.from_user.to_dict(),
            'query': self.query,
            'offset': self.offset,
            'location': self.location.to_dict()
        }
        inline_query_json = InlineQuery.de_json(json_dict, bot)

        assert inline_query_json.id == self.id
        assert inline_query_json.from_user == self.from_user
        assert inline_query_json.location == self.location
        assert inline_query_json.query == self.query
        assert inline_query_json.offset == self.offset
    def test_de_json(self, bot):
        json_dict = {
            'id': self.id,
            'from': self.from_user.to_dict(),
            'query': self.query,
            'offset': self.offset,
            'location': self.location.to_dict()
        }
        inline_query_json = InlineQuery.de_json(json_dict, bot)

        assert inline_query_json.id == self.id
        assert inline_query_json.from_user == self.from_user
        assert inline_query_json.location == self.location
        assert inline_query_json.query == self.query
        assert inline_query_json.offset == self.offset
    def test_de_json(self, bot):
        json_dict = {
            "id": self.id_,
            "from": self.from_user.to_dict(),
            "query": self.query,
            "offset": self.offset,
            "location": self.location.to_dict(),
        }
        inline_query_json = InlineQuery.de_json(json_dict, bot)

        assert inline_query_json.id == self.id_
        assert inline_query_json.from_user == self.from_user
        assert inline_query_json.location == self.location
        assert inline_query_json.query == self.query
        assert inline_query_json.offset == self.offset
Esempio n. 7
0
 def test_all_update_types(self, dp, bot, user1):
     handler = ConversationHandler(entry_points=[CommandHandler('start', self.start_end)],
                                   states={}, fallbacks=[])
     message = Message(0, user1, None, self.group, text='ignore', bot=bot)
     callback_query = CallbackQuery(0, user1, None, message=message, data='data', bot=bot)
     chosen_inline_result = ChosenInlineResult(0, user1, 'query', bot=bot)
     inline_query = InlineQuery(0, user1, 'query', 0, bot=bot)
     pre_checkout_query = PreCheckoutQuery(0, user1, 'USD', 100, [], bot=bot)
     shipping_query = ShippingQuery(0, user1, [], None, bot=bot)
     assert not handler.check_update(Update(0, callback_query=callback_query))
     assert not handler.check_update(Update(0, chosen_inline_result=chosen_inline_result))
     assert not handler.check_update(Update(0, inline_query=inline_query))
     assert not handler.check_update(Update(0, message=message))
     assert not handler.check_update(Update(0, pre_checkout_query=pre_checkout_query))
     assert not handler.check_update(Update(0, shipping_query=shipping_query))
Esempio n. 8
0
    def de_json(data):
        """
        Args:
            data (dict):

        Returns:
            telegram.Update:
        """
        if not data:
            return None

        data['message'] = Message.de_json(data.get('message'))
        data['inline_query'] = InlineQuery.de_json(data.get('inline_query'))
        data['chosen_inline_result'] = \
            ChosenInlineResult.de_json(data.get('chosen_inline_result'))

        return Update(**data)
Esempio n. 9
0
    def de_json(data):
        """
        Args:
            data (dict):

        Returns:
            telegram.Update:
        """
        if not data:
            return None

        data['message'] = Message.de_json(data.get('message'))
        data['inline_query'] = InlineQuery.de_json(data.get('inline_query'))
        data['chosen_inline_result'] = \
            ChosenInlineResult.de_json(data.get('chosen_inline_result'))

        return Update(**data)
Esempio n. 10
0
    def de_json(cls, data, bot):
        if not data:
            return None

        data = super(Update, cls).de_json(data, bot)

        data['message'] = Message.de_json(data.get('message'), bot)
        data['edited_message'] = Message.de_json(data.get('edited_message'), bot)
        data['inline_query'] = InlineQuery.de_json(data.get('inline_query'), bot)
        data['chosen_inline_result'] = ChosenInlineResult.de_json(
            data.get('chosen_inline_result'), bot)
        data['callback_query'] = CallbackQuery.de_json(data.get('callback_query'), bot)
        data['shipping_query'] = ShippingQuery.de_json(data.get('shipping_query'), bot)
        data['pre_checkout_query'] = PreCheckoutQuery.de_json(data.get('pre_checkout_query'), bot)
        data['channel_post'] = Message.de_json(data.get('channel_post'), bot)
        data['edited_channel_post'] = Message.de_json(data.get('edited_channel_post'), bot)

        return cls(**data)
Esempio n. 11
0
    def de_json(cls, data, bot):
        if not data:
            return None

        data = super(Update, cls).de_json(data, bot)

        data['message'] = Message.de_json(data.get('message'), bot)
        data['edited_message'] = Message.de_json(data.get('edited_message'), bot)
        data['inline_query'] = InlineQuery.de_json(data.get('inline_query'), bot)
        data['chosen_inline_result'] = ChosenInlineResult.de_json(
            data.get('chosen_inline_result'), bot)
        data['callback_query'] = CallbackQuery.de_json(data.get('callback_query'), bot)
        data['shipping_query'] = ShippingQuery.de_json(data.get('shipping_query'), bot)
        data['pre_checkout_query'] = PreCheckoutQuery.de_json(data.get('pre_checkout_query'), bot)
        data['channel_post'] = Message.de_json(data.get('channel_post'), bot)
        data['edited_channel_post'] = Message.de_json(data.get('edited_channel_post'), bot)

        return cls(**data)
Esempio n. 12
0
    def de_json(cls, data: Optional[JSONDict], bot: 'Bot') -> Optional['Update']:
        data = cls.parse_data(data)

        if not data:
            return None

        data['message'] = Message.de_json(data.get('message'), bot)
        data['edited_message'] = Message.de_json(data.get('edited_message'), bot)
        data['inline_query'] = InlineQuery.de_json(data.get('inline_query'), bot)
        data['chosen_inline_result'] = ChosenInlineResult.de_json(
            data.get('chosen_inline_result'), bot)
        data['callback_query'] = CallbackQuery.de_json(data.get('callback_query'), bot)
        data['shipping_query'] = ShippingQuery.de_json(data.get('shipping_query'), bot)
        data['pre_checkout_query'] = PreCheckoutQuery.de_json(data.get('pre_checkout_query'), bot)
        data['channel_post'] = Message.de_json(data.get('channel_post'), bot)
        data['edited_channel_post'] = Message.de_json(data.get('edited_channel_post'), bot)
        data['poll'] = Poll.de_json(data.get('poll'), bot)
        data['poll_answer'] = PollAnswer.de_json(data.get('poll_answer'), bot)

        return cls(**data)
    def test_regexGroupHandlerInlineQuery(self):
        self._setup_updater('', messages=0)
        d = self.updater.dispatcher
        handler = InlineQueryHandler(
            self.regexGroupHandlerTest,
            pattern='^(This).*?(?P<testgroup>regex group).*',
            pass_groupdict=True,
            pass_groups=True)
        d.add_handler(handler)
        queue = self.updater.start_polling(0.01)
        queue.put(
            Update(
                update_id=0,
                inline_query=InlineQuery(
                    0, None, 'This is a test message for regex group matching.', None)))

        sleep(.1)
        self.assertEqual(self.received_message, (('This', 'regex group'), {
            'testgroup': 'regex group'
        }))
Esempio n. 14
0
    def de_json(data, bot):
        """
        Args:
            data (dict):
            bot (telegram.Bot):

        Returns:
            telegram.Update:
        """
        if not data:
            return None

        data['message'] = Message.de_json(data.get('message'), bot)
        data['edited_message'] = Message.de_json(data.get('edited_message'), bot)
        data['inline_query'] = InlineQuery.de_json(data.get('inline_query'), bot)
        data['chosen_inline_result'] = ChosenInlineResult.de_json(
            data.get('chosen_inline_result'), bot)
        data['callback_query'] = CallbackQuery.de_json(data.get('callback_query'), bot)

        return Update(**data)
Esempio n. 15
0
    def test_regex_handler_without_message(self):
        self._setup_updater('Test3')
        d = self.updater.dispatcher
        handler = RegexHandler(r'Te.*', self.telegramHandlerTest)
        d.add_handler(handler)

        # message, no text
        m = Message(1,
                    User(1, "testuser"),
                    None,
                    Chat(2, "private"),
                    video="My_vid",
                    caption="test ")
        d.process_update(Update(1, message=m))
        self.assertEqual(self.message_count, 0)

        # no message
        c = InlineQuery(2, User(1, "testuser"), "my_query", offset=15)
        d.process_update(Update(2, inline_query=c))
        self.assertEqual(self.message_count, 0)
Esempio n. 16
0
    def de_json(cls, data, bot):
        if not data:
            return None

        data = super(Update, cls).de_json(data, bot)

        message = data.get_products('message')
        if message:
            message['default_quote'] = data.get_products('default_quote')
        data['message'] = Message.de_json(message, bot)
        edited_message = data.get_products('edited_message')
        if edited_message:
            edited_message['default_quote'] = data.get_products(
                'default_quote')
        data['edited_message'] = Message.de_json(edited_message, bot)
        data['inline_query'] = InlineQuery.de_json(
            data.get_products('inline_query'), bot)
        data['chosen_inline_result'] = ChosenInlineResult.de_json(
            data.get_products('chosen_inline_result'), bot)
        callback_query = data.get_products('callback_query')
        if callback_query:
            callback_query['default_quote'] = data.get_products(
                'default_quote')
        data['callback_query'] = CallbackQuery.de_json(callback_query, bot)
        data['shipping_query'] = ShippingQuery.de_json(
            data.get_products('shipping_query'), bot)
        data['pre_checkout_query'] = PreCheckoutQuery.de_json(
            data.get_products('pre_checkout_query'), bot)
        channel_post = data.get_products('channel_post')
        if channel_post:
            channel_post['default_quote'] = data.get_products('default_quote')
        data['channel_post'] = Message.de_json(channel_post, bot)
        edited_channel_post = data.get_products('edited_channel_post')
        if edited_channel_post:
            edited_channel_post['default_quote'] = data.get_products(
                'default_quote')
        data['edited_channel_post'] = Message.de_json(edited_channel_post, bot)
        data['poll'] = Poll.de_json(data.get_products('poll'), bot)

        return cls(**data)
def get_false_update_fixture_decorator_params():
    message = Message(1,
                      DATE,
                      Chat(1, ""),
                      from_user=User(1, "", False),
                      text="test")
    params = [
        {
            "callback_query":
            CallbackQuery(1, User(1, "", False), "chat", message=message)
        },
        {
            "channel_post": message
        },
        {
            "edited_channel_post": message
        },
        {
            "inline_query": InlineQuery(1, User(1, "", False), "", "")
        },
        {
            "chosen_inline_result":
            ChosenInlineResult("id", User(1, "", False), "")
        },
        {
            "shipping_query": ShippingQuery("id", User(1, "", False), "", None)
        },
        {
            "pre_checkout_query":
            PreCheckoutQuery("id", User(1, "", False), "", 0, "")
        },
        {
            "callback_query": CallbackQuery(1, User(1, "", False), "chat")
        },
    ]
    ids = tuple(key for kwargs in params for key in kwargs)
    return {"params": params, "ids": ids}
Esempio n. 18
0
# You should have received a copy of the GNU Lesser Public License
# along with this program.  If not, see [http://www.gnu.org/licenses/].

import pytest

from telegram import (Message, Update, Chat, Bot, User, CallbackQuery, InlineQuery,
                      ChosenInlineResult, ShippingQuery, PreCheckoutQuery)
from telegram.ext import CommandHandler, Filters

message = Message(1, User(1, ''), None, Chat(1, ''), text='test')

params = [
    {'callback_query': CallbackQuery(1, User(1, ''), 'chat', message=message)},
    {'channel_post': message},
    {'edited_channel_post': message},
    {'inline_query': InlineQuery(1, User(1, ''), '', '')},
    {'chosen_inline_result': ChosenInlineResult('id', User(1, ''), '')},
    {'shipping_query': ShippingQuery('id', User(1, ''), '', None)},
    {'pre_checkout_query': PreCheckoutQuery('id', User(1, ''), '', 0, '')},
    {'callback_query': CallbackQuery(1, User(1, ''), 'chat')}
]

ids = ('callback_query', 'channel_post', 'edited_channel_post', 'inline_query',
       'chosen_inline_result', 'shipping_query', 'pre_checkout_query',
       'callback_query_without_message',)


@pytest.fixture(scope='class', params=params, ids=ids)
def false_update(request):
    return Update(update_id=1, **request.param)
    },
    {
        "edited_message": message
    },
    {
        "callback_query":
        CallbackQuery(1, User(1, "", False), "chat", message=message)
    },
    {
        "channel_post": message
    },
    {
        "edited_channel_post": message
    },
    {
        "inline_query": InlineQuery(1, User(1, "", False), "", "")
    },
    {
        "chosen_inline_result": ChosenInlineResult("id", User(1, "", False),
                                                   "")
    },
    {
        "pre_checkout_query": PreCheckoutQuery("id", User(1, "", False), "", 0,
                                               "")
    },
    {
        "callback_query": CallbackQuery(1, User(1, "", False), "chat")
    },
]

ids = (
Esempio n. 20
0
    def test_no_chat(self, chat_creator_role, update):
        update.message = None
        update.inline_query = InlineQuery(1, User(0, 'TestUser', False),
                                          'query', 0)

        assert not chat_creator_role(update)
Esempio n. 21
0
def inline_query(bot):
    return InlineQuery(TestInlineQuery.id_, TestInlineQuery.from_user, TestInlineQuery.query,
                       TestInlineQuery.offset, location=TestInlineQuery.location, bot=bot)
Esempio n. 22
0
)
from telegram.ext import Filters, MessageHandler, CallbackContext, JobQueue, UpdateFilter

message = Message(1,
                  None,
                  Chat(1, ''),
                  from_user=User(1, '', False),
                  text='Text')

params = [
    {
        'callback_query':
        CallbackQuery(1, User(1, '', False), 'chat', message=message)
    },
    {
        'inline_query': InlineQuery(1, User(1, '', False), '', '')
    },
    {
        'chosen_inline_result': ChosenInlineResult('id', User(1, '', False),
                                                   '')
    },
    {
        'shipping_query': ShippingQuery('id', User(1, '', False), '', None)
    },
    {
        'pre_checkout_query': PreCheckoutQuery('id', User(1, '', False), '', 0,
                                               '')
    },
    {
        'callback_query': CallbackQuery(1, User(1, '', False), 'chat')
    },
def inline_query(bot):
    return Update(0, inline_query=InlineQuery('id', User(2, 'test user', False),
                                              'test query', offset='22',
                                              location=Location(latitude=-23.691288,
                                                                longitude=-46.788279)))
Esempio n. 24
0
def test_inline_query(patched_validate_token):
    patched_validate_token().return_value = True
    bot = Bot('token')
    test_user = User(1, is_bot=False, username='******', first_name='test')
    test_user_without_username = User(1, is_bot=False, first_name='test')

    result_list = []

    def patch_answer_inline_query(query_id, results, cache_time):
        result_list.append(results)

    with mock.patch.object(Bot,
                           'answer_inline_query',
                           side_effect=patch_answer_inline_query):
        # Modifier Query without Username
        query = TEST_QUERY_WITH_MODIFIER

        ilq = InlineQuery(1, test_user_without_username, '{0}'.format(query),
                          0)
        update = Update(0, inline_query=ilq)

        run.inlinequery(bot, update)

        received_results = result_list.pop()

        assert len(received_results) == 1
        actual_response = received_results[0].input_message_content[
            'message_text']
        expected_response = user_and_query_to_static_response(
            test_user_without_username, query)

        assert actual_response == expected_response

        # Modifier Query with Username
        query = TEST_QUERY_WITH_MODIFIER

        ilq = InlineQuery(1, test_user, '{0}'.format(query), 0)
        update = Update(0, inline_query=ilq)

        run.inlinequery(bot, update)

        received_results = result_list.pop()

        assert len(received_results) == 1
        actual_response = received_results[0].input_message_content[
            'message_text']
        expected_response = user_and_query_to_static_response(test_user, query)

        assert actual_response == expected_response

        # Non-Modifier Query
        query = TEST_QUERY_WITHOUT_MODIFIER

        ilq = InlineQuery(1, test_user, '{0}'.format(query), 0)
        update = Update(0, inline_query=ilq)

        run.inlinequery(bot, update)

        received_results = result_list.pop()

        assert len(received_results) == 3

        actual_response = received_results[0].input_message_content[
            'message_text']
        expected_response = user_and_query_to_static_response(test_user,
                                                              query,
                                                              advantage=True)
        assert actual_response == expected_response

        actual_response = received_results[1].input_message_content[
            'message_text']
        expected_response = user_and_query_to_static_response(
            test_user, query, disadvantage=True)
        assert actual_response == expected_response

        actual_response = received_results[2].input_message_content[
            'message_text']
        expected_response = user_and_query_to_static_response(test_user, query)

        assert actual_response == expected_response

        # Invalid Query
        query = TEST_QUERY_INVALID

        ilq = InlineQuery(1, test_user, '{0}'.format(query), 0)
        update = Update(0, inline_query=ilq)

        run.inlinequery(bot, update)

        received_results = result_list.pop()

        assert len(received_results) == 1
        actual_response = received_results[0].input_message_content[
            'message_text']
        expected_response = 'Query: {0}\n\n{1}'.format(
            query, run.INVALID_DICE_NOTATION_MSG)

        assert actual_response == expected_response