Debian Codegraph @

tests/flatpages_tests/test_middleware.py

raw
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>")