#!/usr/bin/env python

#

# A library that provides a Python interface to the Telegram Bot API

# Copyright (C) 2015-2025

# 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 contextlib

import datetime as dtm

from copy import copy

import pytest

from telegram import (

Animation,

Audio,

BackgroundTypeChatTheme,

Bot,

Chat,

ChatBackground,

ChatBoostAdded,

ChatShared,

Contact,

Dice,

Document,

ExternalReplyInfo,

Game,

Giveaway,

GiveawayCompleted,

GiveawayCreated,

GiveawayWinners,

InputPaidMediaPhoto,

Invoice,

LinkPreviewOptions,

Location,

Message,

MessageAutoDeleteTimerChanged,

MessageEntity,

MessageOriginChat,

PaidMediaInfo,

PaidMediaPreview,

PassportData,

PhotoSize,

Poll,

PollOption,

ProximityAlertTriggered,

RefundedPayment,

ReplyParameters,

SharedUser,

Sticker,

Story,

SuccessfulPayment,

TextQuote,

Update,

User,

UsersShared,

Venue,

Video,

VideoChatEnded,

VideoChatParticipantsInvited,

VideoChatScheduled,

VideoChatStarted,

VideoNote,

Voice,

WebAppData,

)

from telegram._utils.datetime import UTC

from telegram._utils.defaultvalue import DEFAULT_NONE

from telegram._utils.types import ODVInput

from telegram.constants import ChatAction, ParseMode

from telegram.ext import Defaults

from telegram.warnings import PTBDeprecationWarning

from tests._passport.test_passport import RAW_PASSPORT_DATA

from tests.auxil.bot_method_checks import (

check_defaults_handling,

check_shortcut_call,

check_shortcut_signature,

)

from tests.auxil.build_messages import make_message

from tests.auxil.pytest_classes import PytestExtBot, PytestMessage

from tests.auxil.slots import mro_slots

@pytest.fixture

def message(bot):

message = PytestMessage(

message_id=MessageTestBase.id_,

date=MessageTestBase.date,

chat=copy(MessageTestBase.chat),

from_user=copy(MessageTestBase.from_user),

business_connection_id="123456789",

)

message.set_bot(bot)

message._unfreeze()

message.chat._unfreeze()

message.from_user._unfreeze()

return message

