Debian Codegraph @

tests/decorators/test_csrf.py

raw
1 from asgiref.sync import iscoroutinefunction
2
3 from django.conf import settings
4 from django.http import HttpRequest, HttpResponse
5 from django.test import SimpleTestCase
6 from django.views.decorators.csrf import (
7 csrf_exempt,
8 csrf_protect,
9 ensure_csrf_cookie,
10 requires_csrf_token,
11 )
12
13 CSRF_TOKEN = "1bcdefghij2bcdefghij3bcdefghij4bcdefghij5bcdefghij6bcdefghijABCD"
14
15
16 class CsrfTestMixin:
17 def get_request(self, token=CSRF_TOKEN):
18 request = HttpRequest()
19 request.method = "POST"
20 if token:
21 request.POST["csrfmiddlewaretoken"] = token
22 request.COOKIES[settings.CSRF_COOKIE_NAME] = token
23 return request
24
25
26 class CsrfProtectTests(CsrfTestMixin, SimpleTestCase):
27 def test_wrapped_sync_function_is_not_coroutine_function(self):
28 def sync_view(request):
29 return HttpResponse()
30
31 wrapped_view = csrf_protect(sync_view)
32 self.assertIs(iscoroutinefunction(wrapped_view), False)
33
34 def test_wrapped_async_function_is_coroutine_function(self):
35 async def async_view(request):
36 return HttpResponse()
37
38 wrapped_view = csrf_protect(async_view)
39 self.assertIs(iscoroutinefunction(wrapped_view), True)
40
41 def test_csrf_protect_decorator(self):
42 @csrf_protect
43 def sync_view(request):
44 return HttpResponse()
45
46 request = self.get_request()
47 response = sync_view(request)
48 self.assertEqual(response.status_code, 200)
49 self.assertIs(request.csrf_processing_done, True)
50
51 with self.assertLogs("django.security.csrf", "WARNING"):
52 request = self.get_request(token=None)
53 response = sync_view(request)
54 self.assertEqual(response.status_code, 403)
55
56 async def test_csrf_protect_decorator_async_view(self):
57 @csrf_protect
58 async def async_view(request):
59 return HttpResponse()
60
61 request = self.get_request()
62 response = await async_view(request)
63 self.assertEqual(response.status_code, 200)
64 self.assertIs(request.csrf_processing_done, True)
65
66 with self.assertLogs("django.security.csrf", "WARNING"):
67 request = self.get_request(token=None)
68 response = await async_view(request)
69 self.assertEqual(response.status_code, 403)
70
71
72 class RequiresCsrfTokenTests(CsrfTestMixin, SimpleTestCase):
73 def test_wrapped_sync_function_is_not_coroutine_function(self):
74 def sync_view(request):
75 return HttpResponse()
76
77 wrapped_view = requires_csrf_token(sync_view)
78 self.assertIs(iscoroutinefunction(wrapped_view), False)
79
80 def test_wrapped_async_function_is_coroutine_function(self):
81 async def async_view(request):
82 return HttpResponse()
83
84 wrapped_view = requires_csrf_token(async_view)
85 self.assertIs(iscoroutinefunction(wrapped_view), True)
86
87 def test_requires_csrf_token_decorator(self):
88 @requires_csrf_token
89 def sync_view(request):
90 return HttpResponse()
91
92 request = self.get_request()
93 response = sync_view(request)
94 self.assertEqual(response.status_code, 200)
95 self.assertIs(request.csrf_processing_done, True)
96
97 with self.assertNoLogs("django.security.csrf", "WARNING"):
98 request = self.get_request(token=None)
99 response = sync_view(request)
100 self.assertEqual(response.status_code, 200)
101
102 async def test_requires_csrf_token_decorator_async_view(self):
103 @requires_csrf_token
104 async def async_view(request):
105 return HttpResponse()
106
107 request = self.get_request()
108 response = await async_view(request)
109 self.assertEqual(response.status_code, 200)
110 self.assertIs(request.csrf_processing_done, True)
111
112 with self.assertNoLogs("django.security.csrf", "WARNING"):
113 request = self.get_request(token=None)
114 response = await async_view(request)
115 self.assertEqual(response.status_code, 200)
116
117
118 class EnsureCsrfCookieTests(CsrfTestMixin, SimpleTestCase):
119 def test_wrapped_sync_function_is_not_coroutine_function(self):
120 def sync_view(request):
121 return HttpResponse()
122
123 wrapped_view = ensure_csrf_cookie(sync_view)
124 self.assertIs(iscoroutinefunction(wrapped_view), False)
125
126 def test_wrapped_async_function_is_coroutine_function(self):
127 async def async_view(request):
128 return HttpResponse()
129
130 wrapped_view = ensure_csrf_cookie(async_view)
131 self.assertIs(iscoroutinefunction(wrapped_view), True)
132
133 def test_ensure_csrf_cookie_decorator(self):
134 @ensure_csrf_cookie
135 def sync_view(request):
136 return HttpResponse()
137
138 request = self.get_request()
139 response = sync_view(request)
140 self.assertEqual(response.status_code, 200)
141 self.assertIs(request.csrf_processing_done, True)
142
143 with self.assertNoLogs("django.security.csrf", "WARNING"):
144 request = self.get_request(token=None)
145 response = sync_view(request)
146 self.assertEqual(response.status_code, 200)
147
148 async def test_ensure_csrf_cookie_decorator_async_view(self):
149 @ensure_csrf_cookie
150 async def async_view(request):
151 return HttpResponse()
152
153 request = self.get_request()
154 response = await async_view(request)
155 self.assertEqual(response.status_code, 200)
156 self.assertIs(request.csrf_processing_done, True)
157
158 with self.assertNoLogs("django.security.csrf", "WARNING"):
159 request = self.get_request(token=None)
160 response = await async_view(request)
161 self.assertEqual(response.status_code, 200)
162
163
164 class CsrfExemptTests(SimpleTestCase):
165 def test_wrapped_sync_function_is_not_coroutine_function(self):
166 def sync_view(request):
167 return HttpResponse()
168
169 wrapped_view = csrf_exempt(sync_view)
170 self.assertIs(iscoroutinefunction(wrapped_view), False)
171
172 def test_wrapped_async_function_is_coroutine_function(self):
173 async def async_view(request):
174 return HttpResponse()
175
176 wrapped_view = csrf_exempt(async_view)
177 self.assertIs(iscoroutinefunction(wrapped_view), True)
178
179 def test_csrf_exempt_decorator(self):
180 @csrf_exempt
181 def sync_view(request):
182 return HttpResponse()
183
184 self.assertIs(sync_view.csrf_exempt, True)
185 self.assertIsInstance(sync_view(HttpRequest()), HttpResponse)
186
187 async def test_csrf_exempt_decorator_async_view(self):
188 @csrf_exempt
189 async def async_view(request):
190 return HttpResponse()
191
192 self.assertIs(async_view.csrf_exempt, True)
193 self.assertIsInstance(await async_view(HttpRequest()), HttpResponse)