def test_hydrate_from_headers_empty_headers_due_to_filtering(self):
headers = HTTPHeaderDict()
headers.add('asasd', 'sdfsdf')
metadata = MetaData()
metadata_original = copy.deepcopy(metadata)
self.assertEqual(str(sorted(metadata_original.__dict__)),
str(sorted(self.hydrator.hydrate_from_headers(metadata, headers).__dict__)))
def test_from_httplib_py2(self):
msg = """
Server: nginx
Content-Type: text/html; charset=windows-1251
Connection: keep-alive
X-Some-Multiline: asdf
asdf\t
\t asdf
Set-Cookie: bb_lastvisit=1348253375; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
Set-Cookie: bb_lastactivity=0; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
www-authenticate: asdf
www-authenticate: bla
"""
buffer = six.moves.StringIO(msg.lstrip().replace('\n', '\r\n'))
msg = six.moves.http_client.HTTPMessage(buffer)
d = HTTPHeaderDict.from_httplib(msg)
assert d['server'] == 'nginx'
cookies = d.getlist('set-cookie')
assert len(cookies) == 2
assert cookies[0].startswith("bb_lastvisit")
assert cookies[1].startswith("bb_lastactivity")
assert d['x-some-multiline'] == 'asdf asdf asdf'
assert d['www-authenticate'] == 'asdf, bla'
assert d.getlist('www-authenticate') == ['asdf', 'bla']
with_invalid_multiline = """\tthis-is-not-a-header: but it has a pretend value
Authorization: Bearer 123
"""
buffer = six.moves.StringIO(with_invalid_multiline.replace('\n', '\r\n'))
msg = six.moves.http_client.HTTPMessage(buffer)
with pytest.raises(InvalidHeader):
HTTPHeaderDict.from_httplib(msg)
def test_create_from_list(self):
h = HTTPHeaderDict([("ab", "A"), ("cd", "B"), ("cookie", "C"), ("cookie", "D"), ("cookie", "E")])
self.assertEqual(len(h), 3)
self.assertTrue("ab" in h)
clist = h.getlist("cookie")
self.assertEqual(len(clist), 3)
self.assertEqual(clist[0], "C")
self.assertEqual(clist[-1], "E")
def test_create_from_list(self):
h = HTTPHeaderDict([('ab', 'A'), ('cd', 'B'), ('cookie', 'C'), ('cookie', 'D'), ('cookie', 'E')])
self.assertEqual(len(h), 3)
self.assertTrue('ab' in h)
clist = h.getlist('cookie')
self.assertEqual(len(clist), 3)
self.assertEqual(clist[0], 'C')
self.assertEqual(clist[-1], 'E')
def test_add(self):
d = HTTPHeaderDict()
d['A'] = 'foo'
d.add('a', 'bar')
self.assertEqual(d['a'], 'foo, bar')
self.assertEqual(d['A'], 'foo, bar')
def test_create_from_list(self):
headers = [('ab', 'A'), ('cd', 'B'), ('cookie', 'C'), ('cookie', 'D'), ('cookie', 'E')]
h = HTTPHeaderDict(headers)
assert len(h) == 3
assert 'ab' in h
clist = h.getlist('cookie')
assert len(clist) == 3
assert clist[0] == 'C'
assert clist[-1] == 'E'
def test_add_multiple_allowed(self):
d = HTTPHeaderDict()
d['Cookie'] = 'foo'
d.add('cookie', 'bar')
self.assertEqual(d['cookie'], 'foo, bar')
self.assertEqual(d['Cookie'], 'foo, bar')
d.add('cookie', 'asdf')
self.assertEqual(d['cookie'], 'foo, bar, asdf')
def test_filter_system_filtering(self):
system_headers = self.metadata_http_descriptor.get_all_http_headers()
headers = HTTPHeaderDict()
for h in system_headers:
headers.add(h, h.upper())
count_system = len(system_headers)
headers.add('another', 'header')
self.assertEqual(count_system, len(self.metadata_http_headers_filter.filter_system(headers)))
def test_create_from_headerdict(self):
org = HTTPHeaderDict([('ab', 'A'), ('cd', 'B'), ('cookie', 'C'), ('cookie', 'D'), ('cookie', 'E')])
h = HTTPHeaderDict(org)
self.assertEqual(len(h), 3)
self.assertTrue('ab' in h)
clist = h.getlist('cookie')
self.assertEqual(len(clist), 3)
self.assertEqual(clist[0], 'C')
self.assertEqual(clist[-1], 'E')
self.assertFalse(h is org)
self.assertEqual(h, org)
def test_create_from_headerdict(self):
org = HTTPHeaderDict([("ab", "A"), ("cd", "B"), ("cookie", "C"), ("cookie", "D"), ("cookie", "E")])
h = HTTPHeaderDict(org)
self.assertEqual(len(h), 3)
self.assertTrue("ab" in h)
clist = h.getlist("cookie")
self.assertEqual(len(clist), 3)
self.assertEqual(clist[0], "C")
self.assertEqual(clist[-1], "E")
self.assertFalse(h is org)
self.assertEqual(h, org)
def test_create_from_headerdict(self):
headers = [('ab', 'A'), ('cd', 'B'), ('cookie', 'C'), ('cookie', 'D'), ('cookie', 'E')]
org = HTTPHeaderDict(headers)
h = HTTPHeaderDict(org)
assert len(h) == 3
assert 'ab' in h
clist = h.getlist('cookie')
assert len(clist) == 3
assert clist[0] == 'C'
assert clist[-1] == 'E'
assert h is not org
assert h == org
def read_http_start_line_and_headers(payload):
headers = HTTPHeaderDict()
start_line = None
for count, line in enumerate(payload):
if count == 0:
start_line = line
elif line == "\r\n":
break
else:
pos = line.index(":")
assert pos != -1
headers.add(line[:pos], line[pos+1:].strip())
return start_line, headers
class TestHTTPHeaderDict(unittest.TestCase):
def setUp(self):
self.d = HTTPHeaderDict(A='foo')
self.d.add('a', 'bar')
def test_overwriting_with_setitem_replaces(self):
d = HTTPHeaderDict()
d['A'] = 'foo'
self.assertEqual(d['a'], 'foo')
d['a'] = 'bar'
self.assertEqual(d['A'], 'bar')
def test_copy(self):
h = self.d.copy()
self.assertTrue(self.d is not h)
self.assertEqual(self.d, h)
def test_add(self):
d = HTTPHeaderDict()
d['A'] = 'foo'
d.add('a', 'bar')
self.assertEqual(d['a'], 'foo, bar')
self.assertEqual(d['A'], 'foo, bar')
def test_getlist(self):
self.assertEqual(self.d.getlist('a'), ['foo', 'bar'])
self.assertEqual(self.d.getlist('A'), ['foo', 'bar'])
self.assertEqual(self.d.getlist('b'), [])
def test_delitem(self):
del self.d['a']
self.assertFalse('a' in self.d)
self.assertFalse('A' in self.d)
def test_equal(self):
b = HTTPHeaderDict({'a': 'foo, bar'})
self.assertEqual(self.d, b)
c = [('a', 'foo, bar')]
self.assertNotEqual(self.d, c)
def test_len(self):
self.assertEqual(len(self.d), 1)
def test_repr(self):
rep = "HTTPHeaderDict({'A': 'foo, bar'})"
self.assertEqual(repr(self.d), rep)
def test_headerdict(self):
default_headers = HTTPHeaderDict(a='b')
proxy_headers = HTTPHeaderDict()
proxy_headers.add('foo', 'bar')
http = proxy_from_url(
self.proxy_url,
headers=default_headers,
proxy_headers=proxy_headers)
request_headers = HTTPHeaderDict(baz='quux')
r = http.request('GET', '%s/headers' % self.http_url, headers=request_headers)
returned_headers = json.loads(r.data.decode())
self.assertEqual(returned_headers.get('Foo'), 'bar')
self.assertEqual(returned_headers.get('Baz'), 'quux')
def test_from_httplib_py2(self):
msg = """
Server: nginx
Content-Type: text/html; charset=windows-1251
Connection: keep-alive
X-Some-Multiline: asdf
asdf
asdf
Set-Cookie: bb_lastvisit=1348253375; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
Set-Cookie: bb_lastactivity=0; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
www-authenticate: asdf
www-authenticate: bla
"""
buffer = six.moves.StringIO(msg.lstrip().replace('\n', '\r\n'))
msg = six.moves.http_client.HTTPMessage(buffer)
d = HTTPHeaderDict.from_httplib(msg)
assert d['server'] == 'nginx'
cookies = d.getlist('set-cookie')
assert len(cookies) == 2
assert cookies[0].startswith("bb_lastvisit")
assert cookies[1].startswith("bb_lastactivity")
assert d['x-some-multiline'].split() == ['asdf', 'asdf', 'asdf']
assert d['www-authenticate'] == 'asdf, bla'
assert d.getlist('www-authenticate') == ['asdf', 'bla']
def test_from_httplib_py2(self):
if six.PY3:
raise SkipTest("python3 has a different internal header implementation")
msg = """
Server: nginx
Content-Type: text/html; charset=windows-1251
Connection: keep-alive
X-Some-Multiline: asdf
asdf
asdf
Set-Cookie: bb_lastvisit=1348253375; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
Set-Cookie: bb_lastactivity=0; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
www-authenticate: asdf
www-authenticate: bla
"""
buffer = six.moves.StringIO(msg.lstrip().replace('\n', '\r\n'))
msg = six.moves.http_client.HTTPMessage(buffer)
d = HTTPHeaderDict.from_httplib(msg)
self.assertEqual(d['server'], 'nginx')
cookies = d.getlist('set-cookie')
self.assertEqual(len(cookies), 2)
self.assertTrue(cookies[0].startswith("bb_lastvisit"))
self.assertTrue(cookies[1].startswith("bb_lastactivity"))
self.assertEqual(d['x-some-multiline'].split(), ['asdf', 'asdf', 'asdf'])
self.assertEqual(d['www-authenticate'], 'asdf, bla')
self.assertEqual(d.getlist('www-authenticate'), ['asdf', 'bla'])
def test_repeating_files(self):
files = HTTPHeaderDict()
files.add('fileA', ('a.txt', 'AAA'))
files.add('f1', ('b.txt', 'BBB'))
files.add('fileA', ('c.txt', 'CCC'))
request = _prepare_request(files=files)
reader = _create_reader(request)
self._read_body(reader, request)
self._assert_files(files, reader.files)
def urlopen(self, method, url=None, headers=None, body=None, status=200):
headers_dict = HTTPHeaderDict()
headers_dict.add('url', url)
headers_dict.add('method', method)
if headers is not None and isinstance(headers, dict):
for k, v in headers.items():
headers_dict.add(k, v)
if body is None:
body = ''.encode()
elif isinstance(body, dict):
body = json.dumps(body).encode()
else:
body = body.encode()
return Bunch(data=body, headers=headers_dict, status=status)
def test_from_httplib(self):
if six.PY3:
raise SkipTest()
from httplib import HTTPMessage
from StringIO import StringIO
msg = """
Server: nginx
Content-Type: text/html; charset=windows-1251
Connection: keep-alive
Set-Cookie: bb_lastvisit=1348253375; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
Set-Cookie: bb_lastactivity=0; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
"""
msg = HTTPMessage(StringIO(msg.lstrip().replace('\n', '\r\n')))
d = HTTPHeaderDict.from_httplib(msg)
self.assertEqual(d['server'], 'nginx')
cookies = d.getlist('set-cookie')
self.assertEqual(len(cookies), 2)
self.assertTrue(cookies[0].startswith("bb_lastvisit"))
self.assertTrue(cookies[1].startswith("bb_lastactivity"))
def d() -> HTTPHeaderDict:
header_dict = HTTPHeaderDict(Cookie="foo")
header_dict.add("cookie", "bar")
return header_dict
class TestHTTPHeaderDict(unittest.TestCase):
def setUp(self):
self.d = HTTPHeaderDict(Cookie='foo')
self.d.add('cookie', 'bar')
def test_create_from_kwargs(self):
h = HTTPHeaderDict(ab=1, cd=2, ef=3, gh=4)
self.assertEqual(len(h), 4)
self.assertTrue('ab' in h)
def test_create_from_dict(self):
h = HTTPHeaderDict(dict(ab=1, cd=2, ef=3, gh=4))
self.assertEqual(len(h), 4)
self.assertTrue('ab' in h)
def test_create_from_iterator(self):
teststr = 'urllib3ontherocks'
h = HTTPHeaderDict((c, c*5) for c in teststr)
self.assertEqual(len(h), len(set(teststr)))
def test_create_from_list(self):
h = HTTPHeaderDict([('ab', 'A'), ('cd', 'B'), ('cookie', 'C'), ('cookie', 'D'), ('cookie', 'E')])
self.assertEqual(len(h), 3)
self.assertTrue('ab' in h)
clist = h.getlist('cookie')
self.assertEqual(len(clist), 3)
self.assertEqual(clist[0], 'C')
self.assertEqual(clist[-1], 'E')
def test_create_from_headerdict(self):
org = HTTPHeaderDict([('ab', 'A'), ('cd', 'B'), ('cookie', 'C'), ('cookie', 'D'), ('cookie', 'E')])
h = HTTPHeaderDict(org)
self.assertEqual(len(h), 3)
self.assertTrue('ab' in h)
clist = h.getlist('cookie')
self.assertEqual(len(clist), 3)
self.assertEqual(clist[0], 'C')
self.assertEqual(clist[-1], 'E')
self.assertFalse(h is org)
self.assertEqual(h, org)
def test_setitem(self):
self.d['Cookie'] = 'foo'
self.assertEqual(self.d['cookie'], 'foo')
self.d['cookie'] = 'with, comma'
self.assertEqual(self.d.getlist('cookie'), ['with, comma'])
def test_update(self):
self.d.update(dict(Cookie='foo'))
self.assertEqual(self.d['cookie'], 'foo')
self.d.update(dict(cookie='with, comma'))
self.assertEqual(self.d.getlist('cookie'), ['with, comma'])
def test_delitem(self):
del self.d['cookie']
self.assertFalse('cookie' in self.d)
self.assertFalse('COOKIE' in self.d)
def test_add_well_known_multiheader(self):
self.d.add('COOKIE', 'asdf')
self.assertEqual(self.d.getlist('cookie'), ['foo', 'bar', 'asdf'])
self.assertEqual(self.d['cookie'], 'foo, bar, asdf')
def test_add_comma_separated_multiheader(self):
self.d.add('bar', 'foo')
self.d.add('BAR', 'bar')
self.d.add('Bar', 'asdf')
self.assertEqual(self.d.getlist('bar'), ['foo', 'bar', 'asdf'])
self.assertEqual(self.d['bar'], 'foo, bar, asdf')
def test_extend_from_list(self):
self.d.extend([('set-cookie', '100'), ('set-cookie', '200'), ('set-cookie', '300')])
self.assertEqual(self.d['set-cookie'], '100, 200, 300')
def test_extend_from_dict(self):
self.d.extend(dict(cookie='asdf'), b='100')
self.assertEqual(self.d['cookie'], 'foo, bar, asdf')
self.assertEqual(self.d['b'], '100')
self.d.add('cookie', 'with, comma')
self.assertEqual(self.d.getlist('cookie'), ['foo', 'bar', 'asdf', 'with, comma'])
def test_extend_from_container(self):
h = NonMappingHeaderContainer(Cookie='foo', e='foofoo')
self.d.extend(h)
self.assertEqual(self.d['cookie'], 'foo, bar, foo')
self.assertEqual(self.d['e'], 'foofoo')
self.assertEqual(len(self.d), 2)
def test_extend_from_headerdict(self):
h = HTTPHeaderDict(Cookie='foo', e='foofoo')
self.d.extend(h)
self.assertEqual(self.d['cookie'], 'foo, bar, foo')
self.assertEqual(self.d['e'], 'foofoo')
self.assertEqual(len(self.d), 2)
def test_copy(self):
h = self.d.copy()
self.assertTrue(self.d is not h)
self.assertEqual(self.d, h)
def test_getlist(self):
self.assertEqual(self.d.getlist('cookie'), ['foo', 'bar'])
self.assertEqual(self.d.getlist('Cookie'), ['foo', 'bar'])
self.assertEqual(self.d.getlist('b'), [])
self.d.add('b', 'asdf')
self.assertEqual(self.d.getlist('b'), ['asdf'])
def test_getlist_after_copy(self):
self.assertEqual(self.d.getlist('cookie'), HTTPHeaderDict(self.d).getlist('cookie'))
def test_equal(self):
b = HTTPHeaderDict(cookie='foo, bar')
c = NonMappingHeaderContainer(cookie='foo, bar')
self.assertEqual(self.d, b)
self.assertEqual(self.d, c)
self.assertNotEqual(self.d, 2)
def test_not_equal(self):
b = HTTPHeaderDict(cookie='foo, bar')
c = NonMappingHeaderContainer(cookie='foo, bar')
self.assertFalse(self.d != b)
self.assertFalse(self.d != c)
self.assertNotEqual(self.d, 2)
def test_pop(self):
key = 'Cookie'
a = self.d[key]
b = self.d.pop(key)
self.assertEqual(a, b)
self.assertFalse(key in self.d)
self.assertRaises(KeyError, self.d.pop, key)
dummy = object()
self.assertTrue(dummy is self.d.pop(key, dummy))
def test_discard(self):
self.d.discard('cookie')
self.assertFalse('cookie' in self.d)
self.d.discard('cookie')
def test_len(self):
self.assertEqual(len(self.d), 1)
self.d.add('cookie', 'bla')
self.d.add('asdf', 'foo')
# len determined by unique fieldnames
self.assertEqual(len(self.d), 2)
def test_repr(self):
rep = "HTTPHeaderDict({'Cookie': 'foo, bar'})"
self.assertEqual(repr(self.d), rep)
def test_items(self):
items = self.d.items()
self.assertEqual(len(items), 2)
self.assertEqual(items[0][0], 'Cookie')
self.assertEqual(items[0][1], 'foo')
self.assertEqual(items[1][0], 'Cookie')
self.assertEqual(items[1][1], 'bar')
def test_dict_conversion(self):
# Also tested in connectionpool, needs to preserve case
hdict = {'Content-Length': '0', 'Content-type': 'text/plain', 'Server': 'TornadoServer/1.2.3'}
h = dict(HTTPHeaderDict(hdict).items())
self.assertEqual(hdict, h)
self.assertEqual(hdict, dict(HTTPHeaderDict(hdict)))
def test_string_enforcement(self):
# This currently throws AttributeError on key.lower(), should probably be something nicer
self.assertRaises(Exception, self.d.__setitem__, 3, 5)
self.assertRaises(Exception, self.d.add, 3, 4)
self.assertRaises(Exception, self.d.__delitem__, 3)
self.assertRaises(Exception, HTTPHeaderDict, {3: 3})
def test_from_httplib_py2(self):
if six.PY3:
raise SkipTest("python3 has a different internal header implementation")
msg = """
Server: nginx
Content-Type: text/html; charset=windows-1251
Connection: keep-alive
X-Some-Multiline: asdf
asdf
asdf
Set-Cookie: bb_lastvisit=1348253375; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
Set-Cookie: bb_lastactivity=0; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
www-authenticate: asdf
www-authenticate: bla
"""
buffer = six.moves.StringIO(msg.lstrip().replace('\n', '\r\n'))
msg = six.moves.http_client.HTTPMessage(buffer)
d = HTTPHeaderDict.from_httplib(msg)
self.assertEqual(d['server'], 'nginx')
cookies = d.getlist('set-cookie')
self.assertEqual(len(cookies), 2)
self.assertTrue(cookies[0].startswith("bb_lastvisit"))
self.assertTrue(cookies[1].startswith("bb_lastactivity"))
self.assertEqual(d['x-some-multiline'].split(), ['asdf', 'asdf', 'asdf'])
self.assertEqual(d['www-authenticate'], 'asdf, bla')
self.assertEqual(d.getlist('www-authenticate'), ['asdf', 'bla'])
def test_getlist(self, d: HTTPHeaderDict) -> None:
assert d.getlist("cookie") == ["foo", "bar"]
assert d.getlist("Cookie") == ["foo", "bar"]
assert d.getlist("b") == []
d.add("b", "asdf")
assert d.getlist("b") == ["asdf"]
def setUp(self):
self.d = HTTPHeaderDict(Cookie="foo")
self.d.add("cookie", "bar")
class TestHTTPHeaderDict(unittest.TestCase):
def setUp(self):
self.d = HTTPHeaderDict(Cookie='foo')
self.d.add('cookie', 'bar')
def test_overwriting_with_setitem_replaces(self):
d = HTTPHeaderDict()
d['Cookie'] = 'foo'
self.assertEqual(d['cookie'], 'foo')
d['cookie'] = 'bar'
self.assertEqual(d['Cookie'], 'bar')
def test_copy(self):
h = self.d.copy()
self.assertTrue(self.d is not h)
self.assertEqual(self.d, h)
def test_add_multiple_allowed(self):
d = HTTPHeaderDict()
d['Cookie'] = 'foo'
d.add('cookie', 'bar')
self.assertEqual(d['cookie'], 'foo, bar')
self.assertEqual(d['Cookie'], 'foo, bar')
d.add('cookie', 'asdf')
self.assertEqual(d['cookie'], 'foo, bar, asdf')
def test_add_multiple_not_allowed(self):
self.d.add('notmulti', 'should be overwritten on next add call')
self.d.add('notmulti', 'new val')
self.assertEqual(self.d['notmulti'], 'new val')
def test_extend(self):
self.d.extend([('set-cookie', '100'), ('set-cookie', '200'), ('set-cookie', '300')])
self.assertEqual(self.d['set-cookie'], '100, 200, 300')
self.d.extend(dict(cookie='asdf'), b='100')
self.assertEqual(self.d['cookie'], 'foo, bar, asdf')
self.assertEqual(self.d['b'], '100')
self.d.add('cookie', 'with, comma')
self.assertEqual(self.d.getlist('cookie'), ['foo', 'bar', 'asdf', 'with, comma'])
header_object = NonMappingHeaderContainer(e='foofoo')
self.d.extend(header_object)
self.assertEqual(self.d['e'], 'foofoo')
def test_getlist(self):
self.assertEqual(self.d.getlist('cookie'), ['foo', 'bar'])
self.assertEqual(self.d.getlist('Cookie'), ['foo', 'bar'])
self.assertEqual(self.d.getlist('b'), [])
self.d.add('b', 'asdf')
self.assertEqual(self.d.getlist('b'), ['asdf'])
def test_update(self):
self.d.update(dict(cookie='with, comma'))
self.assertEqual(self.d.getlist('cookie'), ['with, comma'])
def test_delitem(self):
del self.d['cookie']
self.assertFalse('cookie' in self.d)
self.assertFalse('COOKIE' in self.d)
def test_equal(self):
b = HTTPHeaderDict(cookie='foo, bar')
c = NonMappingHeaderContainer(cookie='foo, bar')
self.assertEqual(self.d, b)
self.assertEqual(self.d, c)
self.assertNotEqual(self.d, 2)
def test_not_equal(self):
b = HTTPHeaderDict(cookie='foo, bar')
c = NonMappingHeaderContainer(cookie='foo, bar')
self.assertFalse(self.d != b)
self.assertFalse(self.d != c)
self.assertNotEqual(self.d, 2)
def test_pop(self):
key = 'Cookie'
a = self.d[key]
b = self.d.pop(key)
self.assertEqual(a, b)
self.assertFalse(key in self.d)
self.assertRaises(KeyError, self.d.pop, key)
dummy = object()
self.assertTrue(dummy is self.d.pop(key, dummy))
def test_discard(self):
self.d.discard('cookie')
self.assertFalse('cookie' in self.d)
self.d.discard('cookie')
def test_len(self):
self.assertEqual(len(self.d), 1)
def test_repr(self):
rep = "HTTPHeaderDict({'Cookie': 'foo, bar'})"
self.assertEqual(repr(self.d), rep)
def test_items(self):
items = self.d.items()
self.assertEqual(len(items), 2)
self.assertEqual(items[0][0], 'Cookie')
self.assertEqual(items[0][1], 'foo')
self.assertEqual(items[1][0], 'Cookie')
self.assertEqual(items[1][1], 'bar')
def test_items_preserving_case(self):
# Should not be tested only in connectionpool
HEADERS = {'Content-Length': '0', 'Content-type': 'text/plain',
'Server': 'TornadoServer/1.2.3'}
h = dict(HTTPHeaderDict(HEADERS).items())
self.assertEqual(HEADERS, h) # to preserve case sensitivity
def test_from_httplib(self):
if six.PY3:
raise SkipTest()
from httplib import HTTPMessage
from StringIO import StringIO
msg = """
Server: nginx
Content-Type: text/html; charset=windows-1251
Connection: keep-alive
Set-Cookie: bb_lastvisit=1348253375; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
Set-Cookie: bb_lastactivity=0; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
"""
msg = HTTPMessage(StringIO(msg.lstrip().replace('\n', '\r\n')))
d = HTTPHeaderDict.from_httplib(msg)
self.assertEqual(d['server'], 'nginx')
cookies = d.getlist('set-cookie')
self.assertEqual(len(cookies), 2)
self.assertTrue(cookies[0].startswith("bb_lastvisit"))
self.assertTrue(cookies[1].startswith("bb_lastactivity"))
def post_job_build(
self: api_client.Api,
query_params: RequestQueryParams = frozendict(),
header_params: RequestHeaderParams = frozendict(),
path_params: RequestPathParams = frozendict(),
stream: bool = False,
timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
skip_deserialization: bool = False,
) -> typing.Union[ApiResponseFor200, ApiResponseFor201,
api_client.ApiResponseWithoutDeserialization]:
"""
:param skip_deserialization: If true then api_response.response will be set but
api_response.body and api_response.headers will not be deserialized into schema
class instances
"""
self._verify_typed_dict_inputs(RequestQueryParams, query_params)
self._verify_typed_dict_inputs(RequestHeaderParams, header_params)
self._verify_typed_dict_inputs(RequestPathParams, path_params)
_path_params = {}
for parameter in (request_path_name, ):
parameter_data = path_params.get(parameter.name, unset)
if parameter_data is unset:
continue
serialized_data = parameter.serialize(parameter_data)
_path_params.update(serialized_data)
_query_params = []
for parameter in (
request_query_json,
request_query_token,
):
parameter_data = query_params.get(parameter.name, unset)
if parameter_data is unset:
continue
serialized_data = parameter.serialize(parameter_data)
_query_params.extend(serialized_data)
_headers = HTTPHeaderDict()
for parameter in (request_header_jenkins_crumb, ):
parameter_data = header_params.get(parameter.name, unset)
if parameter_data is unset:
continue
serialized_data = parameter.serialize(parameter_data)
_headers.extend(serialized_data)
# TODO add cookie handling
response = self.api_client.call_api(
resource_path=_path,
method=_method,
path_params=_path_params,
query_params=tuple(_query_params),
headers=_headers,
auth_settings=_auth,
stream=stream,
timeout=timeout,
)
if skip_deserialization:
api_response = api_client.ApiResponseWithoutDeserialization(
response=response)
else:
response_for_status = _status_code_to_response.get(
str(response.status))
if response_for_status:
api_response = response_for_status.deserialize(
response, self.api_client.configuration)
else:
api_response = api_client.ApiResponseWithoutDeserialization(
response=response)
if not 200 <= response.status <= 299:
raise exceptions.ApiException(api_response=api_response)
return api_response
def test_create_from_iterator(self):
teststr = 'urllib3ontherocks'
h = HTTPHeaderDict((c, c*5) for c in teststr)
self.assertEqual(len(h), len(set(teststr)))
def resolve_redirects(self,
resp,
req,
stream=False,
timeout=None,
verify=True,
cert=None,
proxies=None,
yield_requests=False,
**adapter_kwargs):
"""Receives a Response. Returns a generator of Responses or Requests."""
hist = [] # keep track of history
url = self.get_redirect_target(resp)
while url:
prepared_request = req.copy()
# Update history and keep track of redirects.
# resp.history must ignore the original request in this loop
hist.append(resp)
resp.history = hist[1:]
# Consume socket so it can be released
resp.content
if self.max_redirects <= len(resp.history):
raise TooManyRedirects('Exceeded %s redirects.' %
self.max_redirects,
response=resp)
# Release the connection
resp.close()
# Handle redirection without scheme (see: RFC 1808 Section 4)
if url.startswith('//'):
parsed_rurl = urlparse(resp.url)
url = '%s:%s' % (to_native_string(parsed_rurl.scheme), url)
# The scheme should be lower case...
parsed = urlparse(url)
url = parsed.geturl()
# Facilitate relative 'location' headers, as allowed by RFC 7231.
# (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
# Compliant with RFC3986, we percent encode the url.
if not parsed.netloc:
url = urljoin(resp.url, requote_uri(url))
else:
url = requote_uri(url)
prepared_request.url = to_native_string(url)
self.rebuild_method(prepared_request, resp)
# https://github.com/requests/requests/issues/1084
if resp.status_code not in (codes.temporary_redirect,
codes.permanent_redirect):
# https://github.com/requests/requests/issues/3490
purged_headers = ('Content-Length', 'Content-Type',
'Transfer-Encoding')
for header in purged_headers:
prepared_request.headers.pop(header, None)
prepared_request.body = None
headers = prepared_request.headers
try:
del headers['Cookie']
except KeyError:
pass
# Extract any cookies sent on the response to the cookiejar
# in the new request. Because we've mutated our copied prepared
# request, use the old one that we haven't yet touched.
prepared_request._cookies.extract_cookies(
MockResponse(HTTPHeaderDict(resp.headers)), MockRequest(req))
merge_cookies(prepared_request._cookies, self.cookies)
prepared_request.prepare_cookies(prepared_request._cookies)
# Rebuild auth and proxy information.
proxies = self.rebuild_proxies(prepared_request, proxies)
self.rebuild_auth(prepared_request, resp)
# Override the original request.
req = prepared_request
req.adapt_prepare()
if yield_requests:
yield req
else:
resp = self.send(req,
stream=stream,
timeout=timeout,
verify=verify,
cert=cert,
proxies=proxies,
allow_redirects=False,
**adapter_kwargs)
yield resp
while not resp.done():
yield resp
resp = resp.result()
self.cookies.extract_cookies(
MockResponse(HTTPHeaderDict(resp.headers)),
MockRequest(prepared_request))
# extract redirect url, if any, for the next loop
url = self.get_redirect_target(resp)
def send(self, req, **kwargs):
"""Send a given PreparedRequest.
:rtype: trip.gen.Future
"""
if not isinstance(req, PreparedRequest):
raise ValueError('You can only send PreparedRequests.')
allow_redirects = kwargs.pop('allow_redirects', True)
start_time = preferred_clock()
r = yield self.adapter.send(req, **kwargs)
if isinstance(r, Exception):
raise gen.Return(r)
else:
r = self.prepare_response(req, r)
r.elapsed = timedelta(seconds=(preferred_clock() - start_time))
# Response manipulation hooks
r = dispatch_hook('response', req.hooks, r, **kwargs)
# Persist cookies
if r.history:
# If the hooks create history then we want those cookies too
for resp in r.history:
self.cookies.extract_cookies(
MockResponse(HTTPHeaderDict(resp.headers)),
MockRequest(resp.request))
self.cookies.extract_cookies(MockResponse(HTTPHeaderDict(r.headers)),
MockRequest(req))
# Redirect resolving generator.
redirect_gen = self.resolve_redirects(r, req, **kwargs)
# Resolve redirects if allowed.
history = []
if allow_redirects:
for resp in redirect_gen:
resp = yield resp
history.append(resp)
# Shuffle things around if there's history.
if history:
# Insert the first (original) request at the start
history.insert(0, r)
# Get the last request made
r = history.pop()
r.history = history
# If redirects aren't being followed, store the response on the Request for Response.next().
if not allow_redirects:
try:
r._next = next(
self.resolve_redirects(r,
req,
yield_requests=True,
**kwargs))
except StopIteration:
pass
raise gen.Return(r)
def test_not_equal(self):
b = HTTPHeaderDict(cookie='foo, bar')
c = NonMappingHeaderContainer(cookie='foo, bar')
self.assertFalse(self.d != b)
self.assertFalse(self.d != c)
self.assertNotEqual(self.d, 2)
def test_getlist_after_copy(self):
self.assertEqual(self.d.getlist('cookie'), HTTPHeaderDict(self.d).getlist('cookie'))
def test_extend_from_headerdict(self):
h = HTTPHeaderDict(Cookie='foo', e='foofoo')
self.d.extend(h)
self.assertEqual(self.d['cookie'], 'foo, bar, foo')
self.assertEqual(self.d['e'], 'foofoo')
self.assertEqual(len(self.d), 2)
def test_extend_from_container(self, d: HTTPHeaderDict) -> None:
h = NonMappingHeaderContainer(Cookie="foo", e="foofoo")
d.extend(h)
assert d["cookie"] == "foo, bar, foo"
assert d["e"] == "foofoo"
assert len(d) == 2
def setUp(self):
self.d = HTTPHeaderDict(Cookie='foo')
self.d.add('cookie', 'bar')
def d():
header_dict = HTTPHeaderDict(Cookie='foo')
header_dict.add('cookie', 'bar')
return header_dict
def create_user(
self: api_client.Api,
body: typing.Union[SchemaForRequestBodyApplicationJson],
content_type: str = 'application/json',
stream: bool = False,
timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
skip_deserialization: bool = False,
) -> typing.Union[ApiResponseForDefault,
api_client.ApiResponseWithoutDeserialization]:
"""
Create user
:param skip_deserialization: If true then api_response.response will be set but
api_response.body and api_response.headers will not be deserialized into schema
class instances
"""
_headers = HTTPHeaderDict()
# TODO add cookie handling
if body is unset:
raise exceptions.ApiValueError(
'The required body parameter has an invalid value of: unset. Set a valid value instead'
)
_fields = None
_body = None
serialized_data = request_body_user.serialize(body, content_type)
_headers.add('Content-Type', content_type)
if 'fields' in serialized_data:
_fields = serialized_data['fields']
elif 'body' in serialized_data:
_body = serialized_data['body']
response = self.api_client.call_api(
resource_path=_path,
method=_method,
headers=_headers,
fields=_fields,
body=_body,
stream=stream,
timeout=timeout,
)
if skip_deserialization:
api_response = api_client.ApiResponseWithoutDeserialization(
response=response)
else:
response_for_status = _status_code_to_response.get(
str(response.status))
if response_for_status:
api_response = response_for_status.deserialize(
response, self.api_client.configuration)
else:
default_response = _status_code_to_response.get('default')
if default_response:
api_response = default_response.deserialize(
response, self.api_client.configuration)
else:
api_response = api_client.ApiResponseWithoutDeserialization(
response=response)
if not 200 <= response.status <= 299:
raise exceptions.ApiException(api_response=api_response)
return api_response
def test_filter_http_return_type(self):
headers = HTTPHeaderDict()
headers.add('header', 'asda')
self.assertIsInstance(self.metadata_http_headers_filter.filter_http(headers), HTTPHeaderDict)
def test_update(self, d: HTTPHeaderDict) -> None:
d.update(dict(Cookie="foo"))
assert d["cookie"] == "foo"
d.update(dict(cookie="with, comma"))
assert d.getlist("cookie") == ["with, comma"]
def test_getlist_after_copy(self, d: HTTPHeaderDict) -> None:
assert d.getlist("cookie") == HTTPHeaderDict(d).getlist("cookie")
def test_extend_from_list(self, d: HTTPHeaderDict) -> None:
d.extend([("set-cookie", "100"), ("set-cookie", "200"), ("set-cookie", "300")])
assert d["set-cookie"] == "100, 200, 300"
class TestHTTPHeaderDict(unittest.TestCase):
def setUp(self):
self.d = HTTPHeaderDict(Cookie="foo")
self.d.add("cookie", "bar")
def test_create_from_kwargs(self):
h = HTTPHeaderDict(ab=1, cd=2, ef=3, gh=4)
self.assertEqual(len(h), 4)
self.assertTrue("ab" in h)
def test_create_from_dict(self):
h = HTTPHeaderDict(dict(ab=1, cd=2, ef=3, gh=4))
self.assertEqual(len(h), 4)
self.assertTrue("ab" in h)
def test_create_from_iterator(self):
teststr = "urllib3ontherocks"
h = HTTPHeaderDict((c, c * 5) for c in teststr)
self.assertEqual(len(h), len(set(teststr)))
def test_create_from_list(self):
h = HTTPHeaderDict([("ab", "A"), ("cd", "B"), ("cookie", "C"), ("cookie", "D"), ("cookie", "E")])
self.assertEqual(len(h), 3)
self.assertTrue("ab" in h)
clist = h.getlist("cookie")
self.assertEqual(len(clist), 3)
self.assertEqual(clist[0], "C")
self.assertEqual(clist[-1], "E")
def test_create_from_headerdict(self):
org = HTTPHeaderDict([("ab", "A"), ("cd", "B"), ("cookie", "C"), ("cookie", "D"), ("cookie", "E")])
h = HTTPHeaderDict(org)
self.assertEqual(len(h), 3)
self.assertTrue("ab" in h)
clist = h.getlist("cookie")
self.assertEqual(len(clist), 3)
self.assertEqual(clist[0], "C")
self.assertEqual(clist[-1], "E")
self.assertFalse(h is org)
self.assertEqual(h, org)
def test_setitem(self):
self.d["Cookie"] = "foo"
self.assertEqual(self.d["cookie"], "foo")
self.d["cookie"] = "with, comma"
self.assertEqual(self.d.getlist("cookie"), ["with, comma"])
def test_update(self):
self.d.update(dict(Cookie="foo"))
self.assertEqual(self.d["cookie"], "foo")
self.d.update(dict(cookie="with, comma"))
self.assertEqual(self.d.getlist("cookie"), ["with, comma"])
def test_delitem(self):
del self.d["cookie"]
self.assertFalse("cookie" in self.d)
self.assertFalse("COOKIE" in self.d)
def test_add_well_known_multiheader(self):
self.d.add("COOKIE", "asdf")
self.assertEqual(self.d.getlist("cookie"), ["foo", "bar", "asdf"])
self.assertEqual(self.d["cookie"], "foo, bar, asdf")
def test_add_comma_separated_multiheader(self):
self.d.add("bar", "foo")
self.d.add("BAR", "bar")
self.d.add("Bar", "asdf")
self.assertEqual(self.d.getlist("bar"), ["foo", "bar", "asdf"])
self.assertEqual(self.d["bar"], "foo, bar, asdf")
def test_extend_from_list(self):
self.d.extend([("set-cookie", "100"), ("set-cookie", "200"), ("set-cookie", "300")])
self.assertEqual(self.d["set-cookie"], "100, 200, 300")
def test_extend_from_dict(self):
self.d.extend(dict(cookie="asdf"), b="100")
self.assertEqual(self.d["cookie"], "foo, bar, asdf")
self.assertEqual(self.d["b"], "100")
self.d.add("cookie", "with, comma")
self.assertEqual(self.d.getlist("cookie"), ["foo", "bar", "asdf", "with, comma"])
def test_extend_from_container(self):
h = NonMappingHeaderContainer(Cookie="foo", e="foofoo")
self.d.extend(h)
self.assertEqual(self.d["cookie"], "foo, bar, foo")
self.assertEqual(self.d["e"], "foofoo")
self.assertEqual(len(self.d), 2)
def test_extend_from_headerdict(self):
h = HTTPHeaderDict(Cookie="foo", e="foofoo")
self.d.extend(h)
self.assertEqual(self.d["cookie"], "foo, bar, foo")
self.assertEqual(self.d["e"], "foofoo")
self.assertEqual(len(self.d), 2)
def test_copy(self):
h = self.d.copy()
self.assertTrue(self.d is not h)
self.assertEqual(self.d, h)
def test_getlist(self):
self.assertEqual(self.d.getlist("cookie"), ["foo", "bar"])
self.assertEqual(self.d.getlist("Cookie"), ["foo", "bar"])
self.assertEqual(self.d.getlist("b"), [])
self.d.add("b", "asdf")
self.assertEqual(self.d.getlist("b"), ["asdf"])
def test_getlist_after_copy(self):
self.assertEqual(self.d.getlist("cookie"), HTTPHeaderDict(self.d).getlist("cookie"))
def test_equal(self):
b = HTTPHeaderDict(cookie="foo, bar")
c = NonMappingHeaderContainer(cookie="foo, bar")
self.assertEqual(self.d, b)
self.assertEqual(self.d, c)
self.assertNotEqual(self.d, 2)
def test_not_equal(self):
b = HTTPHeaderDict(cookie="foo, bar")
c = NonMappingHeaderContainer(cookie="foo, bar")
self.assertFalse(self.d != b)
self.assertFalse(self.d != c)
self.assertNotEqual(self.d, 2)
def test_pop(self):
key = "Cookie"
a = self.d[key]
b = self.d.pop(key)
self.assertEqual(a, b)
self.assertFalse(key in self.d)
self.assertRaises(KeyError, self.d.pop, key)
dummy = object()
self.assertTrue(dummy is self.d.pop(key, dummy))
def test_discard(self):
self.d.discard("cookie")
self.assertFalse("cookie" in self.d)
self.d.discard("cookie")
def test_len(self):
self.assertEqual(len(self.d), 1)
self.d.add("cookie", "bla")
self.d.add("asdf", "foo")
# len determined by unique fieldnames
self.assertEqual(len(self.d), 2)
def test_repr(self):
rep = "HTTPHeaderDict({'Cookie': 'foo, bar'})"
self.assertEqual(repr(self.d), rep)
def test_items(self):
items = self.d.items()
self.assertEqual(len(items), 2)
self.assertEqual(items[0][0], "Cookie")
self.assertEqual(items[0][1], "foo")
self.assertEqual(items[1][0], "Cookie")
self.assertEqual(items[1][1], "bar")
def test_dict_conversion(self):
# Also tested in connectionpool, needs to preserve case
hdict = {"Content-Length": "0", "Content-type": "text/plain", "Server": "TornadoServer/1.2.3"}
h = dict(HTTPHeaderDict(hdict).items())
self.assertEqual(hdict, h)
def test_string_enforcement(self):
# This currently throws AttributeError on key.lower(), should probably be something nicer
self.assertRaises(Exception, self.d.__setitem__, 3, 5)
self.assertRaises(Exception, self.d.add, 3, 4)
self.assertRaises(Exception, self.d.__delitem__, 3)
self.assertRaises(Exception, HTTPHeaderDict, {3: 3})
def test_from_httplib_py2(self):
if six.PY3:
raise SkipTest("python3 has a different internal header implementation")
msg = """
Server: nginx
Content-Type: text/html; charset=windows-1251
Connection: keep-alive
X-Some-Multiline: asdf
asdf
asdf
Set-Cookie: bb_lastvisit=1348253375; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
Set-Cookie: bb_lastactivity=0; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
www-authenticate: asdf
www-authenticate: bla
"""
buffer = six.moves.StringIO(msg.lstrip().replace("\n", "\r\n"))
msg = six.moves.http_client.HTTPMessage(buffer)
d = HTTPHeaderDict.from_httplib(msg)
self.assertEqual(d["server"], "nginx")
cookies = d.getlist("set-cookie")
self.assertEqual(len(cookies), 2)
self.assertTrue(cookies[0].startswith("bb_lastvisit"))
self.assertTrue(cookies[1].startswith("bb_lastactivity"))
self.assertEqual(d["x-some-multiline"].split(), ["asdf", "asdf", "asdf"])
self.assertEqual(d["www-authenticate"], "asdf, bla")
self.assertEqual(d.getlist("www-authenticate"), ["asdf", "bla"])
class TestHTTPHeaderDict(unittest.TestCase):
def setUp(self):
self.d = HTTPHeaderDict(Cookie='foo')
self.d.add('cookie', 'bar')
def test_create_from_kwargs(self):
h = HTTPHeaderDict(ab=1, cd=2, ef=3, gh=4)
self.assertEqual(len(h), 4)
self.assertTrue('ab' in h)
def test_create_from_dict(self):
h = HTTPHeaderDict(dict(ab=1, cd=2, ef=3, gh=4))
self.assertEqual(len(h), 4)
self.assertTrue('ab' in h)
def test_create_from_iterator(self):
teststr = 'urllib3ontherocks'
h = HTTPHeaderDict((c, c*5) for c in teststr)
self.assertEqual(len(h), len(set(teststr)))
def test_create_from_list(self):
headers = [('ab', 'A'), ('cd', 'B'), ('cookie', 'C'), ('cookie', 'D'), ('cookie', 'E')]
h = HTTPHeaderDict(headers)
self.assertEqual(len(h), 3)
self.assertTrue('ab' in h)
clist = h.getlist('cookie')
self.assertEqual(len(clist), 3)
self.assertEqual(clist[0], 'C')
self.assertEqual(clist[-1], 'E')
def test_create_from_headerdict(self):
headers = [('ab', 'A'), ('cd', 'B'), ('cookie', 'C'), ('cookie', 'D'), ('cookie', 'E')]
org = HTTPHeaderDict(headers)
h = HTTPHeaderDict(org)
self.assertEqual(len(h), 3)
self.assertTrue('ab' in h)
clist = h.getlist('cookie')
self.assertEqual(len(clist), 3)
self.assertEqual(clist[0], 'C')
self.assertEqual(clist[-1], 'E')
self.assertFalse(h is org)
self.assertEqual(h, org)
def test_setitem(self):
self.d['Cookie'] = 'foo'
self.assertEqual(self.d['cookie'], 'foo')
self.d['cookie'] = 'with, comma'
self.assertEqual(self.d.getlist('cookie'), ['with, comma'])
def test_update(self):
self.d.update(dict(Cookie='foo'))
self.assertEqual(self.d['cookie'], 'foo')
self.d.update(dict(cookie='with, comma'))
self.assertEqual(self.d.getlist('cookie'), ['with, comma'])
def test_delitem(self):
del self.d['cookie']
self.assertFalse('cookie' in self.d)
self.assertFalse('COOKIE' in self.d)
def test_add_well_known_multiheader(self):
self.d.add('COOKIE', 'asdf')
self.assertEqual(self.d.getlist('cookie'), ['foo', 'bar', 'asdf'])
self.assertEqual(self.d['cookie'], 'foo, bar, asdf')
def test_add_comma_separated_multiheader(self):
self.d.add('bar', 'foo')
self.d.add('BAR', 'bar')
self.d.add('Bar', 'asdf')
self.assertEqual(self.d.getlist('bar'), ['foo', 'bar', 'asdf'])
self.assertEqual(self.d['bar'], 'foo, bar, asdf')
def test_extend_from_list(self):
self.d.extend([('set-cookie', '100'), ('set-cookie', '200'), ('set-cookie', '300')])
self.assertEqual(self.d['set-cookie'], '100, 200, 300')
def test_extend_from_dict(self):
self.d.extend(dict(cookie='asdf'), b='100')
self.assertEqual(self.d['cookie'], 'foo, bar, asdf')
self.assertEqual(self.d['b'], '100')
self.d.add('cookie', 'with, comma')
self.assertEqual(self.d.getlist('cookie'), ['foo', 'bar', 'asdf', 'with, comma'])
def test_extend_from_container(self):
h = NonMappingHeaderContainer(Cookie='foo', e='foofoo')
self.d.extend(h)
self.assertEqual(self.d['cookie'], 'foo, bar, foo')
self.assertEqual(self.d['e'], 'foofoo')
self.assertEqual(len(self.d), 2)
def test_extend_from_headerdict(self):
h = HTTPHeaderDict(Cookie='foo', e='foofoo')
self.d.extend(h)
self.assertEqual(self.d['cookie'], 'foo, bar, foo')
self.assertEqual(self.d['e'], 'foofoo')
self.assertEqual(len(self.d), 2)
def test_copy(self):
h = self.d.copy()
self.assertTrue(self.d is not h)
self.assertEqual(self.d, h)
def test_getlist(self):
self.assertEqual(self.d.getlist('cookie'), ['foo', 'bar'])
self.assertEqual(self.d.getlist('Cookie'), ['foo', 'bar'])
self.assertEqual(self.d.getlist('b'), [])
self.d.add('b', 'asdf')
self.assertEqual(self.d.getlist('b'), ['asdf'])
def test_getlist_after_copy(self):
self.assertEqual(self.d.getlist('cookie'), HTTPHeaderDict(self.d).getlist('cookie'))
def test_equal(self):
b = HTTPHeaderDict(cookie='foo, bar')
c = NonMappingHeaderContainer(cookie='foo, bar')
self.assertEqual(self.d, b)
self.assertEqual(self.d, c)
self.assertNotEqual(self.d, 2)
def test_not_equal(self):
b = HTTPHeaderDict(cookie='foo, bar')
c = NonMappingHeaderContainer(cookie='foo, bar')
self.assertFalse(self.d != b)
self.assertFalse(self.d != c)
self.assertNotEqual(self.d, 2)
def test_pop(self):
key = 'Cookie'
a = self.d[key]
b = self.d.pop(key)
self.assertEqual(a, b)
self.assertFalse(key in self.d)
self.assertRaises(KeyError, self.d.pop, key)
dummy = object()
self.assertTrue(dummy is self.d.pop(key, dummy))
def test_discard(self):
self.d.discard('cookie')
self.assertFalse('cookie' in self.d)
self.d.discard('cookie')
def test_len(self):
self.assertEqual(len(self.d), 1)
self.d.add('cookie', 'bla')
self.d.add('asdf', 'foo')
# len determined by unique fieldnames
self.assertEqual(len(self.d), 2)
def test_repr(self):
rep = "HTTPHeaderDict({'Cookie': 'foo, bar'})"
self.assertEqual(repr(self.d), rep)
def test_items(self):
items = self.d.items()
self.assertEqual(len(items), 2)
self.assertEqual(items[0][0], 'Cookie')
self.assertEqual(items[0][1], 'foo')
self.assertEqual(items[1][0], 'Cookie')
self.assertEqual(items[1][1], 'bar')
def test_dict_conversion(self):
# Also tested in connectionpool, needs to preserve case
hdict = {'Content-Length': '0',
'Content-type': 'text/plain',
'Server': 'TornadoServer/1.2.3'}
h = dict(HTTPHeaderDict(hdict).items())
self.assertEqual(hdict, h)
self.assertEqual(hdict, dict(HTTPHeaderDict(hdict)))
def test_string_enforcement(self):
# This currently throws AttributeError on key.lower(), should probably be something nicer
self.assertRaises(Exception, self.d.__setitem__, 3, 5)
self.assertRaises(Exception, self.d.add, 3, 4)
self.assertRaises(Exception, self.d.__delitem__, 3)
self.assertRaises(Exception, HTTPHeaderDict, {3: 3})
def test_from_httplib_py2(self):
if six.PY3:
raise SkipTest("python3 has a different internal header implementation")
msg = """
Server: nginx
Content-Type: text/html; charset=windows-1251
Connection: keep-alive
X-Some-Multiline: asdf
asdf
asdf
Set-Cookie: bb_lastvisit=1348253375; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
Set-Cookie: bb_lastactivity=0; expires=Sat, 21-Sep-2013 18:49:35 GMT; path=/
www-authenticate: asdf
www-authenticate: bla
"""
buffer = six.moves.StringIO(msg.lstrip().replace('\n', '\r\n'))
msg = six.moves.http_client.HTTPMessage(buffer)
d = HTTPHeaderDict.from_httplib(msg)
self.assertEqual(d['server'], 'nginx')
cookies = d.getlist('set-cookie')
self.assertEqual(len(cookies), 2)
self.assertTrue(cookies[0].startswith("bb_lastvisit"))
self.assertTrue(cookies[1].startswith("bb_lastactivity"))
self.assertEqual(d['x-some-multiline'].split(), ['asdf', 'asdf', 'asdf'])
self.assertEqual(d['www-authenticate'], 'asdf, bla')
self.assertEqual(d.getlist('www-authenticate'), ['asdf', 'bla'])
def test_create_from_dict(self) -> None:
h = HTTPHeaderDict(dict(ab="1", cd="2", ef="3", gh="4"))
assert len(h) == 4
assert "ab" in h
def test_len(self, d: HTTPHeaderDict) -> None:
assert len(d) == 1
d.add("cookie", "bla")
d.add("asdf", "foo")
# len determined by unique fieldnames
assert len(d) == 2
def test_copy(self, d: HTTPHeaderDict) -> None:
h = d.copy()
assert d is not h
assert d == h
def test_repeating_value(self):
data = HTTPHeaderDict()
data.add('p1', 'abc')
data.add('x', 'def')
data.add('p1', 'x')
data.add('x', '-1239-')
data.add('x', '!@#$%^&*()_+')
data.add('x', '.')
data.add('another_param', '987654321')
request = _prepare_request(data=data)
reader = _create_reader(request)
self._read_body(reader, request)
self.assertEqual({
'p1': ['abc', 'x'],
'x': ['def', '-1239-', '!@#$%^&*()_+', '.'],
'another_param': '987654321'
}, reader.values)
self.assertEqual({}, reader.files)
def setUp(self):
self.d = HTTPHeaderDict(Cookie='foo')
self.d.add('cookie', 'bar')
def test_create_from_iterator(self) -> None:
teststr = "urllib3ontherocks"
h = HTTPHeaderDict((c, c * 5) for c in teststr)
assert len(h) == len(set(teststr))
def test_extend_from_headerdict(self, d: HTTPHeaderDict) -> None:
h = HTTPHeaderDict(Cookie="foo", e="foofoo")
d.extend(h)
assert d["cookie"] == "foo, bar, foo"
assert d["e"] == "foofoo"
assert len(d) == 2
def test_hydrate_return_object(self):
headers = HTTPHeaderDict()
headers.add('asasd', 'sdfsdf')
self.assertIsInstance(self.hydrator.hydrate_from_headers(MetaData(), headers), MetaData)
def test_extend_from_dict(self, d: HTTPHeaderDict) -> None:
d.extend(dict(cookie="asdf"), b="100")
assert d["cookie"] == "foo, bar, asdf"
assert d["b"] == "100"
d.add("cookie", "with, comma")
assert d.getlist("cookie") == ["foo", "bar", "asdf", "with, comma"]
def test_discard(self, d: HTTPHeaderDict) -> None:
d.discard("cookie")
assert "cookie" not in d
d.discard("cookie")
def test_add_well_known_multiheader(self, d: HTTPHeaderDict) -> None:
d.add("COOKIE", "asdf")
assert d.getlist("cookie") == ["foo", "bar", "asdf"]
assert d["cookie"] == "foo, bar, asdf"
def test_create_from_dict(self):
h = HTTPHeaderDict(dict(ab=1, cd=2, ef=3, gh=4))
self.assertEqual(len(h), 4)
self.assertTrue('ab' in h)
def setUp(self):
self.d = HTTPHeaderDict(A='foo')
self.d.add('a', 'bar')
def upload_file_with_required_file(
self: api_client.Api,
body: typing.Union[SchemaForRequestBodyMultipartFormData,
Unset] = unset,
path_params: RequestPathParams = frozendict(),
content_type: str = 'multipart/form-data',
accept_content_types: typing.Tuple[str] = _all_accept_content_types,
stream: bool = False,
timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
skip_deserialization: bool = False,
) -> typing.Union[ApiResponseFor200,
api_client.ApiResponseWithoutDeserialization]:
"""
uploads an image (required)
:param skip_deserialization: If true then api_response.response will be set but
api_response.body and api_response.headers will not be deserialized into schema
class instances
"""
self._verify_typed_dict_inputs(RequestPathParams, path_params)
_path_params = {}
for parameter in (request_path_pet_id, ):
parameter_data = path_params.get(parameter.name, unset)
if parameter_data is unset:
continue
serialized_data = parameter.serialize(parameter_data)
_path_params.update(serialized_data)
_headers = HTTPHeaderDict()
# TODO add cookie handling
if accept_content_types:
for accept_content_type in accept_content_types:
_headers.add('Accept', accept_content_type)
_fields = None
_body = None
if body is not unset:
serialized_data = request_body_body.serialize(body, content_type)
_headers.add('Content-Type', content_type)
if 'fields' in serialized_data:
_fields = serialized_data['fields']
elif 'body' in serialized_data:
_body = serialized_data['body']
response = self.api_client.call_api(
resource_path=_path,
method=_method,
path_params=_path_params,
headers=_headers,
fields=_fields,
body=_body,
auth_settings=_auth,
stream=stream,
timeout=timeout,
)
if skip_deserialization:
api_response = api_client.ApiResponseWithoutDeserialization(
response=response)
else:
response_for_status = _status_code_to_response.get(
str(response.status))
if response_for_status:
api_response = response_for_status.deserialize(
response, self.api_client.configuration)
else:
api_response = api_client.ApiResponseWithoutDeserialization(
response=response)
if not 200 <= response.status <= 299:
raise exceptions.ApiException(api_response=api_response)
return api_response