@pytest.fixture(

params=[

{

"reply_to_message": Message(

50, dtm.datetime.utcnow(), Chat(13, "channel"), User(9, "i", False)

)

},

{"edit_date": dtm.datetime.utcnow()},

{

"text": "a text message",

"entities": [MessageEntity("bold", 10, 4), MessageEntity("italic", 16, 7)],

},

{

"caption": "A message caption",

"caption_entities": [MessageEntity("bold", 1, 1), MessageEntity("text_link", 4, 3)],

},

{"audio": Audio("audio_id", "unique_id", 12), "caption": "audio_file"},

{"document": Document("document_id", "unique_id"), "caption": "document_file"},

{

"animation": Animation("animation_id", "unique_id", 30, 30, 1),

"caption": "animation_file",

},

{

"game": Game(

"my_game",

"just my game",

[

PhotoSize("game_photo_id", "unique_id", 30, 30),

],

)

},

{"photo": [PhotoSize("photo_id", "unique_id", 50, 50)], "caption": "photo_file"},

{"sticker": Sticker("sticker_id", "unique_id", 50, 50, True, False, Sticker.REGULAR)},

{"story": Story(Chat(1, Chat.PRIVATE), 0)},

{"video": Video("video_id", "unique_id", 12, 12, 12), "caption": "video_file"},

{"voice": Voice("voice_id", "unique_id", 5)},

{"video_note": VideoNote("video_note_id", "unique_id", 20, 12)},

{"new_chat_members": [User(55, "new_user", False)]},

{"contact": Contact("phone_numner", "contact_name")},

{"location": Location(-23.691288, 46.788279)},

{"venue": Venue(Location(-23.691288, 46.788279), "some place", "right here")},

{"left_chat_member": User(33, "kicked", False)},

{"new_chat_title": "new title"},

{"new_chat_photo": [PhotoSize("photo_id", "unique_id", 50, 50)]},

{"delete_chat_photo": True},

{"group_chat_created": True},

{"supergroup_chat_created": True},

{"channel_chat_created": True},

{"message_auto_delete_timer_changed": MessageAutoDeleteTimerChanged(42)},

{"migrate_to_chat_id": -12345},

{"migrate_from_chat_id": -54321},

{

"pinned_message": Message(

7, dtm.datetime.utcnow(), Chat(13, "channel"), User(9, "i", False)

)

},

{"invoice": Invoice("my invoice", "invoice", "start", "EUR", 243)},

{

"successful_payment": SuccessfulPayment(

"EUR", 243, "payload", "charge_id", "provider_id", order_info={}

)

},

{"connected_website": "http://example.com/"},

{"author_signature": "some_author_sign"},

{

"photo": [PhotoSize("photo_id", "unique_id", 50, 50)],

"caption": "photo_file",

"media_group_id": 1234443322222,

},

{"passport_data": PassportData.de_json(RAW_PASSPORT_DATA, None)},

{

"poll": Poll(

id="abc",

question="What is this?",

options=[PollOption(text="a", voter_count=1), PollOption(text="b", voter_count=2)],

is_closed=False,

total_voter_count=0,

is_anonymous=False,

type=Poll.REGULAR,

allows_multiple_answers=True,

explanation_entities=[],

)

},

{

"text": "a text message",

"reply_markup": {

"inline_keyboard": [

[

{"text": "start", "url": "http://google.com"},

{"text": "next", "callback_data": "abcd"},

],

[{"text": "Cancel", "callback_data": "Cancel"}],

]

},

},

{"dice": Dice(4, "🎲")},

{"via_bot": User(9, "A_Bot", True)},

{

"proximity_alert_triggered": ProximityAlertTriggered(

User(1, "John", False), User(2, "Doe", False), 42

)

},

{"video_chat_scheduled": VideoChatScheduled(dtm.datetime.utcnow())},

{"video_chat_started": VideoChatStarted()},

{"video_chat_ended": VideoChatEnded(100)},

{

"video_chat_participants_invited": VideoChatParticipantsInvited(

[User(1, "Rem", False), User(2, "Emilia", False)]

)

},

{"sender_chat": Chat(-123, "discussion_channel")},

{"is_automatic_forward": True},

{"has_protected_content": True},

{

"entities": [

MessageEntity(MessageEntity.BOLD, 0, 1),

MessageEntity(MessageEntity.TEXT_LINK, 2, 3, url="https://ptb.org"),

]

},

{"web_app_data": WebAppData("some_data", "some_button_text")},

{"message_thread_id": 123},

{"users_shared": UsersShared(1, users=[SharedUser(2, "user2"), SharedUser(3, "user3")])},

{"chat_shared": ChatShared(3, 4)},

{

"giveaway": Giveaway(

chats=[Chat(1, Chat.SUPERGROUP)],

winners_selection_date=dtm.datetime.utcnow().replace(microsecond=0),

winner_count=5,

)

},

{"giveaway_created": GiveawayCreated(prize_star_count=99)},

{

"giveaway_winners": GiveawayWinners(

chat=Chat(1, Chat.CHANNEL),

giveaway_message_id=123456789,

winners_selection_date=dtm.datetime.utcnow().replace(microsecond=0),

winner_count=42,

winners=[User(1, "user1", False), User(2, "user2", False)],

)

},

{

"giveaway_completed": GiveawayCompleted(

winner_count=42,

unclaimed_prize_count=4,

giveaway_message=make_message(text="giveaway_message"),

)

},

{

"link_preview_options": LinkPreviewOptions(

is_disabled=True,

url="https://python-telegram-bot.org",

prefer_small_media=True,

prefer_large_media=True,

show_above_text=True,

)

},

{

"external_reply": ExternalReplyInfo(

MessageOriginChat(dtm.datetime.utcnow(), Chat(1, Chat.PRIVATE))

)

},

{"quote": TextQuote("a text quote", 1)},

{"forward_origin": MessageOriginChat(dtm.datetime.utcnow(), Chat(1, Chat.PRIVATE))},

{"reply_to_story": Story(Chat(1, Chat.PRIVATE), 0)},

{"boost_added": ChatBoostAdded(100)},

{"sender_boost_count": 1},

{"is_from_offline": True},

{"sender_business_bot": User(1, "BusinessBot", True)},

{"business_connection_id": "123456789"},

{"chat_background_set": ChatBackground(type=BackgroundTypeChatTheme("ice"))},

{"effect_id": "123456789"},

{"show_caption_above_media": True},

{"paid_media": PaidMediaInfo(5, [PaidMediaPreview(10, 10, 10)])},

{"refunded_payment": RefundedPayment("EUR", 243, "payload", "charge_id", "provider_id")},

],

ids=[

"reply",

"edited",

"text",

"caption_entities",

"audio",

"document",

"animation",

"game",

"photo",

"sticker",

"story",

"video",

"voice",

"video_note",

"new_members",

"contact",

"location",

"venue",

"left_member",

"new_title",

"new_photo",

"delete_photo",

"group_created",

"supergroup_created",

"channel_created",

"message_auto_delete_timer_changed",

"migrated_to",

"migrated_from",

"pinned",

"invoice",

"successful_payment",

"connected_website",

"author_signature",

"photo_from_media_group",

"passport_data",

"poll",

"reply_markup",

"dice",

"via_bot",

"proximity_alert_triggered",

"video_chat_scheduled",

"video_chat_started",

"video_chat_ended",

"video_chat_participants_invited",

"sender_chat",

"is_automatic_forward",

"has_protected_content",

"entities",

"web_app_data",

"message_thread_id",

"users_shared",

"chat_shared",

"giveaway",

"giveaway_created",

"giveaway_winners",

"giveaway_completed",

"link_preview_options",

"external_reply",

"quote",

"forward_origin",

"reply_to_story",

"boost_added",

"sender_boost_count",

"sender_business_bot",

"business_connection_id",

"is_from_offline",

"chat_background_set",

"effect_id",

"show_caption_above_media",

"paid_media",

"refunded_payment",

],

)

