← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_http.py

  • Committer: Martin Pool
  • Date: 2010-08-18 07:25:22 UTC
  • mto: This revision was merged to the branch mainline in revision 5383.
  • Revision ID: mbp@sourcefrog.net-20100818072522-uk3gsazoia3l3s0a
Start adding 'what's new in 2.3'

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_http.py
1
 
# Copyright (C) 2005-2011 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
23
23
# TODO: Should be renamed to bzrlib.transport.http.tests?
24
24
# TODO: What about renaming to bzrlib.tests.transport.http ?
25
25
 
 
26
from cStringIO import StringIO
26
27
import httplib
 
28
import os
 
29
import select
27
30
import SimpleHTTPServer
28
31
import socket
29
32
import sys
32
35
import bzrlib
33
36
from bzrlib import (
34
37
    bzrdir,
35
 
    cethread,
36
38
    config,
37
 
    debug,
38
39
    errors,
39
40
    osutils,
40
41
    remote as _mod_remote,
41
42
    tests,
42
 
    trace,
43
43
    transport,
44
44
    ui,
 
45
    urlutils,
45
46
    )
46
47
from bzrlib.tests import (
47
48
    features,
48
49
    http_server,
49
50
    http_utils,
50
 
    test_server,
51
 
    )
52
 
from bzrlib.tests.scenarios import (
53
 
    load_tests_apply_scenarios,
54
 
    multiply_scenarios,
55
51
    )
56
52
from bzrlib.transport import (
57
53
    http,
67
63
    from bzrlib.transport.http._pycurl import PyCurlTransport
68
64
 
69
65
 
70
 
load_tests = load_tests_apply_scenarios
71
 
 
72
 
 
73
 
def vary_by_http_client_implementation():
74
 
    """Test the two libraries we can use, pycurl and urllib."""
 
66
def load_tests(standard_tests, module, loader):
 
67
    """Multiply tests for http clients and protocol versions."""
 
68
    result = loader.suiteClass()
 
69
 
 
70
    # one for each transport implementation
 
71
    t_tests, remaining_tests = tests.split_suite_by_condition(
 
72
        standard_tests, tests.condition_isinstance((
 
73
                TestHttpTransportRegistration,
 
74
                TestHttpTransportUrls,
 
75
                Test_redirected_to,
 
76
                )))
75
77
    transport_scenarios = [
76
78
        ('urllib', dict(_transport=_urllib.HttpTransport_urllib,
77
79
                        _server=http_server.HttpServer_urllib,
78
 
                        _url_protocol='http+urllib',)),
 
80
                        _qualified_prefix='http+urllib',)),
79
81
        ]
80
82
    if features.pycurl.available():
81
83
        transport_scenarios.append(
82
84
            ('pycurl', dict(_transport=PyCurlTransport,
83
85
                            _server=http_server.HttpServer_PyCurl,
84
 
                            _url_protocol='http+pycurl',)))
85
 
    return transport_scenarios
86
 
 
87
 
 
88
 
def vary_by_http_protocol_version():
89
 
    """Test on http/1.0 and 1.1"""
90
 
    return [
91
 
        ('HTTP/1.0',  dict(_protocol_version='HTTP/1.0')),
92
 
        ('HTTP/1.1',  dict(_protocol_version='HTTP/1.1')),
 
86
                            _qualified_prefix='http+pycurl',)))
 
87
    tests.multiply_tests(t_tests, transport_scenarios, result)
 
88
 
 
89
    protocol_scenarios = [
 
90
            ('HTTP/1.0',  dict(_protocol_version='HTTP/1.0')),
 
91
            ('HTTP/1.1',  dict(_protocol_version='HTTP/1.1')),
 
92
            ]
 
93
 
 
94
    # some tests are parametrized by the protocol version only
 
95
    p_tests, remaining_tests = tests.split_suite_by_condition(
 
96
        remaining_tests, tests.condition_isinstance((
 
97
                TestAuthOnRedirected,
 
98
                )))
 
99
    tests.multiply_tests(p_tests, protocol_scenarios, result)
 
100
 
 
101
    # each implementation tested with each HTTP version
 
102
    tp_tests, remaining_tests = tests.split_suite_by_condition(
 
103
        remaining_tests, tests.condition_isinstance((
 
104
                SmartHTTPTunnellingTest,
 
105
                TestDoCatchRedirections,
 
106
                TestHTTPConnections,
 
107
                TestHTTPRedirections,
 
108
                TestHTTPSilentRedirections,
 
109
                TestLimitedRangeRequestServer,
 
110
                TestPost,
 
111
                TestProxyHttpServer,
 
112
                TestRanges,
 
113
                TestSpecificRequestHandler,
 
114
                )))
 
115
    tp_scenarios = tests.multiply_scenarios(transport_scenarios,
 
116
                                            protocol_scenarios)
 
117
    tests.multiply_tests(tp_tests, tp_scenarios, result)
 
118
 
 
119
    # proxy auth: each auth scheme on all http versions on all implementations.
 
120
    tppa_tests, remaining_tests = tests.split_suite_by_condition(
 
121
        remaining_tests, tests.condition_isinstance((
 
122
                TestProxyAuth,
 
123
                )))
 
124
    proxy_auth_scheme_scenarios = [
 
125
        ('basic', dict(_auth_server=http_utils.ProxyBasicAuthServer)),
 
126
        ('digest', dict(_auth_server=http_utils.ProxyDigestAuthServer)),
 
127
        ('basicdigest',
 
128
         dict(_auth_server=http_utils.ProxyBasicAndDigestAuthServer)),
93
129
        ]
94
 
 
95
 
 
96
 
def vary_by_http_auth_scheme():
97
 
    scenarios = [
 
130
    tppa_scenarios = tests.multiply_scenarios(tp_scenarios,
 
131
                                              proxy_auth_scheme_scenarios)
 
132
    tests.multiply_tests(tppa_tests, tppa_scenarios, result)
 
133
 
 
134
    # auth: each auth scheme on all http versions on all implementations.
 
135
    tpa_tests, remaining_tests = tests.split_suite_by_condition(
 
136
        remaining_tests, tests.condition_isinstance((
 
137
                TestAuth,
 
138
                )))
 
139
    auth_scheme_scenarios = [
98
140
        ('basic', dict(_auth_server=http_utils.HTTPBasicAuthServer)),
99
141
        ('digest', dict(_auth_server=http_utils.HTTPDigestAuthServer)),
100
142
        ('basicdigest',
101
 
            dict(_auth_server=http_utils.HTTPBasicAndDigestAuthServer)),
102
 
        ]
103
 
    # Add some attributes common to all scenarios
104
 
    for scenario_id, scenario_dict in scenarios:
105
 
        scenario_dict.update(_auth_header='Authorization',
106
 
                             _username_prompt_prefix='',
107
 
                             _password_prompt_prefix='')
108
 
    return scenarios
109
 
 
110
 
 
111
 
def vary_by_http_proxy_auth_scheme():
112
 
    scenarios = [
113
 
        ('proxy-basic', dict(_auth_server=http_utils.ProxyBasicAuthServer)),
114
 
        ('proxy-digest', dict(_auth_server=http_utils.ProxyDigestAuthServer)),
115
 
        ('proxy-basicdigest',
116
 
            dict(_auth_server=http_utils.ProxyBasicAndDigestAuthServer)),
117
 
        ]
118
 
    # Add some attributes common to all scenarios
119
 
    for scenario_id, scenario_dict in scenarios:
120
 
        scenario_dict.update(_auth_header='Proxy-Authorization',
121
 
                             _username_prompt_prefix='Proxy ',
122
 
                             _password_prompt_prefix='Proxy ')
123
 
    return scenarios
124
 
 
125
 
 
126
 
def vary_by_http_activity():
 
143
         dict(_auth_server=http_utils.HTTPBasicAndDigestAuthServer)),
 
144
        ]
 
145
    tpa_scenarios = tests.multiply_scenarios(tp_scenarios,
 
146
                                             auth_scheme_scenarios)
 
147
    tests.multiply_tests(tpa_tests, tpa_scenarios, result)
 
148
 
 
149
    # activity: on all http[s] versions on all implementations
 
150
    tpact_tests, remaining_tests = tests.split_suite_by_condition(
 
151
        remaining_tests, tests.condition_isinstance((
 
152
                TestActivity,
 
153
                )))
127
154
    activity_scenarios = [
128
155
        ('urllib,http', dict(_activity_server=ActivityHTTPServer,
129
 
                            _transport=_urllib.HttpTransport_urllib,)),
 
156
                             _transport=_urllib.HttpTransport_urllib,)),
130
157
        ]
131
158
    if tests.HTTPSServerFeature.available():
132
159
        activity_scenarios.append(
133
160
            ('urllib,https', dict(_activity_server=ActivityHTTPSServer,
134
 
                                _transport=_urllib.HttpTransport_urllib,)),)
 
161
                                  _transport=_urllib.HttpTransport_urllib,)),)
135
162
    if features.pycurl.available():
136
163
        activity_scenarios.append(
137
164
            ('pycurl,http', dict(_activity_server=ActivityHTTPServer,
138
 
                                _transport=PyCurlTransport,)),)
 
165
                                 _transport=PyCurlTransport,)),)
139
166
        if tests.HTTPSServerFeature.available():
140
167
            from bzrlib.tests import (
141
168
                ssl_certs,
153
180
 
154
181
            activity_scenarios.append(
155
182
                ('pycurl,https', dict(_activity_server=ActivityHTTPSServer,
156
 
                                    _transport=HTTPS_pycurl_transport,)),)
157
 
    return activity_scenarios
 
183
                                      _transport=HTTPS_pycurl_transport,)),)
 
