python-telegram-bot/tests/test_messageorigin.py
Harshil 8f9db63f4f
Bump ruff and Add New Rules (#4416)
Co-authored-by: Bibo-Joshi <22366557+Bibo-Joshi@users.noreply.github.com>
2024-08-07 21:56:46 +02:00

231 lines
8.2 KiB
Python

#!/usr/bin/env python
#
# A library that provides a Python interface to the Telegram Bot API
# Copyright (C) 2015-2024
# 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 datetime
import inspect
from copy import deepcopy
import pytest
from telegram import (
Chat,
Dice,
MessageOrigin,
MessageOriginChannel,
MessageOriginChat,
MessageOriginHiddenUser,
MessageOriginUser,
User,
)
from telegram._utils.datetime import UTC, to_timestamp
from tests.auxil.slots import mro_slots
ignored = ["self", "api_kwargs"]
class MODefaults:
date: datetime.datetime = to_timestamp(datetime.datetime.utcnow())
chat = Chat(1, Chat.CHANNEL)
message_id = 123
author_signautre = "PTB"
sender_chat = Chat(1, Chat.CHANNEL)
sender_user_name = "PTB"
sender_user = User(1, "user", False)
def message_origin_channel():
return MessageOriginChannel(
MODefaults.date, MODefaults.chat, MODefaults.message_id, MODefaults.author_signautre
)
def message_origin_chat():
return MessageOriginChat(
MODefaults.date,
MODefaults.sender_chat,
MODefaults.author_signautre,
)
def message_origin_hidden_user():
return MessageOriginHiddenUser(MODefaults.date, MODefaults.sender_user_name)
def message_origin_user():
return MessageOriginUser(MODefaults.date, MODefaults.sender_user)
def make_json_dict(instance: MessageOrigin, include_optional_args: bool = False) -> dict:
"""Used to make the json dict which we use for testing de_json. Similar to iter_args()"""
json_dict = {"type": instance.type}
sig = inspect.signature(instance.__class__.__init__)
for param in sig.parameters.values():
if param.name in ignored: # ignore irrelevant params
continue
val = getattr(instance, param.name)
# Compulsory args-
if param.default is inspect.Parameter.empty:
if hasattr(val, "to_dict"): # convert the user object or any future ones to dict.
val = val.to_dict()
json_dict[param.name] = val
# If we want to test all args (for de_json)-
elif param.default is not inspect.Parameter.empty and include_optional_args:
json_dict[param.name] = val
return json_dict
def iter_args(
instance: MessageOrigin, de_json_inst: MessageOrigin, include_optional: bool = False
):
"""
We accept both the regular instance and de_json created instance and iterate over them for
easy one line testing later one.
"""
yield instance.type, de_json_inst.type # yield this here cause it's not available in sig.
sig = inspect.signature(instance.__class__.__init__)
for param in sig.parameters.values():
if param.name in ignored:
continue
inst_at, json_at = getattr(instance, param.name), getattr(de_json_inst, param.name)
if isinstance(json_at, datetime.datetime): # Convert datetime to int
json_at = to_timestamp(json_at)
if (
param.default is not inspect.Parameter.empty and include_optional
) or param.default is inspect.Parameter.empty:
yield inst_at, json_at
@pytest.fixture
def message_origin_type(request):
return request.param()
@pytest.mark.parametrize(
"message_origin_type",
[
message_origin_channel,
message_origin_chat,
message_origin_hidden_user,
message_origin_user,
],
indirect=True,
)
class TestMessageOriginTypesWithoutRequest:
def test_slot_behaviour(self, message_origin_type):
inst = message_origin_type
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_required_args(self, bot, message_origin_type):
cls = message_origin_type.__class__
assert cls.de_json({}, bot) is None
json_dict = make_json_dict(message_origin_type)
const_message_origin = MessageOrigin.de_json(json_dict, bot)
assert const_message_origin.api_kwargs == {}
assert isinstance(const_message_origin, MessageOrigin)
assert isinstance(const_message_origin, cls)
for msg_origin_type_at, const_msg_origin_at in iter_args(
message_origin_type, const_message_origin
):
assert msg_origin_type_at == const_msg_origin_at
def test_de_json_all_args(self, bot, message_origin_type):
json_dict = make_json_dict(message_origin_type, include_optional_args=True)
const_message_origin = MessageOrigin.de_json(json_dict, bot)
assert const_message_origin.api_kwargs == {}
assert isinstance(const_message_origin, MessageOrigin)
assert isinstance(const_message_origin, message_origin_type.__class__)
for msg_origin_type_at, const_msg_origin_at in iter_args(
message_origin_type, const_message_origin, True
):
assert msg_origin_type_at == const_msg_origin_at
def test_de_json_messageorigin_localization(self, message_origin_type, tz_bot, bot, raw_bot):
json_dict = make_json_dict(message_origin_type, include_optional_args=True)
msgorigin_raw = MessageOrigin.de_json(json_dict, raw_bot)
msgorigin_bot = MessageOrigin.de_json(json_dict, bot)
msgorigin_tz = MessageOrigin.de_json(json_dict, tz_bot)
# comparing utcoffsets because comparing timezones is unpredicatable
msgorigin_offset = msgorigin_tz.date.utcoffset()
tz_bot_offset = tz_bot.defaults.tzinfo.utcoffset(msgorigin_tz.date.replace(tzinfo=None))
assert msgorigin_raw.date.tzinfo == UTC
assert msgorigin_bot.date.tzinfo == UTC
assert msgorigin_offset == tz_bot_offset
def test_de_json_invalid_type(self, message_origin_type, bot):
json_dict = {"type": "invalid", "date": MODefaults.date}
message_origin_type = MessageOrigin.de_json(json_dict, bot)
assert type(message_origin_type) is MessageOrigin
assert message_origin_type.type == "invalid"
def test_de_json_subclass(self, message_origin_type, bot, chat_id):
"""This makes sure that e.g. MessageOriginChat(data, bot) never returns a
MessageOriginUser instance."""
cls = message_origin_type.__class__
json_dict = make_json_dict(message_origin_type, True)
assert type(cls.de_json(json_dict, bot)) is cls
def test_to_dict(self, message_origin_type):
message_origin_dict = message_origin_type.to_dict()
assert isinstance(message_origin_dict, dict)
assert message_origin_dict["type"] == message_origin_type.type
assert message_origin_dict["date"] == message_origin_type.date
for slot in message_origin_type.__slots__: # additional verification for the optional args
if slot in ("chat", "sender_chat", "sender_user"):
assert (getattr(message_origin_type, slot)).to_dict() == message_origin_dict[slot]
continue
assert getattr(message_origin_type, slot) == message_origin_dict[slot]
def test_equality(self, message_origin_type):
a = MessageOrigin(type="type", date=MODefaults.date)
b = MessageOrigin(type="type", date=MODefaults.date)
c = message_origin_type
d = deepcopy(message_origin_type)
e = Dice(4, "emoji")
assert a == b
assert hash(a) == hash(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)
assert c == d
assert hash(c) == hash(d)
assert c != e
assert hash(c) != hash(e)