← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_http.py

  • Committer: Andrew Bennetts
  • Date: 2010-10-13 00:26:41 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101013002641-9tlh9k89mlj1666m
Keep docs-plain working.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_http.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
23
23
# TODO: Should be renamed to bzrlib.transport.http.tests?
24
24
# TODO: What about renaming to bzrlib.tests.transport.http ?
25
25
 
 
26
from cStringIO import StringIO
26
27
import httplib
 
28
import os
 
29
import select
27
30
import SimpleHTTPServer
28
31
import socket
29
32
import sys
32
35
import bzrlib
33
36
from bzrlib import (
34
37
    bzrdir,
35
 
    cethread,
36
38
    config,
37
 
    debug,
38
39
    errors,
39
40
    osutils,
40
41
    remote as _mod_remote,
41
42
    tests,
42
 
    trace,
43
43
    transport,
44
44
    ui,
 
45
    urlutils,
45
46
    )
46
47
from bzrlib.tests import (
47
48
    features,
49
50
    http_utils,
50
51
    test_server,
51
52
    )
52
 
from bzrlib.tests.scenarios import (
53
 
    load_tests_apply_scenarios,
54
 
    multiply_scenarios,
55
 
    )
56
53
from bzrlib.transport import (
57
54
    http,
58
55
    remote,
67
64
    from bzrlib.transport.http._pycurl import PyCurlTransport
68
65
 
69
66
 
70
 
load_tests = load_tests_apply_scenarios
71
 
 
72
 
 
73
 
def vary_by_http_client_implementation():
74
 
    """Test the two libraries we can use, pycurl and urllib."""
 
67
def load_tests(standard_tests, module, loader):
 
68
    """Multiply tests for http clients and protocol versions."""
 
69
    result = loader.suiteClass()
 
70
 
 
71
    # one for each transport implementation
 
72
    t_tests, remaining_tests = tests.split_suite_by_condition(
 
73
        standard_tests, tests.condition_isinstance((
 
74
                TestHttpTransportRegistration,
 
75
                TestHttpTransportUrls,
 
76
                Test_redirected_to,
 
77
                )))
75
78
    transport_scenarios = [
76
79
        ('urllib', dict(_transport=_urllib.HttpTransport_urllib,
77
80
                        _server=http_server.HttpServer_urllib,
82
85
            ('pycurl', dict(_transport=PyCurlTransport,
83
86
                            _server=http_server.HttpServer_PyCurl,
84
87
                            _url_protocol='http+pycurl',)))
85
 
    return transport_scenarios
86
 
 
87
 
 
88
 
def vary_by_http_protocol_version():
89
 
    """Test on http/1.0 and 1.1"""
90
 
    return [
91
 
        ('HTTP/1.0',  dict(_protocol_version='HTTP/1.0')),
92
 
        ('HTTP/1.1',  dict(_protocol_version='HTTP/1.1')),
 
88
    tests.multiply_tests(t_tests, transport_scenarios, result)
 
89
 
 
90
    protocol_scenarios = [
 
91
            ('HTTP/1.0',  dict(_protocol_version='HTTP/1.0')),
 
92
            ('HTTP/1.1',  dict(_protocol_version='HTTP/1.1')),
 
93
            ]
 
94
 
 
95
    # some tests are parametrized by the protocol version only
 
96
    p_tests, remaining_tests = tests.split_suite_by_condition(
 
97
        remaining_tests, tests.condition_isinstance((
 
98
                TestAuthOnRedirected,
 
99
                )))
 
100
    tests.multiply_tests(p_tests, protocol_scenarios, result)
 
101
 
 
102
    # each implementation tested with each HTTP version
 
103
    tp_tests, remaining_tests = tests.split_suite_by_condition(
 
104
        remaining_tests, tests.condition_isinstance((
 
105
                SmartHTTPTunnellingTest,
 
106
                TestDoCatchRedirections,
 
107
                TestHTTPConnections,
 
108
                TestHTTPRedirections,
 
109
                TestHTTPSilentRedirections,
 
110
                TestLimitedRangeRequestServer,
 
111
                TestPost,
 
112
                TestProxyHttpServer,
 
113
                TestRanges,
 
114
                TestSpecificRequestHandler,
 
115
                )))
 
116
    tp_scenarios = tests.multiply_scenarios(transport_scenarios,
 
117
                                            protocol_scenarios)
 
118
    tests.multiply_tests(tp_tests, tp_scenarios, result)
 
119
 
 
120
    # proxy auth: each auth scheme on all http versions on all implementations.
 
121
    tppa_tests, remaining_tests = tests.split_suite_by_condition(
 
122
        remaining_tests, tests.condition_isinstance((
 
123
                TestProxyAuth,
 
124
                )))
 
125
    proxy_auth_scheme_scenarios = [
 
126
        ('basic', dict(_auth_server=http_utils.ProxyBasicAuthServer)),
 
127
        ('digest', dict(_auth_server=http_utils.ProxyDigestAuthServer)),
 
128
        ('basicdigest',
 
129
         dict(_auth_server=http_utils.ProxyBasicAndDigestAuthServer)),
93
130
        ]
94
 
 
95
 
 
96
 
def vary_by_http_auth_scheme():
97
 
    scenarios = [
 
131
    tppa_scenarios = tests.multiply_scenarios(tp_scenarios,
 
132
                                              proxy_auth_scheme_scenarios)
 
133
    tests.multiply_tests(tppa_tests, tppa_scenarios, result)
 
134
 
 
135
    # auth: each auth scheme on all http versions on all implementations.
 
136
    tpa_tests, remaining_tests = tests.split_suite_by_condition(
 
137
        remaining_tests, tests.condition_isinstance((
 
138
                TestAuth,
 
139
                )))
 
140
    auth_scheme_scenarios = [
98
141
        ('basic', dict(_auth_server=http_utils.HTTPBasicAuthServer)),
99
142
        ('digest', dict(_auth_server=http_utils.HTTPDigestAuthServer)),
100
143
        ('basicdigest',
101
 
            dict(_auth_server=http_utils.HTTPBasicAndDigestAuthServer)),
102
 
        ]
103
 
    # Add some attributes common to all scenarios
104
 
    for scenario_id, scenario_dict in scenarios:
105
 
        scenario_dict.update(_auth_header='Authorization',
106
 
                             _username_prompt_prefix='',
107
 
                             _password_prompt_prefix='')
108
 
    return scenarios
109
 
 
110
 
 
111
 
def vary_by_http_proxy_auth_scheme():
112
 
    scenarios = [
113
 
        ('proxy-basic', dict(_auth_server=http_utils.ProxyBasicAuthServer)),
114
 
        ('proxy-digest', dict(_auth_server=http_utils.ProxyDigestAuthServer)),
115
 
        ('proxy-basicdigest',
116
 
            dict(_auth_server=http_utils.ProxyBasicAndDigestAuthServer)),
117
 
        ]
118
 
    # Add some attributes common to all scenarios
119
 
    for scenario_id, scenario_dict in scenarios:
120
 
        scenario_dict.update(_auth_header='Proxy-Authorization',
121
 
                             _username_prompt_prefix='Proxy ',
122
 
                             _password_prompt_prefix='Proxy ')
123
 
    return scenarios
124
 
 
125
 
 
126
 
def vary_by_http_activity():
 
144
         dict(_auth_server=http_utils.HTTPBasicAndDigestAuthServer)),
 
145
        ]
 
146
    tpa_scenarios = tests.multiply_scenarios(tp_scenarios,
 
147
                                             auth_scheme_scenarios)
 
148
    tests.multiply_tests(tpa_tests, tpa_scenarios, result)
 
149
 
 
150
    # activity: on all http[s] versions on all implementations
 
151
    tpact_tests, remaining_tests = tests.split_suite_by_condition(
 
152
        remaining_tests, tests.condition_isinstance((
 
153
                TestActivity,
 
154
                )))
127
155
    activity_scenarios = [
128
156
        ('urllib,http', dict(_activity_server=ActivityHTTPServer,
129
 
                            _transport=_urllib.HttpTransport_urllib,)),
 
157
                             _transport=_urllib.HttpTransport_urllib,)),
130
158
        ]
131
159
    if tests.HTTPSServerFeature.available():
132
160
        activity_scenarios.append(
133
161
            ('urllib,https', dict(_activity_server=ActivityHTTPSServer,
134
 
                                _transport=_urllib.HttpTransport_urllib,)),)
 
162
                                  _transport=_urllib.HttpTransport_urllib,)),)
