zod-backend/web_admin/tests/test_article.py

"""
web_admin test article file
"""
# django imports
from django.test import TestCase
from django.urls import reverse
from django.contrib.auth import get_user_model
from rest_framework.test import APITestCase
from rest_framework.test import APIClient
from rest_framework import status

# local imports
from web_admin.models import Article, ArticleCard, ArticleSurvey, DefaultArticleCardImage
from web_admin.tests.test_set_up import ArticleTestSetUp

# user model
User = get_user_model()


class ArticleViewSetTestCase(ArticleTestSetUp):
    """
    test cases for article create, update, list, retrieve, delete
    """
    def setUp(self):
        """
        inherit data here
        :return:
        """
        super(ArticleViewSetTestCase, self).setUp()

        # admin user authentication
        self.client.force_authenticate(user=self.admin_user)

    def test_article_create_with_default_card_image(self):
        """
        test article create with default card_image
        :return:
        """
        url = reverse(self.article_list_url)
        response = self.client.post(url, self.article_data_with_default_card_image, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Check that a new article was created
        self.assertEqual(Article.objects.count(), 2)

    def test_article_create_with_base64_card_image(self):
        """
        test article create with base64 card image
        :return:
        """
        self.client.force_authenticate(user=self.admin_user)
        url = reverse(self.article_list_url)
        response = self.client.post(url, self.article_data_with_base64_card_image, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Check that a new article was created
        self.assertEqual(Article.objects.count(), 2)

    def test_article_update(self):
        """
        test article update
        :return:
        """
        self.client.force_authenticate(user=self.admin_user)
        url = reverse(self.article_detail_url, kwargs={'pk': self.article.id})
        response = self.client.put(url, self.article_update_data, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.article.refresh_from_db()
        self.assertEqual(self.article.title, self.article_update_data['title'])
        self.assertEqual(self.article.article_cards.count(), 1)
        self.assertEqual(self.article.article_survey.count(), 6)
        self.assertEqual(self.article.article_survey.first().options.count(), 3)

    def test_articles_list(self):
        """
        test articles list
        :return:
        """
        url = reverse(self.article_list_url)
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Assuming only one article exists in the database
        self.assertEqual(len(response.data['data']), 1)

    def test_article_retrieve(self):
        """
        test article retrieve
        :return:
        """
        url = reverse(self.article_detail_url, kwargs={'pk': self.article.id})
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_article_delete(self):
        """
        test article delete
        :return:
        """
        url = reverse(self.article_detail_url, kwargs={'pk': self.article.id})
        response = self.client.delete(url)
        self.article.refresh_from_db()
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(self.article.is_deleted, True)

    def test_article_create_with_invalid_data(self):
        """
        test article create with invalid data
        :return:
        """
        url = reverse(self.article_list_url)
        # Missing article_cards
        invalid_data = {
            "title": "Invalid Article",
            "article_survey": [{"question": "Invalid Survey Question"}]
        }
        response = self.client.post(url, invalid_data, format='json')
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_article_status_change(self):
        """
        test article status change (publish/un-publish)
        :return:
        """
        url = reverse('web_admin:article-status-change', kwargs={'pk': self.article.id})
        data = {
            "is_published": False
        }
        response = self.client.patch(url, data, format='json')
        self.article.refresh_from_db()
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(self.article.is_published, False)

    def test_article_card_remove(self):
        """
        test article card remove
        :return:
        """
        url = reverse('web_admin:article-remove-card', kwargs={'pk': self.article_card.id})
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(ArticleCard.objects.count(), 0)

    def test_article_survey_remove(self):
        """
        test article survey remove
        :return:
        """
        url = reverse('web_admin:article-remove-survey', kwargs={'pk': self.article_survey.id})
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(ArticleSurvey.objects.count(), 0)

    def test_article_card_create_with_default_card_image(self):
        """
        test article card create with default card_image
        :return:
        """
        url = reverse('web_admin:article-test-add-card')
        response = self.client.post(url, self.article_card_data_with_default_card_image, format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Check that a new article card was created
        self.assertEqual(ArticleCard.objects.count(), 2)

    def test_article_cards_list(self):
        """
        test article cards list
        :return:
        """
        url = reverse('web_admin:article-test-list-card')
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Assuming only one article exists in the database
        self.assertEqual(len(response.data['data']), 1)


class DefaultArticleCardImagesViewSetTestCase(APITestCase):
    """
    test case for default article card image
    """
    def setUp(self):
        """
        data setup
        :return:
        """
        self.client = APIClient()
        self.admin_user = User.objects.create_user(username='admin@example.com', email='admin@example.com',
                                                   password='admin@1234', is_staff=True, is_superuser=True)
        self.default_image = DefaultArticleCardImage.objects.create(
                                                        image_name="card1.jpg",
                                                        image_url="https://example.com/updated_card1.jpg")

    def test_default_article_card_image_list(self):
        """
        test default article card image list
        :return:
        """
        self.client.force_authenticate(user=self.admin_user)
        url = reverse('web_admin:default-card-images-list')
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Assuming only one default article card image exists in the database
        self.assertEqual(len(response.data['data']), 1)


class ArticleListViewSetTestCase(ArticleTestSetUp):
    """
    test cases for article list for junior
    """
    def setUp(self):
        """
        data setup
        :return:
        """
        super(ArticleListViewSetTestCase, self).setUp()

        self.client.force_authenticate(user=self.user)

    def test_article_list(self):
        """
        test article list
        :return:
        """
        url = reverse('web_admin:article-list-list')
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Assuming only one article exists in the database
        self.assertEqual(len(response.data['data']), 1)


class ArticleCardListViewSetTestCase(ArticleTestSetUp):
    """
    test cases for article card list for junior
    """
    def setUp(self):
        """
        data setup
        :return:
        """
        super(ArticleCardListViewSetTestCase, self).setUp()

        self.client.force_authenticate(user=self.user)

    def test_article_cards_list(self):
        """
        test article cards list for junior
        :return:
        """
        url = reverse('web_admin:article-card-list-list')
        query_params = {
            'article_id': self.article.id,
        }
        response = self.client.get(url, query_params)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        # Assuming only one article exists in the database
        self.assertEqual(len(response.data['data']), 1)

    # Add more test cases for edge cases, permissions, etc.