class CookieHandler(object):
def __init__(self, *args, **kw):
# Somewhere to store cookies between consecutive requests
self.cookies = SimpleCookie()
super(CookieHandler, self).__init__(*args, **kw)
def httpCookie(self, path):
"""Return self.cookies as an HTTP_COOKIE environment value."""
l = [m.OutputString().split(';')[0] for m in self.cookies.values()
if path.startswith(m['path'])]
return '; '.join(l)
def loadCookies(self, envstring):
self.cookies.load(envstring)
def saveCookies(self, response):
"""Save cookies from the response."""
# Urgh - need to play with the response's privates to extract
# cookies that have been set
# TODO: extend the IHTTPRequest interface to allow access to all
# cookies
# TODO: handle cookie expirations
for k, v in response._cookies.items():
k = k.encode('utf8')
self.cookies[k] = v['value'].encode('utf8')
if 'path' in v:
self.cookies[k]['path'] = v['path']
def request_started_handler(sender, environ, **kwargs):
if 'HTTP_COOKIE' not in environ:
return
cookie = SimpleCookie()
cookie.load(environ['HTTP_COOKIE'])
user = None
if 'sessionid' in cookie:
session_id = cookie['sessionid'].value
try:
session = Session.objects.get(session_key=session_id)
except Session.DoesNotExist:
session = None
if session:
user_id = session.get_decoded()['_auth_user_id']
try:
user = get_user_model().objects.get(id=user_id)
except:
user = None
if user is None and WRITE_EVENTS_ONLY_LOGGED_IN_USERS:
return
request_event = RequestEvent.objects.create(
uri=environ['PATH_INFO'],
type=environ['REQUEST_METHOD'],
query_string=environ['QUERY_STRING'],
user=user,
remote_ip=environ['REMOTE_ADDR'],
datetime=timezone.now()
)
request_event.save()
class BaseHeaders(CaseInsensitiveMapping):
"""Represent the headers in an HTTP Request or Response message.
"""
def __init__(self, raw):
"""Takes headers as a string.
"""
def genheaders():
for line in raw.splitlines():
k, v = line.split(':', 1)
yield k.strip(), v.strip()
CaseInsensitiveMapping.__init__(self, genheaders)
# Cookie
# ======
self.cookie = SimpleCookie()
try:
self.cookie.load(self.get('Cookie', ''))
except CookieError:
pass # XXX really?
def raw(self):
"""Return the headers as a string, formatted for an HTTP message.
"""
out = []
for header, values in self.iteritems():
for value in values:
out.append('%s: %s' % (header, value))
return '\r\n'.join(out)
raw = property(raw)
def setup(self, environ):
for p in environ:
if len(p) > 5 and 'HTTP_' in p:
hk = p.replace('HTTP_', '')
self.headers[hk] = environ[p]
self.environ = environ
cookie = SimpleCookie()
name = nfw.utils.if_unicode_to_utf8('neutrino')
if 'HTTP_COOKIE' in self.environ:
cookie.load(self.environ['HTTP_COOKIE'])
if name in cookie:
id = nfw.utils.if_unicode_to_utf8(cookie[name].value)
else:
id = nfw.utils.if_unicode_to_utf8(nfw.random_id(16))
self._id = nfw.utils.if_unicode_to_utf8(id)
self._name = "session:%s" % (id, )
cookie[name] = nfw.utils.if_unicode_to_utf8(id)
host = self._get_host(environ)
if host is not None:
cookie[name]['domain'] = host
cookie[name]['max-age'] = self._expire
cookie_string = cookie[name].OutputString()
if hasattr(self, '_load'):
self._load()
return cookie_string
def get_cookie_dict(environ):
"""Return a *plain* dictionary of cookies as found in the request.
Unlike ``get_cookies`` this returns a dictionary, not a
``SimpleCookie`` object. For incoming cookies a dictionary fully
represents the information. Like ``get_cookies`` this caches and
checks the cache.
"""
header = environ.get('HTTP_COOKIE')
if not header:
return {}
if environ.has_key('paste.cookies.dict'):
cookies, check_header = environ['paste.cookies.dict']
if check_header == header:
return cookies
cookies = SimpleCookie()
try:
cookies.load(header)
except CookieError:
pass
result = {}
for name in cookies:
result[name] = cookies[name].value
environ['paste.cookies.dict'] = (result, header)
return result
def username(cookie, name=None):
""" try to extract username from PAS cookie """
if cookie is not None:
cookies = SimpleCookie()
try:
cookies.load(cookie)
except CookieError:
return name
if cookie_name in cookies:
# Deal with doubly quoted cookies
ac_cookie = repeatedly_unquote(cookies[cookie_name].value)
try:
ac = decodestring(ac_cookie + '=====')
except (TypeError, binascii.Error):
return name
# plone.session 3.x (Plone 4.x)
if '!' in ac[40:]:
name, user_data = ac[40:].split('!', 1)
# plone.session 2.x (Plone 3.x)
elif ' ' in ac[20:21]:
name = ac[21:]
# PluggableAuthService.CookieAuthHelper
elif ':' in ac:
user, pwd = ac.split(':', 1)
# PluggableAuthService >= 1.5
try:
name = user.decode('hex')
# PluggableAuthService < 1.5
except TypeError:
name = user
return name
def is_present(mpkt):
hdrs = mpkt.cfields.get('dissector.http.headers', None)
if not hdrs:
return False
if 'cookie' in hdrs:
for cstr in hdrs['cookie']:
cookie = SimpleCookie()
cookie.load(cstr)
for k, mar in cookie.items():
cookies[k].append(mar.value)
return True
elif 'set-cookie' in hdrs:
for cstr in hdrs['set-cookie']:
cookie = SimpleCookie()
cookie.load(cstr)
for k, mar in cookie.items():
cookies[k].append(mar.value)
return True
return False
def get_cookie_value(environ, name):
c = SimpleCookie()
c.load(environ.get('HTTP_COOKIE', ''))
try:
return c[name].value
except:
return ""
class cookie:
def __init__( self ):
self.cookieObj = SimpleCookie()
self.load()
def load( self ):
if not os.environ.has_key("HTTP_COOKIE"):
# Kein Cookie vorhanden
return
self.cookieObj.load( os.environ["HTTP_COOKIE"] )
def readCookie( self, CookieName ):
if self.cookieObj == False:
# Gibt kein Cookie
return False
if self.cookieObj.has_key(CookieName):
return self.cookieObj[CookieName].value
else:
return False
def debug( self ):
print "Cookie-Debug:"
print "<hr><pre>"
if not os.environ.has_key("HTTP_COOKIE"):
print "There is no HTTP_COOKIE in os.environ:\n"
for k,v in os.environ.iteritems(): print k,v
else:
print self.cookieObj
print "</pre><hr>"
def getSessionId(request_cookie):
cookie = SimpleCookie()
cookie.load(request_cookie)
try:
sessionId = int((cookie['id']).value)
except CookieError, ValueError:
sessionId = sessions.AddNewSession({'num' : 0, 'auth' : False})
def determineKey(handler):
hdr = handler.headers.getheader('Cookie')
if not hdr: return Session.generateKey()
c = SimpleCookie()
c.load(hdr)
return c['session'].value if c.has_key(
'session') else Session.generateKey()
def get_cookie(self, name):
cookie_str = self.request.headers.get('cookie')
if not cookie_str:
return None
cookie = SimpleCookie()
cookie.load(cookie_str)
return cookie[name].value;
def parseStrToCookies(self, cookieStr):
SC = SimpleCookie()
SC.load(cookieStr)
cookies = {}
for key, morsel in SC.items():
cookies[key] = morsel.value
return cookies
def __get_params(self):
self._kwargs = self.__get_query_params()
self._cog_ajax = self._kwargs.get('cog_ajax')
self.__cog_target = self._kwargs.get('cog_target')
self._cog_raw = self._kwargs.get('cog_raw', None)
self._cog_method = self._kwargs.get('cog_method', None)
# cog_method must not contain non-word caracters
assert self._cog_method is None or \
re.search('\W', self._cog_method) is None
if self._cog_method is not None and self._cog_method[0] == '_':
# we never should receive a protected method...
self._cog_method = "w3error"
self._kwargs['cog_method'] = "w3error"
self._kwargs['cog_error'] = "Can't call a protected method!"
self._cog_ref_oid = self._kwargs.get('cog_ref_oid', None)
self._cog_oid_ = self._kwargs.get('cog_oid_', None)
self._session_key = None
if 'HTTP_COOKIE' in self._environ:
cookie_string = self._environ.get('HTTP_COOKIE')
cookie = SimpleCookie()
cookie.load(cookie_string)
if 'cog_session' in cookie:
self._session_key = cookie['cog_session'].value
self.__cog_environment = self.__get_env()
self._cog_fqtn_ = self._kwargs.get('cog_fqtn_', None)
if self._cog_ref_oid and self._cog_ref_oid == self._cog_oid_:
self._cog_oid_ = None
self._kwargs['cog_controller'] = self
self._kwargs['cog_first_call'] = True
def is_present(mpkt):
hdrs = mpkt.cfields.get('dissector.http.headers', None)
if not hdrs:
return False
if 'cookie' in hdrs:
for cstr in hdrs['cookie']:
cookie = SimpleCookie()
cookie.load(cstr)
for k, mar in cookie.items():
cookies[k].append(mar.value)
return True
elif 'set-cookie' in hdrs:
for cstr in hdrs['set-cookie']:
cookie = SimpleCookie()
cookie.load(cstr)
for k, mar in cookie.items():
cookies[k].append(mar.value)
return True
return False
class CookieScraper(object):
"Scraper that keeps track of getting and setting cookies."
def __init__(self):
self._cookies = SimpleCookie()
def get_page(self, url, post_data=None, headers=()):
"""
Helper method that gets the given URL, handling the sending and storing
of cookies. Returns the requested page as a string.
"""
socket.timeout(300)
opener = urllib.URLopener()
opener.addheader('Cookie', self._cookies.output(attrs=[], header='',
sep=';').strip())
for k, v in headers:
opener.addheader(k, v)
try:
f = opener.open(url, post_data)
except IOError, e:
if e[1] == 302:
# Got a 302 redirect, but check for cookies before redirecting.
# e[3] is a httplib.HTTPMessage instance.
if e[3].dict.has_key('set-cookie'):
self._cookies.load(e[3].dict['set-cookie'])
return self.get_page(e[3].getheader('location'))
else:
raise
if f.headers.dict.has_key('set-cookie'):
self._cookies.load(f.headers.dict['set-cookie'])
return f.read()
class CookieHandler(object):
def __init__(self, *args, **kw):
# Somewhere to store cookies between consecutive requests
self.cookies = SimpleCookie()
super(CookieHandler, self).__init__(*args, **kw)
def httpCookie(self, path):
"""Return self.cookies as an HTTP_COOKIE environment value."""
l = [m.OutputString() for m in self.cookies.values()
if path.startswith(m['path'])]
return '; '.join(l)
def loadCookies(self, envstring):
self.cookies.load(envstring)
def saveCookies(self, response):
"""Save cookies from the response."""
# Urgh - need to play with the response's privates to extract
# cookies that have been set
for k,v in response._cookies.items():
k = k.encode('utf8')
self.cookies[k] = v['value'].encode('utf8')
if self.cookies[k].has_key('Path'):
self.cookies[k]['Path'] = v['Path']
def process_request(self, context, start_response):
_cookie = SimpleCookie()
if 'HTTP_COOKIE' in context:
_cookie.load(context['HTTP_COOKIE'])
_protocol = str(context.get('SERVER_PROTOCOL', 'HTTP/1.1'))
if _protocol.startswith('HTTPS'):
_is_secure = True
else:
_is_secure = False
session_id = None
if self.SESSION_KEY in _cookie:
session_id = _cookie[self.SESSION_KEY].value
if not session_id:
session_id = str(uuid.UUID(bytes=OpenSSL.rand.bytes(16)))
push_environ_args(context, self.SESSION_LOCAL_NAME, session_id)
def _start_response(status, response_headers, exc_info=None):
cookie = SimpleCookie()
cookie[self.SESSION_KEY] = session_id
cookie[self.SESSION_KEY]['path'] = '/'
if _is_secure:
cookie[self.SESSION_KEY]['http'] = True
cookie[self.SESSION_KEY]['secure'] = True
cookie_string = cookie[self.SESSION_KEY].OutputString()
response_headers.append(('Set-Cookie', cookie_string))
return start_response(status, response_headers, exc_info)
return super(SessionMiddleware,
self).process_request(context, _start_response)
def get_cookie_dict(environ):
"""Return a *plain* dictionary of cookies as found in the request.
Unlike ``get_cookies`` this returns a dictionary, not a
``SimpleCookie`` object. For incoming cookies a dictionary fully
represents the information. Like ``get_cookies`` this caches and
checks the cache.
"""
header = environ.get('HTTP_COOKIE')
if not header:
return {}
if environ.has_key('paste.cookies.dict'):
cookies, check_header = environ['paste.cookies.dict']
if check_header == header:
return cookies
cookies = SimpleCookie()
try:
cookies.load(header)
except CookieError:
pass
result = {}
for name in cookies:
result[name] = cookies[name].value
environ['paste.cookies.dict'] = (result, header)
return result
class Headers(BaseHeaders):
"""Model headers in an HTTP Request message.
"""
def __init__(self, raw):
"""Extend BaseHeaders to add extra attributes.
"""
BaseHeaders.__init__(self, raw)
# Cookie
# ======
self.cookie = SimpleCookie()
try:
self.cookie.load(self.get('Cookie', ''))
except CookieError:
pass # XXX really?
# Host
# ====
# Per the spec, respond with 400 if no Host header is given. However,
# we prefer X-Forwarded-For if that is available.
host = self.get('X-Forwarded-Host', self['Host']) # KeyError raises 400
self.host = UnicodeWithRaw(host, encoding='idna')
# Scheme
# ======
# http://docs.python.org/library/wsgiref.html#wsgiref.util.guess_scheme
scheme = 'https' if self.get('HTTPS', False) else 'http'
self.scheme = UnicodeWithRaw(scheme)
class CookieScraper(object):
"Scraper that keeps track of getting and setting cookies."
def __init__(self):
self._cookies = SimpleCookie()
def get_page(self, url, post_data=None, headers=()):
"""
Helper method that gets the given URL, handling the sending and storing
of cookies. Returns the requested page as a string.
"""
opener = urllib.URLopener()
opener.addheader('Cookie',
self._cookies.output(attrs=[], header='').strip())
for k, v in headers:
opener.addheader(k, v)
try:
f = opener.open(url, post_data)
except IOError, e:
if e[1] == 302:
# Got a 302 redirect, but check for cookies before redirecting.
# e[3] is a httplib.HTTPMessage instance.
if e[3].dict.has_key('set-cookie'):
self._cookies.load(e[3].dict['set-cookie'])
return self.get_page(e[3].getheader('location'))
else:
raise
if f.headers.dict.has_key('set-cookie'):
self._cookies.load(f.headers.dict['set-cookie'])
return f.read()
def get_cookies(str):
cookie = SimpleCookie()
cookie.load(str)
cookies = {}
for key, morsel in cookie.items():
cookies[key] = morsel.value
return cookies
def cookies(self, rawdata):
"""Set Response Cookies.
:param rawdata: (str or dict). List of `cookielib.Cookie`.
"""
sc = SimpleCookie()
sc.load(rawdata)
self._cookies = sc.items()
def cookies(self):
from Cookie import SimpleCookie
cookie = SimpleCookie()
cookie.load(self.environ.get('HTTP_COOKIE', ''))
result = {}
for key, value in cookie.iteritems():
result[key] = value
return result
def get_cookies(str):
cookie = SimpleCookie()
cookie.load(str)
cookies = {}
for key, morsel in cookie.items():
cookies[key] = morsel.value
return cookies
def cookies(self, rawdata):
"""Set Response Cookies.
:param rawdata: (str or dict). List of `cookielib.Cookie`.
"""
sc = SimpleCookie()
sc.load(rawdata)
self._cookies = sc.items()
def test_cookie_credentials_plaintext(self):
fetch_arguments = build_fetch_arguments("/foobar")
credentials = CookieCredentials("auth", "token")
credentials(fetch_arguments)
cookie = SimpleCookie()
cookie.load(fetch_arguments.headers["Cookie"])
self.assertTrue("auth" in cookie)
self.assertEqual("token", cookie["auth"].value)
def __call__(self, environ, start_response):
sc = SimpleCookie()
if 'HTTP_COOKIE' in environ:
sc.load(environ.get('HTTP_COOKIE'))
ses = Session(ExpressSession(sc))
ses.read()
environ['express.session'] = ses
return self.app(environ, start_response)
def cookies(self):
"""Stored Cookies."""
cookie = SimpleCookie()
cookie.load(self.environ.get('HTTP_COOKIE', ''))
result = {}
for key, value in cookie.iteritems():
result[key] = value.value.decode(self.charset, 'ignore')
return result
def cookies(self):
"""Stored Cookies."""
cookie = SimpleCookie()
cookie.load(self.environ.get('HTTP_COOKIE', ''))
result = {}
for key, value in cookie.iteritems():
result[key] = value.value.decode(self.charset, 'ignore')
return result
def load_username(cookie):
c = SimpleCookie()
c.load(cookie)
try:
return c["username"].value
except:
return ""
def __call__(self, environ, start_response):
sc = SimpleCookie()
if 'HTTP_COOKIE' in environ:
sc.load(environ.get('HTTP_COOKIE'))
ses = Session(ExpressSession(sc))
ses.read()
environ['express.session'] = ses
return self.app(environ, start_response)
def test_cookie_credentials_plaintext(self):
fetch_arguments = build_fetch_arguments("/foobar")
credentials = CookieCredentials("auth", "token")
credentials(fetch_arguments)
cookie = SimpleCookie()
cookie.load(fetch_arguments.headers["Cookie"])
self.assertTrue("auth" in cookie)
self.assertEqual("token", cookie["auth"].value)
def cookies(self, name=None):
""" add method to get Cookie """
cookies = self.environ.get('HTTP_COOKIE', '')
c*k = SimpleCookie()
try:
c*k.load(cookies)
except CookieError, msg:
return c*k
def cookies(self, name=None):
""" add method to get Cookie """
cookies = self.environ.get('HTTP_COOKIE', '')
c*k = SimpleCookie()
try:
c*k.load(cookies)
except CookieError, msg:
return c*k
def get_cookie(self, key):
in_cookies = SimpleCookie()
request_cookies = self.headers.get('Cookie')
if request_cookies:
in_cookies.load(request_cookies)
val = in_cookies.get(key)
return val.value if val else None
return None
def get_cookie(self, key):
in_cookies = SimpleCookie()
request_cookies = self.headers.get('Cookie')
if request_cookies:
in_cookies.load(request_cookies)
val = in_cookies.get(key)
return val.value if val else None
return None
def load_username(cookie):
c = SimpleCookie()
c.load(cookie)
try:
return c["username"].value
except:
return ""
def _parse_cookies(cookies):
if not cookies:
return {}
cookie = SimpleCookie()
cookie.load(cookies)
return {key: cookie[key].coded_value for key in cookie.keys()}
def parse_cookies(environ):
#transform the cookie environment into a SimpleCokkie object
line = environ.get('HTTP_COOKIE', None)
if line:
cook = SimpleCookie()
cook.load(line)
return cook
else:
return None
def parse_cookie(cookie):
if cookie == '':
return {}
c = SimpleCookie()
c.load(cookie)
cookiedict = {}
for key in c.keys():
cookiedict[key] = c.get(key).value
return cookiedict
def _get_cookies(self, response):
c = SimpleCookie()
for h, v in response.getheaders():
if h == 'set-cookie':
c.load(v)
for cookie in c.itervalues():
domain = cookie['domain'].rstrip(',').lstrip('.') or response.host
self.cookies[domain][cookie.key] = cookie
def load(self, rawdata, ignore_parse_errors=False):
if ignore_parse_errors:
self.bad_cookies = []
self._BaseCookie__set = self._loose_set
SimpleCookie.load(self, rawdata)
if ignore_parse_errors:
self._BaseCookie__set = self._strict_set
for key in self.bad_cookies:
del self[key]
def load(self, rawdata, ignore_parse_errors=False):
if ignore_parse_errors:
self.bad_cookies = []
self._BaseCookie__set = self._loose_set
SimpleCookie.load(self, rawdata)
if ignore_parse_errors:
self._BaseCookie__set = self._strict_set
for key in self.bad_cookies:
del self[key]
def session_cookie(self):
cookie = SimpleCookie()
if "HTTP_COOKIE" in environ:
cookie.load(environ["HTTP_COOKIE"])
if self.COOKIE_NAME not in cookie:
cookie[self.COOKIE_NAME] = uuid4().hex
return cookie
def parse_cookie(cookie):
if cookie == '':
return {}
c = SimpleCookie()
c.load(cookie)
cookiedict = {}
for key in c.keys():
cookiedict[key] = c.get(key).value
return cookiedict
def _make_cookie(cookie_headers):
def _add_dash(match_obj):
return match_obj.group(0).replace(' ', '-')
cookie = SimpleCookie()
set_cookie_str = re.sub(r'\d{2}\s\w+\s\d{4}', _add_dash, cookie_headers)
cookie.load(set_cookie_str)
return cookie
def login():
confdir = findconffolder()
conf = ConfigParser.ConfigParser()
conf.read(join(confdir, "config"))
# make the url and credentials
url = join(conf.get("resources", "url"), "authenticate/login")
username = raw_input("Username: "******"Password: "******"username": username, "password": password})
parsed_url = urlparse(url)
host = parsed_url.netloc
if parsed_url.scheme == "https":
conn = httplib.HTTPSConnection(host)
else:
conn = httplib.HTTPConnection(host)
response = conn.request("POST", parsed_url.path, creds, {"Content-type": "application/x-www-form-urlencoded"})
response = conn.getresponse()
if response.status > 400:
raise LoginError(
"Login to %s failed with the following message: %s %s (%s)"
% (url, response.status, response.reason, response.msg)
)
response.read()
setcookie = response.getheader("Set-Cookie")
if setcookie == None:
raise LoginError(
"Login failed. This is usually because of "
"invalid username/password, but might be "
"caused by wrong login urlprefix or server errors. "
"Technical error message: Login urlprefix did not "
"respond with any authorization cookies."
)
cookie = SimpleCookie()
cookie.load(setcookie)
cookieout = cookie.output().replace("Set-Cookie: ", "")
session = open(join(confdir, "session"), "w")
session.write(cookieout)
session.close()
chmod(join(confdir, "session"), stat.S_IRUSR | stat.S_IWUSR)
conf.set("resources", "user", username)
with open(join(confdir, "config"), "wb") as f:
conf.write(f)
return cookieout
def _parse_cookies(self):
cookies = {}
cookie_data = self.environ.get('HTTP_COOKIE', '')
if cookie_data:
_parsed = SimpleCookie()
_parsed.load(cookie_data)
for name in _parsed:
cookies[name] = _parsed[name].value
self._request_cookies = cookies
self._cookies_parsed = 1
def clear_username(cookie):
c = SimpleCookie()
c.load(cookie)
expires = datetime.datetime(2000, 2, 14, 18, 30, 14) + datetime.timedelta(hours=1)
c["username"]["expires"] = expires.strftime("%a, %d %b %Y %H:%M:%S")
s = c.output()
(key, value) = s.split(": ")
return (key, value)
def _parse_cookies(self):
cookies = {}
cookie_data = self.environ.get('HTTP_COOKIE', '')
if cookie_data:
_parsed = SimpleCookie()
_parsed.load(cookie_data)
for name in _parsed:
cookies[name] = _parsed[name].value
self._request_cookies = cookies
self._cookies_parsed = 1
def _handle_cookies(self, response):
# type: (httplib.HTTPResponse) -> None
"""
Parse cookies from |HTTP| response and store for next request.
:param httplib.HTTPResponse: The |HTTP| response.
"""
# FIXME: this cookie handling doesn't respect path, domain and expiry
cookies = SimpleCookie()
cookies.load(response.getheader('set-cookie', ''))
self.cookies.update(dict((cookie.key, cookie.value) for cookie in cookies.values()))
def _get_cookie(self, request, name):
cookie_str = request.environ.get('HTTP_COOKIE')
if not cookie_str:
return
cookie = SimpleCookie()
cookie.load(cookie_str)
if name not in cookie:
return
value = cookie.get(name).value
if value != 'unset_%s' % name:
return json.loads(base64.b64decode(value))
def __retrieve_cookie_values(self, raw_string):
cookies = {}
cookie = SimpleCookie()
cookie.load(raw_string)
for key, morsel in cookie.items():
if any(name.lower() in key.lower()
for name in Scanner.cookie_keys):
cookies[key] = morsel.value
return cookies
def getcookie(self, key, default=''):
try:
#load the cookies from the environ dict's HTTP_COOKIE
c = SimpleCookie()
c.load(self.environ['HTTP_COOKIE'])
#return the value of the cookie
return str(c[key].value)
except KeyError:
return default
def clear_username(cookie):
c = SimpleCookie()
c.load(cookie)
expires = datetime.datetime(2000, 2, 14, 18, 30,
14) + datetime.timedelta(hours=1)
c['username']['expires'] = expires.strftime('%a, %d %b %Y %H:%M:%S')
s = c.output()
(key, value) = s.split(': ')
return (key, value)
def test_get_json(yahoo_response, cookies):
response = yahoo_response('v2/groups/groupname/files/a/2?param1=c¶m2=4', {'result': 'returned data'})
yga = YahooGroupsAPI('groupname', cookies)
json = yga.get_json('files', 'a', 2, param1='c', param2=4)
request = response.calls[0].request
request_cookies = SimpleCookie()
request_cookies.load(request.headers['Cookie'])
assert dict(cookies) == {k: v.value for k, v in request_cookies.items()}
assert json == {'result': 'returned data'}
