def test_mentioning_contact(self,
sending_message: SendingMessage) -> None:
sending_message.payload.options.mentions = []
user_huid = uuid.uuid4()
user_name = "test"
sending_message.mention_contact(user_huid, user_name)
mention = sending_message.payload.options.mentions[0]
assert mention.mention_type == MentionTypes.contact
def test_mentioning_chat(self,
sending_message: SendingMessage) -> None:
sending_message.payload.options.mentions = []
chat_id = uuid.uuid4()
chat_name = "test"
sending_message.mention_chat(chat_id, chat_name)
mention = sending_message.payload.options.mentions[0]
assert mention.mention_type == MentionTypes.chat
def test_message_file_from_bytes_file(
self,
sending_message: SendingMessage,
) -> None:
original_file = sending_message.file
sending_message.add_file(
BytesIO(original_file.file.read()),
filename=original_file.file_name,
)
assert sending_message.file == original_file
def test_message_file_from_string_file(
self,
sending_message: SendingMessage,
) -> None:
original_file = sending_message.file
sending_message.add_file(
StringIO(original_file.file.read().decode()),
filename=original_file.file_name,
)
assert sending_message.file == original_file
def test_adding_recipients_separately(
self,
sending_message: SendingMessage,
) -> None:
users = [uuid.uuid4(), uuid.uuid4()]
sending_message.payload.options.recipients = "all"
sending_message.add_recipient(users[0])
assert sending_message.options.recipients == [users[0]]
sending_message.add_recipient(users[1])
assert sending_message.options.recipients == users
def test_adding_multiple_recipients(
self,
sending_message: SendingMessage,
) -> None:
users = [uuid.uuid4(), uuid.uuid4()]
sending_message.payload.options.recipients = "all"
sending_message.add_recipients(users[:1])
assert sending_message.options.recipients == users[:1]
sending_message.add_recipients(users[1:])
assert sending_message.options.recipients == users
def test_adding_bubbles(self, sending_message: SendingMessage) -> None:
bubble = BubbleElement(command="/test")
sending_message.markup = MessageMarkup()
sending_message.add_bubble("/test")
sending_message.add_bubble("/test", new_row=False)
sending_message.add_bubble("/test")
sending_message.add_bubble("/test")
sending_message.add_bubble("/test", new_row=False)
assert sending_message.markup == MessageMarkup(
bubbles=[[bubble, bubble], [bubble], [bubble, bubble]], )
def sending_message() -> SendingMessage:
return SendingMessage(
text="text",
file=File.from_string(b"data", filename="file.txt"),
credentials=SendingCredentials(
sync_id=uuid.uuid4(),
bot_id=uuid.uuid4(),
host="host",
),
markup=MessageMarkup(
bubbles=[[BubbleElement(command="")]],
keyboard=[[KeyboardElement(command="")]],
),
options=MessageOptions(
recipients=[uuid.uuid4()],
mentions=[
Mention(mention_data=UserMention(user_huid=uuid.uuid4())),
Mention(
mention_data=UserMention(user_huid=uuid.uuid4()),
mention_type=MentionTypes.contact,
),
Mention(
mention_data=ChatMention(group_chat_id=uuid.uuid4()),
mention_type=MentionTypes.chat,
),
],
notifications=NotificationOptions(send=False, force_dnd=True),
),
)
async def my_handler_with_contact_mention(message: Message) -> None:
reply = SendingMessage.from_message(
text="You should request access!",
message=message,
)
reply.mention_chat(USER_FOR_MENTION, name="Administrator")
await bot.send(reply)
async def my_handler(message: Message) -> None:
with open("my_file.txt") as f:
notification = SendingMessage(
file=File.from_file(f), credentials=message.credentials,
)
await bot.send(notification)
async def another_handler(message: Message) -> None:
notification = SendingMessage.from_message(message=message)
with open("my_file.txt") as f:
notification.add_file(f)
await bot.send(notification)
async def some_function() -> None:
message = SendingMessage(
text="You were chosen by random.",
bot_id=BOT_ID,
host=CTS_HOST,
chat_id=CHAT_ID,
)
await bot.send(message)
def test_options_from_recipients(
self, sending_message: SendingMessage) -> None:
msg = SendingMessage(
text=sending_message.text,
credentials=sending_message.credentials,
recipients=sending_message.options.recipients,
)
assert msg.options.recipients == sending_message.options.recipients
async def my_handler_with_user_mention(message: Message) -> None:
reply = SendingMessage.from_message(
text="Hi! There is a notification with mention for you",
message=message,
)
reply.mention_user(message.user_huid)
await bot.send(reply)
def test_adding_keyboard(self,
sending_message: SendingMessage) -> None:
keyboard_button = KeyboardElement(command="/test")
sending_message.markup = MessageMarkup()
sending_message.add_keyboard_button("/test")
sending_message.add_keyboard_button("/test", new_row=False)
sending_message.add_keyboard_button("/test")
sending_message.add_keyboard_button("/test")
sending_message.add_keyboard_button("/test", new_row=False)
assert sending_message.markup == MessageMarkup(keyboard=[
[keyboard_button, keyboard_button],
[keyboard_button],
[keyboard_button, keyboard_button],
], )
def sending_message(message, metadata, sending_file):
sending_message = SendingMessage.from_message(
text="some text",
file=sending_file,
message=message,
)
sending_message.add_keyboard_button(command="/command", label="keyboard")
sending_message.add_bubble(command="/command", label="bubble")
sending_message.metadata = metadata
return sending_message
def test_option_from_message_options(
self,
sending_message: SendingMessage,
) -> None:
msg = SendingMessage(
text=sending_message.text,
credentials=sending_message.credentials,
options=sending_message.options,
)
assert msg.options == sending_message.options
async def my_handler_with_markup_in_sending_message(message: Message) -> None:
reply = SendingMessage.from_message(text="More buttons!!!",
message=message)
reply.add_bubble(command="", label="bubble 1")
reply.add_keyboard_button(command="",
label="keyboard button 1",
new_row=False)
reply.add_keyboard_button(command="", label="keyboard button 2")
await bot.send(reply)
def test_markup_creation_from_bubbles_and_keyboard(
self,
sending_message: SendingMessage,
) -> None:
msg = SendingMessage(
text=sending_message.text,
credentials=sending_message.credentials,
bubbles=sending_message.markup.bubbles,
keyboard=sending_message.markup.keyboard,
)
assert msg.markup == sending_message.markup
def test_only_credentials_or_separate_credential_parts(
self,
sending_message: SendingMessage,
) -> None:
with pytest.raises(AssertionError):
_ = SendingMessage(
sync_id=sending_message.sync_id,
bot_id=sending_message.bot_id,
host=sending_message.host,
credentials=sending_message.credentials,
)
def test_credentials_will_be_built_from_credential_parts(
self,
sending_message: SendingMessage,
) -> None:
msg = SendingMessage(
text=sending_message.text,
sync_id=sending_message.sync_id,
bot_id=sending_message.bot_id,
host=sending_message.host,
)
assert msg.credentials == sending_message.credentials
def test_merging_message_id_into_credentials(
self,
sending_message: SendingMessage,
) -> None:
message_id = uuid.uuid4()
msg = SendingMessage(
text=sending_message.text,
credentials=sending_message.credentials,
message_id=message_id,
)
assert msg.credentials.message_id == message_id
def test_building_from_message(self,
sending_message: SendingMessage) -> None:
builder = MessageBuilder()
msg = Message(message=builder.message, bot=Bot())
sending_msg = SendingMessage.from_message(
text=sending_message.text,
message=msg,
)
assert sending_msg.host == msg.host
assert sending_msg.sync_id == msg.sync_id
assert sending_msg.bot_id == msg.bot_id
def test_only_markup_or_separate_markup_parts(
self,
sending_message: SendingMessage,
) -> None:
with pytest.raises(AssertionError):
_ = SendingMessage(
text=sending_message.text,
credentials=sending_message.credentials,
bubbles=sending_message.markup.bubbles,
keyboard=sending_message.markup.keyboard,
markup=sending_message.markup,
)
def test_leaving_credentials_message_id_into_credentials_if_was_set(
self,
sending_message: SendingMessage,
) -> None:
message_id = uuid.uuid4()
sending_message.credentials.message_id = message_id
msg = SendingMessage(
text=sending_message.text,
credentials=sending_message.credentials,
message_id=uuid.uuid4(),
)
assert msg.credentials.message_id == sending_message.credentials.message_id
async def test_update_metadata(bot, client, message):
msg = SendingMessage.from_message(text="some text", message=message)
msg.metadata = {"hello": "world"}
await bot.send(msg)
upd = UpdatePayload.from_sending_payload(msg.payload)
upd.metadata = {"foo": "bar"}
await bot.update_message(message.credentials, upd)
update = client.message_updates[0].result
assert update.metadata == {"foo": "bar"}
def test_only_options_or_separate_options_parts(
self,
sending_message: SendingMessage,
) -> None:
with pytest.raises(AssertionError):
_ = SendingMessage(
text=sending_message.text,
credentials=sending_message.credentials,
options=sending_message.options,
mentions=sending_message.options.mentions,
recipients=sending_message.options.recipients,
notification_options=sending_message.options.notifications,
)
async def my_handler_with_chat_mention(message: Message) -> None:
reply = SendingMessage.from_message(text="Check this chat",
message=message)
reply.mention_chat(CHAT_FOR_MENTION, name="Interesting chat")
await bot.send(reply)
async def some_handler(message: Message) -> None:
message = SendingMessage.from_message(
text="You were chosen by random.",
message=message,
)
await bot.send(message)
def test_credentials_or_parameters_required_for_message_creation():
with pytest.raises(AssertionError):
SendingMessage()
