Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Lib/test/test_urllib2.py

    r2 r391  
    2525        # And more hacking to get it to work on MacOS. This assumes
    2626        # urllib.pathname2url works, unfortunately...
    27         if os.name == 'mac':
    28             fname = '/' + fname.replace(':', '/')
    29         elif os.name == 'riscos':
     27        if os.name == 'riscos':
    3028            import string
    3129            fname = os.expand(fname)
    … …  
    4846                 ('a="b\\"c", d="e\\,f", g="h\\\\i"', ['a="b"c"', 'd="e,f"', 'g="h\\i"'])]
    4947        for string, list in tests:
    50             self.assertEquals(urllib2.parse_http_list(string), list)
     48            self.assertEqual(urllib2.parse_http_list(string), list)
    5149
    5250
    … …  
    289287        self.level = level
    290288
    291     def _set_tunnel(self, host, port=None, headers=None):
     289    def set_tunnel(self, host, port=None, headers=None):
    292290        self._tunnel_host = host
    293291        self._tunnel_port = port
    … …  
    296294        else:
    297295            self._tunnel_headers.clear()
     296
    298297    def request(self, method, url, body=None, headers=None):
    299298        self.method = method
    … …  
    307306            import socket
    308307            raise socket.error()
     308
    309309    def getresponse(self):
    310310        return MockHTTPResponse(MockFile(), {}, 200, "OK")
     311
     312    def close(self):
     313        pass
    311314
    312315class MockHandler:
    … …  
    581584                self.assertEqual((handler, name), calls[i])
    582585                self.assertEqual(len(args), 1)
    583                 self.assert_(isinstance(args[0], Request))
     586                self.assertIsInstance(args[0], Request)
    584587            else:
    585588                # *_response
    586589                self.assertEqual((handler, name), calls[i])
    587590                self.assertEqual(len(args), 2)
    588                 self.assert_(isinstance(args[0], Request))
     591                self.assertIsInstance(args[0], Request)
    589592                # response from opener.open is None, because there's no
    590593                # handler that defines http_open to handle it
    591                 self.assert_(args[1] is None or
     594                self.assertTrue(args[1] is None or
    592595                             isinstance(args[1], MockResponse))
    593596
    … …  
    609612                self.filename, self.filetype = filename, filetype
    610613                return StringIO.StringIO(self.data), len(self.data)
     614            def close(self): pass
    611615
    612616        class NullFTPHandler(urllib2.FTPHandler):
    … …  
    625629        o = h.parent = MockOpener()
    626630
    627         for url, host, port, type_, dirs, filename, mimetype in [
     631        for url, host, port, user, passwd, type_, dirs, filename, mimetype in [
    628632            ("ftp://localhost/foo/bar/baz.html",
    629              "localhost", ftplib.FTP_PORT, "I",
     633             "localhost", ftplib.FTP_PORT, "", "", "I",
     634             ["foo", "bar"], "baz.html", "text/html"),
     635            ("ftp://parrot@localhost/foo/bar/baz.html",
     636             "localhost", ftplib.FTP_PORT, "parrot", "", "I",
     637             ["foo", "bar"], "baz.html", "text/html"),
     638            ("ftp://%25parrot@localhost/foo/bar/baz.html",
     639             "localhost", ftplib.FTP_PORT, "%parrot", "", "I",
     640             ["foo", "bar"], "baz.html", "text/html"),
     641            ("ftp://%2542parrot@localhost/foo/bar/baz.html",
     642             "localhost", ftplib.FTP_PORT, "%42parrot", "", "I",
    630643             ["foo", "bar"], "baz.html", "text/html"),
    631644            ("ftp://localhost:80/foo/bar/",
    632              "localhost", 80, "D",
     645             "localhost", 80, "", "", "D",
    633646             ["foo", "bar"], "", None),
    634647            ("ftp://localhost/baz.gif;type=a",
    635              "localhost", ftplib.FTP_PORT, "A",
     648             "localhost", ftplib.FTP_PORT, "", "", "A",
    636649             [], "baz.gif", None),  # XXX really this should guess image/gif
    637650            ]:
    … …  
    640653            r = h.ftp_open(req)
    641654            # ftp authentication not yet implemented by FTPHandler
    642             self.assert_(h.user == h.passwd == "")
     655            self.assertEqual(h.user, user)
     656            self.assertEqual(h.passwd, passwd)
    643657            self.assertEqual(h.host, socket.gethostbyname(host))
    644658            self.assertEqual(h.port, port)
    … …  
    682696                    data = r.read()
    683697                    headers = r.info()
    684                     newurl = r.geturl()
     698                    respurl = r.geturl()
    685699                finally:
    686700                    r.close()
    … …  
    693707            self.assertEqual(headers["Content-length"], "13")
    694708            self.assertEqual(headers["Last-modified"], modified)
     709            self.assertEqual(respurl, url)
    695710
    696711        for url in [
    … …  
    728743# XXXX bug: fails with OSError, should be URLError
    729744            ("file://ftp.example.com/foo.txt", False),
     745            ("file://somehost//foo/something.txt", True),
     746            ("file://localhost//foo/something.txt", False),
    730747            ]:
    731748            req = Request(url)
    … …  
    734751            # XXXX remove OSError when bug fixed
    735752            except (urllib2.URLError, OSError):
    736                 self.assert_(not ftp)
     753                self.assertTrue(not ftp)
    737754            else:
    738                 self.assert_(o.req is req)
     755                self.assertTrue(o.req is req)
    739756                self.assertEqual(req.type, "ftp")
     757            self.assertEqual(req.type == "ftp", ftp)
    740758
    741759    def test_http(self):
    … …  
    780798            newreq = h.do_request_(req)
    781799            if data is None:  # GET
    782                 self.assert_("Content-length" not in req.unredirected_hdrs)
    783                 self.assert_("Content-type" not in req.unredirected_hdrs)
     800                self.assertNotIn("Content-length", req.unredirected_hdrs)
     801                self.assertNotIn("Content-type", req.unredirected_hdrs)
    784802            else:  # POST
    785803                self.assertEqual(req.unredirected_hdrs["Content-length"], "0")
    … …  
    827845            self.assertEqual(p_ds_req.unredirected_hdrs["Host"],"example.com")
    828846
     847    def test_fixpath_in_weirdurls(self):
     848        # Issue4493: urllib2 to supply '/' when to urls where path does not
     849        # start with'/'
     850
     851        h = urllib2.AbstractHTTPHandler()
     852        o = h.parent = MockOpener()
     853
     854        weird_url = 'http://www.python.org?getspam'
     855        req = Request(weird_url)
     856        newreq = h.do_request_(req)
     857        self.assertEqual(newreq.get_host(),'www.python.org')
     858        self.assertEqual(newreq.get_selector(),'/?getspam')
     859
     860        url_without_path = 'http://www.python.org'
     861        req = Request(url_without_path)
     862        newreq = h.do_request_(req)
     863        self.assertEqual(newreq.get_host(),'www.python.org')
     864        self.assertEqual(newreq.get_selector(),'')
     865
    829866    def test_errors(self):
    830867        h = urllib2.HTTPErrorProcessor()
    … …  
    836873        r = MockResponse(200, "OK", {}, "", url)
    837874        newr = h.http_response(req, r)
    838         self.assert_(r is newr)
    839         self.assert_(not hasattr(o, "proto"))  # o.error not called
     875        self.assertTrue(r is newr)
     876        self.assertTrue(not hasattr(o, "proto"))  # o.error not called
    840877        r = MockResponse(202, "Accepted", {}, "", url)
    841878        newr = h.http_response(req, r)
    842         self.assert_(r is newr)
    843         self.assert_(not hasattr(o, "proto"))  # o.error not called
     879        self.assertTrue(r is newr)
     880        self.assertTrue(not hasattr(o, "proto"))  # o.error not called
    844881        r = MockResponse(206, "Partial content", {}, "", url)
    845882        newr = h.http_response(req, r)
    846         self.assert_(r is newr)
    847         self.assert_(not hasattr(o, "proto"))  # o.error not called
     883        self.assertTrue(r is newr)
     884        self.assertTrue(not hasattr(o, "proto"))  # o.error not called
    848885        # anything else calls o.error (and MockOpener returns None, here)
    849886        r = MockResponse(502, "Bad gateway", {}, "", url)
    850         self.assert_(h.http_response(req, r) is None)
     887        self.assertTrue(h.http_response(req, r) is None)
    851888        self.assertEqual(o.proto, "http")  # o.error called
    852889        self.assertEqual(o.args, (req, r, 502, "Bad gateway", {}))
    … …  
    860897        r = MockResponse(200, "OK", {}, "")
    861898        newreq = h.http_request(req)
    862         self.assert_(cj.ach_req is req is newreq)
    863         self.assertEquals(req.get_origin_req_host(), "example.com")
    864         self.assert_(not req.is_unverifiable())
     899        self.assertTrue(cj.ach_req is req is newreq)
     900        self.assertEqual(req.get_origin_req_host(), "example.com")
     901        self.assertTrue(not req.is_unverifiable())
    865902        newr = h.http_response(req, r)
    866         self.assert_(cj.ec_req is req)
    867         self.assert_(cj.ec_r is r is newr)
     903        self.assertTrue(cj.ec_req is req)
     904        self.assertTrue(cj.ec_r is r is newr)
    868905
    869906    def test_redirect(self):
    … …  
    888925                except urllib2.HTTPError:
    889926                    # 307 in response to POST requires user OK
    890                     self.assert_(code == 307 and data is not None)
     927                    self.assertTrue(code == 307 and data is not None)
    891928                self.assertEqual(o.req.get_full_url(), to_url)
    892929                try:
    893930                    self.assertEqual(o.req.get_method(), "GET")
    894931                except AttributeError:
    895                     self.assert_(not o.req.has_data())
     932                    self.assertTrue(not o.req.has_data())
    896933
    897934                # now it's a GET, there should not be headers regarding content
    898935                # (possibly dragged from before being a POST)
    899936                headers = [x.lower() for x in o.req.headers]
    900                 self.assertTrue("content-length" not in headers)
    901                 self.assertTrue("content-type" not in headers)
     937                self.assertNotIn("content-length", headers)
     938                self.assertNotIn("content-type", headers)
    902939
    903940                self.assertEqual(o.req.headers["Nonsense"],
    904941                                 "viking=withhold")
    905                 self.assert_("Spam" not in o.req.headers)
    906                 self.assert_("Spam" not in o.req.unredirected_hdrs)
     942                self.assertNotIn("Spam", o.req.headers)
     943                self.assertNotIn("Spam", o.req.unredirected_hdrs)
    907944
    908945        # loop detection
    … …  
    939976                             urllib2.HTTPRedirectHandler.max_redirections)
    940977
     978    def test_invalid_redirect(self):
     979        from_url = "http://example.com/a.html"
     980        valid_schemes = ['http', 'https', 'ftp']
     981        invalid_schemes = ['file', 'imap', 'ldap']
     982        schemeless_url = "example.com/b.html"
     983        h = urllib2.HTTPRedirectHandler()
     984        o = h.parent = MockOpener()
     985        req = Request(from_url)
     986        req.timeout = socket._GLOBAL_DEFAULT_TIMEOUT
     987
     988        for scheme in invalid_schemes:
     989            invalid_url = scheme + '://' + schemeless_url
     990            self.assertRaises(urllib2.HTTPError, h.http_error_302,
     991                              req, MockFile(), 302, "Security Loophole",
     992                              MockHeaders({"location": invalid_url}))
     993
     994        for scheme in valid_schemes:
     995            valid_url = scheme + '://' + schemeless_url
     996            h.http_error_302(req, MockFile(), 302, "That's fine",
     997                MockHeaders({"location": valid_url}))
     998            self.assertEqual(o.req.get_full_url(), valid_url)
     999
    9411000    def test_cookie_redirect(self):
    9421001        # cookies shouldn't leak into redirected requests
    … …  
    9531012        o = build_test_opener(hh, hdeh, hrh, cp)
    9541013        o.open("http://www.example.com/")
    955         self.assert_(not hh.req.has_header("Cookie"))
     1014        self.assertTrue(not hh.req.has_header("Cookie"))
     1015
     1016    def test_redirect_fragment(self):
     1017        redirected_url = 'http://www.example.com/index.html#OK\r\n\r\n'
     1018        hh = MockHTTPHandler(302, 'Location: ' + redirected_url)
     1019        hdeh = urllib2.HTTPDefaultErrorHandler()
     1020        hrh = urllib2.HTTPRedirectHandler()
     1021        o = build_test_opener(hh, hdeh, hrh)
     1022        fp = o.open('http://www.example.com')
     1023        self.assertEqual(fp.geturl(), redirected_url.strip())
    9561024
    9571025    def test_proxy(self):
    … …  
    10131081        req.add_header("User-Agent","Grail")
    10141082        self.assertEqual(req.get_host(), "www.example.com")
    1015         self.assertTrue(req._tunnel_host is None)
     1083        self.assertIsNone(req._tunnel_host)
    10161084        r = o.open(req)
    10171085        # Verify Proxy-Authorization gets tunneled to request.
    10181086        # httpsconn req_headers do not have the Proxy-Authorization header but
    10191087        # the req will have.
    1020         self.assertFalse(("Proxy-Authorization","FooBar") in
     1088        self.assertNotIn(("Proxy-Authorization","FooBar"),
    10211089                         https_handler.httpconn.req_headers)
    1022         self.assertTrue(("User-Agent","Grail") in
    1023                         https_handler.httpconn.req_headers)
    1024         self.assertFalse(req._tunnel_host is None)
     1090        self.assertIn(("User-Agent","Grail"),
     1091                      https_handler.httpconn.req_headers)
     1092        self.assertIsNotNone(req._tunnel_host)
    10251093        self.assertEqual(req.get_host(), "proxy.example.com:3128")
    10261094        self.assertEqual(req.get_header("Proxy-authorization"),"FooBar")
    … …  
    10391107                              realm, http_handler, password_manager,
    10401108                              "http://acme.example.com/protected",
    1041                               "http://acme.example.com/protected",
    1042                               )
     1109                              "http://acme.example.com/protected"
     1110                             )
    10431111
    10441112    def test_basic_auth_with_single_quoted_realm(self):
    10451113        self.test_basic_auth(quote_char="'")
     1114
     1115    def test_basic_auth_with_unquoted_realm(self):
     1116        opener = OpenerDirector()
     1117        password_manager = MockPasswordManager()
     1118        auth_handler = urllib2.HTTPBasicAuthHandler(password_manager)
     1119        realm = "ACME Widget Store"
     1120        http_handler = MockHTTPHandler(
     1121            401, 'WWW-Authenticate: Basic realm=%s\r\n\r\n' % realm)
     1122        opener.add_handler(auth_handler)
     1123        opener.add_handler(http_handler)
     1124        msg = "Basic Auth Realm was unquoted"
     1125        with test_support.check_warnings((msg, UserWarning)):
     1126            self._test_basic_auth(opener, auth_handler, "Authorization",
     1127                                  realm, http_handler, password_manager,
     1128                                  "http://acme.example.com/protected",
     1129                                  "http://acme.example.com/protected"
     1130                                 )
     1131
    10461132
    10471133    def test_proxy_basic_auth(self):
    … …  
    10631149
    10641150    def test_basic_and_digest_auth_handlers(self):
    1065         # HTTPDigestAuthHandler threw an exception if it couldn't handle a 40*
     1151        # HTTPDigestAuthHandler raised an exception if it couldn't handle a 40*
    10661152        # response (http://python.org/sf/1479302), where it should instead
    10671153        # return None to allow another handler (especially
    … …  
    11451231        self.assertFalse(http_handler.requests[0].has_header(auth_header))
    11461232
    1147 
    11481233class MiscTests(unittest.TestCase):
    11491234
    … …  
    11901275                break
    11911276        else:
    1192             self.assert_(False)
     1277            self.assertTrue(False)
    11931278
    11941279class RequestTests(unittest.TestCase):
    … …  
    12051290
    12061291    def test_add_data(self):
    1207         self.assert_(not self.get.has_data())
     1292        self.assertTrue(not self.get.has_data())
    12081293        self.assertEqual("GET", self.get.get_method())
    12091294        self.get.add_data("spam")
    1210         self.assert_(self.get.has_data())
     1295        self.assertTrue(self.get.has_data())
    12111296        self.assertEqual("POST", self.get.get_method())
    12121297
    … …  
    12311316
    12321317    def test_proxy(self):
    1233         self.assert_(not self.get.has_proxy())
     1318        self.assertTrue(not self.get.has_proxy())
    12341319        self.get.set_proxy("www.perl.org", "http")
    1235         self.assert_(self.get.has_proxy())
     1320        self.assertTrue(self.get.has_proxy())
    12361321        self.assertEqual("www.python.org", self.get.get_origin_req_host())
    12371322        self.assertEqual("www.perl.org", self.get.get_host())
    12381323
     1324    def test_wrapped_url(self):
     1325        req = Request("<URL:http://www.python.org>")
     1326        self.assertEqual("www.python.org", req.get_host())
     1327
     1328    def test_url_fragment(self):
     1329        req = Request("http://www.python.org/?qs=query#fragment=true")
     1330        self.assertEqual("/?qs=query", req.get_selector())
     1331        req = Request("http://www.python.org/#fun=true")
     1332        self.assertEqual("/", req.get_selector())
     1333
     1334        # Issue 11703: geturl() omits fragment in the original URL.
     1335        url = 'http://docs.python.org/library/urllib2.html#OK'
     1336        req = Request(url)
     1337        self.assertEqual(req.get_full_url(), url)
     1338
     1339    def test_HTTPError_interface(self):
     1340        """
     1341        Issue 13211 reveals that HTTPError didn't implement the URLError
     1342        interface even though HTTPError is a subclass of URLError.
     1343
     1344        >>> err = urllib2.HTTPError(msg='something bad happened', url=None, code=None, hdrs=None, fp=None)
     1345        >>> assert hasattr(err, 'reason')
     1346        >>> err.reason
     1347        'something bad happened'
     1348        """
     1349
     1350    def test_HTTPError_interface_call(self):
     1351        """
     1352        Issue 15701= - HTTPError interface has info method available from URLError.
     1353        """
     1354        err = urllib2.HTTPError(msg='something bad happened', url=None,
     1355                                code=None, hdrs='Content-Length:42', fp=None)
     1356        self.assertTrue(hasattr(err, 'reason'))
     1357        assert hasattr(err, 'reason')
     1358        assert hasattr(err, 'info')
     1359        assert callable(err.info)
     1360        try:
     1361            err.info()
     1362        except AttributeError:
     1363            self.fail("err.info() failed")
     1364        self.assertEqual(err.info(), "Content-Length:42")
    12391365
    12401366def test_main(verbose=None):
Note: See TracChangeset for help on using the changeset viewer.