/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: 2017-08-09 23:17:39 UTC
  • mfrom: (6746.2.1 trunk)
  • Revision ID: jelmer@jelmer.uk-20170809231739-zaxynffd6oeo6ehe
Merge lp:~jelmer/brz/matchingbzrdir.

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
26
import httplib
28
 
import os
29
 
import select
 
27
import io
30
28
import SimpleHTTPServer
31
29
import socket
32
30
import sys
33
31
import threading
34
32
 
35
 
import bzrlib
36
 
from bzrlib import (
37
 
    bzrdir,
 
33
import breezy
 
34
from .. import (
38
35
    config,
 
36
    controldir,
 
37
    debug,
39
38
    errors,
40
39
    osutils,
41
 
    remote as _mod_remote,
42
40
    tests,
 
41
    trace,
43
42
    transport,
44
43
    ui,
45
44
    urlutils,
46
45
    )
47
 
from bzrlib.symbol_versioning import (
48
 
    deprecated_in,
 
46
from ..bzr import (
 
47
    remote as _mod_remote,
49
48
    )
50
 
from bzrlib.tests import (
 
49
from . import (
51
50
    features,
52
51
    http_server,
53
52
    http_utils,
54
 
    )
55
 
from bzrlib.transport import (
 
53
    test_server,
 
54
    )
 
55
from .scenarios import (
 
56
    load_tests_apply_scenarios,
 
57
    multiply_scenarios,
 
58
    )
 
59
from ..transport import (
56
60
    http,
57
61
    remote,
58
62
    )
59
 
from bzrlib.transport.http import (
 
63
from ..transport.http import (
60
64
    _urllib,
61
65
    _urllib2_wrappers,
62
66
    )
63
67
 
64
68
 
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
 
                )))
 
69
load_tests = load_tests_apply_scenarios
 
70
 
 
71
 
 
72
def vary_by_http_client_implementation():
 
73
    """Test the libraries we can use, currently just urllib."""
80
74
    transport_scenarios = [
81
75
        ('urllib', dict(_transport=_urllib.HttpTransport_urllib,
82
76
                        _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 = [
 
77
                        _url_protocol='http+urllib',)),
 
78
        ]
 
79
    return transport_scenarios
 
80
 
 
81
 
 
82
def vary_by_http_protocol_version():
 
83
    """Test on http/1.0 and 1.1"""
 
84
    return [
 
85
        ('HTTP/1.0',  dict(_protocol_version='HTTP/1.0')),
 
86
        ('HTTP/1.1',  dict(_protocol_version='HTTP/1.1')),
 
87
        ]
 
88
 
 
89
 
 
90
def vary_by_http_auth_scheme():
 
91
    scenarios = [
135
92
        ('basic', dict(_auth_server=http_utils.HTTPBasicAuthServer)),
136
93
        ('digest', dict(_auth_server=http_utils.HTTPDigestAuthServer)),
137
94
        ('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
 
                )))
 
95
            dict(_auth_server=http_utils.HTTPBasicAndDigestAuthServer)),
 
96
        ]
 
97
    # Add some attributes common to all scenarios
 
98
    for scenario_id, scenario_dict in scenarios:
 
99
        scenario_dict.update(_auth_header='Authorization',
 
100
                             _username_prompt_prefix='',
 
101
                             _password_prompt_prefix='')
 
102
    return scenarios
 
103
 
 
104
 
 
105
def vary_by_http_proxy_auth_scheme():
 
106
    scenarios = [
 
107
        ('proxy-basic', dict(_auth_server=http_utils.ProxyBasicAuthServer)),
 
108
        ('proxy-digest', dict(_auth_server=http_utils.ProxyDigestAuthServer)),
 
109
        ('proxy-basicdigest',
 
110
            dict(_auth_server=http_utils.ProxyBasicAndDigestAuthServer)),
 
111
        ]
 
112
    # Add some attributes common to all scenarios
 
113
    for scenario_id, scenario_dict in scenarios:
 
114
        scenario_dict.update(_auth_header='Proxy-Authorization',
 
115
                             _username_prompt_prefix='Proxy ',
 
116
                             _password_prompt_prefix='Proxy ')
 
117
    return scenarios
 
118
 
 
119
 
 
120
def vary_by_http_activity():
149
121
    activity_scenarios = [
150
122
        ('urllib,http', dict(_activity_server=ActivityHTTPServer,
151
 
                             _transport=_urllib.HttpTransport_urllib,)),
 
123
                            _transport=_urllib.HttpTransport_urllib,)),
152
124
        ]
153
 
    if tests.HTTPSServerFeature.available():
 
125
    if features.HTTPSServerFeature.available():
 
126
        # FIXME: Until we have a better way to handle self-signed certificates
 
127
        # (like allowing them in a test specific authentication.conf for
 
128
        # example), we need some specialized urllib transport for tests.
 
129
        # -- vila 2012-01-20
 
130
        from . import (
 
131
            ssl_certs,
 
132
            )
 
133
        class HTTPS_urllib_transport(_urllib.HttpTransport_urllib):
 
134
 
 
135
            def __init__(self, base, _from_transport=None):
 
136
                super(HTTPS_urllib_transport, self).__init__(
 
137
                    base, _from_transport=_from_transport,
 
138
                    ca_certs=ssl_certs.build_path('ca.crt'))
 
139
 
154
140
        activity_scenarios.append(
155
141
            ('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
 
142
                                  _transport=HTTPS_urllib_transport,)),)
 
143
    return activity_scenarios
188
144
 
189
145
 
190
146
class FakeManager(object):
223
179
        self._sock.bind(('127.0.0.1', 0))
224
180
        self.host, self.port = self._sock.getsockname()
225
181
        self._ready = threading.Event()
226
 
        self._thread = threading.Thread(target=self._accept_read_and_reply)
227
 
        self._thread.setDaemon(True)
 
182
        self._thread = test_server.TestThread(
 
183
            sync_event=self._ready, target=self._accept_read_and_reply)
228
184
        self._thread.start()
229
 
        self._ready.wait(5)
 
185
        if 'threads' in tests.selftest_debug_flags:
 
186
            sys.stderr.write('Thread started: %s\n' % (self._thread.ident,))
 
187
        self._ready.wait()
230
188
 
231
189
    def _accept_read_and_reply(self):
232
190
        self._sock.listen(1)
233
191
        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)
 
192
        conn, address = self._sock.accept()
 
193
        if self._expect_body_tail is not None:
240
194
            while not self.received_bytes.endswith(self._expect_body_tail):
241
195
                self.received_bytes += conn.recv(4096)
242
196
            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.
 
197
        try:
245
198
            self._sock.close()
246
199
        except socket.error:
247
200
            # The client may have already closed the socket.
249
202
 
250
203
    def stop_server(self):
251
204
        try:
252
 
            self._sock.close()
 
205
            # Issue a fake connection to wake up the server and allow it to
 
206
            # finish quickly
 
207
            fake_conn = osutils.connect_socket((self.host, self.port))
 
208
            fake_conn.close()
253
209
        except socket.error:
254
210
            # We might have already closed it.  We don't care.
255
211
            pass
256
212
        self.host = None
257
213
        self.port = None
 
214
        self._thread.join()
 
215
        if 'threads' in tests.selftest_debug_flags:
 
216
            sys.stderr.write('Thread  joined: %s\n' % (self._thread.ident,))
258
217
 
259
218
 
260
219
class TestAuthHeader(tests.TestCase):
281
240
        self.assertEqual('basic', scheme)
282
241
        self.assertEqual('realm="Thou should not pass"', remainder)
283
242
 
 
243
    def test_build_basic_header_with_long_creds(self):
 
244
        handler = _urllib2_wrappers.BasicAuthHandler()
 
245
        user = 'user' * 10  # length 40
 
246
        password = 'password' * 5  # length 40
 
247
        header = handler.build_auth_header(
 
248
            dict(user=user, password=password), None)
 
249
        # https://bugs.launchpad.net/bzr/+bug/1606203 was caused by incorrectly
 
250
        # creating a header value with an embedded '\n'
 
251
        self.assertFalse('\n' in header)
 
252
 
284
253
    def test_basic_extract_realm(self):
