/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_http.py

  • Committer: Jelmer Vernooij
  • Date: 2018-08-14 01:15:02 UTC
  • mto: This revision was merged to the branch mainline in revision 7078.
  • Revision ID: jelmer@jelmer.uk-20180814011502-5zaydaq02vc2qxo1
Fix tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_http.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2012, 2015, 2016, 2017 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
20
20
transport implementation, http protocol versions and authentication schemes.
21
21
"""
22
22
 
23
 
# TODO: Should be renamed to bzrlib.transport.http.tests?
24
 
# TODO: What about renaming to bzrlib.tests.transport.http ?
 
23
# TODO: Should be renamed to breezy.transport.http.tests?
 
24
# TODO: What about renaming to breezy.tests.transport.http ?
25
25
 
26
 
from cStringIO import StringIO
27
 
import httplib
28
 
import os
29
 
import select
30
 
import SimpleHTTPServer
 
26
try:
 
27
    from http.client import UnknownProtocol, parse_headers
 
28
    from http.server import SimpleHTTPRequestHandler
 
29
except ImportError:  # python < 3
 
30
    from httplib import UnknownProtocol
 
31
    from SimpleHTTPServer import SimpleHTTPRequestHandler
 
32
import io
31
33
import socket
32
34
import sys
33
35
import threading
34
36
 
35
 
import bzrlib
36
 
from bzrlib import (
37
 
    bzrdir,
 
37
import breezy
 
38
from .. import (
38
39
    config,
 
40
    controldir,
 
41
    debug,
39
42
    errors,
40
43
    osutils,
41
 
    remote as _mod_remote,
42
44
    tests,
 
45
    trace,
43
46
    transport,
44
47
    ui,
45
48
    urlutils,
46
49
    )
47
 
from bzrlib.symbol_versioning import (
48
 
    deprecated_in,
 
50
from ..bzr import (
 
51
    remote as _mod_remote,
49
52
    )
50
 
from bzrlib.tests import (
 
53
from ..sixish import PY3
 
54
from . import (
51
55
    features,
52
56
    http_server,
53
57
    http_utils,
54
 
    )
55
 
from bzrlib.transport import (
 
58
    test_server,
 
59
    )
 
60
from .scenarios import (
 
61
    load_tests_apply_scenarios,
 
62
    multiply_scenarios,
 
63
    )
 
64
from ..transport import (
56
65
    http,
57
66
    remote,
58
67
    )
59
 
from bzrlib.transport.http import (
60
 
    _urllib,
 
68
from ..transport.http import (
 
69
    HttpTransport,
61
70
    _urllib2_wrappers,
62
71
    )
63
72
 
64
73
 
65
 
if features.pycurl.available():
66
 
    from bzrlib.transport.http._pycurl import PyCurlTransport
67
 
 
68
 
 
69
 
def load_tests(standard_tests, module, loader):
70
 
    """Multiply tests for http clients and protocol versions."""
71
 
    result = loader.suiteClass()
72
 
 
73
 
    # one for each transport implementation
74
 
    t_tests, remaining_tests = tests.split_suite_by_condition(
75
 
        standard_tests, tests.condition_isinstance((
76
 
                TestHttpTransportRegistration,
77
 
                TestHttpTransportUrls,
78
 
                Test_redirected_to,
79
 
                )))
 
74
load_tests = load_tests_apply_scenarios
 
75
 
 
76
 
 
77
def vary_by_http_client_implementation():
 
78
    """Test the libraries we can use, currently just urllib."""
80
79
    transport_scenarios = [
81
 
        ('urllib', dict(_transport=_urllib.HttpTransport_urllib,
82
 
                        _server=http_server.HttpServer_urllib,
83
 
                        _qualified_prefix='http+urllib',)),
84
 
        ]
85
 
    if features.pycurl.available():
86
 
        transport_scenarios.append(
87
 
            ('pycurl', dict(_transport=PyCurlTransport,
88
 
                            _server=http_server.HttpServer_PyCurl,
89
 
                            _qualified_prefix='http+pycurl',)))
90
 
    tests.multiply_tests(t_tests, transport_scenarios, result)
91
 
 
92
 
    # each implementation tested with each HTTP version
93
 
    tp_tests, remaining_tests = tests.split_suite_by_condition(
94
 
        remaining_tests, tests.condition_isinstance((
95
 
                SmartHTTPTunnellingTest,
96
 
                TestDoCatchRedirections,
97
 
                TestHTTPConnections,
98
 
                TestHTTPRedirections,
99
 
                TestHTTPSilentRedirections,
100
 
                TestLimitedRangeRequestServer,
101
 
                TestPost,
102
 
                TestProxyHttpServer,
103
 
                TestRanges,
104
 
                TestSpecificRequestHandler,
105
 
                )))
106
 
    protocol_scenarios = [
107
 
            ('HTTP/1.0',  dict(_protocol_version='HTTP/1.0')),
108
 
            ('HTTP/1.1',  dict(_protocol_version='HTTP/1.1')),
109
 
            ]
110
 
    tp_scenarios = tests.multiply_scenarios(transport_scenarios,
111
 
                                            protocol_scenarios)
112
 
    tests.multiply_tests(tp_tests, tp_scenarios, result)
113
 
 
114
 
    # proxy auth: each auth scheme on all http versions on all implementations.
115
 
    tppa_tests, remaining_tests = tests.split_suite_by_condition(
116
 
        remaining_tests, tests.condition_isinstance((
117
 
                TestProxyAuth,
118
 
                )))
119
 
    proxy_auth_scheme_scenarios = [
120
 
        ('basic', dict(_auth_server=http_utils.ProxyBasicAuthServer)),
121
 
        ('digest', dict(_auth_server=http_utils.ProxyDigestAuthServer)),
122
 
        ('basicdigest',
123
 
         dict(_auth_server=http_utils.ProxyBasicAndDigestAuthServer)),
124
 
        ]
125
 
    tppa_scenarios = tests.multiply_scenarios(tp_scenarios,
126
 
                                              proxy_auth_scheme_scenarios)
127
 
    tests.multiply_tests(tppa_tests, tppa_scenarios, result)
128
 
 
129
 
    # auth: each auth scheme on all http versions on all implementations.
130
 
    tpa_tests, remaining_tests = tests.split_suite_by_condition(
131
 
        remaining_tests, tests.condition_isinstance((
132
 
                TestAuth,
133
 
                )))
134
 
    auth_scheme_scenarios = [
 
80
        ('urllib', dict(_transport=HttpTransport,
 
81
                        _server=http_server.HttpServer,
 
82
                        _url_protocol='http',)),
 
83
        ]
 
84
    return transport_scenarios
 
85
 
 
86
 
 
87
def vary_by_http_protocol_version():
 
88
    """Test on http/1.0 and 1.1"""
 
89
    return [
 
90
        ('HTTP/1.0',  dict(_protocol_version='HTTP/1.0')),
 
91
        ('HTTP/1.1',  dict(_protocol_version='HTTP/1.1')),
 
92
        ]
 
93
 
 
94
 
 
95
def vary_by_http_auth_scheme():
 
96
    scenarios = [
135
97
        ('basic', dict(_auth_server=http_utils.HTTPBasicAuthServer)),
136
98
        ('digest', dict(_auth_server=http_utils.HTTPDigestAuthServer)),
137
99
        ('basicdigest',
138
 
         dict(_auth_server=http_utils.HTTPBasicAndDigestAuthServer)),
139
 
        ]
140
 
    tpa_scenarios = tests.multiply_scenarios(tp_scenarios,
141
 
                                             auth_scheme_scenarios)
142
 
    tests.multiply_tests(tpa_tests, tpa_scenarios, result)
143
 
 
144
 
    # activity: on all http[s] versions on all implementations
145
 
    tpact_tests, remaining_tests = tests.split_suite_by_condition(
146
 
        remaining_tests, tests.condition_isinstance((
147
 
                TestActivity,
148
 
                )))
 
100
            dict(_auth_server=http_utils.HTTPBasicAndDigestAuthServer)),
 
101
        ]
 
102
    # Add some attributes common to all scenarios
 
103
    for scenario_id, scenario_dict in scenarios:
 
104
        scenario_dict.update(_auth_header='Authorization',
 
105
                             _username_prompt_prefix='',
 
106
                             _password_prompt_prefix='')
 
107
    return scenarios
 
108
 
 
109
 
 
110
def vary_by_http_proxy_auth_scheme():
 
111
    scenarios = [
 
112
        ('proxy-basic', dict(_auth_server=http_utils.ProxyBasicAuthServer)),
 
113
        ('proxy-digest', dict(_auth_server=http_utils.ProxyDigestAuthServer)),
 
114
        ('proxy-basicdigest',
 
115
            dict(_auth_server=http_utils.ProxyBasicAndDigestAuthServer)),
 
116
        ]
 
117
    # Add some attributes common to all scenarios
 
118
    for scenario_id, scenario_dict in scenarios:
 
119
        scenario_dict.update(_auth_header='Proxy-Authorization',
 
120
                             _username_prompt_prefix='Proxy ',
 
121
                             _password_prompt_prefix='Proxy ')
 
122
    return scenarios
 
123
 
 
124
 
 
125
def vary_by_http_activity():
149
126
    activity_scenarios = [
150
127
        ('urllib,http', dict(_activity_server=ActivityHTTPServer,
151
 
                             _transport=_urllib.HttpTransport_urllib,)),
 
128
                            _transport=HttpTransport,)),
152
129
        ]
153
 
    if tests.HTTPSServerFeature.available():
 
130
    if features.HTTPSServerFeature.available():
 
131
        # FIXME: Until we have a better way to handle self-signed certificates
 
132
        # (like allowing them in a test specific authentication.conf for
 
133
        # example), we need some specialized urllib transport for tests.
 
134
        # -- vila 2012-01-20
 
135
        from . import (
 
136
            ssl_certs,
 
137
            )
 
138
        class HTTPS_transport(HttpTransport):
 
139
 
 
140
            def __init__(self, base, _from_transport=None):
 
141
                super(HTTPS_transport, self).__init__(
 
142
                    base, _from_transport=_from_transport,
 
143
                    ca_certs=ssl_certs.build_path('ca.crt'))
 
144
 
154
145
        activity_scenarios.append(
155
146
            ('urllib,https', dict(_activity_server=ActivityHTTPSServer,
156
 
                                  _transport=_urllib.HttpTransport_urllib,)),)
157
 
    if features.pycurl.available():
158
 
        activity_scenarios.append(
159
 
            ('pycurl,http', dict(_activity_server=ActivityHTTPServer,
160
 
                                 _transport=PyCurlTransport,)),)
161
 
        if tests.HTTPSServerFeature.available():
162
 
            from bzrlib.tests import (
163
 
                ssl_certs,
164
 
                )
165
 
            # FIXME: Until we have a better way to handle self-signed
166
 
            # certificates (like allowing them in a test specific
167
 
            # authentication.conf for example), we need some specialized pycurl
168
 
            # transport for tests.
169
 
            class HTTPS_pycurl_transport(PyCurlTransport):
170
 
 
171
 
                def __init__(self, base, _from_transport=None):
172
 
                    super(HTTPS_pycurl_transport, self).__init__(
173
 
                        base, _from_transport)
174
 
                    self.cabundle = str(ssl_certs.build_path('ca.crt'))
175
 
 
176
 
            activity_scenarios.append(
177
 
                ('pycurl,https', dict(_activity_server=ActivityHTTPSServer,
178
 
                                      _transport=HTTPS_pycurl_transport,)),)
179
 
 
180
 
    tpact_scenarios = tests.multiply_scenarios(activity_scenarios,
181
 
                                               protocol_scenarios)
182
 
    tests.multiply_tests(tpact_tests, tpact_scenarios, result)
183
 
 
184
 
    # No parametrization for the remaining tests
185
 
    result.addTests(remaining_tests)
186
 
 
187
 
    return result
 
147
                                  _transport=HTTPS_transport,)),)
 
148
    return activity_scenarios
188
149
 
189
150
 
190
151
class FakeManager(object):
212
173
        self._expect_body_tail = expect_body_tail
213
174
        self.host = None
214
175
        self.port = None
215
 
        self.received_bytes = ''
 
176
        self.received_bytes = b''
216
177
        self.scheme = scheme
217
178
 
218
179
    def get_url(self):
223
184
        self._sock.bind(('127.0.0.1', 0))
224
185
        self.host, self.port = self._sock.getsockname()
225
186
        self._ready = threading.Event()
226
 
        self._thread = threading.Thread(target=self._accept_read_and_reply)
227
 
        self._thread.setDaemon(True)
 
187
        self._thread = test_server.TestThread(
 
188
            sync_event=self._ready, target=self._accept_read_and_reply)
228
189
        self._thread.start()
229
 
        self._ready.wait(5)
 
190
        if 'threads' in tests.selftest_debug_flags:
 
191
            sys.stderr.write('Thread started: %s\n' % (self._thread.ident,))
 
192
        self._ready.wait()
230
193
 
231
194
    def _accept_read_and_reply(self):
232
195
        self._sock.listen(1)
233
196
        self._ready.set()
234
 
        self._sock.settimeout(5)
235
 
        try:
236
 
            conn, address = self._sock.accept()
237
 
            # On win32, the accepted connection will be non-blocking to start
238
 
            # with because we're using settimeout.
239
 
            conn.setblocking(True)
 
197
        conn, address = self._sock.accept()
 
198
        if self._expect_body_tail is not None:
240
199
            while not self.received_bytes.endswith(self._expect_body_tail):
241
200
                self.received_bytes += conn.recv(4096)
242
 
            conn.sendall('HTTP/1.1 200 OK\r\n')
243
 
        except socket.timeout:
244
 
            # Make sure the client isn't stuck waiting for us to e.g. accept.
 
201
            conn.sendall(b'HTTP/1.1 200 OK\r\n')
 
202
        try:
245
203
            self._sock.close()
246
204
        except socket.error:
247
205
            # The client may have already closed the socket.
249
207
 
250
208
    def stop_server(self):
251
209
        try:
252
 
            self._sock.close()
 
210
            # Issue a fake connection to wake up the server and allow it to
 
211
            # finish quickly
 
212
            fake_conn = osutils.connect_socket((self.host, self.port))
 
213
            fake_conn.close()
253
214
        except socket.error:
254
215
            # We might have already closed it.  We don't care.
255
216
            pass
256
217
        self.host = None
257
218
        self.port = None
 
219
        self._thread.join()
 
220
        if 'threads' in tests.selftest_debug_flags:
 
221
            sys.stderr.write('Thread  joined: %s\n' % (self._thread.ident,))
258
222
 
259
223
 
260
224
class TestAuthHeader(tests.TestCase):
281
245
        self.assertEqual('basic', scheme)
282
246
        self.assertEqual('realm="Thou should not pass"', remainder)
283
247
 
 
248
    def test_build_basic_header_with_long_creds(self):
 
249
        handler = _urllib2_wrappers.BasicAuthHandler()
 
250
        user = 'user' * 10  # length 40
 
251
        password = 'password' * 5  # length 40
 
252
        header = handler.build_auth_header(
 
253
            dict(user=user, password=password), None)
 
254
        # https://bugs.launchpad.net/bzr/+bug/1606203 was caused by incorrectly
 
255
        # creating a header value with an embedded '\n'
 
256
        self.assertFalse('\n' in header)
 
257
 
284
258
    def test_basic_extract_realm(self):
285
259
        scheme, remainder = self.parse_header(
286
260
            'Basic realm="Thou should not pass"',
287
261
            _urllib2_wrappers.BasicAuthHandler)
288
262
        match, realm = self.auth_handler.extract_realm(remainder)
289
263
        self.assertTrue(match is not None)
290
 
        self.assertEqual('Thou should not pass', realm)
 
264
        self.assertEqual(u'Thou should not pass', realm)
291
265
 
292
266
    def test_digest_header(self):
293
267
        scheme, remainder = self.parse_header(
296
270
        self.assertEqual('realm="Thou should not pass"', remainder)
297
271
 
298
272
 
 
273
class TestHTTPRangeParsing(tests.TestCase):
 
274
 
 
275
    def setUp(self):
 
276
        super(TestHTTPRangeParsing, self).setUp()
 
277
        # We focus on range  parsing here and ignore everything else
 
278
        class RequestHandler(http_server.TestingHTTPRequestHandler):
 
279
            def setup(self): pass
 
280
            def handle(self): pass
 
281
            def finish(self): pass
 
282
 
 
283
        self.req_handler = RequestHandler(None, None, None)
 
284
 
 
285
    def assertRanges(self, ranges, header, file_size):
 
286
        self.assertEqual(ranges,
 
287
                          self.req_handler._parse_ranges(header, file_size))
 
288
 
 
289
    def test_simple_range(self):
 
290
        self.assertRanges([(0, 2)], 'bytes=0-2', 12)
 
291
 
 
292
    def test_tail(self):
 
293
        self.assertRanges([(8, 11)], 'bytes=-4', 12)
 
294
 
 
295
    def test_tail_bigger_than_file(self):
 
296
        self.assertRanges([(0, 11)], 'bytes=-99', 12)
 
297
 
 
298
    def test_range_without_end(self):
 
299
        self.assertRanges([(4, 11)], 'bytes=4-', 12)
 
300
 
 
301
    def test_invalid_ranges(self):
 
302
        self.assertRanges(None, 'bytes=12-22', 12)
 
303
        self.assertRanges(None, 'bytes=1-3,12-22', 12)
 
304
        self.assertRanges(None, 'bytes=-', 12)
 
305
 
 
306
 
299
307
class TestHTTPServer(tests.TestCase):
300
308
    """Test the HTTP servers implementations."""
301
309
 
304
312
 
305
313
            protocol_version = 'HTTP/0.1'
306
314
 
307
 
        server = http_server.HttpServer(BogusRequestHandler)
308
 
        try:
309
 
            self.assertRaises(httplib.UnknownProtocol, server.start_server)
310
 
        except:
311
 
            server.stop_server()
312
 
            self.fail('HTTP Server creation did not raise UnknownProtocol')
 
315
        self.assertRaises(UnknownProtocol,
 
316
                          http_server.HttpServer, BogusRequestHandler)
313
317
 
314
318
    def test_force_invalid_protocol(self):
315
 
        server = http_server.HttpServer(protocol_version='HTTP/0.1')
316
 
        try:
317
 
            self.assertRaises(httplib.UnknownProtocol, server.start_server)
318
 
        except:
319
 
            server.stop_server()
320
 
            self.fail('HTTP Server creation did not raise UnknownProtocol')
 
319
        self.assertRaises(UnknownProtocol,
 
320
                          http_server.HttpServer, protocol_version='HTTP/0.1')
321
321
 
322
322
    def test_server_start_and_stop(self):
323
323
        server = http_server.HttpServer()
 
324
        self.addCleanup(server.stop_server)
324
325
        server.start_server()
325
 
        try:
326
 
            self.assertTrue(server._http_running)
327
 
        finally:
328
 
            server.stop_server()
329
 
        self.assertFalse(server._http_running)
 
326
        self.assertTrue(server.server is not None)
 
327
        self.assertTrue(server.server.serving is not None)
 
328
        self.assertTrue(server.server.serving)
330
329
 
331
330
    def test_create_http_server_one_zero(self):
332
331
        class RequestHandlerOneZero(http_server.TestingHTTPRequestHandler):
335
334
 
336
335
        server = http_server.HttpServer(RequestHandlerOneZero)
337
336
        self.start_server(server)
338
 
        self.assertIsInstance(server._httpd, http_server.TestingHTTPServer)
 
337
        self.assertIsInstance(server.server, http_server.TestingHTTPServer)
339
338
 
340
339
    def test_create_http_server_one_one(self):
341
340
        class RequestHandlerOneOne(http_server.TestingHTTPRequestHandler):
344
343
 
345
344
        server = http_server.HttpServer(RequestHandlerOneOne)
346
345
        self.start_server(server)
347
 
        self.assertIsInstance(server._httpd,
 
346
        self.assertIsInstance(server.server,
348
347
                              http_server.TestingThreadingHTTPServer)
349
348
 
350
349
    def test_create_http_server_force_one_one(self):
355
354
        server = http_server.HttpServer(RequestHandlerOneZero,
356
355
                                        protocol_version='HTTP/1.1')
357
356
        self.start_server(server)
358
 
        self.assertIsInstance(server._httpd,
 
357
        self.assertIsInstance(server.server,
359
358
                              http_server.TestingThreadingHTTPServer)
360
359
 
361
360
    def test_create_http_server_force_one_zero(self):
366
365
        server = http_server.HttpServer(RequestHandlerOneOne,
367
366
                                        protocol_version='HTTP/1.0')
368
367
        self.start_server(server)
369
 
        self.assertIsInstance(server._httpd,
 
368
        self.assertIsInstance(server.server,
370
369
                              http_server.TestingHTTPServer)
371
370
 
372
371
 
373
 
class TestWithTransport_pycurl(object):
374
 
    """Test case to inherit from if pycurl is present"""
375
 
 
376
 
    def _get_pycurl_maybe(self):
377
 
        self.requireFeature(features.pycurl)
378
 
        return PyCurlTransport
379
 
 
380
 
    _transport = property(_get_pycurl_maybe)
381
 
 
382
 
 
383
 
class TestHttpUrls(tests.TestCase):
384
 
 
385
 
    # TODO: This should be moved to authorization tests once they
386
 
    # are written.
387
 
 
388
 
    def test_url_parsing(self):
389
 
        f = FakeManager()
390
 
        url = http.extract_auth('http://example.com', f)
391
 
        self.assertEqual('http://example.com', url)
392
 
        self.assertEqual(0, len(f.credentials))
393
 
        url = http.extract_auth(
394
 
            'http://user:pass@example.com/bzr/bzr.dev', f)
395
 
        self.assertEqual('http://example.com/bzr/bzr.dev', url)
396
 
        self.assertEqual(1, len(f.credentials))
397
 
        self.assertEqual([None, 'example.com', 'user', 'pass'],
398
 
                         f.credentials[0])
399
 
 
400
 
 
401
372
class TestHttpTransportUrls(tests.TestCase):
402
373
    """Test the http urls."""
403
374
 
 
375
    scenarios = vary_by_http_client_implementation()
 
376
 
404
377
    def test_abs_url(self):
405
378
        """Construction of absolute http URLs"""
406
 
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
 
379
        t = self._transport('http://example.com/bzr/bzr.dev/')
407
380
        eq = self.assertEqualDiff
408
 
        eq(t.abspath('.'), 'http://bazaar-vcs.org/bzr/bzr.dev')
409
 
        eq(t.abspath('foo/bar'), 'http://bazaar-vcs.org/bzr/bzr.dev/foo/bar')
410
 
        eq(t.abspath('.bzr'), 'http://bazaar-vcs.org/bzr/bzr.dev/.bzr')
 
381
        eq(t.abspath('.'), 'http://example.com/bzr/bzr.dev')
 
382
        eq(t.abspath('foo/bar'), 'http://example.com/bzr/bzr.dev/foo/bar')
 
383
        eq(t.abspath('.bzr'), 'http://example.com/bzr/bzr.dev/.bzr')
411
384
        eq(t.abspath('.bzr/1//2/./3'),
412
 
           'http://bazaar-vcs.org/bzr/bzr.dev/.bzr/1/2/3')
 
385
           'http://example.com/bzr/bzr.dev/.bzr/1/2/3')
413
386
 
414
387
    def test_invalid_http_urls(self):
415
388
        """Trap invalid construction of urls"""
416
 
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
417
 
        self.assertRaises(errors.InvalidURL,
 
389
        self._transport('http://example.com/bzr/bzr.dev/')
 
390
        self.assertRaises(urlutils.InvalidURL,
418
391
                          self._transport,
419
 
                          'http://http://bazaar-vcs.org/bzr/bzr.dev/')
 
392
                          'http://http://example.com/bzr/bzr.dev/')
420
393
 
421
394
    def test_http_root_urls(self):
422
395
        """Construction of URLs from server root"""
423
 
        t = self._transport('http://bzr.ozlabs.org/')
 
396
        t = self._transport('http://example.com/')
424
397
        eq = self.assertEqualDiff
425
398
        eq(t.abspath('.bzr/tree-version'),
426
 
           'http://bzr.ozlabs.org/.bzr/tree-version')
 
399
           'http://example.com/.bzr/tree-version')
427
400
 
428
401
    def test_http_impl_urls(self):
429
402
        """There are servers which ask for particular clients to connect"""
431
404
        server.start_server()
432
405
        try:
433
406
            url = server.get_url()
434
 
            self.assertTrue(url.startswith('%s://' % self._qualified_prefix))
 
407
            self.assertTrue(url.startswith('%s://' % self._url_protocol))
435
408
        finally:
436
409
            server.stop_server()
437
410
 
438
411
 
439
 
class TestHttps_pycurl(TestWithTransport_pycurl, tests.TestCase):
440
 
 
441
 
    # TODO: This should really be moved into another pycurl
442
 
    # specific test. When https tests will be implemented, take
443
 
    # this one into account.
444
 
    def test_pycurl_without_https_support(self):
445
 
        """Test that pycurl without SSL do not fail with a traceback.
