Refractors According To Style Guide

Updates changes made in the PR to be more inline with style guide.

Signed-off-by: Hassan Abouelela <[email protected]>

2 files changed, 74 insertions, 78 deletions

diff --git a/bot/exts/moderation/silence.py b/bot/exts/moderation/silence.py
index 9b3725326..45c3f5b92 100644
--- a/bot/exts/moderation/silence.py
+++ b/bot/exts/moderation/silence.py
@@ -31,6 +31,8 @@ MSG_UNSILENCE_MANUAL = (
 )
 MSG_UNSILENCE_SUCCESS = f"{constants.Emojis.check_mark} unsilenced current channel."
 
+TextOrVoiceChannel = Union[TextChannel, VoiceChannel]
+
 
 class SilenceNotifier(tasks.Loop):
     """Loop notifier for posting notices to `alert_channel` containing added channels."""
@@ -40,7 +42,7 @@ class SilenceNotifier(tasks.Loop):
         self._silenced_channels = {}
         self._alert_channel = alert_channel
 
-    def add_channel(self, channel: Union[TextChannel, VoiceChannel]) -> None:
+    def add_channel(self, channel: TextOrVoiceChannel) -> None:
         """Add channel to `_silenced_channels` and start loop if not launched."""
         if not self._silenced_channels:
             self.start()
@@ -119,7 +121,10 @@ class Silence(commands.Cog):
                 return self.bot.get_channel(channels[name])
 
     async def send_message(
-        self, message: str, source_channel: TextChannel, target_channel: Union[TextChannel, VoiceChannel],
+        self,
+        message: str,
+        source_channel: TextChannel,
+        target_channel: TextOrVoiceChannel,
         alert_target: bool = False
     ) -> None:
         """Helper function to send message confirmation to `source_channel`, and notification to `target_channel`."""
@@ -138,7 +143,7 @@ class Silence(commands.Cog):
             elif source_channel != target_channel:
                 await target_channel.send(message)
 
-    async def _select_lock_channel(*args) -> Union[TextChannel, VoiceChannel]:
+    async def _select_lock_channel(*args) -> TextOrVoiceChannel:
         """Passes the channel to be silenced to the resource lock."""
         channel = args[0].get("channel")
         if channel is not None:
@@ -150,8 +155,11 @@ class Silence(commands.Cog):
     @commands.command(aliases=("hush",))
     @lock(LOCK_NAMESPACE, _select_lock_channel, raise_error=True)
     async def silence(
-        self, ctx: Context, duration: HushDurationConverter = 10, kick: bool = False,
-        *, channel: Union[TextChannel, VoiceChannel] = None
+        self,
+        ctx: Context,
+        duration: HushDurationConverter = 10,
+        kick: bool = False,
+        *, channel: TextOrVoiceChannel = None
     ) -> None:
         """
         Silence the current channel for `duration` minutes or `forever`.
@@ -191,7 +199,7 @@ class Silence(commands.Cog):
             await self.send_message(MSG_SILENCE_SUCCESS.format(duration=duration), ctx.channel, channel, True)
 
     @commands.command(aliases=("unhush",))
-    async def unsilence(self, ctx: Context, *, channel: Union[TextChannel, VoiceChannel] = None) -> None:
+    async def unsilence(self, ctx: Context, *, channel: TextOrVoiceChannel = None) -> None:
         """
         Unsilence the given channel if given, else the current one.
 
@@ -204,9 +212,7 @@ class Silence(commands.Cog):
         await self._unsilence_wrapper(channel, ctx)
 
     @lock_arg(LOCK_NAMESPACE, "channel", raise_error=True)
-    async def _unsilence_wrapper(
-        self, channel: Union[TextChannel, VoiceChannel], ctx: Optional[Context] = None
-    ) -> None:
+    async def _unsilence_wrapper(self, channel: TextOrVoiceChannel, ctx: Optional[Context] = None) -> None:
         """Unsilence `channel` and send a success/failure message."""
         msg_channel = channel
         if ctx is not None:
@@ -229,7 +235,7 @@ class Silence(commands.Cog):
         else:
             await self.send_message(MSG_UNSILENCE_SUCCESS, msg_channel, channel, True)
 
-    async def _set_silence_overwrites(self, channel: Union[TextChannel, VoiceChannel], kick: bool = False) -> bool:
+    async def _set_silence_overwrites(self, channel: TextOrVoiceChannel, kick: bool = False) -> bool:
         """Set silence permission overwrites for `channel` and return True if successful."""
         # Get the original channel overwrites
         if isinstance(channel, TextChannel):
@@ -307,9 +313,7 @@ class Silence(commands.Cog):
             if delete_channel:
                 await afk_channel.delete(reason="Deleting temp mute channel.")
 
