def open(self, url, data=None):
"""See zope.testbrowser.interfaces.IBrowser"""
url = str(url)
self._start_timer()
try:
try:
try:
self.mech_browser.open(url, data)
except Exception, e:
fix_exception_name(e)
raise
except mechanize.HTTPError, e:
if e.code >= 200 and e.code <= 299:
# 200s aren't really errors
pass
elif self.raiseHttpErrors:
raise
finally:
self._stop_timer()
self._changed()
# if the headers don't have a status, I suppose there can't be an error
if 'Status' in self.headers:
code, msg = self.headers['Status'].split(' ', 1)
code = int(code)
if self.raiseHttpErrors and code >= 400:
raise mechanize.HTTPError(url, code, msg, self.headers, fp=None)
def openNoVisit(self, url_or_path, data=None, site_relative=True):
"""
Copy/paste from zope.testbrowser.Browser.open() to allow opening an URL
without changing the current page. See L{open}.
@see zope.testbrowser.interfaces.IBrowser
"""
if site_relative:
# In case url_or_path is an absolute URL, urljoin() will return
# it, otherwise it is a relative path and will be concatenated to
# ERP5 base URL
url_or_path = urljoin(self._erp5_base_url, url_or_path)
import mechanize
if isinstance(data, dict):
data = urllib.urlencode(data)
response = None
url_or_path = str(url_or_path)
self._logger.debug("Opening: " + url_or_path)
self._start_timer()
try:
try:
try:
response = self.mech_browser.open_novisit(
url_or_path, data)
except Exception, e:
fix_exception_name(e)
raise
except mechanize.HTTPError, e:
if e.code >= 200 and e.code <= 299:
# 200s aren't really errors
pass
elif self.raiseHttpErrors:
raise
finally:
self._stop_timer()
# if the headers don't have a status, I suppose there can't be an error
if 'Status' in self.headers:
code, msg = self.headers['Status'].split(' ', 1)
code = int(code)
if self.raiseHttpErrors and code >= 400:
raise mechanize.HTTPError(url_or_path,
code,
msg,
self.headers,
fp=None)
return response
def https_open(self, request):
r = mechanize.HTTPError("https://example.com/bad", 503, "Oops",
MockHeaders(), BytesIO())
return r
def test_upgrade_response(self):
def is_response(r):
names = "get_data read readline readlines close seek code msg".split(
)
for name in names:
self.assertTrue(hasattr(r, name),
'No attr named: {}'.format(name))
self.assertEqual(r.get_data(), b"test data")
from mechanize._response import upgrade_response, make_headers, make_response, closeable_response, seek_wrapper
data = b"test data"
url = "http://example.com/"
code = 200
msg = "OK"
# Normal response (closeable_response wrapped with seek_wrapper): return a copy
r1 = make_response(data, [], url, code, msg)
r2 = upgrade_response(r1)
is_response(r2)
self.assertIsNot(r1, r2)
self.assertIs(r1.wrapped, r2.wrapped)
# closeable_response with no seek_wrapper: wrap with seek_wrapper
r1 = closeable_response(BytesIO(data), make_headers([]), url, code,
msg)
self.assertRaises(AssertionError, is_response, r1)
r2 = upgrade_response(r1)
is_response(r2)
self.assertIsNot(r1, r2)
self.assertIs(r1, r2.wrapped)
# addinfourl: extract .fp and wrap it with closeable_response and seek_wrapper
from mechanize.polyglot import addinfourl
r1 = addinfourl(BytesIO(data), make_headers([]), url)
self.assertRaises(AssertionError, is_response, r1)
r2 = upgrade_response(r1)
is_response(r2)
self.assertIsNot(r1, r2)
self.assertIsNot(r1, r2.wrapped)
self.assertIs(r1.fp, r2.wrapped.fp)
# addinfourl with code, msg
r1 = addinfourl(BytesIO(data), make_headers([]), url)
r1.code = 206
r1.msg = "cool"
r2 = upgrade_response(r1)
is_response(r2)
self.assertEqual(r2.code, r1.code)
self.assertEqual(r2.msg, r1.msg)
# addinfourl with seek wrapper: cached data is not lost
r1 = addinfourl(BytesIO(data), make_headers([]), url)
r1 = seek_wrapper(r1)
self.assertEqual(r1.read(4), b'test')
r2 = upgrade_response(r1)
is_response(r2)
# addinfourl wrapped with HTTPError -- remains an HTTPError of the same subclass (through horrible trickery)
hdrs = make_headers([])
r1 = addinfourl(BytesIO(data), hdrs, url)
class MyHTTPError(mechanize.HTTPError):
pass
r1 = MyHTTPError(url, code, msg, hdrs, r1)
self.assertRaises(AssertionError, is_response, r1)
r2 = upgrade_response(r1)
is_response(r2)
self.assertIsInstance(r2, MyHTTPError)
name = MyHTTPError.__module__ + '.' + MyHTTPError.__name__
self.assertTrue(
repr(r2).startswith(
'<httperror_seek_wrapper ({} instance) at'.format(name)))
# The trickery does not cause double-wrapping
r3 = upgrade_response(r2)
is_response(r3)
self.assertIsNot(r3, r2)
self.assertIs(r3.wrapped, r2.wrapped)
# Test dynamically-created class __repr__ for case where we have the module name
r4 = addinfourl(BytesIO(data), hdrs, url)
r4 = mechanize.HTTPError(url, code, msg, hdrs, r4)
r4 = upgrade_response(r4)
q = '<httperror_seek_wrapper (urllib2.HTTPError instance) at'
if not mechanize.polyglot.is_py2:
q = q.replace('urllib2', 'urllib.error')
self.assertTrue(repr(r4).startswith(q))
