From c5d0eb473a9a1dc486dd2dd60603463435e49da4 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Mon, 28 Oct 2019 15:56:34 +0100
Subject: Change generation of child mocks

- https://docs.python.org/3/library/unittest.mock.html

We previously used an override of the `__new__` method to prevent our
custom mock types from instantiating their children with their own
type instead of a general mock type like `MagicMock` or `Mock`.

As it turns out, the Python documentation suggests another method of
doing this that does not involve overriding `__new__`. This commit
implements this new method to make sure we're using the idiomatic way
of handling this.

The suggested method is overriding the `_get_child_mock` method in
the subclass. To make our code DRY, I've created a mixin that should
come BEFORE the mock type we're subclassing in the MRO.

---

In addition, I have also added this new mixin to our `AsyncMock`
class to make sure that its `__call__` method returns a proper mock
object after it has been awaited. This makes sure that subsequent
attribute access on the returned object is mocked as expected.
---
 tests/helpers.py | 85 ++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 52 insertions(+), 33 deletions(-)

(limited to 'tests/helpers.py')

diff --git a/tests/helpers.py b/tests/helpers.py
index 892d42e6c..9375d0986 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -24,19 +24,6 @@ def async_test(wrapped):
     return wrapper
 
 
-# TODO: Remove me in Python 3.8
-class AsyncMock(unittest.mock.MagicMock):
-    """
-    A MagicMock subclass to mock async callables.
-
-    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)
-
-
 class HashableMixin(discord.mixins.EqualityComparable):
     """
     Mixin that provides similar hashing and equality functionality as discord.py's `Hashable` mixin.
@@ -61,15 +48,43 @@ class ColourMixin:
         self.colour = color
 
 
-class AttributeMock:
+class GetChildMockMixin:
     """Ensures attributes of our mock types will be instantiated with the correct mock type."""
 
-    def __new__(cls, *args, **kwargs):
-        """Stops the regular parent class from propagating to newly mocked attributes."""
-        if 'parent' in kwargs:
-            return cls.attribute_mocktype(*args, **kwargs)
+    def _get_child_mock(self, **kw):
+        """
+        Overwrite of the `_get_child_mock` method to stop the propagation of our custom mock classes.
+
+        Mock objects automatically create children when you access an attribute or call a method on them. By default,
+        the class of these children is the type of the parent itself. However, this would mean that the children created
+        for our custom mock types would also be instances of that custom mock type. This is not desirable, as attributes
+        of, e.g., a `Bot` object are not `Bot` objects themselves. The Python docs for `unittest.mock` hint that
+        overwriting this method is the best way to deal with that.
+
+        This override will look for an attribute called `child_mock_type` and use that as the type of the child mock.
+        """
+        klass = self.child_mock_type
 
-        return super().__new__(cls)
+        if self._mock_sealed:
+            attribute = "." + kw["name"] if "name" in kw else "()"
+            mock_name = self._extract_mock_name() + attribute
+            raise AttributeError(mock_name)
+
+        return klass(**kw)
+
+
+# TODO: Remove me in Python 3.8
+class AsyncMock(GetChildMockMixin, unittest.mock.MagicMock):
+    """
+    A MagicMock subclass to mock async callables.
+
+    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.
+    """
+    child_mock_type = unittest.mock.MagicMock
+
+    async def __call__(self, *args, **kwargs):
+        return super(AsyncMock, self).__call__(*args, **kwargs)
 
 
 # Create a guild instance to get a realistic Mock of `discord.Guild`
@@ -95,7 +110,7 @@ guild_data = {
 guild_instance = discord.Guild(data=guild_data, state=unittest.mock.MagicMock())
 
 
-class MockGuild(AttributeMock, unittest.mock.Mock, HashableMixin):
+class MockGuild(GetChildMockMixin, unittest.mock.Mock, HashableMixin):
     """
     A `Mock` subclass to mock `discord.Guild` objects.
 
@@ -122,7 +137,7 @@ class MockGuild(AttributeMock, unittest.mock.Mock, HashableMixin):
     For more info, see the `Mocking` section in `tests/README.md`.
     """
 
-    attribute_mocktype = unittest.mock.MagicMock
+    child_mock_type = unittest.mock.MagicMock
 
     def __init__(
         self,
@@ -175,7 +190,7 @@ role_data = {'name': 'role', 'id': 1}
 role_instance = discord.Role(guild=guild_instance, state=unittest.mock.MagicMock(), data=role_data)
 
 
-class MockRole(AttributeMock, unittest.mock.Mock, ColourMixin, HashableMixin):
+class MockRole(GetChildMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin):
     """
     A Mock subclass to mock `discord.Role` objects.
 
@@ -183,7 +198,7 @@ class MockRole(AttributeMock, unittest.mock.Mock, ColourMixin, HashableMixin):
     information, see the `MockGuild` docstring.
     """
 
-    attribute_mocktype = unittest.mock.MagicMock
+    child_mock_type = unittest.mock.MagicMock
 
     def __init__(self, name: str = "role", role_id: int = 1, position: int = 1, **kwargs) -> None:
         super().__init__(spec=role_instance, **kwargs)
@@ -208,7 +223,7 @@ state_mock = unittest.mock.MagicMock()
 member_instance = discord.Member(data=member_data, guild=guild_instance, state=state_mock)
 
 
-class MockMember(AttributeMock, unittest.mock.Mock, ColourMixin, HashableMixin):
+class MockMember(GetChildMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin):
     """
     A Mock subclass to mock Member objects.
 
@@ -216,7 +231,7 @@ class MockMember(AttributeMock, unittest.mock.Mock, ColourMixin, HashableMixin):
     information, see the `MockGuild` docstring.
     """
 
-    attribute_mocktype = unittest.mock.MagicMock
+    child_mock_type = unittest.mock.MagicMock
 
     def __init__(
         self,
@@ -254,7 +269,7 @@ class MockMember(AttributeMock, unittest.mock.Mock, ColourMixin, HashableMixin):
 bot_instance = Bot(command_prefix=unittest.mock.MagicMock())
 
 
-class MockBot(AttributeMock, unittest.mock.MagicMock):
+class MockBot(GetChildMockMixin, unittest.mock.MagicMock):
     """
     A MagicMock subclass to mock Bot objects.
 
@@ -262,11 +277,15 @@ class MockBot(AttributeMock, unittest.mock.MagicMock):
     For more information, see the `MockGuild` docstring.
     """
 
-    attribute_mocktype = unittest.mock.MagicMock
+    child_mock_type = unittest.mock.MagicMock
 
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=bot_instance, **kwargs)
 
+        # Our custom attributes and methods
+        self.http_session = unittest.mock.MagicMock()
+        self.api_client = unittest.mock.MagicMock()
+
         # `discord.ext.commands.Bot` coroutines
         self._before_invoke = AsyncMock()
         self._after_invoke = AsyncMock()
@@ -303,7 +322,7 @@ class MockBot(AttributeMock, unittest.mock.MagicMock):
 context_instance = Context(message=unittest.mock.MagicMock(), prefix=unittest.mock.MagicMock())
 
 
-class MockContext(AttributeMock, unittest.mock.MagicMock):
+class MockContext(GetChildMockMixin, unittest.mock.MagicMock):
     """
     A MagicMock subclass to mock Context objects.
 
@@ -311,7 +330,7 @@ class MockContext(AttributeMock, unittest.mock.MagicMock):
     instances. For more information, see the `MockGuild` docstring.
     """
 
-    attribute_mocktype = unittest.mock.MagicMock
+    child_mock_type = unittest.mock.MagicMock
 
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=context_instance, **kwargs)
@@ -346,7 +365,7 @@ guild = unittest.mock.MagicMock()
 channel_instance = discord.TextChannel(state=state, guild=guild, data=channel_data)
 
 
-class MockTextChannel(AttributeMock, unittest.mock.Mock, HashableMixin):
+class MockTextChannel(GetChildMockMixin, unittest.mock.Mock, HashableMixin):
     """
     A MagicMock subclass to mock TextChannel objects.
 
@@ -354,7 +373,7 @@ class MockTextChannel(AttributeMock, unittest.mock.Mock, HashableMixin):
     more information, see the `MockGuild` docstring.
     """
 
-    attribute_mocktype = unittest.mock.MagicMock
+    child_mock_type = unittest.mock.MagicMock
 
     def __init__(self, name: str = 'channel', channel_id: int = 1, **kwargs) -> None:
         super().__init__(spec=channel_instance, **kwargs)
@@ -402,7 +421,7 @@ channel = unittest.mock.MagicMock()
 message_instance = discord.Message(state=state, channel=channel, data=message_data)
 
 
-class MockMessage(AttributeMock, unittest.mock.MagicMock):
+class MockMessage(GetChildMockMixin, unittest.mock.MagicMock):
     """
     A MagicMock subclass to mock Message objects.
 
@@ -410,7 +429,7 @@ class MockMessage(AttributeMock, unittest.mock.MagicMock):
     information, see the `MockGuild` docstring.
     """
 
-    attribute_mocktype = unittest.mock.MagicMock
+    child_mock_type = unittest.mock.MagicMock
 
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=message_instance, **kwargs)
-- 
cgit v1.2.3