def message_params(bot, request):

message = Message(

message_id=MessageTestBase.id_,

from_user=MessageTestBase.from_user,

date=MessageTestBase.date,

chat=MessageTestBase.chat,

**request.param,

)

message.set_bot(bot)

return message

class MessageTestBase:

id_ = 1

from_user = User(2, "testuser", False)

date = dtm.datetime.utcnow()

chat = Chat(3, "private")

test_entities = [

{"length": 4, "offset": 10, "type": "bold"},

{"length": 3, "offset": 16, "type": "italic"},

{"length": 3, "offset": 20, "type": "italic"},

{"length": 4, "offset": 25, "type": "code"},

{"length": 5, "offset": 31, "type": "text_link", "url": "http://github.com/ab_"},

{

"length": 12,

"offset": 38,

"type": "text_mention",

"user": User(123456789, "mentioned user", False),

},

{"length": 3, "offset": 55, "type": "pre", "language": "python"},

{"length": 21, "offset": 60, "type": "url"},

]

test_text = "Test for <bold, ita_lic, code, links, text-mention and pre. http://google.com/ab_"

test_entities_v2 = [

{"length": 4, "offset": 0, "type": "underline"},

{"length": 4, "offset": 10, "type": "bold"},

{"length": 7, "offset": 16, "type": "italic"},

{"length": 6, "offset": 25, "type": "code"},

{"length": 5, "offset": 33, "type": "text_link", "url": r"http://github.com/abc\)def"},

{

"length": 12,

"offset": 40,

"type": "text_mention",

"user": User(123456789, "mentioned user", False),

},

{"length": 5, "offset": 57, "type": "pre"},

{"length": 17, "offset": 64, "type": "url"},

{"length": 41, "offset": 86, "type": "italic"},

{"length": 29, "offset": 91, "type": "bold"},

{"length": 9, "offset": 101, "type": "strikethrough"},

{"length": 10, "offset": 129, "type": "pre", "language": "python"},

{"length": 7, "offset": 141, "type": "spoiler"},

{"length": 2, "offset": 150, "type": "custom_emoji", "custom_emoji_id": "1"},

{"length": 34, "offset": 154, "type": "blockquote"},

{"length": 6, "offset": 181, "type": "bold"},

{"length": 33, "offset": 190, "type": "expandable_blockquote"},

]

