Refactor tests to use updated changes to syncer.py and API.

1 files changed, 59 insertions, 58 deletions

diff --git a/tests/bot/exts/backend/sync/test_users.py b/tests/bot/exts/backend/sync/test_users.py
index c3a486743..9f380a15d 100644
--- a/tests/bot/exts/backend/sync/test_users.py
+++ b/tests/bot/exts/backend/sync/test_users.py
@@ -1,6 +1,6 @@
 import unittest
 
-from bot.exts.backend.sync._syncers import UserSyncer, _Diff, _User
+from bot.exts.backend.sync._syncers import UserSyncer, _Diff
 from tests import helpers
 
 
@@ -9,22 +9,12 @@ def fake_user(**kwargs):
     kwargs.setdefault("id", 43)
     kwargs.setdefault("name", "bob the test man")
     kwargs.setdefault("discriminator", 1337)
-    kwargs.setdefault("roles", (666,))
+    kwargs.setdefault("roles", [666])
     kwargs.setdefault("in_guild", True)
 
     return kwargs
 
 
-def fake_none_user(**kwargs):
-    kwargs.setdefault("id", None)
-    kwargs.setdefault("name", None)
-    kwargs.setdefault("discriminator", None)
-    kwargs.setdefault("roles", None)
-    kwargs.setdefault("in_guild", None)
-
-    return kwargs
-
-
 class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
     """Tests for determining differences between users in the DB and users in the Guild cache."""
 
@@ -49,18 +39,26 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
 
         return guild
 
+    @staticmethod
+    def get_mock_member(member: dict):
+        member = member.copy()
+        del member["in_guild"]
+        mock_member = helpers.MockMember(**member)
+        mock_member.roles = [helpers.MockRole(id=role_id) for role_id in member["roles"]]
+        return mock_member
+
     async def test_empty_diff_for_no_users(self):
         """When no users are given, an empty diff should be returned."""
         self.bot.api_client.get.return_value = {
             "count": 3,
-            "next": None,
-            "previous": None,
+            "next_page_no": None,
+            "previous_page_no": None,
             "results": []
         }
         guild = self.get_guild()
 
         actual_diff = await self.syncer._get_diff(guild)