From 618ba6a523dababde230382e1965ecc89f23aaf5 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Tue, 29 Oct 2019 10:04:37 +0100
Subject: Enhance custom mock helpers

I have enhanced the custom mocks defined in `tests/helpers.py` in a
couple of important ways.

1. Automatically create AsyncMock attributes using `inspect`

Our previous approach, hard-coding AsynckMock attributes for all the
coroutine function methods defined for the class we are trying to
mock is prone to human error and not resilient against changes
introduced in updates of the library we are using.

Instead, I have now created a helper method in our `CustomMockMixin`
(formerly `GetChildMockMixin`) that automatically inspects the spec
instance we've passed for `coroutine functions` using the `inspect`
module. It then sets the according attributes with instances of the
AsyncMock class.

There is one caveat: `discord.py` very rarely defines regular methods
that return a coroutine object. Since the returned coroutine should
still be awaited, these regular methods should also be mocked with an
AsyncMock. However, since they are regular methods, `inspect` does
not detect them and they have to be added manually. (The only case of
this I've found so far is `Client.wait_for`.)

2. Properly set special attributes using `kwargs.get`

As we want attributes that point to other discord.py objects to use
our custom mocks (.e.g, `Message.author` should use `MockMember`),
the `__init__` method of our custom mocks make sure to correctly
instantiate these attributes.

However, the way we previously did that means we can't instantiate
the custom mock with a mock instance we provide, since this special
instantiation would overwrite the custom object we'd passed. I've
solved this by using `kwargs.get`, with a new mock as the default
value. This makes sure we only create a new mock if we didn't pass
a custom one:

```py
class MockMesseage:
    def __init__(self, **kwargs):
        self.author = kwargs.get('author', MockMember())
```

As you can see, we will only create a new MockMember if we did not
pass an `author` argument.

3. Factoring out duplicate lines

Since our `CustomMockMixin` is a parent to all of our custom mock
types, it makes sense to use it to factor out common code of all of
our custom mocks.

I've made the following changes:

- Set a default child mock type in the mixin.

- Create an `__init__` that takes care of the `inspect` of point 1

This means we won't have to repeat this in all of the child classes.

4. Three new Mock types: Emoji, PartialEmoji, and Reaction

I have added three more custom mocks:

- MockEmoji

- MockPartialEmoji

- MockReaction
---
 tests/helpers.py      | 253 +++++++++++++++++++-------------------------------
 tests/test_helpers.py |  58 +++++++++++-
 2 files changed, 150 insertions(+), 161 deletions(-)

(limited to 'tests/helpers.py')

diff --git a/tests/helpers.py b/tests/helpers.py
index 9375d0986..673beae3f 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import asyncio
 import functools
+import inspect
 import unittest.mock
-from typing import Iterable, Optional
+from typing import Any, Iterable, Optional
 
 import discord
 from discord.ext.commands import Bot, Context
@@ -48,9 +49,16 @@ class ColourMixin:
         self.colour = color
 
 
-class GetChildMockMixin:
+class CustomMockMixin:
     """Ensures attributes of our mock types will be instantiated with the correct mock type."""
 
+    child_mock_type = unittest.mock.MagicMock
+
+    def __init__(self, spec: Any = None, **kwargs):
+        super().__init__(spec=spec, **kwargs)
+        if spec:
+            self._extract_coroutine_methods_from_spec_instance(spec)
+
     def _get_child_mock(self, **kw):
         """
         Overwrite of the `_get_child_mock` method to stop the propagation of our custom mock classes.
@@ -72,17 +80,20 @@ class GetChildMockMixin:
 
         return klass(**kw)
 
+    def _extract_coroutine_methods_from_spec_instance(self, source: Any) -> None:
+        """Automatically detect coroutine functions in `source` and set them as AsyncMock attributes."""
+        for name, _method in inspect.getmembers(source, inspect.iscoroutinefunction):
+            setattr(self, name, AsyncMock())
+
 
 # TODO: Remove me in Python 3.8
-class AsyncMock(GetChildMockMixin, unittest.mock.MagicMock):
+class AsyncMock(CustomMockMixin, unittest.mock.MagicMock):
     """
     A MagicMock subclass to mock async callables.
 
     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.
     """
-    child_mock_type = unittest.mock.MagicMock
-
     async def __call__(self, *args, **kwargs):
         return super(AsyncMock, self).__call__(*args, **kwargs)
 
@@ -110,7 +121,7 @@ guild_data = {
 guild_instance = discord.Guild(data=guild_data, state=unittest.mock.MagicMock())
 
 
-class MockGuild(GetChildMockMixin, unittest.mock.Mock, HashableMixin):
+class MockGuild(CustomMockMixin, unittest.mock.Mock, HashableMixin):
     """
     A `Mock` subclass to mock `discord.Guild` objects.
 
@@ -136,9 +147,6 @@ class MockGuild(GetChildMockMixin, unittest.mock.Mock, HashableMixin):
 
     For more info, see the `Mocking` section in `tests/README.md`.
     """
-
-    child_mock_type = unittest.mock.MagicMock
-
     def __init__(
         self,
         guild_id: int = 1,
@@ -158,39 +166,13 @@ class MockGuild(GetChildMockMixin, unittest.mock.Mock, HashableMixin):
         if members:
             self.members.extend(members)
 
-        # `discord.Guild` coroutines
-        self.create_category_channel = AsyncMock()
-        self.ban = AsyncMock()
-        self.bans = AsyncMock()
-        self.create_category = AsyncMock()
-        self.create_custom_emoji = AsyncMock()
-        self.create_role = AsyncMock()
-        self.create_text_channel = AsyncMock()
-        self.create_voice_channel = AsyncMock()
-        self.delete = AsyncMock()
-        self.edit = AsyncMock()
-        self.estimate_pruned_members = AsyncMock()
-        self.fetch_ban = AsyncMock()
-        self.fetch_channels = AsyncMock()
-        self.fetch_emoji = AsyncMock()
-        self.fetch_emojis = AsyncMock()
-        self.fetch_member = AsyncMock()
-        self.invites = AsyncMock()
-        self.kick = AsyncMock()
-        self.leave = AsyncMock()
-        self.prune_members = AsyncMock()
-        self.unban = AsyncMock()
-        self.vanity_invite = AsyncMock()
-        self.webhooks = AsyncMock()
-        self.widget = AsyncMock()
-
 
 # Create a Role instance to get a realistic Mock of `discord.Role`
 role_data = {'name': 'role', 'id': 1}
 role_instance = discord.Role(guild=guild_instance, state=unittest.mock.MagicMock(), data=role_data)
 
 
-class MockRole(GetChildMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin):
+class MockRole(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin):
     """
     A Mock subclass to mock `discord.Role` objects.
 
@@ -208,10 +190,6 @@ class MockRole(GetChildMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin
         self.position = position
         self.mention = f'&{self.name}'
 
-        # 'discord.Role' coroutines
-        self.delete = AsyncMock()
-        self.edit = AsyncMock()
-
     def __lt__(self, other):
         """Simplified position-based comparisons similar to those of `discord.Role`."""
         return self.position < other.position
@@ -223,16 +201,13 @@ state_mock = unittest.mock.MagicMock()
 member_instance = discord.Member(data=member_data, guild=guild_instance, state=state_mock)
 
 
-class MockMember(GetChildMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin):
+class MockMember(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin):
     """
     A Mock subclass to mock Member objects.
 
     Instances of this class will follow the specifications of `discord.Member` instances. For more
     information, see the `MockGuild` docstring.
     """
-
-    child_mock_type = unittest.mock.MagicMock
-
     def __init__(
         self,
         name: str = "member",
@@ -251,34 +226,18 @@ class MockMember(GetChildMockMixin, unittest.mock.Mock, ColourMixin, HashableMix
 
         self.mention = f"@{self.name}"
 
-        # `discord.Member` coroutines
-        self.add_roles = AsyncMock()
-        self.ban = AsyncMock()
-        self.edit = AsyncMock()
-        self.fetch_message = AsyncMock()
-        self.kick = AsyncMock()
-        self.move_to = AsyncMock()
-        self.pins = AsyncMock()
-        self.remove_roles = AsyncMock()
-        self.send = AsyncMock()
-        self.trigger_typing = AsyncMock()
-        self.unban = AsyncMock()
-
 
 # Create a Bot instance to get a realistic MagicMock of `discord.ext.commands.Bot`
 bot_instance = Bot(command_prefix=unittest.mock.MagicMock())
 
 
-class MockBot(GetChildMockMixin, unittest.mock.MagicMock):
+class MockBot(CustomMockMixin, unittest.mock.MagicMock):
     """
     A MagicMock subclass to mock Bot objects.
 
     Instances of this class will follow the specifications of `discord.ext.commands.Bot` instances.
     For more information, see the `MockGuild` docstring.
     """
-
-    child_mock_type = unittest.mock.MagicMock
-
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=bot_instance, **kwargs)
 
@@ -286,69 +245,12 @@ class MockBot(GetChildMockMixin, unittest.mock.MagicMock):
         self.http_session = unittest.mock.MagicMock()
         self.api_client = unittest.mock.MagicMock()
 
-        # `discord.ext.commands.Bot` coroutines
-        self._before_invoke = AsyncMock()
-        self._after_invoke = AsyncMock()
-        self.application_info = AsyncMock()
-        self.change_presence = AsyncMock()
-        self.connect = AsyncMock()
-        self.close = AsyncMock()
-        self.create_guild = AsyncMock()
-        self.delete_invite = AsyncMock()
-        self.fetch_channel = AsyncMock()
-        self.fetch_guild = AsyncMock()
-        self.fetch_guilds = AsyncMock()
-        self.fetch_invite = AsyncMock()
-        self.fetch_user = AsyncMock()
-        self.fetch_user_profile = AsyncMock()
-        self.fetch_webhook = AsyncMock()
-        self.fetch_widget = AsyncMock()
-        self.get_context = AsyncMock()
-        self.get_prefix = AsyncMock()
-        self.invoke = AsyncMock()
-        self.is_owner = AsyncMock()
-        self.login = AsyncMock()
-        self.logout = AsyncMock()
-        self.on_command_error = AsyncMock()
-        self.on_error = AsyncMock()
-        self.process_commands = AsyncMock()
-        self.request_offline_members = AsyncMock()
-        self.start = AsyncMock()
-        self.wait_until_ready = AsyncMock()
+        # self.wait_for is *not* a coroutine function, but returns a coroutine nonetheless and
+        # and should therefore be awaited. (The documentation calls it a coroutine as well, which
+        # is technically incorrect, since it's a regular def.)
         self.wait_for = AsyncMock()
 
 
-# Create a Context instance to get a realistic MagicMock of `discord.ext.commands.Context`
-context_instance = Context(message=unittest.mock.MagicMock(), prefix=unittest.mock.MagicMock())
-
-
-class MockContext(GetChildMockMixin, unittest.mock.MagicMock):
-    """
-    A MagicMock subclass to mock Context objects.
-
-    Instances of this class will follow the specifications of `discord.ext.commands.Context`
-    instances. For more information, see the `MockGuild` docstring.
-    """
-
-    child_mock_type = unittest.mock.MagicMock
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(spec=context_instance, **kwargs)
-        self.bot = MockBot()
-        self.guild = MockGuild()
-        self.author = MockMember()
-        self.command = unittest.mock.MagicMock()
-
-        # `discord.ext.commands.Context` coroutines
-        self.fetch_message = AsyncMock()
-        self.invoke = AsyncMock()
-        self.pins = AsyncMock()
-        self.reinvoke = AsyncMock()
-        self.send = AsyncMock()
-        self.send_help = AsyncMock()
-        self.trigger_typing = AsyncMock()
-
-
 # Create a TextChannel instance to get a realistic MagicMock of `discord.TextChannel`
 channel_data = {
     'id': 1,
@@ -365,39 +267,20 @@ guild = unittest.mock.MagicMock()
 channel_instance = discord.TextChannel(state=state, guild=guild, data=channel_data)
 
 
-class MockTextChannel(GetChildMockMixin, unittest.mock.Mock, HashableMixin):
+class MockTextChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
     """
     A MagicMock subclass to mock TextChannel objects.
 
     Instances of this class will follow the specifications of `discord.TextChannel` instances. For
     more information, see the `MockGuild` docstring.
     """
-
-    child_mock_type = unittest.mock.MagicMock
-
     def __init__(self, name: str = 'channel', channel_id: int = 1, **kwargs) -> None:
         super().__init__(spec=channel_instance, **kwargs)
         self.id = channel_id
         self.name = name
-        self.guild = MockGuild()
+        self.guild = kwargs.get('guild', MockGuild())
         self.mention = f"#{self.name}"
 
-        # `discord.TextChannel` coroutines
-        self.clone = AsyncMock()
-        self.create_invite = AsyncMock()
-        self.create_webhook = AsyncMock()
-        self.delete = AsyncMock()
-        self.delete_messages = AsyncMock()
-        self.edit = AsyncMock()
-        self.fetch_message = AsyncMock()
-        self.invites = AsyncMock()
-        self.pins = AsyncMock()
-        self.purge = AsyncMock()
-        self.send = AsyncMock()
-        self.set_permissions = AsyncMock()
-        self.trigger_typing = AsyncMock()
-        self.webhooks = AsyncMock()
-
 
 # Create a Message instance to get a realistic MagicMock of `discord.Message`
 message_data = {
@@ -421,27 +304,83 @@ channel = unittest.mock.MagicMock()
 message_instance = discord.Message(state=state, channel=channel, data=message_data)
 
 
-class MockMessage(GetChildMockMixin, unittest.mock.MagicMock):
+# Create a Context instance to get a realistic MagicMock of `discord.ext.commands.Context`
+context_instance = Context(message=unittest.mock.MagicMock(), prefix=unittest.mock.MagicMock())
+
+
+class MockContext(CustomMockMixin, unittest.mock.MagicMock):
+    """
+    A MagicMock subclass to mock Context objects.
+
+    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())
+        self.guild = kwargs.get('guild', MockGuild())
+        self.author = kwargs.get('author', MockMember())
+        self.channel = kwargs.get('channel', MockTextChannel())
+        self.command = kwargs.get('command', unittest.mock.MagicMock())
+
+
+class MockMessage(CustomMockMixin, unittest.mock.MagicMock):
     """
     A MagicMock subclass to mock Message objects.
 
     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())
+        self.channel = kwargs.get('channel', MockTextChannel())
 
-    child_mock_type = unittest.mock.MagicMock
 
+emoji_data = {'require_colons': True, 'managed': True, 'id': 1, 'name': 'hyperlemon'}
+emoji_instance = discord.Emoji(guild=MockGuild(), state=unittest.mock.MagicMock(), data=emoji_data)
+
+
+class MockEmoji(CustomMockMixin, unittest.mock.MagicMock):
+    """
+    A MagicMock subclass to mock Emoji objects.
+
+    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=message_instance, **kwargs)
-        self.author = MockMember()
-        self.channel = MockTextChannel()
-
-        # `discord.Message` coroutines
-        self.ack = AsyncMock()
-        self.add_reaction = AsyncMock()
-        self.clear_reactions = AsyncMock()
-        self.delete = AsyncMock()
-        self.edit = AsyncMock()
-        self.pin = AsyncMock()
-        self.remove_reaction = AsyncMock()
-        self.unpin = AsyncMock()
+        super().__init__(spec=emoji_instance, **kwargs)
+        self.guild = kwargs.get('guild', MockGuild())
+
+        # Get all coroutine functions and set them as AsyncMock attributes
+        self._extract_coroutine_methods_from_spec_instance(emoji_instance)
+
+
+partial_emoji_instance = discord.PartialEmoji(animated=False, name='guido')
+
+
+class MockPartialEmoji(CustomMockMixin, unittest.mock.MagicMock):
+    """
+    A MagicMock subclass to mock PartialEmoji objects.
+
+    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)
+
+
+reaction_instance = discord.Reaction(message=MockMessage(), data={'me': True}, emoji=MockEmoji())
+
+
+class MockReaction(CustomMockMixin, unittest.mock.MagicMock):
+    """
+    A MagicMock subclass to mock Reaction objects.
+
+    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())
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
index 62007ff4e..2b58634dd 100644
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@@ -221,7 +221,7 @@ class DiscordMocksTests(unittest.TestCase):
     @unittest.mock.patch(f'{__name__}.DiscordMocksTests.subTest')
     def test_the_custom_mock_methods_test(self, subtest_mock):
         """The custom method test should raise AssertionError for invalid methods."""
-        class FakeMockBot(helpers.GetChildMockMixin, unittest.mock.MagicMock):
+        class FakeMockBot(helpers.CustomMockMixin, unittest.mock.MagicMock):
             """Fake MockBot class with invalid attribute/method `release_the_walrus`."""
 
             child_mock_type = unittest.mock.MagicMock
@@ -331,9 +331,9 @@ class MockObjectTests(unittest.TestCase):
                 self.assertFalse(instance_one != instance_two)
                 self.assertTrue(instance_one != instance_three)
 
-    def test_get_child_mock_mixin_accepts_mock_seal(self):
-        """The `GetChildMockMixin` should support `unittest.mock.seal`."""
-        class MyMock(helpers.GetChildMockMixin, unittest.mock.MagicMock):
+    def test_custom_mock_mixin_accepts_mock_seal(self):
+        """The `CustomMockMixin` should support `unittest.mock.seal`."""
+        class MyMock(helpers.CustomMockMixin, unittest.mock.MagicMock):
 
             child_mock_type = unittest.mock.MagicMock
             pass
@@ -351,6 +351,10 @@ class MockObjectTests(unittest.TestCase):
             (helpers.MockMember, "display_name"),
             (helpers.MockBot, "owner_id"),
             (helpers.MockContext, "command_failed"),
+            (helpers.MockMessage, "mention_everyone"),
+            (helpers.MockEmoji, 'managed'),
+            (helpers.MockPartialEmoji, 'url'),
+            (helpers.MockReaction, 'me'),
         )
 
         for mock_type, valid_attribute in test_values:
@@ -360,6 +364,52 @@ class MockObjectTests(unittest.TestCase):
                 attribute = getattr(mock, valid_attribute)
                 self.assertTrue(isinstance(attribute, mock_type.child_mock_type))
 
+    def test_extract_coroutine_methods_from_spec_instance_should_extract_all_and_only_coroutines(self):
+        """Test if all coroutine functions are extracted, but not regular methods or attributes."""
+        class CoroutineDonor:
+            def __init__(self):
+                self.some_attribute = 'alpha'
+
+            async def first_coroutine():
+                """This coroutine function should be extracted."""
+
+            async def second_coroutine():
+                """This coroutine function should be extracted."""
+
+            def regular_method():
+                """This regular function should not be extracted."""
+
+        class Receiver:
+            pass
+
+        donor = CoroutineDonor()
+        receiver = Receiver()
+
+        helpers.CustomMockMixin._extract_coroutine_methods_from_spec_instance(receiver, donor)
+
+        self.assertIsInstance(receiver.first_coroutine, helpers.AsyncMock)
+        self.assertIsInstance(receiver.second_coroutine, helpers.AsyncMock)
+        self.assertFalse(hasattr(receiver, 'regular_method'))
+        self.assertFalse(hasattr(receiver, 'some_attribute'))
+
+    @unittest.mock.patch("builtins.super", new=unittest.mock.MagicMock())
+    @unittest.mock.patch("tests.helpers.CustomMockMixin._extract_coroutine_methods_from_spec_instance")
+    def test_custom_mock_mixin_init_with_spec(self, extract_method_mock):
+        """Test if CustomMockMixin correctly passes on spec/kwargs and calls the extraction method."""
+        spec = "pydis"
+
+        helpers.CustomMockMixin(spec=spec)
+
+        extract_method_mock.assert_called_once_with(spec)
+
+    @unittest.mock.patch("builtins.super", new=unittest.mock.MagicMock())
+    @unittest.mock.patch("tests.helpers.CustomMockMixin._extract_coroutine_methods_from_spec_instance")
+    def test_custom_mock_mixin_init_without_spec(self, extract_method_mock):
+        """Test if CustomMockMixin correctly passes on spec/kwargs and calls the extraction method."""
+        helpers.CustomMockMixin()
+
+        extract_method_mock.assert_not_called()
+
     def test_async_mock_provides_coroutine_for_dunder_call(self):
         """Test if AsyncMock objects have a coroutine for their __call__ method."""
         async_mock = helpers.AsyncMock()
-- 
cgit v1.2.3


From 586ae18842de0dd92e93945c63ed5e6cd158c1f7 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Wed, 30 Oct 2019 22:54:27 +0100
Subject: Update docstring and remove redundant attribute

I accidentally forgot to update the docstring of `CustomMockMixin`,
which changed quite dramatically in scope with the last commit. This
commit remedies that.

In addition, I inadvertently forgot to remove the `child_mock_type`
class attribute from `MockRole`. Since it uses the default value, it
is no longer necessary to specify it in the child class as well.
---
 tests/helpers.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

(limited to 'tests/helpers.py')

diff --git a/tests/helpers.py b/tests/helpers.py
index 673beae3f..8496ba031 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -50,7 +50,15 @@ class ColourMixin:
 
 
 class CustomMockMixin:
-    """Ensures attributes of our mock types will be instantiated with the correct mock type."""
+    """
+    Provides common functionality for our custom Mock types.
+
+    The cooperative `__init__` automatically creates `AsyncMock` attributes for every coroutine
+    function `inspect` detects in the `spec` instance we provide. In addition, this mixin takes care
+    of making sure child mocks are instantiated with the correct class. By default, the mock of the
+    children will be `unittest.mock.MagicMock`, but this can be overwritten by setting the attribute
+    `child_mock_type` on the custom mock inheriting from this mixin.
+    """
 
     child_mock_type = unittest.mock.MagicMock
 
@@ -179,9 +187,6 @@ 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.
     """
-
-    child_mock_type = unittest.mock.MagicMock
-
     def __init__(self, name: str = "role", role_id: int = 1, position: int = 1, **kwargs) -> None:
         super().__init__(spec=role_instance, **kwargs)
 
-- 
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/helpers.py')

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 dceafb83e829548638e8589c88f80364e8009821 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Wed, 13 Nov 2019 15:32:13 +0100
Subject: Prevent unwanted logging while running tests

Previously, logging messages would output to std.out. when running
individual test files (instead of running the entire suite). To
prevent this, I've added a `for`-loop to `tests.helpers` that sets
the level of all registered loggers to `CRITICAL`.

The reason for adding this to `tests.helpers` is simple: It's the
most common file to be imported in individual tests, increasing the
chance of the code being run for individual test files.

A small downside of this way of handling logging is that when we are
trying to assert logging messages are being emitted, we need to set
the logger explicitly in the `self.assertLogs` context manager. This
is a small downside, though, and probably good practice anyway.

There was one test in `tests.bot.test_api` that did not do this, so
I have changed this to make the test compatible with the new set-up.
---
 tests/bot/test_api.py |  4 +++-
 tests/helpers.py      | 11 +++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

(limited to 'tests/helpers.py')

diff --git a/tests/bot/test_api.py b/tests/bot/test_api.py
index e0ede0eb1..5a88adc5c 100644
--- a/tests/bot/test_api.py
+++ b/tests/bot/test_api.py
@@ -121,7 +121,9 @@ class LoggingHandlerTests(LoggingTestCase):
 
     def test_schedule_queued_tasks_for_nonempty_queue(self):
         """`APILoggingHandler` should schedule logs when the queue is not empty."""
-        with self.assertLogs(level=logging.DEBUG) as logs, patch('asyncio.create_task') as create_task:
+        log = logging.getLogger("bot.api")
+
+        with self.assertLogs(logger=log, level=logging.DEBUG) as logs, patch('asyncio.create_task') as create_task:
             self.log_handler.queue = [555]
             self.log_handler.schedule_queued_tasks()
             self.assertListEqual(self.log_handler.queue, [])
diff --git a/tests/helpers.py b/tests/helpers.py
index 8496ba031..8d661513d 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import functools
 import inspect
+import logging
 import unittest.mock
 from typing import Any, Iterable, Optional
 
@@ -10,6 +11,16 @@ import discord
 from discord.ext.commands import Bot, Context
 
 
+for logger in logging.Logger.manager.loggerDict.values():
+    # Set all loggers to CRITICAL by default to prevent screen clutter during testing
+
+    if not isinstance(logger, logging.Logger):
+        # There might be some logging.PlaceHolder objects in there
+        continue
+
+    logger.setLevel(logging.CRITICAL)
+
+
 def async_test(wrapped):
     """
     Run a test case via asyncio.
-- 
cgit v1.2.3


From bf7720f16fa69716f15b16e3dcd0f20c186958b8 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Wed, 13 Nov 2019 16:06:51 +0100
Subject: Allow `name` attribute to be set during Mock init

The `name` keyword argument has a special meaning for the default
mockobjects provided by `unittest.mock`. This means that by default,
the common d.py `name` attribute can't be set during initalization of
one of our custom Mock-objects by passing it to the constructor.

Since it's unlikely for us to make use of the special `name` feature
of mocks and more likely to want to set the d.py `name` attribute, I
added special handling of the `name` kwarg.
---
 tests/helpers.py | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'tests/helpers.py')

diff --git a/tests/helpers.py b/tests/helpers.py
index 8d661513d..5dc7a0d2f 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -74,7 +74,10 @@ class CustomMockMixin:
     child_mock_type = unittest.mock.MagicMock
 
     def __init__(self, spec: Any = None, **kwargs):
+        name = kwargs.pop('name', None)  # `name` has special meaning for Mock classes, so we need to set it manually.
         super().__init__(spec=spec, **kwargs)
+        if name:
+            self.name = name
         if spec:
             self._extract_coroutine_methods_from_spec_instance(spec)
 
-- 
cgit v1.2.3


From 36e9de480dcabb3c844090a4fd87561534536c04 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Wed, 13 Nov 2019 11:24:58 +0100
Subject: Prevent setting unknown attributes on d.py mocks

Our custom `discord.py` now follow the specifications of the object
they are mocking more strictly by using the `spec_set` instead of the
`spec` kwarg to initialize the specifications. This means that trying
to set an attribute that does not follow the specifications will now
also result in an `AttributeError`.

To make sure we are not trying to set illegal attributes during the
default initialization of the mock objects, I've changed the way we
handle default values of parameters. This does introduce a breaking
change: Instead of passing a `suffix_id`, the `id` attribute should
now be passed using the exact name. `id`.

This commit also makes sure existing tests follow this change.
---
 tests/bot/cogs/test_information.py   | 58 ++++++++++-----------
 tests/bot/cogs/test_token_remover.py |  2 +-
 tests/bot/utils/test_checks.py       |  6 +--
 tests/helpers.py                     | 94 +++++++++++++---------------------
 tests/test_helpers.py                | 99 ++++++++++++------------------------
 5 files changed, 101 insertions(+), 158 deletions(-)

(limited to 'tests/helpers.py')

diff --git a/tests/bot/cogs/test_information.py b/tests/bot/cogs/test_information.py
index 5c34541d8..4496a2ae0 100644
--- a/tests/bot/cogs/test_information.py
+++ b/tests/bot/cogs/test_information.py
@@ -19,7 +19,7 @@ class InformationCogTests(unittest.TestCase):
 
     @classmethod
     def setUpClass(cls):
-        cls.moderator_role = helpers.MockRole(name="Moderator", role_id=constants.Roles.moderator)
+        cls.moderator_role = helpers.MockRole(name="Moderator", id=constants.Roles.moderator)
 
     def setUp(self):
         """Sets up fresh objects for each test."""
@@ -54,7 +54,7 @@ class InformationCogTests(unittest.TestCase):
         """Tests the `role info` command."""
         dummy_role = helpers.MockRole(
             name="Dummy",
-            role_id=112233445566778899,
+            id=112233445566778899,
             colour=discord.Colour.blurple(),
             position=10,
             members=[self.ctx.author],
@@ -63,7 +63,7 @@ class InformationCogTests(unittest.TestCase):
 
         admin_role = helpers.MockRole(
             name="Admins",
-            role_id=998877665544332211,
+            id=998877665544332211,
             colour=discord.Colour.red(),
             position=3,
             members=[self.ctx.author],
@@ -176,7 +176,7 @@ class UserInfractionHelperMethodTests(unittest.TestCase):
         self.bot = helpers.MockBot()
         self.bot.api_client.get = helpers.AsyncMock()
         self.cog = information.Information(self.bot)
-        self.member = helpers.MockMember(user_id=1234)
+        self.member = helpers.MockMember(id=1234)
 
     def test_user_command_helper_method_get_requests(self):
         """The helper methods should form the correct get requests."""
@@ -351,7 +351,7 @@ class UserEmbedTests(unittest.TestCase):
     @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
     def test_create_user_embed_uses_string_representation_of_user_in_title_if_nick_is_not_available(self):
         """The embed should use the string representation of the user if they don't have a nick."""
-        ctx = helpers.MockContext(channel=helpers.MockTextChannel(channel_id=1))
+        ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=1))
         user = helpers.MockMember()
         user.nick = None
         user.__str__ = unittest.mock.Mock(return_value="Mr. Hemlock")
@@ -363,7 +363,7 @@ class UserEmbedTests(unittest.TestCase):
     @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
     def test_create_user_embed_uses_nick_in_title_if_available(self):
         """The embed should use the nick if it's available."""
-        ctx = helpers.MockContext(channel=helpers.MockTextChannel(channel_id=1))
+        ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=1))
         user = helpers.MockMember()
         user.nick = "Cat lover"
         user.__str__ = unittest.mock.Mock(return_value="Mr. Hemlock")
