django-camomilla-cms 6.0.0b15__py2.py3-none-any.whl → 6.0.0b17__py2.py3-none-any.whl

tests/test_pages.py

@@ -0,0 +1,343 @@
+import pytest
+from django.test import TestCase
+from rest_framework.test import APIClient
+from .utils.api import login_superuser
+from camomilla.models import Page
+from camomilla.models.page import UrlRedirect
+from datetime import datetime, timedelta
+
+
+class PagesTestCase(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        token = login_superuser()
+        self.client.credentials(HTTP_AUTHORIZATION='Token ' +  token)
+
+    @pytest.mark.django_db
+    def test_pages_api_no_access(self):
+        client = APIClient()
+        response = client.post("/api/camomilla/pages/")
+        assert response.status_code == 401
+
+    @pytest.mark.django_db
+    def test_pages_api_crud(self):
+        # Create page
+        response = self.client.post(
+            "/api/camomilla/pages/",
+            {
+              "translations": {
+                "it": {
+                  "title": "title_page_1",
+                }
+              }
+            },
+            format='json'
+        )
+
+        assert response.status_code == 201
+        assert len(Page.objects.all()) == 1
+        page = Page.objects.first()
+        assert page.id == 1
+        assert page.title_it == "title_page_1"
+        assert page.url_node.id == 1
+
+        response = self.client.post(
+            "/api/camomilla/pages/",
+            {
+              "title_it": "title_page_2",
+            }
+        )
+
+        assert response.status_code == 201
+        assert len(Page.objects.all()) == 2
+        page = Page.objects.last()
+        assert page.id == 2
+        assert page.title_it == "title_page_2"
+        assert page.url_node.id == 2
+
+         # Update page
+        response = self.client.patch(
+          "/api/camomilla/pages/2/",
+          {
+            "translations": {
+              "it": {
+                "title": "title_page_2_updated",
+              }
+            }
+          },
+          format='json'
+        )
+
+        assert response.status_code == 200
+        assert len(Page.objects.all()) == 2
+        page = Page.objects.last()
+        assert page.id == 2
+        assert page.title_it == "title_page_2_updated"
+
+        # Read page
+        response = self.client.get("/api/camomilla/pages/2/")
+
+        assert response.status_code == 200
+        assert response.json()['id'] == 2
+        assert response.json()['title'] == "title_page_2_updated"
+
+        # Read pages
+        response = self.client.get("/api/camomilla/pages/")
+
+        assert response.status_code == 200
+        assert response.json()[0]['id'] == 1
+        assert response.json()[0]['title'] == "title_page_1"
+        assert response.json()[1]['id'] == 2
+        assert response.json()[1]['title'] == "title_page_2_updated"
+
+        # Delete page
+        response = self.client.delete("/api/camomilla/pages/2/")
+
+        assert response.status_code == 204
+        assert len(Page.objects.all()) == 1
+        page = Page.objects.last()
+        assert page.id == 1
+        assert page.title_it == "title_page_1"
+
+    @pytest.mark.django_db
+    def test_pages_url_nodes(self):
+        # Create page with automatic url creation
+        response = self.client.post(
+            "/api/camomilla/pages/",
+            {
+              "title_en": "title_page_1",
+              "title_it": "titolo_pagina_1",
+            }
+        )
+
+        assert response.status_code == 201
+
+        # EN automatic url creation
+        response = self.client.get("/api/camomilla/pages/1/?language=en")
+        assert response.json()['autopermalink'] == True
+        assert response.json()['permalink'] == "/title_page_1"
+        # IT automatic url creation
+        response = self.client.get("/api/camomilla/pages/1/?language=it")
+        assert response.json()['autopermalink'] == True
+        assert response.json()['permalink'] == "/titolo_pagina_1"
+
+        # Create page with manual url creation
+        response = self.client.post(
+            "/api/camomilla/pages/",
+            {
+              "translations": {
+                "it": {
+                  "title": "titolo_pagina_2",
+                  "permalink": "permalink_manuale_it_2",
+                  "autopermalink": False
+                },
+                "en": {
+                  "title": "title_page_2",
+                  "permalink": "permalink_manual_en_2",
+                  "autopermalink": False
+                }
+              }
+            },
+            format='json'
+        )
+        assert response.status_code == 201
+
+        # EN manual url creation
+        response = self.client.get("/api/camomilla/pages/2/?language=en")
+        assert response.json()['autopermalink'] == False
+        assert response.json()['permalink'] == "/permalink_manual_en_2"
+        # IT manual url creation
+        response = self.client.get("/api/camomilla/pages/2/?language=it")
+        assert response.json()['autopermalink'] == False
+        assert response.json()['permalink'] == "/permalink_manuale_it_2"
+
+        # Create page with a parent page with automatic url creation
+        response = self.client.post(
+            "/api/camomilla/pages/",
+            {
+              "title_en": "title_page_3",
+              "title_it": "titolo_pagina_3",
+              "parent_page": 2
+            }
+        )
+        assert response.status_code == 201
+
+        # EN parent page with automatic url creation
+        response = self.client.get("/api/camomilla/pages/3/?language=en")
+        assert response.json()['autopermalink'] == True
+        assert response.json()['permalink'] == "//permalink_manual_en_2/title_page_3"
+        # IT parent page with automatic url creation
+        response = self.client.get("/api/camomilla/pages/3/?language=it")
+        assert response.json()['autopermalink'] == True
+        assert response.json()['permalink'] == "//permalink_manuale_it_2/titolo_pagina_3"
+
+        # Check url uniqueness and consistency EN
+        response = self.client.post(
+            "/api/camomilla/pages/",
+            {
+              "autopermalink_en": False,
+              "permalink_en": "permalink_manual_en_2",
+            }
+        )
+
+        # Client error when url check uniqueness and consistency fail
+        assert response.status_code == 400
+        assert response.data['permalink_en'][0] == "There is an other page with same permalink."
+
+        # Check url uniqueness and consistency IT
+        response = self.client.post(
+            "/api/camomilla/pages/",
+            {
+              "translations": {
+                "it": {
+                  "autopermalink": False,
+                  "permalink": "permalink_manuale_it_2",
+                }
+              }
+            },
+            format='json'
+        )
+
+        # Client error when url check uniqueness and consistency fail
+        assert response.status_code == 400
+        assert response.data['permalink_it'][0] == "There is an other page with same permalink."
+    
+    @pytest.mark.django_db
+    def test_pages_url_nodes_navigation(self):
+        #Test the camomilla.dynamic_pages_url handler for navigating and rendering UrlNodes
+        self.client.post(
+            "/api/camomilla/pages/", 
+            {
+              "autopermalink_en": False,
+              "permalink_en": "permalink_4_en",
+              "status_en": "PUB",
+              "autopermalink_it": False,
+              "permalink_it": "permalink_4_it",
+              "status_it": "PUB",
+            }
+        )
+
+        response = self.client.get("/permalink_4_en/")
+        assert response.status_code == 200
+        response = self.client.get("/it/permalink_4_it/")
+        assert response.status_code == 200
+
+        #Test draft - published - planned and ?preview=true
+        self.client.post(
+            "/api/camomilla/pages/", 
+            {
+              "translations": {
+                "it": {
+                  "autopermalink": False,
+                  "permalink": "permalink_5_it",
+                  "status": "PLA",
+                },
+                "en": {
+                  "autopermalink": False,
+                  "permalink": "permalink_5_en",
+                  "status": "DRF",
+                }
+              }
+            },
+            format='json'
+        )
+
+        response = self.client.get("/permalink_5_en/")
+        assert response.status_code == 404
+        response = self.client.get("/permalink_5_en/?preview=true")
+        assert response.status_code == 200
+        response = self.client.get("/it/permalink_5_it/")
+        assert response.status_code == 404
+
+        self.client.patch(
+            "/api/camomilla/pages/2/",
+            {
+              "publication_date": (datetime.now() - timedelta(1)).strftime('%Y-%m-%d') +  " 00:00:00",
+            }
+        )
+
+        response = self.client.get("/it/permalink_5_it/")
+        assert response.status_code == 200
+
+    @pytest.mark.django_db
+    def test_pages_url_nodes_navigation_redirects(self):
+        #Test the camomilla.dynamic_pages_url handler for navigating and rendering UrlNodes
+        self.client.post(
+            "/api/camomilla/pages/", 
+            {
+              "translations": {
+                "it": {
+                  "autopermalink": False,
+                  "permalink": "permalink_6_it",
+                  "status": "PUB",
+                },
+                "en": {
+                  "autopermalink": False,
+                  "permalink": "permalink_6_en",
+                  "status": "PUB",
+                }
+              }
+            },
+            format='json'
+        )
+
+        #EN Insert Moved Permanently Redirect 
+        url_redirect = UrlRedirect.objects.create(
+          language_code='en',
+          from_url='/redirecting_1',
+          to_url='/redirected_1',
+          url_node_id=1
+        )
+
+        response = self.client.get("/redirecting_1/")
+        assert response.status_code == 301
+        assert response.url == '/redirected_1/'
+
+        #EN Change to Moved Temporarily Redirect 
+        url_redirect.permanent = False
+        url_redirect.save()
+        response = self.client.get("/redirecting_1/")
+        assert response.status_code == 302
+        
+
+        #IT Insert Moved Permanently Redirect 
+        url_redirect = UrlRedirect.objects.create(
+          language_code='it',
+          from_url='/urlreindirizzamento_1',
+          to_url='/urlreindirizzato_1',
+          url_node_id=1
+        )
+
+        response = self.client.get("/it/urlreindirizzamento_1/")
+        assert response.status_code == 301
+        assert response.url == '/it/urlreindirizzato_1/'
+
+        #IT Change to Moved Temporarily Redirect 
+        url_redirect.permanent = False
+        url_redirect.save()
+        response = self.client.get("/it/urlreindirizzamento_1/")
+        assert response.status_code == 302
+
+        # Test auto redirect after permalink change
+        self.client.patch(
+            "/api/camomilla/pages/1/",
+            {
+              "translations": {
+                "it": {
+                  "permalink": "permalink_6_it_changed",
+                },
+                "en": {
+                  "permalink": "permalink_6_en_changed",
+                }
+              }
+            },
+            format='json'
+        )
+
+        response = self.client.get("/permalink_6_en/")
+        assert response.status_code == 301
+        assert response.url == '/permalink_6_en_changed/'
+
+        response = self.client.get("/it/permalink_6_it/")
+        assert response.status_code == 301
+        assert response.url == '/it/permalink_6_it_changed/'

tests/test_query_parser.py

@@ -0,0 +1,58 @@
+import pytest
+from django.db.models import Q
+from camomilla.utils.query_parser import (
+    ConditionParser,
+)
+
+
+@pytest.mark.parametrize(
+    "query, expected_q",
+    [
+        # Single condition
+        ("name__icontains=foo", Q(name__icontains="foo")),
+        # Multiple conditions with AND
+        (
+            "name__icontains=foo AND age__gt=21",
+            Q(name__icontains="foo") & Q(age__gt=21),
+        ),
+        # Multiple conditions with OR
+        (
+            "name__icontains=foo OR name__icontains=bar",
+            Q(name__icontains="foo") | Q(name__icontains="bar"),
+        ),
+        # Mixed AND and OR conditions
+        (
+            "name__icontains=foo OR (age__gt=21 AND city__iexact='New York')",
+            Q(name__icontains="foo") | (Q(age__gt=21) & Q(city__iexact="New York")),
+        ),
+        # Nested parentheses with OR inside AND
+        (
+            "((name__icontains=foo) OR (name__icontains=bar)) AND name__icontains=baz",
+            (Q(name__icontains="foo") | Q(name__icontains="bar"))
+            & Q(name__icontains="baz"),
+        ),
+        # Complex nested conditions with multiple OR and AND
+        (
+            "((name__icontains=foo) OR (name__icontains=bar) OR (name__icontains=buz)) AND age__gt=25 AND city__iexact='LA'",
+            (
+                Q(name__icontains="foo")
+                | Q(name__icontains="bar")
+                | Q(name__icontains="buz")
+            )
+            & Q(age__gt=25)
+            & Q(city__iexact="LA"),
+        ),
+        # Single condition with no parentheses
+        ("age__lte=30", Q(age__lte=30)),
+        # Simple nested OR and AND with more levels of nesting
+        (
+            "(name__icontains=foo AND (age__gt=21 OR city__iexact='New York')) OR country__iexact='US'",
+            (Q(name__icontains="foo") & (Q(age__gt=21) | Q(city__iexact="New York")))
+            | Q(country__iexact="US"),
+        ),
+    ],
+)
+def test_condition_parser(query, expected_q):
+    parser = ConditionParser(query)
+    q_object = parser.parse_to_q()
+    assert q_object.__str__() == expected_q.__str__()

tests/test_templates_context.py

@@ -0,0 +1,111 @@
+import pytest
+import json
+import re
+from django.test import TestCase
+from rest_framework.test import APIClient
+from .utils.api import login_superuser
+from .utils.media import load_asset_and_remove_media
+
+class TemoplateContextTestCase(TestCase):
+    def setUp(self):
+        self.client = APIClient()
+        token = login_superuser()
+        self.client.credentials(HTTP_AUTHORIZATION='Token ' +  token)
+
+    @pytest.mark.django_db
+    def test_page_context_template_based(self):
+        # Create page with custom context template
+        response = self.client.post(
+            "/api/camomilla/pages/",
+            {
+              "title_en": "Page custom context template",
+              "autopermalink_en": False,
+              "permalink_en": "permalink_context_template",
+              "template": "website/page_context_template_based.html",
+              "status_en": "PUB",
+            },
+            format="multipart",
+        )
+        assert response.status_code == 201
+
+        # Create media for custom context
+        asset = load_asset_and_remove_media("10595073.png")
+        response = self.client.post(
+            "/api/camomilla/media/",
+            {
+                "file": asset,
+                "data": json.dumps({"translations": {"en": {"alt_text": "Test media", "title": "Test media", "description": "Description media"}}}),
+            },
+            format="multipart",
+        )
+        assert response.status_code == 201
+
+        response = self.client.get("/permalink_context_template/")
+        assert response.status_code == 200
+        assert re.sub(r'[\s+]', '', response.content.decode()) == '<!DOCTYPEhtml><html><body><h1>Titlepageforpagecontexttemplatebased</h1><p>Contentpageforpagecontexttemplatebased</p><ul><li>Testmedia</li></ul></body></html>'
+
+
+    @pytest.mark.django_db
+    def test_model_context_template_based(self):
+        # Create page with custom context template
+        response = self.client.post(
+            "/api/camomilla/pages/",
+            {
+              "title_en": "Page custom context template",
+              "autopermalink_en": False,
+              "permalink_en": "permalink_context_template",
+              "template": "website/page_context_model_based.html",
+              "status_en": "PUB",
+            },
+            format="multipart",
+        )
+        assert response.status_code == 201
+
+        # Create media for custom context
+        asset = load_asset_and_remove_media("10595073.png")
+        response = self.client.post(
+            "/api/camomilla/media/",
+            {
+                "file": asset,
+                "data": json.dumps({"translations": {"en": {"alt_text": "Test media", "title": "Test media", "description": "Description media"}}}),
+            },
+            format="multipart",
+        )
+        assert response.status_code == 201
+
+        response = self.client.get("/permalink_context_template/")
+        assert response.status_code == 200
+        assert re.sub(r'[\s+]', '', response.content.decode()) == '<!DOCTYPEhtml><html><body><h1>Titlepageforpagecontextmodelbased</h1><p>Contentpageforpagecontextmodelbased</p><ul><li>Testmedia</li></ul></body></html>'
+
+
+    @pytest.mark.django_db
+    def test_mixed_context_template(self):
+        # Create page with custom context template
+        response = self.client.post(
+            "/api/camomilla/pages/",
+            {
+              "title_en": "Page custom context template",
+              "autopermalink_en": False,
+              "permalink_en": "permalink_context_template",
+              "template": "website/page_context_mixed.html",
+              "status_en": "PUB",
+            },
+            format="multipart",
+        )
+        assert response.status_code == 201
+
+        # Create media for custom context
+        asset = load_asset_and_remove_media("10595073.png")
+        response = self.client.post(
+            "/api/camomilla/media/",
+            {
+                "file": asset,
+                "data": json.dumps({"translations": {"en": {"alt_text": "Test media", "title": "Test media", "description": "Description media"}}}),
+            },
+            format="multipart",
+        )
+        assert response.status_code == 201
+
+        response = self.client.get("/permalink_context_template/")
+        assert response.status_code == 200
+        assert re.sub(r'[\s+]', '', response.content.decode()) == '<!DOCTYPEhtml><html><body><!--Templatecontext--><h1>Titlepageforpagecontexttemplatebased</h1><p>Contentpageforpagecontexttemplatebased</p><ul><li>Testmedia</li></ul><!--Modelcontext--><h1>Titlepageforpagecontextmodelbased</h1><p>Contentpageforpagecontextmodelbased</p><ul><li>Testmedia</li></ul></body></html>'

tests/test_utils.py

@@ -13,74 +13,74 @@ from django.utils.translation import activate, get_language
 from requests import RequestException
 
 
-class UtilsTestCase(TestCase):
-    def setUp(self):
-        pass
+# class UtilsTestCase(TestCase):
+#     def setUp(self):
+#         pass
 
-    def test_get_host_url(self):
-        """Our beloved get_host_url utility"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/path")
-        request.META["HTTP_HOST"] = "localhost"
-        host_url = get_host_url(request)
-        self.assertEqual(host_url, "http://localhost")
-        host_url = get_host_url(None)
-        self.assertEqual(host_url, None)
+#     def test_get_host_url(self):
+#         """Our beloved get_host_url utility"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/path")
+#         request.META["HTTP_HOST"] = "localhost"
+#         host_url = get_host_url(request)
+#         self.assertEqual(host_url, "http://localhost")
+#         host_url = get_host_url(None)
+#         self.assertEqual(host_url, None)
 
