mirror of https://github.com/django/django.git
435 lines
13 KiB
Python
435 lines
13 KiB
Python
import json
|
|
from urllib.parse import urlencode
|
|
from xml.dom.minidom import parseString
|
|
|
|
from django.contrib.auth.decorators import login_required, permission_required
|
|
from django.core import mail
|
|
from django.core.exceptions import ValidationError
|
|
from django.forms import fields
|
|
from django.forms.forms import Form
|
|
from django.http import (
|
|
HttpResponse,
|
|
HttpResponseBadRequest,
|
|
HttpResponseNotAllowed,
|
|
HttpResponseNotFound,
|
|
HttpResponseRedirect,
|
|
)
|
|
from django.shortcuts import render
|
|
from django.template import Context, Template
|
|
from django.test import Client
|
|
from django.utils.decorators import method_decorator
|
|
from django.views.generic import TemplateView
|
|
|
|
|
|
def get_view(request):
|
|
"A simple view that expects a GET request, and returns a rendered template"
|
|
t = Template("This is a test. {{ var }} is the value.", name="GET Template")
|
|
c = Context({"var": request.GET.get("var", 42)})
|
|
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
async def async_get_view(request):
|
|
return HttpResponse(b"GET content.")
|
|
|
|
|
|
def trace_view(request):
|
|
"""
|
|
A simple view that expects a TRACE request and echoes its status line.
|
|
|
|
TRACE requests should not have an entity; the view will return a 400 status
|
|
response if it is present.
|
|
"""
|
|
if request.method.upper() != "TRACE":
|
|
return HttpResponseNotAllowed("TRACE")
|
|
elif request.body:
|
|
return HttpResponseBadRequest("TRACE requests MUST NOT include an entity")
|
|
else:
|
|
protocol = request.META["SERVER_PROTOCOL"]
|
|
t = Template(
|
|
"{{ method }} {{ uri }} {{ version }}",
|
|
name="TRACE Template",
|
|
)
|
|
c = Context(
|
|
{
|
|
"method": request.method,
|
|
"uri": request.path,
|
|
"version": protocol,
|
|
}
|
|
)
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
def put_view(request):
|
|
if request.method == "PUT":
|
|
t = Template("Data received: {{ data }} is the body.", name="PUT Template")
|
|
c = Context(
|
|
{
|
|
"Content-Length": request.META["CONTENT_LENGTH"],
|
|
"data": request.body.decode(),
|
|
}
|
|
)
|
|
else:
|
|
t = Template("Viewing GET page.", name="Empty GET Template")
|
|
c = Context()
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
def post_view(request):
|
|
"""A view that expects a POST, and returns a different template depending
|
|
on whether any POST data is available
|
|
"""
|
|
if request.method == "POST":
|
|
if request.POST:
|
|
t = Template(
|
|
"Data received: {{ data }} is the value.", name="POST Template"
|
|
)
|
|
c = Context({"data": request.POST["value"]})
|
|
else:
|
|
t = Template("Viewing POST page.", name="Empty POST Template")
|
|
c = Context()
|
|
else:
|
|
t = Template("Viewing GET page.", name="Empty GET Template")
|
|
# Used by test_body_read_on_get_data.
|
|
request.read(200)
|
|
c = Context()
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
def post_then_get_view(request):
|
|
"""
|
|
A view that expects a POST request, returns a redirect response
|
|
to itself providing only a ?success=true querystring,
|
|
the value of this querystring is then rendered upon GET.
|
|
"""
|
|
if request.method == "POST":
|
|
return HttpResponseRedirect("?success=true")
|
|
|
|
t = Template("The value of success is {{ value }}.", name="GET Template")
|
|
c = Context({"value": request.GET.get("success", "false")})
|
|
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
def json_view(request):
|
|
"""
|
|
A view that expects a request with the header 'application/json' and JSON
|
|
data, which is deserialized and included in the context.
|
|
"""
|
|
if request.META.get("CONTENT_TYPE") != "application/json":
|
|
return HttpResponse()
|
|
|
|
t = Template("Viewing {} page. With data {{ data }}.".format(request.method))
|
|
data = json.loads(request.body.decode("utf-8"))
|
|
c = Context({"data": data})
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
def view_with_header(request):
|
|
"A view that has a custom header"
|
|
response = HttpResponse()
|
|
response.headers["X-DJANGO-TEST"] = "Slartibartfast"
|
|
return response
|
|
|
|
|
|
def raw_post_view(request):
|
|
"""A view which expects raw XML to be posted and returns content extracted
|
|
from the XML"""
|
|
if request.method == "POST":
|
|
root = parseString(request.body)
|
|
first_book = root.firstChild.firstChild
|
|
title, author = [n.firstChild.nodeValue for n in first_book.childNodes]
|
|
t = Template("{{ title }} - {{ author }}", name="Book template")
|
|
c = Context({"title": title, "author": author})
|
|
else:
|
|
t = Template("GET request.", name="Book GET template")
|
|
c = Context()
|
|
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
def redirect_view(request):
|
|
"A view that redirects all requests to the GET view"
|
|
if request.GET:
|
|
query = "?" + urlencode(request.GET, True)
|
|
else:
|
|
query = ""
|
|
return HttpResponseRedirect("/get_view/" + query)
|
|
|
|
|
|
def method_saving_307_redirect_query_string_view(request):
|
|
return HttpResponseRedirect("/post_view/?hello=world", status=307)
|
|
|
|
|
|
def method_saving_308_redirect_query_string_view(request):
|
|
return HttpResponseRedirect("/post_view/?hello=world", status=308)
|
|
|
|
|
|
def _post_view_redirect(request, status_code):
|
|
"""Redirect to /post_view/ using the status code."""
|
|
redirect_to = request.GET.get("to", "/post_view/")
|
|
return HttpResponseRedirect(redirect_to, status=status_code)
|
|
|
|
|
|
def method_saving_307_redirect_view(request):
|
|
return _post_view_redirect(request, 307)
|
|
|
|
|
|
def method_saving_308_redirect_view(request):
|
|
return _post_view_redirect(request, 308)
|
|
|
|
|
|
def redirect_to_different_hostname(request):
|
|
return HttpResponseRedirect("https://hostname2/get_host_view/")
|
|
|
|
|
|
def get_host_view(request):
|
|
return HttpResponse(request.get_host())
|
|
|
|
|
|
def view_with_secure(request):
|
|
"A view that indicates if the request was secure"
|
|
response = HttpResponse()
|
|
response.test_was_secure_request = request.is_secure()
|
|
response.test_server_port = request.META.get("SERVER_PORT", 80)
|
|
return response
|
|
|
|
|
|
def double_redirect_view(request):
|
|
"A view that redirects all requests to a redirection view"
|
|
return HttpResponseRedirect("/permanent_redirect_view/")
|
|
|
|
|
|
def bad_view(request):
|
|
"A view that returns a 404 with some error content"
|
|
return HttpResponseNotFound("Not found!. This page contains some MAGIC content")
|
|
|
|
|
|
TestChoices = (
|
|
("a", "First Choice"),
|
|
("b", "Second Choice"),
|
|
("c", "Third Choice"),
|
|
("d", "Fourth Choice"),
|
|
("e", "Fifth Choice"),
|
|
)
|
|
|
|
|
|
class TestForm(Form):
|
|
text = fields.CharField()
|
|
email = fields.EmailField()
|
|
value = fields.IntegerField()
|
|
single = fields.ChoiceField(choices=TestChoices)
|
|
multi = fields.MultipleChoiceField(choices=TestChoices)
|
|
|
|
def clean(self):
|
|
cleaned_data = self.cleaned_data
|
|
if cleaned_data.get("text") == "Raise non-field error":
|
|
raise ValidationError("Non-field error.")
|
|
return cleaned_data
|
|
|
|
|
|
def form_view(request):
|
|
"A view that tests a simple form"
|
|
if request.method == "POST":
|
|
form = TestForm(request.POST)
|
|
if form.is_valid():
|
|
t = Template("Valid POST data.", name="Valid POST Template")
|
|
c = Context()
|
|
else:
|
|
t = Template(
|
|
"Invalid POST data. {{ form.errors }}", name="Invalid POST Template"
|
|
)
|
|
c = Context({"form": form})
|
|
else:
|
|
form = TestForm(request.GET)
|
|
t = Template("Viewing base form. {{ form }}.", name="Form GET Template")
|
|
c = Context({"form": form})
|
|
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
def form_view_with_template(request):
|
|
"A view that tests a simple form"
|
|
if request.method == "POST":
|
|
form = TestForm(request.POST)
|
|
if form.is_valid():
|
|
message = "POST data OK"
|
|
else:
|
|
message = "POST data has errors"
|
|
else:
|
|
form = TestForm()
|
|
message = "GET form page"
|
|
return render(
|
|
request,
|
|
"form_view.html",
|
|
{
|
|
"form": form,
|
|
"message": message,
|
|
},
|
|
)
|
|
|
|
|
|
@login_required
|
|
def login_protected_view(request):
|
|
"A simple view that is login protected."
|
|
t = Template(
|
|
"This is a login protected test. Username is {{ user.username }}.",
|
|
name="Login Template",
|
|
)
|
|
c = Context({"user": request.user})
|
|
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
@login_required(redirect_field_name="redirect_to")
|
|
def login_protected_view_changed_redirect(request):
|
|
"A simple view that is login protected with a custom redirect field set"
|
|
t = Template(
|
|
"This is a login protected test. Username is {{ user.username }}.",
|
|
name="Login Template",
|
|
)
|
|
c = Context({"user": request.user})
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
def _permission_protected_view(request):
|
|
"A simple view that is permission protected."
|
|
t = Template(
|
|
"This is a permission protected test. "
|
|
"Username is {{ user.username }}. "
|
|
"Permissions are {{ user.get_all_permissions }}.",
|
|
name="Permissions Template",
|
|
)
|
|
c = Context({"user": request.user})
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
permission_protected_view = permission_required("permission_not_granted")(
|
|
_permission_protected_view
|
|
)
|
|
permission_protected_view_exception = permission_required(
|
|
"permission_not_granted", raise_exception=True
|
|
)(_permission_protected_view)
|
|
|
|
|
|
class _ViewManager:
|
|
@method_decorator(login_required)
|
|
def login_protected_view(self, request):
|
|
t = Template(
|
|
"This is a login protected test using a method. "
|
|
"Username is {{ user.username }}.",
|
|
name="Login Method Template",
|
|
)
|
|
c = Context({"user": request.user})
|
|
return HttpResponse(t.render(c))
|
|
|
|
@method_decorator(permission_required("permission_not_granted"))
|
|
def permission_protected_view(self, request):
|
|
t = Template(
|
|
"This is a permission protected test using a method. "
|
|
"Username is {{ user.username }}. "
|
|
"Permissions are {{ user.get_all_permissions }}.",
|
|
name="Permissions Template",
|
|
)
|
|
c = Context({"user": request.user})
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
_view_manager = _ViewManager()
|
|
login_protected_method_view = _view_manager.login_protected_view
|
|
permission_protected_method_view = _view_manager.permission_protected_view
|
|
|
|
|
|
def session_view(request):
|
|
"A view that modifies the session"
|
|
request.session["tobacconist"] = "hovercraft"
|
|
|
|
t = Template(
|
|
"This is a view that modifies the session.",
|
|
name="Session Modifying View Template",
|
|
)
|
|
c = Context()
|
|
return HttpResponse(t.render(c))
|
|
|
|
|
|
def broken_view(request):
|
|
"""A view which just raises an exception, simulating a broken view."""
|
|
raise KeyError("Oops! Looks like you wrote some bad code.")
|
|
|
|
|
|
def mail_sending_view(request):
|
|
mail.EmailMessage(
|
|
"Test message",
|
|
"This is a test email",
|
|
"from@example.com",
|
|
["first@example.com", "second@example.com"],
|
|
).send()
|
|
return HttpResponse("Mail sent")
|
|
|
|
|
|
def mass_mail_sending_view(request):
|
|
m1 = mail.EmailMessage(
|
|
"First Test message",
|
|
"This is the first test email",
|
|
"from@example.com",
|
|
["first@example.com", "second@example.com"],
|
|
)
|
|
m2 = mail.EmailMessage(
|
|
"Second Test message",
|
|
"This is the second test email",
|
|
"from@example.com",
|
|
["second@example.com", "third@example.com"],
|
|
)
|
|
|
|
c = mail.get_connection()
|
|
c.send_messages([m1, m2])
|
|
|
|
return HttpResponse("Mail sent")
|
|
|
|
|
|
def nesting_exception_view(request):
|
|
"""
|
|
A view that uses a nested client to call another view and then raises an
|
|
exception.
|
|
"""
|
|
client = Client()
|
|
client.get("/get_view/")
|
|
raise Exception("exception message")
|
|
|
|
|
|
def django_project_redirect(request):
|
|
return HttpResponseRedirect("https://www.djangoproject.com/")
|
|
|
|
|
|
def no_trailing_slash_external_redirect(request):
|
|
"""
|
|
RFC 3986 Section 6.2.3: Empty path should be normalized to "/".
|
|
|
|
Use https://testserver, rather than an external domain, in order to allow
|
|
use of follow=True, triggering Client._handle_redirects().
|
|
"""
|
|
return HttpResponseRedirect("https://testserver")
|
|
|
|
|
|
def index_view(request):
|
|
"""Target for no_trailing_slash_external_redirect with follow=True."""
|
|
return HttpResponse("Hello world")
|
|
|
|
|
|
def upload_view(request):
|
|
"""Prints keys of request.FILES to the response."""
|
|
return HttpResponse(", ".join(request.FILES))
|
|
|
|
|
|
class TwoArgException(Exception):
|
|
def __init__(self, one, two):
|
|
pass
|
|
|
|
|
|
def two_arg_exception(request):
|
|
raise TwoArgException("one", "two")
|
|
|
|
|
|
class CBView(TemplateView):
|
|
template_name = "base.html"
|