285
254
        scheme, remainder = self.parse_header(
286
255
            'Basic realm="Thou should not pass"',
296
265
        self.assertEqual('realm="Thou should not pass"', remainder)
297
266
 
298
267
 
 
268
class TestHTTPRangeParsing(tests.TestCase):
 
269
 
 
270
    def setUp(self):
 
271
        super(TestHTTPRangeParsing, self).setUp()
 
272
        # We focus on range  parsing here and ignore everything else
 
273
        class RequestHandler(http_server.TestingHTTPRequestHandler):
 
274
            def setup(self): pass
 
275
            def handle(self): pass
 
276
            def finish(self): pass
 
277
 
 
278
        self.req_handler = RequestHandler(None, None, None)
 
279
 
 
280
    def assertRanges(self, ranges, header, file_size):
 
281
        self.assertEqual(ranges,
 
282
                          self.req_handler._parse_ranges(header, file_size))
 
283
 
 
284
    def test_simple_range(self):
 
285
        self.assertRanges([(0,2)], 'bytes=0-2', 12)
 
286
 
 
287
    def test_tail(self):
 
288
        self.assertRanges([(8, 11)], 'bytes=-4', 12)
 
289
 
 
290
    def test_tail_bigger_than_file(self):
 
291
        self.assertRanges([(0, 11)], 'bytes=-99', 12)
 
292
 
 
293
    def test_range_without_end(self):
 
294
        self.assertRanges([(4, 11)], 'bytes=4-', 12)
 
295
 
 
296
    def test_invalid_ranges(self):
 
297
        self.assertRanges(None, 'bytes=12-22', 12)
 
298
        self.assertRanges(None, 'bytes=1-3,12-22', 12)
 
299
        self.assertRanges(None, 'bytes=-', 12)
 
300
 
 
301
 
299
302
class TestHTTPServer(tests.TestCase):
300
303
    """Test the HTTP servers implementations."""
301
304
 
304
307
 
305
308
            protocol_version = 'HTTP/0.1'
306
309
 
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')
 
310
        self.assertRaises(httplib.UnknownProtocol,
 
311
                          http_server.HttpServer, BogusRequestHandler)
313
312
 
314
313
    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')
 
314
        self.assertRaises(httplib.UnknownProtocol,
 
315
                          http_server.HttpServer, protocol_version='HTTP/0.1')
321
316
 
322
317
    def test_server_start_and_stop(self):
323
318
        server = http_server.HttpServer()
 
319
        self.addCleanup(server.stop_server)
324
320
        server.start_server()
325
 
        try:
326
 
            self.assertTrue(server._http_running)
327
 
        finally:
328
 
            server.stop_server()
329
 
        self.assertFalse(server._http_running)
 
321
        self.assertTrue(server.server is not None)
 
322
        self.assertTrue(server.server.serving is not None)
 
323
        self.assertTrue(server.server.serving)
330
324
 
331
325
    def test_create_http_server_one_zero(self):
332
326
        class RequestHandlerOneZero(http_server.TestingHTTPRequestHandler):
335
329
 
336
330
        server = http_server.HttpServer(RequestHandlerOneZero)
337
331
        self.start_server(server)
338
 
        self.assertIsInstance(server._httpd, http_server.TestingHTTPServer)
 
332
        self.assertIsInstance(server.server, http_server.TestingHTTPServer)
339
333
 
340
334
    def test_create_http_server_one_one(self):
341
335
        class RequestHandlerOneOne(http_server.TestingHTTPRequestHandler):
344
338
 
345
339
        server = http_server.HttpServer(RequestHandlerOneOne)
346
340
        self.start_server(server)
347
 
        self.assertIsInstance(server._httpd,
 
341
        self.assertIsInstance(server.server,
348
342
                              http_server.TestingThreadingHTTPServer)
349
343
 
350
344
    def test_create_http_server_force_one_one(self):
355
349
        server = http_server.HttpServer(RequestHandlerOneZero,
356
350
                                        protocol_version='HTTP/1.1')
357
351
        self.start_server(server)
358
 
        self.assertIsInstance(server._httpd,
 
352
        self.assertIsInstance(server.server,
359
353
                              http_server.TestingThreadingHTTPServer)
360
354
 
361
355
    def test_create_http_server_force_one_zero(self):
366
360
        server = http_server.HttpServer(RequestHandlerOneOne,
367
361
                                        protocol_version='HTTP/1.0')
368
362
        self.start_server(server)
369
 
        self.assertIsInstance(server._httpd,
 
363
        self.assertIsInstance(server.server,
370
364
                              http_server.TestingHTTPServer)
371
365
 
372
366
 
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
367
class TestHttpTransportUrls(tests.TestCase):
402
368
    """Test the http urls."""
403
369
 
 
370
    scenarios = vary_by_http_client_implementation()
 
371
 
404
372
    def test_abs_url(self):
405
373
        """Construction of absolute http URLs"""
406
 
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
 
374
        t = self._transport('http://example.com/bzr/bzr.dev/')
407
375
        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')
 
376
        eq(t.abspath('.'), 'http://example.com/bzr/bzr.dev')
 
377
        eq(t.abspath('foo/bar'), 'http://example.com/bzr/bzr.dev/foo/bar')
 
378
        eq(t.abspath('.bzr'), 'http://example.com/bzr/bzr.dev/.bzr')
411
379
        eq(t.abspath('.bzr/1//2/./3'),
412
 
           'http://bazaar-vcs.org/bzr/bzr.dev/.bzr/1/2/3')
 
380
           'http://example.com/bzr/bzr.dev/.bzr/1/2/3')
413
381
 
414
382
    def test_invalid_http_urls(self):
415
383
        """Trap invalid construction of urls"""
416
 
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
417
 
        self.assertRaises(errors.InvalidURL,
 
384
        self._transport('http://example.com/bzr/bzr.dev/')
 
385
        self.assertRaises(urlutils.InvalidURL,
418
386
                          self._transport,
419
 
                          'http://http://bazaar-vcs.org/bzr/bzr.dev/')
 
387
                          'http://http://example.com/bzr/bzr.dev/')
420
388
 
421
389
    def test_http_root_urls(self):
422
390
        """Construction of URLs from server root"""
423
 
        t = self._transport('http://bzr.ozlabs.org/')
 
391
        t = self._transport('http://example.com/')
424
392
        eq = self.assertEqualDiff
425
393
        eq(t.abspath('.bzr/tree-version'),
426
 
           'http://bzr.ozlabs.org/.bzr/tree-version')
 
394
           'http://example.com/.bzr/tree-version')
427
395
 
428
396
    def test_http_impl_urls(self):
429
397
        """There are servers which ask for particular clients to connect"""
431
399
        server.start_server()
432
400
        try:
433
401
            url = server.get_url()
434
 
            self.assertTrue(url.startswith('%s://' % self._qualified_prefix))
 
402
            self.assertTrue(url.startswith('%s://' % self._url_protocol))
435
403
        finally:
436
404
            server.stop_server()
437
405
 
438
406
 
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
407
class TestHTTPConnections(http_utils.TestCaseWithWebserver):
476
408
    """Test the http connections."""
477
409
 
 
410
    scenarios = multiply_scenarios(
 
411
        vary_by_http_client_implementation(),
 
412
        vary_by_http_protocol_version(),
 
413
        )
 
414
 
478
415
    def setUp(self):
479
 
        http_utils.TestCaseWithWebserver.setUp(self)
 
416
        super(TestHTTPConnections, self).setUp()
480
417
        self.build_tree(['foo/', 'foo/bar'], line_endings='binary',
481
418
                        transport=self.get_transport())
482
419
 
483
420
    def test_http_has(self):
484
421
        server = self.get_readonly_server()
485
 
        t = self._transport(server.get_url())
 
422
        t = self.get_readonly_transport()
486
423
        self.assertEqual(t.has('foo/bar'), True)
487
424
        self.assertEqual(len(server.logs), 1)
488
425
        self.assertContainsRe(server.logs[0],
490
427
 
491
428
    def test_http_has_not_found(self):
492
429
        server = self.get_readonly_server()
493
 
        t = self._transport(server.get_url())
 
430
        t = self.get_readonly_transport()
494
431
        self.assertEqual(t.has('not-found'), False)
495
432
        self.assertContainsRe(server.logs[1],
496
433
            r'"HEAD /not-found HTTP/1.." 404 - "-" "bzr/')
497
434
 
498
435
    def test_http_get(self):
499
436
        server = self.get_readonly_server()
500
 
        t = self._transport(server.get_url())
 
437
        t = self.get_readonly_transport()
501
438
        fp = t.get('foo/bar')
502
439
        self.assertEqualDiff(
503
440
            fp.read(),
505
442
        self.assertEqual(len(server.logs), 1)
506
443
        self.assertTrue(server.logs[0].find(
507
444
            '"GET /foo/bar HTTP/1.1" 200 - "-" "bzr/%s'
508
 
            % bzrlib.__version__) > -1)
 
445
            % breezy.__version__) > -1)
509
446
 
510
447
    def test_has_on_bogus_host(self):
511
448
        # Get a free address and don't 'accept' on it, so that we
525
462
class TestHttpTransportRegistration(tests.TestCase):
526
463
    """Test registrations of various http implementations"""
527
464
 
 
465
    scenarios = vary_by_http_client_implementation()
 
466
 
528
467
    def test_http_registered(self):
529
 
        t = transport.get_transport('%s://foo.com/' % self._qualified_prefix)
 
468
        t = transport.get_transport_from_url(
 
469
            '%s://foo.com/' % self._url_protocol)
530
470
        self.assertIsInstance(t, transport.Transport)
531
471
        self.assertIsInstance(t, self._transport)
532
472
 
533
473
 
534
474
class TestPost(tests.TestCase):
535
475
 
 
476
    scenarios = multiply_scenarios(
 
477
        vary_by_http_client_implementation(),
 
478
        vary_by_http_protocol_version(),
 
479
        )
 
480
 
536
481
    def test_post_body_is_received(self):
537
482
        server = RecordingServer(expect_body_tail='end-of-body',
538
 
            scheme=self._qualified_prefix)
 
483
                                 scheme=self._url_protocol)
539
484
        self.start_server(server)
540
485
        url = server.get_url()
541
 
        http_transport = self._transport(url)
 
486
        # FIXME: needs a cleanup -- vila 20100611
 
487
        http_transport = transport.get_transport_from_url(url)
542
488
        code, response = http_transport._post('abc def end-of-body')
543
489
        self.assertTrue(
544
490
            server.received_bytes.startswith('POST /.bzr/smart HTTP/1.'))
545
491
        self.assertTrue('content-length: 19\r' in server.received_bytes.lower())
 
492
        self.assertTrue('content-type: application/octet-stream\r'
 
493
                        in server.received_bytes.lower())
546
494
        # The transport should not be assuming that the server can accept
547
495
        # chunked encoding the first time it connects, because HTTP/1.1, so we
548
496
        # check for the literal string.
584
532
    Daughter classes are expected to override _req_handler_class
585
533
    """
586
534
 
 
535
    scenarios = multiply_scenarios(
 
536
        vary_by_http_client_implementation(),
 
537
        vary_by_http_protocol_version(),
 
538
        )
 
539
 
587
540
    # Provide a useful default
588
541
    _req_handler_class = http_server.TestingHTTPRequestHandler
589
542
 
590
543
    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)
 
544
        server = http_server.HttpServer(self._req_handler_class,
 
545
                                        protocol_version=self._protocol_version)
 
546
        server._url_protocol = self._url_protocol
 
547
        return server
598
548
 
599
549
 
600
550
class WallRequestHandler(http_server.TestingHTTPRequestHandler):
601
551
    """Whatever request comes in, close the connection"""
602
552
 
603
 
    def handle_one_request(self):
 
553
    def _handle_one_request(self):
604
554
        """Handle a single HTTP request, by abruptly closing the connection"""
605
555
        self.close_connection = 1
606
556
 
611
561
    _req_handler_class = WallRequestHandler
612
562
 
613
563
    def test_http_has(self):
614
 
        server = self.get_readonly_server()
615
 
        t = self._transport(server.get_url())
 
564
        t = self.get_readonly_transport()
616
565
        # Unfortunately httplib (see HTTPResponse._read_status
617
566
        # for details) make no distinction between a closed
618
567
        # socket and badly formatted status line, so we can't
619
568
        # 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),
 
569
        # InvalidHttpResponse too.
 
570
        self.assertRaises((errors.ConnectionError,
 
571
                           errors.InvalidHttpResponse),
624
572
                          t.has, 'foo/bar')
625
573
 
626
574
    def test_http_get(self):
627
 
        server = self.get_readonly_server()
628
 
        t = self._transport(server.get_url())
 
575
        t = self.get_readonly_transport()
629
576
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
630
577
                           errors.InvalidHttpResponse),
631
578
                          t.get, 'foo/bar')
647
594
 
648
595
    _req_handler_class = BadStatusRequestHandler
649
596
 
 
597
    def setUp(self):
 
598
        super(TestBadStatusServer, self).setUp()
 
599
        # See https://bugs.launchpad.net/bzr/+bug/1451448 for details.
 
600
        # TD;LR: Running both a TCP client and server in the same process and
 
601
        # thread uncovers a race in python. The fix is to run the server in a
 
602
        # different process. Trying to fix yet another race here is not worth
 
603
        # the effort. -- vila 2015-09-06
 
604
        if 'HTTP/1.0' in self.id():
 
605
            raise tests.TestSkipped(
 
606
                'Client/Server in the same process and thread can hang')
 
607
 
650
608
    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')
 
609
        t = self.get_readonly_transport()
 
610
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
 
611
                           errors.InvalidHttpResponse),
 
612
                          t.has, 'foo/bar')
654
613
 
655
614
    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')
 
615
        t = self.get_readonly_transport()
 
616
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
 
617
                           errors.InvalidHttpResponse),
 
618
                          t.get, 'foo/bar')
659
619
 
660
620
 
661
621
class InvalidStatusRequestHandler(http_server.TestingHTTPRequestHandler):
665
625
        """Fakes handling a single HTTP request, returns a bad status"""
666
626
        ignored = http_server.TestingHTTPRequestHandler.parse_request(self)
667
627
        self.wfile.write("Invalid status line\r\n")
 
628
        # If we don't close the connection pycurl will hang. Since this is a
 
629
        # stress test we don't *have* to respect the protocol, but we don't
 
630
        # have to sabotage it too much either.
 
631
        self.close_connection = True
668
632
        return False
669
633
 
670
634
 
676
640
 
677
641
    _req_handler_class = InvalidStatusRequestHandler
678
642
 
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
643
 
692
644
class BadProtocolRequestHandler(http_server.TestingHTTPRequestHandler):
693
645
    """Whatever request comes in, returns a bad protocol version"""
708
660
 
709
661
    _req_handler_class = BadProtocolRequestHandler
710
662
 
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
663
    def test_http_has(self):
718
 
        server = self.get_readonly_server()
719
 
        t = self._transport(server.get_url())
 
664
        t = self.get_readonly_transport()
720
665
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
721
666
 
722
667
    def test_http_get(self):
723
 
        server = self.get_readonly_server()
724
 
        t = self._transport(server.get_url())
 
668
        t = self.get_readonly_transport()
725
669
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
726
670
 
727
671
 
741
685
    _req_handler_class = ForbiddenRequestHandler
742
686
 
743
687
    def test_http_has(self):
744
 
        server = self.get_readonly_server()
745
 
        t = self._transport(server.get_url())
 
688
        t = self.get_readonly_transport()
746
689
        self.assertRaises(errors.TransportError, t.has, 'foo/bar')
747
690
 
748
691
    def test_http_get(self):
749
 
        server = self.get_readonly_server()
750
 
        t = self._transport(server.get_url())
 
692
        t = self.get_readonly_transport()
751
693
        self.assertRaises(errors.TransportError, t.get, 'foo/bar')
752
694
 
753
695
 
792
734
        self.build_tree_contents([('a', '0123456789')],)
793
735
 
794
736
    def test_readv(self):
795
 
        server = self.get_readonly_server()
796
 
        t = self._transport(server.get_url())
 
737
        t = self.get_readonly_transport()
797
738
        l = list(t.readv('a', ((0, 1), (1, 1), (3, 2), (9, 1))))
798
739
        self.assertEqual(l[0], (0, '0'))
799
740
        self.assertEqual(l[1], (1, '1'))
801
742
        self.assertEqual(l[3], (9, '9'))
802
743
 
803
744
    def test_readv_out_of_order(self):
804
 
        server = self.get_readonly_server()
805
 
        t = self._transport(server.get_url())
 
745
        t = self.get_readonly_transport()
806
746
        l = list(t.readv('a', ((1, 1), (9, 1), (0, 1), (3, 2))))
807
747
        self.assertEqual(l[0], (1, '1'))
808
748
        self.assertEqual(l[1], (9, '9'))
810
750
        self.assertEqual(l[3], (3, '34'))
811
751
 
812
752
    def test_readv_invalid_ranges(self):
813
 
        server = self.get_readonly_server()
814
 
        t = self._transport(server.get_url())
 
753
        t = self.get_readonly_transport()
815
754
 
816
755
        # This is intentionally reading off the end of the file
817
756
        # since we are sure that it cannot get there
825
764
 
826
765
    def test_readv_multiple_get_requests(self):
827
766
        server = self.get_readonly_server()
828
 
        t = self._transport(server.get_url())
 
767
        t = self.get_readonly_transport()
829
768
        # force transport to issue multiple requests
830
769
        t._max_readv_combine = 1
831
770
        t._max_get_ranges = 1
839
778
 
840
779
    def test_readv_get_max_size(self):
841
780
        server = self.get_readonly_server()
842
 
        t = self._transport(server.get_url())
 
781
        t = self.get_readonly_transport()
843
782
        # force transport to issue multiple requests by limiting the number of
844
783
        # bytes by request. Note that this apply to coalesced offsets only, a
845
784
        # single range will keep its size even if bigger than the limit.
854
793
 
855
794
    def test_complete_readv_leave_pipe_clean(self):
856
795
        server = self.get_readonly_server()
857
 
        t = self._transport(server.get_url())
 
796
        t = self.get_readonly_transport()
858
797
        # force transport to issue multiple requests
859
798
        t._get_max_size = 2
860
 
        l = list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
 
799
        list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
861
800
        # The server should have issued 3 requests
862
801
        self.assertEqual(3, server.GET_request_nb)
863
802
        self.assertEqual('0123456789', t.get_bytes('a'))
865
804
 
866
805
    def test_incomplete_readv_leave_pipe_clean(self):
867
806
        server = self.get_readonly_server()
868
 
        t = self._transport(server.get_url())
 
807
        t = self.get_readonly_transport()
869
808
        # force transport to issue multiple requests
870
809
        t._get_max_size = 2
871
810
        # Don't collapse readv results into a list so that we leave unread
872
811
        # bytes on the socket
873
812
        ireadv = iter(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
874
 
        self.assertEqual((0, '0'), ireadv.next())
 
813
        self.assertEqual((0, '0'), next(ireadv))
875
814
        # The server should have issued one request so far
876
815
        self.assertEqual(1, server.GET_request_nb)
877
816
        self.assertEqual('0123456789', t.get_bytes('a'))
940
879
    def get_multiple_ranges(self, file, file_size, ranges):
941
880
        self.send_response(206)
942
881
        self.send_header('Accept-Ranges', 'bytes')
 
882
        # XXX: this is strange; the 'random' name below seems undefined and
 
883
        # yet the tests pass -- mbp 2010-10-11 bug 658773
943
884
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
944
885
        self.send_header("Content-Type",
945
886
                         "multipart/byteranges; boundary=%s" % boundary)
1007
948
                return
1008
949
            self.send_range_content(file, start, end - start + 1)
1009
950
            cur += 1
1010
 
        # No final boundary
 
951
        # Final boundary
1011
952
        self.wfile.write(boundary_line)
1012
953
 
1013
954
 
1021
962
 
1022
963
    def test_readv_with_short_reads(self):
1023
964
        server = self.get_readonly_server()
1024
 
        t = self._transport(server.get_url())
 
965
        t = self.get_readonly_transport()
1025
966
        # Force separate ranges for each offset
1026
967
        t._bytes_to_read_before_seek = 0
1027
968
        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
 
969
        self.assertEqual((0, '0'), next(ireadv))
 
970
        self.assertEqual((2, '2'), next(ireadv))
 
971
        # Only one request have been issued so far
 
972
        self.assertEqual(1, server.GET_request_nb)
 
973
        self.assertEqual((4, '45'), next(ireadv))
 
974
        self.assertEqual((9, '9'), next(ireadv))
 
975
        # We issue 3 requests: two multiple (4 ranges, then 2 ranges) then a
 
976
        # single range.
1040
977
        self.assertEqual(3, server.GET_request_nb)
1041
978
        # Finally the client have tried a single range request and stays in
1042
979
        # that mode
1043
980
        self.assertEqual('single', t._range_hint)
1044
981
 
 
982
 
 
983
class TruncatedBeforeBoundaryRequestHandler(
 
984
    http_server.TestingHTTPRequestHandler):
 
985
    """Truncation before a boundary, like in bug 198646"""
 
986
 
 
987
    _truncated_ranges = 1
 
988
 
 
989
    def get_multiple_ranges(self, file, file_size, ranges):
 
990
        self.send_response(206)
 
991
        self.send_header('Accept-Ranges', 'bytes')
 
992
        boundary = 'tagada'
 
993
        self.send_header('Content-Type',
 
994
                         'multipart/byteranges; boundary=%s' % boundary)
 
995
        boundary_line = '--%s\r\n' % boundary
 
996
        # Calculate the Content-Length
 
997
        content_length = 0
 
998
        for (start, end) in ranges:
 
999
            content_length += len(boundary_line)
 
1000
            content_length += self._header_line_length(
 
1001
                'Content-type', 'application/octet-stream')
 
1002
            content_length += self._header_line_length(
 
1003
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
 
1004
            content_length += len('\r\n') # end headers
 
1005
            content_length += end - start # + 1
 
1006
        content_length += len(boundary_line)
 
1007
        self.send_header('Content-length', content_length)
 
1008
        self.end_headers()
 
1009
 
 
1010
        # Send the multipart body
 
1011
        cur = 0
 
1012
        for (start, end) in ranges:
 
1013
            if cur + self._truncated_ranges >= len(ranges):
 
1014
                # Abruptly ends the response and close the connection
 
1015
                self.close_connection = 1
 
1016
                return
 
1017
            self.wfile.write(boundary_line)
 
1018
            self.send_header('Content-type', 'application/octet-stream')
 
1019
            self.send_header('Content-Range', 'bytes %d-%d/%d'
 
1020
                             % (start, end, file_size))
 
1021
            self.end_headers()
 
1022
            self.send_range_content(file, start, end - start + 1)
 
1023
            cur += 1
 
1024
        # Final boundary
 
1025
        self.wfile.write(boundary_line)
 
1026
 
 
1027
 
 
1028
class TestTruncatedBeforeBoundary(TestSpecificRequestHandler):
 
1029
    """Tests the case of bug 198646, disconnecting before a boundary."""
 
1030
 
 
1031
    _req_handler_class = TruncatedBeforeBoundaryRequestHandler
 
1032
 
 
1033
    def setUp(self):
 
1034
        super(TestTruncatedBeforeBoundary, self).setUp()
 
1035
        self.build_tree_contents([('a', '0123456789')],)
 
1036
 
 
1037
    def test_readv_with_short_reads(self):
 
1038
        server = self.get_readonly_server()
 
1039
        t = self.get_readonly_transport()
 
1040
        # Force separate ranges for each offset
 
1041
        t._bytes_to_read_before_seek = 0
 
1042
        ireadv = iter(t.readv('a', ((0, 1), (2, 1), (4, 2), (9, 1))))
 
1043
        self.assertEqual((0, '0'), next(ireadv))
 
1044
        self.assertEqual((2, '2'), next(ireadv))
 
1045
        self.assertEqual((4, '45'), next(ireadv))
 
1046
        self.assertEqual((9, '9'), next(ireadv))
 
1047
 
 
1048
 
1045
1049
class LimitedRangeRequestHandler(http_server.TestingHTTPRequestHandler):
1046
1050
    """Errors out when range specifiers exceed the limit"""
1047
1051
 
1071
1075
class TestLimitedRangeRequestServer(http_utils.TestCaseWithWebserver):
1072
1076
    """Tests readv requests against a server erroring out on too much ranges."""
1073
1077
 
 
1078
    scenarios = multiply_scenarios(
 
1079
        vary_by_http_client_implementation(),
 
1080
        vary_by_http_protocol_version(),
 
1081
        )
 
1082
 
1074
1083
    # Requests with more range specifiers will error out
1075
1084
    range_limit = 3
1076
1085
 
1078
1087
        return LimitedRangeHTTPServer(range_limit=self.range_limit,
1079
1088
                                      protocol_version=self._protocol_version)
1080
1089
 
1081
 
    def get_transport(self):
1082
 
        return self._transport(self.get_readonly_server().get_url())
1083
 
 
1084
1090
    def setUp(self):
1085
 
        http_utils.TestCaseWithWebserver.setUp(self)
 
1091
        super(TestLimitedRangeRequestServer, self).setUp()
1086
1092
        # We need to manipulate ranges that correspond to real chunks in the
1087
1093
        # response, so we build a content appropriately.
1088
1094
        filler = ''.join(['abcdefghij' for x in range(102)])
1090
1096
        self.build_tree_contents([('a', content)],)
1091
1097
 
1092
1098
    def test_few_ranges(self):
1093
 
        t = self.get_transport()
 
1099
        t = self.get_readonly_transport()
1094
1100
        l = list(t.readv('a', ((0, 4), (1024, 4), )))
1095
1101
        self.assertEqual(l[0], (0, '0000'))
1096
1102
        self.assertEqual(l[1], (1024, '0001'))
1097
1103
        self.assertEqual(1, self.get_readonly_server().GET_request_nb)
1098
1104
 
1099
1105
    def test_more_ranges(self):
1100
 
        t = self.get_transport()
 
1106
        t = self.get_readonly_transport()
1101
1107
        l = list(t.readv('a', ((0, 4), (1024, 4), (4096, 4), (8192, 4))))
1102
1108
        self.assertEqual(l[0], (0, '0000'))
1103
1109
        self.assertEqual(l[1], (1024, '0001'))
1114
1120
    Only the urllib implementation is tested here.
1115
1121
    """
1116
1122
 
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
1123
    def _proxied_request(self):
1134
1124
        handler = _urllib2_wrappers.ProxyHandler()
1135
 
        request = _urllib2_wrappers.Request('GET','http://baz/buzzle')
 
1125
        request = _urllib2_wrappers.Request('GET', 'http://baz/buzzle')
1136
1126
        handler.set_proxy(request, 'http')
1137
1127
        return request
1138
1128
 
 
1129
    def assertEvaluateProxyBypass(self, expected, host, no_proxy):
 
1130
        handler = _urllib2_wrappers.ProxyHandler()
 
1131
        self.assertEqual(expected,
 
1132
                          handler.evaluate_proxy_bypass(host, no_proxy))
 
1133
 
1139
1134
    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'))
 
1135
        self.overrideEnv('http_proxy', 'http://bar.com')
 
1136
        request = self._proxied_request()
 
1137
        self.assertFalse('Proxy-authorization' in request.headers)
 
1138
 
 
1139
    def test_user_with_at(self):
 
1140
        self.overrideEnv('http_proxy',
 
1141
                         'http://username@domain:password@proxy_host:1234')
 
1142
        request = self._proxied_request()
 
1143
        self.assertFalse('Proxy-authorization' in request.headers)
1143
1144
 
1144
1145
    def test_invalid_proxy(self):
1145
1146
        """A proxy env variable without scheme"""
1146
 
        self._install_env({'http_proxy': 'host:1234'})
1147
 
        self.assertRaises(errors.InvalidURL, self._proxied_request)
 
1147
        self.overrideEnv('http_proxy', 'host:1234')
 
1148
        self.assertRaises(urlutils.InvalidURL, self._proxied_request)
 
1149
 
 
1150
    def test_evaluate_proxy_bypass_true(self):
 
1151
        """The host is not proxied"""
 
1152
        self.assertEvaluateProxyBypass(True, 'example.com', 'example.com')
 
1153
        self.assertEvaluateProxyBypass(True, 'bzr.example.com', '*example.com')
 
1154
 
 
1155
    def test_evaluate_proxy_bypass_false(self):
 
1156
        """The host is proxied"""
 
1157
        self.assertEvaluateProxyBypass(False, 'bzr.example.com', None)
 
1158
 
 
1159
    def test_evaluate_proxy_bypass_unknown(self):
 
1160
        """The host is not explicitly proxied"""
 
1161
        self.assertEvaluateProxyBypass(None, 'example.com', 'not.example.com')
 
1162
        self.assertEvaluateProxyBypass(None, 'bzr.example.com', 'example.com')
 
1163
 
 
1164
    def test_evaluate_proxy_bypass_empty_entries(self):
 
1165
        """Ignore empty entries"""
 
1166
        self.assertEvaluateProxyBypass(None, 'example.com', '')
 
1167
        self.assertEvaluateProxyBypass(None, 'example.com', ',')
 
1168
        self.assertEvaluateProxyBypass(None, 'example.com', 'foo,,bar')
1148
1169
 
1149
1170
 
1150
1171
class TestProxyHttpServer(http_utils.TestCaseWithTwoWebservers):
1156
1177
    to the file names).
