From 0a6415068b782d511cafa32002922061a61b9f67 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 16 Aug 2020 11:43:33 -0700
Subject: Silence: rename _get_instance_vars to _init_cog

It's a more accurate name since it also reschedules unsilences now.
---
 tests/bot/cogs/moderation/test_silence.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index ab3d0742a..7c6efbfe4 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -83,19 +83,19 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_instance_vars_got_guild(self):
         """Bot got guild after it became available."""
-        await self.cog._get_instance_vars()
+        await self.cog._init_cog()
         self.bot.wait_until_guild_available.assert_called_once()
         self.bot.get_guild.assert_called_once_with(Guild.id)
 
     async def test_instance_vars_got_role(self):
         """Got `Roles.verified` role from guild."""
-        await self.cog._get_instance_vars()
+        await self.cog._init_cog()
         guild = self.bot.get_guild()
         guild.get_role.assert_called_once_with(Roles.verified)
 
     async def test_instance_vars_got_channels(self):
         """Got channels from bot."""
-        await self.cog._get_instance_vars()
+        await self.cog._init_cog()
         self.bot.get_channel.called_once_with(Channels.mod_alerts)
         self.bot.get_channel.called_once_with(Channels.mod_log)
 
@@ -104,7 +104,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         """Notifier was started with channel."""
         mod_log = MockTextChannel()
         self.bot.get_channel.side_effect = (None, mod_log)
-        await self.cog._get_instance_vars()
+        await self.cog._init_cog()
         notifier.assert_called_once_with(mod_log)
         self.bot.get_channel.side_effect = None
 
-- 
cgit v1.2.3


From 2300b66c09ac853fbf332ad1bbdd291d6d0c1d87 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 16 Aug 2020 12:27:24 -0700
Subject: Tests: optionally prevent autospec helper from passing mocks

Not everything that's decorated needs the mocks that are patched. Being
required to add the args to the test function anyway is annoying. It's
especially bad if trying to decorate an entire test suite, as every
test would need the args.

Move the definition to a separate module to keep things cleaner.
---
 tests/_autospec.py | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/helpers.py   | 21 ++----------------
 2 files changed, 66 insertions(+), 19 deletions(-)
 create mode 100644 tests/_autospec.py

(limited to 'tests')

diff --git a/tests/_autospec.py b/tests/_autospec.py
new file mode 100644
index 000000000..ee2fc1973
--- /dev/null
+++ b/tests/_autospec.py
@@ -0,0 +1,64 @@
+import contextlib
+import functools
+import unittest.mock
+from typing import Callable
+
+
+@functools.wraps(unittest.mock._patch.decoration_helper)
+@contextlib.contextmanager
+def _decoration_helper(self, patched, args, keywargs):
+    """Skips adding patchings as args if their `dont_pass` attribute is True."""
+    # Don't ask what this does. It's just a copy from stdlib, but with the dont_pass check added.
+    extra_args = []
+    with contextlib.ExitStack() as exit_stack:
+        for patching in patched.patchings:
+            arg = exit_stack.enter_context(patching)
+            if not getattr(patching, "dont_pass", False):
+                # Only add the patching as an arg if dont_pass is False.
+                if patching.attribute_name is not None:
+                    keywargs.update(arg)
+                elif patching.new is unittest.mock.DEFAULT:
+                    extra_args.append(arg)
+
+        args += tuple(extra_args)
+        yield args, keywargs
+
+
+@functools.wraps(unittest.mock._patch.copy)
+def _copy(self):
+    """Copy the `dont_pass` attribute along with the standard copy operation."""
+    patcher_copy = _copy.original(self)
+    patcher_copy.dont_pass = getattr(self, "dont_pass", False)
+    return patcher_copy
+
+
+# Monkey-patch the patcher class :)
+_copy.original = unittest.mock._patch.copy
+unittest.mock._patch.copy = _copy
+unittest.mock._patch.decoration_helper = _decoration_helper
+
+
+def autospec(target, *attributes: str, pass_mocks: bool = True, **patch_kwargs) -> Callable:
+    """
+    Patch multiple `attributes` of a `target` with autospecced mocks and `spec_set` as True.
+
+    If `pass_mocks` is True, pass the autospecced mocks as arguments to the decorated object.
+    """
+    # Caller's kwargs should take priority and overwrite the defaults.
+    kwargs = dict(spec_set=True, autospec=True)
+    kwargs.update(patch_kwargs)
+
+    # Import the target if it's a string.
+    # This is to support both object and string targets like patch.multiple.
+    if type(target) is str:
+        target = unittest.mock._importer(target)
+
+    def decorator(func):
+        for attribute in attributes:
+            patcher = unittest.mock.patch.object(target, attribute, **kwargs)
+            if not pass_mocks:
+                # A custom attribute to keep track of which patchings should be skipped.
+                patcher.dont_pass = True
+            func = patcher(func)
+        return func
+    return decorator
diff --git a/tests/helpers.py b/tests/helpers.py
index facc4e1af..6cf5d12bd 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -5,7 +5,7 @@ import itertools
 import logging
 import unittest.mock
 from asyncio import AbstractEventLoop
-from typing import Callable, Iterable, Optional
+from typing import Iterable, Optional
 
 import discord
 from aiohttp import ClientSession
@@ -14,6 +14,7 @@ from discord.ext.commands import Context
 from bot.api import APIClient
 from bot.async_stats import AsyncStatsClient
 from bot.bot import Bot
+from tests._autospec import autospec  # noqa: F401 other modules import it via this module
 
 
 for logger in logging.Logger.manager.loggerDict.values():
@@ -26,24 +27,6 @@ for logger in logging.Logger.manager.loggerDict.values():
     logger.setLevel(logging.CRITICAL)
 
 
-def autospec(target, *attributes: str, **kwargs) -> Callable:
-    """Patch multiple `attributes` of a `target` with autospecced mocks and `spec_set` as True."""
-    # Caller's kwargs should take priority and overwrite the defaults.
-    kwargs = {'spec_set': True, 'autospec': True, **kwargs}
-
-    # Import the target if it's a string.
-    # This is to support both object and string targets like patch.multiple.
-    if type(target) is str:
-        target = unittest.mock._importer(target)
-
-    def decorator(func):
-        for attribute in attributes:
-            patcher = unittest.mock.patch.object(target, attribute, **kwargs)
-            func = patcher(func)
-        return func
-    return decorator
-
-
 class HashableMixin(discord.mixins.EqualityComparable):
     """
     Mixin that provides similar hashing and equality functionality as discord.py's `Hashable` mixin.
-- 
cgit v1.2.3


From 0ffa80717d9db89ab6ed8865741c39820d33b392 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 16 Aug 2020 12:11:21 -0700
Subject: Silence tests: mock RedisCaches

---
 tests/bot/cogs/moderation/test_silence.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 7c6efbfe4..8dfebb95c 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -6,7 +6,7 @@ from discord import PermissionOverwrite
 
 from bot.cogs.moderation.silence import Silence, SilenceNotifier
 from bot.constants import Channels, Emojis, Guild, Roles
-from tests.helpers import MockBot, MockContext, MockTextChannel
+from tests.helpers import MockBot, MockContext, MockTextChannel, autospec
 
 
 class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
@@ -72,14 +72,13 @@ class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
                     self.alert_channel.send.assert_not_called()
 
 
+@autospec(Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
 class SilenceTests(unittest.IsolatedAsyncioTestCase):
     def setUp(self) -> None:
         self.bot = MockBot()
         self.cog = Silence(self.bot)
         self.ctx = MockContext()
         self.cog._verified_role = None
-        # Set event so command callbacks can continue.
-        self.cog._get_instance_vars_event.set()
 
     async def test_instance_vars_got_guild(self):
         """Bot got guild after it became available."""
-- 
cgit v1.2.3


From 19f801289b14740017687a72d106875276507a1c Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 16 Aug 2020 12:12:34 -0700
Subject: Silence tests: rename test_instance_vars to test_init_cog

---
 tests/bot/cogs/moderation/test_silence.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 8dfebb95c..67a61382c 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -80,26 +80,26 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.ctx = MockContext()
         self.cog._verified_role = None
 
-    async def test_instance_vars_got_guild(self):
+    async def test_init_cog_got_guild(self):
         """Bot got guild after it became available."""
         await self.cog._init_cog()
-        self.bot.wait_until_guild_available.assert_called_once()
+        self.bot.wait_until_guild_available.assert_awaited_once()
         self.bot.get_guild.assert_called_once_with(Guild.id)
 
-    async def test_instance_vars_got_role(self):
+    async def test_init_cog_got_role(self):
         """Got `Roles.verified` role from guild."""
         await self.cog._init_cog()
         guild = self.bot.get_guild()
         guild.get_role.assert_called_once_with(Roles.verified)
 
-    async def test_instance_vars_got_channels(self):
+    async def test_init_cog_got_channels(self):
         """Got channels from bot."""
         await self.cog._init_cog()
         self.bot.get_channel.called_once_with(Channels.mod_alerts)
         self.bot.get_channel.called_once_with(Channels.mod_log)
 
     @mock.patch("bot.cogs.moderation.silence.SilenceNotifier")
-    async def test_instance_vars_got_notifier(self, notifier):
+    async def test_init_cog_got_notifier(self, notifier):
         """Notifier was started with channel."""
         mod_log = MockTextChannel()
         self.bot.get_channel.side_effect = (None, mod_log)
-- 
cgit v1.2.3


From de92d8553de25cc1ec45a5e4dbee8fd4d3426fa8 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 16 Aug 2020 12:15:02 -0700
Subject: Silence tests: replace obsolete cog_unload tests

Moderation notifications are no longer sent so that doesn't need to be
tested.
---
 tests/bot/cogs/moderation/test_silence.py | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 67a61382c..807bb09a0 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -74,6 +74,7 @@ class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
 
 @autospec(Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
 class SilenceTests(unittest.IsolatedAsyncioTestCase):
+    @autospec("bot.cogs.moderation.silence", "Scheduler", pass_mocks=False)
     def setUp(self) -> None:
         self.bot = MockBot()
         self.cog = Silence(self.bot)
@@ -237,20 +238,10 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         del mock_permissions_dict['send_messages']
         self.assertDictEqual(mock_permissions_dict, new_permissions)
 
-    @mock.patch("bot.cogs.moderation.silence.asyncio")
-    @mock.patch.object(Silence, "_mod_alerts_channel", create=True)
-    def test_cog_unload_starts_task(self, alert_channel, asyncio_mock):
-        """Task for sending an alert was created with present `muted_channels`."""
-        with mock.patch.object(self.cog, "muted_channels"):
-            self.cog.cog_unload()
-            alert_channel.send.assert_called_once_with(f"<@&{Roles.moderators}> channels left silenced on cog unload: ")
-            asyncio_mock.create_task.assert_called_once_with(alert_channel.send())
-
-    @mock.patch("bot.cogs.moderation.silence.asyncio")
-    def test_cog_unload_skips_task_start(self, asyncio_mock):
-        """No task created with no channels."""
+    def test_cog_unload_cancels_tasks(self):
+        """All scheduled tasks should be cancelled."""
         self.cog.cog_unload()
-        asyncio_mock.create_task.assert_not_called()
+        self.cog.scheduler.cancel_all.assert_called_once_with()
 
     @mock.patch("bot.cogs.moderation.silence.with_role_check")
     @mock.patch("bot.cogs.moderation.silence.MODERATION_ROLES", new=(1, 2, 3))
-- 
cgit v1.2.3


From 3182bacc342fd87313ffb22742947576d887f73b Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 13:18:58 -0700
Subject: Silence tests: fix silence cache test for overwrites

---
 tests/bot/cogs/moderation/test_silence.py | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 807bb09a0..6f0cd880d 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -184,12 +184,15 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
                 await self.cog._silence(channel, False, None)
                 self.cog.notifier.add_channel.assert_not_called()
 
-    async def test_silence_private_added_muted_channel(self):
-        """Channel was added to `muted_channels` on silence."""
+    async def test_silence_private_cached_perms(self):
+        """Channel's previous overwrites were cached when silenced."""
         channel = MockTextChannel()
-        with mock.patch.object(self.cog, "muted_channels") as muted_channels:
-            await self.cog._silence(channel, False, None)
-        muted_channels.add.assert_called_once_with(channel)
+        overwrite = PermissionOverwrite(send_messages=True, add_reactions=None)
+        overwrite_json = '{"send_messages": true, "add_reactions": null}'
+        channel.overwrites_for.return_value = overwrite
+
+        await self.cog._silence(channel, False, None)
+        self.cog.muted_channel_perms.set.assert_called_once_with(channel.id, overwrite_json)
 
     async def test_unsilence_private_for_false(self):
         """Permissions are not set and `False` is returned in an unsilenced channel."""
-- 
cgit v1.2.3


From ccbc515cfedd5938f4d1d50404a1b32d66bd5511 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 13:29:16 -0700
Subject: Silence tests: fix test_unsilence_private_for_false

---
 tests/bot/cogs/moderation/test_silence.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 6f0cd880d..c1039f85c 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -196,7 +196,10 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_unsilence_private_for_false(self):
         """Permissions are not set and `False` is returned in an unsilenced channel."""
-        channel = Mock()
+        self.cog.scheduler.__contains__.return_value = False
+        self.cog.muted_channel_perms.get.return_value = None
+        channel = MockTextChannel()
+
         self.assertFalse(await self.cog._unsilence(channel))
         channel.set_permissions.assert_not_called()
 
-- 
cgit v1.2.3


From 28f7f66e4e9543d79f5a64ee6a0e0bbc80088804 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 13:33:47 -0700
Subject: Silence tests: fix test_silence_private_notifier

---
 tests/bot/cogs/moderation/test_silence.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index c1039f85c..e2e3ca9c1 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -174,6 +174,9 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_silence_private_notifier(self):
         """Channel should be added to notifier with `persistent` set to `True`, and the other way around."""
         channel = MockTextChannel()
+        overwrite = PermissionOverwrite(send_messages=True, add_reactions=None)
+        channel.overwrites_for.return_value = overwrite
+
         with mock.patch.object(self.cog, "notifier", create=True):
             with self.subTest(persistent=True):
                 await self.cog._silence(channel, True, None)
-- 
cgit v1.2.3


From c24fa4371c9e8b13431b5d5f3808401dda8d449a Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 14:20:05 -0700
Subject: Silence tests: fix test_silence_private_silenced_channel

---
 tests/bot/cogs/moderation/test_silence.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index e2e3ca9c1..75b4ef470 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -151,11 +151,18 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         channel.set_permissions.assert_not_called()
 
     async def test_silence_private_silenced_channel(self):
-        """Channel had `send_message` permissions revoked."""
+        """Channel had `send_message` and `add_reactions` permissions revoked for verified role."""
         channel = MockTextChannel()
+        overwrite = PermissionOverwrite(send_messages=True, add_reactions=None)
+        channel.overwrites_for.return_value = overwrite
+
         self.assertTrue(await self.cog._silence(channel, False, None))
-        channel.set_permissions.assert_called_once()
-        self.assertFalse(channel.set_permissions.call_args.kwargs['send_messages'])
+        self.assertFalse(overwrite.send_messages)
+        self.assertFalse(overwrite.add_reactions)
+        channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_role,
+            overwrite=overwrite
+        )
 
     async def test_silence_private_preserves_permissions(self):
         """Previous permissions were preserved when channel was silenced."""
-- 
cgit v1.2.3


From 830bb36654103474fa74505f3e0ff4bdf91656fd Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 14:28:02 -0700
Subject: Silence tests: fix test_silence_private_for_false

---
 tests/bot/cogs/moderation/test_silence.py | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 75b4ef470..5763c4cdd 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -144,11 +144,20 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_silence_private_for_false(self):
         """Permissions are not set and `False` is returned in an already silenced channel."""
-        perm_overwrite = Mock(send_messages=False)
-        channel = Mock(overwrites_for=Mock(return_value=perm_overwrite))
+        subtests = (
+            (False, PermissionOverwrite(send_messages=False, add_reactions=False)),
+            (True, PermissionOverwrite(send_messages=True, add_reactions=True)),
+            (True, PermissionOverwrite(send_messages=False, add_reactions=False)),
+        )
 
-        self.assertFalse(await self.cog._silence(channel, True, None))
-        channel.set_permissions.assert_not_called()
+        for contains, overwrite in subtests:
+            with self.subTest(contains=contains, overwrite=overwrite):
+                self.cog.scheduler.__contains__.return_value = contains
+                channel = MockTextChannel()
+                channel.overwrites_for.return_value = overwrite
+
+                self.assertFalse(await self.cog._silence(channel, True, None))
+                channel.set_permissions.assert_not_called()
 
     async def test_silence_private_silenced_channel(self):
         """Channel had `send_message` and `add_reactions` permissions revoked for verified role."""
-- 
cgit v1.2.3


From f8485f17ac0263c47365893438b3f1da609cb259 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 14:47:28 -0700
Subject: Silence tests: fix command message tests

---
 tests/bot/cogs/moderation/test_silence.py | 25 ++++++++++---------------
 1 file changed, 10 insertions(+), 15 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 5763c4cdd..02964d7ab 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -115,15 +115,12 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
             (None, f"{Emojis.check_mark} silenced current channel indefinitely.", True,),
             (5, f"{Emojis.cross_mark} current channel is already silenced.", False,),
         )
-        for duration, result_message, _silence_patch_return in test_cases:
-            with self.subTest(
-                silence_duration=duration,
-                result_message=result_message,
-                starting_unsilenced_state=_silence_patch_return
-            ):
-                with mock.patch.object(self.cog, "_silence", return_value=_silence_patch_return):
+        for duration, message, was_silenced in test_cases:
+            self.cog._init_task = mock.AsyncMock()()
+            with self.subTest(was_silenced=was_silenced, message=message, duration=duration):
+                with mock.patch.object(self.cog, "_silence", return_value=was_silenced):
                     await self.cog.silence.callback(self.cog, self.ctx, duration)
-                    self.ctx.send.assert_called_once_with(result_message)
+                    self.ctx.send.assert_called_once_with(message)
             self.ctx.reset_mock()
 
     async def test_unsilence_sent_correct_discord_message(self):
@@ -132,14 +129,12 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
             (True, f"{Emojis.check_mark} unsilenced current channel."),
             (False, f"{Emojis.cross_mark} current channel was not silenced.")
         )
-        for _unsilence_patch_return, result_message in test_cases:
-            with self.subTest(
-                starting_silenced_state=_unsilence_patch_return,
-                result_message=result_message
-            ):
-                with mock.patch.object(self.cog, "_unsilence", return_value=_unsilence_patch_return):
+        for was_unsilenced, message in test_cases:
+            self.cog._init_task = mock.AsyncMock()()
+            with self.subTest(was_unsilenced=was_unsilenced, message=message):
+                with mock.patch.object(self.cog, "_unsilence", return_value=was_unsilenced):
                     await self.cog.unsilence.callback(self.cog, self.ctx)
-                    self.ctx.send.assert_called_once_with(result_message)
+                    self.ctx.channel.send.assert_called_once_with(message)
             self.ctx.reset_mock()
 
     async def test_silence_private_for_false(self):
-- 
cgit v1.2.3


From 89107eccca3213c436028b997bdc6785fa9ce02d Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 15:09:31 -0700
Subject: Silence tests: fix overwrite preservation test for silences

---
 tests/bot/cogs/moderation/test_silence.py | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 02964d7ab..765c324d2 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -168,19 +168,23 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
             overwrite=overwrite
         )
 
-    async def test_silence_private_preserves_permissions(self):
-        """Previous permissions were preserved when channel was silenced."""
+    async def test_silence_private_preserves_other_overwrites(self):
+        """Channel's other unrelated overwrites were not changed when it was silenced."""
         channel = MockTextChannel()
-        # Set up mock channel permission state.
-        mock_permissions = PermissionOverwrite()
-        mock_permissions_dict = dict(mock_permissions)
-        channel.overwrites_for.return_value = mock_permissions
+        overwrite = PermissionOverwrite(stream=True, attach_files=False)
+        channel.overwrites_for.return_value = overwrite
+
+        prev_overwrite_dict = dict(overwrite)
         await self.cog._silence(channel, False, None)
-        new_permissions = channel.set_permissions.call_args.kwargs
-        # Remove 'send_messages' key because it got changed in the method.
-        del new_permissions['send_messages']
-        del mock_permissions_dict['send_messages']
-        self.assertDictEqual(mock_permissions_dict, new_permissions)
+        new_overwrite_dict = dict(overwrite)
+
+        # Remove 'send_messages' & 'add_reactions' keys because they were changed by the method.
+        del prev_overwrite_dict['send_messages']
+        del prev_overwrite_dict['add_reactions']
+        del new_overwrite_dict['send_messages']
+        del new_overwrite_dict['add_reactions']
+
+        self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
 
     async def test_silence_private_notifier(self):
         """Channel should be added to notifier with `persistent` set to `True`, and the other way around."""
-- 
cgit v1.2.3


From eff788aab84ee96408823eb61ebafba2d9e9cbcb Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 15:39:00 -0700
Subject: Silence tests: fix test_unsilence_private_removed_notifier

---
 tests/bot/cogs/moderation/test_silence.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 765c324d2..b21f5f61a 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -233,8 +233,11 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     @mock.patch.object(Silence, "notifier", create=True)
     async def test_unsilence_private_removed_notifier(self, notifier):
         """Channel was removed from `notifier` on unsilence."""
-        perm_overwrite = MagicMock(send_messages=False)
-        channel = MockTextChannel(overwrites_for=Mock(return_value=perm_overwrite))
+        overwrite_json = '{"send_messages": true, "add_reactions": null}'
+        self.cog.muted_channel_perms.get.return_value = overwrite_json
+        channel = MockTextChannel()
+        channel.overwrites_for.return_value = PermissionOverwrite()
+
         await self.cog._unsilence(channel)
         notifier.remove_channel.assert_called_once_with(channel)
 
-- 
cgit v1.2.3


From 3ec17dac3fe8e00f34489a5e3dd927bec39e91e6 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 15:58:31 -0700
Subject: Silence tests: fix tests for _unsilence

Add a fixture to set up mocks for a successful `unsilence` call. This
reduces code redundancy.
---
 tests/bot/cogs/moderation/test_silence.py | 75 ++++++++++++++++++-------------
 1 file changed, 45 insertions(+), 30 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index b21f5f61a..ff32e9a05 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -1,6 +1,6 @@
 import unittest
 from unittest import mock
-from unittest.mock import MagicMock, Mock
+from unittest.mock import Mock
 
 from discord import PermissionOverwrite
 
@@ -81,6 +81,18 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.ctx = MockContext()
         self.cog._verified_role = None
 
+    def unsilence_fixture(self) -> MockTextChannel:
+        """Setup mocks for a successful `_unsilence` call. Return the mocked channel."""
+        overwrite_json = '{"send_messages": true, "add_reactions": null}'
+        self.cog.muted_channel_perms.get.return_value = overwrite_json
+
+        # stream=True just to have at least one other overwrite not be the default value.
+        channel = MockTextChannel()
+        overwrite = PermissionOverwrite(stream=True, send_messages=False, add_reactions=False)
+        channel.overwrites_for.return_value = overwrite
+
+        return channel
+
     async def test_init_cog_got_guild(self):
         """Bot got guild after it became available."""
         await self.cog._init_cog()
@@ -223,47 +235,50 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
     @mock.patch.object(Silence, "notifier", create=True)
     async def test_unsilence_private_unsilenced_channel(self, _):
-        """Channel had `send_message` permissions restored"""
-        perm_overwrite = MagicMock(send_messages=False)
-        channel = MockTextChannel(overwrites_for=Mock(return_value=perm_overwrite))
-        self.assertTrue(await self.cog._unsilence(channel))
-        channel.set_permissions.assert_called_once()
-        self.assertIsNone(channel.set_permissions.call_args.kwargs['send_messages'])
+        """Channel had `send_message` permissions restored."""
+        channel = self.unsilence_fixture()
+        overwrite = channel.overwrites_for.return_value
+
+        await self.cog._unsilence(channel)
+        channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_role, overwrite=overwrite
+        )
+
+        # Recall that these values are determined by the fixture.
+        self.assertTrue(overwrite.send_messages)
+        self.assertIsNone(overwrite.add_reactions)
 
     @mock.patch.object(Silence, "notifier", create=True)
     async def test_unsilence_private_removed_notifier(self, notifier):
         """Channel was removed from `notifier` on unsilence."""
-        overwrite_json = '{"send_messages": true, "add_reactions": null}'
-        self.cog.muted_channel_perms.get.return_value = overwrite_json
-        channel = MockTextChannel()
-        channel.overwrites_for.return_value = PermissionOverwrite()
-
+        channel = self.unsilence_fixture()
         await self.cog._unsilence(channel)
         notifier.remove_channel.assert_called_once_with(channel)
 
     @mock.patch.object(Silence, "notifier", create=True)
     async def test_unsilence_private_removed_muted_channel(self, _):
-        """Channel was removed from `muted_channels` on unsilence."""
-        perm_overwrite = MagicMock(send_messages=False)
-        channel = MockTextChannel(overwrites_for=Mock(return_value=perm_overwrite))
-        with mock.patch.object(self.cog, "muted_channels") as muted_channels:
-            await self.cog._unsilence(channel)
-        muted_channels.discard.assert_called_once_with(channel)
+        """Channel was removed from overwrites cache on unsilence."""
+        channel = self.unsilence_fixture()
+        await self.cog._unsilence(channel)
+        self.cog.muted_channel_perms.delete.assert_awaited_once_with(channel.id)
 
     @mock.patch.object(Silence, "notifier", create=True)
-    async def test_unsilence_private_preserves_permissions(self, _):
-        """Previous permissions were preserved when channel was unsilenced."""
-        channel = MockTextChannel()
-        # Set up mock channel permission state.
-        mock_permissions = PermissionOverwrite(send_messages=False)
-        mock_permissions_dict = dict(mock_permissions)
-        channel.overwrites_for.return_value = mock_permissions
+    async def test_unsilence_private_preserves_other_overwrites(self, _):
+        """Channel's other unrelated overwrites were not changed when it was unsilenced."""
+        channel = self.unsilence_fixture()
+        overwrite = channel.overwrites_for.return_value
+
+        prev_overwrite_dict = dict(overwrite)
         await self.cog._unsilence(channel)
-        new_permissions = channel.set_permissions.call_args.kwargs
-        # Remove 'send_messages' key because it got changed in the method.
-        del new_permissions['send_messages']
-        del mock_permissions_dict['send_messages']
-        self.assertDictEqual(mock_permissions_dict, new_permissions)
+        new_overwrite_dict = dict(overwrite)
+
+        # Remove 'send_messages' & 'add_reactions' keys because they were changed by the method.
+        del prev_overwrite_dict['send_messages']
+        del prev_overwrite_dict['add_reactions']
+        del new_overwrite_dict['send_messages']
+        del new_overwrite_dict['add_reactions']
+
+        self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
 
     def test_cog_unload_cancels_tasks(self):
         """All scheduled tasks should be cancelled."""
-- 
cgit v1.2.3


From 0adaf09af5c7a76566f874eda429dd6f263189be Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 16:33:39 -0700
Subject: Silence tests: separate test cases; refactor names & docstrings

---
 tests/bot/cogs/moderation/test_silence.py | 166 +++++++++++++++++-------------
 1 file changed, 95 insertions(+), 71 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index ff32e9a05..f3ee184d4 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -1,3 +1,4 @@
+import asyncio
 import unittest
 from unittest import mock
 from unittest.mock import Mock
