def test_cookielib_compatibility():
cj = CookieJar()
# Set time in order to be still valid in some years, when cookie strings expire
cj._now = cj._policy._now = time.mktime((2012, 1, 1, 0, 0, 0, 0, 0, 0))
request = Request('')
parser = HTTPResponse()
parser.feed(MULTI_COOKIE_RESPONSE)
cookies = cj.make_cookies(parser, request)
# Don't use extract_cookies directly, as time can not be set there manually for testing
for cookie in cookies:
if cj._policy.set_ok(cookie, request):
cj.set_cookie(cookie)
# Three valid, not expired cookies placed
assert len(list(cj)) == 3
def make_cookies(self, response, request):
hm=response.info()
hm.org_getallmatchingheaders=(
hm.getallmatchingheaders
)
def _getallmatchingheaders(name):
s_list=hm.org_getallmatchingheaders(name)
return reparse(name, s_list)
hm.getallmatchingheaders=_getallmatchingheaders
response.info=lambda: hm
return CookieJar.make_cookies(
self, response, request
)
def test_cookielib_compatibility():
cj = CookieJar()
# Set time in order to be still valid in some years, when cookie strings expire
cj._now = cj._policy._now = time.mktime((2012, 1, 1, 0, 0, 0, 0, 0, 0))
request = Request('http://test.com')
parser = HTTPResponse()
parser.feed(MULTI_COOKIE_RESPONSE)
cookies = cj.make_cookies(parser, request)
# Don't use extract_cookies directly, as time can not be set there manually for testing
for cookie in cookies:
if cj._policy.set_ok(cookie, request):
cj.set_cookie(cookie)
# Three valid, not expired cookies placed
assert len(list(cj)) == 3
def web_login():
params = multi_dict_to_dict(request.form)
params = json.dumps(params, ensure_ascii=False)
# Forward the request to the API
url = SERVER_URL + '/api/login'
req = urllib2.Request(url, params)
req.add_header('Content-Type', 'application/json')
try: # Relies on urllib2 returning an exception if the response code from urllib2 indicates "something bad happened"
rsp = urllib2.urlopen(req)
cookie_jar = CookieJar()
session_id_str = cookie_jar.make_cookies(rsp, req)[0].value
response = make_response(redirect(url_for('web_main_page')))
response.set_cookie('sessionID', session_id_str)
return response
except urllib2.HTTPError, error:
return render_template('index.html',
errors=json.loads(error.read())['errors'],
username=request.form['username'])
def testCookieAdapters(self):
jar = CookieJar(policy=None) # DefaultCookiePolicy())
# set a cookie
res = Response()
tstval = str(uuid.uuid4())
res.set_cookie("a-cookie", tstval, domain="example.com")
cookies = jar.make_cookies(filters.ResponseCookieAdapter(res),
Request.blank("http://example.com"))
for c in cookies:
jar.set_cookie(c)
self.assert_(len(jar), ("where's my cookies?"))
self.assert_("a-cookie" in [c.name for c in jar],
"seriously, where's my cookie")
# now put the header on the request please
request = Request.blank("http://example.com")
self.assert_(".example.com" in jar._cookies.keys(),
jar._cookies.keys())
jar.add_cookie_header(filters.RequestCookieAdapter(request))
self.assert_("Cookie" in request.headers,
(str(request), "Y NO COOKIES?"))
def testCookieAdapters(self):
jar = CookieJar(policy=None) # DefaultCookiePolicy())
# set a cookie
res = Response()
tstval = str(uuid.uuid4())
res.set_cookie("a-cookie", tstval, domain="example.com")
cookies = jar.make_cookies(filters.ResponseCookieAdapter(res),
Request.blank("http://example.com"))
for c in cookies:
jar.set_cookie(c)
self.assert_(len(jar), ("where's my cookies?"))
self.assert_("a-cookie" in [c.name for c in jar],
"seriously, where's my cookie")
# now put the header on the request please
request = Request.blank("http://example.com")
self.assert_(".example.com" in jar._cookies.keys(),
jar._cookies.keys())
jar.add_cookie_header(filters.RequestCookieAdapter(request))
self.assert_("Cookie" in request.headers,
(str(request), "Y NO COOKIES?"))
def request(self):
self.response_text = self._DEFAULT_RESPONSE
if not self.exceptions:
self.exceptions = Exception
if not self.wait:
self.wait = time.sleep
if not self.headers:
self.headers = {}
for i in xrange(self.tries):
self.current_tries = i + 1
if self.before_request:
self.before_request(self)
if self.cancel_operation and self.cancel_operation():
break
request_report = 'Request URL: ' + self.get_url_for_report(
self.url)
request_report += '\nRequest data: ' + Utils.str(self.data)
request_report += '\nRequest headers: ' + Utils.str(
self.get_headers_for_report(self.headers))
response_report = '<response_not_set>'
response = None
try:
Logger.debug(request_report)
req = urllib2.Request(self.url, self.data, self.headers)
response = urllib2.urlopen(req)
self.response_code = response.getcode()
self.response_info = response.info()
self.response_url = response.geturl()
cookiejar = CookieJar()
cookiejar._policy._now = cookiejar._now = int(time.time())
self.response_cookies = cookiejar.make_cookies(response, req)
self.response_text = response.read()
content_length = self.response_info.getheader(
'content-length', -1)
response_report = '\nResponse Headers:\n%s' % Utils.str(
self.response_info)
response_report += '\nResponse (%d) content-length=%s, len=<%s>:\n%s' % (
self.response_code, content_length, len(
self.response_text), self.response_text)
self.success = True
break
except self.exceptions as e:
root_exception = e
response_report = '\nResponse <Exception>: '
if isinstance(e, urllib2.HTTPError):
response_report += Utils.str(e.read())
else:
response_report += Utils.str(e)
rex = RequestException(Utils.str(e), root_exception,
request_report, response_report)
if self.on_exception:
self.on_exception(self, rex)
if self.cancel_operation and self.cancel_operation():
break
if self.current_tries == self.tries:
if self.on_failure:
self.on_failure(self)
if self.on_complete:
self.on_complete(self)
Logger.debug('Raising exception...')
raise rex
current_time = time.time()
max_waiting_time = current_time + self.current_delay
while (not self.cancel_operation
or not self.cancel_operation()
) and max_waiting_time > current_time:
remaining = round(max_waiting_time - current_time)
if self.waiting_retry:
self.waiting_retry(self, remaining)
self.wait(1)
current_time = time.time()
self.current_delay *= self.backoff
finally:
Logger.debug(response_report)
if response:
response.close()
if self.success and self.on_success:
self.on_success(self)
if self.on_complete:
self.on_complete(self)
return self.response_text
def request(self):
self.response_text = self._DEFAULT_RESPONSE
if not self.exceptions:
self.exceptions = Exception
if not self.wait:
self.wait = time.sleep
if not self.headers:
self.headers = {}
for i in xrange(self.tries):
self.current_tries = i + 1
if self.before_request:
self.before_request(self)
if self.cancel_operation and self.cancel_operation():
break
request_report = 'Request URL: ' + self.get_url_for_report(
self.url)
request_report += '\nRequest data: ' + Utils.str(self.data)
request_report += '\nRequest headers: ' + Utils.str(
self.get_headers_for_report(self.headers))
response_report = '<response_not_set>'
response = None
rex = None
download_file = None
try:
Logger.debug(request_report)
req = urllib2.Request(self.url, self.data, self.headers)
response = urllib2.urlopen(req)
self.response_code = response.getcode()
self.response_info = response.info()
self.response_url = response.geturl()
cookiejar = CookieJar()
cookiejar._policy._now = cookiejar._now = int(time.time())
self.response_cookies = cookiejar.make_cookies(response, req)
if self.read_content:
if self.download_path:
self.response_text = 'Downloading to: ' + self.download_path + '... '
download_file = KodiUtils.file(self.download_path,
'wb')
self.download_progress = 0
while True:
chunk = response.read(self.DOWNLOAD_CHUNK_SIZE)
if not chunk:
break
download_file.write(chunk)
self.download_progress += self.DOWNLOAD_CHUNK_SIZE
if self.on_update_download:
self.on_update_download(self)
self.response_text += ' OK.'
else:
self.response_text = response.read()
content_length = self.response_info.getheader(
'content-length', -1)
response_report = '\nResponse Headers:\n%s' % Utils.str(
self.response_info)
response_report += '\nResponse (%d) content-length=%s, len=<%s>:\n' % (
self.response_code,
content_length,
len(self.response_text),
)
try:
response_report += Utils.str(self.response_text)
except:
response_report += '<possible binary content>'
self.success = True
break
except self.exceptions as e:
Logger.debug('Exception...')
root_exception = e
response_report = '\nResponse <Exception>: '
if isinstance(e, urllib2.HTTPError):
self.response_code = e.code
self.response_text = Utils.str(e.read())
response_report += self.response_text
else:
response_report += Utils.str(e)
rex = RequestException(Utils.str(e), root_exception,
request_report, response_report)
finally:
try:
if download_file:
download_file.close()
Logger.debug(response_report)
except:
Logger.debug('unable to print response_report')
if response:
response.close()
if rex:
if self.on_exception:
Logger.debug('calling self.on_exception...')
self.on_exception(self, rex)
if self.cancel_operation and self.cancel_operation():
break
Logger.debug('current_tries: ' + str(self.current_tries) +
' maximum tries: ' + str(self.tries) + ' i: ' +
str(i))
if self.current_tries == self.tries:
Logger.debug('max retries reached')
if self.on_failure:
self.on_failure(self)
if self.on_complete:
self.on_complete(self)
Logger.debug('Raising exception...')
raise rex
current_time = time.time()
max_waiting_time = current_time + self.current_delay
Logger.debug('current_delay: ' + str(self.current_delay) +
' seconds. Waiting...')
while (not self.cancel_operation
or not self.cancel_operation()
) and max_waiting_time > current_time:
remaining = round(max_waiting_time - current_time)
if self.waiting_retry:
Logger.debug('calling self.waiting_retry...')
self.waiting_retry(self, remaining)
self.wait(1)
current_time = time.time()
Logger.debug('Done waiting.')
self.current_delay *= self.backoff
if self.success and self.on_success:
self.on_success(self)
if self.on_complete:
self.on_complete(self)
return self.response_text