135
163
    if features.pycurl.available():
136
164
        activity_scenarios.append(
137
165
            ('pycurl,http', dict(_activity_server=ActivityHTTPServer,
138
 
                                _transport=PyCurlTransport,)),)
 
166
                                 _transport=PyCurlTransport,)),)
139
167
        if tests.HTTPSServerFeature.available():
140
168
            from bzrlib.tests import (
141
169
                ssl_certs,
153
181
 
154
182
            activity_scenarios.append(
155
183
                ('pycurl,https', dict(_activity_server=ActivityHTTPSServer,
156
 
                                    _transport=HTTPS_pycurl_transport,)),)
157
 
    return activity_scenarios
 
184
                                      _transport=HTTPS_pycurl_transport,)),)
 
185
 
 
186
    tpact_scenarios = tests.multiply_scenarios(activity_scenarios,
 
187
                                               protocol_scenarios)
 
188
    tests.multiply_tests(tpact_tests, tpact_scenarios, result)
 
189
 
 
190
    # No parametrization for the remaining tests
 
191
    result.addTests(remaining_tests)
 
192
 
 
193
    return result
158
194
 
159
195
 
160
196
class FakeManager(object):
193
229
        self._sock.bind(('127.0.0.1', 0))
194
230
        self.host, self.port = self._sock.getsockname()
195
231
        self._ready = threading.Event()
196
 
        self._thread = test_server.TestThread(
197
 
            sync_event=self._ready, target=self._accept_read_and_reply)
 
232
        self._thread = test_server.ThreadWithException(
 
233
            event=self._ready, target=self._accept_read_and_reply)
198
234
        self._thread.start()
199
235
        if 'threads' in tests.selftest_debug_flags:
200
236
            sys.stderr.write('Thread started: %s\n' % (self._thread.ident,))
269
305
        self.assertEqual('realm="Thou should not pass"', remainder)
270
306
 
271
307
 
272
 
class TestHTTPRangeParsing(tests.TestCase):
273
 
 
274
 
    def setUp(self):
