Source code for tests.posts.test_serializers

import unittest
from unittest import TestCase

import pytest
from django.conf import settings
from faker import Faker

from api.posts.serializers import (
    CommentSerializer,
    PostContentsSerializer,
    PostMediaContentSerializer,
    PostNotificationSerializer,
    PostSerializer,
    UpdateCommentSerializer,
    WebhookPostSerializer,
)
from tests.posts.factories import CommentFactory, PostFactory, PostMediaFactory
from tests.users.factories import CategoryFactory, UserFactory  # type: ignore




@pytest.mark.usefixtures("jpg_file")
class TestCommentSerializer(TestCase):


    def setUp(self) -> None:
        self.serializer = CommentSerializer
        self.post = PostFactory()
        self.data = {"post": self.post.pk, "text": "Test comment"}




    def test_expected_fields(self):
        serializer = self.serializer(data={})
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["post"])




    def test_reach_limit_image(self):
        data = self.data.copy()
        data["images"] = [self.jpg_file for _ in range(8)]
        serializer = self.serializer(data=data)
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["images"])




    def test_comment_cannot_be_empty(self):
        data = self.data.copy()
        data.pop("text")
        serializer = self.serializer(data=data)
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["text"])




    def test_add_only_image(self):
        data = self.data.copy()
        data.pop("text")
        data["images"] = [self.jpg_file]
        serializer = self.serializer(data=data)
        self.assertTrue(serializer.is_valid())






class TestUpdateCommentSerializer(TestCase):


    def setUp(self) -> None:
        self.serializer = UpdateCommentSerializer
        self.comment = CommentFactory()
        self.data = {"text": "Test comment"}




    def test_data_expected_fields(self):
        serialzer = self.serializer(self.comment)
        self.assertListEqual(list(serialzer.data.keys()), ["id", "text"])






class TestPostSerializer(TestCase):


    def setUp(self) -> None:
        self.serializer = PostSerializer
        self.author = UserFactory()
        self.faker = Faker()
        self.category = CategoryFactory()




    def test_expected_fields(self):
        serializer = self.serializer(data={})
        required_fields = [field_name for field_name, field in self.serializer().fields.items() if field.required]
        required_fields_list = ["category"]
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), required_fields)
        self.assertListEqual(list(serializer.errors.keys()), required_fields_list)




    def test_hasgtags_determination(self):
        tags_raw = [self.faker.word() for _ in range(10)]
        tags = [f"#{tag}" for tag in tags_raw]
        serializer = self.serializer(
            data={"author": self.author.pk, "title": " ".join(tags), "category": self.category.pk}
        )
        serializer.is_valid()
        self.assertTrue(serializer.is_valid())
        self.assertListEqual(tags_raw, serializer.validated_data["tags"])




    def test_hasgtags_with_title_determination(self):
        tags_raw = [self.faker.word() for _ in range(10)]
        tags = [f"#{tag}" for tag in tags_raw]
        title = self.faker.catch_phrase()
        full_title = f"{title} {' '.join(tags)}"
        serializer = self.serializer(data={"author": self.author.pk, "title": full_title, "category": self.category.pk})
        serializer.is_valid()
        self.assertTrue(serializer.is_valid())
        self.assertListEqual(tags_raw, serializer.validated_data["tags"])
        self.assertEqual(title, serializer.validated_data["title"])






@pytest.mark.usefixtures("jpg_file")
@pytest.mark.usefixtures("mp4_file")
class TestPostContentsSerializer(unittest.TestCase):
    """Test post contents serializer"""



    def setUp(self) -> None:
        self.serializer = PostContentsSerializer




    def test_expected_fields(self):
        serializer = self.serializer(data={})
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["content"])




    def test_upload_mixed_content(self):
        data = {"content": [{"original": self.jpg_file}, {"original": self.mp4_file}]}
        serializer = self.serializer(data=data)
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["content"])
        self.assertEqual(serializer.errors["content"][0], "Unable to upload video and image together.")




    def test_upload_too_many_contents(self):
        data = {"content": [{"original": self.jpg_file} for _ in range(0, settings.MAX_CONTENT_ITEMS + 1)]}
        serializer = self.serializer(data=data)
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["content"])
        self.assertEqual(
            serializer.errors["content"][0],
            "Content items cannot be bigger than %s items." % settings.MAX_CONTENT_ITEMS,
        )




    def test_upload_two_video(self):
        data = {"content": [{"original": self.mp4_file}, {"original": self.mp4_file}]}
        serializer = self.serializer(data=data)
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["content"])
        self.assertEqual(serializer.errors["content"][0], "Unable to upload more than 1 video.")




    def test_validate(self):
        data = {"content": [{"original": self.jpg_file}]}
        serializer = self.serializer(data=data)
        self.assertTrue(serializer.is_valid())
        self.assertListEqual(list(serializer.validated_data.keys()), ["content"])