184
 
 
185
    tpact_scenarios = tests.multiply_scenarios(activity_scenarios,
 
186
                                               protocol_scenarios)
 
187
    tests.multiply_tests(tpact_tests, tpact_scenarios, result)
 
188
 
 
189
    # No parametrization for the remaining tests
 
190
    result.addTests(remaining_tests)
 
191
 
 
192
    return result
158
193
 
159
194
 
160
195
class FakeManager(object):
193
228
        self._sock.bind(('127.0.0.1', 0))
194
229
        self.host, self.port = self._sock.getsockname()
195
230
        self._ready = threading.Event()
196
 
        self._thread = test_server.TestThread(
197
 
            sync_event=self._ready, target=self._accept_read_and_reply)
 
231
        self._thread = threading.Thread(target=self._accept_read_and_reply)
 
232
        self._thread.setDaemon(True)
198
233
        self._thread.start()
199
 
        if 'threads' in tests.selftest_debug_flags:
200
 
            sys.stderr.write('Thread started: %s\n' % (self._thread.ident,))
201
 
        self._ready.wait()
 
234
        self._ready.wait(5)
202
235
 
203
236
    def _accept_read_and_reply(self):
204
237
        self._sock.listen(1)
205
238
        self._ready.set()
206
 
        conn, address = self._sock.accept()
207
 
        if self._expect_body_tail is not None:
 
239
        self._sock.settimeout(5)
 
240
        try:
 
241
            conn, address = self._sock.accept()
 
242
            # On win32, the accepted connection will be non-blocking to start
 
243
            # with because we're using settimeout.
 
244
            conn.setblocking(True)
208
245
            while not self.received_bytes.endswith(self._expect_body_tail):
209
246
                self.received_bytes += conn.recv(4096)
210
247
            conn.sendall('HTTP/1.1 200 OK\r\n')
211
 
        try:
 
248
        except socket.timeout:
 
249
            # Make sure the client isn't stuck waiting for us to e.g. accept.
212
250
            self._sock.close()
213
251
        except socket.error:
214
252
            # The client may have already closed the socket.
216
254
 
217
255
    def stop_server(self):
218
256
        try:
219
 
            # Issue a fake connection to wake up the server and allow it to
220
 
            # finish quickly
221
 
            fake_conn = osutils.connect_socket((self.host, self.port))
222
 
            fake_conn.close()
 
257
            self._sock.close()
223
258
        except socket.error:
224
259
            # We might have already closed it.  We don't care.
225
260
            pass
226
261
        self.host = None
227
262
        self.port = None
228
 
        self._thread.join()
229
 
        if 'threads' in tests.selftest_debug_flags:
230
 
            sys.stderr.write('Thread  joined: %s\n' % (self._thread.ident,))
231
263
 
232
264
 
233
265
class TestAuthHeader(tests.TestCase):
269
301
        self.assertEqual('realm="Thou should not pass"', remainder)
270
302
 
271
303
 
272
 
class TestHTTPRangeParsing(tests.TestCase):
273
 
 
274
 
    def setUp(self):
275
 
        super(TestHTTPRangeParsing, self).setUp()
276
 
        # We focus on range  parsing here and ignore everything else
277
 
        class RequestHandler(http_server.TestingHTTPRequestHandler):
278
 
            def setup(self): pass
279
 
            def handle(self): pass
280
 
            def finish(self): pass
281
 
 
282
 
        self.req_handler = RequestHandler(None, None, None)
283
 
 
284
 
    def assertRanges(self, ranges, header, file_size):
285
 
        self.assertEquals(ranges,
286
 
                          self.req_handler._parse_ranges(header, file_size))
287
 
 
288
 
    def test_simple_range(self):
289
 
        self.assertRanges([(0,2)], 'bytes=0-2', 12)
290
 
 
291
 
    def test_tail(self):
292
 
        self.assertRanges([(8, 11)], 'bytes=-4', 12)
293
 
 
294
 
    def test_tail_bigger_than_file(self):
295
 
        self.assertRanges([(0, 11)], 'bytes=-99', 12)
296
 
 
297
 
    def test_range_without_end(self):
298
 
        self.assertRanges([(4, 11)], 'bytes=4-', 12)
299
 
 
300
 
    def test_invalid_ranges(self):
301
 
        self.assertRanges(None, 'bytes=12-22', 12)
302
 
        self.assertRanges(None, 'bytes=1-3,12-22', 12)
303
 
        self.assertRanges(None, 'bytes=-', 12)
304
 
 
305
 
 
306
304
class TestHTTPServer(tests.TestCase):
307
305
    """Test the HTTP servers implementations."""
308
306
 
311
309
 
312
310
            protocol_version = 'HTTP/0.1'
313
311
 
314
 
        self.assertRaises(httplib.UnknownProtocol,
315
 
                          http_server.HttpServer, BogusRequestHandler)
 
312
        server = http_server.HttpServer(BogusRequestHandler)
 
313
        try:
 
314
            self.assertRaises(httplib.UnknownProtocol, server.start_server)
 
315
        except:
 
316
            server.stop_server()
 
317
            self.fail('HTTP Server creation did not raise UnknownProtocol')
316
318
 
317
319
    def test_force_invalid_protocol(self):
318
 
        self.assertRaises(httplib.UnknownProtocol,
319
 
                          http_server.HttpServer, protocol_version='HTTP/0.1')
 
320
        server = http_server.HttpServer(protocol_version='HTTP/0.1')
 
321
        try:
 
322
            self.assertRaises(httplib.UnknownProtocol, server.start_server)
 
323
        except:
 
324
            server.stop_server()
 
325
            self.fail('HTTP Server creation did not raise UnknownProtocol')
320
326
 
321
327
    def test_server_start_and_stop(self):
322
328
        server = http_server.HttpServer()
323
 
        self.addCleanup(server.stop_server)
324
329
        server.start_server()
325
 
        self.assertTrue(server.server is not None)
326
 
        self.assertTrue(server.server.serving is not None)
327
 
        self.assertTrue(server.server.serving)
 
330
        try:
 
331
            self.assertTrue(server._http_running)
 
332
        finally:
 
333
            server.stop_server()
 
334
        self.assertFalse(server._http_running)
328
335
 
329
336
    def test_create_http_server_one_zero(self):
330
337
        class RequestHandlerOneZero(http_server.TestingHTTPRequestHandler):
333
340
 
334
341
        server = http_server.HttpServer(RequestHandlerOneZero)
335
342
        self.start_server(server)
336
 
        self.assertIsInstance(server.server, http_server.TestingHTTPServer)
 
343
        self.assertIsInstance(server._httpd, http_server.TestingHTTPServer)
337
344
 
338
345
    def test_create_http_server_one_one(self):
339
346
        class RequestHandlerOneOne(http_server.TestingHTTPRequestHandler):
342
349
 
343
350
        server = http_server.HttpServer(RequestHandlerOneOne)
344
351
        self.start_server(server)
345
 
        self.assertIsInstance(server.server,
 
352
        self.assertIsInstance(server._httpd,
346
353
                              http_server.TestingThreadingHTTPServer)
347
354
 
348
355
    def test_create_http_server_force_one_one(self):
353
360
        server = http_server.HttpServer(RequestHandlerOneZero,
354
361
                                        protocol_version='HTTP/1.1')
355
362
        self.start_server(server)
356
 
        self.assertIsInstance(server.server,
 
363
        self.assertIsInstance(server._httpd,
357
364
                              http_server.TestingThreadingHTTPServer)
358
365
 
359
366
    def test_create_http_server_force_one_zero(self):
364
371
        server = http_server.HttpServer(RequestHandlerOneOne,
365
372
                                        protocol_version='HTTP/1.0')
366
373
        self.start_server(server)
367
 
        self.assertIsInstance(server.server,
 
374
        self.assertIsInstance(server._httpd,
368
375
                              http_server.TestingHTTPServer)
369
376
 
370
377
 
399
406
class TestHttpTransportUrls(tests.TestCase):
400
407
    """Test the http urls."""
401
408
 
402
 
    scenarios = vary_by_http_client_implementation()
403
 
 
404
409
    def test_abs_url(self):
405
410
        """Construction of absolute http URLs"""
406
 
        t = self._transport('http://example.com/bzr/bzr.dev/')
 
411
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
407
412
        eq = self.assertEqualDiff
408
 
        eq(t.abspath('.'), 'http://example.com/bzr/bzr.dev')
409
 
        eq(t.abspath('foo/bar'), 'http://example.com/bzr/bzr.dev/foo/bar')
410
 
        eq(t.abspath('.bzr'), 'http://example.com/bzr/bzr.dev/.bzr')
 
413
        eq(t.abspath('.'), 'http://bazaar-vcs.org/bzr/bzr.dev')
 
414
        eq(t.abspath('foo/bar'), 'http://bazaar-vcs.org/bzr/bzr.dev/foo/bar')
 
415
        eq(t.abspath('.bzr'), 'http://bazaar-vcs.org/bzr/bzr.dev/.bzr')
411
416
        eq(t.abspath('.bzr/1//2/./3'),
412
 
           'http://example.com/bzr/bzr.dev/.bzr/1/2/3')
 
417
           'http://bazaar-vcs.org/bzr/bzr.dev/.bzr/1/2/3')
413
418
 
414
419
    def test_invalid_http_urls(self):
415
420
        """Trap invalid construction of urls"""
416
 
        self._transport('http://example.com/bzr/bzr.dev/')
 
421
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
417
422
        self.assertRaises(errors.InvalidURL,
418
423
                          self._transport,
419
 
                          'http://http://example.com/bzr/bzr.dev/')
 
424
                          'http://http://bazaar-vcs.org/bzr/bzr.dev/')
420
425
 
421
426
    def test_http_root_urls(self):
422
427
        """Construction of URLs from server root"""
423
 
        t = self._transport('http://example.com/')
 
428
        t = self._transport('http://bzr.ozlabs.org/')
424
429
        eq = self.assertEqualDiff
425
430
        eq(t.abspath('.bzr/tree-version'),
426
 
           'http://example.com/.bzr/tree-version')
 
431
           'http://bzr.ozlabs.org/.bzr/tree-version')
