From a98485e173208cc2272f5c6355ddaf5858050403 Mon Sep 17 00:00:00 2001
From: Leon Sandøy <leon.sandoy@conmodo.com>
Date: Thu, 31 Oct 2019 07:39:03 +0100
Subject: Figure out which tests we need.

This adds empty tests for all the tests I'd like to add to this
pull request. It also adds a few more duckies to the emoji
constant list, and adds a single line of clarification to the
testing readme.
---
 tests/README.md                  |  1 +
 tests/bot/cogs/test_duck_pond.py | 80 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 81 insertions(+)
 create mode 100644 tests/bot/cogs/test_duck_pond.py

(limited to 'tests')

diff --git a/tests/README.md b/tests/README.md
index 6ab9bc93e..d052de2f6 100644
--- a/tests/README.md
+++ b/tests/README.md
@@ -15,6 +15,7 @@ We are using the following modules and packages for our unit tests:
 To ensure the results you obtain on your personal machine are comparable to those generated in the Azure pipeline, please make sure to run your tests with the virtual environment defined by our [Pipfile](/Pipfile). To run your tests with `pipenv`, we've provided two "scripts" shortcuts:
 
 - `pipenv run test` will run `unittest` with `coverage.py`
+- `pipenv run test path/to/test.py` will run a specific test.
 - `pipenv run report` will generate a coverage report of the tests you've run with `pipenv run test`. If you append the `-m` flag to this command, the report will include the lines and branches not covered by tests in addition to the test coverage report.
 
 If you want a coverage report, make sure to run the tests with `pipenv run test` *first*.
diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
new file mode 100644
index 000000000..79f11843b
--- /dev/null
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -0,0 +1,80 @@
+import logging
+import unittest
+from unittest.mock import MagicMock
+
+from bot.cogs import duck_pond
+from tests.helpers import MockBot, MockMessage
+
+
+class DuckPondTest(unittest.TestCase):
+    """Tests the `DuckPond` cog."""
+
+    def setUp(self):
+        """Adds the cog, a bot, and a message to the instance for usage in tests."""
+        self.bot = MockBot()
+        self.cog = duck_pond.DuckPond(bot=self.bot)
+
+        self.msg = MockMessage(message_id=555, content='')
+        self.msg.author.__str__ = MagicMock()
+        self.msg.author.__str__.return_value = 'lemon'
+        self.msg.author.bot = False
+        self.msg.author.avatar_url_as.return_value = 'picture-lemon.png'
+        self.msg.author.id = 42
+        self.msg.author.mention = '@lemon'
+        self.msg.channel.mention = "#lemonade-stand"
+
+    def test_is_staff_correctly_identifies_staff(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        pass
+
+    def test_has_green_checkmark(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        pass
+
+    def test_count_custom_duck_emojis(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        pass
+
+    def test_count_unicode_duck_emojis(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        pass
+
+    def test_count_mixed_duck_emojis(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        pass
+
+    def test_raw_reaction_add_rejects_bot(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        pass
+
+    def test_raw_reaction_add_rejects_non_staff(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        pass
+
+    def test_raw_reaction_add_sends_message_on_valid_input(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        pass
+
+    def test_raw_reaction_remove_rejects_non_checkmarks(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        pass
+
+    def test_raw_reaction_remove_prevents_checkmark_removal(self):
+        """A string decoding to numeric characters is a valid user ID."""
+        pass
+
+
+class DuckPondSetupTests(unittest.TestCase):
+    """Tests setup of the `DuckPond` cog."""
+
+    def test_setup(self):
+        """Setup of the cog should log a message at `INFO` level."""
+        bot = MockBot()
+        log = logging.getLogger('bot.cogs.duck_pond')
+
+        with self.assertLogs(logger=log, level=logging.INFO) as log_watcher:
+            duck_pond.setup(bot)
+            line = log_watcher.output[0]
+
+        bot.add_cog.assert_called_once()
+        self.assertIn("Cog loaded: DuckPond", line)
-- 
cgit v1.2.3


From acb937dc24b30c84b4978f651a642208f562c36e Mon Sep 17 00:00:00 2001
From: Leon Sandøy <leon.sandoy@conmodo.com>
Date: Sun, 3 Nov 2019 22:34:16 +0100
Subject: Test is_staff and has_green_checkmark.

---
 tests/bot/cogs/test_duck_pond.py | 52 +++++++++++++++++++++++++++-------------
 1 file changed, 35 insertions(+), 17 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
index 79f11843b..31c7e9f89 100644
--- a/tests/bot/cogs/test_duck_pond.py
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -1,35 +1,53 @@
 import logging
 import unittest
-from unittest.mock import MagicMock
 
 from bot.cogs import duck_pond
-from tests.helpers import MockBot, MockMessage
+from tests.helpers import MockBot, MockMember, MockMessage, MockReaction, MockRole
 
 
 class DuckPondTest(unittest.TestCase):
     """Tests the `DuckPond` cog."""
 
     def setUp(self):
-        """Adds the cog, a bot, and a message to the instance for usage in tests."""
+        """Adds the cog, a bot, and the mocks we'll need for our tests."""
         self.bot = MockBot()
         self.cog = duck_pond.DuckPond(bot=self.bot)
 
-        self.msg = MockMessage(message_id=555, content='')
-        self.msg.author.__str__ = MagicMock()
-        self.msg.author.__str__.return_value = 'lemon'
-        self.msg.author.bot = False
-        self.msg.author.avatar_url_as.return_value = 'picture-lemon.png'
-        self.msg.author.id = 42
-        self.msg.author.mention = '@lemon'
-        self.msg.channel.mention = "#lemonade-stand"
+        # Set up some roles
+        self.admin_role = MockRole(name="Admins", role_id=476190234653229056)
+        self.contrib_role = MockRole(name="Contributor", role_id=476190302659543061)
 
-    def test_is_staff_correctly_identifies_staff(self):
-        """A string decoding to numeric characters is a valid user ID."""
-        pass
+        # Set up some users
+        self.admin_member = MockMember(roles=(self.admin_role,))
+        self.contrib_member = MockMember(roles=(self.contrib_role,))
+        self.no_role_member = MockMember()
 
-    def test_has_green_checkmark(self):
-        """A string decoding to numeric characters is a valid user ID."""
-        pass
+        # Set up emojis
+        self.checkmark_emoji = "✅"
+        self.thumbs_up_emoji = "👍"
+
+        # Set up reactions
+        self.checkmark_reaction = MockReaction(emoji=self.checkmark_emoji)
+        self.thumbs_up_reaction = MockReaction(emoji=self.thumbs_up_emoji)
+
+        # Set up a messages
+        self.checkmark_message = MockMessage(reactions=(self.checkmark_reaction,))
+        self.thumbs_up_message = MockMessage(reactions=(self.thumbs_up_reaction,))
+        self.no_reaction_message = MockMessage()
+
+    def test_is_staff_correctly_identifies_staff(self):
+        """Test that is_staff correctly identifies a staff member."""
+        with self.subTest():
+            self.assertTrue(duck_pond.DuckPond.is_staff(self.admin_member))
+            self.assertFalse(duck_pond.DuckPond.is_staff(self.contrib_member))
+            self.assertFalse(duck_pond.DuckPond.is_staff(self.no_role_member))
+
+    def test_has_green_checkmark_correctly_identifies_messages(self):
+        """Test that has_green_checkmark recognizes messages with checkmarks."""
+        with self.subTest():
+            self.assertTrue(duck_pond.DuckPond.has_green_checkmark(self.checkmark_message))
+            self.assertFalse(duck_pond.DuckPond.has_green_checkmark(self.thumbs_up_message))
+            self.assertFalse(duck_pond.DuckPond.has_green_checkmark(self.no_reaction_message))
 
     def test_count_custom_duck_emojis(self):
         """A string decoding to numeric characters is a valid user ID."""
-- 
cgit v1.2.3


From aac8404f65b419e212e5372015b63871fab7f3d1 Mon Sep 17 00:00:00 2001
From: Leon Sandøy <leon.sandoy@conmodo.com>
Date: Mon, 11 Nov 2019 07:19:07 +0100
Subject: Adding ducky count tests and a new AsyncIteratorMock

---
 tests/bot/cogs/test_duck_pond.py | 70 ++++++++++++++++++++++++++++++++--------
 tests/helpers.py                 | 38 +++++++++++++++++++++-
 2 files changed, 93 insertions(+), 15 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
index 31c7e9f89..af8ef0e4d 100644
--- a/tests/bot/cogs/test_duck_pond.py
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -1,8 +1,10 @@
+import asyncio
 import logging
 import unittest
 
+from bot import constants
 from bot.cogs import duck_pond
-from tests.helpers import MockBot, MockMember, MockMessage, MockReaction, MockRole
+from tests.helpers import MockBot, MockEmoji, MockMember, MockMessage, MockReaction, MockRole
 
 
 class DuckPondTest(unittest.TestCase):
@@ -13,49 +15,89 @@ class DuckPondTest(unittest.TestCase):
         self.bot = MockBot()
         self.cog = duck_pond.DuckPond(bot=self.bot)
 
+        # Override the constants we'll be needing
+        constants.STAFF_ROLES = (123,)
+        constants.DuckPond.custom_emojis = (789,)
+        constants.DuckPond.threshold = 1
+
         # Set up some roles
-        self.admin_role = MockRole(name="Admins", role_id=476190234653229056)
-        self.contrib_role = MockRole(name="Contributor", role_id=476190302659543061)
+        self.admin_role = MockRole(name="Admins", role_id=123)
+        self.contrib_role = MockRole(name="Contributor", role_id=456)
 
         # Set up some users
-        self.admin_member = MockMember(roles=(self.admin_role,))
+        self.admin_member_1 = MockMember(roles=(self.admin_role,), id=1)
+        self.admin_member_2 = MockMember(roles=(self.admin_role,), id=2)
         self.contrib_member = MockMember(roles=(self.contrib_role,))
         self.no_role_member = MockMember()
 
         # Set up emojis
         self.checkmark_emoji = "✅"
         self.thumbs_up_emoji = "👍"
+        self.unicode_duck_emoji = "🦆"
+        self.yellow_ducky_emoji = MockEmoji(id=789)
 
         # Set up reactions
-        self.checkmark_reaction = MockReaction(emoji=self.checkmark_emoji)
-        self.thumbs_up_reaction = MockReaction(emoji=self.thumbs_up_emoji)
+        self.checkmark_reaction = MockReaction(
+            emoji=self.checkmark_emoji,
+            user_list=[self.admin_member_1]
+        )
+        self.thumbs_up_reaction = MockReaction(
+            emoji=self.thumbs_up_emoji,
+            user_list=[self.admin_member_1, self.contrib_member]
+        )
+        self.yellow_ducky_reaction = MockReaction(
+            emoji=self.yellow_ducky_emoji,
+            user_list=[self.admin_member_1, self.contrib_member]
+        )
+        self.unicode_duck_reaction_1 = MockReaction(
+            emoji=self.unicode_duck_emoji,
+            user_list=[self.admin_member_1]
+        )
+        self.unicode_duck_reaction_2 = MockReaction(
+            emoji=self.unicode_duck_emoji,
+            user_list=[self.admin_member_2]
+        )
 
         # Set up a messages
         self.checkmark_message = MockMessage(reactions=(self.checkmark_reaction,))
         self.thumbs_up_message = MockMessage(reactions=(self.thumbs_up_reaction,))
+        self.yellow_ducky_message = MockMessage(reactions=(self.yellow_ducky_reaction,))
+        self.unicode_duck_message = MockMessage(reactions=(self.unicode_duck_reaction_1,))
+        self.double_duck_message = MockMessage(reactions=(self.unicode_duck_reaction_1, self.unicode_duck_reaction_2))
         self.no_reaction_message = MockMessage()
 
     def test_is_staff_correctly_identifies_staff(self):
         """Test that is_staff correctly identifies a staff member."""
         with self.subTest():
-            self.assertTrue(duck_pond.DuckPond.is_staff(self.admin_member))
-            self.assertFalse(duck_pond.DuckPond.is_staff(self.contrib_member))
-            self.assertFalse(duck_pond.DuckPond.is_staff(self.no_role_member))
+            self.assertTrue(self.cog.is_staff(self.admin_member_1))
+            self.assertFalse(self.cog.is_staff(self.contrib_member))
+            self.assertFalse(self.cog.is_staff(self.no_role_member))
 
     def test_has_green_checkmark_correctly_identifies_messages(self):
         """Test that has_green_checkmark recognizes messages with checkmarks."""
         with self.subTest():
-            self.assertTrue(duck_pond.DuckPond.has_green_checkmark(self.checkmark_message))
-            self.assertFalse(duck_pond.DuckPond.has_green_checkmark(self.thumbs_up_message))
-            self.assertFalse(duck_pond.DuckPond.has_green_checkmark(self.no_reaction_message))
+            self.assertTrue(self.cog.has_green_checkmark(self.checkmark_message))
+            self.assertFalse(self.cog.has_green_checkmark(self.thumbs_up_message))
+            self.assertFalse(self.cog.has_green_checkmark(self.no_reaction_message))
 
     def test_count_custom_duck_emojis(self):
         """A string decoding to numeric characters is a valid user ID."""
-        pass
+        count_one_duck = self.cog.count_ducks(self.yellow_ducky_message)
+        count_no_ducks = self.cog.count_ducks(self.thumbs_up_message)
+        with self.subTest():
+            self.assertEqual(asyncio.run(count_one_duck), 1)
+            self.assertEqual(asyncio.run(count_no_ducks), 0)
 
     def test_count_unicode_duck_emojis(self):
         """A string decoding to numeric characters is a valid user ID."""
-        pass
+        count_no_ducks = self.cog.count_ducks(self.thumbs_up_message)
+        count_one_duck = self.cog.count_ducks(self.unicode_duck_message)
+        count_two_ducks = self.cog.count_ducks(self.double_duck_message)
+
+        with self.subTest():
+            self.assertEqual(asyncio.run(count_no_ducks), 0)
+            self.assertEqual(asyncio.run(count_one_duck), 1)
+            self.assertEqual(asyncio.run(count_two_ducks), 2)
 
     def test_count_mixed_duck_emojis(self):
         """A string decoding to numeric characters is a valid user ID."""
diff --git a/tests/helpers.py b/tests/helpers.py
index 8496ba031..fd79141ec 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -102,8 +102,30 @@ class AsyncMock(CustomMockMixin, unittest.mock.MagicMock):
     Python 3.8 will introduce an AsyncMock class in the standard library that will have some more
     features; this stand-in only overwrites the `__call__` method to an async version.
     """
+
     async def __call__(self, *args, **kwargs):
-        return super(AsyncMock, self).__call__(*args, **kwargs)
+        return super().__call__(*args, **kwargs)
+
+
+class AsyncIteratorMock:
+    """
+    A class to mock asyncronous iterators.
+
+    This allows async for, which is used in certain Discord.py objects. For example,
+    an async iterator is returned by the Reaction.users() coroutine.
+    """
+
+    def __init__(self, sequence):
+        self.iter = iter(sequence)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        try:
+            return next(self.iter)
+        except StopIteration:
+            raise StopAsyncIteration
 
 
 # Create a guild instance to get a realistic Mock of `discord.Guild`
@@ -155,6 +177,7 @@ class MockGuild(CustomMockMixin, unittest.mock.Mock, HashableMixin):
 
     For more info, see the `Mocking` section in `tests/README.md`.
     """
+
     def __init__(
         self,
         guild_id: int = 1,
@@ -187,6 +210,7 @@ class MockRole(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin):
     Instances of this class will follow the specifications of `discord.Role` instances. For more
     information, see the `MockGuild` docstring.
     """
+
     def __init__(self, name: str = "role", role_id: int = 1, position: int = 1, **kwargs) -> None:
         super().__init__(spec=role_instance, **kwargs)
 
@@ -213,6 +237,7 @@ class MockMember(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin
     Instances of this class will follow the specifications of `discord.Member` instances. For more
     information, see the `MockGuild` docstring.
     """
+
     def __init__(
         self,
         name: str = "member",
@@ -243,6 +268,7 @@ class MockBot(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.ext.commands.Bot` instances.
     For more information, see the `MockGuild` docstring.
     """
+
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=bot_instance, **kwargs)
 
@@ -279,6 +305,7 @@ class MockTextChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
     Instances of this class will follow the specifications of `discord.TextChannel` instances. For
     more information, see the `MockGuild` docstring.
     """
+
     def __init__(self, name: str = 'channel', channel_id: int = 1, **kwargs) -> None:
         super().__init__(spec=channel_instance, **kwargs)
         self.id = channel_id
@@ -320,6 +347,7 @@ class MockContext(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.ext.commands.Context`
     instances. For more information, see the `MockGuild` docstring.
     """
+
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=context_instance, **kwargs)
         self.bot = kwargs.get('bot', MockBot())
@@ -336,6 +364,7 @@ class MockMessage(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.Message` instances. For more
     information, see the `MockGuild` docstring.
     """
+
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=message_instance, **kwargs)
         self.author = kwargs.get('author', MockMember())
@@ -353,6 +382,7 @@ class MockEmoji(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.Emoji` instances. For more
     information, see the `MockGuild` docstring.
     """
+
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=emoji_instance, **kwargs)
         self.guild = kwargs.get('guild', MockGuild())
@@ -371,6 +401,7 @@ class MockPartialEmoji(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.PartialEmoji` instances. For
     more information, see the `MockGuild` docstring.
     """
+
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=partial_emoji_instance, **kwargs)
 
@@ -385,7 +416,12 @@ class MockReaction(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.Reaction` instances. For
     more information, see the `MockGuild` docstring.
     """
+
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=reaction_instance, **kwargs)
         self.emoji = kwargs.get('emoji', MockEmoji())
         self.message = kwargs.get('message', MockMessage())
+        self.user_list = AsyncIteratorMock(kwargs.get('user_list', []))
+
+    def users(self):
+        return self.user_list
-- 
cgit v1.2.3


From 98ccfbc218dc762e45f0146d0503dba1fe06fdb9 Mon Sep 17 00:00:00 2001
From: Leon Sandøy <leon.haland@gmail.com>
Date: Mon, 11 Nov 2019 14:55:40 +0100
Subject: Implement a mixed duck test.

Also gets started setting up for the final tests, which will require
more mockwork.
---
 tests/bot/cogs/test_duck_pond.py | 30 ++++++++++++++++++++----------
 1 file changed, 20 insertions(+), 10 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
index af8ef0e4d..211e8b084 100644
--- a/tests/bot/cogs/test_duck_pond.py
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -20,6 +20,10 @@ class DuckPondTest(unittest.TestCase):
         constants.DuckPond.custom_emojis = (789,)
         constants.DuckPond.threshold = 1
 
+        # Mock bot.get_all_channels()
+        CHANNEL_ID = 555
+        USER_ID = 666
+
         # Set up some roles
         self.admin_role = MockRole(name="Admins", role_id=123)
         self.contrib_role = MockRole(name="Contributor", role_id=456)
@@ -63,7 +67,12 @@ class DuckPondTest(unittest.TestCase):
         self.thumbs_up_message = MockMessage(reactions=(self.thumbs_up_reaction,))
         self.yellow_ducky_message = MockMessage(reactions=(self.yellow_ducky_reaction,))
         self.unicode_duck_message = MockMessage(reactions=(self.unicode_duck_reaction_1,))
-        self.double_duck_message = MockMessage(reactions=(self.unicode_duck_reaction_1, self.unicode_duck_reaction_2))
+        self.double_unicode_duck_message = MockMessage(
+            reactions=(self.unicode_duck_reaction_1, self.unicode_duck_reaction_2)
+        )
+        self.double_mixed_duck_message = MockMessage(
+            reactions=(self.unicode_duck_reaction_1, self.yellow_ducky_reaction)
+        )
         self.no_reaction_message = MockMessage()
 
     def test_is_staff_correctly_identifies_staff(self):
@@ -81,27 +90,28 @@ class DuckPondTest(unittest.TestCase):
             self.assertFalse(self.cog.has_green_checkmark(self.no_reaction_message))
 
     def test_count_custom_duck_emojis(self):
-        """A string decoding to numeric characters is a valid user ID."""
-        count_one_duck = self.cog.count_ducks(self.yellow_ducky_message)
+        """Test that count_ducks counts custom ducks correctly."""
         count_no_ducks = self.cog.count_ducks(self.thumbs_up_message)
+        count_one_duck = self.cog.count_ducks(self.yellow_ducky_message)
         with self.subTest():
-            self.assertEqual(asyncio.run(count_one_duck), 1)
             self.assertEqual(asyncio.run(count_no_ducks), 0)
+            self.assertEqual(asyncio.run(count_one_duck), 1)
 
     def test_count_unicode_duck_emojis(self):
-        """A string decoding to numeric characters is a valid user ID."""
-        count_no_ducks = self.cog.count_ducks(self.thumbs_up_message)
+        """Test that count_ducks counts unicode ducks correctly."""
         count_one_duck = self.cog.count_ducks(self.unicode_duck_message)
-        count_two_ducks = self.cog.count_ducks(self.double_duck_message)
+        count_two_ducks = self.cog.count_ducks(self.double_unicode_duck_message)
 
         with self.subTest():
-            self.assertEqual(asyncio.run(count_no_ducks), 0)
             self.assertEqual(asyncio.run(count_one_duck), 1)
             self.assertEqual(asyncio.run(count_two_ducks), 2)
 
     def test_count_mixed_duck_emojis(self):
-        """A string decoding to numeric characters is a valid user ID."""
-        pass
+        """Test that count_ducks counts mixed ducks correctly."""
+        count_two_ducks = self.cog.count_ducks(self.double_mixed_duck_message)
+
+        with self.subTest():
+            self.assertEqual(asyncio.run(count_two_ducks), 2)
 
     def test_raw_reaction_add_rejects_bot(self):
         """A string decoding to numeric characters is a valid user ID."""
-- 
cgit v1.2.3


From a89349ee32bbf2b3506cc278999575db1fbfde74 Mon Sep 17 00:00:00 2001
From: Leon Sandøy <leon.sandoy@conmodo.com>
Date: Tue, 12 Nov 2019 22:05:28 +0100
Subject: Add tests for on_raw_reaction_add.

Basically I suck at this and I can't get this return_value thing to work.
I'll have Ves look at it to resolve it.

As of right now, multiple tests are failing.
---
 tests/bot/cogs/test_duck_pond.py | 84 +++++++++++++++++++++++++++++++++-------
 1 file changed, 70 insertions(+), 14 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
index 211e8b084..088d8ac79 100644
--- a/tests/bot/cogs/test_duck_pond.py
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -1,10 +1,11 @@
 import asyncio
 import logging
 import unittest
+from unittest.mock import MagicMock
 
 from bot import constants
 from bot.cogs import duck_pond
-from tests.helpers import MockBot, MockEmoji, MockMember, MockMessage, MockReaction, MockRole
+from tests.helpers import MockBot, MockEmoji, MockMember, MockMessage, MockReaction, MockRole, MockTextChannel
 
 
 class DuckPondTest(unittest.TestCase):
@@ -15,23 +16,27 @@ class DuckPondTest(unittest.TestCase):
         self.bot = MockBot()
         self.cog = duck_pond.DuckPond(bot=self.bot)
 
+        # Set up some constants
+        self.CHANNEL_ID = 555
+        self.MESSAGE_ID = 666
+        self.BOT_ID = 777
+        self.CONTRIB_ID = 888
+        self.ADMIN_ID = 999
+
         # Override the constants we'll be needing
         constants.STAFF_ROLES = (123,)
         constants.DuckPond.custom_emojis = (789,)
         constants.DuckPond.threshold = 1
 
-        # Mock bot.get_all_channels()
-        CHANNEL_ID = 555
-        USER_ID = 666
-
         # Set up some roles
         self.admin_role = MockRole(name="Admins", role_id=123)
         self.contrib_role = MockRole(name="Contributor", role_id=456)
 
         # Set up some users
-        self.admin_member_1 = MockMember(roles=(self.admin_role,), id=1)
-        self.admin_member_2 = MockMember(roles=(self.admin_role,), id=2)
-        self.contrib_member = MockMember(roles=(self.contrib_role,))
+        self.admin_member_1 = MockMember(roles=(self.admin_role,), id=self.ADMIN_ID)
+        self.admin_member_2 = MockMember(roles=(self.admin_role,), id=911)
+        self.contrib_member = MockMember(roles=(self.contrib_role,), id=self.CONTRIB_ID)
+        self.bot_member = MockMember(roles=(self.contrib_role,), id=self.BOT_ID, bot=True)
         self.no_role_member = MockMember()
 
         # Set up emojis
@@ -61,6 +66,14 @@ class DuckPondTest(unittest.TestCase):
             emoji=self.unicode_duck_emoji,
             user_list=[self.admin_member_2]
         )
+        self.bot_reaction = MockReaction(
+            emoji=self.yellow_ducky_emoji,
+            user_list=[self.bot_member]
+        )
+        self.contrib_reaction = MockReaction(
+            emoji=self.yellow_ducky_emoji,
+            user_list=[self.contrib_member]
+        )
 
         # Set up a messages
         self.checkmark_message = MockMessage(reactions=(self.checkmark_reaction,))
@@ -73,8 +86,18 @@ class DuckPondTest(unittest.TestCase):
         self.double_mixed_duck_message = MockMessage(
             reactions=(self.unicode_duck_reaction_1, self.yellow_ducky_reaction)
         )
+
+        self.bot_message = MockMessage(reactions=(self.bot_reaction,))
+        self.contrib_message = MockMessage(reactions=(self.contrib_reaction,))
         self.no_reaction_message = MockMessage()
 
+        # Set up some channels
+        self.text_channel = MockTextChannel(id=self.CHANNEL_ID)
+
+    @staticmethod
+    def _mock_send_webhook(content, username, avatar_url, embed):
+        """Mock for the send_webhook method in DuckPond"""
+
     def test_is_staff_correctly_identifies_staff(self):
         """Test that is_staff correctly identifies a staff member."""
         with self.subTest():
@@ -114,16 +137,49 @@ class DuckPondTest(unittest.TestCase):
             self.assertEqual(asyncio.run(count_two_ducks), 2)
 
     def test_raw_reaction_add_rejects_bot(self):
-        """A string decoding to numeric characters is a valid user ID."""
-        pass
+        """Test that send_webhook is not called if the user is a bot."""
+        self.text_channel.fetch_message.return_value = self.bot_message
+        self.bot.get_all_channels.return_value = (self.text_channel,)
+
+        payload = MagicMock(  # RawReactionActionEvent
+            channel_id=self.CHANNEL_ID,
+            message_id=self.MESSAGE_ID,
+            user_id=self.BOT_ID,
+        )
+
+        with self.subTest():
+            asyncio.run(self.cog.on_raw_reaction_add(payload))
+            self.bot.cog.send_webhook.assert_not_called()
 
     def test_raw_reaction_add_rejects_non_staff(self):
-        """A string decoding to numeric characters is a valid user ID."""
-        pass
+        """Test that send_webhook is not called if the user is not a member of staff."""
+        self.text_channel.fetch_message.return_value = self.contrib_message
+        self.bot.get_all_channels.return_value = (self.text_channel,)
+
+        payload = MagicMock(  # RawReactionActionEvent
+            channel_id=self.CHANNEL_ID,
+            message_id=self.MESSAGE_ID,
+            user_id=self.CONTRIB_ID,
+        )
+
+        with self.subTest():
+            asyncio.run(self.cog.on_raw_reaction_add(payload))
+            self.bot.cog.send_webhook.assert_not_called()
 
     def test_raw_reaction_add_sends_message_on_valid_input(self):
-        """A string decoding to numeric characters is a valid user ID."""
-        pass
+        """Test that send_webhook is called if payload is valid."""
+        self.text_channel.fetch_message.return_value = self.unicode_duck_message
+        self.bot.get_all_channels.return_value = (self.text_channel,)
+
+        payload = MagicMock(  # RawReactionActionEvent
+            channel_id=self.CHANNEL_ID,
+            message_id=self.MESSAGE_ID,
+            user_id=self.ADMIN_ID,
+        )
+
+        with self.subTest():
+            asyncio.run(self.cog.on_raw_reaction_add(payload))
+            self.bot.cog.send_webhook.assert_called_once()
 
     def test_raw_reaction_remove_rejects_non_checkmarks(self):
         """A string decoding to numeric characters is a valid user ID."""
-- 
cgit v1.2.3


From ccda39c5e42e94011c9c1bd14080d004d3d61f02 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Thu, 14 Nov 2019 10:50:49 +0100
Subject: Add bot=False default value to MockMember

By default, a mocked value is considered `truthy` in Python, like all
non-empty/non-zero/non-None values in Python. This means that if an
attribute is not explicitly set on a mock, it will evaluate at as
truthy in a boolean context, since the mock will provide a truthy
mocked value by default.

This is not the best default value for the `bot` attribute of our
MockMember type, since members are rarely bots. It makes much more
intuitive sense to me to consider a member to not be a bot, unless we
explicitly set `bot=True`.

This commit sets that sensible default value that can be overwritten
by passing `bot=False` to the constructor or setting the `object.bot`
attribute to `False` after the creation of the mock.
---
 tests/helpers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/helpers.py b/tests/helpers.py
index 22f07934f..199d45700 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -242,7 +242,7 @@ class MockMember(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin
     information, see the `MockGuild` docstring.
     """
     def __init__(self, roles: Optional[Iterable[MockRole]] = None, **kwargs) -> None:
-        default_kwargs = {'name': 'member', 'id': next(self.discord_id)}
+        default_kwargs = {'name': 'member', 'id': next(self.discord_id), 'bot': False}
         super().__init__(spec_set=member_instance, **collections.ChainMap(kwargs, default_kwargs))
 
         self.roles = [MockRole(name="@everyone", position=1, id=0)]
-- 
cgit v1.2.3


From 61051f9cc5abbf571dfa13c49324109ef16f78fc Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Thu, 14 Nov 2019 10:58:40 +0100
Subject: Add MockAttachment type and attachments default for MockMessage

As stated from the start, our intention is to add custom mock types
as we need them for testing. While writing tests for DuckPond, I
noticed that we did not have a mock type for Attachments, so I added
one with this commit.

In addition, I think it's a very sensible for MockMessage to have an
empty list as a default value for the `attachements` attribute. This
is equal to what `discord.Message` returns for a message without
attachments and makes sure that if you don't explicitely add an
attachment to a message, `MockMessage.attachments` tests as falsey.
---
 tests/helpers.py | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

(limited to 'tests')

diff --git a/tests/helpers.py b/tests/helpers.py
index 199d45700..3e43679fe 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -355,6 +355,20 @@ class MockContext(CustomMockMixin, unittest.mock.MagicMock):
         self.channel = kwargs.get('channel', MockTextChannel())
 
 
+attachment_instance = discord.Attachment(data=unittest.mock.MagicMock(id=1), state=unittest.mock.MagicMock())
+
+
+class MockAttachment(CustomMockMixin, unittest.mock.MagicMock):
+    """
+    A MagicMock subclass to mock Attachment objects.
+
+    Instances of this class will follow the specifications of `discord.Attachment` instances. For
+    more information, see the `MockGuild` docstring.
+    """
+    def __init__(self, **kwargs) -> None:
+        super().__init__(spec_set=attachment_instance, **kwargs)
+
+
 class MockMessage(CustomMockMixin, unittest.mock.MagicMock):
     """
     A MagicMock subclass to mock Message objects.
@@ -364,7 +378,8 @@ class MockMessage(CustomMockMixin, unittest.mock.MagicMock):
     """
 
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec_set=message_instance, **kwargs)
+        default_kwargs = {'attachments': []}
+        super().__init__(spec_set=message_instance, **collections.ChainMap(kwargs, default_kwargs))
         self.author = kwargs.get('author', MockMember())
         self.channel = kwargs.get('channel', MockTextChannel())
 
-- 
cgit v1.2.3


From 2779a912a8fbe29453543a8fd2888a842c3beb47 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Fri, 15 Nov 2019 01:21:33 +0100
Subject: Add `return_value` support and assertions to AsyncIteratorMock

The AsyncIteratorMock included in Python 3.8 will work similarly to
the mocks of callabes. This means that it allows you to set the items
it will yield using the `return_value` attribute. It will also have
support for the common Mock-specific assertions.

This commit introduces some backports of those features in a slightly
simplified way to make the transition to Python 3.8 easier in the
future.
---
 tests/helpers.py | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 54 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/helpers.py b/tests/helpers.py
index 3e43679fe..50652ef9a 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -127,14 +127,20 @@ class AsyncMock(CustomMockMixin, unittest.mock.MagicMock):
 
 class AsyncIteratorMock:
     """
-    A class to mock asyncronous iterators.
+    A class to mock asynchronous iterators.
 
     This allows async for, which is used in certain Discord.py objects. For example,
-    an async iterator is returned by the Reaction.users() coroutine.
+    an async iterator is returned by the Reaction.users() method.
     """
 
-    def __init__(self, sequence):
-        self.iter = iter(sequence)
+    def __init__(self, iterable: Iterable = None):
+        if iterable is None:
+            iterable = []
+
+        self.iter = iter(iterable)
+        self.iterable = iterable
+
+        self.call_count = 0
 
     def __aiter__(self):
         return self
@@ -145,6 +151,50 @@ class AsyncIteratorMock:
         except StopIteration:
             raise StopAsyncIteration
 
+    def __call__(self):
+        """
+        Keeps track of the number of times an instance has been called.
+
+        This is useful, since it typically shows that the iterator has actually been used somewhere after we have
+        instantiated the mock for an attribute that normally returns an iterator when called.
+        """
+        self.call_count += 1
+        return self
+
+    @property
+    def return_value(self):
+        """Makes `self.iterable` accessible as self.return_value."""
+        return self.iterable
+
+    @return_value.setter
+    def return_value(self, iterable):
+        """Stores the `return_value` as `self.iterable` and its iterator as `self.iter`."""
+        self.iter = iter(iterable)
+        self.iterable = iterable
+
+    def assert_called(self):
+        """Asserts if the AsyncIteratorMock instance has been called at least once."""
+        if self.call_count == 0:
+            raise AssertionError("Expected AsyncIteratorMock to have been called.")
+
+    def assert_called_once(self):
+        """Asserts if the AsyncIteratorMock instance has been called exactly once."""
+        if self.call_count != 1:
+            raise AssertionError(
+                f"Expected AsyncIteratorMock to have been called once. Called {self.call_count} times."
+            )
+
+    def assert_not_called(self):
+        """Asserts if the AsyncIteratorMock instance has not been called."""
+        if self.call_count != 0:
+            raise AssertionError(
+                f"Expected AsyncIteratorMock to not have been called once. Called {self.call_count} times."
+            )
+
+    def reset_mock(self):
+        """Resets the call count, but not the return value or iterator."""
+        self.call_count = 0
+
 
 # Create a guild instance to get a realistic Mock of `discord.Guild`
 guild_data = {
-- 
cgit v1.2.3


From 2c77288eb3ff081e70508094bb8d030900860259 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Fri, 15 Nov 2019 01:28:56 +0100
Subject: Add MockUser to mock `discord.User` objects

I have added a special mock that follows the specifications of a
`discord.User` instance. This is useful, since `Users` have less
attributes available than `discord.Members`. Since this difference
in availability of information can be important, we should not use
a `MockMember` to mock a `discord.user`.
---
 tests/helpers.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

(limited to 'tests')

diff --git a/tests/helpers.py b/tests/helpers.py
index 50652ef9a..4da6bf84d 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -303,6 +303,25 @@ class MockMember(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin
             self.mention = f"@{self.name}"
 
 
+# Create a User instance to get a realistic Mock of `discord.User`
+user_instance = discord.User(data=unittest.mock.MagicMock(), state=unittest.mock.MagicMock())
+
+
+class MockUser(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin):
+    """
+    A Mock subclass to mock User objects.
+
+    Instances of this class will follow the specifications of `discord.User` instances. For more
+    information, see the `MockGuild` docstring.
+    """
+    def __init__(self, **kwargs) -> None:
+        default_kwargs = {'name': 'user', 'id': next(self.discord_id), 'bot': False}
+        super().__init__(spec_set=user_instance, **collections.ChainMap(kwargs, default_kwargs))
+
+        if 'mention' not in kwargs:
+            self.mention = f"@{self.name}"
+
+
 # Create a Bot instance to get a realistic MagicMock of `discord.ext.commands.Bot`
 bot_instance = Bot(command_prefix=unittest.mock.MagicMock())
 bot_instance.http_session = None
-- 
cgit v1.2.3


From 647370d7881d1ab242186599adb76a56a0815150 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Fri, 15 Nov 2019 01:34:46 +0100
Subject: Adjust MockReaction for new AsyncIteratorMock protocol

The new AsyncIteratorMock no longer needs an additional method to be
used with a Mock object.
---
 tests/helpers.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

(limited to 'tests')

diff --git a/tests/helpers.py b/tests/helpers.py
index 4da6bf84d..13852397f 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -500,7 +500,5 @@ class MockReaction(CustomMockMixin, unittest.mock.MagicMock):
         super().__init__(spec_set=reaction_instance, **kwargs)
         self.emoji = kwargs.get('emoji', MockEmoji())
         self.message = kwargs.get('message', MockMessage())
-        self.user_list = AsyncIteratorMock(kwargs.get('user_list', []))
+        self.users = AsyncIteratorMock(kwargs.get('users', []))
 
-    def users(self):
-        return self.user_list
-- 
cgit v1.2.3


From b42a7b5b7f2c1c9f9924eeb9d39f7767306824ec Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Fri, 15 Nov 2019 01:37:02 +0100
Subject: Add MockAsyncWebhook to mock `discord.Webhook` objects

I have added a mock type to mock `discord.Webhook` instances. Note
that the current type is specifically meant to mock webhooks that
use an AsyncAdaptor and therefore has AsyncMock/coroutine mocks for
the "maybe-coroutine" methods specified in the `discord.py` docs.
---
 tests/helpers.py | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'tests')

diff --git a/tests/helpers.py b/tests/helpers.py
index 13852397f..b2daae92d 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -502,3 +502,24 @@ class MockReaction(CustomMockMixin, unittest.mock.MagicMock):
         self.message = kwargs.get('message', MockMessage())
         self.users = AsyncIteratorMock(kwargs.get('users', []))
 
+
+webhook_instance = discord.Webhook(data=unittest.mock.MagicMock(), adapter=unittest.mock.MagicMock())
+
+
+class MockAsyncWebhook(CustomMockMixin, unittest.mock.MagicMock):
+    """
+    A MagicMock subclass to mock Webhook objects using an AsyncWebhookAdapter.
+
+    Instances of this class will follow the specifications of `discord.Webhook` instances. For
+    more information, see the `MockGuild` docstring.
+    """
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(spec_set=webhook_instance, **kwargs)
+
+        # Because Webhooks can also use a synchronous "WebhookAdapter", the methods are not defined
+        # as coroutines. That's why we need to set the methods manually.
+        self.send = AsyncMock()
+        self.edit = AsyncMock()
+        self.delete = AsyncMock()
+        self.execute = AsyncMock()
-- 
cgit v1.2.3


From a692a95896328adf1d52c5a5548e0c72540d6cbc Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Fri, 15 Nov 2019 01:39:51 +0100
Subject: Add unit tests with full coverage for `bot.cogs.duck_pond`

This commit adds unit tests that provide a full branch coverage of
the `bot.cogs.duck_pond` file.
---
 tests/bot/cogs/test_duck_pond.py | 649 +++++++++++++++++++++++++++++----------
 1 file changed, 490 insertions(+), 159 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
index 088d8ac79..ceefc286f 100644
--- a/tests/bot/cogs/test_duck_pond.py
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -1,193 +1,524 @@
 import asyncio
 import logging
+import typing
 import unittest
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
+
+import discord
 
 from bot import constants
 from bot.cogs import duck_pond
-from tests.helpers import MockBot, MockEmoji, MockMember, MockMessage, MockReaction, MockRole, MockTextChannel
+from tests import base
+from tests import helpers
+
+MODULE_PATH = "bot.cogs.duck_pond"
+
+
+class DuckPondTests(base.LoggingTestCase):
+    """Tests for DuckPond functionality."""
+
+    @classmethod
+    def setUpClass(cls):
+        """Sets up the objects that only have to be initialized once."""
+        cls.nonstaff_member = helpers.MockMember(name="Non-staffer")
 
+        cls.staff_role = helpers.MockRole(name="Staff role", id=constants.STAFF_ROLES[0])
+        cls.staff_member = helpers.MockMember(name="staffer", roles=[cls.staff_role])
 
-class DuckPondTest(unittest.TestCase):
-    """Tests the `DuckPond` cog."""
+        cls.checkmark_emoji = "\N{White Heavy Check Mark}"
+        cls.thumbs_up_emoji = "\N{Thumbs Up Sign}"
+        cls.unicode_duck_emoji = "\N{Duck}"
+        cls.duck_pond_emoji = helpers.MockPartialEmoji(id=constants.DuckPond.custom_emojis[0])
+        cls.non_duck_custom_emoji = helpers.MockPartialEmoji(id=123)
 
     def setUp(self):
-        """Adds the cog, a bot, and the mocks we'll need for our tests."""
-        self.bot = MockBot()
+        """Sets up the objects that need to be refreshed before each test."""
+        self.bot = helpers.MockBot(user=helpers.MockMember(id=46692))
         self.cog = duck_pond.DuckPond(bot=self.bot)
 
-        # Set up some constants
-        self.CHANNEL_ID = 555
-        self.MESSAGE_ID = 666
-        self.BOT_ID = 777
-        self.CONTRIB_ID = 888
-        self.ADMIN_ID = 999
-
-        # Override the constants we'll be needing
-        constants.STAFF_ROLES = (123,)
-        constants.DuckPond.custom_emojis = (789,)
-        constants.DuckPond.threshold = 1
-
-        # Set up some roles
-        self.admin_role = MockRole(name="Admins", role_id=123)
-        self.contrib_role = MockRole(name="Contributor", role_id=456)
-
-        # Set up some users
-        self.admin_member_1 = MockMember(roles=(self.admin_role,), id=self.ADMIN_ID)
-        self.admin_member_2 = MockMember(roles=(self.admin_role,), id=911)
-        self.contrib_member = MockMember(roles=(self.contrib_role,), id=self.CONTRIB_ID)
-        self.bot_member = MockMember(roles=(self.contrib_role,), id=self.BOT_ID, bot=True)
-        self.no_role_member = MockMember()
-
-        # Set up emojis
-        self.checkmark_emoji = "✅"
-        self.thumbs_up_emoji = "👍"
-        self.unicode_duck_emoji = "🦆"
-        self.yellow_ducky_emoji = MockEmoji(id=789)
-
-        # Set up reactions
-        self.checkmark_reaction = MockReaction(
-            emoji=self.checkmark_emoji,
-            user_list=[self.admin_member_1]
-        )
-        self.thumbs_up_reaction = MockReaction(
-            emoji=self.thumbs_up_emoji,
-            user_list=[self.admin_member_1, self.contrib_member]
-        )
-        self.yellow_ducky_reaction = MockReaction(
-            emoji=self.yellow_ducky_emoji,
-            user_list=[self.admin_member_1, self.contrib_member]
-        )
-        self.unicode_duck_reaction_1 = MockReaction(
-            emoji=self.unicode_duck_emoji,
-            user_list=[self.admin_member_1]
+    def test_duck_pond_correctly_initializes(self):
+        """`__init__ should set `bot` and `webhook_id` attributes and schedule `fetch_webhook`."""
+        bot = helpers.MockBot()
+        cog = MagicMock()
+
+        duck_pond.DuckPond.__init__(cog, bot)
+
+        self.assertEqual(cog.bot, bot)
+        self.assertEqual(cog.webhook_id, constants.Webhooks.duck_pond)
+        bot.loop.create_loop.called_once_with(cog.fetch_webhook())
+
+    def test_fetch_webhook_succeeds_without_connectivity_issues(self):
+        """The `fetch_webhook` method waits until `READY` event and sets the `webhook` attribute."""
+        self.bot.fetch_webhook.return_value = "dummy webhook"
+        self.cog.webhook_id = 1
+
+        asyncio.run(self.cog.fetch_webhook())
+
+        self.bot.wait_until_ready.assert_called_once()
+        self.bot.fetch_webhook.assert_called_once_with(1)
+        self.assertEqual(self.cog.webhook, "dummy webhook")
+
+    def test_fetch_webhook_logs_when_unable_to_fetch_webhook(self):
+        """The `fetch_webhook` method should log an exception when it fails to fetch the webhook."""
+        self.bot.fetch_webhook.side_effect = discord.HTTPException(response=MagicMock(), message="Not found.")
+        self.cog.webhook_id = 1
+
+        log = logging.getLogger('bot.cogs.duck_pond')
+        with self.assertLogs(logger=log, level=logging.ERROR) as log_watcher:
+            asyncio.run(self.cog.fetch_webhook())
+
+        self.bot.wait_until_ready.assert_called_once()
+        self.bot.fetch_webhook.assert_called_once_with(1)
+
+        self.assertEqual(len(log_watcher.records), 1)
+
+        [record] = log_watcher.records
+        self.assertEqual(record.message, f"Failed to fetch webhook with id `{self.cog.webhook_id}`")
+        self.assertEqual(record.levelno, logging.ERROR)
+
+    def test_is_staff_returns_correct_values_based_on_instance_passed(self):
+        """The `is_staff` method should return correct values based on the instance passed."""
+        test_cases = (
+            (helpers.MockUser(name="User instance"), False),
+            (helpers.MockMember(name="Member instance without staff role"), False),
+            (helpers.MockMember(name="Member instance with staff role", roles=[self.staff_role]), True)
         )
-        self.unicode_duck_reaction_2 = MockReaction(
-            emoji=self.unicode_duck_emoji,
-            user_list=[self.admin_member_2]
+
+        for user, expected_return in test_cases:
+            actual_return = self.cog.is_staff(user)
+            with self.subTest(user_type=user.name, expected_return=expected_return, actual_return=actual_return):
+                self.assertEqual(expected_return, actual_return)
+
+    @helpers.async_test
+    async def test_has_green_checkmark_correctly_detects_presence_of_green_checkmark_emoji(self):
+        """The `has_green_checkmark` method should only return `True` if one is present."""
+        test_cases = (
+            (
+                "No reactions", helpers.MockMessage(), False
+            ),
+            (
+                "No green check mark reactions",
+                helpers.MockMessage(reactions=[
+                    helpers.MockReaction(emoji=self.unicode_duck_emoji),
+                    helpers.MockReaction(emoji=self.thumbs_up_emoji)
+                ]),
+                False
+            ),
+            (
+                "Green check mark reaction, but not from our bot",
+                helpers.MockMessage(reactions=[
+                    helpers.MockReaction(emoji=self.unicode_duck_emoji),
+                    helpers.MockReaction(emoji=self.checkmark_emoji, users=[self.staff_member])
+                ]),
+                False
+            ),
+            (
+                "Green check mark reaction, with one from the bot",
+                helpers.MockMessage(reactions=[
+                    helpers.MockReaction(emoji=self.unicode_duck_emoji),
+                    helpers.MockReaction(emoji=self.checkmark_emoji, users=[self.staff_member, self.bot.user])
+                ]),
+                True
+            )
         )
-        self.bot_reaction = MockReaction(
-            emoji=self.yellow_ducky_emoji,
-            user_list=[self.bot_member]
+
+        for description, message, expected_return in test_cases:
+            actual_return = await self.cog.has_green_checkmark(message)
+            with self.subTest(
+                test_case=description,
+                expected_return=expected_return,
+                actual_return=actual_return
+            ):
+                self.assertEqual(expected_return, actual_return)
+
+    def test_send_webhook_correctly_passes_on_arguments(self):
+        """The `send_webhook` method should pass the arguments to the webhook correctly."""
+        self.cog.webhook = helpers.MockAsyncWebhook()
+
+        content = "fake content"
+        username = "fake username"
+        avatar_url = "fake avatar_url"
+        embed = "fake embed"
+
+        asyncio.run(self.cog.send_webhook(content, username, avatar_url, embed))
+
+        self.cog.webhook.send.assert_called_once_with(
+            content=content,
+            username=username,
+            avatar_url=avatar_url,
+            embed=embed
         )
-        self.contrib_reaction = MockReaction(
-            emoji=self.yellow_ducky_emoji,
-            user_list=[self.contrib_member]
+
+    def test_send_webhook_logs_when_sending_message_fails(self):
+        """The `send_webhook` method should catch a `discord.HTTPException` and log accordingly."""
+        self.cog.webhook = helpers.MockAsyncWebhook()
+        self.cog.webhook.send.side_effect = discord.HTTPException(response=MagicMock(), message="Something failed.")
+
+        log = logging.getLogger('bot.cogs.duck_pond')
+        with self.assertLogs(logger=log, level=logging.ERROR) as log_watcher:
+            asyncio.run(self.cog.send_webhook())
+
+        self.assertEqual(len(log_watcher.records), 1)
+
+        [record] = log_watcher.records
+        self.assertEqual(record.message, "Failed to send a message to the Duck Pool webhook")
+        self.assertEqual(record.levelno, logging.ERROR)
+
+    def _get_reaction(
+        self,
+        emoji: typing.Union[str, helpers.MockEmoji],
+        staff: int = 0,
+        nonstaff: int = 0
+    ) -> helpers.MockReaction:
+        staffers = [helpers.MockMember(roles=[self.staff_role]) for _ in range(staff)]
+        nonstaffers = [helpers.MockMember() for _ in range(nonstaff)]
+        return helpers.MockReaction(emoji=emoji, users=staffers + nonstaffers)
+
+    @helpers.async_test
+    async def test_count_ducks_correctly_counts_the_number_of_eligible_duck_emojis(self):
+        """The `count_ducks` method should return the number of unique staffers who gave a duck."""
+        test_cases = (
+            # Simple test cases
+            # A message without reactions should return 0
+            (
+                "No reactions",
+                helpers.MockMessage(),
+                0
+            ),
+            # A message with a non-duck reaction from a non-staffer should return 0
+            (
+                "Non-duck reaction from non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.thumbs_up_emoji, nonstaff=1)]),
+                0
+            ),
+            # A message with a non-duck reaction from a staffer should return 0
+            (
+                "Non-duck reaction from staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.non_duck_custom_emoji, staff=1)]),
+                0
+            ),
+            # A message with a non-duck reaction from a non-staffer and staffer should return 0
+            (
+                "Non-duck reaction from staffer + non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.thumbs_up_emoji, staff=1, nonstaff=1)]),
+                0
+            ),
+            # A message with a unicode duck reaction from a non-staffer should return 0
+            (
+                "Unicode Duck Reaction from non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.unicode_duck_emoji, nonstaff=1)]),
+                0
+            ),
+            # A message with a unicode duck reaction from a staffer should return 1
+            (
+                "Unicode Duck Reaction from staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.unicode_duck_emoji, staff=1)]),
+                1
+            ),
+            # A message with a unicode duck reaction from a non-staffer and staffer should return 1
+            (
+                "Unicode Duck Reaction from staffer + non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.unicode_duck_emoji, staff=1, nonstaff=1)]),
+                1
+            ),
+            # A message with a duckpond duck reaction from a non-staffer should return 0
+            (
+                "Duckpond Duck Reaction from non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.duck_pond_emoji, nonstaff=1)]),
+                0
+            ),
+            # A message with a duckpond duck reaction from a staffer should return 1
+            (
+                "Duckpond Duck Reaction from staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.duck_pond_emoji, staff=1)]),
+                1
+            ),
+            # A message with a duckpond duck reaction from a non-staffer and staffer should return 1
+            (
+                "Duckpond Duck Reaction from staffer + non-staffer",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.duck_pond_emoji, staff=1, nonstaff=1)]),
+                1
+            ),
+
+            # Complex test cases
+            # A message with duckpond duck reactions from 3 staffers and 2 non-staffers returns 3
+            (
+                "Duckpond Duck Reaction from 3 staffers + 2 non-staffers",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=self.duck_pond_emoji, staff=3, nonstaff=2)]),
+                3
+            ),
+            # A staffer with multiple duck reactions only counts once
+            (
+                "Two different duck reactions from the same staffer",
+                helpers.MockMessage(reactions=[
+                    helpers.MockReaction(emoji=self.duck_pond_emoji, users=[self.staff_member]),
+                    helpers.MockReaction(emoji=self.unicode_duck_emoji, users=[self.staff_member]),
+                ]),
+                1
+            ),
+            # A non-string emoji does not count (to test the `isinstance(reaction.emoji, str)` elif)
+            (
+                "Reaction with non-Emoji/str emoij from 3 staffers + 2 non-staffers",
+                helpers.MockMessage(reactions=[self._get_reaction(emoji=100, staff=3, nonstaff=2)]),
+                0
+            ),
+            # We correctly sum when multiple reactions are provided.
+            (
+                "Duckpond Duck Reaction from 3 staffers + 2 non-staffers",
+                helpers.MockMessage(reactions=[
+                    self._get_reaction(emoji=self.duck_pond_emoji, staff=3, nonstaff=2),
+                    self._get_reaction(emoji=self.unicode_duck_emoji, staff=4, nonstaff=9),
+                ]),
+                3+4
+            ),
         )
 
-        # Set up a messages
-        self.checkmark_message = MockMessage(reactions=(self.checkmark_reaction,))
-        self.thumbs_up_message = MockMessage(reactions=(self.thumbs_up_reaction,))
-        self.yellow_ducky_message = MockMessage(reactions=(self.yellow_ducky_reaction,))
-        self.unicode_duck_message = MockMessage(reactions=(self.unicode_duck_reaction_1,))
-        self.double_unicode_duck_message = MockMessage(
-            reactions=(self.unicode_duck_reaction_1, self.unicode_duck_reaction_2)
+        for description, message, expected_count in test_cases:
+            actual_count = await self.cog.count_ducks(message)
+            with self.subTest(test_case=description, expected_count=expected_count, actual_count=actual_count):
+                self.assertEqual(expected_count, actual_count)
+
+    @helpers.async_test
+    async def test_relay_message_to_duck_pond_correctly_relays_content_and_attachments(self):
+        """The `relay_message_to_duck_pond` method should correctly relay message content and attachments."""
+        send_webhook_path = f"{MODULE_PATH}.DuckPond.send_webhook"
+        send_attachments_path = f"{MODULE_PATH}.send_attachments"
+
+        self.cog.webhook = helpers.MockAsyncWebhook()
+
+        test_values = (
+            (helpers.MockMessage(clean_content="", attachments=[]), False, False),
+            (helpers.MockMessage(clean_content="message", attachments=[]), True, False),
+            (helpers.MockMessage(clean_content="", attachments=["attachment"]), False, True),
+            (helpers.MockMessage(clean_content="message", attachments=["attachment"]), True, True),
         )
-        self.double_mixed_duck_message = MockMessage(
-            reactions=(self.unicode_duck_reaction_1, self.yellow_ducky_reaction)
+
+        for message, expect_webhook_call, expect_attachment_call in test_values:
+            with patch(send_webhook_path, new_callable=helpers.AsyncMock) as send_webhook:
+                with patch(send_attachments_path, new_callable=helpers.AsyncMock) as send_attachments:
+                    with self.subTest(clean_content=message.clean_content, attachments=message.attachments):
+                        await self.cog.relay_message_to_duck_pond(message)
+
+                        self.assertEqual(expect_webhook_call, send_webhook.called)
+                        self.assertEqual(expect_attachment_call, send_attachments.called)
+
+                        message.add_reaction.assert_called_once_with(self.checkmark_emoji)
+                        message.reset_mock()
+
+    @patch(f"{MODULE_PATH}.DuckPond.send_webhook", new_callable=helpers.AsyncMock)
+    @patch(f"{MODULE_PATH}.send_attachments", new_callable=helpers.AsyncMock)
+    @helpers.async_test
+    async def test_relay_message_to_duck_pond_handles_send_attachments_exceptions(self, send_attachments, send_webhook):
+        """The `relay_message_to_duck_pond` method should handle exceptions when calling `send_attachment`."""
+
+        message = helpers.MockMessage(clean_content="message", attachments=["attachment"])
+        side_effects = (discord.errors.Forbidden(MagicMock(), ""), discord.errors.NotFound(MagicMock(), ""))
+
+        self.cog.webhook = helpers.MockAsyncWebhook()
+        log = logging.getLogger("bot.cogs.duck_pond")
+
+        # Subtests for the first `except` block
+        for side_effect in side_effects:
+            send_attachments.side_effect = side_effect
+            with self.subTest(side_effect=type(side_effect).__name__):
+                with self.assertNotLogs(logger=log, level=logging.ERROR):
+                    await self.cog.relay_message_to_duck_pond(message)
+
+                self.assertEqual(send_webhook.call_count, 2)
+                send_webhook.reset_mock()
+
+        # Subtests for the second `except` block
+        side_effect = discord.HTTPException(MagicMock(), "")
+        send_attachments.side_effect = side_effect
+        with self.subTest(side_effect=type(side_effect).__name__):
+            with self.assertLogs(logger=log, level=logging.ERROR) as log_watcher:
+                await self.cog.relay_message_to_duck_pond(message)
+
+            send_webhook.assert_called_once_with(
+                content=message.clean_content,
+                username=message.author.display_name,
+                avatar_url=message.author.avatar_url
+            )
+
+            self.assertEqual(len(log_watcher.records), 1)
+
+            [record] = log_watcher.records
+            self.assertEqual(record.message, "Failed to send an attachment to the webhook")
+            self.assertEqual(record.levelno, logging.ERROR)
+
+    def _raw_reaction_mocks(self, channel_id, message_id, user_id):
+        """Sets up mocks for tests of the `on_raw_reaction_add` event listener."""
+        channel = helpers.MockTextChannel(id=channel_id)
+        self.bot.get_all_channels.return_value = (channel,)
+
+        message = helpers.MockMessage(id=message_id)
+
+        channel.fetch_message.return_value = message
+
+        member = helpers.MockMember(id=user_id, roles=[self.staff_role])
+        message.guild.members = (member,)
+
+        payload = MagicMock(channel_id=channel_id, message_id=message_id, user_id=user_id)
+
+        return channel, message, member, payload
+
+    @helpers.async_test
+    async def test_on_raw_reaction_add_returns_for_non_relevant_emojis(self):
+        """The `on_raw_reaction_add` event handler should ignore irrelevant emojis."""
+        payload_custom_emoji = MagicMock(label="Non-Duck Custom Emoji")
+        payload_custom_emoji.emoji.is_custom_emoji.return_value = True
+        payload_custom_emoji.emoji.id = 12345
+
+        payload_unicode_emoji = MagicMock(label="Non-Duck Unicode Emoji")
+        payload_unicode_emoji.emoji.is_custom_emoji.return_value = False
+        payload_unicode_emoji.emoji.name = self.thumbs_up_emoji
+
+        for payload in (payload_custom_emoji, payload_unicode_emoji):
+            with self.subTest(case=payload.label), patch(f"{MODULE_PATH}.discord.utils.get") as discord_utils_get:
+                self.assertIsNone(await self.cog.on_raw_reaction_add(payload))
+                discord_utils_get.assert_not_called()
+
+    @helpers.async_test
+    async def test_on_raw_reaction_add_returns_for_bot_and_non_staff_members(self):
+        """The `on_raw_reaction_add` event handler should return for bot users or non-staff members."""
+        channel_id = 1234
+        message_id = 2345
+        user_id = 3456
+
+        channel, message, _, payload = self._raw_reaction_mocks(channel_id, message_id, user_id)
+
+        test_cases = (
+            ("non-staff member", helpers.MockMember(id=user_id)),
+            ("bot staff member", helpers.MockMember(id=user_id, roles=[self.staff_role], bot=True)),
         )
 
-        self.bot_message = MockMessage(reactions=(self.bot_reaction,))
-        self.contrib_message = MockMessage(reactions=(self.contrib_reaction,))
-        self.no_reaction_message = MockMessage()
-
-        # Set up some channels
-        self.text_channel = MockTextChannel(id=self.CHANNEL_ID)
-
-    @staticmethod
-    def _mock_send_webhook(content, username, avatar_url, embed):
-        """Mock for the send_webhook method in DuckPond"""
-
-    def test_is_staff_correctly_identifies_staff(self):
-        """Test that is_staff correctly identifies a staff member."""
-        with self.subTest():
-            self.assertTrue(self.cog.is_staff(self.admin_member_1))
-            self.assertFalse(self.cog.is_staff(self.contrib_member))
-            self.assertFalse(self.cog.is_staff(self.no_role_member))
-
-    def test_has_green_checkmark_correctly_identifies_messages(self):
-        """Test that has_green_checkmark recognizes messages with checkmarks."""
-        with self.subTest():
-            self.assertTrue(self.cog.has_green_checkmark(self.checkmark_message))
-            self.assertFalse(self.cog.has_green_checkmark(self.thumbs_up_message))
-            self.assertFalse(self.cog.has_green_checkmark(self.no_reaction_message))
-
-    def test_count_custom_duck_emojis(self):
-        """Test that count_ducks counts custom ducks correctly."""
-        count_no_ducks = self.cog.count_ducks(self.thumbs_up_message)
-        count_one_duck = self.cog.count_ducks(self.yellow_ducky_message)
-        with self.subTest():
-            self.assertEqual(asyncio.run(count_no_ducks), 0)
-            self.assertEqual(asyncio.run(count_one_duck), 1)
-
-    def test_count_unicode_duck_emojis(self):
-        """Test that count_ducks counts unicode ducks correctly."""
-        count_one_duck = self.cog.count_ducks(self.unicode_duck_message)
-        count_two_ducks = self.cog.count_ducks(self.double_unicode_duck_message)
-
-        with self.subTest():
-            self.assertEqual(asyncio.run(count_one_duck), 1)
-            self.assertEqual(asyncio.run(count_two_ducks), 2)
-
-    def test_count_mixed_duck_emojis(self):
-        """Test that count_ducks counts mixed ducks correctly."""
-        count_two_ducks = self.cog.count_ducks(self.double_mixed_duck_message)
-
-        with self.subTest():
-            self.assertEqual(asyncio.run(count_two_ducks), 2)
-
-    def test_raw_reaction_add_rejects_bot(self):
-        """Test that send_webhook is not called if the user is a bot."""
-        self.text_channel.fetch_message.return_value = self.bot_message
-        self.bot.get_all_channels.return_value = (self.text_channel,)
-
-        payload = MagicMock(  # RawReactionActionEvent
-            channel_id=self.CHANNEL_ID,
-            message_id=self.MESSAGE_ID,
-            user_id=self.BOT_ID,
+        payload.emoji = self.duck_pond_emoji
+
+        for description, member in test_cases:
+            message.guild.members = (member, )
+            with self.subTest(test_case=description), patch(f"{MODULE_PATH}.DuckPond.has_green_checkmark") as checkmark:
+                checkmark.side_effect = AssertionError(
+                    "Expected method to return before calling `self.has_green_checkmark`."
+                )
+                self.assertIsNone(await self.cog.on_raw_reaction_add(payload))
+
+                # Check that we did make it past the payload checks
+                channel.fetch_message.assert_called_once()
+                channel.fetch_message.reset_mock()
+
+    @patch(f"{MODULE_PATH}.DuckPond.is_staff")
+    @patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock)
+    def test_on_raw_reaction_add_returns_on_message_with_green_checkmark_placed_by_bot(self, count_ducks, is_staff):
+        """The `on_raw_reaction_add` event should return when the message has a green check mark placed by the bot."""
+        channel_id = 31415926535
+        message_id = 27182818284
+        user_id = 16180339887
+
+        channel, message, member, payload = self._raw_reaction_mocks(channel_id, message_id, user_id)
+
+        payload.emoji = helpers.MockPartialEmoji(name=self.unicode_duck_emoji)
+        payload.emoji.is_custom_emoji.return_value = False
+
+        message.reactions = [helpers.MockReaction(emoji=self.checkmark_emoji, users=[self.bot.user])]
+
+        is_staff.return_value = True
+        count_ducks.side_effect = AssertionError("Expected method to return before calling `self.count_ducks`")
+
+        self.assertIsNone(asyncio.run(self.cog.on_raw_reaction_add(payload)))
+
+        # Assert that we've made it past `self.is_staff`
+        is_staff.assert_called_once()
+
+    @patch(f"{MODULE_PATH}.DuckPond.relay_message_to_duck_pond", new_callable=helpers.AsyncMock)
+    @patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock)
+    @helpers.async_test
+    async def test_on_raw_reaction_add_does_not_relay_below_duck_threshold(self, count_ducks, message_relay):
+        """The `on_raw_reaction_add` listener should not relay messages or attachments below the duck threshold."""
+        test_cases = (
+            (constants.DuckPond.threshold-1, False),
+            (constants.DuckPond.threshold, True),
+            (constants.DuckPond.threshold+1, True),
         )
 
-        with self.subTest():
-            asyncio.run(self.cog.on_raw_reaction_add(payload))
-            self.bot.cog.send_webhook.assert_not_called()
+        channel, message, member, payload = self._raw_reaction_mocks(channel_id=3, message_id=4, user_id=5)
+
+        payload.emoji = self.duck_pond_emoji
+
+        for duck_count, should_relay in test_cases:
+            count_ducks.return_value = duck_count
+            with self.subTest(duck_count=duck_count, should_relay=should_relay):
+                await self.cog.on_raw_reaction_add(payload)
+
+                # Confirm that we've made it past counting
+                count_ducks.assert_called_once()
+                count_ducks.reset_mock()
+
+                # Did we relay a message?
+                has_relayed = message_relay.called
+                self.assertEqual(has_relayed, should_relay)
+
+                if should_relay:
+                    message_relay.assert_called_once_with(message)
+                    message_relay.reset_mock()
 
-    def test_raw_reaction_add_rejects_non_staff(self):
-        """Test that send_webhook is not called if the user is not a member of staff."""
-        self.text_channel.fetch_message.return_value = self.contrib_message
-        self.bot.get_all_channels.return_value = (self.text_channel,)
+    @helpers.async_test
+    async def test_on_raw_reaction_remove_prevents_removal_of_green_checkmark_depending_on_the_duck_count(self):
+        """The `on_raw_reaction_remove` listener prevents removal of the check mark on messages with enough ducks."""
+        checkmark = helpers.MockPartialEmoji(name=self.checkmark_emoji)
 
-        payload = MagicMock(  # RawReactionActionEvent
-            channel_id=self.CHANNEL_ID,
-            message_id=self.MESSAGE_ID,
-            user_id=self.CONTRIB_ID,
+        message = helpers.MockMessage(id=1234)
+
+        channel = helpers.MockTextChannel(id=98765)
+        channel.fetch_message.return_value = message
+
+        self.bot.get_all_channels.return_value = (channel, )
+
+        payload = MagicMock(channel_id=channel.id, message_id=message.id, emoji=checkmark)
+
+        test_cases = (
+            (constants.DuckPond.threshold - 1, False),
+            (constants.DuckPond.threshold, True),
+            (constants.DuckPond.threshold + 1, True),
         )
+        for duck_count, should_readd_checkmark in test_cases:
+            with patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock) as count_ducks:
+                count_ducks.return_value = duck_count
+                with self.subTest(duck_count=duck_count, should_readd_checkmark=should_readd_checkmark):
+                    await self.cog.on_raw_reaction_remove(payload)
+
+                    # Check if we fetched the message
+                    channel.fetch_message.assert_called_once_with(message.id)
 
-        with self.subTest():
-            asyncio.run(self.cog.on_raw_reaction_add(payload))
-            self.bot.cog.send_webhook.assert_not_called()
+                    # Check if we actually counted the number of ducks
+                    count_ducks.assert_called_once_with(message)
 
-    def test_raw_reaction_add_sends_message_on_valid_input(self):
-        """Test that send_webhook is called if payload is valid."""
-        self.text_channel.fetch_message.return_value = self.unicode_duck_message
-        self.bot.get_all_channels.return_value = (self.text_channel,)
+                    has_readded_checkmark = message.add_reaction.called
+                    self.assertEqual(should_readd_checkmark, has_readded_checkmark)
 
-        payload = MagicMock(  # RawReactionActionEvent
-            channel_id=self.CHANNEL_ID,
-            message_id=self.MESSAGE_ID,
-            user_id=self.ADMIN_ID,
+                    if should_readd_checkmark:
+                        message.add_reaction.assert_called_once_with(self.checkmark_emoji)
+                        message.add_reaction.reset_mock()
+
+                    # reset mocks
+                    channel.fetch_message.reset_mock()
+                    count_ducks.reset_mock()
+                    message.reset_mock()
+
+    def test_on_raw_reaction_remove_ignores_removal_of_non_checkmark_reactions(self):
+        """The `on_raw_reaction_remove` listener should ignore the removal of non-check mark emojis."""
+        channel = helpers.MockTextChannel(id=98765)
+
+        channel.fetch_message.side_effect = AssertionError(
+            "Expected method to return before calling `channel.fetch_message`"
         )
 
-        with self.subTest():
-            asyncio.run(self.cog.on_raw_reaction_add(payload))
-            self.bot.cog.send_webhook.assert_called_once()
+        self.bot.get_all_channels.return_value = (channel, )
+
+        payload = MagicMock(emoji=helpers.MockPartialEmoji(name=self.thumbs_up_emoji), channel_id=channel.id)
 
-    def test_raw_reaction_remove_rejects_non_checkmarks(self):
-        """A string decoding to numeric characters is a valid user ID."""
-        pass
+        self.assertIsNone(asyncio.run(self.cog.on_raw_reaction_remove(payload)))
 
-    def test_raw_reaction_remove_prevents_checkmark_removal(self):
-        """A string decoding to numeric characters is a valid user ID."""
-        pass
+        channel.fetch_message.assert_not_called()
 
 
 class DuckPondSetupTests(unittest.TestCase):
@@ -195,7 +526,7 @@ class DuckPondSetupTests(unittest.TestCase):
 
     def test_setup(self):
         """Setup of the cog should log a message at `INFO` level."""
-        bot = MockBot()
+        bot = helpers.MockBot()
         log = logging.getLogger('bot.cogs.duck_pond')
 
         with self.assertLogs(logger=log, level=logging.INFO) as log_watcher:
-- 
cgit v1.2.3


From e67822a46621d20ff0a1a27de1322b14432e4eb9 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Sat, 16 Nov 2019 17:04:27 +0100
Subject: Apply suggestions from code review

Co-Authored-By: Mark <kozlovmark@gmail.com>
---
 tests/bot/cogs/test_duck_pond.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
index ceefc286f..8f0c4f068 100644
--- a/tests/bot/cogs/test_duck_pond.py
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -269,7 +269,7 @@ class DuckPondTests(base.LoggingTestCase):
                     self._get_reaction(emoji=self.duck_pond_emoji, staff=3, nonstaff=2),
                     self._get_reaction(emoji=self.unicode_duck_emoji, staff=4, nonstaff=9),
                 ]),
-                3+4
+                3 + 4
             ),
         )
 
@@ -310,7 +310,6 @@ class DuckPondTests(base.LoggingTestCase):
     @helpers.async_test
     async def test_relay_message_to_duck_pond_handles_send_attachments_exceptions(self, send_attachments, send_webhook):
         """The `relay_message_to_duck_pond` method should handle exceptions when calling `send_attachment`."""
-
         message = helpers.MockMessage(clean_content="message", attachments=["attachment"])
         side_effects = (discord.errors.Forbidden(MagicMock(), ""), discord.errors.NotFound(MagicMock(), ""))
 
@@ -435,9 +434,9 @@ class DuckPondTests(base.LoggingTestCase):
     async def test_on_raw_reaction_add_does_not_relay_below_duck_threshold(self, count_ducks, message_relay):
         """The `on_raw_reaction_add` listener should not relay messages or attachments below the duck threshold."""
         test_cases = (
-            (constants.DuckPond.threshold-1, False),
+            (constants.DuckPond.threshold - 1, False),
             (constants.DuckPond.threshold, True),
-            (constants.DuckPond.threshold+1, True),
+            (constants.DuckPond.threshold + 1, True),
         )
 
         channel, message, member, payload = self._raw_reaction_mocks(channel_id=3, message_id=4, user_id=5)
-- 
cgit v1.2.3


From 80d84e19d6877d2cbf2a6ce5029c1fd96b286b1e Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Wed, 27 Nov 2019 17:46:56 +0100
Subject: Apply review comments to duckpond's unit tests

https://github.com/python-discord/bot/pull/621

I've changed to unit tests according to the comments made on the
issue. Most changes are straightforward enough, but, for context,
see the PR linked above.
---
 tests/bot/cogs/test_duck_pond.py | 200 +++++++++++++++++++++++++--------------
 1 file changed, 128 insertions(+), 72 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
index 8f0c4f068..b801e86f1 100644
--- a/tests/bot/cogs/test_duck_pond.py
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -72,8 +72,7 @@ class DuckPondTests(base.LoggingTestCase):
 
         self.assertEqual(len(log_watcher.records), 1)
 
-        [record] = log_watcher.records
-        self.assertEqual(record.message, f"Failed to fetch webhook with id `{self.cog.webhook_id}`")
+        record = log_watcher.records[0]
         self.assertEqual(record.levelno, logging.ERROR)
 
     def test_is_staff_returns_correct_values_based_on_instance_passed(self):
@@ -99,15 +98,15 @@ class DuckPondTests(base.LoggingTestCase):
             (
                 "No green check mark reactions",
                 helpers.MockMessage(reactions=[
-                    helpers.MockReaction(emoji=self.unicode_duck_emoji),
-                    helpers.MockReaction(emoji=self.thumbs_up_emoji)
+                    helpers.MockReaction(emoji=self.unicode_duck_emoji, users=[self.bot.user]),
+                    helpers.MockReaction(emoji=self.thumbs_up_emoji, users=[self.bot.user])
                 ]),
                 False
             ),
             (
                 "Green check mark reaction, but not from our bot",
                 helpers.MockMessage(reactions=[
-                    helpers.MockReaction(emoji=self.unicode_duck_emoji),
+                    helpers.MockReaction(emoji=self.unicode_duck_emoji, users=[self.bot.user]),
                     helpers.MockReaction(emoji=self.checkmark_emoji, users=[self.staff_member])
                 ]),
                 False
@@ -115,7 +114,7 @@ class DuckPondTests(base.LoggingTestCase):
             (
                 "Green check mark reaction, with one from the bot",
                 helpers.MockMessage(reactions=[
-                    helpers.MockReaction(emoji=self.unicode_duck_emoji),
+                    helpers.MockReaction(emoji=self.unicode_duck_emoji, users=[self.bot.user]),
                     helpers.MockReaction(emoji=self.checkmark_emoji, users=[self.staff_member, self.bot.user])
                 ]),
                 True
@@ -160,8 +159,7 @@ class DuckPondTests(base.LoggingTestCase):
 
         self.assertEqual(len(log_watcher.records), 1)
 
-        [record] = log_watcher.records
-        self.assertEqual(record.message, "Failed to send a message to the Duck Pool webhook")
+        record = log_watcher.records[0]
         self.assertEqual(record.levelno, logging.ERROR)
 
     def _get_reaction(
@@ -250,10 +248,12 @@ class DuckPondTests(base.LoggingTestCase):
             # A staffer with multiple duck reactions only counts once
             (
                 "Two different duck reactions from the same staffer",
-                helpers.MockMessage(reactions=[
-                    helpers.MockReaction(emoji=self.duck_pond_emoji, users=[self.staff_member]),
-                    helpers.MockReaction(emoji=self.unicode_duck_emoji, users=[self.staff_member]),
-                ]),
+                helpers.MockMessage(
+                    reactions=[
+                        helpers.MockReaction(emoji=self.duck_pond_emoji, users=[self.staff_member]),
+                        helpers.MockReaction(emoji=self.unicode_duck_emoji, users=[self.staff_member]),
+                    ]
+                ),
                 1
             ),
             # A non-string emoji does not count (to test the `isinstance(reaction.emoji, str)` elif)
@@ -265,10 +265,12 @@ class DuckPondTests(base.LoggingTestCase):
             # We correctly sum when multiple reactions are provided.
             (
                 "Duckpond Duck Reaction from 3 staffers + 2 non-staffers",
-                helpers.MockMessage(reactions=[
-                    self._get_reaction(emoji=self.duck_pond_emoji, staff=3, nonstaff=2),
-                    self._get_reaction(emoji=self.unicode_duck_emoji, staff=4, nonstaff=9),
-                ]),
+                helpers.MockMessage(
+                    reactions=[
+                        self._get_reaction(emoji=self.duck_pond_emoji, staff=3, nonstaff=2),
+                        self._get_reaction(emoji=self.unicode_duck_emoji, staff=4, nonstaff=9),
+                    ]
+                ),
                 3 + 4
             ),
         )
@@ -279,8 +281,8 @@ class DuckPondTests(base.LoggingTestCase):
                 self.assertEqual(expected_count, actual_count)
 
     @helpers.async_test
-    async def test_relay_message_to_duck_pond_correctly_relays_content_and_attachments(self):
-        """The `relay_message_to_duck_pond` method should correctly relay message content and attachments."""
+    async def test_relay_message_correctly_relays_content_and_attachments(self):
+        """The `relay_message` method should correctly relay message content and attachments."""
         send_webhook_path = f"{MODULE_PATH}.DuckPond.send_webhook"
         send_attachments_path = f"{MODULE_PATH}.send_attachments"
 
@@ -297,41 +299,47 @@ class DuckPondTests(base.LoggingTestCase):
             with patch(send_webhook_path, new_callable=helpers.AsyncMock) as send_webhook:
                 with patch(send_attachments_path, new_callable=helpers.AsyncMock) as send_attachments:
                     with self.subTest(clean_content=message.clean_content, attachments=message.attachments):
-                        await self.cog.relay_message_to_duck_pond(message)
+                        await self.cog.relay_message(message)
 
                         self.assertEqual(expect_webhook_call, send_webhook.called)
                         self.assertEqual(expect_attachment_call, send_attachments.called)
 
                         message.add_reaction.assert_called_once_with(self.checkmark_emoji)
-                        message.reset_mock()
 
-    @patch(f"{MODULE_PATH}.DuckPond.send_webhook", new_callable=helpers.AsyncMock)
     @patch(f"{MODULE_PATH}.send_attachments", new_callable=helpers.AsyncMock)
     @helpers.async_test
-    async def test_relay_message_to_duck_pond_handles_send_attachments_exceptions(self, send_attachments, send_webhook):
-        """The `relay_message_to_duck_pond` method should handle exceptions when calling `send_attachment`."""
+    async def test_relay_message_handles_irretrievable_attachment_exceptions(self, send_attachments):
+        """The `relay_message` method should handle irretrievable attachments."""
         message = helpers.MockMessage(clean_content="message", attachments=["attachment"])
         side_effects = (discord.errors.Forbidden(MagicMock(), ""), discord.errors.NotFound(MagicMock(), ""))
 
         self.cog.webhook = helpers.MockAsyncWebhook()
         log = logging.getLogger("bot.cogs.duck_pond")
 
-        # Subtests for the first `except` block
         for side_effect in side_effects:
             send_attachments.side_effect = side_effect
-            with self.subTest(side_effect=type(side_effect).__name__):
-                with self.assertNotLogs(logger=log, level=logging.ERROR):
-                    await self.cog.relay_message_to_duck_pond(message)
+            with patch(f"{MODULE_PATH}.DuckPond.send_webhook", new_callable=helpers.AsyncMock) as send_webhook:
+                with self.subTest(side_effect=type(side_effect).__name__):
+                    with self.assertNotLogs(logger=log, level=logging.ERROR):
+                        await self.cog.relay_message(message)
+
+                    self.assertEqual(send_webhook.call_count, 2)
+
+    @patch(f"{MODULE_PATH}.DuckPond.send_webhook", new_callable=helpers.AsyncMock)
+    @patch(f"{MODULE_PATH}.send_attachments", new_callable=helpers.AsyncMock)
+    @helpers.async_test
+    async def test_relay_message_handles_attachment_http_error(self, send_attachments, send_webhook):
+        """The `relay_message` method should handle irretrievable attachments."""
+        message = helpers.MockMessage(clean_content="message", attachments=["attachment"])
 
-                self.assertEqual(send_webhook.call_count, 2)
-                send_webhook.reset_mock()
+        self.cog.webhook = helpers.MockAsyncWebhook()
+        log = logging.getLogger("bot.cogs.duck_pond")
 
-        # Subtests for the second `except` block
         side_effect = discord.HTTPException(MagicMock(), "")
         send_attachments.side_effect = side_effect
         with self.subTest(side_effect=type(side_effect).__name__):
             with self.assertLogs(logger=log, level=logging.ERROR) as log_watcher:
-                await self.cog.relay_message_to_duck_pond(message)
+                await self.cog.relay_message(message)
 
             send_webhook.assert_called_once_with(
                 content=message.clean_content,
@@ -341,10 +349,75 @@ class DuckPondTests(base.LoggingTestCase):
 
             self.assertEqual(len(log_watcher.records), 1)
 
-            [record] = log_watcher.records
-            self.assertEqual(record.message, "Failed to send an attachment to the webhook")
+            record = log_watcher.records[0]
             self.assertEqual(record.levelno, logging.ERROR)
 
+    def _mock_payload(self, label: str, is_custom_emoji: bool, id_: int, emoji_name: str):
+        """Creates a mock `on_raw_reaction_add` payload with the specified emoji data."""
+        payload = MagicMock(name=label)
+        payload.emoji.is_custom_emoji.return_value = is_custom_emoji
+        payload.emoji.id = id_
+        payload.emoji.name = emoji_name
+        return payload
+
+    @helpers.async_test
+    async def test_payload_has_duckpond_emoji_correctly_detects_relevant_emojis(self):
+        """The `on_raw_reaction_add` event handler should ignore irrelevant emojis."""
+        test_values = (
+            # Custom Emojis
+            (
+                self._mock_payload(
+                    label="Custom Duckpond Emoji",
+                    is_custom_emoji=True,
+                    id_=constants.DuckPond.custom_emojis[0],
+                    emoji_name=""
+                ),
+                True
+            ),
+            (
+                self._mock_payload(
+                    label="Custom Non-Duckpond Emoji",
+                    is_custom_emoji=True,
+                    id_=123,
+                    emoji_name=""
+                ),
+                False
+            ),
+            # Unicode Emojis
+            (
+                self._mock_payload(
+                    label="Unicode Duck Emoji",
+                    is_custom_emoji=False,
+                    id_=1,
+                    emoji_name=self.unicode_duck_emoji
+                ),
+                True
+            ),
+            (
+                self._mock_payload(
+                    label="Unicode Non-Duck Emoji",
+                    is_custom_emoji=False,
+                    id_=1,
+                    emoji_name=self.thumbs_up_emoji
+                ),
+                False
+            ),
+        )
+
+        for payload, expected_return in test_values:
+            actual_return = self.cog._payload_has_duckpond_emoji(payload)
+            with self.subTest(case=payload._mock_name, expected_return=expected_return, actual_return=actual_return):
+                self.assertEqual(expected_return, actual_return)
+
+    @patch(f"{MODULE_PATH}.discord.utils.get")
+    @patch(f"{MODULE_PATH}.DuckPond._payload_has_duckpond_emoji", new=MagicMock(return_value=False))
+    def test_on_raw_reaction_add_returns_early_with_payload_without_duck_emoji(self, utils_get):
+        """The `on_raw_reaction_add` method should return early if the payload does not contain a duck emoji."""
+        self.assertIsNone(asyncio.run(self.cog.on_raw_reaction_add(payload=MagicMock())))
+
+        # Ensure we've returned before making an unnecessary API call in the lines of code after the emoji check
+        utils_get.assert_not_called()
+
     def _raw_reaction_mocks(self, channel_id, message_id, user_id):
         """Sets up mocks for tests of the `on_raw_reaction_add` event listener."""
         channel = helpers.MockTextChannel(id=channel_id)
@@ -361,22 +434,6 @@ class DuckPondTests(base.LoggingTestCase):
 
         return channel, message, member, payload
 
-    @helpers.async_test
-    async def test_on_raw_reaction_add_returns_for_non_relevant_emojis(self):
-        """The `on_raw_reaction_add` event handler should ignore irrelevant emojis."""
-        payload_custom_emoji = MagicMock(label="Non-Duck Custom Emoji")
-        payload_custom_emoji.emoji.is_custom_emoji.return_value = True
-        payload_custom_emoji.emoji.id = 12345
-
-        payload_unicode_emoji = MagicMock(label="Non-Duck Unicode Emoji")
-        payload_unicode_emoji.emoji.is_custom_emoji.return_value = False
-        payload_unicode_emoji.emoji.name = self.thumbs_up_emoji
-
-        for payload in (payload_custom_emoji, payload_unicode_emoji):
-            with self.subTest(case=payload.label), patch(f"{MODULE_PATH}.discord.utils.get") as discord_utils_get:
-                self.assertIsNone(await self.cog.on_raw_reaction_add(payload))
-                discord_utils_get.assert_not_called()
-
     @helpers.async_test
     async def test_on_raw_reaction_add_returns_for_bot_and_non_staff_members(self):
         """The `on_raw_reaction_add` event handler should return for bot users or non-staff members."""
@@ -428,10 +485,8 @@ class DuckPondTests(base.LoggingTestCase):
         # Assert that we've made it past `self.is_staff`
         is_staff.assert_called_once()
 
-    @patch(f"{MODULE_PATH}.DuckPond.relay_message_to_duck_pond", new_callable=helpers.AsyncMock)
-    @patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock)
     @helpers.async_test
-    async def test_on_raw_reaction_add_does_not_relay_below_duck_threshold(self, count_ducks, message_relay):
+    async def test_on_raw_reaction_add_does_not_relay_below_duck_threshold(self):
         """The `on_raw_reaction_add` listener should not relay messages or attachments below the duck threshold."""
         test_cases = (
             (constants.DuckPond.threshold - 1, False),
@@ -444,21 +499,21 @@ class DuckPondTests(base.LoggingTestCase):
         payload.emoji = self.duck_pond_emoji
 
         for duck_count, should_relay in test_cases:
-            count_ducks.return_value = duck_count
-            with self.subTest(duck_count=duck_count, should_relay=should_relay):
-                await self.cog.on_raw_reaction_add(payload)
+            with patch(f"{MODULE_PATH}.DuckPond.relay_message", new_callable=helpers.AsyncMock) as relay_message:
+                with patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock) as count_ducks:
+                    count_ducks.return_value = duck_count
+                    with self.subTest(duck_count=duck_count, should_relay=should_relay):
+                        await self.cog.on_raw_reaction_add(payload)
 
-                # Confirm that we've made it past counting
-                count_ducks.assert_called_once()
-                count_ducks.reset_mock()
+                        # Confirm that we've made it past counting
+                        count_ducks.assert_called_once()
 
-                # Did we relay a message?
-                has_relayed = message_relay.called
-                self.assertEqual(has_relayed, should_relay)
+                        # Did we relay a message?
+                        has_relayed = relay_message.called
+                        self.assertEqual(has_relayed, should_relay)
 
-                if should_relay:
-                    message_relay.assert_called_once_with(message)
-                    message_relay.reset_mock()
+                        if should_relay:
+                            relay_message.assert_called_once_with(message)
 
     @helpers.async_test
     async def test_on_raw_reaction_remove_prevents_removal_of_green_checkmark_depending_on_the_duck_count(self):
@@ -479,10 +534,10 @@ class DuckPondTests(base.LoggingTestCase):
             (constants.DuckPond.threshold, True),
             (constants.DuckPond.threshold + 1, True),
         )
-        for duck_count, should_readd_checkmark in test_cases:
+        for duck_count, should_re_add_checkmark in test_cases:
             with patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock) as count_ducks:
                 count_ducks.return_value = duck_count
-                with self.subTest(duck_count=duck_count, should_readd_checkmark=should_readd_checkmark):
+                with self.subTest(duck_count=duck_count, should_re_add_checkmark=should_re_add_checkmark):
                     await self.cog.on_raw_reaction_remove(payload)
 
                     # Check if we fetched the message
@@ -491,16 +546,15 @@ class DuckPondTests(base.LoggingTestCase):
                     # Check if we actually counted the number of ducks
                     count_ducks.assert_called_once_with(message)
 
-                    has_readded_checkmark = message.add_reaction.called
-                    self.assertEqual(should_readd_checkmark, has_readded_checkmark)
+                    has_re_added_checkmark = message.add_reaction.called
+                    self.assertEqual(should_re_add_checkmark, has_re_added_checkmark)
 
-                    if should_readd_checkmark:
+                    if should_re_add_checkmark:
                         message.add_reaction.assert_called_once_with(self.checkmark_emoji)
                         message.add_reaction.reset_mock()
 
                     # reset mocks
                     channel.fetch_message.reset_mock()
-                    count_ducks.reset_mock()
                     message.reset_mock()
 
     def test_on_raw_reaction_remove_ignores_removal_of_non_checkmark_reactions(self):
@@ -530,7 +584,9 @@ class DuckPondSetupTests(unittest.TestCase):
 
         with self.assertLogs(logger=log, level=logging.INFO) as log_watcher:
             duck_pond.setup(bot)
-            line = log_watcher.output[0]
+
+        self.assertEqual(len(log_watcher.records), 1)
+        record = log_watcher.records[0]
+        self.assertEqual(record.levelno, logging.INFO)
 
         bot.add_cog.assert_called_once()
-        self.assertIn("Cog loaded: DuckPond", line)
-- 
cgit v1.2.3


From 6fe61e5919cb541a1651312a01ddf7e7f10d0f86 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sat, 7 Dec 2019 20:11:50 -0800
Subject: Change all Bot imports to use the subclass

---
 bot/cogs/alias.py                      | 3 ++-
 bot/cogs/antimalware.py                | 3 ++-
 bot/cogs/antispam.py                   | 3 ++-
 bot/cogs/bot.py                        | 3 ++-
 bot/cogs/clean.py                      | 3 ++-
 bot/cogs/defcon.py                     | 3 ++-
 bot/cogs/doc.py                        | 5 +++--
 bot/cogs/duck_pond.py                  | 3 ++-
 bot/cogs/error_handler.py              | 3 ++-
 bot/cogs/eval.py                       | 3 ++-
 bot/cogs/extensions.py                 | 3 ++-
 bot/cogs/filtering.py                  | 3 ++-
 bot/cogs/free.py                       | 3 ++-
 bot/cogs/help.py                       | 3 ++-
 bot/cogs/information.py                | 3 ++-
 bot/cogs/jams.py                       | 5 +++--
 bot/cogs/logging.py                    | 3 ++-
 bot/cogs/moderation/__init__.py        | 3 +--
 bot/cogs/moderation/infractions.py     | 3 ++-
 bot/cogs/moderation/management.py      | 3 ++-
 bot/cogs/moderation/modlog.py          | 3 ++-
 bot/cogs/moderation/scheduler.py       | 3 ++-
 bot/cogs/moderation/superstarify.py    | 3 ++-
 bot/cogs/off_topic_names.py            | 3 ++-
 bot/cogs/reddit.py                     | 3 ++-
 bot/cogs/reminders.py                  | 3 ++-
 bot/cogs/security.py                   | 4 +++-
 bot/cogs/site.py                       | 3 ++-
 bot/cogs/snekbox.py                    | 3 ++-
 bot/cogs/sync/__init__.py              | 3 +--
 bot/cogs/sync/cog.py                   | 3 ++-
 bot/cogs/sync/syncers.py               | 7 ++++---
 bot/cogs/tags.py                       | 3 ++-
 bot/cogs/token_remover.py              | 3 ++-
 bot/cogs/utils.py                      | 3 ++-
 bot/cogs/verification.py               | 3 ++-
 bot/cogs/watchchannels/__init__.py     | 3 +--
 bot/cogs/watchchannels/bigbrother.py   | 3 ++-
 bot/cogs/watchchannels/talentpool.py   | 3 ++-
 bot/cogs/watchchannels/watchchannel.py | 3 ++-
 bot/cogs/wolfram.py                    | 7 ++++---
 bot/interpreter.py                     | 4 +++-
 tests/helpers.py                       | 4 +++-
 43 files changed, 92 insertions(+), 52 deletions(-)

(limited to 'tests')

diff --git a/bot/cogs/alias.py b/bot/cogs/alias.py
index 5190c559b..4ee5a2aed 100644
--- a/bot/cogs/alias.py
+++ b/bot/cogs/alias.py
@@ -3,8 +3,9 @@ import logging
 from typing import Union
 
 from discord import Colour, Embed, Member, User
-from discord.ext.commands import Bot, Cog, Command, Context, clean_content, command, group
+from discord.ext.commands import Cog, Command, Context, clean_content, command, group
 
+from bot.bot import Bot
 from bot.cogs.extensions import Extension
 from bot.cogs.watchchannels.watchchannel import proxy_user
 from bot.converters import TagNameConverter
diff --git a/bot/cogs/antimalware.py b/bot/cogs/antimalware.py
index 602819191..03c1e28a1 100644
--- a/bot/cogs/antimalware.py
+++ b/bot/cogs/antimalware.py
@@ -1,8 +1,9 @@
 import logging
 
 from discord import Embed, Message, NotFound
-from discord.ext.commands import Bot, Cog
+from discord.ext.commands import Cog
 
+from bot.bot import Bot
 from bot.constants import AntiMalware as AntiMalwareConfig, Channels, URLs
 
 log = logging.getLogger(__name__)
diff --git a/bot/cogs/antispam.py b/bot/cogs/antispam.py
index 1340eb608..88912038a 100644
--- a/bot/cogs/antispam.py
+++ b/bot/cogs/antispam.py
@@ -7,9 +7,10 @@ from operator import itemgetter
 from typing import Dict, Iterable, List, Set
 
 from discord import Colour, Member, Message, NotFound, Object, TextChannel
-from discord.ext.commands import Bot, Cog
+from discord.ext.commands import Cog
 
 from bot import rules
+from bot.bot import Bot
 from bot.cogs.moderation import ModLog
 from bot.constants import (
     AntiSpam as AntiSpamConfig, Channels,
diff --git a/bot/cogs/bot.py b/bot/cogs/bot.py
index ee0a463de..a2edb7576 100644
--- a/bot/cogs/bot.py
+++ b/bot/cogs/bot.py
@@ -5,8 +5,9 @@ import time
 from typing import Optional, Tuple
 
 from discord import Embed, Message, RawMessageUpdateEvent, TextChannel
-from discord.ext.commands import Bot, Cog, Context, command, group
+from discord.ext.commands import Cog, Context, command, group
 
+from bot.bot import Bot
 from bot.constants import Channels, DEBUG_MODE, Guild, MODERATION_ROLES, Roles, URLs
 from bot.decorators import with_role
 from bot.utils.messages import wait_for_deletion
diff --git a/bot/cogs/clean.py b/bot/cogs/clean.py
index dca411d01..3365d0934 100644
--- a/bot/cogs/clean.py
+++ b/bot/cogs/clean.py
@@ -4,8 +4,9 @@ import re
 from typing import Optional
 
 from discord import Colour, Embed, Message, User
-from discord.ext.commands import Bot, Cog, Context, group
+from discord.ext.commands import Cog, Context, group
 
+from bot.bot import Bot
 from bot.cogs.moderation import ModLog
 from bot.constants import (
     Channels, CleanMessages, Colours, Event,
diff --git a/bot/cogs/defcon.py b/bot/cogs/defcon.py
index bedd70c86..f062a7546 100644
--- a/bot/cogs/defcon.py
+++ b/bot/cogs/defcon.py
@@ -6,8 +6,9 @@ from datetime import datetime, timedelta
 from enum import Enum
 
 from discord import Colour, Embed, Member
-from discord.ext.commands import Bot, Cog, Context, group
+from discord.ext.commands import Cog, Context, group
 
+from bot.bot import Bot
 from bot.cogs.moderation import ModLog
 from bot.constants import Channels, Colours, Emojis, Event, Icons, Roles
 from bot.decorators import with_role
diff --git a/bot/cogs/doc.py b/bot/cogs/doc.py
index e5b3a4062..7df159fd9 100644
--- a/bot/cogs/doc.py
+++ b/bot/cogs/doc.py
@@ -17,6 +17,7 @@ from requests import ConnectTimeout, ConnectionError, HTTPError
 from sphinx.ext import intersphinx
 from urllib3.exceptions import ProtocolError
 
+from bot.bot import Bot
 from bot.constants import MODERATION_ROLES, RedirectOutput
 from bot.converters import ValidPythonIdentifier, ValidURL
 from bot.decorators import with_role
@@ -147,7 +148,7 @@ class InventoryURL(commands.Converter):
 class Doc(commands.Cog):
     """A set of commands for querying & displaying documentation."""
 
-    def __init__(self, bot: commands.Bot):
+    def __init__(self, bot: Bot):
         self.base_urls = {}
         self.bot = bot
         self.inventories = {}
@@ -506,7 +507,7 @@ class Doc(commands.Cog):
         return tag.name == "table"
 
 
-def setup(bot: commands.Bot) -> None:
+def setup(bot: Bot) -> None:
     """Doc cog load."""
     bot.add_cog(Doc(bot))
     log.info("Cog loaded: Doc")
diff --git a/bot/cogs/duck_pond.py b/bot/cogs/duck_pond.py
index 2d25cd17e..879071d1b 100644
--- a/bot/cogs/duck_pond.py
+++ b/bot/cogs/duck_pond.py
@@ -3,9 +3,10 @@ from typing import Optional, Union
 
 import discord
 from discord import Color, Embed, Member, Message, RawReactionActionEvent, User, errors
-from discord.ext.commands import Bot, Cog
+from discord.ext.commands import Cog
 
 from bot import constants
+from bot.bot import Bot
 from bot.utils.messages import send_attachments
 
 log = logging.getLogger(__name__)
diff --git a/bot/cogs/error_handler.py b/bot/cogs/error_handler.py
index 49411814c..cf90e9f48 100644
--- a/bot/cogs/error_handler.py
+++ b/bot/cogs/error_handler.py
@@ -14,9 +14,10 @@ from discord.ext.commands import (
     NoPrivateMessage,
     UserInputError,
 )
-from discord.ext.commands import Bot, Cog, Context
+from discord.ext.commands import Cog, Context
 
 from bot.api import ResponseCodeError
+from bot.bot import Bot
 from bot.constants import Channels
 from bot.decorators import InChannelCheckFailure
 
diff --git a/bot/cogs/eval.py b/bot/cogs/eval.py
index 00b988dde..5daec3e39 100644
--- a/bot/cogs/eval.py
+++ b/bot/cogs/eval.py
@@ -9,8 +9,9 @@ from io import StringIO
 from typing import Any, Optional, Tuple
 
 import discord
-from discord.ext.commands import Bot, Cog, Context, group
+from discord.ext.commands import Cog, Context, group
 
+from bot.bot import Bot
 from bot.constants import Roles
 from bot.decorators import with_role
 from bot.interpreter import Interpreter
diff --git a/bot/cogs/extensions.py b/bot/cogs/extensions.py
index bb66e0b8e..4d77d8205 100644
--- a/bot/cogs/extensions.py
+++ b/bot/cogs/extensions.py
@@ -6,8 +6,9 @@ from pkgutil import iter_modules
 
 from discord import Colour, Embed
 from discord.ext import commands
-from discord.ext.commands import Bot, Context, group
+from discord.ext.commands import Context, group
 
+from bot.bot import Bot
 from bot.constants import Emojis, MODERATION_ROLES, Roles, URLs
 from bot.pagination import LinePaginator
 from bot.utils.checks import with_role_check
diff --git a/bot/cogs/filtering.py b/bot/cogs/filtering.py
index 1e7521054..2e54ccecb 100644
--- a/bot/cogs/filtering.py
+++ b/bot/cogs/filtering.py
@@ -5,8 +5,9 @@ from typing import Optional, Union
 import discord.errors
 from dateutil.relativedelta import relativedelta
 from discord import Colour, DMChannel, Member, Message, TextChannel
-from discord.ext.commands import Bot, Cog
+from discord.ext.commands import Cog
 
+from bot.bot import Bot
 from bot.cogs.moderation import ModLog
 from bot.constants import (
     Channels, Colours,
diff --git a/bot/cogs/free.py b/bot/cogs/free.py
index 82285656b..bbc9f063b 100644
--- a/bot/cogs/free.py
+++ b/bot/cogs/free.py
@@ -3,8 +3,9 @@ from datetime import datetime
 from operator import itemgetter
 
 from discord import Colour, Embed, Member, utils
-from discord.ext.commands import Bot, Cog, Context, command
+from discord.ext.commands import Cog, Context, command
 
+from bot.bot import Bot
 from bot.constants import Categories, Channels, Free, STAFF_ROLES
 from bot.decorators import redirect_output
 
diff --git a/bot/cogs/help.py b/bot/cogs/help.py
index 9607dbd8d..6385fa467 100644
--- a/bot/cogs/help.py
+++ b/bot/cogs/help.py
@@ -6,10 +6,11 @@ from typing import Union
 
 from discord import Colour, Embed, HTTPException, Message, Reaction, User
 from discord.ext import commands
-from discord.ext.commands import Bot, CheckFailure, Cog as DiscordCog, Command, Context
+from discord.ext.commands import CheckFailure, Cog as DiscordCog, Command, Context
 from fuzzywuzzy import fuzz, process
 
 from bot import constants
+from bot.bot import Bot
 from bot.constants import Channels, STAFF_ROLES
 from bot.decorators import redirect_output
 from bot.pagination import (
diff --git a/bot/cogs/information.py b/bot/cogs/information.py
index 530453600..56bd37bec 100644
--- a/bot/cogs/information.py
+++ b/bot/cogs/information.py
@@ -9,10 +9,11 @@ from typing import Any, Mapping, Optional
 import discord
 from discord import CategoryChannel, Colour, Embed, Member, Role, TextChannel, VoiceChannel, utils
 from discord.ext import commands
-from discord.ext.commands import Bot, BucketType, Cog, Context, command, group
+from discord.ext.commands import BucketType, Cog, Context, command, group
 from discord.utils import escape_markdown
 
 from bot import constants
+from bot.bot import Bot
 from bot.decorators import InChannelCheckFailure, in_channel, with_role
 from bot.utils.checks import cooldown_with_role_bypass, with_role_check
 from bot.utils.time import time_since
diff --git a/bot/cogs/jams.py b/bot/cogs/jams.py
index be9d33e3e..0c82e7962 100644
--- a/bot/cogs/jams.py
+++ b/bot/cogs/jams.py
@@ -4,6 +4,7 @@ from discord import Member, PermissionOverwrite, utils
 from discord.ext import commands
 from more_itertools import unique_everseen
 
+from bot.bot import Bot
 from bot.constants import Roles
 from bot.decorators import with_role
 
@@ -13,7 +14,7 @@ log = logging.getLogger(__name__)
 class CodeJams(commands.Cog):
     """Manages the code-jam related parts of our server."""
 
-    def __init__(self, bot: commands.Bot):
+    def __init__(self, bot: Bot):
         self.bot = bot
 
     @commands.command()
@@ -108,7 +109,7 @@ class CodeJams(commands.Cog):
         )
 
 
-def setup(bot: commands.Bot) -> None:
+def setup(bot: Bot) -> None:
     """Code Jams cog load."""
     bot.add_cog(CodeJams(bot))
     log.info("Cog loaded: CodeJams")
diff --git a/bot/cogs/logging.py b/bot/cogs/logging.py
index c92b619ff..44c771b42 100644
--- a/bot/cogs/logging.py
+++ b/bot/cogs/logging.py
@@ -1,8 +1,9 @@
 import logging
 
 from discord import Embed
-from discord.ext.commands import Bot, Cog
+from discord.ext.commands import Cog
 
+from bot.bot import Bot
 from bot.constants import Channels, DEBUG_MODE
 
 
diff --git a/bot/cogs/moderation/__init__.py b/bot/cogs/moderation/__init__.py
index 7383ed44e..0cbdb3aa6 100644
--- a/bot/cogs/moderation/__init__.py
+++ b/bot/cogs/moderation/__init__.py
@@ -1,7 +1,6 @@
 import logging
 
-from discord.ext.commands import Bot
-
+from bot.bot import Bot
 from .infractions import Infractions
 from .management import ModManagement
 from .modlog import ModLog
diff --git a/bot/cogs/moderation/infractions.py b/bot/cogs/moderation/infractions.py
index 2713a1b68..7478e19ef 100644
--- a/bot/cogs/moderation/infractions.py
+++ b/bot/cogs/moderation/infractions.py
@@ -7,6 +7,7 @@ from discord.ext import commands
 from discord.ext.commands import Context, command
 
 from bot import constants
+from bot.bot import Bot
 from bot.constants import Event
 from bot.decorators import respect_role_hierarchy
 from bot.utils.checks import with_role_check
@@ -25,7 +26,7 @@ class Infractions(InfractionScheduler, commands.Cog):
     category = "Moderation"
     category_description = "Server moderation tools."
 
-    def __init__(self, bot: commands.Bot):
+    def __init__(self, bot: Bot):
         super().__init__(bot, supported_infractions={"ban", "kick", "mute", "note", "warning"})
 
         self.category = "Moderation"
diff --git a/bot/cogs/moderation/management.py b/bot/cogs/moderation/management.py
index abfe5c2b3..feae00b7c 100644
--- a/bot/cogs/moderation/management.py
+++ b/bot/cogs/moderation/management.py
@@ -9,6 +9,7 @@ from discord.ext import commands
 from discord.ext.commands import Context
 
 from bot import constants
+from bot.bot import Bot
 from bot.converters import InfractionSearchQuery
 from bot.pagination import LinePaginator
 from bot.utils import time
@@ -36,7 +37,7 @@ class ModManagement(commands.Cog):
 
     category = "Moderation"
 
-    def __init__(self, bot: commands.Bot):
+    def __init__(self, bot: Bot):
         self.bot = bot
 
     @property
diff --git a/bot/cogs/moderation/modlog.py b/bot/cogs/moderation/modlog.py
index 0df752a97..35ef6cbcc 100644
--- a/bot/cogs/moderation/modlog.py
+++ b/bot/cogs/moderation/modlog.py
@@ -10,8 +10,9 @@ from dateutil.relativedelta import relativedelta
 from deepdiff import DeepDiff
 from discord import Colour
 from discord.abc import GuildChannel
-from discord.ext.commands import Bot, Cog, Context
+from discord.ext.commands import Cog, Context
 
+from bot.bot import Bot
 from bot.constants import Channels, Colours, Emojis, Event, Guild as GuildConstant, Icons, URLs
 from bot.utils.time import humanize_delta
 from .utils import UserTypes
diff --git a/bot/cogs/moderation/scheduler.py b/bot/cogs/moderation/scheduler.py
index 3e0968121..937113ef4 100644
--- a/bot/cogs/moderation/scheduler.py
+++ b/bot/cogs/moderation/scheduler.py
@@ -7,10 +7,11 @@ from gettext import ngettext
 
 import dateutil.parser
 import discord
-from discord.ext.commands import Bot, Context
+from discord.ext.commands import Context
 
 from bot import constants
 from bot.api import ResponseCodeError
+from bot.bot import Bot
 from bot.constants import Colours, STAFF_CHANNELS
 from bot.utils import time
 from bot.utils.scheduling import Scheduler
diff --git a/bot/cogs/moderation/superstarify.py b/bot/cogs/moderation/superstarify.py
index 9b3c62403..7631d9bbe 100644
--- a/bot/cogs/moderation/superstarify.py
+++ b/bot/cogs/moderation/superstarify.py
@@ -6,9 +6,10 @@ import typing as t
 from pathlib import Path
 
 from discord import Colour, Embed, Member
-from discord.ext.commands import Bot, Cog, Context, command
+from discord.ext.commands import Cog, Context, command
 
 from bot import constants
+from bot.bot import Bot
 from bot.utils.checks import with_role_check
 from bot.utils.time import format_infraction
 from . import utils
diff --git a/bot/cogs/off_topic_names.py b/bot/cogs/off_topic_names.py
index 78792240f..18d9cfb01 100644
--- a/bot/cogs/off_topic_names.py
+++ b/bot/cogs/off_topic_names.py
@@ -4,9 +4,10 @@ import logging
 from datetime import datetime, timedelta
 
 from discord import Colour, Embed
-from discord.ext.commands import BadArgument, Bot, Cog, Context, Converter, group
+from discord.ext.commands import BadArgument, Cog, Context, Converter, group
 
 from bot.api import ResponseCodeError
+from bot.bot import Bot
 from bot.constants import Channels, MODERATION_ROLES
 from bot.decorators import with_role
 from bot.pagination import LinePaginator
diff --git a/bot/cogs/reddit.py b/bot/cogs/reddit.py
index 0d06e9c26..c76fcd937 100644
--- a/bot/cogs/reddit.py
+++ b/bot/cogs/reddit.py
@@ -6,9 +6,10 @@ from datetime import datetime, timedelta
 from typing import List
 
 from discord import Colour, Embed, TextChannel
-from discord.ext.commands import Bot, Cog, Context, group
+from discord.ext.commands import Cog, Context, group
 from discord.ext.tasks import loop
 
+from bot.bot import Bot
 from bot.constants import Channels, ERROR_REPLIES, Emojis, Reddit as RedditConfig, STAFF_ROLES, Webhooks
 from bot.converters import Subreddit
 from bot.decorators import with_role
diff --git a/bot/cogs/reminders.py b/bot/cogs/reminders.py
index 81990704b..b805b24c5 100644
--- a/bot/cogs/reminders.py
+++ b/bot/cogs/reminders.py
@@ -8,8 +8,9 @@ from typing import Optional
 
 from dateutil.relativedelta import relativedelta
 from discord import Colour, Embed, Message
-from discord.ext.commands import Bot, Cog, Context, group
+from discord.ext.commands import Cog, Context, group
 
+from bot.bot import Bot
 from bot.constants import Channels, Icons, NEGATIVE_REPLIES, POSITIVE_REPLIES, STAFF_ROLES
 from bot.converters import Duration
 from bot.pagination import LinePaginator
diff --git a/bot/cogs/security.py b/bot/cogs/security.py
index 316b33d6b..45d0eb2f5 100644
--- a/bot/cogs/security.py
+++ b/bot/cogs/security.py
@@ -1,6 +1,8 @@
 import logging
 
-from discord.ext.commands import Bot, Cog, Context, NoPrivateMessage
+from discord.ext.commands import Cog, Context, NoPrivateMessage
+
+from bot.bot import Bot
 
 log = logging.getLogger(__name__)
 
diff --git a/bot/cogs/site.py b/bot/cogs/site.py
index 683613788..1d7bd03e4 100644
--- a/bot/cogs/site.py
+++ b/bot/cogs/site.py
@@ -1,8 +1,9 @@
 import logging
 
 from discord import Colour, Embed
-from discord.ext.commands import Bot, Cog, Context, group
+from discord.ext.commands import Cog, Context, group
 
+from bot.bot import Bot
 from bot.constants import URLs
 from bot.pagination import LinePaginator
 
diff --git a/bot/cogs/snekbox.py b/bot/cogs/snekbox.py
index 55a187ac1..1ea61a8da 100644
--- a/bot/cogs/snekbox.py
+++ b/bot/cogs/snekbox.py
@@ -5,8 +5,9 @@ import textwrap
 from signal import Signals
 from typing import Optional, Tuple
 
-from discord.ext.commands import Bot, Cog, Context, command, guild_only
+from discord.ext.commands import Cog, Context, command, guild_only
 
+from bot.bot import Bot
 from bot.constants import Channels, Roles, URLs
 from bot.decorators import in_channel
 from bot.utils.messages import wait_for_deletion
diff --git a/bot/cogs/sync/__init__.py b/bot/cogs/sync/__init__.py
index d4565f848..0da81c60e 100644
--- a/bot/cogs/sync/__init__.py
+++ b/bot/cogs/sync/__init__.py
@@ -1,7 +1,6 @@
 import logging
 
-from discord.ext.commands import Bot
-
+from bot.bot import Bot
 from .cog import Sync
 
 log = logging.getLogger(__name__)
diff --git a/bot/cogs/sync/cog.py b/bot/cogs/sync/cog.py
index aaa581f96..90d4c40fe 100644
--- a/bot/cogs/sync/cog.py
+++ b/bot/cogs/sync/cog.py
@@ -3,10 +3,11 @@ from typing import Callable, Iterable
 
 from discord import Guild, Member, Role
 from discord.ext import commands
-from discord.ext.commands import Bot, Cog, Context
+from discord.ext.commands import Cog, Context
 
 from bot import constants
 from bot.api import ResponseCodeError
+from bot.bot import Bot
 from bot.cogs.sync import syncers
 
 log = logging.getLogger(__name__)
diff --git a/bot/cogs/sync/syncers.py b/bot/cogs/sync/syncers.py
index 2cc5a66e1..14cf51383 100644
--- a/bot/cogs/sync/syncers.py
+++ b/bot/cogs/sync/syncers.py
@@ -2,7 +2,8 @@ from collections import namedtuple
 from typing import Dict, Set, Tuple
 
 from discord import Guild
-from discord.ext.commands import Bot
+
+from bot.bot import Bot
 
 # These objects are declared as namedtuples because tuples are hashable,
 # something that we make use of when diffing site roles against guild roles.
@@ -52,7 +53,7 @@ async def sync_roles(bot: Bot, guild: Guild) -> Tuple[int, int, int]:
     Synchronize roles found on the given `guild` with the ones on the API.
 
     Arguments:
-        bot (discord.ext.commands.Bot):
+        bot (bot.bot.Bot):
             The bot instance that we're running with.
 
         guild (discord.Guild):
@@ -169,7 +170,7 @@ async def sync_users(bot: Bot, guild: Guild) -> Tuple[int, int, None]:
     Synchronize users found in the given `guild` with the ones in the API.
 
     Arguments:
-        bot (discord.ext.commands.Bot):
+        bot (bot.bot.Bot):
             The bot instance that we're running with.
 
         guild (discord.Guild):
diff --git a/bot/cogs/tags.py b/bot/cogs/tags.py
index cd70e783a..2ece0095d 100644
--- a/bot/cogs/tags.py
+++ b/bot/cogs/tags.py
@@ -2,8 +2,9 @@ import logging
 import time
 
 from discord import Colour, Embed
-from discord.ext.commands import Bot, Cog, Context, group
+from discord.ext.commands import Cog, Context, group
 
+from bot.bot import Bot
 from bot.constants import Channels, Cooldowns, MODERATION_ROLES, Roles
 from bot.converters import TagContentConverter, TagNameConverter
 from bot.decorators import with_role
diff --git a/bot/cogs/token_remover.py b/bot/cogs/token_remover.py
index 5a0d20e57..7af7ed63a 100644
--- a/bot/cogs/token_remover.py
+++ b/bot/cogs/token_remover.py
@@ -6,9 +6,10 @@ import struct
 from datetime import datetime
 
 from discord import Colour, Message
-from discord.ext.commands import Bot, Cog
+from discord.ext.commands import Cog
 from discord.utils import snowflake_time
 
+from bot.bot import Bot
 from bot.cogs.moderation import ModLog
 from bot.constants import Channels, Colours, Event, Icons
 
diff --git a/bot/cogs/utils.py b/bot/cogs/utils.py
index 793fe4c1a..0ed996430 100644
--- a/bot/cogs/utils.py
+++ b/bot/cogs/utils.py
@@ -8,8 +8,9 @@ from typing import Tuple
 
 from dateutil import relativedelta
 from discord import Colour, Embed, Message, Role
-from discord.ext.commands import Bot, Cog, Context, command
+from discord.ext.commands import Cog, Context, command
 
+from bot.bot import Bot
 from bot.constants import Channels, MODERATION_ROLES, Mention, STAFF_ROLES
 from bot.decorators import in_channel, with_role
 from bot.utils.time import humanize_delta
diff --git a/bot/cogs/verification.py b/bot/cogs/verification.py
index b5e8d4357..74eb0dbf8 100644
--- a/bot/cogs/verification.py
+++ b/bot/cogs/verification.py
@@ -3,8 +3,9 @@ from datetime import datetime
 
 from discord import Colour, Message, NotFound, Object
 from discord.ext import tasks
-from discord.ext.commands import Bot, Cog, Context, command
+from discord.ext.commands import Cog, Context, command
 
+from bot.bot import Bot
 from bot.cogs.moderation import ModLog
 from bot.constants import (
     Bot as BotConfig,
diff --git a/bot/cogs/watchchannels/__init__.py b/bot/cogs/watchchannels/__init__.py
index 86e1050fa..e18aea88a 100644
--- a/bot/cogs/watchchannels/__init__.py
+++ b/bot/cogs/watchchannels/__init__.py
@@ -1,7 +1,6 @@
 import logging
 
-from discord.ext.commands import Bot
-
+from bot.bot import Bot
 from .bigbrother import BigBrother
 from .talentpool import TalentPool
 
diff --git a/bot/cogs/watchchannels/bigbrother.py b/bot/cogs/watchchannels/bigbrother.py
index 49783bb09..306ed4c64 100644
--- a/bot/cogs/watchchannels/bigbrother.py
+++ b/bot/cogs/watchchannels/bigbrother.py
@@ -3,8 +3,9 @@ from collections import ChainMap
 from typing import Union
 
 from discord import User
-from discord.ext.commands import Bot, Cog, Context, group
+from discord.ext.commands import Cog, Context, group
 
+from bot.bot import Bot
 from bot.cogs.moderation.utils import post_infraction
 from bot.constants import Channels, MODERATION_ROLES, Webhooks
 from bot.decorators import with_role
diff --git a/bot/cogs/watchchannels/talentpool.py b/bot/cogs/watchchannels/talentpool.py
index 4ec42dcc1..cc8feeeee 100644
--- a/bot/cogs/watchchannels/talentpool.py
+++ b/bot/cogs/watchchannels/talentpool.py
@@ -4,9 +4,10 @@ from collections import ChainMap
 from typing import Union
 
 from discord import Color, Embed, Member, User
-from discord.ext.commands import Bot, Cog, Context, group
+from discord.ext.commands import Cog, Context, group
 
 from bot.api import ResponseCodeError
+from bot.bot import Bot
 from bot.constants import Channels, Guild, MODERATION_ROLES, STAFF_ROLES, Webhooks
 from bot.decorators import with_role
 from bot.pagination import LinePaginator
diff --git a/bot/cogs/watchchannels/watchchannel.py b/bot/cogs/watchchannels/watchchannel.py
index 0bf75a924..bd0622554 100644
--- a/bot/cogs/watchchannels/watchchannel.py
+++ b/bot/cogs/watchchannels/watchchannel.py
@@ -10,9 +10,10 @@ from typing import Optional
 import dateutil.parser
 import discord
 from discord import Color, Embed, HTTPException, Message, Object, errors
-from discord.ext.commands import BadArgument, Bot, Cog, Context
+from discord.ext.commands import BadArgument, Cog, Context
 
 from bot.api import ResponseCodeError
+from bot.bot import Bot
 from bot.cogs.moderation import ModLog
 from bot.constants import BigBrother as BigBrotherConfig, Guild as GuildConfig, Icons
 from bot.pagination import LinePaginator
diff --git a/bot/cogs/wolfram.py b/bot/cogs/wolfram.py
index ab0ed2472..c3c193cb9 100644
--- a/bot/cogs/wolfram.py
+++ b/bot/cogs/wolfram.py
@@ -7,8 +7,9 @@ import discord
 from dateutil.relativedelta import relativedelta
 from discord import Embed
 from discord.ext import commands
-from discord.ext.commands import Bot, BucketType, Cog, Context, check, group
+from discord.ext.commands import BucketType, Cog, Context, check, group
 
+from bot.bot import Bot
 from bot.constants import Colours, STAFF_ROLES, Wolfram
 from bot.pagination import ImagePaginator
 from bot.utils.time import humanize_delta
@@ -151,7 +152,7 @@ async def get_pod_pages(ctx: Context, bot: Bot, query: str) -> Optional[List[Tup
 class Wolfram(Cog):
     """Commands for interacting with the Wolfram|Alpha API."""
 
-    def __init__(self, bot: commands.Bot):
+    def __init__(self, bot: Bot):
         self.bot = bot
 
     @group(name="wolfram", aliases=("wolf", "wa"), invoke_without_command=True)
@@ -266,7 +267,7 @@ class Wolfram(Cog):
             await send_embed(ctx, message, color)
 
 
-def setup(bot: commands.Bot) -> None:
+def setup(bot: Bot) -> None:
     """Wolfram cog load."""
     bot.add_cog(Wolfram(bot))
     log.info("Cog loaded: Wolfram")
diff --git a/bot/interpreter.py b/bot/interpreter.py
index 76a3fc293..8b7268746 100644
--- a/bot/interpreter.py
+++ b/bot/interpreter.py
@@ -2,7 +2,9 @@ from code import InteractiveInterpreter
 from io import StringIO
 from typing import Any
 
-from discord.ext.commands import Bot, Context
+from discord.ext.commands import Context
+
+from bot.bot import Bot
 
 CODE_TEMPLATE = """
 async def _func():
diff --git a/tests/helpers.py b/tests/helpers.py
index b2daae92d..5df796c23 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -10,7 +10,9 @@ import unittest.mock
 from typing import Any, Iterable, Optional
 
 import discord
-from discord.ext.commands import Bot, Context
+from discord.ext.commands import Context
+
+from bot.bot import Bot
 
 
 for logger in logging.Logger.manager.loggerDict.values():
-- 
cgit v1.2.3


From 23acfce3521cd420a2df6eb51f036a2a54140ef6 Mon Sep 17 00:00:00 2001
From: MarkKoz <KozlovMark@gmail.com>
Date: Sun, 8 Dec 2019 02:01:01 -0800
Subject: Fix test failures for setup log messages

---
 tests/bot/cogs/test_duck_pond.py     | 12 ++----------
 tests/bot/cogs/test_security.py      | 11 +++--------
 tests/bot/cogs/test_token_remover.py |  8 ++------
 3 files changed, 7 insertions(+), 24 deletions(-)

(limited to 'tests')

diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
index b801e86f1..d07b2bce1 100644
--- a/tests/bot/cogs/test_duck_pond.py
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -578,15 +578,7 @@ class DuckPondSetupTests(unittest.TestCase):
     """Tests setup of the `DuckPond` cog."""
 
     def test_setup(self):
-        """Setup of the cog should log a message at `INFO` level."""
+        """Setup of the extension should call add_cog."""
         bot = helpers.MockBot()
-        log = logging.getLogger('bot.cogs.duck_pond')
-
-        with self.assertLogs(logger=log, level=logging.INFO) as log_watcher:
-            duck_pond.setup(bot)
-
-        self.assertEqual(len(log_watcher.records), 1)
-        record = log_watcher.records[0]
-        self.assertEqual(record.levelno, logging.INFO)
-
+        duck_pond.setup(bot)
         bot.add_cog.assert_called_once()
diff --git a/tests/bot/cogs/test_security.py b/tests/bot/cogs/test_security.py
index efa7a50b1..9d1a62f7e 100644
--- a/tests/bot/cogs/test_security.py
+++ b/tests/bot/cogs/test_security.py
@@ -1,4 +1,3 @@
-import logging
 import unittest
 from unittest.mock import MagicMock
 
@@ -49,11 +48,7 @@ class SecurityCogLoadTests(unittest.TestCase):
     """Tests loading the `Security` cog."""
 
     def test_security_cog_load(self):
-        """Cog loading logs a message at `INFO` level."""
+        """Setup of the extension should call add_cog."""
         bot = MagicMock()
-        with self.assertLogs(logger='bot.cogs.security', level=logging.INFO) as cm:
-            security.setup(bot)
-            bot.add_cog.assert_called_once()
-
-        [line] = cm.output
-        self.assertIn("Cog loaded: Security", line)
+        security.setup(bot)
+        bot.add_cog.assert_called_once()
diff --git a/tests/bot/cogs/test_token_remover.py b/tests/bot/cogs/test_token_remover.py
index 3276cf5a5..a54b839d7 100644
--- a/tests/bot/cogs/test_token_remover.py
+++ b/tests/bot/cogs/test_token_remover.py
@@ -125,11 +125,7 @@ class TokenRemoverSetupTests(unittest.TestCase):
     """Tests setup of the `TokenRemover` cog."""
 
     def test_setup(self):
-        """Setup of the cog should log a message at `INFO` level."""
+        """Setup of the extension should call add_cog."""
         bot = MockBot()
-        with self.assertLogs(logger='bot.cogs.token_remover', level=logging.INFO) as cm:
-            setup_cog(bot)
-
-        [line] = cm.output
+        setup_cog(bot)
         bot.add_cog.assert_called_once()
-        self.assertIn("Cog loaded: TokenRemover", line)
-- 
cgit v1.2.3