1157
1178
    """
1158
1179
 
 
1180
    scenarios = multiply_scenarios(
 
1181
        vary_by_http_client_implementation(),
 
1182
        vary_by_http_protocol_version(),
 
1183
        )
 
1184
 
1159
1185
    # FIXME: We don't have an https server available, so we don't
1160
 
    # test https connections.
 
1186
    # test https connections. --vila toolongago
1161
1187
 
1162
1188
    def setUp(self):
1163
1189
        super(TestProxyHttpServer, self).setUp()
 
1190
        self.transport_secondary_server = http_utils.ProxyServer
1164
1191
        self.build_tree_contents([('foo', 'contents of foo\n'),
1165
1192
                                  ('foo-proxied', 'proxied contents of foo\n')])
1166
1193
        # 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
 
1194
        server = self.get_readonly_server()
 
1195
        self.server_host_port = '%s:%d' % (server.host, server.port)
 
1196
        self.no_proxy_host = self.server_host_port
1175
1197
        # 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()
 
1198
        self.proxy_url = self.get_secondary_url()
 
1199
 
 
1200
    def assertProxied(self):
 
1201
        t = self.get_readonly_transport()
 
1202
        self.assertEqual('proxied contents of foo\n', t.get('foo').read())
 
1203
 
 
1204
    def assertNotProxied(self):
 
1205
        t = self.get_readonly_transport()
 
1206
        self.assertEqual('contents of foo\n', t.get('foo').read())
1216
1207
 
1217
1208
    def test_http_proxy(self):
1218
 
        self.proxied_in_env({'http_proxy': self.proxy_url})
 
1209
        self.overrideEnv('http_proxy', self.proxy_url)
 
1210
        self.assertProxied()
1219
1211
 
1220
1212
    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})
 
1213
        self.overrideEnv('HTTP_PROXY', self.proxy_url)
 
1214
        self.assertProxied()
1228
1215
 
1229
1216
    def test_all_proxy(self):
1230
 
        self.proxied_in_env({'all_proxy': self.proxy_url})
 
1217
        self.overrideEnv('all_proxy', self.proxy_url)
 
1218
        self.assertProxied()
1231
1219
 
1232
1220
    def test_ALL_PROXY(self):
1233
 
        self.proxied_in_env({'ALL_PROXY': self.proxy_url})
 
1221
        self.overrideEnv('ALL_PROXY', self.proxy_url)
 
1222
        self.assertProxied()
1234
1223
 
1235
1224
    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})
 
1225
        self.overrideEnv('no_proxy', self.no_proxy_host)
 
1226
        self.overrideEnv('http_proxy', self.proxy_url)
 
1227
        self.assertNotProxied()
1238
1228
 
1239
1229
    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})
 
1230
        self.overrideEnv('NO_PROXY', self.no_proxy_host)
 
1231
        self.overrideEnv('HTTP_PROXY', self.proxy_url)
 
1232
        self.assertNotProxied()
1245
1233
 
1246
1234
    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})
 
1235
        self.overrideEnv('no_proxy', self.no_proxy_host)
 
1236
        self.overrideEnv('all_proxy', self.proxy_url)
 
1237
        self.assertNotProxied()
1249
1238
 
1250
1239
    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})
 
1240
        self.overrideEnv('NO_PROXY', self.no_proxy_host)
 
1241
        self.overrideEnv('ALL_PROXY', self.proxy_url)
 
1242
        self.assertNotProxied()
1253
1243
 
1254
1244
    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})
 
1245
        self.overrideEnv('http_proxy', self.server_host_port)
 
1246
        self.assertRaises(urlutils.InvalidURL, self.assertProxied)
1264
1247
 
1265
1248
 
1266
1249
class TestRanges(http_utils.TestCaseWithWebserver):
1267
1250
    """Test the Range header in GET methods."""
1268
1251
 
 
1252
    scenarios = multiply_scenarios(
 
1253
        vary_by_http_client_implementation(),
 
1254
        vary_by_http_protocol_version(),
 
1255
        )
 
1256
 
1269
1257
    def setUp(self):
1270
 
        http_utils.TestCaseWithWebserver.setUp(self)
 
1258
        super(TestRanges, self).setUp()
1271
1259
        self.build_tree_contents([('a', '0123456789')],)
1272
 
        server = self.get_readonly_server()
1273
 
        self.transport = self._transport(server.get_url())
1274
1260
 
1275
1261
    def create_transport_readonly_server(self):
1276
1262
        return http_server.HttpServer(protocol_version=self._protocol_version)
1277
1263
 
1278
1264
    def _file_contents(self, relpath, ranges):
 
1265
        t = self.get_readonly_transport()
1279
1266
        offsets = [ (start, end - start + 1) for start, end in ranges]
1280
 
        coalesce = self.transport._coalesce_offsets
 
1267
        coalesce = t._coalesce_offsets
1281
1268
        coalesced = list(coalesce(offsets, limit=0, fudge_factor=0))
1282
 
        code, data = self.transport._get(relpath, coalesced)
 
1269
        code, data = t._get(relpath, coalesced)
1283
1270
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
1284
1271
        for start, end in ranges:
1285
1272
            data.seek(start)
1286
1273
            yield data.read(end - start + 1)
1287
1274
 
1288
1275
    def _file_tail(self, relpath, tail_amount):
1289
 
        code, data = self.transport._get(relpath, [], tail_amount)
 
1276
        t = self.get_readonly_transport()
 
1277
        code, data = t._get(relpath, [], tail_amount)
1290
1278
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
1291
1279
        data.seek(-tail_amount, 2)
1292
1280
        return data.read(tail_amount)
1293
1281
 
1294
1282
    def test_range_header(self):
1295
1283
        # Valid ranges
1296
 
        map(self.assertEqual,['0', '234'],
1297
 
            list(self._file_contents('a', [(0,0), (2,4)])),)
 
1284
        self.assertEqual(
 
1285
            ['0', '234'], list(self._file_contents('a', [(0,0), (2,4)])))
1298
1286
 
1299
1287
    def test_range_header_tail(self):
1300
1288
        self.assertEqual('789', self._file_tail('a', 3))
1311
1299
class TestHTTPRedirections(http_utils.TestCaseWithRedirectedWebserver):
1312
1300
    """Test redirection between http servers."""
1313
1301
 
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
 
1302
    scenarios = multiply_scenarios(
 
1303
        vary_by_http_client_implementation(),
 
1304
        vary_by_http_protocol_version(),
 
1305
        )
1322
1306
 
1323
1307
    def setUp(self):
1324
1308
        super(TestHTTPRedirections, self).setUp()
1326
1310
                                  ('bundle',
1327
1311
                                  '# Bazaar revision bundle v0.9\n#\n')
1328
1312
                                  ],)
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
1313
 
1332
1314
    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)
 
1315
        self.assertRaises(errors.RedirectRequested,
 
1316
                          self.get_old_transport().get, 'a')
 
1317
        self.assertEqual('0123456789', self.get_new_transport().get('a').read())
1344
1318
 
1345
1319
 
1346
1320
class RedirectedRequest(_urllib2_wrappers.Request):
1363
1337
    test.overrideAttr(_urllib2_wrappers, 'Request', RedirectedRequest)
1364
1338
 
1365
1339
 
 
1340
def cleanup_http_redirection_connections(test):
 
1341
    # Some sockets are opened but never seen by _urllib, so we trap them at
 
1342
    # the _urllib2_wrappers level to be able to clean them up.
 
1343
    def socket_disconnect(sock):
 
1344
        try:
 
1345
            sock.shutdown(socket.SHUT_RDWR)
 
1346
            sock.close()
 
1347
        except socket.error:
 
1348
            pass
 
1349
    def connect(connection):
 
1350
        test.http_connect_orig(connection)
 
1351
        test.addCleanup(socket_disconnect, connection.sock)
 
1352
    test.http_connect_orig = test.overrideAttr(
 
1353
        _urllib2_wrappers.HTTPConnection, 'connect', connect)
 
1354
    def connect(connection):
 
1355
        test.https_connect_orig(connection)
 
1356
        test.addCleanup(socket_disconnect, connection.sock)
 
1357
    test.https_connect_orig = test.overrideAttr(
 
1358
        _urllib2_wrappers.HTTPSConnection, 'connect', connect)
 
1359
 
 
1360
 
1366
1361
class TestHTTPSilentRedirections(http_utils.TestCaseWithRedirectedWebserver):
1367
1362
    """Test redirections.
