def setUp(self):
self.bot = MockBot()
self.mod = MockMember(roles=[MockRole(id=7890123, position=10)])
self.user = MockMember(roles=[MockRole(id=123456, position=1)])
self.guild = MockGuild()
self.ctx = MockContext(bot=self.bot, author=self.mod)
self.cog = Infractions(self.bot)
def setUp(self):
self.bot = MockBot()
self.cog = Infractions(self.bot)
self.user = MockMember(id=1234, top_role=MockRole(id=3577, position=10))
self.target = MockMember(id=1265, top_role=MockRole(id=9876, position=0))
self.guild = MockGuild(id=4567)
self.ctx = MockContext(bot=self.bot, author=self.user, guild=self.guild)
def make_msg(author: str,
total_user_mentions: int,
total_bot_mentions: int = 0) -> MockMessage:
"""Makes a message with `total_mentions` mentions."""
user_mentions = [MockMember() for _ in range(total_user_mentions)]
bot_mentions = [MockMember(bot=True) for _ in range(total_bot_mentions)]
return MockMessage(author=author, mentions=user_mentions + bot_mentions)
def setUp(self):
self.bot = MockBot()
self.mod = MockMember(top_role=10)
self.user = MockMember(top_role=1, roles=[MockRole(id=123456)])
self.guild = MockGuild()
self.ctx = MockContext(bot=self.bot, author=self.mod)
self.cog = Infractions(self.bot)
async def test_channel_overwrites(self):
"""Should have correct permission overwrites for users and roles."""
leader = (MockMember(), True)
members = [leader] + [(MockMember(), False) for _ in range(4)]
overwrites = _channels._get_overwrites(members, self.guild)
for member, _ in members:
self.assertTrue(overwrites[member].read_messages)
def create_erroneous_members() -> Tuple[List[MockMember], List[MockMember]]:
"""
Helper method to generate a list of members that error out on move_to call.
Returns the list of erroneous members,
as well as a list of regular and erroneous members combined, in that order.
"""
erroneous_member = MockMember(move_to=AsyncMock(side_effect=Exception()))
members = [MockMember(), erroneous_member]
return erroneous_member, members
def setUp(self):
self.me = MockMember(id=7890, roles=[MockRole(id=7890, position=5)])
self.bot = MockBot()
self.cog = Infractions(self.bot)
self.user = MockMember(id=1234, roles=[MockRole(id=3577, position=10)])
self.target = MockMember(id=1265,
roles=[MockRole(id=9876, position=1)])
self.guild = MockGuild(id=4567)
self.ctx = MockContext(me=self.me,
bot=self.bot,
author=self.user,
guild=self.guild)
async def test_jam_roles_adding(self):
"""Should add team leader role to leader and jam role to every team member."""
leader_role = MockRole(name="Team Leader")
leader = MockMember()
members = [(leader, True)] + [(MockMember(), False) for _ in range(4)]
await _channels._add_team_leader_roles(members, leader_role)
leader.add_roles.assert_awaited_once_with(leader_role)
for member, is_leader in members:
if not is_leader:
member.add_roles.assert_not_awaited()
def test_checking_if_user_has_streaming_permission(self):
"""
Test searching for video role in Member.roles
"""
user1 = MockMember(roles=[MockRole(id=Roles.video)])
user2 = MockMember()
already_allowed_user1 = any(Roles.video == role.id
for role in user1.roles)
self.assertEqual(already_allowed_user1, True)
already_allowed_user2 = any(Roles.video == role.id
for role in user2.roles)
self.assertEqual(already_allowed_user2, False)
async def test_jam_roles_adding(self):
"""Should add team leader role to leader and jam role to every team member."""
leader_role = MockRole(name="Team Leader")
jam_role = MockRole(name="Jammer")
self.guild.get_role.side_effect = [leader_role, jam_role]
leader = MockMember()
members = [leader] + [MockMember() for _ in range(4)]
await self.cog.add_roles(self.guild, members)
leader.add_roles.assert_any_await(leader_role)
for member in members:
member.add_roles.assert_any_await(jam_role)
async def test_team_channels_creation(self, get_category, get_overwrites):
"""Should create a text channel for a team."""
team_leaders = MockRole()
members = [(MockMember(), True)] + [(MockMember(), False) for _ in range(5)]
category = MockCategoryChannel()
category.create_text_channel = AsyncMock()
get_category.return_value = category
await _channels.create_team_channel(self.guild, "my-team", members, team_leaders)
category.create_text_channel.assert_awaited_once_with(
"my-team",
overwrites=get_overwrites.return_value
)
async def test_process_event_bad_role(self):
"""The reaction is removed when the author lacks all allowed roles."""
incident = MockMessage()
member = MockMember(roles=[MockRole(id=0)]) # Must have role 1 or 2
await self.cog_instance.process_event("reaction", incident, member)
incident.remove_reaction.assert_called_once_with("reaction", member)
def setUp(self):
self.bot = MockBot()
self.admin_role = MockRole(name="Admins", id=Roles.admins)
self.command_user = MockMember([self.admin_role])
self.guild = MockGuild([self.admin_role])
self.ctx = MockContext(bot=self.bot, author=self.command_user, guild=self.guild)
self.cog = jams.CodeJams(self.bot)
async def test_archive_relays_incident(self):
"""
If webhook is found, method relays `incident` properly.
This test will assert that the fetched webhook's `send` method is fed the correct arguments,
and that the `archive` method returns True.
"""
webhook = MockAsyncWebhook()
self.cog_instance.bot.fetch_webhook = AsyncMock(
return_value=webhook) # Patch in our webhook
# Define our own `incident` to be archived
incident = MockMessage(
content="this is an incident",
author=MockUser(name="author_name",
display_avatar=Mock(url="author_avatar")),
id=123,
)
built_embed = MagicMock(discord.Embed,
id=123) # We patch `make_embed` to return this
with patch("bot.exts.moderation.incidents.make_embed",
AsyncMock(return_value=(built_embed, None))):
archive_return = await self.cog_instance.archive(
incident, MagicMock(value="A"), MockMember())
# Now we check that the webhook was given the correct args, and that `archive` returned True
webhook.send.assert_called_once_with(
embed=built_embed,
username="******",
avatar_url="author_avatar",
file=None,
)
self.assertTrue(archive_return)
async def test_voice_kick(self):
"""Test to ensure kick function can remove all members from a voice channel."""
await self.cog._async_init()
# Create a regular member, and one member for each of the moderation roles
moderation_members = [MockMember(roles=[MockRole(id=role)]) for role in MODERATION_ROLES]
members = [MockMember(), *moderation_members]
channel = MockVoiceChannel(members=members)
await self.cog._kick_voice_members(channel)
for member in members:
if member in moderation_members:
member.move_to.assert_not_called()
else:
self.assertEqual((None,), member.move_to.call_args_list[0].args)
async def test_make_embed_content(self):
"""Incident content appears as embed description."""
incident = MockMessage(content="this is an incident")
embed, file = await incidents.make_embed(incident,
incidents.Signal.ACTIONED,
MockMember())
self.assertEqual(incident.content, embed.description)
async def test_make_embed_actioned(self):
"""Embed is coloured green and footer contains 'Actioned' when `outcome=Signal.ACTIONED`."""
embed, file = await incidents.make_embed(MockMessage(),
incidents.Signal.ACTIONED,
MockMember())
self.assertEqual(embed.colour.value, Colours.soft_green)
self.assertIn("Actioned", embed.footer.text)
async def test_dm_with_string_user(edubot, capture_print, monkeypatch):
"""Testing if direct messaging works when using string input."""
# Adding a mock-member to EduBot to helps us test user retrieval
member = MockMember(name="Uncle Bob")
monkeypatch.setattr(edubot._connection, "_users", {"test": member})
# Checking if the conditional statement functions and that it was
# able to retrieve the correct-member
await edubot.dm("Test", f"Hello {member.name}. This is Pytest!")
async def test_on_raw_reaction_add_user_is_bot(self):
"""
Events dispatched by bot accounts will be ignored.
We check this by asserting that `resolve_message` was never queried.
"""
self.payload.member = MockMember(bot=True)
self.cog_instance.resolve_message = AsyncMock()
await self.cog_instance.on_raw_reaction_add(self.payload)
self.cog_instance.resolve_message.assert_not_called()
async def test_result_sending(self):
"""Should call `ctx.send` when everything goes right."""
self.cog.create_channels = AsyncMock()
self.cog.add_roles = AsyncMock()
members = [MockMember() for _ in range(5)]
await self.cog.createteam(self.cog, self.ctx, "foo", members)
self.cog.create_channels.assert_awaited_once()
self.cog.add_roles.assert_awaited_once()
self.ctx.send.assert_awaited_once()
async def test_channel_overwrites(self):
"""Should have correct permission overwrites for users and roles."""
leader = MockMember()
members = [leader] + [MockMember() for _ in range(4)]
overwrites = self.cog.get_overwrites(members, self.guild)
# Leader permission overwrites
self.assertTrue(overwrites[leader].manage_messages)
self.assertTrue(overwrites[leader].read_messages)
self.assertTrue(overwrites[leader].manage_webhooks)
self.assertTrue(overwrites[leader].connect)
# Other members permission overwrites
for member in members[1:]:
self.assertTrue(overwrites[member].read_messages)
self.assertTrue(overwrites[member].connect)
# Everyone role overwrite
self.assertFalse(overwrites[self.guild.default_role].read_messages)
self.assertFalse(overwrites[self.guild.default_role].connect)
async def test_process_event_no_archive_on_investigating(self):
"""Message is not archived on `Signal.INVESTIGATING`."""
with patch("bot.exts.moderation.incidents.Incidents.archive",
AsyncMock()) as mocked_archive:
await self.cog_instance.process_event(
reaction=incidents.Signal.INVESTIGATING.value,
incident=MockMessage(),
member=MockMember(roles=[MockRole(id=1)]),
)
mocked_archive.assert_not_called()
async def test_duplicate_members_provided(self):
"""Should `ctx.send` and exit early because duplicate members provided and total there is only 1 member."""
self.cog.create_channels = AsyncMock()
self.cog.add_roles = AsyncMock()
member = MockMember()
await self.cog.createteam(self.cog, self.ctx, "foo", (member for _ in range(5)))
self.ctx.send.assert_awaited_once()
self.cog.create_channels.assert_not_awaited()
self.cog.add_roles.assert_not_awaited()
async def test_archive_webhook_not_found(self):
"""
Method recovers and returns False when the webhook is not found.
Implicitly, this also tests that the error is handled internally and doesn't
propagate out of the method, which is just as important.
"""
self.cog_instance.bot.fetch_webhook = AsyncMock(side_effect=mock_404)
self.assertFalse(await
self.cog_instance.archive(incident=MockMessage(),
outcome=MagicMock(),
actioned_by=MockMember()))
async def test_force_voice_sync(self):
"""Tests the _force_voice_sync helper function."""
await self.cog._async_init()
# Create a regular member, and one member for each of the moderation roles
moderation_members = [MockMember(roles=[MockRole(id=role)]) for role in MODERATION_ROLES]
members = [MockMember(), *moderation_members]
channel = MockVoiceChannel(members=members)
await self.cog._force_voice_sync(channel)
for member in members:
if member in moderation_members:
member.move_to.assert_not_called()
else:
self.assertEqual(member.move_to.call_count, 2)
calls = member.move_to.call_args_list
# Tests that the member was moved to the afk channel, and back.
self.assertEqual((channel.guild.afk_channel,), calls[0].args)
self.assertEqual((channel,), calls[1].args)
async def test_process_event_confirmation_task_is_awaited(self):
"""Task given by `Incidents.make_confirmation_task` is awaited before method exits."""
mock_task = AsyncMock()
with patch(
"bot.exts.moderation.incidents.Incidents.make_confirmation_task",
mock_task):
await self.cog_instance.process_event(
reaction=incidents.Signal.ACTIONED.value,
incident=MockMessage(id=123),
member=MockMember(roles=[MockRole(id=1)]))
mock_task.assert_awaited()
async def test_too_small_amount_of_team_members_passed(self):
"""Should `ctx.send` and exit early when too small amount of members."""
for case in (1, 2):
with self.subTest(amount_of_members=case):
self.cog.create_channels = AsyncMock()
self.cog.add_roles = AsyncMock()
self.ctx.reset_mock()
members = (MockMember() for _ in range(case))
await self.cog.createteam(self.cog, self.ctx, "foo", members)
self.ctx.send.assert_awaited_once()
self.cog.create_channels.assert_not_awaited()
self.cog.add_roles.assert_not_awaited()
async def test_process_event_bad_emoji(self):
"""
The reaction is removed when an invalid emoji is used.
This requires that we pass in a `member` with valid roles, as we need the role check
to succeed.
"""
incident = MockMessage()
member = MockMember(roles=[MockRole(id=1)]) # Member has allowed role
await self.cog_instance.process_event("invalid_signal", incident,
member)
incident.remove_reaction.assert_called_once_with(
"invalid_signal", member)
async def test_make_embed_with_attachment_succeeds(self):
"""Incident's attachment is downloaded and displayed in the embed's image field."""
file = MagicMock(discord.File, filename="bigbadjoe.jpg")
attachment = MockAttachment(filename="bigbadjoe.jpg")
incident = MockMessage(content="this is an incident",
attachments=[attachment])
# Patch `download_file` to return our `file`
with patch("bot.exts.moderation.incidents.download_file",
AsyncMock(return_value=file)):
embed, returned_file = await incidents.make_embed(
incident, incidents.Signal.ACTIONED, MockMember())
self.assertIs(file, returned_file)
self.assertEqual("attachment://bigbadjoe.jpg", embed.image.url)
async def test_process_event_no_delete_if_archive_fails(self):
"""
Original message is not deleted when `Incidents.archive` returns False.
This is the way of signaling that the relay failed, and we should not remove the original,
as that would result in losing the incident record.
"""
incident = MockMessage()
with patch("bot.exts.moderation.incidents.Incidents.archive",
AsyncMock(return_value=False)):
await self.cog_instance.process_event(
reaction=incidents.Signal.ACTIONED.value,
incident=incident,
member=MockMember(roles=[MockRole(id=1)]))
incident.delete.assert_not_called()
