def reply_to_message(user, private_chat, message):
params = {'text': '/start'}
reply_message = types.Message(
message_id=2, from_user=user, date=None, chat=private_chat, content_type='text', options=params, json_string=""
)
reply_message.reply_to_message = message
return reply_message
async def test_send_message(
m_telebot: telebot.AsyncTeleBot,
mocker: MockFixture,
) -> None:
chat_id = 123456
message = ExternalMessage(
sender='@sender',
receiver='@receiver',
content='testing message',
)
mocked_send_message = mocker.MagicMock()
m_telebot.send_message.return_value = mocked_send_message
mocked_send_message.wait.return_value = tb_types.Message(
None,
None,
None,
None,
None,
[],
None,
)
bot = TelegramGroupChat(
bot_token=FAKE_TOKEN,
chat_id=chat_id,
)
await bot.send_message(message)
m_telebot.send_message.assert_called_once_with(
chat_id,
f'From {message.sender} '
f'to {message.receiver}: '
f'{message.content}',
)
def message(cmd):
params = {
'text': ''.join(cmd),
}
chat = types.User(uuid.uuid4().hex, False, 'test')
from_user = types.User(uuid.uuid4().hex, False, 'testUser')
return types.Message(uuid.uuid4().hex, from_user, None, chat, 'text',
params, "")
def test_process_text_message():
post_date = 0
user_id = 1
params = {'text': 'message_body'}
user = types.User(user_id, 'Test person')
text_message = types.Message(1, user, post_date, user, 'text', params)
telegram_bot.process(text_message)
assert os.path.isfile(TEST_LOG_FILE)
def message(user, private_chat):
params = {'text': '/start'}
return types.Message(message_id=1,
from_user=user,
date=None,
chat=private_chat,
content_type='text',
options=params,
json_string="")
def create_text_message(text, **kwargs):
params = {'text': text}
return types.Message(message_id=kwargs.get('message_id')
or random.randint(1, 100),
from_user=kwargs.get('from_user') or create_user(),
date=None,
chat=kwargs.get('chat') or create_chat(),
content_type=kwargs.get('content_type') or 'text',
options=params,
json_string="")
def test_invalid_user():
post_date = 0
user_id = 0
params = {'text': 'message_body'}
user = types.User(user_id, 'Test person')
# Stub out the reply_to call as we don't want to access the Telegram API
telegram_bot.my_bot.reply_to = lambda x, y: print(x, y)
text_message = types.Message(1, user, post_date, user, 'text', params)
telegram_bot.process(text_message)
assert not os.path.isfile(TEST_LOG_FILE)
def test_process_photo_message():
photo_url = '''https://upload.wikimedia.org/wikipedia/commons/thumb/6/61/Snow_Monkeys%2C_Nagano%2C_Japan.JPG/320px-Snow_Monkeys%2C_Nagano%2C_Japan.JPG'''
# Stub out the get_photo_url call as we don't want to access the Telegram API
post_date = 0
user_id = 1
params = {'photo': 'message_body'}
user = types.User(user_id, 'Test person')
photo_message = types.Message(1, user, post_date, user, 'photo', params)
telegram_bot.get_photo_url = lambda x: photo_url
telegram_bot.process(photo_message)
assert os.path.exists(TEST_DATA_DIRECTORY)
async def test_consume_messages(
m_telebot: telebot.AsyncTeleBot,
mocker: MockFixture,
) -> None:
chat_id = 123456
messages = [
ExternalMessage(
sender='@sender2',
receiver='@receiver1',
content='testing message 1',
),
ExternalMessage(
sender='@sender1',
receiver='@receiver2',
content='testing message 2',
),
]
mocked_send_message = mocker.MagicMock()
m_telebot.send_message.return_value = mocked_send_message
mocked_send_message.wait.return_value = tb_types.Message(
None,
None,
None,
None,
None,
[],
None,
)
bot = TelegramGroupChat(
bot_token=FAKE_TOKEN,
chat_id=chat_id,
)
await bot.consume_messages(messages)
m_telebot.send_message.assert_has_calls(
[
mocker.call(
chat_id,
f'From {messages[0].sender} '
f'to {messages[0].receiver}: '
f'{messages[0].content}',
),
mocker.call(
chat_id,
f'From {messages[1].sender} '
f'to {messages[1].receiver}: '
f'{messages[1].content}',
),
],
any_order=True,
)
def create_message_update(text):
params = {'text': text}
chat = types.User(11, False, 'test')
message = types.Message(1, None, None, chat, 'text', params, "")
edited_message = None
channel_post = None
edited_channel_post = None
inline_query = None
chosen_inline_result = None
callback_query = None
shipping_query = None
pre_checkout_query = None
poll = None
poll_answer = None
return types.Update(-1001234038283, message, edited_message, channel_post, edited_channel_post, inline_query,
chosen_inline_result, callback_query, shipping_query, pre_checkout_query, poll, poll_answer)
def telegram_message(telegram_user, telegram_chat):
return types.Message(MESSAGE_ID, telegram_user, 0, telegram_chat, 'text',
[], 'null')
def create_text_message(text, user=None):
params = {'text': text}
chat = types.User(11, False, 'test') if user is None else user
return types.Message(1, None, None, chat, 'text', params, "")
def create_text_message(self, text):
params = {'text': text}
chat = types.User(11, False, 'test')
#(self, message_id, from_user, date, chat, content_type, options, json_string)
return types.Message(1, None, None, chat, 'text', params)
def create_text_message(self, text):
params = {'text': text}
chat = types.User(296066710, 'test')
return types.Message(1, chat, None, chat, 'text', params)
def create_group_text_message(text, bot: DoorAlertBot, chat_id):
params = {'text': text}
chat = bot.get_chat(chat_id)
from_user = TestDoorAlertUtils.get_chat_administrator(bot, chat_id)
return types.Message(1, from_user, None, chat, 'text', params, "")
def create_text_message(self, text):
params = {'text': text}
chat = types.User(11, False, 'test')
return types.Message(1, None, None, chat, 'text', params, "")
def telegram_message(db, telegram_user, telegram_chat) -> types.Message:
return types.Message(123123, telegram_user, 1, telegram_chat, "text", [], "null")
def create_text_message(text):
params = {}
params['text'] = text
return types.Message(1, None, None, 1, 'text', params)