-    async def _schedule_unsilence(
-            self, ctx: Context, channel: Union[TextChannel, VoiceChannel], duration: Optional[int]
-    ) -> None:
+    async def _schedule_unsilence(self, ctx: Context, channel: TextOrVoiceChannel, duration: Optional[int]) -> None:
         """Schedule `ctx.channel` to be unsilenced if `duration` is not None."""
         if duration is None:
             await self.unsilence_timestamps.set(channel.id, -1)
@@ -318,7 +322,7 @@ class Silence(commands.Cog):
             unsilence_time = datetime.now(tz=timezone.utc) + timedelta(minutes=duration)
             await self.unsilence_timestamps.set(channel.id, unsilence_time.timestamp())
 
-    async def _unsilence(self, channel: Union[TextChannel, VoiceChannel]) -> bool:
+    async def _unsilence(self, channel: TextOrVoiceChannel) -> bool:
         """
         Unsilence `channel`.
 
diff --git a/tests/bot/exts/moderation/test_silence.py b/tests/bot/exts/moderation/test_silence.py
index 9fb3e404a..635e017e3 100644
--- a/tests/bot/exts/moderation/test_silence.py
+++ b/tests/bot/exts/moderation/test_silence.py
@@ -198,49 +198,37 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
 
         reset()
         with self.subTest("Replacement One Channel Test"):
-            await self.cog.send_message(
-                "Current. The following should be replaced: current channel.", text_channel_1, text_channel_2, False
-            )
-
-            text_channel_1.send.assert_called_once_with(
-                f"Current. The following should be replaced: {text_channel_1.mention}."
-            )
+            message = "Current. The following should be replaced: current channel."
+            await self.cog.send_message(message, text_channel_1, text_channel_2, False)
 
+            text_channel_1.send.assert_called_once_with(message.replace("current channel", text_channel_1.mention))
             text_channel_2.send.assert_not_called()
 
         reset()
         with self.subTest("Replacement Two Channel Test"):
-            await self.cog.send_message(
-                "Current. The following should be replaced: current channel.", text_channel_1, text_channel_2, True
-            )
-
-            text_channel_1.send.assert_called_once_with(
-                f"Current. The following should be replaced: {text_channel_1.mention}."
-            )
+            message = "Current. The following should be replaced: current channel."
+            await self.cog.send_message(message, text_channel_1, text_channel_2, True)
 
-            text_channel_2.send.assert_called_once_with("Current. The following should be replaced: current channel.")
+            text_channel_1.send.assert_called_once_with(message.replace("current channel", text_channel_1.mention))
+            text_channel_2.send.assert_called_once_with(message)
 
         reset()
         with self.subTest("Text and Voice"):
-            await self.cog.send_message(
-                "This should show up just here", text_channel_1, voice_channel, False
-            )
+            await self.cog.send_message("This should show up just here", text_channel_1, voice_channel, False)
             text_channel_1.send.assert_called_once_with("This should show up just here")
 
         reset()
         with self.subTest("Text and Voice"):
-            await self.cog.send_message(
-                "This should show up as current channel", text_channel_1, voice_channel, True
-            )
-            text_channel_1.send.assert_called_once_with(f"This should show up as {voice_channel.mention}")
-            text_channel_2.send.assert_called_once_with(f"This should show up as {voice_channel.mention}")
+            message = "This should show up as current channel"
+            await self.cog.send_message(message, text_channel_1, voice_channel, True)
+            text_channel_1.send.assert_called_once_with(message.replace("current channel", voice_channel.mention))
+            text_channel_2.send.assert_called_once_with(message.replace("current channel", voice_channel.mention))
 
         reset()
         with self.subTest("Text and Voice Same Invocation"):
-            await self.cog.send_message(
-                "This should show up as current channel", text_channel_2, voice_channel, True
-            )
-            text_channel_2.send.assert_called_once_with(f"This should show up as {voice_channel.mention}")
+            message = "This should show up as current channel"
+            await self.cog.send_message(message, text_channel_2, voice_channel, True)
+            text_channel_2.send.assert_called_once_with(message.replace("current channel", voice_channel.mention))
 
     async def test_get_related_text_channel(self):
         """Tests the helper function that connects voice to text channels."""
@@ -276,10 +264,11 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         await self.cog._force_voice_sync(channel)
         for member in members:
             self.assertEqual(member.move_to.call_count, 2)
-            member.move_to.assert_has_calls([
+            calls = [
                 mock.call(afk_channel, reason="Muting VC member."),
                 mock.call(channel, reason="Muting VC member.")
-            ], any_order=False)
+            ]
+            member.move_to.assert_has_calls(calls, any_order=False)
 
     async def test_force_voice_sync_staff(self):
         """Tests to ensure _force_voice_sync does not kick staff members."""
@@ -445,7 +434,9 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
                     await self.cog.silence.callback(self.cog, ctx, duration)
                     ctx.channel.send.assert_called_once_with(message)
 
-    async def test_sent_to_correct_channel(self):
+    @mock.patch.object(silence.Silence, "_set_silence_overwrites", return_value=True)
+    @mock.patch.object(silence.Silence, "_force_voice_sync")
+    async def test_sent_to_correct_channel(self, voice_sync, _):
         """Test function sends messages to the correct channels."""
         text_channel = MockTextChannel()
         voice_channel = MockVoiceChannel()
@@ -459,19 +450,17 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         )
 
         for target, message in test_cases:
-            with mock.patch.object(self.cog, "_force_voice_sync") as voice_sync:
-                with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=True):
-                    with self.subTest(target_channel=target, message=message):
-                        await self.cog.silence.callback(self.cog, ctx, 10, False, channel=target)
-                        if ctx.channel == target or target is None:
-                            ctx.channel.send.assert_called_once_with(message)
-
-                        else:
-                            ctx.channel.send.assert_called_once_with(message.replace("current channel", target.mention))
-                            if isinstance(target, MockTextChannel):
-                                target.send.assert_called_once_with(message)
-                            else:
-                                voice_sync.assert_called_once_with(target)
+            with self.subTest(target_channel=target, message=message):
+                await self.cog.silence.callback(self.cog, ctx, 10, False, channel=target)
+                if ctx.channel == target or target is None:
+                    ctx.channel.send.assert_called_once_with(message)
+
+                else:
+                    ctx.channel.send.assert_called_once_with(message.replace("current channel", target.mention))
+                    if isinstance(target, MockTextChannel):
+                        target.send.assert_called_once_with(message)
+                    else:
+                        voice_sync.assert_called_once_with(target)
 
             ctx.channel.send.reset_mock()
             if target is not None and isinstance(target, MockTextChannel):
@@ -771,7 +760,9 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
                 self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
 
-    async def test_unsilence_helper_fail(self):
+    @mock.patch.object(silence.Silence, "_unsilence", return_value=False)
+    @mock.patch.object(silence.Silence, "send_message")
+    async def test_unsilence_helper_fail(self, send_message, _):
         """Tests unsilence_wrapper when `_unsilence` fails."""
         ctx = MockContext()
 
@@ -797,16 +788,18 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
                 return self.val
 
         for context, channel, role, permission, message in test_cases:
-            with self.subTest(channel=channel, message=message):
-                with mock.patch.object(channel, "overwrites_for", return_value=PermClass(permission)) as overwrites:
-                    with mock.patch.object(self.cog, "send_message") as send_message:
-                        with mock.patch.object(self.cog, "_unsilence", return_value=False):
-                            await self.cog._unsilence_wrapper(channel, context)
+            with mock.patch.object(channel, "overwrites_for", return_value=PermClass(permission)) as overwrites:
+                with self.subTest(channel=channel, message=message):
+                    await self.cog._unsilence_wrapper(channel, context)
+
+                    overwrites.assert_called_once_with(role)
+                    send_message.assert_called_once_with(message, ctx.channel, channel)
 
-                            overwrites.assert_called_once_with(role)
-                            send_message.assert_called_once_with(message, ctx.channel, channel)
+                    send_message.reset_mock()
 
-    async def test_correct_overwrites(self):
+    @mock.patch.object(silence.Silence, "_force_voice_sync")
+    @mock.patch.object(silence.Silence, "send_message")
+    async def test_correct_overwrites(self, send_message, _):
         """Tests the overwrites returned by the _unsilence_wrapper are correct for voice and text channels."""
         ctx = MockContext()
 
@@ -822,6 +815,7 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
             text_channel.reset_mock()
             voice_channel.reset_mock()
+            send_message.reset_mock()
         await reset()
 
         default_text_overwrites = text_channel.overwrites_for(text_role)
@@ -836,17 +830,15 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
         for context, channel, role, overwrites, message in test_cases:
             with self.subTest(ctx=context, channel=channel):
-                with mock.patch.object(self.cog, "send_message") as send_message:
-                    with mock.patch.object(self.cog, "_force_voice_sync"):
-                        await self.cog._unsilence_wrapper(channel, context)
-
-                        if context is None:
-                            send_message.assert_called_once_with(message, channel, channel, True)
-                        else:
-                            send_message.assert_called_once_with(message, context.channel, channel, True)
-
-                        channel.set_permissions.assert_called_once_with(role, overwrite=overwrites)
-                        if channel != ctx.channel:
-                            ctx.channel.send.assert_not_called()
+                await self.cog._unsilence_wrapper(channel, context)
+
+                if context is None:
+                    send_message.assert_called_once_with(message, channel, channel, True)
+                else:
+                    send_message.assert_called_once_with(message, context.channel, channel, True)
+
+                channel.set_permissions.assert_called_once_with(role, overwrite=overwrites)
+                if channel != ctx.channel:
+                    ctx.channel.send.assert_not_called()
 
             await reset()