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))