1368
1363
 
1370
1365
    do not redirect at all in fact). The mechanism is still in
1371
1366
    place at the _urllib2_wrappers.Request level and these tests
1372
1367
    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
1368
    """
1379
1369
 
 
1370
    scenarios = multiply_scenarios(
 
1371
        vary_by_http_client_implementation(),
 
1372
        vary_by_http_protocol_version(),
 
1373
        )
 
1374
 
1380
1375
    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
1376
        super(TestHTTPSilentRedirections, self).setUp()
1386
1377
        install_redirected_request(self)
 
1378
        cleanup_http_redirection_connections(self)
1387
1379
        self.build_tree_contents([('a','a'),
1388
1380
                                  ('1/',),
1389
1381
                                  ('1/a', 'redirected once'),
1397
1389
                                  ('5/a', 'redirected 5 times'),
1398
1390
                                  ],)
1399
1391
 
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
1392
    def test_one_redirection(self):
1408
 
        t = self.old_transport
1409
 
 
1410
 
        req = RedirectedRequest('GET', t.abspath('a'))
 
1393
        t = self.get_old_transport()
 
1394
        req = RedirectedRequest('GET', t._remote_path('a'))
1411
1395
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1412
1396
                                       self.new_server.port)
1413
1397
        self.old_server.redirections = \
1414
1398
            [('(.*)', r'%s/1\1' % (new_prefix), 301),]
1415
 
        self.assertEqual('redirected once',t._perform(req).read())
 
1399
        self.assertEqual('redirected once', t._perform(req).read())
1416
1400
 
1417
1401
    def test_five_redirections(self):
1418
 
        t = self.old_transport
1419
 
 
1420
 
        req = RedirectedRequest('GET', t.abspath('a'))
 
1402
        t = self.get_old_transport()
 
1403
        req = RedirectedRequest('GET', t._remote_path('a'))
1421
1404
        old_prefix = 'http://%s:%s' % (self.old_server.host,
1422
1405
                                       self.old_server.port)
1423
1406
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1429
1412
            ('/4(.*)', r'%s/5\1' % (new_prefix), 301),
1430
1413
            ('(/[^/]+)', r'%s/1\1' % (old_prefix), 301),
1431
1414
            ]
1432
 
        self.assertEqual('redirected 5 times',t._perform(req).read())
 
1415
        self.assertEqual('redirected 5 times', t._perform(req).read())
1433
1416
 
1434
1417
 
1435
1418
class TestDoCatchRedirections(http_utils.TestCaseWithRedirectedWebserver):
1436
1419
    """Test transport.do_catching_redirections."""
1437
1420
 
 
1421
    scenarios = multiply_scenarios(
 
1422
        vary_by_http_client_implementation(),
 
1423
        vary_by_http_protocol_version(),
 
1424
        )
 
1425
 
1438
1426
    def setUp(self):
1439
1427
        super(TestDoCatchRedirections, self).setUp()
1440
1428
        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')
 
1429
        cleanup_http_redirection_connections(self)
 
1430
 
 
1431
        self.old_transport = self.get_old_transport()
 
1432
 
 
1433
    def get_a(self, t):
 
1434
        return t.get('a')
1446
1435
 
1447
1436
    def test_no_redirection(self):
1448
 
        t = self._transport(self.new_server.get_url())
 
1437
        t = self.get_new_transport()
1449
1438
 
1450
1439
        # We use None for redirected so that we fail if redirected
1451
1440
        self.assertEqual('0123456789',
1455
1444
    def test_one_redirection(self):
1456
1445
        self.redirections = 0
1457
1446
 
1458
 
        def redirected(transport, exception, redirection_notice):
 
1447
        def redirected(t, exception, redirection_notice):
1459
1448
            self.redirections += 1
1460
 
            dir, file = urlutils.split(exception.target)
1461
 
            return self._transport(dir)
 
1449
            redirected_t = t._redirected_to(exception.source, exception.target)
 
1450
            return redirected_t
1462
1451
 
1463
1452
        self.assertEqual('0123456789',
1464
1453
                         transport.do_catching_redirections(
1478
1467
                          self.get_a, self.old_transport, redirected)
1479
1468
 
1480
1469
 
 
1470
def _setup_authentication_config(**kwargs):
 
1471
    conf = config.AuthenticationConfig()
 
1472
    conf._get_config().update({'httptest': kwargs})
 
1473
    conf._save()
 
1474
 
 
1475
 
 
1476
class TestUrllib2AuthHandler(tests.TestCaseWithTransport):
 
1477
    """Unit tests for glue by which urllib2 asks us for authentication"""
 
1478
 
 
1479
    def test_get_user_password_without_port(self):
 
1480
        """We cope if urllib2 doesn't tell us the port.
 