275
 
        super(TestHTTPRangeParsing, self).setUp()
276
 
        # We focus on range  parsing here and ignore everything else
277
 
        class RequestHandler(http_server.TestingHTTPRequestHandler):
278
 
            def setup(self): pass
279
 
            def handle(self): pass
280
 
            def finish(self): pass
281
 
 
282
 
        self.req_handler = RequestHandler(None, None, None)
283
 
 
284
 
    def assertRanges(self, ranges, header, file_size):
285
 
        self.assertEquals(ranges,
286
 
                          self.req_handler._parse_ranges(header, file_size))
287
 
 
288
 
    def test_simple_range(self):
289
 
        self.assertRanges([(0,2)], 'bytes=0-2', 12)
290
 
 
291
 
    def test_tail(self):
292
 
        self.assertRanges([(8, 11)], 'bytes=-4', 12)
293
 
 
294
 
    def test_tail_bigger_than_file(self):
295
 
        self.assertRanges([(0, 11)], 'bytes=-99', 12)
296
 
 
297
 
    def test_range_without_end(self):
298
 
        self.assertRanges([(4, 11)], 'bytes=4-', 12)
299
 
 
300
 
    def test_invalid_ranges(self):
301
 
        self.assertRanges(None, 'bytes=12-22', 12)
302
 
        self.assertRanges(None, 'bytes=1-3,12-22', 12)
303
 
        self.assertRanges(None, 'bytes=-', 12)
304
 
 
305
 
 
306
308
class TestHTTPServer(tests.TestCase):
307
309
    """Test the HTTP servers implementations."""
308
310
 
399
401
class TestHttpTransportUrls(tests.TestCase):
400
402
    """Test the http urls."""
401
403
 
402
 
    scenarios = vary_by_http_client_implementation()
403
 
 
404
404
    def test_abs_url(self):
405
405
        """Construction of absolute http URLs"""
406
 
        t = self._transport('http://example.com/bzr/bzr.dev/')
 
406
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
407
407
        eq = self.assertEqualDiff
408
 
        eq(t.abspath('.'), 'http://example.com/bzr/bzr.dev')
409
 
        eq(t.abspath('foo/bar'), 'http://example.com/bzr/bzr.dev/foo/bar')
410
 
        eq(t.abspath('.bzr'), 'http://example.com/bzr/bzr.dev/.bzr')
 
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')
411
411
        eq(t.abspath('.bzr/1//2/./3'),
412
 
           'http://example.com/bzr/bzr.dev/.bzr/1/2/3')
 
412
           'http://bazaar-vcs.org/bzr/bzr.dev/.bzr/1/2/3')
413
413
 
414
414
    def test_invalid_http_urls(self):
415
415
        """Trap invalid construction of urls"""
416
 
        self._transport('http://example.com/bzr/bzr.dev/')
 
416
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
417
417
        self.assertRaises(errors.InvalidURL,
418
418
                          self._transport,
419
 
                          'http://http://example.com/bzr/bzr.dev/')
 
419
                          'http://http://bazaar-vcs.org/bzr/bzr.dev/')
420
420
 
421
421
    def test_http_root_urls(self):
422
422
        """Construction of URLs from server root"""
423
 
        t = self._transport('http://example.com/')
 
423
        t = self._transport('http://bzr.ozlabs.org/')
424
424
        eq = self.assertEqualDiff
425
425
        eq(t.abspath('.bzr/tree-version'),
426
 
           'http://example.com/.bzr/tree-version')
 
426
           'http://bzr.ozlabs.org/.bzr/tree-version')
427
427
 
428
428
    def test_http_impl_urls(self):
429
429
        """There are servers which ask for particular clients to connect"""
475
475
class TestHTTPConnections(http_utils.TestCaseWithWebserver):
476
476
    """Test the http connections."""
477
477
 
478
 
    scenarios = multiply_scenarios(
479
 
        vary_by_http_client_implementation(),
480
 
        vary_by_http_protocol_version(),
481
 
        )
482
 
 
483
478
    def setUp(self):
484
479
        http_utils.TestCaseWithWebserver.setUp(self)
