python-telegram-bot/tests/ext/test_commandhandler.py
Yao Kuan ebed8ec7d3
Add has_args Parameter to CommandHandler (#3854)
Co-authored-by: Yao Kuan <chan_yao_kuan@tech.gov.sg>
2023-08-23 21:28:36 +02:00

290 lines
12 KiB
Python

#!/usr/bin/env python
#
# A library that provides a Python interface to the Telegram Bot API
# Copyright (C) 2015-2023
# Leandro Toledo de Souza <devs@python-telegram-bot.org>
#
# 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/].
import asyncio
import re
import pytest
from telegram import Bot, Chat, Message, Update
from telegram.ext import CallbackContext, CommandHandler, JobQueue, filters
from tests.auxil.build_messages import (
make_command_message,
make_command_update,
make_message_update,
)
from tests.auxil.slots import mro_slots
def is_match(handler, update):
"""
Utility function that returns whether an update matched
against a specific handler.
:param handler: ``CommandHandler`` to check against
:param update: update to check
:return: (bool) whether ``update`` matched with ``handler``
"""
check = handler.check_update(update)
return check is not None and check is not False
class BaseTest:
"""Base class for command and prefix handler test classes. Contains
utility methods an several callbacks used by both classes."""
test_flag = False
SRE_TYPE = type(re.match("", ""))
@pytest.fixture(autouse=True)
def _reset(self):
self.test_flag = False
async def response(self, application, update):
"""
Utility to send an update to a dispatcher and assert
whether the callback was called appropriately. Its purpose is
for repeated usage in the same test function.
"""
self.test_flag = False
async with application:
await application.process_update(update)
return self.test_flag
def callback_basic(self, update, context):
test_bot = isinstance(context.bot, Bot)
test_update = isinstance(update, Update)
self.test_flag = test_bot and test_update
def make_callback_for(self, pass_keyword):
def callback(bot, update, **kwargs):
self.test_flag = kwargs.get(keyword) is not None
keyword = pass_keyword[5:]
return callback
async def callback(self, update, context):
self.test_flag = (
isinstance(context, CallbackContext)
and isinstance(context.bot, Bot)
and isinstance(update, Update)
and isinstance(context.update_queue, asyncio.Queue)
and isinstance(context.job_queue, JobQueue)
and isinstance(context.user_data, dict)
and isinstance(context.chat_data, dict)
and isinstance(context.bot_data, dict)
and isinstance(update.message, Message)
)
def callback_args(self, update, context):
self.test_flag = context.args == ["one", "two"]
def callback_regex1(self, update, context):
if context.matches:
types = all(type(res) is self.SRE_TYPE for res in context.matches)
num = len(context.matches) == 1
self.test_flag = types and num
def callback_regex2(self, update, context):
if context.matches:
types = all(type(res) is self.SRE_TYPE for res in context.matches)
num = len(context.matches) == 2
self.test_flag = types and num
async def _test_context_args_or_regex(self, app, handler, text):
app.add_handler(handler)
update = make_command_update(text, bot=app.bot)
assert not await self.response(app, update)
update = make_command_update(text + " one two", bot=app.bot)
assert await self.response(app, update)
def _test_edited(self, message, handler_edited, handler_not_edited):
"""
Assert whether a handler that should accept edited messages
and a handler that shouldn't work correctly.
:param message: ``telegram.Message`` to check against the handlers
:param handler_edited: handler that should accept edited messages
:param handler_not_edited: handler that should not accept edited messages
"""
update = make_command_update(message)
edited_update = make_command_update(message, edited=True)
assert is_match(handler_edited, update)
assert is_match(handler_edited, edited_update)
assert is_match(handler_not_edited, update)
assert not is_match(handler_not_edited, edited_update)
# ----------------------------- CommandHandler -----------------------------
class TestCommandHandler(BaseTest):
CMD = "/test"
def test_slot_behaviour(self):
handler = self.make_default_handler()
for attr in handler.__slots__:
assert getattr(handler, attr, "err") != "err", f"got extra slot '{attr}'"
assert len(mro_slots(handler)) == len(set(mro_slots(handler))), "duplicate slot"
@pytest.fixture(scope="class")
def command(self):
return self.CMD
@pytest.fixture(scope="class")
def command_message(self, command, bot):
return make_command_message(command, bot=bot)
@pytest.fixture(scope="class")
def command_update(self, command_message):
return make_command_update(command_message)
def make_default_handler(self, callback=None, **kwargs):
callback = callback or self.callback_basic
return CommandHandler(self.CMD[1:], callback, **kwargs)
async def test_basic(self, app, command):
"""Test whether a command handler responds to its command
and not to others, or badly formatted commands"""
handler = self.make_default_handler()
app.add_handler(handler)
assert await self.response(app, make_command_update(command, bot=app.bot))
assert not is_match(handler, make_command_update(command[1:], bot=app.bot))
assert not is_match(handler, make_command_update(f"/not{command[1:]}", bot=app.bot))
assert not is_match(handler, make_command_update(f"not {command} at start", bot=app.bot))
assert not is_match(
handler, make_message_update(bot=app.bot, message=None, caption="caption")
)
handler = CommandHandler(["FOO", "bAR"], callback=self.callback)
assert isinstance(handler.commands, frozenset)
assert handler.commands == {"foo", "bar"}
handler = CommandHandler(["FOO"], callback=self.callback)
assert isinstance(handler.commands, frozenset)
assert handler.commands == {"foo"}
@pytest.mark.parametrize(
"cmd",
["way_too_longcommand1234567yes_way_toooooooLong", "ïñválídletters", "invalid #&* chars"],
ids=["too long", "invalid letter", "invalid characters"],
)
def test_invalid_commands(self, cmd):
with pytest.raises(
ValueError, match=f"`{re.escape(cmd.lower())}` is not a valid bot command"
):
CommandHandler(cmd, self.callback_basic)
def test_command_list(self, bot):
"""A command handler with multiple commands registered should respond to all of them."""
handler = CommandHandler(["test", "star"], self.callback_basic)
assert is_match(handler, make_command_update("/test", bot=bot))
assert is_match(handler, make_command_update("/star", bot=bot))
assert not is_match(handler, make_command_update("/stop", bot=bot))
def test_edited(self, command_message):
"""Test that a CH responds to an edited message if its filters allow it"""
handler_edited = self.make_default_handler()
handler_no_edited = self.make_default_handler(filters=~filters.UpdateType.EDITED_MESSAGE)
self._test_edited(command_message, handler_edited, handler_no_edited)
def test_directed_commands(self, bot, command):
"""Test recognition of commands with a mention to the bot"""
handler = self.make_default_handler()
assert is_match(handler, make_command_update(command + "@" + bot.username, bot=bot))
assert not is_match(handler, make_command_update(command + "@otherbot", bot=bot))
def test_with_filter(self, command, bot):
"""Test that a CH with a (generic) filter responds if its filters match"""
handler = self.make_default_handler(filters=filters.ChatType.GROUP)
assert is_match(handler, make_command_update(command, chat=Chat(-23, Chat.GROUP), bot=bot))
assert not is_match(
handler, make_command_update(command, chat=Chat(23, Chat.PRIVATE), bot=bot)
)
async def test_newline(self, app, command):
"""Assert that newlines don't interfere with a command handler matching a message"""
handler = self.make_default_handler()
app.add_handler(handler)
update = make_command_update(command + "\nfoobar", bot=app.bot)
async with app:
assert is_match(handler, update)
assert await self.response(app, update)
def test_other_update_types(self, false_update):
"""Test that a command handler doesn't respond to unrelated updates"""
handler = self.make_default_handler()
assert not is_match(handler, false_update)
def test_filters_for_wrong_command(self, mock_filter, bot):
"""Filters should not be executed if the command does not match the handler"""
handler = self.make_default_handler(filters=mock_filter)
assert not is_match(handler, make_command_update("/star", bot=bot))
assert not mock_filter.tested
async def test_context(self, app, command_update):
"""Test correct behaviour of CHs with context-based callbacks"""
handler = self.make_default_handler(self.callback)
app.add_handler(handler)
assert await self.response(app, command_update)
async def test_context_args(self, app, command):
"""Test CHs that pass arguments through ``context``"""
handler = self.make_default_handler(self.callback_args)
await self._test_context_args_or_regex(app, handler, command)
async def test_context_regex(self, app, command):
"""Test CHs with context-based callbacks and a single filter"""
handler = self.make_default_handler(self.callback_regex1, filters=filters.Regex("one two"))
await self._test_context_args_or_regex(app, handler, command)
async def test_context_multiple_regex(self, app, command):
"""Test CHs with context-based callbacks and filters combined"""
handler = self.make_default_handler(
self.callback_regex2, filters=filters.Regex("one") & filters.Regex("two")
)
await self._test_context_args_or_regex(app, handler, command)
def test_command_has_args(self, bot):
"""Test CHs with optional has_args specified."""
handler_true = CommandHandler(["test"], self.callback_basic, has_args=True)
handler_false = CommandHandler(["test"], self.callback_basic, has_args=False)
handler_int_one = CommandHandler(["test"], self.callback_basic, has_args=1)
handler_int_two = CommandHandler(["test"], self.callback_basic, has_args=2)
assert is_match(handler_true, make_command_update("/test helloworld", bot=bot))
assert not is_match(handler_true, make_command_update("/test", bot=bot))
assert is_match(handler_false, make_command_update("/test", bot=bot))
assert not is_match(handler_false, make_command_update("/test helloworld", bot=bot))
assert is_match(handler_int_one, make_command_update("/test helloworld", bot=bot))
assert not is_match(handler_int_one, make_command_update("/test hello world", bot=bot))
assert not is_match(handler_int_one, make_command_update("/test", bot=bot))
assert is_match(handler_int_two, make_command_update("/test hello world", bot=bot))
assert not is_match(handler_int_two, make_command_update("/test helloworld", bot=bot))
assert not is_match(handler_int_two, make_command_update("/test", bot=bot))
def test_command_has_negative_args(self, bot):
"""Test CHs with optional has_args specified with negative int"""
# Assert that CommandHandler cannot be instantiated.
with pytest.raises(
ValueError, match="CommandHandler argument has_args cannot be a negative integer"
):
is_match(CommandHandler(["test"], self.callback_basic, has_args=-1))