/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-06-10 21:59:15 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170610215915-zcpu0in3r1irx3ml
Move serializer to bzr.

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