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 setUpClass(cls):
cls.player = AsyncMock() # helpers.MockPlayer
cls.mafia_member = MafiaMember()
cls.godfather = MafiaMember()
cls.goon = MafiaMember()
cls.godfather.role = MockRole(name='Godfather')
cls.goon.role = MockRole(name='Goon')
cls.game = Mock()
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")
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)
def test_role_info_command(self):
"""Tests the `role info` command."""
dummy_role = MockRole(name="Dummy",
role_id=112233445566778899,
colour=discord.Colour.blurple(),
position=10,
members=[self.ctx.author],
permissions=discord.Permissions(0))
admin_role = MockRole(
name="Admins",
role_id=998877665544332211,
colour=discord.Colour.red(),
position=3,
members=[self.ctx.author],
permissions=discord.Permissions(0),
)
self.ctx.guild.roles.append([dummy_role, admin_role])
self.cog.role_info.can_run = AsyncMock()
self.cog.role_info.can_run.return_value = True
coroutine = self.cog.role_info.callback(self.cog, self.ctx, dummy_role,
admin_role)
self.assertIsNone(asyncio.run(coroutine))
self.assertEqual(self.ctx.send.call_count, 2)
(_, dummy_kwargs), (_, admin_kwargs) = self.ctx.send.call_args_list
dummy_embed = dummy_kwargs["embed"]
admin_embed = admin_kwargs["embed"]
self.assertEqual(dummy_embed.title, "Dummy info")
self.assertEqual(dummy_embed.colour, discord.Colour.blurple())
self.assertEqual(dummy_embed.fields[0].value, str(dummy_role.id))
self.assertEqual(dummy_embed.fields[1].value,
f"#{dummy_role.colour.value:0>6x}")
self.assertEqual(dummy_embed.fields[2].value, "0.63 0.48 218")
self.assertEqual(dummy_embed.fields[3].value, "1")
self.assertEqual(dummy_embed.fields[4].value, "10")
self.assertEqual(dummy_embed.fields[5].value, "0")
self.assertEqual(admin_embed.title, "Admins info")
self.assertEqual(admin_embed.colour, discord.Colour.red())
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.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)
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_gf_replacement(self):
player1 = AsyncMock()
player1.role = MockRole(name='Goon')
self.game.players.filter.return_value = [player1]
await self.mafia_member.on_death(self.game, self.godfather)
self.assertEqual(player1.role.name, 'Godfather')
self.assertEqual(player1.user.send.call_count, 2)
async def test_dont_call_suggestion_if_user_mod(self):
"""Should not call command suggestion if user is a mod."""
self.ctx.invoked_with = "foo"
self.ctx.invoke = AsyncMock(return_value=False)
self.ctx.author.roles = [MockRole(id=1234)]
self.cog.send_command_suggestion = AsyncMock()
await self.cog.try_get_tag(self.ctx)
self.cog.send_command_suggestion.assert_not_awaited()
async def test_message_send_by_staff(self):
"""A message send by a member of staff should be ignored."""
staff_role = MockRole(id=STAFF_ROLES[0])
self.message.author.roles.append(staff_role)
attachment = MockAttachment(filename="python.disallowed")
self.message.attachments = [attachment]
await self.cog.on_message(self.message)
self.message.delete.assert_not_called()
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_consort_replacement(self):
player1 = AsyncMock()
player1.role = MockRole(name='Consort')
player1.is_alive = True
player1.faction = MockFaction(spec=['id'])
player1.faction.id = 'mafia'
self.game.players = [player1]
await self.mafia_member.on_death(self.game, self.goon)
self.assertEqual(player1.role.name, 'Goon')
self.assertEqual(player1.user.send.call_count, 2)
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_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_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_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_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_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()
async def test_result_sending(self, create_leader_channel, create_team_channel):
"""Should call `ctx.send` when everything goes right."""
self.ctx.message.attachments = [MockAttachment()]
self.ctx.message.attachments[0].read = AsyncMock()
self.ctx.message.attachments[0].read.return_value = TEST_CSV
team_leaders = MockRole()
self.guild.get_member.return_value = MockMember()
self.ctx.guild.create_role = AsyncMock()
self.ctx.guild.create_role.return_value = team_leaders
self.cog.add_roles = AsyncMock()
await self.cog.create(self.cog, self.ctx, None)
create_team_channel.assert_awaited()
create_leader_channel.assert_awaited_once_with(
self.ctx.guild, team_leaders
)
self.ctx.send.assert_awaited_once()
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_timeout_is_handled(self):
"""
Confirmation task `asyncio.TimeoutError` is handled gracefully.
We have `make_confirmation_task` return a mock with a side effect, and then catch the
exception should it propagate out of `process_event`. This is so that we can then manually
fail the test with a more informative message than just the plain traceback.
"""
mock_task = AsyncMock(side_effect=asyncio.TimeoutError())
try:
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)]))
except asyncio.TimeoutError:
self.fail(
"TimeoutError was not handled gracefully, and propagated out of `process_event`!"
)
def setUpClass(cls):
cls.moderator_role = MockRole(name="Moderator",
role_id=constants.Roles.moderator)
def test_without_role_check_returns_false_with_unwanted_role(self):
"""`without_role_check` returns `False` if `Context.author` has unwanted role."""
role_id = 42
self.ctx.author.roles.append(MockRole(id=role_id))
self.assertFalse(checks.without_role_check(self.ctx, role_id))
def test_without_role_check_returns_true_without_unwanted_role(self):
"""`without_role_check` returns `True` if `Context.author` does not have unwanted role."""
role_id = 42
self.ctx.author.roles.append(MockRole(id=role_id))
self.assertTrue(checks.without_role_check(self.ctx, role_id + 10))
def test_with_role_check_with_guild_and_required_role(self):
"""`with_role_check` returns `True` if `Context.author` has the required role."""
self.ctx.author.roles.append(MockRole(id=10))
self.assertTrue(checks.with_role_check(self.ctx, 10))