test_text_v2 = (

r"Test for <bold, ita_lic, \`code, links, text-mention and `\pre. "

"http://google.com and bold nested in strk>trgh nested in italic. Python pre. Spoiled. "

"👍.\nMultiline\nblock quote\nwith nested.\n\nMultiline\nexpandable\nblock quote."

)

test_message = Message(

message_id=1,

from_user=None,

date=None,

chat=None,

text=test_text,

entities=[MessageEntity(**e) for e in test_entities],

caption=test_text,

caption_entities=[MessageEntity(**e) for e in test_entities],

)

test_message_v2 = Message(

message_id=1,

from_user=None,

date=None,

chat=None,

text=test_text_v2,

entities=[MessageEntity(**e) for e in test_entities_v2],

caption=test_text_v2,

caption_entities=[MessageEntity(**e) for e in test_entities_v2],

)

class TestMessageWithoutRequest(MessageTestBase):

@staticmethod

async def check_quote_parsing(

message: Message, method, bot_method_name: str, args, monkeypatch

):

"""Used in testing reply_* below. Makes sure that quote and do_quote are handled

correctly

"""

with contextlib.suppress(TypeError):

# for newer methods that don't have the deprecated argument

with pytest.raises(ValueError, match="`quote` and `do_quote` are mutually exclusive"):

await method(*args, quote=True, do_quote=True)

# for newer methods that don't have the deprecated argument

with pytest.warns(PTBDeprecationWarning, match="`quote` parameter is deprecated"):

await method(*args, quote=True)

with pytest.raises(

ValueError,

match="`reply_to_message_id` and `reply_parameters` are mutually exclusive.",

):

await method(*args, reply_to_message_id=42, reply_parameters=42)

async def make_assertion(*args, **kwargs):

return kwargs.get("chat_id"), kwargs.get("reply_parameters")

monkeypatch.setattr(message.get_bot(), bot_method_name, make_assertion)

for param in ("quote", "do_quote"):

with contextlib.suppress(TypeError):

# for newer methods that don't have the deprecated argument

chat_id, reply_parameters = await method(*args, **{param: True})

if chat_id != message.chat.id:

pytest.fail(f"chat_id is {chat_id} but should be {message.chat.id}")

if reply_parameters is None or reply_parameters.message_id != message.message_id:

pytest.fail(

f"reply_parameters is {reply_parameters} "

"but should be {message.message_id}"

)

input_chat_id = object()

input_reply_parameters = ReplyParameters(message_id=1, chat_id=42)

chat_id, reply_parameters = await method(

*args, do_quote={"chat_id": input_chat_id, "reply_parameters": input_reply_parameters}

)

if chat_id is not input_chat_id:

pytest.fail(f"chat_id is {chat_id} but should be {chat_id}")

if reply_parameters is not input_reply_parameters:

pytest.fail(f"reply_parameters is {reply_parameters} but should be {reply_parameters}")

input_parameters_2 = ReplyParameters(message_id=2, chat_id=43)

chat_id, reply_parameters = await method(

*args,

reply_parameters=input_parameters_2,

# passing these here to make sure that `reply_parameters` has higher priority

do_quote={"chat_id": input_chat_id, "reply_parameters": input_reply_parameters},

)

if chat_id is not message.chat.id:

pytest.fail(f"chat_id is {chat_id} but should be {message.chat.id}")

if reply_parameters is not input_parameters_2:

pytest.fail(

f"reply_parameters is {reply_parameters} but should be {input_parameters_2}"

)

chat_id, reply_parameters = await method(

*args,

reply_to_message_id=42,

# passing these here to make sure that `reply_to_message_id` has higher priority

do_quote={"chat_id": input_chat_id, "reply_parameters": input_reply_parameters},

)

if chat_id != message.chat.id:

pytest.fail(f"chat_id is {chat_id} but should be {message.chat.id}")

if reply_parameters is None or reply_parameters.message_id != 42:

pytest.fail(f"reply_parameters is {reply_parameters} but should be 42")

@staticmethod

async def check_thread_id_parsing(

message: Message, method, bot_method_name: str, args, monkeypatch

):

"""Used in testing reply_* below. Makes sure that meassage_thread_id is parsed

correctly."""

