From 135d6daa4804574935cd788c5baec656765f484b Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Sun, 23 Feb 2020 13:05:10 +0100
Subject: Use IsolatedAsyncioTestCase instead of async_test

Since we upgraded to Python 3.8, we can now use the new IsolatedAsyncioTestCase test class to use coroutine-based test methods instead of our own, custom async_test decorator. I have changed the base class for all of our test classes that use coroutine-based test methods and removed the now obsolete decorator from our helpers.
---
 tests/helpers.py | 17 -----------------
 1 file changed, 17 deletions(-)

(limited to 'tests/helpers.py')

diff --git a/tests/helpers.py b/tests/helpers.py
index 5df796c23..01752a791 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-import asyncio
 import collections
-import functools
 import inspect
 import itertools
 import logging
@@ -25,21 +23,6 @@ for logger in logging.Logger.manager.loggerDict.values():
     logger.setLevel(logging.CRITICAL)
 
 
-def async_test(wrapped):
-    """
-    Run a test case via asyncio.
-    Example:
-        >>> @async_test
-        ... async def lemon_wins():
-        ...     assert True
-    """
-
-    @functools.wraps(wrapped)
-    def wrapper(*args, **kwargs):
-        return asyncio.run(wrapped(*args, **kwargs))
-    return wrapper
-
-
 class HashableMixin(discord.mixins.EqualityComparable):
     """
     Mixin that provides similar hashing and equality functionality as discord.py's `Hashable` mixin.
-- 
cgit v1.2.3


From ea64d7cc6defa759fc1c7f1631a7ae9b8073cc29 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Sun, 23 Feb 2020 20:53:45 +0100
Subject: Use unittest's AsyncMock instead of our AsyncMock

Python 3.8 introduced an `unittest.mock.AsyncMock` class that can be used to mock coroutines and other types of asynchronous operations like async iterators and async context managers. As we were using our custom, but limited, AsyncMock, I have replaced our mock with unittest's AsyncMock.

Since Python 3.8 also introduces a different way of automatically detecting which attributes should be mocked with an AsyncMock, I've changed our CustomMockMixin to use this new method as well. Together with a couple other small changes, this means that our Custom Mocks now use a lazy method of detecting coroutine attributes, which significantly speeds up the test suite.
---
 tests/bot/cogs/test_duck_pond.py     |  22 ++--
 tests/bot/cogs/test_information.py   |  34 +++----
 tests/bot/cogs/test_token_remover.py |   4 +-
 tests/bot/utils/test_time.py         |   3 +-
 tests/helpers.py                     | 190 ++++++++++++-----------------------
 tests/test_helpers.py                |  63 ++----------
 6 files changed, 103 insertions(+), 213 deletions(-)

(limited to 'tests/helpers.py')

diff --git a/tests/bot/cogs/test_duck_pond.py b/tests/bot/cogs/test_duck_pond.py
index 6406f0737..e164f7544 100644
--- a/tests/bot/cogs/test_duck_pond.py
+++ b/tests/bot/cogs/test_duck_pond.py
@@ -2,7 +2,7 @@ import asyncio
 import logging
 import typing
 import unittest
-from unittest.mock import MagicMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import discord
 
@@ -293,8 +293,8 @@ class DuckPondTests(base.LoggingTestsMixin, unittest.IsolatedAsyncioTestCase):
         )
 
         for message, expect_webhook_call, expect_attachment_call in test_values:
-            with patch(send_webhook_path, new_callable=helpers.AsyncMock) as send_webhook:
-                with patch(send_attachments_path, new_callable=helpers.AsyncMock) as send_attachments:
+            with patch(send_webhook_path, new_callable=AsyncMock) as send_webhook:
+                with patch(send_attachments_path, new_callable=AsyncMock) as send_attachments:
                     with self.subTest(clean_content=message.clean_content, attachments=message.attachments):
                         await self.cog.relay_message(message)
 
@@ -303,7 +303,7 @@ class DuckPondTests(base.LoggingTestsMixin, unittest.IsolatedAsyncioTestCase):
 
                         message.add_reaction.assert_called_once_with(self.checkmark_emoji)
 
-    @patch(f"{MODULE_PATH}.send_attachments", new_callable=helpers.AsyncMock)
+    @patch(f"{MODULE_PATH}.send_attachments", new_callable=AsyncMock)
     async def test_relay_message_handles_irretrievable_attachment_exceptions(self, send_attachments):
         """The `relay_message` method should handle irretrievable attachments."""
         message = helpers.MockMessage(clean_content="message", attachments=["attachment"])
@@ -314,15 +314,15 @@ class DuckPondTests(base.LoggingTestsMixin, unittest.IsolatedAsyncioTestCase):
 
         for side_effect in side_effects:
             send_attachments.side_effect = side_effect
-            with patch(f"{MODULE_PATH}.DuckPond.send_webhook", new_callable=helpers.AsyncMock) as send_webhook:
+            with patch(f"{MODULE_PATH}.DuckPond.send_webhook", new_callable=AsyncMock) as send_webhook:
                 with self.subTest(side_effect=type(side_effect).__name__):
                     with self.assertNotLogs(logger=log, level=logging.ERROR):
                         await self.cog.relay_message(message)
 
                     self.assertEqual(send_webhook.call_count, 2)
 
-    @patch(f"{MODULE_PATH}.DuckPond.send_webhook", new_callable=helpers.AsyncMock)
-    @patch(f"{MODULE_PATH}.send_attachments", new_callable=helpers.AsyncMock)
+    @patch(f"{MODULE_PATH}.DuckPond.send_webhook", new_callable=AsyncMock)
+    @patch(f"{MODULE_PATH}.send_attachments", new_callable=AsyncMock)
     async def test_relay_message_handles_attachment_http_error(self, send_attachments, send_webhook):
         """The `relay_message` method should handle irretrievable attachments."""
         message = helpers.MockMessage(clean_content="message", attachments=["attachment"])
@@ -456,7 +456,7 @@ class DuckPondTests(base.LoggingTestsMixin, unittest.IsolatedAsyncioTestCase):
                 channel.fetch_message.reset_mock()
 
     @patch(f"{MODULE_PATH}.DuckPond.is_staff")
-    @patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock)
+    @patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=AsyncMock)
     def test_on_raw_reaction_add_returns_on_message_with_green_checkmark_placed_by_bot(self, count_ducks, is_staff):
         """The `on_raw_reaction_add` event should return when the message has a green check mark placed by the bot."""
         channel_id = 31415926535
@@ -491,8 +491,8 @@ class DuckPondTests(base.LoggingTestsMixin, unittest.IsolatedAsyncioTestCase):
         payload.emoji = self.duck_pond_emoji
 
         for duck_count, should_relay in test_cases:
-            with patch(f"{MODULE_PATH}.DuckPond.relay_message", new_callable=helpers.AsyncMock) as relay_message:
-                with patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock) as count_ducks:
+            with patch(f"{MODULE_PATH}.DuckPond.relay_message", new_callable=AsyncMock) as relay_message:
+                with patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=AsyncMock) as count_ducks:
                     count_ducks.return_value = duck_count
                     with self.subTest(duck_count=duck_count, should_relay=should_relay):
                         await self.cog.on_raw_reaction_add(payload)
@@ -526,7 +526,7 @@ class DuckPondTests(base.LoggingTestsMixin, unittest.IsolatedAsyncioTestCase):
             (constants.DuckPond.threshold + 1, True),
         )
         for duck_count, should_re_add_checkmark in test_cases:
-            with patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=helpers.AsyncMock) as count_ducks:
+            with patch(f"{MODULE_PATH}.DuckPond.count_ducks", new_callable=AsyncMock) as count_ducks:
                 count_ducks.return_value = duck_count
                 with self.subTest(duck_count=duck_count, should_re_add_checkmark=should_re_add_checkmark):
                     await self.cog.on_raw_reaction_remove(payload)
diff --git a/tests/bot/cogs/test_information.py b/tests/bot/cogs/test_information.py
index deae7ebad..f5e937356 100644
--- a/tests/bot/cogs/test_information.py
+++ b/tests/bot/cogs/test_information.py
@@ -34,7 +34,7 @@ class InformationCogTests(unittest.TestCase):
         """Test if the `role_info` command correctly returns the `moderator_role`."""
         self.ctx.guild.roles.append(self.moderator_role)
 
-        self.cog.roles_info.can_run = helpers.AsyncMock()
+        self.cog.roles_info.can_run = unittest.mock.AsyncMock()
         self.cog.roles_info.can_run.return_value = True
 
         coroutine = self.cog.roles_info.callback(self.cog, self.ctx)
@@ -72,7 +72,7 @@ class InformationCogTests(unittest.TestCase):
 
         self.ctx.guild.roles.append([dummy_role, admin_role])
 
-        self.cog.role_info.can_run = helpers.AsyncMock()
+        self.cog.role_info.can_run = unittest.mock.AsyncMock()
         self.cog.role_info.can_run.return_value = True
 
         coroutine = self.cog.role_info.callback(self.cog, self.ctx, dummy_role, admin_role)
@@ -174,7 +174,7 @@ class UserInfractionHelperMethodTests(unittest.TestCase):
     def setUp(self):
         """Common set-up steps done before for each test."""
         self.bot = helpers.MockBot()
-        self.bot.api_client.get = helpers.AsyncMock()
+        self.bot.api_client.get = unittest.mock.AsyncMock()
         self.cog = information.Information(self.bot)
         self.member = helpers.MockMember(id=1234)
 
@@ -345,10 +345,10 @@ class UserEmbedTests(unittest.TestCase):
     def setUp(self):
         """Common set-up steps done before for each test."""
         self.bot = helpers.MockBot()
-        self.bot.api_client.get = helpers.AsyncMock()
+        self.bot.api_client.get = unittest.mock.AsyncMock()
         self.cog = information.Information(self.bot)
 
-    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=unittest.mock.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(id=1))
@@ -360,7 +360,7 @@ class UserEmbedTests(unittest.TestCase):
 
         self.assertEqual(embed.title, "Mr. Hemlock")
 
-    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=unittest.mock.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(id=1))
@@ -372,7 +372,7 @@ class UserEmbedTests(unittest.TestCase):
 
         self.assertEqual(embed.title, "Cat lover (Mr. Hemlock)")
 
-    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=unittest.mock.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(id=1))
@@ -387,8 +387,8 @@ class UserEmbedTests(unittest.TestCase):
         self.assertIn("&Admins", embed.description)
         self.assertNotIn("&Everyone", embed.description)
 
-    @unittest.mock.patch(f"{COG_PATH}.expanded_user_infraction_counts", new_callable=helpers.AsyncMock)
-    @unittest.mock.patch(f"{COG_PATH}.user_nomination_counts", new_callable=helpers.AsyncMock)
+    @unittest.mock.patch(f"{COG_PATH}.expanded_user_infraction_counts", new_callable=unittest.mock.AsyncMock)
+    @unittest.mock.patch(f"{COG_PATH}.user_nomination_counts", new_callable=unittest.mock.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(id=50))
@@ -423,7 +423,7 @@ class UserEmbedTests(unittest.TestCase):
             embed.description
         )
 
-    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new_callable=helpers.AsyncMock)
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new_callable=unittest.mock.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(id=100))
@@ -454,7 +454,7 @@ class UserEmbedTests(unittest.TestCase):
             embed.description
         )
 
-    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=unittest.mock.AsyncMock(return_value=""))
     def test_create_user_embed_uses_top_role_colour_when_user_has_roles(self):
         """The embed should be created with the colour of the top role, if a top role is available."""
         ctx = helpers.MockContext()
@@ -467,7 +467,7 @@ class UserEmbedTests(unittest.TestCase):
 
         self.assertEqual(embed.colour, discord.Colour(moderators_role.colour))
 
-    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=unittest.mock.AsyncMock(return_value=""))
     def test_create_user_embed_uses_blurple_colour_when_user_has_no_roles(self):
         """The embed should be created with a blurple colour if the user has no assigned roles."""
         ctx = helpers.MockContext()
@@ -477,7 +477,7 @@ class UserEmbedTests(unittest.TestCase):
 
         self.assertEqual(embed.colour, discord.Colour.blurple())
 
-    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=helpers.AsyncMock(return_value=""))
+    @unittest.mock.patch(f"{COG_PATH}.basic_user_infraction_counts", new=unittest.mock.AsyncMock(return_value=""))
     def test_create_user_embed_uses_png_format_of_user_avatar_as_thumbnail(self):
         """The embed thumbnail should be set to the user's avatar in `png` format."""
         ctx = helpers.MockContext()
