Sync tests: use async_test decorator

4 files changed, 135 insertions, 94 deletions

diff --git a/tests/bot/cogs/sync/test_base.py b/tests/bot/cogs/sync/test_base.py
index ff11d911e..0539f5683 100644
--- a/tests/bot/cogs/sync/test_base.py
+++ b/tests/bot/cogs/sync/test_base.py
@@ -1,4 +1,3 @@
-import asyncio
 import unittest
 from unittest import mock
 
@@ -62,16 +61,18 @@ class SyncerSendPromptTests(unittest.TestCase):
 
         return mock_channel, mock_message
 
-    def test_send_prompt_edits_and_returns_message(self):
+    @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()
-        ret_val = asyncio.run(self.syncer._send_prompt(msg))
+        ret_val = await self.syncer._send_prompt(msg)
 
         msg.edit.assert_called_once()
         self.assertIn("content", msg.edit.call_args[1])
         self.assertEqual(ret_val, msg)
 
-    def test_send_prompt_gets_dev_core_channel(self):
+    @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 = (
             (self.bot.get_channel, self.mock_get_channel),
@@ -81,31 +82,34 @@ class SyncerSendPromptTests(unittest.TestCase):
         for method, mock_ in subtests:
             with self.subTest(method=method, msg=mock_.__name__):
                 mock_()
-                asyncio.run(self.syncer._send_prompt())
+                await self.syncer._send_prompt()
 
                 method.assert_called_once_with(constants.Channels.devcore)
 
-    def test_send_prompt_returns_None_if_channel_fetch_fails(self):
+    @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
         self.bot.fetch_channel.side_effect = discord.HTTPException(mock.MagicMock(), "test error!")
 
-        ret_val = asyncio.run(self.syncer._send_prompt())
+        ret_val = await self.syncer._send_prompt()
 
         self.assertIsNone(ret_val)
 
-    def test_send_prompt_sends_and_returns_new_message_if_not_given(self):
+    @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):
             with self.subTest(msg=mock_.__name__):
                 mock_channel, mock_message = mock_()
-                ret_val = asyncio.run(self.syncer._send_prompt())
+                ret_val = await self.syncer._send_prompt()
 
                 mock_channel.send.assert_called_once()
                 self.assertIn(self.syncer._CORE_DEV_MENTION, mock_channel.send.call_args[0][0])
                 self.assertEqual(ret_val, mock_message)
 