async def extract_message_thread_id(*args, **kwargs):

return kwargs.get("message_thread_id")

monkeypatch.setattr(message.get_bot(), bot_method_name, extract_message_thread_id)

for is_topic_message in (True, False):

message.is_topic_message = is_topic_message

message.message_thread_id = None

message_thread_id = await method(*args)

assert message_thread_id is None

message.message_thread_id = 99

message_thread_id = await method(*args)

assert message_thread_id == (99 if is_topic_message else None)

message_thread_id = await method(*args, message_thread_id=50)

assert message_thread_id == 50

message_thread_id = await method(*args, message_thread_id=None)

assert message_thread_id is None

if bot_method_name == "send_chat_action":

return

message_thread_id = await method(

*args,

do_quote=message.build_reply_arguments(

target_chat_id=123,

),

)

assert message_thread_id is None

for target_chat_id in (message.chat_id, message.chat.username):

message_thread_id = await method(

*args,

do_quote=message.build_reply_arguments(

target_chat_id=target_chat_id,

),

)

assert message_thread_id == (message.message_thread_id if is_topic_message else None)

def test_slot_behaviour(self):

message = Message(

message_id=MessageTestBase.id_,

date=MessageTestBase.date,

chat=copy(MessageTestBase.chat),

from_user=copy(MessageTestBase.from_user),

)

for attr in message.__slots__:

assert getattr(message, attr, "err") != "err", f"got extra slot '{attr}'"

assert len(mro_slots(message)) == len(set(mro_slots(message))), "duplicate slot"

def test_all_possibilities_de_json_and_to_dict(self, offline_bot, message_params):

new = Message.de_json(message_params.to_dict(), offline_bot)

assert new.api_kwargs == {}

assert new.to_dict() == message_params.to_dict()

# Checking that none of the attributes are dicts is a best effort approach to ensure that

# de_json converts everything to proper classes without having to write special tests for

# every single case

for slot in new.__slots__:

assert not isinstance(new[slot], dict)

def test_de_json_localization(self, offline_bot, raw_bot, tz_bot):

json_dict = {

"message_id": 12,

"from_user": None,

"date": int(dtm.datetime.now().timestamp()),

"chat": None,

"edit_date": int(dtm.datetime.now().timestamp()),

}

message_raw = Message.de_json(json_dict, raw_bot)

message_bot = Message.de_json(json_dict, offline_bot)

message_tz = Message.de_json(json_dict, tz_bot)

# comparing utcoffsets because comparing timezones is unpredicatable

date_offset = message_tz.date.utcoffset()

date_tz_bot_offset = tz_bot.defaults.tzinfo.utcoffset(message_tz.date.replace(tzinfo=None))

edit_date_offset = message_tz.edit_date.utcoffset()

edit_date_tz_bot_offset = tz_bot.defaults.tzinfo.utcoffset(

message_tz.edit_date.replace(tzinfo=None)

)

assert message_raw.date.tzinfo == UTC

assert message_bot.date.tzinfo == UTC

assert date_offset == date_tz_bot_offset

assert message_raw.edit_date.tzinfo == UTC

assert message_bot.edit_date.tzinfo == UTC

assert edit_date_offset == edit_date_tz_bot_offset

def test_de_json_api_kwargs_backward_compatibility(self, offline_bot, message_params):

message_dict = message_params.to_dict()

keys = (

"user_shared",

"forward_from",

"forward_from_chat",

"forward_from_message_id",

"forward_signature",

"forward_sender_name",

"forward_date",

)

for key in keys:

message_dict[key] = key

message = Message.de_json(message_dict, offline_bot)

assert message.api_kwargs == {key: key for key in keys}

def test_equality(self):

id_ = 1

a = Message(id_, self.date, self.chat, from_user=self.from_user)

b = Message(id_, self.date, self.chat, from_user=self.from_user)

c = Message(id_, self.date, Chat(123, Chat.GROUP), from_user=User(0, "", False))

d = Message(0, self.date, self.chat, from_user=self.from_user)

e = Update(id_)

assert a == b

assert hash(a) == hash(b)

assert a is not b

assert a != c

assert hash(a) != hash(c)

assert a != d

assert hash(a) != hash(d)

assert a != e

