1. from django.conf import settings

  2. from django.contrib.auth.models import User

  3. from django.contrib.flatpages.models import FlatPage

  4. from django.contrib.sites.models import Site

  5. from django.test import TestCase, modify_settings, override_settings

  6. 

  7. from .settings import FLATPAGES_TEMPLATES

  8. 

  9. 

  10. class TestDataMixin:

  11.     @classmethod

  12.     def setUpTestData(cls):

  13.         # don't use the manager because we want to ensure the site exists

  14.         # with pk=1, regardless of whether or not it already exists.

  15.         cls.site1 = Site(pk=1, domain="example.com", name="example.com")

  16.         cls.site1.save()

  17.         cls.fp1 = FlatPage.objects.create(

  18.             url="/flatpage/",

  19.             title="A Flatpage",

  20.             content="Isn't it flat!",

  21.             enable_comments=False,

  22.             template_name="",

  23.             registration_required=False,

  24.         )

  25.         cls.fp2 = FlatPage.objects.create(

  26.             url="/location/flatpage/",

  27.             title="A Nested Flatpage",

  28.             content="Isn't it flat and deep!",

  29.             enable_comments=False,

  30.             template_name="",

  31.             registration_required=False,

  32.         )

  33.         cls.fp3 = FlatPage.objects.create(

  34.             url="/sekrit/",

  35.             title="Sekrit Flatpage",

  36.             content="Isn't it sekrit!",

  37.             enable_comments=False,

  38.             template_name="",

  39.             registration_required=True,

  40.         )

  41.         cls.fp4 = FlatPage.objects.create(

  42.             url="/location/sekrit/",

  43.             title="Sekrit Nested Flatpage",

  44.             content="Isn't it sekrit and deep!",

  45.             enable_comments=False,

  46.             template_name="",

  47.             registration_required=True,

  48.         )

  49.         cls.fp1.sites.add(cls.site1)

  50.         cls.fp2.sites.add(cls.site1)

  51.         cls.fp3.sites.add(cls.site1)

  52.         cls.fp4.sites.add(cls.site1)

  53. 

  54. 

  55. @modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})

  56. @override_settings(

  57.     LOGIN_URL="/accounts/login/",

  58.     MIDDLEWARE=[

  59.         "django.middleware.common.CommonMiddleware",

  60.         "django.contrib.sessions.middleware.SessionMiddleware",

  61.         "django.middleware.csrf.CsrfViewMiddleware",

  62.         "django.contrib.auth.middleware.AuthenticationMiddleware",

  63.         "django.contrib.messages.middleware.MessageMiddleware",

  64.         "django.contrib.flatpages.middleware.FlatpageFallbackMiddleware",

  65.     ],

  66.     ROOT_URLCONF="flatpages_tests.urls",

  67.     TEMPLATES=FLATPAGES_TEMPLATES,

  68.     SITE_ID=1,

  69. )

  70. class FlatpageMiddlewareTests(TestDataMixin, TestCase):

  71.     def test_view_flatpage(self):

  72.         "A flatpage can be served through a view, even when the middleware is in use"

  73.         response = self.client.get("/flatpage_root/flatpage/")

  74.         self.assertContains(response, "<p>Isn't it flat!</p>")

  75. 

  76.     def test_view_non_existent_flatpage(self):

  77.         """

  78.         A nonexistent flatpage raises 404 when served through a view, even when

  79.         the middleware is in use.

  80.         """

  81.         response = self.client.get("/flatpage_root/no_such_flatpage/")

  82.         self.assertEqual(response.status_code, 404)

  83. 

  84.     def test_view_authenticated_flatpage(self):

  85.         "A flatpage served through a view can require authentication"

  86.         response = self.client.get("/flatpage_root/sekrit/")

  87.         self.assertRedirects(response, "/accounts/login/?next=/flatpage_root/sekrit/")

  88.         user = User.objects.create_user("testuser", "[email protected]", "s3krit")

  89.         self.client.force_login(user)

  90.         response = self.client.get("/flatpage_root/sekrit/")

  91.         self.assertContains(response, "<p>Isn't it sekrit!</p>")

  92. 

  93.     def test_fallback_flatpage(self):

  94.         "A flatpage can be served by the fallback middleware"

  95.         response = self.client.get("/flatpage/")

  96.         self.assertContains(response, "<p>Isn't it flat!</p>")

  97. 

  98.     def test_fallback_non_existent_flatpage(self):

  99.         """

  100.         A nonexistent flatpage raises a 404 when served by the fallback

  101.         middleware.

  102.         """

  103.         response = self.client.get("/no_such_flatpage/")

  104.         self.assertEqual(response.status_code, 404)

  105. 

  106.     def test_fallback_authenticated_flatpage(self):

  107.         "A flatpage served by the middleware can require authentication"

  108.         response = self.client.get("/sekrit/")

  109.         self.assertRedirects(response, "/accounts/login/?next=/sekrit/")

  110.         user = User.objects.create_user("testuser", "[email protected]", "s3krit")

  111.         self.client.force_login(user)

  112.         response = self.client.get("/sekrit/")

  113.         self.assertContains(response, "<p>Isn't it sekrit!</p>")

  114. 

  115.     def test_fallback_flatpage_special_chars(self):

  116.         """

  117.         A flatpage with special chars in the URL can be served by the fallback

  118.         middleware.

  119.         """

  120.         fp = FlatPage.objects.create(

  121.             url="/some.very_special~chars-here/",

  122.             title="A very special page",

  123.             content="Isn't it special!",

  124.             enable_comments=False,

  125.             registration_required=False,

  126.         )

  127.         fp.sites.add(settings.SITE_ID)

  128. 

  129.         response = self.client.get("/some.very_special~chars-here/")

  130.         self.assertContains(response, "<p>Isn't it special!</p>")

  131. 

  132. 

  133. @modify_settings(INSTALLED_APPS={"append": "django.contrib.flatpages"})

  134. @override_settings(

  135.     APPEND_SLASH=True,

  136.     LOGIN_URL="/accounts/login/",

  137.     MIDDLEWARE=[

  138.         "django.middleware.common.CommonMiddleware",

  139.         "django.contrib.sessions.middleware.SessionMiddleware",

  140.         "django.middleware.csrf.CsrfViewMiddleware",

  141.         "django.contrib.auth.middleware.AuthenticationMiddleware",

  142.         "django.contrib.messages.middleware.MessageMiddleware",

  143.         "django.contrib.flatpages.middleware.FlatpageFallbackMiddleware",

  144.     ],

  145.     ROOT_URLCONF="flatpages_tests.urls",

  146.     TEMPLATES=FLATPAGES_TEMPLATES,

  147.     SITE_ID=1,

  148. )

  149. class FlatpageMiddlewareAppendSlashTests(TestDataMixin, TestCase):

  150.     def test_redirect_view_flatpage(self):

  151.         "A flatpage can be served through a view and should add a slash"

  152.         response = self.client.get("/flatpage_root/flatpage")

  153.         self.assertRedirects(response, "/flatpage_root/flatpage/", status_code=301)

  154. 

  155.     def test_redirect_view_non_existent_flatpage(self):

  156.         """

  157.         A nonexistent flatpage raises 404 when served through a view and

  158.         should not add a slash.

  159.         """

  160.         response = self.client.get("/flatpage_root/no_such_flatpage")

  161.         self.assertEqual(response.status_code, 404)

  162. 

  163.     def test_redirect_fallback_flatpage(self):

  164.         "A flatpage can be served by the fallback middleware and should add a slash"

  165.         response = self.client.get("/flatpage")

  166.         self.assertRedirects(response, "/flatpage/", status_code=301)

  167. 

  168.     def test_redirect_fallback_non_existent_flatpage(self):

  169.         """

  170.         A nonexistent flatpage raises a 404 when served by the fallback

  171.         middleware and should not add a slash.

  172.         """

  173.         response = self.client.get("/no_such_flatpage")

  174.         self.assertEqual(response.status_code, 404)

  175. 

  176.     def test_redirect_fallback_flatpage_special_chars(self):

  177.         """

  178.         A flatpage with special chars in the URL can be served by the fallback

  179.         middleware and should add a slash.

  180.         """

  181.         fp = FlatPage.objects.create(

  182.             url="/some.very_special~chars-here/",

  183.             title="A very special page",

  184.             content="Isn't it special!",

  185.             enable_comments=False,

  186.             registration_required=False,

  187.         )

  188.         fp.sites.add(settings.SITE_ID)

  189. 

  190.         response = self.client.get("/some.very_special~chars-here")

  191.         self.assertRedirects(

  192.             response, "/some.very_special~chars-here/", status_code=301

  193.         )

  194. 

  195.     def test_redirect_fallback_flatpage_root(self):

  196.         "A flatpage at / should not cause a redirect loop when APPEND_SLASH is set"

  197.         fp = FlatPage.objects.create(

  198.             url="/",

  199.             title="Root",

  200.             content="Root",

  201.             enable_comments=False,

  202.             registration_required=False,

  203.         )

  204.         fp.sites.add(settings.SITE_ID)

  205. 

  206.         response = self.client.get("/")

  207.         self.assertContains(response, "<p>Root</p>")
About Sign Up Leave Feedback Contact