@@ -529,7 +529,7 @@ class UserCommandTests(unittest.TestCase):
         with self.assertRaises(InChannelCheckFailure, msg=msg):
             asyncio.run(self.cog.user_info.callback(self.cog, ctx))
 
-    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=helpers.AsyncMock)
+    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=unittest.mock.AsyncMock)
     def test_regular_user_may_use_command_in_bot_commands_channel(self, create_embed, constants):
         """A regular user should be allowed to use `!user` targeting themselves in bot-commands."""
         constants.STAFF_ROLES = [self.moderator_role.id]
@@ -542,7 +542,7 @@ class UserCommandTests(unittest.TestCase):
         create_embed.assert_called_once_with(ctx, self.author)
         ctx.send.assert_called_once()
 
-    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=helpers.AsyncMock)
+    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=unittest.mock.AsyncMock)
     def test_regular_user_can_explicitly_target_themselves(self, create_embed, constants):
         """A user should target itself with `!user` when a `user` argument was not provided."""
         constants.STAFF_ROLES = [self.moderator_role.id]
@@ -555,7 +555,7 @@ class UserCommandTests(unittest.TestCase):
         create_embed.assert_called_once_with(ctx, self.author)
         ctx.send.assert_called_once()
 
-    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=helpers.AsyncMock)
+    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=unittest.mock.AsyncMock)
     def test_staff_members_can_bypass_channel_restriction(self, create_embed, constants):
         """Staff members should be able to bypass the bot-commands channel restriction."""
         constants.STAFF_ROLES = [self.moderator_role.id]
@@ -568,7 +568,7 @@ class UserCommandTests(unittest.TestCase):
         create_embed.assert_called_once_with(ctx, self.moderator)
         ctx.send.assert_called_once()
 
