Debian Codegraph @

tests/middleware_exceptions/tests.py

raw
1 from django.conf import settings
2 from django.core.exceptions import MiddlewareNotUsed
3 from django.http import HttpResponse
4 from django.test import RequestFactory, SimpleTestCase, override_settings
5
6 from . import middleware as mw
7
8
9 @override_settings(ROOT_URLCONF="middleware_exceptions.urls")
10 class MiddlewareTests(SimpleTestCase):
11 def tearDown(self):
12 mw.log = []
13
14 @override_settings(
15 MIDDLEWARE=["middleware_exceptions.middleware.ProcessViewNoneMiddleware"]
16 )
17 def test_process_view_return_none(self):
18 response = self.client.get("/middleware_exceptions/view/")
19 self.assertEqual(mw.log, ["processed view normal_view"])
20 self.assertEqual(response.content, b"OK")
21
22 @override_settings(
23 MIDDLEWARE=["middleware_exceptions.middleware.ProcessViewMiddleware"]
24 )
25 def test_process_view_return_response(self):
26 response = self.client.get("/middleware_exceptions/view/")
27 self.assertEqual(response.content, b"Processed view normal_view")
28
29 @override_settings(
30 MIDDLEWARE=[
31 "middleware_exceptions.middleware.ProcessViewTemplateResponseMiddleware",
32 "middleware_exceptions.middleware.LogMiddleware",
33 ]
34 )
35 def test_templateresponse_from_process_view_rendered(self):
36 """
37 TemplateResponses returned from process_view() must be rendered before
38 being passed to any middleware that tries to access response.content,
39 such as middleware_exceptions.middleware.LogMiddleware.
40 """
41 response = self.client.get("/middleware_exceptions/view/")
42 self.assertEqual(
43 response.content,
44 b"Processed view normal_view\nProcessViewTemplateResponseMiddleware",
45 )
46
47 @override_settings(
48 MIDDLEWARE=[
49 "middleware_exceptions.middleware.ProcessViewTemplateResponseMiddleware",
50 "middleware_exceptions.middleware.TemplateResponseMiddleware",
51 ]
52 )
53 def test_templateresponse_from_process_view_passed_to_process_template_response(
54 self,
55 ):
56 """
57 TemplateResponses returned from process_view() should be passed to any
58 template response middleware.
59 """
60 response = self.client.get("/middleware_exceptions/view/")
61 expected_lines = [
62 b"Processed view normal_view",
63 b"ProcessViewTemplateResponseMiddleware",
64 b"TemplateResponseMiddleware",
65 ]
66 self.assertEqual(response.content, b"\n".join(expected_lines))
67
68 @override_settings(
69 MIDDLEWARE=["middleware_exceptions.middleware.TemplateResponseMiddleware"]
70 )
71 def test_process_template_response(self):
72 response = self.client.get("/middleware_exceptions/template_response/")
73 self.assertEqual(
74 response.content, b"template_response OK\nTemplateResponseMiddleware"
75 )
76
77 @override_settings(
78 MIDDLEWARE=["middleware_exceptions.middleware.NoTemplateResponseMiddleware"]
79 )
80 def test_process_template_response_returns_none(self):
81 msg = (
82 "NoTemplateResponseMiddleware.process_template_response didn't "
83 "return an HttpResponse object. It returned None instead."
84 )
85 with self.assertRaisesMessage(ValueError, msg):
86 self.client.get("/middleware_exceptions/template_response/")
87
88 @override_settings(MIDDLEWARE=["middleware_exceptions.middleware.LogMiddleware"])
89 def test_view_exception_converted_before_middleware(self):
90 response = self.client.get("/middleware_exceptions/permission_denied/")
91 self.assertEqual(mw.log, [(response.status_code, response.content)])
92 self.assertEqual(response.status_code, 403)
93
94 @override_settings(
95 MIDDLEWARE=["middleware_exceptions.middleware.ProcessExceptionMiddleware"]
96 )
97 def test_view_exception_handled_by_process_exception(self):
98 response = self.client.get("/middleware_exceptions/error/")
99 self.assertEqual(response.content, b"Exception caught")
100
101 @override_settings(
102 MIDDLEWARE=[
103 "middleware_exceptions.middleware.ProcessExceptionLogMiddleware",
104 "middleware_exceptions.middleware.ProcessExceptionMiddleware",
105 ]
106 )
107 def test_response_from_process_exception_short_circuits_remainder(self):
108 response = self.client.get("/middleware_exceptions/error/")
109 self.assertEqual(mw.log, [])
110 self.assertEqual(response.content, b"Exception caught")
111
112 @override_settings(
113 MIDDLEWARE=[
114 "middleware_exceptions.middleware.ProcessExceptionMiddleware",
115 "middleware_exceptions.middleware.ProcessExceptionLogMiddleware",
116 ]
117 )
118 def test_response_from_process_exception_when_return_response(self):
119 response = self.client.get("/middleware_exceptions/error/")
120 self.assertEqual(mw.log, ["process-exception"])
121 self.assertEqual(response.content, b"Exception caught")
122
123 @override_settings(
124 MIDDLEWARE=[
125 "middleware_exceptions.middleware.LogMiddleware",
126 "middleware_exceptions.middleware.NotFoundMiddleware",
127 ]
128 )
129 def test_exception_in_middleware_converted_before_prior_middleware(self):
130 response = self.client.get("/middleware_exceptions/view/")
131 self.assertEqual(mw.log, [(404, response.content)])
132 self.assertEqual(response.status_code, 404)
133
134 @override_settings(
135 MIDDLEWARE=["middleware_exceptions.middleware.ProcessExceptionMiddleware"]
136 )
137 def test_exception_in_render_passed_to_process_exception(self):
138 response = self.client.get("/middleware_exceptions/exception_in_render/")
139 self.assertEqual(response.content, b"Exception caught")
140
141
142 @override_settings(ROOT_URLCONF="middleware_exceptions.urls")
143 class RootUrlconfTests(SimpleTestCase):
144 @override_settings(ROOT_URLCONF=None)
145 def test_missing_root_urlconf(self):
146 # Removing ROOT_URLCONF is safe, as override_settings will restore
147 # the previously defined settings.
148 del settings.ROOT_URLCONF
149 with self.assertRaises(AttributeError):
150 self.client.get("/middleware_exceptions/view/")
151
152
153 class MyMiddleware:
154 def __init__(self, get_response):
155 raise MiddlewareNotUsed
156
157 def process_request(self, request):
158 pass
159
160
161 class MyMiddlewareWithExceptionMessage:
162 def __init__(self, get_response):
163 raise MiddlewareNotUsed("spam eggs")
164
165 def process_request(self, request):
166 pass
167
168
169 @override_settings(
170 DEBUG=True,
171 ROOT_URLCONF="middleware_exceptions.urls",
172 MIDDLEWARE=["django.middleware.common.CommonMiddleware"],
173 )
174 class MiddlewareNotUsedTests(SimpleTestCase):
175 rf = RequestFactory()
176
177 def test_raise_exception(self):
178 request = self.rf.get("middleware_exceptions/view/")
179 with self.assertRaises(MiddlewareNotUsed):
180 MyMiddleware(lambda req: HttpResponse()).process_request(request)
181
182 @override_settings(MIDDLEWARE=["middleware_exceptions.tests.MyMiddleware"])
183 def test_log(self):
184 with self.assertLogs("django.request", "DEBUG") as cm:
185 self.client.get("/middleware_exceptions/view/")
186 self.assertEqual(
187 cm.records[0].getMessage(),
188 "MiddlewareNotUsed: 'middleware_exceptions.tests.MyMiddleware'",
189 )
190
191 @override_settings(
192 MIDDLEWARE=["middleware_exceptions.tests.MyMiddlewareWithExceptionMessage"]
193 )
194 def test_log_custom_message(self):
195 with self.assertLogs("django.request", "DEBUG") as cm:
196 self.client.get("/middleware_exceptions/view/")
197 self.assertEqual(
198 cm.records[0].getMessage(),
199 "MiddlewareNotUsed('middleware_exceptions.tests."
200 "MyMiddlewareWithExceptionMessage'): spam eggs",
201 )
202
203 @override_settings(
204 DEBUG=False,
205 MIDDLEWARE=["middleware_exceptions.tests.MyMiddleware"],
206 )
207 def test_do_not_log_when_debug_is_false(self):
208 with self.assertNoLogs("django.request", "DEBUG"):
209 self.client.get("/middleware_exceptions/view/")
210
211 @override_settings(
212 MIDDLEWARE=[
213 "middleware_exceptions.middleware.SyncAndAsyncMiddleware",
214 "middleware_exceptions.tests.MyMiddleware",
215 ]
216 )
217 async def test_async_and_sync_middleware_chain_async_call(self):
218 with self.assertLogs("django.request", "DEBUG") as cm:
219 response = await self.async_client.get("/middleware_exceptions/view/")
220 self.assertEqual(response.content, b"OK")
221 self.assertEqual(response.status_code, 200)
222 self.assertEqual(
223 cm.records[0].getMessage(),
224 "Asynchronous handler adapted for middleware "
225 "middleware_exceptions.tests.MyMiddleware.",
226 )
227 self.assertEqual(
228 cm.records[1].getMessage(),
229 "MiddlewareNotUsed: 'middleware_exceptions.tests.MyMiddleware'",
230 )
231
232
233 @override_settings(
234 DEBUG=True,
235 ROOT_URLCONF="middleware_exceptions.urls",
236 )
237 class MiddlewareSyncAsyncTests(SimpleTestCase):
238 @override_settings(
239 MIDDLEWARE=[
240 "middleware_exceptions.middleware.PaymentMiddleware",
241 ]
242 )
243 def test_sync_middleware(self):
244 response = self.client.get("/middleware_exceptions/view/")
245 self.assertEqual(response.status_code, 402)
246
247 @override_settings(
248 MIDDLEWARE=[
249 "middleware_exceptions.middleware.DecoratedPaymentMiddleware",
250 ]
251 )
252 def test_sync_decorated_middleware(self):
253 response = self.client.get("/middleware_exceptions/view/")
254 self.assertEqual(response.status_code, 402)
255
256 @override_settings(
257 MIDDLEWARE=[
258 "middleware_exceptions.middleware.async_payment_middleware",
259 ]
260 )
261 def test_async_middleware(self):
262 with self.assertLogs("django.request", "DEBUG") as cm:
263 response = self.client.get("/middleware_exceptions/view/")
264 self.assertEqual(response.status_code, 402)
265 self.assertEqual(
266 cm.records[0].getMessage(),
267 "Synchronous handler adapted for middleware "
268 "middleware_exceptions.middleware.async_payment_middleware.",
269 )
270
271 @override_settings(
272 MIDDLEWARE=[
273 "middleware_exceptions.middleware.NotSyncOrAsyncMiddleware",
274 ]
275 )
276 def test_not_sync_or_async_middleware(self):
277 msg = (
278 "Middleware "
279 "middleware_exceptions.middleware.NotSyncOrAsyncMiddleware must "
280 "have at least one of sync_capable/async_capable set to True."
281 )
282 with self.assertRaisesMessage(RuntimeError, msg):
283 self.client.get("/middleware_exceptions/view/")
284
285 @override_settings(
286 MIDDLEWARE=[
287 "middleware_exceptions.middleware.PaymentMiddleware",
288 ]
289 )
290 async def test_sync_middleware_async(self):
291 with self.assertLogs("django.request", "DEBUG") as cm:
292 response = await self.async_client.get("/middleware_exceptions/view/")
293 self.assertEqual(response.status_code, 402)
294 self.assertEqual(
295 cm.records[0].getMessage(),
296 "Asynchronous handler adapted for middleware "
297 "middleware_exceptions.middleware.PaymentMiddleware.",
298 )
299
300 @override_settings(
301 MIDDLEWARE=[
302 "middleware_exceptions.middleware.async_payment_middleware",
303 ]
304 )
305 async def test_async_middleware_async(self):
306 with self.assertLogs("django.request", "WARNING") as cm:
307 response = await self.async_client.get("/middleware_exceptions/view/")
308 self.assertEqual(response.status_code, 402)
309 self.assertEqual(
310 cm.records[0].getMessage(),
311 "Payment Required: /middleware_exceptions/view/",
312 )
313
314 @override_settings(
315 DEBUG=False,
316 MIDDLEWARE=[
317 "middleware_exceptions.middleware.AsyncNoTemplateResponseMiddleware",
318 ],
319 )
320 def test_async_process_template_response_returns_none_with_sync_client(self):
321 msg = (
322 "AsyncNoTemplateResponseMiddleware.process_template_response "
323 "didn't return an HttpResponse object."
324 )
325 with self.assertRaisesMessage(ValueError, msg):
326 self.client.get("/middleware_exceptions/template_response/")
327
328 @override_settings(
329 MIDDLEWARE=[
330 "middleware_exceptions.middleware.SyncAndAsyncMiddleware",
331 ]
332 )
333 async def test_async_and_sync_middleware_async_call(self):
334 response = await self.async_client.get("/middleware_exceptions/view/")
335 self.assertEqual(response.content, b"OK")
336 self.assertEqual(response.status_code, 200)
337
338 @override_settings(
339 MIDDLEWARE=[
340 "middleware_exceptions.middleware.SyncAndAsyncMiddleware",
341 ]
342 )
343 def test_async_and_sync_middleware_sync_call(self):
344 response = self.client.get("/middleware_exceptions/view/")
345 self.assertEqual(response.content, b"OK")
346 self.assertEqual(response.status_code, 200)
347
348
349 @override_settings(ROOT_URLCONF="middleware_exceptions.urls")
350 class AsyncMiddlewareTests(SimpleTestCase):
351 @override_settings(
352 MIDDLEWARE=[
353 "middleware_exceptions.middleware.AsyncTemplateResponseMiddleware",
354 ]
355 )
356 async def test_process_template_response(self):
357 response = await self.async_client.get(
358 "/middleware_exceptions/template_response/"
359 )
360 self.assertEqual(
361 response.content,
362 b"template_response OK\nAsyncTemplateResponseMiddleware",
363 )
364
365 @override_settings(
366 MIDDLEWARE=[
367 "middleware_exceptions.middleware.AsyncNoTemplateResponseMiddleware",
368 ]
369 )
370 async def test_process_template_response_returns_none(self):
371 msg = (
372 "AsyncNoTemplateResponseMiddleware.process_template_response "
373 "didn't return an HttpResponse object. It returned None instead."
374 )
375 with self.assertRaisesMessage(ValueError, msg):
376 await self.async_client.get("/middleware_exceptions/template_response/")
377
378 @override_settings(
379 MIDDLEWARE=[
380 "middleware_exceptions.middleware.AsyncProcessExceptionMiddleware",
381 ]
382 )
383 async def test_exception_in_render_passed_to_process_exception(self):
384 response = await self.async_client.get(
385 "/middleware_exceptions/exception_in_render/"
386 )
387 self.assertEqual(response.content, b"Exception caught")
388
389 @override_settings(
390 MIDDLEWARE=[
391 "middleware_exceptions.middleware.AsyncProcessExceptionMiddleware",
392 ]
393 )
394 async def test_exception_in_async_render_passed_to_process_exception(self):
395 response = await self.async_client.get(
396 "/middleware_exceptions/async_exception_in_render/"
397 )
398 self.assertEqual(response.content, b"Exception caught")
399
400 @override_settings(
401 MIDDLEWARE=[
402 "middleware_exceptions.middleware.AsyncProcessExceptionMiddleware",
403 ]
404 )
405 async def test_view_exception_handled_by_process_exception(self):
406 response = await self.async_client.get("/middleware_exceptions/error/")
407 self.assertEqual(response.content, b"Exception caught")
408
409 @override_settings(
410 MIDDLEWARE=[
411 "middleware_exceptions.middleware.AsyncProcessViewMiddleware",
412 ]
413 )
414 async def test_process_view_return_response(self):
415 response = await self.async_client.get("/middleware_exceptions/view/")
416 self.assertEqual(response.content, b"Processed view normal_view")