← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_http.py

Merge previous attempt into current trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_http.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
48
48
    deprecated_in,
49
49
    )
50
50
from bzrlib.tests import (
 
51
    features,
51
52
    http_server,
52
53
    http_utils,
53
54
    )
61
62
    )
62
63
 
63
64
 
64
 
try:
 
65
if features.pycurl.available():
65
66
    from bzrlib.transport.http._pycurl import PyCurlTransport
66
 
    pycurl_present = True
67
 
except errors.DependencyNotPresent:
68
 
    pycurl_present = False
69
67
 
70
68
 
71
69
def load_tests(standard_tests, module, loader):
84
82
                        _server=http_server.HttpServer_urllib,
85
83
                        _qualified_prefix='http+urllib',)),
86
84
        ]
87
 
    if pycurl_present:
 
85
    if features.pycurl.available():
88
86
        transport_scenarios.append(
89
87
            ('pycurl', dict(_transport=PyCurlTransport,
90
88
                            _server=http_server.HttpServer_PyCurl,
156
154
        activity_scenarios.append(
157
155
            ('urllib,https', dict(_activity_server=ActivityHTTPSServer,
158
156
                                  _transport=_urllib.HttpTransport_urllib,)),)
159
 
    if pycurl_present:
 
157
    if features.pycurl.available():
160
158
        activity_scenarios.append(
161
159
            ('pycurl,http', dict(_activity_server=ActivityHTTPServer,
162
160
                                 _transport=PyCurlTransport,)),)
204
202
    It records the bytes sent to it, and replies with a 200.
205
203
    """
206
204
 
207
 
    def __init__(self, expect_body_tail=None):
 
205
    def __init__(self, expect_body_tail=None, scheme=''):
208
206
        """Constructor.
209
207
 
210
208
        :type expect_body_tail: str
215
213
        self.host = None
216
214
        self.port = None
217
215
        self.received_bytes = ''
218
 
 
219
 
    def setUp(self):
 
216
        self.scheme = scheme
 
217
 
 
218
    def get_url(self):
 
219
        return '%s://%s:%s/' % (self.scheme, self.host, self.port)
 
220
 
 
221
    def start_server(self):
220
222
        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
221
223
        self._sock.bind(('127.0.0.1', 0))
222
224
        self.host, self.port = self._sock.getsockname()
224
226
        self._thread = threading.Thread(target=self._accept_read_and_reply)
225
227
        self._thread.setDaemon(True)
226
228
        self._thread.start()
227
 
        self._ready.wait(5)
 
229
        if 'threads' in tests.selftest_debug_flags:
 
230
            print 'Thread started: %s' % (self._thread.ident,)
 
231
        self._ready.wait()
228
232
 
229
233
    def _accept_read_and_reply(self):
230
234
        self._sock.listen(1)
 
235
        self._sock.settimeout(5)
231
236
        self._ready.set()
232
 
        self._sock.settimeout(5)
233
237
        try:
234
238
            conn, address = self._sock.accept()
235
239
            # On win32, the accepted connection will be non-blocking to start
236
240
            # with because we're using settimeout.
237
241
            conn.setblocking(True)
238
 
            while not self.received_bytes.endswith(self._expect_body_tail):
239
 
                self.received_bytes += conn.recv(4096)
240
 
            conn.sendall('HTTP/1.1 200 OK\r\n')
 
242
            if self._expect_body_tail is not None:
 
243
                while not self.received_bytes.endswith(self._expect_body_tail):
 
244
                    self.received_bytes += conn.recv(4096)
 
245
                conn.sendall('HTTP/1.1 200 OK\r\n')
241
246
        except socket.timeout:
242
247
            # Make sure the client isn't stuck waiting for us to e.g. accept.
 
248
            pass
 
249
        try:
243
250
            self._sock.close()
244
251
        except socket.error:
245
252
            # The client may have already closed the socket.
246
253
            pass
247
254
 
248
 
    def tearDown(self):
 
255
    def connect_socket(self):
 
256
        err = socket.error('getaddrinfo returns an empty list')
 
257
        for res in socket.getaddrinfo(self.host, self.port):
 
258
            af, socktype, proto, canonname, sa = res
 
259
            sock = None
 
260
            try:
 
261
                sock = socket.socket(af, socktype, proto)
 
262
                sock.connect(sa)
 
263
                return sock
 
264
 
 
265
            except socket.error, err:
 
266
                # err is now the most recent error
 
267
                if sock is not None:
 
268
                    sock.close()
 
269
        raise err
 
270
 
 
271
    def stop_server(self):
249
272
        try:
250
 
            self._sock.close()
 
273
            # Issue a fake connection to wake up the server and allow it to
 
274
            # finish quickly
 
275
            fake_conn = self.connect_socket()
 
276
            fake_conn.close()
251
277
        except socket.error:
252
278
            # We might have already closed it.  We don't care.
253
279
            pass
254
280
        self.host = None
255
281
        self.port = None
 
282
        self._thread.join()
 
283
        if 'threads' in tests.selftest_debug_flags:
 
284
            print 'Thread  joined: %s' % (self._thread.ident,)
256
285
 
257
286
 
258
287
class TestAuthHeader(tests.TestCase):
265
294
 
266
295
    def test_empty_header(self):
267
296
        scheme, remainder = self.parse_header('')
268
 
        self.assertEquals('', scheme)
 
297
        self.assertEqual('', scheme)
269
298
        self.assertIs(None, remainder)
270
299
 
271
300
    def test_negotiate_header(self):
272
301
        scheme, remainder = self.parse_header('Negotiate')
273
 
        self.assertEquals('negotiate', scheme)
 
302
        self.assertEqual('negotiate', scheme)
274
303
        self.assertIs(None, remainder)
275
304
 
276
305
    def test_basic_header(self):
277
306
        scheme, remainder = self.parse_header(
278
307
            'Basic realm="Thou should not pass"')
279
 
        self.assertEquals('basic', scheme)
280
 
        self.assertEquals('realm="Thou should not pass"', remainder)
 
308
        self.assertEqual('basic', scheme)
 
309
        self.assertEqual('realm="Thou should not pass"', remainder)
281
310
 
282
311
    def test_basic_extract_realm(self):
283
312
        scheme, remainder = self.parse_header(
285
314
            _urllib2_wrappers.BasicAuthHandler)
286
315
        match, realm = self.auth_handler.extract_realm(remainder)
287
316
        self.assertTrue(match is not None)
288
 
        self.assertEquals('Thou should not pass', realm)
 
317
        self.assertEqual('Thou should not pass', realm)
289
318
 
290
319
    def test_digest_header(self):
291
320
        scheme, remainder = self.parse_header(
292
321
            'Digest realm="Thou should not pass"')
293
 
        self.assertEquals('digest', scheme)
294
 
        self.assertEquals('realm="Thou should not pass"', remainder)
 
322
        self.assertEqual('digest', scheme)
 
323
        self.assertEqual('realm="Thou should not pass"', remainder)
295
324
 
296
325
 
297
326
class TestHTTPServer(tests.TestCase):
304
333
 
305
334
        server = http_server.HttpServer(BogusRequestHandler)
306
335
        try:
307
 
            self.assertRaises(httplib.UnknownProtocol,server.setUp)
 
336
            self.assertRaises(httplib.UnknownProtocol, server.start_server)
308
337
        except:
309
 
            server.tearDown()
 
338
            server.stop_server()
310
339
            self.fail('HTTP Server creation did not raise UnknownProtocol')
311
340
 
312
341
    def test_force_invalid_protocol(self):
313
342
        server = http_server.HttpServer(protocol_version='HTTP/0.1')
314
343
        try:
315
 
            self.assertRaises(httplib.UnknownProtocol,server.setUp)
 
344
            self.assertRaises(httplib.UnknownProtocol, server.start_server)
316
345
        except:
317
 
            server.tearDown()
 
346
            server.stop_server()
318
347
            self.fail('HTTP Server creation did not raise UnknownProtocol')
319
348
 
320
349
    def test_server_start_and_stop(self):
321
350
        server = http_server.HttpServer()
322
 
        server.setUp()
323
 
        self.assertTrue(server._http_running)
324
 
        server.tearDown()
325
 
        self.assertFalse(server._http_running)
 
351
        server.start_server()
 
352
        try:
 
353
            self.assertTrue(server._httpd is not None)
 
354
            self.assertTrue(server._httpd.serving is not None)
 
355
            self.assertTrue(server._httpd.serving.isSet())
 
356
        finally:
 
357
            server.stop_server()
326
358
 
327
359
    def test_create_http_server_one_zero(self):
328
360
        class RequestHandlerOneZero(http_server.TestingHTTPRequestHandler):
330
362
            protocol_version = 'HTTP/1.0'
331
363
 
332
364
        server = http_server.HttpServer(RequestHandlerOneZero)
333
 
        server.setUp()
334
 
        self.addCleanup(server.tearDown)
 
365
        self.start_server(server)
335
366
        self.assertIsInstance(server._httpd, http_server.TestingHTTPServer)
336
367
 
337
368
    def test_create_http_server_one_one(self):
340
371
            protocol_version = 'HTTP/1.1'
341
372
 
342
373
        server = http_server.HttpServer(RequestHandlerOneOne)
343
 
        server.setUp()
344
 
        self.addCleanup(server.tearDown)
 
374
        self.start_server(server)
345
375
        self.assertIsInstance(server._httpd,
346
376
                              http_server.TestingThreadingHTTPServer)
347
377
 
352
382
 
353
383
        server = http_server.HttpServer(RequestHandlerOneZero,
354
384
                                        protocol_version='HTTP/1.1')
355
 
        server.setUp()
356
 
        self.addCleanup(server.tearDown)
 
385
        self.start_server(server)
357
386
        self.assertIsInstance(server._httpd,
358
387
                              http_server.TestingThreadingHTTPServer)
359
388
 
364
393
 
365
394
        server = http_server.HttpServer(RequestHandlerOneOne,
366
395
                                        protocol_version='HTTP/1.0')
367
 
        server.setUp()
368
 
        self.addCleanup(server.tearDown)
 
396
        self.start_server(server)
369
397
        self.assertIsInstance(server._httpd,
370
398
                              http_server.TestingHTTPServer)
371
399
 
374
402
    """Test case to inherit from if pycurl is present"""
375
403
 
376
404
    def _get_pycurl_maybe(self):
377
 
        try:
378
 
            from bzrlib.transport.http._pycurl import PyCurlTransport
379
 
            return PyCurlTransport
380
 
        except errors.DependencyNotPresent:
381
 
            raise tests.TestSkipped('pycurl not present')
 
405
        self.requireFeature(features.pycurl)
 
406
        return PyCurlTransport
382
407
 
383
408
    _transport = property(_get_pycurl_maybe)
384
409
 
391
416
    def test_url_parsing(self):
392
417
        f = FakeManager()
393
418
        url = http.extract_auth('http://example.com', f)
394
 
        self.assertEquals('http://example.com', url)
395
 
        self.assertEquals(0, len(f.credentials))
 
419
        self.assertEqual('http://example.com', url)
 
420
        self.assertEqual(0, len(f.credentials))
396
421
        url = http.extract_auth(
397
 
            'http://user:pass@www.bazaar-vcs.org/bzr/bzr.dev', f)
398
 
        self.assertEquals('http://www.bazaar-vcs.org/bzr/bzr.dev', url)
399
 
        self.assertEquals(1, len(f.credentials))
400
 
        self.assertEquals([None, 'www.bazaar-vcs.org', 'user', 'pass'],
401
 
                          f.credentials[0])
 
422
            'http://user:pass@example.com/bzr/bzr.dev', f)
 
423
        self.assertEqual('http://example.com/bzr/bzr.dev', url)
 
424
        self.assertEqual(1, len(f.credentials))
 
425
        self.assertEqual([None, 'example.com', 'user', 'pass'],
 
426
                         f.credentials[0])
402
427
 
403
428
 
404
429
class TestHttpTransportUrls(tests.TestCase):
431
456
    def test_http_impl_urls(self):
432
457
        """There are servers which ask for particular clients to connect"""
433
458
        server = self._server()
 
459
        server.start_server()
434
460
        try:
435
 
            server.setUp()
436
461
            url = server.get_url()
437
462
            self.assertTrue(url.startswith('%s://' % self._qualified_prefix))
438
463
        finally:
439
 
            server.tearDown()
 
464
            server.stop_server()
440
465
 
441
466
 
442
467
class TestHttps_pycurl(TestWithTransport_pycurl, tests.TestCase):
451
476
        https by supplying a fake version_info that do not
452
477
        support it.
453
478
        """
454
 
        try:
455
 
            import pycurl
456
 
        except ImportError:
457
 
            raise tests.TestSkipped('pycurl not present')
 
479
        self.requireFeature(features.pycurl)
 
480
        # Import the module locally now that we now it's available.
 
481
        pycurl = features.pycurl.module
458
482
 
459
 
        version_info_orig = pycurl.version_info
460
 
        try:
461
 
            # Now that we have pycurl imported, we can fake its version_info
462
 
            # This was taken from a windows pycurl without SSL
463
 
            # (thanks to bialix)
464
 
            pycurl.version_info = lambda : (2,
465
 
                                            '7.13.2',
466
 
                                            462082,
467
 
                                            'i386-pc-win32',
468
 
                                            2576,
469
 
                                            None,
470
 
                                            0,
471
 
                                            None,
472
 
                                            ('ftp', 'gopher', 'telnet',
473
 
                                             'dict', 'ldap', 'http', 'file'),
474
 
                                            None,
475
 
                                            0,
476
 
                                            None)
477
 
            self.assertRaises(errors.DependencyNotPresent, self._transport,
478
 
                              'https://launchpad.net')
479
 
        finally:
480
 
            # Restore the right function
481
 
            pycurl.version_info = version_info_orig
 
483
        self.overrideAttr(pycurl, 'version_info',
 
484
                          # Fake the pycurl version_info This was taken from
 
485
                          # a windows pycurl without SSL (thanks to bialix)
 
486
                          lambda : (2,
 
487
                                    '7.13.2',
 
488
                                    462082,
 
489
                                    'i386-pc-win32',
 
490
                                    2576,
 
491
                                    None,
 
492
                                    0,
 
493
                                    None,
 
494
                                    ('ftp', 'gopher', 'telnet',
 
495
                                     'dict', 'ldap', 'http', 'file'),
 
496
                                    None,
 
497
                                    0,
 
498
                                    None))
 
499
        self.assertRaises(errors.DependencyNotPresent, self._transport,
 
500
                          'https://launchpad.net')
482
501
 
483
502
 
484
503
class TestHTTPConnections(http_utils.TestCaseWithWebserver):
543
562
class TestPost(tests.TestCase):
544
563
 
545
564
    def test_post_body_is_received(self):
546
 
        server = RecordingServer(expect_body_tail='end-of-body')
547
 
        server.setUp()
548
 
        self.addCleanup(server.tearDown)
549
 
        scheme = self._qualified_prefix
550
 
        url = '%s://%s:%s/' % (scheme, server.host, server.port)
 
565
        server = RecordingServer(expect_body_tail='end-of-body',
 
566
            scheme=self._qualified_prefix)
 
567
        self.start_server(server)
 
568
        url = server.get_url()
551
569
        http_transport = self._transport(url)
552
570
        code, response = http_transport._post('abc def end-of-body')
553
571
        self.assertTrue(
602
620
                                      protocol_version=self._protocol_version)
603
621
 
604
622
    def _testing_pycurl(self):
605
 
        return pycurl_present and self._transport == PyCurlTransport
 
623
        # TODO: This is duplicated for lots of the classes in this file
 
624
        return (features.pycurl.available()
 
625
                and self._transport == PyCurlTransport)
606
626
 
607
627
 
608
628
class WallRequestHandler(http_server.TestingHTTPRequestHandler):
609
629
    """Whatever request comes in, close the connection"""
610
630
 
611
 
    def handle_one_request(self):
 
631
    def _handle_one_request(self):
612
632
        """Handle a single HTTP request, by abruptly closing the connection"""
613
633
        self.close_connection = 1
614
634
 
625
645
        # for details) make no distinction between a closed
626
646
        # socket and badly formatted status line, so we can't
627
647
        # just test for ConnectionError, we have to test
628
 
        # InvalidHttpResponse too.
629
 
        self.assertRaises((errors.ConnectionError, errors.InvalidHttpResponse),
 
648
        # InvalidHttpResponse too. And pycurl may raise ConnectionReset
 
649
        # instead of ConnectionError too.
 
650
        self.assertRaises(( errors.ConnectionError, errors.ConnectionReset,
 
651
                            errors.InvalidHttpResponse),
630
652
                          t.has, 'foo/bar')
631
653
 
632
654
    def test_http_get(self):
633
655
        server = self.get_readonly_server()
634
656
        t = self._transport(server.get_url())
635
 
        self.assertRaises((errors.ConnectionError, errors.InvalidHttpResponse),
 
657
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
 
658
                           errors.InvalidHttpResponse),
636
659
                          t.get, 'foo/bar')
637
660
 
638
661
 
714
737
    _req_handler_class = BadProtocolRequestHandler
715
738
 
716
739
    def setUp(self):
717
 
        if pycurl_present and self._transport == PyCurlTransport:
 
740
        if self._testing_pycurl():
718
741
            raise tests.TestNotApplicable(
719
742
                "pycurl doesn't check the protocol version")
720
743
        super(TestBadProtocolServer, self).setUp()
764
787
        self.assertEqual(None, server.host)
765
788
        self.assertEqual(None, server.port)
766
789
 
767
 
    def test_setUp_and_tearDown(self):
 
790
    def test_setUp_and_stop(self):
768
791
        server = RecordingServer(expect_body_tail=None)
769
 
        server.setUp()
 
792
        server.start_server()
770
793
        try:
771
794
            self.assertNotEqual(None, server.host)
772
795
            self.assertNotEqual(None, server.port)
773
796
        finally:
774
 
            server.tearDown()
 
797
            server.stop_server()
775
798
        self.assertEqual(None, server.host)
776
799
        self.assertEqual(None, server.port)
777
800
 
778
801
    def test_send_receive_bytes(self):
779
 
        server = RecordingServer(expect_body_tail='c')
780
 
        server.setUp()
781
 
        self.addCleanup(server.tearDown)
 
802
        server = RecordingServer(expect_body_tail='c', scheme='http')
 
803
        self.start_server(server)
782
804
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
783
805
        sock.connect((server.host, server.port))
784
806
        sock.sendall('abc')
1175
1197
        if self._testing_pycurl():
1176
1198
            # Oh my ! pycurl does not check for the port as part of
1177
1199
            # no_proxy :-( So we just test the host part
1178
 
            self.no_proxy_host = 'localhost'
 
1200
            self.no_proxy_host = self.server.host
1179
1201
        else:
1180
1202
            self.no_proxy_host = self.proxy_address
1181
1203
        # The secondary server is the proxy
1184
1206
        self._old_env = {}
1185
1207
 
1186
1208
    def _testing_pycurl(self):
1187
 
        return pycurl_present and self._transport == PyCurlTransport
 
1209
        # TODO: This is duplicated for lots of the classes in this file
 
1210
        return (features.pycurl.available()
 
1211
                and self._transport == PyCurlTransport)
1188
1212
 
1189
1213
    def create_transport_secondary_server(self):
1190
1214
        """Creates an http server that will serve files with
1363
1387
        self.follow_redirections = True
1364
1388
 
1365
1389
 
 
1390
def install_redirected_request(test):
 
1391
    test.overrideAttr(_urllib2_wrappers, 'Request', RedirectedRequest)
 
1392
 
 
1393
 
1366
1394
class TestHTTPSilentRedirections(http_utils.TestCaseWithRedirectedWebserver):
1367
1395
    """Test redirections.
1368
1396
 
1378
1406
    """
1379
1407
 
1380
1408
    def setUp(self):
1381
 
        if pycurl_present and self._transport == PyCurlTransport:
 
1409
        if (features.pycurl.available()
 
1410
            and self._transport == PyCurlTransport):
1382
1411
            raise tests.TestNotApplicable(
1383
1412
                "pycurl doesn't redirect silently annymore")
1384
1413
        super(TestHTTPSilentRedirections, self).setUp()
1385
 
        self.setup_redirected_request()
1386
 
        self.addCleanup(self.cleanup_redirected_request)
 
1414
        install_redirected_request(self)
1387
1415
        self.build_tree_contents([('a','a'),
1388
1416
                                  ('1/',),
1389
1417
                                  ('1/a', 'redirected once'),
1399
1427
 
1400
1428
        self.old_transport = self._transport(self.old_server.get_url())
1401
1429
 
1402
 
    def setup_redirected_request(self):
1403
 
        self.original_class = _urllib2_wrappers.Request
1404
 
        _urllib2_wrappers.Request = RedirectedRequest
1405
 
 
1406
 
    def cleanup_redirected_request(self):
1407
 
        _urllib2_wrappers.Request = self.original_class
1408
 
 
1409
1430
    def create_transport_secondary_server(self):
1410
1431
        """Create the secondary server, redirections are defined in the tests"""
1411
1432
        return http_utils.HTTPServerRedirecting(
1415
1436
        t = self.old_transport
1416
1437
 
1417
1438
        req = RedirectedRequest('GET', t.abspath('a'))
1418
 
        req.follow_redirections = True
1419
1439
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1420
1440
                                       self.new_server.port)
1421
1441
        self.old_server.redirections = \
1422
1442
            [('(.*)', r'%s/1\1' % (new_prefix), 301),]
1423
 
        self.assertEquals('redirected once',t._perform(req).read())
 
1443
        self.assertEqual('redirected once',t._perform(req).read())
1424
1444
 
1425
1445
    def test_five_redirections(self):
1426
1446
        t = self.old_transport
1427
1447
 
1428
1448
        req = RedirectedRequest('GET', t.abspath('a'))
1429
 
        req.follow_redirections = True
1430
1449
        old_prefix = 'http://%s:%s' % (self.old_server.host,
1431
1450
                                       self.old_server.port)
1432
1451
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1438
1457
            ('/4(.*)', r'%s/5\1' % (new_prefix), 301),
1439
1458
            ('(/[^/]+)', r'%s/1\1' % (old_prefix), 301),
1440
1459
            ]
1441
 
        self.assertEquals('redirected 5 times',t._perform(req).read())
 
1460
        self.assertEqual('redirected 5 times',t._perform(req).read())
1442
1461
 
1443
1462
 
1444
1463
class TestDoCatchRedirections(http_utils.TestCaseWithRedirectedWebserver):
1457
1476
        t = self._transport(self.new_server.get_url())
1458
1477
 
1459
1478
        # We use None for redirected so that we fail if redirected
1460
 
        self.assertEquals('0123456789',
1461
 
                          transport.do_catching_redirections(
 
1479
        self.assertEqual('0123456789',
 
1480
                         transport.do_catching_redirections(
1462
1481
                self.get_a, t, None).read())
1463
1482
 
1464
1483
    def test_one_redirection(self):
1469
1488
            dir, file = urlutils.split(exception.target)
1470
1489
            return self._transport(dir)
1471
1490
 
1472
 
        self.assertEquals('0123456789',
1473
 
                          transport.do_catching_redirections(
 
1491
        self.assertEqual('0123456789',
 
1492
                         transport.do_catching_redirections(
1474
1493
                self.get_a, self.old_transport, redirected).read())
1475
 
        self.assertEquals(1, self.redirections)
 
1494
        self.assertEqual(1, self.redirections)
1476
1495
 
1477
1496
    def test_redirection_loop(self):
1478
1497
 
1506
1525
        return self._auth_server(protocol_version=self._protocol_version)
1507
1526
 
1508
1527
    def _testing_pycurl(self):
1509
 
        return pycurl_present and self._transport == PyCurlTransport
 
1528
        # TODO: This is duplicated for lots of the classes in this file
 
1529
        return (features.pycurl.available()
 
1530
                and self._transport == PyCurlTransport)
1510
1531
 
1511
1532
    def get_user_url(self, user, password):
1512
1533
        """Build an url embedding user and password"""
1577
1598
        self.assertEqual('', ui.ui_factory.stdin.readline())
1578
1599
        stderr.seek(0)
1579
1600
        expected_prompt = self._expected_username_prompt(t._unqualified_scheme)
1580
 
        self.assertEquals(expected_prompt, stderr.read(len(expected_prompt)))
1581
 
        self.assertEquals('', stdout.getvalue())
 
1601
        self.assertEqual(expected_prompt, stderr.read(len(expected_prompt)))
 
1602
        self.assertEqual('', stdout.getvalue())
1582
1603
        self._check_password_prompt(t._unqualified_scheme, 'joe',
1583
1604
                                    stderr.readline())
1584
1605
 
1599
1620
        self.assertEqual('', ui.ui_factory.stdin.readline())
1600
1621
        self._check_password_prompt(t._unqualified_scheme, 'joe',
1601
1622
                                    stderr.getvalue())
1602
 
        self.assertEquals('', stdout.getvalue())
 
1623
        self.assertEqual('', stdout.getvalue())
1603
1624
        # And we shouldn't prompt again for a different request
1604
1625
        # against the same transport.
1605
1626
        self.assertEqual('contents of b\n',t.get('b').read())
1615
1636
                              % (scheme.upper(),
1616
1637
                                 user, self.server.host, self.server.port,
1617
1638
                                 self.server.auth_realm)))
1618
 
        self.assertEquals(expected_prompt, actual_prompt)
 
1639
        self.assertEqual(expected_prompt, actual_prompt)
1619
1640
 
1620
1641
    def _expected_username_prompt(self, scheme):
1621
1642
        return (self._username_prompt_prefix
1635
1656
        self.server.add_user(user, password)
1636
1657
        t = self.get_user_transport(user, None)
1637
1658
        ui.ui_factory = tests.TestUIFactory(stdin=stdin_content,
1638
 
                                            stdout=tests.StringIOWrapper())
 
1659
                                            stderr=tests.StringIOWrapper())
1639
1660
        # Create a minimal config file with the right password
1640
1661
        conf = config.AuthenticationConfig()
1641
1662
        conf._get_config().update(
1853
1874
                             'http://www.example.com/foo/subdir')
1854
1875
        self.assertIsInstance(r, type(t))
1855
1876
        # Both transports share the some connection
1856
 
        self.assertEquals(t._get_connection(), r._get_connection())
 
1877
        self.assertEqual(t._get_connection(), r._get_connection())
1857
1878
 
1858
1879
    def test_redirected_to_self_with_slash(self):
1859
1880
        t = self._transport('http://www.example.com/foo')
1863
1884
        # Both transports share the some connection (one can argue that we
1864
1885
        # should return the exact same transport here, but that seems
1865
1886
        # overkill).
1866
 
        self.assertEquals(t._get_connection(), r._get_connection())
 
1887
        self.assertEqual(t._get_connection(), r._get_connection())
1867
1888
 
1868
1889
    def test_redirected_to_host(self):
1869
1890
        t = self._transport('http://www.example.com/foo')
1888
1909
        r = t._redirected_to('http://www.example.com/foo',
1889
1910
                             'https://foo.example.com/foo')
1890
1911
        self.assertIsInstance(r, type(t))
1891
 
        self.assertEquals(t._user, r._user)
 
1912
        self.assertEqual(t._user, r._user)
1892
1913
 
1893
1914
 
1894
1915
class PredefinedRequestHandler(http_server.TestingHTTPRequestHandler):
1903
1924
    line.
1904
1925
    """
1905
1926
 
1906
 
    def handle_one_request(self):
 
1927
    def _handle_one_request(self):
1907
1928
        tcs = self.server.test_case_server
1908
1929
        requestline = self.rfile.readline()
1909
1930
        headers = self.MessageClass(self.rfile, 0)
1953
1974
        pass
1954
1975
 
1955
1976
 
1956
 
class TestActivity(tests.TestCase):
 
1977
class TestActivityMixin(object):
1957
1978
    """Test socket activity reporting.
1958
1979
 
1959
1980
    We use a special purpose server to control the bytes sent and received and
1963
1984
    def setUp(self):
1964
1985
        tests.TestCase.setUp(self)
1965
1986
        self.server = self._activity_server(self._protocol_version)
1966
 
        self.server.setUp()
 
1987
        self.server.start_server()
1967
1988
        self.activities = {}
1968
1989
        def report_activity(t, bytes, direction):
1969
1990
            count = self.activities.get(direction, 0)
1978
1999
 
1979
2000
    def tearDown(self):
1980
2001
        self._transport._report_activity = self.orig_report_activity
1981
 
        self.server.tearDown()
 
2002
        self.server.stop_server()
1982
2003
        tests.TestCase.tearDown(self)
1983
2004
 
1984
2005
    def get_transport(self):
2093
2114
'''
2094
2115
        t = self.get_transport()
2095
2116
        # We must send a single line of body bytes, see
2096
 
        # PredefinedRequestHandler.handle_one_request
 
2117
        # PredefinedRequestHandler._handle_one_request
2097
2118
        code, f = t._post('abc def end-of-body\n')
2098
2119
        self.assertEqual('lalala whatever as long as itsssss\n', f.read())
2099
2120
        self.assertActivitiesMatch()
 
2121
 
 
2122
 
 
2123
class TestActivity(tests.TestCase, TestActivityMixin):
 
2124
 
 
2125
    def setUp(self):
 
2126
        tests.TestCase.setUp(self)
 
2127
        self.server = self._activity_server(self._protocol_version)
 
2128
        self.server.start_server()
 
2129
        self.activities = {}
 
2130
        def report_activity(t, bytes, direction):
 
2131
            count = self.activities.get(direction, 0)
 
2132
            count += bytes
 
2133
            self.activities[direction] = count
 
2134
 
 
2135
        # We override at class level because constructors may propagate the
 
2136
        # bound method and render instance overriding ineffective (an
 
2137
        # alternative would be to define a specific ui factory instead...)
 
2138
        self.orig_report_activity = self._transport._report_activity
 
2139
        self._transport._report_activity = report_activity
 
2140
 
 
2141
    def tearDown(self):
 
2142
        self._transport._report_activity = self.orig_report_activity
 
2143
        self.server.stop_server()
 
2144
        tests.TestCase.tearDown(self)
 
2145
 
 
2146
 
 
2147
class TestNoReportActivity(tests.TestCase, TestActivityMixin):
 
2148
 
 
2149
    def setUp(self):
 
2150
        tests.TestCase.setUp(self)
 
2151
        # Unlike TestActivity, we are really testing ReportingFileSocket and
 
2152
        # ReportingSocket, so we don't need all the parametrization. Since
 
2153
        # ReportingFileSocket and ReportingSocket are wrappers, it's easier to
 
2154
        # test them through their use by the transport than directly (that's a
 
2155
        # bit less clean but far more simpler and effective).
 
2156
        self.server = ActivityHTTPServer('HTTP/1.1')
 
2157
        self._transport=_urllib.HttpTransport_urllib
 
2158
 
 
2159
        self.server.start_server()
 
2160
 
 
2161
        # We override at class level because constructors may propagate the
 
2162
        # bound method and render instance overriding ineffective (an
 
2163
        # alternative would be to define a specific ui factory instead...)
 
2164
        self.orig_report_activity = self._transport._report_activity
 
2165
        self._transport._report_activity = None
 
2166
 
 
2167
    def tearDown(self):
 
2168
        self._transport._report_activity = self.orig_report_activity
 
2169
        self.server.stop_server()
 
2170
        tests.TestCase.tearDown(self)
 
2171
 
 
2172
    def assertActivitiesMatch(self):
 
2173
        # Nothing to check here
 
2174
        pass
 
2175
 
 
2176
 
 
2177
class TestAuthOnRedirected(http_utils.TestCaseWithRedirectedWebserver):
 
2178
    """Test authentication on the redirected http server."""
 
2179
 
 
2180
    _auth_header = 'Authorization'
 
2181
    _password_prompt_prefix = ''
 
2182
    _username_prompt_prefix = ''
 
2183
    _auth_server = http_utils.HTTPBasicAuthServer
 
2184
    _transport = _urllib.HttpTransport_urllib
 
2185
 
 
2186
    def create_transport_readonly_server(self):
 
2187
        return self._auth_server()
 
2188
 
 
2189
    def create_transport_secondary_server(self):
 
2190
        """Create the secondary server redirecting to the primary server"""
 
2191
        new = self.get_readonly_server()
 
2192
 
 
2193
        redirecting = http_utils.HTTPServerRedirecting()
 
2194
        redirecting.redirect_to(new.host, new.port)
 
2195
        return redirecting
 
2196
 
 
2197
    def setUp(self):
 
2198
        super(TestAuthOnRedirected, self).setUp()
 
2199
        self.build_tree_contents([('a','a'),
 
2200
                                  ('1/',),
 
2201
                                  ('1/a', 'redirected once'),
 
2202
                                  ],)
 
2203
        new_prefix = 'http://%s:%s' % (self.new_server.host,
 
2204
                                       self.new_server.port)
 
2205
        self.old_server.redirections = [
 
2206
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
 
2207
        self.old_transport = self._transport(self.old_server.get_url())
 
2208
        self.new_server.add_user('joe', 'foo')
 
2209
 
 
2210
    def get_a(self, transport):
 
2211
        return transport.get('a')
 
2212
 
 
2213
    def test_auth_on_redirected_via_do_catching_redirections(self):
 
2214
        self.redirections = 0
 
2215
 
 
2216
        def redirected(transport, exception, redirection_notice):
 
2217
            self.redirections += 1
 
2218
            dir, file = urlutils.split(exception.target)
 
2219
            return self._transport(dir)
 
2220
 
 
2221
        stdout = tests.StringIOWrapper()
 
2222
        stderr = tests.StringIOWrapper()
 
2223
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n',
 
2224
                                            stdout=stdout, stderr=stderr)
 
2225
        self.assertEqual('redirected once',
 
2226
                         transport.do_catching_redirections(
 
2227
                self.get_a, self.old_transport, redirected).read())
 
2228
        self.assertEqual(1, self.redirections)
 
2229
        # stdin should be empty
 
2230
        self.assertEqual('', ui.ui_factory.stdin.readline())
 
2231
        # stdout should be empty, stderr will contains the prompts
 
2232
        self.assertEqual('', stdout.getvalue())
 
2233
 
 
2234
    def test_auth_on_redirected_via_following_redirections(self):
 
2235
        self.new_server.add_user('joe', 'foo')
 
2236
        stdout = tests.StringIOWrapper()
 
2237
        stderr = tests.StringIOWrapper()
 
2238
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n',
 
2239
                                            stdout=stdout, stderr=stderr)
 
2240
        t = self.old_transport
 
2241
        req = RedirectedRequest('GET', t.abspath('a'))
 
2242
        new_prefix = 'http://%s:%s' % (self.new_server.host,
 
2243
                                       self.new_server.port)
 
2244
        self.old_server.redirections = [
 
2245
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
 
2246
        self.assertEqual('redirected once',t._perform(req).read())
 
2247
        # stdin should be empty
 
2248
        self.assertEqual('', ui.ui_factory.stdin.readline())
 
2249
        # stdout should be empty, stderr will contains the prompts
 
2250
        self.assertEqual('', stdout.getvalue())
 
2251
 
 
2252