-    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=helpers.AsyncMock)
+    @unittest.mock.patch("bot.cogs.information.Information.create_user_embed", new_callable=unittest.mock.AsyncMock)
     def test_moderators_can_target_another_member(self, create_embed, constants):
         """A moderator should be able to use `!user` targeting another user."""
         constants.MODERATION_ROLES = [self.moderator_role.id]
diff --git a/tests/bot/cogs/test_token_remover.py b/tests/bot/cogs/test_token_remover.py
index a54b839d7..33d1ec170 100644
--- a/tests/bot/cogs/test_token_remover.py
+++ b/tests/bot/cogs/test_token_remover.py
@@ -1,7 +1,7 @@
 import asyncio
 import logging
 import unittest
-from unittest.mock import MagicMock
+from unittest.mock import AsyncMock, MagicMock
 
 from discord import Colour
 
@@ -11,7 +11,7 @@ from bot.cogs.token_remover import (
     setup as setup_cog,
 )
 from bot.constants import Channels, Colours, Event, Icons
-from tests.helpers import AsyncMock, MockBot, MockMessage
+from tests.helpers import MockBot, MockMessage
 
 
 class TokenRemoverTests(unittest.TestCase):
diff --git a/tests/bot/utils/test_time.py b/tests/bot/utils/test_time.py
index 69f35f2f5..de5724bca 100644
--- a/tests/bot/utils/test_time.py
+++ b/tests/bot/utils/test_time.py
@@ -1,12 +1,11 @@
 import asyncio
 import unittest
 from datetime import datetime, timezone
-from unittest.mock import patch
+from unittest.mock import AsyncMock, patch
 
 from dateutil.relativedelta import relativedelta
 
 from bot.utils import time
-from tests.helpers import AsyncMock
 
 
 class TimeTests(unittest.TestCase):
diff --git a/tests/helpers.py b/tests/helpers.py
index 01752a791..506fe9894 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -1,11 +1,10 @@
 from __future__ import annotations
 
 import collections
-import inspect
 import itertools
 import logging
 import unittest.mock
-from typing import Any, Iterable, Optional
+from typing import Iterable, Optional
 
 import discord
 from discord.ext.commands import Context
@@ -51,24 +50,31 @@ class CustomMockMixin:
     """
     Provides common functionality for our custom Mock types.
 
-    The cooperative `__init__` automatically creates `AsyncMock` attributes for every coroutine
-    function `inspect` detects in the `spec` instance we provide. In addition, this mixin takes care
-    of making sure child mocks are instantiated with the correct class. By default, the mock of the
-    children will be `unittest.mock.MagicMock`, but this can be overwritten by setting the attribute
-    `child_mock_type` on the custom mock inheriting from this mixin.
+    The `_get_child_mock` method automatically returns an AsyncMock for coroutine methods of the mock
+    object. As discord.py also uses synchronous methods that nonetheless return coroutine objects, the
+    class attribute `additional_spec_asyncs` can be overwritten with an iterable containing additional
+    attribute names that should also mocked with an AsyncMock instead of a regular MagicMock/Mock. The
+    class method `spec_set` can be overwritten with the object that should be uses as the specification
+    for the mock.
+
+    Mock/MagicMock subclasses that use this mixin only need to define `__init__` method if they need to
+    implement custom behavior.
     """
 
     child_mock_type = unittest.mock.MagicMock
     discord_id = itertools.count(0)
+    spec_set = None
+    additional_spec_asyncs = None
 
-    def __init__(self, spec_set: Any = None, **kwargs):
+    def __init__(self, **kwargs):
         name = kwargs.pop('name', None)  # `name` has special meaning for Mock classes, so we need to set it manually.
-        super().__init__(spec_set=spec_set, **kwargs)
+        super().__init__(spec_set=self.spec_set, **kwargs)
+
+        if self.additional_spec_asyncs:
+            self._spec_asyncs.extend(self.additional_spec_asyncs)
 
         if name:
             self.name = name
-        if spec_set:
-            self._extract_coroutine_methods_from_spec_instance(spec_set)
 
     def _get_child_mock(self, **kw):
         """
@@ -82,7 +88,16 @@ class CustomMockMixin:
 
         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
+        _new_name = kw.get("_new_name")
+        if _new_name in self.__dict__['_spec_asyncs']:
+            return unittest.mock.AsyncMock(**kw)
+
+        _type = type(self)
+        if issubclass(_type, unittest.mock.MagicMock) and _new_name in unittest.mock._async_method_magics:
+            # Any asynchronous magic becomes an AsyncMock
+            klass = unittest.mock.AsyncMock
+        else:
+            klass = self.child_mock_type
 
         if self._mock_sealed:
             attribute = "." + kw["name"] if "name" in kw else "()"
@@ -91,95 +106,6 @@ class CustomMockMixin:
 
         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(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.
-    """
-
-    async def __call__(self, *args, **kwargs):
-        return super().__call__(*args, **kwargs)
-
-
-class AsyncIteratorMock:
-    """
-    A class to mock asynchronous iterators.
-
-    This allows async for, which is used in certain Discord.py objects. For example,
-    an async iterator is returned by the Reaction.users() method.
-    """
-
-    def __init__(self, iterable: Iterable = None):
-        if iterable is None:
-            iterable = []
-
-        self.iter = iter(iterable)
-        self.iterable = iterable
-
-        self.call_count = 0
-
-    def __aiter__(self):
-        return self
-
-    async def __anext__(self):
-        try:
-            return next(self.iter)
-        except StopIteration:
-            raise StopAsyncIteration
-
-    def __call__(self):
-        """
-        Keeps track of the number of times an instance has been called.
-
-        This is useful, since it typically shows that the iterator has actually been used somewhere after we have
-        instantiated the mock for an attribute that normally returns an iterator when called.
-        """
-        self.call_count += 1
-        return self
-
-    @property
-    def return_value(self):
-        """Makes `self.iterable` accessible as self.return_value."""
-        return self.iterable
-
-    @return_value.setter
-    def return_value(self, iterable):
-        """Stores the `return_value` as `self.iterable` and its iterator as `self.iter`."""
-        self.iter = iter(iterable)
-        self.iterable = iterable
-
-    def assert_called(self):
-        """Asserts if the AsyncIteratorMock instance has been called at least once."""
-        if self.call_count == 0:
-            raise AssertionError("Expected AsyncIteratorMock to have been called.")
-
-    def assert_called_once(self):
-        """Asserts if the AsyncIteratorMock instance has been called exactly once."""
-        if self.call_count != 1:
-            raise AssertionError(
-                f"Expected AsyncIteratorMock to have been called once. Called {self.call_count} times."
-            )
-
-    def assert_not_called(self):
-        """Asserts if the AsyncIteratorMock instance has not been called."""
-        if self.call_count != 0:
-            raise AssertionError(
-                f"Expected AsyncIteratorMock to not have been called once. Called {self.call_count} times."
-            )
-
-    def reset_mock(self):
-        """Resets the call count, but not the return value or iterator."""
-        self.call_count = 0
-
 
 # Create a guild instance to get a realistic Mock of `discord.Guild`
 guild_data = {
@@ -230,9 +156,11 @@ class MockGuild(CustomMockMixin, unittest.mock.Mock, HashableMixin):
 
     For more info, see the `Mocking` section in `tests/README.md`.
     """
+    spec_set = guild_instance
+
     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))
+        super().__init__(**collections.ChainMap(kwargs, default_kwargs))
 
         self.roles = [MockRole(name="@everyone", position=1, id=0)]
         if roles:
@@ -251,9 +179,11 @@ 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.
     """
+    spec_set = role_instance
+
     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))