@@ -375,8 +375,8 @@ class UserEmbedTests(unittest.TestCase):
     @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
     def test_create_user_embed_ignores_everyone_role(self):
         """Created `!user` embeds should not contain mention of the @everyone-role."""
-        ctx = helpers.MockContext(channel=helpers.MockTextChannel(channel_id=1))
-        admins_role = helpers.MockRole('Admins')
+        ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=1))
+        admins_role = helpers.MockRole(name='Admins')
         admins_role.colour = 100
 
         # A `MockMember` has the @Everyone role by default; we add the Admins to that.
@@ -391,15 +391,15 @@ class UserEmbedTests(unittest.TestCase):
     @unittest.mock.patch(f"{COG_PATH}.user_nomination_counts", new_callable=helpers.AsyncMock)
     def test_create_user_embed_expanded_information_in_moderation_channels(self, nomination_counts, infraction_counts):
         """The embed should contain expanded infractions and nomination info in mod channels."""
-        ctx = helpers.MockContext(channel=helpers.MockTextChannel(channel_id=50))
+        ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=50))
 
-        moderators_role = helpers.MockRole('Moderators')
+        moderators_role = helpers.MockRole(name='Moderators')
         moderators_role.colour = 100
 
         infraction_counts.return_value = "expanded infractions info"
         nomination_counts.return_value = "nomination info"
 