1481
 
 
1482
        See https://bugs.launchpad.net/bzr/+bug/654684
 
1483
        """
 
1484
        user = 'joe'
 
1485
        password = 'foo'
 
1486
        _setup_authentication_config(scheme='http', host='localhost',
 
1487
                                     user=user, password=password)
 
1488
        handler = _urllib2_wrappers.HTTPAuthHandler()
 
1489
        got_pass = handler.get_user_password(dict(
 
1490
            user='joe',
 
1491
            protocol='http',
 
1492
            host='localhost',
 
1493
            path='/',
 
1494
            realm='Realm',
 
1495
            ))
 
1496
        self.assertEqual((user, password), got_pass)
 
1497
 
 
1498
 
1481
1499
class TestAuth(http_utils.TestCaseWithWebserver):
1482
1500
    """Test authentication scheme"""
1483
1501
 
1484
 
    _auth_header = 'Authorization'
1485
 
    _password_prompt_prefix = ''
1486
 
    _username_prompt_prefix = ''
1487
 
    # Set by load_tests
1488
 
    _auth_server = None
 
1502
    scenarios = multiply_scenarios(
 
1503
        vary_by_http_client_implementation(),
 
1504
        vary_by_http_protocol_version(),
 
1505
        vary_by_http_auth_scheme(),
 
1506
        )
1489
1507
 
1490
1508
    def setUp(self):
1491
1509
        super(TestAuth, self).setUp()
1494
1512
                                  ('b', 'contents of b\n'),])
1495
1513
 
1496
1514
    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)
 
1515
        server = self._auth_server(protocol_version=self._protocol_version)
 
1516
        server._url_protocol = self._url_protocol
 
1517
        return server
1503
1518
 
1504
1519
    def get_user_url(self, user, password):
1505
1520
        """Build an url embedding user and password"""
1513
1528
        return url
1514
1529
 
1515
1530
    def get_user_transport(self, user, password):
1516
 
        return self._transport(self.get_user_url(user, password))
 
1531
        t = transport.get_transport_from_url(
 
1532
            self.get_user_url(user, password))
 
1533
        return t
1517
1534
 
1518
1535
    def test_no_user(self):
1519
1536
        self.server.add_user('joe', 'foo')
1554
1571
        self.assertEqual(2, self.server.auth_required_errors)
1555
1572
 
1556
1573
    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
1574
        self.server.add_user('joe', 'foo')
1563
1575
        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)
 
1576
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n')
 
1577
        stdout, stderr = ui.ui_factory.stdout, ui.ui_factory.stderr
1568
1578
        self.assertEqual('contents of a\n',t.get('a').read())
1569
1579
        # stdin should be empty
1570
1580
        self.assertEqual('', ui.ui_factory.stdin.readline())
1576
1586
                                    stderr.readline())
1577
1587
 
1578
1588
    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
1589
        self.server.add_user('joe', 'foo')
1585
1590
        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)
 
1591
        ui.ui_factory = tests.TestUIFactory(stdin='foo\n')
 
1592
        stdout, stderr = ui.ui_factory.stdout, ui.ui_factory.stderr
1590
1593
        self.assertEqual('contents of a\n', t.get('a').read())
1591
1594
        # stdin should be empty
1592
1595
        self.assertEqual('', ui.ui_factory.stdin.readline())
1617
1620
                                 self.server.auth_realm))
1618
1621
 
1619
1622
    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
1623
        user =' joe'
1626
1624
        password = 'foo'
1627
1625
        stdin_content = 'bar\n'  # Not the right password
1628
1626
        self.server.add_user(user, password)
1629
1627
        t = self.get_user_transport(user, None)
1630
 
        ui.ui_factory = tests.TestUIFactory(stdin=stdin_content,
1631
 
                                            stderr=tests.StringIOWrapper())
 
1628
        ui.ui_factory = tests.TestUIFactory(stdin=stdin_content)
1632
1629
        # 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()
 
1630
        _setup_authentication_config(scheme='http', port=self.server.port,
 
1631
                                     user=user, password=password)
1638
1632
        # Issue a request to the server to connect
1639
1633
        self.assertEqual('contents of a\n',t.get('a').read())
1640
1634
        # stdin should have  been left untouched
1642
1636
        # Only one 'Authentication Required' error should occur
1643
1637
        self.assertEqual(1, self.server.auth_required_errors)
1644
1638
 
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
1639
    def test_changing_nonce(self):
1665
1640
        if self._auth_server not in (http_utils.HTTPDigestAuthServer,
1666
1641
                                     http_utils.ProxyDigestAuthServer):
1667
1642
            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
1643
        self.server.add_user('joe', 'foo')
1672
1644
        t = self.get_user_transport('joe', 'foo')
1673
1645
        self.assertEqual('contents of a\n', t.get('a').read())
1682
1654
        # initial 'who are you' and a second 'who are you' with the new nonce)
1683
1655
        self.assertEqual(2, self.server.auth_required_errors)
1684
1656
 
 
1657
    def test_user_from_auth_conf(self):
 
1658
        user = 'joe'
 
1659
        password = 'foo'
 
1660
        self.server.add_user(user, password)
 
1661
        _setup_authentication_config(scheme='http', port=self.server.port,
 
1662
                                     user=user, password=password)
 
1663
        t = self.get_user_transport(None, None)
 
1664
        # Issue a request to the server to connect
 
1665
        self.assertEqual('contents of a\n', t.get('a').read())
 
1666
        # Only one 'Authentication Required' error should occur
 
1667
        self.assertEqual(1, self.server.auth_required_errors)
 
1668
 
 
1669
    def test_no_credential_leaks_in_log(self):
 
1670
        self.overrideAttr(debug, 'debug_flags', {'http'})
 
1671
        user = 'joe'
 
1672
        password = 'very-sensitive-password'
 
1673
        self.server.add_user(user, password)
 
1674
        t = self.get_user_transport(user, password)
 
1675
        # Capture the debug calls to mutter
 
1676
        self.mutters = []
 
1677
        def mutter(*args):
 
1678
            lines = args[0] % args[1:]
 
1679
            # Some calls output multiple lines, just split them now since we
 
1680
            # care about a single one later.
 
1681
            self.mutters.extend(lines.splitlines())
 
1682
        self.overrideAttr(trace, 'mutter', mutter)
 
1683
        # Issue a request to the server to connect
 
1684
        self.assertEqual(True, t.has('a'))
 
1685
        # Only one 'Authentication Required' error should occur
 
1686
        self.assertEqual(1, self.server.auth_required_errors)
 
1687
        # Since the authentification succeeded, there should be a corresponding
 
1688
        # debug line
 
1689
        sent_auth_headers = [line for line in self.mutters
 
1690
                             if line.startswith('> %s' % (self._auth_header,))]
 
1691
        self.assertLength(1, sent_auth_headers)
 
1692
        self.assertStartsWith(sent_auth_headers[0],
 
1693
                              '> %s: <masked>' % (self._auth_header,))
1685
1694
 
1686
1695
 
1687
1696
class TestProxyAuth(TestAuth):
1688
 
    """Test proxy authentication schemes."""
1689
 
 
1690
 
    _auth_header = 'Proxy-authorization'
1691
 
    _password_prompt_prefix = 'Proxy '
1692
 
    _username_prompt_prefix = 'Proxy '
 
1697
    """Test proxy authentication schemes.
 