+        super().__init__(**collections.ChainMap(kwargs, default_kwargs))
 
         if 'mention' not in kwargs:
             self.mention = f'&{self.name}'
@@ -276,9 +206,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.
     """
+    spec_set = member_instance
+
     def __init__(self, roles: Optional[Iterable[MockRole]] = None, **kwargs) -> None:
         default_kwargs = {'name': 'member', 'id': next(self.discord_id), 'bot': False}
-        super().__init__(spec_set=member_instance, **collections.ChainMap(kwargs, default_kwargs))
+        super().__init__(**collections.ChainMap(kwargs, default_kwargs))
 
         self.roles = [MockRole(name="@everyone", position=1, id=0)]
         if roles:
@@ -299,9 +231,11 @@ class MockUser(CustomMockMixin, unittest.mock.Mock, ColourMixin, HashableMixin):
     Instances of this class will follow the specifications of `discord.User` instances. For more
     information, see the `MockGuild` docstring.
     """
+    spec_set = user_instance
+
     def __init__(self, **kwargs) -> None:
         default_kwargs = {'name': 'user', 'id': next(self.discord_id), 'bot': False}
-        super().__init__(spec_set=user_instance, **collections.ChainMap(kwargs, default_kwargs))
+        super().__init__(**collections.ChainMap(kwargs, default_kwargs))
 
         if 'mention' not in kwargs:
             self.mention = f"@{self.name}"