427
432
 
428
433
    def test_http_impl_urls(self):
429
434
        """There are servers which ask for particular clients to connect"""
431
436
        server.start_server()
432
437
        try:
433
438
            url = server.get_url()
434
 
            self.assertTrue(url.startswith('%s://' % self._url_protocol))
 
439
            self.assertTrue(url.startswith('%s://' % self._qualified_prefix))
435
440
        finally:
436
441
            server.stop_server()
437
442
 
475
480
class TestHTTPConnections(http_utils.TestCaseWithWebserver):
476
481
    """Test the http connections."""
477
482
 
478
 
    scenarios = multiply_scenarios(
479
 
        vary_by_http_client_implementation(),
480
 
        vary_by_http_protocol_version(),
481
 
        )
482
 
 
483
483
    def setUp(self):
484
484
        http_utils.TestCaseWithWebserver.setUp(self)
485
485
        self.build_tree(['foo/', 'foo/bar'], line_endings='binary',
487
487
 
488
488
    def test_http_has(self):
489
489
        server = self.get_readonly_server()
490
 
        t = self.get_readonly_transport()
 
490
        t = self._transport(server.get_url())
491
491
        self.assertEqual(t.has('foo/bar'), True)
492
492
        self.assertEqual(len(server.logs), 1)
493
493
        self.assertContainsRe(server.logs[0],
495
495
 
496
496
    def test_http_has_not_found(self):
497
497
        server = self.get_readonly_server()
498
 
        t = self.get_readonly_transport()
 
498
        t = self._transport(server.get_url())
499
499
        self.assertEqual(t.has('not-found'), False)
500
500
        self.assertContainsRe(server.logs[1],
501
501
            r'"HEAD /not-found HTTP/1.." 404 - "-" "bzr/')
502
502
 
503
503
    def test_http_get(self):
504
504
        server = self.get_readonly_server()
505
 
        t = self.get_readonly_transport()
 
505
        t = self._transport(server.get_url())
506
506
        fp = t.get('foo/bar')
507
507
        self.assertEqualDiff(
508
508
            fp.read(),
530
530
class TestHttpTransportRegistration(tests.TestCase):
531
531
    """Test registrations of various http implementations"""
532
532
 
533
 
    scenarios = vary_by_http_client_implementation()
534
 
 
535
533
    def test_http_registered(self):
536
 
        t = transport.get_transport('%s://foo.com/' % self._url_protocol)
 
534
        t = transport.get_transport('%s://foo.com/' % self._qualified_prefix)
537
535
        self.assertIsInstance(t, transport.Transport)
538
536
        self.assertIsInstance(t, self._transport)
539
537
 
540
538
 
541
539
class TestPost(tests.TestCase):
542
540
 
543
 
    scenarios = multiply_scenarios(
544
 
        vary_by_http_client_implementation(),
545
 
        vary_by_http_protocol_version(),
546
 
        )
547
 
 
548
541
    def test_post_body_is_received(self):
549
542
        server = RecordingServer(expect_body_tail='end-of-body',
550
 
                                 scheme=self._url_protocol)
 
543
            scheme=self._qualified_prefix)
551
544
        self.start_server(server)
552
545
        url = server.get_url()
553
 
        # FIXME: needs a cleanup -- vila 20100611
554
 
        http_transport = transport.get_transport(url)
 
546
        http_transport = self._transport(url)
555
547
        code, response = http_transport._post('abc def end-of-body')
556
548
        self.assertTrue(
557
549
            server.received_bytes.startswith('POST /.bzr/smart HTTP/1.'))
558
550
        self.assertTrue('content-length: 19\r' in server.received_bytes.lower())
559
 
        self.assertTrue('content-type: application/octet-stream\r'
560
 
                        in server.received_bytes.lower())
561
551
        # The transport should not be assuming that the server can accept
562
552
        # chunked encoding the first time it connects, because HTTP/1.1, so we
563
553
        # check for the literal string.
599
589
    Daughter classes are expected to override _req_handler_class
600
590
    """
601
591
 
602
 
    scenarios = multiply_scenarios(
603
 
        vary_by_http_client_implementation(),
604
 
        vary_by_http_protocol_version(),
605
 
        )
606
 
 
607
592
    # Provide a useful default
608
593
    _req_handler_class = http_server.TestingHTTPRequestHandler
609
594
 
610
595
    def create_transport_readonly_server(self):
611
 
        server = http_server.HttpServer(self._req_handler_class,
612
 
                                        protocol_version=self._protocol_version)
613
 
        server._url_protocol = self._url_protocol
614
 
        return server
 
596
        return http_server.HttpServer(self._req_handler_class,
 
597
                                      protocol_version=self._protocol_version)
615
598
 
616
599
    def _testing_pycurl(self):
617
600
        # TODO: This is duplicated for lots of the classes in this file
622
605
class WallRequestHandler(http_server.TestingHTTPRequestHandler):
623
606
    """Whatever request comes in, close the connection"""
624
607
 
625
 
    def _handle_one_request(self):
 
608
    def handle_one_request(self):
626
609
        """Handle a single HTTP request, by abruptly closing the connection"""
627
610
        self.close_connection = 1
628
611
 
633
616
    _req_handler_class = WallRequestHandler
634
617
 
635
618
    def test_http_has(self):
636
 
        t = self.get_readonly_transport()
 
619
        server = self.get_readonly_server()
 
620
        t = self._transport(server.get_url())
637
621
        # Unfortunately httplib (see HTTPResponse._read_status
638
622
        # for details) make no distinction between a closed
639
623
        # socket and badly formatted status line, so we can't
645
629
                          t.has, 'foo/bar')
646
630
 
647
631
    def test_http_get(self):
648
 
        t = self.get_readonly_transport()
 
632
        server = self.get_readonly_server()
 
633
        t = self._transport(server.get_url())
649
634
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
650
635
                           errors.InvalidHttpResponse),
651
636
                          t.get, 'foo/bar')
668
653
    _req_handler_class = BadStatusRequestHandler
669
654
 
670
655
    def test_http_has(self):
671
 
        t = self.get_readonly_transport()
 
656
        server = self.get_readonly_server()
 
657
        t = self._transport(server.get_url())
672
658
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
673
659
 
674
660
    def test_http_get(self):
675
 
        t = self.get_readonly_transport()
 
661
        server = self.get_readonly_server()
 
662
        t = self._transport(server.get_url())
676
663
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
677
664
 
678
665
 
683
670
        """Fakes handling a single HTTP request, returns a bad status"""
684
671
        ignored = http_server.TestingHTTPRequestHandler.parse_request(self)
685
672
        self.wfile.write("Invalid status line\r\n")
686
 
        # If we don't close the connection pycurl will hang. Since this is a
687
 
        # stress test we don't *have* to respect the protocol, but we don't
688
 
        # have to sabotage it too much either.
689
 
        self.close_connection = True
690
673
        return False
691
674
 
692
675
 
698
681
 
699
682
    _req_handler_class = InvalidStatusRequestHandler
700
683
 
 
684
    def test_http_has(self):
 
685
        if self._testing_pycurl() and self._protocol_version == 'HTTP/1.1':
 
686
            raise tests.KnownFailure(
 
687
                'pycurl hangs if the server send back garbage')
 
688
        super(TestInvalidStatusServer, self).test_http_has()
 
689
 
 
690
    def test_http_get(self):
 
691
        if self._testing_pycurl() and self._protocol_version == 'HTTP/1.1':
 
692
            raise tests.KnownFailure(
 
693
                'pycurl hangs if the server send back garbage')
 
694
        super(TestInvalidStatusServer, self).test_http_get()
 
695
 
701
696
 
702
697
class BadProtocolRequestHandler(http_server.TestingHTTPRequestHandler):
703
698
    """Whatever request comes in, returns a bad protocol version"""
725
720
        super(TestBadProtocolServer, self).setUp()
726
721
 
727
722
    def test_http_has(self):
728
 
        t = self.get_readonly_transport()
 
723
        server = self.get_readonly_server()
 
724
        t = self._transport(server.get_url())
729
725
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
730
726
 
731
727
    def test_http_get(self):
732
 
        t = self.get_readonly_transport()
 
728
        server = self.get_readonly_server()
 
729
        t = self._transport(server.get_url())
733
730
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
734
731
 
735
732
 
749
746
    _req_handler_class = ForbiddenRequestHandler
750
747
 
751
748
    def test_http_has(self):
752
 
        t = self.get_readonly_transport()
 
749
        server = self.get_readonly_server()
 
750
        t = self._transport(server.get_url())
753
751
        self.assertRaises(errors.TransportError, t.has, 'foo/bar')
754
752
 
755
753
    def test_http_get(self):
756
 
        t = self.get_readonly_transport()
 
754
        server = self.get_readonly_server()
 
755
        t = self._transport(server.get_url())
757
756
        self.assertRaises(errors.TransportError, t.get, 'foo/bar')
758
757
 
759
758
 
798
797
        self.build_tree_contents([('a', '0123456789')],)
799
798
 
800
799
    def test_readv(self):
801
 
        t = self.get_readonly_transport()
 
800
        server = self.get_readonly_server()
 
801
        t = self._transport(server.get_url())
802
802
        l = list(t.readv('a', ((0, 1), (1, 1), (3, 2), (9, 1))))
803
803
        self.assertEqual(l[0], (0, '0'))
804
804
        self.assertEqual(l[1], (1, '1'))
806
806
        self.assertEqual(l[3], (9, '9'))
807
807
 
808
808
    def test_readv_out_of_order(self):
809
 
        t = self.get_readonly_transport()
 
809
        server = self.get_readonly_server()
 
810
        t = self._transport(server.get_url())
810
811
        l = list(t.readv('a', ((1, 1), (9, 1), (0, 1), (3, 2))))
811
812
        self.assertEqual(l[0], (1, '1'))
812
813
        self.assertEqual(l[1], (9, '9'))
814
815
        self.assertEqual(l[3], (3, '34'))
815
816
 
816
817
    def test_readv_invalid_ranges(self):
817
 
        t = self.get_readonly_transport()
 
818
        server = self.get_readonly_server()
 
819
        t = self._transport(server.get_url())
818
820
 
819
821
        # This is intentionally reading off the end of the file
820
822
        # since we are sure that it cannot get there
828
830
 
829
831
    def test_readv_multiple_get_requests(self):
830
832
        server = self.get_readonly_server()
831
 
        t = self.get_readonly_transport()
 
833
        t = self._transport(server.get_url())
832
834
        # force transport to issue multiple requests
833
835
        t._max_readv_combine = 1
834
836
        t._max_get_ranges = 1
842
844
 
843
845
    def test_readv_get_max_size(self):
844
846
        server = self.get_readonly_server()
845
 
        t = self.get_readonly_transport()
 
847
        t = self._transport(server.get_url())
846
848
        # force transport to issue multiple requests by limiting the number of
847
849
        # bytes by request. Note that this apply to coalesced offsets only, a
848
850
        # single range will keep its size even if bigger than the limit.
857
859
 
858
860
    def test_complete_readv_leave_pipe_clean(self):
859
861
        server = self.get_readonly_server()
860
 
        t = self.get_readonly_transport()
 
862
        t = self._transport(server.get_url())
861
863
        # force transport to issue multiple requests
862
864
        t._get_max_size = 2
863
 
        list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
 
865
        l = list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
864
866
        # The server should have issued 3 requests
865
867
        self.assertEqual(3, server.GET_request_nb)
866
868
        self.assertEqual('0123456789', t.get_bytes('a'))
868
870
 
869
871
    def test_incomplete_readv_leave_pipe_clean(self):
870
872
        server = self.get_readonly_server()
871
 
        t = self.get_readonly_transport()
 
873
        t = self._transport(server.get_url())
872
874
        # force transport to issue multiple requests
873
875
        t._get_max_size = 2
874
876
        # Don't collapse readv results into a list so that we leave unread
943
945
    def get_multiple_ranges(self, file, file_size, ranges):
944
946
        self.send_response(206)
945
947
        self.send_header('Accept-Ranges', 'bytes')
946
 
        # XXX: this is strange; the 'random' name below seems undefined and
947
 
        # yet the tests pass -- mbp 2010-10-11 bug 658773
948
948
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
949
949
        self.send_header("Content-Type",
950
950
                         "multipart/byteranges; boundary=%s" % boundary)
1012
1012
                return
1013
1013
            self.send_range_content(file, start, end - start + 1)
1014
1014
            cur += 1
1015
 
        # Final boundary
 
1015
        # No final boundary
1016
1016
        self.wfile.write(boundary_line)
1017
1017
 
1018
1018
 
1026
1026
 
1027
1027
    def test_readv_with_short_reads(self):
1028
1028
        server = self.get_readonly_server()
1029
 
        t = self.get_readonly_transport()
 
1029
        t = self._transport(server.get_url())
1030
1030
        # Force separate ranges for each offset
1031
1031
        t._bytes_to_read_before_seek = 0
1032
1032
        ireadv = iter(t.readv('a', ((0, 1), (2, 1), (4, 2), (9, 1))))
1047
1047
        # that mode
1048
1048
        self.assertEqual('single', t._range_hint)
1049
1049
 
1050
 
 
1051
1050
class LimitedRangeRequestHandler(http_server.TestingHTTPRequestHandler):
1052
1051
    """Errors out when range specifiers exceed the limit"""
1053
1052
 
1077
1076
class TestLimitedRangeRequestServer(http_utils.TestCaseWithWebserver):
1078
1077
    """Tests readv requests against a server erroring out on too much ranges."""
1079
1078
 
1080
 
    scenarios = multiply_scenarios(
1081
 
        vary_by_http_client_implementation(),
1082
 
        vary_by_http_protocol_version(),
1083
 
        )
1084
 
 
1085
1079
    # Requests with more range specifiers will error out
1086
1080
    range_limit = 3
1087
1081
 
1089
1083
        return LimitedRangeHTTPServer(range_limit=self.range_limit,
1090
1084
                                      protocol_version=self._protocol_version)
1091
1085
 
 
1086
    def get_transport(self):
 
1087
        return self._transport(self.get_readonly_server().get_url())
 
1088
 
1092
1089
    def setUp(self):
1093
1090
        http_utils.TestCaseWithWebserver.setUp(self)
1094
1091
        # We need to manipulate ranges that correspond to real chunks in the
1098
1095
        self.build_tree_contents([('a', content)],)
1099
1096
 
1100
1097
    def test_few_ranges(self):
1101
 
        t = self.get_readonly_transport()
 
1098
        t = self.get_transport()
1102
1099
        l = list(t.readv('a', ((0, 4), (1024, 4), )))
1103
1100
        self.assertEqual(l[0], (0, '0000'))
1104
1101
        self.assertEqual(l[1], (1024, '0001'))
1105
1102
        self.assertEqual(1, self.get_readonly_server().GET_request_nb)
1106
1103
 
1107
1104
    def test_more_ranges(self):
1108
 
        t = self.get_readonly_transport()
 
1105
        t = self.get_transport()
1109
1106
        l = list(t.readv('a', ((0, 4), (1024, 4), (4096, 4), (8192, 4))))
1110
1107
        self.assertEqual(l[0], (0, '0000'))
1111
1108
        self.assertEqual(l[1], (1024, '0001'))
1122
1119
    Only the urllib implementation is tested here.
1123
1120
    """
1124
1121
 
 
1122
    def setUp(self):
 
1123
        tests.TestCase.setUp(self)
 
1124
        self._old_env = {}
 
1125
        self.addCleanup(self._restore_env)
 
1126
 
 
1127
    def _install_env(self, env):
 
1128
        for name, value in env.iteritems():
 
1129
            self._old_env[name] = osutils.set_or_unset_env(name, value)
 
1130
 
 
1131
    def _restore_env(self):
 
1132
        for name, value in self._old_env.iteritems():
 
1133
            osutils.set_or_unset_env(name, value)
 
1134
 
1125
1135
    def _proxied_request(self):
1126
1136
        handler = _urllib2_wrappers.ProxyHandler()
1127
 
        request = _urllib2_wrappers.Request('GET', 'http://baz/buzzle')
 
1137
        request = _urllib2_wrappers.Request('GET','http://baz/buzzle')
1128
1138
        handler.set_proxy(request, 'http')
1129
1139
        return request
1130
1140
 
1131
 
    def assertEvaluateProxyBypass(self, expected, host, no_proxy):
1132
 
        handler = _urllib2_wrappers.ProxyHandler()
1133
 
        self.assertEquals(expected,
1134
 
                          handler.evaluate_proxy_bypass(host, no_proxy))
1135
 
 
1136
1141
    def test_empty_user(self):
1137
 
        self.overrideEnv('http_proxy', 'http://bar.com')
1138
 
        request = self._proxied_request()
1139
 
        self.assertFalse(request.headers.has_key('Proxy-authorization'))
1140
 
 
1141
 
    def test_user_with_at(self):
1142
 
        self.overrideEnv('http_proxy',
1143
 
                         'http://username@domain:password@proxy_host:1234')
 
1142
        self._install_env({'http_proxy': 'http://bar.com'})
1144
1143
        request = self._proxied_request()
1145
1144
        self.assertFalse(request.headers.has_key('Proxy-authorization'))
1146
1145
 
1147
1146
    def test_invalid_proxy(self):
1148
1147
        """A proxy env variable without scheme"""
1149
 
        self.overrideEnv('http_proxy', 'host:1234')
 
1148
        self._install_env({'http_proxy': 'host:1234'})
1150
1149
        self.assertRaises(errors.InvalidURL, self._proxied_request)
1151
1150
 
1152
 
    def test_evaluate_proxy_bypass_true(self):
1153
 
        """The host is not proxied"""
1154
 
        self.assertEvaluateProxyBypass(True, 'example.com', 'example.com')
1155
 
        self.assertEvaluateProxyBypass(True, 'bzr.example.com', '*example.com')
1156
 
 
1157
 
    def test_evaluate_proxy_bypass_false(self):
1158
 
        """The host is proxied"""
1159
 
        self.assertEvaluateProxyBypass(False, 'bzr.example.com', None)
1160
 
 
1161
 
    def test_evaluate_proxy_bypass_unknown(self):
1162
 
        """The host is not explicitly proxied"""
1163
 
        self.assertEvaluateProxyBypass(None, 'example.com', 'not.example.com')
1164
 
        self.assertEvaluateProxyBypass(None, 'bzr.example.com', 'example.com')
1165
 
 
1166
 
    def test_evaluate_proxy_bypass_empty_entries(self):
1167
 
        """Ignore empty entries"""
1168
 
        self.assertEvaluateProxyBypass(None, 'example.com', '')
1169
 
        self.assertEvaluateProxyBypass(None, 'example.com', ',')
1170
 
        self.assertEvaluateProxyBypass(None, 'example.com', 'foo,,bar')
1171
 
 
1172
1151
 
1173
1152
class TestProxyHttpServer(http_utils.TestCaseWithTwoWebservers):
1174
1153
    """Tests proxy server.
1179
1158
    to the file names).
1180
1159
    """
1181
1160
 
1182
 
    scenarios = multiply_scenarios(
1183
 
        vary_by_http_client_implementation(),
1184
 
        vary_by_http_protocol_version(),
1185
 
        )
1186
 
 
1187
1161
    # FIXME: We don't have an https server available, so we don't
1188
 
    # test https connections. --vila toolongago
 
1162
    # test https connections.
1189
1163
 
1190
1164
    def setUp(self):
1191
1165
        super(TestProxyHttpServer, self).setUp()
1192
 
        self.transport_secondary_server = http_utils.ProxyServer
1193
1166
        self.build_tree_contents([('foo', 'contents of foo\n'),
1194
1167
                                  ('foo-proxied', 'proxied contents of foo\n')])
1195
1168
        # Let's setup some attributes for tests
1196
 
        server = self.get_readonly_server()
1197
 
        self.server_host_port = '%s:%d' % (server.host, server.port)
 
1169
        self.server = self.get_readonly_server()
 
1170
        self.proxy_address = '%s:%d' % (self.server.host, self.server.port)
1198
1171
        if self._testing_pycurl():
1199
1172
            # Oh my ! pycurl does not check for the port as part of
1200
1173
            # no_proxy :-( So we just test the host part
1201
 
            self.no_proxy_host = server.host
 
1174
            self.no_proxy_host = self.server.host
1202
1175
        else:
1203
 
            self.no_proxy_host = self.server_host_port
 
1176
            self.no_proxy_host = self.proxy_address
1204
1177
        # The secondary server is the proxy
1205
 
        self.proxy_url = self.get_secondary_url()
 
1178
        self.proxy = self.get_secondary_server()
 
1179
        self.proxy_url = self.proxy.get_url()
 
1180
        self._old_env = {}
1206
1181
 
1207
1182
    def _testing_pycurl(self):
1208
1183
        # TODO: This is duplicated for lots of the classes in this file
1209
1184
        return (features.pycurl.available()
1210
1185
                and self._transport == PyCurlTransport)
1211
1186
 
1212
 
    def assertProxied(self):
1213
 
        t = self.get_readonly_transport()
1214
 
        self.assertEqual('proxied contents of foo\n', t.get('foo').read())
1215
 
 
1216
 
    def assertNotProxied(self):
1217
 
        t = self.get_readonly_transport()
1218
 
        self.assertEqual('contents of foo\n', t.get('foo').read())
 
1187
    def create_transport_secondary_server(self):
 
1188
        """Creates an http server that will serve files with
 
1189
        '-proxied' appended to their names.
 
1190
        """
 
1191
        return http_utils.ProxyServer(protocol_version=self._protocol_version)
 
1192
 
 
1193
    def _install_env(self, env):
 
1194
        for name, value in env.iteritems():
 
1195
            self._old_env[name] = osutils.set_or_unset_env(name, value)
 
1196
 
 
1197
    def _restore_env(self):
 
1198
        for name, value in self._old_env.iteritems():
 
1199
            osutils.set_or_unset_env(name, value)
 
1200
 
 
1201
    def proxied_in_env(self, env):
 
1202
        self._install_env(env)
 
1203
        url = self.server.get_url()
 
1204
        t = self._transport(url)
 
1205
        try:
 
1206
            self.assertEqual('proxied contents of foo\n', t.get('foo').read())
 
1207
        finally:
 
1208
            self._restore_env()
 
1209
 
 
1210
    def not_proxied_in_env(self, env):
 
1211
        self._install_env(env)
 
1212
        url = self.server.get_url()
 
1213
        t = self._transport(url)
 
1214
        try:
 
1215
            self.assertEqual('contents of foo\n', t.get('foo').read())
 
1216
        finally:
 
1217
            self._restore_env()
1219
1218
 
1220
1219
    def test_http_proxy(self):
1221
 
        self.overrideEnv('http_proxy', self.proxy_url)
1222
 
        self.assertProxied()
 
1220
        self.proxied_in_env({'http_proxy': self.proxy_url})
1223
1221
 
1224
1222
    def test_HTTP_PROXY(self):
1225
1223
        if self._testing_pycurl():
1228
1226
            # about. Should we ?)
1229
1227
            raise tests.TestNotApplicable(
1230
1228
                'pycurl does not check HTTP_PROXY for security reasons')
1231
 
        self.overrideEnv('HTTP_PROXY', self.proxy_url)
1232
 
        self.assertProxied()
 
1229
        self.proxied_in_env({'HTTP_PROXY': self.proxy_url})
1233
1230
 
1234
1231
    def test_all_proxy(self):
1235
 
        self.overrideEnv('all_proxy', self.proxy_url)
1236
 
        self.assertProxied()
 
1232
        self.proxied_in_env({'all_proxy': self.proxy_url})
1237
1233
 
1238
1234
    def test_ALL_PROXY(self):
1239
 
        self.overrideEnv('ALL_PROXY', self.proxy_url)
1240
 
        self.assertProxied()
 
1235
        self.proxied_in_env({'ALL_PROXY': self.proxy_url})
1241
1236
 
1242
1237
    def test_http_proxy_with_no_proxy(self):
1243
 
        self.overrideEnv('no_proxy', self.no_proxy_host)
1244
 
        self.overrideEnv('http_proxy', self.proxy_url)
1245
 
        self.assertNotProxied()
 
1238
        self.not_proxied_in_env({'http_proxy': self.proxy_url,
 
1239
                                 'no_proxy': self.no_proxy_host})
1246
1240
 
1247
1241
    def test_HTTP_PROXY_with_NO_PROXY(self):
1248
1242
        if self._testing_pycurl():
1249
1243
            raise tests.TestNotApplicable(
1250
1244
                'pycurl does not check HTTP_PROXY for security reasons')
1251
 
        self.overrideEnv('NO_PROXY', self.no_proxy_host)
1252
 
        self.overrideEnv('HTTP_PROXY', self.proxy_url)
1253
 
        self.assertNotProxied()
 
1245
        self.not_proxied_in_env({'HTTP_PROXY': self.proxy_url,
 
1246
                                 'NO_PROXY': self.no_proxy_host})
1254
1247
 
1255
1248
    def test_all_proxy_with_no_proxy(self):
1256
 
        self.overrideEnv('no_proxy', self.no_proxy_host)
1257
 
        self.overrideEnv('all_proxy', self.proxy_url)
1258
 
        self.assertNotProxied()
 
1249
        self.not_proxied_in_env({'all_proxy': self.proxy_url,
 
1250
                                 'no_proxy': self.no_proxy_host})
1259
1251
 
1260
1252
    def test_ALL_PROXY_with_NO_PROXY(self):
1261
 
        self.overrideEnv('NO_PROXY', self.no_proxy_host)
1262
 
        self.overrideEnv('ALL_PROXY', self.proxy_url)
1263
 
        self.assertNotProxied()
 
1253
        self.not_proxied_in_env({'ALL_PROXY': self.proxy_url,
 
1254
                                 'NO_PROXY': self.no_proxy_host})
1264
1255
 
1265
1256
    def test_http_proxy_without_scheme(self):
1266
 
        self.overrideEnv('http_proxy', self.server_host_port)
1267
1257
        if self._testing_pycurl():
1268
1258
            # pycurl *ignores* invalid proxy env variables. If that ever change
1269
1259
            # in the future, this test will fail indicating that pycurl do not
1270
1260
            # ignore anymore such variables.
1271
 
            self.assertNotProxied()
 
1261
            self.not_proxied_in_env({'http_proxy': self.proxy_address})
1272
1262
        else:
1273
 
            self.assertRaises(errors.InvalidURL, self.assertProxied)
 
1263
            self.assertRaises(errors.InvalidURL,
 
1264
                              self.proxied_in_env,
 
1265
                              {'http_proxy': self.proxy_address})
1274
1266
 
1275
1267
 
1276
1268
class TestRanges(http_utils.TestCaseWithWebserver):
1277
1269
    """Test the Range header in GET methods."""
1278
1270
 
1279
 
    scenarios = multiply_scenarios(
1280
 
        vary_by_http_client_implementation(),
1281
 
        vary_by_http_protocol_version(),
1282
 
        )
1283
 
 
1284
1271
    def setUp(self):
1285
1272
        http_utils.TestCaseWithWebserver.setUp(self)
1286
1273
        self.build_tree_contents([('a', '0123456789')],)
 
1274
        server = self.get_readonly_server()
 
1275
        self.transport = self._transport(server.get_url())
1287
1276
 
1288
1277
    def create_transport_readonly_server(self):
1289
1278
        return http_server.HttpServer(protocol_version=self._protocol_version)
1290
1279
 
1291
1280
    def _file_contents(self, relpath, ranges):
1292
 
        t = self.get_readonly_transport()
1293
1281
        offsets = [ (start, end - start + 1) for start, end in ranges]
1294
 
        coalesce = t._coalesce_offsets
 
1282
        coalesce = self.transport._coalesce_offsets
1295
1283
        coalesced = list(coalesce(offsets, limit=0, fudge_factor=0))
1296
 
        code, data = t._get(relpath, coalesced)
 
1284
        code, data = self.transport._get(relpath, coalesced)
1297
1285
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
1298
1286
        for start, end in ranges:
1299
1287
            data.seek(start)
1300
1288
            yield data.read(end - start + 1)
1301
1289
 
1302
1290
    def _file_tail(self, relpath, tail_amount):
1303
 
        t = self.get_readonly_transport()
1304
 
        code, data = t._get(relpath, [], tail_amount)
 
1291
        code, data = self.transport._get(relpath, [], tail_amount)
1305
1292
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
1306
1293
        data.seek(-tail_amount, 2)
1307
1294
        return data.read(tail_amount)
1326
1313
class TestHTTPRedirections(http_utils.TestCaseWithRedirectedWebserver):
1327
1314
    """Test redirection between http servers."""
1328
1315
 
1329
 
    scenarios = multiply_scenarios(
1330
 
        vary_by_http_client_implementation(),
1331
 
        vary_by_http_protocol_version(),
1332
 
        )
 
1316
    def create_transport_secondary_server(self):
 
1317
        """Create the secondary server redirecting to the primary server"""
 
1318
        new = self.get_readonly_server()
 
1319
 
 
1320
        redirecting = http_utils.HTTPServerRedirecting(
 
1321
            protocol_version=self._protocol_version)
 
1322
        redirecting.redirect_to(new.host, new.port)
 
1323
        return redirecting
1333
1324
 
1334
1325
    def setUp(self):
1335
1326
        super(TestHTTPRedirections, self).setUp()
1337
1328
                                  ('bundle',
1338
1329
                                  '# Bazaar revision bundle v0.9\n#\n')
1339
1330
                                  ],)
 
