def open(self, fullurl, data=None,
timeout=_sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
self.calls.append((fullurl, data, timeout))
headers = [("Foo", "Bar")]
if self._content_length is not None:
if self._content_length is True:
content_length = str(len(self.data))
else:
content_length = str(self._content_length)
headers.append(("content-length", content_length))
return _response.test_response(self.data, headers)
def open(self, fullurl, data=None):
from mechanize import _response
self.calls.append((fullurl, data))
headers = [("Foo", "Bar")]
if self._content_length is not None:
if self._content_length is True:
content_length = str(len(self.data))
else:
content_length = str(self._content_length)
headers.append(("content-length", content_length))
return _response.test_response(self.data, headers)
def open(self, fullurl, data=None,
timeout=_sockettimeout._GLOBAL_DEFAULT_TIMEOUT):
self.calls.append((fullurl, data, timeout))
headers = [("Foo", "Bar")]
if self._content_length is not None:
if self._content_length is True:
content_length = str(len(self.data))
else:
content_length = str(self._content_length)
headers.append(("content-length", content_length))
return _response.test_response(self.data, headers)
def http_open(self, requst):
return test_response(data, [("content-type", "text/html")])
def http_open(self, request):
r = _response.test_response(url=request.get_full_url())
# these tests aren't interested in auto-.reload() behaviour of
# .back(), so read the response to prevent that happening
r.get_data()
return r
def http_open(self, requst):
return test_response(data, [("content-type", "text/html")])
def http_open(self, request):
r = _response.test_response(url=request.get_full_url())
# these tests aren't interested in auto-.reload() behaviour of
# .back(), so read the response to prevent that happening
r.get_data()
return r
def open(self):
self.opened()
response = _response.test_response("spam")
return ResponseCloseWrapper(response, self.closed, self._read)
def test_read_complete(self):
text = b"To err is human, to moo, bovine.\n" * 10
def get_wrapper():
from mechanize._response import seek_wrapper
f = BytesIO(text)
wr = seek_wrapper(f)
return wr
wr = get_wrapper()
self.assertFalse(wr.read_complete)
wr.read()
self.assertTrue(wr.read_complete)
wr.seek(0)
self.assertTrue(wr.read_complete)
wr = get_wrapper()
wr.read(10)
self.assertFalse(wr.read_complete)
wr.readline()
self.assertFalse(wr.read_complete)
wr.seek(0, 2)
self.assertTrue(wr.read_complete)
wr.seek(0)
self.assertTrue(wr.read_complete)
wr = get_wrapper()
wr.readlines()
self.assertTrue(wr.read_complete)
wr.seek(0)
self.assertTrue(wr.read_complete)
wr = get_wrapper()
wr.seek(10)
self.assertFalse(wr.read_complete)
wr.seek(1000000)
wr = get_wrapper()
wr.read(1000000)
# we read to the end, but don't know it yet
self.assertFalse(wr.read_complete)
wr.read(10)
self.assertTrue(wr.read_complete)
wr = get_wrapper()
wr.read(len(text) - 10)
self.assertFalse(wr.read_complete)
wr.readline()
# we read to the end, but don't know it yet
self.assertFalse(wr.read_complete)
wr.readline()
self.assertTrue(wr.read_complete)
# Test copying and sharing of .read_complete state
wr = get_wrapper()
wr2 = copy.copy(wr)
self.assertFalse(wr.read_complete)
self.assertFalse(wr2.read_complete)
wr2.read()
self.assertTrue(wr.read_complete)
self.assertTrue(wr2.read_complete)
# Fix from -r36082: .read() after .close() used to break
# .read_complete state
from mechanize._response import test_response
r = test_response(text)
r.read(64)
r.close()
self.assertFalse(r.read_complete)
self.assertFalse(r.read())
''
self.assertFalse(r.read_complete)
def open(self):
self.opened()
response = _response.test_response("spam")
return ResponseCloseWrapper(response, self.closed, self._read)
def test_misc_browser_tests(self):
class TestHttpHandler(mechanize.BaseHandler):
def http_open(self, request):
return mechanize._response.test_response(
url=request.get_full_url())
class TestHttpBrowser(TestBrowser2):
handler_classes = TestBrowser2.handler_classes.copy()
handler_classes["http"] = TestHttpHandler
default_schemes = ["http"]
def response_impl(response):
return response.wrapped.fp.__class__.__name__
br = TestHttpBrowser()
r = br.open("http://example.com")
self.assertEqual('BytesIO', response_impl(r))
r2 = br.open("http://example.com")
self.assertEqual('BytesIO', response_impl(r2))
self.assertEqual('eofresponse', response_impl(r))
br.set_response(mechanize._response.test_response())
self.assertEqual('eofresponse', response_impl(r2))
br = TestHttpBrowser()
r = br.open("http://example.com")
r2 = mechanize._response.test_response(url="http://example.com/2")
self.assertEqual(response_impl(r2), 'BytesIO')
br.visit_response(r2)
self.assertEqual(response_impl(r), 'eofresponse')
self.assertEqual(br.geturl(), br.request.get_full_url())
self.assertEqual(br.geturl(), "http://example.com/2")
br.back()
self.assertEqual(br.geturl(), br.request.get_full_url())
self.assertEqual(br.geturl(), "http://example.com")
class ReloadCheckBrowser(TestHttpBrowser):
reloaded = False
def reload(self):
self.reloaded = True
return TestHttpBrowser.reload(self)
br = ReloadCheckBrowser()
old = br.open("http://example.com")
br.open("http://example.com/2")
new = br.back()
self.assertTrue(br.reloaded)
self.assertIsNot(new.wrapped, old.wrapped)
br = TestBrowser2()
self.assertRaises(ValueError, br.set_response, 'blah')
self.assertRaises(ValueError, br.set_response, BytesIO())
self.assertRaises(mechanize.URLError, br.open, "http://example.com")
self.assertRaises(mechanize.URLError, br.reload)
br = TestBrowser2()
br.add_handler(
make_mock_handler(mechanize._response.test_response)([("http_open",
None)]))
self.assertIsNone(br.response())
self.assertEqual(len(br._history._history), 0)
br.open("http://example.com/1")
self.assertIsNotNone(br.response())
self.assertEqual(len(br._history._history), 0)
br.clear_history()
self.assertIsNotNone(br.response())
self.assertEqual(len(br._history._history), 0)
br.open("http://example.com/2")
br.response() is not None
self.assertIsNotNone(br.response())
self.assertEqual(len(br._history._history), 1)
br.clear_history()
self.assertIsNotNone(br.response())
self.assertEqual(len(br._history._history), 0)
from test.test_urllib2 import MockHTTPHandler
def make_browser_with_redirect():
br = TestBrowser2()
hh = MockHTTPHandler(302, "Location: http://example.com/\r\n\r\n")
br.add_handler(hh)
br.add_handler(mechanize.HTTPRedirectHandler())
return br
def test_state(br):
self.assertIsNone(br.request)
self.assertIsNone(br.response())
self.assertRaises(mechanize.BrowserStateError, br.back)
br = make_browser_with_redirect()
test_state(br)
req = mechanize.Request("http://example.com")
req.visit = False
br.open(req)
test_state(br)
br = make_browser_with_redirect()
test_state(br)
req = mechanize.Request("http://example.com")
self.assertIsNone(req.visit)
br.open_novisit(req)
test_state(br)
self.assertFalse(req.visit)
def test_one_visit(handlers):
br = TestBrowser2()
for handler in handlers:
br.add_handler(handler)
req = mechanize.Request("http://example.com")
req.visit = True
br.open(req)
return br
def test_state(br):
# XXX the _history._history check is needed because of the weird
# throwing-away of history entries by .back() where response is
# None, which makes the .back() check insufficient to tell if a
# history entry was .add()ed. I don't want to change this until
# post-stable.
self.assertTrue(br.response())
self.assertTrue(br.request)
self.assertEqual(len(br._history._history), 0)
self.assertRaises(mechanize.BrowserStateError, br.back)
from test.test_urllib2 import HTTPRedirectHandler
hh = MockHTTPHandler(302, "Location: http://example.com/\r\n\r\n")
br = test_one_visit([hh, HTTPRedirectHandler()])
test_state(br)
class MockPasswordManager:
def add_password(self, realm, uri, user, password):
pass
def find_user_password(self, realm, authuri):
return '', ''
ah = mechanize.HTTPBasicAuthHandler(MockPasswordManager())
hh = MockHTTPHandler(401,
'WWW-Authenticate: Basic realm="realm"\r\n\r\n')
test_state(test_one_visit([hh, ah]))
ph = mechanize.ProxyHandler(dict(http="proxy.example.com:3128"))
ah = mechanize.ProxyBasicAuthHandler(MockPasswordManager())
hh = MockHTTPHandler(
407, 'Proxy-Authenticate: Basic realm="realm"\r\n\r\n')
test_state(test_one_visit([ph, hh, ah]))
from mechanize._response import test_response
br = TestBrowser2()
html = b"""\
<html><body>
<input type="text" name="a" />
<form><input type="text" name="b" /></form>
</body></html>
"""
response = test_response(html, headers=[("Content-type", "text/html")])
self.assertRaises(mechanize.BrowserStateError, br.global_form)
br.set_response(response)
self.assertEqual(str(br.global_form().find_control(nr=0).name), 'a')
self.assertEqual(len(list(br.forms())), 1)
self.assertEqual(str(next(iter(br.forms())).find_control(nr=0).name),
'b')
from mechanize._response import test_html_response
br = TestBrowser2()
br.visit_response(
test_html_response(b"""\
<html><head><title></title></head><body>
<input type="text" name="a" value="b"></input>
<form>
<input type="text" name="p" value="q"></input>
</form>
</body></html>"""))
def has_a(form):
try:
form.find_control(name="a")
except mechanize.ControlNotFoundError:
return False
else:
return True
br.select_form(predicate=has_a)
self.assertEqual(str(br.form.find_control(name="a").value), 'b')