@@ -320,14 +254,16 @@ class MockBot(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.ext.commands.Bot` instances.
     For more information, see the `MockGuild` docstring.
     """
+    spec_set = bot_instance
+    additional_spec_asyncs = ("wait_for",)
 
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec_set=bot_instance, **kwargs)
+        super().__init__(**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
         # is technically incorrect, since it's a regular def.)
-        self.wait_for = AsyncMock()
+        # self.wait_for = unittest.mock.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
@@ -358,10 +294,11 @@ class MockTextChannel(CustomMockMixin, unittest.mock.Mock, HashableMixin):
     Instances of this class will follow the specifications of `discord.TextChannel` instances. For
     more information, see the `MockGuild` docstring.
     """
+    spec_set = channel_instance
 
     def __init__(self, name: str = 'channel', channel_id: int = 1, **kwargs) -> None:
         default_kwargs = {'id': next(self.discord_id), 'name': 'channel', 'guild': MockGuild()}
-        super().__init__(spec_set=channel_instance, **collections.ChainMap(kwargs, default_kwargs))
+        super().__init__(**collections.ChainMap(kwargs, default_kwargs))
 
         if 'mention' not in kwargs:
             self.mention = f"#{self.name}"
@@ -400,9 +337,10 @@ class MockContext(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.ext.commands.Context`
     instances. For more information, see the `MockGuild` docstring.
     """
+    spec_set = context_instance
 
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec_set=context_instance, **kwargs)
+        super().__init__(**kwargs)
         self.bot = kwargs.get('bot', MockBot())
         self.guild = kwargs.get('guild', MockGuild())
         self.author = kwargs.get('author', MockMember())
@@ -419,8 +357,7 @@ class MockAttachment(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.Attachment` instances. For
     more information, see the `MockGuild` docstring.
     """
-    def __init__(self, **kwargs) -> None:
-        super().__init__(spec_set=attachment_instance, **kwargs)
+    spec_set = attachment_instance
 
 
 class MockMessage(CustomMockMixin, unittest.mock.MagicMock):
@@ -430,10 +367,11 @@ class MockMessage(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.Message` instances. For more
     information, see the `MockGuild` docstring.
     """
+    spec_set = message_instance
 
     def __init__(self, **kwargs) -> None:
         default_kwargs = {'attachments': []}
-        super().__init__(spec_set=message_instance, **collections.ChainMap(kwargs, default_kwargs))
+        super().__init__(**collections.ChainMap(kwargs, default_kwargs))
         self.author = kwargs.get('author', MockMember())
         self.channel = kwargs.get('channel', MockTextChannel())
 
@@ -449,9 +387,10 @@ class MockEmoji(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.Emoji` instances. For more
     information, see the `MockGuild` docstring.
     """
+    spec_set = emoji_instance
 
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec_set=emoji_instance, **kwargs)
+        super().__init__(**kwargs)
         self.guild = kwargs.get('guild', MockGuild())
 
 
@@ -465,9 +404,7 @@ class MockPartialEmoji(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.PartialEmoji` instances. For
     more information, see the `MockGuild` docstring.
     """
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(spec_set=partial_emoji_instance, **kwargs)
+    spec_set = partial_emoji_instance
 
 
 reaction_instance = discord.Reaction(message=MockMessage(), data={'me': True}, emoji=MockEmoji())
@@ -480,12 +417,17 @@ class MockReaction(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.Reaction` instances. For
     more information, see the `MockGuild` docstring.
     """
+    spec_set = reaction_instance
 
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec_set=reaction_instance, **kwargs)
+        _users = kwargs.pop("users", [])
+        super().__init__(**kwargs)
         self.emoji = kwargs.get('emoji', MockEmoji())
         self.message = kwargs.get('message', MockMessage())
-        self.users = AsyncIteratorMock(kwargs.get('users', []))
+
+        user_iterator = unittest.mock.AsyncMock()
+        user_iterator.__aiter__.return_value = _users
+        self.users.return_value = user_iterator
 
 
 webhook_instance = discord.Webhook(data=unittest.mock.MagicMock(), adapter=unittest.mock.MagicMock())
@@ -498,13 +440,5 @@ class MockAsyncWebhook(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `discord.Webhook` instances. For
     more information, see the `MockGuild` docstring.
     """
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(spec_set=webhook_instance, **kwargs)
-
-        # Because Webhooks can also use a synchronous "WebhookAdapter", the methods are not defined
-        # as coroutines. That's why we need to set the methods manually.
-        self.send = AsyncMock()
-        self.edit = AsyncMock()
-        self.delete = AsyncMock()
-        self.execute = AsyncMock()
+    spec_set = webhook_instance
+    additional_spec_asyncs = ("send", "edit", "delete", "execute")
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
index fe39df308..81285e009 100644
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@@ -1,5 +1,4 @@
 import asyncio
-import inspect
 import unittest
 import unittest.mock
 
@@ -214,6 +213,11 @@ class DiscordMocksTests(unittest.TestCase):
         with self.assertRaises(RuntimeError, msg="cannot reuse already awaited coroutine"):
             asyncio.run(coroutine_object)
 
+    def test_user_mock_uses_explicitly_passed_mention_attribute(self):
+        """MockUser should use an explicitly passed value for user.mention."""
+        user = helpers.MockUser(mention="hello")
+        self.assertEqual(user.mention, "hello")
+
 
 class MockObjectTests(unittest.TestCase):
     """Tests the mock objects and mixins we've defined."""
@@ -341,57 +345,10 @@ 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:
+    def test_custom_mock_mixin_mocks_async_magic_methods_with_async_mock(self):
+        """The CustomMockMixin should mock async magic methods with an AsyncMock."""
+        class MyMock(helpers.CustomMockMixin, unittest.mock.MagicMock):
             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_set = "pydis"
-
-        helpers.CustomMockMixin(spec_set=spec_set)
-
-        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")
-    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()
-        self.assertTrue(inspect.iscoroutinefunction(async_mock.__call__))
-
-        coroutine = async_mock()
-        self.assertTrue(inspect.iscoroutine(coroutine))
-        self.assertIsNotNone(asyncio.run(coroutine))
+        mock = MyMock()
+        self.assertIsInstance(mock.__aenter__, unittest.mock.AsyncMock)
-- 
cgit v1.2.3


From b8bd18bd743608ddff47064d0b459edff3da65e3 Mon Sep 17 00:00:00 2001
From: Sebastiaan Zeeff <33516116+SebastiaanZ@users.noreply.github.com>
Date: Mon, 24 Feb 2020 02:12:02 +0100
Subject: Migrate syncers test suite to Python 3.8

The test suite for the new role/member syncers used the "old"-style test suite with the helpers implemented for Python 3.7. I have migrated it to use the new Python 3.8 asyncio test helpers.
---
 tests/base.py                     |  4 ++--
 tests/bot/cogs/sync/test_base.py  | 45 ++++++++++++++++-----------------------
 tests/bot/cogs/sync/test_cog.py   | 31 ++++++++-------------------
 tests/bot/cogs/sync/test_roles.py | 12 ++---------
 tests/bot/cogs/sync/test_users.py | 13 ++---------
 tests/helpers.py                  |  4 +---
 6 files changed, 34 insertions(+), 75 deletions(-)

(limited to 'tests/helpers.py')

diff --git a/tests/base.py b/tests/base.py
index 21613110e..42174e911 100644
--- a/tests/base.py
+++ b/tests/base.py
@@ -1,4 +1,5 @@
 import logging
+import unittest
 from contextlib import contextmanager
 from typing import Dict
 
@@ -77,10 +78,9 @@ class LoggingTestsMixin:
             self.fail(msg)
 
 
-class CommandTestCase(unittest.TestCase):
+class CommandTestCase(unittest.IsolatedAsyncioTestCase):
     """TestCase with additional assertions that are useful for testing Discord commands."""
 
-    @helpers.async_test
     async def assertHasPermissionsCheck(
         self,
         cmd: commands.Command,
diff --git a/tests/bot/cogs/sync/test_base.py b/tests/bot/cogs/sync/test_base.py
index e6a6f9688..17aa4198b 100644
--- a/tests/bot/cogs/sync/test_base.py
+++ b/tests/bot/cogs/sync/test_base.py
@@ -13,8 +13,8 @@ class TestSyncer(Syncer):
     """Syncer subclass with mocks for abstract methods for testing purposes."""
 
     name = "test"
-    _get_diff = helpers.AsyncMock()
-    _sync = helpers.AsyncMock()
+    _get_diff = mock.AsyncMock()
+    _sync = mock.AsyncMock()
 
 
 class SyncerBaseTests(unittest.TestCase):
@@ -29,7 +29,7 @@ class SyncerBaseTests(unittest.TestCase):
             Syncer(self.bot)
 
 
-class SyncerSendPromptTests(unittest.TestCase):
+class SyncerSendPromptTests(unittest.IsolatedAsyncioTestCase):
     """Tests for sending the sync confirmation prompt."""
 
     def setUp(self):
@@ -61,7 +61,6 @@ class SyncerSendPromptTests(unittest.TestCase):
 
         return mock_channel, mock_message
 
-    @helpers.async_test
     async def test_send_prompt_edits_and_returns_message(self):
         """The given message should be edited to display the prompt and then should be returned."""
         msg = helpers.MockMessage()
@@ -71,7 +70,6 @@ class SyncerSendPromptTests(unittest.TestCase):
         self.assertIn("content", msg.edit.call_args[1])
         self.assertEqual(ret_val, msg)
 
-    @helpers.async_test
     async def test_send_prompt_gets_dev_core_channel(self):
         """The dev-core channel should be retrieved if an extant message isn't given."""
         subtests = (
@@ -86,7 +84,6 @@ class SyncerSendPromptTests(unittest.TestCase):
 
                 method.assert_called_once_with(constants.Channels.devcore)
 
-    @helpers.async_test
     async def test_send_prompt_returns_None_if_channel_fetch_fails(self):
         """None should be returned if there's an HTTPException when fetching the channel."""
         self.bot.get_channel.return_value = None
@@ -96,7 +93,6 @@ class SyncerSendPromptTests(unittest.TestCase):
 
         self.assertIsNone(ret_val)
 
-    @helpers.async_test
     async def test_send_prompt_sends_and_returns_new_message_if_not_given(self):
         """A new message mentioning core devs should be sent and returned if message isn't given."""
         for mock_ in (self.mock_get_channel, self.mock_fetch_channel):
@@ -108,7 +104,6 @@ class SyncerSendPromptTests(unittest.TestCase):
                 self.assertIn(self.syncer._CORE_DEV_MENTION, mock_channel.send.call_args[0][0])
                 self.assertEqual(ret_val, mock_message)
 
-    @helpers.async_test
     async def test_send_prompt_adds_reactions(self):
         """The message should have reactions for confirmation added."""
         extant_message = helpers.MockMessage()
@@ -129,7 +124,7 @@ class SyncerSendPromptTests(unittest.TestCase):
                 mock_message.add_reaction.assert_has_calls(calls)
 
 
-class SyncerConfirmationTests(unittest.TestCase):
+class SyncerConfirmationTests(unittest.IsolatedAsyncioTestCase):
     """Tests for waiting for a sync confirmation reaction on the prompt."""
 
     def setUp(self):
@@ -211,7 +206,6 @@ class SyncerConfirmationTests(unittest.TestCase):
                 ret_val = self.syncer._reaction_check(*args)
                 self.assertFalse(ret_val)
 
-    @helpers.async_test
     async def test_wait_for_confirmation(self):
         """The message should always be edited and only return True if the emoji is a check mark."""
         subtests = (
@@ -251,14 +245,13 @@ class SyncerConfirmationTests(unittest.TestCase):
                     self.assertIs(actual_return, ret_val)
 
 
-class SyncerSyncTests(unittest.TestCase):
+class SyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for main function orchestrating the sync."""
 
     def setUp(self):
         self.bot = helpers.MockBot(user=helpers.MockMember(bot=True))
         self.syncer = TestSyncer(self.bot)
 
-    @helpers.async_test
     async def test_sync_respects_confirmation_result(self):
         """The sync should abort if confirmation fails and continue if confirmed."""
         mock_message = helpers.MockMessage()
@@ -274,7 +267,7 @@ class SyncerSyncTests(unittest.TestCase):
 
                 diff = _Diff({1, 2, 3}, {4, 5}, None)
                 self.syncer._get_diff.return_value = diff
-                self.syncer._get_confirmation_result = helpers.AsyncMock(
+                self.syncer._get_confirmation_result = mock.AsyncMock(
                     return_value=(confirmed, message)
                 )
 
@@ -289,7 +282,6 @@ class SyncerSyncTests(unittest.TestCase):
                 else:
                     self.syncer._sync.assert_not_called()
 
-    @helpers.async_test
     async def test_sync_diff_size(self):
         """The diff size should be correctly calculated."""
         subtests = (
@@ -303,7 +295,7 @@ class SyncerSyncTests(unittest.TestCase):
             with self.subTest(size=size, diff=diff):
                 self.syncer._get_diff.reset_mock()
                 self.syncer._get_diff.return_value = diff
-                self.syncer._get_confirmation_result = helpers.AsyncMock(return_value=(False, None))
+                self.syncer._get_confirmation_result = mock.AsyncMock(return_value=(False, None))
 
                 guild = helpers.MockGuild()
                 await self.syncer.sync(guild)
@@ -312,7 +304,6 @@ class SyncerSyncTests(unittest.TestCase):
                 self.syncer._get_confirmation_result.assert_called_once()
                 self.assertEqual(self.syncer._get_confirmation_result.call_args[0][0], size)
 
-    @helpers.async_test
     async def test_sync_message_edited(self):
         """The message should be edited if one was sent, even if the sync has an API error."""
         subtests = (
@@ -324,7 +315,7 @@ class SyncerSyncTests(unittest.TestCase):
         for message, side_effect, should_edit in subtests:
             with self.subTest(message=message, side_effect=side_effect, should_edit=should_edit):
                 self.syncer._sync.side_effect = side_effect
-                self.syncer._get_confirmation_result = helpers.AsyncMock(
+                self.syncer._get_confirmation_result = mock.AsyncMock(
                     return_value=(True, message)
                 )
 
@@ -335,7 +326,6 @@ class SyncerSyncTests(unittest.TestCase):
                     message.edit.assert_called_once()
                     self.assertIn("content", message.edit.call_args[1])
 
-    @helpers.async_test
     async def test_sync_confirmation_context_redirect(self):
         """If ctx is given, a new message should be sent and author should be ctx's author."""
         mock_member = helpers.MockMember()
@@ -349,7 +339,10 @@ class SyncerSyncTests(unittest.TestCase):
                 if ctx is not None:
                     ctx.send.return_value = message
 
-                self.syncer._get_confirmation_result = helpers.AsyncMock(return_value=(False, None))
+                diff = _Diff({1, 2, 3}, {4, 5}, None)
+                self.syncer._get_diff.return_value = diff
+
+                self.syncer._get_confirmation_result = mock.AsyncMock(return_value=(False, None))
 
                 guild = helpers.MockGuild()
                 await self.syncer.sync(guild, ctx)
@@ -362,16 +355,15 @@ class SyncerSyncTests(unittest.TestCase):
                 self.assertEqual(self.syncer._get_confirmation_result.call_args[0][2], message)
 
     @mock.patch.object(constants.Sync, "max_diff", new=3)
-    @helpers.async_test
     async def test_confirmation_result_small_diff(self):
         """Should always return True and the given message if the diff size is too small."""
         author = helpers.MockMember()
         expected_message = helpers.MockMessage()
 
-        for size in (3, 2):
+        for size in (3, 2):  # pragma: no cover
             with self.subTest(size=size):
-                self.syncer._send_prompt = helpers.AsyncMock()
-                self.syncer._wait_for_confirmation = helpers.AsyncMock()
+                self.syncer._send_prompt = mock.AsyncMock()
+                self.syncer._wait_for_confirmation = mock.AsyncMock()
 
                 coro = self.syncer._get_confirmation_result(size, author, expected_message)
                 result, actual_message = await coro
@@ -382,7 +374,6 @@ class SyncerSyncTests(unittest.TestCase):
                 self.syncer._wait_for_confirmation.assert_not_called()
 
     @mock.patch.object(constants.Sync, "max_diff", new=3)
-    @helpers.async_test
     async def test_confirmation_result_large_diff(self):
         """Should return True if confirmed and False if _send_prompt fails or aborted."""
         author = helpers.MockMember()
@@ -394,10 +385,10 @@ class SyncerSyncTests(unittest.TestCase):
             (False, mock_message, False, "aborted"),
         )
 
-        for expected_result, expected_message, confirmed, msg in subtests:
+        for expected_result, expected_message, confirmed, msg in subtests:  # pragma: no cover
             with self.subTest(msg=msg):
-                self.syncer._send_prompt = helpers.AsyncMock(return_value=expected_message)
-                self.syncer._wait_for_confirmation = helpers.AsyncMock(return_value=confirmed)
+                self.syncer._send_prompt = mock.AsyncMock(return_value=expected_message)
+                self.syncer._wait_for_confirmation = mock.AsyncMock(return_value=confirmed)
 
                 coro = self.syncer._get_confirmation_result(4, author)
                 actual_result, actual_message = await coro
diff --git a/tests/bot/cogs/sync/test_cog.py b/tests/bot/cogs/sync/test_cog.py
index 98c9afc0d..8c87c0d6b 100644
--- a/tests/bot/cogs/sync/test_cog.py
+++ b/tests/bot/cogs/sync/test_cog.py
@@ -18,12 +18,13 @@ class MockSyncer(helpers.CustomMockMixin, mock.MagicMock):
     Instances of this class will follow the specifications of `bot.cogs.sync.syncers.Syncer`
     instances. For more information, see the `MockGuild` docstring.
     """
+    spec_set = Syncer
 
     def __init__(self, **kwargs) -> None:
-        super().__init__(spec_set=Syncer, **kwargs)
+        super().__init__(**kwargs)
 
 
-class SyncExtensionTests(unittest.TestCase):
+class SyncExtensionTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the sync extension."""
 
     @staticmethod
@@ -34,7 +35,7 @@ class SyncExtensionTests(unittest.TestCase):
         bot.add_cog.assert_called_once()
 
 
-class SyncCogTestCase(unittest.TestCase):
+class SyncCogTestCase(unittest.IsolatedAsyncioTestCase):
     """Base class for Sync cog tests. Sets up patches for syncers."""
 
     def setUp(self):
@@ -72,13 +73,13 @@ class SyncCogTestCase(unittest.TestCase):
 class SyncCogTests(SyncCogTestCase):
     """Tests for the Sync cog."""
 
-    @mock.patch.object(sync.Sync, "sync_guild")
+    @mock.patch.object(sync.Sync, "sync_guild", new_callable=mock.MagicMock)
     def test_sync_cog_init(self, sync_guild):
         """Should instantiate syncers and run a sync for the guild."""
         # Reset because a Sync cog was already instantiated in setUp.
         self.RoleSyncer.reset_mock()
         self.UserSyncer.reset_mock()
-        self.bot.loop.create_task.reset_mock()
+        self.bot.loop.create_task = mock.MagicMock()
 
         mock_sync_guild_coro = mock.MagicMock()
         sync_guild.return_value = mock_sync_guild_coro
@@ -90,7 +91,6 @@ class SyncCogTests(SyncCogTestCase):
         sync_guild.assert_called_once_with()
         self.bot.loop.create_task.assert_called_once_with(mock_sync_guild_coro)
 
-    @helpers.async_test
     async def test_sync_cog_sync_guild(self):
         """Roles and users should be synced only if a guild is successfully retrieved."""
         for guild in (helpers.MockGuild(), None):
@@ -126,14 +126,12 @@ class SyncCogTests(SyncCogTestCase):
             json=updated_information,
         )
 
-    @helpers.async_test
     async def test_sync_cog_patch_user(self):
         """A PATCH request should be sent and 404 errors ignored."""
         for side_effect in (None, self.response_error(404)):
             with self.subTest(side_effect=side_effect):
                 await self.patch_user_helper(side_effect)
 
-    @helpers.async_test
     async def test_sync_cog_patch_user_non_404(self):
         """A PATCH request should be sent and the error raised if it's not a 404."""
         with self.assertRaises(ResponseCodeError):
@@ -145,9 +143,8 @@ class SyncCogListenerTests(SyncCogTestCase):
 
     def setUp(self):
         super().setUp()
-        self.cog.patch_user = helpers.AsyncMock(spec_set=self.cog.patch_user)
+        self.cog.patch_user = mock.AsyncMock(spec_set=self.cog.patch_user)
 
-    @helpers.async_test
     async def test_sync_cog_on_guild_role_create(self):
         """A POST request should be sent with the new role's data."""
         self.assertTrue(self.cog.on_guild_role_create.__cog_listener__)
@@ -164,7 +161,6 @@ class SyncCogListenerTests(SyncCogTestCase):
 
         self.bot.api_client.post.assert_called_once_with("bot/roles", json=role_data)
 
-    @helpers.async_test
     async def test_sync_cog_on_guild_role_delete(self):
         """A DELETE request should be sent."""
         self.assertTrue(self.cog.on_guild_role_delete.__cog_listener__)
@@ -174,7 +170,6 @@ class SyncCogListenerTests(SyncCogTestCase):
 
         self.bot.api_client.delete.assert_called_once_with("bot/roles/99")
 
-    @helpers.async_test
     async def test_sync_cog_on_guild_role_update(self):
         """A PUT request should be sent if the colour, name, permissions, or position changes."""
         self.assertTrue(self.cog.on_guild_role_update.__cog_listener__)
@@ -212,7 +207,6 @@ class SyncCogListenerTests(SyncCogTestCase):
                     else:
                         self.bot.api_client.put.assert_not_called()
 
-    @helpers.async_test
     async def test_sync_cog_on_member_remove(self):
         """Member should patched to set in_guild as False."""
         self.assertTrue(self.cog.on_member_remove.__cog_listener__)
@@ -225,7 +219,6 @@ class SyncCogListenerTests(SyncCogTestCase):
             updated_information={"in_guild": False}
         )
 
-    @helpers.async_test
     async def test_sync_cog_on_member_update_roles(self):
         """Members should be patched if their roles have changed."""
         self.assertTrue(self.cog.on_member_update.__cog_listener__)
@@ -240,7 +233,6 @@ class SyncCogListenerTests(SyncCogTestCase):
         data = {"roles": sorted(role.id for role in after_member.roles)}
         self.cog.patch_user.assert_called_once_with(after_member.id, updated_information=data)
 
-    @helpers.async_test
     async def test_sync_cog_on_member_update_other(self):
         """Members should not be patched if other attributes have changed."""
         self.assertTrue(self.cog.on_member_update.__cog_listener__)
@@ -262,7 +254,6 @@ class SyncCogListenerTests(SyncCogTestCase):
 
                 self.cog.patch_user.assert_not_called()
 
-    @helpers.async_test
     async def test_sync_cog_on_user_update(self):
         """A user should be patched only if the name, discriminator, or avatar changes."""
         self.assertTrue(self.cog.on_user_update.__cog_listener__)
@@ -341,7 +332,6 @@ class SyncCogListenerTests(SyncCogTestCase):
 
         return data
 
-    @helpers.async_test
     async def test_sync_cog_on_member_join(self):
         """Should PUT user's data or POST it if the user doesn't exist."""
         for side_effect in (None, self.response_error(404)):
@@ -354,7 +344,6 @@ class SyncCogListenerTests(SyncCogTestCase):
                 else:
                     self.bot.api_client.post.assert_not_called()
 
-    @helpers.async_test
     async def test_sync_cog_on_member_join_non_404(self):
         """ResponseCodeError should be re-raised if status code isn't a 404."""
         with self.assertRaises(ResponseCodeError):
@@ -366,7 +355,6 @@ class SyncCogListenerTests(SyncCogTestCase):
 class SyncCogCommandTests(SyncCogTestCase, CommandTestCase):
     """Tests for the commands in the Sync cog."""
 
-    @helpers.async_test
     async def test_sync_roles_command(self):
         """sync() should be called on the RoleSyncer."""
         ctx = helpers.MockContext()
@@ -374,7 +362,6 @@ class SyncCogCommandTests(SyncCogTestCase, CommandTestCase):
 
         self.cog.role_syncer.sync.assert_called_once_with(ctx.guild, ctx)
 
-    @helpers.async_test
     async def test_sync_users_command(self):
         """sync() should be called on the UserSyncer."""
         ctx = helpers.MockContext()
@@ -382,7 +369,7 @@ class SyncCogCommandTests(SyncCogTestCase, CommandTestCase):
 
         self.cog.user_syncer.sync.assert_called_once_with(ctx.guild, ctx)
 
-    def test_commands_require_admin(self):
+    async def test_commands_require_admin(self):
         """The sync commands should only run if the author has the administrator permission."""
         cmds = (
             self.cog.sync_group,
@@ -392,4 +379,4 @@ class SyncCogCommandTests(SyncCogTestCase, CommandTestCase):
 
         for cmd in cmds:
             with self.subTest(cmd=cmd):
-                self.assertHasPermissionsCheck(cmd, {"administrator": True})
+                await self.assertHasPermissionsCheck(cmd, {"administrator": True})
diff --git a/tests/bot/cogs/sync/test_roles.py b/tests/bot/cogs/sync/test_roles.py
index 14fb2577a..79eee98f4 100644
--- a/tests/bot/cogs/sync/test_roles.py
+++ b/tests/bot/cogs/sync/test_roles.py
@@ -18,7 +18,7 @@ def fake_role(**kwargs):
     return kwargs
 
 
-class RoleSyncerDiffTests(unittest.TestCase):
+class RoleSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
     """Tests for determining differences between roles in the DB and roles in the Guild cache."""
 
     def setUp(self):
@@ -39,7 +39,6 @@ class RoleSyncerDiffTests(unittest.TestCase):
 
         return guild
 
-    @helpers.async_test
     async def test_empty_diff_for_identical_roles(self):
         """No differences should be found if the roles in the guild and DB are identical."""
         self.bot.api_client.get.return_value = [fake_role()]
@@ -50,7 +49,6 @@ class RoleSyncerDiffTests(unittest.TestCase):
 
         self.assertEqual(actual_diff, expected_diff)
 
-    @helpers.async_test
     async def test_diff_for_updated_roles(self):
         """Only updated roles should be added to the 'updated' set of the diff."""
         updated_role = fake_role(id=41, name="new")
@@ -63,7 +61,6 @@ class RoleSyncerDiffTests(unittest.TestCase):
 
         self.assertEqual(actual_diff, expected_diff)
 
-    @helpers.async_test
     async def test_diff_for_new_roles(self):
         """Only new roles should be added to the 'created' set of the diff."""
         new_role = fake_role(id=41, name="new")
@@ -76,7 +73,6 @@ class RoleSyncerDiffTests(unittest.TestCase):
 
         self.assertEqual(actual_diff, expected_diff)
 
-    @helpers.async_test
     async def test_diff_for_deleted_roles(self):
         """Only deleted roles should be added to the 'deleted' set of the diff."""
         deleted_role = fake_role(id=61, name="deleted")
@@ -89,7 +85,6 @@ class RoleSyncerDiffTests(unittest.TestCase):
 
         self.assertEqual(actual_diff, expected_diff)
 
-    @helpers.async_test
     async def test_diff_for_new_updated_and_deleted_roles(self):
         """When roles are added, updated, and removed, all of them are returned properly."""
         new = fake_role(id=41, name="new")
@@ -109,14 +104,13 @@ class RoleSyncerDiffTests(unittest.TestCase):
         self.assertEqual(actual_diff, expected_diff)
 
 
-class RoleSyncerSyncTests(unittest.TestCase):
+class RoleSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the API requests that sync roles."""
 
     def setUp(self):
         self.bot = helpers.MockBot()
         self.syncer = RoleSyncer(self.bot)
 
-    @helpers.async_test
     async def test_sync_created_roles(self):
         """Only POST requests should be made with the correct payload."""
         roles = [fake_role(id=111), fake_role(id=222)]
@@ -132,7 +126,6 @@ class RoleSyncerSyncTests(unittest.TestCase):
         self.bot.api_client.put.assert_not_called()
         self.bot.api_client.delete.assert_not_called()
 
-    @helpers.async_test
     async def test_sync_updated_roles(self):
         """Only PUT requests should be made with the correct payload."""
         roles = [fake_role(id=111), fake_role(id=222)]
@@ -148,7 +141,6 @@ class RoleSyncerSyncTests(unittest.TestCase):
         self.bot.api_client.post.assert_not_called()
         self.bot.api_client.delete.assert_not_called()
 
-    @helpers.async_test
     async def test_sync_deleted_roles(self):
         """Only DELETE requests should be made with the correct payload."""
         roles = [fake_role(id=111), fake_role(id=222)]
diff --git a/tests/bot/cogs/sync/test_users.py b/tests/bot/cogs/sync/test_users.py
index 421bf6bb6..818883012 100644
--- a/tests/bot/cogs/sync/test_users.py
+++ b/tests/bot/cogs/sync/test_users.py
@@ -17,7 +17,7 @@ def fake_user(**kwargs):
     return kwargs
 
 
-class UserSyncerDiffTests(unittest.TestCase):
+class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
     """Tests for determining differences between users in the DB and users in the Guild cache."""
 
     def setUp(self):
@@ -42,7 +42,6 @@ class UserSyncerDiffTests(unittest.TestCase):
 
         return guild
 
-    @helpers.async_test
     async def test_empty_diff_for_no_users(self):
         """When no users are given, an empty diff should be returned."""
         guild = self.get_guild()
@@ -52,7 +51,6 @@ class UserSyncerDiffTests(unittest.TestCase):
 
         self.assertEqual(actual_diff, expected_diff)
 
-    @helpers.async_test
     async def test_empty_diff_for_identical_users(self):
         """No differences should be found if the users in the guild and DB are identical."""
         self.bot.api_client.get.return_value = [fake_user()]
@@ -63,7 +61,6 @@ class UserSyncerDiffTests(unittest.TestCase):
 
         self.assertEqual(actual_diff, expected_diff)
 
-    @helpers.async_test
     async def test_diff_for_updated_users(self):
         """Only updated users should be added to the 'updated' set of the diff."""
         updated_user = fake_user(id=99, name="new")
@@ -76,7 +73,6 @@ class UserSyncerDiffTests(unittest.TestCase):
 
         self.assertEqual(actual_diff, expected_diff)
 
-    @helpers.async_test
     async def test_diff_for_new_users(self):
         """Only new users should be added to the 'created' set of the diff."""
         new_user = fake_user(id=99, name="new")
@@ -89,7 +85,6 @@ class UserSyncerDiffTests(unittest.TestCase):
 
         self.assertEqual(actual_diff, expected_diff)
 
-    @helpers.async_test
     async def test_diff_sets_in_guild_false_for_leaving_users(self):
         """When a user leaves the guild, the `in_guild` flag is updated to `False`."""
         leaving_user = fake_user(id=63, in_guild=False)
@@ -102,7 +97,6 @@ class UserSyncerDiffTests(unittest.TestCase):
 
         self.assertEqual(actual_diff, expected_diff)
 
-    @helpers.async_test
     async def test_diff_for_new_updated_and_leaving_users(self):
         """When users are added, updated, and removed, all of them are returned properly."""
         new_user = fake_user(id=99, name="new")
@@ -117,7 +111,6 @@ class UserSyncerDiffTests(unittest.TestCase):
 
         self.assertEqual(actual_diff, expected_diff)
 
-    @helpers.async_test
     async def test_empty_diff_for_db_users_not_in_guild(self):
         """When the DB knows a user the guild doesn't, no difference is found."""
         self.bot.api_client.get.return_value = [fake_user(), fake_user(id=63, in_guild=False)]
@@ -129,14 +122,13 @@ class UserSyncerDiffTests(unittest.TestCase):
         self.assertEqual(actual_diff, expected_diff)
 
 
-class UserSyncerSyncTests(unittest.TestCase):
+class UserSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
     """Tests for the API requests that sync users."""
 
     def setUp(self):
         self.bot = helpers.MockBot()
         self.syncer = UserSyncer(self.bot)
 
-    @helpers.async_test
     async def test_sync_created_users(self):
         """Only POST requests should be made with the correct payload."""
         users = [fake_user(id=111), fake_user(id=222)]
@@ -152,7 +144,6 @@ class UserSyncerSyncTests(unittest.TestCase):
         self.bot.api_client.put.assert_not_called()
         self.bot.api_client.delete.assert_not_called()
 
-    @helpers.async_test
     async def test_sync_updated_users(self):
         """Only PUT requests should be made with the correct payload."""
         users = [fake_user(id=111), fake_user(id=222)]
diff --git a/tests/helpers.py b/tests/helpers.py
index 7ae7ed621..8e13f0f28 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -261,9 +261,7 @@ class MockAPIClient(CustomMockMixin, unittest.mock.MagicMock):
     Instances of this class will follow the specifications of `bot.api.APIClient` instances.
     For more information, see the `MockGuild` docstring.
     """
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(spec_set=APIClient, **kwargs)
+    spec_set = APIClient
 
 
 # Create a Bot instance to get a realistic MagicMock of `discord.ext.commands.Bot`
-- 
cgit v1.2.3