Source code for tests.users.test_serializers

import os
import unittest

from django.core.files import File
from django.test import TestCase
from phone_gen import PhoneNumber

from api.users.serializers import (
    AuthorCommentSerializer,
    CategorySerializer,
    ProfileSerializer,
    SenderNotificationSerializer,
    UserSerializer,
)
from apps.users.models import Category
from tests.users.factories import CategoryFactory, ProfileFactory, UserFactory, fake  # type: ignore




class TestInterestsSerializer(TestCase):


    def test_valid_serializer(self):
        interest = CategoryFactory.create()
        serializer = CategorySerializer(interest)

        self.assertIn("name", serializer.data)
        self.assertEqual(serializer.data["name"], interest.name)




    def test_create_interest(self):
        data = {
            "name": fake.word().capitalize(),
        }

        serializer = CategorySerializer(data=data)
        self.assertTrue(serializer.is_valid())
        interest = serializer.save()

        self.assertIsInstance(interest, Category)
        self.assertEqual(interest.name, data["name"])




    def test_invalid_data(self):
        data = {
            "name": "",  # Empty name should be invalid
        }

        serializer = CategorySerializer(data=data)
        self.assertFalse(serializer.is_valid())
        self.assertIn("name", serializer.errors)






class TestUserSerializer(TestCase):


    def test_valid_serializer(self):
        user = UserFactory.create()

        serializer = UserSerializer(user)

        self.assertIn("username", serializer.data)
        self.assertEqual(serializer.data["username"], user.username)




    def test_invalid_password_repeat(self):
        image_path = os.path.join(os.path.dirname(__file__), "../_data/1.jpg")
        interests = CategoryFactory.create_batch(10)
        with open(image_path, "rb") as image:
            data = {
                "username": fake.user_name(),
                "email": fake.email(),
                "password": "Testpassword",
                "password_repeat": "Wrongpassword",
                "phone_number": PhoneNumber("UA").get_number(),
                "avatar": File(image),
                "birthdate": fake.date_of_birth(minimum_age=14).strftime("%Y-%m-%d"),
                "interests": [interest.id for interest in interests],
                "first_name": fake.first_name(),
                "last_name": fake.last_name(),
            }

            serializer = UserSerializer(data=data)
            self.assertFalse(serializer.is_valid())
            self.assertIn("password_repeat", serializer.errors)




    def test_dynamic_profile_fields(self):
        user = UserFactory.create()
        serializer = UserSerializer(user)
        profile = ProfileFactory.create(user=user)

        # Check if profile fields are in the serialized data
        self.assertIn("avatar", serializer.data)
        self.assertEqual(serializer.data["avatar"], str(profile.avatar.url))




    def test_includes_all_profile_fields(self):
        user_serializer = UserSerializer()
        profile_serializer = ProfileSerializer()

        # Get all ProfileSerializer fields, except those that are excluded
        profile_fields = set(profile_serializer.fields.keys())
        excluded_fields = set(profile_serializer.Meta.exclude)
        expected_fields = profile_fields - excluded_fields

        # Check whether all these fields are present in UserSerializer
        user_fields = set(user_serializer.fields.keys())
        for field in expected_fields:
            self.assertIn(field, user_fields, f"Field {field} from ProfileSerializer not found in UserSerializer")




    def test_expected_fields(self):
        serializer = UserSerializer(data={})
        serializer.is_valid()
        required_fields = [field_name for field_name, field in serializer.fields.items() if field.required]
        required_fields_list = [
            "interests",
            "password_repeat",
            "password",
            "username",
            "first_name",
            "last_name",
            "email",
            "birthdate",
        ]
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), required_fields)
        self.assertListEqual(list(serializer.errors.keys()), required_fields_list)






class TestSenderNotificationSerializer(unittest.TestCase):
    """Test sender notification serializer"""



    def setUp(self) -> None:
        self.user = UserFactory()
        self.serializer = SenderNotificationSerializer




    def test_data(self):
        serializer = self.serializer(self.user)
        self.assertListEqual(list(serializer.data.keys()), ["id", "username", "is_current_user_following", "avatar"])






class TestAuthorCommentSerializer(unittest.TestCase):
    """Test author comment serializer"""



    def setUp(self) -> None:
        self.user = UserFactory()
        self.serializer = AuthorCommentSerializer




    def test_data(self):
        serializer = self.serializer(self.user)
        self.assertListEqual(list(serializer.data.keys()), ["id", "username", "avatar"])