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 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 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')