1698
 
 
1699
    This inherits from TestAuth to tweak the setUp and filter some failing
 
1700
    tests.
 
1701
    """
 
1702
 
 
1703
    scenarios = multiply_scenarios(
 
1704
        vary_by_http_client_implementation(),
 
1705
        vary_by_http_protocol_version(),
 
1706
        vary_by_http_proxy_auth_scheme(),
 
1707
        )
1693
1708
 
1694
1709
    def setUp(self):
1695
1710
        super(TestProxyAuth, self).setUp()
1696
 
        self._old_env = {}
1697
 
        self.addCleanup(self._restore_env)
1698
1711
        # Override the contents to avoid false positives
1699
1712
        self.build_tree_contents([('a', 'not proxied contents of a\n'),
1700
1713
                                  ('b', 'not proxied contents of b\n'),
1703
1716
                                  ])
1704
1717
 
1705
1718
    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()
 
1719
        proxy_url = self.get_user_url(user, password)
 
1720
        self.overrideEnv('all_proxy', proxy_url)
 
1721
        return TestAuth.get_user_transport(self, user, password)
 
1722
 
 
1723
 
 
1724
class NonClosingBytesIO(io.BytesIO):
 
1725
 
 
1726
    def close(self):
 
1727
        """Ignore and leave file open."""
1724
1728
 
1725
1729
 
1726
1730
class SampleSocket(object):
1731
1735
 
1732
1736
        :param socket_read_content: a byte sequence
1733
1737
        """
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
 
