Debian Codegraph @

tests/check_framework/test_security.py

raw
1 import unittest
2 from typing import TYPE_CHECKING
3
4 from django.conf import settings
5 from django.core.checks.messages import Error, Warning
6 from django.core.checks.security import base, csrf, sessions
7 from django.core.management.utils import get_random_secret_key
8 from django.test import SimpleTestCase
9 from django.test.utils import override_settings
10 from django.utils.version import PY314
11 from django.views.generic import View
12
13 if TYPE_CHECKING:
14 from django.http.request import HttpRequest
15
16
17 class CheckSessionCookieSecureTest(SimpleTestCase):
18 @override_settings(
19 SESSION_COOKIE_SECURE=False,
20 INSTALLED_APPS=["django.contrib.sessions"],
21 MIDDLEWARE=[],
22 )
23 def test_session_cookie_secure_with_installed_app(self):
24 """
25 Warn if SESSION_COOKIE_SECURE is off and "django.contrib.sessions" is
26 in INSTALLED_APPS.
27 """
28 self.assertEqual(sessions.check_session_cookie_secure(None), [sessions.W010])
29
30 @override_settings(
31 SESSION_COOKIE_SECURE="1",
32 INSTALLED_APPS=["django.contrib.sessions"],
33 MIDDLEWARE=[],
34 )
35 def test_session_cookie_secure_with_installed_app_truthy(self):
36 """SESSION_COOKIE_SECURE must be boolean."""
37 self.assertEqual(sessions.check_session_cookie_secure(None), [sessions.W010])
38
39 @override_settings(
40 SESSION_COOKIE_SECURE=False,
41 INSTALLED_APPS=[],
42 MIDDLEWARE=["django.contrib.sessions.middleware.SessionMiddleware"],
43 )
44 def test_session_cookie_secure_with_middleware(self):
45 """
46 Warn if SESSION_COOKIE_SECURE is off and
47 "django.contrib.sessions.middleware.SessionMiddleware" is in
48 MIDDLEWARE.
49 """
50 self.assertEqual(sessions.check_session_cookie_secure(None), [sessions.W011])
51
52 @override_settings(
53 SESSION_COOKIE_SECURE=False,
54 INSTALLED_APPS=["django.contrib.sessions"],
55 MIDDLEWARE=["django.contrib.sessions.middleware.SessionMiddleware"],
56 )
57 def test_session_cookie_secure_both(self):
58 """
59 If SESSION_COOKIE_SECURE is off and we find both the session app and
60 the middleware, provide one common warning.
61 """
62 self.assertEqual(sessions.check_session_cookie_secure(None), [sessions.W012])
63
64 @override_settings(
65 SESSION_COOKIE_SECURE=True,
66 INSTALLED_APPS=["django.contrib.sessions"],
67 MIDDLEWARE=["django.contrib.sessions.middleware.SessionMiddleware"],
68 )
69 def test_session_cookie_secure_true(self):
70 """
71 If SESSION_COOKIE_SECURE is on, there's no warning about it.
72 """
73 self.assertEqual(sessions.check_session_cookie_secure(None), [])
74
75
76 class CheckSessionCookieHttpOnlyTest(SimpleTestCase):
77 @override_settings(
78 SESSION_COOKIE_HTTPONLY=False,
79 INSTALLED_APPS=["django.contrib.sessions"],
80 MIDDLEWARE=[],
81 )
82 def test_session_cookie_httponly_with_installed_app(self):
83 """
84 Warn if SESSION_COOKIE_HTTPONLY is off and "django.contrib.sessions"
85 is in INSTALLED_APPS.
86 """
87 self.assertEqual(sessions.check_session_cookie_httponly(None), [sessions.W013])
88
89 @override_settings(
90 SESSION_COOKIE_HTTPONLY="1",
91 INSTALLED_APPS=["django.contrib.sessions"],
92 MIDDLEWARE=[],
93 )
94 def test_session_cookie_httponly_with_installed_app_truthy(self):
95 """SESSION_COOKIE_HTTPONLY must be boolean."""
96 self.assertEqual(sessions.check_session_cookie_httponly(None), [sessions.W013])
97
98 @override_settings(
99 SESSION_COOKIE_HTTPONLY=False,
100 INSTALLED_APPS=[],
101 MIDDLEWARE=["django.contrib.sessions.middleware.SessionMiddleware"],
102 )
103 def test_session_cookie_httponly_with_middleware(self):
104 """
105 Warn if SESSION_COOKIE_HTTPONLY is off and
106 "django.contrib.sessions.middleware.SessionMiddleware" is in
107 MIDDLEWARE.
108 """
109 self.assertEqual(sessions.check_session_cookie_httponly(None), [sessions.W014])
110
111 @override_settings(
112 SESSION_COOKIE_HTTPONLY=False,
113 INSTALLED_APPS=["django.contrib.sessions"],
114 MIDDLEWARE=["django.contrib.sessions.middleware.SessionMiddleware"],
115 )
116 def test_session_cookie_httponly_both(self):
117 """
118 If SESSION_COOKIE_HTTPONLY is off and we find both the session app and
119 the middleware, provide one common warning.
120 """
121 self.assertEqual(sessions.check_session_cookie_httponly(None), [sessions.W015])
122
123 @override_settings(
124 SESSION_COOKIE_HTTPONLY=True,
125 INSTALLED_APPS=["django.contrib.sessions"],
126 MIDDLEWARE=["django.contrib.sessions.middleware.SessionMiddleware"],
127 )
128 def test_session_cookie_httponly_true(self):
129 """
130 If SESSION_COOKIE_HTTPONLY is on, there's no warning about it.
131 """
132 self.assertEqual(sessions.check_session_cookie_httponly(None), [])
133
134
135 class CheckCSRFMiddlewareTest(SimpleTestCase):
136 @override_settings(MIDDLEWARE=[])
137 def test_no_csrf_middleware(self):
138 """
139 Warn if CsrfViewMiddleware isn't in MIDDLEWARE.
140 """
141 self.assertEqual(csrf.check_csrf_middleware(None), [csrf.W003])
142
143 @override_settings(MIDDLEWARE=["django.middleware.csrf.CsrfViewMiddleware"])
144 def test_with_csrf_middleware(self):
145 self.assertEqual(csrf.check_csrf_middleware(None), [])
146
147
148 class CheckCSRFCookieSecureTest(SimpleTestCase):
149 @override_settings(
150 MIDDLEWARE=["django.middleware.csrf.CsrfViewMiddleware"],
151 CSRF_COOKIE_SECURE=False,
152 )
153 def test_with_csrf_cookie_secure_false(self):
154 """
155 Warn if CsrfViewMiddleware is in MIDDLEWARE but
156 CSRF_COOKIE_SECURE isn't True.
157 """
158 self.assertEqual(csrf.check_csrf_cookie_secure(None), [csrf.W016])
159
160 @override_settings(
161 MIDDLEWARE=["django.middleware.csrf.CsrfViewMiddleware"],
162 CSRF_COOKIE_SECURE="1",
163 )
164 def test_with_csrf_cookie_secure_truthy(self):
165 """CSRF_COOKIE_SECURE must be boolean."""
166 self.assertEqual(csrf.check_csrf_cookie_secure(None), [csrf.W016])
167
168 @override_settings(
169 MIDDLEWARE=["django.middleware.csrf.CsrfViewMiddleware"],
170 CSRF_USE_SESSIONS=True,
171 CSRF_COOKIE_SECURE=False,
172 )
173 def test_use_sessions_with_csrf_cookie_secure_false(self):
174 """
175 No warning if CSRF_COOKIE_SECURE isn't True while CSRF_USE_SESSIONS
176 is True.
177 """
178 self.assertEqual(csrf.check_csrf_cookie_secure(None), [])
179
180 @override_settings(MIDDLEWARE=[], CSRF_COOKIE_SECURE=False)
181 def test_with_csrf_cookie_secure_false_no_middleware(self):
182 """
183 No warning if CsrfViewMiddleware isn't in MIDDLEWARE, even if
184 CSRF_COOKIE_SECURE is False.
185 """
186 self.assertEqual(csrf.check_csrf_cookie_secure(None), [])
187
188 @override_settings(
189 MIDDLEWARE=["django.middleware.csrf.CsrfViewMiddleware"],
190 CSRF_COOKIE_SECURE=True,
191 )
192 def test_with_csrf_cookie_secure_true(self):
193 self.assertEqual(csrf.check_csrf_cookie_secure(None), [])
194
195
196 class CheckSecurityMiddlewareTest(SimpleTestCase):
197 @override_settings(MIDDLEWARE=[])
198 def test_no_security_middleware(self):
199 """
200 Warn if SecurityMiddleware isn't in MIDDLEWARE.
201 """
202 self.assertEqual(base.check_security_middleware(None), [base.W001])
203
204 @override_settings(MIDDLEWARE=["django.middleware.security.SecurityMiddleware"])
205 def test_with_security_middleware(self):
206 self.assertEqual(base.check_security_middleware(None), [])
207
208
209 class CheckStrictTransportSecurityTest(SimpleTestCase):
210 @override_settings(
211 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
212 SECURE_HSTS_SECONDS=0,
213 )
214 def test_no_sts(self):
215 """
216 Warn if SECURE_HSTS_SECONDS isn't > 0.
217 """
218 self.assertEqual(base.check_sts(None), [base.W004])
219
220 @override_settings(MIDDLEWARE=[], SECURE_HSTS_SECONDS=0)
221 def test_no_sts_no_middleware(self):
222 """
223 Don't warn if SECURE_HSTS_SECONDS isn't > 0 and SecurityMiddleware isn't
224 installed.
225 """
226 self.assertEqual(base.check_sts(None), [])
227
228 @override_settings(
229 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
230 SECURE_HSTS_SECONDS=3600,
231 )
232 def test_with_sts(self):
233 self.assertEqual(base.check_sts(None), [])
234
235
236 class CheckStrictTransportSecuritySubdomainsTest(SimpleTestCase):
237 @override_settings(
238 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
239 SECURE_HSTS_INCLUDE_SUBDOMAINS=False,
240 SECURE_HSTS_SECONDS=3600,
241 )
242 def test_no_sts_subdomains(self):
243 """
244 Warn if SECURE_HSTS_INCLUDE_SUBDOMAINS isn't True.
245 """
246 self.assertEqual(base.check_sts_include_subdomains(None), [base.W005])
247
248 @override_settings(
249 MIDDLEWARE=[],
250 SECURE_HSTS_INCLUDE_SUBDOMAINS=False,
251 SECURE_HSTS_SECONDS=3600,
252 )
253 def test_no_sts_subdomains_no_middleware(self):
254 """
255 Don't warn if SecurityMiddleware isn't installed.
256 """
257 self.assertEqual(base.check_sts_include_subdomains(None), [])
258
259 @override_settings(
260 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
261 SECURE_SSL_REDIRECT=False,
262 SECURE_HSTS_SECONDS=None,
263 )
264 def test_no_sts_subdomains_no_seconds(self):
265 """
266 Don't warn if SECURE_HSTS_SECONDS isn't set.
267 """
268 self.assertEqual(base.check_sts_include_subdomains(None), [])
269
270 @override_settings(
271 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
272 SECURE_HSTS_INCLUDE_SUBDOMAINS=True,
273 SECURE_HSTS_SECONDS=3600,
274 )
275 def test_with_sts_subdomains(self):
276 self.assertEqual(base.check_sts_include_subdomains(None), [])
277
278
279 class CheckStrictTransportSecurityPreloadTest(SimpleTestCase):
280 @override_settings(
281 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
282 SECURE_HSTS_PRELOAD=False,
283 SECURE_HSTS_SECONDS=3600,
284 )
285 def test_no_sts_preload(self):
286 """
287 Warn if SECURE_HSTS_PRELOAD isn't True.
288 """
289 self.assertEqual(base.check_sts_preload(None), [base.W021])
290
291 @override_settings(
292 MIDDLEWARE=[], SECURE_HSTS_PRELOAD=False, SECURE_HSTS_SECONDS=3600
293 )
294 def test_no_sts_preload_no_middleware(self):
295 """
296 Don't warn if SecurityMiddleware isn't installed.
297 """
298 self.assertEqual(base.check_sts_preload(None), [])
299
300 @override_settings(
301 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
302 SECURE_SSL_REDIRECT=False,
303 SECURE_HSTS_SECONDS=None,
304 )
305 def test_no_sts_preload_no_seconds(self):
306 """
307 Don't warn if SECURE_HSTS_SECONDS isn't set.
308 """
309 self.assertEqual(base.check_sts_preload(None), [])
310
311 @override_settings(
312 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
313 SECURE_HSTS_PRELOAD=True,
314 SECURE_HSTS_SECONDS=3600,
315 )
316 def test_with_sts_preload(self):
317 self.assertEqual(base.check_sts_preload(None), [])
318
319
320 class CheckXFrameOptionsMiddlewareTest(SimpleTestCase):
321 @override_settings(MIDDLEWARE=[])
322 def test_middleware_not_installed(self):
323 """
324 Warn if XFrameOptionsMiddleware isn't in MIDDLEWARE.
325 """
326 self.assertEqual(base.check_xframe_options_middleware(None), [base.W002])
327
328 @override_settings(
329 MIDDLEWARE=["django.middleware.clickjacking.XFrameOptionsMiddleware"]
330 )
331 def test_middleware_installed(self):
332 self.assertEqual(base.check_xframe_options_middleware(None), [])
333
334
335 class CheckXFrameOptionsDenyTest(SimpleTestCase):
336 @override_settings(
337 MIDDLEWARE=["django.middleware.clickjacking.XFrameOptionsMiddleware"],
338 X_FRAME_OPTIONS="SAMEORIGIN",
339 )
340 def test_x_frame_options_not_deny(self):
341 """
342 Warn if XFrameOptionsMiddleware is in MIDDLEWARE but
343 X_FRAME_OPTIONS isn't 'DENY'.
344 """
345 self.assertEqual(base.check_xframe_deny(None), [base.W019])
346
347 @override_settings(MIDDLEWARE=[], X_FRAME_OPTIONS="SAMEORIGIN")
348 def test_middleware_not_installed(self):
349 """
350 No error if XFrameOptionsMiddleware isn't in MIDDLEWARE even if
351 X_FRAME_OPTIONS isn't 'DENY'.
352 """
353 self.assertEqual(base.check_xframe_deny(None), [])
354
355 @override_settings(
356 MIDDLEWARE=["django.middleware.clickjacking.XFrameOptionsMiddleware"],
357 X_FRAME_OPTIONS="DENY",
358 )
359 def test_xframe_deny(self):
360 self.assertEqual(base.check_xframe_deny(None), [])
361
362
363 class CheckContentTypeNosniffTest(SimpleTestCase):
364 @override_settings(
365 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
366 SECURE_CONTENT_TYPE_NOSNIFF=False,
367 )
368 def test_no_content_type_nosniff(self):
369 """
370 Warn if SECURE_CONTENT_TYPE_NOSNIFF isn't True.
371 """
372 self.assertEqual(base.check_content_type_nosniff(None), [base.W006])
373
374 @override_settings(MIDDLEWARE=[], SECURE_CONTENT_TYPE_NOSNIFF=False)
375 def test_no_content_type_nosniff_no_middleware(self):
376 """
377 Don't warn if SECURE_CONTENT_TYPE_NOSNIFF isn't True and
378 SecurityMiddleware isn't in MIDDLEWARE.
379 """
380 self.assertEqual(base.check_content_type_nosniff(None), [])
381
382 @override_settings(
383 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
384 SECURE_CONTENT_TYPE_NOSNIFF=True,
385 )
386 def test_with_content_type_nosniff(self):
387 self.assertEqual(base.check_content_type_nosniff(None), [])
388
389
390 class CheckSSLRedirectTest(SimpleTestCase):
391 @override_settings(
392 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
393 SECURE_SSL_REDIRECT=False,
394 )
395 def test_no_ssl_redirect(self):
396 """
397 Warn if SECURE_SSL_REDIRECT isn't True.
398 """
399 self.assertEqual(base.check_ssl_redirect(None), [base.W008])
400
401 @override_settings(MIDDLEWARE=[], SECURE_SSL_REDIRECT=False)
402 def test_no_ssl_redirect_no_middleware(self):
403 """
404 Don't warn if SECURE_SSL_REDIRECT is False and SecurityMiddleware isn't
405 installed.
406 """
407 self.assertEqual(base.check_ssl_redirect(None), [])
408
409 @override_settings(
410 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
411 SECURE_SSL_REDIRECT=True,
412 )
413 def test_with_ssl_redirect(self):
414 self.assertEqual(base.check_ssl_redirect(None), [])
415
416
417 class CheckSecretKeyTest(SimpleTestCase):
418 @override_settings(SECRET_KEY=("abcdefghijklmnopqrstuvwx" * 2) + "ab")
419 def test_okay_secret_key(self):
420 self.assertEqual(len(settings.SECRET_KEY), base.SECRET_KEY_MIN_LENGTH)
421 self.assertGreater(
422 len(set(settings.SECRET_KEY)), base.SECRET_KEY_MIN_UNIQUE_CHARACTERS
423 )
424 self.assertEqual(base.check_secret_key(None), [])
425
426 @override_settings(SECRET_KEY="")
427 def test_empty_secret_key(self):
428 self.assertEqual(base.check_secret_key(None), [base.W009])
429
430 @override_settings(SECRET_KEY=None)
431 def test_missing_secret_key(self):
432 del settings.SECRET_KEY
433 self.assertEqual(base.check_secret_key(None), [base.W009])
434
435 @override_settings(SECRET_KEY=None)
436 def test_none_secret_key(self):
437 self.assertEqual(base.check_secret_key(None), [base.W009])
438
439 @override_settings(
440 SECRET_KEY=base.SECRET_KEY_INSECURE_PREFIX + get_random_secret_key()
441 )
442 def test_insecure_secret_key(self):
443 self.assertEqual(base.check_secret_key(None), [base.W009])
444
445 @override_settings(SECRET_KEY=("abcdefghijklmnopqrstuvwx" * 2) + "a")
446 def test_low_length_secret_key(self):
447 self.assertEqual(len(settings.SECRET_KEY), base.SECRET_KEY_MIN_LENGTH - 1)
448 self.assertEqual(base.check_secret_key(None), [base.W009])
449
450 @override_settings(SECRET_KEY="abcd" * 20)
451 def test_low_entropy_secret_key(self):
452 self.assertGreater(len(settings.SECRET_KEY), base.SECRET_KEY_MIN_LENGTH)
453 self.assertLess(
454 len(set(settings.SECRET_KEY)), base.SECRET_KEY_MIN_UNIQUE_CHARACTERS
455 )
456 self.assertEqual(base.check_secret_key(None), [base.W009])
457
458
459 class CheckSecretKeyFallbacksTest(SimpleTestCase):
460 @override_settings(SECRET_KEY_FALLBACKS=[("abcdefghijklmnopqrstuvwx" * 2) + "ab"])
461 def test_okay_secret_key_fallbacks(self):
462 self.assertEqual(
463 len(settings.SECRET_KEY_FALLBACKS[0]),
464 base.SECRET_KEY_MIN_LENGTH,
465 )
466 self.assertGreater(
467 len(set(settings.SECRET_KEY_FALLBACKS[0])),
468 base.SECRET_KEY_MIN_UNIQUE_CHARACTERS,
469 )
470 self.assertEqual(base.check_secret_key_fallbacks(None), [])
471
472 def test_no_secret_key_fallbacks(self):
473 with self.settings(SECRET_KEY_FALLBACKS=None):
474 del settings.SECRET_KEY_FALLBACKS
475 self.assertEqual(
476 base.check_secret_key_fallbacks(None),
477 [
478 Warning(base.W025.msg % "SECRET_KEY_FALLBACKS", id=base.W025.id),
479 ],
480 )
481
482 @override_settings(
483 SECRET_KEY_FALLBACKS=[base.SECRET_KEY_INSECURE_PREFIX + get_random_secret_key()]
484 )
485 def test_insecure_secret_key_fallbacks(self):
486 self.assertEqual(
487 base.check_secret_key_fallbacks(None),
488 [
489 Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[0]", id=base.W025.id),
490 ],
491 )
492
493 @override_settings(SECRET_KEY_FALLBACKS=[("abcdefghijklmnopqrstuvwx" * 2) + "a"])
494 def test_low_length_secret_key_fallbacks(self):
495 self.assertEqual(
496 len(settings.SECRET_KEY_FALLBACKS[0]),
497 base.SECRET_KEY_MIN_LENGTH - 1,
498 )
499 self.assertEqual(
500 base.check_secret_key_fallbacks(None),
501 [
502 Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[0]", id=base.W025.id),
503 ],
504 )
505
506 @override_settings(SECRET_KEY_FALLBACKS=["abcd" * 20])
507 def test_low_entropy_secret_key_fallbacks(self):
508 self.assertGreater(
509 len(settings.SECRET_KEY_FALLBACKS[0]),
510 base.SECRET_KEY_MIN_LENGTH,
511 )
512 self.assertLess(
513 len(set(settings.SECRET_KEY_FALLBACKS[0])),
514 base.SECRET_KEY_MIN_UNIQUE_CHARACTERS,
515 )
516 self.assertEqual(
517 base.check_secret_key_fallbacks(None),
518 [
519 Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[0]", id=base.W025.id),
520 ],
521 )
522
523 @override_settings(
524 SECRET_KEY_FALLBACKS=[
525 ("abcdefghijklmnopqrstuvwx" * 2) + "ab",
526 "badkey",
527 ]
528 )
529 def test_multiple_keys(self):
530 self.assertEqual(
531 base.check_secret_key_fallbacks(None),
532 [
533 Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[1]", id=base.W025.id),
534 ],
535 )
536
537 @override_settings(
538 SECRET_KEY_FALLBACKS=[
539 ("abcdefghijklmnopqrstuvwx" * 2) + "ab",
540 "badkey1",
541 "badkey2",
542 ]
543 )
544 def test_multiple_bad_keys(self):
545 self.assertEqual(
546 base.check_secret_key_fallbacks(None),
547 [
548 Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[1]", id=base.W025.id),
549 Warning(base.W025.msg % "SECRET_KEY_FALLBACKS[2]", id=base.W025.id),
550 ],
551 )
552
553
554 class CheckDebugTest(SimpleTestCase):
555 @override_settings(DEBUG=True)
556 def test_debug_true(self):
557 """
558 Warn if DEBUG is True.
559 """
560 self.assertEqual(base.check_debug(None), [base.W018])
561
562 @override_settings(DEBUG=False)
563 def test_debug_false(self):
564 self.assertEqual(base.check_debug(None), [])
565
566
567 class CheckAllowedHostsTest(SimpleTestCase):
568 @override_settings(ALLOWED_HOSTS=[])
569 def test_allowed_hosts_empty(self):
570 self.assertEqual(base.check_allowed_hosts(None), [base.W020])
571
572 @override_settings(ALLOWED_HOSTS=[".example.com"])
573 def test_allowed_hosts_set(self):
574 self.assertEqual(base.check_allowed_hosts(None), [])
575
576
577 class CheckReferrerPolicyTest(SimpleTestCase):
578 @override_settings(
579 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
580 SECURE_REFERRER_POLICY=None,
581 )
582 def test_no_referrer_policy(self):
583 self.assertEqual(base.check_referrer_policy(None), [base.W022])
584
585 @override_settings(MIDDLEWARE=[], SECURE_REFERRER_POLICY=None)
586 def test_no_referrer_policy_no_middleware(self):
587 """
588 Don't warn if SECURE_REFERRER_POLICY is None and SecurityMiddleware
589 isn't in MIDDLEWARE.
590 """
591 self.assertEqual(base.check_referrer_policy(None), [])
592
593 @override_settings(MIDDLEWARE=["django.middleware.security.SecurityMiddleware"])
594 def test_with_referrer_policy(self):
595 tests = (
596 "strict-origin",
597 "strict-origin,origin",
598 "strict-origin, origin",
599 ["strict-origin", "origin"],
600 ("strict-origin", "origin"),
601 )
602 for value in tests:
603 with (
604 self.subTest(value=value),
605 override_settings(SECURE_REFERRER_POLICY=value),
606 ):
607 self.assertEqual(base.check_referrer_policy(None), [])
608
609 @override_settings(
610 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
611 SECURE_REFERRER_POLICY="invalid-value",
612 )
613 def test_with_invalid_referrer_policy(self):
614 self.assertEqual(base.check_referrer_policy(None), [base.E023])
615
616
617 def failure_view_with_invalid_signature():
618 pass
619
620
621 if PY314:
622
623 def failure_view_with_deferred_annotations(request: HttpRequest, reason: str):
624 pass
625
626
627 good_class_based_csrf_failure_view = View.as_view()
628
629
630 class CSRFFailureViewTest(SimpleTestCase):
631 @override_settings(CSRF_FAILURE_VIEW="")
632 def test_failure_view_import_error(self):
633 self.assertEqual(
634 csrf.check_csrf_failure_view(None),
635 [
636 Error(
637 "The CSRF failure view '' could not be imported.",
638 id="security.E102",
639 )
640 ],
641 )
642
643 @override_settings(
644 CSRF_FAILURE_VIEW=(
645 "check_framework.test_security.failure_view_with_invalid_signature"
646 ),
647 )
648 def test_failure_view_invalid_signature(self):
649 msg = (
650 "The CSRF failure view "
651 "'check_framework.test_security.failure_view_with_invalid_signature' "
652 "does not take the correct number of arguments."
653 )
654 self.assertEqual(
655 csrf.check_csrf_failure_view(None),
656 [Error(msg, id="security.E101")],
657 )
658
659 @override_settings(
660 CSRF_FAILURE_VIEW=(
661 "check_framework.test_security.good_class_based_csrf_failure_view"
662 ),
663 )
664 def test_failure_view_valid_class_based(self):
665 self.assertEqual(csrf.check_csrf_failure_view(None), [])
666
667 @unittest.skipUnless(PY314, "Deferred annotations are Python 3.14+ only")
668 @override_settings(
669 CSRF_FAILURE_VIEW=(
670 "check_framework.test_security.failure_view_with_deferred_annotations"
671 ),
672 )
673 def test_failure_view_valid_deferred_annotations(self):
674 self.assertEqual(csrf.check_csrf_failure_view(None), [])
675
676
677 class CheckCrossOriginOpenerPolicyTest(SimpleTestCase):
678 @override_settings(
679 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
680 SECURE_CROSS_ORIGIN_OPENER_POLICY=None,
681 )
682 def test_no_coop(self):
683 self.assertEqual(base.check_cross_origin_opener_policy(None), [])
684
685 @override_settings(MIDDLEWARE=["django.middleware.security.SecurityMiddleware"])
686 def test_with_coop(self):
687 tests = ["same-origin", "same-origin-allow-popups", "unsafe-none"]
688 for value in tests:
689 with (
690 self.subTest(value=value),
691 override_settings(
692 SECURE_CROSS_ORIGIN_OPENER_POLICY=value,
693 ),
694 ):
695 self.assertEqual(base.check_cross_origin_opener_policy(None), [])
696
697 @override_settings(
698 MIDDLEWARE=["django.middleware.security.SecurityMiddleware"],
699 SECURE_CROSS_ORIGIN_OPENER_POLICY="invalid-value",
700 )
701 def test_with_invalid_coop(self):
702 self.assertEqual(base.check_cross_origin_opener_policy(None), [base.E024])