-        user = helpers.MockMember(user_id=314, roles=[moderators_role], top_role=moderators_role)
+        user = helpers.MockMember(id=314, roles=[moderators_role], top_role=moderators_role)
         embed = asyncio.run(self.cog.create_user_embed(ctx, user))
 
         infraction_counts.assert_called_once_with(user)
@@ -426,14 +426,14 @@ class UserEmbedTests(unittest.TestCase):
     @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new_callable=helpers.AsyncMock)
     def test_create_user_embed_basic_information_outside_of_moderation_channels(self, infraction_counts):
         """The embed should contain only basic infraction data outside of mod channels."""
-        ctx = helpers.MockContext(channel=helpers.MockTextChannel(channel_id=100))
+        ctx = helpers.MockContext(channel=helpers.MockTextChannel(id=100))
 
-        moderators_role = helpers.MockRole('Moderators')
+        moderators_role = helpers.MockRole(name='Moderators')
         moderators_role.colour = 100
 
         infraction_counts.return_value = "basic infractions info"
 
-        user = helpers.MockMember(user_id=314, roles=[moderators_role], top_role=moderators_role)
+        user = helpers.MockMember(id=314, roles=[moderators_role], top_role=moderators_role)
         embed = asyncio.run(self.cog.create_user_embed(ctx, user))
 
         infraction_counts.assert_called_once_with(user)
