/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-07-10 20:12:25 UTC
  • mto: This revision was merged to the branch mainline in revision 6733.
  • Revision ID: jelmer@jelmer.uk-20170710201225-49fe7zy6plr03ep0
Move bugtracker errors to breezy.bugtracker.

Show diffs side-by-side

added added

removed removed

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