assert hash(a) != hash(e)

def test_bool(self, message, recwarn):

# Relevant as long as we override MaybeInaccessibleMessage.__bool__

# Can be removed once that's removed

assert bool(message) is True

assert len(recwarn) == 0

async def test_parse_entity(self):

text = (

b"\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467"

b"\\u200d\\U0001f467\\U0001f431http://google.com"

).decode("unicode-escape")

entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)

message = Message(

1,

from_user=self.from_user,

date=self.date,

chat=self.chat,

text=text,

entities=[entity],

)

assert message.parse_entity(entity) == "http://google.com"

with pytest.raises(RuntimeError, match="Message has no"):

Message(message_id=1, date=self.date, chat=self.chat).parse_entity(entity)

async def test_parse_caption_entity(self):

caption = (

b"\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467"

b"\\u200d\\U0001f467\\U0001f431http://google.com"

).decode("unicode-escape")

entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)

message = Message(

1,

from_user=self.from_user,

date=self.date,

chat=self.chat,

caption=caption,

caption_entities=[entity],

)

assert message.parse_caption_entity(entity) == "http://google.com"

with pytest.raises(RuntimeError, match="Message has no"):

Message(message_id=1, date=self.date, chat=self.chat).parse_entity(entity)

async def test_parse_entities(self):

text = (

b"\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467"

b"\\u200d\\U0001f467\\U0001f431http://google.com"

).decode("unicode-escape")

entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)

entity_2 = MessageEntity(type=MessageEntity.BOLD, offset=13, length=1)

message = Message(

1,

from_user=self.from_user,

date=self.date,

chat=self.chat,

text=text,

entities=[entity_2, entity],

)

assert message.parse_entities(MessageEntity.URL) == {entity: "http://google.com"}

assert message.parse_entities() == {entity: "http://google.com", entity_2: "h"}

async def test_parse_caption_entities(self):

text = (

b"\\U0001f469\\u200d\\U0001f469\\u200d\\U0001f467"

b"\\u200d\\U0001f467\\U0001f431http://google.com"

).decode("unicode-escape")

entity = MessageEntity(type=MessageEntity.URL, offset=13, length=17)

entity_2 = MessageEntity(type=MessageEntity.BOLD, offset=13, length=1)

message = Message(

1,

from_user=self.from_user,

date=self.date,

chat=self.chat,

caption=text,

caption_entities=[entity_2, entity],

)

assert message.parse_caption_entities(MessageEntity.URL) == {entity: "http://google.com"}

assert message.parse_caption_entities() == {

entity: "http://google.com",

entity_2: "h",

}

def test_text_html_simple(self):

test_html_string = (

"<u>Test</u> for &lt;<b>bold</b>, <i>ita_lic</i>, "

r"<code>\`code</code>, "

r'<a href="http://github.com/abc\)def">links</a>, '

'<a href="tg://user?id=123456789">text-mention</a> and '

r"<pre>`\pre</pre>. http://google.com "

"and <i>bold <b>nested in <s>strk&gt;trgh</s> nested in</b> italic</i>. "

'<pre><code class="python">Python pre</code></pre>. '

'<span class="tg-spoiler">Spoiled</span>. '

'<tg-emoji emoji-id="1">👍</tg-emoji>.\n'

"<blockquote>Multiline\nblock quote\nwith <b>nested</b>.</blockquote>\n\n"

"<blockquote expandable>Multiline\nexpandable\nblock quote.</blockquote>"

)

text_html = self.test_message_v2.text_html

assert text_html == test_html_string

def test_text_html_empty(self, message):

message.text = None

message.caption = "test"

assert message.text_html is None

def test_text_html_urled(self):

test_html_string = (

"<u>Test</u> for &lt;<b>bold</b>, <i>ita_lic</i>, "

r"<code>\`code</code>, "

r'<a href="http://github.com/abc\)def">links</a>, '

'<a href="tg://user?id=123456789">text-mention</a> and '

r'<pre>`\pre</pre>. <a href="http://google.com">http://google.com</a> '

"and <i>bold <b>nested in <s>strk&gt;trgh</s> nested in</b> italic</i>. "

'<pre><code class="python">Python pre</code></pre>. '

'<span class="tg-spoiler">Spoiled</span>. '

'<tg-emoji emoji-id="1">👍</tg-emoji>.\n'

"<blockquote>Multiline\nblock quote\nwith <b>nested</b>.</blockquote>\n\n"

"<blockquote expandable>Multiline\nexpandable\nblock quote.</blockquote>"

)

