From c4213744c18be23e3e4484f126ae0b2d0eba4437 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Wed, 2 Oct 2019 16:59:03 +0200
Subject: Migrate pytest to unittest

After a discussion in the core developers channel, we have decided to
migrate from `pytest` to `unittest` as the testing framework. This
commit sets up the repository to use `unittest` and migrates the
first couple of tests files to the new framework.

What I have done to migrate to `unitest`:

- Removed all `pytest` test files, since they are incompatible.

- Removed `pytest`-related dependencies from the Pipfile.

- Added `coverage.py` to the Pipfile dev-packages and relocked.

- Added convenience scripts to Pipfile for running the test suite.

- Adjust to `azure-pipelines.yml` to use `coverage.py` and `unittest`.

- Migrated four test files from `pytest` to `unittest` format.

In addition, I've added five helper Mock subclasses in `helpers.py`
and created a `TestCase` subclass in `base.py` to add an assertion
that asserts that no log records were logged within the context of
the context manager. Obviously, these new utility functions and
classes are fully tested in their respective `test_` files.

Finally, I've started with an introductory guide for writing tests
for our bot in `README.md`.
---
 tests/test_helpers.py | 339 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 339 insertions(+)
 create mode 100644 tests/test_helpers.py

(limited to 'tests/test_helpers.py')

