#!/usr/bin/env python

#

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

# Copyright (C) 2015-2026

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

import json

import re

import pytest

from telegram import Message, constants

from telegram._utils.enum import FloatEnum, IntEnum, StringEnum

from telegram.error import BadRequest

from tests.auxil.build_messages import make_message

from tests.auxil.files import data_file

from tests.auxil.string_manipulation import to_snake_case

class StrEnumTest(StringEnum):

FOO = "foo"

BAR = "bar"

class IntEnumTest(IntEnum):

FOO = 1

BAR = 2

class FloatEnumTest(FloatEnum):

FOO = 1.1

BAR = 2.1

class TestConstantsWithoutRequest:

"""Also test _utils.enum.StringEnum on the fly because tg.constants is currently the only

place where that class is used."""

def test__all__(self):

expected = {

key

for key, member in constants.__dict__.items()

if (

not key.startswith("_")

# exclude imported stuff

and getattr(member, "__module__", "telegram.constants") == "telegram.constants"

and key not in ("sys", "dtm", "UTC")

)

}

actual = set(constants.__all__)

assert actual == expected, (

f"Members {expected - actual} were not listed in constants.__all__"

)

def test_message_attachment_type(self):

assert all(

getattr(constants.MessageType, x.name, False) for x in constants.MessageAttachmentType

), "All MessageAttachmentType members should be in MessageType"

def test_to_json(self):

assert json.dumps(StrEnumTest.FOO) == json.dumps("foo")

assert json.dumps(IntEnumTest.FOO) == json.dumps(1)

assert json.dumps(FloatEnumTest.FOO) == json.dumps(1.1)

def test_string_representation(self):

# test __repr__

assert repr(StrEnumTest.FOO) == "<StrEnumTest.FOO>"

# test __format__

assert f"{StrEnumTest.FOO} this {StrEnumTest.BAR}" == "foo this bar"

assert f"{StrEnumTest.FOO:*^10}" == "***foo****"

# test __str__

assert str(StrEnumTest.FOO) == "foo"

def test_int_representation(self):

# test __repr__

assert repr(IntEnumTest.FOO) == "<IntEnumTest.FOO>"

# test __format__

assert f"{IntEnumTest.FOO}/0 is undefined!" == "1/0 is undefined!"

assert f"{IntEnumTest.FOO:*^10}" == "****1*****"

# test __str__

assert str(IntEnumTest.FOO) == "1"

def test_float_representation(self):

# test __repr__

assert repr(FloatEnumTest.FOO) == "<FloatEnumTest.FOO>"

# test __format__

assert f"{FloatEnumTest.FOO}/0 is undefined!" == "1.1/0 is undefined!"

assert f"{FloatEnumTest.FOO:*^10}" == "***1.1****"

# test __str__

assert str(FloatEnumTest.FOO) == "1.1"

def test_string_inheritance(self):

assert isinstance(StrEnumTest.FOO, str)

assert StrEnumTest.FOO + StrEnumTest.BAR == "foobar"

assert StrEnumTest.FOO.replace("o", "a") == "faa"

assert StrEnumTest.FOO == StrEnumTest.FOO

assert StrEnumTest.FOO == "foo"

assert StrEnumTest.FOO != StrEnumTest.BAR

assert StrEnumTest.FOO != "bar"

assert object() != StrEnumTest.FOO

assert hash(StrEnumTest.FOO) == hash("foo")

def test_int_inheritance(self):

assert isinstance(IntEnumTest.FOO, int)

assert IntEnumTest.FOO + IntEnumTest.BAR == 3

assert IntEnumTest.FOO == IntEnumTest.FOO

assert IntEnumTest.FOO == 1

assert IntEnumTest.FOO != IntEnumTest.BAR

assert IntEnumTest.FOO != 2

assert object() != IntEnumTest.FOO

assert hash(IntEnumTest.FOO) == hash(1)

def test_float_inheritance(self):

assert isinstance(FloatEnumTest.FOO, float)

assert FloatEnumTest.FOO + FloatEnumTest.BAR == 3.2

assert FloatEnumTest.FOO == FloatEnumTest.FOO

assert FloatEnumTest.FOO == 1.1

assert FloatEnumTest.FOO != FloatEnumTest.BAR

assert FloatEnumTest.FOO != 2.1

assert object() != FloatEnumTest.FOO

assert hash(FloatEnumTest.FOO) == hash(1.1)

def test_bot_api_version_and_info(self):

assert str(constants.BOT_API_VERSION_INFO) == constants.BOT_API_VERSION

assert (

tuple(int(x) for x in constants.BOT_API_VERSION.split("."))

== constants.BOT_API_VERSION_INFO

)

def test_bot_api_version_info(self):

vi = constants.BOT_API_VERSION_INFO