text_html = self.test_message_v2.text_html_urled

assert text_html == test_html_string

def test_text_markdown_simple(self):

test_md_string = (

r"Test for <*bold*, _ita_\__lic_, `code`, "

"[links](http://github.com/ab_), "

"[text-mention](tg://user?id=123456789) and ```python\npre```. "

r"http://google.com/ab\_"

)

text_markdown = self.test_message.text_markdown

assert text_markdown == test_md_string

def test_text_markdown_v2_simple(self):

test_md_string = (

r"__Test__ for <*bold*, _ita\_lic_, `\\\`code`, "

"[links](http://github.com/abc\\\\\\)def), "

"[text\\-mention](tg://user?id=123456789) and ```\\`\\\\pre```\\. "

r"http://google\.com and _bold *nested in ~strk\>trgh~ nested in* italic_\. "

"```python\nPython pre```\\. ||Spoiled||\\. \\.\n"

">Multiline\n"

">block quote\n"

r">with *nested*\."

"\n\n>Multiline\n"

">expandable\n"

r">block quote\.||"

)

text_markdown = self.test_message_v2.text_markdown_v2

assert text_markdown == test_md_string

@pytest.mark.parametrize(

"entity_type",

[

MessageEntity.UNDERLINE,

MessageEntity.STRIKETHROUGH,

MessageEntity.SPOILER,

MessageEntity.BLOCKQUOTE,

MessageEntity.CUSTOM_EMOJI,

],

)

def test_text_markdown_new_in_v2(self, message, entity_type):

message.text = "test"

message.entities = [

MessageEntity(MessageEntity.BOLD, offset=0, length=4),

MessageEntity(MessageEntity.ITALIC, offset=0, length=4),

]

with pytest.raises(ValueError, match="Nested entities are not supported for"):

assert message.text_markdown

message.entities = [MessageEntity(entity_type, offset=0, length=4)]

with pytest.raises(ValueError, match="entities are not supported for"):

message.text_markdown

message.entities = []

def test_text_markdown_empty(self, message):

message.text = None

message.caption = "test"

assert message.text_markdown is None

assert message.text_markdown_v2 is None

def test_text_markdown_urled(self):

test_md_string = (

r"Test for <*bold*, _ita_\__lic_, `code`, "

"[links](http://github.com/ab_), "

"[text-mention](tg://user?id=123456789) and ```python\npre```. "

"[http://google.com/ab_](http://google.com/ab_)"

)

text_markdown = self.test_message.text_markdown_urled

assert text_markdown == test_md_string

def test_text_markdown_v2_urled(self):

test_md_string = (

r"__Test__ for <*bold*, _ita\_lic_, `\\\`code`, "

"[links](http://github.com/abc\\\\\\)def), "

"[text\\-mention](tg://user?id=123456789) and ```\\`\\\\pre```\\. "

r"[http://google\.com](http://google.com) and _bold *nested in ~strk\>trgh~ "

"nested in* italic_\\. ```python\nPython pre```\\. ||Spoiled||\\. "

"\\.\n"

">Multiline\n"

">block quote\n"

r">with *nested*\."

"\n\n>Multiline\n"

">expandable\n"

r">block quote\.||"

)

text_markdown = self.test_message_v2.text_markdown_v2_urled

assert text_markdown == test_md_string

def test_text_html_emoji(self):

text = b"\\U0001f469\\u200d\\U0001f469\\u200d ABC".decode("unicode-escape")

expected = b"\\U0001f469\\u200d\\U0001f469\\u200d <b>ABC</b>".decode("unicode-escape")

bold_entity = MessageEntity(type=MessageEntity.BOLD, offset=7, length=3)

message = Message(

1,

from_user=self.from_user,

date=self.date,

chat=self.chat,

text=text,

entities=[bold_entity],

)

assert expected == message.text_html

def test_text_markdown_emoji(self):

