Refactorise les tests des vues de la bibliothèque

Author: Arnaud-D

zds/tutorialv2/tests/factories.py

@@ -242,7 +242,7 @@ class PublishedContentFactory(PublishableContentFactory):
     """
 
     @classmethod
-    def _generate(cls, create, attrs):
+    def _generate(cls, create, attrs) -> PublishableContent:
         # This parameter is only used inside _generate() and won't be saved in the database,
         # which is why we use attrs.pop() (it is removed from attrs).
         is_major_update = attrs.pop("is_major_update", True)

zds/tutorialv2/tests/tests_lists.py

@@ -65,14 +65,6 @@ def test_public_lists(self):
         article_unpublished = PublishableContentFactory(author_list=[self.user_author], type="ARTICLE")
         self.client.logout()
 
-        resp = self.client.get(reverse("publication:list") + "?type=tutorial")
-        self.assertContains(resp, tutorial.title)
-        self.assertNotContains(resp, tutorial_unpublished.title)
-
-        resp = self.client.get(reverse("publication:list") + "?type=article")
-        self.assertContains(resp, article.title)
-        self.assertNotContains(resp, article_unpublished.title)
-
         resp = self.client.get(reverse("tutorial:find-tutorial", args=[self.user_author.username]) + "?filter=public")
         self.assertContains(resp, tutorial.title)
         self.assertNotContains(resp, tutorial_unpublished.title)

zds/tutorialv2/tests/tests_views/tests_published.py

@@ -35,8 +35,8 @@
     PublishedContentFactory,
 )
 from zds.utils.header_notifications import get_header_notifications
-from zds.utils.models import Alert, Hat, Tag
-from zds.utils.tests.factories import CategoryFactory, LicenceFactory, SubCategoryFactory
+from zds.utils.models import Alert, Hat
+from zds.utils.tests.factories import LicenceFactory, SubCategoryFactory
 
 overridden_zds_app = deepcopy(settings.ZDS_APP)
 overridden_zds_app["content"]["repo_private_path"] = settings.BASE_DIR / "contents-private-test"
@@ -1599,177 +1599,6 @@ def test_obsolete(self):
         self.assertEqual(result.status_code, 200)
         self.assertNotContains(result, _("Ce contenu est obsolète."))
 
-    def test_list_publications(self):
-        """Test the behavior of the publication list"""
-
-        category_1 = CategoryFactory()
-        category_2 = CategoryFactory()
-        subcategory_1 = SubCategoryFactory(category=category_1)
-        subcategory_2 = SubCategoryFactory(category=category_1)
-        subcategory_3 = SubCategoryFactory(category=category_2)
-        subcategory_4 = SubCategoryFactory(category=category_2)
-        tag_1 = Tag(title="random")
-        tag_1.save()
-
-        tuto_p_1 = PublishedContentFactory(author_list=[self.user_author])
-        tuto_p_2 = PublishedContentFactory(author_list=[self.user_author])
-        tuto_p_3 = PublishedContentFactory(author_list=[self.user_author])
-
-        article_p_1 = PublishedContentFactory(author_list=[self.user_author], type="ARTICLE")
-
-        tuto_p_1.subcategory.add(subcategory_1)
-        tuto_p_1.subcategory.add(subcategory_2)
-        tuto_p_1.save()
-
-        tuto_p_2.subcategory.add(subcategory_1)
-        tuto_p_2.subcategory.add(subcategory_2)
-        tuto_p_2.save()
-
-        tuto_p_3.subcategory.add(subcategory_3)
-        tuto_p_3.save()
-
-        article_p_1.subcategory.add(subcategory_4)
-        article_p_1.tags.add(tag_1)
-        article_p_1.save()
-
-        tuto_1 = PublishedContent.objects.get(content=tuto_p_1.pk)
-        tuto_2 = PublishedContent.objects.get(content=tuto_p_2.pk)
-        tuto_3 = PublishedContent.objects.get(content=tuto_p_3.pk)
-        article_1 = PublishedContent.objects.get(content=article_p_1.pk)
-
-        self.assertEqual(PublishableContent.objects.filter(type="ARTICLE").count(), 1)
-        self.assertEqual(PublishableContent.objects.filter(type="TUTORIAL").count(), 4)
-
-        # 1. Publication list
-        result = self.client.get(reverse("publication:list"))
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["last_contents"]), 5)
-
-        # 2. Category page
-        result = self.client.get(reverse("publication:category", kwargs={"slug": category_1.slug}))
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["last_contents"]), 2)
-
-        pks = [x.pk for x in result.context["last_contents"]]
-        self.assertIn(tuto_1.pk, pks)
-        self.assertIn(tuto_2.pk, pks)
-
-        result = self.client.get(reverse("publication:category", kwargs={"slug": category_2.slug}))
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["last_contents"]), 2)
-
-        pks = [x.pk for x in result.context["last_contents"]]
-        self.assertIn(tuto_3.pk, pks)
-        self.assertIn(article_1.pk, pks)
-
-        # 3. Subcategory page
-        result = self.client.get(
-            reverse("publication:subcategory", kwargs={"slug_category": category_1.slug, "slug": subcategory_1.slug})
-        )
-
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["last_contents"]), 2)
-
-        pks = [x.pk for x in result.context["last_contents"]]
-        self.assertIn(tuto_1.pk, pks)
-        self.assertIn(tuto_2.pk, pks)
-
-        result = self.client.get(
-            reverse("publication:subcategory", kwargs={"slug_category": category_1.slug, "slug": subcategory_2.slug})
-        )
-
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["last_contents"]), 2)
-
-        pks = [x.pk for x in result.context["last_contents"]]
-        self.assertIn(tuto_1.pk, pks)
-        self.assertIn(tuto_2.pk, pks)
-
-        result = self.client.get(
-            reverse("publication:subcategory", kwargs={"slug_category": category_2.slug, "slug": subcategory_3.slug})
-        )
-
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["last_contents"]), 1)
-
-        pks = [x.pk for x in result.context["last_contents"]]
-        self.assertIn(tuto_3.pk, pks)
-
-        result = self.client.get(
-            reverse("publication:subcategory", kwargs={"slug_category": category_2.slug, "slug": subcategory_4.slug})
-        )
-
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["last_contents"]), 1)
-
-        pks = [x.pk for x in result.context["last_contents"]]
-        self.assertIn(article_1.pk, pks)
-
-        # 4. Final page and filters
-        result = self.client.get(reverse("publication:list") + f"?category={category_1.slug}")
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["filtered_contents"]), 2)
-        pks = [x.pk for x in result.context["filtered_contents"]]
-        self.assertIn(tuto_1.pk, pks)
-        self.assertIn(tuto_2.pk, pks)
-
-        # filter by category and type
-        result = self.client.get(reverse("publication:list") + f"?category={category_2.slug}")
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["filtered_contents"]), 2)
-        pks = [x.pk for x in result.context["filtered_contents"]]
-        self.assertIn(tuto_3.pk, pks)
-        self.assertIn(article_1.pk, pks)
-
-        # filter by subcategory
-        result = self.client.get(reverse("publication:list") + f"?subcategory={subcategory_1.slug}")
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["filtered_contents"]), 2)
-        pks = [x.pk for x in result.context["filtered_contents"]]
-        self.assertIn(tuto_1.pk, pks)
-        self.assertIn(tuto_2.pk, pks)
-
-        # filter by subcategory and type
-        result = self.client.get(reverse("publication:list") + f"?subcategory={subcategory_3.slug}")
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["filtered_contents"]), 1)
-        pks = [x.pk for x in result.context["filtered_contents"]]
-        self.assertIn(tuto_3.pk, pks)
-
-        # filter by tag
-        result = self.client.get(reverse("publication:list") + f"?tag={tag_1.slug}" + "&type=article")
-        self.assertEqual(result.status_code, 200)
-
-        self.assertEqual(len(result.context["filtered_contents"]), 1)
-        pks = [x.pk for x in result.context["filtered_contents"]]
-        self.assertIn(article_1.pk, pks)
-
-        # 5. Everything else results in 404
-        wrong_urls = [
-            # not existing (sub)categories, types or tags with slug "xxx"
-            reverse("publication:list") + "?category=xxx",
-            reverse("publication:list") + "?subcategory=xxx",
-            reverse("publication:list") + "?tag=xxx",
-            reverse("publication:category", kwargs={"slug": "xxx"}),
-            reverse("publication:subcategory", kwargs={"slug_category": category_2.slug, "slug": "xxx"}),
-            # subcategory_1 does not belong to category_2:
-            reverse("publication:subcategory", kwargs={"slug_category": category_2.slug, "slug": subcategory_1.slug}),
-        ]
-
-        for url in wrong_urls:
-            self.assertEqual(self.client.get(url).status_code, 404, msg=url)
-
     def test_article_previous_link(self):
         """Test the behaviour of the article previous link."""
 

zds/tutorialv2/tests/tests_views/tests_viewpublications.py

@@ -0,0 +1,144 @@
+from copy import deepcopy
+
+from django.conf import settings
+from django.test import TestCase
+from django.test.utils import override_settings
+from django.urls import reverse
+
+from zds.member.tests.factories import ProfileFactory
+from zds.tutorialv2.models.database import PublishableContent
+from zds.tutorialv2.tests import TutorialTestMixin
+from zds.tutorialv2.tests.factories import PublishableContentFactory, PublishedContentFactory
+from zds.utils.models import Tag
+from zds.utils.tests.factories import CategoryFactory, SubCategoryFactory
+
+overridden_zds_app = deepcopy(settings.ZDS_APP)
+overridden_zds_app["content"]["repo_private_path"] = settings.BASE_DIR / "contents-private-test"
+overridden_zds_app["content"]["repo_public_path"] = settings.BASE_DIR / "contents-public-test"
+overridden_zds_app["content"]["extra_content_generation_policy"] = "NOTHING"
+
+
+@override_settings(MEDIA_ROOT=settings.BASE_DIR / "media-test")
+@override_settings(ZDS_APP=overridden_zds_app)
+@override_settings(SEARCH_ENABLED=False)
+class ViewPublicationsTest(TutorialTestMixin, TestCase):
+    """Test the library pages."""
+
+    def setUp(self):
+        self.author = ProfileFactory().user
+
+        self.category_1 = CategoryFactory()
+        self.category_2 = CategoryFactory()
+        self.subcategory_1 = SubCategoryFactory(category=self.category_1)
+        self.subcategory_2 = SubCategoryFactory(category=self.category_1)
+        self.subcategory_3 = SubCategoryFactory(category=self.category_2)
+        self.subcategory_4 = SubCategoryFactory(category=self.category_2)
+        self.tag_1 = Tag.objects.create(title="random")
+
+        # unpublished content
+        PublishableContentFactory(author_list=[self.author])
+
+        tuto_p_1 = PublishedContentFactory(author_list=[self.author])
+        tuto_p_1.subcategory.add(self.subcategory_1)
+        tuto_p_1.subcategory.add(self.subcategory_2)
+        self.tuto_1 = tuto_p_1.public_version
+
+        tuto_p_2 = PublishedContentFactory(author_list=[self.author])
+        tuto_p_2.subcategory.add(self.subcategory_1)
+        tuto_p_2.subcategory.add(self.subcategory_2)
+        self.tuto_2 = tuto_p_2.public_version
+
+        tuto_p_3 = PublishedContentFactory(author_list=[self.author])
+        tuto_p_3.subcategory.add(self.subcategory_3)
+        self.tuto_3 = tuto_p_3.public_version
+
+        article_p_1 = PublishedContentFactory(author_list=[self.author], type="ARTICLE")
+        article_p_1.subcategory.add(self.subcategory_4)
+        article_p_1.tags.add(self.tag_1)
+        self.article_1 = article_p_1.public_version
+
+        self.assertEqual(PublishableContent.objects.filter(type="ARTICLE").count(), 1)
+        self.assertEqual(PublishableContent.objects.filter(type="TUTORIAL").count(), 3)
+
+    def test_library_main_page(self):
+        result = self.client.get(reverse("publication:list"))
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(
+            result.context["last_contents"], [self.article_1, self.tuto_3, self.tuto_2, self.tuto_1]
+        )
+
+    def test_category_page_1(self):
+        result = self.client.get(reverse("publication:category", kwargs={"slug": self.category_1.slug}))
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["last_contents"], [self.tuto_2, self.tuto_1])
+
+    def test_category_page_2(self):
+        result = self.client.get(reverse("publication:category", kwargs={"slug": self.category_2.slug}))
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["last_contents"], [self.article_1, self.tuto_3])
+
+    def test_subcategory_1(self):
+        kwargs = {"slug_category": self.category_1.slug, "slug": self.subcategory_1.slug}
+        result = self.client.get(reverse("publication:subcategory", kwargs=kwargs))
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["last_contents"], [self.tuto_2, self.tuto_1])
+
+    def test_subcategory_2(self):
+        kwargs = {"slug_category": self.category_1.slug, "slug": self.subcategory_2.slug}
+        result = self.client.get(reverse("publication:subcategory", kwargs=kwargs))
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["last_contents"], [self.tuto_2, self.tuto_1])
+
+    def test_subcategory_3(self):
+        kwargs = {"slug_category": self.category_2.slug, "slug": self.subcategory_3.slug}
+        result = self.client.get(reverse("publication:subcategory", kwargs=kwargs))
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["last_contents"], [self.tuto_3])
+
+    def test_subcategory_4(self):
+        kwargs = {"slug_category": self.category_2.slug, "slug": self.subcategory_4.slug}
+        result = self.client.get(reverse("publication:subcategory", kwargs=kwargs))
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["last_contents"], [self.article_1])
+
+    def test_content_list_page_1(self):
+        result = self.client.get(reverse("publication:list") + f"?category={self.category_1.slug}")
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["filtered_contents"], [self.tuto_2, self.tuto_1])
+
+    def test_content_list_page_2(self):
+        result = self.client.get(reverse("publication:list") + f"?category={self.category_2.slug}")
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["filtered_contents"], [self.article_1, self.tuto_3])
+
+    def test_content_list_page_3(self):
+        result = self.client.get(reverse("publication:list") + f"?subcategory={self.subcategory_1.slug}")
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["filtered_contents"], [self.tuto_2, self.tuto_1])
+
+    def test_content_list_page_4(self):
+        result = self.client.get(reverse("publication:list") + f"?subcategory={self.subcategory_3.slug}")
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["filtered_contents"], [self.tuto_3])
+
+    def test_content_list_page_(self):
+        result = self.client.get(reverse("publication:list") + f"?tag={self.tag_1.slug}")
+        self.assertEqual(result.status_code, 200)
+        self.assertQuerySetEqual(result.context["filtered_contents"], [self.article_1])
+
+    def test_wrong_urls(self):
+        # not existing (sub)categories and tags with slug not existing
+        wrong_urls = [
+            reverse("publication:list") + "?category=xxx",
+            reverse("publication:list") + "?subcategory=xxx",
+            reverse("publication:list") + "?tag=xxx",
+            reverse("publication:category", kwargs={"slug": "xxx"}),
+            reverse("publication:subcategory", kwargs={"slug_category": self.category_2.slug, "slug": "xxx"}),
+            # subcategory_1 does not belong to category_2:
+            reverse(
+                "publication:subcategory",
+                kwargs={"slug_category": self.category_2.slug, "slug": self.subcategory_1.slug},
+            ),
+        ]
+        for url in wrong_urls:
+            self.assertEqual(self.client.get(url).status_code, 404, msg=url)