446
 
 
447
 
        For the purpose of the test, we force pycurl to ignore
448
 
        https by supplying a fake version_info that do not
449
 
        support it.
450
 
        """
451
 
        self.requireFeature(features.pycurl)
452
 
        # Import the module locally now that we now it's available.
453
 
        pycurl = features.pycurl.module
454
 
 
455
 
        self.overrideAttr(pycurl, 'version_info',
456
 
                          # Fake the pycurl version_info This was taken from
457
 
                          # a windows pycurl without SSL (thanks to bialix)
458
 
                          lambda : (2,
459
 
                                    '7.13.2',
460
 
                                    462082,
461
 
                                    'i386-pc-win32',
462
 
                                    2576,
463
 
                                    None,
464
 
                                    0,
465
 
                                    None,
466
 
                                    ('ftp', 'gopher', 'telnet',
467
 
                                     'dict', 'ldap', 'http', 'file'),
468
 
                                    None,
469
 
                                    0,
470
 
                                    None))
471
 
        self.assertRaises(errors.DependencyNotPresent, self._transport,
472
 
                          'https://launchpad.net')
473
 
 
474
 
 
475
412
class TestHTTPConnections(http_utils.TestCaseWithWebserver):
476
413
    """Test the http connections."""
477
414
 
 
415
    scenarios = multiply_scenarios(
 
416
        vary_by_http_client_implementation(),
 
417
        vary_by_http_protocol_version(),
 
418
        )
 
419
 
478
420
    def setUp(self):
479
 
        http_utils.TestCaseWithWebserver.setUp(self)
 
421
        super(TestHTTPConnections, self).setUp()
480
422
        self.build_tree(['foo/', 'foo/bar'], line_endings='binary',
481
423
                        transport=self.get_transport())
482
424
 
483
425
    def test_http_has(self):
484
426
        server = self.get_readonly_server()
485
 
        t = self._transport(server.get_url())
 
427
        t = self.get_readonly_transport()
486
428
        self.assertEqual(t.has('foo/bar'), True)
487
429
        self.assertEqual(len(server.logs), 1)
488
430
        self.assertContainsRe(server.logs[0],
489
 
            r'"HEAD /foo/bar HTTP/1.." (200|302) - "-" "bzr/')
 
431
            r'"HEAD /foo/bar HTTP/1.." (200|302) - "-" "Breezy/')
490
432
 
491
433
    def test_http_has_not_found(self):
492
434
        server = self.get_readonly_server()
493
 
        t = self._transport(server.get_url())
 
435
        t = self.get_readonly_transport()
494
436
        self.assertEqual(t.has('not-found'), False)
495
437
        self.assertContainsRe(server.logs[1],
496
 
            r'"HEAD /not-found HTTP/1.." 404 - "-" "bzr/')
 
438
            r'"HEAD /not-found HTTP/1.." 404 - "-" "Breezy/')
497
439
 
498
440
    def test_http_get(self):
499
441
        server = self.get_readonly_server()
500
 
        t = self._transport(server.get_url())
 
442
        t = self.get_readonly_transport()
501
443
        fp = t.get('foo/bar')
502
444
        self.assertEqualDiff(
503
445
            fp.read(),
504
 
            'contents of foo/bar\n')
 
446
            b'contents of foo/bar\n')
505
447
        self.assertEqual(len(server.logs), 1)
506
448
        self.assertTrue(server.logs[0].find(
507
 
            '"GET /foo/bar HTTP/1.1" 200 - "-" "bzr/%s'
508
 
            % bzrlib.__version__) > -1)
 
449
            '"GET /foo/bar HTTP/1.1" 200 - "-" "Breezy/%s'
 
450
            % breezy.__version__) > -1)
509
451
 
510
452
    def test_has_on_bogus_host(self):
511
453
        # Get a free address and don't 'accept' on it, so that we
525
467
class TestHttpTransportRegistration(tests.TestCase):
526
468
    """Test registrations of various http implementations"""
527
469
 
 
470
    scenarios = vary_by_http_client_implementation()
 
471
 
528
472
    def test_http_registered(self):
529
 
        t = transport.get_transport('%s://foo.com/' % self._qualified_prefix)
 
473
        t = transport.get_transport_from_url(
 
474
            '%s://foo.com/' % self._url_protocol)
530
475
        self.assertIsInstance(t, transport.Transport)
531
476
        self.assertIsInstance(t, self._transport)
532
477
 
533
478
 
534
479
class TestPost(tests.TestCase):
535
480
 
 
481
    scenarios = multiply_scenarios(
 
482
        vary_by_http_client_implementation(),
 
483
        vary_by_http_protocol_version(),
 
484
        )
 
485
 
536
486
    def test_post_body_is_received(self):
537
 
        server = RecordingServer(expect_body_tail='end-of-body',
538
 
            scheme=self._qualified_prefix)
 
487
        server = RecordingServer(expect_body_tail=b'end-of-body',
 
488
                                 scheme=self._url_protocol)
539
489
        self.start_server(server)
540
490
        url = server.get_url()
541
 
        http_transport = self._transport(url)
542
 
        code, response = http_transport._post('abc def end-of-body')
 
491
        # FIXME: needs a cleanup -- vila 20100611
 
492
        http_transport = transport.get_transport_from_url(url)
 
493
        code, response = http_transport._post(b'abc def end-of-body')
543
494
        self.assertTrue(
544
 
            server.received_bytes.startswith('POST /.bzr/smart HTTP/1.'))
545
 
        self.assertTrue('content-length: 19\r' in server.received_bytes.lower())
 
495
            server.received_bytes.startswith(b'POST /.bzr/smart HTTP/1.'))
 
496
        self.assertTrue(b'content-length: 19\r' in server.received_bytes.lower())
 
497
        self.assertTrue(b'content-type: application/octet-stream\r'
 
498
                        in server.received_bytes.lower())
546
499
        # The transport should not be assuming that the server can accept
547
500
        # chunked encoding the first time it connects, because HTTP/1.1, so we
548
501
        # check for the literal string.
549
502
        self.assertTrue(
550
 
            server.received_bytes.endswith('\r\n\r\nabc def end-of-body'))
 
503
            server.received_bytes.endswith(b'\r\n\r\nabc def end-of-body'))
551
504
 
552
505
 
553
506
class TestRangeHeader(tests.TestCase):
557
510
        offsets = [ (start, end - start + 1) for start, end in ranges]
558
511
        coalesce = transport.Transport._coalesce_offsets
559
512
        coalesced = list(coalesce(offsets, limit=0, fudge_factor=0))
560
 
        range_header = http.HttpTransportBase._range_header
 
513
        range_header = http.HttpTransport._range_header
561
514
        self.assertEqual(value, range_header(coalesced, tail))
562
515
 
563
516
    def test_range_header_single(self):
564
 
        self.check_header('0-9', ranges=[(0,9)])
565
 
        self.check_header('100-109', ranges=[(100,109)])
 
517
        self.check_header('0-9', ranges=[(0, 9)])
 
518
        self.check_header('100-109', ranges=[(100, 109)])
566
519
 
567
520
    def test_range_header_tail(self):
568
521
        self.check_header('-10', tail=10)
570
523
 
571
524
    def test_range_header_multi(self):
572
525
        self.check_header('0-9,100-200,300-5000',
573
 
                          ranges=[(0,9), (100, 200), (300,5000)])
 
526
                          ranges=[(0, 9), (100, 200), (300, 5000)])
574
527
 
575
528
    def test_range_header_mixed(self):
576
529
        self.check_header('0-9,300-5000,-50',
577
 
                          ranges=[(0,9), (300,5000)],
 
530
                          ranges=[(0, 9), (300, 5000)],
578
531
                          tail=50)
579
532
 
580
533
 
584
537
    Daughter classes are expected to override _req_handler_class
585
538
    """