@@ -73,25 +74,13 @@ class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
 
 
 @autospec(Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
-class SilenceTests(unittest.IsolatedAsyncioTestCase):
+class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for the general functionality of the Silence cog."""
+
     @autospec("bot.cogs.moderation.silence", "Scheduler", pass_mocks=False)
     def setUp(self) -> None:
         self.bot = MockBot()
         self.cog = Silence(self.bot)
-        self.ctx = MockContext()
-        self.cog._verified_role = None
-
-    def unsilence_fixture(self) -> MockTextChannel:
-        """Setup mocks for a successful `_unsilence` call. Return the mocked channel."""
-        overwrite_json = '{"send_messages": true, "add_reactions": null}'
-        self.cog.muted_channel_perms.get.return_value = overwrite_json
-
-        # stream=True just to have at least one other overwrite not be the default value.
-        channel = MockTextChannel()
-        overwrite = PermissionOverwrite(stream=True, send_messages=False, add_reactions=False)
-        channel.overwrites_for.return_value = overwrite
-
-        return channel
 
     async def test_init_cog_got_guild(self):
         """Bot got guild after it became available."""
@@ -120,37 +109,49 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         notifier.assert_called_once_with(mod_log)
         self.bot.get_channel.side_effect = None
 
-    async def test_silence_sent_correct_discord_message(self):
-        """Check if proper message was sent when called with duration in channel with previous state."""
+    def test_cog_unload_cancelled_tasks(self):
+        """All scheduled tasks were cancelled."""
+        self.cog.cog_unload()
+        self.cog.scheduler.cancel_all.assert_called_once_with()
+
+    @mock.patch("bot.cogs.moderation.silence.with_role_check")
+    @mock.patch("bot.cogs.moderation.silence.MODERATION_ROLES", new=(1, 2, 3))
+    def test_cog_check(self, role_check):
+        """Role check was called with `MODERATION_ROLES`"""
+        ctx = MockContext()
+        self.cog.cog_check(ctx)
+        role_check.assert_called_once_with(ctx, *(1, 2, 3))
+
+
+@autospec(Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
+class SilenceTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for the silence command and its related helper methods."""
+
+    @autospec(Silence, "_reschedule", pass_mocks=False)
+    @autospec("bot.cogs.moderation.silence", "Scheduler", "SilenceNotifier", pass_mocks=False)
+    def setUp(self) -> None:
+        self.bot = MockBot()
+        self.cog = Silence(self.bot)
+        self.cog._init_task = mock.AsyncMock()()
+
+        asyncio.run(self.cog._init_cog())  # Populate instance attributes.
+
+    async def test_sent_correct_message(self):
+        """Appropriate failure/success message was sent by the command."""
         test_cases = (
             (0.0001, f"{Emojis.check_mark} silenced current channel for 0.0001 minute(s).", True,),
             (None, f"{Emojis.check_mark} silenced current channel indefinitely.", True,),
             (5, f"{Emojis.cross_mark} current channel is already silenced.", False,),
         )
         for duration, message, was_silenced in test_cases:
-            self.cog._init_task = mock.AsyncMock()()
+            ctx = MockContext()
             with self.subTest(was_silenced=was_silenced, message=message, duration=duration):
                 with mock.patch.object(self.cog, "_silence", return_value=was_silenced):
-                    await self.cog.silence.callback(self.cog, self.ctx, duration)
-                    self.ctx.send.assert_called_once_with(message)
-            self.ctx.reset_mock()
+                    await self.cog.silence.callback(self.cog, ctx, duration)
+                    ctx.send.assert_called_once_with(message)
 
-    async def test_unsilence_sent_correct_discord_message(self):
-        """Check if proper message was sent when unsilencing channel."""
-        test_cases = (
-            (True, f"{Emojis.check_mark} unsilenced current channel."),
-            (False, f"{Emojis.cross_mark} current channel was not silenced.")
-        )
-        for was_unsilenced, message in test_cases:
-            self.cog._init_task = mock.AsyncMock()()
-            with self.subTest(was_unsilenced=was_unsilenced, message=message):
-                with mock.patch.object(self.cog, "_unsilence", return_value=was_unsilenced):
-                    await self.cog.unsilence.callback(self.cog, self.ctx)
-                    self.ctx.channel.send.assert_called_once_with(message)
-            self.ctx.reset_mock()
-
-    async def test_silence_private_for_false(self):
-        """Permissions are not set and `False` is returned in an already silenced channel."""
+    async def test_skipped_already_silenced(self):
+        """Permissions were not set and `False` was returned for an already silenced channel."""
         subtests = (
             (False, PermissionOverwrite(send_messages=False, add_reactions=False)),
             (True, PermissionOverwrite(send_messages=True, add_reactions=True)),
@@ -166,7 +167,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
                 self.assertFalse(await self.cog._silence(channel, True, None))
                 channel.set_permissions.assert_not_called()
 
-    async def test_silence_private_silenced_channel(self):
+    async def test_silenced_channel(self):
         """Channel had `send_message` and `add_reactions` permissions revoked for verified role."""
         channel = MockTextChannel()
         overwrite = PermissionOverwrite(send_messages=True, add_reactions=None)
@@ -180,8 +181,8 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
             overwrite=overwrite
         )
 
-    async def test_silence_private_preserves_other_overwrites(self):
-        """Channel's other unrelated overwrites were not changed when it was silenced."""
+    async def test_preserved_other_overwrites(self):
+        """Channel's other unrelated overwrites were not changed."""
         channel = MockTextChannel()
         overwrite = PermissionOverwrite(stream=True, attach_files=False)
         channel.overwrites_for.return_value = overwrite
@@ -198,8 +199,8 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
 
-    async def test_silence_private_notifier(self):
-        """Channel should be added to notifier with `persistent` set to `True`, and the other way around."""
+    async def test_added_removed_notifier(self):
+        """Channel was added to notifier if `persistent` was `True`, and removed if `False`."""
         channel = MockTextChannel()
         overwrite = PermissionOverwrite(send_messages=True, add_reactions=None)
         channel.overwrites_for.return_value = overwrite
@@ -214,8 +215,8 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
                 await self.cog._silence(channel, False, None)
                 self.cog.notifier.add_channel.assert_not_called()
 
-    async def test_silence_private_cached_perms(self):
-        """Channel's previous overwrites were cached when silenced."""
+    async def test_cached_previous_overwrites(self):
+        """Channel's previous overwrites were cached."""
         channel = MockTextChannel()
         overwrite = PermissionOverwrite(send_messages=True, add_reactions=None)
         overwrite_json = '{"send_messages": true, "add_reactions": null}'
@@ -224,8 +225,47 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         await self.cog._silence(channel, False, None)
         self.cog.muted_channel_perms.set.assert_called_once_with(channel.id, overwrite_json)
 
-    async def test_unsilence_private_for_false(self):
-        """Permissions are not set and `False` is returned in an unsilenced channel."""
+
+@autospec(Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
+class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for the unsilence command and its related helper methods."""
+
+    @autospec(Silence, "_reschedule", pass_mocks=False)
+    @autospec("bot.cogs.moderation.silence", "Scheduler", "SilenceNotifier", pass_mocks=False)
+    def setUp(self) -> None:
+        self.bot = MockBot()
+        self.cog = Silence(self.bot)
+        self.cog._init_task = mock.AsyncMock()()
+
+        asyncio.run(self.cog._init_cog())  # Populate instance attributes.
+
+    def unsilence_fixture(self) -> MockTextChannel:
+        """Setup mocks for a successful `_unsilence` call. Return the mocked channel."""
+        overwrite_json = '{"send_messages": true, "add_reactions": null}'
+        self.cog.muted_channel_perms.get.return_value = overwrite_json
+
+        # stream=True just to have at least one other overwrite not be the default value.
+        channel = MockTextChannel()
+        overwrite = PermissionOverwrite(stream=True, send_messages=False, add_reactions=False)
+        channel.overwrites_for.return_value = overwrite
+
+        return channel
+
+    async def test_sent_correct_message(self):
+        """Appropriate failure/success message was sent by the command."""
+        test_cases = (
+            (True, f"{Emojis.check_mark} unsilenced current channel."),
+            (False, f"{Emojis.cross_mark} current channel was not silenced.")
+        )
+        for was_unsilenced, message in test_cases:
+            ctx = MockContext()
+            with self.subTest(was_unsilenced=was_unsilenced, message=message):
+                with mock.patch.object(self.cog, "_unsilence", return_value=was_unsilenced):
+                    await self.cog.unsilence.callback(self.cog, ctx)
+                    ctx.channel.send.assert_called_once_with(message)
+
+    async def test_skipped_already_unsilenced(self):
+        """Permissions were not set and `False` was returned for an already unsilenced channel."""
         self.cog.scheduler.__contains__.return_value = False
         self.cog.muted_channel_perms.get.return_value = None
         channel = MockTextChannel()
@@ -233,9 +273,8 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.assertFalse(await self.cog._unsilence(channel))
         channel.set_permissions.assert_not_called()
 
-    @mock.patch.object(Silence, "notifier", create=True)
-    async def test_unsilence_private_unsilenced_channel(self, _):
-        """Channel had `send_message` permissions restored."""
+    async def test_unsilenced_channel(self):
+        """Channel's `send_message` and `add_reactions` overwrites were restored."""
         channel = self.unsilence_fixture()
         overwrite = channel.overwrites_for.return_value
 
@@ -248,23 +287,20 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.assertTrue(overwrite.send_messages)
         self.assertIsNone(overwrite.add_reactions)
 
-    @mock.patch.object(Silence, "notifier", create=True)
-    async def test_unsilence_private_removed_notifier(self, notifier):
-        """Channel was removed from `notifier` on unsilence."""
+    async def test_removed_notifier(self):
+        """Channel was removed from `notifier`."""
         channel = self.unsilence_fixture()
         await self.cog._unsilence(channel)
-        notifier.remove_channel.assert_called_once_with(channel)
+        self.cog.notifier.remove_channel.assert_called_once_with(channel)
 
-    @mock.patch.object(Silence, "notifier", create=True)
-    async def test_unsilence_private_removed_muted_channel(self, _):
-        """Channel was removed from overwrites cache on unsilence."""
+    async def test_deleted_cached_overwrite(self):
+        """Channel was deleted from the overwrites cache."""
         channel = self.unsilence_fixture()
         await self.cog._unsilence(channel)
         self.cog.muted_channel_perms.delete.assert_awaited_once_with(channel.id)
 
-    @mock.patch.object(Silence, "notifier", create=True)
-    async def test_unsilence_private_preserves_other_overwrites(self, _):
-        """Channel's other unrelated overwrites were not changed when it was unsilenced."""
+    async def test_preserved_other_overwrites(self):
+        """Channel's other unrelated overwrites were not changed."""
         channel = self.unsilence_fixture()
         overwrite = channel.overwrites_for.return_value
 
@@ -279,15 +315,3 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         del new_overwrite_dict['add_reactions']
 
         self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
-
-    def test_cog_unload_cancels_tasks(self):
-        """All scheduled tasks should be cancelled."""
-        self.cog.cog_unload()
-        self.cog.scheduler.cancel_all.assert_called_once_with()
-
-    @mock.patch("bot.cogs.moderation.silence.with_role_check")
-    @mock.patch("bot.cogs.moderation.silence.MODERATION_ROLES", new=(1, 2, 3))
-    def test_cog_check(self, role_check):
-        """Role check is called with `MODERATION_ROLES`"""
-        self.cog.cog_check(self.ctx)
-        role_check.assert_called_once_with(self.ctx, *(1, 2, 3))
-- 
cgit v1.2.3


From 3f4d409bd951e749bdc643b0bc288cfc0f5136bd Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 16:46:13 -0700
Subject: Silence tests: autospec _reschedule and SilenceNotifier for cog tests

---
 tests/bot/cogs/moderation/test_silence.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index f3ee184d4..ae8b59ff5 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -82,39 +82,45 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         self.bot = MockBot()
         self.cog = Silence(self.bot)
 
+    @autospec(Silence, "_reschedule", pass_mocks=False)
+    @autospec("bot.cogs.moderation.silence", "SilenceNotifier", pass_mocks=False)
     async def test_init_cog_got_guild(self):
         """Bot got guild after it became available."""
         await self.cog._init_cog()
         self.bot.wait_until_guild_available.assert_awaited_once()
         self.bot.get_guild.assert_called_once_with(Guild.id)
 
+    @autospec(Silence, "_reschedule", pass_mocks=False)
+    @autospec("bot.cogs.moderation.silence", "SilenceNotifier", pass_mocks=False)
     async def test_init_cog_got_role(self):
         """Got `Roles.verified` role from guild."""
         await self.cog._init_cog()
         guild = self.bot.get_guild()
         guild.get_role.assert_called_once_with(Roles.verified)
 
+    @autospec(Silence, "_reschedule", pass_mocks=False)
+    @autospec("bot.cogs.moderation.silence", "SilenceNotifier", pass_mocks=False)
     async def test_init_cog_got_channels(self):
         """Got channels from bot."""
         await self.cog._init_cog()
         self.bot.get_channel.called_once_with(Channels.mod_alerts)
         self.bot.get_channel.called_once_with(Channels.mod_log)
 
-    @mock.patch("bot.cogs.moderation.silence.SilenceNotifier")
+    @autospec(Silence, "_reschedule", pass_mocks=False)
+    @autospec("bot.cogs.moderation.silence", "SilenceNotifier")
     async def test_init_cog_got_notifier(self, notifier):
         """Notifier was started with channel."""
         mod_log = MockTextChannel()
         self.bot.get_channel.side_effect = (None, mod_log)
         await self.cog._init_cog()
-        notifier.assert_called_once_with(mod_log)
-        self.bot.get_channel.side_effect = None
+        notifier.assert_called_once_with(self.cog._mod_log_channel)
 
     def test_cog_unload_cancelled_tasks(self):
         """All scheduled tasks were cancelled."""
         self.cog.cog_unload()
         self.cog.scheduler.cancel_all.assert_called_once_with()
 
-    @mock.patch("bot.cogs.moderation.silence.with_role_check")
+    @autospec("bot.cogs.moderation.silence", "with_role_check")
     @mock.patch("bot.cogs.moderation.silence.MODERATION_ROLES", new=(1, 2, 3))
     def test_cog_check(self, role_check):
         """Role check was called with `MODERATION_ROLES`"""
-- 
cgit v1.2.3


From a13bf79ba2aa672e52bcffe38720c7686cac67ba Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 18:40:36 -0700
Subject: Silence tests: merge unsilence fixture into setUp

Now that there are separate test cases, there's no need to keep the
fixtures separate.
---
 tests/bot/cogs/moderation/test_silence.py | 52 ++++++++++++-------------------
 1 file changed, 20 insertions(+), 32 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index ae8b59ff5..fe6045c87 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -232,7 +232,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.cog.muted_channel_perms.set.assert_called_once_with(channel.id, overwrite_json)
 
 
-@autospec(Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
+@autospec(Silence, "muted_channel_times", pass_mocks=False)
 class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the unsilence command and its related helper methods."""
 
@@ -243,19 +243,15 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         self.cog = Silence(self.bot)
         self.cog._init_task = mock.AsyncMock()()
 
-        asyncio.run(self.cog._init_cog())  # Populate instance attributes.
-
-    def unsilence_fixture(self) -> MockTextChannel:
-        """Setup mocks for a successful `_unsilence` call. Return the mocked channel."""
-        overwrite_json = '{"send_messages": true, "add_reactions": null}'
-        self.cog.muted_channel_perms.get.return_value = overwrite_json
+        perms_cache = mock.create_autospec(self.cog.muted_channel_perms, spec_set=True)
+        self.cog.muted_channel_perms = perms_cache
 
-        # stream=True just to have at least one other overwrite not be the default value.
-        channel = MockTextChannel()
-        overwrite = PermissionOverwrite(stream=True, send_messages=False, add_reactions=False)
-        channel.overwrites_for.return_value = overwrite
+        asyncio.run(self.cog._init_cog())  # Populate instance attributes.
 
-        return channel
+        perms_cache.get.return_value = '{"send_messages": true, "add_reactions": null}'
+        self.channel = MockTextChannel()
+        self.overwrite = PermissionOverwrite(stream=True, send_messages=False, add_reactions=False)
+        self.channel.overwrites_for.return_value = self.overwrite
 
     async def test_sent_correct_message(self):
         """Appropriate failure/success message was sent by the command."""
@@ -281,38 +277,30 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_unsilenced_channel(self):
         """Channel's `send_message` and `add_reactions` overwrites were restored."""
-        channel = self.unsilence_fixture()
-        overwrite = channel.overwrites_for.return_value
-
-        await self.cog._unsilence(channel)
-        channel.set_permissions.assert_awaited_once_with(
-            self.cog._verified_role, overwrite=overwrite
+        await self.cog._unsilence(self.channel)
+        self.channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_role, overwrite=self.overwrite
         )
 
         # Recall that these values are determined by the fixture.
-        self.assertTrue(overwrite.send_messages)
-        self.assertIsNone(overwrite.add_reactions)
+        self.assertTrue(self.overwrite.send_messages)
+        self.assertIsNone(self.overwrite.add_reactions)
 
     async def test_removed_notifier(self):
         """Channel was removed from `notifier`."""
-        channel = self.unsilence_fixture()
-        await self.cog._unsilence(channel)
-        self.cog.notifier.remove_channel.assert_called_once_with(channel)
+        await self.cog._unsilence(self.channel)
+        self.cog.notifier.remove_channel.assert_called_once_with(self.channel)
 
     async def test_deleted_cached_overwrite(self):
         """Channel was deleted from the overwrites cache."""
-        channel = self.unsilence_fixture()
-        await self.cog._unsilence(channel)
-        self.cog.muted_channel_perms.delete.assert_awaited_once_with(channel.id)
+        await self.cog._unsilence(self.channel)
+        self.cog.muted_channel_perms.delete.assert_awaited_once_with(self.channel.id)
 
     async def test_preserved_other_overwrites(self):
         """Channel's other unrelated overwrites were not changed."""
-        channel = self.unsilence_fixture()
-        overwrite = channel.overwrites_for.return_value
-
-        prev_overwrite_dict = dict(overwrite)
-        await self.cog._unsilence(channel)
-        new_overwrite_dict = dict(overwrite)
+        prev_overwrite_dict = dict(self.overwrite)
+        await self.cog._unsilence(self.channel)
+        new_overwrite_dict = dict(self.overwrite)
 
         # Remove 'send_messages' & 'add_reactions' keys because they were changed by the method.
         del prev_overwrite_dict['send_messages']
-- 
cgit v1.2.3


From 8c2945f9fee9f6041edaea5b5c98209478b33259 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 18:46:27 -0700
Subject: Silence tests: create channel and overwrite in setUp for silence
 tests

Reduce code redundancy by only defining them once.
---
 tests/bot/cogs/moderation/test_silence.py | 46 ++++++++++++-------------------
 1 file changed, 17 insertions(+), 29 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index fe6045c87..eba8385bc 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -142,6 +142,10 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
         asyncio.run(self.cog._init_cog())  # Populate instance attributes.
 
+        self.channel = MockTextChannel()
+        self.overwrite = PermissionOverwrite(stream=True, send_messages=True, add_reactions=False)
+        self.channel.overwrites_for.return_value = self.overwrite
+
     async def test_sent_correct_message(self):
         """Appropriate failure/success message was sent by the command."""
         test_cases = (
@@ -175,27 +179,19 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_silenced_channel(self):
         """Channel had `send_message` and `add_reactions` permissions revoked for verified role."""
-        channel = MockTextChannel()
-        overwrite = PermissionOverwrite(send_messages=True, add_reactions=None)
-        channel.overwrites_for.return_value = overwrite
-
-        self.assertTrue(await self.cog._silence(channel, False, None))
-        self.assertFalse(overwrite.send_messages)
-        self.assertFalse(overwrite.add_reactions)
-        channel.set_permissions.assert_awaited_once_with(
+        self.assertTrue(await self.cog._silence(self.channel, False, None))
+        self.assertFalse(self.overwrite.send_messages)
+        self.assertFalse(self.overwrite.add_reactions)
+        self.channel.set_permissions.assert_awaited_once_with(
             self.cog._verified_role,
-            overwrite=overwrite
+            overwrite=self.overwrite
         )
 
     async def test_preserved_other_overwrites(self):
         """Channel's other unrelated overwrites were not changed."""
-        channel = MockTextChannel()
-        overwrite = PermissionOverwrite(stream=True, attach_files=False)
-        channel.overwrites_for.return_value = overwrite
-
-        prev_overwrite_dict = dict(overwrite)
-        await self.cog._silence(channel, False, None)
-        new_overwrite_dict = dict(overwrite)
+        prev_overwrite_dict = dict(self.overwrite)
+        await self.cog._silence(self.channel, False, None)
+        new_overwrite_dict = dict(self.overwrite)
 
         # Remove 'send_messages' & 'add_reactions' keys because they were changed by the method.
         del prev_overwrite_dict['send_messages']
@@ -207,29 +203,21 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_added_removed_notifier(self):
         """Channel was added to notifier if `persistent` was `True`, and removed if `False`."""
-        channel = MockTextChannel()
-        overwrite = PermissionOverwrite(send_messages=True, add_reactions=None)
-        channel.overwrites_for.return_value = overwrite
-
         with mock.patch.object(self.cog, "notifier", create=True):
             with self.subTest(persistent=True):
-                await self.cog._silence(channel, True, None)
+                await self.cog._silence(self.channel, True, None)
                 self.cog.notifier.add_channel.assert_called_once()
 
         with mock.patch.object(self.cog, "notifier", create=True):
             with self.subTest(persistent=False):
-                await self.cog._silence(channel, False, None)
+                await self.cog._silence(self.channel, False, None)
                 self.cog.notifier.add_channel.assert_not_called()
 
     async def test_cached_previous_overwrites(self):
         """Channel's previous overwrites were cached."""
-        channel = MockTextChannel()
-        overwrite = PermissionOverwrite(send_messages=True, add_reactions=None)
-        overwrite_json = '{"send_messages": true, "add_reactions": null}'
-        channel.overwrites_for.return_value = overwrite
-
-        await self.cog._silence(channel, False, None)
-        self.cog.muted_channel_perms.set.assert_called_once_with(channel.id, overwrite_json)
+        overwrite_json = '{"send_messages": true, "add_reactions": false}'
+        await self.cog._silence(self.channel, False, None)
+        self.cog.muted_channel_perms.set.assert_called_once_with(self.channel.id, overwrite_json)
 
 
 @autospec(Silence, "muted_channel_times", pass_mocks=False)
-- 
cgit v1.2.3


From 282596d1414613e05ee8b956393913da976b35e3 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 19:13:18 -0700
Subject: Silence tests: fix mock for _init_task

An `AsyncMock` fails because it returns a coroutine which may only be
awaited once. However, an `asyncio.Future` is perfect because it is
easy to create and can be awaited repeatedly, just like the actual
`asyncio.Task` that is being mocked.
---
 tests/bot/cogs/moderation/test_silence.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index eba8385bc..5d42d8c36 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -138,7 +138,8 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     def setUp(self) -> None:
         self.bot = MockBot()
         self.cog = Silence(self.bot)
-        self.cog._init_task = mock.AsyncMock()()
+        self.cog._init_task = asyncio.Future()
+        self.cog._init_task.set_result(None)
 
         asyncio.run(self.cog._init_cog())  # Populate instance attributes.
 
@@ -229,7 +230,8 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
     def setUp(self) -> None:
         self.bot = MockBot()
         self.cog = Silence(self.bot)
-        self.cog._init_task = mock.AsyncMock()()
+        self.cog._init_task = asyncio.Future()
+        self.cog._init_task.set_result(None)
 
         perms_cache = mock.create_autospec(self.cog.muted_channel_perms, spec_set=True)
         self.cog.muted_channel_perms = perms_cache
-- 
cgit v1.2.3


From eda342b40ccd941050a1421ef1907cb2790c1cde Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 19:15:53 -0700
Subject: Silence tests: add a test for the time cache

---
 tests/bot/cogs/moderation/test_silence.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 5d42d8c36..1ae17177f 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -1,5 +1,6 @@
 import asyncio
 import unittest
+from datetime import datetime, timezone
 from unittest import mock
 from unittest.mock import Mock
 
@@ -220,6 +221,20 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         await self.cog._silence(self.channel, False, None)
         self.cog.muted_channel_perms.set.assert_called_once_with(self.channel.id, overwrite_json)
 
+    @autospec("bot.cogs.moderation.silence", "datetime")
+    async def test_cached_unsilence_time(self, datetime_mock):
+        """The UTC POSIX timestamp for the unsilence was cached."""
+        now_timestamp = 100
+        duration = 15
+        timestamp = now_timestamp + duration * 60
+        datetime_mock.now.return_value = datetime.fromtimestamp(now_timestamp, tz=timezone.utc)
+
+        ctx = MockContext(channel=self.channel)
+        await self.cog.silence.callback(self.cog, ctx, duration)
+
+        self.cog.muted_channel_times.set.assert_awaited_once_with(ctx.channel.id, timestamp)
+        datetime_mock.now.assert_called_once_with(tz=timezone.utc)  # Ensure it's using an aware dt.
+
 
 @autospec(Silence, "muted_channel_times", pass_mocks=False)
 class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
-- 
cgit v1.2.3


From 5eec1c2db319ccdb1f71c1a25fa541eeb7a2707a Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 19:17:51 -0700
Subject: Silence tests: add a test for caching permanent times

---
 tests/bot/cogs/moderation/test_silence.py | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 1ae17177f..2e756a88f 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -235,6 +235,12 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.cog.muted_channel_times.set.assert_awaited_once_with(ctx.channel.id, timestamp)
         datetime_mock.now.assert_called_once_with(tz=timezone.utc)  # Ensure it's using an aware dt.
 
+    async def test_cached_indefinite_time(self):
+        """A value of -1 was cached for a permanent silence."""
+        ctx = MockContext(channel=self.channel)
+        await self.cog.silence.callback(self.cog, ctx, None)
+        self.cog.muted_channel_times.set.assert_awaited_once_with(ctx.channel.id, -1)
+
 
 @autospec(Silence, "muted_channel_times", pass_mocks=False)
 class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
-- 
cgit v1.2.3


From 1e1d358ae38bb9d554e993fb61ee8f0b52f977b5 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 19:25:15 -0700
Subject: Silence tests: add tests for scheduling tasks

---
 tests/bot/cogs/moderation/test_silence.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 2e756a88f..979b4f4e5 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -241,6 +241,18 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         await self.cog.silence.callback(self.cog, ctx, None)
         self.cog.muted_channel_times.set.assert_awaited_once_with(ctx.channel.id, -1)
 
+    async def test_scheduled_task(self):
+        """An unsilence task was scheduled."""
+        ctx = MockContext(channel=self.channel)
+        await self.cog.silence.callback(self.cog, ctx)
+        self.cog.scheduler.schedule_later.assert_called_once()
+
+    async def test_permanent_not_scheduled(self):
+        """A task was not scheduled for a permanent silence."""
+        ctx = MockContext(channel=self.channel)
+        await self.cog.silence.callback(self.cog, ctx, None)
+        self.cog.scheduler.schedule_later.assert_not_called()
+
 
 @autospec(Silence, "muted_channel_times", pass_mocks=False)
 class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
-- 
cgit v1.2.3


From d4fbd675d9803cc664909c19fcec8a430524f918 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 19:26:48 -0700
Subject: Silence tests: add a test for deletion from the time cache

---
 tests/bot/cogs/moderation/test_silence.py | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 979b4f4e5..6f913b8f9 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -319,6 +319,11 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         await self.cog._unsilence(self.channel)
         self.cog.muted_channel_perms.delete.assert_awaited_once_with(self.channel.id)
 
+    async def test_deleted_cached_time(self):
+        """Channel was deleted from the timestamp cache."""
+        await self.cog._unsilence(self.channel)
+        self.cog.muted_channel_times.delete.assert_awaited_once_with(self.channel.id)
+
     async def test_preserved_other_overwrites(self):
         """Channel's other unrelated overwrites were not changed."""
         prev_overwrite_dict = dict(self.overwrite)
-- 
cgit v1.2.3


From 67f88e0b63ec9ac198b8204d4b07e6f7ee67937b Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 19:28:15 -0700
Subject: Silence tests: add a test for task cancellation

---
 tests/bot/cogs/moderation/test_silence.py | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 6f913b8f9..9e81df9c4 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -324,6 +324,11 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         await self.cog._unsilence(self.channel)
         self.cog.muted_channel_times.delete.assert_awaited_once_with(self.channel.id)
 
+    async def test_cancelled_task(self):
+        """The scheduled unsilence task should be cancelled."""
+        await self.cog._unsilence(self.channel)
+        self.cog.scheduler.cancel.assert_called_once_with(self.channel.id)
+
     async def test_preserved_other_overwrites(self):
         """Channel's other unrelated overwrites were not changed."""
         prev_overwrite_dict = dict(self.overwrite)
-- 
cgit v1.2.3


From cc956f24e1f748dbe97fc6bd96383d22a494c5ed Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 19:50:14 -0700
Subject: Silence tests: add a test for default overwrites on cache miss

Use a False for `add_reactions` in the mock overwrite rather than None
to be sure the default (also None) is actually set for it.

Fix channels set by `_init_cog` not being mocked properly.
---
 tests/bot/cogs/moderation/test_silence.py | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 9e81df9c4..992906a50 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -261,7 +261,7 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
     @autospec(Silence, "_reschedule", pass_mocks=False)
     @autospec("bot.cogs.moderation.silence", "Scheduler", "SilenceNotifier", pass_mocks=False)
     def setUp(self) -> None:
-        self.bot = MockBot()
+        self.bot = MockBot(get_channel=lambda _: MockTextChannel())
         self.cog = Silence(self.bot)
         self.cog._init_task = asyncio.Future()
         self.cog._init_task.set_result(None)
@@ -271,7 +271,8 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
         asyncio.run(self.cog._init_cog())  # Populate instance attributes.
 
-        perms_cache.get.return_value = '{"send_messages": true, "add_reactions": null}'
+        self.cog.scheduler.__contains__.return_value = True
+        perms_cache.get.return_value = '{"send_messages": true, "add_reactions": false}'
         self.channel = MockTextChannel()
         self.overwrite = PermissionOverwrite(stream=True, send_messages=False, add_reactions=False)
         self.channel.overwrites_for.return_value = self.overwrite
@@ -298,15 +299,29 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         self.assertFalse(await self.cog._unsilence(channel))
         channel.set_permissions.assert_not_called()
 
-    async def test_unsilenced_channel(self):
+    async def test_restored_overwrites(self):
         """Channel's `send_message` and `add_reactions` overwrites were restored."""
         await self.cog._unsilence(self.channel)
         self.channel.set_permissions.assert_awaited_once_with(
-            self.cog._verified_role, overwrite=self.overwrite
+            self.cog._verified_role,
+            overwrite=self.overwrite,
         )
 
         # Recall that these values are determined by the fixture.
         self.assertTrue(self.overwrite.send_messages)
+        self.assertFalse(self.overwrite.add_reactions)
+
+    async def test_cache_miss_used_default_overwrites(self):
+        """Both overwrites were set to None due previous values not being found in the cache."""
+        self.cog.muted_channel_perms.get.return_value = None
+
+        await self.cog._unsilence(self.channel)
+        self.channel.set_permissions.assert_awaited_once_with(
+            self.cog._verified_role,
+            overwrite=self.overwrite,
+        )
+
+        self.assertIsNone(self.overwrite.send_messages)
         self.assertIsNone(self.overwrite.add_reactions)
 
     async def test_removed_notifier(self):
-- 
cgit v1.2.3


From e4548b2505cf4765cfd2a2c1a1762212cc5cba25 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 19:54:04 -0700
Subject: Silence tests: add a test for a mod alert on cache miss

---
 tests/bot/cogs/moderation/test_silence.py | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 992906a50..ccc908ee4 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -324,6 +324,13 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         self.assertIsNone(self.overwrite.send_messages)
         self.assertIsNone(self.overwrite.add_reactions)
 
+    async def test_cache_miss_sent_mod_alert(self):
+        """A message was sent to the mod alerts channel."""
+        self.cog.muted_channel_perms.get.return_value = None
+
+        await self.cog._unsilence(self.channel)
+        self.cog._mod_alerts_channel.send.assert_awaited_once()
+
     async def test_removed_notifier(self):
         """Channel was removed from `notifier`."""
         await self.cog._unsilence(self.channel)
-- 
cgit v1.2.3


From 33fb55cbe431211f99acfbce22129c48a60a1e6b Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 19:58:26 -0700
Subject: Silence tests: also test that cache misses preserve other overwrites

---
 tests/bot/cogs/moderation/test_silence.py | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index ccc908ee4..71608d3f9 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -352,15 +352,19 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         self.cog.scheduler.cancel.assert_called_once_with(self.channel.id)
 
     async def test_preserved_other_overwrites(self):
-        """Channel's other unrelated overwrites were not changed."""
-        prev_overwrite_dict = dict(self.overwrite)
-        await self.cog._unsilence(self.channel)
-        new_overwrite_dict = dict(self.overwrite)
-
-        # Remove 'send_messages' & 'add_reactions' keys because they were changed by the method.
-        del prev_overwrite_dict['send_messages']
-        del prev_overwrite_dict['add_reactions']
-        del new_overwrite_dict['send_messages']
-        del new_overwrite_dict['add_reactions']
-
-        self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
+        """Channel's other unrelated overwrites were not changed, including cache misses."""
+        for overwrite_json in ('{"send_messages": true, "add_reactions": null}', None):
+            with self.subTest(overwrite_json=overwrite_json):
+                self.cog.muted_channel_perms.get.return_value = overwrite_json
+
+                prev_overwrite_dict = dict(self.overwrite)
+                await self.cog._unsilence(self.channel)
+                new_overwrite_dict = dict(self.overwrite)
+
+                # Remove these keys because they were modified by the unsilence.
+                del prev_overwrite_dict['send_messages']
+                del prev_overwrite_dict['add_reactions']
+                del new_overwrite_dict['send_messages']
+                del new_overwrite_dict['add_reactions']
+
+                self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
-- 
cgit v1.2.3


From 83d74c56af2a777a2a4f6f7f5347598d0000a66b Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 20:14:46 -0700
Subject: Silence tests: assert against message constants

Duplicating strings in assertions is redundant, closely coupled, and
less maintainable.
---
 bot/cogs/moderation/silence.py            | 26 +++++++++++++++++---------
 tests/bot/cogs/moderation/test_silence.py | 13 +++++++------
 2 files changed, 24 insertions(+), 15 deletions(-)

(limited to 'tests')

diff --git a/bot/cogs/moderation/silence.py b/bot/cogs/moderation/silence.py
index de799f64f..9732248ff 100644
--- a/bot/cogs/moderation/silence.py
+++ b/bot/cogs/moderation/silence.py
@@ -17,6 +17,17 @@ from bot.utils.scheduling import Scheduler
 
 log = logging.getLogger(__name__)
 
+MSG_SILENCE_FAIL = f"{Emojis.cross_mark} current channel is already silenced."
+MSG_SILENCE_PERMANENT = f"{Emojis.check_mark} silenced current channel indefinitely."
+MSG_SILENCE_SUCCESS = Emojis.check_mark + " silenced current channel for {duration} minute(s)."
+
+MSG_UNSILENCE_FAIL = f"{Emojis.cross_mark} current channel was not silenced."
+MSG_UNSILENCE_MANUAL = (
+    f"{Emojis.cross_mark} current channel was not unsilenced because the current "
+    f"overwrites were set manually. Please edit them manually to unsilence."
+)
+MSG_UNSILENCE_SUCCESS = f"{Emojis.check_mark} unsilenced current channel."
+
 
 class SilenceNotifier(tasks.Loop):
     """Loop notifier for posting notices to `alert_channel` containing added channels."""
@@ -96,15 +107,15 @@ class Silence(commands.Cog):
         log.debug(f"{ctx.author} is silencing channel #{ctx.channel}.")
 
         if not await self._silence(ctx.channel, persistent=(duration is None), duration=duration):
-            await ctx.send(f"{Emojis.cross_mark} current channel is already silenced.")
+            await ctx.send(MSG_SILENCE_FAIL)
             return
 
         if duration is None:
-            await ctx.send(f"{Emojis.check_mark} silenced current channel indefinitely.")
+            await ctx.send(MSG_SILENCE_PERMANENT)
             await self.muted_channel_times.set(ctx.channel.id, -1)
             return
 
-        await ctx.send(f"{Emojis.check_mark} silenced current channel for {duration} minute(s).")
+        await ctx.send(MSG_SILENCE_SUCCESS.format(duration=duration))
 
         self.scheduler.schedule_later(duration * 60, ctx.channel.id, ctx.invoke(self.unsilence))
         unsilence_time = (datetime.now(tz=timezone.utc) + timedelta(minutes=duration))
@@ -126,14 +137,11 @@ class Silence(commands.Cog):
         if not await self._unsilence(channel):
             overwrite = channel.overwrites_for(self._verified_role)
             if overwrite.send_messages is False and overwrite.add_reactions is False:
-                await channel.send(
-                    f"{Emojis.cross_mark} current channel was not unsilenced because the current "
-                    f"overwrites were set manually. Please edit them manually to unsilence."
-                )
+                await channel.send(MSG_UNSILENCE_MANUAL)
             else:
-                await channel.send(f"{Emojis.cross_mark} current channel was not silenced.")
+                await channel.send(MSG_UNSILENCE_FAIL)
         else:
-            await channel.send(f"{Emojis.check_mark} unsilenced current channel.")
+            await channel.send(MSG_UNSILENCE_SUCCESS)
 
     async def _silence(self, channel: TextChannel, persistent: bool, duration: Optional[int]) -> bool:
         """
diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 71608d3f9..168794b6f 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -6,8 +6,9 @@ from unittest.mock import Mock
 
 from discord import PermissionOverwrite
 
+from bot.cogs.moderation import silence
 from bot.cogs.moderation.silence import Silence, SilenceNotifier
-from bot.constants import Channels, Emojis, Guild, Roles
+from bot.constants import Channels, Guild, Roles
 from tests.helpers import MockBot, MockContext, MockTextChannel, autospec
 
 
@@ -151,9 +152,9 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_sent_correct_message(self):
         """Appropriate failure/success message was sent by the command."""
         test_cases = (
-            (0.0001, f"{Emojis.check_mark} silenced current channel for 0.0001 minute(s).", True,),
-            (None, f"{Emojis.check_mark} silenced current channel indefinitely.", True,),
-            (5, f"{Emojis.cross_mark} current channel is already silenced.", False,),
+            (0.0001, silence.MSG_SILENCE_SUCCESS.format(duration=0.0001), True,),
+            (None, silence.MSG_SILENCE_PERMANENT, True,),
+            (5, silence.MSG_SILENCE_FAIL, False,),
         )
         for duration, message, was_silenced in test_cases:
             ctx = MockContext()
@@ -280,8 +281,8 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_sent_correct_message(self):
         """Appropriate failure/success message was sent by the command."""
         test_cases = (
-            (True, f"{Emojis.check_mark} unsilenced current channel."),
-            (False, f"{Emojis.cross_mark} current channel was not silenced.")
+            (True, silence.MSG_UNSILENCE_SUCCESS),
+            (False, silence.MSG_UNSILENCE_FAIL)
         )
         for was_unsilenced, message in test_cases:
             ctx = MockContext()
-- 
cgit v1.2.3


From ed30502710e805de5e3793b762a3848a0295582d Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 20:18:14 -0700
Subject: Silence tests: add a subtest for the manual unsilence message

---
 tests/bot/cogs/moderation/test_silence.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 168794b6f..254480a6d 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -280,14 +280,17 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_sent_correct_message(self):
         """Appropriate failure/success message was sent by the command."""
+        unsilenced_overwrite = PermissionOverwrite(send_messages=True, add_reactions=True)
         test_cases = (
-            (True, silence.MSG_UNSILENCE_SUCCESS),
-            (False, silence.MSG_UNSILENCE_FAIL)
+            (True, silence.MSG_UNSILENCE_SUCCESS, unsilenced_overwrite),
+            (False, silence.MSG_UNSILENCE_FAIL, unsilenced_overwrite),
+            (False, silence.MSG_UNSILENCE_MANUAL, self.overwrite),
         )
-        for was_unsilenced, message in test_cases:
+        for was_unsilenced, message, overwrite in test_cases:
             ctx = MockContext()
-            with self.subTest(was_unsilenced=was_unsilenced, message=message):
+            with self.subTest(was_unsilenced=was_unsilenced, message=message, overwrite=overwrite):
                 with mock.patch.object(self.cog, "_unsilence", return_value=was_unsilenced):
+                    ctx.channel.overwrites_for.return_value = overwrite
                     await self.cog.unsilence.callback(self.cog, ctx)
                     ctx.channel.send.assert_called_once_with(message)
 
-- 
cgit v1.2.3


From f9d4081efc41c7ab9f5e6362a0ab4fab5bc88cd8 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 20:23:15 -0700
Subject: Silence tests: access everything via the silence module

The module is imported anyway to keep imports short and clean. Using it
in patch targets is shorter and allows for the two imports from the
module to be removed.
---
 tests/bot/cogs/moderation/test_silence.py | 47 +++++++++++++++----------------
 1 file changed, 23 insertions(+), 24 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 254480a6d..0a93cc623 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -7,7 +7,6 @@ from unittest.mock import Mock
 from discord import PermissionOverwrite
 
 from bot.cogs.moderation import silence
-from bot.cogs.moderation.silence import Silence, SilenceNotifier
 from bot.constants import Channels, Guild, Roles
 from tests.helpers import MockBot, MockContext, MockTextChannel, autospec
 
@@ -15,7 +14,7 @@ from tests.helpers import MockBot, MockContext, MockTextChannel, autospec
 class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
     def setUp(self) -> None:
         self.alert_channel = MockTextChannel()
-        self.notifier = SilenceNotifier(self.alert_channel)
+        self.notifier = silence.SilenceNotifier(self.alert_channel)
         self.notifier.stop = self.notifier_stop_mock = Mock()
         self.notifier.start = self.notifier_start_mock = Mock()
 
@@ -75,41 +74,41 @@ class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
                     self.alert_channel.send.assert_not_called()
 
 
-@autospec(Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
+@autospec(silence.Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
 class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the general functionality of the Silence cog."""
 
-    @autospec("bot.cogs.moderation.silence", "Scheduler", pass_mocks=False)
+    @autospec(silence, "Scheduler", pass_mocks=False)
     def setUp(self) -> None:
         self.bot = MockBot()
-        self.cog = Silence(self.bot)
+        self.cog = silence.Silence(self.bot)
 
-    @autospec(Silence, "_reschedule", pass_mocks=False)
-    @autospec("bot.cogs.moderation.silence", "SilenceNotifier", pass_mocks=False)
+    @autospec(silence.Silence, "_reschedule", pass_mocks=False)
+    @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_init_cog_got_guild(self):
         """Bot got guild after it became available."""
         await self.cog._init_cog()
         self.bot.wait_until_guild_available.assert_awaited_once()
         self.bot.get_guild.assert_called_once_with(Guild.id)
 
-    @autospec(Silence, "_reschedule", pass_mocks=False)
-    @autospec("bot.cogs.moderation.silence", "SilenceNotifier", pass_mocks=False)
+    @autospec(silence.Silence, "_reschedule", pass_mocks=False)
+    @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_init_cog_got_role(self):
         """Got `Roles.verified` role from guild."""
         await self.cog._init_cog()
         guild = self.bot.get_guild()
         guild.get_role.assert_called_once_with(Roles.verified)
 
-    @autospec(Silence, "_reschedule", pass_mocks=False)
-    @autospec("bot.cogs.moderation.silence", "SilenceNotifier", pass_mocks=False)
+    @autospec(silence.Silence, "_reschedule", pass_mocks=False)
+    @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_init_cog_got_channels(self):
         """Got channels from bot."""
         await self.cog._init_cog()
         self.bot.get_channel.called_once_with(Channels.mod_alerts)
         self.bot.get_channel.called_once_with(Channels.mod_log)
 
-    @autospec(Silence, "_reschedule", pass_mocks=False)
-    @autospec("bot.cogs.moderation.silence", "SilenceNotifier")
+    @autospec(silence.Silence, "_reschedule", pass_mocks=False)
+    @autospec(silence, "SilenceNotifier")
     async def test_init_cog_got_notifier(self, notifier):
         """Notifier was started with channel."""
         mod_log = MockTextChannel()
@@ -122,8 +121,8 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         self.cog.cog_unload()
         self.cog.scheduler.cancel_all.assert_called_once_with()
 
-    @autospec("bot.cogs.moderation.silence", "with_role_check")
-    @mock.patch("bot.cogs.moderation.silence.MODERATION_ROLES", new=(1, 2, 3))
+    @autospec(silence, "with_role_check")
+    @mock.patch.object(silence, "MODERATION_ROLES", new=(1, 2, 3))
     def test_cog_check(self, role_check):
         """Role check was called with `MODERATION_ROLES`"""
         ctx = MockContext()
@@ -131,15 +130,15 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         role_check.assert_called_once_with(ctx, *(1, 2, 3))
 
 
-@autospec(Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
+@autospec(silence.Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
 class SilenceTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the silence command and its related helper methods."""
 
-    @autospec(Silence, "_reschedule", pass_mocks=False)
-    @autospec("bot.cogs.moderation.silence", "Scheduler", "SilenceNotifier", pass_mocks=False)
+    @autospec(silence.Silence, "_reschedule", pass_mocks=False)
+    @autospec(silence, "Scheduler", "SilenceNotifier", pass_mocks=False)
     def setUp(self) -> None:
         self.bot = MockBot()
-        self.cog = Silence(self.bot)
+        self.cog = silence.Silence(self.bot)
         self.cog._init_task = asyncio.Future()
         self.cog._init_task.set_result(None)
 
@@ -222,7 +221,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         await self.cog._silence(self.channel, False, None)
         self.cog.muted_channel_perms.set.assert_called_once_with(self.channel.id, overwrite_json)
 
-    @autospec("bot.cogs.moderation.silence", "datetime")
+    @autospec(silence, "datetime")
     async def test_cached_unsilence_time(self, datetime_mock):
         """The UTC POSIX timestamp for the unsilence was cached."""
         now_timestamp = 100
@@ -255,15 +254,15 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.cog.scheduler.schedule_later.assert_not_called()
 
 
-@autospec(Silence, "muted_channel_times", pass_mocks=False)
+@autospec(silence.Silence, "muted_channel_times", pass_mocks=False)
 class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the unsilence command and its related helper methods."""
 
-    @autospec(Silence, "_reschedule", pass_mocks=False)
-    @autospec("bot.cogs.moderation.silence", "Scheduler", "SilenceNotifier", pass_mocks=False)
+    @autospec(silence.Silence, "_reschedule", pass_mocks=False)
+    @autospec(silence, "Scheduler", "SilenceNotifier", pass_mocks=False)
     def setUp(self) -> None:
         self.bot = MockBot(get_channel=lambda _: MockTextChannel())
-        self.cog = Silence(self.bot)
+        self.cog = silence.Silence(self.bot)
         self.cog._init_task = asyncio.Future()
         self.cog._init_task.set_result(None)
 
-- 
cgit v1.2.3


From cbdc14a3abbcbee644e9d4a6f3ffde125a7c91f1 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 20:36:48 -0700
Subject: Silence tests: remove _reschedule patch for cog tests

They don't do anything because they patch the class rather than the
instance. It's too late for patching the instance to work since the
`setUp` fixture, which instantiates the cog, executes before the patches
do. Patching `setUp` would work (and its done in the other test cases),
but some tests in this case will need the unpatched function too.
Patching it doesn't serve much benefit to most tests anyway, so it's
not worth the effort trying to make them work where they aren't needed.
---
 tests/bot/cogs/moderation/test_silence.py | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 0a93cc623..667d61776 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -83,7 +83,6 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         self.bot = MockBot()
         self.cog = silence.Silence(self.bot)
 
-    @autospec(silence.Silence, "_reschedule", pass_mocks=False)
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_init_cog_got_guild(self):
         """Bot got guild after it became available."""
@@ -91,7 +90,6 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         self.bot.wait_until_guild_available.assert_awaited_once()
         self.bot.get_guild.assert_called_once_with(Guild.id)
 
-    @autospec(silence.Silence, "_reschedule", pass_mocks=False)
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_init_cog_got_role(self):
         """Got `Roles.verified` role from guild."""
@@ -99,7 +97,6 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         guild = self.bot.get_guild()
         guild.get_role.assert_called_once_with(Roles.verified)
 
-    @autospec(silence.Silence, "_reschedule", pass_mocks=False)
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_init_cog_got_channels(self):
         """Got channels from bot."""
@@ -107,7 +104,6 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         self.bot.get_channel.called_once_with(Channels.mod_alerts)
         self.bot.get_channel.called_once_with(Channels.mod_log)
 
-    @autospec(silence.Silence, "_reschedule", pass_mocks=False)
     @autospec(silence, "SilenceNotifier")
     async def test_init_cog_got_notifier(self, notifier):
         """Notifier was started with channel."""
-- 
cgit v1.2.3


From 366f975bbb22c45b9e071644ab4053416bf351fb Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Mon, 17 Aug 2020 20:37:24 -0700
Subject: Silence tests: add a test for _init_cog rescheduling unsilences

---
 tests/bot/cogs/moderation/test_silence.py | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 667d61776..5deed2d0b 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -112,6 +112,13 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         await self.cog._init_cog()
         notifier.assert_called_once_with(self.cog._mod_log_channel)
 
+    @autospec(silence, "SilenceNotifier", pass_mocks=False)
+    async def test_init_cog_rescheduled(self):
+        """`_reschedule_` coroutine was awaited."""
+        self.cog._reschedule = mock.create_autospec(self.cog._reschedule, spec_set=True)
+        await self.cog._init_cog()
+        self.cog._reschedule.assert_awaited_once_with()
+
     def test_cog_unload_cancelled_tasks(self):
         """All scheduled tasks were cancelled."""
         self.cog.cog_unload()
-- 
cgit v1.2.3


From d5032459bfe1bbbc10ffc3b95809e0fc377de60c Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 18 Aug 2020 10:19:17 -0700
Subject: Silence tests: test the scheduler skips missing channels

---
 tests/bot/cogs/moderation/test_silence.py | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 5deed2d0b..2c8059752 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -133,6 +133,31 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         role_check.assert_called_once_with(ctx, *(1, 2, 3))
 
 
+@autospec(silence.Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
+class RescheduleTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for the rescheduling of cached unsilences."""
+
+    @autospec(silence, "Scheduler", "SilenceNotifier", pass_mocks=False)
+    def setUp(self):
+        self.bot = MockBot()
+        self.cog = silence.Silence(self.bot)
+        self.cog._unsilence_wrapper = mock.create_autospec(self.cog._unsilence_wrapper, spec_set=True)
+
+        with mock.patch.object(self.cog, "_reschedule", spec_set=True, autospec=True):
+            asyncio.run(self.cog._init_cog())  # Populate instance attributes.
+
+    async def test_skipped_missing_channel(self):
+        """Did nothing because the channel couldn't be retrieved."""
+        self.cog.muted_channel_times.items.return_value = [(123, -1), (123, 1), (123, 100000000000)]
+        self.bot.get_channel.return_value = None
+
+        await self.cog._reschedule()
+
+        self.cog.notifier.add_channel.assert_not_called()
+        self.cog._unsilence_wrapper.assert_not_called()
+        self.cog.scheduler.schedule_later.assert_not_called()
+
+
 @autospec(silence.Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
 class SilenceTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the silence command and its related helper methods."""
-- 
cgit v1.2.3


From d44e3f795f8c56a1fbbce2833b27474b263e911b Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 18 Aug 2020 10:53:33 -0700
Subject: Silence tests: test the rescheduler adds permanent silence to
 notifier

---
 tests/bot/cogs/moderation/test_silence.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 2c8059752..6e8c9ff38 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -157,6 +157,20 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
         self.cog._unsilence_wrapper.assert_not_called()
         self.cog.scheduler.schedule_later.assert_not_called()
 
+    async def test_added_permanent_to_notifier(self):
+        """Permanently silenced channels were added to the notifier."""
+        channels = [MockTextChannel(id=123), MockTextChannel(id=456)]
+        self.bot.get_channel.side_effect = channels
+        self.cog.muted_channel_times.items.return_value = [(123, -1), (456, -1)]
+
+        await self.cog._reschedule()
+
+        self.cog.notifier.add_channel.assert_any_call(channels[0])
+        self.cog.notifier.add_channel.assert_any_call(channels[1])
+
+        self.cog._unsilence_wrapper.assert_not_called()
+        self.cog.scheduler.schedule_later.assert_not_called()
+
 
 @autospec(silence.Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
 class SilenceTests(unittest.IsolatedAsyncioTestCase):
-- 
cgit v1.2.3


From 5f23f6630cd1c44d129d23e4becd9fce7f76135d Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 18 Aug 2020 10:57:17 -0700
Subject: Silence tests: test the rescheduler unsilences expired silences

---
 tests/bot/cogs/moderation/test_silence.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 6e8c9ff38..d9ff13595 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -171,6 +171,20 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
         self.cog._unsilence_wrapper.assert_not_called()
         self.cog.scheduler.schedule_later.assert_not_called()
 
+    async def test_unsilenced_expired(self):
+        """Unsilenced expired silences."""
+        channels = [MockTextChannel(id=123), MockTextChannel(id=456)]
+        self.bot.get_channel.side_effect = channels
+        self.cog.muted_channel_times.items.return_value = [(123, 100), (456, 200)]
+
+        await self.cog._reschedule()
+
+        self.cog._unsilence_wrapper.assert_any_call(channels[0])
+        self.cog._unsilence_wrapper.assert_any_call(channels[1])
+
+        self.cog.notifier.add_channel.assert_not_called()
+        self.cog.scheduler.schedule_later.assert_not_called()
+
 
 @autospec(silence.Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
 class SilenceTests(unittest.IsolatedAsyncioTestCase):
-- 
cgit v1.2.3


From 7fadf2d531562dcc7e78bcb70d59d0a0575a18be Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 18 Aug 2020 11:56:49 -0700
Subject: Silence tests: add a test for rescheduling active silences

---
 tests/bot/cogs/moderation/test_silence.py | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index d9ff13595..3d111341b 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -11,6 +11,13 @@ from bot.constants import Channels, Guild, Roles
 from tests.helpers import MockBot, MockContext, MockTextChannel, autospec
 
 
+# Have to subclass it because builtins can't be patched.
+class PatchedDatetime(datetime):
+    """A datetime object with a mocked now() function."""
+
+    now = mock.create_autospec(datetime, "now")
+
+
 class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
     def setUp(self) -> None:
         self.alert_channel = MockTextChannel()
@@ -185,6 +192,28 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
         self.cog.notifier.add_channel.assert_not_called()
         self.cog.scheduler.schedule_later.assert_not_called()
 
+    @mock.patch.object(silence, "datetime", new=PatchedDatetime)
+    async def test_rescheduled_active(self):
+        """Rescheduled active silences."""
+        channels = [MockTextChannel(id=123), MockTextChannel(id=456)]
+        self.bot.get_channel.side_effect = channels
+        self.cog.muted_channel_times.items.return_value = [(123, 2000), (456, 3000)]
+        silence.datetime.now.return_value = datetime.fromtimestamp(1000, tz=timezone.utc)
+
+        self.cog._unsilence_wrapper = mock.MagicMock()
+        unsilence_return = self.cog._unsilence_wrapper.return_value
+
+        await self.cog._reschedule()
+
+        # Yuck.
+        calls = [mock.call(1000, 123, unsilence_return), mock.call(2000, 456, unsilence_return)]
+        self.cog.scheduler.schedule_later.assert_has_calls(calls)
+
+        unsilence_calls = [mock.call(channel) for channel in channels]
+        self.cog._unsilence_wrapper.assert_has_calls(unsilence_calls)
+
+        self.cog.notifier.add_channel.assert_not_called()
+
 
 @autospec(silence.Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
 class SilenceTests(unittest.IsolatedAsyncioTestCase):
-- 
cgit v1.2.3


From a9ddbf346d95e67731196d8d822835330b6992af Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 18 Aug 2020 12:02:29 -0700
Subject: Silence tests: more accurately assert the silence cmd schedule a task

---
 tests/bot/cogs/moderation/test_silence.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 3d111341b..bc41422ef 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -328,9 +328,13 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_scheduled_task(self):
         """An unsilence task was scheduled."""
-        ctx = MockContext(channel=self.channel)
-        await self.cog.silence.callback(self.cog, ctx)
-        self.cog.scheduler.schedule_later.assert_called_once()
+        ctx = MockContext(channel=self.channel, invoke=mock.MagicMock())
+
+        await self.cog.silence.callback(self.cog, ctx, 5)
+
+        args = (300, ctx.channel.id, ctx.invoke.return_value)
+        self.cog.scheduler.schedule_later.assert_called_once_with(*args)
+        ctx.invoke.assert_called_once_with(self.cog.unsilence)
 
     async def test_permanent_not_scheduled(self):
         """A task was not scheduled for a permanent silence."""
-- 
cgit v1.2.3


From 40c6f688eb0e317b1489b069f263f25b202a345c Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 18 Aug 2020 12:15:36 -0700
Subject: Silence tests: remove unnecessary spec_set args

It's not really necessary to set to True when mocking functions.
---
 tests/bot/cogs/moderation/test_silence.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index bc41422ef..5c6d677ca 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -122,7 +122,7 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_init_cog_rescheduled(self):
         """`_reschedule_` coroutine was awaited."""
-        self.cog._reschedule = mock.create_autospec(self.cog._reschedule, spec_set=True)
+        self.cog._reschedule = mock.create_autospec(self.cog._reschedule)
         await self.cog._init_cog()
         self.cog._reschedule.assert_awaited_once_with()
 
@@ -148,9 +148,9 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
     def setUp(self):
         self.bot = MockBot()
         self.cog = silence.Silence(self.bot)
-        self.cog._unsilence_wrapper = mock.create_autospec(self.cog._unsilence_wrapper, spec_set=True)
+        self.cog._unsilence_wrapper = mock.create_autospec(self.cog._unsilence_wrapper)
 
-        with mock.patch.object(self.cog, "_reschedule", spec_set=True, autospec=True):
+        with mock.patch.object(self.cog, "_reschedule", autospec=True):
             asyncio.run(self.cog._init_cog())  # Populate instance attributes.
 
     async def test_skipped_missing_channel(self):
-- 
cgit v1.2.3


From 27a00bf29193b1768c298c1455936bb7dc92aaf1 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 18 Aug 2020 12:18:14 -0700
Subject: Silence: rename caches

---
 bot/cogs/moderation/silence.py            | 18 +++++++-------
 tests/bot/cogs/moderation/test_silence.py | 40 +++++++++++++++----------------
 2 files changed, 29 insertions(+), 29 deletions(-)

(limited to 'tests')

diff --git a/bot/cogs/moderation/silence.py b/bot/cogs/moderation/silence.py
index 9732248ff..5851be00a 100644
--- a/bot/cogs/moderation/silence.py
+++ b/bot/cogs/moderation/silence.py
@@ -72,11 +72,11 @@ class Silence(commands.Cog):
 
     # Maps muted channel IDs to their previous overwrites for send_message and add_reactions.
     # Overwrites are stored as JSON.
-    muted_channel_perms = RedisCache()
+    previous_overwrites = RedisCache()
 
     # Maps muted channel IDs to POSIX timestamps of when they'll be unsilenced.
     # A timestamp equal to -1 means it's indefinite.
-    muted_channel_times = RedisCache()
+    unsilence_timestamps = RedisCache()
 
     def __init__(self, bot: Bot):
         self.bot = bot
@@ -112,14 +112,14 @@ class Silence(commands.Cog):
 
         if duration is None:
             await ctx.send(MSG_SILENCE_PERMANENT)
-            await self.muted_channel_times.set(ctx.channel.id, -1)
+            await self.unsilence_timestamps.set(ctx.channel.id, -1)
             return
 
         await ctx.send(MSG_SILENCE_SUCCESS.format(duration=duration))
 
         self.scheduler.schedule_later(duration * 60, ctx.channel.id, ctx.invoke(self.unsilence))
         unsilence_time = (datetime.now(tz=timezone.utc) + timedelta(minutes=duration))
-        await self.muted_channel_times.set(ctx.channel.id, unsilence_time.timestamp())
+        await self.unsilence_timestamps.set(ctx.channel.id, unsilence_time.timestamp())
 
     @commands.command(aliases=("unhush",))
     async def unsilence(self, ctx: Context) -> None:
@@ -160,7 +160,7 @@ class Silence(commands.Cog):
 
         overwrite.update(send_messages=False, add_reactions=False)
         await channel.set_permissions(self._verified_role, overwrite=overwrite)
-        await self.muted_channel_perms.set(channel.id, json.dumps(prev_overwrites))
+        await self.previous_overwrites.set(channel.id, json.dumps(prev_overwrites))
 
         if persistent:
             log.info(f"Silenced #{channel} ({channel.id}) indefinitely.")
@@ -180,7 +180,7 @@ class Silence(commands.Cog):
 
         Return `True` if channel permissions were changed, `False` otherwise.
         """
-        prev_overwrites = await self.muted_channel_perms.get(channel.id)
+        prev_overwrites = await self.previous_overwrites.get(channel.id)
         if channel.id not in self.scheduler and prev_overwrites is None:
             log.info(f"Tried to unsilence channel #{channel} ({channel.id}) but the channel was not silenced.")
             return False
@@ -197,8 +197,8 @@ class Silence(commands.Cog):
 
         self.scheduler.cancel(channel.id)
         self.notifier.remove_channel(channel)
-        await self.muted_channel_perms.delete(channel.id)
-        await self.muted_channel_times.delete(channel.id)
+        await self.previous_overwrites.delete(channel.id)
+        await self.unsilence_timestamps.delete(channel.id)
 
         if prev_overwrites is None:
             await self._mod_alerts_channel.send(
@@ -211,7 +211,7 @@ class Silence(commands.Cog):
 
     async def _reschedule(self) -> None:
         """Reschedule unsilencing of active silences and add permanent ones to the notifier."""
-        for channel_id, timestamp in await self.muted_channel_times.items():
+        for channel_id, timestamp in await self.unsilence_timestamps.items():
             channel = self.bot.get_channel(channel_id)
             if channel is None:
                 log.info(f"Can't reschedule silence for {channel_id}: channel not found.")
diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 5c6d677ca..a66d27d08 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -81,7 +81,7 @@ class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
                     self.alert_channel.send.assert_not_called()
 
 
-@autospec(silence.Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
+@autospec(silence.Silence, "previous_overwrites", "unsilence_timestamps", pass_mocks=False)
 class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the general functionality of the Silence cog."""
 
@@ -140,7 +140,7 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         role_check.assert_called_once_with(ctx, *(1, 2, 3))
 
 
-@autospec(silence.Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
+@autospec(silence.Silence, "previous_overwrites", "unsilence_timestamps", pass_mocks=False)
 class RescheduleTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the rescheduling of cached unsilences."""
 
@@ -155,7 +155,7 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_skipped_missing_channel(self):
         """Did nothing because the channel couldn't be retrieved."""
-        self.cog.muted_channel_times.items.return_value = [(123, -1), (123, 1), (123, 100000000000)]
+        self.cog.unsilence_timestamps.items.return_value = [(123, -1), (123, 1), (123, 100000000000)]
         self.bot.get_channel.return_value = None
 
         await self.cog._reschedule()
@@ -168,7 +168,7 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
         """Permanently silenced channels were added to the notifier."""
         channels = [MockTextChannel(id=123), MockTextChannel(id=456)]
         self.bot.get_channel.side_effect = channels
-        self.cog.muted_channel_times.items.return_value = [(123, -1), (456, -1)]
+        self.cog.unsilence_timestamps.items.return_value = [(123, -1), (456, -1)]
 
         await self.cog._reschedule()
 
@@ -182,7 +182,7 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
         """Unsilenced expired silences."""
         channels = [MockTextChannel(id=123), MockTextChannel(id=456)]
         self.bot.get_channel.side_effect = channels
-        self.cog.muted_channel_times.items.return_value = [(123, 100), (456, 200)]
+        self.cog.unsilence_timestamps.items.return_value = [(123, 100), (456, 200)]
 
         await self.cog._reschedule()
 
@@ -197,7 +197,7 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
         """Rescheduled active silences."""
         channels = [MockTextChannel(id=123), MockTextChannel(id=456)]
         self.bot.get_channel.side_effect = channels
-        self.cog.muted_channel_times.items.return_value = [(123, 2000), (456, 3000)]
+        self.cog.unsilence_timestamps.items.return_value = [(123, 2000), (456, 3000)]
         silence.datetime.now.return_value = datetime.fromtimestamp(1000, tz=timezone.utc)
 
         self.cog._unsilence_wrapper = mock.MagicMock()
@@ -215,7 +215,7 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
         self.cog.notifier.add_channel.assert_not_called()
 
 
-@autospec(silence.Silence, "muted_channel_perms", "muted_channel_times", pass_mocks=False)
+@autospec(silence.Silence, "previous_overwrites", "unsilence_timestamps", pass_mocks=False)
 class SilenceTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the silence command and its related helper methods."""
 
@@ -304,7 +304,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         """Channel's previous overwrites were cached."""
         overwrite_json = '{"send_messages": true, "add_reactions": false}'
         await self.cog._silence(self.channel, False, None)
-        self.cog.muted_channel_perms.set.assert_called_once_with(self.channel.id, overwrite_json)
+        self.cog.previous_overwrites.set.assert_called_once_with(self.channel.id, overwrite_json)
 
     @autospec(silence, "datetime")
     async def test_cached_unsilence_time(self, datetime_mock):
@@ -317,14 +317,14 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         ctx = MockContext(channel=self.channel)
         await self.cog.silence.callback(self.cog, ctx, duration)
 
-        self.cog.muted_channel_times.set.assert_awaited_once_with(ctx.channel.id, timestamp)
+        self.cog.unsilence_timestamps.set.assert_awaited_once_with(ctx.channel.id, timestamp)
         datetime_mock.now.assert_called_once_with(tz=timezone.utc)  # Ensure it's using an aware dt.
 
     async def test_cached_indefinite_time(self):
         """A value of -1 was cached for a permanent silence."""
         ctx = MockContext(channel=self.channel)
         await self.cog.silence.callback(self.cog, ctx, None)
-        self.cog.muted_channel_times.set.assert_awaited_once_with(ctx.channel.id, -1)
+        self.cog.unsilence_timestamps.set.assert_awaited_once_with(ctx.channel.id, -1)
 
     async def test_scheduled_task(self):
         """An unsilence task was scheduled."""
@@ -343,7 +343,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.cog.scheduler.schedule_later.assert_not_called()
 
 
-@autospec(silence.Silence, "muted_channel_times", pass_mocks=False)
+@autospec(silence.Silence, "unsilence_timestamps", pass_mocks=False)
 class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the unsilence command and its related helper methods."""
 
@@ -355,13 +355,13 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         self.cog._init_task = asyncio.Future()
         self.cog._init_task.set_result(None)
 
-        perms_cache = mock.create_autospec(self.cog.muted_channel_perms, spec_set=True)
-        self.cog.muted_channel_perms = perms_cache
+        overwrites_cache = mock.create_autospec(self.cog.previous_overwrites, spec_set=True)
+        self.cog.previous_overwrites = overwrites_cache
 
         asyncio.run(self.cog._init_cog())  # Populate instance attributes.
 
         self.cog.scheduler.__contains__.return_value = True
-        perms_cache.get.return_value = '{"send_messages": true, "add_reactions": false}'
+        overwrites_cache.get.return_value = '{"send_messages": true, "add_reactions": false}'
         self.channel = MockTextChannel()
         self.overwrite = PermissionOverwrite(stream=True, send_messages=False, add_reactions=False)
         self.channel.overwrites_for.return_value = self.overwrite
@@ -385,7 +385,7 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_skipped_already_unsilenced(self):
         """Permissions were not set and `False` was returned for an already unsilenced channel."""
         self.cog.scheduler.__contains__.return_value = False
-        self.cog.muted_channel_perms.get.return_value = None
+        self.cog.previous_overwrites.get.return_value = None
         channel = MockTextChannel()
 
         self.assertFalse(await self.cog._unsilence(channel))
@@ -405,7 +405,7 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_cache_miss_used_default_overwrites(self):
         """Both overwrites were set to None due previous values not being found in the cache."""
-        self.cog.muted_channel_perms.get.return_value = None
+        self.cog.previous_overwrites.get.return_value = None
 
         await self.cog._unsilence(self.channel)
         self.channel.set_permissions.assert_awaited_once_with(
@@ -418,7 +418,7 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_cache_miss_sent_mod_alert(self):
         """A message was sent to the mod alerts channel."""
-        self.cog.muted_channel_perms.get.return_value = None
+        self.cog.previous_overwrites.get.return_value = None
 
         await self.cog._unsilence(self.channel)
         self.cog._mod_alerts_channel.send.assert_awaited_once()
@@ -431,12 +431,12 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_deleted_cached_overwrite(self):
         """Channel was deleted from the overwrites cache."""
         await self.cog._unsilence(self.channel)
-        self.cog.muted_channel_perms.delete.assert_awaited_once_with(self.channel.id)
+        self.cog.previous_overwrites.delete.assert_awaited_once_with(self.channel.id)
 
     async def test_deleted_cached_time(self):
         """Channel was deleted from the timestamp cache."""
         await self.cog._unsilence(self.channel)
-        self.cog.muted_channel_times.delete.assert_awaited_once_with(self.channel.id)
+        self.cog.unsilence_timestamps.delete.assert_awaited_once_with(self.channel.id)
 
     async def test_cancelled_task(self):
         """The scheduled unsilence task should be cancelled."""
@@ -447,7 +447,7 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         """Channel's other unrelated overwrites were not changed, including cache misses."""
         for overwrite_json in ('{"send_messages": true, "add_reactions": null}', None):
             with self.subTest(overwrite_json=overwrite_json):
-                self.cog.muted_channel_perms.get.return_value = overwrite_json
+                self.cog.previous_overwrites.get.return_value = overwrite_json
 
                 prev_overwrite_dict = dict(self.overwrite)
                 await self.cog._unsilence(self.channel)
-- 
cgit v1.2.3


From 2fd2c77035e87dde009c39aa7345e4871d5b41df Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 18 Aug 2020 15:02:13 -0700
Subject: Silence: cancel init task when cog unloads

---
 bot/cogs/moderation/silence.py            | 9 +++++++--
 tests/bot/cogs/moderation/test_silence.py | 7 +++++--
 2 files changed, 12 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/bot/cogs/moderation/silence.py b/bot/cogs/moderation/silence.py
index 5851be00a..c339fd4d0 100644
--- a/bot/cogs/moderation/silence.py
+++ b/bot/cogs/moderation/silence.py
@@ -231,8 +231,13 @@ class Silence(commands.Cog):
                 self.scheduler.schedule_later(delta, channel_id, self._unsilence_wrapper(channel))
 
     def cog_unload(self) -> None:
-        """Cancel scheduled tasks."""
-        self.scheduler.cancel_all()
+        """Cancel the init task and scheduled tasks."""
+        # It's important to wait for _init_task (specifically for _reschedule) to be cancelled
+        # before cancelling scheduled tasks. Otherwise, it's possible for _reschedule to schedule
+        # more tasks after cancel_all has finished, despite _init_task.cancel being called first.
+        # This is cause cancel() on its own doesn't block until the task is cancelled.
+        self._init_task.cancel()
+        self._init_task.add_done_callback(lambda _: self.scheduler.cancel_all)
 
     # This cannot be static (must have a __func__ attribute).
     def cog_check(self, ctx: Context) -> bool:
diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index a66d27d08..d56a731b6 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -127,9 +127,12 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         self.cog._reschedule.assert_awaited_once_with()
 
     def test_cog_unload_cancelled_tasks(self):
-        """All scheduled tasks were cancelled."""
+        """The init task was cancelled."""
+        self.cog._init_task = asyncio.Future()
         self.cog.cog_unload()
-        self.cog.scheduler.cancel_all.assert_called_once_with()
+
+        # It's too annoying to test cancel_all since it's a done callback and wrapped in a lambda.
+        self.assertTrue(self.cog._init_task.cancelled())
 
     @autospec(silence, "with_role_check")
     @mock.patch.object(silence, "MODERATION_ROLES", new=(1, 2, 3))
-- 
cgit v1.2.3


From cf2c03215ef340b9e093828de365563bb6be587a Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 6 Oct 2020 13:23:03 -0700
Subject: Silence: refactor _silence

* Rename to `_silence_overwrites`
* Reduce responsibilities to only setting permission overwrites
* Log in `silence` instead
* Add to notifier in `silence` instead
---
 bot/cogs/moderation/silence.py            | 27 ++++++++--------------
 tests/bot/cogs/moderation/test_silence.py | 38 ++++++++++++++++++-------------
 2 files changed, 32 insertions(+), 33 deletions(-)

(limited to 'tests')

diff --git a/bot/cogs/moderation/silence.py b/bot/cogs/moderation/silence.py
index 08d0328ab..12896022f 100644
--- a/bot/cogs/moderation/silence.py
+++ b/bot/cogs/moderation/silence.py
@@ -104,17 +104,23 @@ class Silence(commands.Cog):
         Indefinitely silenced channels get added to a notifier which posts notices every 15 minutes from the start.
         """
         await self._init_task
-        log.debug(f"{ctx.author} is silencing channel #{ctx.channel}.")
 
-        if not await self._silence(ctx.channel, persistent=(duration is None), duration=duration):
+        channel_info = f"#{ctx.channel} ({ctx.channel.id})"
+        log.debug(f"{ctx.author} is silencing channel {channel_info}.")
+
+        if not await self._silence_overwrites(ctx.channel):
+            log.info(f"Tried to silence channel {channel_info} but the channel was already silenced.")
             await ctx.send(MSG_SILENCE_FAIL)
             return
 
         await self._schedule_unsilence(ctx, duration)
 
         if duration is None:
+            log.info(f"Silenced {channel_info} indefinitely.")
             await ctx.send(MSG_SILENCE_PERMANENT)
         else:
+            self.notifier.add_channel(ctx.channel)
+            log.info(f"Silenced {channel_info} for {duration} minute(s).")
             await ctx.send(MSG_SILENCE_SUCCESS.format(duration=duration))
 
     @commands.command(aliases=("unhush",))
@@ -139,31 +145,18 @@ class Silence(commands.Cog):
         else:
             await channel.send(MSG_UNSILENCE_SUCCESS)
 
-    async def _silence(self, channel: TextChannel, persistent: bool, duration: Optional[int]) -> bool:
-        """
-        Silence `channel` for `self._verified_role`.
-
-        If `persistent` is `True` add `channel` to notifier.
-        `duration` is only used for logging; if None is passed `persistent` should be True to not log None.
-        Return `True` if channel permissions were changed, `False` otherwise.
-        """
+    async def _silence_overwrites(self, channel: TextChannel) -> bool:
+        """Set silence permission overwrites for `channel` and return True if successful."""
         overwrite = channel.overwrites_for(self._verified_role)
         prev_overwrites = dict(send_messages=overwrite.send_messages, add_reactions=overwrite.add_reactions)
 
         if channel.id in self.scheduler or all(val is False for val in prev_overwrites.values()):
-            log.info(f"Tried to silence channel #{channel} ({channel.id}) but the channel was already silenced.")
             return False
 
         overwrite.update(send_messages=False, add_reactions=False)
         await channel.set_permissions(self._verified_role, overwrite=overwrite)
         await self.previous_overwrites.set(channel.id, json.dumps(prev_overwrites))
 
-        if persistent:
-            log.info(f"Silenced #{channel} ({channel.id}) indefinitely.")
-            self.notifier.add_channel(channel)
-            return True
-
-        log.info(f"Silenced #{channel} ({channel.id}) for {duration} minute(s).")
         return True
 
     async def _schedule_unsilence(self, ctx: Context, duration: Optional[int]) -> None:
diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index d56a731b6..9dbdfd10a 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -245,8 +245,8 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         )
         for duration, message, was_silenced in test_cases:
             ctx = MockContext()
-            with self.subTest(was_silenced=was_silenced, message=message, duration=duration):
-                with mock.patch.object(self.cog, "_silence", return_value=was_silenced):
+            with mock.patch.object(self.cog, "_silence_overwrites", return_value=was_silenced):
+                with self.subTest(was_silenced=was_silenced, message=message, duration=duration):
                     await self.cog.silence.callback(self.cog, ctx, duration)
                     ctx.send.assert_called_once_with(message)
 
@@ -264,12 +264,12 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
                 channel = MockTextChannel()
                 channel.overwrites_for.return_value = overwrite
 
-                self.assertFalse(await self.cog._silence(channel, True, None))
+                self.assertFalse(await self.cog._silence_overwrites(channel))
                 channel.set_permissions.assert_not_called()
 
     async def test_silenced_channel(self):
         """Channel had `send_message` and `add_reactions` permissions revoked for verified role."""
-        self.assertTrue(await self.cog._silence(self.channel, False, None))
+        self.assertTrue(await self.cog._silence_overwrites(self.channel))
         self.assertFalse(self.overwrite.send_messages)
         self.assertFalse(self.overwrite.add_reactions)
         self.channel.set_permissions.assert_awaited_once_with(
@@ -280,7 +280,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_preserved_other_overwrites(self):
         """Channel's other unrelated overwrites were not changed."""
         prev_overwrite_dict = dict(self.overwrite)
-        await self.cog._silence(self.channel, False, None)
+        await self.cog._silence_overwrites(self.channel)
         new_overwrite_dict = dict(self.overwrite)
 
         # Remove 'send_messages' & 'add_reactions' keys because they were changed by the method.
@@ -291,22 +291,28 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
 
-    async def test_added_removed_notifier(self):
-        """Channel was added to notifier if `persistent` was `True`, and removed if `False`."""
-        with mock.patch.object(self.cog, "notifier", create=True):
-            with self.subTest(persistent=True):
-                await self.cog._silence(self.channel, True, None)
-                self.cog.notifier.add_channel.assert_called_once()
+    async def test_temp_added_to_notifier(self):
+        """Channel was added to notifier if a duration was set for the silence."""
+        with mock.patch.object(self.cog, "_silence_overwrites", return_value=True):
+            await self.cog.silence.callback(self.cog, MockContext(), 15)
+            self.cog.notifier.add_channel.assert_called_once()
 
-        with mock.patch.object(self.cog, "notifier", create=True):
-            with self.subTest(persistent=False):
-                await self.cog._silence(self.channel, False, None)
-                self.cog.notifier.add_channel.assert_not_called()
+    async def test_indefinite_not_added_to_notifier(self):
+        """Channel was not added to notifier if a duration was not set for the silence."""
+        with mock.patch.object(self.cog, "_silence_overwrites", return_value=True):
+            await self.cog.silence.callback(self.cog, MockContext(), None)
+            self.cog.notifier.add_channel.assert_not_called()
+
+    async def test_silenced_not_added_to_notifier(self):
+        """Channel was not added to the notifier if it was already silenced."""
+        with mock.patch.object(self.cog, "_silence_overwrites", return_value=False):
+            await self.cog.silence.callback(self.cog, MockContext(), 15)
+            self.cog.notifier.add_channel.assert_not_called()
 
     async def test_cached_previous_overwrites(self):
         """Channel's previous overwrites were cached."""
         overwrite_json = '{"send_messages": true, "add_reactions": false}'
-        await self.cog._silence(self.channel, False, None)
+        await self.cog._silence_overwrites(self.channel)
         self.cog.previous_overwrites.set.assert_called_once_with(self.channel.id, overwrite_json)
 
     @autospec(silence, "datetime")
-- 
cgit v1.2.3


From f218c7b0a505416d44b177b0e863575db626d20c Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Tue, 6 Oct 2020 13:27:42 -0700
Subject: Silence: rename _init_cog to _async_init

---
 bot/cogs/moderation/silence.py            |  4 ++--
 tests/bot/cogs/moderation/test_silence.py | 26 +++++++++++++-------------
 2 files changed, 15 insertions(+), 15 deletions(-)

(limited to 'tests')

diff --git a/bot/cogs/moderation/silence.py b/bot/cogs/moderation/silence.py
index 12896022f..178dee06f 100644
--- a/bot/cogs/moderation/silence.py
+++ b/bot/cogs/moderation/silence.py
@@ -82,9 +82,9 @@ class Silence(commands.Cog):
         self.bot = bot
         self.scheduler = Scheduler(self.__class__.__name__)
 
-        self._init_task = self.bot.loop.create_task(self._init_cog())
+        self._init_task = self.bot.loop.create_task(self._async_init())
 
-    async def _init_cog(self) -> None:
+    async def _async_init(self) -> None:
         """Set instance attributes once the guild is available and reschedule unsilences."""
         await self.bot.wait_until_guild_available()
 
diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 9dbdfd10a..5588115ae 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -91,39 +91,39 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         self.cog = silence.Silence(self.bot)
 
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
-    async def test_init_cog_got_guild(self):
+    async def test_async_init_got_guild(self):
         """Bot got guild after it became available."""
-        await self.cog._init_cog()
+        await self.cog._async_init()
         self.bot.wait_until_guild_available.assert_awaited_once()
         self.bot.get_guild.assert_called_once_with(Guild.id)
 
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
-    async def test_init_cog_got_role(self):
+    async def test_async_init_got_role(self):
         """Got `Roles.verified` role from guild."""
-        await self.cog._init_cog()
+        await self.cog._async_init()
         guild = self.bot.get_guild()
         guild.get_role.assert_called_once_with(Roles.verified)
 
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
-    async def test_init_cog_got_channels(self):
+    async def test_async_init_got_channels(self):
         """Got channels from bot."""
-        await self.cog._init_cog()
+        await self.cog._async_init()
         self.bot.get_channel.called_once_with(Channels.mod_alerts)
         self.bot.get_channel.called_once_with(Channels.mod_log)
 
     @autospec(silence, "SilenceNotifier")
-    async def test_init_cog_got_notifier(self, notifier):
+    async def test_async_init_got_notifier(self, notifier):
         """Notifier was started with channel."""
         mod_log = MockTextChannel()
         self.bot.get_channel.side_effect = (None, mod_log)
-        await self.cog._init_cog()
+        await self.cog._async_init()
         notifier.assert_called_once_with(self.cog._mod_log_channel)
 
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
-    async def test_init_cog_rescheduled(self):
+    async def test_async_init_rescheduled(self):
         """`_reschedule_` coroutine was awaited."""
         self.cog._reschedule = mock.create_autospec(self.cog._reschedule)
-        await self.cog._init_cog()
+        await self.cog._async_init()
         self.cog._reschedule.assert_awaited_once_with()
 
     def test_cog_unload_cancelled_tasks(self):
@@ -154,7 +154,7 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
         self.cog._unsilence_wrapper = mock.create_autospec(self.cog._unsilence_wrapper)
 
         with mock.patch.object(self.cog, "_reschedule", autospec=True):
-            asyncio.run(self.cog._init_cog())  # Populate instance attributes.
+            asyncio.run(self.cog._async_init())  # Populate instance attributes.
 
     async def test_skipped_missing_channel(self):
         """Did nothing because the channel couldn't be retrieved."""
@@ -230,7 +230,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.cog._init_task = asyncio.Future()
         self.cog._init_task.set_result(None)
 
-        asyncio.run(self.cog._init_cog())  # Populate instance attributes.
+        asyncio.run(self.cog._async_init())  # Populate instance attributes.
 
         self.channel = MockTextChannel()
         self.overwrite = PermissionOverwrite(stream=True, send_messages=True, add_reactions=False)
@@ -367,7 +367,7 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         overwrites_cache = mock.create_autospec(self.cog.previous_overwrites, spec_set=True)
         self.cog.previous_overwrites = overwrites_cache
 
-        asyncio.run(self.cog._init_cog())  # Populate instance attributes.
+        asyncio.run(self.cog._async_init())  # Populate instance attributes.
 
         self.cog.scheduler.__contains__.return_value = True
         overwrites_cache.get.return_value = '{"send_messages": true, "add_reactions": false}'
-- 
cgit v1.2.3


From 46bdcdf9414786f1432b4937590a0448122e6f34 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Wed, 7 Oct 2020 15:13:01 -0700
Subject: Silence tests: fix unawaited coro warnings

Because the Scheduler is mocked, it doesn't actually do anything with
the coroutines passed to the schedule() functions, hence the warnings.
---
 tests/bot/cogs/moderation/test_silence.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 5588115ae..6a8db72e8 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -68,7 +68,9 @@ class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
             with self.subTest(current_loop=current_loop):
                 with mock.patch.object(self.notifier, "_current_loop", new=current_loop):
                     await self.notifier._notifier()
-                self.alert_channel.send.assert_called_once_with(f"<@&{Roles.moderators}> currently silenced channels: ")
+                self.alert_channel.send.assert_called_once_with(
+                    f"<@&{Roles.moderators}> currently silenced channels: "
+                )
             self.alert_channel.send.reset_mock()
 
     async def test_notifier_skips_alert(self):
@@ -158,7 +160,7 @@ class RescheduleTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_skipped_missing_channel(self):
         """Did nothing because the channel couldn't be retrieved."""
-        self.cog.unsilence_timestamps.items.return_value = [(123, -1), (123, 1), (123, 100000000000)]
+        self.cog.unsilence_timestamps.items.return_value = [(123, -1), (123, 1), (123, 10000000000)]
         self.bot.get_channel.return_value = None
 
         await self.cog._reschedule()
@@ -230,6 +232,9 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.cog._init_task = asyncio.Future()
         self.cog._init_task.set_result(None)
 
+        # Avoid unawaited coroutine warnings.
+        self.cog.scheduler.schedule_later.side_effect = lambda delay, task_id, coro: coro.close()
+
         asyncio.run(self.cog._async_init())  # Populate instance attributes.
 
         self.channel = MockTextChannel()
-- 
cgit v1.2.3


From d0635ea328ed5bc659d77820752dedef3c19df0c Mon Sep 17 00:00:00 2001
From: mbaruh <mbaruh@hotmail.com>
Date: Thu, 8 Oct 2020 01:21:19 +0300
Subject: adjusted prepare_input docs and unittests

---
 bot/exts/utils/snekbox.py            | 8 +++++++-
 tests/bot/exts/utils/test_snekbox.py | 7 +++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

(limited to 'tests')

diff --git a/bot/exts/utils/snekbox.py b/bot/exts/utils/snekbox.py
index 77830209e..295c84901 100644
--- a/bot/exts/utils/snekbox.py
+++ b/bot/exts/utils/snekbox.py
@@ -74,7 +74,13 @@ class Snekbox(Cog):
 
     @staticmethod
     def prepare_input(code: str) -> str:
-        """Extract code from the Markdown, format it, and insert it into the code template."""
+        """
+        Extract code from the Markdown, format it, and insert it into the code template.
+
+        If there is Markdown, ignores surrounding text.
+        If there are several Markdown parts in the message, concatenates only the code blocks.
+        If there is inline code but no code blocks, takes the first instance of inline code.
+        """
         if match := list(FORMATTED_CODE_REGEX.finditer(code)):
             blocks = [block for block in match if block.group("block")]
 
diff --git a/tests/bot/exts/utils/test_snekbox.py b/tests/bot/exts/utils/test_snekbox.py
index 6601fad2c..9a42d0610 100644
--- a/tests/bot/exts/utils/test_snekbox.py
+++ b/tests/bot/exts/utils/test_snekbox.py
@@ -52,6 +52,13 @@ class SnekboxTests(unittest.IsolatedAsyncioTestCase):
             ('`print("Hello world!")`', 'print("Hello world!")', 'one line code block'),
             ('```\nprint("Hello world!")```', 'print("Hello world!")', 'multiline code block'),
             ('```py\nprint("Hello world!")```', 'print("Hello world!")', 'multiline python code block'),
+            ('text```print("Hello world!")```text', 'print("Hello world!")', 'code block surrounded by text'),
+            ('```print("Hello world!")```\ntext\n```py\nprint("Hello world!")```',
+             'print("Hello world!")\nprint("Hello world!")', 'two code blocks with text in-between'),
+            ('`print("Hello world!")`\ntext\n```print("How\'s it going?")```',
+             'print("How\'s it going?")', 'code block preceded by inline code'),
+            ('`print("Hello world!")`\ntext\n`print("Hello world!")`',
+             'print("Hello world!")', 'one inline code block of two')
         )
         for case, expected, testname in cases:
             with self.subTest(msg=f'Extract code from {testname}.'):
-- 
cgit v1.2.3


From d0c3990e8eb9e68537c05ec58594abdf5c4cee9e Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 8 Oct 2020 12:25:41 -0700
Subject: Silence: add to notifier when indefinite rather than temporary

Accidentally swapped the logic in a previous commit during a refactor.
---
 bot/cogs/moderation/silence.py            |  2 +-
 tests/bot/cogs/moderation/test_silence.py | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'tests')

diff --git a/bot/cogs/moderation/silence.py b/bot/cogs/moderation/silence.py
index 178dee06f..95706392a 100644
--- a/bot/cogs/moderation/silence.py
+++ b/bot/cogs/moderation/silence.py
@@ -116,10 +116,10 @@ class Silence(commands.Cog):
         await self._schedule_unsilence(ctx, duration)
 
         if duration is None:
+            self.notifier.add_channel(ctx.channel)
             log.info(f"Silenced {channel_info} indefinitely.")
             await ctx.send(MSG_SILENCE_PERMANENT)
         else:
-            self.notifier.add_channel(ctx.channel)
             log.info(f"Silenced {channel_info} for {duration} minute(s).")
             await ctx.send(MSG_SILENCE_SUCCESS.format(duration=duration))
 
diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 6a8db72e8..50d8419ac 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -296,17 +296,17 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertDictEqual(prev_overwrite_dict, new_overwrite_dict)
 
-    async def test_temp_added_to_notifier(self):
-        """Channel was added to notifier if a duration was set for the silence."""
+    async def test_temp_not_added_to_notifier(self):
+        """Channel was not added to notifier if a duration was set for the silence."""
         with mock.patch.object(self.cog, "_silence_overwrites", return_value=True):
             await self.cog.silence.callback(self.cog, MockContext(), 15)
-            self.cog.notifier.add_channel.assert_called_once()
+            self.cog.notifier.add_channel.assert_not_called()
 
-    async def test_indefinite_not_added_to_notifier(self):
-        """Channel was not added to notifier if a duration was not set for the silence."""
+    async def test_indefinite_added_to_notifier(self):
+        """Channel was added to notifier if a duration was not set for the silence."""
         with mock.patch.object(self.cog, "_silence_overwrites", return_value=True):
             await self.cog.silence.callback(self.cog, MockContext(), None)
-            self.cog.notifier.add_channel.assert_not_called()
+            self.cog.notifier.add_channel.assert_called_once()
 
     async def test_silenced_not_added_to_notifier(self):
         """Channel was not added to the notifier if it was already silenced."""
-- 
cgit v1.2.3


From 5b87a272ff21df9fa4fb59fdf9ec92c6b57193c6 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 8 Oct 2020 13:22:54 -0700
Subject: Silence: remove _mod_log_channel attribute

It's only used as an argument to `SilenceNotifier`, so it doesn't need
to be an instance attribute.
---
 bot/cogs/moderation/silence.py            | 3 +--
 tests/bot/cogs/moderation/test_silence.py | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/bot/cogs/moderation/silence.py b/bot/cogs/moderation/silence.py
index 95706392a..80c4e6a25 100644
--- a/bot/cogs/moderation/silence.py
+++ b/bot/cogs/moderation/silence.py
@@ -91,8 +91,7 @@ class Silence(commands.Cog):
         guild = self.bot.get_guild(Guild.id)
         self._verified_role = guild.get_role(Roles.verified)
         self._mod_alerts_channel = self.bot.get_channel(Channels.mod_alerts)
-        self._mod_log_channel = self.bot.get_channel(Channels.mod_log)
-        self.notifier = SilenceNotifier(self._mod_log_channel)
+        self.notifier = SilenceNotifier(self.bot.get_channel(Channels.mod_log))
         await self._reschedule()
 
     @commands.command(aliases=("hush",))
diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 50d8419ac..6f8f4386b 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -119,7 +119,7 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         mod_log = MockTextChannel()
         self.bot.get_channel.side_effect = (None, mod_log)
         await self.cog._async_init()
-        notifier.assert_called_once_with(self.cog._mod_log_channel)
+        notifier.assert_called_once_with(mod_log)
 
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_async_init_rescheduled(self):
-- 
cgit v1.2.3


From e85a4d254cadd303537a4d2cce6637bbcd3cf2f9 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Thu, 8 Oct 2020 13:23:35 -0700
Subject: Silence tests: make _async_init attribute tests more robust

---
 tests/bot/cogs/moderation/test_silence.py | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/moderation/test_silence.py b/tests/bot/cogs/moderation/test_silence.py
index 6f8f4386b..3e1b963b0 100644
--- a/tests/bot/cogs/moderation/test_silence.py
+++ b/tests/bot/cogs/moderation/test_silence.py
@@ -102,24 +102,28 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_async_init_got_role(self):
         """Got `Roles.verified` role from guild."""
-        await self.cog._async_init()
         guild = self.bot.get_guild()
-        guild.get_role.assert_called_once_with(Roles.verified)
+        guild.get_role.side_effect = lambda id_: Mock(id=id_)
+
+        await self.cog._async_init()
+        self.assertEqual(self.cog._verified_role.id, Roles.verified)
 
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_async_init_got_channels(self):
         """Got channels from bot."""
+        self.bot.get_channel.side_effect = lambda id_: MockTextChannel(id=id_)
+
         await self.cog._async_init()
-        self.bot.get_channel.called_once_with(Channels.mod_alerts)
-        self.bot.get_channel.called_once_with(Channels.mod_log)
+        self.assertEqual(self.cog._mod_alerts_channel.id, Channels.mod_alerts)
 
     @autospec(silence, "SilenceNotifier")
     async def test_async_init_got_notifier(self, notifier):
         """Notifier was started with channel."""
-        mod_log = MockTextChannel()
-        self.bot.get_channel.side_effect = (None, mod_log)
+        self.bot.get_channel.side_effect = lambda id_: MockTextChannel(id=id_)
+
         await self.cog._async_init()
-        notifier.assert_called_once_with(mod_log)
+        notifier.assert_called_once_with(MockTextChannel(id=Channels.mod_log))
+        self.assertEqual(self.cog.notifier, notifier.return_value)
 
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_async_init_rescheduled(self):
-- 
cgit v1.2.3


From bfab4928e5b219660f76e2516c4ec0bb67fcba89 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 9 Oct 2020 18:26:03 -0700
Subject: Silence: require only 1 permission to be False for a manual unsilence

Previously, both sending messages and adding reactions had to be false
in order for the manual unsilence failure message to be sent. Because
staff may only set one of these manually, the message should be sent
if at least one of the permissions is set.
---
 bot/exts/moderation/silence.py            | 2 +-
 tests/bot/exts/moderation/test_silence.py | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

(limited to 'tests')

diff --git a/bot/exts/moderation/silence.py b/bot/exts/moderation/silence.py
index bb8e06924..ee2c0dc7c 100644
--- a/bot/exts/moderation/silence.py
+++ b/bot/exts/moderation/silence.py
@@ -136,7 +136,7 @@ class Silence(commands.Cog):
         """Unsilence `channel` and send a success/failure message."""
         if not await self._unsilence(channel):
             overwrite = channel.overwrites_for(self._verified_role)
-            if overwrite.send_messages is False and overwrite.add_reactions is False:
+            if overwrite.send_messages is False or overwrite.add_reactions is False:
                 await channel.send(MSG_UNSILENCE_MANUAL)
             else:
                 await channel.send(MSG_UNSILENCE_FAIL)
diff --git a/tests/bot/exts/moderation/test_silence.py b/tests/bot/exts/moderation/test_silence.py
index 39e32fdb2..6d5ffa7e8 100644
--- a/tests/bot/exts/moderation/test_silence.py
+++ b/tests/bot/exts/moderation/test_silence.py
@@ -411,6 +411,8 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
             (True, silence.MSG_UNSILENCE_SUCCESS, unsilenced_overwrite),
             (False, silence.MSG_UNSILENCE_FAIL, unsilenced_overwrite),
             (False, silence.MSG_UNSILENCE_MANUAL, self.overwrite),
+            (False, silence.MSG_UNSILENCE_MANUAL, PermissionOverwrite(send_messages=False)),
+            (False, silence.MSG_UNSILENCE_MANUAL, PermissionOverwrite(add_reactions=False)),
         )
         for was_unsilenced, message, overwrite in test_cases:
             ctx = MockContext()
-- 
cgit v1.2.3


From 4d967cd27d049bffc2585d2cc8f381f44f59ca61 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 13:04:35 +0300
Subject: Create test for permanent voice ban

---
 .../bot/exts/moderation/infraction/test_infractions.py  | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index be1b649e1..27f346648 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -53,3 +53,20 @@ class TruncationTests(unittest.IsolatedAsyncioTestCase):
         self.cog.apply_infraction.assert_awaited_once_with(
             self.ctx, {"foo": "bar"}, self.target, self.target.kick.return_value
         )
+
+
+class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
+    """Tests for voice ban related functions and commands."""
+
+    def setUp(self):
+        self.bot = MockBot()
+        self.mod = MockMember()
+        self.user = MockMember()
+        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."""
+        self.cog.apply_voice_ban = AsyncMock()
+        self.assertIsNone(await self.cog.voice_ban(self.cog, self.ctx, self.user, reason="foobar"))
+        self.cog.apply_voice_ban.assert_awaited_once_with(self.ctx, self.user, "foobar")
-- 
cgit v1.2.3


From b792af63022bf8e435210c9efefccc664c3bbf80 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 13:08:27 +0300
Subject: Create test for temporary voice ban

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 27f346648..814959775 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -66,7 +66,13 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.cog = Infractions(self.bot)
 
     async def test_permanent_voice_ban(self):
-        """Should call voice ban applying function."""
+        """Should call voice ban applying function without expiry."""
         self.cog.apply_voice_ban = AsyncMock()
         self.assertIsNone(await self.cog.voice_ban(self.cog, self.ctx, self.user, reason="foobar"))
         self.cog.apply_voice_ban.assert_awaited_once_with(self.ctx, self.user, "foobar")
+
+    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")
-- 
cgit v1.2.3


From 2b701b05b55d6c62c27497d39b142370693ef88d Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 13:13:23 +0300
Subject: Create test for voice unban

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 814959775..02062932e 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -76,3 +76,9 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         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_voice_unban(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)
-- 
cgit v1.2.3


From 8faa82f7d7de795b4a8e2fc7a6dc919994258d6c Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 14:00:09 +0300
Subject: Create test for case when trying to voice ban user who haven't passed
 gate

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 02062932e..b2b617e51 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -60,8 +60,8 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
     def setUp(self):
         self.bot = MockBot()
-        self.mod = MockMember()
-        self.user = MockMember()
+        self.mod = MockMember(top_role=10)
+        self.user = MockMember(top_role=1)
         self.ctx = MockContext(bot=self.bot, author=self.mod)
         self.cog = Infractions(self.bot)
 
@@ -82,3 +82,12 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         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)
+
+    @patch("bot.exts.moderation.infraction.infractions.constants.Roles.voice_verified", new=123456)
+    @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
+    async def test_voice_ban_not_having_voice_verified_role(self, get_active_infraction_mock):
+        """Should send message and not apply infraction when user don't have voice verified role."""
+        self.user.roles = [MockRole(id=987)]
+        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
+        self.ctx.send.assert_awaited_once()
+        get_active_infraction_mock.assert_not_awaited()
-- 
cgit v1.2.3


From b7a072c1c43ad5b0779c1e979a1870c002cfd5c3 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 14:05:42 +0300
Subject: Create test for case when user already have active Voice Ban

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index b2b617e51..510f31db3 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -55,13 +55,14 @@ 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."""
 
     def setUp(self):
         self.bot = MockBot()
         self.mod = MockMember(top_role=10)
-        self.user = MockMember(top_role=1)
+        self.user = MockMember(top_role=1, roles=[MockRole(id=123456)])
         self.ctx = MockContext(bot=self.bot, author=self.mod)
         self.cog = Infractions(self.bot)
 
@@ -83,7 +84,6 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         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)
 
-    @patch("bot.exts.moderation.infraction.infractions.constants.Roles.voice_verified", new=123456)
     @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
     async def test_voice_ban_not_having_voice_verified_role(self, get_active_infraction_mock):
         """Should send message and not apply infraction when user don't have voice verified role."""
@@ -91,3 +91,12 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
         self.ctx.send.assert_awaited_once()
         get_active_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_user_have_active_infraction(self, get_active_infraction, post_infraction_mock):
+        """Should return early when user already have Voice Ban 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()
+        post_infraction_mock.assert_not_awaited()
-- 
cgit v1.2.3


From c719169bffcca8898ced04c1fed0264a5b9cd7f6 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 14:11:36 +0300
Subject: Create test for case when posting infraction fails

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 510f31db3..1c3294b39 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -1,6 +1,6 @@
 import textwrap
 import unittest
-from unittest.mock import AsyncMock, Mock, patch
+from unittest.mock import AsyncMock, Mock, patch, MagicMock
 
 from bot.exts.moderation.infraction.infractions import Infractions
 from tests.helpers import MockBot, MockContext, MockGuild, MockMember, MockRole
@@ -100,3 +100,14 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
         get_active_infraction.assert_awaited_once()
         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):
+        """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"))
+        post_infraction_mock.assert_awaited_once()
+        self.cog.mod_log.ignore.assert_not_called()
-- 
cgit v1.2.3


From 2a6f86b87aa7bc19a26df739111a678f8fa03083 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 14:15:16 +0300
Subject: Create test to check does this pass proper kwargs to infraction
 posting

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 1c3294b39..ebb39320a 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -111,3 +111,15 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.assertIsNone(await self.cog.apply_voice_ban(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."""
+        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))
+        post_infraction_mock.assert_awaited_once_with(
+            self.ctx, self.user, "voice_ban", "foobar", active=True, my_kwarg=23
+        )
-- 
cgit v1.2.3


From 06343b5b24aa2b5e9d7d34e39ff604ec4577bcd8 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 14:16:33 +0300
Subject: Check arguments for get_active_infraction in voice ban tests

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index ebb39320a..37848e9e8 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -98,7 +98,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         """Should return early when user already have Voice Ban 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()
+        get_active_infraction.assert_awaited_once_with(self.ctx, self.user, "voice_ban")
         post_infraction_mock.assert_not_awaited()
 
     @patch("bot.exts.moderation.infraction.infractions._utils.post_infraction")
-- 
cgit v1.2.3


From a4036476bca02cf645c459510c3866c6442020c7 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 14:22:37 +0300
Subject: Create test for voice ban applying role remove ignore.

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 37848e9e8..d4fb2b119 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -2,6 +2,7 @@ import textwrap
 import unittest
 from unittest.mock import AsyncMock, Mock, patch, MagicMock
 
+from bot.constants import Event
 from bot.exts.moderation.infraction.infractions import Infractions
 from tests.helpers import MockBot, MockContext, MockGuild, MockMember, MockRole
 
@@ -123,3 +124,17 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         post_infraction_mock.assert_awaited_once_with(
             self.ctx, self.user, "voice_ban", "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):
+        """Should ignore Voice Verified role removing."""
+        self.cog.mod_log.ignore = MagicMock()
+        self.cog.apply_infraction = AsyncMock()
+        self.user.remove_roles = MagicMock(return_value="my_return_value")
+
+        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.cog.mod_log.ignore.assert_called_once_with(Event.member_update, self.user.id)
-- 
cgit v1.2.3


From d9d3b1a3615f347958cd8e194323b0c9b13d6a35 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 14:26:40 +0300
Subject: Add Voice Ban test about calling apply_infraction

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index d4fb2b119..1f4a3e7f0 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -138,3 +138,18 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
 
         self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
         self.cog.mod_log.ignore.assert_called_once_with(Event.member_update, self.user.id)
+
+    @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):
+        """Should ignore Voice Verified role removing."""
+        self.cog.mod_log.ignore = MagicMock()
+        self.cog.apply_infraction = AsyncMock()
+        self.user.remove_roles = MagicMock(return_value="my_return_value")
+
+        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.user.remove_roles.assert_called_once_with(self.cog._voice_verified_role, reason="foobar")
+        self.cog.apply_infraction.assert_awaited_once_with(self.ctx, {"foo": "bar"}, self.user, "my_return_value")
-- 
cgit v1.2.3


From fda0359abfe8644cc2a9452c19713395dec16dab Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 14:41:51 +0300
Subject: Shorten voice ban reason and create test for it

---
 bot/exts/moderation/infraction/infractions.py           |  3 +++
 .../bot/exts/moderation/infraction/test_infractions.py  | 17 +++++++++++++++++
 2 files changed, 20 insertions(+)

(limited to 'tests')

diff --git a/bot/exts/moderation/infraction/infractions.py b/bot/exts/moderation/infraction/infractions.py
index 2157c040c..0dab3a72e 100644
--- a/bot/exts/moderation/infraction/infractions.py
+++ b/bot/exts/moderation/infraction/infractions.py
@@ -372,6 +372,9 @@ class Infractions(InfractionScheduler, commands.Cog):
 
         self.mod_log.ignore(Event.member_update, user.id)
 
+        if reason:
+            reason = textwrap.shorten(reason, width=512, placeholder="...")
+
         action = user.remove_roles(self._voice_verified_role, reason=reason)
         await self.apply_infraction(ctx, infraction, user, action)
 
diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 1f4a3e7f0..a6ebe2162 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -153,3 +153,20 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
         self.user.remove_roles.assert_called_once_with(self.cog._voice_verified_role, reason="foobar")
         self.cog.apply_infraction.assert_awaited_once_with(self.ctx, {"foo": "bar"}, self.user, "my_return_value")
+
+    @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."""
+        self.cog.mod_log.ignore = MagicMock()
+        self.cog.apply_infraction = AsyncMock()
+        self.user.remove_roles = MagicMock(return_value="my_return_value")
+
+        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.user.remove_roles.assert_called_once_with(
+            self.cog._voice_verified_role, reason=textwrap.shorten("foobar" * 3000, 512, placeholder="...")
+        )
+        self.cog.apply_infraction.assert_awaited_once_with(self.ctx, {"foo": "bar"}, self.user, "my_return_value")
-- 
cgit v1.2.3


From b8855bced0913f087d25d571fe9a5ccf7f5e1727 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 14:53:33 +0300
Subject: Create test for voice ban pardon when user not found

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index a6ebe2162..ae8c1d35e 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -64,6 +64,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         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)
 
@@ -170,3 +171,9 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
             self.cog._voice_verified_role, reason=textwrap.shorten("foobar" * 3000, 512, placeholder="...")
         )
         self.cog.apply_infraction.assert_awaited_once_with(self.ctx, {"foo": "bar"}, self.user, "my_return_value")
+
+    async def test_voice_unban_user_not_found(self):
+        """Should include info to return dict when user was not found from guild."""
+        self.guild.get_member.return_value = None
+        result = await self.cog.pardon_voice_ban(self.user.id, self.guild, "foobar")
+        self.assertEqual(result, {"Failure": "User was not found in the guild."})
-- 
cgit v1.2.3


From 6e8e9fd8c3db4ac8a65bed65d2fa1ecbea1c98c5 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 15:02:27 +0300
Subject: Create base test for voice unban

---
 .../bot/exts/moderation/infraction/test_infractions.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index ae8c1d35e..9d4180902 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -177,3 +177,21 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.guild.get_member.return_value = None
         result = await self.cog.pardon_voice_ban(self.user.id, self.guild, "foobar")
         self.assertEqual(result, {"Failure": "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):
+        """Should add role back with ignoring, notify user and return log dictionary.."""
+        self.cog.mod_log.ignore = MagicMock()
+        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, "foobar")
+        self.assertEqual(result, {
+            "Member": "my-user",
+            "DM": "Sent"
+        })
+        self.cog.mod_log.ignore.assert_called_once_with(Event.member_update, self.user.id)
+        self.user.add_roles.assert_awaited_once_with(self.cog._voice_verified_role, reason="foobar")
+        notify_pardon_mock.assert_awaited_once()
-- 
cgit v1.2.3


From 339769d8c863b192e1b298e211d1ab0261d1b26f Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 15:04:35 +0300
Subject: Create test for voice unban fail send DM

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 9d4180902..b60c203a1 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -195,3 +195,18 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         self.cog.mod_log.ignore.assert_called_once_with(Event.member_update, self.user.id)
         self.user.add_roles.assert_awaited_once_with(self.cog._voice_verified_role, reason="foobar")
         notify_pardon_mock.assert_awaited_once()
+
+    @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):
+        """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, "foobar")
+        self.assertEqual(result, {
+            "Member": "my-user",
+            "DM": "**Failed**"
+        })
+        notify_pardon_mock.assert_awaited_once()
-- 
cgit v1.2.3


From 0a4bed86d3826e611cd1675d54596a8dcedbe29a Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 11 Oct 2020 15:08:21 +0300
Subject: Fix linting for voice gate and voice ban

---
 bot/exts/moderation/voice_gate.py                        | 7 +++----
 tests/bot/exts/moderation/infraction/test_infractions.py | 2 +-
 2 files changed, 4 insertions(+), 5 deletions(-)

(limited to 'tests')

diff --git a/bot/exts/moderation/voice_gate.py b/bot/exts/moderation/voice_gate.py
index bd2afb464..8f2b51dbb 100644
--- a/bot/exts/moderation/voice_gate.py
+++ b/bot/exts/moderation/voice_gate.py
@@ -4,12 +4,11 @@ from datetime import datetime, timedelta
 
 import discord
 from dateutil import parser
-
 from discord.ext.commands import Cog, Context, command
 
 from bot.api import ResponseCodeError
 from bot.bot import Bot
-from bot.constants import Channels, Roles, VoiceGate as VoiceGateConf, MODERATION_ROLES, Event
+from bot.constants import Channels, Event, MODERATION_ROLES, Roles, VoiceGate as VoiceGateConf
 from bot.decorators import has_no_roles, in_whitelist
 from bot.exts.moderation.modlog import ModLog
 from bot.utils.checks import InWhitelistCheckFailure
@@ -55,7 +54,7 @@ class VoiceGate(Cog):
                 log.info(f"Unable to find Metricity data about {ctx.author} ({ctx.author.id})")
             else:
                 log.warning(f"Got response code {e.status} while trying to get {ctx.author.id} metricity data.")
-                await ctx.send(f":x: Got unexpected response from site. Please let us know about this.")
+                await ctx.send(":x: Got unexpected response from site. Please let us know about this.")
             return
 
         # Pre-parse this for better code style
@@ -115,7 +114,7 @@ class VoiceGate(Cog):
                 return
 
         # Then check is member moderator+, because we don't want to delete their messages.
-        if any(role.id in MODERATION_ROLES for role in message.author.roles) and is_verify_command == False:
+        if any(role.id in MODERATION_ROLES for role in message.author.roles) and is_verify_command is False:
             log.trace(f"Excluding moderator message {message.id} from deletion in #{message.channel}.")
             return
 
diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index b60c203a1..caa42ba3d 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -1,6 +1,6 @@
 import textwrap
 import unittest
-from unittest.mock import AsyncMock, Mock, patch, MagicMock
+from unittest.mock import AsyncMock, MagicMock, Mock, patch
 
 from bot.constants import Event
 from bot.exts.moderation.infraction.infractions import Infractions
-- 
cgit v1.2.3


From e059c32d10997e22b508c04031c19999f3185f7d Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 14:53:18 -0700
Subject: Use global bot instance in send_to_paste_service

---
 bot/exts/utils/internal.py           |  2 +-
 bot/exts/utils/snekbox.py            |  2 +-
 bot/utils/services.py                |  8 ++++----
 tests/bot/exts/utils/test_snekbox.py |  4 +---
 tests/bot/utils/test_services.py     | 39 +++++++++++++++++++-----------------
 5 files changed, 28 insertions(+), 27 deletions(-)

(limited to 'tests')

diff --git a/bot/exts/utils/internal.py b/bot/exts/utils/internal.py
index 1b4900f42..a6bc60026 100644
--- a/bot/exts/utils/internal.py
+++ b/bot/exts/utils/internal.py
@@ -195,7 +195,7 @@ async def func():  # (None,) -> Any
             truncate_index = newline_truncate_index
 
         if len(out) > truncate_index:
-            paste_link = await send_to_paste_service(self.bot.http_session, out, extension="py")
+            paste_link = await send_to_paste_service(out, extension="py")
             if paste_link is not None:
                 paste_text = f"full contents at {paste_link}"
             else:
diff --git a/bot/exts/utils/snekbox.py b/bot/exts/utils/snekbox.py
index 59a27a2be..e727be39e 100644
--- a/bot/exts/utils/snekbox.py
+++ b/bot/exts/utils/snekbox.py
@@ -72,7 +72,7 @@ class Snekbox(Cog):
         if len(output) > MAX_PASTE_LEN:
             log.info("Full output is too long to upload")
             return "too long to upload"
-        return await send_to_paste_service(self.bot.http_session, output, extension="txt")
+        return await send_to_paste_service(output, extension="txt")
 
     @staticmethod
     def prepare_input(code: str) -> str:
diff --git a/bot/utils/services.py b/bot/utils/services.py
index 087b9f969..5949c9e48 100644
--- a/bot/utils/services.py
+++ b/bot/utils/services.py
@@ -1,8 +1,9 @@
 import logging
 from typing import Optional
 
-from aiohttp import ClientConnectorError, ClientSession
+from aiohttp import ClientConnectorError
 
+import bot
 from bot.constants import URLs
 
 log = logging.getLogger(__name__)
@@ -10,11 +11,10 @@ log = logging.getLogger(__name__)
 FAILED_REQUEST_ATTEMPTS = 3
 
 
-async def send_to_paste_service(http_session: ClientSession, contents: str, *, extension: str = "") -> Optional[str]:
+async def send_to_paste_service(contents: str, *, extension: str = "") -> Optional[str]:
     """
     Upload `contents` to the paste service.
 
-    `http_session` should be the current running ClientSession from aiohttp
     `extension` is added to the output URL
 
     When an error occurs, `None` is returned, otherwise the generated URL with the suffix.
@@ -24,7 +24,7 @@ async def send_to_paste_service(http_session: ClientSession, contents: str, *, e
     paste_url = URLs.paste_service.format(key="documents")
     for attempt in range(1, FAILED_REQUEST_ATTEMPTS + 1):
         try:
-            async with http_session.post(paste_url, data=contents) as response:
+            async with bot.instance.http_session.post(paste_url, data=contents) as response:
                 response_json = await response.json()
         except ClientConnectorError:
             log.warning(
diff --git a/tests/bot/exts/utils/test_snekbox.py b/tests/bot/exts/utils/test_snekbox.py
index 6601fad2c..9d3e07e7c 100644
--- a/tests/bot/exts/utils/test_snekbox.py
+++ b/tests/bot/exts/utils/test_snekbox.py
@@ -42,9 +42,7 @@ class SnekboxTests(unittest.IsolatedAsyncioTestCase):
     async def test_upload_output(self, mock_paste_util):
         """Upload the eval output to the URLs.paste_service.format(key="documents") endpoint."""
         await self.cog.upload_output("Test output.")
-        mock_paste_util.assert_called_once_with(
-            self.bot.http_session, "Test output.", extension="txt"
-        )
+        mock_paste_util.assert_called_once_with("Test output.", extension="txt")
 
     def test_prepare_input(self):
         cases = (
diff --git a/tests/bot/utils/test_services.py b/tests/bot/utils/test_services.py
index 5e0855704..1b48f6560 100644
--- a/tests/bot/utils/test_services.py
+++ b/tests/bot/utils/test_services.py
@@ -5,11 +5,14 @@ from unittest.mock import AsyncMock, MagicMock, Mock, patch
 from aiohttp import ClientConnectorError
 
 from bot.utils.services import FAILED_REQUEST_ATTEMPTS, send_to_paste_service
+from tests.helpers import MockBot
 
 
 class PasteTests(unittest.IsolatedAsyncioTestCase):
     def setUp(self) -> None:
-        self.http_session = MagicMock()
+        patcher = patch("bot.instance", new=MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
 
     @patch("bot.utils.services.URLs.paste_service", "https://paste_service.com/{key}")
     async def test_url_and_sent_contents(self):
@@ -17,10 +20,10 @@ class PasteTests(unittest.IsolatedAsyncioTestCase):
         response = MagicMock(
             json=AsyncMock(return_value={"key": ""})
         )
-        self.http_session.post().__aenter__.return_value = response
-        self.http_session.post.reset_mock()
-        await send_to_paste_service(self.http_session, "Content")
-        self.http_session.post.assert_called_once_with("https://paste_service.com/documents", data="Content")
+        self.bot.http_session.post.return_value.__aenter__.return_value = response
+        self.bot.http_session.post.reset_mock()
+        await send_to_paste_service("Content")
+        self.bot.http_session.post.assert_called_once_with("https://paste_service.com/documents", data="Content")
 
     @patch("bot.utils.services.URLs.paste_service", "https://paste_service.com/{key}")
     async def test_paste_returns_correct_url_on_success(self):
@@ -34,41 +37,41 @@ class PasteTests(unittest.IsolatedAsyncioTestCase):
         response = MagicMock(
             json=AsyncMock(return_value={"key": key})
         )
-        self.http_session.post().__aenter__.return_value = response
+        self.bot.http_session.post.return_value.__aenter__.return_value = response
 
         for expected_output, extension in test_cases:
             with self.subTest(msg=f"Send contents with extension {repr(extension)}"):
                 self.assertEqual(
-                    await send_to_paste_service(self.http_session, "", extension=extension),
+                    await send_to_paste_service("", extension=extension),
                     expected_output
                 )
 
     async def test_request_repeated_on_json_errors(self):
         """Json with error message and invalid json are handled as errors and requests repeated."""
         test_cases = ({"message": "error"}, {"unexpected_key": None}, {})
-        self.http_session.post().__aenter__.return_value = response = MagicMock()
-        self.http_session.post.reset_mock()
+        self.bot.http_session.post.return_value.__aenter__.return_value = response = MagicMock()
+        self.bot.http_session.post.reset_mock()
 
         for error_json in test_cases:
             with self.subTest(error_json=error_json):
                 response.json = AsyncMock(return_value=error_json)
-                result = await send_to_paste_service(self.http_session, "")
-                self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+                result = await send_to_paste_service("")
+                self.assertEqual(self.bot.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
                 self.assertIsNone(result)
 
-            self.http_session.post.reset_mock()
+            self.bot.http_session.post.reset_mock()
 
     async def test_request_repeated_on_connection_errors(self):
         """Requests are repeated in the case of connection errors."""
-        self.http_session.post = MagicMock(side_effect=ClientConnectorError(Mock(), Mock()))
-        result = await send_to_paste_service(self.http_session, "")
-        self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+        self.bot.http_session.post = MagicMock(side_effect=ClientConnectorError(Mock(), Mock()))
+        result = await send_to_paste_service("")
+        self.assertEqual(self.bot.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
         self.assertIsNone(result)
 
     async def test_general_error_handled_and_request_repeated(self):
         """All `Exception`s are handled, logged and request repeated."""
-        self.http_session.post = MagicMock(side_effect=Exception)
-        result = await send_to_paste_service(self.http_session, "")
-        self.assertEqual(self.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
+        self.bot.http_session.post = MagicMock(side_effect=Exception)
+        result = await send_to_paste_service("")
+        self.assertEqual(self.bot.http_session.post.call_count, FAILED_REQUEST_ATTEMPTS)
         self.assertLogs("bot.utils", logging.ERROR)
         self.assertIsNone(result)
-- 
cgit v1.2.3


From f3f4b2acc2500e37ed7d1007c40a125b3442c5f0 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Fri, 16 Oct 2020 15:51:04 -0700
Subject: Use global bot instance in syncers

They're pretty close to being fully static classes, but it's difficult
to make the name attribute a static abstract property.
---
 bot/exts/backend/sync/_cog.py             |  4 +--
 bot/exts/backend/sync/_syncers.py         | 42 +++++++++++++++++--------------
 tests/bot/exts/backend/sync/test_base.py  | 12 ++++-----
 tests/bot/exts/backend/sync/test_cog.py   | 20 +++++++--------
 tests/bot/exts/backend/sync/test_roles.py | 14 ++++++++---
 tests/bot/exts/backend/sync/test_users.py | 15 ++++++++---
 6 files changed, 62 insertions(+), 45 deletions(-)

(limited to 'tests')

diff --git a/bot/exts/backend/sync/_cog.py b/bot/exts/backend/sync/_cog.py
index 6e85e2b7d..b71ed3e69 100644
--- a/bot/exts/backend/sync/_cog.py
+++ b/bot/exts/backend/sync/_cog.py
@@ -18,8 +18,8 @@ class Sync(Cog):
 
     def __init__(self, bot: Bot) -> None:
         self.bot = bot
-        self.role_syncer = _syncers.RoleSyncer(self.bot)
-        self.user_syncer = _syncers.UserSyncer(self.bot)
+        self.role_syncer = _syncers.RoleSyncer()
+        self.user_syncer = _syncers.UserSyncer()
 
         self.bot.loop.create_task(self.sync_guild())
 
diff --git a/bot/exts/backend/sync/_syncers.py b/bot/exts/backend/sync/_syncers.py
index 38468c2b1..bdd76806b 100644
--- a/bot/exts/backend/sync/_syncers.py
+++ b/bot/exts/backend/sync/_syncers.py
@@ -6,8 +6,8 @@ from collections import namedtuple
 from discord import Guild
 from discord.ext.commands import Context
 
+import bot
 from bot.api import ResponseCodeError
-from bot.bot import Bot
 
 log = logging.getLogger(__name__)
 
@@ -20,22 +20,21 @@ _Diff = namedtuple('Diff', ('created', 'updated', 'deleted'))
 class Syncer(abc.ABC):
     """Base class for synchronising the database with objects in the Discord cache."""
 
-    def __init__(self, bot: Bot) -> None:
-        self.bot = bot
-
     @property
     @abc.abstractmethod
     def name(self) -> str:
         """The name of the syncer; used in output messages and logging."""
         raise NotImplementedError  # pragma: no cover
 
+    @staticmethod
     @abc.abstractmethod
-    async def _get_diff(self, guild: Guild) -> _Diff:
+    async def _get_diff(guild: Guild) -> _Diff:
         """Return the difference between the cache of `guild` and the database."""
         raise NotImplementedError  # pragma: no cover
 
+    @staticmethod
     @abc.abstractmethod
-    async def _sync(self, diff: _Diff) -> None:
+    async def _sync(diff: _Diff) -> None:
         """Perform the API calls for synchronisation."""
         raise NotImplementedError  # pragma: no cover
 
@@ -78,10 +77,11 @@ class RoleSyncer(Syncer):
 
     name = "role"
 
-    async def _get_diff(self, guild: Guild) -> _Diff:
+    @staticmethod
+    async def _get_diff(guild: Guild) -> _Diff:
         """Return the difference of roles between the cache of `guild` and the database."""
         log.trace("Getting the diff for roles.")
-        roles = await self.bot.api_client.get('bot/roles')
+        roles = await bot.instance.api_client.get('bot/roles')
 
         # Pack DB roles and guild roles into one common, hashable format.
         # They're hashable so that they're easily comparable with sets later.
@@ -110,19 +110,20 @@ class RoleSyncer(Syncer):
 
         return _Diff(roles_to_create, roles_to_update, roles_to_delete)
 
-    async def _sync(self, diff: _Diff) -> None:
+    @staticmethod
+    async def _sync(diff: _Diff) -> None:
         """Synchronise the database with the role cache of `guild`."""
         log.trace("Syncing created roles...")
         for role in diff.created:
-            await self.bot.api_client.post('bot/roles', json=role._asdict())
+            await bot.instance.api_client.post('bot/roles', json=role._asdict())
 
         log.trace("Syncing updated roles...")
         for role in diff.updated:
-            await self.bot.api_client.put(f'bot/roles/{role.id}', json=role._asdict())
+            await bot.instance.api_client.put(f'bot/roles/{role.id}', json=role._asdict())
 
         log.trace("Syncing deleted roles...")
         for role in diff.deleted:
-            await self.bot.api_client.delete(f'bot/roles/{role.id}')
+            await bot.instance.api_client.delete(f'bot/roles/{role.id}')
 
 
 class UserSyncer(Syncer):
@@ -130,7 +131,8 @@ class UserSyncer(Syncer):
 
     name = "user"
 
-    async def _get_diff(self, guild: Guild) -> _Diff:
+    @staticmethod
+    async def _get_diff(guild: Guild) -> _Diff:
         """Return the difference of users between the cache of `guild` and the database."""
         log.trace("Getting the diff for users.")
 
@@ -138,7 +140,7 @@ class UserSyncer(Syncer):
         users_to_update = []
         seen_guild_users = set()
 
-        async for db_user in self._get_users():
+        async for db_user in UserSyncer._get_users():
             # Store user fields which are to be updated.
             updated_fields = {}
 
@@ -185,24 +187,26 @@ class UserSyncer(Syncer):
 
         return _Diff(users_to_create, users_to_update, None)
 
-    async def _get_users(self) -> t.AsyncIterable:
+    @staticmethod
+    async def _get_users() -> t.AsyncIterable:
         """GET users from database."""
         query_params = {
             "page": 1
         }
         while query_params["page"]:
-            res = await self.bot.api_client.get("bot/users", params=query_params)
+            res = await bot.instance.api_client.get("bot/users", params=query_params)
             for user in res["results"]:
                 yield user
 
             query_params["page"] = res["next_page_no"]
 
-    async def _sync(self, diff: _Diff) -> None:
+    @staticmethod
+    async def _sync(diff: _Diff) -> None:
         """Synchronise the database with the user cache of `guild`."""
         log.trace("Syncing created users...")
         if diff.created:
-            await self.bot.api_client.post("bot/users", json=diff.created)
+            await bot.instance.api_client.post("bot/users", json=diff.created)
 
         log.trace("Syncing updated users...")
         if diff.updated:
-            await self.bot.api_client.patch("bot/users/bulk_patch", json=diff.updated)
+            await bot.instance.api_client.patch("bot/users/bulk_patch", json=diff.updated)
diff --git a/tests/bot/exts/backend/sync/test_base.py b/tests/bot/exts/backend/sync/test_base.py
index 4953550f9..157d42452 100644
--- a/tests/bot/exts/backend/sync/test_base.py
+++ b/tests/bot/exts/backend/sync/test_base.py
@@ -18,21 +18,21 @@ class TestSyncer(Syncer):
 class SyncerBaseTests(unittest.TestCase):
     """Tests for the syncer base class."""
 
-    def setUp(self):
-        self.bot = helpers.MockBot()
-
     def test_instantiation_fails_without_abstract_methods(self):
         """The class must have abstract methods implemented."""
         with self.assertRaisesRegex(TypeError, "Can't instantiate abstract class"):
-            Syncer(self.bot)
+            Syncer()
 
 
 class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for main function orchestrating the sync."""
 
     def setUp(self):
-        self.bot = helpers.MockBot(user=helpers.MockMember(bot=True))
-        self.syncer = TestSyncer(self.bot)
+        patcher = mock.patch("bot.instance", new=helpers.MockBot(user=helpers.MockMember(bot=True)))
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.syncer = TestSyncer()
         self.guild = helpers.MockGuild()
 
         # Make sure `_get_diff` returns a MagicMock, not an AsyncMock
diff --git a/tests/bot/exts/backend/sync/test_cog.py b/tests/bot/exts/backend/sync/test_cog.py
index 063a82754..1e1883558 100644
--- a/tests/bot/exts/backend/sync/test_cog.py
+++ b/tests/bot/exts/backend/sync/test_cog.py
@@ -29,24 +29,24 @@ class SyncCogTestCase(unittest.IsolatedAsyncioTestCase):
     def setUp(self):
         self.bot = helpers.MockBot()
 
-        self.role_syncer_patcher = mock.patch(
+        role_syncer_patcher = mock.patch(
             "bot.exts.backend.sync._syncers.RoleSyncer",
             autospec=Syncer,
             spec_set=True
         )
-        self.user_syncer_patcher = mock.patch(
+        user_syncer_patcher = mock.patch(
             "bot.exts.backend.sync._syncers.UserSyncer",
             autospec=Syncer,
             spec_set=True
         )
-        self.RoleSyncer = self.role_syncer_patcher.start()
-        self.UserSyncer = self.user_syncer_patcher.start()
 
-        self.cog = Sync(self.bot)
+        self.RoleSyncer = role_syncer_patcher.start()
+        self.UserSyncer = user_syncer_patcher.start()
 
-    def tearDown(self):
-        self.role_syncer_patcher.stop()
-        self.user_syncer_patcher.stop()
+        self.addCleanup(role_syncer_patcher.stop)
+        self.addCleanup(user_syncer_patcher.stop)
+
+        self.cog = Sync(self.bot)
 
     @staticmethod
     def response_error(status: int) -> ResponseCodeError:
@@ -73,8 +73,8 @@ class SyncCogTests(SyncCogTestCase):
 
         Sync(self.bot)
 
-        self.RoleSyncer.assert_called_once_with(self.bot)
-        self.UserSyncer.assert_called_once_with(self.bot)
+        self.RoleSyncer.assert_called_once_with()
+        self.UserSyncer.assert_called_once_with()
         sync_guild.assert_called_once_with()
         self.bot.loop.create_task.assert_called_once_with(mock_sync_guild_coro)
 
diff --git a/tests/bot/exts/backend/sync/test_roles.py b/tests/bot/exts/backend/sync/test_roles.py
index 7b9f40cad..fb63a4ae0 100644
--- a/tests/bot/exts/backend/sync/test_roles.py
+++ b/tests/bot/exts/backend/sync/test_roles.py
@@ -22,8 +22,11 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
     """Tests for determining differences between roles in the DB and roles in the Guild cache."""
 
     def setUp(self):
-        self.bot = helpers.MockBot()
-        self.syncer = RoleSyncer(self.bot)
+        patcher = mock.patch("bot.instance", new=helpers.MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.syncer = RoleSyncer()
 
     @staticmethod
     def get_guild(*roles):
@@ -108,8 +111,11 @@ class RoleSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the API requests that sync roles."""
 
     def setUp(self):
-        self.bot = helpers.MockBot()
-        self.syncer = RoleSyncer(self.bot)
+        patcher = mock.patch("bot.instance", new=helpers.MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.syncer = RoleSyncer()
 
     async def test_sync_created_roles(self):
         """Only POST requests should be made with the correct payload."""
diff --git a/tests/bot/exts/backend/sync/test_users.py b/tests/bot/exts/backend/sync/test_users.py
index 9f380a15d..9f28d0162 100644
--- a/tests/bot/exts/backend/sync/test_users.py
+++ b/tests/bot/exts/backend/sync/test_users.py
@@ -1,4 +1,5 @@
 import unittest
+from unittest import mock
 
 from bot.exts.backend.sync._syncers import UserSyncer, _Diff
 from tests import helpers
@@ -19,8 +20,11 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
     """Tests for determining differences between users in the DB and users in the Guild cache."""
 
     def setUp(self):
-        self.bot = helpers.MockBot()
-        self.syncer = UserSyncer(self.bot)
+        patcher = mock.patch("bot.instance", new=helpers.MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.syncer = UserSyncer()
 
     @staticmethod
     def get_guild(*members):
@@ -186,8 +190,11 @@ class UserSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the API requests that sync users."""
 
     def setUp(self):
-        self.bot = helpers.MockBot()
-        self.syncer = UserSyncer(self.bot)
+        patcher = mock.patch("bot.instance", new=helpers.MockBot())
+        self.bot = patcher.start()
+        self.addCleanup(patcher.stop)
+
+        self.syncer = UserSyncer()
 
     async def test_sync_created_users(self):
         """Only POST requests should be made with the correct payload."""
-- 
cgit v1.2.3


From cc3805e0ca378ccaa3d025947c0982d0c8cb4e9f Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sat, 17 Oct 2020 13:33:55 -0700
Subject: Syncers: make functions static

The classes no longer hold any state since they can use the global bot
instance.
---
 bot/exts/backend/sync/_cog.py             |  9 +++------
 bot/exts/backend/sync/_syncers.py         | 24 ++++++++++++++----------
 tests/bot/exts/backend/sync/test_base.py  | 21 +++++++--------------
 tests/bot/exts/backend/sync/test_cog.py   | 18 ++++++++----------
 tests/bot/exts/backend/sync/test_roles.py | 20 ++++++++------------
 tests/bot/exts/backend/sync/test_users.py | 22 +++++++++-------------
 6 files changed, 49 insertions(+), 65 deletions(-)

(limited to 'tests')

diff --git a/bot/exts/backend/sync/_cog.py b/bot/exts/backend/sync/_cog.py
index b71ed3e69..48d2b6f02 100644
--- a/bot/exts/backend/sync/_cog.py
+++ b/bot/exts/backend/sync/_cog.py
@@ -18,9 +18,6 @@ class Sync(Cog):
 
     def __init__(self, bot: Bot) -> None:
         self.bot = bot
-        self.role_syncer = _syncers.RoleSyncer()
-        self.user_syncer = _syncers.UserSyncer()
-
         self.bot.loop.create_task(self.sync_guild())
 
     async def sync_guild(self) -> None:
@@ -31,7 +28,7 @@ class Sync(Cog):
         if guild is None:
             return
 
-        for syncer in (self.role_syncer, self.user_syncer):
+        for syncer in (_syncers.RoleSyncer, _syncers.UserSyncer):
             await syncer.sync(guild)
 
     async def patch_user(self, user_id: int, json: Dict[str, Any], ignore_404: bool = False) -> None:
@@ -171,10 +168,10 @@ class Sync(Cog):
     @commands.has_permissions(administrator=True)
     async def sync_roles_command(self, ctx: Context) -> None:
         """Manually synchronise the guild's roles with the roles on the site."""
-        await self.role_syncer.sync(ctx.guild, ctx)
+        await _syncers.RoleSyncer.sync(ctx.guild, ctx)
 
     @sync_group.command(name='users')
     @commands.has_permissions(administrator=True)
     async def sync_users_command(self, ctx: Context) -> None:
         """Manually synchronise the guild's users with the users on the site."""
-        await self.user_syncer.sync(ctx.guild, ctx)
+        await _syncers.UserSyncer.sync(ctx.guild, ctx)
diff --git a/bot/exts/backend/sync/_syncers.py b/bot/exts/backend/sync/_syncers.py
index bdd76806b..2eb9f9971 100644
--- a/bot/exts/backend/sync/_syncers.py
+++ b/bot/exts/backend/sync/_syncers.py
@@ -17,12 +17,15 @@ _Role = namedtuple('Role', ('id', 'name', 'colour', 'permissions', 'position'))
 _Diff = namedtuple('Diff', ('created', 'updated', 'deleted'))
 
 
+# Implementation of static abstract methods are not enforced if the subclass is never instantiated.
+# However, methods are kept abstract to at least symbolise that they should be abstract.
 class Syncer(abc.ABC):
     """Base class for synchronising the database with objects in the Discord cache."""
 
+    @staticmethod
     @property
     @abc.abstractmethod
-    def name(self) -> str:
+    def name() -> str:
         """The name of the syncer; used in output messages and logging."""
         raise NotImplementedError  # pragma: no cover
 
@@ -38,35 +41,36 @@ class Syncer(abc.ABC):
         """Perform the API calls for synchronisation."""
         raise NotImplementedError  # pragma: no cover
 
-    async def sync(self, guild: Guild, ctx: t.Optional[Context] = None) -> None:
+    @classmethod
+    async def sync(cls, guild: Guild, ctx: t.Optional[Context] = None) -> None:
         """
         Synchronise the database with the cache of `guild`.
 
         If `ctx` is given, send a message with the results.
         """
-        log.info(f"Starting {self.name} syncer.")
+        log.info(f"Starting {cls.name} syncer.")
 
         if ctx:
-            message = await ctx.send(f"📊 Synchronising {self.name}s.")
+            message = await ctx.send(f"📊 Synchronising {cls.name}s.")
         else:
             message = None
-        diff = await self._get_diff(guild)
+        diff = await cls._get_diff(guild)
 
         try:
-            await self._sync(diff)
+            await cls._sync(diff)
         except ResponseCodeError as e:
-            log.exception(f"{self.name} syncer failed!")
+            log.exception(f"{cls.name} syncer failed!")
 
             # Don't show response text because it's probably some really long HTML.
             results = f"status {e.status}\n```{e.response_json or 'See log output for details'}```"
-            content = f":x: Synchronisation of {self.name}s failed: {results}"
+            content = f":x: Synchronisation of {cls.name}s failed: {results}"
         else:
             diff_dict = diff._asdict()
             results = (f"{name} `{len(val)}`" for name, val in diff_dict.items() if val is not None)
             results = ", ".join(results)
 
-            log.info(f"{self.name} syncer finished: {results}.")
-            content = f":ok_hand: Synchronisation of {self.name}s complete: {results}"
+            log.info(f"{cls.name} syncer finished: {results}.")
+            content = f":ok_hand: Synchronisation of {cls.name}s complete: {results}"
 
         if message:
             await message.edit(content=content)
diff --git a/tests/bot/exts/backend/sync/test_base.py b/tests/bot/exts/backend/sync/test_base.py
index 157d42452..3ad9db9c3 100644
--- a/tests/bot/exts/backend/sync/test_base.py
+++ b/tests/bot/exts/backend/sync/test_base.py
@@ -15,15 +15,6 @@ class TestSyncer(Syncer):
     _sync = mock.AsyncMock()
 
 
-class SyncerBaseTests(unittest.TestCase):
-    """Tests for the syncer base class."""
-
-    def test_instantiation_fails_without_abstract_methods(self):
-        """The class must have abstract methods implemented."""
-        with self.assertRaisesRegex(TypeError, "Can't instantiate abstract class"):
-            Syncer()
-
-
 class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for main function orchestrating the sync."""
 
@@ -32,11 +23,13 @@ class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
         self.bot = patcher.start()
         self.addCleanup(patcher.stop)
 
-        self.syncer = TestSyncer()
         self.guild = helpers.MockGuild()
 
+        TestSyncer._get_diff.reset_mock(return_value=True, side_effect=True)
+        TestSyncer._sync.reset_mock(return_value=True, side_effect=True)
+
         # Make sure `_get_diff` returns a MagicMock, not an AsyncMock
-        self.syncer._get_diff.return_value = mock.MagicMock()
+        TestSyncer._get_diff.return_value = mock.MagicMock()
 
     async def test_sync_message_edited(self):
         """The message should be edited if one was sent, even if the sync has an API error."""
@@ -48,11 +41,11 @@ class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
 
         for message, side_effect, should_edit in subtests:
             with self.subTest(message=message, side_effect=side_effect, should_edit=should_edit):
-                self.syncer._sync.side_effect = side_effect
+                TestSyncer._sync.side_effect = side_effect
                 ctx = helpers.MockContext()
                 ctx.send.return_value = message
 
-                await self.syncer.sync(self.guild, ctx)
+                await TestSyncer.sync(self.guild, ctx)
 
                 if should_edit:
                     message.edit.assert_called_once()
@@ -67,7 +60,7 @@ class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
 
         for ctx, message in subtests:
             with self.subTest(ctx=ctx, message=message):
-                await self.syncer.sync(self.guild, ctx)
+                await TestSyncer.sync(self.guild, ctx)
 
                 if ctx is not None:
                     ctx.send.assert_called_once()
diff --git a/tests/bot/exts/backend/sync/test_cog.py b/tests/bot/exts/backend/sync/test_cog.py
index 1e1883558..22a07313e 100644
--- a/tests/bot/exts/backend/sync/test_cog.py
+++ b/tests/bot/exts/backend/sync/test_cog.py
@@ -73,8 +73,6 @@ class SyncCogTests(SyncCogTestCase):
 
         Sync(self.bot)
 
-        self.RoleSyncer.assert_called_once_with()
-        self.UserSyncer.assert_called_once_with()
         sync_guild.assert_called_once_with()
         self.bot.loop.create_task.assert_called_once_with(mock_sync_guild_coro)
 
@@ -83,8 +81,8 @@ class SyncCogTests(SyncCogTestCase):
         for guild in (helpers.MockGuild(), None):
             with self.subTest(guild=guild):
                 self.bot.reset_mock()
-                self.cog.role_syncer.reset_mock()
-                self.cog.user_syncer.reset_mock()
+                self.RoleSyncer.reset_mock()
+                self.UserSyncer.reset_mock()
 
                 self.bot.get_guild = mock.MagicMock(return_value=guild)
 
@@ -94,11 +92,11 @@ class SyncCogTests(SyncCogTestCase):
                 self.bot.get_guild.assert_called_once_with(constants.Guild.id)
 
                 if guild is None:
-                    self.cog.role_syncer.sync.assert_not_called()
-                    self.cog.user_syncer.sync.assert_not_called()
+                    self.RoleSyncer.sync.assert_not_called()
+                    self.UserSyncer.sync.assert_not_called()
                 else:
-                    self.cog.role_syncer.sync.assert_called_once_with(guild)
-                    self.cog.user_syncer.sync.assert_called_once_with(guild)
+                    self.RoleSyncer.sync.assert_called_once_with(guild)
+                    self.UserSyncer.sync.assert_called_once_with(guild)
 
     async def patch_user_helper(self, side_effect: BaseException) -> None:
         """Helper to set a side effect for bot.api_client.patch and then assert it is called."""
@@ -394,14 +392,14 @@ class SyncCogCommandTests(SyncCogTestCase, CommandTestCase):
         ctx = helpers.MockContext()
         await self.cog.sync_roles_command(self.cog, ctx)
 
-        self.cog.role_syncer.sync.assert_called_once_with(ctx.guild, ctx)
+        self.RoleSyncer.sync.assert_called_once_with(ctx.guild, ctx)
 
     async def test_sync_users_command(self):
         """sync() should be called on the UserSyncer."""
         ctx = helpers.MockContext()
         await self.cog.sync_users_command(self.cog, ctx)
 
-        self.cog.user_syncer.sync.assert_called_once_with(ctx.guild, ctx)
+        self.UserSyncer.sync.assert_called_once_with(ctx.guild, ctx)
 
     async def test_commands_require_admin(self):
         """The sync commands should only run if the author has the administrator permission."""
diff --git a/tests/bot/exts/backend/sync/test_roles.py b/tests/bot/exts/backend/sync/test_roles.py
index fb63a4ae0..541074336 100644
--- a/tests/bot/exts/backend/sync/test_roles.py
+++ b/tests/bot/exts/backend/sync/test_roles.py
@@ -26,8 +26,6 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot = patcher.start()
         self.addCleanup(patcher.stop)
 
-        self.syncer = RoleSyncer()
-
     @staticmethod
     def get_guild(*roles):
         """Fixture to return a guild object with the given roles."""
@@ -47,7 +45,7 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot.api_client.get.return_value = [fake_role()]
         guild = self.get_guild(fake_role())
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await RoleSyncer._get_diff(guild)
         expected_diff = (set(), set(), set())
 
         self.assertEqual(actual_diff, expected_diff)
@@ -59,7 +57,7 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot.api_client.get.return_value = [fake_role(id=41, name="old"), fake_role()]
         guild = self.get_guild(updated_role, fake_role())
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await RoleSyncer._get_diff(guild)
         expected_diff = (set(), {_Role(**updated_role)}, set())
 
         self.assertEqual(actual_diff, expected_diff)
@@ -71,7 +69,7 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot.api_client.get.return_value = [fake_role()]
         guild = self.get_guild(fake_role(), new_role)
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await RoleSyncer._get_diff(guild)
         expected_diff = ({_Role(**new_role)}, set(), set())
 
         self.assertEqual(actual_diff, expected_diff)
@@ -83,7 +81,7 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot.api_client.get.return_value = [fake_role(), deleted_role]
         guild = self.get_guild(fake_role())
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await RoleSyncer._get_diff(guild)
         expected_diff = (set(), set(), {_Role(**deleted_role)})
 
         self.assertEqual(actual_diff, expected_diff)
@@ -101,7 +99,7 @@ class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         ]
         guild = self.get_guild(fake_role(), new, updated)
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await RoleSyncer._get_diff(guild)
         expected_diff = ({_Role(**new)}, {_Role(**updated)}, {_Role(**deleted)})
 
         self.assertEqual(actual_diff, expected_diff)
@@ -115,15 +113,13 @@ class RoleSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
         self.bot = patcher.start()
         self.addCleanup(patcher.stop)
 
-        self.syncer = RoleSyncer()
-
     async def test_sync_created_roles(self):
         """Only POST requests should be made with the correct payload."""
         roles = [fake_role(id=111), fake_role(id=222)]
 
         role_tuples = {_Role(**role) for role in roles}
         diff = _Diff(role_tuples, set(), set())
-        await self.syncer._sync(diff)
+        await RoleSyncer._sync(diff)
 
         calls = [mock.call("bot/roles", json=role) for role in roles]
         self.bot.api_client.post.assert_has_calls(calls, any_order=True)
@@ -138,7 +134,7 @@ class RoleSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
 
         role_tuples = {_Role(**role) for role in roles}
         diff = _Diff(set(), role_tuples, set())
-        await self.syncer._sync(diff)
+        await RoleSyncer._sync(diff)
 
         calls = [mock.call(f"bot/roles/{role['id']}", json=role) for role in roles]
         self.bot.api_client.put.assert_has_calls(calls, any_order=True)
@@ -153,7 +149,7 @@ class RoleSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
 
         role_tuples = {_Role(**role) for role in roles}
         diff = _Diff(set(), set(), role_tuples)
-        await self.syncer._sync(diff)
+        await RoleSyncer._sync(diff)
 
         calls = [mock.call(f"bot/roles/{role['id']}") for role in roles]
         self.bot.api_client.delete.assert_has_calls(calls, any_order=True)
diff --git a/tests/bot/exts/backend/sync/test_users.py b/tests/bot/exts/backend/sync/test_users.py
index 9f28d0162..61673e1bb 100644
--- a/tests/bot/exts/backend/sync/test_users.py
+++ b/tests/bot/exts/backend/sync/test_users.py
@@ -24,8 +24,6 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         self.bot = patcher.start()
         self.addCleanup(patcher.stop)
 
-        self.syncer = UserSyncer()
-
     @staticmethod
     def get_guild(*members):
         """Fixture to return a guild object with the given members."""
@@ -61,7 +59,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         }
         guild = self.get_guild()
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -77,7 +75,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         guild = self.get_guild(fake_user())
 
         guild.get_member.return_value = self.get_mock_member(fake_user())
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -98,7 +96,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
             self.get_mock_member(fake_user())
         ]
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([], [{"id": 99, "name": "new"}], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -118,7 +116,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
             self.get_mock_member(fake_user()),
             self.get_mock_member(new_user)
         ]
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([new_user], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -137,7 +135,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
             None
         ]
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([], [{"id": 63, "in_guild": False}], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -161,7 +159,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
             None
         ]
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([new_user], [{"id": 55, "name": "updated"}, {"id": 63, "in_guild": False}], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -180,7 +178,7 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
             None
         ]
 
-        actual_diff = await self.syncer._get_diff(guild)
+        actual_diff = await UserSyncer._get_diff(guild)
         expected_diff = ([], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -194,14 +192,12 @@ class UserSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
         self.bot = patcher.start()
         self.addCleanup(patcher.stop)
 
-        self.syncer = UserSyncer()
-
     async def test_sync_created_users(self):
         """Only POST requests should be made with the correct payload."""
         users = [fake_user(id=111), fake_user(id=222)]
 
         diff = _Diff(users, [], None)
-        await self.syncer._sync(diff)
+        await UserSyncer._sync(diff)
 
         self.bot.api_client.post.assert_called_once_with("bot/users", json=diff.created)
 
@@ -213,7 +209,7 @@ class UserSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
         users = [fake_user(id=111), fake_user(id=222)]
 
         diff = _Diff([], users, None)
-        await self.syncer._sync(diff)
+        await UserSyncer._sync(diff)
 
         self.bot.api_client.patch.assert_called_once_with("bot/users/bulk_patch", json=diff.updated)
 
-- 
cgit v1.2.3


From 5d732c97daccece1fe7945d92b426be76ee02ea0 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 18 Oct 2020 09:31:36 +0300
Subject: Fix user not found info field test

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index caa42ba3d..b666e1f85 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -176,7 +176,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         """Should include info to return dict when user was not found from guild."""
         self.guild.get_member.return_value = None
         result = await self.cog.pardon_voice_ban(self.user.id, self.guild, "foobar")
-        self.assertEqual(result, {"Failure": "User was not found in the 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")
-- 
cgit v1.2.3


From 77effb0bdf167020f4733b8d8e2bf980a4016f52 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 18 Oct 2020 09:36:53 +0300
Subject: Update tests to not automatically adding back verified after vban
 expire

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index b666e1f85..f2617cf59 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -182,7 +182,6 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
     @patch("bot.exts.moderation.infraction.infractions.format_user")
     async def test_voice_unban_user_found(self, format_user_mock, notify_pardon_mock):
         """Should add role back with ignoring, notify user and return log dictionary.."""
-        self.cog.mod_log.ignore = MagicMock()
         self.guild.get_member.return_value = self.user
         notify_pardon_mock.return_value = True
         format_user_mock.return_value = "my-user"
@@ -192,8 +191,6 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
             "Member": "my-user",
             "DM": "Sent"
         })
-        self.cog.mod_log.ignore.assert_called_once_with(Event.member_update, self.user.id)
-        self.user.add_roles.assert_awaited_once_with(self.cog._voice_verified_role, reason="foobar")
         notify_pardon_mock.assert_awaited_once()
 
     @patch("bot.exts.moderation.infraction.infractions._utils.notify_pardon")
-- 
cgit v1.2.3


From 61206175591841d7ffed7b202c1bcf81d2b9ba99 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 18 Oct 2020 10:04:49 +0300
Subject: Fix voice ban command name in test

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index f2617cf59..5dbbb8e00 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -71,7 +71,7 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
     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.voice_ban(self.cog, self.ctx, self.user, reason="foobar"))
+        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")
 
     async def test_temporary_voice_ban(self):
-- 
cgit v1.2.3


From e840f0f17d5f9cdfde9c610ef75224ca84fe52a4 Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Sun, 18 Oct 2020 15:31:00 +0300
Subject: Remove test for case when user don't have VV for voice ban

---
 tests/bot/exts/moderation/infraction/test_infractions.py | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/infraction/test_infractions.py b/tests/bot/exts/moderation/infraction/test_infractions.py
index 5dbbb8e00..bf557a484 100644
--- a/tests/bot/exts/moderation/infraction/test_infractions.py
+++ b/tests/bot/exts/moderation/infraction/test_infractions.py
@@ -86,14 +86,6 @@ class VoiceBanTests(unittest.IsolatedAsyncioTestCase):
         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)
 
-    @patch("bot.exts.moderation.infraction.infractions._utils.get_active_infraction")
-    async def test_voice_ban_not_having_voice_verified_role(self, get_active_infraction_mock):
-        """Should send message and not apply infraction when user don't have voice verified role."""
-        self.user.roles = [MockRole(id=987)]
-        self.assertIsNone(await self.cog.apply_voice_ban(self.ctx, self.user, "foobar"))
-        self.ctx.send.assert_awaited_once()
-        get_active_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_user_have_active_infraction(self, get_active_infraction, post_infraction_mock):
-- 
cgit v1.2.3


From dc2797bc7d24d80c08c559bc381c465db1312143 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 18 Oct 2020 18:12:29 -0700
Subject: Silence: rename function to reduce ambiguity

---
 bot/exts/moderation/silence.py            |  4 ++--
 tests/bot/exts/moderation/test_silence.py | 16 ++++++++--------
 2 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'tests')

diff --git a/bot/exts/moderation/silence.py b/bot/exts/moderation/silence.py
index cfdefe103..3bbf8d21a 100644
--- a/bot/exts/moderation/silence.py
+++ b/bot/exts/moderation/silence.py
@@ -107,7 +107,7 @@ class Silence(commands.Cog):
         channel_info = f"#{ctx.channel} ({ctx.channel.id})"
         log.debug(f"{ctx.author} is silencing channel {channel_info}.")
 
-        if not await self._silence_overwrites(ctx.channel):
+        if not await self._set_silence_overwrites(ctx.channel):
             log.info(f"Tried to silence channel {channel_info} but the channel was already silenced.")
             await ctx.send(MSG_SILENCE_FAIL)
             return
@@ -144,7 +144,7 @@ class Silence(commands.Cog):
         else:
             await channel.send(MSG_UNSILENCE_SUCCESS)
 
-    async def _silence_overwrites(self, channel: TextChannel) -> bool:
+    async def _set_silence_overwrites(self, channel: TextChannel) -> bool:
         """Set silence permission overwrites for `channel` and return True if successful."""
         overwrite = channel.overwrites_for(self._verified_role)
         prev_overwrites = dict(send_messages=overwrite.send_messages, add_reactions=overwrite.add_reactions)
diff --git a/tests/bot/exts/moderation/test_silence.py b/tests/bot/exts/moderation/test_silence.py
index 6d5ffa7e8..6b67a21a0 100644
--- a/tests/bot/exts/moderation/test_silence.py
+++ b/tests/bot/exts/moderation/test_silence.py
@@ -274,7 +274,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         )
         for duration, message, was_silenced in test_cases:
             ctx = MockContext()
-            with mock.patch.object(self.cog, "_silence_overwrites", return_value=was_silenced):
+            with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=was_silenced):
                 with self.subTest(was_silenced=was_silenced, message=message, duration=duration):
                     await self.cog.silence.callback(self.cog, ctx, duration)
                     ctx.send.assert_called_once_with(message)
@@ -293,12 +293,12 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
                 channel = MockTextChannel()
                 channel.overwrites_for.return_value = overwrite
 
-                self.assertFalse(await self.cog._silence_overwrites(channel))
+                self.assertFalse(await self.cog._set_silence_overwrites(channel))
                 channel.set_permissions.assert_not_called()
 
     async def test_silenced_channel(self):
         """Channel had `send_message` and `add_reactions` permissions revoked for verified role."""
-        self.assertTrue(await self.cog._silence_overwrites(self.channel))
+        self.assertTrue(await self.cog._set_silence_overwrites(self.channel))
         self.assertFalse(self.overwrite.send_messages)
         self.assertFalse(self.overwrite.add_reactions)
         self.channel.set_permissions.assert_awaited_once_with(
@@ -309,7 +309,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
     async def test_preserved_other_overwrites(self):
         """Channel's other unrelated overwrites were not changed."""
         prev_overwrite_dict = dict(self.overwrite)
-        await self.cog._silence_overwrites(self.channel)
+        await self.cog._set_silence_overwrites(self.channel)
         new_overwrite_dict = dict(self.overwrite)
 
         # Remove 'send_messages' & 'add_reactions' keys because they were changed by the method.
@@ -322,26 +322,26 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
 
     async def test_temp_not_added_to_notifier(self):
         """Channel was not added to notifier if a duration was set for the silence."""
-        with mock.patch.object(self.cog, "_silence_overwrites", return_value=True):
+        with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=True):
             await self.cog.silence.callback(self.cog, MockContext(), 15)
             self.cog.notifier.add_channel.assert_not_called()
 
     async def test_indefinite_added_to_notifier(self):
         """Channel was added to notifier if a duration was not set for the silence."""
-        with mock.patch.object(self.cog, "_silence_overwrites", return_value=True):
+        with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=True):
             await self.cog.silence.callback(self.cog, MockContext(), None)
             self.cog.notifier.add_channel.assert_called_once()
 
     async def test_silenced_not_added_to_notifier(self):
         """Channel was not added to the notifier if it was already silenced."""
-        with mock.patch.object(self.cog, "_silence_overwrites", return_value=False):
+        with mock.patch.object(self.cog, "_set_silence_overwrites", return_value=False):
             await self.cog.silence.callback(self.cog, MockContext(), 15)
             self.cog.notifier.add_channel.assert_not_called()
 
     async def test_cached_previous_overwrites(self):
         """Channel's previous overwrites were cached."""
         overwrite_json = '{"send_messages": true, "add_reactions": false}'
-        await self.cog._silence_overwrites(self.channel)
+        await self.cog._set_silence_overwrites(self.channel)
         self.cog.previous_overwrites.set.assert_called_once_with(self.channel.id, overwrite_json)
 
     @autospec(silence, "datetime")
-- 
cgit v1.2.3


From 50324b3ec0e0285300e4f4cf389fd93c4801f1ec Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Wed, 21 Oct 2020 09:46:33 -0700
Subject: Silence tests: update docstrings in notifier tests

---
 tests/bot/exts/moderation/test_silence.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/test_silence.py b/tests/bot/exts/moderation/test_silence.py
index 6b67a21a0..104293d8e 100644
--- a/tests/bot/exts/moderation/test_silence.py
+++ b/tests/bot/exts/moderation/test_silence.py
@@ -43,7 +43,7 @@ class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
         self.notifier.start = self.notifier_start_mock = Mock()
 
     def test_add_channel_adds_channel(self):
-        """Channel in FirstHash with current loop is added to internal set."""
+        """Channel is added to `_silenced_channels` with the current loop."""
         channel = Mock()
         with mock.patch.object(self.notifier, "_silenced_channels") as silenced_channels:
             self.notifier.add_channel(channel)
@@ -61,7 +61,7 @@ class SilenceNotifierTests(unittest.IsolatedAsyncioTestCase):
         self.notifier_start_mock.assert_not_called()
 
     def test_remove_channel_removes_channel(self):
-        """Channel in FirstHash is removed from `_silenced_channels`."""
+        """Channel is removed from `_silenced_channels`."""
         channel = Mock()
         with mock.patch.object(self.notifier, "_silenced_channels") as silenced_channels:
             self.notifier.remove_channel(channel)
-- 
cgit v1.2.3


From 14734fde3d2a8d268bdae1603a6b64d964546dff Mon Sep 17 00:00:00 2001
From: ks129 <45097959+ks129@users.noreply.github.com>
Date: Fri, 20 Nov 2020 20:35:00 +0200
Subject: Cover Unicode emojis catching as antispam rule with test cases

---
 tests/bot/rules/test_discord_emojis.py | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/rules/test_discord_emojis.py b/tests/bot/rules/test_discord_emojis.py
index 9a72723e2..66c2d9f92 100644
--- a/tests/bot/rules/test_discord_emojis.py
+++ b/tests/bot/rules/test_discord_emojis.py
@@ -5,11 +5,12 @@ from tests.bot.rules import DisallowedCase, RuleTest
 from tests.helpers import MockMessage
 
 discord_emoji = "<:abcd:1234>"  # Discord emojis follow the format <:name:id>
+unicode_emoji = "🧪"
 
 
-def make_msg(author: str, n_emojis: int) -> MockMessage:
+def make_msg(author: str, n_emojis: int, emoji: str = discord_emoji) -> MockMessage:
     """Build a MockMessage instance with content containing `n_emojis` arbitrary emojis."""
-    return MockMessage(author=author, content=discord_emoji * n_emojis)
+    return MockMessage(author=author, content=emoji * n_emojis)
 
 
 class DiscordEmojisRuleTests(RuleTest):
@@ -20,16 +21,22 @@ class DiscordEmojisRuleTests(RuleTest):
         self.config = {"max": 2, "interval": 10}
 
     async def test_allows_messages_within_limit(self):
-        """Cases with a total amount of discord emojis within limit."""
+        """Cases with a total amount of discord and unicode emojis within limit."""
         cases = (
             [make_msg("bob", 2)],
             [make_msg("alice", 1), make_msg("bob", 2), make_msg("alice", 1)],
+            [make_msg("bob", 2, unicode_emoji)],
+            [
+                make_msg("alice", 1, unicode_emoji),
+                make_msg("bob", 2, unicode_emoji),
+                make_msg("alice", 1, unicode_emoji)
+            ],
         )
 
         await self.run_allowed(cases)
 
     async def test_disallows_messages_beyond_limit(self):
-        """Cases with more than the allowed amount of discord emojis."""
+        """Cases with more than the allowed amount of discord and unicode emojis."""
         cases = (
             DisallowedCase(
                 [make_msg("bob", 3)],
@@ -41,6 +48,20 @@ class DiscordEmojisRuleTests(RuleTest):
                 ("alice",),
                 4,
             ),
+            DisallowedCase(
+                [make_msg("bob", 3, unicode_emoji)],
+                ("bob",),
+                3,
+            ),
+            DisallowedCase(
+                [
+                    make_msg("alice", 2, unicode_emoji),
+                    make_msg("bob", 2, unicode_emoji),
+                    make_msg("alice", 2, unicode_emoji)
+                ],
+                ("alice",),
+                4
+            )
         )
 
         await self.run_disallowed(cases)
-- 
cgit v1.2.3


From 2fa5b78e357bf45e23e188dc501180ed241237d1 Mon Sep 17 00:00:00 2001
From: Xithrius <xithrius@gmail.com>
Date: Fri, 11 Dec 2020 05:06:03 -0800
Subject: Added catching for unparsable short ISO dates.

---
 bot/exts/info/information.py            | 11 +++++++----
 tests/bot/exts/info/test_information.py |  1 +
 2 files changed, 8 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/bot/exts/info/information.py b/bot/exts/info/information.py
index 8eec22c58..0c04d7cd0 100644
--- a/bot/exts/info/information.py
+++ b/bot/exts/info/information.py
@@ -230,7 +230,7 @@ class Information(Cog):
         if on_server:
             joined = time_since(user.joined_at, max_units=3)
             roles = ", ".join(role.mention for role in user.roles[1:])
-            membership = {"Joined": joined, "Verified": verified_at, "Roles": roles or None}
+            membership = {"Joined": joined, "Verified": verified_at or "False", "Roles": roles or None}
             if not is_mod_channel(ctx.channel):
                 membership.pop("Verified")
 
@@ -377,9 +377,12 @@ class Information(Cog):
                 activity_output = "No activity"
 
         else:
-            verified_at = user_activity['verified_at']
-            if verified_at is not None:
-                verified_at = time_since(parser.isoparse(user_activity["verified_at"]), max_units=3)
+            try:
+                if (verified_at := user_activity['verified_at']) is not None:
+                    verified_at = time_since(parser.isoparse(verified_at), max_units=3)
+            except ValueError:
+                log.warning('Could not parse ISO string correctly for user verification date.')
+                verified_at = None
 
             activity_output.append(user_activity['total_messages'] or "No messages")
             activity_output.append(user_activity["activity_blocks"] or "No activity")
diff --git a/tests/bot/exts/info/test_information.py b/tests/bot/exts/info/test_information.py
index daede54c5..254b0a867 100644
--- a/tests/bot/exts/info/test_information.py
+++ b/tests/bot/exts/info/test_information.py
@@ -355,6 +355,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(
             textwrap.dedent(f"""
                 Joined: {"1 year ago"}
+                Verified: {"False"}
                 Roles: &Moderators
             """).strip(),
             embed.fields[1].value
-- 
cgit v1.2.3


From 688908d1d996708525b9125a20e7c72b4413b252 Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Sat, 19 Dec 2020 04:00:59 +0000
Subject: Fix pending tests

---
 bot/exts/info/information.py            | 4 ++--
 tests/bot/exts/info/test_information.py | 2 +-
 tests/helpers.py                        | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/bot/exts/info/information.py b/bot/exts/info/information.py
index 15f96db3a..2057876e4 100644
--- a/bot/exts/info/information.py
+++ b/bot/exts/info/information.py
@@ -229,9 +229,9 @@ class Information(Cog):
         if on_server:
             joined = time_since(user.joined_at, max_units=3)
             roles = ", ".join(role.mention for role in user.roles[1:])
-            membership = {"Joined": joined, "Verified": user.pending, "Roles": roles or None}
+            membership = {"Joined": joined, "Pending": user.pending, "Roles": roles or None}
             if not is_mod_channel(ctx.channel):
-                membership.pop("Verified")
+                membership.pop("Pending")
 
             membership = textwrap.dedent("\n".join([f"{key}: {value}" for key, value in membership.items()]))
         else:
diff --git a/tests/bot/exts/info/test_information.py b/tests/bot/exts/info/test_information.py
index 254b0a867..043cce8de 100644
--- a/tests/bot/exts/info/test_information.py
+++ b/tests/bot/exts/info/test_information.py
@@ -355,7 +355,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(
             textwrap.dedent(f"""
                 Joined: {"1 year ago"}
-                Verified: {"False"}
+                Pending: {"False"}
                 Roles: &Moderators
             """).strip(),
             embed.fields[1].value
diff --git a/tests/helpers.py b/tests/helpers.py
index 870f66197..496363ae3 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -230,7 +230,7 @@ class MockMember(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin
     spec_set = member_instance
 
     def __init__(self, roles: Optional[Iterable[MockRole]] = None, **kwargs) -> None:
-        default_kwargs = {'name': 'member', 'id': next(self.discord_id), 'bot': False}
+        default_kwargs = {'name': 'member', 'id': next(self.discord_id), 'bot': False, "pending": False}
         super().__init__(**collections.ChainMap(kwargs, default_kwargs))
 
         self.roles = [MockRole(name="@everyone", position=1, id=0)]
-- 
cgit v1.2.3


From c4545d8f5206e296bcecfd87236be57fbc91b778 Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Sat, 19 Dec 2020 04:21:52 +0000
Subject: Fix silence command to use guild default role

---
 bot/exts/moderation/silence.py            | 14 +++++++-------
 tests/bot/exts/moderation/test_silence.py |  9 ---------
 2 files changed, 7 insertions(+), 16 deletions(-)

(limited to 'tests')

diff --git a/bot/exts/moderation/silence.py b/bot/exts/moderation/silence.py
index e6712b3b6..a942d5294 100644
--- a/bot/exts/moderation/silence.py
+++ b/bot/exts/moderation/silence.py
@@ -93,7 +93,7 @@ class Silence(commands.Cog):
         await self.bot.wait_until_guild_available()
 
         guild = self.bot.get_guild(Guild.id)
-        self._verified_role = guild.get_role(Roles.verified)
+        self._everyone_role = guild.default_role
         self._mod_alerts_channel = self.bot.get_channel(Channels.mod_alerts)
         self.notifier = SilenceNotifier(self.bot.get_channel(Channels.mod_log))
         await self._reschedule()
@@ -142,7 +142,7 @@ class Silence(commands.Cog):
     async def _unsilence_wrapper(self, channel: TextChannel) -> None:
         """Unsilence `channel` and send a success/failure message."""
         if not await self._unsilence(channel):
-            overwrite = channel.overwrites_for(self._verified_role)
+            overwrite = channel.overwrites_for(self._everyone_role)
             if overwrite.send_messages is False or overwrite.add_reactions is False:
                 await channel.send(MSG_UNSILENCE_MANUAL)
             else:
@@ -152,14 +152,14 @@ class Silence(commands.Cog):
 
     async def _set_silence_overwrites(self, channel: TextChannel) -> bool:
         """Set silence permission overwrites for `channel` and return True if successful."""
-        overwrite = channel.overwrites_for(self._verified_role)
+        overwrite = channel.overwrites_for(self._everyone_role)
         prev_overwrites = dict(send_messages=overwrite.send_messages, add_reactions=overwrite.add_reactions)
 
         if channel.id in self.scheduler or all(val is False for val in prev_overwrites.values()):
             return False
 
         overwrite.update(send_messages=False, add_reactions=False)
-        await channel.set_permissions(self._verified_role, overwrite=overwrite)
+        await channel.set_permissions(self._everyone_role, overwrite=overwrite)
         await self.previous_overwrites.set(channel.id, json.dumps(prev_overwrites))
 
         return True
@@ -188,14 +188,14 @@ class Silence(commands.Cog):
             log.info(f"Tried to unsilence channel #{channel} ({channel.id}) but the channel was not silenced.")
             return False
 
-        overwrite = channel.overwrites_for(self._verified_role)
+        overwrite = channel.overwrites_for(self._everyone_role)
         if prev_overwrites is None:
             log.info(f"Missing previous overwrites for #{channel} ({channel.id}); defaulting to None.")
             overwrite.update(send_messages=None, add_reactions=None)
         else:
             overwrite.update(**json.loads(prev_overwrites))
 
-        await channel.set_permissions(self._verified_role, overwrite=overwrite)
+        await channel.set_permissions(self._everyone_role, overwrite=overwrite)
         log.info(f"Unsilenced channel #{channel} ({channel.id}).")
 
         self.scheduler.cancel(channel.id)
@@ -207,7 +207,7 @@ class Silence(commands.Cog):
             await self._mod_alerts_channel.send(
                 f"<@&{Roles.admins}> Restored overwrites with default values after unsilencing "
                 f"{channel.mention}. Please check that the `Send Messages` and `Add Reactions` "
-                f"overwrites for {self._verified_role.mention} are at their desired values."
+                f"overwrites for {self._everyone_role.mention} are at their desired values."
             )
 
         return True
diff --git a/tests/bot/exts/moderation/test_silence.py b/tests/bot/exts/moderation/test_silence.py
index 104293d8e..5c89a2f2a 100644
--- a/tests/bot/exts/moderation/test_silence.py
+++ b/tests/bot/exts/moderation/test_silence.py
@@ -116,15 +116,6 @@ class SilenceCogTests(unittest.IsolatedAsyncioTestCase):
         self.bot.wait_until_guild_available.assert_awaited_once()
         self.bot.get_guild.assert_called_once_with(Guild.id)
 
-    @autospec(silence, "SilenceNotifier", pass_mocks=False)
-    async def test_async_init_got_role(self):
-        """Got `Roles.verified` role from guild."""
-        guild = self.bot.get_guild()
-        guild.get_role.side_effect = lambda id_: Mock(id=id_)
-
-        await self.cog._async_init()
-        self.assertEqual(self.cog._verified_role.id, Roles.verified)
-
     @autospec(silence, "SilenceNotifier", pass_mocks=False)
     async def test_async_init_got_channels(self):
         """Got channels from bot."""
-- 
cgit v1.2.3


From 9799020de67c9350ee57f9ee3edff348a718cf6b Mon Sep 17 00:00:00 2001
From: Joe Banks <joseph@josephbanks.me>
Date: Sat, 19 Dec 2020 04:27:01 +0000
Subject: Fix silence tests

---
 tests/bot/exts/moderation/test_silence.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/exts/moderation/test_silence.py b/tests/bot/exts/moderation/test_silence.py
index 5c89a2f2a..fa5fc9e81 100644
--- a/tests/bot/exts/moderation/test_silence.py
+++ b/tests/bot/exts/moderation/test_silence.py
@@ -293,7 +293,7 @@ class SilenceTests(unittest.IsolatedAsyncioTestCase):
         self.assertFalse(self.overwrite.send_messages)
         self.assertFalse(self.overwrite.add_reactions)
         self.channel.set_permissions.assert_awaited_once_with(
-            self.cog._verified_role,
+            self.cog._everyone_role,
             overwrite=self.overwrite
         )
 
@@ -426,7 +426,7 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
         """Channel's `send_message` and `add_reactions` overwrites were restored."""
         await self.cog._unsilence(self.channel)
         self.channel.set_permissions.assert_awaited_once_with(
-            self.cog._verified_role,
+            self.cog._everyone_role,
             overwrite=self.overwrite,
         )
 
@@ -440,7 +440,7 @@ class UnsilenceTests(unittest.IsolatedAsyncioTestCase):
 
         await self.cog._unsilence(self.channel)
         self.channel.set_permissions.assert_awaited_once_with(
-            self.cog._verified_role,
+            self.cog._everyone_role,
             overwrite=self.overwrite,
         )
 
-- 
cgit v1.2.3


From 52ee0dab1e59089a7acc9f08078dee0df3fa40e6 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sat, 19 Dec 2020 11:33:37 -0800
Subject: Remove obsolete test cases

Forgot to remove these when removing `loop_is_running` in a previous
commit.
---
 tests/bot/test_api.py | 8 --------
 1 file changed, 8 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/test_api.py b/tests/bot/test_api.py
index 99e942813..76bcb481d 100644
--- a/tests/bot/test_api.py
+++ b/tests/bot/test_api.py
@@ -13,14 +13,6 @@ class APIClientTests(unittest.IsolatedAsyncioTestCase):
         cls.error_api_response = MagicMock()
         cls.error_api_response.status = 999
 
-    def test_loop_is_not_running_by_default(self):
-        """The event loop should not be running by default."""
-        self.assertFalse(api.loop_is_running())
-
-    async def test_loop_is_running_in_async_context(self):
-        """The event loop should be running in an async context."""
-        self.assertTrue(api.loop_is_running())
-
     def test_response_code_error_default_initialization(self):
         """Test the default initialization of `ResponseCodeError` without `text` or `json`"""
         error = api.ResponseCodeError(response=self.error_api_response)
-- 
cgit v1.2.3


From fc8a1246b281fd0d495955e0b84c6fc75a59ba4d Mon Sep 17 00:00:00 2001
From: Steele <swfarnsworth@gmail.com>
Date: Wed, 30 Dec 2020 16:39:49 -0500
Subject: "Pending: False" to "Verified: True" to agree with new semantics.

---
 tests/bot/exts/info/test_information.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/bot/exts/info/test_information.py b/tests/bot/exts/info/test_information.py
index 043cce8de..d077be960 100644
--- a/tests/bot/exts/info/test_information.py
+++ b/tests/bot/exts/info/test_information.py
@@ -355,7 +355,7 @@ class UserEmbedTests(unittest.IsolatedAsyncioTestCase):
         self.assertEqual(
             textwrap.dedent(f"""
                 Joined: {"1 year ago"}
-                Pending: {"False"}
+                Verified: {"True"}
                 Roles: &Moderators
             """).strip(),
             embed.fields[1].value
-- 
cgit v1.2.3


From 2e51515af5ca51beff6acbc1e48e064c78611dec Mon Sep 17 00:00:00 2001
From: mbaruh <mbaruh@hotmail.com>
Date: Mon, 11 Jan 2021 01:52:08 +0200
Subject: Annihilate all traces of Developer and Unverified roles

---
 bot/constants.py                    |  13 -
 bot/exts/backend/error_handler.py   |  10 +-
 bot/exts/moderation/silence.py      |   2 +-
 bot/exts/moderation/verification.py | 675 +-----------------------------------
 bot/exts/utils/jams.py              |   4 -
 bot/rules/burst_shared.py           |  11 +-
 config-default.yml                  |  15 -
 tests/bot/exts/utils/test_jams.py   |   4 +-
 8 files changed, 14 insertions(+), 720 deletions(-)

(limited to 'tests')

diff --git a/bot/constants.py b/bot/constants.py
index 6bfda160b..d813046ab 100644
--- a/bot/constants.py
+++ b/bot/constants.py
@@ -434,7 +434,6 @@ class Channels(metaclass=YAMLGetter):
     talent_pool: int
     user_event_announcements: int
     user_log: int
-    verification: int
     voice_chat: int
     voice_gate: int
     voice_log: int
@@ -471,8 +470,6 @@ class Roles(metaclass=YAMLGetter):
     python_community: int
     sprinters: int
     team_leaders: int
-    unverified: int
-    verified: int  # This is the Developers role on PyDis, here named verified for readability reasons.
     voice_verified: int
 
 
@@ -594,16 +591,6 @@ class PythonNews(metaclass=YAMLGetter):
     webhook: int
 
 
-class Verification(metaclass=YAMLGetter):
-    section = "verification"
-
-    unverified_after: int
-    kicked_after: int
-    reminder_frequency: int
-    bot_message_delete_delay: int
-    kick_confirmation_threshold: float
-
-
 class VoiceGate(metaclass=YAMLGetter):
     section = "voice_gate"
 
diff --git a/bot/exts/backend/error_handler.py b/bot/exts/backend/error_handler.py
index c643d346e..5b5840858 100644
--- a/bot/exts/backend/error_handler.py
+++ b/bot/exts/backend/error_handler.py
@@ -8,7 +8,7 @@ from sentry_sdk import push_scope
 
 from bot.api import ResponseCodeError
 from bot.bot import Bot
-from bot.constants import Channels, Colours
+from bot.constants import Colours
 from bot.converters import TagNameConverter
 from bot.errors import LockedResourceError
 from bot.utils.checks import InWhitelistCheckFailure
@@ -47,7 +47,6 @@ class ErrorHandler(Cog):
             * If CommandNotFound is raised when invoking the tag (determined by the presence of the
               `invoked_from_error_handler` attribute), this error is treated as being unexpected
               and therefore sends an error message
-            * Commands in the verification channel are ignored
         2. UserInputError: see `handle_user_input_error`
         3. CheckFailure: see `handle_check_failure`
         4. CommandOnCooldown: send an error message in the invoking context
@@ -63,10 +62,9 @@ class ErrorHandler(Cog):
         if isinstance(e, errors.CommandNotFound) and not hasattr(ctx, "invoked_from_error_handler"):
             if await self.try_silence(ctx):
                 return
-            if ctx.channel.id != Channels.verification:
-                # Try to look for a tag with the command's name
-                await self.try_get_tag(ctx)
-                return  # Exit early to avoid logging.
+            # Try to look for a tag with the command's name
+            await self.try_get_tag(ctx)
+            return  # Exit early to avoid logging.
         elif isinstance(e, errors.UserInputError):
             await self.handle_user_input_error(ctx, e)
         elif isinstance(e, errors.CheckFailure):
diff --git a/bot/exts/moderation/silence.py b/bot/exts/moderation/silence.py
index a942d5294..2a7ca932e 100644
--- a/bot/exts/moderation/silence.py
+++ b/bot/exts/moderation/silence.py
@@ -72,7 +72,7 @@ class SilenceNotifier(tasks.Loop):
 
 
 class Silence(commands.Cog):
-    """Commands for stopping channel messages for `verified` role in a channel."""
+    """Commands for stopping channel messages for `everyone` role in a channel."""
 
     # Maps muted channel IDs to their previous overwrites for send_message and add_reactions.
     # Overwrites are stored as JSON.
diff --git a/bot/exts/moderation/verification.py b/bot/exts/moderation/verification.py
index ce91dcb15..2a24c8ec6 100644
--- a/bot/exts/moderation/verification.py
+++ b/bot/exts/moderation/verification.py
@@ -1,27 +1,18 @@
-import asyncio
 import logging
 import typing as t
-from contextlib import suppress
-from datetime import datetime, timedelta
 
 import discord
-from async_rediscache import RedisCache
-from discord.ext import tasks
-from discord.ext.commands import Cog, Context, command, group, has_any_role
-from discord.utils import snowflake_time
+from discord.ext.commands import Cog, Context, command, has_any_role
 
 from bot import constants
-from bot.api import ResponseCodeError
 from bot.bot import Bot
-from bot.decorators import has_no_roles, in_whitelist
-from bot.exts.moderation.modlog import ModLog
-from bot.utils.checks import InWhitelistCheckFailure, has_no_roles_check
-from bot.utils.messages import format_user
+from bot.decorators import in_whitelist
+from bot.utils.checks import InWhitelistCheckFailure
 
 log = logging.getLogger(__name__)
 
 # Sent via DMs once user joins the guild
-ON_JOIN_MESSAGE = f"""
+ON_JOIN_MESSAGE = """
 Welcome to Python Discord!
 
 To show you what kind of community we are, we've created this video:
@@ -29,32 +20,9 @@ https://youtu.be/ZH26PuX3re0
 
 As a new user, you have read-only access to a few select channels to give you a taste of what our server is like. \
 In order to see the rest of the channels and to send messages, you first have to accept our rules.
-
-Please visit <#{constants.Channels.verification}> to get started. Thank you!
 """
 
-# Sent via DMs once user verifies
 VERIFIED_MESSAGE = f"""
-Thanks for verifying yourself!
-
-For your records, these are the documents you accepted:
-
-`1)` Our rules, here: <https://pythondiscord.com/pages/rules>
-`2)` Our privacy policy, here: <https://pythondiscord.com/pages/privacy> - you can find information on how to have \
-your information removed here as well.
-
-Feel free to review them at any point!
-
-Additionally, if you'd like to receive notifications for the announcements \
-we post in <#{constants.Channels.announcements}>
-from time to time, you can send `!subscribe` to <#{constants.Channels.bot_commands}> at any time \
-to assign yourself the **Announcements** role. We'll mention this role every time we make an announcement.
-
-If you'd like to unsubscribe from the announcement notifications, simply send `!unsubscribe` to \
-<#{constants.Channels.bot_commands}>.
-"""
-
-ALTERNATE_VERIFIED_MESSAGE = f"""
 You are now verified!
 
 You can find a copy of our rules for reference at <https://pythondiscord.com/pages/rules>.
@@ -71,61 +39,6 @@ To introduce you to our community, we've made the following video:
 https://youtu.be/ZH26PuX3re0
 """
 
-# Sent via DMs to users kicked for failing to verify
-KICKED_MESSAGE = f"""
-Hi! You have been automatically kicked from Python Discord as you have failed to accept our rules \
-within `{constants.Verification.kicked_after}` days. If this was an accident, please feel free to join us again!
-
-{constants.Guild.invite}
-"""
-
-# Sent periodically in the verification channel
-REMINDER_MESSAGE = f"""
-<@&{constants.Roles.unverified}>
-
-Welcome to Python Discord! Please read the documents mentioned above and type `!accept` to gain permissions \
-to send messages in the community!
-
-You will be kicked if you don't verify within `{constants.Verification.kicked_after}` days.
-""".strip()
-
-# An async function taking a Member param
-Request = t.Callable[[discord.Member], t.Awaitable]
-
-
-class StopExecution(Exception):
-    """Signals that a task should halt immediately & alert admins."""
-
-    def __init__(self, reason: discord.HTTPException) -> None:
-        super().__init__()
-        self.reason = reason
-
-
-class Limit(t.NamedTuple):
-    """Composition over config for throttling requests."""
-
-    batch_size: int  # Amount of requests after which to pause
-    sleep_secs: int  # Sleep this many seconds after each batch
-
-
-def mention_role(role_id: int) -> discord.AllowedMentions:
-    """Construct an allowed mentions instance that allows pinging `role_id`."""
-    return discord.AllowedMentions(roles=[discord.Object(role_id)])
-
-
-def is_verified(member: discord.Member) -> bool:
-    """
-    Check whether `member` is considered verified.
-
-    Members are considered verified if they have at least 1 role other than
-    the default role (@everyone) and the @Unverified role.
-    """
-    unverified_roles = {
-        member.guild.get_role(constants.Roles.unverified),
-        member.guild.default_role,
-    }
-    return len(set(member.roles) - unverified_roles) > 0
-
 
 async def safe_dm(coro: t.Coroutine) -> None:
     """
@@ -150,410 +63,16 @@ class Verification(Cog):
     """
     User verification and role management.
 
-    There are two internal tasks in this cog:
-
-    * `update_unverified_members`
-        * Unverified members are given the @Unverified role after configured `unverified_after` days
-        * Unverified members are kicked after configured `kicked_after` days
-    * `ping_unverified`
-        * Periodically ping the @Unverified role in the verification channel
-
     Statistics are collected in the 'verification.' namespace.
 
-    Moderators+ can use the `verification` command group to start or stop both internal
-    tasks, if necessary. Settings are persisted in Redis across sessions.
-
-    Additionally, this cog offers the !accept, !subscribe and !unsubscribe commands,
-    and keeps the verification channel clean by deleting messages.
+    Additionally, this cog offers the !subscribe and !unsubscribe commands,
     """
 
-    # Persist task settings & last sent `REMINDER_MESSAGE` id
-    # RedisCache[
-    #   "tasks_running": int (0 or 1),
-    #   "last_reminder": int (discord.Message.id),
-    # ]
-    task_cache = RedisCache()
-
     def __init__(self, bot: Bot) -> None:
         """Start internal tasks."""
         self.bot = bot
-        self.bot.loop.create_task(self._maybe_start_tasks())
-
         self.pending_members = set()
 
-    def cog_unload(self) -> None:
-        """
-        Cancel internal tasks.
-
-        This is necessary, as tasks are not automatically cancelled on cog unload.
-        """
-        self._stop_tasks(gracefully=False)
-
-    @property
-    def mod_log(self) -> ModLog:
-        """Get currently loaded ModLog cog instance."""
-        return self.bot.get_cog("ModLog")
-
-    async def _maybe_start_tasks(self) -> None:
-        """
-        Poll Redis to check whether internal tasks should start.
-
-        Redis must be interfaced with from an async function.
-        """
-        log.trace("Checking whether background tasks should begin")
-        setting: t.Optional[int] = await self.task_cache.get("tasks_running")  # This can be None if never set
-
-        if setting:
-            log.trace("Background tasks will be started")
-            self.update_unverified_members.start()
-            self.ping_unverified.start()
-
-    def _stop_tasks(self, *, gracefully: bool) -> None:
-        """
-        Stop the update users & ping @Unverified tasks.
-
-        If `gracefully` is True, the tasks will be able to finish their current iteration.
-        Otherwise, they are cancelled immediately.
-        """
-        log.info(f"Stopping internal tasks ({gracefully=})")
-        if gracefully:
-            self.update_unverified_members.stop()
-            self.ping_unverified.stop()
-        else:
-            self.update_unverified_members.cancel()
-            self.ping_unverified.cancel()
-
-    # region: automatically update unverified users
-
-    async def _verify_kick(self, n_members: int) -> bool:
-        """
-        Determine whether `n_members` is a reasonable amount of members to kick.
-
-        First, `n_members` is checked against the size of the PyDis guild. If `n_members` are
-        more than the configured `kick_confirmation_threshold` of the guild, the operation
-        must be confirmed by staff in #core-dev. Otherwise, the operation is seen as safe.
-        """
-        log.debug(f"Checking whether {n_members} members are safe to kick")
-
-        await self.bot.wait_until_guild_available()  # Ensure cache is populated before we grab the guild
-        pydis = self.bot.get_guild(constants.Guild.id)
-
-        percentage = n_members / len(pydis.members)
-        if percentage < constants.Verification.kick_confirmation_threshold:
-            log.debug(f"Kicking {percentage:.2%} of the guild's population is seen as safe")
-            return True
-
-        # Since `n_members` is a suspiciously large number, we will ask for confirmation
-        log.debug("Amount of users is too large, requesting staff confirmation")
-
-        core_dev_channel = pydis.get_channel(constants.Channels.dev_core)
-        core_dev_ping = f"<@&{constants.Roles.core_developers}>"
-
-        confirmation_msg = await core_dev_channel.send(
-            f"{core_dev_ping} Verification determined that `{n_members}` members should be kicked as they haven't "
-            f"verified in `{constants.Verification.kicked_after}` days. This is `{percentage:.2%}` of the guild's "
-            f"population. Proceed?",
-            allowed_mentions=mention_role(constants.Roles.core_developers),
-        )
-
-        options = (constants.Emojis.incident_actioned, constants.Emojis.incident_unactioned)
-        for option in options:
-            await confirmation_msg.add_reaction(option)
-
-        core_dev_ids = [member.id for member in pydis.get_role(constants.Roles.core_developers).members]
-
-        def check(reaction: discord.Reaction, user: discord.User) -> bool:
-            """Check whether `reaction` is a valid reaction to `confirmation_msg`."""
-            return (
-                reaction.message.id == confirmation_msg.id  # Reacted to `confirmation_msg`
-                and str(reaction.emoji) in options  # With one of `options`
-                and user.id in core_dev_ids  # By a core developer
-            )
-
-        timeout = 60 * 5  # Seconds, i.e. 5 minutes
-        try:
-            choice, _ = await self.bot.wait_for("reaction_add", check=check, timeout=timeout)
-        except asyncio.TimeoutError:
-            log.debug("Staff prompt not answered, aborting operation")
-            return False
-        finally:
-            with suppress(discord.HTTPException):
-                await confirmation_msg.clear_reactions()
-
-        result = str(choice) == constants.Emojis.incident_actioned
-        log.debug(f"Received answer: {choice}, result: {result}")
-
-        # Edit the prompt message to reflect the final choice
-        if result is True:
-            result_msg = f":ok_hand: {core_dev_ping} Request to kick `{n_members}` members was authorized!"
-        else:
-            result_msg = f":warning: {core_dev_ping} Request to kick `{n_members}` members was denied!"
-
-        with suppress(discord.HTTPException):
-            await confirmation_msg.edit(content=result_msg)
-
-        return result
-
-    async def _alert_admins(self, exception: discord.HTTPException) -> None:
-        """
-        Ping @Admins with information about `exception`.
-
-        This is used when a critical `exception` caused a verification task to abort.
-        """
-        await self.bot.wait_until_guild_available()
-        log.info(f"Sending admin alert regarding exception: {exception}")
-
-        admins_channel = self.bot.get_guild(constants.Guild.id).get_channel(constants.Channels.admins)
-        ping = f"<@&{constants.Roles.admins}>"
-
-        await admins_channel.send(
-            f"{ping} Aborted updating unverified users due to the following exception:\n"
-            f"```{exception}```\n"
-            f"Internal tasks will be stopped.",
-            allowed_mentions=mention_role(constants.Roles.admins),
-        )
-
-    async def _send_requests(self, members: t.Collection[discord.Member], request: Request, limit: Limit) -> int:
-        """
-        Pass `members` one by one to `request` handling Discord exceptions.
-
-        This coroutine serves as a generic `request` executor for kicking members and adding
-        roles, as it allows us to define the error handling logic in one place only.
-
-        Any `request` has the ability to completely abort the execution by raising `StopExecution`.
-        In such a case, the @Admins will be alerted of the reason attribute.
-
-        To avoid rate-limits, pass a `limit` configuring the batch size and the amount of seconds
-        to sleep between batches.
-
-        Returns the amount of successful requests. Failed requests are logged at info level.
-        """
-        log.trace(f"Sending {len(members)} requests")
-        n_success, bad_statuses = 0, set()
-
-        for progress, member in enumerate(members, start=1):
-            if is_verified(member):  # Member could have verified in the meantime
-                continue
-            try:
-                await request(member)
-            except StopExecution as stop_execution:
-                await self._alert_admins(stop_execution.reason)
-                await self.task_cache.set("tasks_running", 0)
-                self._stop_tasks(gracefully=True)  # Gracefully finish current iteration, then stop
-                break
-            except discord.HTTPException as http_exc:
-                bad_statuses.add(http_exc.status)
-            else:
-                n_success += 1
-
-            if progress % limit.batch_size == 0:
-                log.trace(f"Processed {progress} requests, pausing for {limit.sleep_secs} seconds")
-                await asyncio.sleep(limit.sleep_secs)
-
-        if bad_statuses:
-            log.info(f"Failed to send {len(members) - n_success} requests due to following statuses: {bad_statuses}")
-
-        return n_success
-
-    async def _add_kick_note(self, member: discord.Member) -> None:
-        """
-        Post a note regarding `member` being kicked to site.
-
-        Allows keeping track of kicked members for auditing purposes.
-        """
-        payload = {
-            "active": False,
-            "actor": self.bot.user.id,  # Bot actions this autonomously
-            "expires_at": None,
-            "hidden": True,
-            "reason": "Verification kick",
-            "type": "note",
-            "user": member.id,
-        }
-
-        log.trace(f"Posting kick note for member {member} ({member.id})")
-        try:
-            await self.bot.api_client.post("bot/infractions", json=payload)
-        except ResponseCodeError as api_exc:
-            log.warning("Failed to post kick note", exc_info=api_exc)
-
-    async def _kick_members(self, members: t.Collection[discord.Member]) -> int:
-        """
-        Kick `members` from the PyDis guild.
-
-        Due to strict ratelimits on sending messages (120 requests / 60 secs), we sleep for a second
-        after each 2 requests to allow breathing room for other features.
-
-        Note that this is a potentially destructive operation. Returns the amount of successful requests.
-        """
-        log.info(f"Kicking {len(members)} members (not verified after {constants.Verification.kicked_after} days)")
-
-        async def kick_request(member: discord.Member) -> None:
-            """Send `KICKED_MESSAGE` to `member` and kick them from the guild."""
-            try:
-                await safe_dm(member.send(KICKED_MESSAGE))  # Suppress disabled DMs
-            except discord.HTTPException as suspicious_exception:
-                raise StopExecution(reason=suspicious_exception)
-            await member.kick(reason=f"User has not verified in {constants.Verification.kicked_after} days")
-            await self._add_kick_note(member)
-
-        n_kicked = await self._send_requests(members, kick_request, Limit(batch_size=2, sleep_secs=1))
-        self.bot.stats.incr("verification.kicked", count=n_kicked)
-
-        return n_kicked
-
-    async def _give_role(self, members: t.Collection[discord.Member], role: discord.Role) -> int:
-        """
-        Give `role` to all `members`.
-
-        We pause for a second after batches of 25 requests to ensure ratelimits aren't exceeded.
-
-        Returns the amount of successful requests.
-        """
-        log.info(
-            f"Assigning {role} role to {len(members)} members (not verified "
-            f"after {constants.Verification.unverified_after} days)"
-        )
-
-        async def role_request(member: discord.Member) -> None:
-            """Add `role` to `member`."""
-            await member.add_roles(role, reason=f"Not verified after {constants.Verification.unverified_after} days")
-
-        return await self._send_requests(members, role_request, Limit(batch_size=25, sleep_secs=1))
-
-    async def _check_members(self) -> t.Tuple[t.Set[discord.Member], t.Set[discord.Member]]:
-        """
-        Check in on the verification status of PyDis members.
-
-        This coroutine finds two sets of users:
-        * Not verified after configured `unverified_after` days, should be given the @Unverified role
-        * Not verified after configured `kicked_after` days, should be kicked from the guild
-
-        These sets are always disjoint, i.e. share no common members.
-        """
-        await self.bot.wait_until_guild_available()  # Ensure cache is ready
-        pydis = self.bot.get_guild(constants.Guild.id)
-
-        unverified = pydis.get_role(constants.Roles.unverified)
-        current_dt = datetime.utcnow()  # Discord timestamps are UTC
-
-        # Users to be given the @Unverified role, and those to be kicked, these should be entirely disjoint
-        for_role, for_kick = set(), set()
-
-        log.debug("Checking verification status of guild members")
-        for member in pydis.members:
-
-            # Skip verified members, bots, and members for which we do not know their join date,
-            # this should be extremely rare but docs mention that it can happen
-            if is_verified(member) or member.bot or member.joined_at is None:
-                continue
-
-            # At this point, we know that `member` is an unverified user, and we will decide what
-            # to do with them based on time passed since their join date
-            since_join = current_dt - member.joined_at
-
-            if since_join > timedelta(days=constants.Verification.kicked_after):
-                for_kick.add(member)  # User should be removed from the guild
-
-            elif (
-                since_join > timedelta(days=constants.Verification.unverified_after)
-                and unverified not in member.roles
-            ):
-                for_role.add(member)  # User should be given the @Unverified role
-
-        log.debug(f"Found {len(for_role)} users for {unverified} role, {len(for_kick)} users to be kicked")
-        return for_role, for_kick
-
-    @tasks.loop(minutes=30)
-    async def update_unverified_members(self) -> None:
-        """
-        Periodically call `_check_members` and update unverified members accordingly.
-
-        After each run, a summary will be sent to the modlog channel. If a suspiciously high
-        amount of members to be kicked is found, the operation is guarded by `_verify_kick`.
-        """
-        log.info("Updating unverified guild members")
-
-        await self.bot.wait_until_guild_available()
-        unverified = self.bot.get_guild(constants.Guild.id).get_role(constants.Roles.unverified)
-
-        for_role, for_kick = await self._check_members()
-
-        if not for_role:
-            role_report = f"Found no users to be assigned the {unverified.mention} role."
-        else:
-            n_roles = await self._give_role(for_role, unverified)
-            role_report = f"Assigned {unverified.mention} role to `{n_roles}`/`{len(for_role)}` members."
-
-        if not for_kick:
-            kick_report = "Found no users to be kicked."
-        elif not await self._verify_kick(len(for_kick)):
-            kick_report = f"Not authorized to kick `{len(for_kick)}` members."
-        else:
-            n_kicks = await self._kick_members(for_kick)
-            kick_report = f"Kicked `{n_kicks}`/`{len(for_kick)}` members from the guild."
-
-        await self.mod_log.send_log_message(
-            icon_url=self.bot.user.avatar_url,
-            colour=discord.Colour.blurple(),
-            title="Verification system",
-            text=f"{kick_report}\n{role_report}",
-        )
-
-    # endregion
-    # region: periodically ping @Unverified
-
-    @tasks.loop(hours=constants.Verification.reminder_frequency)
-    async def ping_unverified(self) -> None:
-        """
-        Delete latest `REMINDER_MESSAGE` and send it again.
-
-        This utilizes RedisCache to persist the latest reminder message id.
-        """
-        await self.bot.wait_until_guild_available()
-        verification = self.bot.get_guild(constants.Guild.id).get_channel(constants.Channels.verification)
-
-        last_reminder: t.Optional[int] = await self.task_cache.get("last_reminder")
-
-        if last_reminder is not None:
-            log.trace(f"Found verification reminder message in cache, deleting: {last_reminder}")
-
-            with suppress(discord.HTTPException):  # If something goes wrong, just ignore it
-                await self.bot.http.delete_message(verification.id, last_reminder)
-
-        log.trace("Sending verification reminder")
-        new_reminder = await verification.send(
-            REMINDER_MESSAGE, allowed_mentions=mention_role(constants.Roles.unverified),
-        )
-
-        await self.task_cache.set("last_reminder", new_reminder.id)
-
-    @ping_unverified.before_loop
-    async def _before_first_ping(self) -> None:
-        """
-        Sleep until `REMINDER_MESSAGE` should be sent again.
-
-        If latest reminder is not cached, exit instantly. Otherwise, wait wait until the
-        configured `reminder_frequency` has passed.
-        """
-        last_reminder: t.Optional[int] = await self.task_cache.get("last_reminder")
-
-        if last_reminder is None:
-            log.trace("Latest verification reminder message not cached, task will not wait")
-            return
-
-        # Convert cached message id into a timestamp
-        time_since = datetime.utcnow() - snowflake_time(last_reminder)
-        log.trace(f"Time since latest verification reminder: {time_since}")
-
-        to_sleep = timedelta(hours=constants.Verification.reminder_frequency) - time_since
-        log.trace(f"Time to sleep until next ping: {to_sleep}")
-
-        # Delta can be negative if `reminder_frequency` has already passed
-        secs = max(to_sleep.total_seconds(), 0)
-        await asyncio.sleep(secs)
-
-    # endregion
     # region: listeners
 
     @Cog.listener()
@@ -586,183 +105,12 @@ class Verification(Cog):
                 # and has gone through the alternate gating system we should send
                 # our alternate welcome DM which includes info such as our welcome
                 # video.
-                await safe_dm(after.send(ALTERNATE_VERIFIED_MESSAGE))
+                await safe_dm(after.send(VERIFIED_MESSAGE))
             except discord.HTTPException:
                 log.exception("DM dispatch failed on unexpected error code")
 
-    @Cog.listener()
-    async def on_message(self, message: discord.Message) -> None:
-        """Check new message event for messages to the checkpoint channel & process."""
-        if message.channel.id != constants.Channels.verification:
-            return  # Only listen for #checkpoint messages
-
-        if message.content == REMINDER_MESSAGE:
-            return  # Ignore bots own verification reminder
-
-        if message.author.bot:
-            # They're a bot, delete their message after the delay.
-            await message.delete(delay=constants.Verification.bot_message_delete_delay)
-            return
-
-        # if a user mentions a role or guild member
-        # alert the mods in mod-alerts channel
-        if message.mentions or message.role_mentions:
-            log.debug(
-                f"{message.author} mentioned one or more users "
-                f"and/or roles in {message.channel.name}"
-            )
-
-            embed_text = (
-                f"{format_user(message.author)} sent a message in "
-                f"{message.channel.mention} that contained user and/or role mentions."
-                f"\n\n**Original message:**\n>>> {message.content}"
-            )
-
-            # Send pretty mod log embed to mod-alerts
-            await self.mod_log.send_log_message(
-                icon_url=constants.Icons.filtering,
-                colour=discord.Colour(constants.Colours.soft_red),
-                title=f"User/Role mentioned in {message.channel.name}",
-                text=embed_text,
-                thumbnail=message.author.avatar_url_as(static_format="png"),
-                channel_id=constants.Channels.mod_alerts,
-            )
-
-        ctx: Context = await self.bot.get_context(message)
-        if ctx.command is not None and ctx.command.name == "accept":
-            return
-
-        if any(r.id == constants.Roles.verified for r in ctx.author.roles):
-            log.info(
-                f"{ctx.author} posted '{ctx.message.content}' "
-                "in the verification channel, but is already verified."
-            )
-            return
-
-        log.debug(
-            f"{ctx.author} posted '{ctx.message.content}' in the verification "
-            "channel. We are providing instructions how to verify."
-        )
-        await ctx.send(
-            f"{ctx.author.mention} Please type `!accept` to verify that you accept our rules, "
-            f"and gain access to the rest of the server.",
-            delete_after=20
-        )
-
-        log.trace(f"Deleting the message posted by {ctx.author}")
-        with suppress(discord.NotFound):
-            await ctx.message.delete()
-
     # endregion
-    # region: task management commands
-
-    @has_any_role(*constants.MODERATION_ROLES)
-    @group(name="verification")
-    async def verification_group(self, ctx: Context) -> None:
-        """Manage internal verification tasks."""
-        if ctx.invoked_subcommand is None:
-            await ctx.send_help(ctx.command)
-
-    @verification_group.command(name="status")
-    async def status_cmd(self, ctx: Context) -> None:
-        """Check whether verification tasks are running."""
-        log.trace("Checking status of verification tasks")
-
-        if self.update_unverified_members.is_running():
-            update_status = f"{constants.Emojis.incident_actioned} Member update task is running."
-        else:
-            update_status = f"{constants.Emojis.incident_unactioned} Member update task is **not** running."
-
-        mention = f"<@&{constants.Roles.unverified}>"
-        if self.ping_unverified.is_running():
-            ping_status = f"{constants.Emojis.incident_actioned} Ping {mention} task is running."
-        else:
-            ping_status = f"{constants.Emojis.incident_unactioned} Ping {mention} task is **not** running."
-
-        embed = discord.Embed(
-            title="Verification system",
-            description=f"{update_status}\n{ping_status}",
-            colour=discord.Colour.blurple(),
-        )
-        await ctx.send(embed=embed)
-
-    @verification_group.command(name="start")
-    async def start_cmd(self, ctx: Context) -> None:
-        """Start verification tasks if they are not already running."""
-        log.info("Starting verification tasks")
-
-        if not self.update_unverified_members.is_running():
-            self.update_unverified_members.start()
-
-        if not self.ping_unverified.is_running():
-            self.ping_unverified.start()
-
-        await self.task_cache.set("tasks_running", 1)
-
-        colour = discord.Colour.blurple()
-        await ctx.send(embed=discord.Embed(title="Verification system", description="Done. :ok_hand:", colour=colour))
-
-    @verification_group.command(name="stop", aliases=["kill"])
-    async def stop_cmd(self, ctx: Context) -> None:
-        """Stop verification tasks."""
-        log.info("Stopping verification tasks")
-
-        self._stop_tasks(gracefully=False)
-        await self.task_cache.set("tasks_running", 0)
-
-        colour = discord.Colour.blurple()
-        await ctx.send(embed=discord.Embed(title="Verification system", description="Tasks canceled.", colour=colour))
-
-    # endregion
-    # region: accept and subscribe commands
-
-    def _bump_verified_stats(self, verified_member: discord.Member) -> None:
-        """
-        Increment verification stats for `verified_member`.
-
-        Each member falls into one of the three categories:
-            * Verified within 24 hours after joining
-            * Does not have @Unverified role yet
-            * Does have @Unverified role
-
-        Stats for member kicking are handled separately.
-        """
-        if verified_member.joined_at is None:  # Docs mention this can happen
-            return
-
-        if (datetime.utcnow() - verified_member.joined_at) < timedelta(hours=24):
-            category = "accepted_on_day_one"
-        elif constants.Roles.unverified not in [role.id for role in verified_member.roles]:
-            category = "accepted_before_unverified"
-        else:
-            category = "accepted_after_unverified"
-
-        log.trace(f"Bumping verification stats in category: {category}")
-        self.bot.stats.incr(f"verification.{category}")
-
-    @command(name='accept', aliases=('verified', 'accepted'), hidden=True)
-    @has_no_roles(constants.Roles.verified)
-    @in_whitelist(channels=(constants.Channels.verification,))
-    async def accept_command(self, ctx: Context, *_) -> None:  # We don't actually care about the args
-        """Accept our rules and gain access to the rest of the server."""
-        log.debug(f"{ctx.author} called !accept. Assigning the 'Developer' role.")
-        await ctx.author.add_roles(discord.Object(constants.Roles.verified), reason="Accepted the rules")
-
-        self._bump_verified_stats(ctx.author)  # This checks for @Unverified so make sure it's not yet removed
-
-        if constants.Roles.unverified in [role.id for role in ctx.author.roles]:
-            log.debug(f"Removing Unverified role from: {ctx.author}")
-            await ctx.author.remove_roles(discord.Object(constants.Roles.unverified))
-
-        try:
-            await safe_dm(ctx.author.send(VERIFIED_MESSAGE))
-        except discord.HTTPException:
-            log.exception(f"Sending welcome message failed for {ctx.author}.")
-        finally:
-            log.trace(f"Deleting accept message by {ctx.author}.")
-            with suppress(discord.NotFound):
-                self.mod_log.ignore(constants.Event.message_delete, ctx.message.id)
-                await ctx.message.delete()
+    # region: subscribe commands
 
     @command(name='subscribe')
     @in_whitelist(channels=(constants.Channels.bot_commands,))
@@ -823,15 +171,6 @@ class Verification(Cog):
         if isinstance(error, InWhitelistCheckFailure):
             error.handled = True
 
-    @staticmethod
-    async def bot_check(ctx: Context) -> bool:
-        """Block any command within the verification channel that is not !accept."""
-        is_verification = ctx.channel.id == constants.Channels.verification
-        if is_verification and await has_no_roles_check(ctx, *constants.MODERATION_ROLES):
-            return ctx.command.name == "accept"
-        else:
-            return True
-
     @command(name='verify')
     @has_any_role(*constants.MODERATION_ROLES)
     async def perform_manual_verification(self, ctx: Context, user: discord.Member) -> None:
diff --git a/bot/exts/utils/jams.py b/bot/exts/utils/jams.py
index 1c0988343..98fbcb303 100644
--- a/bot/exts/utils/jams.py
+++ b/bot/exts/utils/jams.py
@@ -93,10 +93,6 @@ class CodeJams(commands.Cog):
                 connect=True
             ),
             guild.default_role: PermissionOverwrite(read_messages=False, connect=False),
-            guild.get_role(Roles.verified): PermissionOverwrite(
-                read_messages=False,
-                connect=False
-            )
         }
 
         # Rest of members should just have read_messages
diff --git a/bot/rules/burst_shared.py b/bot/rules/burst_shared.py
index 0e66df69c..bbe9271b3 100644
--- a/bot/rules/burst_shared.py
+++ b/bot/rules/burst_shared.py
@@ -2,20 +2,11 @@ from typing import Dict, Iterable, List, Optional, Tuple
 
 from discord import Member, Message
 
-from bot.constants import Channels
-
 
 async def apply(
     last_message: Message, recent_messages: List[Message], config: Dict[str, int]
 ) -> Optional[Tuple[str, Iterable[Member], Iterable[Message]]]:
-    """
-    Detects repeated messages sent by multiple users.
-
-    This filter never triggers in the verification channel.
-    """
-    if last_message.channel.id == Channels.verification:
-        return
-
+    """Detects repeated messages sent by multiple users."""
     total_recent = len(recent_messages)
 
     if total_recent > config['max']:
diff --git a/config-default.yml b/config-default.yml
index e713a59d2..175460a31 100644
--- a/config-default.yml
+++ b/config-default.yml
@@ -173,7 +173,6 @@ guild:
         # Special
         bot_commands:       &BOT_CMD        267659945086812160
         esoteric:                           470884583684964352
-        verification:                       352442727016693763
         voice_gate:                         764802555427029012
 
         # Staff
@@ -244,8 +243,6 @@ guild:
         python_community:   &PY_COMMUNITY_ROLE  458226413825294336
         sprinters:          &SPRINTERS          758422482289426471
 
-        unverified:                             739794855945044069
-        verified:                               352427296948486144  # @Developers on PyDis
         voice_verified:                         764802720779337729
 
         # Staff
@@ -514,18 +511,6 @@ python_news:
     webhook: *PYNEWS_WEBHOOK
 
 
-verification:
-    unverified_after: 3  # Days after which non-Developers receive the @Unverified role
-    kicked_after: 30  # Days after which non-Developers get kicked from the guild
-    reminder_frequency: 28  # Hours between @Unverified pings
-    bot_message_delete_delay: 10  # Seconds before deleting bots response in #verification
-
-    # Number in range [0, 1] determining the percentage of unverified users that are safe
-    # to be kicked from the guild in one batch, any larger amount will require staff confirmation,
-    # set this to 0 to require explicit approval for batches of any size
-    kick_confirmation_threshold: 0.01  # 1%
-
-
 voice_gate:
     minimum_days_member: 3  # How many days the user must have been a member for
     minimum_messages: 50  # How many messages a user must have to be eligible for voice
diff --git a/tests/bot/exts/utils/test_jams.py b/tests/bot/exts/utils/test_jams.py
index 45e7b5b51..85d6a1173 100644
--- a/tests/bot/exts/utils/test_jams.py
+++ b/tests/bot/exts/utils/test_jams.py
@@ -118,11 +118,9 @@ class JamCreateTeamTests(unittest.IsolatedAsyncioTestCase):
             self.assertTrue(overwrites[member].read_messages)
             self.assertTrue(overwrites[member].connect)
 
-        # Everyone and verified role overwrite
+        # Everyone role overwrite
         self.assertFalse(overwrites[self.guild.default_role].read_messages)
         self.assertFalse(overwrites[self.guild.default_role].connect)
-        self.assertFalse(overwrites[self.guild.get_role(Roles.verified)].read_messages)
-        self.assertFalse(overwrites[self.guild.get_role(Roles.verified)].connect)
 
     async def test_team_channels_creation(self):
         """Should create new voice and text channel for team."""
-- 
cgit v1.2.3