1331
        # The requests to the old server will be redirected to the new server
 
1332
        self.old_transport = self._transport(self.old_server.get_url())
1340
1333
 
1341
1334
    def test_redirected(self):
1342
 
        self.assertRaises(errors.RedirectRequested,
1343
 
                          self.get_old_transport().get, 'a')
1344
 
        self.assertEqual('0123456789', self.get_new_transport().get('a').read())
 
1335
        self.assertRaises(errors.RedirectRequested, self.old_transport.get, 'a')
 
1336
        t = self._transport(self.new_server.get_url())
 
1337
        self.assertEqual('0123456789', t.get('a').read())
1345
1338
 
1346
1339
 
1347
1340
class RedirectedRequest(_urllib2_wrappers.Request):
1364
1357
    test.overrideAttr(_urllib2_wrappers, 'Request', RedirectedRequest)
1365
1358
 
1366
1359
 
1367
 
def cleanup_http_redirection_connections(test):
1368
 
    # Some sockets are opened but never seen by _urllib, so we trap them at
1369
 
    # the _urllib2_wrappers level to be able to clean them up.
1370
 
    def socket_disconnect(sock):
1371
 
        try:
1372
 
            sock.shutdown(socket.SHUT_RDWR)
1373
 
            sock.close()
1374
 
        except socket.error:
