def test_cookie_as_dict_keeps_len(self):
key = 'some_cookie'
value = 'some_value'
key1 = 'some_cookie1'
value1 = 'some_value1'
jar = requests.cookies.RequestsCookieJar()
jar.set(key, value)
jar.set(key1, value1)
d1 = dict(jar)
d2 = dict(jar.iteritems())
d3 = dict(jar.items())
assert len(jar) == 2
assert len(d1) == 2
assert len(d2) == 2
assert len(d3) == 2
python类cookies()的实例源码
def test_cookie_as_dict_keys(self):
key = 'some_cookie'
value = 'some_value'
key1 = 'some_cookie1'
value1 = 'some_value1'
jar = requests.cookies.RequestsCookieJar()
jar.set(key, value)
jar.set(key1, value1)
keys = jar.keys()
assert keys == list(keys)
# make sure one can use keys multiple times
assert list(keys) == list(keys)
def test_cookie_as_dict_values(self):
key = 'some_cookie'
value = 'some_value'
key1 = 'some_cookie1'
value1 = 'some_value1'
jar = requests.cookies.RequestsCookieJar()
jar.set(key, value)
jar.set(key1, value1)
values = jar.values()
assert values == list(values)
# make sure one can use values multiple times
assert list(values) == list(values)
def test_cookie_as_dict_items(self):
key = 'some_cookie'
value = 'some_value'
key1 = 'some_cookie1'
value1 = 'some_value1'
jar = requests.cookies.RequestsCookieJar()
jar.set(key, value)
jar.set(key1, value1)
items = jar.items()
assert items == list(items)
# make sure one can use items multiple times
assert list(items) == list(items)
def test_cookie_duplicate_names_raises_cookie_conflict_error(self):
key = 'some_cookie'
value = 'some_value'
path = 'some_path'
jar = requests.cookies.RequestsCookieJar()
jar.set(key, value, path=path)
jar.set(key, value)
with pytest.raises(requests.cookies.CookieConflictError):
jar.get(key)
def __init__(self, order_of_redirects):
self.redirects = order_of_redirects
self.calls = []
self.max_redirects = 30
self.cookies = {}
self.trust_env = False
def __init__(self, *, status_code: int = 200, headers: dict = None, cookies: dict = None,
reason: str = None, body: str = None):
body = body or ""
status_code = status_code or 200
headers = headers or {}
cookies = cookies or {}
if isinstance(cookies, RequestsCookieJar):
cookies = dict(cookies)
reason = reason or "OK"
assert isinstance(body, str)
assert isinstance(reason, str)
assert isinstance(headers, dict)
assert isinstance(cookies, dict)
assert isinstance(status_code, int)
assert isinstance(status_code, int)
self.body = body
self.reason = reason
self.headers = headers
self.cookies = cookies
self.status_code = status_code
self.__content_type_cache = None
self.__content_body_cache = None
def build_from_json(cls, **kwargs):
o = cls(status_code=kwargs.get("status_code"),
headers=kwargs.get("headers"),
body=kwargs.get("body"),
cookies=kwargs.get("cookies"),
reason=kwargs.get("reason"))
return o
def request_good(request):
def _new_fn(url: str, *, method: str = "GET", headers: dict = None, body: str = None):
# Get the unique signature for the Query
url_signature = "%s_ok" % make_url_signature(url,
method=method,
headers=headers,
body=body)
response = request.config.cache.get(url_signature, None)
# If response is not cached
if not response:
# Get and store a GOOD requests
raw_response = requests.request(url=url, method=method, headers=headers, data=body)
response = Response(status_code=raw_response.status_code,
headers=dict(raw_response.headers),
cookies=raw_response.cookies,
reason=raw_response.reason,
body=raw_response.text)
request.config.cache.set(url_signature, response.dump_json)
else:
# Recover response from cached info
response = Response.build_from_json(**response)
return response
return _new_fn
def make_request():
def _new_fn(url: str, *, method: str = "GET", headers: dict = None, body: str = None):
raw_response = requests.request(url=url, method=method, headers=headers, data=body)
return Response(status_code=raw_response.status_code,
headers=dict(raw_response.headers),
cookies=raw_response.cookies,
reason=raw_response.reason,
body=raw_response.text)
return _new_fn
def save_cookies(session, filename):
with open(filename, 'w') as f:
f.truncate()
pickle.dump(session.cookies._cookies, f)
return True
def has_cookies():
return os.path.isfile(ConfigUtil.instance().cookies)
def test_set_cookie_on_301(self, httpbin):
s = requests.session()
url = httpbin('cookies/set?foo=bar')
s.get(url)
assert s.cookies['foo'] == 'bar'
def test_cookie_sent_on_redirect(self, httpbin):
s = requests.session()
s.get(httpbin('cookies/set?foo=bar'))
r = s.get(httpbin('redirect/1')) # redirects to httpbin('get')
assert 'Cookie' in r.json()['headers']
def test_cookie_removed_on_expire(self, httpbin):
s = requests.session()
s.get(httpbin('cookies/set?foo=bar'))
assert s.cookies['foo'] == 'bar'
s.get(
httpbin('response-headers'),
params={
'Set-Cookie':
'foo=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT'
}
)
assert 'foo' not in s.cookies
def test_cookie_quote_wrapped(self, httpbin):
s = requests.session()
s.get(httpbin('cookies/set?foo="bar:baz"'))
assert s.cookies['foo'] == '"bar:baz"'
def test_cookie_persists_via_api(self, httpbin):
s = requests.session()
r = s.get(httpbin('redirect/1'), cookies={'foo': 'bar'})
assert 'foo' in r.request.headers['Cookie']
assert 'foo' in r.history[0].request.headers['Cookie']
def test_request_cookies_not_persisted(self, httpbin):
s = requests.session()
s.get(httpbin('cookies'), cookies={'foo': 'baz'})
# Sending a request with cookies should not add cookies to the session
assert not s.cookies