@@ -459,10 +459,10 @@ class UserEmbedTests(unittest.TestCase):
         """The embed should be created with the colour of the top role, if a top role is available."""
         ctx = helpers.MockContext()
 
-        moderators_role = helpers.MockRole('Moderators')
+        moderators_role = helpers.MockRole(name='Moderators')
         moderators_role.colour = 100
 
-        user = helpers.MockMember(user_id=314, roles=[moderators_role], top_role=moderators_role)
+        user = helpers.MockMember(id=314, roles=[moderators_role], top_role=moderators_role)
         embed = asyncio.run(self.cog.create_user_embed(ctx, user))
 
         self.assertEqual(embed.colour, discord.Colour(moderators_role.colour))
@@ -472,7 +472,7 @@ class UserEmbedTests(unittest.TestCase):
         """The embed should be created with a blurple colour if the user has no assigned roles."""
         ctx = helpers.MockContext()
 
-        user = helpers.MockMember(user_id=217)
+        user = helpers.MockMember(id=217)
         embed = asyncio.run(self.cog.create_user_embed(ctx, user))
 
         self.assertEqual(embed.colour, discord.Colour.blurple())
@@ -482,7 +482,7 @@ class UserEmbedTests(unittest.TestCase):
         """The embed thumbnail should be set to the user's avatar in `png` format."""
         ctx = helpers.MockContext()
 
