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 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