python-telegram-bot/tests/test_storyarea.py

#!/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 pytest

from telegram._dice import Dice
from telegram._reaction import ReactionTypeEmoji
from telegram._storyarea import (
    LocationAddress,
    StoryArea,
    StoryAreaPosition,
    StoryAreaType,
    StoryAreaTypeLink,
    StoryAreaTypeLocation,
    StoryAreaTypeSuggestedReaction,
    StoryAreaTypeUniqueGift,
    StoryAreaTypeWeather,
)
from telegram.constants import StoryAreaTypeType
from tests.auxil.slots import mro_slots


@pytest.fixture
def story_area_position():
    return StoryAreaPosition(
        x_percentage=StoryAreaPositionTestBase.x_percentage,
        y_percentage=StoryAreaPositionTestBase.y_percentage,
        width_percentage=StoryAreaPositionTestBase.width_percentage,
        height_percentage=StoryAreaPositionTestBase.height_percentage,
        rotation_angle=StoryAreaPositionTestBase.rotation_angle,
        corner_radius_percentage=StoryAreaPositionTestBase.corner_radius_percentage,
    )


class StoryAreaPositionTestBase:
    x_percentage = 50.0
    y_percentage = 10.0
    width_percentage = 15
    height_percentage = 15
    rotation_angle = 0.0
    corner_radius_percentage = 8.0


class TestStoryAreaPositionWithoutRequest(StoryAreaPositionTestBase):
    def test_slot_behaviour(self, story_area_position):
        inst = story_area_position
        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_expected_values(self, story_area_position):
        assert story_area_position.x_percentage == self.x_percentage
        assert story_area_position.y_percentage == self.y_percentage
        assert story_area_position.width_percentage == self.width_percentage
        assert story_area_position.height_percentage == self.height_percentage
        assert story_area_position.rotation_angle == self.rotation_angle
        assert story_area_position.corner_radius_percentage == self.corner_radius_percentage

    def test_to_dict(self, story_area_position):
        json_dict = story_area_position.to_dict()
        assert json_dict["x_percentage"] == self.x_percentage
        assert json_dict["y_percentage"] == self.y_percentage
        assert json_dict["width_percentage"] == self.width_percentage
        assert json_dict["height_percentage"] == self.height_percentage
        assert json_dict["rotation_angle"] == self.rotation_angle
        assert json_dict["corner_radius_percentage"] == self.corner_radius_percentage

    def test_equality(self, story_area_position):
        a = story_area_position
        b = StoryAreaPosition(
            self.x_percentage,
            self.y_percentage,
            self.width_percentage,
            self.height_percentage,
            self.rotation_angle,
            self.corner_radius_percentage,
        )
        c = StoryAreaPosition(
            self.x_percentage + 10.0,
            self.y_percentage,
            self.width_percentage,
            self.height_percentage,
            self.rotation_angle,
            self.corner_radius_percentage,
        )
        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
def location_address():
    return LocationAddress(
        country_code=LocationAddressTestBase.country_code,
        state=LocationAddressTestBase.state,
        city=LocationAddressTestBase.city,
        street=LocationAddressTestBase.street,
    )


class LocationAddressTestBase:
    country_code = "CC"
    state = "State"
    city = "City"
    street = "12 downtown"


class TestLocationAddressWithoutRequest(LocationAddressTestBase):
    def test_slot_behaviour(self, location_address):
        inst = location_address
        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_expected_values(self, location_address):
        assert location_address.country_code == self.country_code
        assert location_address.state == self.state
        assert location_address.city == self.city
        assert location_address.street == self.street

    def test_to_dict(self, location_address):
        json_dict = location_address.to_dict()
        assert json_dict["country_code"] == self.country_code
        assert json_dict["state"] == self.state
        assert json_dict["city"] == self.city
        assert json_dict["street"] == self.street

    def test_equality(self, location_address):
        a = location_address
        b = LocationAddress(self.country_code, self.state, self.city, self.street)
        c = LocationAddress("some_other_code", self.state, self.city, self.street)
        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
def story_area():
    return StoryArea(
        position=StoryAreaTestBase.position,
        type=StoryAreaTestBase.type,
    )


class StoryAreaTestBase:
    position = StoryAreaPosition(
        x_percentage=50.0,
        y_percentage=10.0,
        width_percentage=15,
        height_percentage=15,
        rotation_angle=0.0,
        corner_radius_percentage=8.0,
    )
    type = StoryAreaTypeLink(url="some_url")