-        user = helpers.MockMember(user_id=217)
+        user = helpers.MockMember(id=217)
         user.avatar_url_as.return_value = "avatar url"
         embed = asyncio.run(self.cog.create_user_embed(ctx, user))
 
@@ -499,13 +499,13 @@ class UserCommandTests(unittest.TestCase):
         self.bot = helpers.MockBot()
         self.cog = information.Information(self.bot)
 
-        self.moderator_role = helpers.MockRole("Moderators", role_id=2, position=10)
-        self.flautist_role = helpers.MockRole("Flautists", role_id=3, position=2)
-        self.bassist_role = helpers.MockRole("Bassists", role_id=4, position=3)
+        self.moderator_role = helpers.MockRole(name="Moderators", id=2, position=10)
+        self.flautist_role = helpers.MockRole(name="Flautists", id=3, position=2)
+        self.bassist_role = helpers.MockRole(name="Bassists", id=4, position=3)
 
-        self.author = helpers.MockMember(user_id=1, name="syntaxaire")
-        self.moderator = helpers.MockMember(user_id=2, name="riffautae", roles=[self.moderator_role])
-        self.target = helpers.MockMember(user_id=3, name="__fluzz__")
+        self.author = helpers.MockMember(id=1, name="syntaxaire")
+        self.moderator = helpers.MockMember(id=2, name="riffautae", roles=[self.moderator_role])
+        self.target = helpers.MockMember(id=3, name="__fluzz__")
 
     def test_regular_member_cannot_target_another_member(self, constants):
         """A regular user should not be able to use `!user` targeting another user."""
@@ -523,7 +523,7 @@ class UserCommandTests(unittest.TestCase):
         constants.STAFF_ROLES = [self.moderator_role.id]
         constants.Channels.bot = 50
 
-        ctx = helpers.MockContext(author=self.author, channel=helpers.MockTextChannel(channel_id=100))
+        ctx = helpers.MockContext(author=self.author, channel=helpers.MockTextChannel(id=100))
 
         msg = "Sorry, but you may only use this command within <#50>."
         with self.assertRaises(InChannelCheckFailure, msg=msg):
@@ -535,7 +535,7 @@ class UserCommandTests(unittest.TestCase):
         constants.STAFF_ROLES = [self.moderator_role.id]
         constants.Channels.bot = 50
 
-        ctx = helpers.MockContext(author=self.author, channel=helpers.MockTextChannel(channel_id=50))
+        ctx = helpers.MockContext(author=self.author, channel=helpers.MockTextChannel(id=50))
 
         asyncio.run(self.cog.user_info.callback(self.cog, ctx))
 
@@ -548,7 +548,7 @@ class UserCommandTests(unittest.TestCase):
         constants.STAFF_ROLES = [self.moderator_role.id]
         constants.Channels.bot = 50
 
-        ctx = helpers.MockContext(author=self.author, channel=helpers.MockTextChannel(channel_id=50))
+        ctx = helpers.MockContext(author=self.author, channel=helpers.MockTextChannel(id=50))
 
         asyncio.run(self.cog.user_info.callback(self.cog, ctx, self.author))
 
@@ -561,7 +561,7 @@ class UserCommandTests(unittest.TestCase):
         constants.STAFF_ROLES = [self.moderator_role.id]
         constants.Channels.bot = 50
 
-        ctx = helpers.MockContext(author=self.moderator, channel=helpers.MockTextChannel(channel_id=200))
+        ctx = helpers.MockContext(author=self.moderator, channel=helpers.MockTextChannel(id=200))
 
         asyncio.run(self.cog.user_info.callback(self.cog, ctx))
 
@@ -574,7 +574,7 @@ class UserCommandTests(unittest.TestCase):
         constants.MODERATION_ROLES = [self.moderator_role.id]
         constants.STAFF_ROLES = [self.moderator_role.id]
 
-        ctx = helpers.MockContext(author=self.moderator, channel=helpers.MockTextChannel(channel_id=50))
+        ctx = helpers.MockContext(author=self.moderator, channel=helpers.MockTextChannel(id=50))
 
         asyncio.run(self.cog.user_info.callback(self.cog, ctx, self.target))
 
diff --git a/tests/bot/cogs/test_token_remover.py b/tests/bot/cogs/test_token_remover.py
index dfb1bafc9..3276cf5a5 100644
--- a/tests/bot/cogs/test_token_remover.py
+++ b/tests/bot/cogs/test_token_remover.py
@@ -24,7 +24,7 @@ class TokenRemoverTests(unittest.TestCase):
         self.bot.get_cog.return_value.send_log_message = AsyncMock()
         self.cog = TokenRemover(bot=self.bot)
 
-        self.msg = MockMessage(message_id=555, content='')
+        self.msg = MockMessage(id=555, content='')
         self.msg.author.__str__ = MagicMock()
         self.msg.author.__str__.return_value = 'lemon'
         self.msg.author.bot = False
diff --git a/tests/bot/utils/test_checks.py b/tests/bot/utils/test_checks.py
index 19b758336..9610771e5 100644
--- a/tests/bot/utils/test_checks.py
+++ b/tests/bot/utils/test_checks.py
@@ -22,7 +22,7 @@ class ChecksTests(unittest.TestCase):
 
     def test_with_role_check_with_guild_and_required_role(self):
         """`with_role_check` returns `True` if `Context.author` has the required role."""
-        self.ctx.author.roles.append(MockRole(role_id=10))
+        self.ctx.author.roles.append(MockRole(id=10))
         self.assertTrue(checks.with_role_check(self.ctx, 10))
 
     def test_without_role_check_without_guild(self):
@@ -33,13 +33,13 @@ class ChecksTests(unittest.TestCase):
     def test_without_role_check_returns_false_with_unwanted_role(self):
         """`without_role_check` returns `False` if `Context.author` has unwanted role."""
         role_id = 42
-        self.ctx.author.roles.append(MockRole(role_id=role_id))
+        self.ctx.author.roles.append(MockRole(id=role_id))
         self.assertFalse(checks.without_role_check(self.ctx, role_id))
 
     def test_without_role_check_returns_true_without_unwanted_role(self):
         """`without_role_check` returns `True` if `Context.author` does not have unwanted role."""
         role_id = 42
-        self.ctx.author.roles.append(MockRole(role_id=role_id))
+        self.ctx.author.roles.append(MockRole(id=role_id))
         self.assertTrue(checks.without_role_check(self.ctx, role_id + 10))
 
     def test_in_channel_check_for_correct_channel(self):
diff --git a/tests/helpers.py b/tests/helpers.py
index 5dc7a0d2f..35f2c288c 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import asyncio
+import collections
 import functools
 import inspect
+import itertools
 import logging
 import unittest.mock
 from typing import Any, Iterable, Optional
@@ -72,14 +74,16 @@ class CustomMockMixin:
     """
 
     child_mock_type = unittest.mock.MagicMock
+    discord_id = itertools.count(0)
 
-    def __init__(self, spec: Any = None, **kwargs):
+    def __init__(self, spec_set: Any = None, **kwargs):
         name = kwargs.pop('name', None)  # `name` has special meaning for Mock classes, so we need to set it manually.
-        super().__init__(spec=spec, **kwargs)
+        super().__init__(spec_set=spec_set, **kwargs)
+
         if name:
             self.name = name
-        if spec:
-            self._extract_coroutine_methods_from_spec_instance(spec)
+        if spec_set:
+            self._extract_coroutine_methods_from_spec_instance(spec_set)
 
     def _get_child_mock(self, **kw):
         """
@@ -169,25 +173,14 @@ 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,
-        roles: Optional[Iterable[MockRole]] = None,
-        members: Optional[Iterable[MockMember]] = None,
-        **kwargs,
-    ) -> None:
-        super().__init__(spec=guild_instance, **kwargs)
-
-        self.id = guild_id
-
-        self.roles = [MockRole("@everyone", 1)]
+    def __init__(self, roles: Optional[Iterable[MockRole]] = None, **kwargs) -> None:
+        default_kwargs = {'id': next(self.discord_id), 'members': []}
+        super().__init__(spec_set=guild_instance, **collections.ChainMap(kwargs, default_kwargs))
+
+        self.roles = [MockRole(name="@everyone", position=1, id=0)]
         if roles:
             self.roles.extend(roles)
 
