class TestEmoji:
@pytest.mark.parametrize(
("input", "output"),
[
("12345",
emojis.CustomEmoji(
id=snowflakes.Snowflake(12345), name=None, is_animated=None)),
("<:foo:12345>",
emojis.CustomEmoji(id=snowflakes.Snowflake(12345),
name="foo",
is_animated=False)),
("<bar:foo:12345>",
emojis.CustomEmoji(id=snowflakes.Snowflake(12345),
name="foo",
is_animated=False)),
("<a:foo:12345>",
emojis.CustomEmoji(id=snowflakes.Snowflake(12345),
name="foo",
is_animated=True)),
("\N{OK HAND SIGN}", emojis.UnicodeEmoji(name="\N{OK HAND SIGN}")),
(
"\N{REGIONAL INDICATOR SYMBOL LETTER G}\N{REGIONAL INDICATOR SYMBOL LETTER B}",
emojis.UnicodeEmoji(
name=
"\N{REGIONAL INDICATOR SYMBOL LETTER G}\N{REGIONAL INDICATOR SYMBOL LETTER B}"
),
),
],
)
def test_parse(self, input, output):
assert emojis.Emoji.parse(input) == output
class TestReactionDeleteEmojiEvent:
def test_is_for_emoji_when_custom_emoji_matches(self):
event = hikari_test_helpers.mock_class_namespace(
reaction_events.ReactionDeleteEmojiEvent, emoji_id=332223333)()
assert event.is_for_emoji(
emojis.CustomEmoji(id=332223333, name=None, is_animated=True))
def test_is_for_emoji_when_unicode_emoji_matches(self):
event = hikari_test_helpers.mock_class_namespace(
reaction_events.ReactionDeleteEmojiEvent, emoji_name="🌲e")()
assert event.is_for_emoji(emojis.UnicodeEmoji("🌲e"))
@pytest.mark.parametrize(
("emoji_id", "emoji_name", "emoji"),
[
(None, "heeei",
emojis.CustomEmoji(name=None, id=541123, is_animated=False)),
(1233211, None, emojis.UnicodeEmoji("no eeeu")),
],
)
def test_is_for_emoji_when_wrong_emoji_type(self, emoji_id, emoji_name,
emoji):
event = hikari_test_helpers.mock_class_namespace(
reaction_events.ReactionDeleteEmojiEvent,
emoji_id=emoji_id,
emoji_name=emoji_name)()
assert event.is_for_emoji(emoji) is False
@pytest.mark.parametrize(
("emoji_id", "emoji_name", "emoji"),
[
(None, "dsahi", emojis.UnicodeEmoji("bye321")),
(12331231, None,
emojis.CustomEmoji(id=121233312123, name=None,
is_animated=False)),
],
)
def test_is_for_emoji_when_emoji_miss_match(self, emoji_id, emoji_name,
emoji):
event = hikari_test_helpers.mock_class_namespace(
reaction_events.ReactionDeleteEmojiEvent,
emoji_id=emoji_id,
emoji_name=emoji_name)()
assert event.is_for_emoji(emoji) is False
def build_entity(self, _: traits.RESTAware, /) -> presences.RichActivity:
emoji: typing.Optional[emojis.Emoji] = None
if isinstance(self.emoji, RefCell):
emoji = self.emoji.copy()
elif self.emoji is not None:
emoji = emojis.UnicodeEmoji(self.emoji)
return presences.RichActivity(
name=self.name,
url=self.url,
type=self.type,
created_at=self.created_at,
application_id=self.application_id,
details=self.details,
is_instance=self.is_instance,
flags=self.flags,
state=self.state,
timestamps=copy.copy(self.timestamps) if self.timestamps is not None else None,
party=copy.copy(self.party) if self.party is not None else None,
assets=copy.copy(self.assets) if self.assets is not None else None,
secrets=copy.copy(self.secrets) if self.secrets is not None else None,
emoji=emoji,
buttons=self.buttons,
)
class TestReactionDeleteEvent:
def test_is_for_emoji_when_custom_emoji_matches(self):
event = hikari_test_helpers.mock_class_namespace(
reaction_events.ReactionDeleteEvent, emoji_id=333)()
assert event.is_for_emoji(
emojis.CustomEmoji(id=333, name=None, is_animated=True))
def test_is_for_emoji_when_unicode_emoji_matches(self):
event = hikari_test_helpers.mock_class_namespace(
reaction_events.ReactionDeleteEvent, emoji_name="e")()
assert event.is_for_emoji(emojis.UnicodeEmoji("e"))
@pytest.mark.parametrize(
("emoji_id", "emoji_name", "emoji"),
[
(None, "hasdi",
emojis.CustomEmoji(name=None, id=3123, is_animated=False)),
(534123, None, emojis.UnicodeEmoji("nodfgdu")),
],
)
def test_is_for_emoji_when_wrong_emoji_type(self, emoji_id, emoji_name,
emoji):
event = hikari_test_helpers.mock_class_namespace(
reaction_events.ReactionDeleteEvent,
emoji_id=emoji_id,
emoji_name=emoji_name)()
assert event.is_for_emoji(emoji) is False
@pytest.mark.parametrize(
("emoji_id", "emoji_name", "emoji"),
[
(None, "hfdasi", emojis.UnicodeEmoji("bgye")),
(54123, None,
emojis.CustomEmoji(id=34123, name=None, is_animated=False)),
],
)
def test_is_for_emoji_when_emoji_miss_match(self, emoji_id, emoji_name,
emoji):
event = hikari_test_helpers.mock_class_namespace(
reaction_events.ReactionDeleteEvent,
emoji_id=emoji_id,
emoji_name=emoji_name)()
assert event.is_for_emoji(emoji) is False
class TestUnicodeEmoji:
def test_str_operator(self):
assert emojis.UnicodeEmoji(
name="\N{OK HAND SIGN}") == "\N{OK HAND SIGN}"
@pytest.mark.parametrize(
("input", "output"),
[
("\N{OK HAND SIGN}", emojis.UnicodeEmoji(name="\N{OK HAND SIGN}")),
(
"\N{REGIONAL INDICATOR SYMBOL LETTER G}\N{REGIONAL INDICATOR SYMBOL LETTER B}",
emojis.UnicodeEmoji(
name=
"\N{REGIONAL INDICATOR SYMBOL LETTER G}\N{REGIONAL INDICATOR SYMBOL LETTER B}"
),
),
],
)
def test_parse(self, input, output):
assert emojis.UnicodeEmoji.parse(input) == output
def deserialize_message_reaction_add_event(
self, shard: gateway_shard.GatewayShard,
payload: data_binding.JSONObject
) -> reaction_events.ReactionAddEvent:
channel_id = snowflakes.Snowflake(payload["channel_id"])
message_id = snowflakes.Snowflake(payload["message_id"])
emoji_payload = payload["emoji"]
raw_emoji_id = emoji_payload.get("id")
emoji_id = snowflakes.Snowflake(raw_emoji_id) if raw_emoji_id else None
is_animated = bool(emoji_payload.get("animated", False))
emoji_name = emojis_models.UnicodeEmoji(
emoji_payload["name"]) if not emoji_id else emoji_payload["name"]
if "member" in payload:
guild_id = snowflakes.Snowflake(payload["guild_id"])
member = self._app.entity_factory.deserialize_member(
payload["member"], guild_id=guild_id)
return reaction_events.GuildReactionAddEvent(
shard=shard,
member=member,
channel_id=channel_id,
message_id=message_id,
emoji_id=emoji_id,
emoji_name=emoji_name,
is_animated=is_animated,
)
user_id = snowflakes.Snowflake(payload["user_id"])
return reaction_events.DMReactionAddEvent(
app=self._app,
shard=shard,
channel_id=channel_id,
message_id=message_id,
user_id=user_id,
emoji_id=emoji_id,
emoji_name=emoji_name,
is_animated=is_animated,
)
def test_str_operator(self):
assert emojis.UnicodeEmoji(
name="\N{OK HAND SIGN}") == "\N{OK HAND SIGN}"
def test_str_operator(self):
reaction = messages.Reaction(
emoji=emojis.UnicodeEmoji("\N{OK HAND SIGN}"),
count=42,
is_me=True)
assert str(reaction) == "\N{OK HAND SIGN}"
channel_id=channel_id,
message_id=message_id,
user_id=user_id,
emoji_id=emoji_id,
emoji_name=emoji_name,
is_animated=is_animated,
)
def _split_reaction_emoji(
self, emoji_payload: data_binding.JSONObject, /
) -> typing.Tuple[typing.Optional[snowflakes.Snowflake], typing.Union[
str, emojis_models.UnicodeEmoji, None]]:
if (emoji_id := emoji_payload.get("id")) is not None:
return snowflakes.Snowflake(emoji_id), emoji_payload["name"]
return None, emojis_models.UnicodeEmoji(emoji_payload["name"])
def deserialize_message_reaction_remove_event(
self, shard: gateway_shard.GatewayShard,
payload: data_binding.JSONObject
) -> reaction_events.ReactionDeleteEvent:
channel_id = snowflakes.Snowflake(payload["channel_id"])
message_id = snowflakes.Snowflake(payload["message_id"])
user_id = snowflakes.Snowflake(payload["user_id"])
emoji_id, emoji_name = self._split_reaction_emoji(payload["emoji"])
if "guild_id" in payload:
return reaction_events.GuildReactionDeleteEvent(
app=self._app,
shard=shard,
user_id=user_id,
class Test_SelectOptionBuilder:
@pytest.fixture()
def option(self):
return special_endpoints._SelectOptionBuilder(menu=mock.Mock(),
label="ok",
value="ok2")
def test_label_property(self, option):
assert option.label == "ok"
def test_value_property(self, option):
assert option.value == "ok2"
def test_emoji_property(self, option):
option._emoji = 123321
assert option.emoji == 123321
def test_set_description(self, option):
assert option.set_description("a desk") is option
assert option.description == "a desk"
@pytest.mark.parametrize(
"emoji", ["unicode", emojis.UnicodeEmoji("unicode")])
def test_set_emoji_with_unicode_emoji(self, option, emoji):
result = option.set_emoji(emoji)
assert result is option
assert option._emoji == emoji
assert option._emoji_id is undefined.UNDEFINED
assert option._emoji_name == "unicode"
@pytest.mark.parametrize("emoji", [
emojis.CustomEmoji(name="ok", id=34123123, is_animated=False), 34123123
])
def test_set_emoji_with_custom_emoji(self, option, emoji):
result = option.set_emoji(emoji)
assert result is option
assert option._emoji == emoji
assert option._emoji_id == "34123123"
assert option._emoji_name is undefined.UNDEFINED
def test_set_emoji_with_undefined(self, option):
result = option.set_emoji(undefined.UNDEFINED)
assert result is option
assert option._emoji_id is undefined.UNDEFINED
assert option._emoji_name is undefined.UNDEFINED
assert option._emoji is undefined.UNDEFINED
def test_set_is_default(self, option):
assert option.set_is_default(True) is option
assert option.is_default is True
def test_add_to_menu(self, option):
assert option.add_to_menu() is option._menu
option._menu.add_raw_option.assert_called_once_with(option)
def test_build_with_custom_emoji(self, option):
result = (special_endpoints._SelectOptionBuilder(
label="ok", value="ok2", menu=object()).set_is_default(
True).set_emoji(123312).set_description("very").build())
assert result == {
"label": "ok",
"value": "ok2",
"default": True,
"emoji": {
"id": "123312"
},
"description": "very",
}
def test_build_with_unicode_emoji(self, option):
result = (special_endpoints._SelectOptionBuilder(
label="ok", value="ok2", menu=object()).set_is_default(
True).set_emoji("hi").set_description("very").build())
assert result == {
"label": "ok",
"value": "ok2",
"default": True,
"emoji": {
"name": "hi"
},
"description": "very",
}
def test_build_partial(self, option):
result = special_endpoints._SelectOptionBuilder(label="ok",
value="ok2",
menu=object()).build()
assert result == {"label": "ok", "value": "ok2", "default": False}
class Test_ButtonBuilder:
@pytest.fixture()
def button(self):
return special_endpoints._ButtonBuilder(
container=mock.Mock(),
style=messages.ButtonStyle.DANGER,
custom_id="sfdasdasd",
url="hi there",
emoji=543123,
emoji_id="56554456",
emoji_name="hi there",
label="a lebel",
is_disabled=True,
)
def test_style_property(self, button):
assert button.style is messages.ButtonStyle.DANGER
def test_emoji_property(self, button):
assert button.emoji == 543123
@pytest.mark.parametrize(
"emoji", ["unicode", emojis.UnicodeEmoji("unicode")])
def test_set_emoji_with_unicode_emoji(self, button, emoji):
result = button.set_emoji(emoji)
assert result is button
assert button._emoji == emoji
assert button._emoji_id is undefined.UNDEFINED
assert button._emoji_name == "unicode"
@pytest.mark.parametrize("emoji", [
emojis.CustomEmoji(name="ok", id=34123123, is_animated=False), 34123123
])
def test_set_emoji_with_custom_emoji(self, button, emoji):
result = button.set_emoji(emoji)
assert result is button
assert button._emoji == emoji
assert button._emoji_id == "34123123"
assert button._emoji_name is undefined.UNDEFINED
def test_set_emoji_with_undefined(self, button):
result = button.set_emoji(undefined.UNDEFINED)
assert result is button
assert button._emoji_id is undefined.UNDEFINED
assert button._emoji_name is undefined.UNDEFINED
assert button._emoji is undefined.UNDEFINED
def test_set_label(self, button):
assert button.set_label("hi hi") is button
assert button.label == "hi hi"
def test_set_is_disabled(self, button):
assert button.set_is_disabled(False)
assert button.is_disabled is False
def test_build(self):
result = special_endpoints._ButtonBuilder(
container=object(),
style=messages.ButtonStyle.DANGER,
url=undefined.UNDEFINED,
emoji_id=undefined.UNDEFINED,
emoji_name="emoji_name",
label="no u",
custom_id="ooga booga",
is_disabled=True,
).build()
assert result == {
"type": messages.ComponentType.BUTTON,
"style": messages.ButtonStyle.DANGER,
"emoji": {
"name": "emoji_name"
},
"label": "no u",
"custom_id": "ooga booga",
"disabled": True,
}
def test_build_without_optional_fields(self):
result = special_endpoints._ButtonBuilder(
container=object(),
style=messages.ButtonStyle.LINK,
url="OK",
emoji_id="123321",
emoji_name=undefined.UNDEFINED,
label=undefined.UNDEFINED,
custom_id=undefined.UNDEFINED,
is_disabled=False,
).build()
assert result == {
"type": messages.ComponentType.BUTTON,
"style": messages.ButtonStyle.LINK,
"emoji": {
"id": "123321"
},
"disabled": False,
"url": "OK",
}
def test_add_to_container(self):
mock_container = mock.Mock()
button = special_endpoints._ButtonBuilder(
container=mock_container,
style=messages.ButtonStyle.DANGER,
url=undefined.UNDEFINED,
emoji_id=undefined.UNDEFINED,
emoji_name="emoji_name",
label="no u",
custom_id="ooga booga",
is_disabled=True,
)
assert button.add_to_container() is mock_container
mock_container.add_component.assert_called_once_with(button)
"id": "3412312",
}
def test_build_without_optional_data(self):
builder = special_endpoints.CommandBuilder("we are numberr", "oner")
result = builder.build(mock.Mock())
assert result == {
"name": "we are numberr",
"description": "oner",
"options": []
}
@pytest.mark.parametrize("emoji", ["UNICORN", emojis.UnicodeEmoji("UNICORN")])
def test__build_emoji_with_unicode_emoji(emoji):
result = special_endpoints._build_emoji(emoji)
assert result == (undefined.UNDEFINED, "UNICORN")
@pytest.mark.parametrize("emoji", [
snowflakes.Snowflake(54123123), 54123123,
emojis.CustomEmoji(id=54123123, name=None, is_animated=None)
])
def test__build_emoji_with_custom_emoji(emoji):
result = special_endpoints._build_emoji(emoji)
assert result == ("54123123", undefined.UNDEFINED)
def test_is_for_emoji_when_unicode_emoji_matches(self):
event = hikari_test_helpers.mock_class_namespace(reaction_events.ReactionDeleteEvent, emoji_name="e")()
assert event.is_for_emoji(emojis.UnicodeEmoji("e"))
from hikari import traits
from hikari import undefined
from hikari.events import lifetime_events
from hikari.events import reaction_events
from yuyo import backoff
if typing.TYPE_CHECKING:
from hikari import channels
from hikari import messages
from hikari import users
from hikari.api import event_manager
LEFT_DOUBLE_TRIANGLE: typing.Final[emojis.UnicodeEmoji] = emojis.UnicodeEmoji(
"\N{BLACK LEFT-POINTING DOUBLE TRIANGLE WITH VERTICAL BAR}\N{VARIATION SELECTOR-16}"
)
"""The emoji used to go back to the first entry."""
LEFT_TRIANGLE: typing.Final[emojis.UnicodeEmoji] = emojis.UnicodeEmoji(
"\N{BLACK LEFT-POINTING TRIANGLE}\N{VARIATION SELECTOR-16}"
)
"""The emoji used to go back an entry."""
STOP_SQUARE: typing.Final[emojis.UnicodeEmoji] = emojis.UnicodeEmoji(
"\N{BLACK SQUARE FOR STOP}\N{VARIATION SELECTOR-16}"
)
"""The emoji used to close a menu."""
RIGHT_TRIANGLE: typing.Final[emojis.UnicodeEmoji] = emojis.UnicodeEmoji(
"\N{BLACK RIGHT-POINTING TRIANGLE}\N{VARIATION SELECTOR-16}"
)
"""The emoji used to continue to the next entry."""
RIGHT_DOUBLE_TRIANGLE: typing.Final[emojis.UnicodeEmoji] = emojis.UnicodeEmoji(
def emoji(self):
return emojis.UnicodeEmoji("\N{OK HAND SIGN}")
class TestUnicodeEmoji:
@pytest.fixture()
def emoji(self):
return emojis.UnicodeEmoji("\N{OK HAND SIGN}")
def test_name_property(self, emoji):
assert emoji.name == emoji
def test_url_name_property(self, emoji):
assert emoji.url_name == emoji
def test_mention_property(self, emoji):
assert emoji.mention == emoji
def test_codepoints_property(self, emoji):
assert emoji.codepoints == [128076]
@pytest.mark.parametrize(
("codepoints", "expected_filename"),
[
# Normal tests
([0x1F44C], "1f44c"),
([0x1F44C, 0x1F44C, 0x1F44C, 0x1F44C], "1f44c-1f44c-1f44c-1f44c"),
# Outliers tests
# 1. Second codepoint is not 0xFE0F => Nothing
([0xFE0F, 0x1F44C], "fe0f-1f44c"),
# 2. More than 4 codepoints => Nothing
([0x1F44C, 0xFE0F, 0x1F44C, 0x1F44C, 0x1F44C
], "1f44c-fe0f-1f44c-1f44c-1f44c"),
# 3. Third codepoint is 0x200D => Nothing
([0x1F44C, 0xFE0F, 0x200D], "1f44c-fe0f-200d"),
# 4. None of above apply => Remove second codepoint
([0x200D, 0xFE0F, 0x1F44C, 0x1F44C], "200d-1f44c-1f44c"),
],
)
def test_filename_property(self, codepoints, expected_filename):
emoji = emojis.UnicodeEmoji.parse_codepoints(*codepoints)
assert emoji.filename == f"{expected_filename}.png"
def test_url_property(self, emoji):
assert emoji.url == "https://raw.githubusercontent.com/twitter/twemoji/master/assets/72x72/1f44c.png"
def test_unicode_escape_property(self, emoji):
assert emoji.unicode_escape == "\\U0001f44c"
def test_parse_codepoints(self, emoji):
assert emojis.UnicodeEmoji.parse_codepoints(128076) == emoji
def test_parse_unicode_escape(self, emoji):
assert emojis.UnicodeEmoji.parse_unicode_escape("\\U0001f44c") == emoji
def test_str_operator(self, emoji):
assert str(emoji) == emoji
@pytest.mark.parametrize(
("input", "output"),
[
("\N{OK HAND SIGN}", emojis.UnicodeEmoji("\N{OK HAND SIGN}")),
(
"\N{REGIONAL INDICATOR SYMBOL LETTER G}\N{REGIONAL INDICATOR SYMBOL LETTER B}",
emojis.UnicodeEmoji(
"\N{REGIONAL INDICATOR SYMBOL LETTER G}\N{REGIONAL INDICATOR SYMBOL LETTER B}"
),
),
],
)
def test_parse(self, input, output):
assert emojis.UnicodeEmoji.parse(input) == output
