# python-telegram-bot - a Python interface to the Telegram Bot API # Copyright (C) 2015-2025 # by the python-telegram-bot contributors # # 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 datetime as dtm import pytest from telegram import ( Chat, ChatBoost, ChatBoostAdded, ChatBoostRemoved, ChatBoostSource, ChatBoostSourceGiftCode, ChatBoostSourceGiveaway, ChatBoostSourcePremium, ChatBoostUpdated, Dice, User, UserChatBoosts, ) from telegram._utils.datetime import UTC, to_timestamp from telegram.constants import ChatBoostSources from telegram.request import RequestData from tests.auxil.dummy_objects import get_dummy_object_json_dict from tests.auxil.slots import mro_slots class ChatBoostDefaults: source = ChatBoostSource.PREMIUM chat_id = 1 boost_id = "2" giveaway_message_id = 3 is_unclaimed = False chat = Chat(1, "group") user = User(1, "user", False) date = dtm.datetime.now(dtm.timezone.utc).replace(microsecond=0) default_source = ChatBoostSourcePremium(user) prize_star_count = 99 boost = ChatBoost( boost_id=boost_id, add_date=date, expiration_date=date, source=default_source, ) @pytest.fixture(scope="module") def chat_boost_source(): return ChatBoostSource( source=ChatBoostDefaults.source, ) class TestChatBoostSourceWithoutRequest(ChatBoostDefaults): def test_slot_behaviour(self, chat_boost_source): inst = chat_boost_source for attr in inst.__slots__: assert getattr(inst, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot" def test_type_enum_conversion(self, chat_boost_source): assert type(ChatBoostSource("premium").source) is ChatBoostSources assert ChatBoostSource("unknown").source == "unknown" def test_de_json(self, offline_bot): json_dict = { "source": "unknown", } cbs = ChatBoostSource.de_json(json_dict, offline_bot) assert cbs.api_kwargs == {} assert cbs.source == "unknown" @pytest.mark.parametrize( ("cb_source", "subclass"), [ ("premium", ChatBoostSourcePremium), ("gift_code", ChatBoostSourceGiftCode), ("giveaway", ChatBoostSourceGiveaway), ], ) def test_de_json_subclass(self, offline_bot, cb_source, subclass): json_dict = { "source": cb_source, "user": ChatBoostDefaults.user.to_dict(), "giveaway_message_id": ChatBoostDefaults.giveaway_message_id, } cbs = ChatBoostSource.de_json(json_dict, offline_bot) assert type(cbs) is subclass assert set(cbs.api_kwargs.keys()) == set(json_dict.keys()) - set(subclass.__slots__) - { "source" } assert cbs.source == cb_source def test_to_dict(self, chat_boost_source): chat_boost_source_dict = chat_boost_source.to_dict() assert isinstance(chat_boost_source_dict, dict) assert chat_boost_source_dict["source"] == chat_boost_source.source def test_equality(self, chat_boost_source): a = chat_boost_source b = ChatBoostSource(source=ChatBoostDefaults.source) c = ChatBoostSource(source="unknown") d = Dice(5, "test") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) assert a != d assert hash(a) != hash(d) @pytest.fixture(scope="module") def chat_boost_source_premium(): return ChatBoostSourcePremium( user=TestChatBoostSourcePremiumWithoutRequest.user, ) class TestChatBoostSourcePremiumWithoutRequest(ChatBoostDefaults): source = ChatBoostSources.PREMIUM def test_slot_behaviour(self, chat_boost_source_premium): inst = chat_boost_source_premium for attr in inst.__slots__: assert getattr(inst, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot" def test_de_json(self, offline_bot): json_dict = { "user": self.user.to_dict(), } cbsp = ChatBoostSourcePremium.de_json(json_dict, offline_bot) assert cbsp.api_kwargs == {} assert cbsp.user == self.user def test_to_dict(self, chat_boost_source_premium): chat_boost_source_premium_dict = chat_boost_source_premium.to_dict() assert isinstance(chat_boost_source_premium_dict, dict) assert chat_boost_source_premium_dict["source"] == self.source assert chat_boost_source_premium_dict["user"] == self.user.to_dict() def test_equality(self, chat_boost_source_premium): a = chat_boost_source_premium b = ChatBoostSourcePremium(user=self.user) c = Dice(5, "test") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) @pytest.fixture(scope="module") def chat_boost_source_gift_code(): return ChatBoostSourceGiftCode( user=TestChatBoostSourceGiftCodeWithoutRequest.user, ) class TestChatBoostSourceGiftCodeWithoutRequest(ChatBoostDefaults): source = ChatBoostSources.GIFT_CODE def test_slot_behaviour(self, chat_boost_source_gift_code): inst = chat_boost_source_gift_code for attr in inst.__slots__: assert getattr(inst, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot" def test_de_json(self, offline_bot): json_dict = { "user": self.user.to_dict(), } cbsgc = ChatBoostSourceGiftCode.de_json(json_dict, offline_bot) assert cbsgc.api_kwargs == {} assert cbsgc.user == self.user def test_to_dict(self, chat_boost_source_gift_code): chat_boost_source_gift_code_dict = chat_boost_source_gift_code.to_dict() assert isinstance(chat_boost_source_gift_code_dict, dict) assert chat_boost_source_gift_code_dict["source"] == self.source assert chat_boost_source_gift_code_dict["user"] == self.user.to_dict() def test_equality(self, chat_boost_source_gift_code): a = chat_boost_source_gift_code b = ChatBoostSourceGiftCode(user=self.user) c = Dice(5, "test") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) @pytest.fixture(scope="module") def chat_boost_source_giveaway(): return ChatBoostSourceGiveaway( user=TestChatBoostSourceGiveawayWithoutRequest.user, giveaway_message_id=TestChatBoostSourceGiveawayWithoutRequest.giveaway_message_id, ) class TestChatBoostSourceGiveawayWithoutRequest(ChatBoostDefaults): source = ChatBoostSources.GIVEAWAY def test_slot_behaviour(self, chat_boost_source_giveaway): inst = chat_boost_source_giveaway for attr in inst.__slots__: assert getattr(inst, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot" def test_de_json(self, offline_bot): json_dict = { "user": self.user.to_dict(), "giveaway_message_id": self.giveaway_message_id, } cbsg = ChatBoostSourceGiveaway.de_json(json_dict, offline_bot) assert cbsg.api_kwargs == {} assert cbsg.user == self.user assert cbsg.giveaway_message_id == self.giveaway_message_id def test_to_dict(self, chat_boost_source_giveaway): chat_boost_source_giveaway_dict = chat_boost_source_giveaway.to_dict() assert isinstance(chat_boost_source_giveaway_dict, dict) assert chat_boost_source_giveaway_dict["source"] == self.source assert chat_boost_source_giveaway_dict["user"] == self.user.to_dict() assert chat_boost_source_giveaway_dict["giveaway_message_id"] == self.giveaway_message_id def test_equality(self, chat_boost_source_giveaway): a = chat_boost_source_giveaway b = ChatBoostSourceGiveaway(user=self.user, giveaway_message_id=self.giveaway_message_id) c = Dice(5, "test") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) @pytest.fixture(scope="module") def chat_boost(): return ChatBoost( boost_id=ChatBoostDefaults.boost_id, add_date=ChatBoostDefaults.date, expiration_date=ChatBoostDefaults.date, source=ChatBoostDefaults.default_source, ) class TestChatBoostWithoutRequest(ChatBoostDefaults): def test_slot_behaviour(self, chat_boost): inst = chat_boost for attr in inst.__slots__: assert getattr(inst, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot" def test_de_json(self, offline_bot, chat_boost): json_dict = { "boost_id": self.boost_id, "add_date": to_timestamp(self.date), "expiration_date": to_timestamp(self.date), "source": self.default_source.to_dict(), } cb = ChatBoost.de_json(json_dict, offline_bot) assert cb.api_kwargs == {} assert cb.boost_id == self.boost_id assert (cb.add_date) == self.date assert (cb.expiration_date) == self.date assert cb.source == self.default_source def test_de_json_localization(self, offline_bot, raw_bot, tz_bot): json_dict = { "boost_id": "2", "add_date": to_timestamp(self.date), "expiration_date": to_timestamp(self.date), "source": self.default_source.to_dict(), } cb_bot = ChatBoost.de_json(json_dict, offline_bot) cb_raw = ChatBoost.de_json(json_dict, raw_bot) cb_tz = ChatBoost.de_json(json_dict, tz_bot) # comparing utcoffsets because comparing timezones is unpredicatable message_offset = cb_tz.add_date.utcoffset() tz_bot_offset = tz_bot.defaults.tzinfo.utcoffset(cb_tz.add_date.replace(tzinfo=None)) assert cb_raw.add_date.tzinfo == UTC assert cb_bot.add_date.tzinfo == UTC assert message_offset == tz_bot_offset def test_to_dict(self, chat_boost): chat_boost_dict = chat_boost.to_dict() assert isinstance(chat_boost_dict, dict) assert chat_boost_dict["boost_id"] == chat_boost.boost_id assert chat_boost_dict["add_date"] == to_timestamp(chat_boost.add_date) assert chat_boost_dict["expiration_date"] == to_timestamp(chat_boost.expiration_date) assert chat_boost_dict["source"] == chat_boost.source.to_dict() def test_equality(self): a = ChatBoost( boost_id="2", add_date=self.date, expiration_date=self.date, source=self.default_source, ) b = ChatBoost( boost_id="2", add_date=self.date, expiration_date=self.date, source=self.default_source, ) c = ChatBoost( boost_id="3", add_date=self.date, expiration_date=self.date, source=self.default_source, ) assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) @pytest.fixture(scope="module") def chat_boost_updated(chat_boost): return ChatBoostUpdated( chat=ChatBoostDefaults.chat, boost=chat_boost, ) class TestChatBoostUpdatedWithoutRequest(ChatBoostDefaults): def test_slot_behaviour(self, chat_boost_updated): inst = chat_boost_updated for attr in inst.__slots__: assert getattr(inst, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot" def test_de_json(self, offline_bot, chat_boost): json_dict = { "chat": self.chat.to_dict(), "boost": self.boost.to_dict(), } cbu = ChatBoostUpdated.de_json(json_dict, offline_bot) assert cbu.api_kwargs == {} assert cbu.chat == self.chat assert cbu.boost == self.boost def test_to_dict(self, chat_boost_updated): chat_boost_updated_dict = chat_boost_updated.to_dict() assert isinstance(chat_boost_updated_dict, dict) assert chat_boost_updated_dict["chat"] == chat_boost_updated.chat.to_dict() assert chat_boost_updated_dict["boost"] == chat_boost_updated.boost.to_dict() def test_equality(self): a = ChatBoostUpdated( chat=Chat(1, "group"), boost=ChatBoost( boost_id="2", add_date=self.date, expiration_date=self.date, source=self.default_source, ), ) b = ChatBoostUpdated( chat=Chat(1, "group"), boost=ChatBoost( boost_id="2", add_date=self.date, expiration_date=self.date, source=self.default_source, ), ) c = ChatBoostUpdated( chat=Chat(2, "group"), boost=ChatBoost( boost_id="3", add_date=self.date, expiration_date=self.date, source=self.default_source, ), ) assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) @pytest.fixture(scope="module") def chat_boost_removed(): return ChatBoostRemoved( chat=ChatBoostDefaults.chat, boost_id=ChatBoostDefaults.boost_id, remove_date=ChatBoostDefaults.date, source=ChatBoostDefaults.default_source, ) class TestChatBoostRemovedWithoutRequest(ChatBoostDefaults): def test_slot_behaviour(self, chat_boost_removed): inst = chat_boost_removed for attr in inst.__slots__: assert getattr(inst, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot" def test_de_json(self, offline_bot, chat_boost_removed): json_dict = { "chat": self.chat.to_dict(), "boost_id": self.boost_id, "remove_date": to_timestamp(self.date), "source": self.default_source.to_dict(), } cbr = ChatBoostRemoved.de_json(json_dict, offline_bot) assert cbr.api_kwargs == {} assert cbr.chat == self.chat assert cbr.boost_id == self.boost_id assert cbr.remove_date == self.date assert cbr.source == self.default_source def test_de_json_localization(self, offline_bot, raw_bot, tz_bot): json_dict = { "chat": self.chat.to_dict(), "boost_id": self.boost_id, "remove_date": to_timestamp(self.date), "source": self.default_source.to_dict(), } cbr_bot = ChatBoostRemoved.de_json(json_dict, offline_bot) cbr_raw = ChatBoostRemoved.de_json(json_dict, raw_bot) cbr_tz = ChatBoostRemoved.de_json(json_dict, tz_bot) # comparing utcoffsets because comparing timezones is unpredicatable message_offset = cbr_tz.remove_date.utcoffset() tz_bot_offset = tz_bot.defaults.tzinfo.utcoffset(cbr_tz.remove_date.replace(tzinfo=None)) assert cbr_raw.remove_date.tzinfo == UTC assert cbr_bot.remove_date.tzinfo == UTC assert message_offset == tz_bot_offset def test_to_dict(self, chat_boost_removed): chat_boost_removed_dict = chat_boost_removed.to_dict() assert isinstance(chat_boost_removed_dict, dict) assert chat_boost_removed_dict["chat"] == chat_boost_removed.chat.to_dict() assert chat_boost_removed_dict["boost_id"] == chat_boost_removed.boost_id assert chat_boost_removed_dict["remove_date"] == to_timestamp( chat_boost_removed.remove_date ) assert chat_boost_removed_dict["source"] == chat_boost_removed.source.to_dict() def test_equality(self): a = ChatBoostRemoved( chat=Chat(1, "group"), boost_id="2", remove_date=self.date, source=self.default_source, ) b = ChatBoostRemoved( chat=Chat(1, "group"), boost_id="2", remove_date=self.date, source=self.default_source, ) c = ChatBoostRemoved( chat=Chat(2, "group"), boost_id="3", remove_date=self.date, source=self.default_source, ) assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) @pytest.fixture(scope="module") def user_chat_boosts(chat_boost): return UserChatBoosts( boosts=[chat_boost], ) class TestUserChatBoostsWithoutRequest(ChatBoostDefaults): def test_slot_behaviour(self, user_chat_boosts): inst = user_chat_boosts for attr in inst.__slots__: assert getattr(inst, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(inst)) == len(set(mro_slots(inst))), "duplicate slot" def test_de_json(self, offline_bot, user_chat_boosts): json_dict = { "boosts": [ self.boost.to_dict(), ] } ucb = UserChatBoosts.de_json(json_dict, offline_bot) assert ucb.api_kwargs == {} assert ucb.boosts[0] == self.boost def test_to_dict(self, user_chat_boosts): user_chat_boosts_dict = user_chat_boosts.to_dict() assert isinstance(user_chat_boosts_dict, dict) assert isinstance(user_chat_boosts_dict["boosts"], list) assert user_chat_boosts_dict["boosts"][0] == user_chat_boosts.boosts[0].to_dict() async def test_get_user_chat_boosts(self, monkeypatch, offline_bot): async def make_assertion(url, request_data: RequestData, *args, **kwargs): data = request_data.json_parameters chat_id = data["chat_id"] == "3" user_id = data["user_id"] == "2" if not all((chat_id, user_id)): pytest.fail("I got wrong parameters in post") return get_dummy_object_json_dict(UserChatBoosts) monkeypatch.setattr(offline_bot.request, "post", make_assertion) assert await offline_bot.get_user_chat_boosts("3", 2) class TestUserChatBoostsWithRequest(ChatBoostDefaults): async def test_get_user_chat_boosts(self, bot, channel_id, chat_id): chat_boosts = await bot.get_user_chat_boosts(channel_id, chat_id) assert isinstance(chat_boosts, UserChatBoosts) class TestChatBoostAddedWithoutRequest: boost_count = 100 def test_slot_behaviour(self): action = ChatBoostAdded(8) for attr in action.__slots__: assert getattr(action, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(action)) == len(set(mro_slots(action))), "duplicate slot" def test_de_json(self): json_dict = {"boost_count": self.boost_count} chat_boost_added = ChatBoostAdded.de_json(json_dict, None) assert chat_boost_added.api_kwargs == {} assert chat_boost_added.boost_count == self.boost_count def test_to_dict(self): chat_boost_added = ChatBoostAdded(self.boost_count) chat_boost_added_dict = chat_boost_added.to_dict() assert isinstance(chat_boost_added_dict, dict) assert chat_boost_added_dict["boost_count"] == self.boost_count def test_equality(self): a = ChatBoostAdded(100) b = ChatBoostAdded(100) c = ChatBoostAdded(50) d = Chat(1, "") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) assert a != d assert hash(a) != hash(d)