-        self.members = []
-        if members:
-            self.members.extend(members)
-
 
 # Create a Role instance to get a realistic Mock of `discord.Role`
 role_data = {'name': 'role', 'id': 1}
@@ -201,13 +194,12 @@ 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)
+    def __init__(self, **kwargs) -> None:
+        default_kwargs = {'id': next(self.discord_id), 'name': 'role', 'position': 1}
+        super().__init__(spec_set=role_instance, **collections.ChainMap(kwargs, default_kwargs))
 
-        self.name = name
-        self.id = role_id
-        self.position = position
-        self.mention = f'&{self.name}'
+        if 'mention' not in kwargs:
+            self.mention = f'&{self.name}'
 
     def __lt__(self, other):
         """Simplified position-based comparisons similar to those of `discord.Role`."""
@@ -227,19 +219,11 @@ 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",
-        user_id: int = 1,
-        roles: Optional[Iterable[MockRole]] = None,
-        **kwargs,
-    ) -> None:
-        super().__init__(spec=member_instance, **kwargs)
-
-        self.name = name
-        self.id = user_id
-
-        self.roles = [MockRole("@everyone", 1)]
+    def __init__(self, roles: Optional[Iterable[MockRole]] = None, **kwargs) -> None:
+        default_kwargs = {'name': 'member', 'id': next(self.discord_id)}
+        super().__init__(spec_set=member_instance, **collections.ChainMap(kwargs, default_kwargs))
+
+        self.roles = [MockRole(name="@everyone", position=1, id=0)]
         if roles:
             self.roles.extend(roles)
 
@@ -248,6 +232,8 @@ class MockMember(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin
 
 # 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
+bot_instance.api_client = None
 
 
 class MockBot(CustomMockMixin, unittest.mock.MagicMock):
@@ -258,11 +244,7 @@ class MockBot(CustomMockMixin, unittest.mock.MagicMock):
     For more information, see the `MockGuild` docstring.
     """
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec=bot_instance, **kwargs)
-
-        # Our custom attributes and methods
-        self.http_session = unittest.mock.MagicMock()
-        self.api_client = unittest.mock.MagicMock()
+        super().__init__(spec_set=bot_instance, **kwargs)
 
         # self.wait_for is *not* a coroutine function, but returns a coroutine nonetheless and
         # and should therefore be awaited. (The documentation calls it a coroutine as well, which
@@ -294,11 +276,11 @@ class MockTextChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
     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
-        self.name = name
-        self.guild = kwargs.get('guild', MockGuild())
-        self.mention = f"#{self.name}"
+        default_kwargs = {'id': next(self.discord_id), 'name': 'channel', 'guild': MockGuild()}
+        super().__init__(spec_set=channel_instance, **collections.ChainMap(kwargs, default_kwargs))
+
+        if 'mention' not in kwargs:
+            self.mention = f"#{self.name}"
 
 
 # Create a Message instance to get a realistic MagicMock of `discord.Message`
@@ -335,12 +317,11 @@ class MockContext(CustomMockMixin, unittest.mock.MagicMock):
     instances. For more information, see the `MockGuild` docstring.
     """
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec=context_instance, **kwargs)
+        super().__init__(spec_set=context_instance, **kwargs)
         self.bot = kwargs.get('bot', MockBot())
         self.guild = kwargs.get('guild', MockGuild())
         self.author = kwargs.get('author', MockMember())
         self.channel = kwargs.get('channel', MockTextChannel())
-        self.command = kwargs.get('command', unittest.mock.MagicMock())
 
 
 class MockMessage(CustomMockMixin, unittest.mock.MagicMock):
@@ -351,7 +332,7 @@ class MockMessage(CustomMockMixin, unittest.mock.MagicMock):
     information, see the `MockGuild` docstring.
     """
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec=message_instance, **kwargs)
+        super().__init__(spec_set=message_instance, **kwargs)
         self.author = kwargs.get('author', MockMember())
         self.channel = kwargs.get('channel', MockTextChannel())
 
@@ -368,12 +349,9 @@ class MockEmoji(CustomMockMixin, unittest.mock.MagicMock):
     information, see the `MockGuild` docstring.
     """
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec=emoji_instance, **kwargs)
+        super().__init__(spec_set=emoji_instance, **kwargs)
         self.guild = kwargs.get('guild', MockGuild())
 
-        # Get all coroutine functions and set them as AsyncMock attributes
-        self._extract_coroutine_methods_from_spec_instance(emoji_instance)
-
 
 partial_emoji_instance = discord.PartialEmoji(animated=False, name='guido')
 
@@ -386,7 +364,7 @@ class MockPartialEmoji(CustomMockMixin, unittest.mock.MagicMock):
     more information, see the `MockGuild` docstring.
     """
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec=partial_emoji_instance, **kwargs)
+        super().__init__(spec_set=partial_emoji_instance, **kwargs)
 
 
 reaction_instance = discord.Reaction(message=MockMessage(), data={'me': True}, emoji=MockEmoji())
@@ -400,6 +378,6 @@ class MockReaction(CustomMockMixin, unittest.mock.MagicMock):
     more information, see the `MockGuild` docstring.
     """
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec=reaction_instance, **kwargs)
+        super().__init__(spec_set=reaction_instance, **kwargs)
         self.emoji = kwargs.get('emoji', MockEmoji())
         self.message = kwargs.get('message', MockMessage())
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
index 2b58634dd..e879ef97a 100644
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@@ -19,7 +19,6 @@ class DiscordMocksTests(unittest.TestCase):
         self.assertIsInstance(role, discord.Role)
 
         self.assertEqual(role.name, "role")
-        self.assertEqual(role.id, 1)
         self.assertEqual(role.position, 1)
         self.assertEqual(role.mention, "&role")
 
@@ -27,7 +26,7 @@ class DiscordMocksTests(unittest.TestCase):
         """Test if MockRole initializes with the arguments provided."""
         role = helpers.MockRole(
             name="Admins",
-            role_id=90210,
+            id=90210,
             position=10,
         )
 
@@ -67,22 +66,21 @@ class DiscordMocksTests(unittest.TestCase):
         self.assertIsInstance(member, discord.Member)
 
         self.assertEqual(member.name, "member")
-        self.assertEqual(member.id, 1)
-        self.assertListEqual(member.roles, [helpers.MockRole("@everyone", 1)])
+        self.assertListEqual(member.roles, [helpers.MockRole(name="@everyone", position=1, id=0)])
         self.assertEqual(member.mention, "@member")
 
     def test_mock_member_alternative_arguments(self):
         """Test if MockMember initializes with the arguments provided."""
-        core_developer = helpers.MockRole("Core Developer", 2)
+        core_developer = helpers.MockRole(name="Core Developer", position=2)
         member = helpers.MockMember(
             name="Mark",
-            user_id=12345,
+            id=12345,
             roles=[core_developer]
         )
 
         self.assertEqual(member.name, "Mark")
         self.assertEqual(member.id, 12345)
-        self.assertListEqual(member.roles, [helpers.MockRole("@everyone", 1), core_developer])
+        self.assertListEqual(member.roles, [helpers.MockRole(name="@everyone", position=1, id=0), core_developer])
         self.assertEqual(member.mention, "@Mark")
 
     def test_mock_member_accepts_dynamic_arguments(self):
@@ -102,19 +100,19 @@ class DiscordMocksTests(unittest.TestCase):
         # The `spec` argument makes sure `isistance` checks with `discord.Guild` pass
         self.assertIsInstance(guild, discord.Guild)
 
-        self.assertListEqual(guild.roles, [helpers.MockRole("@everyone", 1)])
+        self.assertListEqual(guild.roles, [helpers.MockRole(name="@everyone", position=1, id=0)])
         self.assertListEqual(guild.members, [])
 
     def test_mock_guild_alternative_arguments(self):
         """Test if MockGuild initializes with the arguments provided."""
-        core_developer = helpers.MockRole("Core Developer", 2)
+        core_developer = helpers.MockRole(name="Core Developer", position=2)
         guild = helpers.MockGuild(
             roles=[core_developer],
-            members=[helpers.MockMember(user_id=54321)],
+            members=[helpers.MockMember(id=54321)],
         )
 
-        self.assertListEqual(guild.roles, [helpers.MockRole("@everyone", 1), core_developer])
-        self.assertListEqual(guild.members, [helpers.MockMember(user_id=54321)])
+        self.assertListEqual(guild.roles, [helpers.MockRole(name="@everyone", position=1, id=0), core_developer])
+        self.assertListEqual(guild.members, [helpers.MockMember(id=54321)])
 
     def test_mock_guild_accepts_dynamic_arguments(self):
         """Test if MockGuild accepts and sets abitrary keyword arguments."""
