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

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

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

  4. from django.test import Client, TestCase, modify_settings, override_settings

  5. 

  6. from .settings import FLATPAGES_TEMPLATES

  7. 

  8. 

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

  10. @override_settings(

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

  12.     MIDDLEWARE=[

  13.         "django.middleware.common.CommonMiddleware",

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

  15.         "django.middleware.csrf.CsrfViewMiddleware",

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

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

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

  19.     ],

  20.     ROOT_URLCONF="flatpages_tests.urls",

  21.     CSRF_FAILURE_VIEW="django.views.csrf.csrf_failure",

  22.     TEMPLATES=FLATPAGES_TEMPLATES,

  23.     SITE_ID=1,

  24. )

  25. class FlatpageCSRFTests(TestCase):

  26.     @classmethod

  27.     def setUpTestData(cls):

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

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

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

  31.         cls.site1.save()

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

  33.             url="/flatpage/",

  34.             title="A Flatpage",

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

  36.             enable_comments=False,

  37.             template_name="",

  38.             registration_required=False,

  39.         )

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

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

  42.             title="A Nested Flatpage",

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

  44.             enable_comments=False,

  45.             template_name="",

  46.             registration_required=False,

  47.         )

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

  49.             url="/sekrit/",

  50.             title="Sekrit Flatpage",

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

  52.             enable_comments=False,

  53.             template_name="",

  54.             registration_required=True,

  55.         )

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

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

  58.             title="Sekrit Nested Flatpage",

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

  60.             enable_comments=False,

  61.             template_name="",

  62.             registration_required=True,

  63.         )

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

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

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

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

  68. 

  69.     def setUp(self):

  70.         self.client = Client(enforce_csrf_checks=True)

  71. 

  72.     def test_view_flatpage(self):

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

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

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

  76. 

  77.     def test_view_non_existent_flatpage(self):

  78.         """

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

  80.         the middleware is in use.

  81.         """

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

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

  84. 

  85.     def test_view_authenticated_flatpage(self):

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

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

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

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

  90.         self.client.force_login(user)

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

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

  93. 

  94.     def test_fallback_flatpage(self):

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

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

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

  98. 

  99.     def test_fallback_non_existent_flatpage(self):

  100.         """

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

  102.         middleware.

  103.         """

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

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

  106. 

  107.     def test_post_view_flatpage(self):

  108.         """

  109.         POSTing to a flatpage served through a view will raise a CSRF error if

  110.         no token is provided.

  111.         """

  112.         response = self.client.post("/flatpage_root/flatpage/")

  113.         self.assertEqual(response.status_code, 403)

  114. 

  115.     def test_post_fallback_flatpage(self):

  116.         """

  117.         POSTing to a flatpage served by the middleware will raise a CSRF error

  118.         if no token is provided.

  119.         """

  120.         response = self.client.post("/flatpage/")

  121.         self.assertEqual(response.status_code, 403)

  122. 

  123.     def test_post_unknown_page(self):

  124.         "POSTing to an unknown page isn't caught as a 403 CSRF error"

  125.         response = self.client.post("/no_such_page/")

  126.         self.assertEqual(response.status_code, 404)
About Sign Up Leave Feedback Contact