def test_from_text_file():
res = Response("test")
inp = io.StringIO(text_(str(res), "utf-8"))
equal_resp(res, inp)
res = Response(app_iter=iter([b"test ", b"body"]),
content_type="text/plain")
inp = io.StringIO(text_(str(res), "utf-8"))
equal_resp(res, inp)
def test_response():
req = BaseRequest.blank("/")
res = req.get_response(simple_app)
assert res.status == "200 OK"
assert res.status_code == 200
assert res.body == "OK"
assert res.charset == "UTF-8"
assert res.content_type == "text/html"
res.status = 404
assert res.status == "404 Not Found"
assert res.status_code == 404
res.body = b"Not OK"
assert b"".join(res.app_iter) == b"Not OK"
res.charset = "iso8859-1"
assert "text/html; charset=iso8859-1" == res.headers["content-type"]
res.content_type = "text/xml"
assert "text/xml; charset=UTF-8" == res.headers["content-type"]
res.content_type = "text/xml; charset=UTF-8"
assert "text/xml; charset=UTF-8" == res.headers["content-type"]
res.headers = {"content-type": "text/html"}
assert res.headers["content-type"] == "text/html"
assert res.headerlist == [("content-type", "text/html")]
res.set_cookie("x", "y")
assert res.headers["set-cookie"].strip(";") == "x=y; Path=/"
res.set_cookie(text_("x"), text_("y"))
assert res.headers["set-cookie"].strip(";") == "x=y; Path=/"
res = Response("a body", "200 OK", content_type="text/html")
res.encode_content()
assert res.content_encoding == "gzip"
assert (
res.body ==
b"\x1f\x8b\x08\x00\x00\x00\x00\x00\x02\xffKTH\xcaO\xa9\x04\x00\xf6\x86GI\x06\x00\x00\x00"
)
res.decode_content()
assert res.content_encoding is None
assert res.body == b"a body"
res.set_cookie("x", text_(b"foo")) # test unicode value
with pytest.raises(TypeError):
Response(app_iter=iter(["a"]), body="somebody")
del req.environ
with pytest.raises(TypeError):
Response(charset=None,
content_type="image/jpeg",
body=text_(b"unicode body"))
with pytest.raises(TypeError):
Response(wrong_key="dummy")
with pytest.raises(TypeError):
resp = Response()
resp.body = text_(b"unicode body")
def test_from_fieldstorage_with_quoted_printable_encoding(self):
from cgi import FieldStorage
from webob.multidict import MultiDict
from webob.request import BaseRequest
multipart_type = "multipart/form-data; boundary=foobar"
from io import BytesIO
body = (b"--foobar\r\n"
b'Content-Disposition: form-data; name="title"\r\n'
b'Content-type: text/plain; charset="ISO-2022-JP"\r\n'
b"Content-Transfer-Encoding: quoted-printable\r\n"
b"\r\n"
b"=1B$B$3$s$K$A$O=1B(B"
b"\r\n"
b"--foobar--")
multipart_body = BytesIO(body)
environ = BaseRequest.blank("/").environ
environ.update(CONTENT_TYPE=multipart_type)
environ.update(REQUEST_METHOD="POST")
environ.update(CONTENT_LENGTH=len(body))
fs = FieldStorage(multipart_body, environ=environ)
vars = MultiDict.from_fieldstorage(fs)
self.assertEqual(vars["title"].encode("utf8"),
text_("こんにちは", "utf8").encode("utf8"))
def test_content_type_has_charset():
res = Response(content_type="application/foo; charset=UTF-8",
body=text_(b"test"))
assert res.body == b"test"
assert res.content_type == "application/foo"
assert res.charset == "UTF-8"
assert res.headers["Content-Type"] == "application/foo; charset=UTF-8"
def serialize(self, full=True):
result = []
add = result.append
add(self.name + b"=" + _value_quote(self.value))
if full:
for k in _c_valkeys:
v = self[k]
if v:
info = _c_renames[k]
name = info["name"]
quoter = info["quoter"]
add(name + b"=" + quoter(v))
expires = self[b"expires"]
if expires:
add(b"expires=" + expires)
if self.secure:
add(b"secure")
if self.httponly:
add(b"HttpOnly")
if self.samesite:
if not self.secure and self.samesite.lower() == b"none":
raise ValueError(
"Incompatible cookie attributes: "
"when the samesite equals 'none', then the secure must be True"
)
add(b"SameSite=" + self.samesite)
return text_(b"; ".join(result), "ascii")
def test_doesnt_raise_with_charset_content_type_has_no_charset():
res = Response(content_type="image/jpeg",
body=text_(b"test"),
charset="utf-8")
assert res.body == b"test"
assert res.content_type == "image/jpeg"
assert res.charset is None
def test_header_getter_fset_text():
from webob import Response
from webob.descriptors import header_getter
resp = Response("aresp")
desc = header_getter("AHEADER", "14.3")
desc.fset(resp, text_("avalue"))
assert desc.fget(resp) == "avalue"
def test_unset_cookie_key_in_cookies():
res = Response()
res.headers.add("Set-Cookie", "a=2; Path=/")
res.headers.add("Set-Cookie", "b=3; Path=/")
res.unset_cookie("a")
assert res.headers.getall("Set-Cookie") == ["b=3; Path=/"]
res.unset_cookie(text_("b"))
assert res.headers.getall("Set-Cookie") == []
def test_header_getter_fset_text_control_chars():
from webob import Response
from webob.descriptors import header_getter
resp = Response("aresp")
desc = header_getter("AHEADER", "14.3")
with pytest.raises(ValueError):
desc.fset(resp, text_("\n"))
def no_escape(value):
if value is None:
return ""
if not isinstance(value, str):
if isinstance(value, bytes):
value = text_(value, "utf-8")
else:
value = str(value)
return value
def test_unicode_body():
res = Response()
res.charset = "utf-8"
bbody = b"La Pe\xc3\xb1a" # binary string
ubody = text_(bbody, "utf-8") # unicode string
res.body = bbody
assert res.unicode_body == ubody
res.ubody = ubody
assert res.body == bbody
del res.ubody
assert res.body == b""
def tapp(env, sr):
req = Request(env)
req = req.decode()
v = req.POST[req.query_string]
if hasattr(v, "filename"):
r = Response(text_("%s\n%r" % (v.filename, v.value)))
else:
r = Response(v)
return r(env, sr)
def test_serialize_cookie_date():
"""
Testing webob.cookies.serialize_cookie_date.
Missing scenarios:
* input value is an str, should be returned verbatim
* input value is an int, should be converted to timedelta and we
should continue the rest of the process
"""
date_one = cookies.serialize_cookie_date(b"Tue, 04-Jan-2011 13:43:50 GMT")
assert date_one == b"Tue, 04-Jan-2011 13:43:50 GMT"
date_two = cookies.serialize_cookie_date(text_("Tue, 04-Jan-2011 13:43:50 GMT"))
assert date_two == b"Tue, 04-Jan-2011 13:43:50 GMT"
assert cookies.serialize_cookie_date(None) is None
cdate_delta = cookies.serialize_cookie_date(timedelta(seconds=10))
cdate_int = cookies.serialize_cookie_date(10)
assert cdate_delta == cdate_int
def test_unicode_cookies_warning_issued():
import warnings
cookies._should_raise = False
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
# Trigger a warning.
res = Response()
res.set_cookie("x", text_(b"\\N{BLACK SQUARE}", "unicode_escape"))
assert len(w) == 1
assert issubclass(w[-1].category, RuntimeWarning) is True
assert "ValueError" in str(w[-1].message)
cookies._should_raise = True
def _mutate_header(self, name, value):
header = self._environ.get("HTTP_COOKIE")
had_header = header is not None
header = header or ""
header = header.encode("latin-1")
bytes_name = bytes_(name, "ascii")
if value is None:
replacement = None
else:
bytes_val = _value_quote(bytes_(value, "utf-8"))
replacement = bytes_name + b"=" + bytes_val
matches = _rx_cookie.finditer(header)
found = False
for match in matches:
start, end = match.span()
match_name = match.group(1)
if match_name == bytes_name:
found = True
if replacement is None: # remove value
header = header[:start].rstrip(b" ;") + header[end:]
else: # replace value
header = header[:start] + replacement + header[end:]
break
else:
if replacement is not None:
if header:
header += b"; " + replacement
else:
header = replacement
if header:
self._environ["HTTP_COOKIE"] = text_(header, "latin-1")
elif had_header:
self._environ["HTTP_COOKIE"] = ""
return found
def serialize_date(dt):
if isinstance(dt, (bytes, str)):
return text_(dt)
if isinstance(dt, timedelta):
dt = _now() + dt
if isinstance(dt, (datetime, date)):
dt = dt.timetuple()
if isinstance(dt, (tuple, time.struct_time)):
dt = calendar.timegm(dt)
if not (isinstance(dt, float) or isinstance(dt, int)):
raise ValueError(
"You must pass in a datetime, date, time tuple, or integer object, "
"not %r" % dt
)
return formatdate(dt, usegmt=True)
def test_serialize_date():
"""Testing datetime_utils.serialize_date
We need to verify the following scenarios:
* on py3, passing an binary date, return the same date but str
* on py2, passing an unicode date, return the same date but str
* passing a timedelta, return now plus the delta
* passing an invalid object, should raise ValueError
"""
from webob.util import text_
ret = datetime_utils.serialize_date("Mon, 20 Nov 1995 19:12:08 GMT")
assert isinstance(ret, str)
assert ret == "Mon, 20 Nov 1995 19:12:08 GMT"
ret = datetime_utils.serialize_date(text_("Mon, 20 Nov 1995 19:12:08 GMT"))
assert isinstance(ret, str)
assert ret == "Mon, 20 Nov 1995 19:12:08 GMT"
dt = formatdate(
calendar.timegm(
(datetime.datetime.now() + datetime.timedelta(1)).timetuple()),
usegmt=True,
)
assert dt == datetime_utils.serialize_date(datetime.timedelta(1))
with pytest.raises(ValueError):
datetime_utils.serialize_date(None)
def test_text_set_no_charset():
res = Response()
res.charset = None
res.text = text_("abc")
assert res.text == "abc"
def test_fget_nonascii(self):
desc = self._callFUT("HTTP_X_AKEY", encattr="url_encoding")
req = self._makeRequest()
req.environ["HTTP_X_AKEY"] = str(b"\xc3\xab", "latin-1")
result = desc.fget(req)
assert result == text_(b"\xc3\xab", "utf-8")
def setUp(self):
self._list = [("a", text_("\xe9")), ("a", "e"), ("a", "f"), ("b", "1")]
self.data = multidict.MultiDict(self._list)
self.d = self._get_instance()
def test_dict_of_lists(self):
self.assertEqual(self.d.dict_of_lists(), {
"a": [text_("\xe9"), "e", "f"],
"b": ["1"]
})
def items(self):
return [("a", text_("\xe9")), ("a", "e"), ("a", "f"), ("b", 1)]
def test_body_set_unicode():
res = Response()
with pytest.raises(TypeError):
res.__setattr__("body", text_(b"abc"))
def test_write_text():
res = Response()
res.body = b"abc"
assert res.write(text_(b"a")) == 1
assert res.text == "abca"
def test_write_unicode_no_charset():
res = Response(charset=None)
with pytest.raises(TypeError):
res.write(text_(b"a"))
def test_write_unicode():
res = Response()
res.text = text_(b"La Pe\xc3\xb1a", "utf-8")
assert res.write(text_(b"a")) == 1
assert res.text, text_(b"La Pe\xc3\xb1aa" == "utf-8")
def test_transcode_non_multipart():
req = Request.blank("/?a", POST="%EF%F0%E8=%E2%E5%F2")
req._content_type_raw = "application/x-www-form-urlencoded"
req2 = req.decode("cp1251")
assert text_(req2.body) == "%D0%BF%D1%80%D0%B8=%D0%B2%D0%B5%D1%82"
def test_text_get_decode():
res = Response()
res.charset = "utf-8"
res.body = b"La Pe\xc3\xb1a"
assert res.text, text_(b"La Pe\xc3\xb1a")
def test_transcode_non_form():
req = Request.blank("/?a", POST="%EF%F0%E8=%E2%E5%F2")
req._content_type_raw = "application/x-foo"
req2 = req.decode("cp1251")
assert text_(req2.body) == "%EF%F0%E8=%E2%E5%F2"
def test_text_set_no_default_body_encoding():
res = Response()
res.charset = None
res.default_body_encoding = None
with pytest.raises(AttributeError):
res.text = text_("abc")
