async def test_request_guild_members_when_shard_previously_tracked_with_optionals(
self, mock_chunker, mock_app, guild):
mock_chunker._tracked[0] = {"randomNonce": object()}
with mock.patch.object(stateful_guild_chunker,
"_random_nonce",
return_value="AvEryCrYpToGraPhIcNoNcE"):
result = await mock_chunker.request_guild_members(
guild,
include_presences=True,
limit=53,
query="Kiss",
users=[snowflakes.Snowflake(1235432)])
stateful_guild_chunker._random_nonce.assert_called_once()
assert result == "0.AvEryCrYpToGraPhIcNoNcE"
assert len(mock_chunker._tracked[0]) == 2
assert mock_chunker._tracked[0][
"0.AvEryCrYpToGraPhIcNoNcE"].guild_id == snowflakes.Snowflake(
43123)
assert mock_chunker._tracked[0][
"0.AvEryCrYpToGraPhIcNoNcE"].nonce == "0.AvEryCrYpToGraPhIcNoNcE"
mock_app.shards[0].request_guild_members.assert_awaited_once_with(
guild=snowflakes.Snowflake(43123),
include_presences=True,
limit=53,
nonce="0.AvEryCrYpToGraPhIcNoNcE",
query="Kiss",
users=[snowflakes.Snowflake(1235432)],
)
async def test_request_guild_members_when_shard_not_previously_tracked_without_optionals(
self, mock_chunker, mock_app):
mock_app.shards[2].intents = intents.Intents.GUILD_MESSAGES
with mock.patch.object(stateful_guild_chunker,
"_random_nonce",
return_value="NonceNonceNonceNonce"):
result = await mock_chunker.request_guild_members(
745181921625243730, )
stateful_guild_chunker._random_nonce.assert_called_once()
assert result == "2.NonceNonceNonceNonce"
assert len(mock_chunker._tracked[2]) == 1
assert mock_chunker._tracked[2][
"2.NonceNonceNonceNonce"].guild_id == snowflakes.Snowflake(
745181921625243730)
assert mock_chunker._tracked[2][
"2.NonceNonceNonceNonce"].nonce == "2.NonceNonceNonceNonce"
mock_app.shards[2].request_guild_members.assert_awaited_once_with(
guild=snowflakes.Snowflake(745181921625243730),
include_presences=False,
limit=0,
nonce="2.NonceNonceNonceNonce",
query="",
users=undefined.UNDEFINED,
)
async def test_list_chunk_statuses_for_guild_for_known_shard(
self, mock_chunker):
mock_tracked_info_0 = mock.MagicMock(
stateful_guild_chunker._TrackedRequests,
guild_id=snowflakes.Snowflake(379953393319542784))
mock_tracked_info_1 = mock.MagicMock(
stateful_guild_chunker._TrackedRequests,
guild_id=snowflakes.Snowflake(379953393319542784))
mock_chunker._tracked = {
0: {
"0.owowo":
mock_tracked_info_0,
"0.game":
mock.Mock(stateful_guild_chunker._TrackedRequests,
guild_id=snowflakes.Snowflake(45123)),
"0.blam":
mock_tracked_info_1,
"0.pow":
mock.Mock(stateful_guild_chunker._TrackedRequests,
guild_id=snowflakes.Snowflake(53123)),
}
}
result = await mock_chunker.list_requests_for_guild(379953393319542784)
assert result == (mock_tracked_info_0, mock_tracked_info_1)
assert result[0] is not mock_tracked_info_0
assert result[1] is not mock_tracked_info_1
async def test_open_for_inactive_stream(self, mock_app):
stream = hikari_test_helpers.stub_class(
stateful_guild_chunker.ChunkStream,
_active=False,
_app=mock_app,
_guild_id=snowflakes.Snowflake(35412312312),
_event_type=shard_events.MemberChunkEvent,
_include_presences=True,
_query="a query",
_limit=42,
_users=[snowflakes.Snowflake(431223), 54234],
_nonce="AnOnCe",
)
with mock.patch.object(event_stream.EventStream,
"open") as patched_super:
assert await stream.open() is None
patched_super.assert_called_once()
mock_app.shards[2].request_guild_members.assert_awaited_once_with(
guild=snowflakes.Snowflake(35412312312),
include_presences=True,
query="a query",
limit=42,
users=[snowflakes.Snowflake(431223), 54234],
nonce="AnOnCe",
)
def deserialize_message_delete_bulk_event(
self, shard: gateway_shard.GatewayShard,
payload: data_binding.JSONObject
) -> message_events.MessageDeleteEvent:
message_ids = collections.SnowflakeSet(
*(snowflakes.Snowflake(message_id)
for message_id in payload["ids"]))
channel_id = snowflakes.Snowflake(payload["channel_id"])
if "guild_id" in payload:
return message_events.GuildMessageDeleteEvent(
app=self._app,
shard=shard,
channel_id=channel_id,
guild_id=snowflakes.Snowflake(payload["guild_id"]),
message_ids=message_ids,
is_bulk=True,
)
return message_events.DMMessageDeleteEvent(app=self._app,
shard=shard,
channel_id=channel_id,
message_ids=message_ids,
is_bulk=True)
def deserialize_message_delete_event(
self,
shard: gateway_shard.GatewayShard,
payload: data_binding.JSONObject,
*,
old_message: typing.Optional[messages_models.Message],
) -> message_events.MessageDeleteEvent:
channel_id = snowflakes.Snowflake(payload["channel_id"])
message_id = snowflakes.Snowflake(payload["id"])
if "guild_id" in payload:
return message_events.GuildMessageDeleteEvent(
app=self._app,
shard=shard,
channel_id=channel_id,
message_id=message_id,
guild_id=snowflakes.Snowflake(payload["guild_id"]),
old_message=old_message,
)
return message_events.DMMessageDeleteEvent(
app=self._app,
shard=shard,
channel_id=channel_id,
message_id=message_id,
old_message=old_message,
)
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
def deserialize_message_reaction_remove_emoji_event(
self, shard: gateway_shard.GatewayShard,
payload: data_binding.JSONObject
) -> reaction_events.ReactionDeleteEmojiEvent:
channel_id = snowflakes.Snowflake(payload["channel_id"])
message_id = snowflakes.Snowflake(payload["message_id"])
emoji = self._app.entity_factory.deserialize_emoji(payload["emoji"])
if "guild_id" in payload:
return reaction_events.GuildReactionDeleteEmojiEvent(
app=self._app,
shard=shard,
emoji=emoji,
guild_id=snowflakes.Snowflake(payload["guild_id"]),
channel_id=channel_id,
message_id=message_id,
)
# TODO: check if this can even occur.
return reaction_events.DMReactionDeleteEmojiEvent(
app=self._app,
shard=shard,
emoji=emoji,
channel_id=channel_id,
message_id=message_id,
)
def deserialize_message_reaction_remove_emoji_event(
self, shard: gateway_shard.GatewayShard,
payload: data_binding.JSONObject
) -> reaction_events.ReactionDeleteEmojiEvent:
channel_id = snowflakes.Snowflake(payload["channel_id"])
message_id = snowflakes.Snowflake(payload["message_id"])
emoji_id, emoji_name = self._split_reaction_emoji(payload["emoji"])
if "guild_id" in payload:
return reaction_events.GuildReactionDeleteEmojiEvent(
app=self._app,
shard=shard,
emoji_id=emoji_id,
emoji_name=emoji_name,
guild_id=snowflakes.Snowflake(payload["guild_id"]),
channel_id=channel_id,
message_id=message_id,
)
return reaction_events.DMReactionDeleteEmojiEvent(
app=self._app,
shard=shard,
emoji_id=emoji_id,
emoji_name=emoji_name,
channel_id=channel_id,
message_id=message_id,
)
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 = self._app.entity_factory.deserialize_emoji(payload["emoji"])
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(
app=self._app,
shard=shard,
member=member,
channel_id=channel_id,
message_id=message_id,
emoji=emoji,
)
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=emoji,
)
def deserialize_typing_start_event(
self, shard: gateway_shard.GatewayShard,
payload: data_binding.JSONObject) -> typing_events.TypingEvent:
channel_id = snowflakes.Snowflake(payload["channel_id"])
user_id = snowflakes.Snowflake(payload["user_id"])
# Turns out that this endpoint uses seconds rather than milliseconds.
timestamp = time.unix_epoch_to_datetime(payload["timestamp"],
is_millis=False)
if "guild_id" in payload:
guild_id = snowflakes.Snowflake(payload["guild_id"])
member = self._app.entity_factory.deserialize_member(
payload["member"], guild_id=guild_id)
return typing_events.GuildTypingEvent(
app=self._app,
shard=shard,
channel_id=channel_id,
guild_id=guild_id,
timestamp=timestamp,
user=member,
)
return typing_events.DMTypingEvent(app=self._app,
shard=shard,
channel_id=channel_id,
user_id=user_id,
timestamp=timestamp)
def test_get_channel_when_no_cache_trait(self):
follow = channels.ChannelFollow(
webhook_id=snowflakes.Snowflake(993883),
app=object(),
channel_id=snowflakes.Snowflake(696969))
assert follow.get_channel() is None
def message():
return messages.Message(
app=None,
id=snowflakes.Snowflake(1234),
channel_id=snowflakes.Snowflake(5678),
guild_id=snowflakes.Snowflake(910112),
author=mock.Mock(spec_set=users.User),
member=mock.Mock(spec_set=guilds.Member),
content="blahblahblah",
timestamp=datetime.datetime.now().astimezone(),
edited_timestamp=None,
is_tts=False,
mentions=messages.Mentions(
message=mock.Mock(),
users={},
role_ids=[],
channels={},
everyone=False,
),
attachments=(),
embeds=(),
reactions=(),
is_pinned=True,
webhook_id=None,
type=messages.MessageType.DEFAULT,
activity=None,
application=None,
message_reference=None,
flags=None,
nonce=None,
referenced_message=None,
stickers=[],
)
def model(self, mock_app):
return hikari_test_helpers.mock_class_namespace(guilds.Guild)(
app=mock_app,
id=snowflakes.Snowflake(123),
splash_hash="splash_hash",
discovery_splash_hash="discovery_splash_hash",
banner_hash="banner_hash",
icon_hash="icon_hash",
features=[guilds.GuildFeature.ANIMATED_ICON],
name="some guild",
application_id=snowflakes.Snowflake(9876),
afk_channel_id=snowflakes.Snowflake(1234),
afk_timeout=datetime.timedelta(seconds=60),
default_message_notifications=guilds.
GuildMessageNotificationsLevel.ONLY_MENTIONS,
description=None,
explicit_content_filter=guilds.GuildExplicitContentFilterLevel.
ALL_MEMBERS,
is_widget_enabled=False,
max_video_channel_users=10,
mfa_level=guilds.GuildMFALevel.NONE,
owner_id=snowflakes.Snowflake(1111),
preferred_locale="en-GB",
premium_subscription_count=12,
premium_tier=guilds.GuildPremiumTier.TIER_3,
public_updates_channel_id=None,
region="london",
rules_channel_id=None,
system_channel_id=None,
vanity_url_code="yeet",
verification_level=guilds.GuildVerificationLevel.VERY_HIGH,
widget_channel_id=None,
system_channel_flags=guilds.GuildSystemChannelFlag.
SUPPRESS_PREMIUM_SUBSCRIPTION,
)
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 = self._app.entity_factory.deserialize_emoji(payload["emoji"])
if "guild_id" in payload:
return reaction_events.GuildReactionDeleteEvent(
app=self._app,
shard=shard,
user_id=user_id,
guild_id=snowflakes.Snowflake(payload["guild_id"]),
channel_id=channel_id,
message_id=message_id,
emoji=emoji,
)
return reaction_events.PrivateReactionDeleteEvent(
app=self._app,
shard=shard,
user_id=user_id,
channel_id=channel_id,
message_id=message_id,
emoji=emoji,
)
def event(self):
return message_events.GuildMessageBulkDeleteEvent(
guild_id=snowflakes.Snowflake(542342354564),
channel_id=snowflakes.Snowflake(54213123123),
app=mock.Mock(),
shard=None,
message_ids=None,
)
def model(self, mock_app):
return presences.MemberPresence(
app=mock_app,
user_id=snowflakes.Snowflake(432),
guild_id=snowflakes.Snowflake(234),
visible_status=presences.Status.ONLINE,
activities=mock.Mock(presences.RichActivity),
client_status=mock.Mock(presences.ClientStatus),
)
def event(self):
return message_events.GuildMessageDeleteEvent(
guild_id=snowflakes.Snowflake(542342354564),
channel_id=snowflakes.Snowflake(54213123123),
app=mock.Mock(),
shard=object(),
message_id=9,
old_message=object(),
)
def event(self):
return message_events.GuildMessageCreateEvent(
message=mock.Mock(
spec_set=messages.Message,
guild_id=snowflakes.Snowflake(342123123),
channel_id=snowflakes.Snowflake(9121234),
),
shard=mock.Mock(),
)
def event(self):
cls = hikari_test_helpers.mock_class_namespace(
channel_events.GuildChannelEvent,
guild_id=mock.PropertyMock(
return_value=snowflakes.Snowflake(929292929)),
channel_id=mock.PropertyMock(
return_value=snowflakes.Snowflake(432432432)),
)
return cls()
def deserialize_guild_role_delete_event(
self, shard: gateway_shard.GatewayShard,
payload: data_binding.JSONObject) -> role_events.RoleDeleteEvent:
return role_events.RoleDeleteEvent(
app=self._app,
shard=shard,
guild_id=snowflakes.Snowflake(payload["guild_id"]),
role_id=snowflakes.Snowflake(payload["role_id"]),
)
def model(self, mock_app):
return channels.DMChannel(
id=snowflakes.Snowflake(12345),
name="steve",
type=channels.ChannelType.DM,
last_message_id=snowflakes.Snowflake(12345),
recipient=mock.Mock(spec_set=users.UserImpl, __str__=mock.Mock(return_value="snoop#0420")),
app=mock_app,
)
def event(self):
cls = hikari_test_helpers.mock_class_namespace(
message_events.GuildMessageEvent,
guild_id=mock.PropertyMock(
return_value=snowflakes.Snowflake(342123123)),
channel_id=mock.PropertyMock(
return_value=snowflakes.Snowflake(54123123123)),
)
return cls()
def event(self):
return message_events.GuildMessageDeleteEvent(
guild_id=snowflakes.Snowflake(542342354564),
channel_id=snowflakes.Snowflake(54213123123),
app=mock.Mock(),
shard=mock.Mock(),
message_ids={9, 18, 27, 36},
is_bulk=True,
)
def event(self):
return message_events.GuildMessageUpdateEvent(
app=mock.Mock(),
message=mock.Mock(
spec_set=messages.Message,
guild_id=snowflakes.Snowflake(54123123123),
channel_id=snowflakes.Snowflake(800001066),
),
shard=mock.Mock(),
)
def parse(cls, string: str, /) -> CustomEmoji:
if string.isdigit():
return CustomEmoji(id=snowflakes.Snowflake(string), name=None, is_animated=None)
if emoji_match := _CUSTOM_EMOJI_REGEX.match(string):
return CustomEmoji(
id=snowflakes.Snowflake(emoji_match.group("id")),
name=emoji_match.group("name"),
is_animated=emoji_match.group("flags").lower() == "a",
)
async def on_guild_member_remove(self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject) -> None:
"""See https://discord.com/developers/docs/topics/gateway#guild-member-remove for more info."""
old: typing.Optional[guilds.Member] = None
if self._cache:
old = self._cache.delete_member(
snowflakes.Snowflake(payload["guild_id"]), snowflakes.Snowflake(payload["user"]["id"])
)
event = self._event_factory.deserialize_guild_member_remove_event(shard, payload, old_member=old)
await self.dispatch(event)
async def test_fetch_webhook(self, mock_app):
mock_app.rest.fetch_webhook = mock.AsyncMock(return_value=mock.Mock(webhooks.ChannelFollowerWebhook))
follow = channels.ChannelFollow(
webhook_id=snowflakes.Snowflake(54123123), app=mock_app, channel_id=snowflakes.Snowflake(94949494)
)
result = await follow.fetch_webhook()
assert result is mock_app.rest.fetch_webhook.return_value
mock_app.rest.fetch_webhook.assert_awaited_once_with(54123123)
class TestCustomEmoji:
@pytest.fixture()
def emoji(self):
return emojis.CustomEmoji(id=3213452, name="ok", is_animated=False)
def test_filename_property(self, emoji):
assert emoji.filename == "3213452.png"
def test_filename_property_when_animated(self, emoji):
emoji.is_animated = True
assert emoji.filename == "3213452.gif"
def test_url_name_property(self, emoji):
assert emoji.url_name == "ok:3213452"
def test_mention_property(self, emoji):
assert emoji.mention == "<:ok:3213452>"
def test_mention_property_when_animated(self, emoji):
emoji.is_animated = True
assert emoji.mention == "<a:ok:3213452>"
def test_url_property(self, emoji):
assert emoji.url == "https://cdn.discordapp.com/emojis/3213452.png"
def test_str_operator_when_populated_name(self):
emoji = emojis.CustomEmoji(id=snowflakes.Snowflake(12345),
name="peepoSad",
is_animated=True)
assert str(emoji) == emoji.mention
@pytest.mark.parametrize(
("input", "output"),
[
("<: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)),
],
)
def test_parse(self, input, output):
assert emojis.CustomEmoji.parse(input) == output
def test_parse_unhappy_path(self):
with pytest.raises(ValueError, match="Expected an emoji mention"):
emojis.CustomEmoji.parse("xxx")
def deserialize_webhook_update_event(
self, shard: gateway_shard.GatewayShard, payload: data_binding.JSONObject
) -> channel_events.WebhookUpdateEvent:
guild_id = snowflakes.Snowflake(payload["guild_id"])
channel_id = snowflakes.Snowflake(payload["channel_id"])
return channel_events.WebhookUpdateEvent(
app=self._app,
shard=shard,
channel_id=channel_id,
guild_id=guild_id,
)