586
539
 
 
540
    scenarios = multiply_scenarios(
 
541
        vary_by_http_client_implementation(),
 
542
        vary_by_http_protocol_version(),
 
543
        )
 
544
 
587
545
    # Provide a useful default
588
546
    _req_handler_class = http_server.TestingHTTPRequestHandler
589
547
 
590
548
    def create_transport_readonly_server(self):
591
 
        return http_server.HttpServer(self._req_handler_class,
592
 
                                      protocol_version=self._protocol_version)
593
 
 
594
 
    def _testing_pycurl(self):
595
 
        # TODO: This is duplicated for lots of the classes in this file
596
 
        return (features.pycurl.available()
597
 
                and self._transport == PyCurlTransport)
 
549
        server = http_server.HttpServer(self._req_handler_class,
 
550
                                        protocol_version=self._protocol_version)
 
551
        server._url_protocol = self._url_protocol
 
552
        return server
598
553
 
599
554
 
600
555
class WallRequestHandler(http_server.TestingHTTPRequestHandler):
601
556
    """Whatever request comes in, close the connection"""
602
557
 
603
 
    def handle_one_request(self):
 
558
    def _handle_one_request(self):
604
559
        """Handle a single HTTP request, by abruptly closing the connection"""
605
560
        self.close_connection = 1
606
561
 
611
566
    _req_handler_class = WallRequestHandler
612
567
 
613
568
    def test_http_has(self):
614
 
        server = self.get_readonly_server()
615
 
        t = self._transport(server.get_url())
 
569
        t = self.get_readonly_transport()
616
570
        # Unfortunately httplib (see HTTPResponse._read_status
617
571
        # for details) make no distinction between a closed
618
572
        # socket and badly formatted status line, so we can't
619
573
        # just test for ConnectionError, we have to test
620
 
        # InvalidHttpResponse too. And pycurl may raise ConnectionReset
621
 
        # instead of ConnectionError too.
622
 
        self.assertRaises(( errors.ConnectionError, errors.ConnectionReset,
623
 
                            errors.InvalidHttpResponse),
 
574
        # InvalidHttpResponse too.
 
575
        self.assertRaises((errors.ConnectionError,
 
576
                           errors.InvalidHttpResponse),
624
577
                          t.has, 'foo/bar')
625
578
 
626
579
    def test_http_get(self):
627
 
        server = self.get_readonly_server()
628
 
        t = self._transport(server.get_url())
 
580
        t = self.get_readonly_transport()
629
581
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
630
582
                           errors.InvalidHttpResponse),
631
583
                          t.get, 'foo/bar')
647
599
 
648
600
    _req_handler_class = BadStatusRequestHandler
649
601
 
 
602
    def setUp(self):
 
603
        super(TestBadStatusServer, self).setUp()
 
604
        # See https://bugs.launchpad.net/bzr/+bug/1451448 for details.
 
605
        # TD;LR: Running both a TCP client and server in the same process and
 
606
        # thread uncovers a race in python. The fix is to run the server in a
 
607
        # different process. Trying to fix yet another race here is not worth
 
608
        # the effort. -- vila 2015-09-06
 
609
        if 'HTTP/1.0' in self.id():
 
610
            raise tests.TestSkipped(
 
611
                'Client/Server in the same process and thread can hang')
 
612
 
650
613
    def test_http_has(self):
651
 
        server = self.get_readonly_server()
652
 
        t = self._transport(server.get_url())
653
 
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
 
614
        t = self.get_readonly_transport()
 
615
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
 
616
                           errors.InvalidHttpResponse),
 
617
                          t.has, 'foo/bar')
654
618
 
655
619
    def test_http_get(self):
656
 
        server = self.get_readonly_server()
657
 
        t = self._transport(server.get_url())
658
 
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
 
620
        t = self.get_readonly_transport()
 
621
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
 
622
                           errors.InvalidHttpResponse),
 
623
                          t.get, 'foo/bar')
659
624
 
660
625
 
661
626
class InvalidStatusRequestHandler(http_server.TestingHTTPRequestHandler):
664
629
    def parse_request(self):
665
630
        """Fakes handling a single HTTP request, returns a bad status"""
666
631
        ignored = http_server.TestingHTTPRequestHandler.parse_request(self)
667
 
        self.wfile.write("Invalid status line\r\n")
 
632
        self.wfile.write(b"Invalid status line\r\n")
 
633
        # If we don't close the connection pycurl will hang. Since this is a
 
634
        # stress test we don't *have* to respect the protocol, but we don't
 
635
        # have to sabotage it too much either.
 
636
        self.close_connection = True
668
637
        return False
669
638
 
670
639
 
676
645
 
677
646
    _req_handler_class = InvalidStatusRequestHandler
678
647
 
679
 
    def test_http_has(self):
680
 
        if self._testing_pycurl() and self._protocol_version == 'HTTP/1.1':
681
 
            raise tests.KnownFailure(
682
 
                'pycurl hangs if the server send back garbage')
683
 
        super(TestInvalidStatusServer, self).test_http_has()
684
 
 
685
 
    def test_http_get(self):
686
 
        if self._testing_pycurl() and self._protocol_version == 'HTTP/1.1':
687
 
            raise tests.KnownFailure(
688
 
                'pycurl hangs if the server send back garbage')
689
 
        super(TestInvalidStatusServer, self).test_http_get()
690
 
 
691
648
 
692
649
class BadProtocolRequestHandler(http_server.TestingHTTPRequestHandler):
693
650
    """Whatever request comes in, returns a bad protocol version"""
697
654
        ignored = http_server.TestingHTTPRequestHandler.parse_request(self)
698
655
        # Returns an invalid protocol version, but curl just
699
656
        # ignores it and those cannot be tested.
700
 
        self.wfile.write("%s %d %s\r\n" % ('HTTP/0.0',
701
 
                                           404,
702
 
                                           'Look at my protocol version'))
 
657
        self.wfile.write(b"%s %d %s\r\n" % (
 
658
            b'HTTP/0.0', 404, b'Look at my protocol version'))
703
659
        return False
704
660
 
705
661
 
708
664
 
709
665
    _req_handler_class = BadProtocolRequestHandler
710
666
 
711
 
    def setUp(self):
712
 
        if self._testing_pycurl():
713
 
            raise tests.TestNotApplicable(
714
 
                "pycurl doesn't check the protocol version")
715
 
        super(TestBadProtocolServer, self).setUp()
716
 
 
717
667
    def test_http_has(self):
718
 
        server = self.get_readonly_server()
719
 
        t = self._transport(server.get_url())
 
668
        t = self.get_readonly_transport()
720
669
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
721
670
 
722
671
    def test_http_get(self):
723
 
        server = self.get_readonly_server()
724
 
        t = self._transport(server.get_url())
 
672
        t = self.get_readonly_transport()
725
673
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
726
674
 
727
675
 
741
689
    _req_handler_class = ForbiddenRequestHandler
742
690
 
743
691
    def test_http_has(self):
744
 
        server = self.get_readonly_server()
745
 
        t = self._transport(server.get_url())
 
692
        t = self.get_readonly_transport()
746
693
        self.assertRaises(errors.TransportError, t.has, 'foo/bar')
747
694
 
748
695
    def test_http_get(self):
749
 
        server = self.get_readonly_server()
750
 
        t = self._transport(server.get_url())
 
696
        t = self.get_readonly_transport()
751
697
        self.assertRaises(errors.TransportError, t.get, 'foo/bar')
752
698
 
753
699
 
755
701
 
756
702
    def test_create(self):
757
703
        server = RecordingServer(expect_body_tail=None)
758
 
        self.assertEqual('', server.received_bytes)
 
704
        self.assertEqual(b'', server.received_bytes)
759
705
        self.assertEqual(None, server.host)
760
706
        self.assertEqual(None, server.port)
761
707
 
771
717
        self.assertEqual(None, server.port)
772
718
 
773
719
    def test_send_receive_bytes(self):
774
 
        server = RecordingServer(expect_body_tail='c', scheme='http')
 
720
        server = RecordingServer(expect_body_tail=b'c', scheme='http')
775
721
        self.start_server(server)
776
722
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
777
723
        sock.connect((server.host, server.port))
778
 
        sock.sendall('abc')
779
 
        self.assertEqual('HTTP/1.1 200 OK\r\n',
 
724
        sock.sendall(b'abc')
 
725
        self.assertEqual(b'HTTP/1.1 200 OK\r\n',
780
726
                         osutils.recv_all(sock, 4096))
781
 
        self.assertEqual('abc', server.received_bytes)
 
727
        self.assertEqual(b'abc', server.received_bytes)
782
728
 
783
729
 
784
730
class TestRangeRequestServer(TestSpecificRequestHandler):
789
735
 
790
736
    def setUp(self):
791
737
        super(TestRangeRequestServer, self).setUp()
792
 
        self.build_tree_contents([('a', '0123456789')],)
 
738
        self.build_tree_contents([('a', b'0123456789')],)
793
739
 
794
740
    def test_readv(self):
795
 
        server = self.get_readonly_server()
796
 
        t = self._transport(server.get_url())
 
741
        t = self.get_readonly_transport()
797
742
        l = list(t.readv('a', ((0, 1), (1, 1), (3, 2), (9, 1))))
798
 
        self.assertEqual(l[0], (0, '0'))
799
 
        self.assertEqual(l[1], (1, '1'))
800
 
        self.assertEqual(l[2], (3, '34'))
801
 
        self.assertEqual(l[3], (9, '9'))
 
743
        self.assertEqual(l[0], (0, b'0'))
 
744
        self.assertEqual(l[1], (1, b'1'))
 
745
        self.assertEqual(l[2], (3, b'34'))
 
746
        self.assertEqual(l[3], (9, b'9'))
802
747
 
803
748
    def test_readv_out_of_order(self):
804
 
        server = self.get_readonly_server()
805
 
        t = self._transport(server.get_url())
 
749
        t = self.get_readonly_transport()
806
750
        l = list(t.readv('a', ((1, 1), (9, 1), (0, 1), (3, 2))))
807
 
        self.assertEqual(l[0], (1, '1'))
808
 
        self.assertEqual(l[1], (9, '9'))
809
 
        self.assertEqual(l[2], (0, '0'))
810
 
        self.assertEqual(l[3], (3, '34'))
 
751
        self.assertEqual(l[0], (1, b'1'))
 
752
        self.assertEqual(l[1], (9, b'9'))
 
753
        self.assertEqual(l[2], (0, b'0'))
 
754
        self.assertEqual(l[3], (3, b'34'))
811
755
 
812
756
    def test_readv_invalid_ranges(self):
813
 
        server = self.get_readonly_server()
814
 
        t = self._transport(server.get_url())
 
757
        t = self.get_readonly_transport()
815
758
 
816
759
        # This is intentionally reading off the end of the file
817
760
        # since we are sure that it cannot get there
818
761
        self.assertListRaises((errors.InvalidRange, errors.ShortReadvError,),
819
 
                              t.readv, 'a', [(1,1), (8,10)])
 
762
                              t.readv, 'a', [(1, 1), (8, 10)])
820
763
 
821
764
        # This is trying to seek past the end of the file, it should
822
765
        # also raise a special error
823
766
        self.assertListRaises((errors.InvalidRange, errors.ShortReadvError,),
824
 
                              t.readv, 'a', [(12,2)])
 
767
                              t.readv, 'a', [(12, 2)])
825
768
 
826
769
    def test_readv_multiple_get_requests(self):
827
770
        server = self.get_readonly_server()
828
 
        t = self._transport(server.get_url())
 
771
        t = self.get_readonly_transport()
829
772
        # force transport to issue multiple requests
830
773
        t._max_readv_combine = 1
831
774
        t._max_get_ranges = 1
832
775
        l = list(t.readv('a', ((0, 1), (1, 1), (3, 2), (9, 1))))
833
 
        self.assertEqual(l[0], (0, '0'))
834
 
        self.assertEqual(l[1], (1, '1'))
835
 
        self.assertEqual(l[2], (3, '34'))
836
 
        self.assertEqual(l[3], (9, '9'))
 
776
        self.assertEqual(l[0], (0, b'0'))
 
777
        self.assertEqual(l[1], (1, b'1'))
 
778
        self.assertEqual(l[2], (3, b'34'))
 
779
        self.assertEqual(l[3], (9, b'9'))
837
780
        # The server should have issued 4 requests
838
781
        self.assertEqual(4, server.GET_request_nb)
839
782
 
840
783
    def test_readv_get_max_size(self):
841
784
        server = self.get_readonly_server()
842
 
        t = self._transport(server.get_url())
 
785
        t = self.get_readonly_transport()
843
786
        # force transport to issue multiple requests by limiting the number of
844
787
        # bytes by request. Note that this apply to coalesced offsets only, a
845
788
        # single range will keep its size even if bigger than the limit.
846
789
        t._get_max_size = 2
847
790
        l = list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
848
 
        self.assertEqual(l[0], (0, '0'))
849
 
        self.assertEqual(l[1], (1, '1'))
850
 
        self.assertEqual(l[2], (2, '2345'))
851
 
        self.assertEqual(l[3], (6, '6789'))
 
791
        self.assertEqual(l[0], (0, b'0'))
 
792
        self.assertEqual(l[1], (1, b'1'))
 
793
        self.assertEqual(l[2], (2, b'2345'))
 
794
        self.assertEqual(l[3], (6, b'6789'))
852
795
        # The server should have issued 3 requests
853
796
        self.assertEqual(3, server.GET_request_nb)
854
797
 
855
798
    def test_complete_readv_leave_pipe_clean(self):
856
799
        server = self.get_readonly_server()
857
 
        t = self._transport(server.get_url())
 
800
        t = self.get_readonly_transport()
858
801
        # force transport to issue multiple requests
859
802
        t._get_max_size = 2
860
 
        l = list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
 
803
        list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
861
804
        # The server should have issued 3 requests
862
805
        self.assertEqual(3, server.GET_request_nb)