1738
        self.readfile = io.BytesIO(socket_read_content)
 
1739
        self.writefile = NonClosingBytesIO()
 
1740
 
 
1741
    def close(self):
 
1742
        """Ignore and leave files alone."""
1740
1743
 
1741
1744
    def makefile(self, mode='r', bufsize=None):
1742
1745
        if 'r' in mode:
1747
1750
 
1748
1751
class SmartHTTPTunnellingTest(tests.TestCaseWithTransport):
1749
1752
 
 
1753
    scenarios = multiply_scenarios(
 
1754
        vary_by_http_client_implementation(),
 
1755
        vary_by_http_protocol_version(),
 
1756
        )
 
1757
 
1750
1758
    def setUp(self):
1751
1759
        super(SmartHTTPTunnellingTest, self).setUp()
1752
1760
        # We use the VFS layer as part of HTTP tunnelling tests.
1753
 
        self._captureVar('BZR_NO_SMART_VFS', None)
 
1761
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1754
1762
        self.transport_readonly_server = http_utils.HTTPServerWithSmarts
 
1763
        self.http_server = self.get_readonly_server()
1755
1764
 
1756
1765
    def create_transport_readonly_server(self):
1757
 
        return http_utils.HTTPServerWithSmarts(
 
1766
        server = http_utils.HTTPServerWithSmarts(
1758
1767
            protocol_version=self._protocol_version)
 
1768
        server._url_protocol = self._url_protocol
 
1769
        return server
1759
1770
 
1760
 
    def test_open_bzrdir(self):
 
1771
    def test_open_controldir(self):
1761
1772
        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)
 
1773
        url = self.http_server.get_url() + 'relpath'
 
1774
        bd = controldir.ControlDir.open(url)
 
1775
        self.addCleanup(bd.transport.disconnect)
1765
1776
        self.assertIsInstance(bd, _mod_remote.RemoteBzrDir)
1766
1777
 
1767
1778
    def test_bulk_data(self):
1769
1780
        # The 'readv' command in the smart protocol both sends and receives
1770
1781
        # bulk data, so we use that.
1771
1782
        self.build_tree(['data-file'])
1772
 
        http_server = self.get_readonly_server()
1773
 
        http_transport = self._transport(http_server.get_url())
 
1783
        http_transport = transport.get_transport_from_url(
 
1784
            self.http_server.get_url())
1774
1785
        medium = http_transport.get_smart_medium()
1775
1786
        # Since we provide the medium, the url below will be mostly ignored
1776
1787
        # during the test, as long as the path is '/'.
1784
1795
        post_body = 'hello\n'
1785
1796
        expected_reply_body = 'ok\x012\n'
1786
1797
 
1787
 
        http_server = self.get_readonly_server()
1788
 
        http_transport = self._transport(http_server.get_url())
 
1798
        http_transport = transport.get_transport_from_url(
 
1799
            self.http_server.get_url())
1789
1800
        medium = http_transport.get_smart_medium()
1790
1801
        response = medium.send_http_smart_request(post_body)
1791
1802
        reply_body = response.read()
1792
1803
        self.assertEqual(expected_reply_body, reply_body)
1793
1804
 
1794
1805
    def test_smart_http_server_post_request_handler(self):
1795
 
        httpd = self.get_readonly_server()._get_httpd()
 
1806
        httpd = self.http_server.server
1796
1807
 