-    def test_send_prompt_adds_reactions(self):
+    @helpers.async_test
+    async def test_send_prompt_adds_reactions(self):
         """The message should have reactions for confirmation added."""
         extant_message = helpers.MockMessage()
         subtests = (
@@ -119,7 +123,7 @@ class SyncerSendPromptTests(unittest.TestCase):
 
             with self.subTest(msg=subtest_msg):
                 _, mock_message = mock_()
-                asyncio.run(self.syncer._send_prompt(message_arg))
+                await self.syncer._send_prompt(message_arg)
 
                 calls = [mock.call(emoji) for emoji in self.syncer._REACTION_EMOJIS]
                 mock_message.add_reaction.assert_has_calls(calls)
@@ -207,7 +211,8 @@ class SyncerConfirmationTests(unittest.TestCase):
                 ret_val = self.syncer._reaction_check(*args)
                 self.assertFalse(ret_val)
 
-    def test_wait_for_confirmation(self):
+    @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 = (
             (constants.Emojis.check_mark, True, None),
@@ -227,7 +232,7 @@ class SyncerConfirmationTests(unittest.TestCase):
                     self.bot.wait_for.side_effect = side_effect
 
                     # Call the function
-                    actual_return = asyncio.run(self.syncer._wait_for_confirmation(member, message))
+                    actual_return = await self.syncer._wait_for_confirmation(member, message)
 
                     # Perform assertions
                     self.bot.wait_for.assert_called_once()
@@ -253,7 +258,8 @@ class SyncerSyncTests(unittest.TestCase):
         self.bot = helpers.MockBot(user=helpers.MockMember(bot=True))
         self.syncer = TestSyncer(self.bot)
 
-    def test_sync_respects_confirmation_result(self):
+    @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()
         subtests = (
@@ -273,7 +279,7 @@ class SyncerSyncTests(unittest.TestCase):
                 )
 
                 guild = helpers.MockGuild()
-                asyncio.run(self.syncer.sync(guild))
+                await self.syncer.sync(guild)
 
                 self.syncer._get_diff.assert_called_once_with(guild)
                 self.syncer._get_confirmation_result.assert_called_once()
@@ -283,7 +289,8 @@ class SyncerSyncTests(unittest.TestCase):
                 else:
                     self.syncer._sync.assert_not_called()
 
-    def test_sync_diff_size(self):
+    @helpers.async_test
+    async def test_sync_diff_size(self):
         """The diff size should be correctly calculated."""
         subtests = (
             (6, _Diff({1, 2}, {3, 4}, {5, 6})),
@@ -299,13 +306,14 @@ class SyncerSyncTests(unittest.TestCase):
                 self.syncer._get_confirmation_result = helpers.AsyncMock(return_value=(False, None))
 
                 guild = helpers.MockGuild()
-                asyncio.run(self.syncer.sync(guild))
+                await self.syncer.sync(guild)
 
                 self.syncer._get_diff.assert_called_once_with(guild)
                 self.syncer._get_confirmation_result.assert_called_once()
                 self.assertEqual(self.syncer._get_confirmation_result.call_args[0][0], size)
 
-    def test_sync_message_edited(self):
+    @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 = (
             (None, None, False),
@@ -321,13 +329,14 @@ class SyncerSyncTests(unittest.TestCase):
                 )
 
                 guild = helpers.MockGuild()
-                asyncio.run(self.syncer.sync(guild))
+                await self.syncer.sync(guild)
 
                 if should_edit:
                     message.edit.assert_called_once()
                     self.assertIn("content", message.edit.call_args[1])
 
-    def test_sync_confirmation_context_redirect(self):
+    @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()
         subtests = (
@@ -343,7 +352,7 @@ class SyncerSyncTests(unittest.TestCase):
                 self.syncer._get_confirmation_result = helpers.AsyncMock(return_value=(False, None))
 
                 guild = helpers.MockGuild()
-                asyncio.run(self.syncer.sync(guild, ctx))
+                await self.syncer.sync(guild, ctx)
 
                 if ctx is not None:
                     ctx.send.assert_called_once()
@@ -352,7 +361,8 @@ class SyncerSyncTests(unittest.TestCase):
                 self.assertEqual(self.syncer._get_confirmation_result.call_args[0][1], author)
                 self.assertEqual(self.syncer._get_confirmation_result.call_args[0][2], message)
 
-    def test_confirmation_result_small_diff(self):
+    @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."""
         self.syncer.MAX_DIFF = 3
         author = helpers.MockMember()
@@ -364,14 +374,15 @@ class SyncerSyncTests(unittest.TestCase):
                 self.syncer._wait_for_confirmation = helpers.AsyncMock()
 
                 coro = self.syncer._get_confirmation_result(size, author, expected_message)
-                result, actual_message = asyncio.run(coro)
+                result, actual_message = await coro
 
                 self.assertTrue(result)
                 self.assertEqual(actual_message, expected_message)
                 self.syncer._send_prompt.assert_not_called()
                 self.syncer._wait_for_confirmation.assert_not_called()
 
-    def test_confirmation_result_large_diff(self):
+    @helpers.async_test
+    async def test_confirmation_result_large_diff(self):
         """Should return True if confirmed and False if _send_prompt fails or aborted."""
         self.syncer.MAX_DIFF = 3
         author = helpers.MockMember()
@@ -389,7 +400,7 @@ class SyncerSyncTests(unittest.TestCase):
                 self.syncer._wait_for_confirmation = helpers.AsyncMock(return_value=confirmed)
 
                 coro = self.syncer._get_confirmation_result(4, author)
-                actual_result, actual_message = asyncio.run(coro)
+                actual_result, actual_message = await coro
 
                 self.syncer._send_prompt.assert_called_once_with(None)  # message defaults to None
                 self.assertIs(actual_result, expected_result)
diff --git a/tests/bot/cogs/sync/test_cog.py b/tests/bot/cogs/sync/test_cog.py
index f66adfea1..98c9afc0d 100644
--- a/tests/bot/cogs/sync/test_cog.py
+++ b/tests/bot/cogs/sync/test_cog.py
@@ -1,4 +1,3 @@
-import asyncio
 import unittest
 from unittest import mock
 
@@ -91,7 +90,8 @@ class SyncCogTests(SyncCogTestCase):
         sync_guild.assert_called_once_with()
         self.bot.loop.create_task.assert_called_once_with(mock_sync_guild_coro)
 
-    def test_sync_cog_sync_guild(self):
+    @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):
             with self.subTest(guild=guild):
@@ -101,7 +101,7 @@ class SyncCogTests(SyncCogTestCase):
 
                 self.bot.get_guild = mock.MagicMock(return_value=guild)
 
-                asyncio.run(self.cog.sync_guild())
+                await self.cog.sync_guild()
 
                 self.bot.wait_until_guild_available.assert_called_once()
                 self.bot.get_guild.assert_called_once_with(constants.Guild.id)
@@ -113,29 +113,31 @@ class SyncCogTests(SyncCogTestCase):
                     self.cog.role_syncer.sync.assert_called_once_with(guild)
                     self.cog.user_syncer.sync.assert_called_once_with(guild)
 
-    def patch_user_helper(self, side_effect: BaseException) -> None:
+    async def patch_user_helper(self, side_effect: BaseException) -> None:
         """Helper to set a side effect for bot.api_client.patch and then assert it is called."""
         self.bot.api_client.patch.reset_mock(side_effect=True)
         self.bot.api_client.patch.side_effect = side_effect
 
         user_id, updated_information = 5, {"key": 123}
-        asyncio.run(self.cog.patch_user(user_id, updated_information))
+        await self.cog.patch_user(user_id, updated_information)
 
         self.bot.api_client.patch.assert_called_once_with(
             f"bot/users/{user_id}",
             json=updated_information,
         )
 
-    def test_sync_cog_patch_user(self):
+    @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):
-                self.patch_user_helper(side_effect)
+                await self.patch_user_helper(side_effect)
 
-    def test_sync_cog_patch_user_non_404(self):
+    @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):
-            self.patch_user_helper(self.response_error(500))
+            await self.patch_user_helper(self.response_error(500))
 
 
 class SyncCogListenerTests(SyncCogTestCase):
@@ -145,7 +147,8 @@ class SyncCogListenerTests(SyncCogTestCase):
         super().setUp()
         self.cog.patch_user = helpers.AsyncMock(spec_set=self.cog.patch_user)
 
-    def test_sync_cog_on_guild_role_create(self):
+    @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__)
 
@@ -157,20 +160,22 @@ class SyncCogListenerTests(SyncCogTestCase):
             "position": 23,
         }
         role = helpers.MockRole(**role_data)
-        asyncio.run(self.cog.on_guild_role_create(role))
+        await self.cog.on_guild_role_create(role)
 
         self.bot.api_client.post.assert_called_once_with("bot/roles", json=role_data)
 
-    def test_sync_cog_on_guild_role_delete(self):
+    @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__)
 
         role = helpers.MockRole(id=99)
-        asyncio.run(self.cog.on_guild_role_delete(role))
+        await self.cog.on_guild_role_delete(role)
 
         self.bot.api_client.delete.assert_called_once_with("bot/roles/99")
 
-    def test_sync_cog_on_guild_role_update(self):
+    @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__)
 
@@ -197,7 +202,7 @@ class SyncCogListenerTests(SyncCogTestCase):
                     before_role = helpers.MockRole(**role_data)
                     after_role = helpers.MockRole(**after_role_data)
 
-                    asyncio.run(self.cog.on_guild_role_update(before_role, after_role))
+                    await self.cog.on_guild_role_update(before_role, after_role)
 
                     if should_put:
                         self.bot.api_client.put.assert_called_once_with(
@@ -207,19 +212,21 @@ class SyncCogListenerTests(SyncCogTestCase):
                     else:
                         self.bot.api_client.put.assert_not_called()
 
-    def test_sync_cog_on_member_remove(self):
+    @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__)
 
         member = helpers.MockMember()
-        asyncio.run(self.cog.on_member_remove(member))
+        await self.cog.on_member_remove(member)
 
         self.cog.patch_user.assert_called_once_with(
             member.id,
             updated_information={"in_guild": False}
         )
 
-    def test_sync_cog_on_member_update_roles(self):
+    @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__)
 
@@ -228,12 +235,13 @@ class SyncCogListenerTests(SyncCogTestCase):
         before_member = helpers.MockMember(roles=before_roles)
         after_member = helpers.MockMember(roles=before_roles[1:])
 
-        asyncio.run(self.cog.on_member_update(before_member, after_member))
+        await self.cog.on_member_update(before_member, after_member)
 
         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)
 
-    def test_sync_cog_on_member_update_other(self):
+    @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__)
 
@@ -250,11 +258,12 @@ class SyncCogListenerTests(SyncCogTestCase):
                 before_member = helpers.MockMember(**{attribute: old_value})
                 after_member = helpers.MockMember(**{attribute: new_value})
 
-                asyncio.run(self.cog.on_member_update(before_member, after_member))
+                await self.cog.on_member_update(before_member, after_member)
 
                 self.cog.patch_user.assert_not_called()
 
-    def test_sync_cog_on_user_update(self):
+    @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__)
 
@@ -281,7 +290,7 @@ class SyncCogListenerTests(SyncCogTestCase):
                 before_user = helpers.MockUser(**before_data)
                 after_user = helpers.MockUser(**after_data)
 
-                asyncio.run(self.cog.on_user_update(before_user, after_user))
+                await self.cog.on_user_update(before_user, after_user)
 
                 if should_patch:
                     self.cog.patch_user.assert_called_once()
@@ -297,7 +306,7 @@ class SyncCogListenerTests(SyncCogTestCase):
                 else:
                     self.cog.patch_user.assert_not_called()
 
-    def on_member_join_helper(self, side_effect: Exception) -> dict:
+    async def on_member_join_helper(self, side_effect: Exception) -> dict:
         """
         Helper to set `side_effect` for on_member_join and assert a PUT request was sent.
 
@@ -321,7 +330,7 @@ class SyncCogListenerTests(SyncCogTestCase):
         self.bot.api_client.put.side_effect = side_effect
 
         try:
-            asyncio.run(self.cog.on_member_join(member))
+            await self.cog.on_member_join(member)
         except Exception:
             raise
         finally:
@@ -332,38 +341,44 @@ class SyncCogListenerTests(SyncCogTestCase):
 
         return data
 
-    def test_sync_cog_on_member_join(self):
+    @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)):
             with self.subTest(side_effect=side_effect):
                 self.bot.api_client.post.reset_mock()
-                data = self.on_member_join_helper(side_effect)
+                data = await self.on_member_join_helper(side_effect)
 
                 if side_effect:
                     self.bot.api_client.post.assert_called_once_with("bot/users", json=data)
                 else:
                     self.bot.api_client.post.assert_not_called()
 
-    def test_sync_cog_on_member_join_non_404(self):
+    @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."""
-        self.assertRaises(ResponseCodeError, self.on_member_join_helper, self.response_error(500))
+        with self.assertRaises(ResponseCodeError):
+            await self.on_member_join_helper(self.response_error(500))
+
         self.bot.api_client.post.assert_not_called()
 
 
 class SyncCogCommandTests(SyncCogTestCase, CommandTestCase):
     """Tests for the commands in the Sync cog."""
 
-    def test_sync_roles_command(self):
+    @helpers.async_test
+    async def test_sync_roles_command(self):
         """sync() should be called on the RoleSyncer."""
         ctx = helpers.MockContext()
-        asyncio.run(self.cog.sync_roles_command.callback(self.cog, ctx))
+        await self.cog.sync_roles_command.callback(self.cog, ctx)
 
         self.cog.role_syncer.sync.assert_called_once_with(ctx.guild, ctx)
 
-    def test_sync_users_command(self):
+    @helpers.async_test
+    async def test_sync_users_command(self):
         """sync() should be called on the UserSyncer."""
         ctx = helpers.MockContext()
-        asyncio.run(self.cog.sync_users_command.callback(self.cog, ctx))
+        await self.cog.sync_users_command.callback(self.cog, ctx)
 
         self.cog.user_syncer.sync.assert_called_once_with(ctx.guild, ctx)
 
diff --git a/tests/bot/cogs/sync/test_roles.py b/tests/bot/cogs/sync/test_roles.py
index 8324b99cd..14fb2577a 100644
--- a/tests/bot/cogs/sync/test_roles.py
+++ b/tests/bot/cogs/sync/test_roles.py
@@ -1,4 +1,3 @@
-import asyncio
 import unittest
 from unittest import mock
 
@@ -40,53 +39,58 @@ class RoleSyncerDiffTests(unittest.TestCase):
 
         return guild
 
-    def test_empty_diff_for_identical_roles(self):
+    @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()]
         guild = self.get_guild(fake_role())
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = (set(), set(), set())
 
         self.assertEqual(actual_diff, expected_diff)
 
-    def test_diff_for_updated_roles(self):
+    @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")
 
         self.bot.api_client.get.return_value = [fake_role(id=41, name="old"), fake_role()]
         guild = self.get_guild(updated_role, fake_role())
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = (set(), {_Role(**updated_role)}, set())
 
         self.assertEqual(actual_diff, expected_diff)
 
-    def test_diff_for_new_roles(self):
+    @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")
 
         self.bot.api_client.get.return_value = [fake_role()]
         guild = self.get_guild(fake_role(), new_role)
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = ({_Role(**new_role)}, set(), set())
 
         self.assertEqual(actual_diff, expected_diff)
 
-    def test_diff_for_deleted_roles(self):
+    @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")
 
         self.bot.api_client.get.return_value = [fake_role(), deleted_role]
         guild = self.get_guild(fake_role())
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = (set(), set(), {_Role(**deleted_role)})
 
         self.assertEqual(actual_diff, expected_diff)
 
-    def test_diff_for_new_updated_and_deleted_roles(self):
+    @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")
         updated = fake_role(id=71, name="updated")
@@ -99,7 +103,7 @@ class RoleSyncerDiffTests(unittest.TestCase):
         ]
         guild = self.get_guild(fake_role(), new, updated)
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = ({_Role(**new)}, {_Role(**updated)}, {_Role(**deleted)})
 
         self.assertEqual(actual_diff, expected_diff)
@@ -112,13 +116,14 @@ class RoleSyncerSyncTests(unittest.TestCase):
         self.bot = helpers.MockBot()
         self.syncer = RoleSyncer(self.bot)
 
-    def test_sync_created_roles(self):
+    @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)]
 
         role_tuples = {_Role(**role) for role in roles}
         diff = _Diff(role_tuples, set(), set())
-        asyncio.run(self.syncer._sync(diff))
+        await self.syncer._sync(diff)
 
         calls = [mock.call("bot/roles", json=role) for role in roles]
         self.bot.api_client.post.assert_has_calls(calls, any_order=True)
@@ -127,13 +132,14 @@ class RoleSyncerSyncTests(unittest.TestCase):
         self.bot.api_client.put.assert_not_called()
         self.bot.api_client.delete.assert_not_called()
 
-    def test_sync_updated_roles(self):
+    @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)]
 
         role_tuples = {_Role(**role) for role in roles}
         diff = _Diff(set(), role_tuples, set())
-        asyncio.run(self.syncer._sync(diff))
+        await self.syncer._sync(diff)
 
         calls = [mock.call(f"bot/roles/{role['id']}", json=role) for role in roles]
         self.bot.api_client.put.assert_has_calls(calls, any_order=True)
@@ -142,13 +148,14 @@ class RoleSyncerSyncTests(unittest.TestCase):
         self.bot.api_client.post.assert_not_called()
         self.bot.api_client.delete.assert_not_called()
 
-    def test_sync_deleted_roles(self):
+    @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)]
 
         role_tuples = {_Role(**role) for role in roles}
         diff = _Diff(set(), set(), role_tuples)
-        asyncio.run(self.syncer._sync(diff))
+        await self.syncer._sync(diff)
 
         calls = [mock.call(f"bot/roles/{role['id']}") for role in roles]
         self.bot.api_client.delete.assert_has_calls(calls, any_order=True)
diff --git a/tests/bot/cogs/sync/test_users.py b/tests/bot/cogs/sync/test_users.py
index e9f9db2ea..421bf6bb6 100644
--- a/tests/bot/cogs/sync/test_users.py
+++ b/tests/bot/cogs/sync/test_users.py
@@ -1,4 +1,3 @@
-import asyncio
 import unittest
 from unittest import mock
 
@@ -43,62 +42,68 @@ class UserSyncerDiffTests(unittest.TestCase):
 
         return guild
 
-    def test_empty_diff_for_no_users(self):
+    @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()
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = (set(), set(), None)
 
         self.assertEqual(actual_diff, expected_diff)
 
-    def test_empty_diff_for_identical_users(self):
+    @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()]
         guild = self.get_guild(fake_user())
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = (set(), set(), None)
 
         self.assertEqual(actual_diff, expected_diff)
 
-    def test_diff_for_updated_users(self):
+    @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")
 
         self.bot.api_client.get.return_value = [fake_user(id=99, name="old"), fake_user()]
         guild = self.get_guild(updated_user, fake_user())
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = (set(), {_User(**updated_user)}, None)
 
         self.assertEqual(actual_diff, expected_diff)
 
-    def test_diff_for_new_users(self):
+    @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")
 
         self.bot.api_client.get.return_value = [fake_user()]
         guild = self.get_guild(fake_user(), new_user)
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = ({_User(**new_user)}, set(), None)
 
         self.assertEqual(actual_diff, expected_diff)
 
-    def test_diff_sets_in_guild_false_for_leaving_users(self):
+    @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)
 
         self.bot.api_client.get.return_value = [fake_user(), fake_user(id=63)]
         guild = self.get_guild(fake_user())
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = (set(), {_User(**leaving_user)}, None)
 
         self.assertEqual(actual_diff, expected_diff)
 
-    def test_diff_for_new_updated_and_leaving_users(self):
+    @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")
         updated_user = fake_user(id=55, name="updated")
@@ -107,17 +112,18 @@ class UserSyncerDiffTests(unittest.TestCase):
         self.bot.api_client.get.return_value = [fake_user(), fake_user(id=55), fake_user(id=63)]
         guild = self.get_guild(fake_user(), new_user, updated_user)
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = ({_User(**new_user)}, {_User(**updated_user), _User(**leaving_user)}, None)
 
         self.assertEqual(actual_diff, expected_diff)
 
-    def test_empty_diff_for_db_users_not_in_guild(self):
+    @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)]
         guild = self.get_guild(fake_user())
 
-        actual_diff = asyncio.run(self.syncer._get_diff(guild))
+        actual_diff = await self.syncer._get_diff(guild)
         expected_diff = (set(), set(), None)
 
         self.assertEqual(actual_diff, expected_diff)
@@ -130,13 +136,14 @@ class UserSyncerSyncTests(unittest.TestCase):
         self.bot = helpers.MockBot()
         self.syncer = UserSyncer(self.bot)
 
-    def test_sync_created_users(self):
+    @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)]
 
         user_tuples = {_User(**user) for user in users}
         diff = _Diff(user_tuples, set(), None)
-        asyncio.run(self.syncer._sync(diff))
+        await self.syncer._sync(diff)
 
         calls = [mock.call("bot/users", json=user) for user in users]
         self.bot.api_client.post.assert_has_calls(calls, any_order=True)
@@ -145,13 +152,14 @@ class UserSyncerSyncTests(unittest.TestCase):
         self.bot.api_client.put.assert_not_called()
         self.bot.api_client.delete.assert_not_called()
 
-    def test_sync_updated_users(self):
+    @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)]
 
         user_tuples = {_User(**user) for user in users}
         diff = _Diff(set(), user_tuples, None)
-        asyncio.run(self.syncer._sync(diff))
+        await self.syncer._sync(diff)
 
         calls = [mock.call(f"bot/users/{user['id']}", json=user) for user in users]
         self.bot.api_client.put.assert_has_calls(calls, any_order=True)