-        expected_diff = (set(), set(), None)
+        expected_diff = ([], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
 
@@ -68,66 +66,75 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         """No differences should be found if the users in the guild and DB are identical."""
         self.bot.api_client.get.return_value = {
             "count": 3,
-            "next": None,
-            "previous": None,
+            "next_page_no": None,
+            "previous_page_no": None,
             "results": [fake_user()]
         }
         guild = self.get_guild(fake_user())
 
+        guild.get_member.return_value = self.get_mock_member(fake_user())
         actual_diff = await self.syncer._get_diff(guild)
-        expected_diff = (set(), set(), None)
+        expected_diff = ([], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
 
     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")
-        updated_user_none = fake_none_user(id=99, name="new")
 
         self.bot.api_client.get.return_value = {
             "count": 3,
-            "next": None,
-            "previous": None,
+            "next_page_no": None,
+            "previous_page_no": None,
             "results": [fake_user(id=99, name="old"), fake_user()]
         }
         guild = self.get_guild(updated_user, fake_user())
+        guild.get_member.side_effect = [
+            self.get_mock_member(updated_user),
+            self.get_mock_member(fake_user())
+        ]
 
         actual_diff = await self.syncer._get_diff(guild)
-        expected_diff = (set(), {_User(**updated_user_none)}, None)
+        expected_diff = ([], [{"id": 99, "name": "new"}], None)
 
         self.assertEqual(actual_diff, expected_diff)
 
     async def test_diff_for_new_users(self):
-        """Only new users should be added to the 'created' set of the diff."""
+        """Only new users should be added to the 'created' list of the diff."""
         new_user = fake_user(id=99, name="new")
 
         self.bot.api_client.get.return_value = {
             "count": 3,
-            "next": None,
-            "previous": None,
+            "next_page_no": None,
+            "previous_page_no": None,
             "results": [fake_user()]
         }
         guild = self.get_guild(fake_user(), new_user)
-
+        guild.get_member.side_effect = [
+            self.get_mock_member(fake_user()),
+            self.get_mock_member(new_user)
+        ]
         actual_diff = await self.syncer._get_diff(guild)
-        expected_diff = ({_User(**new_user)}, set(), None)
+        expected_diff = ([new_user], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
 
     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_none = fake_none_user(id=63, in_guild=False)
-
         self.bot.api_client.get.return_value = {
             "count": 3,
-            "next": None,
-            "previous": None,
+            "next_page_no": None,
+            "previous_page_no": None,
             "results": [fake_user(), fake_user(id=63)]
         }
         guild = self.get_guild(fake_user())
+        guild.get_member.side_effect = [
+            self.get_mock_member(fake_user()),
+            None
+        ]
 
         actual_diff = await self.syncer._get_diff(guild)
-        expected_diff = (set(), {_User(**leaving_user_none)}, None)
+        expected_diff = ([], [{"id": 63, "in_guild": False}], None)
 
         self.assertEqual(actual_diff, expected_diff)
 
@@ -136,42 +143,41 @@ class UserSyncerDiffTests(unittest.IsolatedAsyncioTestCase):
         new_user = fake_user(id=99, name="new")
 
         updated_user = fake_user(id=55, name="updated")
-        updated_user_none = fake_none_user(id=55, name="updated")
-
-        leaving_user_none = fake_none_user(id=63, in_guild=False)
 
         self.bot.api_client.get.return_value = {
             "count": 3,
-            "next": None,
-            "previous": None,
+            "next_page_no": None,
+            "previous_page_no": None,
             "results": [fake_user(), fake_user(id=55), fake_user(id=63)]
         }
         guild = self.get_guild(fake_user(), new_user, updated_user)
+        guild.get_member.side_effect = [
+            self.get_mock_member(fake_user()),
+            self.get_mock_member(updated_user),
+            None
+        ]
 
         actual_diff = await self.syncer._get_diff(guild)
-        expected_diff = (
-            {_User(**new_user)},
-            {
-                _User(**updated_user_none),
-                _User(**leaving_user_none)
-            },
-            None
-        )
+        expected_diff = ([new_user], [{"id": 55, "name": "updated"}, {"id": 63, "in_guild": False}], None)
 
         self.assertEqual(actual_diff, expected_diff)
 
     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."""
+        """When the DB knows a user, but the guild doesn't, no difference is found."""
         self.bot.api_client.get.return_value = {
             "count": 3,
-            "next": None,
-            "previous": None,
+            "next_page_no": None,
+            "previous_page_no": None,
             "results": [fake_user(), fake_user(id=63, in_guild=False)]
         }
         guild = self.get_guild(fake_user())
+        guild.get_member.side_effect = [
+            self.get_mock_member(fake_user()),
+            None
+        ]
 
         actual_diff = await self.syncer._get_diff(guild)
-        expected_diff = (set(), set(), None)
+        expected_diff = ([], [], None)
 
         self.assertEqual(actual_diff, expected_diff)
 
@@ -187,13 +193,10 @@ class UserSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
         """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)
+        diff = _Diff(users, [], None)
         await self.syncer._sync(diff)
 
-        # Convert namedtuples to dicts as done in self.syncer._sync method.
-        created = [user._asdict() for user in diff.created]
-        self.bot.api_client.post.assert_called_once_with("bot/users", json=created)
+        self.bot.api_client.post.assert_called_once_with("bot/users", json=diff.created)
 
         self.bot.api_client.put.assert_not_called()
         self.bot.api_client.delete.assert_not_called()
@@ -202,12 +205,10 @@ class UserSyncerSyncTests(unittest.IsolatedAsyncioTestCase):
         """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)
+        diff = _Diff([], users, None)
         await self.syncer._sync(diff)
 
-        updated = [self.syncer.patch_dict(user) for user in diff.updated]
-        self.bot.api_client.patch.assert_called_once_with("bot/users/bulk_patch", json=updated)
+        self.bot.api_client.patch.assert_called_once_with("bot/users/bulk_patch", json=diff.updated)
 
         self.bot.api_client.post.assert_not_called()
         self.bot.api_client.delete.assert_not_called()