1375
 
            pass
1376
 
    def connect(connection):
1377
 
        test.http_connect_orig(connection)
1378
 
        test.addCleanup(socket_disconnect, connection.sock)
1379
 
    test.http_connect_orig = test.overrideAttr(
1380
 
        _urllib2_wrappers.HTTPConnection, 'connect', connect)
1381
 
    def connect(connection):
1382
 
        test.https_connect_orig(connection)
1383
 
        test.addCleanup(socket_disconnect, connection.sock)
1384
 
    test.https_connect_orig = test.overrideAttr(
1385
 
        _urllib2_wrappers.HTTPSConnection, 'connect', connect)
1386
 
 
1387
 
 
1388
1360
class TestHTTPSilentRedirections(http_utils.TestCaseWithRedirectedWebserver):
1389
1361
    """Test redirections.
1390
1362
 
1399
1371
    -- vila 20070212
1400
1372
    """
1401
1373
 
1402
 
    scenarios = multiply_scenarios(
1403
 
        vary_by_http_client_implementation(),
1404
 
        vary_by_http_protocol_version(),
1405
 
        )
1406
 
 
1407
1374
    def setUp(self):
1408
1375
        if (features.pycurl.available()
1409
1376
            and self._transport == PyCurlTransport):
1410
1377
            raise tests.TestNotApplicable(
1411
 
                "pycurl doesn't redirect silently anymore")
 
