python-telegram-bot/tests/test_reaction.py

#!/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 inspect
from copy import deepcopy

import pytest

from telegram import (
    BotCommand,
    Dice,
    ReactionCount,
    ReactionType,
    ReactionTypeCustomEmoji,
    ReactionTypeEmoji,
    ReactionTypePaid,
)
from telegram.constants import ReactionEmoji
from tests.auxil.slots import mro_slots

ignored = ["self", "api_kwargs"]


class RTDefaults:
    custom_emoji = "123custom"
    normal_emoji = ReactionEmoji.THUMBS_UP


def reaction_type_custom_emoji():
    return ReactionTypeCustomEmoji(RTDefaults.custom_emoji)


def reaction_type_emoji():
    return ReactionTypeEmoji(RTDefaults.normal_emoji)


def reaction_type_paid():
    return ReactionTypePaid()


def make_json_dict(instance: ReactionType, 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)-
        # currently not needed, keeping for completeness
        elif param.default is not inspect.Parameter.empty and include_optional_args:
            json_dict[param.name] = val
    return json_dict


def iter_args(instance: ReactionType, de_json_inst: ReactionType, 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 (
            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 reaction_type(request):
    return request.param()


@pytest.mark.parametrize(
    "reaction_type",
    [
        reaction_type_custom_emoji,
        reaction_type_emoji,
        reaction_type_paid,
    ],
    indirect=True,
)
class TestReactionTypesWithoutRequest:
    def test_slot_behaviour(self, reaction_type):
        inst = reaction_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, reaction_type):
        cls = reaction_type.__class__
        assert cls.de_json(None, bot) is None
        assert ReactionType.de_json({}, bot) is None

        json_dict = make_json_dict(reaction_type)
        const_reaction_type = ReactionType.de_json(json_dict, bot)
        assert const_reaction_type.api_kwargs == {}

        assert isinstance(const_reaction_type, ReactionType)
        assert isinstance(const_reaction_type, cls)
        for reaction_type_at, const_reaction_type_at in iter_args(
            reaction_type, const_reaction_type
        ):
            assert reaction_type_at == const_reaction_type_at

    def test_de_json_all_args(self, bot, reaction_type):
        json_dict = make_json_dict(reaction_type, include_optional_args=True)
        const_reaction_type = ReactionType.de_json(json_dict, bot)
        assert const_reaction_type.api_kwargs == {}

        assert isinstance(const_reaction_type, ReactionType)
        assert isinstance(const_reaction_type, reaction_type.__class__)
        for c_mem_type_at, const_c_mem_at in iter_args(reaction_type, const_reaction_type, True):
            assert c_mem_type_at == const_c_mem_at

    def test_de_json_invalid_type(self, bot, reaction_type):
        json_dict = {"type": "invalid"}
        reaction_type = ReactionType.de_json(json_dict, bot)

        assert type(reaction_type) is ReactionType
        assert reaction_type.type == "invalid"

    def test_de_json_subclass(self, reaction_type, bot, chat_id):
        """This makes sure that e.g. ReactionTypeEmoji(data, bot) never returns a
        ReactionTypeCustomEmoji instance."""
        cls = reaction_type.__class__
        json_dict = make_json_dict(reaction_type, True)
        assert type(cls.de_json(json_dict, bot)) is cls

    def test_to_dict(self, reaction_type):
        reaction_type_dict = reaction_type.to_dict()

        assert isinstance(reaction_type_dict, dict)
        assert reaction_type_dict["type"] == reaction_type.type
        if reaction_type.type == ReactionType.EMOJI:
            assert reaction_type_dict["emoji"] == reaction_type.emoji
        elif reaction_type.type == ReactionType.CUSTOM_EMOJI:
            assert reaction_type_dict["custom_emoji_id"] == reaction_type.custom_emoji_id

        for slot in reaction_type.__slots__:  # additional verification for the optional args
            assert getattr(reaction_type, slot) == reaction_type_dict[slot]

    def test_reaction_type_api_kwargs(self, reaction_type):
        json_dict = make_json_dict(reaction_type_custom_emoji())
        json_dict["custom_arg"] = "wuhu"
        reaction_type_custom_emoji_instance = ReactionType.de_json(json_dict, None)
        assert reaction_type_custom_emoji_instance.api_kwargs == {
            "custom_arg": "wuhu",
        }

    def test_equality(self, reaction_type):
        a = ReactionTypeEmoji(emoji=RTDefaults.normal_emoji)
        b = ReactionTypeEmoji(emoji=RTDefaults.normal_emoji)
        c = ReactionTypeCustomEmoji(custom_emoji_id=RTDefaults.custom_emoji)
        d = ReactionTypeCustomEmoji(custom_emoji_id=RTDefaults.custom_emoji)
        e = ReactionTypeEmoji(emoji=ReactionEmoji.RED_HEART)
        f = ReactionTypeCustomEmoji(custom_emoji_id="1234custom")
        g = deepcopy(a)
        h = deepcopy(c)
        i = 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)

        assert a == g
        assert hash(a) == hash(g)

        assert a != i
        assert hash(a) != hash(i)

        assert c == d
        assert hash(c) == hash(d)

        assert c != e
        assert hash(c) != hash(e)

        assert c != f
        assert hash(c) != hash(f)

        assert c == h
        assert hash(c) == hash(h)

        assert c != i
        assert hash(c) != hash(i)


@pytest.fixture(scope="module")
def reaction_count():
    return ReactionCount(
        type=TestReactionCountWithoutRequest.type,
        total_count=TestReactionCountWithoutRequest.total_count,
    )


class TestReactionCountWithoutRequest:
    type = ReactionTypeEmoji(ReactionEmoji.THUMBS_UP)
    total_count = 42

    def test_slot_behaviour(self, reaction_count):
        for attr in reaction_count.__slots__:
            assert getattr(reaction_count, attr, "err") != "err", f"got extra slot '{attr}'"
        assert len(mro_slots(reaction_count)) == len(
            set(mro_slots(reaction_count))
        ), "duplicate slot"

    def test_de_json(self, bot):
        json_dict = {
            "type": self.type.to_dict(),
            "total_count": self.total_count,
        }

        reaction_count = ReactionCount.de_json(json_dict, bot)
        assert reaction_count.api_kwargs == {}

        assert isinstance(reaction_count, ReactionCount)
        assert reaction_count.type == self.type
        assert reaction_count.type.type == self.type.type
        assert reaction_count.type.emoji == self.type.emoji
        assert reaction_count.total_count == self.total_count

        assert ReactionCount.de_json(None, bot) is None

    def test_to_dict(self, reaction_count):
        reaction_count_dict = reaction_count.to_dict()

        assert isinstance(reaction_count_dict, dict)
        assert reaction_count_dict["type"] == reaction_count.type.to_dict()
        assert reaction_count_dict["total_count"] == reaction_count.total_count

    def test_equality(self, reaction_count):
        a = reaction_count
        b = ReactionCount(
            type=self.type,
            total_count=self.total_count,
        )
        c = ReactionCount(
            type=self.type,
            total_count=self.total_count + 1,
        )
        d = BotCommand("start", "description")

        assert a == b
        assert hash(a) == hash(b)

        assert a != c
        assert hash(a) != hash(c)

        assert a != d
        assert hash(a) != hash(d)