863
 
        self.assertEqual('0123456789', t.get_bytes('a'))
 
806
        self.assertEqual(b'0123456789', t.get_bytes('a'))
864
807
        self.assertEqual(4, server.GET_request_nb)
865
808
 
866
809
    def test_incomplete_readv_leave_pipe_clean(self):
867
810
        server = self.get_readonly_server()
868
 
        t = self._transport(server.get_url())
 
811
        t = self.get_readonly_transport()
869
812
        # force transport to issue multiple requests
870
813
        t._get_max_size = 2
871
814
        # Don't collapse readv results into a list so that we leave unread
872
815
        # bytes on the socket
873
816
        ireadv = iter(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
874
 
        self.assertEqual((0, '0'), ireadv.next())
 
817
        self.assertEqual((0, b'0'), next(ireadv))
875
818
        # The server should have issued one request so far
876
819
        self.assertEqual(1, server.GET_request_nb)
877
 
        self.assertEqual('0123456789', t.get_bytes('a'))
 
820
        self.assertEqual(b'0123456789', t.get_bytes('a'))
878
821
        # get_bytes issued an additional request, the readv pending ones are
879
822
        # lost
880
823
        self.assertEqual(2, server.GET_request_nb)
924
867
        # Update the statistics
925
868
        self.server.test_case_server.GET_request_nb += 1
926
869
        # Just bypass the range handling done by TestingHTTPRequestHandler
927
 
        return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
 
870
        return SimpleHTTPRequestHandler.do_GET(self)
928
871
 
929
872
 
930
873
class TestNoRangeRequestServer(TestRangeRequestServer):
940
883
    def get_multiple_ranges(self, file, file_size, ranges):
941
884
        self.send_response(206)
942
885
        self.send_header('Accept-Ranges', 'bytes')
943
 
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
 
886
        # XXX: this is strange; the 'random' name below seems undefined and
 
887
        # yet the tests pass -- mbp 2010-10-11 bug 658773
 
888
        boundary = "%d" % random.randint(0, 0x7FFFFFFF)
944
889
        self.send_header("Content-Type",
945
890
                         "multipart/byteranges; boundary=%s" % boundary)
946
891
        self.end_headers()
947
892
        for (start, end) in ranges:
948
 
            self.wfile.write("--%s\r\n" % boundary)
 
893
            self.wfile.write(b"--%s\r\n" % boundary.encode('ascii'))
949
894
            self.send_header("Content-type", 'application/octet-stream')
950
895
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
951
896
                                                                  end,
953
898
            self.end_headers()
954
899
            self.send_range_content(file, start, end - start + 1)
955
900
        # Final boundary
956
 
        self.wfile.write("--%s\r\n" % boundary)
 
901
        self.wfile.write(b"--%s\r\n" % boundary)
957
902
 
958
903
 
959
904
class TestMultipleRangeWithoutContentLengthServer(TestRangeRequestServer):
978
923
        boundary = 'tagada'
979
924
        self.send_header('Content-Type',
980
925
                         'multipart/byteranges; boundary=%s' % boundary)
981
 
        boundary_line = '--%s\r\n' % boundary
 
926
        boundary_line = b'--%s\r\n' % boundary.encode('ascii')
982
927
        # Calculate the Content-Length
983
928
        content_length = 0
984
929
        for (start, end) in ranges:
1007
952
                return
1008
953
            self.send_range_content(file, start, end - start + 1)
1009
954
            cur += 1
1010
 
        # No final boundary
 
955
        # Final boundary
1011
956
        self.wfile.write(boundary_line)
1012
957
 
1013
958
 
1017
962
 
1018
963
    def setUp(self):
1019
964
        super(TestTruncatedMultipleRangeServer, self).setUp()
1020
 
        self.build_tree_contents([('a', '0123456789')],)
 
965
        self.build_tree_contents([('a', b'0123456789')],)
1021
966
 
1022
967
    def test_readv_with_short_reads(self):
1023
968
        server = self.get_readonly_server()
1024
 
        t = self._transport(server.get_url())
 
969
        t = self.get_readonly_transport()
1025
970
        # Force separate ranges for each offset
1026
971
        t._bytes_to_read_before_seek = 0
1027
972
        ireadv = iter(t.readv('a', ((0, 1), (2, 1), (4, 2), (9, 1))))
1028
 
        self.assertEqual((0, '0'), ireadv.next())
1029
 
        self.assertEqual((2, '2'), ireadv.next())
1030
 
        if not self._testing_pycurl():
1031
 
            # Only one request have been issued so far (except for pycurl that
1032
 
            # try to read the whole response at once)
1033
 
            self.assertEqual(1, server.GET_request_nb)
1034
 
        self.assertEqual((4, '45'), ireadv.next())
1035
 
        self.assertEqual((9, '9'), ireadv.next())
1036
 
        # Both implementations issue 3 requests but:
1037
 
        # - urllib does two multiple (4 ranges, then 2 ranges) then a single
1038
 
        #   range,
1039
 
        # - pycurl does two multiple (4 ranges, 4 ranges) then a single range
 
973
        self.assertEqual((0, b'0'), next(ireadv))
 
974
        self.assertEqual((2, b'2'), next(ireadv))
 
975
        # Only one request have been issued so far
 
976
        self.assertEqual(1, server.GET_request_nb)
 
977
        self.assertEqual((4, b'45'), next(ireadv))
 
978
        self.assertEqual((9, b'9'), next(ireadv))
 
979
        # We issue 3 requests: two multiple (4 ranges, then 2 ranges) then a
 
980
        # single range.
1040
981
        self.assertEqual(3, server.GET_request_nb)
1041
982
        # Finally the client have tried a single range request and stays in
1042
983
        # that mode
1043
984
        self.assertEqual('single', t._range_hint)
1044
985
 
 
986
 
 
987
class TruncatedBeforeBoundaryRequestHandler(
 
988
    http_server.TestingHTTPRequestHandler):
 
989
    """Truncation before a boundary, like in bug 198646"""
 
990
 
 
991
    _truncated_ranges = 1
 
992
 
 
993
    def get_multiple_ranges(self, file, file_size, ranges):
 
994
        self.send_response(206)
 
995
        self.send_header('Accept-Ranges', 'bytes')
 
996
        boundary = 'tagada'
 
997
        self.send_header('Content-Type',
 
998
                         'multipart/byteranges; boundary=%s' % boundary)
 
999
        boundary_line = b'--%s\r\n' % boundary.encode('ascii')
 
1000
        # Calculate the Content-Length
 
1001
        content_length = 0
 
1002
        for (start, end) in ranges:
 
1003
            content_length += len(boundary_line)
 
1004
            content_length += self._header_line_length(
 
1005
                'Content-type', 'application/octet-stream')
 
1006
            content_length += self._header_line_length(
 
1007
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
 
1008
            content_length += len('\r\n') # end headers
 
1009
            content_length += end - start # + 1
 
1010
        content_length += len(boundary_line)
 
1011
        self.send_header('Content-length', content_length)
 
1012
        self.end_headers()
 
1013
 
 
1014
        # Send the multipart body
 
1015
        cur = 0
 
1016
        for (start, end) in ranges:
 
1017
            if cur + self._truncated_ranges >= len(ranges):
 
1018
                # Abruptly ends the response and close the connection
 
1019
                self.close_connection = 1
 
1020
                return
 
1021
            self.wfile.write(boundary_line)
 
1022
            self.send_header('Content-type', 'application/octet-stream')
 
1023
            self.send_header('Content-Range', 'bytes %d-%d/%d'
 
1024
                             % (start, end, file_size))
 
1025
            self.end_headers()
 
1026
            self.send_range_content(file, start, end - start + 1)
 
1027
            cur += 1
 
1028
        # Final boundary
 
1029
        self.wfile.write(boundary_line)
 
1030
 
 
1031
 
 
1032
class TestTruncatedBeforeBoundary(TestSpecificRequestHandler):
 
1033
    """Tests the case of bug 198646, disconnecting before a boundary."""
 
1034
 
 
1035
    _req_handler_class = TruncatedBeforeBoundaryRequestHandler
 
1036
 
 
1037
    def setUp(self):
 
1038
        super(TestTruncatedBeforeBoundary, self).setUp()
 
1039
        self.build_tree_contents([('a', b'0123456789')],)
 
1040
 
 
1041
    def test_readv_with_short_reads(self):
 
1042
        server = self.get_readonly_server()
 
1043
        t = self.get_readonly_transport()
 
1044
        # Force separate ranges for each offset
 
1045
        t._bytes_to_read_before_seek = 0
 
1046
        ireadv = iter(t.readv('a', ((0, 1), (2, 1), (4, 2), (9, 1))))
 
1047
        self.assertEqual((0, b'0'), next(ireadv))
 
1048
        self.assertEqual((2, b'2'), next(ireadv))
 
1049
        self.assertEqual((4, b'45'), next(ireadv))
 
1050
        self.assertEqual((9, b'9'), next(ireadv))
 
1051
 
 
1052
 
1045
1053
class LimitedRangeRequestHandler(http_server.TestingHTTPRequestHandler):
1046
1054
    """Errors out when range specifiers exceed the limit"""
1047
1055
 
1071
1079
class TestLimitedRangeRequestServer(http_utils.TestCaseWithWebserver):
1072
1080
    """Tests readv requests against a server erroring out on too much ranges."""
1073
1081
 
 
1082
    scenarios = multiply_scenarios(
 
1083
        vary_by_http_client_implementation(),
 
1084
        vary_by_http_protocol_version(),
 
1085
        )
 
1086
 
1074
1087
    # Requests with more range specifiers will error out
1075
1088
    range_limit = 3
1076
1089
 
1078
1091
        return LimitedRangeHTTPServer(range_limit=self.range_limit,
1079
1092
                                      protocol_version=self._protocol_version)
1080
1093
 
1081
 
    def get_transport(self):
1082
 
        return self._transport(self.get_readonly_server().get_url())
1083
 
 
1084
1094
    def setUp(self):
1085
 
        http_utils.TestCaseWithWebserver.setUp(self)
 
1095
        super(TestLimitedRangeRequestServer, self).setUp()
1086
1096
        # We need to manipulate ranges that correspond to real chunks in the
1087
1097
        # response, so we build a content appropriately.
1088
 
        filler = ''.join(['abcdefghij' for x in range(102)])
1089
 
        content = ''.join(['%04d' % v + filler for v in range(16)])
 
1098
        filler = b''.join([b'abcdefghij' for x in range(102)])
 
1099
        content = b''.join([b'%04d' % v + filler for v in range(16)])
1090
1100
        self.build_tree_contents([('a', content)],)
1091
1101
 
1092
1102
    def test_few_ranges(self):
1093
 
        t = self.get_transport()
 
1103
        t = self.get_readonly_transport()
1094
1104
        l = list(t.readv('a', ((0, 4), (1024, 4), )))
1095
 
        self.assertEqual(l[0], (0, '0000'))
1096
 
        self.assertEqual(l[1], (1024, '0001'))
 
1105
        self.assertEqual(l[0], (0, b'0000'))
 
1106
        self.assertEqual(l[1], (1024, b'0001'))
1097
1107
        self.assertEqual(1, self.get_readonly_server().GET_request_nb)
1098
1108
 
1099
1109
    def test_more_ranges(self):
1100
 
        t = self.get_transport()
 
1110
        t = self.get_readonly_transport()
1101
1111
        l = list(t.readv('a', ((0, 4), (1024, 4), (4096, 4), (8192, 4))))
1102
 
        self.assertEqual(l[0], (0, '0000'))
1103
 
        self.assertEqual(l[1], (1024, '0001'))
1104
 
        self.assertEqual(l[2], (4096, '0004'))
1105
 
        self.assertEqual(l[3], (8192, '0008'))
 
1112
        self.assertEqual(l[0], (0, b'0000'))
 
1113
        self.assertEqual(l[1], (1024, b'0001'))
 
1114
        self.assertEqual(l[2], (4096, b'0004'))
 
1115
        self.assertEqual(l[3], (8192, b'0008'))
1106
1116
        # The server will refuse to serve the first request (too much ranges),
1107
1117
        # a second request will succeed.
1108
1118
        self.assertEqual(2, self.get_readonly_server().GET_request_nb)
1114
1124
    Only the urllib implementation is tested here.
1115
1125
    """
1116
1126
 
1117
 
    def setUp(self):
1118
 
        tests.TestCase.setUp(self)
1119
 
        self._old_env = {}
1120
 
 
1121
 
    def tearDown(self):
1122
 
        self._restore_env()
1123
 
        tests.TestCase.tearDown(self)
1124
 
 
1125
 
    def _install_env(self, env):
1126
 
        for name, value in env.iteritems():
1127
 
            self._old_env[name] = osutils.set_or_unset_env(name, value)
1128
 
 
1129
 
    def _restore_env(self):
1130
 
        for name, value in self._old_env.iteritems():
1131
 
            osutils.set_or_unset_env(name, value)
1132
 
 
1133
1127
    def _proxied_request(self):
1134
1128
        handler = _urllib2_wrappers.ProxyHandler()
1135
 
        request = _urllib2_wrappers.Request('GET','http://baz/buzzle')
 
1129
        request = _urllib2_wrappers.Request('GET', 'http://baz/buzzle')
1136
1130
        handler.set_proxy(request, 'http')
1137
1131
        return request
1138
1132
 
 
1133
    def assertEvaluateProxyBypass(self, expected, host, no_proxy):
 
1134
        handler = _urllib2_wrappers.ProxyHandler()
 
1135
        self.assertEqual(expected,
 
1136
                          handler.evaluate_proxy_bypass(host, no_proxy))
 
1137
 
1139
1138
    def test_empty_user(self):
1140
 
        self._install_env({'http_proxy': 'http://bar.com'})
1141
 
        request = self._proxied_request()
1142
 
        self.assertFalse(request.headers.has_key('Proxy-authorization'))
 
1139
        self.overrideEnv('http_proxy', 'http://bar.com')
 
1140
        request = self._proxied_request()
 
1141
        self.assertFalse('Proxy-authorization' in request.headers)
 
1142
 
 
1143
    def test_user_with_at(self):
 
1144
        self.overrideEnv('http_proxy',
 
1145
                         'http://username@domain:password@proxy_host:1234')
 
1146
        request = self._proxied_request()
 
1147
        self.assertFalse('Proxy-authorization' in request.headers)
1143
1148
 
1144
1149
    def test_invalid_proxy(self):
1145
1150
        """A proxy env variable without scheme"""
1146
 
        self._install_env({'http_proxy': 'host:1234'})
1147
 
        self.assertRaises(errors.InvalidURL, self._proxied_request)
 
1151
        self.overrideEnv('http_proxy', 'host:1234')
 
1152
        self.assertRaises(urlutils.InvalidURL, self._proxied_request)
 
1153
 
 
1154
    def test_evaluate_proxy_bypass_true(self):
 
1155
        """The host is not proxied"""
 
1156
        self.assertEvaluateProxyBypass(True, 'example.com', 'example.com')
 
1157
        self.assertEvaluateProxyBypass(True, 'bzr.example.com', '*example.com')
 
1158
 
 
1159
    def test_evaluate_proxy_bypass_false(self):
 
1160
        """The host is proxied"""
 
1161
        self.assertEvaluateProxyBypass(False, 'bzr.example.com', None)
 
1162
 
 
1163
    def test_evaluate_proxy_bypass_unknown(self):
 
1164
        """The host is not explicitly proxied"""
 
1165
        self.assertEvaluateProxyBypass(None, 'example.com', 'not.example.com')
 
1166
        self.assertEvaluateProxyBypass(None, 'bzr.example.com', 'example.com')
 
1167
 
 
1168
    def test_evaluate_proxy_bypass_empty_entries(self):
 
1169
        """Ignore empty entries"""
 
1170
        self.assertEvaluateProxyBypass(None, 'example.com', '')
 
1171
        self.assertEvaluateProxyBypass(None, 'example.com', ',')
 
1172
        self.assertEvaluateProxyBypass(None, 'example.com', 'foo,,bar')
1148
1173
 
1149
1174
 
1150
1175
class TestProxyHttpServer(http_utils.TestCaseWithTwoWebservers):
1156
1181
    to the file names).
1157
1182
    """
1158
1183
 
 
1184
    scenarios = multiply_scenarios(
 
1185
        vary_by_http_client_implementation(),
 
1186
        vary_by_http_protocol_version(),
 
1187
        )
 
1188
 
1159
1189
    # FIXME: We don't have an https server available, so we don't
1160
 
    # test https connections.
 
1190
    # test https connections. --vila toolongago
1161
1191
 
1162
1192
    def setUp(self):
1163
1193
        super(TestProxyHttpServer, self).setUp()
1164
 
        self.build_tree_contents([('foo', 'contents of foo\n'),
1165
 
                                  ('foo-proxied', 'proxied contents of foo\n')])
 
1194
        self.transport_secondary_server = http_utils.ProxyServer
 
1195
        self.build_tree_contents([('foo', b'contents of foo\n'),
 
1196
                                  ('foo-proxied', b'proxied contents of foo\n')])
1166
1197
        # Let's setup some attributes for tests
1167
 
        self.server = self.get_readonly_server()
1168
 
        self.proxy_address = '%s:%d' % (self.server.host, self.server.port)
1169
 
        if self._testing_pycurl():
1170
 
            # Oh my ! pycurl does not check for the port as part of
1171
 
            # no_proxy :-( So we just test the host part
1172
 
            self.no_proxy_host = self.server.host
1173
 
        else:
1174
 
            self.no_proxy_host = self.proxy_address
 
1198
        server = self.get_readonly_server()
 
1199
        self.server_host_port = '%s:%d' % (server.host, server.port)
 
1200
        self.no_proxy_host = self.server_host_port
1175
1201
        # The secondary server is the proxy
1176
 
        self.proxy = self.get_secondary_server()
1177
 
        self.proxy_url = self.proxy.get_url()
1178
 
        self._old_env = {}
1179
 
 
1180
 
    def _testing_pycurl(self):
1181
 
        # TODO: This is duplicated for lots of the classes in this file
1182
 
        return (features.pycurl.available()
1183
 
                and self._transport == PyCurlTransport)
1184
 
 
1185
 
    def create_transport_secondary_server(self):
1186
 
        """Creates an http server that will serve files with
1187
 
        '-proxied' appended to their names.
1188
 
        """
1189
 
        return http_utils.ProxyServer(protocol_version=self._protocol_version)
1190
 
 
1191
 
    def _install_env(self, env):
1192
 
        for name, value in env.iteritems():
1193
 
            self._old_env[name] = osutils.set_or_unset_env(name, value)
1194
 
 
1195
 
    def _restore_env(self):
1196
 
        for name, value in self._old_env.iteritems():
1197
 
            osutils.set_or_unset_env(name, value)
1198
 
 
1199
 
    def proxied_in_env(self, env):
1200
 
        self._install_env(env)
1201
 
        url = self.server.get_url()
1202
 
        t = self._transport(url)
1203
 
        try:
1204
 
            self.assertEqual('proxied contents of foo\n', t.get('foo').read())
1205
 
        finally:
1206
 
            self._restore_env()
1207
 
 
1208
 
    def not_proxied_in_env(self, env):
1209
 
        self._install_env(env)
1210
 
        url = self.server.get_url()
1211
 
        t = self._transport(url)
1212
 
        try:
1213
 
            self.assertEqual('contents of foo\n', t.get('foo').read())
1214
 
        finally:
1215
 
            self._restore_env()
 
1202
        self.proxy_url = self.get_secondary_url()
 
1203
 
 
1204
    def assertProxied(self):
 
1205
        t = self.get_readonly_transport()
 
1206
        self.assertEqual(b'proxied contents of foo\n', t.get('foo').read())
 
1207
 
 
1208
    def assertNotProxied(self):
 
1209
        t = self.get_readonly_transport()
 
1210
        self.assertEqual(b'contents of foo\n', t.get('foo').read())
1216
1211
 
1217
1212
    def test_http_proxy(self):
1218
 
        self.proxied_in_env({'http_proxy': self.proxy_url})
 
1213
        self.overrideEnv('http_proxy', self.proxy_url)
 
1214
        self.assertProxied()
1219
1215
 
1220
1216
    def test_HTTP_PROXY(self):
1221
 
        if self._testing_pycurl():
1222
 
            # pycurl does not check HTTP_PROXY for security reasons
1223
 
            # (for use in a CGI context that we do not care
1224
 
            # about. Should we ?)
1225
 
            raise tests.TestNotApplicable(
1226
 
                'pycurl does not check HTTP_PROXY for security reasons')
1227
 
        self.proxied_in_env({'HTTP_PROXY': self.proxy_url})
 
1217
        self.overrideEnv('HTTP_PROXY', self.proxy_url)
 
1218
        self.assertProxied()
1228
1219
 
1229
1220
    def test_all_proxy(self):
1230
 
        self.proxied_in_env({'all_proxy': self.proxy_url})
 
1221
        self.overrideEnv('all_proxy', self.proxy_url)
 
1222
        self.assertProxied()
1231
1223
 
1232
1224
    def test_ALL_PROXY(self):
1233
 
        self.proxied_in_env({'ALL_PROXY': self.proxy_url})
 
1225
        self.overrideEnv('ALL_PROXY', self.proxy_url)
 
1226
        self.assertProxied()
1234
1227
 
1235
1228
    def test_http_proxy_with_no_proxy(self):
1236
 
        self.not_proxied_in_env({'http_proxy': self.proxy_url,
1237
 
                                 'no_proxy': self.no_proxy_host})
 
1229
        self.overrideEnv('no_proxy', self.no_proxy_host)
 
1230
        self.overrideEnv('http_proxy', self.proxy_url)
 
1231
        self.assertNotProxied()
1238
1232
 
1239
1233
    def test_HTTP_PROXY_with_NO_PROXY(self):
1240
 
        if self._testing_pycurl():
1241
 
            raise tests.TestNotApplicable(
1242
 
                'pycurl does not check HTTP_PROXY for security reasons')
1243
 
        self.not_proxied_in_env({'HTTP_PROXY': self.proxy_url,
1244
 
                                 'NO_PROXY': self.no_proxy_host})
 
1234
        self.overrideEnv('NO_PROXY', self.no_proxy_host)
 
1235
        self.overrideEnv('HTTP_PROXY', self.proxy_url)
 
1236
        self.assertNotProxied()
1245
1237
 
1246
1238
    def test_all_proxy_with_no_proxy(self):
1247
 
        self.not_proxied_in_env({'all_proxy': self.proxy_url,
1248
 
                                 'no_proxy': self.no_proxy_host})
 
1239
        self.overrideEnv('no_proxy', self.no_proxy_host)
 
1240
        self.overrideEnv('all_proxy', self.proxy_url)
 
1241
        self.assertNotProxied()
1249
1242
 
1250
1243
    def test_ALL_PROXY_with_NO_PROXY(self):
1251
 
        self.not_proxied_in_env({'ALL_PROXY': self.proxy_url,
1252
 
                                 'NO_PROXY': self.no_proxy_host})
 
1244
        self.overrideEnv('NO_PROXY', self.no_proxy_host)
 
1245
        self.overrideEnv('ALL_PROXY', self.proxy_url)
 
1246
        self.assertNotProxied()
1253
1247
 
1254
1248
    def test_http_proxy_without_scheme(self):
1255
 
        if self._testing_pycurl():
1256
 
            # pycurl *ignores* invalid proxy env variables. If that ever change
1257
 
            # in the future, this test will fail indicating that pycurl do not
1258
 
            # ignore anymore such variables.
1259
 
            self.not_proxied_in_env({'http_proxy': self.proxy_address})
1260
 
        else:
1261
 
            self.assertRaises(errors.InvalidURL,
1262
 
                              self.proxied_in_env,
1263
 
                              {'http_proxy': self.proxy_address})
 
1249
        self.overrideEnv('http_proxy', self.server_host_port)
 
1250
        self.assertRaises(urlutils.InvalidURL, self.assertProxied)
1264
1251
 
1265
1252
 
1266
1253
class TestRanges(http_utils.TestCaseWithWebserver):
1267
1254
    """Test the Range header in GET methods."""
1268
1255
 
 
1256
    scenarios = multiply_scenarios(
 
1257
        vary_by_http_client_implementation(),
 
1258
        vary_by_http_protocol_version(),
 
1259
        )
 
1260
 
1269
1261
    def setUp(self):
1270
 
        http_utils.TestCaseWithWebserver.setUp(self)
1271
 
        self.build_tree_contents([('a', '0123456789')],)
1272
 
        server = self.get_readonly_server()
1273
 
        self.transport = self._transport(server.get_url())
 
1262
        super(TestRanges, self).setUp()
 
1263
        self.build_tree_contents([('a', b'0123456789')],)
1274
1264
 
1275
1265
    def create_transport_readonly_server(self):
1276
1266
        return http_server.HttpServer(protocol_version=self._protocol_version)
1277
1267
 
1278
1268
    def _file_contents(self, relpath, ranges):
 
1269
        t = self.get_readonly_transport()
1279
1270
        offsets = [ (start, end - start + 1) for start, end in ranges]
1280
 
        coalesce = self.transport._coalesce_offsets
 
1271
        coalesce = t._coalesce_offsets
1281
1272
        coalesced = list(coalesce(offsets, limit=0, fudge_factor=0))
1282
 
        code, data = self.transport._get(relpath, coalesced)
1283
 
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
 
1273
        code, data = t._get(relpath, coalesced)
 
1274
        self.assertTrue(code in (200, 206), '_get returns: %d' % code)
1284
1275
        for start, end in ranges:
1285
1276
            data.seek(start)
1286
1277
            yield data.read(end - start + 1)
1287
1278
 
1288
1279
    def _file_tail(self, relpath, tail_amount):
1289
 
        code, data = self.transport._get(relpath, [], tail_amount)
1290
 
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
 
1280
        t = self.get_readonly_transport()
 
1281
        code, data = t._get(relpath, [], tail_amount)
 
1282
        self.assertTrue(code in (200, 206), '_get returns: %d' % code)
1291
1283
        data.seek(-tail_amount, 2)
1292
1284
        return data.read(tail_amount)
1293
1285
 
1294
1286
    def test_range_header(self):
1295
1287
        # Valid ranges
1296
 
        map(self.assertEqual,['0', '234'],
1297
 
            list(self._file_contents('a', [(0,0), (2,4)])),)
 
1288
        self.assertEqual(
 
1289
            [b'0', b'234'], list(self._file_contents('a', [(0, 0), (2, 4)])))
1298
1290
 
1299
1291
    def test_range_header_tail(self):
1300
 
        self.assertEqual('789', self._file_tail('a', 3))
 
1292
        self.assertEqual(b'789', self._file_tail('a', 3))
1301
1293
 
1302
1294
    def test_syntactically_invalid_range_header(self):
1303
1295
        self.assertListRaises(errors.InvalidHttpRange,
1311
1303
class TestHTTPRedirections(http_utils.TestCaseWithRedirectedWebserver):
1312
1304
    """Test redirection between http servers."""
1313
1305
 
1314
 
    def create_transport_secondary_server(self):
1315
 
        """Create the secondary server redirecting to the primary server"""
1316
 
        new = self.get_readonly_server()
1317
 
 
1318
 
        redirecting = http_utils.HTTPServerRedirecting(
1319
 
            protocol_version=self._protocol_version)
1320
 
        redirecting.redirect_to(new.host, new.port)
1321
 
        return redirecting
 
1306
    scenarios = multiply_scenarios(
 
1307
        vary_by_http_client_implementation(),
 
1308
        vary_by_http_protocol_version(),
 
1309
        )
1322
1310
 
1323
1311
    def setUp(self):
1324
1312
        super(TestHTTPRedirections, self).setUp()
1325
 
        self.build_tree_contents([('a', '0123456789'),
 
1313
        self.build_tree_contents([('a', b'0123456789'),
1326
1314
                                  ('bundle',
1327
 
                                  '# Bazaar revision bundle v0.9\n#\n')
 
1315
                                  b'# Bazaar revision bundle v0.9\n#\n')
1328
1316
                                  ],)
1329
 
        # The requests to the old server will be redirected to the new server
1330
 
        self.old_transport = self._transport(self.old_server.get_url())
1331
1317
 
1332
1318
    def test_redirected(self):
1333
 
        self.assertRaises(errors.RedirectRequested, self.old_transport.get, 'a')
1334
 
        t = self._transport(self.new_server.get_url())
1335
 
        self.assertEqual('0123456789', t.get('a').read())
1336
 
 
1337
 
    def test_read_redirected_bundle_from_url(self):
1338
 
        from bzrlib.bundle import read_bundle_from_url
1339
 
        url = self.old_transport.abspath('bundle')
1340
 
        bundle = self.applyDeprecated(deprecated_in((1, 12, 0)),
1341
 
                read_bundle_from_url, url)
1342
 
        # If read_bundle_from_url was successful we get an empty bundle
1343
 
        self.assertEqual([], bundle.revisions)
 
1319
        self.assertRaises(errors.RedirectRequested,
 
1320
                          self.get_old_transport().get, 'a')
 
1321
        self.assertEqual(
 
1322
                b'0123456789',
 
1323
                self.get_new_transport().get('a').read())
1344
1324
 
1345
1325
 
1346
1326
class RedirectedRequest(_urllib2_wrappers.Request):
1363
1343
    test.overrideAttr(_urllib2_wrappers, 'Request', RedirectedRequest)
1364
1344
 
1365
1345
 
 
1346
def cleanup_http_redirection_connections(test):
 
1347
    # Some sockets are opened but never seen by _urllib, so we trap them at
 
1348
    # the _urllib2_wrappers level to be able to clean them up.
 
1349
    def socket_disconnect(sock):
 
1350
        try:
 
1351
            sock.shutdown(socket.SHUT_RDWR)
 
1352
            sock.close()
 
1353
        except socket.error:
 
1354
            pass
 
1355
    def connect(connection):
 
1356
        test.http_connect_orig(connection)
 
1357
        test.addCleanup(socket_disconnect, connection.sock)
 
1358
    test.http_connect_orig = test.overrideAttr(
 
1359
        _urllib2_wrappers.HTTPConnection, 'connect', connect)
 
1360
    def connect(connection):
 
1361
        test.https_connect_orig(connection)
 
1362
        test.addCleanup(socket_disconnect, connection.sock)
 
1363
    test.https_connect_orig = test.overrideAttr(
 
1364
        _urllib2_wrappers.HTTPSConnection, 'connect', connect)
 
1365
 
 
1366
 
1366
1367
class TestHTTPSilentRedirections(http_utils.TestCaseWithRedirectedWebserver):
1367
1368
    """Test redirections.
1368
1369
 
1370
1371
    do not redirect at all in fact). The mechanism is still in
1371
1372
    place at the _urllib2_wrappers.Request level and these tests
1372
1373
    exercise it.
1373
 
 
1374
 
    For the pycurl implementation
1375
 
    the redirection have been deleted as we may deprecate pycurl
1376
 
    and I have no place to keep a working implementation.
1377
 
    -- vila 20070212
1378
1374
    """
1379
1375
 
 
1376
    scenarios = multiply_scenarios(
 
1377
        vary_by_http_client_implementation(),
 
1378
        vary_by_http_protocol_version(),
 
1379
        )
 
1380
 
1380
1381
    def setUp(self):
1381
 
        if (features.pycurl.available()
1382
 
            and self._transport == PyCurlTransport):
1383
 
            raise tests.TestNotApplicable(
1384
 
                "pycurl doesn't redirect silently annymore")
1385
1382
        super(TestHTTPSilentRedirections, self).setUp()
1386
1383
        install_redirected_request(self)
1387
 
        self.build_tree_contents([('a','a'),
 
1384
        cleanup_http_redirection_connections(self)
 
1385
        self.build_tree_contents([('a', b'a'),
1388
1386
                                  ('1/',),
1389
 
                                  ('1/a', 'redirected once'),
 
1387
                                  ('1/a', b'redirected once'),
1390
1388
                                  ('2/',),
1391
 
                                  ('2/a', 'redirected twice'),
 
1389
                                  ('2/a', b'redirected twice'),
1392
1390
                                  ('3/',),
1393
 
                                  ('3/a', 'redirected thrice'),
 
1391
                                  ('3/a', b'redirected thrice'),
1394
1392
                                  ('4/',),
1395
 
                                  ('4/a', 'redirected 4 times'),
 
1393
                                  ('4/a', b'redirected 4 times'),
1396
1394
                                  ('5/',),
1397
 
                                  ('5/a', 'redirected 5 times'),
 
1395
                                  ('5/a', b'redirected 5 times'),
1398
1396
                                  ],)
1399
1397
 
1400
 
        self.old_transport = self._transport(self.old_server.get_url())
1401
 
 
1402
 
    def create_transport_secondary_server(self):
1403
 
        """Create the secondary server, redirections are defined in the tests"""
1404
 
        return http_utils.HTTPServerRedirecting(
1405
 
            protocol_version=self._protocol_version)
1406
 
 
1407
1398
    def test_one_redirection(self):
1408
 
        t = self.old_transport
1409
 
 
1410
 
        req = RedirectedRequest('GET', t.abspath('a'))
 
1399
        t = self.get_old_transport()
 
1400
        req = RedirectedRequest('GET', t._remote_path('a'))
1411
1401
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1412
1402
                                       self.new_server.port)
1413
1403
        self.old_server.redirections = \
1414
1404
            [('(.*)', r'%s/1\1' % (new_prefix), 301),]
1415
 
        self.assertEqual('redirected once',t._perform(req).read())
 
1405
        self.assertEqual(b'redirected once', t._perform(req).read())
1416
1406
 
1417
1407
    def test_five_redirections(self):
1418
 
        t = self.old_transport
1419
 
 
1420
 
        req = RedirectedRequest('GET', t.abspath('a'))
 
1408
        t = self.get_old_transport()
 
1409
        req = RedirectedRequest('GET', t._remote_path('a'))
1421
1410
        old_prefix = 'http://%s:%s' % (self.old_server.host,
1422
1411
                                       self.old_server.port)
1423
1412
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1429
1418
            ('/4(.*)', r'%s/5\1' % (new_prefix), 301),
1430
1419
            ('(/[^/]+)', r'%s/1\1' % (old_prefix), 301),
1431
1420
            ]
1432
 
        self.assertEqual('redirected 5 times',t._perform(req).read())
 
1421
        self.assertEqual(b'redirected 5 times', t._perform(req).read())
1433
1422
 
1434
1423
 
1435
1424
class TestDoCatchRedirections(http_utils.TestCaseWithRedirectedWebserver):
1436
1425
    """Test transport.do_catching_redirections."""
1437
1426
 
 
1427
    scenarios = multiply_scenarios(
 
1428
        vary_by_http_client_implementation(),
 
1429
        vary_by_http_protocol_version(),
 
1430
        )
 
1431
 
1438
1432
    def setUp(self):
1439
1433
        super(TestDoCatchRedirections, self).setUp()
1440
 
        self.build_tree_contents([('a', '0123456789'),],)
1441
 
 
1442
 
        self.old_transport = self._transport(self.old_server.get_url())
1443
 
 
1444
 
    def get_a(self, transport):
1445
 
        return transport.get('a')
 
1434
        self.build_tree_contents([('a', b'0123456789'),],)
 
1435
        cleanup_http_redirection_connections(self)
 
1436
 
 
1437
        self.old_transport = self.get_old_transport()
 
1438
 
 
1439
    def get_a(self, t):
 
1440
        return t.get('a')
1446
1441
 
1447
1442
    def test_no_redirection(self):
1448
 
        t = self._transport(self.new_server.get_url())
 
1443
        t = self.get_new_transport()
1449
1444
 
1450
1445
        # We use None for redirected so that we fail if redirected
1451
 
        self.assertEqual('0123456789',
 
1446
        self.assertEqual(b'0123456789',
1452
1447
                         transport.do_catching_redirections(
1453
1448
                self.get_a, t, None).read())
1454
1449
 
1455
1450
    def test_one_redirection(self):
1456
1451
        self.redirections = 0
1457
1452
 
1458
 
        def redirected(transport, exception, redirection_notice):
 
1453
        def redirected(t, exception, redirection_notice):
1459
1454
            self.redirections += 1
1460
 
            dir, file = urlutils.split(exception.target)
1461
 
            return self._transport(dir)
 
1455
            redirected_t = t._redirected_to(exception.source, exception.target)
 
1456
            return redirected_t
1462
1457
 
1463
 
        self.assertEqual('0123456789',
 
1458
        self.assertEqual(b'0123456789',
1464
1459
                         transport.do_catching_redirections(
1465
1460
                self.get_a, self.old_transport, redirected).read())
1466
1461
        self.assertEqual(1, self.redirections)
1478
1473
                          self.get_a, self.old_transport, redirected)
1479
1474
 
1480
1475
 
 
1476
def _setup_authentication_config(**kwargs):
 
1477
    conf = config.AuthenticationConfig()
 
1478
    conf._get_config().update({'httptest': kwargs})
 
1479
    conf._save()
 
1480
 
 
1481
 
 
1482
class TestUrllib2AuthHandler(tests.TestCaseWithTransport):
 
1483
    """Unit tests for glue by which urllib2 asks us for authentication"""
 
1484
 
 
1485
    def test_get_user_password_without_port(self):
 
1486
        """We cope if urllib2 doesn't tell us the port.
 
1487
 
 
1488
        See https://bugs.launchpad.net/bzr/+bug/654684
 
1489
        """
 
1490
        user = 'joe'
 
1491
        password = 'foo'
 
1492
        _setup_authentication_config(scheme='http', host='localhost',
 
1493
                                     user=user, password=password)
 
1494
        handler = _urllib2_wrappers.HTTPAuthHandler()
 
1495
        got_pass = handler.get_user_password(dict(
 
1496
            user='joe',
 
1497
            protocol='http',
 
1498
            host='localhost',
 
1499
            path='/',
 
1500
            realm=u'Realm',
 
1501
            ))
 
1502
        self.assertEqual((user, password), got_pass)
 
1503
 
 
1504
 
1481
1505
class TestAuth(http_utils.TestCaseWithWebserver):
1482
1506
    """Test authentication scheme"""
1483
1507
 
1484
 
    _auth_header = 'Authorization'
1485
 
    _password_prompt_prefix = ''
1486
 
    _username_prompt_prefix = ''
1487
 
    # Set by load_tests
1488
 
    _auth_server = None
 
1508
    scenarios = multiply_scenarios(
 
1509
        vary_by_http_client_implementation(),
 
1510
        vary_by_http_protocol_version(),
 
1511
        vary_by_http_auth_scheme(),
 
1512
        )
1489
1513
 
1490
1514
    def setUp(self):
1491
1515
        super(TestAuth, self).setUp()
1492
1516
        self.server = self.get_readonly_server()
1493
 
        self.build_tree_contents([('a', 'contents of a\n'),
1494
 
                                  ('b', 'contents of b\n'),])
 
1517
        self.build_tree_contents([('a', b'contents of a\n'),
 
1518
                                  ('b', b'contents of b\n'),])
1495
1519
 
1496
1520
    def create_transport_readonly_server(self):
1497
 
        return self._auth_server(protocol_version=self._protocol_version)
1498
 
 
1499
 
    def _testing_pycurl(self):
1500
 
        # TODO: This is duplicated for lots of the classes in this file
1501
 
        return (features.pycurl.available()
1502
 
                and self._transport == PyCurlTransport)
 
1521
        server = self._auth_server(protocol_version=self._protocol_version)
 
1522
        server._url_protocol = self._url_protocol
 
1523
        return server
1503
1524
 
1504
1525
    def get_user_url(self, user, password):
1505
1526
        """Build an url embedding user and password"""
1513
1534
        return url
1514
1535
 
1515
1536
    def get_user_transport(self, user, password):
1516
 
        return self._transport(self.get_user_url(user, password))
 
1537
        t = transport.get_transport_from_url(
 
1538
            self.get_user_url(user, password))
 
1539
        return t
1517
1540
 
1518
1541
    def test_no_user(self):
1519
1542
        self.server.add_user('joe', 'foo')
1525
1548
    def test_empty_pass(self):
1526
1549
        self.server.add_user('joe', '')
1527
1550
        t = self.get_user_transport('joe', '')
1528
 
        self.assertEqual('contents of a\n', t.get('a').read())
 
1551
        self.assertEqual(b'contents of a\n', t.get('a').read())
1529
1552
        # Only one 'Authentication Required' error should occur
1530
1553
        self.assertEqual(1, self.server.auth_required_errors)
1531
1554
 
1532
1555
    def test_user_pass(self):
1533
1556
        self.server.add_user('joe', 'foo')
1534
1557
        t = self.get_user_transport('joe', 'foo')
1535
 
        self.assertEqual('contents of a\n', t.get('a').read())
 
1558
        self.assertEqual(b'contents of a\n', t.get('a').read())
1536
1559
        # Only one 'Authentication Required' error should occur
1537
1560
        self.assertEqual(1, self.server.auth_required_errors)
1538
1561
 
1554
1577
        self.assertEqual(2, self.server.auth_required_errors)
1555
1578
 
1556
1579
    def test_prompt_for_username(self):
1557
 
        if self._testing_pycurl():
1558
 
            raise tests.TestNotApplicable(
1559
 
                'pycurl cannot prompt, it handles auth by embedding'
1560
 
                ' user:pass in urls only')
1561
 
 
1562
1580
        self.server.add_user('joe', 'foo')
1563
1581
        t = self.get_user_transport(None, None)
1564
 
        stdout = tests.StringIOWrapper()
1565
 
        stderr = tests.StringIOWrapper()
1566
 
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n',
1567
 
                                            stdout=stdout, stderr=stderr)
1568
 
        self.assertEqual('contents of a\n',t.get('a').read())
 
1582
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n')
 
1583
        stdout, stderr = ui.ui_factory.stdout, ui.ui_factory.stderr
 
1584
        self.assertEqual(b'contents of a\n', t.get('a').read())
1569
1585
        # stdin should be empty
1570
1586
        self.assertEqual('', ui.ui_factory.stdin.readline())
1571
1587
        stderr.seek(0)
1576
1592
                                    stderr.readline())
1577
1593
 
1578
1594
    def test_prompt_for_password(self):
1579
 
        if self._testing_pycurl():
1580
 
            raise tests.TestNotApplicable(
1581
 
                'pycurl cannot prompt, it handles auth by embedding'
1582
 
                ' user:pass in urls only')
1583
 
 
1584
1595
        self.server.add_user('joe', 'foo')
1585
1596
        t = self.get_user_transport('joe', None)
1586
 
        stdout = tests.StringIOWrapper()
1587
 
        stderr = tests.StringIOWrapper()
1588
 
        ui.ui_factory = tests.TestUIFactory(stdin='foo\n',
1589
 
                                            stdout=stdout, stderr=stderr)
1590
 
        self.assertEqual('contents of a\n', t.get('a').read())
 
1597
        ui.ui_factory = tests.TestUIFactory(stdin='foo\n')
 
1598
        stdout, stderr = ui.ui_factory.stdout, ui.ui_factory.stderr
 
1599
        self.assertEqual(b'contents of a\n', t.get('a').read())
1591
1600
        # stdin should be empty
1592
1601
        self.assertEqual('', ui.ui_factory.stdin.readline())
1593
1602
        self._check_password_prompt(t._unqualified_scheme, 'joe',
1595
1604
        self.assertEqual('', stdout.getvalue())
1596
1605
        # And we shouldn't prompt again for a different request
1597
1606
        # against the same transport.
1598
 
        self.assertEqual('contents of b\n',t.get('b').read())
 
1607
        self.assertEqual(b'contents of b\n', t.get('b').read())
1599
1608
        t2 = t.clone()
1600
1609
        # And neither against a clone
1601
 
        self.assertEqual('contents of b\n',t2.get('b').read())
 
1610
        self.assertEqual(b'contents of b\n', t2.get('b').read())
1602
1611
        # Only one 'Authentication Required' error should occur
1603
1612
        self.assertEqual(1, self.server.auth_required_errors)
1604
1613
 
1617
1626
                                 self.server.auth_realm))
1618
1627
 
1619
1628
    def test_no_prompt_for_password_when_using_auth_config(self):
1620
 
        if self._testing_pycurl():
1621
 
            raise tests.TestNotApplicable(
1622
 
                'pycurl does not support authentication.conf'
1623
 
                ' since it cannot prompt')
1624
 
 
1625
1629
        user =' joe'
1626
1630
        password = 'foo'
1627
1631
        stdin_content = 'bar\n'  # Not the right password
1628
1632
        self.server.add_user(user, password)
1629
1633
        t = self.get_user_transport(user, None)
1630
 
        ui.ui_factory = tests.TestUIFactory(stdin=stdin_content,
1631
 
                                            stderr=tests.StringIOWrapper())
 
1634
        ui.ui_factory = tests.TestUIFactory(stdin=stdin_content)
1632
1635
        # Create a minimal config file with the right password
1633
 
        conf = config.AuthenticationConfig()
1634
 
        conf._get_config().update(
1635
 
            {'httptest': {'scheme': 'http', 'port': self.server.port,
1636
 
                          'user': user, 'password': password}})
1637
 
        conf._save()
 
1636
        _setup_authentication_config(scheme='http', port=self.server.port,
 
1637
                                     user=user, password=password)
1638
1638
        # Issue a request to the server to connect
1639
 
        self.assertEqual('contents of a\n',t.get('a').read())
 
1639
        with t.get('a') as f:
 
1640
            self.assertEqual(b'contents of a\n', f.read())
1640
1641
        # stdin should have  been left untouched
1641
1642
        self.assertEqual(stdin_content, ui.ui_factory.stdin.readline())
1642
1643
        # Only one 'Authentication Required' error should occur
1643
1644
        self.assertEqual(1, self.server.auth_required_errors)
1644
1645
 
1645
 
    def test_user_from_auth_conf(self):
1646
 
        if self._testing_pycurl():
1647
 
            raise tests.TestNotApplicable(
1648
 
                'pycurl does not support authentication.conf')
1649
 
        user = 'joe'
1650
 
        password = 'foo'
1651
 
        self.server.add_user(user, password)
1652
 
        # Create a minimal config file with the right password
1653
 
        conf = config.AuthenticationConfig()
1654
 
        conf._get_config().update(
1655
 
            {'httptest': {'scheme': 'http', 'port': self.server.port,
1656
 
                          'user': user, 'password': password}})
1657
 
        conf._save()
1658
 
        t = self.get_user_transport(None, None)
1659
 
        # Issue a request to the server to connect
1660
 
        self.assertEqual('contents of a\n', t.get('a').read())
1661
 
        # Only one 'Authentication Required' error should occur
1662
 
        self.assertEqual(1, self.server.auth_required_errors)
1663
 
 
1664
1646
    def test_changing_nonce(self):
1665
1647
        if self._auth_server not in (http_utils.HTTPDigestAuthServer,
1666
1648
                                     http_utils.ProxyDigestAuthServer):
1667
1649
            raise tests.TestNotApplicable('HTTP/proxy auth digest only test')
1668
 
        if self._testing_pycurl():
1669
 
            raise tests.KnownFailure(
1670
 
                'pycurl does not handle a nonce change')
1671
1650
        self.server.add_user('joe', 'foo')
1672
1651
        t = self.get_user_transport('joe', 'foo')
1673
 
        self.assertEqual('contents of a\n', t.get('a').read())
1674
 
        self.assertEqual('contents of b\n', t.get('b').read())
 
1652
        with t.get('a') as f:
 
1653
            self.assertEqual(b'contents of a\n', f.read())
 
1654
        with t.get('b') as f:
 
1655
            self.assertEqual(b'contents of b\n', f.read())
1675
1656
        # Only one 'Authentication Required' error should have
1676
1657
        # occured so far
1677
1658
        self.assertEqual(1, self.server.auth_required_errors)
1678
1659
        # The server invalidates the current nonce
1679
1660
        self.server.auth_nonce = self.server.auth_nonce + '. No, now!'
1680
 
        self.assertEqual('contents of a\n', t.get('a').read())
 
1661
        self.assertEqual(b'contents of a\n', t.get('a').read())
1681
1662
        # Two 'Authentication Required' errors should occur (the
1682
1663
        # initial 'who are you' and a second 'who are you' with the new nonce)
1683
1664
        self.assertEqual(2, self.server.auth_required_errors)
1684
1665
 
 
1666
    def test_user_from_auth_conf(self):
 
1667
        user = 'joe'
 
1668
        password = 'foo'
 
1669
        self.server.add_user(user, password)
 
1670
        _setup_authentication_config(scheme='http', port=self.server.port,
 
1671
                                     user=user, password=password)
 
1672
        t = self.get_user_transport(None, None)
 
1673
        # Issue a request to the server to connect
 
1674
        with t.get('a') as f:
 
1675
            self.assertEqual(b'contents of a\n', f.read())
 
1676
        # Only one 'Authentication Required' error should occur
 
1677
        self.assertEqual(1, self.server.auth_required_errors)
 
1678
 
 
1679
    def test_no_credential_leaks_in_log(self):
 
1680
        self.overrideAttr(debug, 'debug_flags', {'http'})
 
1681
        user = 'joe'
 
1682
        password = 'very-sensitive-password'
 
1683
        self.server.add_user(user, password)
 
1684
        t = self.get_user_transport(user, password)
 
1685
        # Capture the debug calls to mutter
 
1686
        self.mutters = []
 
1687
        def mutter(*args):
 
1688
            lines = args[0] % args[1:]
 
1689
            # Some calls output multiple lines, just split them now since we
 
1690
            # care about a single one later.
 
1691
            self.mutters.extend(lines.splitlines())
 
1692
        self.overrideAttr(trace, 'mutter', mutter)
 
1693
        # Issue a request to the server to connect
 
1694
        self.assertEqual(True, t.has('a'))
 
1695
        # Only one 'Authentication Required' error should occur
 
1696
        self.assertEqual(1, self.server.auth_required_errors)
 
1697
        # Since the authentification succeeded, there should be a corresponding
 
1698
        # debug line
 
1699
        sent_auth_headers = [line for line in self.mutters
 
1700
                             if line.startswith('> %s' % (self._auth_header,))]
 
1701
        self.assertLength(1, sent_auth_headers)
 
1702
        self.assertStartsWith(sent_auth_headers[0],
 
1703
                              '> %s: <masked>' % (self._auth_header,))
1685
1704
 
1686
1705
 
1687
1706
class TestProxyAuth(TestAuth):
1688
 
    """Test proxy authentication schemes."""
1689
 
 
1690
 
    _auth_header = 'Proxy-authorization'
1691
 
    _password_prompt_prefix = 'Proxy '
1692
 
    _username_prompt_prefix = 'Proxy '
 
1707
    """Test proxy authentication schemes.
 
1708
 
 
1709
    This inherits from TestAuth to tweak the setUp and filter some failing
 
1710
    tests.
 
1711
    """
 
1712
 
 
1713
    scenarios = multiply_scenarios(
 
1714
        vary_by_http_client_implementation(),
 
1715
        vary_by_http_protocol_version(),
 
1716
        vary_by_http_proxy_auth_scheme(),
 
1717
        )
1693
1718
 
1694
1719
    def setUp(self):
1695
1720
        super(TestProxyAuth, self).setUp()
1696
 
        self._old_env = {}
1697
 
        self.addCleanup(self._restore_env)
1698
1721
        # Override the contents to avoid false positives
1699
 
        self.build_tree_contents([('a', 'not proxied contents of a\n'),
1700
 
                                  ('b', 'not proxied contents of b\n'),
1701
 
                                  ('a-proxied', 'contents of a\n'),
1702
 
                                  ('b-proxied', 'contents of b\n'),
 
1722
        self.build_tree_contents([('a', b'not proxied contents of a\n'),
 
1723
                                  ('b', b'not proxied contents of b\n'),
 
1724
                                  ('a-proxied', b'contents of a\n'),
 
1725
                                  ('b-proxied', b'contents of b\n'),
1703
1726
                                  ])
1704
1727
 
1705
1728
    def get_user_transport(self, user, password):
1706
 
        self._install_env({'all_proxy': self.get_user_url(user, password)})
1707
 
        return self._transport(self.server.get_url())
1708
 
 
1709
 
    def _install_env(self, env):
1710
 
        for name, value in env.iteritems():
1711
 
            self._old_env[name] = osutils.set_or_unset_env(name, value)
1712
 
 
1713
 
    def _restore_env(self):
1714
 
        for name, value in self._old_env.iteritems():
1715
 
            osutils.set_or_unset_env(name, value)
1716
 
 
1717
 
    def test_empty_pass(self):
1718
 
        if self._testing_pycurl():
1719
 
            import pycurl
1720
 
            if pycurl.version_info()[1] < '7.16.0':
1721
 
                raise tests.KnownFailure(
1722
 
                    'pycurl < 7.16.0 does not handle empty proxy passwords')
1723
 
        super(TestProxyAuth, self).test_empty_pass()
 
1729
        proxy_url = self.get_user_url(user, password)
 
1730
        self.overrideEnv('all_proxy', proxy_url)
 
1731
        return TestAuth.get_user_transport(self, user, password)
 
1732
 
 
1733
 
 
1734
class NonClosingBytesIO(io.BytesIO):
 
1735
 
 
1736
    def close(self):
 
1737
        """Ignore and leave file open."""
1724
1738
 
1725
1739
 
1726
1740
class SampleSocket(object):
1731
1745
 
1732
1746
        :param socket_read_content: a byte sequence
1733
1747
        """
1734
 
        # Use plain python StringIO so we can monkey-patch the close method to
1735
 
        # not discard the contents.
1736
 
        from StringIO import StringIO
1737
 
        self.readfile = StringIO(socket_read_content)
1738
 
        self.writefile = StringIO()
1739
 
        self.writefile.close = lambda: None
 
1748
        self.readfile = io.BytesIO(socket_read_content)
 
1749
        self.writefile = NonClosingBytesIO()
 
1750
 
 
1751
    def close(self):
 
1752
        """Ignore and leave files alone."""
 
1753
 
 
1754
    def sendall(self, bytes):
 
1755
        self.writefile.write(bytes)
1740
1756
 
1741
1757
    def makefile(self, mode='r', bufsize=None):
1742
1758
        if 'r' in mode:
1747
1763
 
1748
1764
class SmartHTTPTunnellingTest(tests.TestCaseWithTransport):
1749
1765
 
 
1766
    scenarios = multiply_scenarios(
 
1767
        vary_by_http_client_implementation(),
 
1768
        vary_by_http_protocol_version(),
 
1769
        )
 
1770
 
1750
1771
    def setUp(self):
1751
1772
        super(SmartHTTPTunnellingTest, self).setUp()
1752
1773
        # We use the VFS layer as part of HTTP tunnelling tests.
1753
 
        self._captureVar('BZR_NO_SMART_VFS', None)
 
1774
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1754
1775
        self.transport_readonly_server = http_utils.HTTPServerWithSmarts
 
1776
        self.http_server = self.get_readonly_server()
1755
1777
 
1756
1778
    def create_transport_readonly_server(self):
1757
 
        return http_utils.HTTPServerWithSmarts(
 
1779
        server = http_utils.HTTPServerWithSmarts(
1758
1780
            protocol_version=self._protocol_version)
 
1781
        server._url_protocol = self._url_protocol
 
1782
        return server
1759
1783
 
1760
 
    def test_open_bzrdir(self):
 
1784
    def test_open_controldir(self):
1761
1785
        branch = self.make_branch('relpath')
1762
 
        http_server = self.get_readonly_server()
1763
 
        url = http_server.get_url() + 'relpath'
1764
 
        bd = bzrdir.BzrDir.open(url)
 
1786
        url = self.http_server.get_url() + 'relpath'
 
1787
        bd = controldir.ControlDir.open(url)
 
1788
        self.addCleanup(bd.transport.disconnect)
1765
1789
        self.assertIsInstance(bd, _mod_remote.RemoteBzrDir)
1766
1790
 
1767
1791
    def test_bulk_data(self):
1769
1793
        # The 'readv' command in the smart protocol both sends and receives
1770
1794
        # bulk data, so we use that.
1771
1795
        self.build_tree(['data-file'])
1772
 
        http_server = self.get_readonly_server()
1773
 
        http_transport = self._transport(http_server.get_url())
 
1796
        http_transport = transport.get_transport_from_url(
 
1797
            self.http_server.get_url())
1774
1798
        medium = http_transport.get_smart_medium()
1775
1799
        # Since we provide the medium, the url below will be mostly ignored
1776
1800
        # during the test, as long as the path is '/'.
1777
1801
        remote_transport = remote.RemoteTransport('bzr://fake_host/',
1778
1802
                                                  medium=medium)
1779
1803
        self.assertEqual(
1780
 
            [(0, "c")], list(remote_transport.readv("data-file", [(0,1)])))
 
1804
            [(0, b"c")], list(remote_transport.readv("data-file", [(0, 1)])))
1781
1805
 
1782
1806
    def test_http_send_smart_request(self):
1783
1807
 
1784
 
        post_body = 'hello\n'
1785
 
        expected_reply_body = 'ok\x012\n'
 
1808
        post_body = b'hello\n'
 
1809
        expected_reply_body = b'ok\x012\n'
1786
1810
 
1787
 
        http_server = self.get_readonly_server()
1788
 
        http_transport = self._transport(http_server.get_url())
 
1811
        http_transport = transport.get_transport_from_url(
 
1812
            self.http_server.get_url())
1789
1813
        medium = http_transport.get_smart_medium()
1790
1814
        response = medium.send_http_smart_request(post_body)
1791
1815
        reply_body = response.read()
1792
1816
        self.assertEqual(expected_reply_body, reply_body)
1793
1817
 
1794
1818
    def test_smart_http_server_post_request_handler(self):
1795
 
        httpd = self.get_readonly_server()._get_httpd()
 
1819
        httpd = self.http_server.server
1796
1820
 
1797
1821
        socket = SampleSocket(
1798
 
            'POST /.bzr/smart %s \r\n' % self._protocol_version
 
1822
            b'POST /.bzr/smart %s \r\n' % self._protocol_version.encode('ascii')
1799
1823
            # HTTP/1.1 posts must have a Content-Length (but it doesn't hurt
1800
1824
            # for 1.0)
1801
 
            + 'Content-Length: 6\r\n'
1802
 
            '\r\n'
1803
 
            'hello\n')
 
1825
            + b'Content-Length: 6\r\n'
 
1826
            b'\r\n'
 
1827
            b'hello\n')
1804
1828
        # Beware: the ('localhost', 80) below is the
1805
1829
        # client_address parameter, but we don't have one because
1806
1830
        # we have defined a socket which is not bound to an
1810
1834
                                                         ('localhost', 80),
1811
1835
                                                         httpd)
1812
1836
        response = socket.writefile.getvalue()
1813
 
        self.assertStartsWith(response, '%s 200 ' % self._protocol_version)
 
1837
        self.assertStartsWith(
 
1838
                response,
 
1839
                b'%s 200 ' % self._protocol_version.encode('ascii'))
1814
1840
        # This includes the end of the HTTP headers, and all the body.
1815
 
        expected_end_of_response = '\r\n\r\nok\x012\n'
 
1841
        expected_end_of_response = b'\r\n\r\nok\x012\n'
1816
1842
        self.assertEndsWith(response, expected_end_of_response)
1817
1843
 
1818
1844
 
1830
1856
 
1831
1857
    def test_probe_smart_server(self):
1832
1858
        """Test error handling against server refusing smart requests."""
1833
 
        server = self.get_readonly_server()
1834
 
        t = self._transport(server.get_url())
 
1859
        t = self.get_readonly_transport()
1835
1860
        # No need to build a valid smart request here, the server will not even
1836
1861
        # try to interpret it.
1837
1862
        self.assertRaises(errors.SmartProtocolError,
1838
1863
                          t.get_smart_medium().send_http_smart_request,
1839
 
                          'whatever')
 
1864
                          b'whatever')
 
1865
 
1840
1866
 
1841
1867
class Test_redirected_to(tests.TestCase):
1842
1868
 
 
1869
    scenarios = vary_by_http_client_implementation()
 
1870
 
1843
1871
    def test_redirected_to_subdir(self):
1844
1872
        t = self._transport('http://www.example.com/foo')
1845
1873
        r = t._redirected_to('http://www.example.com/foo',
1847
1875
        self.assertIsInstance(r, type(t))
1848
1876
        # Both transports share the some connection
1849
1877
        self.assertEqual(t._get_connection(), r._get_connection())
 
1878
        self.assertEqual('http://www.example.com/foo/subdir/', r.base)
1850
1879
 
1851
1880
    def test_redirected_to_self_with_slash(self):
1852
1881
        t = self._transport('http://www.example.com/foo')
1863
1892
        r = t._redirected_to('http://www.example.com/foo',
1864
1893
                             'http://foo.example.com/foo/subdir')
1865
1894
        self.assertIsInstance(r, type(t))
 
1895
        self.assertEqual('http://foo.example.com/foo/subdir/',
 
1896
            r.external_url())
1866
1897
 
1867
1898
    def test_redirected_to_same_host_sibling_protocol(self):
1868
1899
        t = self._transport('http://www.example.com/foo')
1869
1900
        r = t._redirected_to('http://www.example.com/foo',
1870
1901
                             'https://www.example.com/foo')
1871
1902
        self.assertIsInstance(r, type(t))
 
1903
        self.assertEqual('https://www.example.com/foo/',
 
1904
            r.external_url())
1872
1905
 
1873
1906
    def test_redirected_to_same_host_different_protocol(self):
1874
1907
        t = self._transport('http://www.example.com/foo')
1875
1908
        r = t._redirected_to('http://www.example.com/foo',
1876
 
                             'ftp://www.example.com/foo')
1877
 
        self.assertNotEquals(type(r), type(t))
 
1909
                             'bzr://www.example.com/foo')
 
1910
        self.assertNotEqual(type(r), type(t))
 
1911
        self.assertEqual('bzr://www.example.com/foo/', r.external_url())
 
1912
 
 
1913
    def test_redirected_to_same_host_specific_implementation(self):
 
1914
        t = self._transport('http://www.example.com/foo')
 
1915
        r = t._redirected_to('http://www.example.com/foo',
 
1916
                             'https+urllib://www.example.com/foo')
 
1917
        self.assertEqual('https://www.example.com/foo/', r.external_url())
1878
1918
 
1879
1919
    def test_redirected_to_different_host_same_user(self):
1880
1920
        t = self._transport('http://joe@www.example.com/foo')
1881
1921
        r = t._redirected_to('http://www.example.com/foo',
1882
1922
                             'https://foo.example.com/foo')
1883
1923
        self.assertIsInstance(r, type(t))
1884
 
        self.assertEqual(t._user, r._user)
 
1924
        self.assertEqual(t._parsed_url.user, r._parsed_url.user)
 
1925
        self.assertEqual('https://joe@foo.example.com/foo/', r.external_url())
1885
1926
 
1886
1927
 
1887
1928
class PredefinedRequestHandler(http_server.TestingHTTPRequestHandler):
1896
1937
    line.
1897
1938
    """
1898
1939
 
1899
 
    def handle_one_request(self):
 
1940
    def _handle_one_request(self):
1900
1941
        tcs = self.server.test_case_server
1901
1942
        requestline = self.rfile.readline()
1902
 
        headers = self.MessageClass(self.rfile, 0)
1903
 
        # We just read: the request, the headers, an empty line indicating the
1904
 
        # end of the headers.
1905
 
        bytes_read = len(requestline)
1906
 
        for line in headers.headers:
1907
 
            bytes_read += len(line)
1908
 
        bytes_read += len('\r\n')
1909
 
        if requestline.startswith('POST'):
 
1943
        if PY3:
 
1944
            headers = parse_headers(self.rfile)
 
1945
            bytes_read = len(headers.as_bytes())
 
1946
            bytes_read += headers.as_bytes().count(b'\n')
 
1947
            bytes_read += len(requestline)
 
1948
        else:
 
1949
            headers = self.MessageClass(self.rfile, 0)
 
1950
            # We just read: the request, the headers, an empty line indicating the
 
1951
            # end of the headers.
 
1952
            bytes_read = len(requestline)
 
1953
            for line in headers.headers:
 
1954
                bytes_read += len(line)
 
1955
            bytes_read += len(b'\r\n')
 
1956
        if requestline.startswith(b'POST'):
1910
1957
            # The body should be a single line (or we don't know where it ends
1911
1958
            # and we don't want to issue a blocking read)
1912
1959
            body = self.rfile.readline()
1940
1987
    pass
1941
1988
 
1942
1989
 
1943
 
if tests.HTTPSServerFeature.available():
1944
 
    from bzrlib.tests import https_server
 
1990
if features.HTTPSServerFeature.available():
 
1991
    from . import https_server
1945
1992
    class ActivityHTTPSServer(ActivityServerMixin, https_server.HTTPSServer):
1946
1993
        pass
1947
1994
 
1954
2001
    """
1955
2002
 
1956
2003
    def setUp(self):
1957
 
        tests.TestCase.setUp(self)
1958
2004
        self.server = self._activity_server(self._protocol_version)
1959
2005
        self.server.start_server()
1960
 
        self.activities = {}
 
2006
        self.addCleanup(self.server.stop_server)
 
2007
        _activities = {} # Don't close over self and create a cycle
1961
2008
        def report_activity(t, bytes, direction):
1962
 
            count = self.activities.get(direction, 0)
 
2009
            count = _activities.get(direction, 0)
1963
2010
            count += bytes
1964
 
            self.activities[direction] = count
1965
 
 
 
2011
            _activities[direction] = count
 
2012
        self.activities = _activities
1966
2013
        # We override at class level because constructors may propagate the
1967
2014
        # bound method and render instance overriding ineffective (an
1968
2015
        # alternative would be to define a specific ui factory instead...)
1969
 
        self.orig_report_activity = self._transport._report_activity
1970
 
        self._transport._report_activity = report_activity
1971
 
 
1972
 
    def tearDown(self):
1973
 
        self._transport._report_activity = self.orig_report_activity
1974
 
        self.server.stop_server()
1975
 
        tests.TestCase.tearDown(self)
 
2016
        self.overrideAttr(self._transport, '_report_activity', report_activity)
1976
2017
 
1977
2018
    def get_transport(self):
1978
 
        return self._transport(self.server.get_url())
 
2019
        t = self._transport(self.server.get_url())
 
2020
        # FIXME: Needs cleanup -- vila 20100611
 
2021
        return t
1979
2022
 
1980
2023
    def assertActivitiesMatch(self):
1981
2024
        self.assertEqual(self.server.bytes_read,
1984
2027
                         self.activities.get('read', 0), 'read bytes')
1985
2028
 
1986
2029
    def test_get(self):
1987
 
        self.server.canned_response = '''HTTP/1.1 200 OK\r
 
2030
        self.server.canned_response = b'''HTTP/1.1 200 OK\r
1988
2031
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
1989
2032
Server: Apache/2.0.54 (Fedora)\r
1990
2033
Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
1997
2040
Bazaar-NG meta directory, format 1
1998
2041
'''
1999
2042
        t = self.get_transport()
2000
 
        self.assertEqual('Bazaar-NG meta directory, format 1\n',
 
2043
        self.assertEqual(b'Bazaar-NG meta directory, format 1\n',
2001
2044
                         t.get('foo/bar').read())
2002
2045
        self.assertActivitiesMatch()
2003
2046
 
2004
2047
    def test_has(self):
2005
 
        self.server.canned_response = '''HTTP/1.1 200 OK\r
 
2048
        self.server.canned_response = b'''HTTP/1.1 200 OK\r
2006
2049
Server: SimpleHTTP/0.6 Python/2.5.2\r
2007
2050
Date: Thu, 29 Jan 2009 20:21:47 GMT\r
2008
2051
Content-type: application/octet-stream\r
2015
2058
        self.assertActivitiesMatch()
2016
2059
 
2017
2060
    def test_readv(self):
2018
 
        self.server.canned_response = '''HTTP/1.1 206 Partial Content\r
 
2061
        self.server.canned_response = b'''HTTP/1.1 206 Partial Content\r
2019
2062
Date: Tue, 11 Jul 2006 04:49:48 GMT\r
2020
2063
Server: Apache/2.0.54 (Fedora)\r
2021
2064
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
2072
2115
        self.assertActivitiesMatch()
2073
2116
 
2074
2117
    def test_post(self):
2075
 
        self.server.canned_response = '''HTTP/1.1 200 OK\r
 
2118
        self.server.canned_response = b'''HTTP/1.1 200 OK\r
2076
2119
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
2077
2120
Server: Apache/2.0.54 (Fedora)\r
2078
2121
Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
2086
2129
'''
2087
2130
        t = self.get_transport()
2088
2131
        # We must send a single line of body bytes, see
2089
 
        # PredefinedRequestHandler.handle_one_request
2090
 
        code, f = t._post('abc def end-of-body\n')
2091
 
        self.assertEqual('lalala whatever as long as itsssss\n', f.read())
 
2132
        # PredefinedRequestHandler._handle_one_request
 
2133
        code, f = t._post(b'abc def end-of-body\n')
 
2134
        self.assertEqual(b'lalala whatever as long as itsssss\n', f.read())
2092
2135
        self.assertActivitiesMatch()
2093
2136
 
2094
2137
 
2095
2138
class TestActivity(tests.TestCase, TestActivityMixin):
2096
2139
 
 
2140
    scenarios = multiply_scenarios(
 
2141
        vary_by_http_activity(),
 
2142
        vary_by_http_protocol_version(),
 
2143
        )
 
2144
 
2097
2145
    def setUp(self):
2098
 
        tests.TestCase.setUp(self)
2099
 
        self.server = self._activity_server(self._protocol_version)
2100
 
        self.server.start_server()
2101
 
        self.activities = {}
2102
 
        def report_activity(t, bytes, direction):
2103
 
            count = self.activities.get(direction, 0)
2104
 
            count += bytes
2105
 
            self.activities[direction] = count
2106
 
 
2107
 
        # We override at class level because constructors may propagate the
2108
 
        # bound method and render instance overriding ineffective (an
2109
 
        # alternative would be to define a specific ui factory instead...)
2110
 
        self.orig_report_activity = self._transport._report_activity
2111
 
        self._transport._report_activity = report_activity
2112
 
 
2113
 
    def tearDown(self):
2114
 
        self._transport._report_activity = self.orig_report_activity
2115
 
        self.server.stop_server()
2116
 
        tests.TestCase.tearDown(self)
 
2146
        super(TestActivity, self).setUp()
 
2147
        TestActivityMixin.setUp(self)
2117
2148
 
2118
2149
 
2119
2150
class TestNoReportActivity(tests.TestCase, TestActivityMixin):
2120
2151
 
 
2152
    # Unlike TestActivity, we are really testing ReportingFileSocket and
 
2153
    # ReportingSocket, so we don't need all the parametrization. Since
 
2154
    # ReportingFileSocket and ReportingSocket are wrappers, it's easier to
 
2155
    # test them through their use by the transport than directly (that's a
 
2156
    # bit less clean but far more simpler and effective).
 
2157
    _activity_server = ActivityHTTPServer
 
2158
    _protocol_version = 'HTTP/1.1'
 
2159
 
2121
2160
    def setUp(self):
2122
 
        tests.TestCase.setUp(self)
2123
 
        # Unlike TestActivity, we are really testing ReportingFileSocket and
2124
 
        # ReportingSocket, so we don't need all the parametrization. Since
2125
 
        # ReportingFileSocket and ReportingSocket are wrappers, it's easier to
2126
 
        # test them through their use by the transport than directly (that's a
2127
 
        # bit less clean but far more simpler and effective).
2128
 
        self.server = ActivityHTTPServer('HTTP/1.1')
2129
 
        self._transport=_urllib.HttpTransport_urllib
2130
 
 
2131
 
        self.server.start_server()
2132
 
 
2133
 
        # We override at class level because constructors may propagate the
2134
 
        # bound method and render instance overriding ineffective (an
2135
 
        # alternative would be to define a specific ui factory instead...)
2136
 
        self.orig_report_activity = self._transport._report_activity
2137
 
        self._transport._report_activity = None
2138
 
 
2139
 
    def tearDown(self):
2140
 
        self._transport._report_activity = self.orig_report_activity
2141
 
        self.server.stop_server()
2142
 
        tests.TestCase.tearDown(self)
 
2161
        super(TestNoReportActivity, self).setUp()
 
2162
        self._transport = HttpTransport
 
2163
        TestActivityMixin.setUp(self)
2143
2164
 
2144
2165
    def assertActivitiesMatch(self):
2145
2166
        # Nothing to check here
2149
2170
class TestAuthOnRedirected(http_utils.TestCaseWithRedirectedWebserver):
2150
2171
    """Test authentication on the redirected http server."""
2151
2172
 
 
2173
    scenarios = vary_by_http_protocol_version()
 
2174
 
2152
2175
    _auth_header = 'Authorization'
2153
2176
    _password_prompt_prefix = ''
2154
2177
    _username_prompt_prefix = ''
2155
2178
    _auth_server = http_utils.HTTPBasicAuthServer
2156
 
    _transport = _urllib.HttpTransport_urllib
2157
 
 
2158
 
    def create_transport_readonly_server(self):
2159
 
        return self._auth_server()
2160
 
 
2161
 
    def create_transport_secondary_server(self):
2162
 
        """Create the secondary server redirecting to the primary server"""
2163
 
        new = self.get_readonly_server()
2164
 
 
2165
 
        redirecting = http_utils.HTTPServerRedirecting()
2166
 
        redirecting.redirect_to(new.host, new.port)
2167
 
        return redirecting
 
2179
    _transport = HttpTransport
2168
2180
 
2169
2181
    def setUp(self):
2170
2182
        super(TestAuthOnRedirected, self).setUp()
2171
 
        self.build_tree_contents([('a','a'),
 
2183
        self.build_tree_contents([('a', b'a'),
2172
2184
                                  ('1/',),
2173
 
                                  ('1/a', 'redirected once'),
 
2185
                                  ('1/a', b'redirected once'),
2174
2186
                                  ],)
2175
2187
        new_prefix = 'http://%s:%s' % (self.new_server.host,
2176
2188
                                       self.new_server.port)
2177
2189
        self.old_server.redirections = [
2178
2190
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2179
 
        self.old_transport = self._transport(self.old_server.get_url())
 
2191
        self.old_transport = self.get_old_transport()
2180
2192
        self.new_server.add_user('joe', 'foo')
2181
 
 
2182
 
    def get_a(self, transport):
2183
 
        return transport.get('a')
 
2193
        cleanup_http_redirection_connections(self)
 
2194
 
 
2195
    def create_transport_readonly_server(self):
 
2196
        server = self._auth_server(protocol_version=self._protocol_version)
 
2197
        server._url_protocol = self._url_protocol
 
2198
        return server
 
2199
 
 
2200
    def get_a(self, t):
 
2201
        return t.get('a')
2184
2202
 
2185
2203
    def test_auth_on_redirected_via_do_catching_redirections(self):
2186
2204
        self.redirections = 0
2187
2205
 
2188
 
        def redirected(transport, exception, redirection_notice):
 
2206
        def redirected(t, exception, redirection_notice):
2189
2207
            self.redirections += 1
2190
 
            dir, file = urlutils.split(exception.target)
2191
 
            return self._transport(dir)
 
2208
            redirected_t = t._redirected_to(exception.source, exception.target)
 
2209
            self.addCleanup(redirected_t.disconnect)
 
2210
            return redirected_t
2192
2211
 
2193
 
        stdout = tests.StringIOWrapper()
2194
 
        stderr = tests.StringIOWrapper()
2195
 
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n',
2196
 
                                            stdout=stdout, stderr=stderr)
 
2212
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n')
2197
2213
        self.assertEqual('redirected once',
2198
2214
                         transport.do_catching_redirections(
2199
2215
                self.get_a, self.old_transport, redirected).read())
2201
2217
        # stdin should be empty
2202
2218
        self.assertEqual('', ui.ui_factory.stdin.readline())
2203
2219
        # stdout should be empty, stderr will contains the prompts
2204
 
        self.assertEqual('', stdout.getvalue())
 
2220
        self.assertEqual('', ui.ui_factory.stdout.getvalue())
2205
2221
 
2206
2222
    def test_auth_on_redirected_via_following_redirections(self):
2207
2223
        self.new_server.add_user('joe', 'foo')
2208
 
        stdout = tests.StringIOWrapper()
2209
 
        stderr = tests.StringIOWrapper()
2210
 
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n',
2211
 
                                            stdout=stdout, stderr=stderr)
 
2224
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n')
2212
2225
        t = self.old_transport
2213
2226
        req = RedirectedRequest('GET', t.abspath('a'))
2214
2227
        new_prefix = 'http://%s:%s' % (self.new_server.host,
2215
2228
                                       self.new_server.port)
2216
2229
        self.old_server.redirections = [
2217
2230
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2218
 
        self.assertEqual('redirected once',t._perform(req).read())
 
2231
        self.assertEqual('redirected once', t._perform(req).read())
2219
2232
        # stdin should be empty
2220
2233
        self.assertEqual('', ui.ui_factory.stdin.readline())
2221
2234
        # stdout should be empty, stderr will contains the prompts
2222
 
        self.assertEqual('', stdout.getvalue())
2223
 
 
 
2235
        self.assertEqual('', ui.ui_factory.stdout.getvalue())
2224
2236