1378
                "pycurl doesn't redirect silently annymore")
1412
1379
        super(TestHTTPSilentRedirections, self).setUp()
1413
1380
        install_redirected_request(self)
1414
 
        cleanup_http_redirection_connections(self)
1415
1381
        self.build_tree_contents([('a','a'),
1416
1382
                                  ('1/',),
1417
1383
                                  ('1/a', 'redirected once'),
1425
1391
                                  ('5/a', 'redirected 5 times'),
1426
1392
                                  ],)
1427
1393
 
 
1394
        self.old_transport = self._transport(self.old_server.get_url())
 
1395
 
 
1396
    def create_transport_secondary_server(self):
 
1397
        """Create the secondary server, redirections are defined in the tests"""
 
1398
        return http_utils.HTTPServerRedirecting(
 
1399
            protocol_version=self._protocol_version)
 
1400
 
1428
1401
    def test_one_redirection(self):
1429
 
        t = self.get_old_transport()
1430
 
        req = RedirectedRequest('GET', t._remote_path('a'))
 
1402
        t = self.old_transport
 
1403
 
 
1404
        req = RedirectedRequest('GET', t.abspath('a'))
1431
1405
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1432
1406
                                       self.new_server.port)
1433
1407
        self.old_server.redirections = \
1434
1408
            [('(.*)', r'%s/1\1' % (new_prefix), 301),]
1435
 
        self.assertEqual('redirected once', t._perform(req).read())
 
1409
        self.assertEqual('redirected once',t._perform(req).read())
1436
1410
 
1437
1411
    def test_five_redirections(self):
1438
 
        t = self.get_old_transport()
1439
 
        req = RedirectedRequest('GET', t._remote_path('a'))
 
1412
        t = self.old_transport
 
1413
 
 
1414
        req = RedirectedRequest('GET', t.abspath('a'))
1440
1415
        old_prefix = 'http://%s:%s' % (self.old_server.host,
1441
1416
                                       self.old_server.port)
1442
1417
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1448
1423
            ('/4(.*)', r'%s/5\1' % (new_prefix), 301),
1449
1424
            ('(/[^/]+)', r'%s/1\1' % (old_prefix), 301),
1450
1425
            ]
1451
 
        self.assertEqual('redirected 5 times', t._perform(req).read())
 
1426
        self.assertEqual('redirected 5 times',t._perform(req).read())
1452
1427
 
1453
1428
 
1454
1429
class TestDoCatchRedirections(http_utils.TestCaseWithRedirectedWebserver):
1455
1430
    """Test transport.do_catching_redirections."""
1456
1431
 
1457
 
    scenarios = multiply_scenarios(
1458
 
        vary_by_http_client_implementation(),
1459
 
        vary_by_http_protocol_version(),
1460
 
        )
1461
 
 
1462
1432
    def setUp(self):
1463
1433
        super(TestDoCatchRedirections, self).setUp()
1464
1434
        self.build_tree_contents([('a', '0123456789'),],)
1465
 
        cleanup_http_redirection_connections(self)
1466
 
 
1467
 
        self.old_transport = self.get_old_transport()
1468
 
 
1469
 
    def get_a(self, t):
1470
 
        return t.get('a')
 
1435
 
 
1436
        self.old_transport = self._transport(self.old_server.get_url())
 
1437
 
 
1438
    def get_a(self, transport):
 
1439
        return transport.get('a')
1471
1440
 
1472
1441
    def test_no_redirection(self):
1473
 
        t = self.get_new_transport()
 
1442
        t = self._transport(self.new_server.get_url())
1474
1443
 
1475
1444
        # We use None for redirected so that we fail if redirected
