zod-backend/web_admin/tests/test_user_management.py

"""
web admin test user management file
"""
# django imports
from django.contrib.auth import get_user_model
from rest_framework import status

# local imports
from base.constants import GUARDIAN, JUNIOR
from web_admin.tests.test_set_up import UserManagementSetUp

# user model
User = get_user_model()


class UserManagementViewSetTestCase(UserManagementSetUp):
    """
    test cases for user management
    """
    def setUp(self) -> None:
        super(UserManagementViewSetTestCase, self).setUp()

        self.update_data = {
            'email': 'user5@yopmail.com',
            'country_code': 93,
            'phone': '8765454235'
        }
        self.user_management_endpoint = "/api/v1/user-management"

    def test_user_management_list_all_users(self):
        """
        test user management list all users
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/"
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Assuming four user exists in the database
        self.assertEqual(len(response.data['data']), 4)

    def test_user_management_list_guardians(self):
        """
        test user management list guardians
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/?user_type={GUARDIAN}"
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Assuming two guardians exists in the database
        self.assertEqual(len(response.data['data']), 2)

    def test_user_management_list_juniors(self):
        """
        test user management list juniors
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/?user_type={JUNIOR}"
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Assuming two juniors exists in the database
        self.assertEqual(len(response.data['data']), 2)

    def test_user_management_list_with_unauthorised_user(self):
        """
        test user management list with unauthorised user
        :return:
        """
        # user unauthorised access
        self.client.force_authenticate(user=self.user)
        url = f"{self.user_management_endpoint}/"
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_user_management_retrieve_guardian(self):
        """
        test user management retrieve guardian
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user.id}/?user_type={GUARDIAN}"
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data['data']), 1)

    def test_user_management_retrieve_junior(self):
        """
        test user management retrieve junior
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user_3.id}/?user_type={JUNIOR}"
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data['data']), 1)

    def test_user_management_retrieve_without_user_type(self):
        """
        test user management retrieve without user type
        user status is mandatory
        API will throw error
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user.id}/"
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_user_management_update_guardian(self):
        """
        test user management update guardian
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user.id}/?user_type={GUARDIAN}"
        response = self.client.patch(url, self.update_data, format='json',)
        self.user.refresh_from_db()
        self.guardian.refresh_from_db()
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(self.user.email, self.update_data['email'])
        self.assertEqual(self.guardian.country_code, self.update_data['country_code'])
        self.assertEqual(self.guardian.phone, self.update_data['phone'])

    def test_user_management_update_guardian_with_existing_email(self):
        """
        test user management update guardian with existing email
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user.id}/?user_type={GUARDIAN}"
        data = {
            'email': self.user_email_2
        }
        response = self.client.patch(url, data, format='json',)
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_user_management_update_guardian_with_existing_phone(self):
        """
        test user management update guardian with existing phone
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user.id}/?user_type={GUARDIAN}"
        data = {
            'phone': self.guardian_2.phone
        }
        response = self.client.patch(url, data, format='json',)
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_user_management_update_junior(self):
        """
        test user management update junior
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user_3.id}/?user_type={JUNIOR}"
        response = self.client.patch(url, self.update_data, format='json',)
        self.user_3.refresh_from_db()
        self.junior.refresh_from_db()
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(self.user_3.email, self.update_data['email'])
        self.assertEqual(self.junior.country_code, self.update_data['country_code'])
        self.assertEqual(self.junior.phone, self.update_data['phone'])

    def test_user_management_update_junior_with_existing_email(self):
        """
        test user management update guardian with existing phone
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user_3.id}/?user_type={JUNIOR}"
        data = {
            'email': self.user_email_4
        }
        response = self.client.patch(url, data, format='json',)
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_user_management_update_junior_with_existing_phone(self):
        """
        test user management update junior with existing phone
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user_3.id}/?user_type={JUNIOR}"
        data = {
            'phone': self.junior_2.phone
        }
        response = self.client.patch(url, data, format='json',)
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_user_management_update_without_user_type(self):
        """
        test user management update without user type
        user status is mandatory
        API will throw error
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user_3.id}/"
        response = self.client.patch(url, self.update_data, format='json',)
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_user_management_change_status_guardian(self):
        """
        test user management change status guardian
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user.id}/change-status/?user_type={GUARDIAN}"
        response = self.client.get(url)
        self.guardian.refresh_from_db()
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(self.guardian.is_active, False)

    def test_user_management_change_status_junior(self):
        """
        test user management change status junior
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user_3.id}/change-status/?user_type={JUNIOR}"
        response = self.client.get(url)
        self.junior.refresh_from_db()
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(self.junior.is_active, False)

    def test_user_management_change_status_without_user_type(self):
        """
        test user management change status without user type
        user status is mandatory
        API will throw error
        :return:
        """
        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)
        url = f"{self.user_management_endpoint}/{self.user.id}/"
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)