Merge pull request #2052 from python-discord/voicemute

1 files changed, 43 insertions, 43 deletions

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 4d01e18a5..f89465f84 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -62,8 +62,8 @@ class TruncationTests(unittest.IsolatedAsyncioTestCase):
 
 
 @patch("bot.exts.moderation.infraction.infractions.constants.Roles.voice_verified", new=123456)
-class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
-    """Tests for voice ban related functions and commands."""
+class VoiceMuteTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for voice mute related functions and commands."""
 
     def setUp(self):
         self.bot = MockBot()
@@ -73,59 +73,59 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.ctx = MockContext(bot=self.bot, author=self.mod)
         self.cog = Infractions(self.bot)
 
-    async def test_permanent_voice_ban(self):
-        """Should call voice ban applying function without expiry."""
-        self.cog.apply_voice_ban = AsyncMock()
-        self.assertIsNone(await self.cog.voiceban(self.cog, self.ctx, self.user, reason="foobar"))
-        self.cog.apply_voice_ban.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at=None)
+    async def test_permanent_voice_mute(self):
+        """Should call voice mute applying function without expiry."""
+        self.cog.apply_voice_mute = AsyncMock()
+        self.assertIsNone(await self.cog.voicemute(self.cog, self.ctx, self.user, reason="foobar"))
+        self.cog.apply_voice_mute.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at=None)
 
-    async def test_temporary_voice_ban(self):
-        """Should call voice ban applying function with expiry."""
-        self.cog.apply_voice_ban = AsyncMock()
-        self.assertIsNone(await self.cog.tempvoiceban(self.cog, self.ctx, self.user, "baz", reason="foobar"))
-        self.cog.apply_voice_ban.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at="baz")
+    async def test_temporary_voice_mute(self):
+        """Should call voice mute applying function with expiry."""
+        self.cog.apply_voice_mute = AsyncMock()
+        self.assertIsNone(await self.cog.tempvoicemute(self.cog, self.ctx, self.user, "baz", reason="foobar"))
+        self.cog.apply_voice_mute.assert_awaited_once_with(self.ctx, self.user, "foobar", expires_at="baz")
 
-    async def test_voice_unban(self):
+    async def test_voice_unmute(self):
         """Should call infraction pardoning function."""
         self.cog.pardon_infraction = AsyncMock()
-        self.assertIsNone(await self.cog.unvoiceban(self.cog, self.ctx, self.user))
-        self.cog.pardon_infraction.assert_awaited_once_with(self.ctx, "voice_ban", self.user)
+        self.assertIsNone(await self.cog.unvoicemute(self.cog, self.ctx, self.user))
+        self.cog.pardon_infraction.assert_awaited_once_with(self.ctx, "voice_mute", self.user)
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_user_have_active_infraction(self, get_active_infraction, post_infraction_mock):
-        """Should return early when user already have Voice Ban infraction."""
+    async def test_voice_mute_user_have_active_infraction(self, get_active_infraction, post_infraction_mock):
+        """Should return early when user already have Voice Mute infraction."""
         get_active_infraction.return_value = {"foo": "bar"}
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
-        get_active_infraction.assert_awaited_once_with(self.ctx, self.user, "voice_ban")
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, "foobar"))
+        get_active_infraction.assert_awaited_once_with(self.ctx, self.user, "voice_mute")
         post_infraction_mock.assert_not_awaited()
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_infraction_post_failed(self, get_active_infraction, post_infraction_mock):
+    async def test_voice_mute_infraction_post_failed(self, get_active_infraction, post_infraction_mock):
         """Should return early when posting infraction fails."""
         self.cog.mod_log.ignore = MagicMock()
         get_active_infraction.return_value = None
         post_infraction_mock.return_value = None
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, "foobar"))
         post_infraction_mock.assert_awaited_once()
         self.cog.mod_log.ignore.assert_not_called()
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_infraction_post_add_kwargs(self, get_active_infraction, post_infraction_mock):
-        """Should pass all kwargs passed to apply_voice_ban to post_infraction."""
+    async def test_voice_mute_infraction_post_add_kwargs(self, get_active_infraction, post_infraction_mock):
+        """Should pass all kwargs passed to apply_voice_mute to post_infraction."""
         get_active_infraction.return_value = None
         # We don't want that this continue yet
         post_infraction_mock.return_value = None
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar", my_kwarg=23))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, "foobar", my_kwarg=23))
         post_infraction_mock.assert_awaited_once_with(
-            self.ctx, self.user, "voice_ban", "foobar", active=True, my_kwarg=23
+            self.ctx, self.user, "voice_mute", "foobar", active=True, my_kwarg=23
         )
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_mod_log_ignore(self, get_active_infraction, post_infraction_mock):
+    async def test_voice_mute_mod_log_ignore(self, get_active_infraction, post_infraction_mock):
         """Should ignore Voice Verified role removing."""
         self.cog.mod_log.ignore = MagicMock()
         self.cog.apply_infraction = AsyncMock()
@@ -134,11 +134,11 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         get_active_infraction.return_value = None
         post_infraction_mock.return_value = {"foo": "bar"}
 
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, "foobar"))
         self.cog.mod_log.ignore.assert_called_once_with(Event.member_update, self.user.id)
 
     async def action_tester(self, action, reason: str) -> None:
-        """Helper method to test voice ban action."""
+        """Helper method to test voice mute action."""
         self.assertTrue(inspect.iscoroutine(action))
         await action
 
@@ -147,7 +147,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_apply_infraction(self, get_active_infraction, post_infraction_mock):
+    async def test_voice_mute_apply_infraction(self, get_active_infraction, post_infraction_mock):
         """Should ignore Voice Verified role removing."""
         self.cog.mod_log.ignore = MagicMock()
         self.cog.apply_infraction = AsyncMock()
@@ -156,22 +156,22 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         post_infraction_mock.return_value = {"foo": "bar"}
 
         reason = "foobar"
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, reason))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, reason))
         self.cog.apply_infraction.assert_awaited_once_with(self.ctx, {"foo": "bar"}, self.user, ANY)
 
         await self.action_tester(self.cog.apply_infraction.call_args[0][-1], reason)
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_truncate_reason(self, get_active_infraction, post_infraction_mock):
-        """Should truncate reason for voice ban."""
+    async def test_voice_mute_truncate_reason(self, get_active_infraction, post_infraction_mock):
+        """Should truncate reason for voice mute."""
         self.cog.mod_log.ignore = MagicMock()
         self.cog.apply_infraction = AsyncMock()
 
         get_active_infraction.return_value = None
         post_infraction_mock.return_value = {"foo": "bar"}
 
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar" * 3000))
+        self.assertIsNone(await self.cog.apply_voice_mute(self.ctx, self.user, "foobar" * 3000))
         self.cog.apply_infraction.assert_awaited_once_with(self.ctx, {"foo": "bar"}, self.user, ANY)
 
         # Test action
@@ -180,14 +180,14 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
     @autospec(_utils, "post_infraction", "get_active_infraction", return_value=None)
     @autospec(Infractions, "apply_infraction")
-    async def test_voice_ban_user_left_guild(self, apply_infraction_mock, post_infraction_mock, _):
-        """Should voice ban user that left the guild without throwing an error."""
+    async def test_voice_mute_user_left_guild(self, apply_infraction_mock, post_infraction_mock, _):
+        """Should voice mute user that left the guild without throwing an error."""
         infraction = {"foo": "bar"}
         post_infraction_mock.return_value = {"foo": "bar"}
 
         user = MockUser()
-        await self.cog.voiceban(self.cog, self.ctx, user, reason=None)
-        post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_ban", None, active=True, expires_at=None)
+        await self.cog.voicemute(self.cog, self.ctx, user, reason=None)
+        post_infraction_mock.assert_called_once_with(self.ctx, user, "voice_mute", None, active=True, expires_at=None)
         apply_infraction_mock.assert_called_once_with(self.cog, self.ctx, infraction, user, ANY)
 
         # Test action
@@ -195,22 +195,22 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.assertTrue(inspect.iscoroutine(action))
         await action
 
-    async def test_voice_unban_user_not_found(self):
+    async def test_voice_unmute_user_not_found(self):
         """Should include info to return dict when user was not found from guild."""
         self.guild.get_member.return_value = None
         self.guild.fetch_member.side_effect = NotFound(Mock(status=404), "Not found")
-        result = await self.cog.pardon_voice_ban(self.user.id, self.guild)
+        result = await self.cog.pardon_voice_mute(self.user.id, self.guild)
         self.assertEqual(result, {"Info": "User was not found in the guild."})
 
     @patch("bot.exts.moderation.infraction.infractions._utils.notify_pardon")
     @patch("bot.exts.moderation.infraction.infractions.format_user")
-    async def test_voice_unban_user_found(self, format_user_mock, notify_pardon_mock):
+    async def test_voice_unmute_user_found(self, format_user_mock, notify_pardon_mock):
         """Should add role back with ignoring, notify user and return log dictionary.."""
         self.guild.get_member.return_value = self.user
         notify_pardon_mock.return_value = True
         format_user_mock.return_value = "my-user"
 
-        result = await self.cog.pardon_voice_ban(self.user.id, self.guild)
+        result = await self.cog.pardon_voice_mute(self.user.id, self.guild)
         self.assertEqual(result, {
             "Member": "my-user",
             "DM": "Sent"
@@ -219,13 +219,13 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
     @patch("bot.exts.moderation.infraction.infractions._utils.notify_pardon")
     @patch("bot.exts.moderation.infraction.infractions.format_user")
-    async def test_voice_unban_dm_fail(self, format_user_mock, notify_pardon_mock):
+    async def test_voice_unmute_dm_fail(self, format_user_mock, notify_pardon_mock):
         """Should add role back with ignoring, notify user and return log dictionary.."""
         self.guild.get_member.return_value = self.user
         notify_pardon_mock.return_value = False
         format_user_mock.return_value = "my-user"
 
-        result = await self.cog.pardon_voice_ban(self.user.id, self.guild)
+        result = await self.cog.pardon_voice_mute(self.user.id, self.guild)
         self.assertEqual(result, {
             "Member": "my-user",
             "DM": "**Failed**"