1476
1445
        self.assertEqual('0123456789',
1480
1449
    def test_one_redirection(self):
1481
1450
        self.redirections = 0
1482
1451
 
1483
 
        def redirected(t, exception, redirection_notice):
 
1452
        def redirected(transport, exception, redirection_notice):
1484
1453
            self.redirections += 1
1485
 
            redirected_t = t._redirected_to(exception.source, exception.target)
1486
 
            return redirected_t
 
1454
            dir, file = urlutils.split(exception.target)
 
1455
            return self._transport(dir)
1487
1456
 
1488
1457
        self.assertEqual('0123456789',
1489
1458
                         transport.do_catching_redirections(
1503
1472
                          self.get_a, self.old_transport, redirected)
1504
1473
 
1505
1474
 
1506
 
def _setup_authentication_config(**kwargs):
1507
 
    conf = config.AuthenticationConfig()
1508
 
    conf._get_config().update({'httptest': kwargs})
1509
 
    conf._save()
1510
 
 
1511
 
 
1512
 
class TestUrllib2AuthHandler(tests.TestCaseWithTransport):
1513
 
    """Unit tests for glue by which urllib2 asks us for authentication"""
1514
 
 
1515
 
    def test_get_user_password_without_port(self):
1516
 
        """We cope if urllib2 doesn't tell us the port.
1517
 
 
1518
 
        See https://bugs.launchpad.net/bzr/+bug/654684
1519
 
        """
1520
 
        user = 'joe'
1521
 
        password = 'foo'
1522
 
        _setup_authentication_config(scheme='http', host='localhost',
1523
 
                                     user=user, password=password)
1524
 
        handler = _urllib2_wrappers.HTTPAuthHandler()
1525
 
        got_pass = handler.get_user_password(dict(
1526
 
            user='joe',
1527
 
            protocol='http',
1528
 
            host='localhost',
1529
 
            path='/',
1530
 
            realm='Realm',
1531
 
            ))
1532
 
        self.assertEquals((user, password), got_pass)
1533
 
 
1534
 
 
1535
1475
class TestAuth(http_utils.TestCaseWithWebserver):
1536
1476
    """Test authentication scheme"""
1537
1477
 
1538
 
    scenarios = multiply_scenarios(
1539
 
        vary_by_http_client_implementation(),
1540
 
        vary_by_http_protocol_version(),
1541
 
        vary_by_http_auth_scheme(),
1542
 
        )
 
1478
    _auth_header = 'Authorization'
 
1479
    _password_prompt_prefix = ''
 
1480
    _username_prompt_prefix = ''
 
1481
    # Set by load_tests
 
1482
    _auth_server = None
1543
1483
 
1544
1484
    def setUp(self):
1545
1485
        super(TestAuth, self).setUp()
1548
1488
                                  ('b', 'contents of b\n'),])
1549
1489
 
1550
1490
    def create_transport_readonly_server(self):
1551
 
        server = self._auth_server(protocol_version=self._protocol_version)
1552
 
        server._url_protocol = self._url_protocol
1553
 
        return server
 
1491
        return self._auth_server(protocol_version=self._protocol_version)
1554
1492
 
1555
1493
    def _testing_pycurl(self):
1556
1494
        # TODO: This is duplicated for lots of the classes in this file
1569
1507
        return url
1570
1508
 
1571
1509
    def get_user_transport(self, user, password):
1572
 
        t = transport.get_transport(self.get_user_url(user, password))
1573
 
        return t
 
1510
        return self._transport(self.get_user_url(user, password))
1574
1511
 
1575
1512
    def test_no_user(self):
1576
1513
        self.server.add_user('joe', 'foo')
1687
1624
        ui.ui_factory = tests.TestUIFactory(stdin=stdin_content,
1688
1625
                                            stderr=tests.StringIOWrapper())
1689
1626
        # Create a minimal config file with the right password
1690
 
        _setup_authentication_config(scheme='http', port=self.server.port,
1691
 
                                     user=user, password=password)
 
1627
        conf = config.AuthenticationConfig()
 
1628
        conf._get_config().update(
 
1629
            {'httptest': {'scheme': 'http', 'port': self.server.port,
 
1630
                          'user': user, 'password': password}})
 
1631
        conf._save()
1692
1632
        # Issue a request to the server to connect
1693
1633
        self.assertEqual('contents of a\n',t.get('a').read())
1694
1634
        # stdin should have  been left untouched
1696
1636
        # Only one 'Authentication Required' error should occur
1697
1637
        self.assertEqual(1, self.server.auth_required_errors)
1698
1638
 
 
1639
    def test_user_from_auth_conf(self):
 
1640
        if self._testing_pycurl():
 
1641
            raise tests.TestNotApplicable(
 
1642
                'pycurl does not support authentication.conf')
 
1643
        user = 'joe'
 
1644
        password = 'foo'
 
1645
        self.server.add_user(user, password)
 
1646
        # Create a minimal config file with the right password
 
1647
        conf = config.AuthenticationConfig()
 
1648
        conf._get_config().update(
 
1649
            {'httptest': {'scheme': 'http', 'port': self.server.port,
 
1650
                          'user': user, 'password': password}})
 
1651
        conf._save()
 
1652
        t = self.get_user_transport(None, None)
 
1653
        # Issue a request to the server to connect
 
1654
        self.assertEqual('contents of a\n', t.get('a').read())
 
1655
        # Only one 'Authentication Required' error should occur
 
1656
        self.assertEqual(1, self.server.auth_required_errors)
 
1657
 
1699
1658
    def test_changing_nonce(self):
1700
1659
        if self._auth_server not in (http_utils.HTTPDigestAuthServer,
1701
1660
                                     http_utils.ProxyDigestAuthServer):
1717
1676
        # initial 'who are you' and a second 'who are you' with the new nonce)
1718
1677
        self.assertEqual(2, self.server.auth_required_errors)
1719
1678
 
1720
 
    def test_user_from_auth_conf(self):
1721
 
        if self._testing_pycurl():
1722
 
            raise tests.TestNotApplicable(
1723
 
                'pycurl does not support authentication.conf')
1724
 
        user = 'joe'
1725
 
        password = 'foo'
1726
 
        self.server.add_user(user, password)
1727
 
        _setup_authentication_config(scheme='http', port=self.server.port,
1728
 
                                     user=user, password=password)
1729
 
        t = self.get_user_transport(None, None)
1730
 
        # Issue a request to the server to connect
1731
 
        self.assertEqual('contents of a\n', t.get('a').read())
1732
 
        # Only one 'Authentication Required' error should occur
1733
 
        self.assertEqual(1, self.server.auth_required_errors)
1734
 
 
1735
 
    def test_no_credential_leaks_in_log(self):
1736
 
        self.overrideAttr(debug, 'debug_flags', set(['http']))
1737
 
        user = 'joe'
1738
 
        password = 'very-sensitive-password'
1739
 
        self.server.add_user(user, password)
1740
 
        t = self.get_user_transport(user, password)
1741
 
        # Capture the debug calls to mutter
1742
 
        self.mutters = []
1743
 
        def mutter(*args):
1744
 
            lines = args[0] % args[1:]
1745
 
            # Some calls output multiple lines, just split them now since we
1746
 
            # care about a single one later.
1747
 
            self.mutters.extend(lines.splitlines())
1748
 
        self.overrideAttr(trace, 'mutter', mutter)
1749
 
        # Issue a request to the server to connect
1750
 
        self.assertEqual(True, t.has('a'))
1751
 
        # Only one 'Authentication Required' error should occur
1752
 
        self.assertEqual(1, self.server.auth_required_errors)
1753
 
        # Since the authentification succeeded, there should be a corresponding
1754
 
        # debug line
1755
 
        sent_auth_headers = [line for line in self.mutters
1756
 
                             if line.startswith('> %s' % (self._auth_header,))]
1757
 
        self.assertLength(1, sent_auth_headers)
1758
 
        self.assertStartsWith(sent_auth_headers[0],
1759
 
                              '> %s: <masked>' % (self._auth_header,))
1760
1679
 
1761
1680
 
1762
1681
class TestProxyAuth(TestAuth):
1763
 
    """Test proxy authentication schemes.
1764
 
 
1765
 
    This inherits from TestAuth to tweak the setUp and filter some failing
1766
 
    tests.
1767
 
    """
1768
 
 
1769
 
    scenarios = multiply_scenarios(
1770
 
        vary_by_http_client_implementation(),
1771
 
        vary_by_http_protocol_version(),
1772
 
        vary_by_http_proxy_auth_scheme(),
1773
 
        )
 
1682
    """Test proxy authentication schemes."""
 
1683
 
 
1684
    _auth_header = 'Proxy-authorization'
 
1685
    _password_prompt_prefix = 'Proxy '
 
1686
    _username_prompt_prefix = 'Proxy '
1774
1687
 
1775
1688
    def setUp(self):
1776
1689
        super(TestProxyAuth, self).setUp()
 
1690
        self._old_env = {}
 
1691
        self.addCleanup(self._restore_env)
1777
1692
        # Override the contents to avoid false positives
1778
1693
        self.build_tree_contents([('a', 'not proxied contents of a\n'),
1779
1694
                                  ('b', 'not proxied contents of b\n'),
1782
1697
                                  ])
1783
1698
 
1784
1699
    def get_user_transport(self, user, password):
1785
 
        self.overrideEnv('all_proxy', self.get_user_url(user, password))
1786
 
        return TestAuth.get_user_transport(self, user, password)
 
1700
        self._install_env({'all_proxy': self.get_user_url(user, password)})
 
1701
        return self._transport(self.server.get_url())
 
1702
 
 
1703
    def _install_env(self, env):
 
1704
        for name, value in env.iteritems():
 
1705
            self._old_env[name] = osutils.set_or_unset_env(name, value)
 
1706
 
 
1707
    def _restore_env(self):
 
1708
        for name, value in self._old_env.iteritems():
 
1709
            osutils.set_or_unset_env(name, value)
1787
1710
 
1788
1711
    def test_empty_pass(self):
1789
1712
        if self._testing_pycurl():
1808
1731
        self.readfile = StringIO(socket_read_content)
1809
1732
        self.writefile = StringIO()
1810
1733
        self.writefile.close = lambda: None
1811
 
        self.close = lambda: None
1812
1734
 
1813
1735
    def makefile(self, mode='r', bufsize=None):
1814
1736
        if 'r' in mode:
1819
1741
 
1820
1742
class SmartHTTPTunnellingTest(tests.TestCaseWithTransport):
1821
1743
 
1822
 
    scenarios = multiply_scenarios(
1823
 
        vary_by_http_client_implementation(),
1824
 
        vary_by_http_protocol_version(),
1825
 
        )