@pytest.mark.usefixtures("svg_file")
@pytest.mark.usefixtures("jpg_file")
@pytest.mark.usefixtures("oversize_png_file")
@pytest.mark.usefixtures("invalid_resolution_jpg_file")
@pytest.mark.usefixtures("mp4_file")
class TestPostMediaContentSerializer(unittest.TestCase):
    """Test post media content serializer"""



    def setUp(self) -> None:
        self.serializer = PostMediaContentSerializer




    def test_expected_fields(self):
        serializer = self.serializer(data={})
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["original"])




    def test_upload_unsupported_format(self):
        data = {"original": self.svg_file}
        serializer = self.serializer(data=data)
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["original"])
        self.assertEqual(serializer.errors["original"][0], "Unsupported extension format.")




    def test_upload_image_invalid_size(self):
        data = {"original": self.oversize_png_file}
        serializer = self.serializer(data=data)
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["original"])
        self.assertEqual(serializer.errors["original"][0], "The maximum file size that can be uploaded is 10MB.")




    def test_upload_image_invalid_resolution(self):
        data = {"original": self.invalid_resolution_jpg_file}
        serializer = self.serializer(data=data)
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(list(serializer.errors.keys()), ["original"])




    def test_upload_valid_file(self):
        data = {"original": self.jpg_file}
        serializer = self.serializer(data=data)
        self.assertTrue(serializer.is_valid())
        self.assertListEqual(list(serializer.validated_data.keys()), ["original", "type"])




    def test_upload_valid_video(self):
        data = {"original": self.mp4_file}
        serializer = self.serializer(data=data)
        self.assertTrue(serializer.is_valid())
        self.assertListEqual(list(serializer.validated_data.keys()), ["original", "type"])






class TestWebhookPostSerializer(unittest.TestCase):
    """Test webhook post serializer"""



    def setUp(self) -> None:
        """Set up method for WebhookPostSerializer"""
        self.post = PostFactory()
        self.post_media = PostMediaFactory(post=self.post)
        self.serializer = WebhookPostSerializer
        self.data = {
            "post": self.post.id,
            "post_media": self.post_media.id,
            "upload_video_path": "media/post-content/%s/video/formated/stream.m3u8" % self.post_media.id,
            "upload_preview_path": "media/post-content/%s/video/preview.jpg" % self.post_media.id,
        }




    def test_expected_fields(self) -> None:
        """Test expected fields"""
        serializer = self.serializer(data={})
        self.assertFalse(serializer.is_valid())
        self.assertListEqual(
            list(serializer.errors.keys()), ["post", "post_media", "upload_video_path", "upload_preview_path"]
        )




    def test_success(self) -> None:
        """Test succes case"""
        serializer = self.serializer(data=self.data)
        self.assertTrue(serializer.is_valid())
        self.assertListEqual(
            list(serializer.validated_data.keys()), ["post", "post_media", "upload_video_path", "upload_preview_path"]
        )
        self.assertNotIn("media", serializer.validated_data["upload_video_path"])
        self.assertNotIn("media", serializer.validated_data["upload_preview_path"])






class TestPostNotificationSerializer(unittest.TestCase):
    """Test post notification serializer"""



    def setUp(self) -> None:
        self.post = PostFactory()
        self.serializer = PostNotificationSerializer




    def test_data(self):
        serializer = self.serializer(self.post)
        self.assertListEqual(list(serializer.data.keys()), ["id", "preview"])