1344 lines
53 KiB
Python
1344 lines
53 KiB
Python
"""
|
|
Regression tests for the Test Client, especially the customized assertions.
|
|
"""
|
|
import itertools
|
|
import os
|
|
|
|
from django.contrib.auth.models import User
|
|
from django.contrib.auth.signals import user_logged_in, user_logged_out
|
|
from django.http import HttpResponse
|
|
from django.template import Context, RequestContext, TemplateSyntaxError, engines
|
|
from django.template.response import SimpleTemplateResponse
|
|
from django.test import (
|
|
Client,
|
|
SimpleTestCase,
|
|
TestCase,
|
|
modify_settings,
|
|
override_settings,
|
|
)
|
|
from django.test.client import RedirectCycleError, RequestFactory, encode_file
|
|
from django.test.utils import ContextList
|
|
from django.urls import NoReverseMatch, reverse
|
|
from django.utils.translation import gettext_lazy
|
|
|
|
from .models import CustomUser
|
|
from .views import CustomTestException
|
|
|
|
|
|
class TestDataMixin:
|
|
@classmethod
|
|
def setUpTestData(cls):
|
|
cls.u1 = User.objects.create_user(username="testclient", password="password")
|
|
cls.staff = User.objects.create_user(
|
|
username="staff", password="password", is_staff=True
|
|
)
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class AssertContainsTests(SimpleTestCase):
|
|
def test_contains(self):
|
|
"Responses can be inspected for content, including counting repeated substrings"
|
|
response = self.client.get("/no_template_view/")
|
|
|
|
self.assertNotContains(response, "never")
|
|
self.assertContains(response, "never", 0)
|
|
self.assertContains(response, "once")
|
|
self.assertContains(response, "once", 1)
|
|
self.assertContains(response, "twice")
|
|
self.assertContains(response, "twice", 2)
|
|
|
|
try:
|
|
self.assertContains(response, "text", status_code=999)
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Couldn't retrieve content: Response code was 200 (expected 999)",
|
|
str(e),
|
|
)
|
|
try:
|
|
self.assertContains(response, "text", status_code=999, msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Couldn't retrieve content: Response code was 200 (expected 999)",
|
|
str(e),
|
|
)
|
|
|
|
try:
|
|
self.assertNotContains(response, "text", status_code=999)
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Couldn't retrieve content: Response code was 200 (expected 999)",
|
|
str(e),
|
|
)
|
|
try:
|
|
self.assertNotContains(response, "text", status_code=999, msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Couldn't retrieve content: Response code was 200 (expected 999)",
|
|
str(e),
|
|
)
|
|
|
|
try:
|
|
self.assertNotContains(response, "once")
|
|
except AssertionError as e:
|
|
self.assertIn("Response should not contain 'once'", str(e))
|
|
try:
|
|
self.assertNotContains(response, "once", msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn("abc: Response should not contain 'once'", str(e))
|
|
|
|
try:
|
|
self.assertContains(response, "never", 1)
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Found 0 instances of 'never' in response (expected 1)", str(e)
|
|
)
|
|
try:
|
|
self.assertContains(response, "never", 1, msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Found 0 instances of 'never' in response (expected 1)", str(e)
|
|
)
|
|
|
|
try:
|
|
self.assertContains(response, "once", 0)
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Found 1 instances of 'once' in response (expected 0)", str(e)
|
|
)
|
|
try:
|
|
self.assertContains(response, "once", 0, msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Found 1 instances of 'once' in response (expected 0)", str(e)
|
|
)
|
|
|
|
try:
|
|
self.assertContains(response, "once", 2)
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Found 1 instances of 'once' in response (expected 2)", str(e)
|
|
)
|
|
try:
|
|
self.assertContains(response, "once", 2, msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Found 1 instances of 'once' in response (expected 2)", str(e)
|
|
)
|
|
|
|
try:
|
|
self.assertContains(response, "twice", 1)
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Found 2 instances of 'twice' in response (expected 1)", str(e)
|
|
)
|
|
try:
|
|
self.assertContains(response, "twice", 1, msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Found 2 instances of 'twice' in response (expected 1)", str(e)
|
|
)
|
|
|
|
try:
|
|
self.assertContains(response, "thrice")
|
|
except AssertionError as e:
|
|
self.assertIn("Couldn't find 'thrice' in response", str(e))
|
|
try:
|
|
self.assertContains(response, "thrice", msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn("abc: Couldn't find 'thrice' in response", str(e))
|
|
|
|
try:
|
|
self.assertContains(response, "thrice", 3)
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Found 0 instances of 'thrice' in response (expected 3)", str(e)
|
|
)
|
|
try:
|
|
self.assertContains(response, "thrice", 3, msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Found 0 instances of 'thrice' in response (expected 3)", str(e)
|
|
)
|
|
|
|
def test_unicode_contains(self):
|
|
"Unicode characters can be found in template context"
|
|
# Regression test for #10183
|
|
r = self.client.get("/check_unicode/")
|
|
self.assertContains(r, "さかき")
|
|
self.assertContains(r, b"\xe5\xb3\xa0".decode())
|
|
|
|
def test_unicode_not_contains(self):
|
|
"Unicode characters can be searched for, and not found in template context"
|
|
# Regression test for #10183
|
|
r = self.client.get("/check_unicode/")
|
|
self.assertNotContains(r, "はたけ")
|
|
self.assertNotContains(r, b"\xe3\x81\xaf\xe3\x81\x9f\xe3\x81\x91".decode())
|
|
|
|
def test_binary_contains(self):
|
|
r = self.client.get("/check_binary/")
|
|
self.assertContains(r, b"%PDF-1.4\r\n%\x93\x8c\x8b\x9e")
|
|
with self.assertRaises(AssertionError):
|
|
self.assertContains(r, b"%PDF-1.4\r\n%\x93\x8c\x8b\x9e", count=2)
|
|
|
|
def test_binary_not_contains(self):
|
|
r = self.client.get("/check_binary/")
|
|
self.assertNotContains(r, b"%ODF-1.4\r\n%\x93\x8c\x8b\x9e")
|
|
with self.assertRaises(AssertionError):
|
|
self.assertNotContains(r, b"%PDF-1.4\r\n%\x93\x8c\x8b\x9e")
|
|
|
|
def test_nontext_contains(self):
|
|
r = self.client.get("/no_template_view/")
|
|
self.assertContains(r, gettext_lazy("once"))
|
|
|
|
def test_nontext_not_contains(self):
|
|
r = self.client.get("/no_template_view/")
|
|
self.assertNotContains(r, gettext_lazy("never"))
|
|
|
|
def test_assert_contains_renders_template_response(self):
|
|
"""
|
|
An unrendered SimpleTemplateResponse may be used in assertContains().
|
|
"""
|
|
template = engines["django"].from_string("Hello")
|
|
response = SimpleTemplateResponse(template)
|
|
self.assertContains(response, "Hello")
|
|
|
|
def test_assert_contains_using_non_template_response(self):
|
|
"""auto-rendering does not affect responses that aren't
|
|
instances (or subclasses) of SimpleTemplateResponse.
|
|
Refs #15826.
|
|
"""
|
|
response = HttpResponse("Hello")
|
|
self.assertContains(response, "Hello")
|
|
|
|
def test_assert_not_contains_renders_template_response(self):
|
|
"""
|
|
An unrendered SimpleTemplateResponse may be used in assertNotContains().
|
|
"""
|
|
template = engines["django"].from_string("Hello")
|
|
response = SimpleTemplateResponse(template)
|
|
self.assertNotContains(response, "Bye")
|
|
|
|
def test_assert_not_contains_using_non_template_response(self):
|
|
"""
|
|
auto-rendering does not affect responses that aren't instances (or
|
|
subclasses) of SimpleTemplateResponse.
|
|
"""
|
|
response = HttpResponse("Hello")
|
|
self.assertNotContains(response, "Bye")
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class AssertTemplateUsedTests(TestDataMixin, TestCase):
|
|
def test_no_context(self):
|
|
"Template usage assertions work then templates aren't in use"
|
|
response = self.client.get("/no_template_view/")
|
|
|
|
# The no template case doesn't mess with the template assertions
|
|
self.assertTemplateNotUsed(response, "GET Template")
|
|
|
|
try:
|
|
self.assertTemplateUsed(response, "GET Template")
|
|
except AssertionError as e:
|
|
self.assertIn("No templates used to render the response", str(e))
|
|
|
|
try:
|
|
self.assertTemplateUsed(response, "GET Template", msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn("abc: No templates used to render the response", str(e))
|
|
|
|
msg = "No templates used to render the response"
|
|
with self.assertRaisesMessage(AssertionError, msg):
|
|
self.assertTemplateUsed(response, "GET Template", count=2)
|
|
|
|
def test_single_context(self):
|
|
"Template assertions work when there is a single context"
|
|
response = self.client.get("/post_view/", {})
|
|
msg = (
|
|
": Template 'Empty GET Template' was used unexpectedly in "
|
|
"rendering the response"
|
|
)
|
|
with self.assertRaisesMessage(AssertionError, msg):
|
|
self.assertTemplateNotUsed(response, "Empty GET Template")
|
|
with self.assertRaisesMessage(AssertionError, "abc" + msg):
|
|
self.assertTemplateNotUsed(response, "Empty GET Template", msg_prefix="abc")
|
|
msg = (
|
|
": Template 'Empty POST Template' was not a template used to "
|
|
"render the response. Actual template(s) used: Empty GET Template"
|
|
)
|
|
with self.assertRaisesMessage(AssertionError, msg):
|
|
self.assertTemplateUsed(response, "Empty POST Template")
|
|
with self.assertRaisesMessage(AssertionError, "abc" + msg):
|
|
self.assertTemplateUsed(response, "Empty POST Template", msg_prefix="abc")
|
|
msg = (
|
|
": Template 'Empty GET Template' was expected to be rendered 2 "
|
|
"time(s) but was actually rendered 1 time(s)."
|
|
)
|
|
with self.assertRaisesMessage(AssertionError, msg):
|
|
self.assertTemplateUsed(response, "Empty GET Template", count=2)
|
|
with self.assertRaisesMessage(AssertionError, "abc" + msg):
|
|
self.assertTemplateUsed(
|
|
response, "Empty GET Template", msg_prefix="abc", count=2
|
|
)
|
|
|
|
def test_multiple_context(self):
|
|
"Template assertions work when there are multiple contexts"
|
|
post_data = {
|
|
"text": "Hello World",
|
|
"email": "foo@example.com",
|
|
"value": 37,
|
|
"single": "b",
|
|
"multi": ("b", "c", "e"),
|
|
}
|
|
response = self.client.post("/form_view_with_template/", post_data)
|
|
self.assertContains(response, "POST data OK")
|
|
msg = "Template '%s' was used unexpectedly in rendering the response"
|
|
with self.assertRaisesMessage(AssertionError, msg % "form_view.html"):
|
|
self.assertTemplateNotUsed(response, "form_view.html")
|
|
with self.assertRaisesMessage(AssertionError, msg % "base.html"):
|
|
self.assertTemplateNotUsed(response, "base.html")
|
|
msg = (
|
|
"Template 'Valid POST Template' was not a template used to render "
|
|
"the response. Actual template(s) used: form_view.html, base.html"
|
|
)
|
|
with self.assertRaisesMessage(AssertionError, msg):
|
|
self.assertTemplateUsed(response, "Valid POST Template")
|
|
msg = (
|
|
"Template 'base.html' was expected to be rendered 2 time(s) but "
|
|
"was actually rendered 1 time(s)."
|
|
)
|
|
with self.assertRaisesMessage(AssertionError, msg):
|
|
self.assertTemplateUsed(response, "base.html", count=2)
|
|
|
|
def test_template_rendered_multiple_times(self):
|
|
"""Template assertions work when a template is rendered multiple times."""
|
|
response = self.client.get("/render_template_multiple_times/")
|
|
|
|
self.assertTemplateUsed(response, "base.html", count=2)
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class AssertRedirectsTests(SimpleTestCase):
|
|
def test_redirect_page(self):
|
|
"An assertion is raised if the original page couldn't be retrieved as expected"
|
|
# This page will redirect with code 301, not 302
|
|
response = self.client.get("/permanent_redirect_view/")
|
|
try:
|
|
self.assertRedirects(response, "/get_view/")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Response didn't redirect as expected: Response code was 301 "
|
|
"(expected 302)",
|
|
str(e),
|
|
)
|
|
|
|
try:
|
|
self.assertRedirects(response, "/get_view/", msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Response didn't redirect as expected: Response code was 301 "
|
|
"(expected 302)",
|
|
str(e),
|
|
)
|
|
|
|
def test_lost_query(self):
|
|
"""
|
|
An assertion is raised if the redirect location doesn't preserve GET
|
|
parameters.
|
|
"""
|
|
response = self.client.get("/redirect_view/", {"var": "value"})
|
|
try:
|
|
self.assertRedirects(response, "/get_view/")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Response redirected to '/get_view/?var=value', expected '/get_view/'",
|
|
str(e),
|
|
)
|
|
|
|
try:
|
|
self.assertRedirects(response, "/get_view/", msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Response redirected to '/get_view/?var=value', expected "
|
|
"'/get_view/'",
|
|
str(e),
|
|
)
|
|
|
|
def test_incorrect_target(self):
|
|
"An assertion is raised if the response redirects to another target"
|
|
response = self.client.get("/permanent_redirect_view/")
|
|
try:
|
|
# Should redirect to get_view
|
|
self.assertRedirects(response, "/some_view/")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Response didn't redirect as expected: Response code was 301 "
|
|
"(expected 302)",
|
|
str(e),
|
|
)
|
|
|
|
def test_target_page(self):
|
|
"""
|
|
An assertion is raised if the response redirect target cannot be
|
|
retrieved as expected.
|
|
"""
|
|
response = self.client.get("/double_redirect_view/")
|
|
try:
|
|
# The redirect target responds with a 301 code, not 200
|
|
self.assertRedirects(response, "http://testserver/permanent_redirect_view/")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Couldn't retrieve redirection page '/permanent_redirect_view/': "
|
|
"response code was 301 (expected 200)",
|
|
str(e),
|
|
)
|
|
|
|
try:
|
|
# The redirect target responds with a 301 code, not 200
|
|
self.assertRedirects(
|
|
response, "http://testserver/permanent_redirect_view/", msg_prefix="abc"
|
|
)
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Couldn't retrieve redirection page '/permanent_redirect_view/': "
|
|
"response code was 301 (expected 200)",
|
|
str(e),
|
|
)
|
|
|
|
def test_redirect_chain(self):
|
|
"You can follow a redirect chain of multiple redirects"
|
|
response = self.client.get("/redirects/further/more/", {}, follow=True)
|
|
self.assertRedirects(
|
|
response, "/no_template_view/", status_code=302, target_status_code=200
|
|
)
|
|
|
|
self.assertEqual(len(response.redirect_chain), 1)
|
|
self.assertEqual(response.redirect_chain[0], ("/no_template_view/", 302))
|
|
|
|
def test_multiple_redirect_chain(self):
|
|
"You can follow a redirect chain of multiple redirects"
|
|
response = self.client.get("/redirects/", {}, follow=True)
|
|
self.assertRedirects(
|
|
response, "/no_template_view/", status_code=302, target_status_code=200
|
|
)
|
|
|
|
self.assertEqual(len(response.redirect_chain), 3)
|
|
self.assertEqual(response.redirect_chain[0], ("/redirects/further/", 302))
|
|
self.assertEqual(response.redirect_chain[1], ("/redirects/further/more/", 302))
|
|
self.assertEqual(response.redirect_chain[2], ("/no_template_view/", 302))
|
|
|
|
def test_redirect_chain_to_non_existent(self):
|
|
"You can follow a chain to a nonexistent view."
|
|
response = self.client.get("/redirect_to_non_existent_view2/", {}, follow=True)
|
|
self.assertRedirects(
|
|
response, "/non_existent_view/", status_code=302, target_status_code=404
|
|
)
|
|
|
|
def test_redirect_chain_to_self(self):
|
|
"Redirections to self are caught and escaped"
|
|
with self.assertRaises(RedirectCycleError) as context:
|
|
self.client.get("/redirect_to_self/", {}, follow=True)
|
|
response = context.exception.last_response
|
|
# The chain of redirects stops once the cycle is detected.
|
|
self.assertRedirects(
|
|
response, "/redirect_to_self/", status_code=302, target_status_code=302
|
|
)
|
|
self.assertEqual(len(response.redirect_chain), 2)
|
|
|
|
def test_redirect_to_self_with_changing_query(self):
|
|
"Redirections don't loop forever even if query is changing"
|
|
with self.assertRaises(RedirectCycleError):
|
|
self.client.get(
|
|
"/redirect_to_self_with_changing_query_view/",
|
|
{"counter": "0"},
|
|
follow=True,
|
|
)
|
|
|
|
def test_circular_redirect(self):
|
|
"Circular redirect chains are caught and escaped"
|
|
with self.assertRaises(RedirectCycleError) as context:
|
|
self.client.get("/circular_redirect_1/", {}, follow=True)
|
|
response = context.exception.last_response
|
|
# The chain of redirects will get back to the starting point, but stop there.
|
|
self.assertRedirects(
|
|
response, "/circular_redirect_2/", status_code=302, target_status_code=302
|
|
)
|
|
self.assertEqual(len(response.redirect_chain), 4)
|
|
|
|
def test_redirect_chain_post(self):
|
|
"A redirect chain will be followed from an initial POST post"
|
|
response = self.client.post("/redirects/", {"nothing": "to_send"}, follow=True)
|
|
self.assertRedirects(response, "/no_template_view/", 302, 200)
|
|
self.assertEqual(len(response.redirect_chain), 3)
|
|
|
|
def test_redirect_chain_head(self):
|
|
"A redirect chain will be followed from an initial HEAD request"
|
|
response = self.client.head("/redirects/", {"nothing": "to_send"}, follow=True)
|
|
self.assertRedirects(response, "/no_template_view/", 302, 200)
|
|
self.assertEqual(len(response.redirect_chain), 3)
|
|
|
|
def test_redirect_chain_options(self):
|
|
"A redirect chain will be followed from an initial OPTIONS request"
|
|
response = self.client.options("/redirects/", follow=True)
|
|
self.assertRedirects(response, "/no_template_view/", 302, 200)
|
|
self.assertEqual(len(response.redirect_chain), 3)
|
|
|
|
def test_redirect_chain_put(self):
|
|
"A redirect chain will be followed from an initial PUT request"
|
|
response = self.client.put("/redirects/", follow=True)
|
|
self.assertRedirects(response, "/no_template_view/", 302, 200)
|
|
self.assertEqual(len(response.redirect_chain), 3)
|
|
|
|
def test_redirect_chain_delete(self):
|
|
"A redirect chain will be followed from an initial DELETE request"
|
|
response = self.client.delete("/redirects/", follow=True)
|
|
self.assertRedirects(response, "/no_template_view/", 302, 200)
|
|
self.assertEqual(len(response.redirect_chain), 3)
|
|
|
|
@modify_settings(ALLOWED_HOSTS={"append": "otherserver"})
|
|
def test_redirect_to_different_host(self):
|
|
"The test client will preserve scheme, host and port changes"
|
|
response = self.client.get("/redirect_other_host/", follow=True)
|
|
self.assertRedirects(
|
|
response,
|
|
"https://otherserver:8443/no_template_view/",
|
|
status_code=302,
|
|
target_status_code=200,
|
|
)
|
|
# We can't use is_secure() or get_host()
|
|
# because response.request is a dictionary, not an HttpRequest
|
|
self.assertEqual(response.request.get("wsgi.url_scheme"), "https")
|
|
self.assertEqual(response.request.get("SERVER_NAME"), "otherserver")
|
|
self.assertEqual(response.request.get("SERVER_PORT"), "8443")
|
|
# assertRedirects() can follow redirect to 'otherserver' too.
|
|
response = self.client.get("/redirect_other_host/", follow=False)
|
|
self.assertRedirects(
|
|
response,
|
|
"https://otherserver:8443/no_template_view/",
|
|
status_code=302,
|
|
target_status_code=200,
|
|
)
|
|
|
|
def test_redirect_chain_on_non_redirect_page(self):
|
|
"""
|
|
An assertion is raised if the original page couldn't be retrieved as
|
|
expected.
|
|
"""
|
|
# This page will redirect with code 301, not 302
|
|
response = self.client.get("/get_view/", follow=True)
|
|
try:
|
|
self.assertRedirects(response, "/get_view/")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Response didn't redirect as expected: Response code was 200 "
|
|
"(expected 302)",
|
|
str(e),
|
|
)
|
|
|
|
try:
|
|
self.assertRedirects(response, "/get_view/", msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Response didn't redirect as expected: Response code was 200 "
|
|
"(expected 302)",
|
|
str(e),
|
|
)
|
|
|
|
def test_redirect_on_non_redirect_page(self):
|
|
"An assertion is raised if the original page couldn't be retrieved as expected"
|
|
# This page will redirect with code 301, not 302
|
|
response = self.client.get("/get_view/")
|
|
try:
|
|
self.assertRedirects(response, "/get_view/")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"Response didn't redirect as expected: Response code was 200 "
|
|
"(expected 302)",
|
|
str(e),
|
|
)
|
|
|
|
try:
|
|
self.assertRedirects(response, "/get_view/", msg_prefix="abc")
|
|
except AssertionError as e:
|
|
self.assertIn(
|
|
"abc: Response didn't redirect as expected: Response code was 200 "
|
|
"(expected 302)",
|
|
str(e),
|
|
)
|
|
|
|
def test_redirect_scheme(self):
|
|
"""
|
|
An assertion is raised if the response doesn't have the scheme
|
|
specified in expected_url.
|
|
"""
|
|
|
|
# For all possible True/False combinations of follow and secure
|
|
for follow, secure in itertools.product([True, False], repeat=2):
|
|
# always redirects to https
|
|
response = self.client.get(
|
|
"/https_redirect_view/", follow=follow, secure=secure
|
|
)
|
|
# the goal scheme is https
|
|
self.assertRedirects(
|
|
response, "https://testserver/secure_view/", status_code=302
|
|
)
|
|
with self.assertRaises(AssertionError):
|
|
self.assertRedirects(
|
|
response, "http://testserver/secure_view/", status_code=302
|
|
)
|
|
|
|
def test_redirect_fetch_redirect_response(self):
|
|
"""Preserve extra headers of requests made with django.test.Client."""
|
|
methods = (
|
|
"get",
|
|
"post",
|
|
"head",
|
|
"options",
|
|
"put",
|
|
"patch",
|
|
"delete",
|
|
"trace",
|
|
)
|
|
for method in methods:
|
|
with self.subTest(method=method):
|
|
req_method = getattr(self.client, method)
|
|
response = req_method(
|
|
"/redirect_based_on_extra_headers_1/",
|
|
follow=False,
|
|
HTTP_REDIRECT="val",
|
|
)
|
|
self.assertRedirects(
|
|
response,
|
|
"/redirect_based_on_extra_headers_2/",
|
|
fetch_redirect_response=True,
|
|
status_code=302,
|
|
target_status_code=302,
|
|
)
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class LoginTests(TestDataMixin, TestCase):
|
|
def test_login_different_client(self):
|
|
"Using a different test client doesn't violate authentication"
|
|
|
|
# Create a second client, and log in.
|
|
c = Client()
|
|
login = c.login(username="testclient", password="password")
|
|
self.assertTrue(login, "Could not log in")
|
|
|
|
# Get a redirection page with the second client.
|
|
response = c.get("/login_protected_redirect_view/")
|
|
|
|
# At this points, the self.client isn't logged in.
|
|
# assertRedirects uses the original client, not the default client.
|
|
self.assertRedirects(response, "/get_view/")
|
|
|
|
|
|
@override_settings(
|
|
SESSION_ENGINE="test_client_regress.session",
|
|
ROOT_URLCONF="test_client_regress.urls",
|
|
)
|
|
class SessionEngineTests(TestDataMixin, TestCase):
|
|
def test_login(self):
|
|
"A session engine that modifies the session key can be used to log in"
|
|
login = self.client.login(username="testclient", password="password")
|
|
self.assertTrue(login, "Could not log in")
|
|
|
|
# Try to access a login protected page.
|
|
response = self.client.get("/login_protected_view/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.context["user"].username, "testclient")
|
|
|
|
|
|
@override_settings(
|
|
ROOT_URLCONF="test_client_regress.urls",
|
|
)
|
|
class URLEscapingTests(SimpleTestCase):
|
|
def test_simple_argument_get(self):
|
|
"Get a view that has a simple string argument"
|
|
response = self.client.get(reverse("arg_view", args=["Slartibartfast"]))
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"Howdy, Slartibartfast")
|
|
|
|
def test_argument_with_space_get(self):
|
|
"Get a view that has a string argument that requires escaping"
|
|
response = self.client.get(reverse("arg_view", args=["Arthur Dent"]))
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"Hi, Arthur")
|
|
|
|
def test_simple_argument_post(self):
|
|
"Post for a view that has a simple string argument"
|
|
response = self.client.post(reverse("arg_view", args=["Slartibartfast"]))
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"Howdy, Slartibartfast")
|
|
|
|
def test_argument_with_space_post(self):
|
|
"Post for a view that has a string argument that requires escaping"
|
|
response = self.client.post(reverse("arg_view", args=["Arthur Dent"]))
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"Hi, Arthur")
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class ExceptionTests(TestDataMixin, TestCase):
|
|
def test_exception_cleared(self):
|
|
"#5836 - A stale user exception isn't re-raised by the test client."
|
|
|
|
login = self.client.login(username="testclient", password="password")
|
|
self.assertTrue(login, "Could not log in")
|
|
with self.assertRaises(CustomTestException):
|
|
self.client.get("/staff_only/")
|
|
|
|
# At this point, an exception has been raised, and should be cleared.
|
|
|
|
# This next operation should be successful; if it isn't we have a problem.
|
|
login = self.client.login(username="staff", password="password")
|
|
self.assertTrue(login, "Could not log in")
|
|
self.client.get("/staff_only/")
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class TemplateExceptionTests(SimpleTestCase):
|
|
@override_settings(
|
|
TEMPLATES=[
|
|
{
|
|
"BACKEND": "django.template.backends.django.DjangoTemplates",
|
|
"DIRS": [os.path.join(os.path.dirname(__file__), "bad_templates")],
|
|
}
|
|
]
|
|
)
|
|
def test_bad_404_template(self):
|
|
"Errors found when rendering 404 error templates are re-raised"
|
|
with self.assertRaises(TemplateSyntaxError):
|
|
self.client.get("/no_such_view/")
|
|
|
|
|
|
# We need two different tests to check URLconf substitution - one to check
|
|
# it was changed, and another one (without self.urls) to check it was reverted on
|
|
# teardown. This pair of tests relies upon the alphabetical ordering of test execution.
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class UrlconfSubstitutionTests(SimpleTestCase):
|
|
def test_urlconf_was_changed(self):
|
|
"TestCase can enforce a custom URLconf on a per-test basis"
|
|
url = reverse("arg_view", args=["somename"])
|
|
self.assertEqual(url, "/arg_view/somename/")
|
|
|
|
|
|
# This test needs to run *after* UrlconfSubstitutionTests; the zz prefix in the
|
|
# name is to ensure alphabetical ordering.
|
|
class zzUrlconfSubstitutionTests(SimpleTestCase):
|
|
def test_urlconf_was_reverted(self):
|
|
"""URLconf is reverted to original value after modification in a TestCase
|
|
|
|
This will not find a match as the default ROOT_URLCONF is empty.
|
|
"""
|
|
with self.assertRaises(NoReverseMatch):
|
|
reverse("arg_view", args=["somename"])
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class ContextTests(TestDataMixin, TestCase):
|
|
def test_single_context(self):
|
|
"Context variables can be retrieved from a single context"
|
|
response = self.client.get("/request_data/", data={"foo": "whiz"})
|
|
self.assertIsInstance(response.context, RequestContext)
|
|
self.assertIn("get-foo", response.context)
|
|
self.assertEqual(response.context["get-foo"], "whiz")
|
|
self.assertEqual(response.context["data"], "sausage")
|
|
|
|
with self.assertRaisesMessage(KeyError, "does-not-exist"):
|
|
response.context["does-not-exist"]
|
|
|
|
def test_inherited_context(self):
|
|
"Context variables can be retrieved from a list of contexts"
|
|
response = self.client.get("/request_data_extended/", data={"foo": "whiz"})
|
|
self.assertEqual(response.context.__class__, ContextList)
|
|
self.assertEqual(len(response.context), 2)
|
|
self.assertIn("get-foo", response.context)
|
|
self.assertEqual(response.context["get-foo"], "whiz")
|
|
self.assertEqual(response.context["data"], "bacon")
|
|
|
|
with self.assertRaisesMessage(KeyError, "does-not-exist"):
|
|
response.context["does-not-exist"]
|
|
|
|
def test_contextlist_keys(self):
|
|
c1 = Context()
|
|
c1.update({"hello": "world", "goodbye": "john"})
|
|
c1.update({"hello": "dolly", "dolly": "parton"})
|
|
c2 = Context()
|
|
c2.update({"goodbye": "world", "python": "rocks"})
|
|
c2.update({"goodbye": "dolly"})
|
|
|
|
k = ContextList([c1, c2])
|
|
# None, True and False are builtins of BaseContext, and present
|
|
# in every Context without needing to be added.
|
|
self.assertEqual(
|
|
{"None", "True", "False", "hello", "goodbye", "python", "dolly"}, k.keys()
|
|
)
|
|
|
|
def test_contextlist_get(self):
|
|
c1 = Context({"hello": "world", "goodbye": "john"})
|
|
c2 = Context({"goodbye": "world", "python": "rocks"})
|
|
k = ContextList([c1, c2])
|
|
self.assertEqual(k.get("hello"), "world")
|
|
self.assertEqual(k.get("goodbye"), "john")
|
|
self.assertEqual(k.get("python"), "rocks")
|
|
self.assertEqual(k.get("nonexistent", "default"), "default")
|
|
|
|
def test_15368(self):
|
|
# Need to insert a context processor that assumes certain things about
|
|
# the request instance. This triggers a bug caused by some ways of
|
|
# copying RequestContext.
|
|
with self.settings(
|
|
TEMPLATES=[
|
|
{
|
|
"BACKEND": "django.template.backends.django.DjangoTemplates",
|
|
"APP_DIRS": True,
|
|
"OPTIONS": {
|
|
"context_processors": [
|
|
"test_client_regress.context_processors.special",
|
|
],
|
|
},
|
|
}
|
|
]
|
|
):
|
|
response = self.client.get("/request_context_view/")
|
|
self.assertContains(response, "Path: /request_context_view/")
|
|
|
|
def test_nested_requests(self):
|
|
"""
|
|
response.context is not lost when view call another view.
|
|
"""
|
|
response = self.client.get("/nested_view/")
|
|
self.assertIsInstance(response.context, RequestContext)
|
|
self.assertEqual(response.context["nested"], "yes")
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class SessionTests(TestDataMixin, TestCase):
|
|
def test_session(self):
|
|
"The session isn't lost if a user logs in"
|
|
# The session doesn't exist to start.
|
|
response = self.client.get("/check_session/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"NO")
|
|
|
|
# This request sets a session variable.
|
|
response = self.client.get("/set_session/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"set_session")
|
|
|
|
# The session has been modified
|
|
response = self.client.get("/check_session/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"YES")
|
|
|
|
# Log in
|
|
login = self.client.login(username="testclient", password="password")
|
|
self.assertTrue(login, "Could not log in")
|
|
|
|
# Session should still contain the modified value
|
|
response = self.client.get("/check_session/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"YES")
|
|
|
|
def test_session_initiated(self):
|
|
session = self.client.session
|
|
session["session_var"] = "foo"
|
|
session.save()
|
|
|
|
response = self.client.get("/check_session/")
|
|
self.assertEqual(response.content, b"foo")
|
|
|
|
def test_logout(self):
|
|
"""Logout should work whether the user is logged in or not (#9978)."""
|
|
self.client.logout()
|
|
login = self.client.login(username="testclient", password="password")
|
|
self.assertTrue(login, "Could not log in")
|
|
self.client.logout()
|
|
self.client.logout()
|
|
|
|
def test_logout_with_user(self):
|
|
"""Logout should send user_logged_out signal if user was logged in."""
|
|
|
|
def listener(*args, **kwargs):
|
|
listener.executed = True
|
|
self.assertEqual(kwargs["sender"], User)
|
|
|
|
listener.executed = False
|
|
|
|
user_logged_out.connect(listener)
|
|
self.client.login(username="testclient", password="password")
|
|
self.client.logout()
|
|
user_logged_out.disconnect(listener)
|
|
self.assertTrue(listener.executed)
|
|
|
|
@override_settings(AUTH_USER_MODEL="test_client_regress.CustomUser")
|
|
def test_logout_with_custom_user(self):
|
|
"""Logout should send user_logged_out signal if custom user was logged in."""
|
|
|
|
def listener(*args, **kwargs):
|
|
self.assertEqual(kwargs["sender"], CustomUser)
|
|
listener.executed = True
|
|
|
|
listener.executed = False
|
|
u = CustomUser.custom_objects.create(email="test@test.com")
|
|
u.set_password("password")
|
|
u.save()
|
|
|
|
user_logged_out.connect(listener)
|
|
self.client.login(username="test@test.com", password="password")
|
|
self.client.logout()
|
|
user_logged_out.disconnect(listener)
|
|
self.assertTrue(listener.executed)
|
|
|
|
@override_settings(
|
|
AUTHENTICATION_BACKENDS=(
|
|
"django.contrib.auth.backends.ModelBackend",
|
|
"test_client_regress.auth_backends.CustomUserBackend",
|
|
)
|
|
)
|
|
def test_logout_with_custom_auth_backend(self):
|
|
"Request a logout after logging in with custom authentication backend"
|
|
|
|
def listener(*args, **kwargs):
|
|
self.assertEqual(kwargs["sender"], CustomUser)
|
|
listener.executed = True
|
|
|
|
listener.executed = False
|
|
u = CustomUser.custom_objects.create(email="test@test.com")
|
|
u.set_password("password")
|
|
u.save()
|
|
|
|
user_logged_out.connect(listener)
|
|
self.client.login(username="test@test.com", password="password")
|
|
self.client.logout()
|
|
user_logged_out.disconnect(listener)
|
|
self.assertTrue(listener.executed)
|
|
|
|
def test_logout_without_user(self):
|
|
"""Logout should send signal even if user not authenticated."""
|
|
|
|
def listener(user, *args, **kwargs):
|
|
listener.user = user
|
|
listener.executed = True
|
|
|
|
listener.executed = False
|
|
|
|
user_logged_out.connect(listener)
|
|
self.client.login(username="incorrect", password="password")
|
|
self.client.logout()
|
|
user_logged_out.disconnect(listener)
|
|
|
|
self.assertTrue(listener.executed)
|
|
self.assertIsNone(listener.user)
|
|
|
|
def test_login_with_user(self):
|
|
"""Login should send user_logged_in signal on successful login."""
|
|
|
|
def listener(*args, **kwargs):
|
|
listener.executed = True
|
|
|
|
listener.executed = False
|
|
|
|
user_logged_in.connect(listener)
|
|
self.client.login(username="testclient", password="password")
|
|
user_logged_out.disconnect(listener)
|
|
|
|
self.assertTrue(listener.executed)
|
|
|
|
def test_login_without_signal(self):
|
|
"""Login shouldn't send signal if user wasn't logged in"""
|
|
|
|
def listener(*args, **kwargs):
|
|
listener.executed = True
|
|
|
|
listener.executed = False
|
|
|
|
user_logged_in.connect(listener)
|
|
self.client.login(username="incorrect", password="password")
|
|
user_logged_in.disconnect(listener)
|
|
|
|
self.assertFalse(listener.executed)
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class RequestMethodTests(SimpleTestCase):
|
|
def test_get(self):
|
|
"Request a view via request method GET"
|
|
response = self.client.get("/request_methods/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"request method: GET")
|
|
|
|
def test_post(self):
|
|
"Request a view via request method POST"
|
|
response = self.client.post("/request_methods/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"request method: POST")
|
|
|
|
def test_head(self):
|
|
"Request a view via request method HEAD"
|
|
response = self.client.head("/request_methods/")
|
|
self.assertEqual(response.status_code, 200)
|
|
# A HEAD request doesn't return any content.
|
|
self.assertNotEqual(response.content, b"request method: HEAD")
|
|
self.assertEqual(response.content, b"")
|
|
|
|
def test_options(self):
|
|
"Request a view via request method OPTIONS"
|
|
response = self.client.options("/request_methods/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"request method: OPTIONS")
|
|
|
|
def test_put(self):
|
|
"Request a view via request method PUT"
|
|
response = self.client.put("/request_methods/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"request method: PUT")
|
|
|
|
def test_delete(self):
|
|
"Request a view via request method DELETE"
|
|
response = self.client.delete("/request_methods/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"request method: DELETE")
|
|
|
|
def test_patch(self):
|
|
"Request a view via request method PATCH"
|
|
response = self.client.patch("/request_methods/")
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"request method: PATCH")
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class RequestMethodStringDataTests(SimpleTestCase):
|
|
def test_post(self):
|
|
"Request a view with string data via request method POST"
|
|
# Regression test for #11371
|
|
data = '{"test": "json"}'
|
|
response = self.client.post(
|
|
"/request_methods/", data=data, content_type="application/json"
|
|
)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"request method: POST")
|
|
|
|
def test_put(self):
|
|
"Request a view with string data via request method PUT"
|
|
# Regression test for #11371
|
|
data = '{"test": "json"}'
|
|
response = self.client.put(
|
|
"/request_methods/", data=data, content_type="application/json"
|
|
)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"request method: PUT")
|
|
|
|
def test_patch(self):
|
|
"Request a view with string data via request method PATCH"
|
|
# Regression test for #17797
|
|
data = '{"test": "json"}'
|
|
response = self.client.patch(
|
|
"/request_methods/", data=data, content_type="application/json"
|
|
)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertEqual(response.content, b"request method: PATCH")
|
|
|
|
def test_empty_string_data(self):
|
|
"Request a view with empty string data via request method GET/POST/HEAD"
|
|
# Regression test for #21740
|
|
response = self.client.get("/body/", data="", content_type="application/json")
|
|
self.assertEqual(response.content, b"")
|
|
response = self.client.post("/body/", data="", content_type="application/json")
|
|
self.assertEqual(response.content, b"")
|
|
response = self.client.head("/body/", data="", content_type="application/json")
|
|
self.assertEqual(response.content, b"")
|
|
|
|
def test_json_bytes(self):
|
|
response = self.client.post(
|
|
"/body/", data=b"{'value': 37}", content_type="application/json"
|
|
)
|
|
self.assertEqual(response.content, b"{'value': 37}")
|
|
|
|
def test_json(self):
|
|
response = self.client.get("/json_response/")
|
|
self.assertEqual(response.json(), {"key": "value"})
|
|
|
|
def test_json_charset(self):
|
|
response = self.client.get("/json_response_latin1/")
|
|
self.assertEqual(response.charset, "latin1")
|
|
self.assertEqual(response.json(), {"a": "Å"})
|
|
|
|
def test_json_structured_suffixes(self):
|
|
valid_types = (
|
|
"application/vnd.api+json",
|
|
"application/vnd.api.foo+json",
|
|
"application/json; charset=utf-8",
|
|
"application/activity+json",
|
|
"application/activity+json; charset=utf-8",
|
|
)
|
|
for content_type in valid_types:
|
|
response = self.client.get(
|
|
"/json_response/", {"content_type": content_type}
|
|
)
|
|
self.assertEqual(response.headers["Content-Type"], content_type)
|
|
self.assertEqual(response.json(), {"key": "value"})
|
|
|
|
def test_json_multiple_access(self):
|
|
response = self.client.get("/json_response/")
|
|
self.assertIs(response.json(), response.json())
|
|
|
|
def test_json_wrong_header(self):
|
|
response = self.client.get("/body/")
|
|
msg = (
|
|
'Content-Type header is "text/html; charset=utf-8", not "application/json"'
|
|
)
|
|
with self.assertRaisesMessage(ValueError, msg):
|
|
self.assertEqual(response.json(), {"key": "value"})
|
|
|
|
|
|
@override_settings(
|
|
ROOT_URLCONF="test_client_regress.urls",
|
|
)
|
|
class QueryStringTests(SimpleTestCase):
|
|
def test_get_like_requests(self):
|
|
for method_name in ("get", "head"):
|
|
# A GET-like request can pass a query string as data (#10571)
|
|
method = getattr(self.client, method_name)
|
|
response = method("/request_data/", data={"foo": "whiz"})
|
|
self.assertEqual(response.context["get-foo"], "whiz")
|
|
|
|
# A GET-like request can pass a query string as part of the URL
|
|
response = method("/request_data/?foo=whiz")
|
|
self.assertEqual(response.context["get-foo"], "whiz")
|
|
|
|
# Data provided in the URL to a GET-like request is overridden by
|
|
# actual form data.
|
|
response = method("/request_data/?foo=whiz", data={"foo": "bang"})
|
|
self.assertEqual(response.context["get-foo"], "bang")
|
|
|
|
response = method("/request_data/?foo=whiz", data={"bar": "bang"})
|
|
self.assertIsNone(response.context["get-foo"])
|
|
self.assertEqual(response.context["get-bar"], "bang")
|
|
|
|
def test_post_like_requests(self):
|
|
# A POST-like request can pass a query string as data
|
|
response = self.client.post("/request_data/", data={"foo": "whiz"})
|
|
self.assertIsNone(response.context["get-foo"])
|
|
self.assertEqual(response.context["post-foo"], "whiz")
|
|
|
|
# A POST-like request can pass a query string as part of the URL
|
|
response = self.client.post("/request_data/?foo=whiz")
|
|
self.assertEqual(response.context["get-foo"], "whiz")
|
|
self.assertIsNone(response.context["post-foo"])
|
|
|
|
# POST data provided in the URL augments actual form data
|
|
response = self.client.post("/request_data/?foo=whiz", data={"foo": "bang"})
|
|
self.assertEqual(response.context["get-foo"], "whiz")
|
|
self.assertEqual(response.context["post-foo"], "bang")
|
|
|
|
response = self.client.post("/request_data/?foo=whiz", data={"bar": "bang"})
|
|
self.assertEqual(response.context["get-foo"], "whiz")
|
|
self.assertIsNone(response.context["get-bar"])
|
|
self.assertIsNone(response.context["post-foo"])
|
|
self.assertEqual(response.context["post-bar"], "bang")
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class PayloadEncodingTests(SimpleTestCase):
|
|
"""Regression tests for #10571."""
|
|
|
|
def test_simple_payload(self):
|
|
"""A simple ASCII-only text can be POSTed."""
|
|
text = "English: mountain pass"
|
|
response = self.client.post(
|
|
"/parse_encoded_text/", text, content_type="text/plain"
|
|
)
|
|
self.assertEqual(response.content, text.encode())
|
|
|
|
def test_utf8_payload(self):
|
|
"""Non-ASCII data encoded as UTF-8 can be POSTed."""
|
|
text = "dog: собака"
|
|
response = self.client.post(
|
|
"/parse_encoded_text/", text, content_type="text/plain; charset=utf-8"
|
|
)
|
|
self.assertEqual(response.content, text.encode())
|
|
|
|
def test_utf16_payload(self):
|
|
"""Non-ASCII data encoded as UTF-16 can be POSTed."""
|
|
text = "dog: собака"
|
|
response = self.client.post(
|
|
"/parse_encoded_text/", text, content_type="text/plain; charset=utf-16"
|
|
)
|
|
self.assertEqual(response.content, text.encode("utf-16"))
|
|
|
|
def test_non_utf_payload(self):
|
|
"""Non-ASCII data as a non-UTF based encoding can be POSTed."""
|
|
text = "dog: собака"
|
|
response = self.client.post(
|
|
"/parse_encoded_text/", text, content_type="text/plain; charset=koi8-r"
|
|
)
|
|
self.assertEqual(response.content, text.encode("koi8-r"))
|
|
|
|
|
|
class DummyFile:
|
|
def __init__(self, filename):
|
|
self.name = filename
|
|
|
|
def read(self):
|
|
return b"TEST_FILE_CONTENT"
|
|
|
|
|
|
class UploadedFileEncodingTest(SimpleTestCase):
|
|
def test_file_encoding(self):
|
|
encoded_file = encode_file(
|
|
"TEST_BOUNDARY", "TEST_KEY", DummyFile("test_name.bin")
|
|
)
|
|
self.assertEqual(b"--TEST_BOUNDARY", encoded_file[0])
|
|
self.assertEqual(
|
|
b'Content-Disposition: form-data; name="TEST_KEY"; '
|
|
b'filename="test_name.bin"',
|
|
encoded_file[1],
|
|
)
|
|
self.assertEqual(b"TEST_FILE_CONTENT", encoded_file[-1])
|
|
|
|
def test_guesses_content_type_on_file_encoding(self):
|
|
self.assertEqual(
|
|
b"Content-Type: application/octet-stream",
|
|
encode_file("IGNORE", "IGNORE", DummyFile("file.bin"))[2],
|
|
)
|
|
self.assertEqual(
|
|
b"Content-Type: text/plain",
|
|
encode_file("IGNORE", "IGNORE", DummyFile("file.txt"))[2],
|
|
)
|
|
self.assertIn(
|
|
encode_file("IGNORE", "IGNORE", DummyFile("file.zip"))[2],
|
|
(
|
|
b"Content-Type: application/x-compress",
|
|
b"Content-Type: application/x-zip",
|
|
b"Content-Type: application/x-zip-compressed",
|
|
b"Content-Type: application/zip",
|
|
),
|
|
)
|
|
self.assertEqual(
|
|
b"Content-Type: application/octet-stream",
|
|
encode_file("IGNORE", "IGNORE", DummyFile("file.unknown"))[2],
|
|
)
|
|
|
|
|
|
@override_settings(
|
|
ROOT_URLCONF="test_client_regress.urls",
|
|
)
|
|
class RequestHeadersTest(SimpleTestCase):
|
|
def test_client_headers(self):
|
|
"A test client can receive custom headers"
|
|
response = self.client.get("/check_headers/", HTTP_X_ARG_CHECK="Testing 123")
|
|
self.assertEqual(response.content, b"HTTP_X_ARG_CHECK: Testing 123")
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
def test_client_headers_redirect(self):
|
|
"Test client headers are preserved through redirects"
|
|
response = self.client.get(
|
|
"/check_headers_redirect/", follow=True, HTTP_X_ARG_CHECK="Testing 123"
|
|
)
|
|
self.assertEqual(response.content, b"HTTP_X_ARG_CHECK: Testing 123")
|
|
self.assertRedirects(
|
|
response, "/check_headers/", status_code=302, target_status_code=200
|
|
)
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class ReadLimitedStreamTest(SimpleTestCase):
|
|
"""
|
|
HttpRequest.body, HttpRequest.read(), and HttpRequest.read(BUFFER) have
|
|
proper LimitedStream behavior.
|
|
|
|
Refs #14753, #15785
|
|
"""
|
|
|
|
def test_body_from_empty_request(self):
|
|
"""HttpRequest.body on a test client GET request should return
|
|
the empty string."""
|
|
self.assertEqual(self.client.get("/body/").content, b"")
|
|
|
|
def test_read_from_empty_request(self):
|
|
"""HttpRequest.read() on a test client GET request should return the
|
|
empty string."""
|
|
self.assertEqual(self.client.get("/read_all/").content, b"")
|
|
|
|
def test_read_numbytes_from_empty_request(self):
|
|
"""HttpRequest.read(LARGE_BUFFER) on a test client GET request should
|
|
return the empty string."""
|
|
self.assertEqual(self.client.get("/read_buffer/").content, b"")
|
|
|
|
def test_read_from_nonempty_request(self):
|
|
"""HttpRequest.read() on a test client PUT request with some payload
|
|
should return that payload."""
|
|
payload = b"foobar"
|
|
self.assertEqual(
|
|
self.client.put(
|
|
"/read_all/", data=payload, content_type="text/plain"
|
|
).content,
|
|
payload,
|
|
)
|
|
|
|
def test_read_numbytes_from_nonempty_request(self):
|
|
"""HttpRequest.read(LARGE_BUFFER) on a test client PUT request with
|
|
some payload should return that payload."""
|
|
payload = b"foobar"
|
|
self.assertEqual(
|
|
self.client.put(
|
|
"/read_buffer/", data=payload, content_type="text/plain"
|
|
).content,
|
|
payload,
|
|
)
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class RequestFactoryStateTest(SimpleTestCase):
|
|
"""Regression tests for #15929."""
|
|
|
|
# These tests are checking that certain middleware don't change certain
|
|
# global state. Alternatively, from the point of view of a test, they are
|
|
# ensuring test isolation behavior. So, unusually, it doesn't make sense to
|
|
# run the tests individually, and if any are failing it is confusing to run
|
|
# them with any other set of tests.
|
|
|
|
def common_test_that_should_always_pass(self):
|
|
request = RequestFactory().get("/")
|
|
request.session = {}
|
|
self.assertFalse(hasattr(request, "user"))
|
|
|
|
def test_request(self):
|
|
self.common_test_that_should_always_pass()
|
|
|
|
def test_request_after_client(self):
|
|
# apart from the next line the three tests are identical
|
|
self.client.get("/")
|
|
self.common_test_that_should_always_pass()
|
|
|
|
def test_request_after_client_2(self):
|
|
# This test is executed after the previous one
|
|
self.common_test_that_should_always_pass()
|
|
|
|
|
|
@override_settings(ROOT_URLCONF="test_client_regress.urls")
|
|
class RequestFactoryEnvironmentTests(SimpleTestCase):
|
|
"""
|
|
Regression tests for #8551 and #17067: ensure that environment variables
|
|
are set correctly in RequestFactory.
|
|
"""
|
|
|
|
def test_should_set_correct_env_variables(self):
|
|
request = RequestFactory().get("/path/")
|
|
|
|
self.assertEqual(request.META.get("REMOTE_ADDR"), "127.0.0.1")
|
|
self.assertEqual(request.META.get("SERVER_NAME"), "testserver")
|
|
self.assertEqual(request.META.get("SERVER_PORT"), "80")
|
|
self.assertEqual(request.META.get("SERVER_PROTOCOL"), "HTTP/1.1")
|
|
self.assertEqual(
|
|
request.META.get("SCRIPT_NAME") + request.META.get("PATH_INFO"), "/path/"
|
|
)
|
|
|
|
def test_cookies(self):
|
|
factory = RequestFactory()
|
|
factory.cookies.load('A="B"; C="D"; Path=/; Version=1')
|
|
request = factory.get("/")
|
|
self.assertEqual(request.META["HTTP_COOKIE"], 'A="B"; C="D"')
|