#!/usr/bin/env python # # A library that provides a Python interface to the Telegram Bot API # Copyright (C) 2015-2025 # Leandro Toledo de Souza # # 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 Dice from telegram._chat import Chat from telegram._message import Message from telegram._payment.stars.staramount import StarAmount from telegram._suggestedpost import ( SuggestedPostApprovalFailed, SuggestedPostApproved, SuggestedPostDeclined, SuggestedPostInfo, SuggestedPostPaid, SuggestedPostParameters, SuggestedPostPrice, SuggestedPostRefunded, ) from telegram._utils.datetime import UTC, to_timestamp from telegram.constants import SuggestedPostInfoState from tests.auxil.slots import mro_slots @pytest.fixture(scope="module") def suggested_post_parameters(): return SuggestedPostParameters( price=SuggestedPostParametersTestBase.price, send_date=SuggestedPostParametersTestBase.send_date, ) class SuggestedPostParametersTestBase: price = SuggestedPostPrice(currency="XTR", amount=100) send_date = dtm.datetime.now(tz=UTC).replace(microsecond=0) class TestSuggestedPostParametersWithoutRequest(SuggestedPostParametersTestBase): def test_slot_behaviour(self, suggested_post_parameters): for attr in suggested_post_parameters.__slots__: assert getattr(suggested_post_parameters, attr, "err") != "err", ( f"got extra slot '{attr}'" ) assert len(mro_slots(suggested_post_parameters)) == len( set(mro_slots(suggested_post_parameters)) ), "duplicate slot" def test_de_json(self, offline_bot): json_dict = { "price": self.price.to_dict(), "send_date": to_timestamp(self.send_date), } spp = SuggestedPostParameters.de_json(json_dict, offline_bot) assert spp.price == self.price assert spp.send_date == self.send_date assert spp.api_kwargs == {} def test_de_json_localization(self, offline_bot, raw_bot, tz_bot): json_dict = { "price": self.price.to_dict(), "send_date": to_timestamp(self.send_date), } spp_bot = SuggestedPostParameters.de_json(json_dict, offline_bot) spp_bot_raw = SuggestedPostParameters.de_json(json_dict, raw_bot) spp_bot_tz = SuggestedPostParameters.de_json(json_dict, tz_bot) # comparing utcoffsets because comparing tzinfo objects is not reliable send_date_offset = spp_bot_tz.send_date.utcoffset() send_date_offset_tz = tz_bot.defaults.tzinfo.utcoffset( spp_bot_tz.send_date.replace(tzinfo=None) ) assert spp_bot.send_date.tzinfo == UTC assert spp_bot_raw.send_date.tzinfo == UTC assert send_date_offset_tz == send_date_offset def test_to_dict(self, suggested_post_parameters): spp_dict = suggested_post_parameters.to_dict() assert isinstance(spp_dict, dict) assert spp_dict["price"] == self.price.to_dict() assert spp_dict["send_date"] == to_timestamp(self.send_date) def test_equality(self, suggested_post_parameters): a = suggested_post_parameters b = SuggestedPostParameters(price=self.price, send_date=self.send_date) c = SuggestedPostParameters( price=self.price, send_date=self.send_date + dtm.timedelta(seconds=1) ) e = Dice(4, "emoji") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) assert a != e assert hash(a) != hash(e) @pytest.fixture(scope="module") def suggested_post_info(): return SuggestedPostInfo( state=SuggestedPostInfoTestBase.state, price=SuggestedPostInfoTestBase.price, send_date=SuggestedPostInfoTestBase.send_date, ) class SuggestedPostInfoTestBase: state = SuggestedPostInfoState.PENDING price = SuggestedPostPrice(currency="XTR", amount=100) send_date = dtm.datetime.now(tz=UTC).replace(microsecond=0) class TestSuggestedPostInfoWithoutRequest(SuggestedPostInfoTestBase): def test_slot_behaviour(self, suggested_post_info): for attr in suggested_post_info.__slots__: assert getattr(suggested_post_info, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(suggested_post_info)) == len(set(mro_slots(suggested_post_info))), ( "duplicate slot" ) def test_type_enum_conversion(self): assert type(SuggestedPostInfo("pending").state) is SuggestedPostInfoState assert SuggestedPostInfo("unknown").state == "unknown" def test_de_json(self, offline_bot): json_dict = { "state": self.state, "price": self.price.to_dict(), "send_date": to_timestamp(self.send_date), } spi = SuggestedPostInfo.de_json(json_dict, offline_bot) assert spi.state == self.state assert spi.price == self.price assert spi.send_date == self.send_date assert spi.api_kwargs == {} def test_de_json_localization(self, offline_bot, raw_bot, tz_bot): json_dict = { "state": self.state, "price": self.price.to_dict(), "send_date": to_timestamp(self.send_date), } spi_bot = SuggestedPostInfo.de_json(json_dict, offline_bot) spi_bot_raw = SuggestedPostInfo.de_json(json_dict, raw_bot) spi_bot_tz = SuggestedPostInfo.de_json(json_dict, tz_bot) # comparing utcoffsets because comparing tzinfo objects is not reliable send_date_offset = spi_bot_tz.send_date.utcoffset() send_date_offset_tz = tz_bot.defaults.tzinfo.utcoffset( spi_bot_tz.send_date.replace(tzinfo=None) ) assert spi_bot.send_date.tzinfo == UTC assert spi_bot_raw.send_date.tzinfo == UTC assert send_date_offset_tz == send_date_offset def test_to_dict(self, suggested_post_info): spi_dict = suggested_post_info.to_dict() assert isinstance(spi_dict, dict) assert spi_dict["state"] == self.state assert spi_dict["price"] == self.price.to_dict() assert spi_dict["send_date"] == to_timestamp(self.send_date) def test_equality(self, suggested_post_info): a = suggested_post_info b = SuggestedPostInfo(state=self.state, price=self.price) c = SuggestedPostInfo(state=SuggestedPostInfoState.DECLINED, price=self.price) e = Dice(4, "emoji") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) assert a != e assert hash(a) != hash(e) @pytest.fixture(scope="module") def suggested_post_price(): return SuggestedPostPrice( currency=SuggestedPostPriceTestBase.currency, amount=SuggestedPostPriceTestBase.amount, ) class SuggestedPostPriceTestBase: currency = "XTR" amount = 100 class TestSuggestedPostPriceWithoutRequest(SuggestedPostPriceTestBase): def test_slot_behaviour(self, suggested_post_price): for attr in suggested_post_price.__slots__: assert getattr(suggested_post_price, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(suggested_post_price)) == len(set(mro_slots(suggested_post_price))), ( "duplicate slot" ) def test_de_json(self, offline_bot): json_dict = { "currency": self.currency, "amount": self.amount, } spp = SuggestedPostPrice.de_json(json_dict, offline_bot) assert spp.currency == self.currency assert spp.amount == self.amount assert spp.api_kwargs == {} def test_to_dict(self, suggested_post_price): spp_dict = suggested_post_price.to_dict() assert isinstance(spp_dict, dict) assert spp_dict["currency"] == self.currency assert spp_dict["amount"] == self.amount def test_equality(self, suggested_post_price): a = suggested_post_price b = SuggestedPostPrice(currency=self.currency, amount=self.amount) c = SuggestedPostPrice(currency="TON", amount=self.amount) e = Dice(4, "emoji") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) assert a != e assert hash(a) != hash(e) @pytest.fixture(scope="module") def suggested_post_declined(): return SuggestedPostDeclined( suggested_post_message=SuggestedPostDeclinedTestBase.suggested_post_message, comment=SuggestedPostDeclinedTestBase.comment, ) class SuggestedPostDeclinedTestBase: suggested_post_message = Message(1, dtm.datetime.now(), Chat(1, ""), text="post this pls.") comment = "another time" class TestSuggestedPostDeclinedWithoutRequest(SuggestedPostDeclinedTestBase): def test_slot_behaviour(self, suggested_post_declined): for attr in suggested_post_declined.__slots__: assert getattr(suggested_post_declined, attr, "err") != "err", ( f"got extra slot '{attr}'" ) assert len(mro_slots(suggested_post_declined)) == len( set(mro_slots(suggested_post_declined)) ), "duplicate slot" def test_de_json(self, offline_bot): json_dict = { "suggested_post_message": self.suggested_post_message.to_dict(), "comment": self.comment, } spd = SuggestedPostDeclined.de_json(json_dict, offline_bot) assert spd.suggested_post_message == self.suggested_post_message assert spd.comment == self.comment assert spd.api_kwargs == {} def test_to_dict(self, suggested_post_declined): spd_dict = suggested_post_declined.to_dict() assert isinstance(spd_dict, dict) assert spd_dict["suggested_post_message"] == self.suggested_post_message.to_dict() assert spd_dict["comment"] == self.comment def test_equality(self, suggested_post_declined): a = suggested_post_declined b = SuggestedPostDeclined( suggested_post_message=self.suggested_post_message, comment=self.comment ) c = SuggestedPostDeclined(suggested_post_message=self.suggested_post_message, comment="no") e = Dice(4, "emoji") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) assert a != e assert hash(a) != hash(e) @pytest.fixture(scope="module") def suggested_post_paid(): return SuggestedPostPaid( currency=SuggestedPostPaidTestBase.currency, suggested_post_message=SuggestedPostPaidTestBase.suggested_post_message, amount=SuggestedPostPaidTestBase.amount, star_amount=SuggestedPostPaidTestBase.star_amount, ) class SuggestedPostPaidTestBase: suggested_post_message = Message(1, dtm.datetime.now(), Chat(1, ""), text="post this pls.") currency = "XTR" amount = 100 star_amount = StarAmount(100) class TestSuggestedPostPaidWithoutRequest(SuggestedPostPaidTestBase): def test_slot_behaviour(self, suggested_post_paid): for attr in suggested_post_paid.__slots__: assert getattr(suggested_post_paid, attr, "err") != "err", f"got extra slot '{attr}'" assert len(mro_slots(suggested_post_paid)) == len(set(mro_slots(suggested_post_paid))), ( "duplicate slot" ) def test_de_json(self, offline_bot): json_dict = { "suggested_post_message": self.suggested_post_message.to_dict(), "currency": self.currency, "amount": self.amount, "star_amount": self.star_amount.to_dict(), } spp = SuggestedPostPaid.de_json(json_dict, offline_bot) assert spp.suggested_post_message == self.suggested_post_message assert spp.currency == self.currency assert spp.amount == self.amount assert spp.star_amount == self.star_amount assert spp.api_kwargs == {} def test_to_dict(self, suggested_post_paid): spp_dict = suggested_post_paid.to_dict() assert isinstance(spp_dict, dict) assert spp_dict["suggested_post_message"] == self.suggested_post_message.to_dict() assert spp_dict["currency"] == self.currency assert spp_dict["amount"] == self.amount assert spp_dict["star_amount"] == self.star_amount.to_dict() def test_equality(self, suggested_post_paid): a = suggested_post_paid b = SuggestedPostPaid( suggested_post_message=self.suggested_post_message, currency=self.currency, amount=self.amount, star_amount=self.star_amount, ) c = SuggestedPostPaid( suggested_post_message=self.suggested_post_message, currency=self.currency, amount=self.amount - 1, star_amount=StarAmount(self.amount - 1), ) e = Dice(4, "emoji") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) assert a != e assert hash(a) != hash(e) @pytest.fixture(scope="module") def suggested_post_refunded(): return SuggestedPostRefunded( reason=SuggestedPostRefundedTestBase.reason, suggested_post_message=SuggestedPostRefundedTestBase.suggested_post_message, ) class SuggestedPostRefundedTestBase: reason = "post_deleted" suggested_post_message = Message(1, dtm.datetime.now(), Chat(1, ""), text="post this pls.") class TestSuggestedPostRefundedWithoutRequest(SuggestedPostRefundedTestBase): def test_slot_behaviour(self, suggested_post_refunded): for attr in suggested_post_refunded.__slots__: assert getattr(suggested_post_refunded, attr, "err") != "err", ( f"got extra slot '{attr}'" ) assert len(mro_slots(suggested_post_refunded)) == len( set(mro_slots(suggested_post_refunded)) ), "duplicate slot" def test_de_json(self, offline_bot): json_dict = { "suggested_post_message": self.suggested_post_message.to_dict(), "reason": self.reason, } spr = SuggestedPostRefunded.de_json(json_dict, offline_bot) assert spr.suggested_post_message == self.suggested_post_message assert spr.reason == self.reason assert spr.api_kwargs == {} def test_to_dict(self, suggested_post_refunded): spr_dict = suggested_post_refunded.to_dict() assert isinstance(spr_dict, dict) assert spr_dict["suggested_post_message"] == self.suggested_post_message.to_dict() assert spr_dict["reason"] == self.reason def test_equality(self, suggested_post_refunded): a = suggested_post_refunded b = SuggestedPostRefunded( suggested_post_message=self.suggested_post_message, reason=self.reason ) c = SuggestedPostRefunded( suggested_post_message=self.suggested_post_message, reason="payment_refunded" ) e = Dice(4, "emoji") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) assert a != e assert hash(a) != hash(e) @pytest.fixture(scope="module") def suggested_post_approved(): return SuggestedPostApproved( send_date=SuggestedPostApprovedTestBase.send_date, suggested_post_message=SuggestedPostApprovedTestBase.suggested_post_message, price=SuggestedPostApprovedTestBase.price, ) class SuggestedPostApprovedTestBase: send_date = dtm.datetime.now(tz=UTC).replace(microsecond=0) suggested_post_message = Message(1, dtm.datetime.now(), Chat(1, ""), text="post this pls.") price = SuggestedPostPrice(currency="XTR", amount=100) class TestSuggestedPostApprovedWithoutRequest(SuggestedPostApprovedTestBase): def test_slot_behaviour(self, suggested_post_approved): for attr in suggested_post_approved.__slots__: assert getattr(suggested_post_approved, attr, "err") != "err", ( f"got extra slot '{attr}'" ) assert len(mro_slots(suggested_post_approved)) == len( set(mro_slots(suggested_post_approved)) ), "duplicate slot" def test_de_json(self, offline_bot): json_dict = { "send_date": to_timestamp(self.send_date), "suggested_post_message": self.suggested_post_message.to_dict(), "price": self.price.to_dict(), } spa = SuggestedPostApproved.de_json(json_dict, offline_bot) assert spa.send_date == self.send_date assert spa.suggested_post_message == self.suggested_post_message assert spa.price == self.price assert spa.api_kwargs == {} def test_de_json_localization(self, offline_bot, raw_bot, tz_bot): json_dict = { "send_date": to_timestamp(self.send_date), "suggested_post_message": self.suggested_post_message.to_dict(), "price": self.price.to_dict(), } spa_bot = SuggestedPostApproved.de_json(json_dict, offline_bot) spa_bot_raw = SuggestedPostApproved.de_json(json_dict, raw_bot) spi_bot_tz = SuggestedPostApproved.de_json(json_dict, tz_bot) # comparing utcoffsets because comparing tzinfo objects is not reliable send_date_offset = spi_bot_tz.send_date.utcoffset() send_date_offset_tz = tz_bot.defaults.tzinfo.utcoffset( spi_bot_tz.send_date.replace(tzinfo=None) ) assert spa_bot.send_date.tzinfo == UTC assert spa_bot_raw.send_date.tzinfo == UTC assert send_date_offset_tz == send_date_offset def test_to_dict(self, suggested_post_approved): spa_dict = suggested_post_approved.to_dict() assert isinstance(spa_dict, dict) assert spa_dict["send_date"] == to_timestamp(self.send_date) assert spa_dict["suggested_post_message"] == self.suggested_post_message.to_dict() assert spa_dict["price"] == self.price.to_dict() def test_equality(self, suggested_post_approved): a = suggested_post_approved b = SuggestedPostApproved( send_date=self.send_date, suggested_post_message=self.suggested_post_message, price=self.price, ) c = SuggestedPostApproved( send_date=self.send_date, suggested_post_message=self.suggested_post_message, price=SuggestedPostPrice(currency="XTR", amount=self.price.amount - 1), ) e = Dice(4, "emoji") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) assert a != e assert hash(a) != hash(e) @pytest.fixture(scope="module") def suggested_post_approval_failed(): return SuggestedPostApprovalFailed( price=SuggestedPostApprovalFailedTestBase.price, suggested_post_message=SuggestedPostApprovalFailedTestBase.suggested_post_message, ) class SuggestedPostApprovalFailedTestBase: price = SuggestedPostPrice(currency="XTR", amount=100) suggested_post_message = Message(1, dtm.datetime.now(), Chat(1, ""), text="post this pls.") class TestSuggestedPostApprovalFailedWithoutRequest(SuggestedPostApprovalFailedTestBase): def test_slot_behaviour(self, suggested_post_approval_failed): for attr in suggested_post_approval_failed.__slots__: assert getattr(suggested_post_approval_failed, attr, "err") != "err", ( f"got extra slot '{attr}'" ) assert len(mro_slots(suggested_post_approval_failed)) == len( set(mro_slots(suggested_post_approval_failed)) ), "duplicate slot" def test_de_json(self, offline_bot): json_dict = { "price": self.price.to_dict(), "suggested_post_message": self.suggested_post_message.to_dict(), } spaf = SuggestedPostApprovalFailed.de_json(json_dict, offline_bot) assert spaf.price == self.price assert spaf.suggested_post_message == self.suggested_post_message assert spaf.api_kwargs == {} def test_to_dict(self, suggested_post_approval_failed): spaf_dict = suggested_post_approval_failed.to_dict() assert isinstance(spaf_dict, dict) assert spaf_dict["price"] == self.price.to_dict() assert spaf_dict["suggested_post_message"] == self.suggested_post_message.to_dict() def test_equality(self, suggested_post_approval_failed): a = suggested_post_approval_failed b = SuggestedPostApprovalFailed( price=self.price, suggested_post_message=self.suggested_post_message, ) c = SuggestedPostApprovalFailed( price=SuggestedPostPrice(currency="XTR", amount=self.price.amount - 1), suggested_post_message=self.suggested_post_message, ) e = Dice(4, "emoji") assert a == b assert hash(a) == hash(b) assert a != c assert hash(a) != hash(c) assert a != e assert hash(a) != hash(e)