Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 1 | #!/usr/bin/env python |
| 2 | |
Barry Warsaw | 820c120 | 2008-06-12 04:06:45 +0000 | [diff] [blame] | 3 | import email |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 4 | import threading |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 5 | import urllib.parse |
| 6 | import urllib.request |
Georg Brandl | 2442015 | 2008-05-26 16:32:26 +0000 | [diff] [blame] | 7 | import http.server |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 8 | import unittest |
| 9 | import hashlib |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 10 | from test import support |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 11 | |
| 12 | # Loopback http server infrastructure |
| 13 | |
Georg Brandl | 2442015 | 2008-05-26 16:32:26 +0000 | [diff] [blame] | 14 | class LoopbackHttpServer(http.server.HTTPServer): |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 15 | """HTTP server w/ a few modifications that make it useful for |
| 16 | loopback testing purposes. |
| 17 | """ |
| 18 | |
| 19 | def __init__(self, server_address, RequestHandlerClass): |
Georg Brandl | 2442015 | 2008-05-26 16:32:26 +0000 | [diff] [blame] | 20 | http.server.HTTPServer.__init__(self, |
| 21 | server_address, |
| 22 | RequestHandlerClass) |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 23 | |
| 24 | # Set the timeout of our listening socket really low so |
| 25 | # that we can stop the server easily. |
| 26 | self.socket.settimeout(1.0) |
| 27 | |
| 28 | def get_request(self): |
Georg Brandl | 2442015 | 2008-05-26 16:32:26 +0000 | [diff] [blame] | 29 | """HTTPServer method, overridden.""" |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 30 | |
| 31 | request, client_address = self.socket.accept() |
| 32 | |
| 33 | # It's a loopback connection, so setting the timeout |
| 34 | # really low shouldn't affect anything, but should make |
| 35 | # deadlocks less likely to occur. |
| 36 | request.settimeout(10.0) |
| 37 | |
| 38 | return (request, client_address) |
| 39 | |
| 40 | class LoopbackHttpServerThread(threading.Thread): |
| 41 | """Stoppable thread that runs a loopback http server.""" |
| 42 | |
Guido van Rossum | 806c246 | 2007-08-06 23:33:07 +0000 | [diff] [blame] | 43 | def __init__(self, request_handler): |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 44 | threading.Thread.__init__(self) |
Guido van Rossum | 4566c71 | 2007-08-21 03:36:47 +0000 | [diff] [blame] | 45 | self._stop_server = False |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 46 | self.ready = threading.Event() |
Guido van Rossum | 806c246 | 2007-08-06 23:33:07 +0000 | [diff] [blame] | 47 | request_handler.protocol_version = "HTTP/1.0" |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 48 | self.httpd = LoopbackHttpServer(("127.0.0.1", 0), |
Guido van Rossum | 806c246 | 2007-08-06 23:33:07 +0000 | [diff] [blame] | 49 | request_handler) |
| 50 | #print "Serving HTTP on %s port %s" % (self.httpd.server_name, |
| 51 | # self.httpd.server_port) |
| 52 | self.port = self.httpd.server_port |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 53 | |
| 54 | def stop(self): |
| 55 | """Stops the webserver if it's currently running.""" |
| 56 | |
| 57 | # Set the stop flag. |
Guido van Rossum | 4566c71 | 2007-08-21 03:36:47 +0000 | [diff] [blame] | 58 | self._stop_server = True |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 59 | |
| 60 | self.join() |
| 61 | |
| 62 | def run(self): |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 63 | self.ready.set() |
Guido van Rossum | 4566c71 | 2007-08-21 03:36:47 +0000 | [diff] [blame] | 64 | while not self._stop_server: |
Guido van Rossum | 806c246 | 2007-08-06 23:33:07 +0000 | [diff] [blame] | 65 | self.httpd.handle_request() |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 66 | |
| 67 | # Authentication infrastructure |
| 68 | |
| 69 | class DigestAuthHandler: |
| 70 | """Handler for performing digest authentication.""" |
| 71 | |
| 72 | def __init__(self): |
| 73 | self._request_num = 0 |
| 74 | self._nonces = [] |
| 75 | self._users = {} |
| 76 | self._realm_name = "Test Realm" |
| 77 | self._qop = "auth" |
| 78 | |
| 79 | def set_qop(self, qop): |
| 80 | self._qop = qop |
| 81 | |
| 82 | def set_users(self, users): |
| 83 | assert isinstance(users, dict) |
| 84 | self._users = users |
| 85 | |
| 86 | def set_realm(self, realm): |
| 87 | self._realm_name = realm |
| 88 | |
| 89 | def _generate_nonce(self): |
| 90 | self._request_num += 1 |
Guido van Rossum | 8136014 | 2007-08-29 14:26:52 +0000 | [diff] [blame] | 91 | nonce = hashlib.md5(str(self._request_num).encode("ascii")).hexdigest() |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 92 | self._nonces.append(nonce) |
| 93 | return nonce |
| 94 | |
| 95 | def _create_auth_dict(self, auth_str): |
| 96 | first_space_index = auth_str.find(" ") |
| 97 | auth_str = auth_str[first_space_index+1:] |
| 98 | |
| 99 | parts = auth_str.split(",") |
| 100 | |
| 101 | auth_dict = {} |
| 102 | for part in parts: |
| 103 | name, value = part.split("=") |
| 104 | name = name.strip() |
| 105 | if value[0] == '"' and value[-1] == '"': |
| 106 | value = value[1:-1] |
| 107 | else: |
| 108 | value = value.strip() |
| 109 | auth_dict[name] = value |
| 110 | return auth_dict |
| 111 | |
| 112 | def _validate_auth(self, auth_dict, password, method, uri): |
| 113 | final_dict = {} |
| 114 | final_dict.update(auth_dict) |
| 115 | final_dict["password"] = password |
| 116 | final_dict["method"] = method |
| 117 | final_dict["uri"] = uri |
| 118 | HA1_str = "%(username)s:%(realm)s:%(password)s" % final_dict |
Guido van Rossum | 8136014 | 2007-08-29 14:26:52 +0000 | [diff] [blame] | 119 | HA1 = hashlib.md5(HA1_str.encode("ascii")).hexdigest() |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 120 | HA2_str = "%(method)s:%(uri)s" % final_dict |
Guido van Rossum | 8136014 | 2007-08-29 14:26:52 +0000 | [diff] [blame] | 121 | HA2 = hashlib.md5(HA2_str.encode("ascii")).hexdigest() |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 122 | final_dict["HA1"] = HA1 |
| 123 | final_dict["HA2"] = HA2 |
| 124 | response_str = "%(HA1)s:%(nonce)s:%(nc)s:" \ |
| 125 | "%(cnonce)s:%(qop)s:%(HA2)s" % final_dict |
Guido van Rossum | 8136014 | 2007-08-29 14:26:52 +0000 | [diff] [blame] | 126 | response = hashlib.md5(response_str.encode("ascii")).hexdigest() |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 127 | |
| 128 | return response == auth_dict["response"] |
| 129 | |
| 130 | def _return_auth_challenge(self, request_handler): |
| 131 | request_handler.send_response(407, "Proxy Authentication Required") |
| 132 | request_handler.send_header("Content-Type", "text/html") |
| 133 | request_handler.send_header( |
| 134 | 'Proxy-Authenticate', 'Digest realm="%s", ' |
| 135 | 'qop="%s",' |
| 136 | 'nonce="%s", ' % \ |
| 137 | (self._realm_name, self._qop, self._generate_nonce())) |
| 138 | # XXX: Not sure if we're supposed to add this next header or |
| 139 | # not. |
| 140 | #request_handler.send_header('Connection', 'close') |
| 141 | request_handler.end_headers() |
Guido van Rossum | 8a392d7 | 2007-11-21 22:09:45 +0000 | [diff] [blame] | 142 | request_handler.wfile.write(b"Proxy Authentication Required.") |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 143 | return False |
| 144 | |
| 145 | def handle_request(self, request_handler): |
| 146 | """Performs digest authentication on the given HTTP request |
| 147 | handler. Returns True if authentication was successful, False |
| 148 | otherwise. |
| 149 | |
| 150 | If no users have been set, then digest auth is effectively |
| 151 | disabled and this method will always return True. |
| 152 | """ |
| 153 | |
| 154 | if len(self._users) == 0: |
| 155 | return True |
| 156 | |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 157 | if "Proxy-Authorization" not in request_handler.headers: |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 158 | return self._return_auth_challenge(request_handler) |
| 159 | else: |
| 160 | auth_dict = self._create_auth_dict( |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 161 | request_handler.headers["Proxy-Authorization"] |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 162 | ) |
| 163 | if auth_dict["username"] in self._users: |
| 164 | password = self._users[ auth_dict["username"] ] |
| 165 | else: |
| 166 | return self._return_auth_challenge(request_handler) |
| 167 | if not auth_dict.get("nonce") in self._nonces: |
| 168 | return self._return_auth_challenge(request_handler) |
| 169 | else: |
| 170 | self._nonces.remove(auth_dict["nonce"]) |
| 171 | |
| 172 | auth_validated = False |
| 173 | |
| 174 | # MSIE uses short_path in its validation, but Python's |
| 175 | # urllib2 uses the full path, so we're going to see if |
| 176 | # either of them works here. |
| 177 | |
| 178 | for path in [request_handler.path, request_handler.short_path]: |
| 179 | if self._validate_auth(auth_dict, |
| 180 | password, |
| 181 | request_handler.command, |
| 182 | path): |
| 183 | auth_validated = True |
| 184 | |
| 185 | if not auth_validated: |
| 186 | return self._return_auth_challenge(request_handler) |
| 187 | return True |
| 188 | |
| 189 | # Proxy test infrastructure |
| 190 | |
Georg Brandl | 2442015 | 2008-05-26 16:32:26 +0000 | [diff] [blame] | 191 | class FakeProxyHandler(http.server.BaseHTTPRequestHandler): |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 192 | """This is a 'fake proxy' that makes it look like the entire |
| 193 | internet has gone down due to a sudden zombie invasion. It main |
| 194 | utility is in providing us with authentication support for |
| 195 | testing. |
| 196 | """ |
| 197 | |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 198 | def __init__(self, digest_auth_handler, *args, **kwargs): |
| 199 | # This has to be set before calling our parent's __init__(), which will |
| 200 | # try to call do_GET(). |
| 201 | self.digest_auth_handler = digest_auth_handler |
| 202 | http.server.BaseHTTPRequestHandler.__init__(self, *args, **kwargs) |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 203 | |
| 204 | def log_message(self, format, *args): |
| 205 | # Uncomment the next line for debugging. |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 206 | # sys.stderr.write(format % args) |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 207 | pass |
| 208 | |
| 209 | def do_GET(self): |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 210 | (scm, netloc, path, params, query, fragment) = urllib.parse.urlparse( |
| 211 | self.path, "http") |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 212 | self.short_path = path |
| 213 | if self.digest_auth_handler.handle_request(self): |
| 214 | self.send_response(200, "OK") |
| 215 | self.send_header("Content-Type", "text/html") |
| 216 | self.end_headers() |
Guido van Rossum | 8a392d7 | 2007-11-21 22:09:45 +0000 | [diff] [blame] | 217 | self.wfile.write(bytes("You've reached %s!<BR>" % self.path, |
| 218 | "ascii")) |
| 219 | self.wfile.write(b"Our apologies, but our server is down due to " |
| 220 | b"a sudden zombie invasion.") |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 221 | |
| 222 | # Test cases |
| 223 | |
| 224 | class ProxyAuthTests(unittest.TestCase): |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 225 | URL = "http://localhost" |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 226 | |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 227 | USER = "tester" |
| 228 | PASSWD = "test123" |
| 229 | REALM = "TestRealm" |
| 230 | |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 231 | def setUp(self): |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 232 | self.digest_auth_handler = DigestAuthHandler() |
| 233 | self.digest_auth_handler.set_users({self.USER: self.PASSWD}) |
| 234 | self.digest_auth_handler.set_realm(self.REALM) |
| 235 | def create_fake_proxy_handler(*args, **kwargs): |
| 236 | return FakeProxyHandler(self.digest_auth_handler, *args, **kwargs) |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 237 | |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 238 | self.server = LoopbackHttpServerThread(create_fake_proxy_handler) |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 239 | self.server.start() |
| 240 | self.server.ready.wait() |
Guido van Rossum | 806c246 | 2007-08-06 23:33:07 +0000 | [diff] [blame] | 241 | proxy_url = "http://127.0.0.1:%d" % self.server.port |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 242 | handler = urllib.request.ProxyHandler({"http" : proxy_url}) |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 243 | self.proxy_digest_handler = urllib.request.ProxyDigestAuthHandler() |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 244 | self.opener = urllib.request.build_opener( |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 245 | handler, self.proxy_digest_handler) |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 246 | |
| 247 | def tearDown(self): |
| 248 | self.server.stop() |
| 249 | |
| 250 | def test_proxy_with_bad_password_raises_httperror(self): |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 251 | self.proxy_digest_handler.add_password(self.REALM, self.URL, |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 252 | self.USER, self.PASSWD+"bad") |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 253 | self.digest_auth_handler.set_qop("auth") |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 254 | self.assertRaises(urllib.error.HTTPError, |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 255 | self.opener.open, |
| 256 | self.URL) |
| 257 | |
| 258 | def test_proxy_with_no_password_raises_httperror(self): |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 259 | self.digest_auth_handler.set_qop("auth") |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 260 | self.assertRaises(urllib.error.HTTPError, |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 261 | self.opener.open, |
| 262 | self.URL) |
| 263 | |
| 264 | def test_proxy_qop_auth_works(self): |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 265 | self.proxy_digest_handler.add_password(self.REALM, self.URL, |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 266 | self.USER, self.PASSWD) |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 267 | self.digest_auth_handler.set_qop("auth") |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 268 | result = self.opener.open(self.URL) |
| 269 | while result.read(): |
| 270 | pass |
| 271 | result.close() |
| 272 | |
| 273 | def test_proxy_qop_auth_int_works_or_throws_urlerror(self): |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 274 | self.proxy_digest_handler.add_password(self.REALM, self.URL, |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 275 | self.USER, self.PASSWD) |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 276 | self.digest_auth_handler.set_qop("auth-int") |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 277 | try: |
| 278 | result = self.opener.open(self.URL) |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 279 | except urllib.error.URLError: |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 280 | # It's okay if we don't support auth-int, but we certainly |
| 281 | # shouldn't receive any kind of exception here other than |
| 282 | # a URLError. |
| 283 | result = None |
| 284 | if result: |
| 285 | while result.read(): |
| 286 | pass |
| 287 | result.close() |
| 288 | |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 289 | |
| 290 | def GetRequestHandler(responses): |
| 291 | |
Georg Brandl | 2442015 | 2008-05-26 16:32:26 +0000 | [diff] [blame] | 292 | class FakeHTTPRequestHandler(http.server.BaseHTTPRequestHandler): |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 293 | |
| 294 | server_version = "TestHTTP/" |
| 295 | requests = [] |
| 296 | headers_received = [] |
| 297 | port = 80 |
| 298 | |
| 299 | def do_GET(self): |
| 300 | body = self.send_head() |
| 301 | if body: |
| 302 | self.wfile.write(body) |
| 303 | |
| 304 | def do_POST(self): |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 305 | content_length = self.headers["Content-Length"] |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 306 | post_data = self.rfile.read(int(content_length)) |
| 307 | self.do_GET() |
| 308 | self.requests.append(post_data) |
| 309 | |
| 310 | def send_head(self): |
| 311 | FakeHTTPRequestHandler.headers_received = self.headers |
| 312 | self.requests.append(self.path) |
| 313 | response_code, headers, body = responses.pop(0) |
| 314 | |
| 315 | self.send_response(response_code) |
| 316 | |
| 317 | for (header, value) in headers: |
Antoine Pitrou | b353c12 | 2009-02-11 00:39:14 +0000 | [diff] [blame] | 318 | self.send_header(header, value % {'port':self.port}) |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 319 | if body: |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 320 | self.send_header("Content-type", "text/plain") |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 321 | self.end_headers() |
| 322 | return body |
| 323 | self.end_headers() |
| 324 | |
| 325 | def log_message(self, *args): |
| 326 | pass |
| 327 | |
| 328 | |
| 329 | return FakeHTTPRequestHandler |
| 330 | |
| 331 | |
| 332 | class TestUrlopen(unittest.TestCase): |
| 333 | """Tests urllib2.urlopen using the network. |
| 334 | |
| 335 | These tests are not exhaustive. Assuming that testing using files does a |
| 336 | good job overall of some of the basic interface features. There are no |
| 337 | tests exercising the optional 'data' and 'proxies' arguments. No tests |
| 338 | for transparent redirection have been written. |
| 339 | """ |
| 340 | |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 341 | def setUp(self): |
| 342 | self.server = None |
| 343 | |
| 344 | def tearDown(self): |
| 345 | if self.server is not None: |
| 346 | self.server.stop() |
| 347 | |
| 348 | def urlopen(self, url, data=None): |
Antoine Pitrou | b353c12 | 2009-02-11 00:39:14 +0000 | [diff] [blame] | 349 | l = [] |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 350 | f = urllib.request.urlopen(url, data) |
Antoine Pitrou | b353c12 | 2009-02-11 00:39:14 +0000 | [diff] [blame] | 351 | try: |
| 352 | # Exercise various methods |
| 353 | l.extend(f.readlines(200)) |
| 354 | l.append(f.readline()) |
| 355 | l.append(f.read(1024)) |
| 356 | l.append(f.read()) |
| 357 | finally: |
| 358 | f.close() |
| 359 | return b"".join(l) |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 360 | |
| 361 | def start_server(self, responses=None): |
| 362 | if responses is None: |
| 363 | responses = [(200, [], b"we don't care")] |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 364 | handler = GetRequestHandler(responses) |
| 365 | |
| 366 | self.server = LoopbackHttpServerThread(handler) |
| 367 | self.server.start() |
| 368 | self.server.ready.wait() |
| 369 | port = self.server.port |
| 370 | handler.port = port |
| 371 | return handler |
| 372 | |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 373 | def test_redirection(self): |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 374 | expected_response = b"We got here..." |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 375 | responses = [ |
Antoine Pitrou | b353c12 | 2009-02-11 00:39:14 +0000 | [diff] [blame] | 376 | (302, [("Location", "http://localhost:%(port)s/somewhere_else")], |
| 377 | ""), |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 378 | (200, [], expected_response) |
| 379 | ] |
| 380 | |
| 381 | handler = self.start_server(responses) |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 382 | data = self.urlopen("http://localhost:%s/" % handler.port) |
| 383 | self.assertEquals(data, expected_response) |
| 384 | self.assertEquals(handler.requests, ["/", "/somewhere_else"]) |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 385 | |
Antoine Pitrou | b353c12 | 2009-02-11 00:39:14 +0000 | [diff] [blame] | 386 | def test_chunked(self): |
| 387 | expected_response = b"hello world" |
| 388 | chunked_start = ( |
| 389 | b'a\r\n' |
| 390 | b'hello worl\r\n' |
| 391 | b'1\r\n' |
| 392 | b'd\r\n' |
| 393 | b'0\r\n' |
| 394 | ) |
| 395 | response = [(200, [("Transfer-Encoding", "chunked")], chunked_start)] |
| 396 | handler = self.start_server(response) |
| 397 | data = self.urlopen("http://localhost:%s/" % handler.port) |
| 398 | self.assertEquals(data, expected_response) |
| 399 | |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 400 | def test_404(self): |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 401 | expected_response = b"Bad bad bad..." |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 402 | handler = self.start_server([(404, [], expected_response)]) |
| 403 | |
| 404 | try: |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 405 | self.urlopen("http://localhost:%s/weeble" % handler.port) |
| 406 | except urllib.error.URLError as f: |
| 407 | data = f.read() |
| 408 | f.close() |
| 409 | else: |
| 410 | self.fail("404 should raise URLError") |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 411 | |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 412 | self.assertEquals(data, expected_response) |
| 413 | self.assertEquals(handler.requests, ["/weeble"]) |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 414 | |
| 415 | def test_200(self): |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 416 | expected_response = b"pycon 2008..." |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 417 | handler = self.start_server([(200, [], expected_response)]) |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 418 | data = self.urlopen("http://localhost:%s/bizarre" % handler.port) |
| 419 | self.assertEquals(data, expected_response) |
| 420 | self.assertEquals(handler.requests, ["/bizarre"]) |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 421 | |
| 422 | def test_200_with_parameters(self): |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 423 | expected_response = b"pycon 2008..." |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 424 | handler = self.start_server([(200, [], expected_response)]) |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 425 | data = self.urlopen("http://localhost:%s/bizarre" % handler.port, |
| 426 | b"get=with_feeling") |
| 427 | self.assertEquals(data, expected_response) |
| 428 | self.assertEquals(handler.requests, ["/bizarre", b"get=with_feeling"]) |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 429 | |
| 430 | def test_sending_headers(self): |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 431 | handler = self.start_server() |
| 432 | req = urllib.request.Request("http://localhost:%s/" % handler.port, |
| 433 | headers={"Range": "bytes=20-39"}) |
| 434 | urllib.request.urlopen(req) |
| 435 | self.assertEqual(handler.headers_received["Range"], "bytes=20-39") |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 436 | |
| 437 | def test_basic(self): |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 438 | handler = self.start_server() |
| 439 | open_url = urllib.request.urlopen("http://localhost:%s" % handler.port) |
| 440 | for attr in ("read", "close", "info", "geturl"): |
| 441 | self.assert_(hasattr(open_url, attr), "object returned from " |
| 442 | "urlopen lacks the %s attribute" % attr) |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 443 | try: |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 444 | self.assert_(open_url.read(), "calling 'read' failed") |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 445 | finally: |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 446 | open_url.close() |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 447 | |
| 448 | def test_info(self): |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 449 | handler = self.start_server() |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 450 | try: |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 451 | open_url = urllib.request.urlopen( |
| 452 | "http://localhost:%s" % handler.port) |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 453 | info_obj = open_url.info() |
Barry Warsaw | 820c120 | 2008-06-12 04:06:45 +0000 | [diff] [blame] | 454 | self.assert_(isinstance(info_obj, email.message.Message), |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 455 | "object returned by 'info' is not an instance of " |
Barry Warsaw | 820c120 | 2008-06-12 04:06:45 +0000 | [diff] [blame] | 456 | "email.message.Message") |
| 457 | self.assertEqual(info_obj.get_content_subtype(), "plain") |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 458 | finally: |
| 459 | self.server.stop() |
| 460 | |
| 461 | def test_geturl(self): |
| 462 | # Make sure same URL as opened is returned by geturl. |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 463 | handler = self.start_server() |
| 464 | open_url = urllib.request.urlopen("http://localhost:%s" % handler.port) |
| 465 | url = open_url.geturl() |
| 466 | self.assertEqual(url, "http://localhost:%s" % handler.port) |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 467 | |
| 468 | def test_bad_address(self): |
| 469 | # Make sure proper exception is raised when connecting to a bogus |
| 470 | # address. |
| 471 | self.assertRaises(IOError, |
| 472 | # SF patch 809915: In Sep 2003, VeriSign started |
| 473 | # highjacking invalid .com and .net addresses to |
| 474 | # boost traffic to their own site. This test |
| 475 | # started failing then. One hopes the .invalid |
| 476 | # domain will be spared to serve its defined |
| 477 | # purpose. |
Jeremy Hylton | 1afc169 | 2008-06-18 20:49:58 +0000 | [diff] [blame] | 478 | urllib.request.urlopen, |
Antoine Pitrou | 8fd33d3 | 2008-12-15 13:08:55 +0000 | [diff] [blame] | 479 | "http://sadflkjsasf.i.nvali.d/") |
Christian Heimes | bbe741d | 2008-03-28 10:53:29 +0000 | [diff] [blame] | 480 | |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 481 | def test_main(): |
Collin Winter | 9a4414d | 2009-05-18 22:32:26 +0000 | [diff] [blame] | 482 | support.run_unittest(ProxyAuthTests, TestUrlopen) |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 483 | |
| 484 | if __name__ == "__main__": |
| 485 | test_main() |