assert isinstance(vi, tuple)

assert repr(vi) == f"BotAPIVersion(major={vi[0]}, minor={vi[1]})"

assert vi == (vi[0], vi[1])

assert not (vi < (vi[0], vi[1]))

assert vi < (vi[0], vi[1] + 1)

assert vi < (vi[0] + 1, vi[1])

assert vi < (vi[0] + 1, vi[1] + 1)

assert vi[0] == vi.major

assert vi[1] == vi.minor

@staticmethod

def is_type_attribute(name: str) -> bool:

# Return False if the attribute doesn't generate a message type, i.e. only message

# metadata. Manually excluding a lot of attributes here is a bit of work, but it makes

# sure that we don't miss any new message types in the future.

patters = {

"(text|caption)_(markdown|html)",

"caption_(entities|html|markdown)",

"(edit_)?date",

"forward_",

"has_",

}

if any(re.match(pattern, name) for pattern in patters):

return False

return name not in {

"author_signature",

"api_kwargs",

"caption",

"chat",

"chat_id",

"direct_messages_topic",

"effective_attachment",

"entities",

"from_user",

"id",

"is_automatic_forward",

"is_topic_message",

"link",

"link_preview_options",

"media_group_id",

"message_id",

"message_thread_id",

"migrate_from_chat_id",

"reply_markup",

"reply_to_message",

"sender_chat",

"sender_tag",

"is_accessible",

"quote",

"external_reply",

"via_bot",

"is_from_offline",

"show_caption_above_media",

"paid_star_count",

"is_paid_post",

"reply_to_checklist_task_id",

}

@pytest.mark.parametrize(

"attribute",

[

name

for name, _ in inspect.getmembers(

make_message("test"), lambda x: not inspect.isroutine(x)

)

],

)

def test_message_type_completeness(self, attribute):

if attribute.startswith("_") or not self.is_type_attribute(attribute):

return

assert hasattr(constants.MessageType, attribute.upper()), (

f"Missing MessageType.{attribute}. Please also check if this should be present in "

f"MessageAttachmentType."

)

@pytest.mark.parametrize("member", constants.MessageType)

def test_message_type_completeness_reverse(self, member):

assert self.is_type_attribute(member.value), (

f"Additional member {member} in MessageType that should not be a message type"

)

@pytest.mark.parametrize("member", constants.MessageAttachmentType)

def test_message_attachment_type_completeness(self, member):

try:

constants.MessageType(member)

except ValueError:

pytest.fail(f"Missing MessageType for {member}")

def test_message_attachment_type_completeness_reverse(self):

# Getting the type hints of a property is a bit tricky, so we instead parse the docstring

# for now

for match in re.finditer(r"`telegram.(\w+)`", Message.effective_attachment.__doc__):

name = to_snake_case(match.group(1))

if name == "photo_size":

name = "photo"

if name == "paid_media_info":

name = "paid_media"

try:

constants.MessageAttachmentType(name)

except ValueError:

pytest.fail(f"Missing MessageAttachmentType for {match.group(1)}")

def test_keyboard_button_style(self):

assert constants.KeyboardButtonStyle.PRIMARY == "primary"

assert constants.KeyboardButtonStyle.SUCCESS == "success"

assert constants.KeyboardButtonStyle.DANGER == "danger"

assert constants.KeyboardButtonStyle.BLUE == "primary"

assert constants.KeyboardButtonStyle.GREEN == "success"

assert constants.KeyboardButtonStyle.RED == "danger"

class TestConstantsWithRequest:

async def test_max_message_length(self, bot, chat_id):

good_text = "a" * constants.MessageLimit.MAX_TEXT_LENGTH

bad_text = good_text + "Z"

tasks = asyncio.gather(

bot.send_message(chat_id, text=good_text),

bot.send_message(chat_id, text=bad_text),

return_exceptions=True,

)

good_msg, bad_msg = await tasks

if isinstance(good_msg, BaseException):

# handling xfails

raise good_msg

assert good_msg.text == good_text

assert isinstance(bad_msg, BadRequest)

assert "Message is too long" in str(bad_msg)

async def test_max_caption_length(self, bot, chat_id):

good_caption = "a" * constants.MessageLimit.CAPTION_LENGTH

bad_caption = good_caption + "Z"

tasks = asyncio.gather(

bot.send_photo(chat_id, data_file("telegram.png").read_bytes(), good_caption),

bot.send_photo(chat_id, data_file("telegram.png").read_bytes(), bad_caption),

return_exceptions=True,

)

good_msg, bad_msg = await tasks

if isinstance(good_msg, BaseException):

# handling xfails

raise good_msg

assert good_msg.caption == good_caption

assert isinstance(bad_msg, BadRequest)

assert "Message caption is too long" in str(bad_msg)