Debian Codegraph @

tests/generic_views/test_base.py

raw
1 import logging
2 import time
3
4 from logging_tests.tests import LoggingAssertionMixin
5
6 from django.core.exceptions import ImproperlyConfigured
7 from django.http import HttpResponse
8 from django.test import RequestFactory, SimpleTestCase, override_settings
9 from django.test.utils import require_jinja2
10 from django.urls import resolve
11 from django.views.generic import RedirectView, TemplateView, View
12
13 from . import views
14
15
16 class SimpleView(View):
17 """
18 A simple view with a docstring.
19 """
20
21 def get(self, request):
22 return HttpResponse("This is a simple view")
23
24
25 class SimplePostView(SimpleView):
26 post = SimpleView.get
27
28
29 class PostOnlyView(View):
30 def post(self, request):
31 return HttpResponse("This view only accepts POST")
32
33
34 class CustomizableView(SimpleView):
35 parameter = {}
36
37
38 def decorator(view):
39 view.is_decorated = True
40 return view
41
42
43 class DecoratedDispatchView(SimpleView):
44 @decorator
45 def dispatch(self, request, *args, **kwargs):
46 return super().dispatch(request, *args, **kwargs)
47
48
49 class AboutTemplateView(TemplateView):
50 def get(self, request):
51 return self.render_to_response({})
52
53 def get_template_names(self):
54 return ["generic_views/about.html"]
55
56
57 class AboutTemplateAttributeView(TemplateView):
58 template_name = "generic_views/about.html"
59
60 def get(self, request):
61 return self.render_to_response(context={})
62
63
64 class InstanceView(View):
65 def get(self, request):
66 return self
67
68
69 class ViewTest(LoggingAssertionMixin, SimpleTestCase):
70 rf = RequestFactory()
71
72 def _assert_simple(self, response):
73 self.assertEqual(response.status_code, 200)
74 self.assertEqual(response.content, b"This is a simple view")
75
76 def test_no_init_kwargs(self):
77 """
78 A view can't be accidentally instantiated before deployment
79 """
80 msg = "This method is available only on the class, not on instances."
81 with self.assertRaisesMessage(AttributeError, msg):
82 SimpleView(key="value").as_view()
83
84 def test_no_init_args(self):
85 """
86 A view can't be accidentally instantiated before deployment
87 """
88 msg = "as_view() takes 1 positional argument but 2 were given"
89 with self.assertRaisesMessage(TypeError, msg):
90 SimpleView.as_view("value")
91
92 def test_pathological_http_method(self):
93 """
94 The edge case of an HTTP request that spoofs an existing method name is
95 caught.
96 """
97 self.assertEqual(
98 SimpleView.as_view()(
99 self.rf.get("/", REQUEST_METHOD="DISPATCH")
100 ).status_code,
101 405,
102 )
103
104 def test_get_only(self):
105 """
106 Test a view which only allows GET doesn't allow other methods.
107 """
108 self._assert_simple(SimpleView.as_view()(self.rf.get("/")))
109 self.assertEqual(SimpleView.as_view()(self.rf.post("/")).status_code, 405)
110 self.assertEqual(
111 SimpleView.as_view()(self.rf.get("/", REQUEST_METHOD="FAKE")).status_code,
112 405,
113 )
114
115 def test_get_and_head(self):
116 """
117 Test a view which supplies a GET method also responds correctly to HEAD.
118 """
119 self._assert_simple(SimpleView.as_view()(self.rf.get("/")))
120 response = SimpleView.as_view()(self.rf.head("/"))
121 self.assertEqual(response.status_code, 200)
122
123 def test_setup_get_and_head(self):
124 view_instance = SimpleView()
125 self.assertFalse(hasattr(view_instance, "head"))
126 view_instance.setup(self.rf.get("/"))
127 self.assertTrue(hasattr(view_instance, "head"))
128 self.assertEqual(view_instance.head, view_instance.get)
129
130 def test_head_no_get(self):
131 """
132 Test a view which supplies no GET method responds to HEAD with HTTP 405.
133 """
134 response = PostOnlyView.as_view()(self.rf.head("/"))
135 self.assertEqual(response.status_code, 405)
136
137 def test_get_and_post(self):
138 """
139 Test a view which only allows both GET and POST.
140 """
141 self._assert_simple(SimplePostView.as_view()(self.rf.get("/")))
142 self._assert_simple(SimplePostView.as_view()(self.rf.post("/")))
143 self.assertEqual(
144 SimplePostView.as_view()(
145 self.rf.get("/", REQUEST_METHOD="FAKE")
146 ).status_code,
147 405,
148 )
149
150 def test_invalid_keyword_argument(self):
151 """
152 View arguments must be predefined on the class and can't
153 be named like an HTTP method.
154 """
155 msg = (
156 "The method name %s is not accepted as a keyword argument to "
157 "SimpleView()."
158 )
159 # Check each of the allowed method names
160 for method in SimpleView.http_method_names:
161 with self.assertRaisesMessage(TypeError, msg % method):
162 SimpleView.as_view(**{method: "value"})
163
164 # Check the case view argument is ok if predefined on the class...
165 CustomizableView.as_view(parameter="value")
166 # ...but raises errors otherwise.
167 msg = (
168 "CustomizableView() received an invalid keyword 'foobar'. "
169 "as_view only accepts arguments that are already attributes of "
170 "the class."
171 )
172 with self.assertRaisesMessage(TypeError, msg):
173 CustomizableView.as_view(foobar="value")
174
175 def test_calling_more_than_once(self):
176 """
177 Test a view can only be called once.
178 """
179 request = self.rf.get("/")
180 view = InstanceView.as_view()
181 self.assertNotEqual(view(request), view(request))
182
183 def test_class_attributes(self):
184 """
185 The callable returned from as_view() has proper special attributes.
186 """
187 cls = SimpleView
188 view = cls.as_view()
189 self.assertEqual(view.__doc__, cls.__doc__)
190 self.assertEqual(view.__name__, "view")
191 self.assertEqual(view.__module__, cls.__module__)
192 self.assertEqual(view.__qualname__, f"{cls.as_view.__qualname__}.<locals>.view")
193 self.assertEqual(view.__annotations__, cls.dispatch.__annotations__)
194 self.assertFalse(hasattr(view, "__wrapped__"))
195
196 def test_dispatch_decoration(self):
197 """
198 Attributes set by decorators on the dispatch method
199 are also present on the closure.
200 """
201 self.assertTrue(DecoratedDispatchView.as_view().is_decorated)
202
203 def test_options(self):
204 """
205 Views respond to HTTP OPTIONS requests with an Allow header
206 appropriate for the methods implemented by the view class.
207 """
208 request = self.rf.options("/")
209 view = SimpleView.as_view()
210 response = view(request)
211 self.assertEqual(200, response.status_code)
212 self.assertTrue(response.headers["Allow"])
213
214 def test_options_for_get_view(self):
215 """
216 A view implementing GET allows GET and HEAD.
217 """
218 request = self.rf.options("/")
219 view = SimpleView.as_view()
220 response = view(request)
221 self._assert_allows(response, "GET", "HEAD")
222
223 def test_options_for_get_and_post_view(self):
224 """
225 A view implementing GET and POST allows GET, HEAD, and POST.
226 """
227 request = self.rf.options("/")
228 view = SimplePostView.as_view()
229 response = view(request)
230 self._assert_allows(response, "GET", "HEAD", "POST")
231
232 def test_options_for_post_view(self):
233 """
234 A view implementing POST allows POST.
235 """
236 request = self.rf.options("/")
237 view = PostOnlyView.as_view()
238 response = view(request)
239 self._assert_allows(response, "POST")
240
241 def _assert_allows(self, response, *expected_methods):
242 "Assert allowed HTTP methods reported in the Allow response header"
243 response_allows = set(response.headers["Allow"].split(", "))
244 self.assertEqual(set(expected_methods + ("OPTIONS",)), response_allows)
245
246 def test_args_kwargs_request_on_self(self):
247 """
248 Test a view only has args, kwargs & request once `as_view`
249 has been called.
250 """
251 bare_view = InstanceView()
252 view = InstanceView.as_view()(self.rf.get("/"))
253 for attribute in ("args", "kwargs", "request"):
254 self.assertNotIn(attribute, dir(bare_view))
255 self.assertIn(attribute, dir(view))
256
257 def test_overridden_setup(self):
258 class SetAttributeMixin:
259 def setup(self, request, *args, **kwargs):
260 self.attr = True
261 super().setup(request, *args, **kwargs)
262
263 class CheckSetupView(SetAttributeMixin, SimpleView):
264 def dispatch(self, request, *args, **kwargs):
265 assert hasattr(self, "attr")
266 return super().dispatch(request, *args, **kwargs)
267
268 response = CheckSetupView.as_view()(self.rf.get("/"))
269 self.assertEqual(response.status_code, 200)
270
271 def test_not_calling_parent_setup_error(self):
272 class TestView(View):
273 def setup(self, request, *args, **kwargs):
274 pass # Not calling super().setup()
275
276 msg = (
277 "TestView instance has no 'request' attribute. Did you override "
278 "setup() and forget to call super()?"
279 )
280 with self.assertRaisesMessage(AttributeError, msg):
281 TestView.as_view()(self.rf.get("/"))
282
283 def test_setup_adds_args_kwargs_request(self):
284 request = self.rf.get("/")
285 args = ("arg 1", "arg 2")
286 kwargs = {"kwarg_1": 1, "kwarg_2": "year"}
287
288 view = View()
289 view.setup(request, *args, **kwargs)
290 self.assertEqual(request, view.request)
291 self.assertEqual(args, view.args)
292 self.assertEqual(kwargs, view.kwargs)
293
294 def test_direct_instantiation(self):
295 """
296 It should be possible to use the view by directly instantiating it
297 without going through .as_view() (#21564).
298 """
299 view = PostOnlyView()
300 response = view.dispatch(self.rf.head("/"))
301 self.assertEqual(response.status_code, 405)
302
303 def test_method_not_allowed_response_logged(self):
304 for path, escaped in [
305 ("/foo/", "/foo/"),
306 (r"/%1B[1;31mNOW IN RED!!!1B[0m/", r"/\x1b[1;31mNOW IN RED!!!1B[0m/"),
307 ]:
308 with self.subTest(path=path):
309 request = self.rf.get(path, REQUEST_METHOD="BOGUS")
310 with self.assertLogs("django.request", "WARNING") as handler:
311 response = SimpleView.as_view()(request)
312
313 self.assertLogRecord(
314 handler,
315 f"Method Not Allowed (BOGUS): {escaped}",
316 logging.WARNING,
317 405,
318 request,
319 )
320 self.assertEqual(response.status_code, 405)
321
322
323 @override_settings(ROOT_URLCONF="generic_views.urls")
324 class TemplateViewTest(SimpleTestCase):
325 rf = RequestFactory()
326
327 def _assert_about(self, response):
328 response.render()
329 self.assertContains(response, "<h1>About</h1>")
330
331 def test_get(self):
332 """
333 Test a view that simply renders a template on GET
334 """
335 self._assert_about(AboutTemplateView.as_view()(self.rf.get("/about/")))
336
337 def test_head(self):
338 """
339 Test a TemplateView responds correctly to HEAD
340 """
341 response = AboutTemplateView.as_view()(self.rf.head("/about/"))
342 self.assertEqual(response.status_code, 200)
343
344 def test_get_template_attribute(self):
345 """
346 Test a view that renders a template on GET with the template name as
347 an attribute on the class.
348 """
349 self._assert_about(AboutTemplateAttributeView.as_view()(self.rf.get("/about/")))
350
351 def test_get_generic_template(self):
352 """
353 Test a completely generic view that renders a template on GET
354 with the template name as an argument at instantiation.
355 """
356 self._assert_about(
357 TemplateView.as_view(template_name="generic_views/about.html")(
358 self.rf.get("/about/")
359 )
360 )
361
362 def test_template_name_required(self):
363 """
364 A template view must provide a template name.
365 """
366 msg = (
367 "TemplateResponseMixin requires either a definition of "
368 "'template_name' or an implementation of 'get_template_names()'"
369 )
370 with self.assertRaisesMessage(ImproperlyConfigured, msg):
371 self.client.get("/template/no_template/")
372
373 @require_jinja2
374 def test_template_engine(self):
375 """
376 A template view may provide a template engine.
377 """
378 request = self.rf.get("/using/")
379 view = TemplateView.as_view(template_name="generic_views/using.html")
380 self.assertEqual(view(request).render().content, b"DTL\n")
381 view = TemplateView.as_view(
382 template_name="generic_views/using.html", template_engine="django"
383 )
384 self.assertEqual(view(request).render().content, b"DTL\n")
385 view = TemplateView.as_view(
386 template_name="generic_views/using.html", template_engine="jinja2"
387 )
388 self.assertEqual(view(request).render().content, b"Jinja2\n")
389
390 def test_template_params(self):
391 """
392 A generic template view passes kwargs as context.
393 """
394 response = self.client.get("/template/simple/bar/")
395 self.assertEqual(response.status_code, 200)
396 self.assertEqual(response.context["foo"], "bar")
397 self.assertIsInstance(response.context["view"], View)
398
399 def test_extra_template_params(self):
400 """
401 A template view can be customized to return extra context.
402 """
403 response = self.client.get("/template/custom/bar/")
404 self.assertEqual(response.status_code, 200)
405 self.assertEqual(response.context["foo"], "bar")
406 self.assertEqual(response.context["key"], "value")
407 self.assertIsInstance(response.context["view"], View)
408
409 def test_cached_views(self):
410 """
411 A template view can be cached
412 """
413 response = self.client.get("/template/cached/bar/")
414 self.assertEqual(response.status_code, 200)
415
416 time.sleep(1.0)
417
418 response2 = self.client.get("/template/cached/bar/")
419 self.assertEqual(response2.status_code, 200)
420
421 self.assertEqual(response.content, response2.content)
422
423 time.sleep(2.0)
424
425 # Let the cache expire and test again
426 response2 = self.client.get("/template/cached/bar/")
427 self.assertEqual(response2.status_code, 200)
428
429 self.assertNotEqual(response.content, response2.content)
430
431 def test_content_type(self):
432 response = self.client.get("/template/content_type/")
433 self.assertEqual(response.headers["Content-Type"], "text/plain")
434
435 def test_resolve_view(self):
436 match = resolve("/template/content_type/")
437 self.assertIs(match.func.view_class, TemplateView)
438 self.assertEqual(match.func.view_initkwargs["content_type"], "text/plain")
439
440 def test_resolve_login_required_view(self):
441 match = resolve("/template/login_required/")
442 self.assertIs(match.func.view_class, TemplateView)
443
444 def test_extra_context(self):
445 response = self.client.get("/template/extra_context/")
446 self.assertEqual(response.context["title"], "Title")
447
448
449 @override_settings(ROOT_URLCONF="generic_views.urls")
450 class RedirectViewTest(LoggingAssertionMixin, SimpleTestCase):
451 rf = RequestFactory()
452
453 def test_no_url(self):
454 "Without any configuration, returns HTTP 410 GONE"
455 response = RedirectView.as_view()(self.rf.get("/foo/"))
456 self.assertEqual(response.status_code, 410)
457
458 def test_default_redirect(self):
459 "Default is a temporary redirect"
460 response = RedirectView.as_view(url="/bar/")(self.rf.get("/foo/"))
461 self.assertEqual(response.status_code, 302)
462 self.assertEqual(response.url, "/bar/")
463
464 def test_permanent_redirect(self):
465 "Permanent redirects are an option"
466 response = RedirectView.as_view(url="/bar/", permanent=True)(
467 self.rf.get("/foo/")
468 )
469 self.assertEqual(response.status_code, 301)
470 self.assertEqual(response.url, "/bar/")
471
472 def test_temporary_redirect(self):
473 "Temporary redirects are an option"
474 response = RedirectView.as_view(url="/bar/", permanent=False)(
475 self.rf.get("/foo/")
476 )
477 self.assertEqual(response.status_code, 302)
478 self.assertEqual(response.url, "/bar/")
479
480 def test_include_args(self):
481 "GET arguments can be included in the redirected URL"
482 response = RedirectView.as_view(url="/bar/")(self.rf.get("/foo/"))
483 self.assertEqual(response.status_code, 302)
484 self.assertEqual(response.url, "/bar/")
485
486 response = RedirectView.as_view(url="/bar/", query_string=True)(
487 self.rf.get("/foo/?pork=spam")
488 )
489 self.assertEqual(response.status_code, 302)
490 self.assertEqual(response.url, "/bar/?pork=spam")
491
492 def test_include_urlencoded_args(self):
493 "GET arguments can be URL-encoded when included in the redirected URL"
494 response = RedirectView.as_view(url="/bar/", query_string=True)(
495 self.rf.get("/foo/?unicode=%E2%9C%93")
496 )
497 self.assertEqual(response.status_code, 302)
498 self.assertEqual(response.url, "/bar/?unicode=%E2%9C%93")
499
500 def test_parameter_substitution(self):
501 "Redirection URLs can be parameterized"
502 response = RedirectView.as_view(url="/bar/%(object_id)d/")(
503 self.rf.get("/foo/42/"), object_id=42
504 )
505 self.assertEqual(response.status_code, 302)
506 self.assertEqual(response.url, "/bar/42/")
507
508 def test_named_url_pattern(self):
509 "Named pattern parameter should reverse to the matching pattern"
510 response = RedirectView.as_view(pattern_name="artist_detail")(
511 self.rf.get("/foo/"), pk=1
512 )
513 self.assertEqual(response.status_code, 302)
514 self.assertEqual(response.headers["Location"], "/detail/artist/1/")
515
516 def test_named_url_pattern_using_args(self):
517 response = RedirectView.as_view(pattern_name="artist_detail")(
518 self.rf.get("/foo/"), 1
519 )
520 self.assertEqual(response.status_code, 302)
521 self.assertEqual(response.headers["Location"], "/detail/artist/1/")
522
523 def test_redirect_POST(self):
524 "Default is a temporary redirect"
525 response = RedirectView.as_view(url="/bar/")(self.rf.post("/foo/"))
526 self.assertEqual(response.status_code, 302)
527 self.assertEqual(response.url, "/bar/")
528
529 def test_redirect_HEAD(self):
530 "Default is a temporary redirect"
531 response = RedirectView.as_view(url="/bar/")(self.rf.head("/foo/"))
532 self.assertEqual(response.status_code, 302)
533 self.assertEqual(response.url, "/bar/")
534
535 def test_redirect_OPTIONS(self):
536 "Default is a temporary redirect"
537 response = RedirectView.as_view(url="/bar/")(self.rf.options("/foo/"))
538 self.assertEqual(response.status_code, 302)
539 self.assertEqual(response.url, "/bar/")
540
541 def test_redirect_PUT(self):
542 "Default is a temporary redirect"
543 response = RedirectView.as_view(url="/bar/")(self.rf.put("/foo/"))
544 self.assertEqual(response.status_code, 302)
545 self.assertEqual(response.url, "/bar/")
546
547 def test_redirect_PATCH(self):
548 "Default is a temporary redirect"
549 response = RedirectView.as_view(url="/bar/")(self.rf.patch("/foo/"))
550 self.assertEqual(response.status_code, 302)
551 self.assertEqual(response.url, "/bar/")
552
553 def test_redirect_DELETE(self):
554 "Default is a temporary redirect"
555 response = RedirectView.as_view(url="/bar/")(self.rf.delete("/foo/"))
556 self.assertEqual(response.status_code, 302)
557 self.assertEqual(response.url, "/bar/")
558
559 def test_redirect_when_meta_contains_no_query_string(self):
560 "regression for #16705"
561 # we can't use self.rf.get because it always sets QUERY_STRING
562 response = RedirectView.as_view(url="/bar/")(self.rf.request(PATH_INFO="/foo/"))
563 self.assertEqual(response.status_code, 302)
564
565 def test_direct_instantiation(self):
566 """
567 It should be possible to use the view without going through .as_view()
568 (#21564).
569 """
570 view = RedirectView()
571 response = view.dispatch(self.rf.head("/foo/"))
572 self.assertEqual(response.status_code, 410)
573
574 def test_gone_response_logged(self):
575 for path, escaped in [
576 ("/foo/", "/foo/"),
577 (r"/%1B[1;31mNOW IN RED!!!1B[0m/", r"/\x1b[1;31mNOW IN RED!!!1B[0m/"),
578 ]:
579 with self.subTest(path=path):
580 request = self.rf.get(path)
581 with self.assertLogs("django.request", "WARNING") as handler:
582 RedirectView().dispatch(request)
583
584 self.assertLogRecord(
585 handler, f"Gone: {escaped}", logging.WARNING, 410, request
586 )
587
588
589 class GetContextDataTest(SimpleTestCase):
590 def test_get_context_data_super(self):
591 test_view = views.CustomContextView()
592 context = test_view.get_context_data(kwarg_test="kwarg_value")
593
594 # the test_name key is inserted by the test classes parent
595 self.assertIn("test_name", context)
596 self.assertEqual(context["kwarg_test"], "kwarg_value")
597 self.assertEqual(context["custom_key"], "custom_value")
598
599 # test that kwarg overrides values assigned higher up
600 context = test_view.get_context_data(test_name="test_value")
601 self.assertEqual(context["test_name"], "test_value")
602
603 def test_object_at_custom_name_in_context_data(self):
604 # Checks 'pony' key presence in dict returned by get_context_date
605 test_view = views.CustomSingleObjectView()
606 test_view.context_object_name = "pony"
607 context = test_view.get_context_data()
608 self.assertEqual(context["pony"], test_view.object)
609
610 def test_object_in_get_context_data(self):
611 # Checks 'object' key presence in dict returned by get_context_date #20234
612 test_view = views.CustomSingleObjectView()
613 context = test_view.get_context_data()
614 self.assertEqual(context["object"], test_view.object)
615
616
617 class UseMultipleObjectMixinTest(SimpleTestCase):
618 rf = RequestFactory()
619
620 def test_use_queryset_from_view(self):
621 test_view = views.CustomMultipleObjectMixinView()
622 test_view.get(self.rf.get("/"))
623 # Don't pass queryset as argument
624 context = test_view.get_context_data()
625 self.assertEqual(context["object_list"], test_view.queryset)
626
627 def test_overwrite_queryset(self):
628 test_view = views.CustomMultipleObjectMixinView()
629 test_view.get(self.rf.get("/"))
630 queryset = [{"name": "Lennon"}, {"name": "Ono"}]
631 self.assertNotEqual(test_view.queryset, queryset)
632 # Overwrite the view's queryset with queryset from kwarg
633 context = test_view.get_context_data(object_list=queryset)
634 self.assertEqual(context["object_list"], queryset)
635
636
637 class SingleObjectTemplateResponseMixinTest(SimpleTestCase):
638 def test_template_mixin_without_template(self):
639 """
640 We want to makes sure that if you use a template mixin, but forget the
641 template, it still tells you it's ImproperlyConfigured instead of
642 TemplateDoesNotExist.
643 """
644 view = views.TemplateResponseWithoutTemplate()
645 msg = (
646 "SingleObjectTemplateResponseMixin requires a definition "
647 "of 'template_name', 'template_name_field', or 'model'; "
648 "or an implementation of 'get_template_names()'."
649 )
650 with self.assertRaisesMessage(ImproperlyConfigured, msg):
651 view.get_template_names()