Debian Codegraph @

tests/test_client/views.py

raw
1 import json
2 from urllib.parse import urlencode
3 from xml.dom.minidom import parseString
4
5 from django.contrib.auth.decorators import login_required, permission_required
6 from django.core import mail
7 from django.core.exceptions import ValidationError
8 from django.forms import fields
9 from django.forms.forms import Form
10 from django.http import (
11 HttpResponse,
12 HttpResponseBadRequest,
13 HttpResponseNotAllowed,
14 HttpResponseNotFound,
15 HttpResponseRedirect,
16 )
17 from django.shortcuts import render
18 from django.template import Context, Template
19 from django.test import Client
20 from django.utils.decorators import method_decorator
21 from django.views.generic import TemplateView
22
23
24 def get_view(request):
25 "A simple view that expects a GET request, and returns a rendered template"
26 t = Template("This is a test. {{ var }} is the value.", name="GET Template")
27 c = Context({"var": request.GET.get("var", 42)})
28
29 return HttpResponse(t.render(c))
30
31
32 async def async_get_view(request):
33 return HttpResponse(b"GET content.")
34
35
36 def trace_view(request):
37 """
38 A simple view that expects a TRACE request and echoes its status line.
39
40 TRACE requests should not have an entity; the view will return a 400 status
41 response if it is present.
42 """
43 if request.method.upper() != "TRACE":
44 return HttpResponseNotAllowed("TRACE")
45 elif request.body:
46 return HttpResponseBadRequest("TRACE requests MUST NOT include an entity")
47 else:
48 protocol = request.META["SERVER_PROTOCOL"]
49 t = Template(
50 "{{ method }} {{ uri }} {{ version }}",
51 name="TRACE Template",
52 )
53 c = Context(
54 {
55 "method": request.method,
56 "uri": request.path,
57 "version": protocol,
58 }
59 )
60 return HttpResponse(t.render(c))
61
62
63 def put_view(request):
64 if request.method == "PUT":
65 t = Template("Data received: {{ data }} is the body.", name="PUT Template")
66 c = Context(
67 {
68 "Content-Length": request.META["CONTENT_LENGTH"],
69 "data": request.body.decode(),
70 }
71 )
72 else:
73 t = Template("Viewing GET page.", name="Empty GET Template")
74 c = Context()
75 return HttpResponse(t.render(c))
76
77
78 def post_view(request):
79 """A view that expects a POST, and returns a different template depending
80 on whether any POST data is available
81 """
82 if request.method == "POST":
83 if request.POST:
84 t = Template(
85 "Data received: {{ data }} is the value.", name="POST Template"
86 )
87 c = Context({"data": request.POST["value"]})
88 else:
89 t = Template("Viewing POST page.", name="Empty POST Template")
90 c = Context()
91 else:
92 t = Template("Viewing GET page.", name="Empty GET Template")
93 # Used by test_body_read_on_get_data.
94 request.read(200)
95 c = Context()
96 return HttpResponse(t.render(c))
97
98
99 def post_then_get_view(request):
100 """
101 A view that expects a POST request, returns a redirect response
102 to itself providing only a ?success=true querystring,
103 the value of this querystring is then rendered upon GET.
104 """
105 if request.method == "POST":
106 return HttpResponseRedirect("?success=true")
107
108 t = Template("The value of success is {{ value }}.", name="GET Template")
109 c = Context({"value": request.GET.get("success", "false")})
110
111 return HttpResponse(t.render(c))
112
113
114 def json_view(request):
115 """
116 A view that expects a request with the header 'application/json' and JSON
117 data, which is deserialized and included in the context.
118 """
119 if request.META.get("CONTENT_TYPE") != "application/json":
120 return HttpResponse()
121
122 t = Template("Viewing {} page. With data {{ data }}.".format(request.method))
123 data = json.loads(request.body.decode("utf-8"))
124 c = Context({"data": data})
125 return HttpResponse(t.render(c))
126
127
128 def view_with_header(request):
129 "A view that has a custom header"
130 response = HttpResponse()
131 response.headers["X-DJANGO-TEST"] = "Slartibartfast"
132 return response
133
134
135 def raw_post_view(request):
136 """A view which expects raw XML to be posted and returns content extracted
137 from the XML"""
138 if request.method == "POST":
139 root = parseString(request.body)
140 first_book = root.firstChild.firstChild
141 title, author = [n.firstChild.nodeValue for n in first_book.childNodes]
142 t = Template("{{ title }} - {{ author }}", name="Book template")
143 c = Context({"title": title, "author": author})
144 else:
145 t = Template("GET request.", name="Book GET template")
146 c = Context()
147
148 return HttpResponse(t.render(c))
149
150
151 def redirect_view(request):
152 "A view that redirects all requests to the GET view"
153 if request.GET:
154 query = "?" + urlencode(request.GET, True)
155 else:
156 query = ""
157 return HttpResponseRedirect("/get_view/" + query)
158
159
160 def method_saving_307_redirect_query_string_view(request):
161 return HttpResponseRedirect("/post_view/?hello=world", status=307)
162
163
164 def method_saving_308_redirect_query_string_view(request):
165 return HttpResponseRedirect("/post_view/?hello=world", status=308)
166
167
168 def _post_view_redirect(request, status_code):
169 """Redirect to /post_view/ using the status code."""
170 redirect_to = request.GET.get("to", "/post_view/")
171 return HttpResponseRedirect(redirect_to, status=status_code)
172
173
174 def method_saving_307_redirect_view(request):
175 return _post_view_redirect(request, 307)
176
177
178 def method_saving_308_redirect_view(request):
179 return _post_view_redirect(request, 308)
180
181
182 def redirect_to_different_hostname(request):
183 return HttpResponseRedirect("https://hostname2/get_host_view/")
184
185
186 def get_host_view(request):
187 return HttpResponse(request.get_host())
188
189
190 def view_with_secure(request):
191 "A view that indicates if the request was secure"
192 response = HttpResponse()
193 response.test_was_secure_request = request.is_secure()
194 response.test_server_port = request.META.get("SERVER_PORT", 80)
195 return response
196
197
198 def double_redirect_view(request):
199 "A view that redirects all requests to a redirection view"
200 return HttpResponseRedirect("/permanent_redirect_view/")
201
202
203 def bad_view(request):
204 "A view that returns a 404 with some error content"
205 return HttpResponseNotFound("Not found!. This page contains some MAGIC content")
206
207
208 TestChoices = (
209 ("a", "First Choice"),
210 ("b", "Second Choice"),
211 ("c", "Third Choice"),
212 ("d", "Fourth Choice"),
213 ("e", "Fifth Choice"),
214 )
215
216
217 class TestForm(Form):
218 text = fields.CharField()
219 email = fields.EmailField()
220 value = fields.IntegerField()
221 single = fields.ChoiceField(choices=TestChoices)
222 multi = fields.MultipleChoiceField(choices=TestChoices)
223
224 def clean(self):
225 cleaned_data = self.cleaned_data
226 if cleaned_data.get("text") == "Raise non-field error":
227 raise ValidationError("Non-field error.")
228 return cleaned_data
229
230
231 def form_view(request):
232 "A view that tests a simple form"
233 if request.method == "POST":
234 form = TestForm(request.POST)
235 if form.is_valid():
236 t = Template("Valid POST data.", name="Valid POST Template")
237 c = Context()
238 else:
239 t = Template(
240 "Invalid POST data. {{ form.errors }}", name="Invalid POST Template"
241 )
242 c = Context({"form": form})
243 else:
244 form = TestForm(request.GET)
245 t = Template("Viewing base form. {{ form }}.", name="Form GET Template")
246 c = Context({"form": form})
247
248 return HttpResponse(t.render(c))
249
250
251 def form_view_with_template(request):
252 "A view that tests a simple form"
253 if request.method == "POST":
254 form = TestForm(request.POST)
255 if form.is_valid():
256 message = "POST data OK"
257 else:
258 message = "POST data has errors"
259 else:
260 form = TestForm()
261 message = "GET form page"
262 return render(
263 request,
264 "form_view.html",
265 {
266 "form": form,
267 "message": message,
268 },
269 )
270
271
272 @login_required
273 def login_protected_view(request):
274 "A simple view that is login protected."
275 t = Template(
276 "This is a login protected test. Username is {{ user.username }}.",
277 name="Login Template",
278 )
279 c = Context({"user": request.user})
280
281 return HttpResponse(t.render(c))
282
283
284 @login_required(redirect_field_name="redirect_to")
285 def login_protected_view_changed_redirect(request):
286 "A simple view that is login protected with a custom redirect field set"
287 t = Template(
288 "This is a login protected test. Username is {{ user.username }}.",
289 name="Login Template",
290 )
291 c = Context({"user": request.user})
292 return HttpResponse(t.render(c))
293
294
295 def _permission_protected_view(request):
296 "A simple view that is permission protected."
297 t = Template(
298 "This is a permission protected test. "
299 "Username is {{ user.username }}. "
300 "Permissions are {{ user.get_all_permissions }}.",
301 name="Permissions Template",
302 )
303 c = Context({"user": request.user})
304 return HttpResponse(t.render(c))
305
306
307 permission_protected_view = permission_required("permission_not_granted")(
308 _permission_protected_view
309 )
310 permission_protected_view_exception = permission_required(
311 "permission_not_granted", raise_exception=True
312 )(_permission_protected_view)
313
314
315 class _ViewManager:
316 @method_decorator(login_required)
317 def login_protected_view(self, request):
318 t = Template(
319 "This is a login protected test using a method. "
320 "Username is {{ user.username }}.",
321 name="Login Method Template",
322 )
323 c = Context({"user": request.user})
324 return HttpResponse(t.render(c))
325
326 @method_decorator(permission_required("permission_not_granted"))
327 def permission_protected_view(self, request):
328 t = Template(
329 "This is a permission protected test using a method. "
330 "Username is {{ user.username }}. "
331 "Permissions are {{ user.get_all_permissions }}.",
332 name="Permissions Template",
333 )
334 c = Context({"user": request.user})
335 return HttpResponse(t.render(c))
336
337
338 _view_manager = _ViewManager()
339 login_protected_method_view = _view_manager.login_protected_view
340 permission_protected_method_view = _view_manager.permission_protected_view
341
342
343 def session_view(request):
344 "A view that modifies the session"
345 request.session["tobacconist"] = "hovercraft"
346
347 t = Template(
348 "This is a view that modifies the session.",
349 name="Session Modifying View Template",
350 )
351 c = Context()
352 return HttpResponse(t.render(c))
353
354
355 def broken_view(request):
356 """A view which just raises an exception, simulating a broken view."""
357 raise KeyError("Oops! Looks like you wrote some bad code.")
358
359
360 def mail_sending_view(request):
361 mail.EmailMessage(
362 "Test message",
363 "This is a test email",
364 "[email protected]",
365 ["[email protected]", "[email protected]"],
366 ).send()
367 return HttpResponse("Mail sent")
368
369
370 def mass_mail_sending_view(request):
371 m1 = mail.EmailMessage(
372 "First Test message",
373 "This is the first test email",
374 "[email protected]",
375 ["[email protected]", "[email protected]"],
376 )
377 m2 = mail.EmailMessage(
378 "Second Test message",
379 "This is the second test email",
380 "[email protected]",
381 ["[email protected]", "[email protected]"],
382 )
383
384 c = mail.get_connection()
385 c.send_messages([m1, m2])
386
387 return HttpResponse("Mail sent")
388
389
390 def nesting_exception_view(request):
391 """
392 A view that uses a nested client to call another view and then raises an
393 exception.
394 """
395 client = Client()
396 client.get("/get_view/")
397 raise Exception("exception message")
398
399
400 def django_project_redirect(request):
401 return HttpResponseRedirect("https://www.djangoproject.com/")
402
403
404 def no_trailing_slash_external_redirect(request):
405 """
406 RFC 3986 Section 6.2.3: Empty path should be normalized to "/".
407
408 Use https://testserver, rather than an external domain, in order to allow
409 use of follow=True, triggering Client._handle_redirects().
410 """
411 return HttpResponseRedirect("https://testserver")
412
413
414 def index_view(request):
415 """Target for no_trailing_slash_external_redirect with follow=True."""
416 return HttpResponse("Hello world")
417
418
419 def upload_view(request):
420 """Prints keys of request.FILES to the response."""
421 return HttpResponse(", ".join(request.FILES))
422
423
424 class TwoArgException(Exception):
425 def __init__(self, one, two):
426 pass
427
428
429 def two_arg_exception(request):
430 raise TwoArgException("one", "two")
431
432
433 class CBView(TemplateView):
434 template_name = "base.html"