@@ -191,51 +189,18 @@ class DiscordMocksTests(unittest.TestCase):
                 with self.assertRaises(AttributeError):
                     mock.the_cake_is_a_lie
 
-    def test_custom_mock_methods_are_valid_discord_object_methods(self):
-        """The `AsyncMock` attributes of the mocks should be valid for the class they're mocking."""
-        mocks = (
-            (helpers.MockGuild, helpers.guild_instance),
-            (helpers.MockRole, helpers.role_instance),
-            (helpers.MockMember, helpers.member_instance),
-            (helpers.MockBot, helpers.bot_instance),
-            (helpers.MockContext, helpers.context_instance),
-            (helpers.MockTextChannel, helpers.channel_instance),
-            (helpers.MockMessage, helpers.message_instance),
+    def test_mocks_use_mention_when_provided_as_kwarg(self):
+        """The mock should use the passed `mention` instead of the default one if present."""
+        test_cases = (
+            (helpers.MockRole, "role mention"),
+            (helpers.MockMember, "member mention"),
+            (helpers.MockTextChannel, "channel mention"),
         )
 
-        for mock_class, instance in mocks:
-            mock = mock_class()
-            async_methods = (
-                attr for attr in dir(mock) if isinstance(getattr(mock, attr), helpers.AsyncMock)
-            )
-
-            # spec_mock = unittest.mock.MagicMock(spec=instance)
-            for method in async_methods:
-                with self.subTest(mock_class=mock_class, method=method):
-                    try:
-                        getattr(instance, method)
-                    except AttributeError:
-                        msg = f"method {method} is not a method attribute of {instance.__class__}"
-                        self.fail(msg)
-
-    @unittest.mock.patch(f'{__name__}.DiscordMocksTests.subTest')
-    def test_the_custom_mock_methods_test(self, subtest_mock):
-        """The custom method test should raise AssertionError for invalid methods."""
-        class FakeMockBot(helpers.CustomMockMixin, unittest.mock.MagicMock):
-            """Fake MockBot class with invalid attribute/method `release_the_walrus`."""
-
-            child_mock_type = unittest.mock.MagicMock
-
-            def __init__(self, **kwargs):
-                super().__init__(spec=helpers.bot_instance, **kwargs)
-
-                # Fake attribute
-                self.release_the_walrus = helpers.AsyncMock()
-
-        with unittest.mock.patch("tests.helpers.MockBot", new=FakeMockBot):
-            msg = "method release_the_walrus is not a valid method of <class 'discord.ext.commands.bot.Bot'>"
-            with self.assertRaises(AssertionError, msg=msg):
-                self.test_custom_mock_methods_are_valid_discord_object_methods()
+        for mock_type, mention in test_cases:
+            with self.subTest(mock_type=mock_type, mention=mention):
+                mock = mock_type(mention=mention)
+                self.assertEqual(mock.mention, mention)
 
 
 class MockObjectTests(unittest.TestCase):
@@ -266,14 +231,14 @@ class MockObjectTests(unittest.TestCase):
 
     def test_hashable_mixin_uses_id_for_equality_comparison(self):
         """Test if the HashableMixing uses the id attribute for hashing."""
-        class MockScragly(unittest.mock.Mock, helpers.HashableMixin):
+        class MockScragly(helpers.HashableMixin):
             pass
 
-        scragly = MockScragly(spec=object)
+        scragly = MockScragly()
         scragly.id = 10
-        eevee = MockScragly(spec=object)
+        eevee = MockScragly()
         eevee.id = 10
-        python = MockScragly(spec=object)
+        python = MockScragly()
         python.id = 20
 
         self.assertTrue(scragly == eevee)
@@ -281,14 +246,14 @@ class MockObjectTests(unittest.TestCase):
 
     def test_hashable_mixin_uses_id_for_nonequality_comparison(self):
         """Test if the HashableMixing uses the id attribute for hashing."""
-        class MockScragly(unittest.mock.Mock, helpers.HashableMixin):
+        class MockScragly(helpers.HashableMixin):
             pass
 
-        scragly = MockScragly(spec=object)
+        scragly = MockScragly()
         scragly.id = 10
-        eevee = MockScragly(spec=object)
+        eevee = MockScragly()
         eevee.id = 10
-        python = MockScragly(spec=object)
+        python = MockScragly()
         python.id = 20
 
         self.assertTrue(scragly != python)
@@ -298,7 +263,7 @@ class MockObjectTests(unittest.TestCase):
         """Test if the MagicMock subclasses that implement the HashableMixin use id for hash."""
         for mock in self.hashable_mocks:
             with self.subTest(mock_class=mock):
-                instance = helpers.MockRole(role_id=100)
+                instance = helpers.MockRole(id=100)
                 self.assertEqual(hash(instance), instance.id)
 
     def test_mock_class_with_hashable_mixin_uses_id_for_equality(self):
@@ -396,11 +361,11 @@ class MockObjectTests(unittest.TestCase):
     @unittest.mock.patch("tests.helpers.CustomMockMixin._extract_coroutine_methods_from_spec_instance")
     def test_custom_mock_mixin_init_with_spec(self, extract_method_mock):
         """Test if CustomMockMixin correctly passes on spec/kwargs and calls the extraction method."""
-        spec = "pydis"
+        spec_set = "pydis"
 
-        helpers.CustomMockMixin(spec=spec)
+        helpers.CustomMockMixin(spec_set=spec_set)
 
-        extract_method_mock.assert_called_once_with(spec)
+        extract_method_mock.assert_called_once_with(spec_set)
 
     @unittest.mock.patch("builtins.super", new=unittest.mock.MagicMock())
     @unittest.mock.patch("tests.helpers.CustomMockMixin._extract_coroutine_methods_from_spec_instance")
-- 
cgit v1.2.3


From 7f4829e9fab007690d48188f499bfcc1a7baa437 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Wed, 13 Nov 2019 17:29:09 +0100
Subject: Prevent await warnings for MockBot's create_task

Previously, the coroutine object passed to `MockBot.loop.create_task`
would trigger a `RuntimeWarning` for not being awaited as we do not
actually create a task for it. To prevent these warnings, coroutine
objects passed will now automatically be closed.
---
 tests/helpers.py      |  8 +++++++-
 tests/test_helpers.py | 12 ++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

(limited to 'tests/helpers.py')

diff --git a/tests/helpers.py b/tests/helpers.py
index 35f2c288c..8a14aeef4 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -227,7 +227,8 @@ class MockMember(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin
         if roles:
             self.roles.extend(roles)
 
-        self.mention = f"@{self.name}"
+        if 'mention' not in kwargs:
+            self.mention = f"@{self.name}"
 
 
 # Create a Bot instance to get a realistic MagicMock of `discord.ext.commands.Bot`
@@ -251,6 +252,11 @@ class MockBot(CustomMockMixin, unittest.mock.MagicMock):
         # is technically incorrect, since it's a regular def.)
         self.wait_for = AsyncMock()
 
+        # Since calling `create_task` on our MockBot does not actually schedule the coroutine object
+        # as a task in the asyncio loop, this `side_effect` calls `close()` on the coroutine object
+        # to prevent "has not been awaited"-warnings.
+        self.loop.create_task.side_effect = lambda coroutine: coroutine.close()
+
 
 # Create a TextChannel instance to get a realistic MagicMock of `discord.TextChannel`
 channel_data = {
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
index e879ef97a..7894e104a 100644
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@@ -202,6 +202,18 @@ class DiscordMocksTests(unittest.TestCase):
                 mock = mock_type(mention=mention)
                 self.assertEqual(mock.mention, mention)
 
+    def test_create_test_on_mock_bot_closes_passed_coroutine(self):
+        """`bot.loop.create_task` should close the passed coroutine object to prevent warnings."""
+        async def dementati():
+            """Dummy coroutine for testing purposes."""
+
+        coroutine_object = dementati()
+
+        bot = helpers.MockBot()
+        bot.loop.create_task(coroutine_object)
+        with self.assertRaises(RuntimeError, msg="cannot reuse already awaited coroutine"):
+            asyncio.run(coroutine_object)
+
 
 class MockObjectTests(unittest.TestCase):
     """Tests the mock objects and mixins we've defined."""
-- 
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/helpers.py')

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/helpers.py')

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/helpers.py')

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/helpers.py')

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/helpers.py')

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/helpers.py')

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 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/helpers.py')

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