def test_get_yes_no_filters_and_proceed(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text=YES)
message.chat = chat
update.message = message
data = c.get_yes_no_filters_and_proceed(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == TelegramConversation.STATUS.BUILD_FILTERS
message = Message(1, timezone.now(), chat=chat, text=NO)
message.chat = chat
update.message = message
data = c.get_yes_no_filters_and_proceed(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == TelegramConversation.STATUS.BUILD_AGGREGATE_YES_NO
def test_get_mode_show_mode_options_w_f_and_c(mocker):
log = logging.getLogger()
c = ConvTestFiltersCommands(log, 'created_at', suffix='dev')
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
mocker.patch('os.listdir', return_value=["x.py"])
update = Update(1)
chat = Chat(1, 'user')
message = Message(1,
timezone.now(),
chat=chat,
text=BTN_CAPTION_BUILD_QUERY)
message.chat = chat
update.message = message
data = c.get_mode_show_mode_options(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == TelegramConversation.STATUS.BUILD_PERIOD
message = Message(1,
timezone.now(),
chat=chat,
text=BTN_CAPTION_USE_SAVED_FILTER)
message.chat = chat
update.message = message
data = c.get_mode_show_mode_options(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == TelegramConversation.STATUS.SAVED_FILTER_SELECT
message = Message(1,
timezone.now(),
chat=chat,
text=BTN_CAPTION_CUSTOM_MGMT)
message.chat = chat
update.message = message
data = c.get_mode_show_mode_options(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == TelegramConversation.STATUS.CUSTOM_MGMT_COMMAND_SELECT
def test_execute_command_exception(mocker):
log = logging.getLogger()
c = ConvTestFiltersCommands(log, 'created_at', suffix='dev')
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
mocker.patch(
DJANGO_CALL_COMMAND,
side_effect=Exception('ERROR'),
)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text='10')
message.chat = chat
update.message = message
data = c.execute_custom_command(update, 'xx')
assert mock.called
assert mock.call_args[0] == ("``` Error xx:\nERROR ```", )
assert data is False
assert c.query_context == {
'mode': '',
'period': {
'uom': '',
'quantity': 0,
'timedelta': None,
},
'filters': [],
'aggregate': {
'type': '',
'property': '',
},
'saved': '',
'custom_command': '',
}
def test_conversation_handler_per_user(self, dp, bot, user1):
handler = ConversationHandler(entry_points=self.entry_points,
states=self.states,
fallbacks=self.fallbacks,
per_chat=False)
dp.add_handler(handler)
# User one, starts the state machine.
message = Message(0,
user1,
None,
self.group,
text='/start',
entities=[
MessageEntity(type=MessageEntity.BOT_COMMAND,
offset=0,
length=len('/start'))
],
bot=bot)
dp.process_update(Update(update_id=0, message=message))
# The user is thirsty and wants to brew coffee.
message.text = '/brew'
message.entities[0].length = len('/brew')
dp.process_update(Update(update_id=0, message=message))
# Let's now verify that for the same user in a different group, the state will still be
# updated
message.chat = self.second_group
message.text = '/pourCoffee'
message.entities[0].length = len('/pourCoffee')
dp.process_update(Update(update_id=0, message=message))
assert handler.conversations[(user1.id, )] == self.DRINKING
def test_get_mode_show_mode_options(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1,
timezone.now(),
chat=chat,
text=BTN_CAPTION_BUILD_QUERY)
message.chat = chat
update.message = message
data = c.get_mode_show_mode_options(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == TelegramConversation.STATUS.BUILD_PERIOD
message = Message(1,
timezone.now(),
chat=chat,
text=BTN_CAPTION_USE_SAVED_FILTER)
message.chat = chat
update.message = message
data = c.get_mode_show_mode_options(update, None)
assert mock.called
assert mock.call_args[0] == (
'``` No saved filters found for this command ```', )
assert data == ConversationHandler.END
message = Message(1,
timezone.now(),
chat=chat,
text=BTN_CAPTION_CUSTOM_MGMT)
message.chat = chat
update.message = message
data = c.get_mode_show_mode_options(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == ConversationHandler.END
def test_get_yes_no_aggregate_and_proceed(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_chat_id(1)
c.set_query_period_uom(WEEKS)
c.set_query_period_quantity(10)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text=YES)
message.chat = chat
update.message = message
data = c.get_yes_no_aggregate_and_proceed(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == TelegramConversation.STATUS.BUILD_AGGREGATE
fake_data = MockSet()
for _i in range(1, 15):
fake_data.add(
MockModel(
mock_name=f'name{_i}',
id=f'id{_i}',
name=f'name{_i}',
status='pending',
created_at=timezone.now(),
))
mocker.patch(
INITIAL_QUERY_SET_METHOD,
return_value=fake_data,
)
message = Message(1, timezone.now(), chat=chat, text=NO)
message.chat = chat
update.message = message
data = c.get_yes_no_aggregate_and_proceed(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == ConversationHandler.END
def test_get_saved_filter_and_proceed_no_user(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.model = MockModel
c.get_saved_filter = lambda x: 1
mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text='saved_filter')
message.chat = chat
update = Update(1)
update.message = message
data = c.get_saved_filter_and_proceed(update, None)
assert data is None
def test_get_saved_filter_and_proceed_no_filter_method(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.model = MockModel
c.set_chat_id(1)
mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text='unknown')
message.chat = chat
update.message = message
with pytest.raises(SavedFilterNotFound):
c.get_saved_filter_and_proceed(update, None)
def test_cancel(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat)
message.chat = chat
update.message = message
data = c.cancel(update, None)
assert mock.called
assert mock.call_args[0] == ('``` End of conversation ```', )
assert data == ConversationHandler.END
def test_show_mode_select(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat)
message.chat = chat
update.message = message
data = c.show_mode_select(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == TelegramConversation.STATUS.MODE_SELECTOR
def test_show_list_of_commands(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text=WEEKS)
message.chat = chat
update.message = message
data = c.show_list_of_commands(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == ConversationHandler.END
def test_get_aggregate_and_proceed_unknown(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_query_period_uom(WEEKS)
c.set_query_period_quantity(10)
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text='unknown')
message.chat = chat
update.message = message
data = c.get_aggregate_and_proceed(update, None)
assert mock.called
assert mock.call_args[0] == ('``` End of conversation ```', )
assert data == ConversationHandler.END
def test_get_period_uom_show_quantity(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text=WEEKS)
message.chat = chat
update.message = message
data = c.get_period_uom_show_quantity(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == TelegramConversation.STATUS.BUILD_PERIOD_QUANTITY
assert c.query_period_uom == WEEKS
def test_get_aggregate_and_proceed_sum(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_query_period_uom(WEEKS)
c.set_query_period_quantity(10)
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text=SUM)
message.chat = chat
update.message = message
data = c.get_aggregate_and_proceed(update, None)
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data == c.STATUS.BUILD_AGGREGATE_SUM_PROPERTY
assert c.aggregate_type == SUM
def test_empty_queryset(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.model = FakeModel
c.set_chat_id(1)
c.set_query_period_uom(WEEKS)
c.set_query_period_quantity(1)
c.add_query_filter('status', 'pending')
c.set_query_mode(BTN_CAPTION_BUILD_QUERY)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text=COUNT)
message.chat = chat
update.message = message
c.run_query(update)
assert mock.call_args[0] == (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
def test_conversation_handler_per_user(self, dp, bot, user1):
handler = ConversationHandler(
entry_points=self.entry_points,
states=self.states,
fallbacks=self.fallbacks,
per_chat=False)
dp.add_handler(handler)
# User one, starts the state machine.
message = Message(0, user1, None, self.group, text='/start', bot=bot)
dp.process_update(Update(update_id=0, message=message))
# The user is thirsty and wants to brew coffee.
message.text = '/brew'
dp.process_update(Update(update_id=0, message=message))
# Let's now verify that for the same user in a different group, the state will still be
# updated
message.chat = self.second_group
message.text = '/pourCoffee'
dp.process_update(Update(update_id=0, message=message))
assert handler.conversations[(user1.id,)] == self.DRINKING
def test_get_custom_command_and_execute(mocker):
log = logging.getLogger()
c = ConvTest(log, 'created_at', suffix='dev')
c.set_chat_id(1)
c.model = MockModel
def x(*args, **kwargs):
# empty function to patch custom mgmt command
pass
c.execute_custom_command = x
mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
mocker.patch('os.listdir', return_value=["x.py"])
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text='x')
message.chat = chat
update.message = message
data = c.get_custom_command_and_execute(update, None)
assert data == ConversationHandler.END
assert c.custom_command == 'x'
def test_execute_custom_command(mocker):
log = logging.getLogger()
c = ConvTestFiltersCommands(log, 'created_at', suffix='dev')
c.set_chat_id(1)
mock = mocker.patch(TELEGRAM_REPLY_METHOD, return_value=None)
mocker.patch(
DJANGO_CALL_COMMAND,
return_value=True,
)
update = Update(1)
chat = Chat(1, 'user')
message = Message(1, timezone.now(), chat=chat, text='10')
message.chat = chat
update.message = message
data = c.execute_custom_command(update, 'xx')
assert mock.called
assert mock.call_args[0] != (
f'``` {TelegramConversation.EMPTY_RESULT} ```', )
assert data is True
assert c.query_context == {
'mode': '',
'period': {
'uom': '',
'quantity': 0,
'timedelta': None,
},
'filters': [],
'aggregate': {
'type': '',
'property': '',
},
'saved': '',
'custom_command': '',
}
def test_dispatcher_integration_handlers(self, caplog, bot,
base_persistence, chat_data,
user_data):
def get_user_data():
return user_data
def get_chat_data():
return chat_data
base_persistence.get_user_data = get_user_data
base_persistence.get_chat_data = get_chat_data
# base_persistence.update_chat_data = lambda x: x
# base_persistence.update_user_data = lambda x: x
updater = Updater(bot=bot,
persistence=base_persistence,
use_context=True)
dp = updater.dispatcher
def callback_known_user(update, context):
if not context.user_data['test1'] == 'test2':
pytest.fail('user_data corrupt')
def callback_known_chat(update, context):
if not context.chat_data['test3'] == 'test4':
pytest.fail('chat_data corrupt')
def callback_unknown_user_or_chat(update, context):
if not context.user_data == {}:
pytest.fail('user_data corrupt')
if not context.chat_data == {}:
pytest.fail('chat_data corrupt')
context.user_data[1] = 'test7'
context.chat_data[2] = 'test8'
known_user = MessageHandler(Filters.user(user_id=12345),
callback_known_user,
pass_chat_data=True,
pass_user_data=True)
known_chat = MessageHandler(Filters.chat(chat_id=-67890),
callback_known_chat,
pass_chat_data=True,
pass_user_data=True)
unknown = MessageHandler(Filters.all,
callback_unknown_user_or_chat,
pass_chat_data=True,
pass_user_data=True)
dp.add_handler(known_user)
dp.add_handler(known_chat)
dp.add_handler(unknown)
user1 = User(id=12345, first_name='test user', is_bot=False)
user2 = User(id=54321, first_name='test user', is_bot=False)
chat1 = Chat(id=-67890, type='group')
chat2 = Chat(id=-987654, type='group')
m = Message(1, user1, None, chat2)
u = Update(0, m)
with caplog.at_level(logging.ERROR):
dp.process_update(u)
rec = caplog.records[-1]
assert rec.msg == 'No error handlers are registered, logging exception.'
assert rec.levelname == 'ERROR'
rec = caplog.records[-2]
assert rec.msg == 'No error handlers are registered, logging exception.'
assert rec.levelname == 'ERROR'
m.from_user = user2
m.chat = chat1
u = Update(1, m)
dp.process_update(u)
m.chat = chat2
u = Update(2, m)
def save_chat_data(data):
if -987654 not in data:
pytest.fail()
def save_user_data(data):
if 54321 not in data:
pytest.fail()
base_persistence.update_chat_data = save_chat_data
base_persistence.update_user_data = save_user_data
dp.process_update(u)
assert dp.user_data[54321][1] == 'test7'
assert dp.chat_data[-987654][2] == 'test8'
