← Back to branch summary

~ubuntu-branches/ubuntu/lucid/python2.6/lucid

« back to all changes in this revision

Viewing changes to Lib/test/test_urllib2.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2010-03-11 13:30:19 UTC
  • mto: (10.1.13 sid)
  • mto: This revision was merged to the branch mainline in revision 44.
  • Revision ID: james.westby@ubuntu.com-20100311133019-sblbooa3uqrkoe70
Tags: upstream-2.6.5~rc2
Import upstream version 2.6.5~rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/test/test_urllib2.py
21
21
 
22
22
        # XXX Name hacking to get this to work on Windows.
23
23
        fname = os.path.abspath(urllib2.__file__).replace('\\', '/')
24
 
        if fname[1:2] == ":":
25
 
            fname = fname[2:]
 
24
 
26
25
        # And more hacking to get it to work on MacOS. This assumes
27
26
        # urllib.pathname2url works, unfortunately...
28
27
        if os.name == 'mac':
32
31
            fname = os.expand(fname)
33
32
            fname = fname.translate(string.maketrans("/.", "./"))
34
33
 
35
 
        file_url = "file://%s" % fname
 
34
        if os.name == 'nt':
 
35
            file_url = "file:///%s" % fname
 
36
        else:
 
37
            file_url = "file://%s" % fname
 
38
 
36
39
        f = urllib2.urlopen(file_url)
37
40
 
38
41
        buf = f.read()
261
264
    def __call__(self, *args):
262
265
        return self.handle(self.meth_name, self.action, *args)
263
266
 
 
267
class MockHTTPResponse:
 
268
    def __init__(self, fp, msg, status, reason):
 
269
        self.fp = fp
 
270
        self.msg = msg
 
271
        self.status = status
 
272
        self.reason = reason
 
273
    def read(self):
 
274
        return ''
 
275
 
 
276
class MockHTTPClass:
 
277
    def __init__(self):
 
278
        self.req_headers = []
 
279
        self.data = None
 
280
        self.raise_on_endheaders = False
 
281
        self._tunnel_headers = {}
 
282
 
 
283
    def __call__(self, host, timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
 
284
        self.host = host
 
285
        self.timeout = timeout
 
286
        return self
 
287
 
 
288
    def set_debuglevel(self, level):
 
289
        self.level = level
 
290
 
 
291
    def _set_tunnel(self, host, port=None, headers=None):
 
292
        self._tunnel_host = host
 
293
        self._tunnel_port = port
 
294
        if headers:
 
295
            self._tunnel_headers = headers
 
296
        else:
 
297
            self._tunnel_headers.clear()
 
298
    def request(self, method, url, body=None, headers=None):
 
299
        self.method = method
 
300
        self.selector = url
 
301
        if headers is not None:
 
302
            self.req_headers += headers.items()
 
303
        self.req_headers.sort()
 
304
        if body:
 
305
            self.data = body
 
306
        if self.raise_on_endheaders:
 
307
            import socket
 
308
            raise socket.error()
 
309
    def getresponse(self):
 
310
        return MockHTTPResponse(MockFile(), {}, 200, "OK")
 
311
 
264
312
class MockHandler:
265
313
    # useful for testing handler machinery
266
314
    # see add_ordered_mock_handlers() docstring
368
416
            msg = mimetools.Message(StringIO("\r\n\r\n"))
369
417
            return MockResponse(200, "OK", msg, "", req.get_full_url())
370
418
 
 
419
class MockHTTPSHandler(urllib2.AbstractHTTPHandler):
 
420
    # Useful for testing the Proxy-Authorization request by verifying the
 
421
    # properties of httpcon
 
422
 
 
423
    def __init__(self):
 
424
        urllib2.AbstractHTTPHandler.__init__(self)
 
425
        self.httpconn = MockHTTPClass()
 
426
 
 
427
    def https_open(self, req):
 
428
        return self.do_open(self.httpconn, req)
 
429
 
371
430
class MockPasswordManager:
372
431
    def add_password(self, realm, uri, user, password):
373
432
        self.realm = realm
680
739
                self.assertEqual(req.type, "ftp")
681
740
 
682
741
    def test_http(self):
683
 
        class MockHTTPResponse:
684
 
            def __init__(self, fp, msg, status, reason):
685
 
                self.fp = fp
686
 
                self.msg = msg
687
 
                self.status = status
688
 
                self.reason = reason
689
 
            def read(self):
690
 
                return ''
691
 
        class MockHTTPClass:
692
 
            def __init__(self):
693
 
                self.req_headers = []
694
 
                self.data = None
695
 
                self.raise_on_endheaders = False
696
 
            def __call__(self, host, timeout=socket._GLOBAL_DEFAULT_TIMEOUT):
697
 
                self.host = host
698
 
                self.timeout = timeout
699
 
                return self
700
 
            def set_debuglevel(self, level):
701
 
                self.level = level
702
 
            def request(self, method, url, body=None, headers={}):
703
 
                self.method = method
704
 
                self.selector = url
705
 
                self.req_headers += headers.items()
706
 
                self.req_headers.sort()
707
 
                if body:
708
 
                    self.data = body
709
 
                if self.raise_on_endheaders:
710
 
                    import socket
711
 
                    raise socket.error()
712
 
            def getresponse(self):
713
 
                return MockHTTPResponse(MockFile(), {}, 200, "OK")
714
742
 
715
743
        h = urllib2.AbstractHTTPHandler()
716
744
        o = h.parent = MockOpener()
974
1002
        self.assertEqual([(handlers[0], "https_open")],
975
1003
                         [tup[0:2] for tup in o.calls])
976
1004
 
 
1005
    def test_proxy_https_proxy_authorization(self):
 
1006
        o = OpenerDirector()
 
1007
        ph = urllib2.ProxyHandler(dict(https='proxy.example.com:3128'))
 
1008
        o.add_handler(ph)
 
1009
        https_handler = MockHTTPSHandler()
 
1010
        o.add_handler(https_handler)
 
1011
        req = Request("https://www.example.com/")
 
1012
        req.add_header("Proxy-Authorization","FooBar")
 
1013
        req.add_header("User-Agent","Grail")
 
1014
        self.assertEqual(req.get_host(), "www.example.com")
 
1015
        self.assertTrue(req._tunnel_host is None)
 
1016
        r = o.open(req)
 
1017
        # Verify Proxy-Authorization gets tunneled to request.
 
1018
        # httpsconn req_headers do not have the Proxy-Authorization header but
 
1019
        # the req will have.
 
1020
        self.assertFalse(("Proxy-Authorization","FooBar") in
 
1021
                         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)
 
1025
        self.assertEqual(req.get_host(), "proxy.example.com:3128")
 
1026
        self.assertEqual(req.get_header("Proxy-authorization"),"FooBar")
 
1027
 
977
1028
    def test_basic_auth(self, quote_char='"'):
978
1029
        opener = OpenerDirector()
979
1030
        password_manager = MockPasswordManager()
1083
1134
        auth_hdr_value = 'Basic '+base64.encodestring(userpass).strip()
1084
1135
        self.assertEqual(http_handler.requests[1].get_header(auth_header),
1085
1136
                         auth_hdr_value)
1086
 
 
 
1137
        self.assertEqual(http_handler.requests[1].unredirected_hdrs[auth_header],
 
1138
                         auth_hdr_value)
1087
1139
        # if the password manager can't find a password, the handler won't
1088
1140
        # handle the HTTP auth error
1089
1141
        password_manager.user = password_manager.password = None