485
480
        self.build_tree(['foo/', 'foo/bar'], line_endings='binary',
530
525
class TestHttpTransportRegistration(tests.TestCase):
531
526
    """Test registrations of various http implementations"""
532
527
 
533
 
    scenarios = vary_by_http_client_implementation()
534
 
 
535
528
    def test_http_registered(self):
536
529
        t = transport.get_transport('%s://foo.com/' % self._url_protocol)
537
530
        self.assertIsInstance(t, transport.Transport)
540
533
 
541
534
class TestPost(tests.TestCase):
542
535
 
543
 
    scenarios = multiply_scenarios(
544
 
        vary_by_http_client_implementation(),
545
 
        vary_by_http_protocol_version(),
546
 
        )
547
 
 
548
536
    def test_post_body_is_received(self):
549
537
        server = RecordingServer(expect_body_tail='end-of-body',
550
538
                                 scheme=self._url_protocol)
556
544
        self.assertTrue(
557
545
            server.received_bytes.startswith('POST /.bzr/smart HTTP/1.'))
558
546
        self.assertTrue('content-length: 19\r' in server.received_bytes.lower())
559
 
        self.assertTrue('content-type: application/octet-stream\r'
560
 
                        in server.received_bytes.lower())
561
547
        # The transport should not be assuming that the server can accept
562
548
        # chunked encoding the first time it connects, because HTTP/1.1, so we
563
549
        # check for the literal string.
599
585
    Daughter classes are expected to override _req_handler_class
600
586
    """
601
587
 
602
 
    scenarios = multiply_scenarios(
603
 
        vary_by_http_client_implementation(),
604
 
        vary_by_http_protocol_version(),
605
 
        )
606
 
 
607
588
    # Provide a useful default
608
589
    _req_handler_class = http_server.TestingHTTPRequestHandler
609
590
 
860
841
        t = self.get_readonly_transport()
861
842
        # force transport to issue multiple requests
862
843
        t._get_max_size = 2
863
 
        list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
 
844
        l = list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
864
845
        # The server should have issued 3 requests
865
846
        self.assertEqual(3, server.GET_request_nb)
866
847
        self.assertEqual('0123456789', t.get_bytes('a'))
943
924
    def get_multiple_ranges(self, file, file_size, ranges):
944
925
        self.send_response(206)
945
926
        self.send_header('Accept-Ranges', 'bytes')
946
 
        # XXX: this is strange; the 'random' name below seems undefined and
947
 
        # yet the tests pass -- mbp 2010-10-11 bug 658773
948
927
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
949
928
        self.send_header("Content-Type",
950
929
                         "multipart/byteranges; boundary=%s" % boundary)
1012
991
                return
1013
992
            self.send_range_content(file, start, end - start + 1)
1014
993
            cur += 1
1015
 
        # Final boundary
 
994
        # No final boundary
1016
995
        self.wfile.write(boundary_line)
1017
996
 
1018
997
 
1047
1026
        # that mode
1048
1027
        self.assertEqual('single', t._range_hint)
1049
1028
 
1050
 
 
1051
1029
class LimitedRangeRequestHandler(http_server.TestingHTTPRequestHandler):
1052
1030
    """Errors out when range specifiers exceed the limit"""
1053
1031
 
1077
1055
class TestLimitedRangeRequestServer(http_utils.TestCaseWithWebserver):
1078
1056
    """Tests readv requests against a server erroring out on too much ranges."""
1079
1057
 
1080
 
    scenarios = multiply_scenarios(
1081
 
        vary_by_http_client_implementation(),
1082
 
        vary_by_http_protocol_version(),
1083
 
        )
1084
 
 
1085
1058
    # Requests with more range specifiers will error out
1086
1059
    range_limit = 3
1087
1060
 
1122
1095
    Only the urllib implementation is tested here.
1123
1096
    """
1124
1097
 
 
1098
    def setUp(self):
 
1099
        tests.TestCase.setUp(self)
 
1100
        self._old_env = {}
 
1101
        self.addCleanup(self._restore_env)
 
1102
 
 
1103
    def _install_env(self, env):
 
1104
        for name, value in env.iteritems():
 
1105
            self._old_env[name] = osutils.set_or_unset_env(name, value)
 
1106
 
 
1107
    def _restore_env(self):
 
1108
        for name, value in self._old_env.iteritems():
 
1109
            osutils.set_or_unset_env(name, value)
 
1110
 
1125
1111
    def _proxied_request(self):
1126
1112
        handler = _urllib2_wrappers.ProxyHandler()
1127
 
        request = _urllib2_wrappers.Request('GET', 'http://baz/buzzle')
 
1113
        request = _urllib2_wrappers.Request('GET','http://baz/buzzle')
1128
1114
        handler.set_proxy(request, 'http')
1129
1115
        return request
1130
1116
 
1131
 
    def assertEvaluateProxyBypass(self, expected, host, no_proxy):
1132
 
        handler = _urllib2_wrappers.ProxyHandler()
1133
 
        self.assertEquals(expected,
1134
 
                          handler.evaluate_proxy_bypass(host, no_proxy))
1135
 
 
1136
1117
    def test_empty_user(self):
1137
 
        self.overrideEnv('http_proxy', 'http://bar.com')
1138
 
        request = self._proxied_request()
1139
 
        self.assertFalse(request.headers.has_key('Proxy-authorization'))
1140
 
 
1141
 
    def test_user_with_at(self):
1142
 
        self.overrideEnv('http_proxy',
1143
 
                         'http://username@domain:password@proxy_host:1234')
 
1118
        self._install_env({'http_proxy': 'http://bar.com'})
1144
1119
        request = self._proxied_request()
1145
1120
        self.assertFalse(request.headers.has_key('Proxy-authorization'))
1146
1121
 
1147
1122
    def test_invalid_proxy(self):
1148
1123
        """A proxy env variable without scheme"""
1149
 
        self.overrideEnv('http_proxy', 'host:1234')
 
1124
        self._install_env({'http_proxy': 'host:1234'})
1150
1125
        self.assertRaises(errors.InvalidURL, self._proxied_request)
1151
1126
 
1152
 
    def test_evaluate_proxy_bypass_true(self):
1153
 
        """The host is not proxied"""
1154
 
        self.assertEvaluateProxyBypass(True, 'example.com', 'example.com')
1155
 
        self.assertEvaluateProxyBypass(True, 'bzr.example.com', '*example.com')
1156
 
 
1157
 
    def test_evaluate_proxy_bypass_false(self):
1158
 
        """The host is proxied"""
1159
 
        self.assertEvaluateProxyBypass(False, 'bzr.example.com', None)
1160
 
 
1161
 
    def test_evaluate_proxy_bypass_unknown(self):
1162
 
        """The host is not explicitly proxied"""
1163
 
        self.assertEvaluateProxyBypass(None, 'example.com', 'not.example.com')
1164
 
        self.assertEvaluateProxyBypass(None, 'bzr.example.com', 'example.com')
1165
 
 
1166
 
    def test_evaluate_proxy_bypass_empty_entries(self):
1167
 
        """Ignore empty entries"""
1168
 
        self.assertEvaluateProxyBypass(None, 'example.com', '')
1169
 
        self.assertEvaluateProxyBypass(None, 'example.com', ',')
1170
 
        self.assertEvaluateProxyBypass(None, 'example.com', 'foo,,bar')
1171
 
 
1172
1127
 
1173
1128
class TestProxyHttpServer(http_utils.TestCaseWithTwoWebservers):
1174
1129
    """Tests proxy server.
1179
1134
    to the file names).
1180
1135
    """
1181
1136
 
1182
 
    scenarios = multiply_scenarios(
1183
 
        vary_by_http_client_implementation(),
1184
 
        vary_by_http_protocol_version(),
1185
 
        )
1186
 
 
1187
1137
    # FIXME: We don't have an https server available, so we don't
1188
1138
    # test https connections. --vila toolongago
1189
1139
 
1203
1153
            self.no_proxy_host = self.server_host_port
1204
1154
        # The secondary server is the proxy
1205
1155
        self.proxy_url = self.get_secondary_url()
 
1156
        self._old_env = {}
1206
1157
 
1207
1158
    def _testing_pycurl(self):
1208
1159
        # TODO: This is duplicated for lots of the classes in this file
1209
1160
        return (features.pycurl.available()
1210
1161
                and self._transport == PyCurlTransport)
1211
1162
 
1212
 
    def assertProxied(self):
1213
 
        t = self.get_readonly_transport()
1214
 
        self.assertEqual('proxied contents of foo\n', t.get('foo').read())
1215
 
 
1216
 
    def assertNotProxied(self):
1217
 
        t = self.get_readonly_transport()
1218
 
        self.assertEqual('contents of foo\n', t.get('foo').read())
 
1163
    def _install_env(self, env):
 
1164
        for name, value in env.iteritems():
 
1165
            self._old_env[name] = osutils.set_or_unset_env(name, value)
 
1166
 
 
1167
    def _restore_env(self):
 
1168
        for name, value in self._old_env.iteritems():
 
1169
            osutils.set_or_unset_env(name, value)
 
1170
 
 
1171
    def proxied_in_env(self, env):
 
1172
        self._install_env(env)
 
1173
        t = self.get_readonly_transport()
 
1174
        try:
 
1175
            self.assertEqual('proxied contents of foo\n', t.get('foo').read())
 
1176
        finally:
 
1177
            self._restore_env()
 
1178
 
 
1179
    def not_proxied_in_env(self, env):
 
1180
        self._install_env(env)
 
1181
        t = self.get_readonly_transport()
 
1182
        try:
 
1183
            self.assertEqual('contents of foo\n', t.get('foo').read())
 
1184
        finally:
 
1185
            self._restore_env()
1219
1186
 
1220
1187
    def test_http_proxy(self):
1221
 
        self.overrideEnv('http_proxy', self.proxy_url)
1222
 
        self.assertProxied()
 
1188
        self.proxied_in_env({'http_proxy': self.proxy_url})
1223
1189
 
1224
1190
    def test_HTTP_PROXY(self):
1225
1191
        if self._testing_pycurl():
1228
1194
            # about. Should we ?)
1229
1195
            raise tests.TestNotApplicable(
1230
1196
                'pycurl does not check HTTP_PROXY for security reasons')
1231
 
        self.overrideEnv('HTTP_PROXY', self.proxy_url)
1232
 
        self.assertProxied()
 
1197
        self.proxied_in_env({'HTTP_PROXY': self.proxy_url})
1233
1198
 
1234
1199
    def test_all_proxy(self):
1235
 
        self.overrideEnv('all_proxy', self.proxy_url)
1236
 
        self.assertProxied()
 
1200
        self.proxied_in_env({'all_proxy': self.proxy_url})
1237
1201
 
1238
1202
    def test_ALL_PROXY(self):
1239
 
        self.overrideEnv('ALL_PROXY', self.proxy_url)
1240
 
        self.assertProxied()
 
1203
        self.proxied_in_env({'ALL_PROXY': self.proxy_url})
1241
1204
 
1242
1205
    def test_http_proxy_with_no_proxy(self):
1243
 
        self.overrideEnv('no_proxy', self.no_proxy_host)
1244
 
        self.overrideEnv('http_proxy', self.proxy_url)
1245
 
        self.assertNotProxied()
 
1206
        self.not_proxied_in_env({'http_proxy': self.proxy_url,
 
1207
                                 'no_proxy': self.no_proxy_host})
1246
1208
 
1247
1209
    def test_HTTP_PROXY_with_NO_PROXY(self):
1248
1210
        if self._testing_pycurl():
1249
1211
            raise tests.TestNotApplicable(
1250
1212
                'pycurl does not check HTTP_PROXY for security reasons')
1251
 
        self.overrideEnv('NO_PROXY', self.no_proxy_host)
1252
 
        self.overrideEnv('HTTP_PROXY', self.proxy_url)
1253
 
        self.assertNotProxied()
 
1213
        self.not_proxied_in_env({'HTTP_PROXY': self.proxy_url,
 
1214
                                 'NO_PROXY': self.no_proxy_host})
1254
1215
 
1255
1216
    def test_all_proxy_with_no_proxy(self):
1256
 
        self.overrideEnv('no_proxy', self.no_proxy_host)
1257
 
        self.overrideEnv('all_proxy', self.proxy_url)
1258
 
        self.assertNotProxied()
 
1217
        self.not_proxied_in_env({'all_proxy': self.proxy_url,
 
1218
                                 'no_proxy': self.no_proxy_host})
1259
1219
 
1260
1220
    def test_ALL_PROXY_with_NO_PROXY(self):
1261
 
        self.overrideEnv('NO_PROXY', self.no_proxy_host)
1262
 
        self.overrideEnv('ALL_PROXY', self.proxy_url)
1263
 
        self.assertNotProxied()
 
1221
        self.not_proxied_in_env({'ALL_PROXY': self.proxy_url,
 
1222
                                 'NO_PROXY': self.no_proxy_host})
1264
1223
 
1265
1224
    def test_http_proxy_without_scheme(self):
1266
 
        self.overrideEnv('http_proxy', self.server_host_port)
1267
1225
        if self._testing_pycurl():
1268
1226
            # pycurl *ignores* invalid proxy env variables. If that ever change
1269
1227
            # in the future, this test will fail indicating that pycurl do not
1270
1228
            # ignore anymore such variables.
1271
 
            self.assertNotProxied()
 
1229
            self.not_proxied_in_env({'http_proxy': self.server_host_port})
1272
1230
        else:
1273
 
            self.assertRaises(errors.InvalidURL, self.assertProxied)
 
1231
            self.assertRaises(errors.InvalidURL,
 
1232
                              self.proxied_in_env,
 
1233
                              {'http_proxy': self.server_host_port})
1274
1234
 
1275
1235
 
1276
1236
class TestRanges(http_utils.TestCaseWithWebserver):
1277
1237
    """Test the Range header in GET methods."""
1278
1238
 
1279
 
    scenarios = multiply_scenarios(
1280
 
        vary_by_http_client_implementation(),
1281
 
        vary_by_http_protocol_version(),
1282
 
        )
1283
 
 
1284
1239
    def setUp(self):
1285
1240
        http_utils.TestCaseWithWebserver.setUp(self)
1286
1241
        self.build_tree_contents([('a', '0123456789')],)
1326
1281
class TestHTTPRedirections(http_utils.TestCaseWithRedirectedWebserver):
1327
1282
    """Test redirection between http servers."""
1328
1283
 
1329
 
    scenarios = multiply_scenarios(
1330
 
        vary_by_http_client_implementation(),
1331
 
        vary_by_http_protocol_version(),
1332
 
        )
1333
 
 
1334
1284
    def setUp(self):
1335
1285
        super(TestHTTPRedirections, self).setUp()
1336
1286
        self.build_tree_contents([('a', '0123456789'),
1399
1349
    -- vila 20070212
1400
1350
    """
1401
1351
 
1402
 
    scenarios = multiply_scenarios(
1403
 
        vary_by_http_client_implementation(),
1404
 
        vary_by_http_protocol_version(),
1405
 
        )
1406
 
 
1407
1352
    def setUp(self):
1408
1353
        if (features.pycurl.available()
1409
1354
            and self._transport == PyCurlTransport):
1454
1399
class TestDoCatchRedirections(http_utils.TestCaseWithRedirectedWebserver):
1455
1400
    """Test transport.do_catching_redirections."""
1456
1401
 
1457
 
    scenarios = multiply_scenarios(
1458
 
        vary_by_http_client_implementation(),
1459
 
        vary_by_http_protocol_version(),
1460
 
        )
1461
 
 
1462
1402
    def setUp(self):
1463
1403
        super(TestDoCatchRedirections, self).setUp()
1464
1404
        self.build_tree_contents([('a', '0123456789'),],)
1503
1443
                          self.get_a, self.old_transport, redirected)
1504
1444
 
1505
1445
 
1506
 
def _setup_authentication_config(**kwargs):
1507
 
    conf = config.AuthenticationConfig()
1508
 
    conf._get_config().update({'httptest': kwargs})
1509
 
    conf._save()
1510
 
 
1511
 
 
1512
 
class TestUrllib2AuthHandler(tests.TestCaseWithTransport):
1513
 
    """Unit tests for glue by which urllib2 asks us for authentication"""
1514
 
 
1515
 
    def test_get_user_password_without_port(self):
1516
 
        """We cope if urllib2 doesn't tell us the port.
1517
 
 
1518
 
        See https://bugs.launchpad.net/bzr/+bug/654684
1519
 
        """
1520
 
        user = 'joe'
1521
 
        password = 'foo'
1522
 
        _setup_authentication_config(scheme='http', host='localhost',
1523
 
                                     user=user, password=password)
1524
 
        handler = _urllib2_wrappers.HTTPAuthHandler()
1525
 
        got_pass = handler.get_user_password(dict(
1526
 
            user='joe',
1527
 
            protocol='http',
1528
 
            host='localhost',
1529
 
            path='/',
1530
 
            realm='Realm',
1531
 
            ))
1532
 
        self.assertEquals((user, password), got_pass)
1533
 
 
1534
 
 
1535
1446
class TestAuth(http_utils.TestCaseWithWebserver):
1536
1447
    """Test authentication scheme"""
1537
1448
 
1538
 
    scenarios = multiply_scenarios(
1539
 
        vary_by_http_client_implementation(),
1540
 
        vary_by_http_protocol_version(),
1541
 
        vary_by_http_auth_scheme(),
1542
 
        )
 
1449
    _auth_header = 'Authorization'
 
1450
    _password_prompt_prefix = ''
 
1451
    _username_prompt_prefix = ''
 
1452
    # Set by load_tests
 
1453
    _auth_server = None
1543
1454
 
1544
1455
    def setUp(self):
1545
1456
        super(TestAuth, self).setUp()
1687
1598
        ui.ui_factory = tests.TestUIFactory(stdin=stdin_content,
1688
1599
                                            stderr=tests.StringIOWrapper())
1689
1600
        # Create a minimal config file with the right password
1690
 
        _setup_authentication_config(scheme='http', port=self.server.port,
1691
 
                                     user=user, password=password)
 
1601
        conf = config.AuthenticationConfig()
 
1602
        conf._get_config().update(
 
1603
            {'httptest': {'scheme': 'http', 'port': self.server.port,
 
1604
                          'user': user, 'password': password}})
 
1605
        conf._save()
1692
1606
        # Issue a request to the server to connect
1693
1607
        self.assertEqual('contents of a\n',t.get('a').read())
1694
1608
        # stdin should have  been left untouched
1696
1610
        # Only one 'Authentication Required' error should occur
1697
1611
        self.assertEqual(1, self.server.auth_required_errors)
1698
1612
 
 
1613
    def test_user_from_auth_conf(self):
 
1614
        if self._testing_pycurl():
 
1615
            raise tests.TestNotApplicable(
 
1616
                'pycurl does not support authentication.conf')
 
1617
        user = 'joe'
 
1618
        password = 'foo'
 
1619
        self.server.add_user(user, password)
 
1620
        # Create a minimal config file with the right password
 
1621
        conf = config.AuthenticationConfig()
 
1622
        conf._get_config().update(
 
1623
            {'httptest': {'scheme': 'http', 'port': self.server.port,
 
1624
                          'user': user, 'password': password}})
 
1625
        conf._save()
 
1626
        t = self.get_user_transport(None, None)
 
1627
        # Issue a request to the server to connect
 
1628
        self.assertEqual('contents of a\n', t.get('a').read())
 
1629
        # Only one 'Authentication Required' error should occur
 
1630
        self.assertEqual(1, self.server.auth_required_errors)
 
1631
 
1699
1632
    def test_changing_nonce(self):
1700
1633
        if self._auth_server not in (http_utils.HTTPDigestAuthServer,
1701
1634
                                     http_utils.ProxyDigestAuthServer):
1717
1650
        # initial 'who are you' and a second 'who are you' with the new nonce)
1718
1651
        self.assertEqual(2, self.server.auth_required_errors)
1719
1652
 
1720
 
    def test_user_from_auth_conf(self):
1721
 
        if self._testing_pycurl():
1722
 
            raise tests.TestNotApplicable(
1723
 
                'pycurl does not support authentication.conf')
1724
 
        user = 'joe'
1725
 
        password = 'foo'
1726
 
        self.server.add_user(user, password)
1727
 
        _setup_authentication_config(scheme='http', port=self.server.port,
1728
 
                                     user=user, password=password)
1729
 
        t = self.get_user_transport(None, None)
1730
 
        # Issue a request to the server to connect
1731
 
        self.assertEqual('contents of a\n', t.get('a').read())
1732
 
        # Only one 'Authentication Required' error should occur
1733
 
        self.assertEqual(1, self.server.auth_required_errors)
1734
 
 
1735
 
    def test_no_credential_leaks_in_log(self):
1736
 
        self.overrideAttr(debug, 'debug_flags', set(['http']))
1737
 
        user = 'joe'
1738
 
        password = 'very-sensitive-password'
1739
 
        self.server.add_user(user, password)
1740
 
        t = self.get_user_transport(user, password)
1741
 
        # Capture the debug calls to mutter
1742
 
        self.mutters = []
1743
 
        def mutter(*args):
1744
 
            lines = args[0] % args[1:]
1745
 
            # Some calls output multiple lines, just split them now since we
1746
 
            # care about a single one later.
1747
 
            self.mutters.extend(lines.splitlines())
1748
 
        self.overrideAttr(trace, 'mutter', mutter)
1749
 
        # Issue a request to the server to connect
1750
 
        self.assertEqual(True, t.has('a'))
1751
 
        # Only one 'Authentication Required' error should occur
1752
 
        self.assertEqual(1, self.server.auth_required_errors)
1753
 
        # Since the authentification succeeded, there should be a corresponding
1754
 
        # debug line
1755
 
        sent_auth_headers = [line for line in self.mutters
1756
 
                             if line.startswith('> %s' % (self._auth_header,))]
1757
 
        self.assertLength(1, sent_auth_headers)
1758
 
        self.assertStartsWith(sent_auth_headers[0],
1759
 
                              '> %s: <masked>' % (self._auth_header,))
1760
1653
 
1761
1654
 
1762
1655
class TestProxyAuth(TestAuth):
1763
 
    """Test proxy authentication schemes.
1764
 
 
1765
 
    This inherits from TestAuth to tweak the setUp and filter some failing
1766
 
    tests.
1767
 
    """
1768
 
 
1769
 
    scenarios = multiply_scenarios(
1770
 
        vary_by_http_client_implementation(),
1771
 
        vary_by_http_protocol_version(),
1772
 
        vary_by_http_proxy_auth_scheme(),
1773
 
        )
 
1656
    """Test proxy authentication schemes."""
 
1657
 
 
1658
    _auth_header = 'Proxy-authorization'
 
1659
    _password_prompt_prefix = 'Proxy '
 
1660
    _username_prompt_prefix = 'Proxy '
1774
1661
 
1775
1662
    def setUp(self):
1776
1663
        super(TestProxyAuth, self).setUp()
 
1664
        self._old_env = {}
 
1665
        self.addCleanup(self._restore_env)
1777
1666
        # Override the contents to avoid false positives
1778
1667
        self.build_tree_contents([('a', 'not proxied contents of a\n'),
1779
1668
                                  ('b', 'not proxied contents of b\n'),
1782
1671
                                  ])
1783
1672
 
1784
1673
    def get_user_transport(self, user, password):
1785
 
        self.overrideEnv('all_proxy', self.get_user_url(user, password))
 
1674
        self._install_env({'all_proxy': self.get_user_url(user, password)})
1786
1675
        return TestAuth.get_user_transport(self, user, password)
1787
1676
 
 
1677
    def _install_env(self, env):
 
1678
        for name, value in env.iteritems():
 
1679
            self._old_env[name] = osutils.set_or_unset_env(name, value)
 
1680
 
 
1681
    def _restore_env(self):
 
1682
        for name, value in self._old_env.iteritems():
 
1683
            osutils.set_or_unset_env(name, value)
 
1684
 
1788
1685
    def test_empty_pass(self):
1789
1686
        if self._testing_pycurl():
1790
1687
            import pycurl
1819
1716
 
1820
1717
class SmartHTTPTunnellingTest(tests.TestCaseWithTransport):
1821
1718
 
1822
 
    scenarios = multiply_scenarios(
1823
 
        vary_by_http_client_implementation(),
1824
 
        vary_by_http_protocol_version(),
1825
 
        )
1826
 
 
1827
1719
    def setUp(self):
1828
1720
        super(SmartHTTPTunnellingTest, self).setUp()
1829
1721
        # We use the VFS layer as part of HTTP tunnelling tests.
1830
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1722
        self._captureVar('BZR_NO_SMART_VFS', None)
1831
1723
        self.transport_readonly_server = http_utils.HTTPServerWithSmarts
1832
1724
        self.http_server = self.get_readonly_server()
1833
1725
 
1918
1810
 
1919
1811
class Test_redirected_to(tests.TestCase):
1920
1812
 
1921
 
    scenarios = vary_by_http_client_implementation()
1922
 
 
1923
1813
    def test_redirected_to_subdir(self):
1924
1814
        t = self._transport('http://www.example.com/foo')
1925
1815
        r = t._redirected_to('http://www.example.com/foo',
2037
1927
        tests.TestCase.setUp(self)
2038
1928
        self.server = self._activity_server(self._protocol_version)
2039
1929
        self.server.start_server()
2040
 
        _activities = {} # Don't close over self and create a cycle
 
1930
        self.activities = {}
2041
1931
        def report_activity(t, bytes, direction):
2042
 
            count = _activities.get(direction, 0)
 
1932
            count = self.activities.get(direction, 0)
2043
1933
            count += bytes
2044
 
            _activities[direction] = count
2045
 
        self.activities = _activities
 
1934
            self.activities[direction] = count
2046
1935
 
2047
1936
        # We override at class level because constructors may propagate the
2048
1937
        # bound method and render instance overriding ineffective (an
2172
2061
 
2173
2062
class TestActivity(tests.TestCase, TestActivityMixin):
2174
2063
 
2175
 
    scenarios = multiply_scenarios(
2176
 
        vary_by_http_activity(),
2177
 
        vary_by_http_protocol_version(),
2178
 
        )
2179
 
 
2180
2064
    def setUp(self):
2181
2065
        TestActivityMixin.setUp(self)
2182
2066
 
2203
2087
class TestAuthOnRedirected(http_utils.TestCaseWithRedirectedWebserver):
2204
2088
    """Test authentication on the redirected http server."""
2205
2089
 
2206
 
    scenarios = vary_by_http_protocol_version()
2207
 
 
2208
2090
    _auth_header = 'Authorization'
2209
2091
    _password_prompt_prefix = ''
2210
2092
    _username_prompt_prefix = ''
2273
2155
        # stdout should be empty, stderr will contains the prompts
2274
2156
        self.assertEqual('', stdout.getvalue())
2275
2157
 
 
2158