Merge branch 'main' into content/update-help-channel-timing

3 files changed, 157 insertions, 28 deletions

diff --git a/pydis_site/apps/api/tests/test_off_topic_channel_names.py b/pydis_site/apps/api/tests/test_off_topic_channel_names.py
index 1825f6e6..34098c92 100644
--- a/pydis_site/apps/api/tests/test_off_topic_channel_names.py
+++ b/pydis_site/apps/api/tests/test_off_topic_channel_names.py
@@ -65,8 +65,18 @@ class EmptyDatabaseTests(AuthenticatedAPITestCase):
 class ListTests(AuthenticatedAPITestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.test_name = OffTopicChannelName.objects.create(name='lemons-lemonade-stand', used=False)
-        cls.test_name_2 = OffTopicChannelName.objects.create(name='bbq-with-bisk', used=True)
+        cls.test_name = OffTopicChannelName.objects.create(
+            name='lemons-lemonade-stand', used=False, active=True
+        )
+        cls.test_name_2 = OffTopicChannelName.objects.create(
+            name='bbq-with-bisk', used=False, active=True
+        )
+        cls.test_name_3 = OffTopicChannelName.objects.create(
+            name="frozen-with-iceman", used=True, active=False
+        )
+        cls.test_name_4 = OffTopicChannelName.objects.create(
+            name="xith-is-cool", used=True, active=True
+        )
 
     def test_returns_name_in_list(self):
         """Return all off-topic channel names."""
@@ -75,29 +85,73 @@ class ListTests(AuthenticatedAPITestCase):
 
         self.assertEqual(response.status_code, 200)
         self.assertEqual(
-            response.json(),
-            [
+            set(response.json()),
+            {
                 self.test_name.name,
-                self.test_name_2.name
-            ]
+                self.test_name_2.name,
+                self.test_name_3.name,
+                self.test_name_4.name
+            }
         )
 
-    def test_returns_single_item_with_random_items_param_set_to_1(self):
-        """Return not-used name instead used."""
+    def test_returns_two_active_items_with_random_items_param_set_to_2(self):
+        """Return not-used active names instead used."""
         url = reverse('api:bot:offtopicchannelname-list')
-        response = self.client.get(f'{url}?random_items=1')
+        response = self.client.get(f'{url}?random_items=2')
 
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(len(response.json()), 1)
-        self.assertEqual(response.json(), [self.test_name.name])
+        self.assertEqual(len(response.json()), 2)
+        self.assertTrue(
+            all(
+                item in (self.test_name.name, self.test_name_2.name, self.test_name_4.name)
+                for item in response.json()
+            )
+        )
+
+    def test_returns_three_active_items_with_random_items_param_set_to_3(self):
+        """Return not-used active names instead used."""
+        url = reverse('api:bot:offtopicchannelname-list')
+        response = self.client.get(f'{url}?random_items=3')
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(len(response.json()), 3)
+        self.assertEqual(
+            set(response.json()),
+            {self.test_name.name, self.test_name_2.name, self.test_name_4.name}
+        )
 
     def test_running_out_of_names_with_random_parameter(self):
-        """Reset names `used` parameter to `False` when running out of names."""
+        """Reset names `used` parameter to `False` when running out of active names."""
         url = reverse('api:bot:offtopicchannelname-list')
-        response = self.client.get(f'{url}?random_items=2')
+        response = self.client.get(f'{url}?random_items=3')
 
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.json(), [self.test_name.name, self.test_name_2.name])
+        self.assertEqual(
+            set(response.json()),
+            {self.test_name.name, self.test_name_2.name, self.test_name_4.name}
+        )
+
+    def test_returns_inactive_ot_names(self):
+        """Return inactive off topic names."""
+        url = reverse('api:bot:offtopicchannelname-list')
+        response = self.client.get(f"{url}?active=false")
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            response.json(),
+            [self.test_name_3.name]
+        )
+
+    def test_returns_active_ot_names(self):
+        """Return active off topic names."""
+        url = reverse('api:bot:offtopicchannelname-list')
+        response = self.client.get(f"{url}?active=true")
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            set(response.json()),
+            {self.test_name.name, self.test_name_2.name, self.test_name_4.name}
+        )
 
 
 class CreationTests(AuthenticatedAPITestCase):
diff --git a/pydis_site/apps/api/tests/test_roles.py b/pydis_site/apps/api/tests/test_roles.py
index d39cea4d..73c80c77 100644
--- a/pydis_site/apps/api/tests/test_roles.py
+++ b/pydis_site/apps/api/tests/test_roles.py
@@ -1,7 +1,7 @@
 from django.urls import reverse
 
 from .base import AuthenticatedAPITestCase
-from ..models import Role
+from ..models import Role, User
 
 
 class CreationTests(AuthenticatedAPITestCase):
@@ -35,6 +35,20 @@ class CreationTests(AuthenticatedAPITestCase):
             permissions=6,
             position=0,
         )
+        cls.role_to_delete = Role.objects.create(
+            id=7,
+            name="role to delete",
+            colour=7,
+            permissions=7,
+            position=0,
+        )
+        cls.role_unassigned_test_user = User.objects.create(
+            id=8,
+            name="role_unassigned_test_user",
+            discriminator="0000",
+            roles=[cls.role_to_delete.id],
+            in_guild=True
+        )
 
     def _validate_roledict(self, role_dict: dict) -> None:
         """Helper method to validate a dict representing a role."""
@@ -81,11 +95,11 @@ class CreationTests(AuthenticatedAPITestCase):
         url = reverse('api:bot:role-list')
 
         response = self.client.get(url)
