<reponame>TamaraAbells/okuna-api<gh_stars>100-1000
import random

from django.urls import reverse
from faker import Faker
from rest_framework import status
from openbook_common.tests.models import OpenbookAPITestCase

import logging
import json

from openbook_common.tests.helpers import make_user, make_authentication_headers_for_user, \
    make_community

logger = logging.getLogger(__name__)
fake = Faker()


class CommunityModeratorsAPITest(OpenbookAPITestCase):

    def test_can_get_community_moderators_if_admin(self):
        """
        should be able to retrieve the community moderators if user is admin of community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        other_user = make_user()
        community = make_community(creator=other_user)
        community_name = community.name

        user.join_community_with_name(community_name)
        other_user.add_administrator_with_username_to_community_with_name(username=user.username,
                                                                          community_name=community.name)

        amount_of_moderators = 5
        moderators_ids = [
        ]

        for i in range(0, amount_of_moderators):
            community_member = make_user()
            community_member.join_community_with_name(community_name)
            other_user.add_moderator_with_username_to_community_with_name(username=community_member,
                                                                          community_name=community.name)
            moderators_ids.append(community_member.pk)

        url = self._get_url(community_name=community.name)
        response = self.client.get(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

        response_moderators = json.loads(response.content)

        self.assertEqual(len(response_moderators), len(moderators_ids))

        for response_moderator in response_moderators:
            response_moderator_id = response_moderator.get('id')
            self.assertIn(response_moderator_id, moderators_ids)

    def test_can_get_community_moderators_if_mod(self):
        """
        should be able to retrieve the community moderators if user is moderator of community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        other_user = make_user()
        community = make_community(creator=other_user)
        community_name = community.name

        user.join_community_with_name(community_name)
        other_user.add_moderator_with_username_to_community_with_name(username=user.username,
                                                                      community_name=community.name)

        amount_of_moderators = 5
        moderators_ids = [
            user.pk
        ]

        for i in range(0, amount_of_moderators):
            community_member = make_user()
            community_member.join_community_with_name(community_name)
            other_user.add_moderator_with_username_to_community_with_name(username=community_member,
                                                                          community_name=community.name)
            moderators_ids.append(community_member.pk)

        url = self._get_url(community_name=community.name)
        response = self.client.get(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

        response_moderators = json.loads(response.content)

        self.assertEqual(len(response_moderators), len(moderators_ids))

        for response_moderator in response_moderators:
            response_moderator_id = response_moderator.get('id')
            self.assertIn(response_moderator_id, moderators_ids)

    def test_can_get_community_moderators_if_member(self):
        """
        should be able to retrieve the community moderators if user is member of community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        other_user = make_user()
        community = make_community(creator=other_user)
        community_name = community.name

        user.join_community_with_name(community_name)

        amount_of_moderators = 5
        moderators_ids = [
        ]

        for i in range(0, amount_of_moderators):
            community_member = make_user()
            community_member.join_community_with_name(community_name)
            other_user.add_moderator_with_username_to_community_with_name(username=community_member,
                                                                          community_name=community.name)
            moderators_ids.append(community_member.pk)

        url = self._get_url(community_name=community.name)
        response = self.client.get(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

        response_moderators = json.loads(response.content)

        self.assertEqual(len(response_moderators), len(moderators_ids))

        for response_moderator in response_moderators:
            response_moderator_id = response_moderator.get('id')
            self.assertIn(response_moderator_id, moderators_ids)

    def test_cant_get_community_moderators_if_banned(self):
        """
        should not be able to retrieve the community moderators if user has been banned from community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community_owner = make_user()
        community = make_community(creator=community_owner)
        community_name = community.name

        user.join_community_with_name(community_name)
        community_owner.ban_user_with_username_from_community_with_name(username=user.username,
                                                                        community_name=community.name)
        amount_of_moderators = 5

        for i in range(0, amount_of_moderators):
            community_member = make_user()
            community_member.join_community_with_name(community_name)
            community_owner.add_moderator_with_username_to_community_with_name(username=community_member,
                                                                               community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.get(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_can_add_community_moderator_if_creator(self):
        """
        should be able to add a community moderator if user is creator of community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=user, type='P')

        user_to_make_moderator = make_user()
        user_to_make_moderator.join_community_with_name(community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_moderator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_201_CREATED)

        self.assertTrue(
            user_to_make_moderator.is_moderator_of_community_with_name(community_name=community.name))

    def test_logs_community_moderator_added(self):
        """
        should create a log when community moderator was added
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=user, type='P')

        moderator_to_add = make_user()
        moderator_to_add.join_community_with_name(community_name=community.name)

        url = self._get_url(community_name=community.name)
        self.client.put(url, {
            'username': moderator_to_add.username
        }, **headers)

        self.assertTrue(community.logs.filter(action_type='AM',
                                              source_user=user,
                                              target_user=moderator_to_add).exists())

    def test_can_add_community_moderator_if_admin(self):
        """
        should be able to add a community moderator if user is administrator of community
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user.join_community_with_name(community_name=community.name)
        other_user.add_administrator_with_username_to_community_with_name(username=user,
                                                                          community_name=community.name)

        user_to_make_admnistrator = make_user()
        user_to_make_admnistrator.join_community_with_name(community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_admnistrator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_201_CREATED)

        self.assertTrue(
            user_to_make_admnistrator.is_moderator_of_community_with_name(community_name=community.name))

    def test_cant_add_community_moderator_if_mod(self):
        """
        should not be able to add a community moderator if user is moderator of community
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user.join_community_with_name(community_name=community.name)
        other_user.add_moderator_with_username_to_community_with_name(username=user.username,
                                                                      community_name=community.name)

        user_to_make_admnistrator = make_user()
        user_to_make_admnistrator.join_community_with_name(community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_admnistrator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertFalse(
            user_to_make_admnistrator.is_moderator_of_community_with_name(community_name=community.name))

    def test_cant_add_community_moderator_if_member(self):
        """
        should not be able to add a community moderator if user is just a member of community
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user.join_community_with_name(community_name=community.name)

        user_to_make_admnistrator = make_user()
        user_to_make_admnistrator.join_community_with_name(community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_admnistrator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertFalse(
            user_to_make_admnistrator.is_moderator_of_community_with_name(community_name=community.name))

    def test_cant_add_community_moderator_if_not_member(self):
        """
        should not be able to add a community moderator if user is not even a member of community
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user_to_make_moderator = make_user()

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_moderator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertFalse(
            user_to_make_moderator.is_moderator_of_community_with_name(community_name=community.name))

    def test_cant_add_community_moderator_if_admin(self):
        """
        should not be able to add a community moderator if the user is already an admin
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=user, type='P')

        user_to_make_moderator = make_user()
        user_to_make_moderator.join_community_with_name(community_name=community.name)
        user.add_administrator_with_username_to_community_with_name(username=user_to_make_moderator.username,
                                                                    community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_moderator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertFalse(
            user_to_make_moderator.is_moderator_of_community_with_name(community_name=community.name))

    def _get_url(self, community_name):
        return reverse('community-moderators', kwargs={
            'community_name': community_name
        })


class CommunityModeratorAPITest(OpenbookAPITestCase):
    def test_can_remove_community_moderator_if_admin(self):
        """
        should be able to remove a community moderator if user is admin of the community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=user, type='P')

        moderator_to_remove = make_user()
        moderator_to_remove.join_community_with_name(community_name=community.name)
        user.add_moderator_with_username_to_community_with_name(username=moderator_to_remove.username,
                                                                community_name=community.name)

        url = self._get_url(community_name=community.name, username=moderator_to_remove.username)
        response = self.client.delete(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

        self.assertFalse(
            moderator_to_remove.is_moderator_of_community_with_name(community_name=community.name))

    def test_logs_community_moderator_removed(self):
        """
        should create a log when community moderator was removed
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=user, type='P')

        moderator_to_remove = make_user()
        moderator_to_remove.join_community_with_name(community_name=community.name)
        user.add_moderator_with_username_to_community_with_name(username=moderator_to_remove.username,
                                                                community_name=community.name)

        url = self._get_url(community_name=community.name, username=moderator_to_remove.username)
        self.client.delete(url, **headers)

        self.assertTrue(community.logs.filter(action_type='RM',
                                              source_user=user,
                                              target_user=moderator_to_remove).exists())

    def test_cant_remove_community_moderator_if_mod(self):
        """
        should not be able to remove a community moderator if user is moderator
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user.join_community_with_name(community.name)
        other_user.add_moderator_with_username_to_community_with_name(username=user.username,
                                                                      community_name=community.name)

        moderator_to_remove = make_user()
        moderator_to_remove.join_community_with_name(community_name=community.name)
        other_user.add_moderator_with_username_to_community_with_name(username=moderator_to_remove.username,
                                                                      community_name=community.name)

        url = self._get_url(community_name=community.name, username=moderator_to_remove.username)
        response = self.client.delete(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertTrue(
            moderator_to_remove.is_moderator_of_community_with_name(community_name=community.name))

    def test_cant_remove_community_moderator_if_member(self):
        """
        should not be able to remove a community moderator if user is member
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user.join_community_with_name(community.name)

        moderator_to_remove = make_user()
        moderator_to_remove.join_community_with_name(community_name=community.name)
        other_user.add_moderator_with_username_to_community_with_name(username=moderator_to_remove.username,
                                                                      community_name=community.name)

        url = self._get_url(community_name=community.name, username=moderator_to_remove.username)
        response = self.client.delete(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertTrue(
            moderator_to_remove.is_moderator_of_community_with_name(community_name=community.name))

    def _get_url(self, community_name, username):
        return reverse('community-moderator', kwargs={
            'community_name': community_name,
            'community_moderator_username': username
        })


class SearchCommunityModeratorsAPITests(OpenbookAPITestCase):
    """
    SearchCommunityModeratorsAPITests
    """

    def test_can_search_community_moderators_by_name(self):
        """
        should be able to search for community moderators by their name and return 200
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)
        community = make_community(creator=user)

        amount_of_community_moderators_to_search_for = 5

        for i in range(0, amount_of_community_moderators_to_search_for):
            moderator = make_user()
            moderator.join_community_with_name(community_name=community.name)
            user.add_moderator_with_username_to_community_with_name(username=moderator.username,
                                                                    community_name=community.name)
            moderator_name = moderator.profile.name
            amount_of_characters_to_query = random.randint(1, len(moderator_name))
            query = moderator_name[0:amount_of_characters_to_query]
            final_query = ''
            for character in query:
                final_query = final_query + (character.upper() if fake.boolean() else character.lower())

            url = self._get_url(community_name=community.name)
            response = self.client.get(url, {
                'query': final_query
            }, **headers)
            self.assertEqual(response.status_code, status.HTTP_200_OK)
            response_moderators = json.loads(response.content)
            response_moderators_count = len(response_moderators)
            if response_moderators_count == 1:
                # Our community creator was not retrieved
                self.assertEqual(response_moderators_count, 1)
                retrieved_moderator = response_moderators[0]
                self.assertEqual(retrieved_moderator['id'], moderator.id)
            else:
                # Our community creator was retrieved too
                for response_moderator in response_moderators:
                    response_moderator_id = response_moderator['id']
                    self.assertTrue(
                        response_moderator_id == moderator.id or response_moderator_id == user.id)
            user.remove_moderator_with_username_from_community_with_name(username=moderator.username,
                                                                         community_name=community.name)

    def test_can_search_community_moderators_by_username(self):
        """
        should be able to search for community moderators by their username and return 200
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)
        community = make_community(creator=user)

        amount_of_community_moderators_to_search_for = 5

        for i in range(0, amount_of_community_moderators_to_search_for):
            moderator = make_user()
            moderator.join_community_with_name(community_name=community.name)
            user.add_moderator_with_username_to_community_with_name(username=moderator.username,
                                                                    community_name=community.name)
            moderator_username = moderator.username
            amount_of_characters_to_query = random.randint(1, len(moderator_username))
            query = moderator_username[0:amount_of_characters_to_query]
            final_query = ''
            for character in query:
                final_query = final_query + (character.upper() if fake.boolean() else character.lower())

            url = self._get_url(community_name=community.name)
            response = self.client.get(url, {
                'query': final_query
            }, **headers)
            self.assertEqual(response.status_code, status.HTTP_200_OK)
            response_moderators = json.loads(response.content)
            response_moderators_count = len(response_moderators)
            if response_moderators_count == 1:
                # Our community creator was not retrieved
                self.assertEqual(response_moderators_count, 1)
                retrieved_moderator = response_moderators[0]
                self.assertEqual(retrieved_moderator['id'], moderator.id)
            else:
                # Our community creator was retrieved too
                for response_moderator in response_moderators:
                    response_moderator_id = response_moderator['id']
                    self.assertTrue(
                        response_moderator_id == moderator.id or response_moderator_id == user.id)

            user.remove_moderator_with_username_from_community_with_name(username=moderator.username,
                                                                         community_name=community.name)

    def _get_url(self, community_name):
        return reverse('search-community-moderators', kwargs={
            'community_name': community_name,
        })

import random

from django.urls import reverse
from faker import Faker
from rest_framework import status
from openbook_common.tests.models import OpenbookAPITestCase

import logging
import json

from openbook_common.tests.helpers import make_user, make_authentication_headers_for_user, \
    make_community

logger = logging.getLogger(__name__)
fake = Faker()


class CommunityModeratorsAPITest(OpenbookAPITestCase):

    def test_can_get_community_moderators_if_admin(self):
        """
        should be able to retrieve the community moderators if user is admin of community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        other_user = make_user()
        community = make_community(creator=other_user)
        community_name = community.name

        user.join_community_with_name(community_name)
        other_user.add_administrator_with_username_to_community_with_name(username=user.username,
                                                                          community_name=community.name)

        amount_of_moderators = 5
        moderators_ids = [
        ]

        for i in range(0, amount_of_moderators):
            community_member = make_user()
            community_member.join_community_with_name(community_name)
            other_user.add_moderator_with_username_to_community_with_name(username=community_member,
                                                                          community_name=community.name)
            moderators_ids.append(community_member.pk)

        url = self._get_url(community_name=community.name)
        response = self.client.get(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

        response_moderators = json.loads(response.content)

        self.assertEqual(len(response_moderators), len(moderators_ids))

        for response_moderator in response_moderators:
            response_moderator_id = response_moderator.get('id')
            self.assertIn(response_moderator_id, moderators_ids)

    def test_can_get_community_moderators_if_mod(self):
        """
        should be able to retrieve the community moderators if user is moderator of community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        other_user = make_user()
        community = make_community(creator=other_user)
        community_name = community.name

        user.join_community_with_name(community_name)
        other_user.add_moderator_with_username_to_community_with_name(username=user.username,
                                                                      community_name=community.name)

        amount_of_moderators = 5
        moderators_ids = [
            user.pk
        ]

        for i in range(0, amount_of_moderators):
            community_member = make_user()
            community_member.join_community_with_name(community_name)
            other_user.add_moderator_with_username_to_community_with_name(username=community_member,
                                                                          community_name=community.name)
            moderators_ids.append(community_member.pk)

        url = self._get_url(community_name=community.name)
        response = self.client.get(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

        response_moderators = json.loads(response.content)

        self.assertEqual(len(response_moderators), len(moderators_ids))

        for response_moderator in response_moderators:
            response_moderator_id = response_moderator.get('id')
            self.assertIn(response_moderator_id, moderators_ids)

    def test_can_get_community_moderators_if_member(self):
        """
        should be able to retrieve the community moderators if user is member of community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        other_user = make_user()
        community = make_community(creator=other_user)
        community_name = community.name

        user.join_community_with_name(community_name)

        amount_of_moderators = 5
        moderators_ids = [
        ]

        for i in range(0, amount_of_moderators):
            community_member = make_user()
            community_member.join_community_with_name(community_name)
            other_user.add_moderator_with_username_to_community_with_name(username=community_member,
                                                                          community_name=community.name)
            moderators_ids.append(community_member.pk)

        url = self._get_url(community_name=community.name)
        response = self.client.get(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

        response_moderators = json.loads(response.content)

        self.assertEqual(len(response_moderators), len(moderators_ids))

        for response_moderator in response_moderators:
            response_moderator_id = response_moderator.get('id')
            self.assertIn(response_moderator_id, moderators_ids)

    def test_cant_get_community_moderators_if_banned(self):
        """
        should not be able to retrieve the community moderators if user has been banned from community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community_owner = make_user()
        community = make_community(creator=community_owner)
        community_name = community.name

        user.join_community_with_name(community_name)
        community_owner.ban_user_with_username_from_community_with_name(username=user.username,
                                                                        community_name=community.name)
        amount_of_moderators = 5

        for i in range(0, amount_of_moderators):
            community_member = make_user()
            community_member.join_community_with_name(community_name)
            community_owner.add_moderator_with_username_to_community_with_name(username=community_member,
                                                                               community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.get(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_can_add_community_moderator_if_creator(self):
        """
        should be able to add a community moderator if user is creator of community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=user, type='P')

        user_to_make_moderator = make_user()
        user_to_make_moderator.join_community_with_name(community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_moderator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_201_CREATED)

        self.assertTrue(
            user_to_make_moderator.is_moderator_of_community_with_name(community_name=community.name))

    def test_logs_community_moderator_added(self):
        """
        should create a log when community moderator was added
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=user, type='P')

        moderator_to_add = make_user()
        moderator_to_add.join_community_with_name(community_name=community.name)

        url = self._get_url(community_name=community.name)
        self.client.put(url, {
            'username': moderator_to_add.username
        }, **headers)

        self.assertTrue(community.logs.filter(action_type='AM',
                                              source_user=user,
                                              target_user=moderator_to_add).exists())

    def test_can_add_community_moderator_if_admin(self):
        """
        should be able to add a community moderator if user is administrator of community
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user.join_community_with_name(community_name=community.name)
        other_user.add_administrator_with_username_to_community_with_name(username=user,
                                                                          community_name=community.name)

        user_to_make_admnistrator = make_user()
        user_to_make_admnistrator.join_community_with_name(community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_admnistrator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_201_CREATED)

        self.assertTrue(
            user_to_make_admnistrator.is_moderator_of_community_with_name(community_name=community.name))

    def test_cant_add_community_moderator_if_mod(self):
        """
        should not be able to add a community moderator if user is moderator of community
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user.join_community_with_name(community_name=community.name)
        other_user.add_moderator_with_username_to_community_with_name(username=user.username,
                                                                      community_name=community.name)

        user_to_make_admnistrator = make_user()
        user_to_make_admnistrator.join_community_with_name(community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_admnistrator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertFalse(
            user_to_make_admnistrator.is_moderator_of_community_with_name(community_name=community.name))

    def test_cant_add_community_moderator_if_member(self):
        """
        should not be able to add a community moderator if user is just a member of community
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user.join_community_with_name(community_name=community.name)

        user_to_make_admnistrator = make_user()
        user_to_make_admnistrator.join_community_with_name(community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_admnistrator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertFalse(
            user_to_make_admnistrator.is_moderator_of_community_with_name(community_name=community.name))

    def test_cant_add_community_moderator_if_not_member(self):
        """
        should not be able to add a community moderator if user is not even a member of community
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user_to_make_moderator = make_user()

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_moderator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertFalse(
            user_to_make_moderator.is_moderator_of_community_with_name(community_name=community.name))

    def test_cant_add_community_moderator_if_admin(self):
        """
        should not be able to add a community moderator if the user is already an admin
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=user, type='P')

        user_to_make_moderator = make_user()
        user_to_make_moderator.join_community_with_name(community_name=community.name)
        user.add_administrator_with_username_to_community_with_name(username=user_to_make_moderator.username,
                                                                    community_name=community.name)

        url = self._get_url(community_name=community.name)
        response = self.client.put(url, {
            'username': user_to_make_moderator.username
        }, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertFalse(
            user_to_make_moderator.is_moderator_of_community_with_name(community_name=community.name))

    def _get_url(self, community_name):
        return reverse('community-moderators', kwargs={
            'community_name': community_name
        })


class CommunityModeratorAPITest(OpenbookAPITestCase):
    def test_can_remove_community_moderator_if_admin(self):
        """
        should be able to remove a community moderator if user is admin of the community
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=user, type='P')

        moderator_to_remove = make_user()
        moderator_to_remove.join_community_with_name(community_name=community.name)
        user.add_moderator_with_username_to_community_with_name(username=moderator_to_remove.username,
                                                                community_name=community.name)

        url = self._get_url(community_name=community.name, username=moderator_to_remove.username)
        response = self.client.delete(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

        self.assertFalse(
            moderator_to_remove.is_moderator_of_community_with_name(community_name=community.name))

    def test_logs_community_moderator_removed(self):
        """
        should create a log when community moderator was removed
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=user, type='P')

        moderator_to_remove = make_user()
        moderator_to_remove.join_community_with_name(community_name=community.name)
        user.add_moderator_with_username_to_community_with_name(username=moderator_to_remove.username,
                                                                community_name=community.name)

        url = self._get_url(community_name=community.name, username=moderator_to_remove.username)
        self.client.delete(url, **headers)

        self.assertTrue(community.logs.filter(action_type='RM',
                                              source_user=user,
                                              target_user=moderator_to_remove).exists())

    def test_cant_remove_community_moderator_if_mod(self):
        """
        should not be able to remove a community moderator if user is moderator
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user.join_community_with_name(community.name)
        other_user.add_moderator_with_username_to_community_with_name(username=user.username,
                                                                      community_name=community.name)

        moderator_to_remove = make_user()
        moderator_to_remove.join_community_with_name(community_name=community.name)
        other_user.add_moderator_with_username_to_community_with_name(username=moderator_to_remove.username,
                                                                      community_name=community.name)

        url = self._get_url(community_name=community.name, username=moderator_to_remove.username)
        response = self.client.delete(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertTrue(
            moderator_to_remove.is_moderator_of_community_with_name(community_name=community.name))

    def test_cant_remove_community_moderator_if_member(self):
        """
        should not be able to remove a community moderator if user is member
        """
        user = make_user()
        other_user = make_user()
        headers = make_authentication_headers_for_user(user)

        community = make_community(creator=other_user, type='P')

        user.join_community_with_name(community.name)

        moderator_to_remove = make_user()
        moderator_to_remove.join_community_with_name(community_name=community.name)
        other_user.add_moderator_with_username_to_community_with_name(username=moderator_to_remove.username,
                                                                      community_name=community.name)

        url = self._get_url(community_name=community.name, username=moderator_to_remove.username)
        response = self.client.delete(url, **headers)

        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

        self.assertTrue(
            moderator_to_remove.is_moderator_of_community_with_name(community_name=community.name))

    def _get_url(self, community_name, username):
        return reverse('community-moderator', kwargs={
            'community_name': community_name,
            'community_moderator_username': username
        })


class SearchCommunityModeratorsAPITests(OpenbookAPITestCase):
    """
    SearchCommunityModeratorsAPITests
    """

    def test_can_search_community_moderators_by_name(self):
        """
        should be able to search for community moderators by their name and return 200
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)
        community = make_community(creator=user)

        amount_of_community_moderators_to_search_for = 5

        for i in range(0, amount_of_community_moderators_to_search_for):
            moderator = make_user()
            moderator.join_community_with_name(community_name=community.name)
            user.add_moderator_with_username_to_community_with_name(username=moderator.username,
                                                                    community_name=community.name)
            moderator_name = moderator.profile.name
            amount_of_characters_to_query = random.randint(1, len(moderator_name))
            query = moderator_name[0:amount_of_characters_to_query]
            final_query = ''
            for character in query:
                final_query = final_query + (character.upper() if fake.boolean() else character.lower())

            url = self._get_url(community_name=community.name)
            response = self.client.get(url, {
                'query': final_query
            }, **headers)
            self.assertEqual(response.status_code, status.HTTP_200_OK)
            response_moderators = json.loads(response.content)
            response_moderators_count = len(response_moderators)
            if response_moderators_count == 1:
                # Our community creator was not retrieved
                self.assertEqual(response_moderators_count, 1)
                retrieved_moderator = response_moderators[0]
                self.assertEqual(retrieved_moderator['id'], moderator.id)
            else:
                # Our community creator was retrieved too
                for response_moderator in response_moderators:
                    response_moderator_id = response_moderator['id']
                    self.assertTrue(
                        response_moderator_id == moderator.id or response_moderator_id == user.id)
            user.remove_moderator_with_username_from_community_with_name(username=moderator.username,
                                                                         community_name=community.name)

    def test_can_search_community_moderators_by_username(self):
        """
        should be able to search for community moderators by their username and return 200
        """
        user = make_user()
        headers = make_authentication_headers_for_user(user)
        community = make_community(creator=user)

        amount_of_community_moderators_to_search_for = 5

        for i in range(0, amount_of_community_moderators_to_search_for):
            moderator = make_user()
            moderator.join_community_with_name(community_name=community.name)
            user.add_moderator_with_username_to_community_with_name(username=moderator.username,
                                                                    community_name=community.name)
            moderator_username = moderator.username
            amount_of_characters_to_query = random.randint(1, len(moderator_username))
            query = moderator_username[0:amount_of_characters_to_query]
            final_query = ''
            for character in query:
                final_query = final_query + (character.upper() if fake.boolean() else character.lower())

            url = self._get_url(community_name=community.name)
            response = self.client.get(url, {
                'query': final_query
            }, **headers)
            self.assertEqual(response.status_code, status.HTTP_200_OK)
            response_moderators = json.loads(response.content)
            response_moderators_count = len(response_moderators)
            if response_moderators_count == 1:
                # Our community creator was not retrieved
                self.assertEqual(response_moderators_count, 1)
                retrieved_moderator = response_moderators[0]
                self.assertEqual(retrieved_moderator['id'], moderator.id)
            else:
                # Our community creator was retrieved too
                for response_moderator in response_moderators:
                    response_moderator_id = response_moderator['id']
                    self.assertTrue(
                        response_moderator_id == moderator.id or response_moderator_id == user.id)

            user.remove_moderator_with_username_from_community_with_name(username=moderator.username,
                                                                         community_name=community.name)

    def _get_url(self, community_name):
        return reverse('search-community-moderators', kwargs={
            'community_name': community_name,
        })
should be able to retrieve the community moderators if user is admin of community should be able to retrieve the community moderators if user is moderator of community should be able to retrieve the community moderators if user is member of community should not be able to retrieve the community moderators if user has been banned from community should be able to add a community moderator if user is creator of community should create a log when community moderator was added should be able to add a community moderator if user is administrator of community should not be able to add a community moderator if user is moderator of community should not be able to add a community moderator if user is just a member of community should not be able to add a community moderator if user is not even a member of community should not be able to add a community moderator if the user is already an admin should be able to remove a community moderator if user is admin of the community should create a log when community moderator was removed should not be able to remove a community moderator if user is moderator should not be able to remove a community moderator if user is member SearchCommunityModeratorsAPITests should be able to search for community moderators by their name and return 200 # Our community creator was not retrieved # Our community creator was retrieved too should be able to search for community moderators by their username and return 200 # Our community creator was not retrieved # Our community creator was retrieved too