1. import copy

  2. import json

  3. import os

  4. import pickle

  5. import unittest

  6. import uuid

  7. 

  8. from django.core.exceptions import DisallowedRedirect

  9. from django.core.serializers.json import DjangoJSONEncoder

  10. from django.core.signals import request_finished

  11. from django.db import close_old_connections

  12. from django.http import (

  13.     BadHeaderError,

  14.     HttpResponse,

  15.     HttpResponseNotAllowed,

  16.     HttpResponseNotModified,

  17.     HttpResponsePermanentRedirect,

  18.     HttpResponseRedirect,

  19.     JsonResponse,

  20.     QueryDict,

  21.     SimpleCookie,

  22.     StreamingHttpResponse,

  23.     parse_cookie,

  24. )

  25. from django.test import SimpleTestCase

  26. from django.utils.functional import lazystr

  27. 

  28. 

  29. class QueryDictTests(SimpleTestCase):

  30.     def test_create_with_no_args(self):

  31.         self.assertEqual(QueryDict(), QueryDict(""))

  32. 

  33.     def test_missing_key(self):

  34.         q = QueryDict()

  35.         with self.assertRaises(KeyError):

  36.             q.__getitem__("foo")

  37. 

  38.     def test_immutability(self):

  39.         q = QueryDict()

  40.         with self.assertRaises(AttributeError):

  41.             q.__setitem__("something", "bar")

  42.         with self.assertRaises(AttributeError):

  43.             q.setlist("foo", ["bar"])

  44.         with self.assertRaises(AttributeError):

  45.             q.appendlist("foo", ["bar"])

  46.         with self.assertRaises(AttributeError):

  47.             q.update({"foo": "bar"})

  48.         with self.assertRaises(AttributeError):

  49.             q.pop("foo")

  50.         with self.assertRaises(AttributeError):

  51.             q.popitem()

  52.         with self.assertRaises(AttributeError):

  53.             q.clear()

  54. 

  55.     def test_immutable_get_with_default(self):

  56.         q = QueryDict()

  57.         self.assertEqual(q.get("foo", "default"), "default")

  58. 

  59.     def test_immutable_basic_operations(self):

  60.         q = QueryDict()

  61.         self.assertEqual(q.getlist("foo"), [])

  62.         self.assertNotIn("foo", q)

  63.         self.assertEqual(list(q), [])

  64.         self.assertEqual(list(q.items()), [])

  65.         self.assertEqual(list(q.lists()), [])

  66.         self.assertEqual(list(q.keys()), [])

  67.         self.assertEqual(list(q.values()), [])

  68.         self.assertEqual(len(q), 0)

  69.         self.assertEqual(q.urlencode(), "")

  70. 

  71.     def test_single_key_value(self):

  72.         """Test QueryDict with one key/value pair"""

  73. 

  74.         q = QueryDict("foo=bar")

  75.         self.assertEqual(q["foo"], "bar")

  76.         with self.assertRaises(KeyError):

  77.             q.__getitem__("bar")

  78.         with self.assertRaises(AttributeError):

  79.             q.__setitem__("something", "bar")

  80. 

  81.         self.assertEqual(q.get("foo", "default"), "bar")

  82.         self.assertEqual(q.get("bar", "default"), "default")

  83.         self.assertEqual(q.getlist("foo"), ["bar"])

  84.         self.assertEqual(q.getlist("bar"), [])

  85. 

  86.         with self.assertRaises(AttributeError):

  87.             q.setlist("foo", ["bar"])

  88.         with self.assertRaises(AttributeError):

  89.             q.appendlist("foo", ["bar"])

  90. 

  91.         self.assertIn("foo", q)

  92.         self.assertNotIn("bar", q)

  93. 

  94.         self.assertEqual(list(q), ["foo"])

  95.         self.assertEqual(list(q.items()), [("foo", "bar")])

  96.         self.assertEqual(list(q.lists()), [("foo", ["bar"])])

  97.         self.assertEqual(list(q.keys()), ["foo"])

  98.         self.assertEqual(list(q.values()), ["bar"])

  99.         self.assertEqual(len(q), 1)

  100. 

  101.         with self.assertRaises(AttributeError):

  102.             q.update({"foo": "bar"})

  103.         with self.assertRaises(AttributeError):

  104.             q.pop("foo")

  105.         with self.assertRaises(AttributeError):

  106.             q.popitem()

  107.         with self.assertRaises(AttributeError):

  108.             q.clear()

  109.         with self.assertRaises(AttributeError):

  110.             q.setdefault("foo", "bar")

  111. 

  112.         self.assertEqual(q.urlencode(), "foo=bar")

  113. 

  114.     def test_urlencode(self):

  115.         q = QueryDict(mutable=True)

  116.         q["next"] = "/a&b/"

  117.         self.assertEqual(q.urlencode(), "next=%2Fa%26b%2F")

  118.         self.assertEqual(q.urlencode(safe="/"), "next=/a%26b/")

  119.         q = QueryDict(mutable=True)

  120.         q["next"] = "/t\xebst&key/"

  121.         self.assertEqual(q.urlencode(), "next=%2Ft%C3%ABst%26key%2F")

  122.         self.assertEqual(q.urlencode(safe="/"), "next=/t%C3%ABst%26key/")

  123. 

  124.     def test_urlencode_int(self):

  125.         # Normally QueryDict doesn't contain non-string values but lazily

  126.         # written tests may make that mistake.

  127.         q = QueryDict(mutable=True)

  128.         q["a"] = 1

  129.         self.assertEqual(q.urlencode(), "a=1")

  130. 

  131.     def test_mutable_copy(self):

  132.         """A copy of a QueryDict is mutable."""

  133.         q = QueryDict().copy()

  134.         with self.assertRaises(KeyError):

  135.             q.__getitem__("foo")

  136.         q["name"] = "john"

  137.         self.assertEqual(q["name"], "john")

  138. 

  139.     def test_mutable_delete(self):

  140.         q = QueryDict(mutable=True)

  141.         q["name"] = "john"

  142.         del q["name"]

  143.         self.assertNotIn("name", q)

  144. 

  145.     def test_basic_mutable_operations(self):

  146.         q = QueryDict(mutable=True)

  147.         q["name"] = "john"

  148.         self.assertEqual(q.get("foo", "default"), "default")

  149.         self.assertEqual(q.get("name", "default"), "john")

  150.         self.assertEqual(q.getlist("name"), ["john"])

  151.         self.assertEqual(q.getlist("foo"), [])

  152. 

  153.         q.setlist("foo", ["bar", "baz"])

  154.         self.assertEqual(q.get("foo", "default"), "baz")

  155.         self.assertEqual(q.getlist("foo"), ["bar", "baz"])

  156. 

  157.         q.appendlist("foo", "another")

  158.         self.assertEqual(q.getlist("foo"), ["bar", "baz", "another"])

  159.         self.assertEqual(q["foo"], "another")

  160.         self.assertIn("foo", q)

  161. 

  162.         self.assertCountEqual(q, ["foo", "name"])

  163.         self.assertCountEqual(q.items(), [("foo", "another"), ("name", "john")])

  164.         self.assertCountEqual(

  165.             q.lists(), [("foo", ["bar", "baz", "another"]), ("name", ["john"])]

  166.         )

  167.         self.assertCountEqual(q.keys(), ["foo", "name"])

  168.         self.assertCountEqual(q.values(), ["another", "john"])

  169. 

  170.         q.update({"foo": "hello"})

  171.         self.assertEqual(q["foo"], "hello")

  172.         self.assertEqual(q.get("foo", "not available"), "hello")

  173.         self.assertEqual(q.getlist("foo"), ["bar", "baz", "another", "hello"])

  174.         self.assertEqual(q.pop("foo"), ["bar", "baz", "another", "hello"])

  175.         self.assertEqual(q.pop("foo", "not there"), "not there")

  176.         self.assertEqual(q.get("foo", "not there"), "not there")

  177.         self.assertEqual(q.setdefault("foo", "bar"), "bar")

  178.         self.assertEqual(q["foo"], "bar")

  179.         self.assertEqual(q.getlist("foo"), ["bar"])

  180.         self.assertIn(q.urlencode(), ["foo=bar&name=john", "name=john&foo=bar"])

  181. 

  182.         q.clear()

  183.         self.assertEqual(len(q), 0)

  184. 

  185.     def test_multiple_keys(self):

  186.         """Test QueryDict with two key/value pairs with same keys."""

  187. 

  188.         q = QueryDict("vote=yes&vote=no")

  189. 

  190.         self.assertEqual(q["vote"], "no")

  191.         with self.assertRaises(AttributeError):

  192.             q.__setitem__("something", "bar")

  193. 

  194.         self.assertEqual(q.get("vote", "default"), "no")

  195.         self.assertEqual(q.get("foo", "default"), "default")

  196.         self.assertEqual(q.getlist("vote"), ["yes", "no"])

  197.         self.assertEqual(q.getlist("foo"), [])

  198. 

  199.         with self.assertRaises(AttributeError):

  200.             q.setlist("foo", ["bar", "baz"])

  201.         with self.assertRaises(AttributeError):

  202.             q.setlist("foo", ["bar", "baz"])

  203.         with self.assertRaises(AttributeError):

  204.             q.appendlist("foo", ["bar"])

  205. 

  206.         self.assertIn("vote", q)

  207.         self.assertNotIn("foo", q)

  208.         self.assertEqual(list(q), ["vote"])

  209.         self.assertEqual(list(q.items()), [("vote", "no")])

  210.         self.assertEqual(list(q.lists()), [("vote", ["yes", "no"])])

  211.         self.assertEqual(list(q.keys()), ["vote"])

  212.         self.assertEqual(list(q.values()), ["no"])

  213.         self.assertEqual(len(q), 1)

  214. 

  215.         with self.assertRaises(AttributeError):

  216.             q.update({"foo": "bar"})

  217.         with self.assertRaises(AttributeError):

  218.             q.pop("foo")

  219.         with self.assertRaises(AttributeError):

  220.             q.popitem()

  221.         with self.assertRaises(AttributeError):

  222.             q.clear()

  223.         with self.assertRaises(AttributeError):

  224.             q.setdefault("foo", "bar")

  225.         with self.assertRaises(AttributeError):

  226.             q.__delitem__("vote")

  227. 

  228.     def test_pickle(self):

  229.         q = QueryDict()

  230.         q1 = pickle.loads(pickle.dumps(q, 2))

  231.         self.assertEqual(q, q1)

  232.         q = QueryDict("a=b&c=d")

  233.         q1 = pickle.loads(pickle.dumps(q, 2))

  234.         self.assertEqual(q, q1)

  235.         q = QueryDict("a=b&c=d&a=1")

  236.         q1 = pickle.loads(pickle.dumps(q, 2))

  237.         self.assertEqual(q, q1)

  238. 

  239.     def test_update_from_querydict(self):

  240.         """Regression test for #8278: QueryDict.update(QueryDict)"""

  241.         x = QueryDict("a=1&a=2", mutable=True)

  242.         y = QueryDict("a=3&a=4")

  243.         x.update(y)

  244.         self.assertEqual(x.getlist("a"), ["1", "2", "3", "4"])

  245. 

  246.     def test_non_default_encoding(self):

  247.         """#13572 - QueryDict with a non-default encoding"""

  248.         q = QueryDict("cur=%A4", encoding="iso-8859-15")

  249.         self.assertEqual(q.encoding, "iso-8859-15")

  250.         self.assertEqual(list(q.items()), [("cur", "€")])

  251.         self.assertEqual(q.urlencode(), "cur=%A4")

  252.         q = q.copy()

  253.         self.assertEqual(q.encoding, "iso-8859-15")

  254.         self.assertEqual(list(q.items()), [("cur", "€")])

  255.         self.assertEqual(q.urlencode(), "cur=%A4")

  256.         self.assertEqual(copy.copy(q).encoding, "iso-8859-15")

  257.         self.assertEqual(copy.deepcopy(q).encoding, "iso-8859-15")

  258. 

  259.     def test_querydict_fromkeys(self):

  260.         self.assertEqual(

  261.             QueryDict.fromkeys(["key1", "key2", "key3"]), QueryDict("key1&key2&key3")

  262.         )

  263. 

  264.     def test_fromkeys_with_nonempty_value(self):

  265.         self.assertEqual(

  266.             QueryDict.fromkeys(["key1", "key2", "key3"], value="val"),

  267.             QueryDict("key1=val&key2=val&key3=val"),

  268.         )

  269. 

  270.     def test_fromkeys_is_immutable_by_default(self):

  271.         # Match behavior of __init__() which is also immutable by default.

  272.         q = QueryDict.fromkeys(["key1", "key2", "key3"])

  273.         with self.assertRaisesMessage(

  274.             AttributeError, "This QueryDict instance is immutable"

  275.         ):

  276.             q["key4"] = "nope"

  277. 

  278.     def test_fromkeys_mutable_override(self):

  279.         q = QueryDict.fromkeys(["key1", "key2", "key3"], mutable=True)

  280.         q["key4"] = "yep"

  281.         self.assertEqual(q, QueryDict("key1&key2&key3&key4=yep"))

  282. 

  283.     def test_duplicates_in_fromkeys_iterable(self):

  284.         self.assertEqual(QueryDict.fromkeys("xyzzy"), QueryDict("x&y&z&z&y"))

  285. 

  286.     def test_fromkeys_with_nondefault_encoding(self):

  287.         key_utf16 = b"\xff\xfe\x8e\x02\xdd\x01\x9e\x02"

  288.         value_utf16 = b"\xff\xfe\xdd\x01n\x00l\x00P\x02\x8c\x02"

  289.         q = QueryDict.fromkeys([key_utf16], value=value_utf16, encoding="utf-16")

  290.         expected = QueryDict("", mutable=True)

  291.         expected["ʎǝʞ"] = "ǝnlɐʌ"

  292.         self.assertEqual(q, expected)

  293. 

  294.     def test_fromkeys_empty_iterable(self):

  295.         self.assertEqual(QueryDict.fromkeys([]), QueryDict(""))

  296. 

  297.     def test_fromkeys_noniterable(self):

  298.         with self.assertRaises(TypeError):

  299.             QueryDict.fromkeys(0)

  300. 

  301. 

  302. class HttpResponseTests(SimpleTestCase):

  303.     def test_headers_type(self):

  304.         r = HttpResponse()

  305. 

  306.         # ASCII strings or bytes values are converted to strings.

  307.         r.headers["key"] = "test"

  308.         self.assertEqual(r.headers["key"], "test")

  309.         r.headers["key"] = b"test"

  310.         self.assertEqual(r.headers["key"], "test")

  311.         self.assertIn(b"test", r.serialize_headers())

  312. 

  313.         # Non-ASCII values are serialized to Latin-1.

  314.         r.headers["key"] = "café"

  315.         self.assertIn("café".encode("latin-1"), r.serialize_headers())

  316. 

  317.         # Other Unicode values are MIME-encoded (there's no way to pass them as

  318.         # bytes).

  319.         r.headers["key"] = "†"

  320.         self.assertEqual(r.headers["key"], "=?utf-8?b?4oCg?=")

  321.         self.assertIn(b"=?utf-8?b?4oCg?=", r.serialize_headers())

  322. 

  323.         # The response also converts string or bytes keys to strings, but requires

  324.         # them to contain ASCII

  325.         r = HttpResponse()

  326.         del r.headers["Content-Type"]

  327.         r.headers["foo"] = "bar"

  328.         headers = list(r.headers.items())

  329.         self.assertEqual(len(headers), 1)

  330.         self.assertEqual(headers[0], ("foo", "bar"))

  331. 

  332.         r = HttpResponse()

  333.         del r.headers["Content-Type"]

  334.         r.headers[b"foo"] = "bar"

  335.         headers = list(r.headers.items())

  336.         self.assertEqual(len(headers), 1)

  337.         self.assertEqual(headers[0], ("foo", "bar"))

  338.         self.assertIsInstance(headers[0][0], str)

  339. 

  340.         r = HttpResponse()

  341.         with self.assertRaises(UnicodeError):

  342.             r.headers.__setitem__("føø", "bar")

  343.         with self.assertRaises(UnicodeError):

  344.             r.headers.__setitem__("føø".encode(), "bar")

  345. 

  346.     def test_long_line(self):

  347.         # Bug #20889: long lines trigger newlines to be added to headers

  348.         # (which is not allowed due to bug #10188)

  349.         h = HttpResponse()

  350.         f = b"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz a\xcc\x88"

  351.         f = f.decode("utf-8")

  352.         h.headers["Content-Disposition"] = 'attachment; filename="%s"' % f

  353.         # This one is triggering https://bugs.python.org/issue20747, that is Python

  354.         # will itself insert a newline in the header

  355.         h.headers[

  356.             "Content-Disposition"

  357.         ] = 'attachment; filename="EdelRot_Blu\u0308te (3)-0.JPG"'

  358. 

  359.     def test_newlines_in_headers(self):

  360.         # Bug #10188: Do not allow newlines in headers (CR or LF)

  361.         r = HttpResponse()

  362.         with self.assertRaises(BadHeaderError):

  363.             r.headers.__setitem__("test\rstr", "test")

  364.         with self.assertRaises(BadHeaderError):

  365.             r.headers.__setitem__("test\nstr", "test")

  366. 

  367.     def test_encoded_with_newlines_in_headers(self):

  368.         """

  369.         Keys & values which throw a UnicodeError when encoding/decoding should

  370.         still be checked for newlines and re-raised as a BadHeaderError.

  371.         These specifically would still throw BadHeaderError after decoding

  372.         successfully, because the newlines are sandwiched in the middle of the

  373.         string and email.Header leaves those as they are.

  374.         """

  375.         r = HttpResponse()

  376.         pairs = (

  377.             ("†\nother", "test"),

  378.             ("test", "†\nother"),

  379.             (b"\xe2\x80\xa0\nother", "test"),

  380.             ("test", b"\xe2\x80\xa0\nother"),

  381.         )

  382.         msg = "Header values can't contain newlines"

  383.         for key, value in pairs:

  384.             with self.subTest(key=key, value=value):

  385.                 with self.assertRaisesMessage(BadHeaderError, msg):

  386.                     r[key] = value

  387. 

  388.     def test_dict_behavior(self):

  389.         """

  390.         Test for bug #14020: Make HttpResponse.get work like dict.get

  391.         """

  392.         r = HttpResponse()

  393.         self.assertIsNone(r.get("test"))

  394. 

  395.     def test_non_string_content(self):

  396.         # Bug 16494: HttpResponse should behave consistently with non-strings

  397.         r = HttpResponse(12345)

  398.         self.assertEqual(r.content, b"12345")

  399. 

  400.         # test content via property

  401.         r = HttpResponse()

  402.         r.content = 12345

  403.         self.assertEqual(r.content, b"12345")

  404. 

  405.     def test_memoryview_content(self):

  406.         r = HttpResponse(memoryview(b"memoryview"))

  407.         self.assertEqual(r.content, b"memoryview")

  408. 

  409.     def test_iter_content(self):

  410.         r = HttpResponse(["abc", "def", "ghi"])

  411.         self.assertEqual(r.content, b"abcdefghi")

  412. 

  413.         # test iter content via property

  414.         r = HttpResponse()

  415.         r.content = ["idan", "alex", "jacob"]

  416.         self.assertEqual(r.content, b"idanalexjacob")

  417. 

  418.         r = HttpResponse()

  419.         r.content = [1, 2, 3]

  420.         self.assertEqual(r.content, b"123")

  421. 

  422.         # test odd inputs

  423.         r = HttpResponse()

  424.         r.content = ["1", "2", 3, "\u079e"]

  425.         # '\xde\x9e' == unichr(1950).encode()

  426.         self.assertEqual(r.content, b"123\xde\x9e")

  427. 

  428.         # .content can safely be accessed multiple times.

  429.         r = HttpResponse(iter(["hello", "world"]))

  430.         self.assertEqual(r.content, r.content)

  431.         self.assertEqual(r.content, b"helloworld")

  432.         # __iter__ can safely be called multiple times (#20187).

  433.         self.assertEqual(b"".join(r), b"helloworld")

  434.         self.assertEqual(b"".join(r), b"helloworld")

  435.         # Accessing .content still works.

  436.         self.assertEqual(r.content, b"helloworld")

  437. 

  438.         # Accessing .content also works if the response was iterated first.

  439.         r = HttpResponse(iter(["hello", "world"]))

  440.         self.assertEqual(b"".join(r), b"helloworld")

  441.         self.assertEqual(r.content, b"helloworld")

  442. 

  443.         # Additional content can be written to the response.

  444.         r = HttpResponse(iter(["hello", "world"]))

  445.         self.assertEqual(r.content, b"helloworld")

  446.         r.write("!")

  447.         self.assertEqual(r.content, b"helloworld!")

  448. 

  449.     def test_iterator_isnt_rewound(self):

  450.         # Regression test for #13222

  451.         r = HttpResponse("abc")

  452.         i = iter(r)

  453.         self.assertEqual(list(i), [b"abc"])

  454.         self.assertEqual(list(i), [])

  455. 

  456.     def test_lazy_content(self):

  457.         r = HttpResponse(lazystr("helloworld"))

  458.         self.assertEqual(r.content, b"helloworld")

  459. 

  460.     def test_file_interface(self):

  461.         r = HttpResponse()

  462.         r.write(b"hello")

  463.         self.assertEqual(r.tell(), 5)

  464.         r.write("привет")

  465.         self.assertEqual(r.tell(), 17)

  466. 

  467.         r = HttpResponse(["abc"])

  468.         r.write("def")

  469.         self.assertEqual(r.tell(), 6)

  470.         self.assertEqual(r.content, b"abcdef")

  471. 

  472.         # with Content-Encoding header

  473.         r = HttpResponse()

  474.         r.headers["Content-Encoding"] = "winning"

  475.         r.write(b"abc")

  476.         r.write(b"def")

  477.         self.assertEqual(r.content, b"abcdef")

  478. 

  479.     def test_stream_interface(self):

  480.         r = HttpResponse("asdf")

  481.         self.assertEqual(r.getvalue(), b"asdf")

  482. 

  483.         r = HttpResponse()

  484.         self.assertIs(r.writable(), True)

  485.         r.writelines(["foo\n", "bar\n", "baz\n"])

  486.         self.assertEqual(r.content, b"foo\nbar\nbaz\n")

  487. 

  488.     def test_unsafe_redirect(self):

  489.         bad_urls = [

  490.             'data:text/html,<script>window.alert("xss")</script>',

  491.             "mailto:[email protected]",

  492.             "file:///etc/passwd",

  493.         ]

  494.         for url in bad_urls:

  495.             with self.assertRaises(DisallowedRedirect):

  496.                 HttpResponseRedirect(url)

  497.             with self.assertRaises(DisallowedRedirect):

  498.                 HttpResponsePermanentRedirect(url)

  499. 

  500.     def test_header_deletion(self):

  501.         r = HttpResponse("hello")

  502.         r.headers["X-Foo"] = "foo"

  503.         del r.headers["X-Foo"]

  504.         self.assertNotIn("X-Foo", r.headers)

  505.         # del doesn't raise a KeyError on nonexistent headers.

  506.         del r.headers["X-Foo"]

  507. 

  508.     def test_instantiate_with_headers(self):

  509.         r = HttpResponse("hello", headers={"X-Foo": "foo"})

  510.         self.assertEqual(r.headers["X-Foo"], "foo")

  511.         self.assertEqual(r.headers["x-foo"], "foo")

  512. 

  513.     def test_content_type(self):

  514.         r = HttpResponse("hello", content_type="application/json")

  515.         self.assertEqual(r.headers["Content-Type"], "application/json")

  516. 

  517.     def test_content_type_headers(self):

  518.         r = HttpResponse("hello", headers={"Content-Type": "application/json"})

  519.         self.assertEqual(r.headers["Content-Type"], "application/json")

  520. 

  521.     def test_content_type_mutually_exclusive(self):

  522.         msg = (

  523.             "'headers' must not contain 'Content-Type' when the "

  524.             "'content_type' parameter is provided."

  525.         )

  526.         with self.assertRaisesMessage(ValueError, msg):

  527.             HttpResponse(

  528.                 "hello",

  529.                 content_type="application/json",

  530.                 headers={"Content-Type": "text/csv"},

  531.             )

  532. 

  533. 

  534. class HttpResponseSubclassesTests(SimpleTestCase):

  535.     def test_redirect(self):

  536.         response = HttpResponseRedirect("/redirected/")

  537.         self.assertEqual(response.status_code, 302)

  538.         # Standard HttpResponse init args can be used

  539.         response = HttpResponseRedirect(

  540.             "/redirected/",

  541.             content="The resource has temporarily moved",

  542.         )

  543.         self.assertContains(

  544.             response, "The resource has temporarily moved", status_code=302

  545.         )

  546.         self.assertEqual(response.url, response.headers["Location"])

  547. 

  548.     def test_redirect_lazy(self):

  549.         """Make sure HttpResponseRedirect works with lazy strings."""

  550.         r = HttpResponseRedirect(lazystr("/redirected/"))

  551.         self.assertEqual(r.url, "/redirected/")

  552. 

  553.     def test_redirect_repr(self):

  554.         response = HttpResponseRedirect("/redirected/")

  555.         expected = (

  556.             '<HttpResponseRedirect status_code=302, "text/html; charset=utf-8", '

  557.             'url="/redirected/">'

  558.         )

  559.         self.assertEqual(repr(response), expected)

  560. 

  561.     def test_invalid_redirect_repr(self):

  562.         """

  563.         If HttpResponseRedirect raises DisallowedRedirect, its __repr__()

  564.         should work (in the debug view, for example).

  565.         """

  566.         response = HttpResponseRedirect.__new__(HttpResponseRedirect)

  567.         with self.assertRaisesMessage(

  568.             DisallowedRedirect, "Unsafe redirect to URL with protocol 'ssh'"

  569.         ):

  570.             HttpResponseRedirect.__init__(response, "ssh://foo")

  571.         expected = (

  572.             '<HttpResponseRedirect status_code=302, "text/html; charset=utf-8", '

  573.             'url="ssh://foo">'

  574.         )

  575.         self.assertEqual(repr(response), expected)

  576. 

  577.     def test_not_modified(self):

  578.         response = HttpResponseNotModified()

  579.         self.assertEqual(response.status_code, 304)

  580.         # 304 responses should not have content/content-type

  581.         with self.assertRaises(AttributeError):

  582.             response.content = "Hello dear"

  583.         self.assertNotIn("content-type", response)

  584. 

  585.     def test_not_modified_repr(self):

  586.         response = HttpResponseNotModified()

  587.         self.assertEqual(repr(response), "<HttpResponseNotModified status_code=304>")

  588. 

  589.     def test_not_allowed(self):

  590.         response = HttpResponseNotAllowed(["GET"])

  591.         self.assertEqual(response.status_code, 405)

  592.         # Standard HttpResponse init args can be used

  593.         response = HttpResponseNotAllowed(

  594.             ["GET"], content="Only the GET method is allowed"

  595.         )

  596.         self.assertContains(response, "Only the GET method is allowed", status_code=405)

  597. 

  598.     def test_not_allowed_repr(self):

  599.         response = HttpResponseNotAllowed(["GET", "OPTIONS"], content_type="text/plain")

  600.         expected = (

  601.             '<HttpResponseNotAllowed [GET, OPTIONS] status_code=405, "text/plain">'

  602.         )

  603.         self.assertEqual(repr(response), expected)

  604. 

  605.     def test_not_allowed_repr_no_content_type(self):

  606.         response = HttpResponseNotAllowed(("GET", "POST"))

  607.         del response.headers["Content-Type"]

  608.         self.assertEqual(

  609.             repr(response), "<HttpResponseNotAllowed [GET, POST] status_code=405>"

  610.         )

  611. 

  612. 

  613. class JsonResponseTests(SimpleTestCase):

  614.     def test_json_response_non_ascii(self):

  615.         data = {"key": "łóżko"}

  616.         response = JsonResponse(data)

  617.         self.assertEqual(json.loads(response.content.decode()), data)

  618. 

  619.     def test_json_response_raises_type_error_with_default_setting(self):

  620.         with self.assertRaisesMessage(

  621.             TypeError,

  622.             "In order to allow non-dict objects to be serialized set the "

  623.             "safe parameter to False",

  624.         ):

  625.             JsonResponse([1, 2, 3])

  626. 

  627.     def test_json_response_text(self):

  628.         response = JsonResponse("foobar", safe=False)

  629.         self.assertEqual(json.loads(response.content.decode()), "foobar")

  630. 

  631.     def test_json_response_list(self):

  632.         response = JsonResponse(["foo", "bar"], safe=False)

  633.         self.assertEqual(json.loads(response.content.decode()), ["foo", "bar"])

  634. 

  635.     def test_json_response_uuid(self):

  636.         u = uuid.uuid4()

  637.         response = JsonResponse(u, safe=False)

  638.         self.assertEqual(json.loads(response.content.decode()), str(u))

  639. 

  640.     def test_json_response_custom_encoder(self):

  641.         class CustomDjangoJSONEncoder(DjangoJSONEncoder):

  642.             def encode(self, o):

  643.                 return json.dumps({"foo": "bar"})

  644. 

  645.         response = JsonResponse({}, encoder=CustomDjangoJSONEncoder)

  646.         self.assertEqual(json.loads(response.content.decode()), {"foo": "bar"})

  647. 

  648.     def test_json_response_passing_arguments_to_json_dumps(self):

  649.         response = JsonResponse({"foo": "bar"}, json_dumps_params={"indent": 2})

  650.         self.assertEqual(response.content.decode(), '{\n  "foo": "bar"\n}')

  651. 

  652. 

  653. class StreamingHttpResponseTests(SimpleTestCase):

  654.     def test_streaming_response(self):

  655.         r = StreamingHttpResponse(iter(["hello", "world"]))

  656. 

  657.         # iterating over the response itself yields bytestring chunks.

  658.         chunks = list(r)

  659.         self.assertEqual(chunks, [b"hello", b"world"])

  660.         for chunk in chunks:

  661.             self.assertIsInstance(chunk, bytes)

  662. 

  663.         # and the response can only be iterated once.

  664.         self.assertEqual(list(r), [])

  665. 

  666.         # even when a sequence that can be iterated many times, like a list,

  667.         # is given as content.

  668.         r = StreamingHttpResponse(["abc", "def"])

  669.         self.assertEqual(list(r), [b"abc", b"def"])

  670.         self.assertEqual(list(r), [])

  671. 

  672.         # iterating over strings still yields bytestring chunks.

  673.         r.streaming_content = iter(["hello", "café"])

  674.         chunks = list(r)

  675.         # '\xc3\xa9' == unichr(233).encode()

  676.         self.assertEqual(chunks, [b"hello", b"caf\xc3\xa9"])

  677.         for chunk in chunks:

  678.             self.assertIsInstance(chunk, bytes)

  679. 

  680.         # streaming responses don't have a `content` attribute.

  681.         self.assertFalse(hasattr(r, "content"))

  682. 

  683.         # and you can't accidentally assign to a `content` attribute.

  684.         with self.assertRaises(AttributeError):

  685.             r.content = "xyz"

  686. 

  687.         # but they do have a `streaming_content` attribute.

  688.         self.assertTrue(hasattr(r, "streaming_content"))

  689. 

  690.         # that exists so we can check if a response is streaming, and wrap or

  691.         # replace the content iterator.

  692.         r.streaming_content = iter(["abc", "def"])

  693.         r.streaming_content = (chunk.upper() for chunk in r.streaming_content)

  694.         self.assertEqual(list(r), [b"ABC", b"DEF"])

  695. 

  696.         # coercing a streaming response to bytes doesn't return a complete HTTP

  697.         # message like a regular response does. it only gives us the headers.

  698.         r = StreamingHttpResponse(iter(["hello", "world"]))

  699.         self.assertEqual(bytes(r), b"Content-Type: text/html; charset=utf-8")

  700. 

  701.         # and this won't consume its content.

  702.         self.assertEqual(list(r), [b"hello", b"world"])

  703. 

  704.         # additional content cannot be written to the response.

  705.         r = StreamingHttpResponse(iter(["hello", "world"]))

  706.         with self.assertRaises(Exception):

  707.             r.write("!")

  708. 

  709.         # and we can't tell the current position.

  710.         with self.assertRaises(Exception):

  711.             r.tell()

  712. 

  713.         r = StreamingHttpResponse(iter(["hello", "world"]))

  714.         self.assertEqual(r.getvalue(), b"helloworld")

  715. 

  716.     def test_repr(self):

  717.         r = StreamingHttpResponse(iter(["hello", "café"]))

  718.         self.assertEqual(

  719.             repr(r),

  720.             '<StreamingHttpResponse status_code=200, "text/html; charset=utf-8">',

  721.         )

  722. 

  723. 

  724. class FileCloseTests(SimpleTestCase):

  725.     def setUp(self):

  726.         # Disable the request_finished signal during this test

  727.         # to avoid interfering with the database connection.

  728.         request_finished.disconnect(close_old_connections)

  729. 

  730.     def tearDown(self):

  731.         request_finished.connect(close_old_connections)

  732. 

  733.     def test_response(self):

  734.         filename = os.path.join(os.path.dirname(__file__), "abc.txt")

  735. 

  736.         # file isn't closed until we close the response.

  737.         file1 = open(filename)

  738.         r = HttpResponse(file1)

  739.         self.assertTrue(file1.closed)

  740.         r.close()

  741. 

  742.         # when multiple file are assigned as content, make sure they are all

  743.         # closed with the response.

  744.         file1 = open(filename)

  745.         file2 = open(filename)

  746.         r = HttpResponse(file1)

  747.         r.content = file2

  748.         self.assertTrue(file1.closed)

  749.         self.assertTrue(file2.closed)

  750. 

  751.     def test_streaming_response(self):

  752.         filename = os.path.join(os.path.dirname(__file__), "abc.txt")

  753. 

  754.         # file isn't closed until we close the response.

  755.         file1 = open(filename)

  756.         r = StreamingHttpResponse(file1)

  757.         self.assertFalse(file1.closed)

  758.         r.close()

  759.         self.assertTrue(file1.closed)

  760. 

  761.         # when multiple file are assigned as content, make sure they are all

  762.         # closed with the response.

  763.         file1 = open(filename)

  764.         file2 = open(filename)

  765.         r = StreamingHttpResponse(file1)

  766.         r.streaming_content = file2

  767.         self.assertFalse(file1.closed)

  768.         self.assertFalse(file2.closed)

  769.         r.close()

  770.         self.assertTrue(file1.closed)

  771.         self.assertTrue(file2.closed)

  772. 

  773. 

  774. class CookieTests(unittest.TestCase):

  775.     def test_encode(self):

  776.         """Semicolons and commas are encoded."""

  777.         c = SimpleCookie()

  778.         c["test"] = "An,awkward;value"

  779.         self.assertNotIn(";", c.output().rstrip(";"))  # IE compat

  780.         self.assertNotIn(",", c.output().rstrip(";"))  # Safari compat

  781. 

  782.     def test_decode(self):

  783.         """Semicolons and commas are decoded."""

  784.         c = SimpleCookie()

  785.         c["test"] = "An,awkward;value"

  786.         c2 = SimpleCookie()

  787.         c2.load(c.output()[12:])

  788.         self.assertEqual(c["test"].value, c2["test"].value)

  789.         c3 = parse_cookie(c.output()[12:])

  790.         self.assertEqual(c["test"].value, c3["test"])

  791. 

  792.     def test_nonstandard_keys(self):

  793.         """

  794.         A single non-standard cookie name doesn't affect all cookies (#13007).

  795.         """

  796.         self.assertIn("good_cookie", parse_cookie("good_cookie=yes;bad:cookie=yes"))

  797. 

  798.     def test_repeated_nonstandard_keys(self):

  799.         """

  800.         A repeated non-standard name doesn't affect all cookies (#15852).

  801.         """

  802.         self.assertIn("good_cookie", parse_cookie("a:=b; a:=c; good_cookie=yes"))

  803. 

  804.     def test_python_cookies(self):

  805.         """

  806.         Test cases copied from Python's Lib/test/test_http_cookies.py

  807.         """

  808.         self.assertEqual(

  809.             parse_cookie("chips=ahoy; vienna=finger"),

  810.             {"chips": "ahoy", "vienna": "finger"},

  811.         )

  812.         # Here parse_cookie() differs from Python's cookie parsing in that it

  813.         # treats all semicolons as delimiters, even within quotes.

  814.         self.assertEqual(

  815.             parse_cookie('keebler="E=mc2; L=\\"Loves\\"; fudge=\\012;"'),

  816.             {"keebler": '"E=mc2', "L": '\\"Loves\\"', "fudge": "\\012", "": '"'},

  817.         )

  818.         # Illegal cookies that have an '=' char in an unquoted value.

  819.         self.assertEqual(parse_cookie("keebler=E=mc2"), {"keebler": "E=mc2"})

  820.         # Cookies with ':' character in their name.

  821.         self.assertEqual(

  822.             parse_cookie("key:term=value:term"), {"key:term": "value:term"}

  823.         )

  824.         # Cookies with '[' and ']'.

  825.         self.assertEqual(

  826.             parse_cookie("a=b; c=[; d=r; f=h"), {"a": "b", "c": "[", "d": "r", "f": "h"}

  827.         )

  828. 

  829.     def test_cookie_edgecases(self):

  830.         # Cookies that RFC6265 allows.

  831.         self.assertEqual(

  832.             parse_cookie("a=b; Domain=example.com"), {"a": "b", "Domain": "example.com"}

  833.         )

  834.         # parse_cookie() has historically kept only the last cookie with the

  835.         # same name.

  836.         self.assertEqual(parse_cookie("a=b; h=i; a=c"), {"a": "c", "h": "i"})

  837. 

  838.     def test_invalid_cookies(self):

  839.         """

  840.         Cookie strings that go against RFC6265 but browsers will send if set

  841.         via document.cookie.

  842.         """

  843.         # Chunks without an equals sign appear as unnamed values per

  844.         # https://bugzilla.mozilla.org/show_bug.cgi?id=169091

  845.         self.assertIn(

  846.             "django_language", parse_cookie("abc=def; unnamed; django_language=en")

  847.         )

  848.         # Even a double quote may be an unnamed value.

  849.         self.assertEqual(parse_cookie('a=b; "; c=d'), {"a": "b", "": '"', "c": "d"})

  850.         # Spaces in names and values, and an equals sign in values.

  851.         self.assertEqual(

  852.             parse_cookie("a b c=d e = f; gh=i"), {"a b c": "d e = f", "gh": "i"}

  853.         )

  854.         # More characters the spec forbids.

  855.         self.assertEqual(

  856.             parse_cookie('a   b,c<>@:/[]?{}=d  "  =e,f g'),

  857.             {"a   b,c<>@:/[]?{}": 'd  "  =e,f g'},

  858.         )

  859.         # Unicode characters. The spec only allows ASCII.

  860.         self.assertEqual(

  861.             parse_cookie("saint=André Bessette"), {"saint": "André Bessette"}

  862.         )

  863.         # Browsers don't send extra whitespace or semicolons in Cookie headers,

  864.         # but parse_cookie() should parse whitespace the same way

  865.         # document.cookie parses whitespace.

  866.         self.assertEqual(

  867.             parse_cookie("  =  b  ;  ;  =  ;   c  =  ;  "), {"": "b", "c": ""}

  868.         )

  869. 

  870.     def test_samesite(self):

  871.         c = SimpleCookie("name=value; samesite=lax; httponly")

  872.         self.assertEqual(c["name"]["samesite"], "lax")

  873.         self.assertIn("SameSite=lax", c.output())

  874. 

  875.     def test_httponly_after_load(self):

  876.         c = SimpleCookie()

  877.         c.load("name=val")

  878.         c["name"]["httponly"] = True

  879.         self.assertTrue(c["name"]["httponly"])

  880. 

  881.     def test_load_dict(self):

  882.         c = SimpleCookie()

  883.         c.load({"name": "val"})

  884.         self.assertEqual(c["name"].value, "val")

  885. 

  886.     def test_pickle(self):

  887.         rawdata = 'Customer="WILE_E_COYOTE"; Path=/acme; Version=1'

  888.         expected_output = "Set-Cookie: %s" % rawdata

  889. 

  890.         C = SimpleCookie()

  891.         C.load(rawdata)

  892.         self.assertEqual(C.output(), expected_output)

  893. 

  894.         for proto in range(pickle.HIGHEST_PROTOCOL + 1):

  895.             C1 = pickle.loads(pickle.dumps(C, protocol=proto))

  896.             self.assertEqual(C1.output(), expected_output)

  897. 

  898. 

  899. class HttpResponseHeadersTestCase(SimpleTestCase):

  900.     """Headers by treating HttpResponse like a dictionary."""

  901. 

  902.     def test_headers(self):

  903.         response = HttpResponse()

  904.         response["X-Foo"] = "bar"

  905.         self.assertEqual(response["X-Foo"], "bar")

  906.         self.assertEqual(response.headers["X-Foo"], "bar")

  907.         self.assertIn("X-Foo", response)

  908.         self.assertIs(response.has_header("X-Foo"), True)

  909.         del response["X-Foo"]

  910.         self.assertNotIn("X-Foo", response)

  911.         self.assertNotIn("X-Foo", response.headers)

  912.         # del doesn't raise a KeyError on nonexistent headers.

  913.         del response["X-Foo"]

  914. 

  915.     def test_headers_as_iterable_of_tuple_pairs(self):

  916.         response = HttpResponse(headers=(("X-Foo", "bar"),))

  917.         self.assertEqual(response["X-Foo"], "bar")

  918. 

  919.     def test_headers_bytestring(self):

  920.         response = HttpResponse()

  921.         response["X-Foo"] = b"bar"

  922.         self.assertEqual(response["X-Foo"], "bar")

  923.         self.assertEqual(response.headers["X-Foo"], "bar")

  924. 

  925.     def test_newlines_in_headers(self):

  926.         response = HttpResponse()

  927.         with self.assertRaises(BadHeaderError):

  928.             response["test\rstr"] = "test"

  929.         with self.assertRaises(BadHeaderError):

  930.             response["test\nstr"] = "test"
About Sign Up Leave Feedback Contact