-        self.assertContains(response, text="id", count=4, status_code=200)
+        self.assertContains(response, text="id", count=5, status_code=200)
 
         roles = response.json()
         self.assertIsInstance(roles, list)
-        self.assertEqual(len(roles), 4)
+        self.assertEqual(len(roles), 5)
 
         for role in roles:
             self._validate_roledict(role)
@@ -181,6 +195,12 @@ class CreationTests(AuthenticatedAPITestCase):
         response = self.client.delete(url)
         self.assertEqual(response.status_code, 204)
 
+    def test_role_delete_unassigned(self):
+        """Tests if the deleted Role gets unassigned from the user."""
+        self.role_to_delete.delete()
+        self.role_unassigned_test_user.refresh_from_db()
+        self.assertEqual(self.role_unassigned_test_user.roles, [])
+
     def test_role_detail_404_all_methods(self):
         """Tests detail view with non-existing ID."""
         url = reverse('api:bot:role-detail', args=(20190815,))
diff --git a/pydis_site/apps/api/tests/test_users.py b/pydis_site/apps/api/tests/test_users.py
index 295bcf64..5d10069d 100644
--- a/pydis_site/apps/api/tests/test_users.py
+++ b/pydis_site/apps/api/tests/test_users.py
@@ -1,10 +1,10 @@
-from unittest.mock import patch
+import random
+from unittest.mock import Mock, patch
 
-from django.core.exceptions import ObjectDoesNotExist
 from django.urls import reverse
 
 from .base import AuthenticatedAPITestCase
-from ..models import Role, User
+from ..models import Infraction, Role, User
 from ..models.bot.metricity import NotFoundError
 from ..viewsets.bot.user import UserListPagination
 
@@ -421,10 +421,10 @@ class UserMetricityTests(AuthenticatedAPITestCase):
 
         # Then
         self.assertEqual(response.status_code, 200)
-        self.assertEqual(response.json(), {
+        self.assertCountEqual(response.json(), {
             "joined_at": joined_at,
             "total_messages": total_messages,
-            "voice_banned": False,
+            "voice_gate_blocked": False,
             "activity_blocks": total_blocks
         })
 
@@ -451,23 +451,36 @@ class UserMetricityTests(AuthenticatedAPITestCase):
         self.assertEqual(response.status_code, 404)
 
     def test_metricity_voice_banned(self):
+        queryset_with_values = Mock(spec=Infraction.objects)
+        queryset_with_values.filter.return_value = queryset_with_values
+        queryset_with_values.exists.return_value = True
+
+        queryset_without_values = Mock(spec=Infraction.objects)
+        queryset_without_values.filter.return_value = queryset_without_values
+        queryset_without_values.exists.return_value = False
         cases = [
-            {'exception': None, 'voice_banned': True},
-            {'exception': ObjectDoesNotExist, 'voice_banned': False},
+            {'voice_infractions': queryset_with_values, 'voice_gate_blocked': True},
+            {'voice_infractions': queryset_without_values, 'voice_gate_blocked': False},
         ]
 
         self.mock_metricity_user("foo", 1, 1, [["bar", 1]])
 
         for case in cases:
-            with self.subTest(exception=case['exception'], voice_banned=case['voice_banned']):
-                with patch("pydis_site.apps.api.viewsets.bot.user.Infraction.objects.get") as p:
-                    p.side_effect = case['exception']
+            with self.subTest(
+                voice_infractions=case['voice_infractions'],
+                voice_gate_blocked=case['voice_gate_blocked']
+            ):
+                with patch("pydis_site.apps.api.viewsets.bot.user.Infraction.objects.filter") as p:
+                    p.return_value = case['voice_infractions']
 
                     url = reverse('api:bot:user-metricity-data', args=[0])
                     response = self.client.get(url)
 
                     self.assertEqual(response.status_code, 200)
-                    self.assertEqual(response.json()["voice_banned"], case["voice_banned"])
+                    self.assertEqual(
+                        response.json()["voice_gate_blocked"],
+                        case["voice_gate_blocked"]
+                    )
 
     def test_metricity_review_data(self):
         # Given
@@ -508,3 +521,45 @@ class UserMetricityTests(AuthenticatedAPITestCase):
         self.metricity.total_messages.side_effect = NotFoundError()
         self.metricity.total_message_blocks.side_effect = NotFoundError()
         self.metricity.top_channel_activity.side_effect = NotFoundError()
+
+
+class UserViewSetTests(AuthenticatedAPITestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.searched_user = User.objects.create(
+            id=12095219,
+            name=f"Test user {random.randint(100, 1000)}",
+            discriminator=random.randint(1, 9999),
+            in_guild=True,
+        )
+        cls.other_user = User.objects.create(
+            id=18259125,
+            name=f"Test user {random.randint(100, 1000)}",
+            discriminator=random.randint(1, 9999),
+            in_guild=True,
+        )
+
+    def test_search_lookup_of_wanted_user(self) -> None:
+        """Searching a user by name and discriminator should return that user."""
+        url = reverse('api:bot:user-list')
+        params = {
+            'username': self.searched_user.name,
+            'discriminator': self.searched_user.discriminator,
+        }
+        response = self.client.get(url, params)
+        result = response.json()
+        self.assertEqual(result['count'], 1)
+        [user] = result['results']
+        self.assertEqual(user['id'], self.searched_user.id)
+
+    def test_search_lookup_of_unknown_user(self) -> None:
+        """Searching an unknown user should return no results."""
+        url = reverse('api:bot:user-list')
+        params = {
+            'username': "f-string enjoyer",
+            'discriminator': 1245,
+        }
+        response = self.client.get(url, params)
+        result = response.json()
+        self.assertEqual(result['count'], 0)
+        self.assertEqual(result['results'], [])