text = b"\\U0001f469\\u200d\\U0001f469\\u200d ABC".decode("unicode-escape")

expected = b"\\U0001f469\\u200d\\U0001f469\\u200d *ABC*".decode("unicode-escape")

bold_entity = MessageEntity(type=MessageEntity.BOLD, offset=7, length=3)

message = Message(

1, self.date, self.chat, self.from_user, text=text, entities=[bold_entity]

)

assert expected == message.text_markdown

@pytest.mark.parametrize(

"type_",

argvalues=[

"text_markdown",

"text_markdown_urled",

],

)

def test_text_custom_emoji_md_v1(self, type_, recwarn):

text = "Look a custom emoji: 😎"

emoji_entity = MessageEntity(

type=MessageEntity.CUSTOM_EMOJI,

offset=21,

length=2,

custom_emoji_id="5472409228461217725",

)

message = Message(

1,

from_user=self.from_user,

date=self.date,

chat=self.chat,

text=text,

entities=[emoji_entity],

)

with pytest.raises(ValueError, match="Custom Emoji entities are not supported for"):

getattr(message, type_)

@pytest.mark.parametrize(

"type_",

argvalues=[

"text_markdown_v2",

"text_markdown_v2_urled",

],

)

def test_text_custom_emoji_md_v2(self, type_):

text = "Look a custom emoji: 😎"

expected = "Look a custom emoji: "

emoji_entity = MessageEntity(

type=MessageEntity.CUSTOM_EMOJI,

offset=21,

length=2,

custom_emoji_id="5472409228461217725",

)

message = Message(

1,

from_user=self.from_user,

date=self.date,

chat=self.chat,

text=text,

entities=[emoji_entity],

)

assert expected == message[type_]

@pytest.mark.parametrize(

"type_",

argvalues=[

"text_html",

"text_html_urled",

],

)

def test_text_custom_emoji_html(self, type_):

text = "Look a custom emoji: 😎"

expected = 'Look a custom emoji: <tg-emoji emoji-id="5472409228461217725">😎</tg-emoji>'

emoji_entity = MessageEntity(

type=MessageEntity.CUSTOM_EMOJI,

offset=21,

length=2,

custom_emoji_id="5472409228461217725",

)

message = Message(

1,

from_user=self.from_user,

date=self.date,

chat=self.chat,

text=text,

entities=[emoji_entity],

)

assert expected == message[type_]

def test_caption_html_simple(self):

test_html_string = (

"<u>Test</u> for &lt;<b>bold</b>, <i>ita_lic</i>, "

r"<code>\`code</code>, "

r'<a href="http://github.com/abc\)def">links</a>, '

'<a href="tg://user?id=123456789">text-mention</a> and '

r"<pre>`\pre</pre>. http://google.com "

"and <i>bold <b>nested in <s>strk&gt;trgh</s> nested in</b> italic</i>. "

'<pre><code class="python">Python pre</code></pre>. '

'<span class="tg-spoiler">Spoiled</span>. '

'<tg-emoji emoji-id="1">👍</tg-emoji>.\n'

"<blockquote>Multiline\nblock quote\nwith <b>nested</b>.</blockquote>\n\n"

"<blockquote expandable>Multiline\nexpandable\nblock quote.</blockquote>"

)

caption_html = self.test_message_v2.caption_html

assert caption_html == test_html_string

def test_caption_html_empty(self, message):

message.text = "test"

message.caption = None

assert message.caption_html is None

def test_caption_html_urled(self):

test_html_string = (

"<u>Test</u> for &lt;<b>bold</b>, <i>ita_lic</i>, "

r"<code>\`code</code>, "

r'<a href="http://github.com/abc\)def">links</a>, '

'<a href="tg://user?id=123456789">text-mention</a> and '

r'<pre>`\pre</pre>. <a href="http://google.com">http://google.com</a> '

"and <i>bold <b>nested in <s>strk&gt;trgh</s> nested in</b> italic</i>. "

'<pre><code class="python">Python pre</code></pre>. '

'<span class="tg-spoiler">Spoiled</span>. '

'<tg-emoji emoji-id="1">👍</tg-emoji>.\n'

"<blockquote>Multiline\nblock quote\nwith <b>nested</b>.</blockquote>\n\n"