-    def test_get_complete_url(self):
-        """Our beloved get_complete_url utility"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/path")
-        request.META["HTTP_HOST"] = "localhost"
-        complete_url = get_complete_url(request, "path")
-        self.assertEqual(complete_url, "http://localhost/path")
-        complete_url = get_complete_url(request, "path", "it")
-        self.assertEqual(complete_url, "http://localhost/path")
-        complete_url = get_complete_url(request, "path", "fr")
-        self.assertEqual(complete_url, "http://localhost/fr/path")
+#     def test_get_complete_url(self):
+#         """Our beloved get_complete_url utility"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/path")
+#         request.META["HTTP_HOST"] = "localhost"
+#         complete_url = get_complete_url(request, "path")
+#         self.assertEqual(complete_url, "http://localhost/path")
+#         complete_url = get_complete_url(request, "path", "it")
+#         self.assertEqual(complete_url, "http://localhost/path")
+#         complete_url = get_complete_url(request, "path", "fr")
+#         self.assertEqual(complete_url, "http://localhost/fr/path")
 
-    def test_get_page_with_default_seo(self):
-        """Our beloved get_seo utility with auto attributes"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/path")
-        request.META["HTTP_HOST"] = "localhost"
-        page = Page.get(request, identifier="home")
-        self.assertEqual(page.og_url, "http://localhost/path")
-        self.assertEqual(page.canonical, "http://localhost/path")
+#     def test_get_page_with_default_seo(self):
+#         """Our beloved get_seo utility with auto attributes"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/path")
+#         request.META["HTTP_HOST"] = "localhost"
+#         page = Page.get(request, identifier="home")
+#         self.assertEqual(page.og_url, "http://localhost/path")
+#         self.assertEqual(page.canonical, "http://localhost/path")
 