class TestStoryAreaWithoutRequest(StoryAreaTestBase):
    def test_slot_behaviour(self, story_area):
        inst = story_area
        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_expected_values(self, story_area):
        assert story_area.position == self.position
        assert story_area.type == self.type

    def test_to_dict(self, story_area):
        json_dict = story_area.to_dict()
        assert json_dict["position"] == self.position.to_dict()
        assert json_dict["type"] == self.type.to_dict()

    def test_equality(self, story_area):
        a = story_area
        b = StoryArea(self.position, self.type)
        c = StoryArea(self.position, StoryAreaTypeLink(url="some_other_url"))
        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
def story_area_type():
    return StoryAreaType(type=StoryAreaTypeTestBase.type)


class StoryAreaTypeTestBase:
    type = StoryAreaTypeType.LOCATION
    latitude = 100.5
    longitude = 200.5
    address = LocationAddress(
        country_code="cc",
        state="State",
        city="City",
        street="12 downtown",
    )
    reaction_type = ReactionTypeEmoji(emoji="emoji")
    is_dark = False
    is_flipped = False
    url = "http_url"
    temperature = 35.0
    emoji = "emoji"
    background_color = 0xFF66CCFF
    name = "unique_gift_name"


class TestStoryAreaTypeWithoutRequest(StoryAreaTypeTestBase):
    def test_slot_behaviour(self, story_area_type):
        inst = story_area_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_expected_values(self, story_area_type):
        assert story_area_type.type == self.type

    def test_type_enum_conversion(self, story_area_type):
        assert type(StoryAreaType("location").type) is StoryAreaTypeType
        assert StoryAreaType("unknown").type == "unknown"

    def test_to_dict(self, story_area_type):
        assert story_area_type.to_dict() == {"type": self.type}

    def test_equality(self, story_area_type):
        a = story_area_type
        b = StoryAreaType(self.type)
        c = StoryAreaType("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
def story_area_type_location():
    return StoryAreaTypeLocation(
        latitude=TestStoryAreaTypeLocationWithoutRequest.latitude,
        longitude=TestStoryAreaTypeLocationWithoutRequest.longitude,
        address=TestStoryAreaTypeLocationWithoutRequest.address,
    )


class TestStoryAreaTypeLocationWithoutRequest(StoryAreaTypeTestBase):
    type = StoryAreaTypeType.LOCATION

    def test_slot_behaviour(self, story_area_type_location):
        inst = story_area_type_location
        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_expected_values(self, story_area_type_location):
        assert story_area_type_location.type == self.type
        assert story_area_type_location.latitude == self.latitude
        assert story_area_type_location.longitude == self.longitude
        assert story_area_type_location.address == self.address

    def test_to_dict(self, story_area_type_location):
        json_dict = story_area_type_location.to_dict()
        assert isinstance(json_dict, dict)
        assert json_dict["type"] == self.type
        assert json_dict["latitude"] == self.latitude
        assert json_dict["longitude"] == self.longitude
        assert json_dict["address"] == self.address.to_dict()

    def test_equality(self, story_area_type_location):
        a = story_area_type_location
        b = StoryAreaTypeLocation(self.latitude, self.longitude, self.address)
        c = StoryAreaTypeLocation(self.latitude + 0.5, self.longitude, self.address)
        d = Dice(5, "test")

        assert a == b
        assert hash(a) == hash(b)
        assert a is not b

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

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


@pytest.fixture
def story_area_type_suggested_reaction():
    return StoryAreaTypeSuggestedReaction(
        reaction_type=TestStoryAreaTypeSuggestedReactionWithoutRequest.reaction_type,
        is_dark=TestStoryAreaTypeSuggestedReactionWithoutRequest.is_dark,
        is_flipped=TestStoryAreaTypeSuggestedReactionWithoutRequest.is_flipped,
    )


class TestStoryAreaTypeSuggestedReactionWithoutRequest(StoryAreaTypeTestBase):
    type = StoryAreaTypeType.SUGGESTED_REACTION

    def test_slot_behaviour(self, story_area_type_suggested_reaction):
        inst = story_area_type_suggested_reaction
        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_expected_values(self, story_area_type_suggested_reaction):
        assert story_area_type_suggested_reaction.type == self.type
        assert story_area_type_suggested_reaction.reaction_type == self.reaction_type
        assert story_area_type_suggested_reaction.is_dark is self.is_dark
        assert story_area_type_suggested_reaction.is_flipped is self.is_flipped

    def test_to_dict(self, story_area_type_suggested_reaction):
        json_dict = story_area_type_suggested_reaction.to_dict()
        assert isinstance(json_dict, dict)
        assert json_dict["type"] == self.type
        assert json_dict["reaction_type"] == self.reaction_type.to_dict()
        assert json_dict["is_dark"] is self.is_dark
        assert json_dict["is_flipped"] is self.is_flipped

    def test_equality(self, story_area_type_suggested_reaction):
        a = story_area_type_suggested_reaction
        b = StoryAreaTypeSuggestedReaction(self.reaction_type, self.is_dark, self.is_flipped)
        c = StoryAreaTypeSuggestedReaction(self.reaction_type, not self.is_dark, self.is_flipped)
        d = Dice(5, "test")

        assert a == b
        assert hash(a) == hash(b)
        assert a is not b

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

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


@pytest.fixture
def story_area_type_link():
    return StoryAreaTypeLink(
        url=TestStoryAreaTypeLinkWithoutRequest.url,
    )


class TestStoryAreaTypeLinkWithoutRequest(StoryAreaTypeTestBase):
    type = StoryAreaTypeType.LINK

    def test_slot_behaviour(self, story_area_type_link):
        inst = story_area_type_link
        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_expected_values(self, story_area_type_link):
        assert story_area_type_link.type == self.type
        assert story_area_type_link.url == self.url

    def test_to_dict(self, story_area_type_link):
        json_dict = story_area_type_link.to_dict()
        assert isinstance(json_dict, dict)
        assert json_dict["type"] == self.type
        assert json_dict["url"] == self.url

    def test_equality(self, story_area_type_link):
        a = story_area_type_link
        b = StoryAreaTypeLink(self.url)
        c = StoryAreaTypeLink("other_http_url")
        d = Dice(5, "test")

        assert a == b
        assert hash(a) == hash(b)
        assert a is not b

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

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


@pytest.fixture
def story_area_type_weather():
    return StoryAreaTypeWeather(
        temperature=TestStoryAreaTypeWeatherWithoutRequest.temperature,
        emoji=TestStoryAreaTypeWeatherWithoutRequest.emoji,
        background_color=TestStoryAreaTypeWeatherWithoutRequest.background_color,
    )


class TestStoryAreaTypeWeatherWithoutRequest(StoryAreaTypeTestBase):
    type = StoryAreaTypeType.WEATHER

    def test_slot_behaviour(self, story_area_type_weather):
        inst = story_area_type_weather
        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_expected_values(self, story_area_type_weather):
        assert story_area_type_weather.type == self.type
        assert story_area_type_weather.temperature == self.temperature
        assert story_area_type_weather.emoji == self.emoji
        assert story_area_type_weather.background_color == self.background_color

    def test_to_dict(self, story_area_type_weather):
        json_dict = story_area_type_weather.to_dict()
        assert isinstance(json_dict, dict)
        assert json_dict["type"] == self.type
        assert json_dict["temperature"] == self.temperature
        assert json_dict["emoji"] == self.emoji
        assert json_dict["background_color"] == self.background_color

    def test_equality(self, story_area_type_weather):
        a = story_area_type_weather
        b = StoryAreaTypeWeather(self.temperature, self.emoji, self.background_color)
        c = StoryAreaTypeWeather(self.temperature - 5.0, self.emoji, self.background_color)
        d = Dice(5, "test")

        assert a == b
        assert hash(a) == hash(b)
        assert a is not b

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

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


@pytest.fixture
def story_area_type_unique_gift():
    return StoryAreaTypeUniqueGift(
        name=TestStoryAreaTypeUniqueGiftWithoutRequest.name,
    )


class TestStoryAreaTypeUniqueGiftWithoutRequest(StoryAreaTypeTestBase):
    type = StoryAreaTypeType.UNIQUE_GIFT

    def test_slot_behaviour(self, story_area_type_unique_gift):
        inst = story_area_type_unique_gift
        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_expected_values(self, story_area_type_unique_gift):
        assert story_area_type_unique_gift.type == self.type
        assert story_area_type_unique_gift.name == self.name

    def test_to_dict(self, story_area_type_unique_gift):
        json_dict = story_area_type_unique_gift.to_dict()
        assert isinstance(json_dict, dict)
        assert json_dict["type"] == self.type
        assert json_dict["name"] == self.name

    def test_equality(self, story_area_type_unique_gift):
        a = story_area_type_unique_gift
        b = StoryAreaTypeUniqueGift(self.name)
        c = StoryAreaTypeUniqueGift("other_name")
        d = Dice(5, "test")

        assert a == b
        assert hash(a) == hash(b)
        assert a is not b

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

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