Debian Codegraph @

tests/middleware/tests.py

raw
1 import gzip
2 import random
3 import re
4 import struct
5 from io import BytesIO
6 from unittest import mock
7 from urllib.parse import quote
8
9 from django.conf import settings
10 from django.core import mail
11 from django.core.exceptions import PermissionDenied
12 from django.http import (
13 FileResponse,
14 HttpRequest,
15 HttpResponse,
16 HttpResponseNotFound,
17 HttpResponsePermanentRedirect,
18 HttpResponseRedirect,
19 StreamingHttpResponse,
20 )
21 from django.middleware.clickjacking import XFrameOptionsMiddleware
22 from django.middleware.common import BrokenLinkEmailsMiddleware, CommonMiddleware
23 from django.middleware.gzip import GZipMiddleware
24 from django.middleware.http import ConditionalGetMiddleware
25 from django.test import RequestFactory, SimpleTestCase, override_settings
26
27 int2byte = struct.Struct(">B").pack
28
29
30 def get_response_empty(request):
31 return HttpResponse()
32
33
34 def get_response_404(request):
35 return HttpResponseNotFound()
36
37
38 @override_settings(ROOT_URLCONF="middleware.urls")
39 class CommonMiddlewareTest(SimpleTestCase):
40 rf = RequestFactory()
41
42 @override_settings(APPEND_SLASH=True)
43 def test_append_slash_have_slash(self):
44 """
45 URLs with slashes should go unmolested.
46 """
47 request = self.rf.get("/slash/")
48 self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
49 self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
50
51 @override_settings(APPEND_SLASH=True)
52 def test_append_slash_slashless_resource(self):
53 """
54 Matches to explicit slashless URLs should go unmolested.
55 """
56
57 def get_response(req):
58 return HttpResponse("Here's the text of the web page.")
59
60 request = self.rf.get("/noslash")
61 self.assertIsNone(CommonMiddleware(get_response).process_request(request))
62 self.assertEqual(
63 CommonMiddleware(get_response)(request).content,
64 b"Here's the text of the web page.",
65 )
66
67 @override_settings(APPEND_SLASH=True)
68 def test_append_slash_slashless_unknown(self):
69 """
70 APPEND_SLASH should not redirect to unknown resources.
71 """
72 request = self.rf.get("/unknown")
73 response = CommonMiddleware(get_response_404)(request)
74 self.assertEqual(response.status_code, 404)
75
76 @override_settings(APPEND_SLASH=True)
77 def test_append_slash_redirect(self):
78 """
79 APPEND_SLASH should redirect slashless URLs to a valid pattern.
80 """
81 request = self.rf.get("/slash")
82 r = CommonMiddleware(get_response_empty).process_request(request)
83 self.assertIsNone(r)
84 response = HttpResponseNotFound()
85 r = CommonMiddleware(get_response_empty).process_response(request, response)
86 self.assertEqual(r.status_code, 301)
87 self.assertEqual(r.url, "/slash/")
88
89 @override_settings(APPEND_SLASH=True)
90 def test_append_slash_redirect_querystring(self):
91 """
92 APPEND_SLASH should preserve querystrings when redirecting.
93 """
94 request = self.rf.get("/slash?test=1")
95 resp = CommonMiddleware(get_response_404)(request)
96 self.assertEqual(resp.url, "/slash/?test=1")
97
98 @override_settings(APPEND_SLASH=True)
99 def test_append_slash_redirect_querystring_have_slash(self):
100 """
101 APPEND_SLASH should append slash to path when redirecting a request
102 with a querystring ending with slash.
103 """
104 request = self.rf.get("/slash?test=slash/")
105 resp = CommonMiddleware(get_response_404)(request)
106 self.assertIsInstance(resp, HttpResponsePermanentRedirect)
107 self.assertEqual(resp.url, "/slash/?test=slash/")
108
109 @override_settings(APPEND_SLASH=True, DEBUG=True)
110 def test_append_slash_no_redirect_in_DEBUG(self):
111 """
112 While in debug mode, an exception is raised with a warning
113 when a failed attempt is made to DELETE, POST, PUT, or PATCH to an URL
114 which would normally be redirected to a slashed version.
115 """
116 msg = "maintaining %s data. Change your form to point to testserver/slash/"
117 request = self.rf.get("/slash")
118 request.method = "POST"
119 with self.assertRaisesMessage(RuntimeError, msg % request.method):
120 CommonMiddleware(get_response_404)(request)
121 request = self.rf.get("/slash")
122 request.method = "PUT"
123 with self.assertRaisesMessage(RuntimeError, msg % request.method):
124 CommonMiddleware(get_response_404)(request)
125 request = self.rf.get("/slash")
126 request.method = "PATCH"
127 with self.assertRaisesMessage(RuntimeError, msg % request.method):
128 CommonMiddleware(get_response_404)(request)
129 request = self.rf.delete("/slash")
130 with self.assertRaisesMessage(RuntimeError, msg % request.method):
131 CommonMiddleware(get_response_404)(request)
132
133 @override_settings(APPEND_SLASH=False)
134 def test_append_slash_disabled(self):
135 """
136 Disabling append slash functionality should leave slashless URLs alone.
137 """
138 request = self.rf.get("/slash")
139 self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
140
141 @override_settings(APPEND_SLASH=True)
142 def test_append_slash_opt_out(self):
143 """
144 Views marked with @no_append_slash should be left alone.
145 """
146 request = self.rf.get("/sensitive_fbv")
147 self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
148
149 request = self.rf.get("/sensitive_cbv")
150 self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
151
152 @override_settings(APPEND_SLASH=True)
153 def test_append_slash_quoted(self):
154 """
155 URLs which require quoting should be redirected to their slash version.
156 """
157 request = self.rf.get(quote("/needsquoting#"))
158 r = CommonMiddleware(get_response_404)(request)
159 self.assertEqual(r.status_code, 301)
160 self.assertEqual(r.url, "/needsquoting%23/")
161
162 @override_settings(APPEND_SLASH=True)
163 def test_append_slash_leading_slashes(self):
164 """
165 Paths starting with two slashes are escaped to prevent open redirects.
166 If there's a URL pattern that allows paths to start with two slashes, a
167 request with path //evil.com must not redirect to //evil.com/ (appended
168 slash) which is a schemaless absolute URL. The browser would navigate
169 to evil.com/.
170 """
171 # Use 4 slashes because of RequestFactory behavior.
172 request = self.rf.get("////evil.com/security")
173 r = CommonMiddleware(get_response_404).process_request(request)
174 self.assertIsNone(r)
175 response = HttpResponseNotFound()
176 r = CommonMiddleware(get_response_404).process_response(request, response)
177 self.assertEqual(r.status_code, 301)
178 self.assertEqual(r.url, "/%2Fevil.com/security/")
179 r = CommonMiddleware(get_response_404)(request)
180 self.assertEqual(r.status_code, 301)
181 self.assertEqual(r.url, "/%2Fevil.com/security/")
182
183 @override_settings(APPEND_SLASH=False, PREPEND_WWW=True)
184 def test_prepend_www(self):
185 request = self.rf.get("/path/")
186 r = CommonMiddleware(get_response_empty).process_request(request)
187 self.assertEqual(r.status_code, 301)
188 self.assertEqual(r.url, "http://www.testserver/path/")
189
190 @override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
191 def test_prepend_www_append_slash_have_slash(self):
192 request = self.rf.get("/slash/")
193 r = CommonMiddleware(get_response_empty).process_request(request)
194 self.assertEqual(r.status_code, 301)
195 self.assertEqual(r.url, "http://www.testserver/slash/")
196
197 @override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
198 def test_prepend_www_append_slash_slashless(self):
199 request = self.rf.get("/slash")
200 r = CommonMiddleware(get_response_empty).process_request(request)
201 self.assertEqual(r.status_code, 301)
202 self.assertEqual(r.url, "http://www.testserver/slash/")
203
204 # The following tests examine expected behavior given a custom URLconf that
205 # overrides the default one through the request object.
206
207 @override_settings(APPEND_SLASH=True)
208 def test_append_slash_have_slash_custom_urlconf(self):
209 """
210 URLs with slashes should go unmolested.
211 """
212 request = self.rf.get("/customurlconf/slash/")
213 request.urlconf = "middleware.extra_urls"
214 self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
215 self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
216
217 @override_settings(APPEND_SLASH=True)
218 def test_append_slash_slashless_resource_custom_urlconf(self):
219 """
220 Matches to explicit slashless URLs should go unmolested.
221 """
222
223 def get_response(req):
224 return HttpResponse("web content")
225
226 request = self.rf.get("/customurlconf/noslash")
227 request.urlconf = "middleware.extra_urls"
228 self.assertIsNone(CommonMiddleware(get_response).process_request(request))
229 self.assertEqual(
230 CommonMiddleware(get_response)(request).content, b"web content"
231 )
232
233 @override_settings(APPEND_SLASH=True)
234 def test_append_slash_slashless_unknown_custom_urlconf(self):
235 """
236 APPEND_SLASH should not redirect to unknown resources.
237 """
238 request = self.rf.get("/customurlconf/unknown")
239 request.urlconf = "middleware.extra_urls"
240 self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
241 self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
242
243 @override_settings(APPEND_SLASH=True)
244 def test_append_slash_redirect_custom_urlconf(self):
245 """
246 APPEND_SLASH should redirect slashless URLs to a valid pattern.
247 """
248 request = self.rf.get("/customurlconf/slash")
249 request.urlconf = "middleware.extra_urls"
250 r = CommonMiddleware(get_response_404)(request)
251 self.assertIsNotNone(
252 r,
253 "CommonMiddleware failed to return APPEND_SLASH redirect using "
254 "request.urlconf",
255 )
256 self.assertEqual(r.status_code, 301)
257 self.assertEqual(r.url, "/customurlconf/slash/")
258
259 @override_settings(APPEND_SLASH=True, DEBUG=True)
260 def test_append_slash_no_redirect_on_POST_in_DEBUG_custom_urlconf(self):
261 """
262 While in debug mode, an exception is raised with a warning
263 when a failed attempt is made to POST to an URL which would normally be
264 redirected to a slashed version.
265 """
266 request = self.rf.get("/customurlconf/slash")
267 request.urlconf = "middleware.extra_urls"
268 request.method = "POST"
269 with self.assertRaisesMessage(RuntimeError, "end in a slash"):
270 CommonMiddleware(get_response_404)(request)
271
272 @override_settings(APPEND_SLASH=False)
273 def test_append_slash_disabled_custom_urlconf(self):
274 """
275 Disabling append slash functionality should leave slashless URLs alone.
276 """
277 request = self.rf.get("/customurlconf/slash")
278 request.urlconf = "middleware.extra_urls"
279 self.assertIsNone(CommonMiddleware(get_response_404).process_request(request))
280 self.assertEqual(CommonMiddleware(get_response_404)(request).status_code, 404)
281
282 @override_settings(APPEND_SLASH=True)
283 def test_append_slash_quoted_custom_urlconf(self):
284 """
285 URLs which require quoting should be redirected to their slash version.
286 """
287 request = self.rf.get(quote("/customurlconf/needsquoting#"))
288 request.urlconf = "middleware.extra_urls"
289 r = CommonMiddleware(get_response_404)(request)
290 self.assertIsNotNone(
291 r,
292 "CommonMiddleware failed to return APPEND_SLASH redirect using "
293 "request.urlconf",
294 )
295 self.assertEqual(r.status_code, 301)
296 self.assertEqual(r.url, "/customurlconf/needsquoting%23/")
297
298 @override_settings(APPEND_SLASH=False, PREPEND_WWW=True)
299 def test_prepend_www_custom_urlconf(self):
300 request = self.rf.get("/customurlconf/path/")
301 request.urlconf = "middleware.extra_urls"
302 r = CommonMiddleware(get_response_empty).process_request(request)
303 self.assertEqual(r.status_code, 301)
304 self.assertEqual(r.url, "http://www.testserver/customurlconf/path/")
305
306 @override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
307 def test_prepend_www_append_slash_have_slash_custom_urlconf(self):
308 request = self.rf.get("/customurlconf/slash/")
309 request.urlconf = "middleware.extra_urls"
310 r = CommonMiddleware(get_response_empty).process_request(request)
311 self.assertEqual(r.status_code, 301)
312 self.assertEqual(r.url, "http://www.testserver/customurlconf/slash/")
313
314 @override_settings(APPEND_SLASH=True, PREPEND_WWW=True)
315 def test_prepend_www_append_slash_slashless_custom_urlconf(self):
316 request = self.rf.get("/customurlconf/slash")
317 request.urlconf = "middleware.extra_urls"
318 r = CommonMiddleware(get_response_empty).process_request(request)
319 self.assertEqual(r.status_code, 301)
320 self.assertEqual(r.url, "http://www.testserver/customurlconf/slash/")
321
322 # Tests for the Content-Length header
323
324 def test_content_length_header_added(self):
325 def get_response(req):
326 response = HttpResponse("content")
327 self.assertNotIn("Content-Length", response)
328 return response
329
330 response = CommonMiddleware(get_response)(self.rf.get("/"))
331 self.assertEqual(int(response.headers["Content-Length"]), len(response.content))
332
333 def test_content_length_header_not_added_for_streaming_response(self):
334 def get_response(req):
335 response = StreamingHttpResponse("content")
336 self.assertNotIn("Content-Length", response)
337 return response
338
339 response = CommonMiddleware(get_response)(self.rf.get("/"))
340 self.assertNotIn("Content-Length", response)
341
342 def test_content_length_header_not_changed(self):
343 bad_content_length = 500
344
345 def get_response(req):
346 response = HttpResponse()
347 response.headers["Content-Length"] = bad_content_length
348 return response
349
350 response = CommonMiddleware(get_response)(self.rf.get("/"))
351 self.assertEqual(int(response.headers["Content-Length"]), bad_content_length)
352
353 # Other tests
354
355 @override_settings(DISALLOWED_USER_AGENTS=[re.compile(r"foo")])
356 def test_disallowed_user_agents(self):
357 request = self.rf.get("/slash")
358 request.META["HTTP_USER_AGENT"] = "foo"
359 with self.assertRaisesMessage(PermissionDenied, "Forbidden user agent"):
360 CommonMiddleware(get_response_empty).process_request(request)
361
362 def test_non_ascii_query_string_does_not_crash(self):
363 """Regression test for #15152"""
364 request = self.rf.get("/slash")
365 request.META["QUERY_STRING"] = "drink=café"
366 r = CommonMiddleware(get_response_empty).process_request(request)
367 self.assertIsNone(r)
368 response = HttpResponseNotFound()
369 r = CommonMiddleware(get_response_empty).process_response(request, response)
370 self.assertEqual(r.status_code, 301)
371
372 def test_response_redirect_class(self):
373 request = self.rf.get("/slash")
374 r = CommonMiddleware(get_response_404)(request)
375 self.assertEqual(r.status_code, 301)
376 self.assertEqual(r.url, "/slash/")
377 self.assertIsInstance(r, HttpResponsePermanentRedirect)
378
379 def test_response_redirect_class_subclass(self):
380 class MyCommonMiddleware(CommonMiddleware):
381 response_redirect_class = HttpResponseRedirect
382
383 request = self.rf.get("/slash")
384 r = MyCommonMiddleware(get_response_404)(request)
385 self.assertEqual(r.status_code, 302)
386 self.assertEqual(r.url, "/slash/")
387 self.assertIsInstance(r, HttpResponseRedirect)
388
389
390 @override_settings(
391 IGNORABLE_404_URLS=[re.compile(r"foo")],
392 MANAGERS=[("PHD", "[email protected]")],
393 )
394 class BrokenLinkEmailsMiddlewareTest(SimpleTestCase):
395 rf = RequestFactory()
396
397 def setUp(self):
398 self.req = self.rf.get("/regular_url/that/does/not/exist")
399
400 def get_response(self, req):
401 return self.client.get(req.path)
402
403 def test_404_error_reporting(self):
404 self.req.META["HTTP_REFERER"] = "/another/url/"
405 BrokenLinkEmailsMiddleware(self.get_response)(self.req)
406 self.assertEqual(len(mail.outbox), 1)
407 self.assertIn("Broken", mail.outbox[0].subject)
408
409 def test_404_error_reporting_no_referer(self):
410 BrokenLinkEmailsMiddleware(self.get_response)(self.req)
411 self.assertEqual(len(mail.outbox), 0)
412
413 def test_404_error_reporting_ignored_url(self):
414 self.req.path = self.req.path_info = "foo_url/that/does/not/exist"
415 BrokenLinkEmailsMiddleware(self.get_response)(self.req)
416 self.assertEqual(len(mail.outbox), 0)
417
418 def test_custom_request_checker(self):
419 class SubclassedMiddleware(BrokenLinkEmailsMiddleware):
420 ignored_user_agent_patterns = (
421 re.compile(r"Spider.*"),
422 re.compile(r"Robot.*"),
423 )
424
425 def is_ignorable_request(self, request, uri, domain, referer):
426 """Check user-agent in addition to normal checks."""
427 if super().is_ignorable_request(request, uri, domain, referer):
428 return True
429 user_agent = request.META["HTTP_USER_AGENT"]
430 return any(
431 pattern.search(user_agent)
432 for pattern in self.ignored_user_agent_patterns
433 )
434
435 self.req.META["HTTP_REFERER"] = "/another/url/"
436 self.req.META["HTTP_USER_AGENT"] = "Spider machine 3.4"
437 SubclassedMiddleware(self.get_response)(self.req)
438 self.assertEqual(len(mail.outbox), 0)
439 self.req.META["HTTP_USER_AGENT"] = "My user agent"
440 SubclassedMiddleware(self.get_response)(self.req)
441 self.assertEqual(len(mail.outbox), 1)
442
443 def test_referer_equal_to_requested_url(self):
444 """
445 Some bots set the referer to the current URL to avoid being blocked by
446 an referer check (#25302).
447 """
448 self.req.META["HTTP_REFERER"] = self.req.path
449 BrokenLinkEmailsMiddleware(self.get_response)(self.req)
450 self.assertEqual(len(mail.outbox), 0)
451
452 # URL with scheme and domain should also be ignored
453 self.req.META["HTTP_REFERER"] = "http://testserver%s" % self.req.path
454 BrokenLinkEmailsMiddleware(self.get_response)(self.req)
455 self.assertEqual(len(mail.outbox), 0)
456
457 # URL with a different scheme should be ignored as well because bots
458 # tend to use http:// in referers even when browsing HTTPS websites.
459 self.req.META["HTTP_X_PROTO"] = "https"
460 self.req.META["SERVER_PORT"] = 443
461 with self.settings(SECURE_PROXY_SSL_HEADER=("HTTP_X_PROTO", "https")):
462 BrokenLinkEmailsMiddleware(self.get_response)(self.req)
463 self.assertEqual(len(mail.outbox), 0)
464
465 def test_referer_equal_to_requested_url_on_another_domain(self):
466 self.req.META["HTTP_REFERER"] = "http://anotherserver%s" % self.req.path
467 BrokenLinkEmailsMiddleware(self.get_response)(self.req)
468 self.assertEqual(len(mail.outbox), 1)
469
470 @override_settings(APPEND_SLASH=True)
471 def test_referer_equal_to_requested_url_without_trailing_slash_with_append_slash(
472 self,
473 ):
474 self.req.path = self.req.path_info = "/regular_url/that/does/not/exist/"
475 self.req.META["HTTP_REFERER"] = self.req.path_info[:-1]
476 BrokenLinkEmailsMiddleware(self.get_response)(self.req)
477 self.assertEqual(len(mail.outbox), 0)
478
479 @override_settings(APPEND_SLASH=False)
480 def test_referer_equal_to_requested_url_without_trailing_slash_with_no_append_slash(
481 self,
482 ):
483 self.req.path = self.req.path_info = "/regular_url/that/does/not/exist/"
484 self.req.META["HTTP_REFERER"] = self.req.path_info[:-1]
485 BrokenLinkEmailsMiddleware(self.get_response)(self.req)
486 self.assertEqual(len(mail.outbox), 1)
487
488
489 @override_settings(ROOT_URLCONF="middleware.cond_get_urls")
490 class ConditionalGetMiddlewareTest(SimpleTestCase):
491 request_factory = RequestFactory()
492
493 def setUp(self):
494 self.req = self.request_factory.get("/")
495 self.resp_headers = {}
496
497 def get_response(self, req):
498 resp = self.client.get(req.path_info)
499 for key, value in self.resp_headers.items():
500 resp[key] = value
501 return resp
502
503 # Tests for the ETag header
504
505 def test_middleware_calculates_etag(self):
506 resp = ConditionalGetMiddleware(self.get_response)(self.req)
507 self.assertEqual(resp.status_code, 200)
508 self.assertNotEqual("", resp["ETag"])
509
510 def test_middleware_wont_overwrite_etag(self):
511 self.resp_headers["ETag"] = "eggs"
512 resp = ConditionalGetMiddleware(self.get_response)(self.req)
513 self.assertEqual(resp.status_code, 200)
514 self.assertEqual("eggs", resp["ETag"])
515
516 def test_no_etag_streaming_response(self):
517 def get_response(req):
518 return StreamingHttpResponse(["content"])
519
520 self.assertFalse(
521 ConditionalGetMiddleware(get_response)(self.req).has_header("ETag")
522 )
523
524 def test_no_etag_response_empty_content(self):
525 def get_response(req):
526 return HttpResponse()
527
528 self.assertFalse(
529 ConditionalGetMiddleware(get_response)(self.req).has_header("ETag")
530 )
531
532 def test_no_etag_no_store_cache(self):
533 self.resp_headers["Cache-Control"] = "No-Cache, No-Store, Max-age=0"
534 self.assertFalse(
535 ConditionalGetMiddleware(self.get_response)(self.req).has_header("ETag")
536 )
537
538 def test_etag_extended_cache_control(self):
539 self.resp_headers["Cache-Control"] = 'my-directive="my-no-store"'
540 self.assertTrue(
541 ConditionalGetMiddleware(self.get_response)(self.req).has_header("ETag")
542 )
543
544 def test_if_none_match_and_no_etag(self):
545 self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
546 resp = ConditionalGetMiddleware(self.get_response)(self.req)
547 self.assertEqual(resp.status_code, 200)
548
549 def test_no_if_none_match_and_etag(self):
550 self.resp_headers["ETag"] = "eggs"
551 resp = ConditionalGetMiddleware(self.get_response)(self.req)
552 self.assertEqual(resp.status_code, 200)
553
554 def test_if_none_match_and_same_etag(self):
555 self.req.META["HTTP_IF_NONE_MATCH"] = '"spam"'
556 self.resp_headers["ETag"] = '"spam"'
557 resp = ConditionalGetMiddleware(self.get_response)(self.req)
558 self.assertEqual(resp.status_code, 304)
559
560 def test_if_none_match_and_different_etag(self):
561 self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
562 self.resp_headers["ETag"] = "eggs"
563 resp = ConditionalGetMiddleware(self.get_response)(self.req)
564 self.assertEqual(resp.status_code, 200)
565
566 def test_if_none_match_and_redirect(self):
567 def get_response(req):
568 resp = self.client.get(req.path_info)
569 resp["ETag"] = "spam"
570 resp["Location"] = "/"
571 resp.status_code = 301
572 return resp
573
574 self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
575 resp = ConditionalGetMiddleware(get_response)(self.req)
576 self.assertEqual(resp.status_code, 301)
577
578 def test_if_none_match_and_client_error(self):
579 def get_response(req):
580 resp = self.client.get(req.path_info)
581 resp["ETag"] = "spam"
582 resp.status_code = 400
583 return resp
584
585 self.req.META["HTTP_IF_NONE_MATCH"] = "spam"
586 resp = ConditionalGetMiddleware(get_response)(self.req)
587 self.assertEqual(resp.status_code, 400)
588
589 # Tests for the Last-Modified header
590
591 def test_if_modified_since_and_no_last_modified(self):
592 self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
593 resp = ConditionalGetMiddleware(self.get_response)(self.req)
594 self.assertEqual(resp.status_code, 200)
595
596 def test_no_if_modified_since_and_last_modified(self):
597 self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:38:44 GMT"
598 resp = ConditionalGetMiddleware(self.get_response)(self.req)
599 self.assertEqual(resp.status_code, 200)
600
601 def test_if_modified_since_and_same_last_modified(self):
602 self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
603 self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:38:44 GMT"
604 self.resp = ConditionalGetMiddleware(self.get_response)(self.req)
605 self.assertEqual(self.resp.status_code, 304)
606
607 def test_if_modified_since_and_last_modified_in_the_past(self):
608 self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
609 self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
610 resp = ConditionalGetMiddleware(self.get_response)(self.req)
611 self.assertEqual(resp.status_code, 304)
612
613 def test_if_modified_since_and_last_modified_in_the_future(self):
614 self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
615 self.resp_headers["Last-Modified"] = "Sat, 12 Feb 2011 17:41:44 GMT"
616 self.resp = ConditionalGetMiddleware(self.get_response)(self.req)
617 self.assertEqual(self.resp.status_code, 200)
618
619 def test_if_modified_since_and_redirect(self):
620 def get_response(req):
621 resp = self.client.get(req.path_info)
622 resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
623 resp["Location"] = "/"
624 resp.status_code = 301
625 return resp
626
627 self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
628 resp = ConditionalGetMiddleware(get_response)(self.req)
629 self.assertEqual(resp.status_code, 301)
630
631 def test_if_modified_since_and_client_error(self):
632 def get_response(req):
633 resp = self.client.get(req.path_info)
634 resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
635 resp.status_code = 400
636 return resp
637
638 self.req.META["HTTP_IF_MODIFIED_SINCE"] = "Sat, 12 Feb 2011 17:38:44 GMT"
639 resp = ConditionalGetMiddleware(get_response)(self.req)
640 self.assertEqual(resp.status_code, 400)
641
642 def test_not_modified_headers(self):
643 """
644 The 304 Not Modified response should include only the headers required
645 by RFC 9110 Section 15.4.5, Last-Modified, and the cookies.
646 """
647
648 def get_response(req):
649 resp = self.client.get(req.path_info)
650 resp["Date"] = "Sat, 12 Feb 2011 17:35:44 GMT"
651 resp["Last-Modified"] = "Sat, 12 Feb 2011 17:35:44 GMT"
652 resp["Expires"] = "Sun, 13 Feb 2011 17:35:44 GMT"
653 resp["Vary"] = "Cookie"
654 resp["Cache-Control"] = "public"
655 resp["Content-Location"] = "/alt"
656 resp["Content-Language"] = "en" # shouldn't be preserved
657 resp["ETag"] = '"spam"'
658 resp.set_cookie("key", "value")
659 return resp
660
661 self.req.META["HTTP_IF_NONE_MATCH"] = '"spam"'
662
663 new_response = ConditionalGetMiddleware(get_response)(self.req)
664 self.assertEqual(new_response.status_code, 304)
665 base_response = get_response(self.req)
666 for header in (
667 "Cache-Control",
668 "Content-Location",
669 "Date",
670 "ETag",
671 "Expires",
672 "Last-Modified",
673 "Vary",
674 ):
675 self.assertEqual(
676 new_response.headers[header], base_response.headers[header]
677 )
678 self.assertEqual(new_response.cookies, base_response.cookies)
679 self.assertNotIn("Content-Language", new_response)
680
681 def test_no_unsafe(self):
682 """
683 ConditionalGetMiddleware shouldn't return a conditional response on an
684 unsafe request. A response has already been generated by the time
685 ConditionalGetMiddleware is called, so it's too late to return a 412
686 Precondition Failed.
687 """
688
689 def get_200_response(req):
690 return HttpResponse(status=200)
691
692 response = ConditionalGetMiddleware(self.get_response)(self.req)
693 etag = response.headers["ETag"]
694 put_request = self.request_factory.put("/", headers={"if-match": etag})
695 conditional_get_response = ConditionalGetMiddleware(get_200_response)(
696 put_request
697 )
698 self.assertEqual(
699 conditional_get_response.status_code, 200
700 ) # should never be a 412
701
702 def test_no_head(self):
703 """
704 ConditionalGetMiddleware shouldn't compute and return an ETag on a
705 HEAD request since it can't do so accurately without access to the
706 response body of the corresponding GET.
707 """
708
709 def get_200_response(req):
710 return HttpResponse(status=200)
711
712 request = self.request_factory.head("/")
713 conditional_get_response = ConditionalGetMiddleware(get_200_response)(request)
714 self.assertNotIn("ETag", conditional_get_response)
715
716
717 class XFrameOptionsMiddlewareTest(SimpleTestCase):
718 """
719 Tests for the X-Frame-Options clickjacking prevention middleware.
720 """
721
722 def test_same_origin(self):
723 """
724 The X_FRAME_OPTIONS setting can be set to SAMEORIGIN to have the
725 middleware use that value for the HTTP header.
726 """
727 with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
728 r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
729 self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
730
731 with override_settings(X_FRAME_OPTIONS="sameorigin"):
732 r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
733 self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
734
735 def test_deny(self):
736 """
737 The X_FRAME_OPTIONS setting can be set to DENY to have the middleware
738 use that value for the HTTP header.
739 """
740 with override_settings(X_FRAME_OPTIONS="DENY"):
741 r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
742 self.assertEqual(r.headers["X-Frame-Options"], "DENY")
743
744 with override_settings(X_FRAME_OPTIONS="deny"):
745 r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
746 self.assertEqual(r.headers["X-Frame-Options"], "DENY")
747
748 def test_defaults_sameorigin(self):
749 """
750 If the X_FRAME_OPTIONS setting is not set then it defaults to
751 DENY.
752 """
753 with override_settings(X_FRAME_OPTIONS=None):
754 del settings.X_FRAME_OPTIONS # restored by override_settings
755 r = XFrameOptionsMiddleware(get_response_empty)(HttpRequest())
756 self.assertEqual(r.headers["X-Frame-Options"], "DENY")
757
758 def test_dont_set_if_set(self):
759 """
760 If the X-Frame-Options header is already set then the middleware does
761 not attempt to override it.
762 """
763
764 def same_origin_response(request):
765 response = HttpResponse()
766 response.headers["X-Frame-Options"] = "SAMEORIGIN"
767 return response
768
769 def deny_response(request):
770 response = HttpResponse()
771 response.headers["X-Frame-Options"] = "DENY"
772 return response
773
774 with override_settings(X_FRAME_OPTIONS="DENY"):
775 r = XFrameOptionsMiddleware(same_origin_response)(HttpRequest())
776 self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
777
778 with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
779 r = XFrameOptionsMiddleware(deny_response)(HttpRequest())
780 self.assertEqual(r.headers["X-Frame-Options"], "DENY")
781
782 def test_response_exempt(self):
783 """
784 If the response has an xframe_options_exempt attribute set to False
785 then it still sets the header, but if it's set to True then it doesn't.
786 """
787
788 def xframe_exempt_response(request):
789 response = HttpResponse()
790 response.xframe_options_exempt = True
791 return response
792
793 def xframe_not_exempt_response(request):
794 response = HttpResponse()
795 response.xframe_options_exempt = False
796 return response
797
798 with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
799 r = XFrameOptionsMiddleware(xframe_not_exempt_response)(HttpRequest())
800 self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
801
802 r = XFrameOptionsMiddleware(xframe_exempt_response)(HttpRequest())
803 self.assertIsNone(r.headers.get("X-Frame-Options"))
804
805 def test_is_extendable(self):
806 """
807 The XFrameOptionsMiddleware method that determines the X-Frame-Options
808 header value can be overridden based on something in the request or
809 response.
810 """
811
812 class OtherXFrameOptionsMiddleware(XFrameOptionsMiddleware):
813 # This is just an example for testing purposes...
814 def get_xframe_options_value(self, request, response):
815 if getattr(request, "sameorigin", False):
816 return "SAMEORIGIN"
817 if getattr(response, "sameorigin", False):
818 return "SAMEORIGIN"
819 return "DENY"
820
821 def same_origin_response(request):
822 response = HttpResponse()
823 response.sameorigin = True
824 return response
825
826 with override_settings(X_FRAME_OPTIONS="DENY"):
827 r = OtherXFrameOptionsMiddleware(same_origin_response)(HttpRequest())
828 self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
829
830 request = HttpRequest()
831 request.sameorigin = True
832 r = OtherXFrameOptionsMiddleware(get_response_empty)(request)
833 self.assertEqual(r.headers["X-Frame-Options"], "SAMEORIGIN")
834
835 with override_settings(X_FRAME_OPTIONS="SAMEORIGIN"):
836 r = OtherXFrameOptionsMiddleware(get_response_empty)(HttpRequest())
837 self.assertEqual(r.headers["X-Frame-Options"], "DENY")
838
839
840 class GZipMiddlewareTest(SimpleTestCase):
841 """
842 Tests the GZipMiddleware.
843 """
844
845 short_string = b"This string is too short to be worth compressing."
846 compressible_string = b"a" * 500
847 incompressible_string = b"".join(
848 int2byte(random.randint(0, 255)) for _ in range(500)
849 )
850 sequence = [b"a" * 500, b"b" * 200, b"a" * 300]
851 sequence_unicode = ["a" * 500, "é" * 200, "a" * 300]
852 request_factory = RequestFactory()
853
854 def setUp(self):
855 self.req = self.request_factory.get("/")
856 self.req.META["HTTP_ACCEPT_ENCODING"] = "gzip, deflate"
857 self.req.META["HTTP_USER_AGENT"] = (
858 "Mozilla/5.0 (Windows NT 5.1; rv:9.0.1) Gecko/20100101 Firefox/9.0.1"
859 )
860 self.resp = HttpResponse()
861 self.resp.status_code = 200
862 self.resp.content = self.compressible_string
863 self.resp["Content-Type"] = "text/html; charset=UTF-8"
864
865 def get_response(self, request):
866 return self.resp
867
868 @staticmethod
869 def decompress(gzipped_string):
870 with gzip.GzipFile(mode="rb", fileobj=BytesIO(gzipped_string)) as f:
871 return f.read()
872
873 @staticmethod
874 def get_mtime(gzipped_string):
875 with gzip.GzipFile(mode="rb", fileobj=BytesIO(gzipped_string)) as f:
876 f.read() # must read the data before accessing the header
877 return f.mtime
878
879 def test_compress_response(self):
880 """
881 Compression is performed on responses with compressible content.
882 """
883 r = GZipMiddleware(self.get_response)(self.req)
884 self.assertEqual(self.decompress(r.content), self.compressible_string)
885 self.assertEqual(r.get("Content-Encoding"), "gzip")
886 self.assertEqual(r.get("Content-Length"), str(len(r.content)))
887
888 def test_compress_streaming_response(self):
889 """
890 Compression is performed on responses with streaming content.
891 """
892
893 def get_stream_response(request):
894 resp = StreamingHttpResponse(self.sequence)
895 resp["Content-Type"] = "text/html; charset=UTF-8"
896 return resp
897
898 r = GZipMiddleware(get_stream_response)(self.req)
899 self.assertEqual(self.decompress(b"".join(r)), b"".join(self.sequence))
900 self.assertEqual(r.get("Content-Encoding"), "gzip")
901 self.assertFalse(r.has_header("Content-Length"))
902
903 async def test_compress_async_streaming_response(self):
904 """
905 Compression is performed on responses with async streaming content.
906 """
907
908 async def get_stream_response(request):
909 async def iterator():
910 for chunk in self.sequence:
911 yield chunk
912
913 resp = StreamingHttpResponse(iterator())
914 resp["Content-Type"] = "text/html; charset=UTF-8"
915 return resp
916
917 r = await GZipMiddleware(get_stream_response)(self.req)
918 self.assertEqual(
919 self.decompress(b"".join([chunk async for chunk in r])),
920 b"".join(self.sequence),
921 )
922 self.assertEqual(r.get("Content-Encoding"), "gzip")
923 self.assertFalse(r.has_header("Content-Length"))
924
925 def test_compress_streaming_response_unicode(self):
926 """
927 Compression is performed on responses with streaming Unicode content.
928 """
929
930 def get_stream_response_unicode(request):
931 resp = StreamingHttpResponse(self.sequence_unicode)
932 resp["Content-Type"] = "text/html; charset=UTF-8"
933 return resp
934
935 r = GZipMiddleware(get_stream_response_unicode)(self.req)
936 self.assertEqual(
937 self.decompress(b"".join(r)),
938 b"".join(x.encode() for x in self.sequence_unicode),
939 )
940 self.assertEqual(r.get("Content-Encoding"), "gzip")
941 self.assertFalse(r.has_header("Content-Length"))
942
943 def test_compress_file_response(self):
944 """
945 Compression is performed on FileResponse.
946 """
947 with open(__file__, "rb") as file1:
948
949 def get_response(req):
950 file_resp = FileResponse(file1)
951 file_resp["Content-Type"] = "text/html; charset=UTF-8"
952 return file_resp
953
954 r = GZipMiddleware(get_response)(self.req)
955 with open(__file__, "rb") as file2:
956 self.assertEqual(self.decompress(b"".join(r)), file2.read())
957 self.assertEqual(r.get("Content-Encoding"), "gzip")
958 self.assertIsNot(r.file_to_stream, file1)
959
960 def test_compress_non_200_response(self):
961 """
962 Compression is performed on responses with a status other than 200
963 (#10762).
964 """
965 self.resp.status_code = 404
966 r = GZipMiddleware(self.get_response)(self.req)
967 self.assertEqual(self.decompress(r.content), self.compressible_string)
968 self.assertEqual(r.get("Content-Encoding"), "gzip")
969
970 def test_no_compress_short_response(self):
971 """
972 Compression isn't performed on responses with short content.
973 """
974 self.resp.content = self.short_string
975 r = GZipMiddleware(self.get_response)(self.req)
976 self.assertEqual(r.content, self.short_string)
977 self.assertIsNone(r.get("Content-Encoding"))
978
979 def test_no_compress_compressed_response(self):
980 """
981 Compression isn't performed on responses that are already compressed.
982 """
983 self.resp["Content-Encoding"] = "deflate"
984 r = GZipMiddleware(self.get_response)(self.req)
985 self.assertEqual(r.content, self.compressible_string)
986 self.assertEqual(r.get("Content-Encoding"), "deflate")
987
988 def test_no_compress_incompressible_response(self):
989 """
990 Compression isn't performed on responses with incompressible content.
991 """
992 self.resp.content = self.incompressible_string
993 r = GZipMiddleware(self.get_response)(self.req)
994 self.assertEqual(r.content, self.incompressible_string)
995 self.assertIsNone(r.get("Content-Encoding"))
996
997 def test_compress_deterministic(self):
998 """
999 Compression results are the same for the same content and don't
1000 include a modification time (since that would make the results
1001 of compression non-deterministic and prevent
1002 ConditionalGetMiddleware from recognizing conditional matches
1003 on gzipped content).
1004 """
1005
1006 class DeterministicGZipMiddleware(GZipMiddleware):
1007 max_random_bytes = 0
1008
1009 r1 = DeterministicGZipMiddleware(self.get_response)(self.req)
1010 r2 = DeterministicGZipMiddleware(self.get_response)(self.req)
1011 self.assertEqual(r1.content, r2.content)
1012 self.assertEqual(self.get_mtime(r1.content), 0)
1013 self.assertEqual(self.get_mtime(r2.content), 0)
1014
1015 def test_random_bytes(self):
1016 """A random number of bytes is added to mitigate the BREACH attack."""
1017 with mock.patch(
1018 "django.utils.text.secrets.randbelow", autospec=True, return_value=3
1019 ):
1020 r = GZipMiddleware(self.get_response)(self.req)
1021 # The fourth byte of a gzip stream contains flags.
1022 self.assertEqual(r.content[3], gzip.FNAME)
1023 # A 3 byte filename "aaa" and a null byte are added.
1024 self.assertEqual(r.content[10:14], b"aaa\x00")
1025 self.assertEqual(self.decompress(r.content), self.compressible_string)
1026
1027 def test_random_bytes_streaming_response(self):
1028 """A random number of bytes is added to mitigate the BREACH attack."""
1029
1030 def get_stream_response(request):
1031 resp = StreamingHttpResponse(self.sequence)
1032 resp["Content-Type"] = "text/html; charset=UTF-8"
1033 return resp
1034
1035 with mock.patch(
1036 "django.utils.text.secrets.randbelow", autospec=True, return_value=3
1037 ):
1038 r = GZipMiddleware(get_stream_response)(self.req)
1039 content = b"".join(r)
1040 # The fourth byte of a gzip stream contains flags.
1041 self.assertEqual(content[3], gzip.FNAME)
1042 # A 3 byte filename "aaa" and a null byte are added.
1043 self.assertEqual(content[10:14], b"aaa\x00")
1044 self.assertEqual(self.decompress(content), b"".join(self.sequence))
1045
1046
1047 class ETagGZipMiddlewareTest(SimpleTestCase):
1048 """
1049 ETags are handled properly by GZipMiddleware.
1050 """
1051
1052 rf = RequestFactory()
1053 compressible_string = b"a" * 500
1054
1055 def test_strong_etag_modified(self):
1056 """
1057 GZipMiddleware makes a strong ETag weak.
1058 """
1059
1060 def get_response(req):
1061 response = HttpResponse(self.compressible_string)
1062 response.headers["ETag"] = '"eggs"'
1063 return response
1064
1065 request = self.rf.get("/", headers={"accept-encoding": "gzip, deflate"})
1066 gzip_response = GZipMiddleware(get_response)(request)
1067 self.assertEqual(gzip_response.headers["ETag"], 'W/"eggs"')
1068
1069 def test_weak_etag_not_modified(self):
1070 """
1071 GZipMiddleware doesn't modify a weak ETag.
1072 """
1073
1074 def get_response(req):
1075 response = HttpResponse(self.compressible_string)
1076 response.headers["ETag"] = 'W/"eggs"'
1077 return response
1078
1079 request = self.rf.get("/", headers={"accept-encoding": "gzip, deflate"})
1080 gzip_response = GZipMiddleware(get_response)(request)
1081 self.assertEqual(gzip_response.headers["ETag"], 'W/"eggs"')
1082
1083 def test_etag_match(self):
1084 """
1085 GZipMiddleware allows 304 Not Modified responses.
1086 """
1087
1088 def get_response(req):
1089 return HttpResponse(self.compressible_string)
1090
1091 def get_cond_response(req):
1092 return ConditionalGetMiddleware(get_response)(req)
1093
1094 request = self.rf.get("/", headers={"accept-encoding": "gzip, deflate"})
1095 response = GZipMiddleware(get_cond_response)(request)
1096 gzip_etag = response.headers["ETag"]
1097 next_request = self.rf.get(
1098 "/",
1099 headers={"accept-encoding": "gzip, deflate", "if-none-match": gzip_etag},
1100 )
1101 next_response = ConditionalGetMiddleware(get_response)(next_request)
1102 self.assertEqual(next_response.status_code, 304)