1797
1808
        socket = SampleSocket(
1798
1809
            'POST /.bzr/smart %s \r\n' % self._protocol_version
1830
1841
 
1831
1842
    def test_probe_smart_server(self):
1832
1843
        """Test error handling against server refusing smart requests."""
1833
 
        server = self.get_readonly_server()
1834
 
        t = self._transport(server.get_url())
 
1844
        t = self.get_readonly_transport()
1835
1845
        # No need to build a valid smart request here, the server will not even
1836
1846
        # try to interpret it.
1837
1847
        self.assertRaises(errors.SmartProtocolError,
1838
1848
                          t.get_smart_medium().send_http_smart_request,
1839
1849
                          'whatever')
1840
1850
 
 
1851
 
1841
1852
class Test_redirected_to(tests.TestCase):
1842
1853
 
 
1854
    scenarios = vary_by_http_client_implementation()
 
1855
 
1843
1856
    def test_redirected_to_subdir(self):
1844
1857
        t = self._transport('http://www.example.com/foo')
1845
1858
        r = t._redirected_to('http://www.example.com/foo',
1847
1860
        self.assertIsInstance(r, type(t))
1848
1861
        # Both transports share the some connection
1849
1862
        self.assertEqual(t._get_connection(), r._get_connection())
 
1863
        self.assertEqual('http://www.example.com/foo/subdir/', r.base)
1850
1864
 
1851
1865
    def test_redirected_to_self_with_slash(self):
1852
1866
        t = self._transport('http://www.example.com/foo')
1863
1877
        r = t._redirected_to('http://www.example.com/foo',
1864
1878
                             'http://foo.example.com/foo/subdir')
1865
1879
        self.assertIsInstance(r, type(t))
 
1880
        self.assertEqual('http://foo.example.com/foo/subdir/',
 
1881
            r.external_url())
1866
1882
 
1867
1883
    def test_redirected_to_same_host_sibling_protocol(self):
1868
1884
        t = self._transport('http://www.example.com/foo')
1869
1885
        r = t._redirected_to('http://www.example.com/foo',
1870
1886
                             'https://www.example.com/foo')
1871
1887
        self.assertIsInstance(r, type(t))
 
1888
        self.assertEqual('https://www.example.com/foo/',
 
1889
            r.external_url())
1872
1890
 
1873
1891
    def test_redirected_to_same_host_different_protocol(self):
1874
1892
        t = self._transport('http://www.example.com/foo')
1875
1893
        r = t._redirected_to('http://www.example.com/foo',
1876
1894
                             'ftp://www.example.com/foo')
1877
 
        self.assertNotEquals(type(r), type(t))
 
1895
        self.assertNotEqual(type(r), type(t))
 
1896
        self.assertEqual('ftp://www.example.com/foo/', r.external_url())
 
1897
 
 
1898
    def test_redirected_to_same_host_specific_implementation(self):
 
1899
        t = self._transport('http://www.example.com/foo')
 
1900
        r = t._redirected_to('http://www.example.com/foo',
 
1901
                             'https+urllib://www.example.com/foo')
 
1902
        self.assertEqual('https://www.example.com/foo/', r.external_url())
1878
1903
 
1879
1904
    def test_redirected_to_different_host_same_user(self):
1880
1905
        t = self._transport('http://joe@www.example.com/foo')
1881
1906
        r = t._redirected_to('http://www.example.com/foo',
1882
1907
                             'https://foo.example.com/foo')
1883
1908
        self.assertIsInstance(r, type(t))
1884
 
        self.assertEqual(t._user, r._user)
 
1909
        self.assertEqual(t._parsed_url.user, r._parsed_url.user)
 
1910
        self.assertEqual('https://joe@foo.example.com/foo/', r.external_url())
1885
1911
 
1886
1912
 
1887
1913
class PredefinedRequestHandler(http_server.TestingHTTPRequestHandler):
1896
1922
    line.
1897
1923
    """
1898
1924
 
1899
 
    def handle_one_request(self):
 
1925
    def _handle_one_request(self):
1900
1926
        tcs = self.server.test_case_server
1901
1927
        requestline = self.rfile.readline()
1902
1928
        headers = self.MessageClass(self.rfile, 0)
1940
1966
    pass
1941
1967
 
1942
1968
 
1943
 
if tests.HTTPSServerFeature.available():
1944
 
    from bzrlib.tests import https_server
 
1969
if features.HTTPSServerFeature.available():
 
1970
    from . import https_server
1945
1971
    class ActivityHTTPSServer(ActivityServerMixin, https_server.HTTPSServer):
1946
1972
        pass
1947
1973
 
1954
1980
    """
1955
1981
 
1956
1982
    def setUp(self):
1957
 
        tests.TestCase.setUp(self)
1958
1983
        self.server = self._activity_server(self._protocol_version)
1959
1984
        self.server.start_server()
1960
 
        self.activities = {}
 
1985
        self.addCleanup(self.server.stop_server)
 
1986
        _activities = {} # Don't close over self and create a cycle
1961
1987
        def report_activity(t, bytes, direction):
1962
 
            count = self.activities.get(direction, 0)
 
1988
            count = _activities.get(direction, 0)
1963
1989
            count += bytes
1964
 
            self.activities[direction] = count
1965
 
 
 
1990
            _activities[direction] = count
 
1991
        self.activities = _activities
1966
1992
        # We override at class level because constructors may propagate the
1967
1993
        # bound method and render instance overriding ineffective (an
1968
1994
        # 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)
 
1995
        self.overrideAttr(self._transport, '_report_activity', report_activity)
1976
1996
 
1977
1997
    def get_transport(self):
1978
 
        return self._transport(self.server.get_url())
 
1998
        t = self._transport(self.server.get_url())
 
1999
        # FIXME: Needs cleanup -- vila 20100611
 
2000
        return t
1979
2001
 
1980
2002
    def assertActivitiesMatch(self):
1981
2003
        self.assertEqual(self.server.bytes_read,
2086
2108
'''
2087
2109
        t = self.get_transport()
2088
2110
        # We must send a single line of body bytes, see
2089
 
        # PredefinedRequestHandler.handle_one_request
 
2111
        # PredefinedRequestHandler._handle_one_request
2090
2112
        code, f = t._post('abc def end-of-body\n')
2091
2113
        self.assertEqual('lalala whatever as long as itsssss\n', f.read())
2092
2114
        self.assertActivitiesMatch()
2094
2116
 
2095
2117
class TestActivity(tests.TestCase, TestActivityMixin):
2096
2118
 
 
2119
    scenarios = multiply_scenarios(
 
2120
        vary_by_http_activity(),
 
2121
        vary_by_http_protocol_version(),
 
2122
        )
 
2123
 
2097
2124
    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)
 
2125
        super(TestActivity, self).setUp()
 
2126
        TestActivityMixin.setUp(self)
2117
2127
 
2118
2128
 
2119
2129
class TestNoReportActivity(tests.TestCase, TestActivityMixin):
2120
2130
 
 
2131
    # Unlike TestActivity, we are really testing ReportingFileSocket and
 
2132
    # ReportingSocket, so we don't need all the parametrization. Since
 
2133
    # ReportingFileSocket and ReportingSocket are wrappers, it's easier to
 
2134
    # test them through their use by the transport than directly (that's a
 
2135
    # bit less clean but far more simpler and effective).
 
2136
    _activity_server = ActivityHTTPServer
 
2137
    _protocol_version = 'HTTP/1.1'
 
2138
 
2121
2139
    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)
 
2140
        super(TestNoReportActivity, self).setUp()
 
2141
        self._transport =_urllib.HttpTransport_urllib
 
2142
        TestActivityMixin.setUp(self)
2143
2143
 
2144
2144
    def assertActivitiesMatch(self):
2145
2145
        # Nothing to check here
2149
2149
class TestAuthOnRedirected(http_utils.TestCaseWithRedirectedWebserver):
2150
2150
    """Test authentication on the redirected http server."""
2151
2151
 
 
2152
    scenarios = vary_by_http_protocol_version()
 
2153
 
2152
2154
    _auth_header = 'Authorization'
2153
2155
    _password_prompt_prefix = ''
2154
2156
    _username_prompt_prefix = ''
2155
2157
    _auth_server = http_utils.HTTPBasicAuthServer
2156
2158
    _transport = _urllib.HttpTransport_urllib
2157
2159
 
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
2168
 
 
2169
2160
    def setUp(self):
2170
2161
        super(TestAuthOnRedirected, self).setUp()
2171
2162
        self.build_tree_contents([('a','a'),
2176
2167
                                       self.new_server.port)
2177
2168
        self.old_server.redirections = [
2178
2169
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2179
 
        self.old_transport = self._transport(self.old_server.get_url())
 
2170
        self.old_transport = self.get_old_transport()
2180
2171
        self.new_server.add_user('joe', 'foo')
2181
 
 
2182
 
    def get_a(self, transport):
2183
 
        return transport.get('a')
 
2172
        cleanup_http_redirection_connections(self)
 
2173
 
 
2174
    def create_transport_readonly_server(self):
 
2175
        server = self._auth_server(protocol_version=self._protocol_version)
 
2176
        server._url_protocol = self._url_protocol
 
2177
        return server
 
2178
 
 
2179
    def get_a(self, t):
 
2180
        return t.get('a')
2184
2181
 
2185
2182
    def test_auth_on_redirected_via_do_catching_redirections(self):
2186
2183
        self.redirections = 0
2187
2184
 
2188
 
        def redirected(transport, exception, redirection_notice):
 
2185
        def redirected(t, exception, redirection_notice):
2189
2186
            self.redirections += 1
2190
 
            dir, file = urlutils.split(exception.target)
2191
 
            return self._transport(dir)
 
2187
            redirected_t = t._redirected_to(exception.source, exception.target)
 
2188
            self.addCleanup(redirected_t.disconnect)
 
2189
            return redirected_t
2192
2190
 
2193
 
        stdout = tests.StringIOWrapper()
2194
 
        stderr = tests.StringIOWrapper()
2195
 
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n',
2196
 
                                            stdout=stdout, stderr=stderr)
 
2191
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n')
2197
2192
        self.assertEqual('redirected once',
2198
2193
                         transport.do_catching_redirections(
2199
2194
                self.get_a, self.old_transport, redirected).read())
2201
2196
        # stdin should be empty
2202
2197
        self.assertEqual('', ui.ui_factory.stdin.readline())
2203
2198
        # stdout should be empty, stderr will contains the prompts
2204
 
        self.assertEqual('', stdout.getvalue())
 
2199
        self.assertEqual('', ui.ui_factory.stdout.getvalue())
2205
2200
 
2206
2201
    def test_auth_on_redirected_via_following_redirections(self):
2207
2202
        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)
 
2203
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n')
2212
2204
        t = self.old_transport
2213
2205
        req = RedirectedRequest('GET', t.abspath('a'))
2214
2206
        new_prefix = 'http://%s:%s' % (self.new_server.host,
2215
2207
                                       self.new_server.port)
2216
2208
        self.old_server.redirections = [
2217
2209
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2218
 
        self.assertEqual('redirected once',t._perform(req).read())
 
2210
        self.assertEqual('redirected once', t._perform(req).read())
2219
2211
        # stdin should be empty
2220
2212
        self.assertEqual('', ui.ui_factory.stdin.readline())
2221
2213
        # stdout should be empty, stderr will contains the prompts
2222
 
        self.assertEqual('', stdout.getvalue())
2223
 
 
 
2214
        self.assertEqual('', ui.ui_factory.stdout.getvalue())
2224
2215