1826
 
 
1827
1744
    def setUp(self):
1828
1745
        super(SmartHTTPTunnellingTest, self).setUp()
1829
1746
        # We use the VFS layer as part of HTTP tunnelling tests.
1830
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1747
        self._captureVar('BZR_NO_SMART_VFS', None)
1831
1748
        self.transport_readonly_server = http_utils.HTTPServerWithSmarts
1832
 
        self.http_server = self.get_readonly_server()
1833
1749
 
1834
1750
    def create_transport_readonly_server(self):
1835
 
        server = http_utils.HTTPServerWithSmarts(
 
1751
        return http_utils.HTTPServerWithSmarts(
1836
1752
            protocol_version=self._protocol_version)
1837
 
        server._url_protocol = self._url_protocol
1838
 
        return server
1839
1753
 
1840
1754
    def test_open_bzrdir(self):
1841
1755
        branch = self.make_branch('relpath')
1842
 
        url = self.http_server.get_url() + 'relpath'
 
1756
        http_server = self.get_readonly_server()
 
1757
        url = http_server.get_url() + 'relpath'
1843
1758
        bd = bzrdir.BzrDir.open(url)
1844
 
        self.addCleanup(bd.transport.disconnect)
1845
1759
        self.assertIsInstance(bd, _mod_remote.RemoteBzrDir)
1846
1760
 
1847
1761
    def test_bulk_data(self):
1849
1763
        # The 'readv' command in the smart protocol both sends and receives
1850
1764
        # bulk data, so we use that.
1851
1765
        self.build_tree(['data-file'])
1852
 
        http_transport = transport.get_transport(self.http_server.get_url())
 
1766
        http_server = self.get_readonly_server()
 
1767
        http_transport = self._transport(http_server.get_url())
1853
1768
        medium = http_transport.get_smart_medium()
1854
1769
        # Since we provide the medium, the url below will be mostly ignored
1855
1770
        # during the test, as long as the path is '/'.
1863
1778
        post_body = 'hello\n'
1864
1779
        expected_reply_body = 'ok\x012\n'
1865
1780
 
1866
 
        http_transport = transport.get_transport(self.http_server.get_url())
 
1781
        http_server = self.get_readonly_server()
 
1782
        http_transport = self._transport(http_server.get_url())
1867
1783
        medium = http_transport.get_smart_medium()
1868
1784
        response = medium.send_http_smart_request(post_body)
1869
1785
        reply_body = response.read()
1870
1786
        self.assertEqual(expected_reply_body, reply_body)
1871
1787
 
1872
1788
    def test_smart_http_server_post_request_handler(self):
1873
 
        httpd = self.http_server.server
 
1789
        httpd = self.get_readonly_server()._get_httpd()
1874
1790
 
1875
1791
        socket = SampleSocket(
1876
1792
            'POST /.bzr/smart %s \r\n' % self._protocol_version
1908
1824
 
1909
1825
    def test_probe_smart_server(self):
1910
1826
        """Test error handling against server refusing smart requests."""
1911
 
        t = self.get_readonly_transport()
 
1827
        server = self.get_readonly_server()
 
1828
        t = self._transport(server.get_url())
1912
1829
        # No need to build a valid smart request here, the server will not even
1913
1830
        # try to interpret it.
1914
1831
        self.assertRaises(errors.SmartProtocolError,
1915
1832
                          t.get_smart_medium().send_http_smart_request,
1916
1833
                          'whatever')
1917
1834
 
1918
 
 
1919
1835
class Test_redirected_to(tests.TestCase):
1920
1836
 
1921
 
    scenarios = vary_by_http_client_implementation()
1922
 
 
1923
1837
    def test_redirected_to_subdir(self):
1924
1838
        t = self._transport('http://www.example.com/foo')
1925
1839
        r = t._redirected_to('http://www.example.com/foo',
1976
1890
    line.
1977
1891
    """
1978
1892
 
1979
 
    def _handle_one_request(self):
 
1893
    def handle_one_request(self):
1980
1894
        tcs = self.server.test_case_server
1981
1895
        requestline = self.rfile.readline()
1982
1896
        headers = self.MessageClass(self.rfile, 0)
2037
1951
        tests.TestCase.setUp(self)
2038
1952
        self.server = self._activity_server(self._protocol_version)
2039
1953
        self.server.start_server()
2040
 
        _activities = {} # Don't close over self and create a cycle
 
1954
        self.activities = {}
2041
1955
        def report_activity(t, bytes, direction):
2042
 
            count = _activities.get(direction, 0)
 
1956
            count = self.activities.get(direction, 0)
2043
1957
            count += bytes
2044
 
            _activities[direction] = count
2045
 
        self.activities = _activities
 
1958
            self.activities[direction] = count
2046
1959
 
2047
1960
        # We override at class level because constructors may propagate the
2048
1961
        # bound method and render instance overriding ineffective (an
2051
1964
        self.addCleanup(self.server.stop_server)
2052
1965
 
2053
1966
    def get_transport(self):
2054
 
        t = self._transport(self.server.get_url())
2055
 
        # FIXME: Needs cleanup -- vila 20100611
2056
 
        return t
 
1967
        return self._transport(self.server.get_url())
2057
1968
 
2058
1969
    def assertActivitiesMatch(self):
2059
1970
        self.assertEqual(self.server.bytes_read,
2164
2075
'''
2165
2076
        t = self.get_transport()
2166
2077
        # We must send a single line of body bytes, see
2167
 
        # PredefinedRequestHandler._handle_one_request
 
2078
        # PredefinedRequestHandler.handle_one_request
2168
2079
        code, f = t._post('abc def end-of-body\n')
2169
2080
        self.assertEqual('lalala whatever as long as itsssss\n', f.read())
2170
2081
        self.assertActivitiesMatch()
2172
2083
 
2173
2084
class TestActivity(tests.TestCase, TestActivityMixin):
2174
2085
 
2175
 
    scenarios = multiply_scenarios(
2176
 
        vary_by_http_activity(),
2177
 
        vary_by_http_protocol_version(),
2178
 
        )
2179
 
 
2180
2086
    def setUp(self):
2181
2087
        TestActivityMixin.setUp(self)
2182
2088
 
2203
2109
class TestAuthOnRedirected(http_utils.TestCaseWithRedirectedWebserver):
2204
2110
    """Test authentication on the redirected http server."""
2205
2111
 
2206
 
    scenarios = vary_by_http_protocol_version()
2207
 
 
2208
2112
    _auth_header = 'Authorization'
2209
2113
    _password_prompt_prefix = ''
2210
2114
    _username_prompt_prefix = ''
2211
2115
    _auth_server = http_utils.HTTPBasicAuthServer
2212
2116
    _transport = _urllib.HttpTransport_urllib
2213
2117
 
 
2118
    def create_transport_readonly_server(self):
 
2119
        return self._auth_server(protocol_version=self._protocol_version)
 
2120
 
 
2121
    def create_transport_secondary_server(self):
 
2122
        """Create the secondary server redirecting to the primary server"""
 
2123
        new = self.get_readonly_server()
 
2124
 
 
2125
        redirecting = http_utils.HTTPServerRedirecting(
 
2126
            protocol_version=self._protocol_version)
 
2127
        redirecting.redirect_to(new.host, new.port)
 
2128
        return redirecting
 
2129
 
2214
2130
    def setUp(self):
2215
2131
        super(TestAuthOnRedirected, self).setUp()
2216
2132
        self.build_tree_contents([('a','a'),
2221
2137
                                       self.new_server.port)
2222
2138
        self.old_server.redirections = [
2223
2139
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2224
 
        self.old_transport = self.get_old_transport()
 
2140
        self.old_transport = self._transport(self.old_server.get_url())
2225
2141
        self.new_server.add_user('joe', 'foo')
2226
 
        cleanup_http_redirection_connections(self)
2227
 
 
2228
 
    def create_transport_readonly_server(self):
2229
 
        server = self._auth_server(protocol_version=self._protocol_version)
2230
 
        server._url_protocol = self._url_protocol
2231
 
        return server
2232
 
 
2233
 
    def get_a(self, t):
2234
 
        return t.get('a')
 
2142
 
 
2143
    def get_a(self, transport):
 
2144
        return transport.get('a')
2235
2145
 
2236
2146
    def test_auth_on_redirected_via_do_catching_redirections(self):
2237
2147
        self.redirections = 0
2238
2148
 
2239
 
        def redirected(t, exception, redirection_notice):
 
2149
        def redirected(transport, exception, redirection_notice):
2240
2150
            self.redirections += 1
2241
 
            redirected_t = t._redirected_to(exception.source, exception.target)
2242
 
            self.addCleanup(redirected_t.disconnect)
2243
 
            return redirected_t
 
2151
            dir, file = urlutils.split(exception.target)
 
2152
            return self._transport(dir)
2244
2153
 
2245
2154
        stdout = tests.StringIOWrapper()
2246
2155
        stderr = tests.StringIOWrapper()
2267
2176
                                       self.new_server.port)
2268
2177
        self.old_server.redirections = [
2269
2178
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2270
 
        self.assertEqual('redirected once', t._perform(req).read())
 
2179
        self.assertEqual('redirected once',t._perform(req).read())
2271
2180
        # stdin should be empty
2272
2181
        self.assertEqual('', ui.ui_factory.stdin.readline())
2273
2182
        # stdout should be empty, stderr will contains the prompts
2274
2183
        self.assertEqual('', stdout.getvalue())
2275
2184
 
 
2185