diff --git a/tests/test_helpers.py b/tests/test_helpers.py
new file mode 100644
index 000000000..766fe17b8
--- /dev/null
+++ b/tests/test_helpers.py
@@ -0,0 +1,339 @@
+import asyncio
+import inspect
+import unittest
+import unittest.mock
+
+import discord
+
+from tests import helpers
+
+
+class MockObjectTests(unittest.TestCase):
+    """Tests the mock objects and mixins we've defined."""
+    @classmethod
+    def setUpClass(cls):
+        cls.hashable_mocks = (helpers.MockRole, helpers.MockMember, helpers.MockGuild)
+
+    def test_colour_mixin(self):
+        """Test if the ColourMixin adds aliasing of color -> colour for child classes."""
+        class MockHemlock(unittest.mock.MagicMock, helpers.ColourMixin):
+            pass
+
+        hemlock = MockHemlock()
+        hemlock.color = 1
+        self.assertEqual(hemlock.colour, 1)
+        self.assertEqual(hemlock.colour, hemlock.color)
+
+    def test_hashable_mixin_hash_returns_id(self):
+        """Test if the HashableMixing uses the id attribute for hashing."""
+        class MockScragly(unittest.mock.Mock, helpers.HashableMixin):
+            pass
+
+        scragly = MockScragly()
+        scragly.id = 10
+        self.assertEqual(hash(scragly), scragly.id)
+
+    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):
+            pass
+
+        scragly = MockScragly(spec=object)
+        scragly.id = 10
+        eevee = MockScragly(spec=object)
+        eevee.id = 10
+        python = MockScragly(spec=object)
+        python.id = 20
+
+        self.assertTrue(scragly == eevee)
+        self.assertFalse(scragly == python)
+
+    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):
+            pass
+
+        scragly = MockScragly(spec=object)
+        scragly.id = 10
+        eevee = MockScragly(spec=object)
+        eevee.id = 10
+        python = MockScragly(spec=object)
+        python.id = 20
+
+        self.assertTrue(scragly != python)
+        self.assertFalse(scragly != eevee)
+
+    def test_mock_class_with_hashable_mixin_uses_id_for_hashing(self):
+        """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)
+                self.assertEqual(hash(instance), instance.id)
+
+    def test_mock_class_with_hashable_mixin_uses_id_for_equality(self):
+        """Test if MagicMocks that implement the HashableMixin use id for equality comparisons."""
+        for mock_class in self.hashable_mocks:
+            with self.subTest(mock_class=mock_class):
+                instance_one = mock_class()
+                instance_two = mock_class()
+                instance_three = mock_class()
+
+                instance_one.id = 10
+                instance_two.id = 10
+                instance_three.id = 20
+
+                self.assertTrue(instance_one == instance_two)
+                self.assertFalse(instance_one == instance_three)
+
+    def test_mock_class_with_hashable_mixin_uses_id_for_nonequality(self):
+        """Test if MagicMocks that implement HashableMixin use id for nonequality comparisons."""
+        for mock_class in self.hashable_mocks:
+            with self.subTest(mock_class=mock_class):
+                instance_one = mock_class()
+                instance_two = mock_class()
+                instance_three = mock_class()
+
+                instance_one.id = 10
+                instance_two.id = 10
+                instance_three.id = 20
+
+                self.assertFalse(instance_one != instance_two)
+                self.assertTrue(instance_one != instance_three)
+
+    def test_spec_propagation_of_mock_subclasses(self):
+        """Test if the `spec` does not propagate to attributes of the mock object."""
+        test_values = (
+            (helpers.MockGuild, "region"),
+            (helpers.MockRole, "mentionable"),
+            (helpers.MockMember, "display_name"),
+            (helpers.MockBot, "owner_id"),
+            (helpers.MockContext, "command_failed"),
+        )
+
+        for mock_type, valid_attribute in test_values:
+            with self.subTest(mock_type=mock_type, attribute=valid_attribute):
+                mock = mock_type()
+                self.assertTrue(isinstance(mock, mock_type))
+                attribute = getattr(mock, valid_attribute)
+                self.assertTrue(isinstance(attribute, mock_type.attribute_mocktype))
+
+    def test_mock_role_default_initialization(self):
+        """Test if the default initialization of MockRole results in the correct object."""
+        role = helpers.MockRole()
+
+        # The `spec` argument makes sure `isistance` checks with `discord.Role` pass
+        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")
+
+    def test_mock_role_alternative_arguments(self):
+        """Test if MockRole initializes with the arguments provided."""
+        role = helpers.MockRole(
+            name="Admins",
+            role_id=90210,
+            position=10,
+        )
+
+        self.assertEqual(role.name, "Admins")
+        self.assertEqual(role.id, 90210)
+        self.assertEqual(role.position, 10)
+        self.assertEqual(role.mention, "&Admins")
+
+    def test_mock_role_accepts_dynamic_arguments(self):
+        """Test if MockRole accepts and sets abitrary keyword arguments."""
+        role = helpers.MockRole(
+            guild="Dino Man",
+            hoist=True,
+        )
+
+        self.assertEqual(role.guild, "Dino Man")
+        self.assertTrue(role.hoist)
+
+    def test_mock_role_rejects_accessing_attributes_not_following_spec(self):
+        """Test if MockRole throws AttributeError for attribute not existing in discord.Role."""
+        with self.assertRaises(AttributeError):
+            role = helpers.MockRole()
+            role.joseph
+
+    def test_mock_role_rejects_accessing_methods_not_following_spec(self):
+        """Test if MockRole throws AttributeError for method not existing in discord.Role."""
+        with self.assertRaises(AttributeError):
+            role = helpers.MockRole()
+            role.lemon()
+
+    def test_mock_role_accepts_accessing_attributes_following_spec(self):
+        """Test if MockRole accepts attribute access for valid attributes of discord.Role."""
+        role = helpers.MockRole()
+        role.hoist
+
+    def test_mock_role_accepts_accessing_methods_following_spec(self):
+        """Test if MockRole accepts method calls for valid methods of discord.Role."""
+        role = helpers.MockRole()
+        role.edit()
+
+    def test_mock_role_uses_position_for_less_than_greater_than(self):
+        """Test if `<` and `>` comparisons for MockRole are based on its position attribute."""
+        role_one = helpers.MockRole(position=1)
+        role_two = helpers.MockRole(position=2)
+        role_three = helpers.MockRole(position=3)
+
+        self.assertLess(role_one, role_two)
+        self.assertLess(role_one, role_three)
+        self.assertLess(role_two, role_three)
+        self.assertGreater(role_three, role_two)
+        self.assertGreater(role_three, role_one)
+        self.assertGreater(role_two, role_one)
+
+    def test_mock_member_default_initialization(self):
+        """Test if the default initialization of Mockmember results in the correct object."""
+        member = helpers.MockMember()
+
+        # The `spec` argument makes sure `isistance` checks with `discord.Member` pass
+        self.assertIsInstance(member, discord.Member)
+
+        self.assertEqual(member.name, "member")
+        self.assertEqual(member.id, 1)
+        self.assertListEqual(member.roles, [helpers.MockRole("@everyone", 1)])
+        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)
+        member = helpers.MockMember(
+            name="Mark",
+            user_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.assertEqual(member.mention, "@Mark")
+
+    def test_mock_member_accepts_dynamic_arguments(self):
+        """Test if MockMember accepts and sets abitrary keyword arguments."""
+        member = helpers.MockMember(
+            nick="Dino Man",
+            colour=discord.Colour.default(),
+        )
+
+        self.assertEqual(member.nick, "Dino Man")
+        self.assertEqual(member.colour, discord.Colour.default())
+
+    def test_mock_member_rejects_accessing_attributes_not_following_spec(self):
+        """Test if MockMember throws AttributeError for attribute not existing in spec discord.Member."""
+        with self.assertRaises(AttributeError):
+            member = helpers.MockMember()
+            member.joseph
+
+    def test_mock_member_rejects_accessing_methods_not_following_spec(self):
+        """Test if MockMember throws AttributeError for method not existing in spec discord.Member."""
+        with self.assertRaises(AttributeError):
+            member = helpers.MockMember()
+            member.lemon()
+
+    def test_mock_member_accepts_accessing_attributes_following_spec(self):
+        """Test if MockMember accepts attribute access for valid attributes of discord.Member."""
+        member = helpers.MockMember()
+        member.display_name
+
+    def test_mock_member_accepts_accessing_methods_following_spec(self):
+        """Test if MockMember accepts method calls for valid methods of discord.Member."""
+        member = helpers.MockMember()
+        member.mentioned_in()
+
+    def test_mock_guild_default_initialization(self):
+        """Test if the default initialization of Mockguild results in the correct object."""
+        guild = helpers.MockGuild()
+
+        # 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.members, [])
+
+    def test_mock_guild_alternative_arguments(self):
+        """Test if MockGuild initializes with the arguments provided."""
+        core_developer = helpers.MockRole("Core Developer", 2)
+        guild = helpers.MockGuild(
+            roles=[core_developer],
+            members=[helpers.MockMember(user_id=54321)],
+        )
+
+        self.assertListEqual(guild.roles, [helpers.MockRole("@everyone", 1), core_developer])
+        self.assertListEqual(guild.members, [helpers.MockMember(user_id=54321)])
+
+    def test_mock_guild_accepts_dynamic_arguments(self):
+        """Test if MockGuild accepts and sets abitrary keyword arguments."""
+        guild = helpers.MockGuild(
+            emojis=(":hyperjoseph:", ":pensive_ela:"),
+            premium_subscription_count=15,
+        )
+
+        self.assertTupleEqual(guild.emojis, (":hyperjoseph:", ":pensive_ela:"))
+        self.assertEqual(guild.premium_subscription_count, 15)
+
+    def test_mock_guild_rejects_accessing_attributes_not_following_spec(self):
+        """Test if MockGuild throws AttributeError for attribute not existing in spec discord.Guild."""
+        with self.assertRaises(AttributeError):
+            guild = helpers.MockGuild()
+            guild.aperture
+
+    def test_mock_guild_rejects_accessing_methods_not_following_spec(self):
+        """Test if MockGuild throws AttributeError for method not existing in spec discord.Guild."""
+        with self.assertRaises(AttributeError):
+            guild = helpers.MockGuild()
+            guild.volcyyy()
+
+    def test_mock_guild_accepts_accessing_attributes_following_spec(self):
+        """Test if MockGuild accepts attribute access for valid attributes of discord.Guild."""
+        guild = helpers.MockGuild()
+        guild.name
+
+    def test_mock_guild_accepts_accessing_methods_following_spec(self):
+        """Test if MockGuild accepts method calls for valid methods of discord.Guild."""
+        guild = helpers.MockGuild()
+        guild.by_category()
+
+    def test_mock_bot_default_initialization(self):
+        """Tests if MockBot initializes with the correct values."""
+        bot = helpers.MockBot()
+
+        # The `spec` argument makes sure `isistance` checks with `discord.ext.commands.Bot` pass
+        self.assertIsInstance(bot, discord.ext.commands.Bot)
+
+        self.assertIsInstance(bot._before_invoke, helpers.AsyncMock)
+        self.assertIsInstance(bot._after_invoke, helpers.AsyncMock)
+        self.assertEqual(bot.user, helpers.MockMember(name="Python", user_id=123456789))
+
+    def test_mock_context_default_initialization(self):
+        """Tests if MockContext initializes with the correct values."""
+        context = helpers.MockContext()
+
+        # The `spec` argument makes sure `isistance` checks with `discord.ext.commands.Context` pass
+        self.assertIsInstance(context, discord.ext.commands.Context)
+
+        self.assertIsInstance(context.bot, helpers.MockBot)
+        self.assertIsInstance(context.send, helpers.AsyncMock)
+        self.assertIsInstance(context.guild, helpers.MockGuild)
+        self.assertIsInstance(context.author, helpers.MockMember)
+
+    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()
+        self.assertTrue(inspect.iscoroutinefunction(async_mock.__call__))
+
+        coroutine = async_mock()
+        self.assertTrue(inspect.iscoroutine(coroutine))
+        self.assertIsNotNone(asyncio.run(coroutine))
+
+    def test_async_test_decorator_allows_synchronous_call_to_async_def(self):
+        """Test if the `async_test` decorator allows an `async def` to be called synchronously."""
+        @helpers.async_test
+        async def kosayoda():
+            return "return value"
+
+        self.assertEqual(kosayoda(), "return value")
-- 
cgit v1.2.3


From e4e01cd5388da19435637353e711c2feab5a0e59 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Mon, 14 Oct 2019 22:13:22 +0200
Subject: Add more specialized Mocks to tests.helpers

This commit introduces some new Mock-types to the already existing
Mock-types for discord.py objects. The total list is now:

- MockGuild
- MockRole
- MockMember
- MockBot
- MockContext
- MockTextChannel
- MockMessage

In addition, I've added all coroutines in the documentation for these
discord.py objects as `AsyncMock` attributes to ease testing. Tests
ensure that the attributes set for the Mocks exist for the actual
discord.py objects as well.
---
 tests/helpers.py      | 179 ++++++++++++++++++++++-
 tests/test_helpers.py | 385 +++++++++++++++++++++++++++-----------------------
 2 files changed, 383 insertions(+), 181 deletions(-)

(limited to 'tests/test_helpers.py')

diff --git a/tests/helpers.py b/tests/helpers.py
index 18c9866bf..f8e8357f1 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -143,6 +143,32 @@ class MockGuild(AttributeMock, 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}
@@ -167,6 +193,10 @@ class MockRole(AttributeMock, 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
@@ -205,7 +235,19 @@ class MockMember(AttributeMock, unittest.mock.Mock, ColourMixin, HashableMixin):
             self.roles.extend(roles)
 
         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`
@@ -224,9 +266,37 @@ class MockBot(AttributeMock, unittest.mock.MagicMock):
 
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=bot_instance, **kwargs)
+
+        # `discord.ext.commands.Bot` coroutines
         self._before_invoke = AsyncMock()
         self._after_invoke = AsyncMock()
-        self.user = MockMember(name="Python", user_id=123456789)
+        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 = AsyncMock()
 
 
 # Create a Context instance to get a realistic MagicMock of `discord.ext.commands.Context`
@@ -246,7 +316,112 @@ class MockContext(AttributeMock, unittest.mock.MagicMock):
     def __init__(self, **kwargs) -> None:
         super().__init__(spec=context_instance, **kwargs)
         self.bot = MockBot()
-        self.send = AsyncMock()
         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,
+    'type': 'TextChannel',
+    'name': 'channel',
+    'parent_id': 1234567890,
+    'topic': 'topic',
+    'position': 1,
+    'nsfw': False,
+    'last_message_id': 1,
+}
+state = unittest.mock.MagicMock()
+guild = unittest.mock.MagicMock()
+channel_instance = discord.TextChannel(state=state, guild=guild, data=channel_data)
+
+
+class MockTextChannel(AttributeMock, 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.
+    """
+
+    attribute_mocktype = 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.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 = {
+    'id': 1,
+    'webhook_id': 431341013479718912,
+    'attachments': [],
+    'embeds': [],
+    'application': 'Python Discord',
+    'activity': 'mocking',
+    'channel': unittest.mock.MagicMock(),
+    'edited_timestamp': '2019-10-14T15:33:48+00:00',
+    'type': 'message',
+    'pinned': False,
+    'mention_everyone': False,
+    'tts': None,
+    'content': 'content',
+    'nonce': None,
+}
+state = unittest.mock.MagicMock()
+channel = unittest.mock.MagicMock()
+message_instance = discord.Message(state=state, channel=channel, data=message_data)
+
+
+class MockMessage(AttributeMock, 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.
+    """
+
+    attribute_mocktype = unittest.mock.MagicMock
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(spec=message_instance, **kwargs)
+        self.author = MockMember()
+
+        # `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()
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
index 766fe17b8..f08239981 100644
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@@ -8,114 +8,8 @@ import discord
 from tests import helpers
 
 
-class MockObjectTests(unittest.TestCase):
-    """Tests the mock objects and mixins we've defined."""
-    @classmethod
-    def setUpClass(cls):
-        cls.hashable_mocks = (helpers.MockRole, helpers.MockMember, helpers.MockGuild)
-
-    def test_colour_mixin(self):
-        """Test if the ColourMixin adds aliasing of color -> colour for child classes."""
-        class MockHemlock(unittest.mock.MagicMock, helpers.ColourMixin):
-            pass
-
-        hemlock = MockHemlock()
-        hemlock.color = 1
-        self.assertEqual(hemlock.colour, 1)
-        self.assertEqual(hemlock.colour, hemlock.color)
-
-    def test_hashable_mixin_hash_returns_id(self):
-        """Test if the HashableMixing uses the id attribute for hashing."""
-        class MockScragly(unittest.mock.Mock, helpers.HashableMixin):
-            pass
-
-        scragly = MockScragly()
-        scragly.id = 10
-        self.assertEqual(hash(scragly), scragly.id)
-
-    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):
-            pass
-
-        scragly = MockScragly(spec=object)
-        scragly.id = 10
-        eevee = MockScragly(spec=object)
-        eevee.id = 10
-        python = MockScragly(spec=object)
-        python.id = 20
-
-        self.assertTrue(scragly == eevee)
-        self.assertFalse(scragly == python)
-
-    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):
-            pass
-
-        scragly = MockScragly(spec=object)
-        scragly.id = 10
-        eevee = MockScragly(spec=object)
-        eevee.id = 10
-        python = MockScragly(spec=object)
-        python.id = 20
-
-        self.assertTrue(scragly != python)
-        self.assertFalse(scragly != eevee)
-
-    def test_mock_class_with_hashable_mixin_uses_id_for_hashing(self):
-        """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)
-                self.assertEqual(hash(instance), instance.id)
-
-    def test_mock_class_with_hashable_mixin_uses_id_for_equality(self):
-        """Test if MagicMocks that implement the HashableMixin use id for equality comparisons."""
-        for mock_class in self.hashable_mocks:
-            with self.subTest(mock_class=mock_class):
-                instance_one = mock_class()
-                instance_two = mock_class()
-                instance_three = mock_class()
-
-                instance_one.id = 10
-                instance_two.id = 10
-                instance_three.id = 20
-
-                self.assertTrue(instance_one == instance_two)
-                self.assertFalse(instance_one == instance_three)
-
-    def test_mock_class_with_hashable_mixin_uses_id_for_nonequality(self):
-        """Test if MagicMocks that implement HashableMixin use id for nonequality comparisons."""
-        for mock_class in self.hashable_mocks:
-            with self.subTest(mock_class=mock_class):
-                instance_one = mock_class()
-                instance_two = mock_class()
-                instance_three = mock_class()
-
-                instance_one.id = 10
-                instance_two.id = 10
-                instance_three.id = 20
-
-                self.assertFalse(instance_one != instance_two)
-                self.assertTrue(instance_one != instance_three)
-
-    def test_spec_propagation_of_mock_subclasses(self):
-        """Test if the `spec` does not propagate to attributes of the mock object."""
-        test_values = (
-            (helpers.MockGuild, "region"),
-            (helpers.MockRole, "mentionable"),
-            (helpers.MockMember, "display_name"),
-            (helpers.MockBot, "owner_id"),
-            (helpers.MockContext, "command_failed"),
-        )
-
-        for mock_type, valid_attribute in test_values:
-            with self.subTest(mock_type=mock_type, attribute=valid_attribute):
-                mock = mock_type()
-                self.assertTrue(isinstance(mock, mock_type))
-                attribute = getattr(mock, valid_attribute)
-                self.assertTrue(isinstance(attribute, mock_type.attribute_mocktype))
+class DiscordMocksTests(unittest.TestCase):
+    """Tests for our specialized discord.py mocks."""
 
     def test_mock_role_default_initialization(self):
         """Test if the default initialization of MockRole results in the correct object."""
@@ -152,28 +46,6 @@ class MockObjectTests(unittest.TestCase):
         self.assertEqual(role.guild, "Dino Man")
         self.assertTrue(role.hoist)
 
-    def test_mock_role_rejects_accessing_attributes_not_following_spec(self):
-        """Test if MockRole throws AttributeError for attribute not existing in discord.Role."""
-        with self.assertRaises(AttributeError):
-            role = helpers.MockRole()
-            role.joseph
-
-    def test_mock_role_rejects_accessing_methods_not_following_spec(self):
-        """Test if MockRole throws AttributeError for method not existing in discord.Role."""
-        with self.assertRaises(AttributeError):
-            role = helpers.MockRole()
-            role.lemon()
-
-    def test_mock_role_accepts_accessing_attributes_following_spec(self):
-        """Test if MockRole accepts attribute access for valid attributes of discord.Role."""
-        role = helpers.MockRole()
-        role.hoist
-
-    def test_mock_role_accepts_accessing_methods_following_spec(self):
-        """Test if MockRole accepts method calls for valid methods of discord.Role."""
-        role = helpers.MockRole()
-        role.edit()
-
     def test_mock_role_uses_position_for_less_than_greater_than(self):
         """Test if `<` and `>` comparisons for MockRole are based on its position attribute."""
         role_one = helpers.MockRole(position=1)
@@ -223,28 +95,6 @@ class MockObjectTests(unittest.TestCase):
         self.assertEqual(member.nick, "Dino Man")
         self.assertEqual(member.colour, discord.Colour.default())
 
-    def test_mock_member_rejects_accessing_attributes_not_following_spec(self):
-        """Test if MockMember throws AttributeError for attribute not existing in spec discord.Member."""
-        with self.assertRaises(AttributeError):
-            member = helpers.MockMember()
-            member.joseph
-
-    def test_mock_member_rejects_accessing_methods_not_following_spec(self):
-        """Test if MockMember throws AttributeError for method not existing in spec discord.Member."""
-        with self.assertRaises(AttributeError):
-            member = helpers.MockMember()
-            member.lemon()
-
-    def test_mock_member_accepts_accessing_attributes_following_spec(self):
-        """Test if MockMember accepts attribute access for valid attributes of discord.Member."""
-        member = helpers.MockMember()
-        member.display_name
-
-    def test_mock_member_accepts_accessing_methods_following_spec(self):
-        """Test if MockMember accepts method calls for valid methods of discord.Member."""
-        member = helpers.MockMember()
-        member.mentioned_in()
-
     def test_mock_guild_default_initialization(self):
         """Test if the default initialization of Mockguild results in the correct object."""
         guild = helpers.MockGuild()
@@ -276,28 +126,6 @@ class MockObjectTests(unittest.TestCase):
         self.assertTupleEqual(guild.emojis, (":hyperjoseph:", ":pensive_ela:"))
         self.assertEqual(guild.premium_subscription_count, 15)
 
-    def test_mock_guild_rejects_accessing_attributes_not_following_spec(self):
-        """Test if MockGuild throws AttributeError for attribute not existing in spec discord.Guild."""
-        with self.assertRaises(AttributeError):
-            guild = helpers.MockGuild()
-            guild.aperture
-
-    def test_mock_guild_rejects_accessing_methods_not_following_spec(self):
-        """Test if MockGuild throws AttributeError for method not existing in spec discord.Guild."""
-        with self.assertRaises(AttributeError):
-            guild = helpers.MockGuild()
-            guild.volcyyy()
-
-    def test_mock_guild_accepts_accessing_attributes_following_spec(self):
-        """Test if MockGuild accepts attribute access for valid attributes of discord.Guild."""
-        guild = helpers.MockGuild()
-        guild.name
-
-    def test_mock_guild_accepts_accessing_methods_following_spec(self):
-        """Test if MockGuild accepts method calls for valid methods of discord.Guild."""
-        guild = helpers.MockGuild()
-        guild.by_category()
-
     def test_mock_bot_default_initialization(self):
         """Tests if MockBot initializes with the correct values."""
         bot = helpers.MockBot()
@@ -305,10 +133,6 @@ class MockObjectTests(unittest.TestCase):
         # The `spec` argument makes sure `isistance` checks with `discord.ext.commands.Bot` pass
         self.assertIsInstance(bot, discord.ext.commands.Bot)
 
-        self.assertIsInstance(bot._before_invoke, helpers.AsyncMock)
-        self.assertIsInstance(bot._after_invoke, helpers.AsyncMock)
-        self.assertEqual(bot.user, helpers.MockMember(name="Python", user_id=123456789))
-
     def test_mock_context_default_initialization(self):
         """Tests if MockContext initializes with the correct values."""
         context = helpers.MockContext()
@@ -317,10 +141,213 @@ class MockObjectTests(unittest.TestCase):
         self.assertIsInstance(context, discord.ext.commands.Context)
 
         self.assertIsInstance(context.bot, helpers.MockBot)
-        self.assertIsInstance(context.send, helpers.AsyncMock)
         self.assertIsInstance(context.guild, helpers.MockGuild)
         self.assertIsInstance(context.author, helpers.MockMember)
 
+    def test_mocks_allows_access_to_attributes_part_of_spec(self):
+        """Accessing attributes that are valid for the objects they mock should succeed."""
+        mocks = (
+            (helpers.MockGuild(), 'name'),
+            (helpers.MockRole(), 'hoist'),
+            (helpers.MockMember(), 'display_name'),
+            (helpers.MockBot(), 'user'),
+            (helpers.MockContext(), 'invoked_with'),
+            (helpers.MockTextChannel(), 'last_message'),
+            (helpers.MockMessage(), 'mention_everyone'),
+        )
+
+        for mock, valid_attribute in mocks:
+            with self.subTest(mock=mock):
+                try:
+                    getattr(mock, valid_attribute)
+                except AttributeError:
+                    msg = f"accessing valid attribute `{valid_attribute}` raised an AttributeError"
+                    self.fail(msg)
+
+    @unittest.mock.patch(f'{__name__}.DiscordMocksTests.subTest')
+    @unittest.mock.patch(f'{__name__}.getattr')
+    def test_mock_allows_access_to_attributes_test(self, mock_getattr, mock_subtest):
+        """The valid attribute test should raise an AssertionError after an AttributeError."""
+        mock_getattr.side_effect = AttributeError
+
+        msg = "accessing valid attribute `name` raised an AttributeError"
+        with self.assertRaises(AssertionError, msg=msg):
+            self.test_mocks_allows_access_to_attributes_part_of_spec()
+
+    def test_mocks_rejects_access_to_attributes_not_part_of_spec(self):
+        """Accessing attributes that are invalid for the objects they mock should fail."""
+        mocks = (
+            helpers.MockGuild(),
+            helpers.MockRole(),
+            helpers.MockMember(),
+            helpers.MockBot(),
+            helpers.MockContext(),
+            helpers.MockTextChannel(),
+            helpers.MockMessage(),
+        )
+
+        for mock in mocks:
+            with self.subTest(mock=mock):
+                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),
+        )
+
+        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.AttributeMock, unittest.mock.MagicMock):
+            """Fake MockBot class with invalid attribute/method `release_the_walrus`."""
+
+            attribute_mocktype = 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()
+
+
+class MockObjectTests(unittest.TestCase):
+    """Tests the mock objects and mixins we've defined."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.hashable_mocks = (helpers.MockRole, helpers.MockMember, helpers.MockGuild)
+
+    def test_colour_mixin(self):
+        """Test if the ColourMixin adds aliasing of color -> colour for child classes."""
+        class MockHemlock(unittest.mock.MagicMock, helpers.ColourMixin):
+            pass
+
+        hemlock = MockHemlock()
+        hemlock.color = 1
+        self.assertEqual(hemlock.colour, 1)
+        self.assertEqual(hemlock.colour, hemlock.color)
+
+    def test_hashable_mixin_hash_returns_id(self):
+        """Test if the HashableMixing uses the id attribute for hashing."""
+        class MockScragly(unittest.mock.Mock, helpers.HashableMixin):
+            pass
+
+        scragly = MockScragly()
+        scragly.id = 10
+        self.assertEqual(hash(scragly), scragly.id)
+
+    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):
+            pass
+
+        scragly = MockScragly(spec=object)
+        scragly.id = 10
+        eevee = MockScragly(spec=object)
+        eevee.id = 10
+        python = MockScragly(spec=object)
+        python.id = 20
+
+        self.assertTrue(scragly == eevee)
+        self.assertFalse(scragly == python)
+
+    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):
+            pass
+
+        scragly = MockScragly(spec=object)
+        scragly.id = 10
+        eevee = MockScragly(spec=object)
+        eevee.id = 10
+        python = MockScragly(spec=object)
+        python.id = 20
+
+        self.assertTrue(scragly != python)
+        self.assertFalse(scragly != eevee)
+
+    def test_mock_class_with_hashable_mixin_uses_id_for_hashing(self):
+        """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)
+                self.assertEqual(hash(instance), instance.id)
+
+    def test_mock_class_with_hashable_mixin_uses_id_for_equality(self):
+        """Test if MagicMocks that implement the HashableMixin use id for equality comparisons."""
+        for mock_class in self.hashable_mocks:
+            with self.subTest(mock_class=mock_class):
+                instance_one = mock_class()
+                instance_two = mock_class()
+                instance_three = mock_class()
+
+                instance_one.id = 10
+                instance_two.id = 10
+                instance_three.id = 20
+
+                self.assertTrue(instance_one == instance_two)
+                self.assertFalse(instance_one == instance_three)
+
+    def test_mock_class_with_hashable_mixin_uses_id_for_nonequality(self):
+        """Test if MagicMocks that implement HashableMixin use id for nonequality comparisons."""
+        for mock_class in self.hashable_mocks:
+            with self.subTest(mock_class=mock_class):
+                instance_one = mock_class()
+                instance_two = mock_class()
+                instance_three = mock_class()
+
+                instance_one.id = 10
+                instance_two.id = 10
+                instance_three.id = 20
+
+                self.assertFalse(instance_one != instance_two)
+                self.assertTrue(instance_one != instance_three)
+
+    def test_spec_propagation_of_mock_subclasses(self):
+        """Test if the `spec` does not propagate to attributes of the mock object."""
+        test_values = (
+            (helpers.MockGuild, "region"),
+            (helpers.MockRole, "mentionable"),
+            (helpers.MockMember, "display_name"),
+            (helpers.MockBot, "owner_id"),
+            (helpers.MockContext, "command_failed"),
+        )
+
+        for mock_type, valid_attribute in test_values:
+            with self.subTest(mock_type=mock_type, attribute=valid_attribute):
+                mock = mock_type()
+                self.assertTrue(isinstance(mock, mock_type))
+                attribute = getattr(mock, valid_attribute)
+                self.assertTrue(isinstance(attribute, mock_type.attribute_mocktype))
+
     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 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 +++++++++++++++++++++++++++++++--------------------
 tests/test_helpers.py | 18 +++++++++--
 2 files changed, 67 insertions(+), 36 deletions(-)

(limited to 'tests/test_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)
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
index f08239981..62007ff4e 100644
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@@ -221,10 +221,10 @@ 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.AttributeMock, unittest.mock.MagicMock):
+        class FakeMockBot(helpers.GetChildMockMixin, unittest.mock.MagicMock):
             """Fake MockBot class with invalid attribute/method `release_the_walrus`."""
 
-            attribute_mocktype = unittest.mock.MagicMock
+            child_mock_type = unittest.mock.MagicMock
 
             def __init__(self, **kwargs):
                 super().__init__(spec=helpers.bot_instance, **kwargs)
@@ -331,6 +331,18 @@ 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):
+
+            child_mock_type = unittest.mock.MagicMock
+            pass
+
+        mock = MyMock()
+        unittest.mock.seal(mock)
+        with self.assertRaises(AttributeError, msg="MyMock.shirayuki"):
+            mock.shirayuki = "hello!"
+
     def test_spec_propagation_of_mock_subclasses(self):
         """Test if the `spec` does not propagate to attributes of the mock object."""
         test_values = (
@@ -346,7 +358,7 @@ class MockObjectTests(unittest.TestCase):
                 mock = mock_type()
                 self.assertTrue(isinstance(mock, mock_type))
                 attribute = getattr(mock, valid_attribute)
-                self.assertTrue(isinstance(attribute, mock_type.attribute_mocktype))
+                self.assertTrue(isinstance(attribute, mock_type.child_mock_type))
 
     def test_async_mock_provides_coroutine_for_dunder_call(self):
         """Test if AsyncMock objects have a coroutine for their __call__ method."""
-- 
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/test_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 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/test_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/test_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