-    def test_get_article_with_default_seo(self):
-        """Our beloved get_seo utility with auto attributes"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/path")
-        request.META["HTTP_HOST"] = "localhost"
-        Article.objects.create(permalink="main")
-        article = Article.get(request, permalink="main")
-        self.assertEqual(article.og_url, "http://localhost/path")
-        self.assertEqual(article.canonical, "http://localhost/path")
+#     def test_get_article_with_default_seo(self):
+#         """Our beloved get_seo utility with auto attributes"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/path")
+#         request.META["HTTP_HOST"] = "localhost"
+#         Article.objects.create(permalink="main")
+#         article = Article.get(request, permalink="main")
+#         self.assertEqual(article.og_url, "http://localhost/path")
+#         self.assertEqual(article.canonical, "http://localhost/path")
 
-    def test_compile_seo_overwrite(self):
-        """Our beloved get_seo utility with auto attributes"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/path")
-        request.META["HTTP_HOST"] = "localhost"
-        article = Article.objects.create(permalink="main")
-        article.canonical = "/myarticle"
-        article.og_url = "/myarticle"
-        article.save()
-        article = Article.get(request, permalink="main")
-        self.assertEqual(article.og_url, "http://localhost/myarticle")
-        self.assertEqual(article.canonical, "http://localhost/myarticle")
+#     def test_compile_seo_overwrite(self):
+#         """Our beloved get_seo utility with auto attributes"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/path")
+#         request.META["HTTP_HOST"] = "localhost"
+#         article = Article.objects.create(permalink="main")
+#         article.canonical = "/myarticle"
+#         article.og_url = "/myarticle"
+#         article.save()
+#         article = Article.get(request, permalink="main")
+#         self.assertEqual(article.og_url, "http://localhost/myarticle")
+#         self.assertEqual(article.canonical, "http://localhost/myarticle")
 
-    def test_get_article_with_redirect(self):
-        """Our beloved get_seo utility with auto attributes"""
-        request_factory = RequestFactory()
-        request = request_factory.get("/articles/articolo-1")
-        request.META["HTTP_HOST"] = "localhost"
+#     def test_get_article_with_redirect(self):
+#         """Our beloved get_seo utility with auto attributes"""
+#         request_factory = RequestFactory()
+#         request = request_factory.get("/articles/articolo-1")
+#         request.META["HTTP_HOST"] = "localhost"
 
-        article = Article.objects.create(permalink="article-1", language_code="en")
-        article.translate("it")
-        article.permalink = "articolo-1"
-        article.save()
-        self.assertRaises(NeedARedirect, Article.get, request, permalink="article-1")
-        activate("de")
-        self.assertRaises(Http404, Article.get, request, permalink="article-1")
+#         article = Article.objects.create(permalink="article-1", language_code="en")
+#         article.translate("it")
+#         article.permalink = "articolo-1"
+#         article.save()
+#         self.assertRaises(NeedARedirect, Article.get, request, permalink="article-1")
+#         activate("de")
+#         self.assertRaises(Http404, Article.get, request, permalink="article-1")