~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_http.py

  • Committer: Aaron Bentley
  • Date: 2007-06-06 01:28:18 UTC
  • mto: This revision was merged to the branch mainline in revision 2509.
  • Revision ID: aaron.bentley@utoronto.ca-20070606012818-ubf8cmaj1imntttb
Updates from review

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
"""Tests for HTTP implementations.
18
 
 
19
 
This module defines a load_tests() method that parametrize tests classes for
20
 
transport implementation, http protocol versions and authentication schemes.
21
 
"""
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
# FIXME: This test should be repeated for each available http client
 
18
# implementation; at the moment we have urllib and pycurl.
22
19
 
23
20
# TODO: Should be renamed to bzrlib.transport.http.tests?
24
21
# TODO: What about renaming to bzrlib.tests.transport.http ?
25
22
 
26
23
from cStringIO import StringIO
27
 
import httplib
28
24
import os
29
25
import select
30
 
import SimpleHTTPServer
31
26
import socket
32
27
import sys
33
28
import threading
34
29
 
35
30
import bzrlib
36
31
from bzrlib import (
37
 
    bzrdir,
38
 
    config,
39
32
    errors,
40
33
    osutils,
41
 
    remote as _mod_remote,
42
 
    tests,
43
 
    transport,
44
34
    ui,
45
35
    urlutils,
46
36
    )
47
 
from bzrlib.symbol_versioning import (
48
 
    deprecated_in,
49
 
    )
50
37
from bzrlib.tests import (
51
 
    features,
52
 
    http_server,
53
 
    http_utils,
 
38
    TestCase,
 
39
    TestUIFactory,
 
40
    TestSkipped,
 
41
    StringIOWrapper,
 
42
    )
 
43
from bzrlib.tests.HttpServer import (
 
44
    HttpServer,
 
45
    HttpServer_PyCurl,
 
46
    HttpServer_urllib,
 
47
    )
 
48
from bzrlib.tests.HTTPTestUtil import (
 
49
    BadProtocolRequestHandler,
 
50
    BadStatusRequestHandler,
 
51
    ForbiddenRequestHandler,
 
52
    HTTPBasicAuthServer,
 
53
    HTTPDigestAuthServer,
 
54
    HTTPServerRedirecting,
 
55
    InvalidStatusRequestHandler,
 
56
    NoRangeRequestHandler,
 
57
    ProxyBasicAuthServer,
 
58
    ProxyDigestAuthServer,
 
59
    ProxyServer,
 
60
    SingleRangeRequestHandler,
 
61
    SingleOnlyRangeRequestHandler,
 
62
    TestCaseWithRedirectedWebserver,
 
63
    TestCaseWithTwoWebservers,
 
64
    TestCaseWithWebserver,
 
65
    WallRequestHandler,
54
66
    )
55
67
from bzrlib.transport import (
56
 
    http,
57
 
    remote,
 
68
    do_catching_redirections,
 
69
    get_transport,
 
70
    Transport,
58
71
    )
59
72
from bzrlib.transport.http import (
60
 
    _urllib,
 
73
    extract_auth,
 
74
    HttpTransportBase,
61
75
    _urllib2_wrappers,
62
76
    )
63
 
 
64
 
 
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
 
                )))
80
 
    transport_scenarios = [
81
 
        ('urllib', dict(_transport=_urllib.HttpTransport_urllib,
82
 
                        _server=http_server.HttpServer_urllib,
83
 
                        _qualified_prefix='http+urllib',)),
84
 
        ]
85
 
    if features.pycurl.available():
86
 
        transport_scenarios.append(
87
 
            ('pycurl', dict(_transport=PyCurlTransport,
88
 
                            _server=http_server.HttpServer_PyCurl,
89
 
                            _qualified_prefix='http+pycurl',)))
90
 
    tests.multiply_tests(t_tests, transport_scenarios, result)
91
 
 
92
 
    # each implementation tested with each HTTP version
93
 
    tp_tests, remaining_tests = tests.split_suite_by_condition(
94
 
        remaining_tests, tests.condition_isinstance((
95
 
                SmartHTTPTunnellingTest,
96
 
                TestDoCatchRedirections,
97
 
                TestHTTPConnections,
98
 
                TestHTTPRedirections,
99
 
                TestHTTPSilentRedirections,
100
 
                TestLimitedRangeRequestServer,
101
 
                TestPost,
102
 
                TestProxyHttpServer,
103
 
                TestRanges,
104
 
                TestSpecificRequestHandler,
105
 
                )))
106
 
    protocol_scenarios = [
107
 
            ('HTTP/1.0',  dict(_protocol_version='HTTP/1.0')),
108
 
            ('HTTP/1.1',  dict(_protocol_version='HTTP/1.1')),
109
 
            ]
110
 
    tp_scenarios = tests.multiply_scenarios(transport_scenarios,
111
 
                                            protocol_scenarios)
112
 
    tests.multiply_tests(tp_tests, tp_scenarios, result)
113
 
 
114
 
    # proxy auth: each auth scheme on all http versions on all implementations.
115
 
    tppa_tests, remaining_tests = tests.split_suite_by_condition(
116
 
        remaining_tests, tests.condition_isinstance((
117
 
                TestProxyAuth,
118
 
                )))
119
 
    proxy_auth_scheme_scenarios = [
120
 
        ('basic', dict(_auth_server=http_utils.ProxyBasicAuthServer)),
121
 
        ('digest', dict(_auth_server=http_utils.ProxyDigestAuthServer)),
122
 
        ('basicdigest',
123
 
         dict(_auth_server=http_utils.ProxyBasicAndDigestAuthServer)),
124
 
        ]
125
 
    tppa_scenarios = tests.multiply_scenarios(tp_scenarios,
126
 
                                              proxy_auth_scheme_scenarios)
127
 
    tests.multiply_tests(tppa_tests, tppa_scenarios, result)
128
 
 
129
 
    # auth: each auth scheme on all http versions on all implementations.
130
 
    tpa_tests, remaining_tests = tests.split_suite_by_condition(
131
 
        remaining_tests, tests.condition_isinstance((
132
 
                TestAuth,
133
 
                )))
134
 
    auth_scheme_scenarios = [
135
 
        ('basic', dict(_auth_server=http_utils.HTTPBasicAuthServer)),
136
 
        ('digest', dict(_auth_server=http_utils.HTTPDigestAuthServer)),
137
 
        ('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
 
                )))
149
 
    activity_scenarios = [
150
 
        ('urllib,http', dict(_activity_server=ActivityHTTPServer,
151
 
                             _transport=_urllib.HttpTransport_urllib,)),
152
 
        ]
153
 
    if tests.HTTPSServerFeature.available():
154
 
        activity_scenarios.append(
155
 
            ('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
 
77
from bzrlib.transport.http._urllib import HttpTransport_urllib
 
78
from bzrlib.transport.http._urllib2_wrappers import (
 
79
    PasswordManager,
 
80
    ProxyHandler,
 
81
    Request,
 
82
    )
188
83
 
189
84
 
190
85
class FakeManager(object):
198
93
 
199
94
class RecordingServer(object):
200
95
    """A fake HTTP server.
201
 
 
 
96
    
202
97
    It records the bytes sent to it, and replies with a 200.
203
98
    """
204
99
 
205
 
    def __init__(self, expect_body_tail=None, scheme=''):
 
100
    def __init__(self, expect_body_tail=None):
206
101
        """Constructor.
207
102
 
208
103
        :type expect_body_tail: str
213
108
        self.host = None
214
109
        self.port = None
215
110
        self.received_bytes = ''
216
 
        self.scheme = scheme
217
 
 
218
 
    def get_url(self):
219
 
        return '%s://%s:%s/' % (self.scheme, self.host, self.port)
220
 
 
221
 
    def start_server(self):
 
111
 
 
112
    def setUp(self):
222
113
        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
223
114
        self._sock.bind(('127.0.0.1', 0))
224
115
        self.host, self.port = self._sock.getsockname()
247
138
            # The client may have already closed the socket.
248
139
            pass
249
140
 
250
 
    def stop_server(self):
 
141
    def tearDown(self):
251
142
        try:
252
143
            self._sock.close()
253
144
        except socket.error:
257
148
        self.port = None
258
149
 
259
150
 
260
 
class TestAuthHeader(tests.TestCase):
261
 
 
262
 
    def parse_header(self, header, auth_handler_class=None):
263
 
        if auth_handler_class is None:
264
 
            auth_handler_class = _urllib2_wrappers.AbstractAuthHandler
265
 
        self.auth_handler =  auth_handler_class()
266
 
        return self.auth_handler._parse_auth_header(header)
267
 
 
268
 
    def test_empty_header(self):
269
 
        scheme, remainder = self.parse_header('')
270
 
        self.assertEqual('', scheme)
271
 
        self.assertIs(None, remainder)
272
 
 
273
 
    def test_negotiate_header(self):
274
 
        scheme, remainder = self.parse_header('Negotiate')
275
 
        self.assertEqual('negotiate', scheme)
276
 
        self.assertIs(None, remainder)
277
 
 
278
 
    def test_basic_header(self):
279
 
        scheme, remainder = self.parse_header(
280
 
            'Basic realm="Thou should not pass"')
281
 
        self.assertEqual('basic', scheme)
282
 
        self.assertEqual('realm="Thou should not pass"', remainder)
283
 
 
284
 
    def test_basic_extract_realm(self):
285
 
        scheme, remainder = self.parse_header(
286
 
            'Basic realm="Thou should not pass"',
287
 
            _urllib2_wrappers.BasicAuthHandler)
288
 
        match, realm = self.auth_handler.extract_realm(remainder)
289
 
        self.assertTrue(match is not None)
290
 
        self.assertEqual('Thou should not pass', realm)
291
 
 
292
 
    def test_digest_header(self):
293
 
        scheme, remainder = self.parse_header(
294
 
            'Digest realm="Thou should not pass"')
295
 
        self.assertEqual('digest', scheme)
296
 
        self.assertEqual('realm="Thou should not pass"', remainder)
297
 
 
298
 
 
299
 
class TestHTTPServer(tests.TestCase):
300
 
    """Test the HTTP servers implementations."""
301
 
 
302
 
    def test_invalid_protocol(self):
303
 
        class BogusRequestHandler(http_server.TestingHTTPRequestHandler):
304
 
 
305
 
            protocol_version = 'HTTP/0.1'
306
 
 
307
 
        server = http_server.HttpServer(BogusRequestHandler)
308
 
        try:
309
 
            self.assertRaises(httplib.UnknownProtocol, server.start_server)
310
 
        except:
311
 
            server.stop_server()
312
 
            self.fail('HTTP Server creation did not raise UnknownProtocol')
313
 
 
314
 
    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')
321
 
 
322
 
    def test_server_start_and_stop(self):
323
 
        server = http_server.HttpServer()
324
 
        server.start_server()
325
 
        try:
326
 
            self.assertTrue(server._http_running)
327
 
        finally:
328
 
            server.stop_server()
329
 
        self.assertFalse(server._http_running)
330
 
 
331
 
    def test_create_http_server_one_zero(self):
332
 
        class RequestHandlerOneZero(http_server.TestingHTTPRequestHandler):
333
 
 
334
 
            protocol_version = 'HTTP/1.0'
335
 
 
336
 
        server = http_server.HttpServer(RequestHandlerOneZero)
337
 
        self.start_server(server)
338
 
        self.assertIsInstance(server._httpd, http_server.TestingHTTPServer)
339
 
 
340
 
    def test_create_http_server_one_one(self):
341
 
        class RequestHandlerOneOne(http_server.TestingHTTPRequestHandler):
342
 
 
343
 
            protocol_version = 'HTTP/1.1'
344
 
 
345
 
        server = http_server.HttpServer(RequestHandlerOneOne)
346
 
        self.start_server(server)
347
 
        self.assertIsInstance(server._httpd,
348
 
                              http_server.TestingThreadingHTTPServer)
349
 
 
350
 
    def test_create_http_server_force_one_one(self):
351
 
        class RequestHandlerOneZero(http_server.TestingHTTPRequestHandler):
352
 
 
353
 
            protocol_version = 'HTTP/1.0'
354
 
 
355
 
        server = http_server.HttpServer(RequestHandlerOneZero,
356
 
                                        protocol_version='HTTP/1.1')
357
 
        self.start_server(server)
358
 
        self.assertIsInstance(server._httpd,
359
 
                              http_server.TestingThreadingHTTPServer)
360
 
 
361
 
    def test_create_http_server_force_one_zero(self):
362
 
        class RequestHandlerOneOne(http_server.TestingHTTPRequestHandler):
363
 
 
364
 
            protocol_version = 'HTTP/1.1'
365
 
 
366
 
        server = http_server.HttpServer(RequestHandlerOneOne,
367
 
                                        protocol_version='HTTP/1.0')
368
 
        self.start_server(server)
369
 
        self.assertIsInstance(server._httpd,
370
 
                              http_server.TestingHTTPServer)
371
 
 
372
 
 
373
151
class TestWithTransport_pycurl(object):
374
152
    """Test case to inherit from if pycurl is present"""
375
153
 
376
154
    def _get_pycurl_maybe(self):
377
 
        self.requireFeature(features.pycurl)
378
 
        return PyCurlTransport
 
155
        try:
 
156
            from bzrlib.transport.http._pycurl import PyCurlTransport
 
157
            return PyCurlTransport
 
158
        except errors.DependencyNotPresent:
 
159
            raise TestSkipped('pycurl not present')
379
160
 
380
161
    _transport = property(_get_pycurl_maybe)
381
162
 
382
163
 
383
 
class TestHttpUrls(tests.TestCase):
 
164
class TestHttpUrls(TestCase):
384
165
 
385
166
    # TODO: This should be moved to authorization tests once they
386
167
    # are written.
387
168
 
388
169
    def test_url_parsing(self):
389
170
        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
 
class TestHttpTransportUrls(tests.TestCase):
402
 
    """Test the http urls."""
 
171
        url = extract_auth('http://example.com', f)
 
172
        self.assertEquals('http://example.com', url)
 
173
        self.assertEquals(0, len(f.credentials))
 
174
        url = extract_auth('http://user:pass@www.bazaar-vcs.org/bzr/bzr.dev', f)
 
175
        self.assertEquals('http://www.bazaar-vcs.org/bzr/bzr.dev', url)
 
176
        self.assertEquals(1, len(f.credentials))
 
177
        self.assertEquals([None, 'www.bazaar-vcs.org', 'user', 'pass'],
 
178
                          f.credentials[0])
 
179
 
 
180
 
 
181
class TestHttpTransportUrls(object):
 
182
    """Test the http urls.
 
183
 
 
184
    This MUST be used by daughter classes that also inherit from
 
185
    TestCase.
 
186
 
 
187
    We can't inherit directly from TestCase or the
 
188
    test framework will try to create an instance which cannot
 
189
    run, its implementation being incomplete.
 
190
    """
403
191
 
404
192
    def test_abs_url(self):
405
193
        """Construction of absolute http URLs"""
414
202
    def test_invalid_http_urls(self):
415
203
        """Trap invalid construction of urls"""
416
204
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
417
 
        self.assertRaises(errors.InvalidURL,
418
 
                          self._transport,
419
 
                          'http://http://bazaar-vcs.org/bzr/bzr.dev/')
 
205
        self.assertRaises(ValueError, t.abspath, '.bzr/')
 
206
        t = self._transport('http://http://bazaar-vcs.org/bzr/bzr.dev/')
 
207
        self.assertRaises((errors.InvalidURL, errors.ConnectionError),
 
208
                          t.has, 'foo/bar')
420
209
 
421
210
    def test_http_root_urls(self):
422
211
        """Construction of URLs from server root"""
428
217
    def test_http_impl_urls(self):
429
218
        """There are servers which ask for particular clients to connect"""
430
219
        server = self._server()
431
 
        server.start_server()
432
220
        try:
 
221
            server.setUp()
433
222
            url = server.get_url()
434
223
            self.assertTrue(url.startswith('%s://' % self._qualified_prefix))
435
224
        finally:
436
 
            server.stop_server()
437
 
 
438
 
 
439
 
class TestHttps_pycurl(TestWithTransport_pycurl, tests.TestCase):
 
225
            server.tearDown()
 
226
 
 
227
 
 
228
class TestHttpUrls_urllib(TestHttpTransportUrls, TestCase):
 
229
    """Test http urls with urllib"""
 
230
 
 
231
    _transport = HttpTransport_urllib
 
232
    _server = HttpServer_urllib
 
233
    _qualified_prefix = 'http+urllib'
 
234
 
 
235
 
 
236
class TestHttpUrls_pycurl(TestWithTransport_pycurl, TestHttpTransportUrls,
 
237
                          TestCase):
 
238
    """Test http urls with pycurl"""
 
239
 
 
240
    _server = HttpServer_PyCurl
 
241
    _qualified_prefix = 'http+pycurl'
440
242
 
441
243
    # TODO: This should really be moved into another pycurl
442
244
    # specific test. When https tests will be implemented, take
448
250
        https by supplying a fake version_info that do not
449
251
        support it.
450
252
        """
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))
 
253
        try:
 
254
            import pycurl
 
255
        except ImportError:
 
256
            raise TestSkipped('pycurl not present')
 
257
        # Now that we have pycurl imported, we can fake its version_info
 
258
        # This was taken from a windows pycurl without SSL
 
259
        # (thanks to bialix)
 
260
        pycurl.version_info = lambda : (2,
 
261
                                        '7.13.2',
 
262
                                        462082,
 
263
                                        'i386-pc-win32',
 
264
                                        2576,
 
265
                                        None,
 
266
                                        0,
 
267
                                        None,
 
268
                                        ('ftp', 'gopher', 'telnet',
 
269
                                         'dict', 'ldap', 'http', 'file'),
 
270
                                        None,
 
271
                                        0,
 
272
                                        None)
471
273
        self.assertRaises(errors.DependencyNotPresent, self._transport,
472
274
                          'https://launchpad.net')
473
275
 
474
 
 
475
 
class TestHTTPConnections(http_utils.TestCaseWithWebserver):
476
 
    """Test the http connections."""
 
276
class TestHttpConnections(object):
 
277
    """Test the http connections.
 
278
 
 
279
    This MUST be used by daughter classes that also inherit from
 
280
    TestCaseWithWebserver.
 
281
 
 
282
    We can't inherit directly from TestCaseWithWebserver or the
 
283
    test framework will try to create an instance which cannot
 
284
    run, its implementation being incomplete.
 
285
    """
477
286
 
478
287
    def setUp(self):
479
 
        http_utils.TestCaseWithWebserver.setUp(self)
480
 
        self.build_tree(['foo/', 'foo/bar'], line_endings='binary',
 
288
        TestCaseWithWebserver.setUp(self)
 
289
        self.build_tree(['xxx', 'foo/', 'foo/bar'], line_endings='binary',
481
290
                        transport=self.get_transport())
482
291
 
483
292
    def test_http_has(self):
507
316
            '"GET /foo/bar HTTP/1.1" 200 - "-" "bzr/%s'
508
317
            % bzrlib.__version__) > -1)
509
318
 
 
319
    def test_get_smart_medium(self):
 
320
        # For HTTP, get_smart_medium should return the transport object.
 
321
        server = self.get_readonly_server()
 
322
        http_transport = self._transport(server.get_url())
 
323
        medium = http_transport.get_smart_medium()
 
324
        self.assertIs(medium, http_transport)
 
325
 
510
326
    def test_has_on_bogus_host(self):
511
327
        # Get a free address and don't 'accept' on it, so that we
512
328
        # can be sure there is no http handler there, but set a
522
338
            socket.setdefaulttimeout(default_timeout)
523
339
 
524
340
 
525
 
class TestHttpTransportRegistration(tests.TestCase):
 
341
class TestHttpConnections_urllib(TestHttpConnections, TestCaseWithWebserver):
 
342
    """Test http connections with urllib"""
 
343
 
 
344
    _transport = HttpTransport_urllib
 
345
 
 
346
 
 
347
 
 
348
class TestHttpConnections_pycurl(TestWithTransport_pycurl,
 
349
                                 TestHttpConnections,
 
350
                                 TestCaseWithWebserver):
 
351
    """Test http connections with pycurl"""
 
352
 
 
353
 
 
354
class TestHttpTransportRegistration(TestCase):
526
355
    """Test registrations of various http implementations"""
527
356
 
528
357
    def test_http_registered(self):
529
 
        t = transport.get_transport('%s://foo.com/' % self._qualified_prefix)
530
 
        self.assertIsInstance(t, transport.Transport)
531
 
        self.assertIsInstance(t, self._transport)
532
 
 
533
 
 
534
 
class TestPost(tests.TestCase):
535
 
 
536
 
    def test_post_body_is_received(self):
537
 
        server = RecordingServer(expect_body_tail='end-of-body',
538
 
            scheme=self._qualified_prefix)
539
 
        self.start_server(server)
540
 
        url = server.get_url()
541
 
        http_transport = self._transport(url)
 
358
        # urlllib should always be present
 
359
        t = get_transport('http+urllib://bzr.google.com/')
 
360
        self.assertIsInstance(t, Transport)
 
361
        self.assertIsInstance(t, HttpTransport_urllib)
 
362
 
 
363
 
 
364
class TestOffsets(TestCase):
 
365
    """Test offsets_to_ranges method"""
 
366
 
 
367
    def test_offsets_to_ranges_simple(self):
 
368
        to_range = HttpTransportBase.offsets_to_ranges
 
369
        ranges = to_range([(10, 1)])
 
370
        self.assertEqual([[10, 10]], ranges)
 
371
 
 
372
        ranges = to_range([(0, 1), (1, 1)])
 
373
        self.assertEqual([[0, 1]], ranges)
 
374
 
 
375
        ranges = to_range([(1, 1), (0, 1)])
 
376
        self.assertEqual([[0, 1]], ranges)
 
377
 
 
378
    def test_offset_to_ranges_overlapped(self):
 
379
        to_range = HttpTransportBase.offsets_to_ranges
 
380
 
 
381
        ranges = to_range([(10, 1), (20, 2), (22, 5)])
 
382
        self.assertEqual([[10, 10], [20, 26]], ranges)
 
383
 
 
384
        ranges = to_range([(10, 1), (11, 2), (22, 5)])
 
385
        self.assertEqual([[10, 12], [22, 26]], ranges)
 
386
 
 
387
 
 
388
class TestPost(object):
 
389
 
 
390
    def _test_post_body_is_received(self, scheme):
 
391
        server = RecordingServer(expect_body_tail='end-of-body')
 
392
        server.setUp()
 
393
        self.addCleanup(server.tearDown)
 
394
        url = '%s://%s:%s/' % (scheme, server.host, server.port)
 
395
        try:
 
396
            http_transport = get_transport(url)
 
397
        except errors.UnsupportedProtocol:
 
398
            raise TestSkipped('%s not available' % scheme)
542
399
        code, response = http_transport._post('abc def end-of-body')
543
400
        self.assertTrue(
544
401
            server.received_bytes.startswith('POST /.bzr/smart HTTP/1.'))
550
407
            server.received_bytes.endswith('\r\n\r\nabc def end-of-body'))
551
408
 
552
409
 
553
 
class TestRangeHeader(tests.TestCase):
 
410
class TestPost_urllib(TestCase, TestPost):
 
411
    """TestPost for urllib implementation"""
 
412
 
 
413
    _transport = HttpTransport_urllib
 
414
 
 
415
    def test_post_body_is_received_urllib(self):
 
416
        self._test_post_body_is_received('http+urllib')
 
417
 
 
418
 
 
419
class TestPost_pycurl(TestWithTransport_pycurl, TestCase, TestPost):
 
420
    """TestPost for pycurl implementation"""
 
421
 
 
422
    def test_post_body_is_received_pycurl(self):
 
423
        self._test_post_body_is_received('http+pycurl')
 
424
 
 
425
 
 
426
class TestRangeHeader(TestCase):
554
427
    """Test range_header method"""
555
428
 
556
429
    def check_header(self, value, ranges=[], tail=0):
557
 
        offsets = [ (start, end - start + 1) for start, end in ranges]
558
 
        coalesce = transport.Transport._coalesce_offsets
559
 
        coalesced = list(coalesce(offsets, limit=0, fudge_factor=0))
560
 
        range_header = http.HttpTransportBase._range_header
561
 
        self.assertEqual(value, range_header(coalesced, tail))
 
430
        range_header = HttpTransportBase.range_header
 
431
        self.assertEqual(value, range_header(ranges, tail))
562
432
 
563
433
    def test_range_header_single(self):
564
 
        self.check_header('0-9', ranges=[(0,9)])
565
 
        self.check_header('100-109', ranges=[(100,109)])
 
434
        self.check_header('0-9', ranges=[[0,9]])
 
435
        self.check_header('100-109', ranges=[[100,109]])
566
436
 
567
437
    def test_range_header_tail(self):
568
438
        self.check_header('-10', tail=10)
578
448
                          tail=50)
579
449
 
580
450
 
581
 
class TestSpecificRequestHandler(http_utils.TestCaseWithWebserver):
582
 
    """Tests a specific request handler.
583
 
 
584
 
    Daughter classes are expected to override _req_handler_class
585
 
    """
586
 
 
587
 
    # Provide a useful default
588
 
    _req_handler_class = http_server.TestingHTTPRequestHandler
589
 
 
590
 
    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)
598
 
 
599
 
 
600
 
class WallRequestHandler(http_server.TestingHTTPRequestHandler):
601
 
    """Whatever request comes in, close the connection"""
602
 
 
603
 
    def handle_one_request(self):
604
 
        """Handle a single HTTP request, by abruptly closing the connection"""
605
 
        self.close_connection = 1
606
 
 
607
 
 
608
 
class TestWallServer(TestSpecificRequestHandler):
 
451
class TestWallServer(object):
609
452
    """Tests exceptions during the connection phase"""
610
453
 
611
 
    _req_handler_class = WallRequestHandler
 
454
    def create_transport_readonly_server(self):
 
455
        return HttpServer(WallRequestHandler)
612
456
 
613
457
    def test_http_has(self):
614
458
        server = self.get_readonly_server()
617
461
        # for details) make no distinction between a closed
618
462
        # socket and badly formatted status line, so we can't
619
463
        # 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),
 
464
        # InvalidHttpResponse too.
 
465
        self.assertRaises((errors.ConnectionError, errors.InvalidHttpResponse),
624
466
                          t.has, 'foo/bar')
625
467
 
626
468
    def test_http_get(self):
627
469
        server = self.get_readonly_server()
628
470
        t = self._transport(server.get_url())
629
 
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
630
 
                           errors.InvalidHttpResponse),
 
471
        self.assertRaises((errors.ConnectionError, errors.InvalidHttpResponse),
631
472
                          t.get, 'foo/bar')
632
473
 
633
474
 
634
 
class BadStatusRequestHandler(http_server.TestingHTTPRequestHandler):
635
 
    """Whatever request comes in, returns a bad status"""
636
 
 
637
 
    def parse_request(self):
638
 
        """Fakes handling a single HTTP request, returns a bad status"""
639
 
        ignored = http_server.TestingHTTPRequestHandler.parse_request(self)
640
 
        self.send_response(0, "Bad status")
641
 
        self.close_connection = 1
642
 
        return False
643
 
 
644
 
 
645
 
class TestBadStatusServer(TestSpecificRequestHandler):
 
475
class TestWallServer_urllib(TestWallServer, TestCaseWithWebserver):
 
476
    """Tests "wall" server for urllib implementation"""
 
477
 
 
478
    _transport = HttpTransport_urllib
 
479
 
 
480
 
 
481
class TestWallServer_pycurl(TestWithTransport_pycurl,
 
482
                            TestWallServer,
 
483
                            TestCaseWithWebserver):
 
484
    """Tests "wall" server for pycurl implementation"""
 
485
 
 
486
 
 
487
class TestBadStatusServer(object):
646
488
    """Tests bad status from server."""
647
489
 
648
 
    _req_handler_class = BadStatusRequestHandler
 
490
    def create_transport_readonly_server(self):
 
491
        return HttpServer(BadStatusRequestHandler)
649
492
 
650
493
    def test_http_has(self):
651
494
        server = self.get_readonly_server()
658
501
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
659
502
 
660
503
 
661
 
class InvalidStatusRequestHandler(http_server.TestingHTTPRequestHandler):
662
 
    """Whatever request comes in, returns an invalid status"""
663
 
 
664
 
    def parse_request(self):
665
 
        """Fakes handling a single HTTP request, returns a bad status"""
666
 
        ignored = http_server.TestingHTTPRequestHandler.parse_request(self)
667
 
        self.wfile.write("Invalid status line\r\n")
668
 
        return False
 
504
class TestBadStatusServer_urllib(TestBadStatusServer, TestCaseWithWebserver):
 
505
    """Tests bad status server for urllib implementation"""
 
506
 
 
507
    _transport = HttpTransport_urllib
 
508
 
 
509
 
 
510
class TestBadStatusServer_pycurl(TestWithTransport_pycurl,
 
511
                                 TestBadStatusServer,
 
512
                                 TestCaseWithWebserver):
 
513
    """Tests bad status server for pycurl implementation"""
669
514
 
670
515
 
671
516
class TestInvalidStatusServer(TestBadStatusServer):
674
519
    Both implementations raises the same error as for a bad status.
675
520
    """
676
521
 
677
 
    _req_handler_class = InvalidStatusRequestHandler
678
 
 
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
 
 
692
 
class BadProtocolRequestHandler(http_server.TestingHTTPRequestHandler):
693
 
    """Whatever request comes in, returns a bad protocol version"""
694
 
 
695
 
    def parse_request(self):
696
 
        """Fakes handling a single HTTP request, returns a bad status"""
697
 
        ignored = http_server.TestingHTTPRequestHandler.parse_request(self)
698
 
        # Returns an invalid protocol version, but curl just
699
 
        # ignores it and those cannot be tested.
700
 
        self.wfile.write("%s %d %s\r\n" % ('HTTP/0.0',
701
 
                                           404,
702
 
                                           'Look at my protocol version'))
703
 
        return False
704
 
 
705
 
 
706
 
class TestBadProtocolServer(TestSpecificRequestHandler):
 
522
    def create_transport_readonly_server(self):
 
523
        return HttpServer(InvalidStatusRequestHandler)
 
524
 
 
525
 
 
526
class TestInvalidStatusServer_urllib(TestInvalidStatusServer,
 
527
                                     TestCaseWithWebserver):
 
528
    """Tests invalid status server for urllib implementation"""
 
529
 
 
530
    _transport = HttpTransport_urllib
 
531
 
 
532
 
 
533
class TestInvalidStatusServer_pycurl(TestWithTransport_pycurl,
 
534
                                     TestInvalidStatusServer,
 
535
                                     TestCaseWithWebserver):
 
536
    """Tests invalid status server for pycurl implementation"""
 
537
 
 
538
 
 
539
class TestBadProtocolServer(object):
707
540
    """Tests bad protocol from server."""
708
541
 
709
 
    _req_handler_class = BadProtocolRequestHandler
710
 
 
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()
 
542
    def create_transport_readonly_server(self):
 
543
        return HttpServer(BadProtocolRequestHandler)
716
544
 
717
545
    def test_http_has(self):
718
546
        server = self.get_readonly_server()
725
553
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
726
554
 
727
555
 
728
 
class ForbiddenRequestHandler(http_server.TestingHTTPRequestHandler):
729
 
    """Whatever request comes in, returns a 403 code"""
730
 
 
731
 
    def parse_request(self):
732
 
        """Handle a single HTTP request, by replying we cannot handle it"""
733
 
        ignored = http_server.TestingHTTPRequestHandler.parse_request(self)
734
 
        self.send_error(403)
735
 
        return False
736
 
 
737
 
 
738
 
class TestForbiddenServer(TestSpecificRequestHandler):
 
556
class TestBadProtocolServer_urllib(TestBadProtocolServer,
 
557
                                   TestCaseWithWebserver):
 
558
    """Tests bad protocol server for urllib implementation"""
 
559
 
 
560
    _transport = HttpTransport_urllib
 
561
 
 
562
# curl don't check the protocol version
 
563
#class TestBadProtocolServer_pycurl(TestWithTransport_pycurl,
 
564
#                                   TestBadProtocolServer,
 
565
#                                   TestCaseWithWebserver):
 
566
#    """Tests bad protocol server for pycurl implementation"""
 
567
 
 
568
 
 
569
class TestForbiddenServer(object):
739
570
    """Tests forbidden server"""
740
571
 
741
 
    _req_handler_class = ForbiddenRequestHandler
 
572
    def create_transport_readonly_server(self):
 
573
        return HttpServer(ForbiddenRequestHandler)
742
574
 
743
575
    def test_http_has(self):
744
576
        server = self.get_readonly_server()
751
583
        self.assertRaises(errors.TransportError, t.get, 'foo/bar')
752
584
 
753
585
 
754
 
class TestRecordingServer(tests.TestCase):
 
586
class TestForbiddenServer_urllib(TestForbiddenServer, TestCaseWithWebserver):
 
587
    """Tests forbidden server for urllib implementation"""
 
588
 
 
589
    _transport = HttpTransport_urllib
 
590
 
 
591
 
 
592
class TestForbiddenServer_pycurl(TestWithTransport_pycurl,
 
593
                                 TestForbiddenServer,
 
594
                                 TestCaseWithWebserver):
 
595
    """Tests forbidden server for pycurl implementation"""
 
596
 
 
597
 
 
598
class TestRecordingServer(TestCase):
755
599
 
756
600
    def test_create(self):
757
601
        server = RecordingServer(expect_body_tail=None)
759
603
        self.assertEqual(None, server.host)
760
604
        self.assertEqual(None, server.port)
761
605
 
762
 
    def test_setUp_and_stop(self):
 
606
    def test_setUp_and_tearDown(self):
763
607
        server = RecordingServer(expect_body_tail=None)
764
 
        server.start_server()
 
608
        server.setUp()
765
609
        try:
766
610
            self.assertNotEqual(None, server.host)
767
611
            self.assertNotEqual(None, server.port)
768
612
        finally:
769
 
            server.stop_server()
 
613
            server.tearDown()
770
614
        self.assertEqual(None, server.host)
771
615
        self.assertEqual(None, server.port)
772
616
 
773
617
    def test_send_receive_bytes(self):
774
 
        server = RecordingServer(expect_body_tail='c', scheme='http')
775
 
        self.start_server(server)
 
618
        server = RecordingServer(expect_body_tail='c')
 
619
        server.setUp()
 
620
        self.addCleanup(server.tearDown)
776
621
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
777
622
        sock.connect((server.host, server.port))
778
623
        sock.sendall('abc')
781
626
        self.assertEqual('abc', server.received_bytes)
782
627
 
783
628
 
784
 
class TestRangeRequestServer(TestSpecificRequestHandler):
 
629
class TestRangeRequestServer(object):
785
630
    """Tests readv requests against server.
786
631
 
787
 
    We test against default "normal" server.
 
632
    This MUST be used by daughter classes that also inherit from
 
633
    TestCaseWithWebserver.
 
634
 
 
635
    We can't inherit directly from TestCaseWithWebserver or the
 
636
    test framework will try to create an instance which cannot
 
637
    run, its implementation being incomplete.
788
638
    """
789
639
 
790
640
    def setUp(self):
791
 
        super(TestRangeRequestServer, self).setUp()
 
641
        TestCaseWithWebserver.setUp(self)
792
642
        self.build_tree_contents([('a', '0123456789')],)
793
643
 
794
644
    def test_readv(self):
823
673
        self.assertListRaises((errors.InvalidRange, errors.ShortReadvError,),
824
674
                              t.readv, 'a', [(12,2)])
825
675
 
826
 
    def test_readv_multiple_get_requests(self):
827
 
        server = self.get_readonly_server()
828
 
        t = self._transport(server.get_url())
829
 
        # force transport to issue multiple requests
830
 
        t._max_readv_combine = 1
831
 
        t._max_get_ranges = 1
832
 
        l = list(t.readv('a', ((0, 1), (1, 1), (3, 2), (9, 1))))
833
 
        self.assertEqual(l[0], (0, '0'))
834
 
        self.assertEqual(l[1], (1, '1'))
835
 
        self.assertEqual(l[2], (3, '34'))
836
 
        self.assertEqual(l[3], (9, '9'))
837
 
        # The server should have issued 4 requests
838
 
        self.assertEqual(4, server.GET_request_nb)
839
 
 
840
 
    def test_readv_get_max_size(self):
841
 
        server = self.get_readonly_server()
842
 
        t = self._transport(server.get_url())
843
 
        # force transport to issue multiple requests by limiting the number of
844
 
        # bytes by request. Note that this apply to coalesced offsets only, a
845
 
        # single range will keep its size even if bigger than the limit.
846
 
        t._get_max_size = 2
847
 
        l = list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
848
 
        self.assertEqual(l[0], (0, '0'))
849
 
        self.assertEqual(l[1], (1, '1'))
850
 
        self.assertEqual(l[2], (2, '2345'))
851
 
        self.assertEqual(l[3], (6, '6789'))
852
 
        # The server should have issued 3 requests
853
 
        self.assertEqual(3, server.GET_request_nb)
854
 
 
855
 
    def test_complete_readv_leave_pipe_clean(self):
856
 
        server = self.get_readonly_server()
857
 
        t = self._transport(server.get_url())
858
 
        # force transport to issue multiple requests
859
 
        t._get_max_size = 2
860
 
        l = list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
861
 
        # The server should have issued 3 requests
862
 
        self.assertEqual(3, server.GET_request_nb)
863
 
        self.assertEqual('0123456789', t.get_bytes('a'))
864
 
        self.assertEqual(4, server.GET_request_nb)
865
 
 
866
 
    def test_incomplete_readv_leave_pipe_clean(self):
867
 
        server = self.get_readonly_server()
868
 
        t = self._transport(server.get_url())
869
 
        # force transport to issue multiple requests
870
 
        t._get_max_size = 2
871
 
        # Don't collapse readv results into a list so that we leave unread
872
 
        # bytes on the socket
873
 
        ireadv = iter(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
874
 
        self.assertEqual((0, '0'), ireadv.next())
875
 
        # The server should have issued one request so far
876
 
        self.assertEqual(1, server.GET_request_nb)
877
 
        self.assertEqual('0123456789', t.get_bytes('a'))
878
 
        # get_bytes issued an additional request, the readv pending ones are
879
 
        # lost
880
 
        self.assertEqual(2, server.GET_request_nb)
881
 
 
882
 
 
883
 
class SingleRangeRequestHandler(http_server.TestingHTTPRequestHandler):
884
 
    """Always reply to range request as if they were single.
885
 
 
886
 
    Don't be explicit about it, just to annoy the clients.
887
 
    """
888
 
 
889
 
    def get_multiple_ranges(self, file, file_size, ranges):
890
 
        """Answer as if it was a single range request and ignores the rest"""
891
 
        (start, end) = ranges[0]
892
 
        return self.get_single_range(file, file_size, start, end)
893
 
 
894
676
 
895
677
class TestSingleRangeRequestServer(TestRangeRequestServer):
896
678
    """Test readv against a server which accept only single range requests"""
897
679
 
898
 
    _req_handler_class = SingleRangeRequestHandler
899
 
 
900
 
 
901
 
class SingleOnlyRangeRequestHandler(http_server.TestingHTTPRequestHandler):
902
 
    """Only reply to simple range requests, errors out on multiple"""
903
 
 
904
 
    def get_multiple_ranges(self, file, file_size, ranges):
905
 
        """Refuses the multiple ranges request"""
906
 
        if len(ranges) > 1:
907
 
            file.close()
908
 
            self.send_error(416, "Requested range not satisfiable")
909
 
            return
910
 
        (start, end) = ranges[0]
911
 
        return self.get_single_range(file, file_size, start, end)
 
680
    def create_transport_readonly_server(self):
 
681
        return HttpServer(SingleRangeRequestHandler)
 
682
 
 
683
 
 
684
class TestSingleRangeRequestServer_urllib(TestSingleRangeRequestServer,
 
685
                                          TestCaseWithWebserver):
 
686
    """Tests single range requests accepting server for urllib implementation"""
 
687
 
 
688
    _transport = HttpTransport_urllib
 
689
 
 
690
 
 
691
class TestSingleRangeRequestServer_pycurl(TestWithTransport_pycurl,
 
692
                                          TestSingleRangeRequestServer,
 
693
                                          TestCaseWithWebserver):
 
694
    """Tests single range requests accepting server for pycurl implementation"""
912
695
 
913
696
 
914
697
class TestSingleOnlyRangeRequestServer(TestRangeRequestServer):
915
698
    """Test readv against a server which only accept single range requests"""
916
699
 
917
 
    _req_handler_class = SingleOnlyRangeRequestHandler
918
 
 
919
 
 
920
 
class NoRangeRequestHandler(http_server.TestingHTTPRequestHandler):
921
 
    """Ignore range requests without notice"""
922
 
 
923
 
    def do_GET(self):
924
 
        # Update the statistics
925
 
        self.server.test_case_server.GET_request_nb += 1
926
 
        # Just bypass the range handling done by TestingHTTPRequestHandler
927
 
        return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
 
700
    def create_transport_readonly_server(self):
 
701
        return HttpServer(SingleOnlyRangeRequestHandler)
 
702
 
 
703
 
 
704
class TestSingleOnlyRangeRequestServer_urllib(TestSingleOnlyRangeRequestServer,
 
705
                                              TestCaseWithWebserver):
 
706
    """Tests single range requests accepting server for urllib implementation"""
 
707
 
 
708
    _transport = HttpTransport_urllib
 
709
 
 
710
 
 
711
class TestSingleOnlyRangeRequestServer_pycurl(TestWithTransport_pycurl,
 
712
                                              TestSingleOnlyRangeRequestServer,
 
713
                                              TestCaseWithWebserver):
 
714
    """Tests single range requests accepting server for pycurl implementation"""
928
715
 
929
716
 
930
717
class TestNoRangeRequestServer(TestRangeRequestServer):
931
718
    """Test readv against a server which do not accept range requests"""
932
719
 
933
 
    _req_handler_class = NoRangeRequestHandler
934
 
 
935
 
 
936
 
class MultipleRangeWithoutContentLengthRequestHandler(
937
 
    http_server.TestingHTTPRequestHandler):
938
 
    """Reply to multiple range requests without content length header."""
939
 
 
940
 
    def get_multiple_ranges(self, file, file_size, ranges):
941
 
        self.send_response(206)
942
 
        self.send_header('Accept-Ranges', 'bytes')
943
 
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
944
 
        self.send_header("Content-Type",
945
 
                         "multipart/byteranges; boundary=%s" % boundary)
946
 
        self.end_headers()
947
 
        for (start, end) in ranges:
948
 
            self.wfile.write("--%s\r\n" % boundary)
949
 
            self.send_header("Content-type", 'application/octet-stream')
950
 
            self.send_header("Content-Range", "bytes %d-%d/%d" % (start,
951
 
                                                                  end,
952
 
                                                                  file_size))
953
 
            self.end_headers()
954
 
            self.send_range_content(file, start, end - start + 1)
955
 
        # Final boundary
956
 
        self.wfile.write("--%s\r\n" % boundary)
957
 
 
958
 
 
959
 
class TestMultipleRangeWithoutContentLengthServer(TestRangeRequestServer):
960
 
 
961
 
    _req_handler_class = MultipleRangeWithoutContentLengthRequestHandler
962
 
 
963
 
 
964
 
class TruncatedMultipleRangeRequestHandler(
965
 
    http_server.TestingHTTPRequestHandler):
966
 
    """Reply to multiple range requests truncating the last ones.
967
 
 
968
 
    This server generates responses whose Content-Length describes all the
969
 
    ranges, but fail to include the last ones leading to client short reads.
970
 
    This has been observed randomly with lighttpd (bug #179368).
971
 
    """
972
 
 
973
 
    _truncated_ranges = 2
974
 
 
975
 
    def get_multiple_ranges(self, file, file_size, ranges):
976
 
        self.send_response(206)
977
 
        self.send_header('Accept-Ranges', 'bytes')
978
 
        boundary = 'tagada'
979
 
        self.send_header('Content-Type',
980
 
                         'multipart/byteranges; boundary=%s' % boundary)
981
 
        boundary_line = '--%s\r\n' % boundary
982
 
        # Calculate the Content-Length
983
 
        content_length = 0
984
 
        for (start, end) in ranges:
985
 
            content_length += len(boundary_line)
986
 
            content_length += self._header_line_length(
987
 
                'Content-type', 'application/octet-stream')
988
 
            content_length += self._header_line_length(
989
 
                'Content-Range', 'bytes %d-%d/%d' % (start, end, file_size))
990
 
            content_length += len('\r\n') # end headers
991
 
            content_length += end - start # + 1
992
 
        content_length += len(boundary_line)
993
 
        self.send_header('Content-length', content_length)
994
 
        self.end_headers()
995
 
 
996
 
        # Send the multipart body
997
 
        cur = 0
998
 
        for (start, end) in ranges:
999
 
            self.wfile.write(boundary_line)
1000
 
            self.send_header('Content-type', 'application/octet-stream')
1001
 
            self.send_header('Content-Range', 'bytes %d-%d/%d'
1002
 
                             % (start, end, file_size))
1003
 
            self.end_headers()
1004
 
            if cur + self._truncated_ranges >= len(ranges):
1005
 
                # Abruptly ends the response and close the connection
1006
 
                self.close_connection = 1
1007
 
                return
1008
 
            self.send_range_content(file, start, end - start + 1)
1009
 
            cur += 1
1010
 
        # No final boundary
1011
 
        self.wfile.write(boundary_line)
1012
 
 
1013
 
 
1014
 
class TestTruncatedMultipleRangeServer(TestSpecificRequestHandler):
1015
 
 
1016
 
    _req_handler_class = TruncatedMultipleRangeRequestHandler
1017
 
 
1018
 
    def setUp(self):
1019
 
        super(TestTruncatedMultipleRangeServer, self).setUp()
1020
 
        self.build_tree_contents([('a', '0123456789')],)
1021
 
 
1022
 
    def test_readv_with_short_reads(self):
1023
 
        server = self.get_readonly_server()
1024
 
        t = self._transport(server.get_url())
1025
 
        # Force separate ranges for each offset
1026
 
        t._bytes_to_read_before_seek = 0
1027
 
        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
1040
 
        self.assertEqual(3, server.GET_request_nb)
1041
 
        # Finally the client have tried a single range request and stays in
1042
 
        # that mode
1043
 
        self.assertEqual('single', t._range_hint)
1044
 
 
1045
 
class LimitedRangeRequestHandler(http_server.TestingHTTPRequestHandler):
1046
 
    """Errors out when range specifiers exceed the limit"""
1047
 
 
1048
 
    def get_multiple_ranges(self, file, file_size, ranges):
1049
 
        """Refuses the multiple ranges request"""
1050
 
        tcs = self.server.test_case_server
1051
 
        if tcs.range_limit is not None and len(ranges) > tcs.range_limit:
1052
 
            file.close()
1053
 
            # Emulate apache behavior
1054
 
            self.send_error(400, "Bad Request")
1055
 
            return
1056
 
        return http_server.TestingHTTPRequestHandler.get_multiple_ranges(
1057
 
            self, file, file_size, ranges)
1058
 
 
1059
 
 
1060
 
class LimitedRangeHTTPServer(http_server.HttpServer):
1061
 
    """An HttpServer erroring out on requests with too much range specifiers"""
1062
 
 
1063
 
    def __init__(self, request_handler=LimitedRangeRequestHandler,
1064
 
                 protocol_version=None,
1065
 
                 range_limit=None):
1066
 
        http_server.HttpServer.__init__(self, request_handler,
1067
 
                                        protocol_version=protocol_version)
1068
 
        self.range_limit = range_limit
1069
 
 
1070
 
 
1071
 
class TestLimitedRangeRequestServer(http_utils.TestCaseWithWebserver):
1072
 
    """Tests readv requests against a server erroring out on too much ranges."""
1073
 
 
1074
 
    # Requests with more range specifiers will error out
1075
 
    range_limit = 3
1076
 
 
1077
720
    def create_transport_readonly_server(self):
1078
 
        return LimitedRangeHTTPServer(range_limit=self.range_limit,
1079
 
                                      protocol_version=self._protocol_version)
1080
 
 
1081
 
    def get_transport(self):
1082
 
        return self._transport(self.get_readonly_server().get_url())
1083
 
 
1084
 
    def setUp(self):
1085
 
        http_utils.TestCaseWithWebserver.setUp(self)
1086
 
        # We need to manipulate ranges that correspond to real chunks in the
1087
 
        # response, so we build a content appropriately.
1088
 
        filler = ''.join(['abcdefghij' for x in range(102)])
1089
 
        content = ''.join(['%04d' % v + filler for v in range(16)])
1090
 
        self.build_tree_contents([('a', content)],)
1091
 
 
1092
 
    def test_few_ranges(self):
1093
 
        t = self.get_transport()
1094
 
        l = list(t.readv('a', ((0, 4), (1024, 4), )))
1095
 
        self.assertEqual(l[0], (0, '0000'))
1096
 
        self.assertEqual(l[1], (1024, '0001'))
1097
 
        self.assertEqual(1, self.get_readonly_server().GET_request_nb)
1098
 
 
1099
 
    def test_more_ranges(self):
1100
 
        t = self.get_transport()
1101
 
        l = list(t.readv('a', ((0, 4), (1024, 4), (4096, 4), (8192, 4))))
1102
 
        self.assertEqual(l[0], (0, '0000'))
1103
 
        self.assertEqual(l[1], (1024, '0001'))
1104
 
        self.assertEqual(l[2], (4096, '0004'))
1105
 
        self.assertEqual(l[3], (8192, '0008'))
1106
 
        # The server will refuse to serve the first request (too much ranges),
1107
 
        # a second request will succeed.
1108
 
        self.assertEqual(2, self.get_readonly_server().GET_request_nb)
1109
 
 
1110
 
 
1111
 
class TestHttpProxyWhiteBox(tests.TestCase):
 
721
        return HttpServer(NoRangeRequestHandler)
 
722
 
 
723
 
 
724
class TestNoRangeRequestServer_urllib(TestNoRangeRequestServer,
 
725
                                      TestCaseWithWebserver):
 
726
    """Tests range requests refusing server for urllib implementation"""
 
727
 
 
728
    _transport = HttpTransport_urllib
 
729
 
 
730
 
 
731
class TestNoRangeRequestServer_pycurl(TestWithTransport_pycurl,
 
732
                               TestNoRangeRequestServer,
 
733
                               TestCaseWithWebserver):
 
734
    """Tests range requests refusing server for pycurl implementation"""
 
735
 
 
736
 
 
737
class TestHttpProxyWhiteBox(TestCase):
1112
738
    """Whitebox test proxy http authorization.
1113
739
 
1114
740
    Only the urllib implementation is tested here.
1115
741
    """
1116
742
 
1117
743
    def setUp(self):
1118
 
        tests.TestCase.setUp(self)
 
744
        TestCase.setUp(self)
1119
745
        self._old_env = {}
1120
746
 
1121
747
    def tearDown(self):
1122
748
        self._restore_env()
1123
 
        tests.TestCase.tearDown(self)
1124
749
 
1125
750
    def _install_env(self, env):
1126
751
        for name, value in env.iteritems():
1131
756
            osutils.set_or_unset_env(name, value)
1132
757
 
1133
758
    def _proxied_request(self):
1134
 
        handler = _urllib2_wrappers.ProxyHandler()
1135
 
        request = _urllib2_wrappers.Request('GET','http://baz/buzzle')
 
759
        handler = ProxyHandler(PasswordManager())
 
760
        request = Request('GET','http://baz/buzzle')
1136
761
        handler.set_proxy(request, 'http')
1137
762
        return request
1138
763
 
1147
772
        self.assertRaises(errors.InvalidURL, self._proxied_request)
1148
773
 
1149
774
 
1150
 
class TestProxyHttpServer(http_utils.TestCaseWithTwoWebservers):
 
775
class TestProxyHttpServer(object):
1151
776
    """Tests proxy server.
1152
777
 
 
778
    This MUST be used by daughter classes that also inherit from
 
779
    TestCaseWithTwoWebservers.
 
780
 
 
781
    We can't inherit directly from TestCaseWithTwoWebservers or
 
782
    the test framework will try to create an instance which
 
783
    cannot run, its implementation being incomplete.
 
784
 
1153
785
    Be aware that we do not setup a real proxy here. Instead, we
1154
786
    check that the *connection* goes through the proxy by serving
1155
787
    different content (the faked proxy server append '-proxied'
1159
791
    # FIXME: We don't have an https server available, so we don't
1160
792
    # test https connections.
1161
793
 
 
794
    # FIXME: Once the test suite is better fitted to test
 
795
    # authorization schemes, test proxy authorizations too (see
 
796
    # bug #83954).
 
797
 
1162
798
    def setUp(self):
1163
 
        super(TestProxyHttpServer, self).setUp()
 
799
        TestCaseWithTwoWebservers.setUp(self)
1164
800
        self.build_tree_contents([('foo', 'contents of foo\n'),
1165
801
                                  ('foo-proxied', 'proxied contents of foo\n')])
1166
802
        # Let's setup some attributes for tests
1167
803
        self.server = self.get_readonly_server()
1168
804
        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
 
805
        self.no_proxy_host = self.proxy_address
1175
806
        # The secondary server is the proxy
1176
807
        self.proxy = self.get_secondary_server()
1177
808
        self.proxy_url = self.proxy.get_url()
1178
809
        self._old_env = {}
1179
810
 
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
811
    def create_transport_secondary_server(self):
1186
812
        """Creates an http server that will serve files with
1187
813
        '-proxied' appended to their names.
1188
814
        """
1189
 
        return http_utils.ProxyServer(protocol_version=self._protocol_version)
 
815
        return ProxyServer()
1190
816
 
1191
817
    def _install_env(self, env):
1192
818
        for name, value in env.iteritems():
1201
827
        url = self.server.get_url()
1202
828
        t = self._transport(url)
1203
829
        try:
1204
 
            self.assertEqual('proxied contents of foo\n', t.get('foo').read())
 
830
            self.assertEqual(t.get('foo').read(), 'proxied contents of foo\n')
1205
831
        finally:
1206
832
            self._restore_env()
1207
833
 
1210
836
        url = self.server.get_url()
1211
837
        t = self._transport(url)
1212
838
        try:
1213
 
            self.assertEqual('contents of foo\n', t.get('foo').read())
 
839
            self.assertEqual(t.get('foo').read(), 'contents of foo\n')
1214
840
        finally:
1215
841
            self._restore_env()
1216
842
 
1218
844
        self.proxied_in_env({'http_proxy': self.proxy_url})
1219
845
 
1220
846
    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
847
        self.proxied_in_env({'HTTP_PROXY': self.proxy_url})
1228
848
 
1229
849
    def test_all_proxy(self):
1237
857
                                 'no_proxy': self.no_proxy_host})
1238
858
 
1239
859
    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
860
        self.not_proxied_in_env({'HTTP_PROXY': self.proxy_url,
1244
861
                                 'NO_PROXY': self.no_proxy_host})
1245
862
 
1252
869
                                 'NO_PROXY': self.no_proxy_host})
1253
870
 
1254
871
    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})
1264
 
 
1265
 
 
1266
 
class TestRanges(http_utils.TestCaseWithWebserver):
1267
 
    """Test the Range header in GET methods."""
1268
 
 
1269
 
    def setUp(self):
1270
 
        http_utils.TestCaseWithWebserver.setUp(self)
 
872
        self.assertRaises(errors.InvalidURL,
 
873
                          self.proxied_in_env,
 
874
                          {'http_proxy': self.proxy_address})
 
875
 
 
876
 
 
877
class TestProxyHttpServer_urllib(TestProxyHttpServer,
 
878
                                 TestCaseWithTwoWebservers):
 
879
    """Tests proxy server for urllib implementation"""
 
880
 
 
881
    _transport = HttpTransport_urllib
 
882
 
 
883
 
 
884
class TestProxyHttpServer_pycurl(TestWithTransport_pycurl,
 
885
                                 TestProxyHttpServer,
 
886
                                 TestCaseWithTwoWebservers):
 
887
    """Tests proxy server for pycurl implementation"""
 
888
 
 
889
    def setUp(self):
 
890
        TestProxyHttpServer.setUp(self)
 
891
        # Oh my ! pycurl does not check for the port as part of
 
892
        # no_proxy :-( So we just test the host part
 
893
        self.no_proxy_host = 'localhost'
 
894
 
 
895
    def test_HTTP_PROXY(self):
 
896
        # pycurl do not check HTTP_PROXY for security reasons
 
897
        # (for use in a CGI context that we do not care
 
898
        # about. Should we ?)
 
899
        raise TestSkipped()
 
900
 
 
901
    def test_HTTP_PROXY_with_NO_PROXY(self):
 
902
        raise TestSkipped()
 
903
 
 
904
    def test_http_proxy_without_scheme(self):
 
905
        # pycurl *ignores* invalid proxy env variables. If that
 
906
        # ever change in the future, this test will fail
 
907
        # indicating that pycurl do not ignore anymore such
 
908
        # variables.
 
909
        self.not_proxied_in_env({'http_proxy': self.proxy_address})
 
910
 
 
911
 
 
912
class TestRanges(object):
 
913
    """Test the Range header in GET methods..
 
914
 
 
915
    This MUST be used by daughter classes that also inherit from
 
916
    TestCaseWithWebserver.
 
917
 
 
918
    We can't inherit directly from TestCaseWithWebserver or the
 
919
    test framework will try to create an instance which cannot
 
920
    run, its implementation being incomplete.
 
921
    """
 
922
 
 
923
    def setUp(self):
 
924
        TestCaseWithWebserver.setUp(self)
1271
925
        self.build_tree_contents([('a', '0123456789')],)
1272
926
        server = self.get_readonly_server()
1273
927
        self.transport = self._transport(server.get_url())
1274
928
 
1275
 
    def create_transport_readonly_server(self):
1276
 
        return http_server.HttpServer(protocol_version=self._protocol_version)
1277
 
 
1278
 
    def _file_contents(self, relpath, ranges):
1279
 
        offsets = [ (start, end - start + 1) for start, end in ranges]
1280
 
        coalesce = self.transport._coalesce_offsets
1281
 
        coalesced = list(coalesce(offsets, limit=0, fudge_factor=0))
1282
 
        code, data = self.transport._get(relpath, coalesced)
1283
 
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
1284
 
        for start, end in ranges:
1285
 
            data.seek(start)
1286
 
            yield data.read(end - start + 1)
 
929
    def _file_contents(self, relpath, ranges, tail_amount=0):
 
930
         code, data = self.transport._get(relpath, ranges)
 
931
         self.assertTrue(code in (200, 206),'_get returns: %d' % code)
 
932
         for start, end in ranges:
 
933
             data.seek(start)
 
934
             yield data.read(end - start + 1)
1287
935
 
1288
936
    def _file_tail(self, relpath, tail_amount):
1289
 
        code, data = self.transport._get(relpath, [], tail_amount)
1290
 
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
1291
 
        data.seek(-tail_amount, 2)
1292
 
        return data.read(tail_amount)
 
937
         code, data = self.transport._get(relpath, [], tail_amount)
 
938
         self.assertTrue(code in (200, 206),'_get returns: %d' % code)
 
939
         data.seek(-tail_amount + 1, 2)
 
940
         return data.read(tail_amount)
1293
941
 
1294
942
    def test_range_header(self):
1295
943
        # Valid ranges
1296
944
        map(self.assertEqual,['0', '234'],
1297
945
            list(self._file_contents('a', [(0,0), (2,4)])),)
1298
 
 
1299
 
    def test_range_header_tail(self):
 
946
        # Tail
1300
947
        self.assertEqual('789', self._file_tail('a', 3))
1301
 
 
1302
 
    def test_syntactically_invalid_range_header(self):
1303
 
        self.assertListRaises(errors.InvalidHttpRange,
1304
 
                          self._file_contents, 'a', [(4, 3)])
1305
 
 
1306
 
    def test_semantically_invalid_range_header(self):
1307
 
        self.assertListRaises(errors.InvalidHttpRange,
1308
 
                          self._file_contents, 'a', [(42, 128)])
1309
 
 
1310
 
 
1311
 
class TestHTTPRedirections(http_utils.TestCaseWithRedirectedWebserver):
1312
 
    """Test redirection between http servers."""
 
948
        # Syntactically invalid range
 
949
        self.assertRaises(errors.InvalidRange,
 
950
                          self.transport._get, 'a', [(4, 3)])
 
951
        # Semantically invalid range
 
952
        self.assertRaises(errors.InvalidRange,
 
953
                          self.transport._get, 'a', [(42, 128)])
 
954
 
 
955
 
 
956
class TestRanges_urllib(TestRanges, TestCaseWithWebserver):
 
957
    """Test the Range header in GET methods for urllib implementation"""
 
958
 
 
959
    _transport = HttpTransport_urllib
 
960
 
 
961
 
 
962
class TestRanges_pycurl(TestWithTransport_pycurl,
 
963
                        TestRanges,
 
964
                        TestCaseWithWebserver):
 
965
    """Test the Range header in GET methods for pycurl implementation"""
 
966
 
 
967
 
 
968
class TestHTTPRedirections(object):
 
969
    """Test redirection between http servers.
 
970
 
 
971
    This MUST be used by daughter classes that also inherit from
 
972
    TestCaseWithRedirectedWebserver.
 
973
 
 
974
    We can't inherit directly from TestCaseWithTwoWebservers or the
 
975
    test framework will try to create an instance which cannot
 
976
    run, its implementation being incomplete. 
 
977
    """
1313
978
 
1314
979
    def create_transport_secondary_server(self):
1315
980
        """Create the secondary server redirecting to the primary server"""
1316
981
        new = self.get_readonly_server()
1317
982
 
1318
 
        redirecting = http_utils.HTTPServerRedirecting(
1319
 
            protocol_version=self._protocol_version)
 
983
        redirecting = HTTPServerRedirecting()
1320
984
        redirecting.redirect_to(new.host, new.port)
1321
985
        return redirecting
1322
986
 
1326
990
                                  ('bundle',
1327
991
                                  '# Bazaar revision bundle v0.9\n#\n')
1328
992
                                  ],)
1329
 
        # The requests to the old server will be redirected to the new server
 
993
 
1330
994
        self.old_transport = self._transport(self.old_server.get_url())
1331
995
 
1332
996
    def test_redirected(self):
1337
1001
    def test_read_redirected_bundle_from_url(self):
1338
1002
        from bzrlib.bundle import read_bundle_from_url
1339
1003
        url = self.old_transport.abspath('bundle')
1340
 
        bundle = self.applyDeprecated(deprecated_in((1, 12, 0)),
1341
 
                read_bundle_from_url, url)
 
1004
        bundle = read_bundle_from_url(url)
1342
1005
        # If read_bundle_from_url was successful we get an empty bundle
1343
1006
        self.assertEqual([], bundle.revisions)
1344
1007
 
1345
1008
 
1346
 
class RedirectedRequest(_urllib2_wrappers.Request):
1347
 
    """Request following redirections. """
1348
 
 
1349
 
    init_orig = _urllib2_wrappers.Request.__init__
 
1009
class TestHTTPRedirections_urllib(TestHTTPRedirections,
 
1010
                                  TestCaseWithRedirectedWebserver):
 
1011
    """Tests redirections for urllib implementation"""
 
1012
 
 
1013
    _transport = HttpTransport_urllib
 
1014
 
 
1015
 
 
1016
 
 
1017
class TestHTTPRedirections_pycurl(TestWithTransport_pycurl,
 
1018
                                  TestHTTPRedirections,
 
1019
                                  TestCaseWithRedirectedWebserver):
 
1020
    """Tests redirections for pycurl implementation"""
 
1021
 
 
1022
 
 
1023
class RedirectedRequest(Request):
 
1024
    """Request following redirections"""
 
1025
 
 
1026
    init_orig = Request.__init__
1350
1027
 
1351
1028
    def __init__(self, method, url, *args, **kwargs):
1352
 
        """Constructor.
1353
 
 
1354
 
        """
1355
 
        # Since the tests using this class will replace
1356
 
        # _urllib2_wrappers.Request, we can't just call the base class __init__
1357
 
        # or we'll loop.
1358
 
        RedirectedRequest.init_orig(self, method, url, *args, **kwargs)
 
1029
        RedirectedRequest.init_orig(self, method, url, args, kwargs)
1359
1030
        self.follow_redirections = True
1360
1031
 
1361
1032
 
1362
 
def install_redirected_request(test):
1363
 
    test.overrideAttr(_urllib2_wrappers, 'Request', RedirectedRequest)
1364
 
 
1365
 
 
1366
 
class TestHTTPSilentRedirections(http_utils.TestCaseWithRedirectedWebserver):
1367
 
    """Test redirections.
 
1033
class TestHTTPSilentRedirections_urllib(TestCaseWithRedirectedWebserver):
 
1034
    """Test redirections provided by urllib.
1368
1035
 
1369
1036
    http implementations do not redirect silently anymore (they
1370
1037
    do not redirect at all in fact). The mechanism is still in
1377
1044
    -- vila 20070212
1378
1045
    """
1379
1046
 
 
1047
    _transport = HttpTransport_urllib
 
1048
 
1380
1049
    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
 
        super(TestHTTPSilentRedirections, self).setUp()
1386
 
        install_redirected_request(self)
 
1050
        super(TestHTTPSilentRedirections_urllib, self).setUp()
 
1051
        self.setup_redirected_request()
 
1052
        self.addCleanup(self.cleanup_redirected_request)
1387
1053
        self.build_tree_contents([('a','a'),
1388
1054
                                  ('1/',),
1389
1055
                                  ('1/a', 'redirected once'),
1399
1065
 
1400
1066
        self.old_transport = self._transport(self.old_server.get_url())
1401
1067
 
 
1068
    def setup_redirected_request(self):
 
1069
        self.original_class = _urllib2_wrappers.Request
 
1070
        _urllib2_wrappers.Request = RedirectedRequest
 
1071
 
 
1072
    def cleanup_redirected_request(self):
 
1073
        _urllib2_wrappers.Request = self.original_class
 
1074
 
1402
1075
    def create_transport_secondary_server(self):
1403
1076
        """Create the secondary server, redirections are defined in the tests"""
1404
 
        return http_utils.HTTPServerRedirecting(
1405
 
            protocol_version=self._protocol_version)
 
1077
        return HTTPServerRedirecting()
1406
1078
 
1407
1079
    def test_one_redirection(self):
1408
1080
        t = self.old_transport
1409
1081
 
1410
1082
        req = RedirectedRequest('GET', t.abspath('a'))
 
1083
        req.follow_redirections = True
1411
1084
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1412
1085
                                       self.new_server.port)
1413
1086
        self.old_server.redirections = \
1414
1087
            [('(.*)', r'%s/1\1' % (new_prefix), 301),]
1415
 
        self.assertEqual('redirected once',t._perform(req).read())
 
1088
        self.assertEquals('redirected once',t._perform(req).read())
1416
1089
 
1417
1090
    def test_five_redirections(self):
1418
1091
        t = self.old_transport
1419
1092
 
1420
1093
        req = RedirectedRequest('GET', t.abspath('a'))
 
1094
        req.follow_redirections = True
1421
1095
        old_prefix = 'http://%s:%s' % (self.old_server.host,
1422
1096
                                       self.old_server.port)
1423
1097
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1424
1098
                                       self.new_server.port)
1425
 
        self.old_server.redirections = [
1426
 
            ('/1(.*)', r'%s/2\1' % (old_prefix), 302),
1427
 
            ('/2(.*)', r'%s/3\1' % (old_prefix), 303),
1428
 
            ('/3(.*)', r'%s/4\1' % (old_prefix), 307),
1429
 
            ('/4(.*)', r'%s/5\1' % (new_prefix), 301),
1430
 
            ('(/[^/]+)', r'%s/1\1' % (old_prefix), 301),
1431
 
            ]
1432
 
        self.assertEqual('redirected 5 times',t._perform(req).read())
1433
 
 
1434
 
 
1435
 
class TestDoCatchRedirections(http_utils.TestCaseWithRedirectedWebserver):
1436
 
    """Test transport.do_catching_redirections."""
 
1099
        self.old_server.redirections = \
 
1100
            [('/1(.*)', r'%s/2\1' % (old_prefix), 302),
 
1101
             ('/2(.*)', r'%s/3\1' % (old_prefix), 303),
 
1102
             ('/3(.*)', r'%s/4\1' % (old_prefix), 307),
 
1103
             ('/4(.*)', r'%s/5\1' % (new_prefix), 301),
 
1104
             ('(/[^/]+)', r'%s/1\1' % (old_prefix), 301),
 
1105
             ]
 
1106
        self.assertEquals('redirected 5 times',t._perform(req).read())
 
1107
 
 
1108
 
 
1109
class TestDoCatchRedirections(TestCaseWithRedirectedWebserver):
 
1110
    """Test transport.do_catching_redirections.
 
1111
 
 
1112
    We arbitrarily choose to use urllib transports
 
1113
    """
 
1114
 
 
1115
    _transport = HttpTransport_urllib
1437
1116
 
1438
1117
    def setUp(self):
1439
1118
        super(TestDoCatchRedirections, self).setUp()
1448
1127
        t = self._transport(self.new_server.get_url())
1449
1128
 
1450
1129
        # We use None for redirected so that we fail if redirected
1451
 
        self.assertEqual('0123456789',
1452
 
                         transport.do_catching_redirections(
1453
 
                self.get_a, t, None).read())
 
1130
        self.assertEquals('0123456789',
 
1131
                          do_catching_redirections(self.get_a, t, None).read())
1454
1132
 
1455
1133
    def test_one_redirection(self):
1456
1134
        self.redirections = 0
1460
1138
            dir, file = urlutils.split(exception.target)
1461
1139
            return self._transport(dir)
1462
1140
 
1463
 
        self.assertEqual('0123456789',
1464
 
                         transport.do_catching_redirections(
1465
 
                self.get_a, self.old_transport, redirected).read())
1466
 
        self.assertEqual(1, self.redirections)
 
1141
        self.assertEquals('0123456789',
 
1142
                          do_catching_redirections(self.get_a,
 
1143
                                                   self.old_transport,
 
1144
                                                   redirected
 
1145
                                                   ).read())
 
1146
        self.assertEquals(1, self.redirections)
1467
1147
 
1468
1148
    def test_redirection_loop(self):
1469
1149
 
1473
1153
            # a/a/a
1474
1154
            return self.old_transport.clone(exception.target)
1475
1155
 
1476
 
        self.assertRaises(errors.TooManyRedirections,
1477
 
                          transport.do_catching_redirections,
 
1156
        self.assertRaises(errors.TooManyRedirections, do_catching_redirections,
1478
1157
                          self.get_a, self.old_transport, redirected)
1479
1158
 
1480
1159
 
1481
 
class TestAuth(http_utils.TestCaseWithWebserver):
1482
 
    """Test authentication scheme"""
 
1160
class TestAuth(object):
 
1161
    """Test some authentication scheme specified by daughter class.
1483
1162
 
1484
 
    _auth_header = 'Authorization'
1485
 
    _password_prompt_prefix = ''
1486
 
    _username_prompt_prefix = ''
1487
 
    # Set by load_tests
1488
 
    _auth_server = None
 
1163
    This MUST be used by daughter classes that also inherit from
 
1164
    either TestCaseWithWebserver or TestCaseWithTwoWebservers.
 
1165
    """
1489
1166
 
1490
1167
    def setUp(self):
1491
 
        super(TestAuth, self).setUp()
1492
 
        self.server = self.get_readonly_server()
 
1168
        """Set up the test environment
 
1169
 
 
1170
        Daughter classes should set up their own environment
 
1171
        (including self.server) and explicitely call this
 
1172
        method. This is needed because we want to reuse the same
 
1173
        tests for proxy and no-proxy accesses which have
 
1174
        different ways of setting self.server.
 
1175
        """
1493
1176
        self.build_tree_contents([('a', 'contents of a\n'),
1494
1177
                                  ('b', 'contents of b\n'),])
1495
 
 
1496
 
    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)
1503
 
 
1504
 
    def get_user_url(self, user, password):
 
1178
        self.old_factory = ui.ui_factory
 
1179
        self.old_stdout = sys.stdout
 
1180
        sys.stdout = StringIOWrapper()
 
1181
        self.addCleanup(self.restoreUIFactory)
 
1182
 
 
1183
    def restoreUIFactory(self):
 
1184
        ui.ui_factory = self.old_factory
 
1185
        sys.stdout = self.old_stdout
 
1186
 
 
1187
    def get_user_url(self, user=None, password=None):
1505
1188
        """Build an url embedding user and password"""
1506
1189
        url = '%s://' % self.server._url_protocol
1507
1190
        if user is not None:
1512
1195
        url += '%s:%s/' % (self.server.host, self.server.port)
1513
1196
        return url
1514
1197
 
1515
 
    def get_user_transport(self, user, password):
1516
 
        return self._transport(self.get_user_url(user, password))
1517
 
 
1518
1198
    def test_no_user(self):
1519
1199
        self.server.add_user('joe', 'foo')
1520
 
        t = self.get_user_transport(None, None)
 
1200
        t = self.get_user_transport()
1521
1201
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'a')
1522
1202
        # Only one 'Authentication Required' error should occur
1523
1203
        self.assertEqual(1, self.server.auth_required_errors)
1553
1233
        # initial 'who are you' and 'this is not you, who are you')
1554
1234
        self.assertEqual(2, self.server.auth_required_errors)
1555
1235
 
1556
 
    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
 
        self.server.add_user('joe', 'foo')
1563
 
        t = self.get_user_transport(None, None)
1564
 
        stdout = tests.StringIOWrapper()
1565
 
        stderr = tests.StringIOWrapper()
1566
 
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n',
1567
 
                                            stdout=stdout, stderr=stderr)
1568
 
        self.assertEqual('contents of a\n',t.get('a').read())
1569
 
        # stdin should be empty
1570
 
        self.assertEqual('', ui.ui_factory.stdin.readline())
1571
 
        stderr.seek(0)
1572
 
        expected_prompt = self._expected_username_prompt(t._unqualified_scheme)
1573
 
        self.assertEqual(expected_prompt, stderr.read(len(expected_prompt)))
1574
 
        self.assertEqual('', stdout.getvalue())
1575
 
        self._check_password_prompt(t._unqualified_scheme, 'joe',
1576
 
                                    stderr.readline())
1577
 
 
1578
1236
    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
1237
        self.server.add_user('joe', 'foo')
1585
1238
        t = self.get_user_transport('joe', None)
1586
 
        stdout = tests.StringIOWrapper()
1587
 
        stderr = tests.StringIOWrapper()
1588
 
        ui.ui_factory = tests.TestUIFactory(stdin='foo\n',
1589
 
                                            stdout=stdout, stderr=stderr)
1590
 
        self.assertEqual('contents of a\n', t.get('a').read())
 
1239
        ui.ui_factory = TestUIFactory(stdin='foo\n')
 
1240
        self.assertEqual('contents of a\n',t.get('a').read())
1591
1241
        # stdin should be empty
1592
1242
        self.assertEqual('', ui.ui_factory.stdin.readline())
1593
 
        self._check_password_prompt(t._unqualified_scheme, 'joe',
1594
 
                                    stderr.getvalue())
1595
 
        self.assertEqual('', stdout.getvalue())
1596
1243
        # And we shouldn't prompt again for a different request
1597
1244
        # against the same transport.
1598
1245
        self.assertEqual('contents of b\n',t.get('b').read())
1602
1249
        # Only one 'Authentication Required' error should occur
1603
1250
        self.assertEqual(1, self.server.auth_required_errors)
1604
1251
 
1605
 
    def _check_password_prompt(self, scheme, user, actual_prompt):
1606
 
        expected_prompt = (self._password_prompt_prefix
1607
 
                           + ("%s %s@%s:%d, Realm: '%s' password: "
1608
 
                              % (scheme.upper(),
1609
 
                                 user, self.server.host, self.server.port,
1610
 
                                 self.server.auth_realm)))
1611
 
        self.assertEqual(expected_prompt, actual_prompt)
1612
 
 
1613
 
    def _expected_username_prompt(self, scheme):
1614
 
        return (self._username_prompt_prefix
1615
 
                + "%s %s:%d, Realm: '%s' username: " % (scheme.upper(),
1616
 
                                 self.server.host, self.server.port,
1617
 
                                 self.server.auth_realm))
1618
 
 
1619
 
    def test_no_prompt_for_password_when_using_auth_config(self):
1620
 
        if self._testing_pycurl():
1621
 
            raise tests.TestNotApplicable(
1622
 
                'pycurl does not support authentication.conf'
1623
 
                ' since it cannot prompt')
1624
 
 
1625
 
        user =' joe'
1626
 
        password = 'foo'
1627
 
        stdin_content = 'bar\n'  # Not the right password
1628
 
        self.server.add_user(user, password)
1629
 
        t = self.get_user_transport(user, None)
1630
 
        ui.ui_factory = tests.TestUIFactory(stdin=stdin_content,
1631
 
                                            stderr=tests.StringIOWrapper())
1632
 
        # 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()
1638
 
        # Issue a request to the server to connect
1639
 
        self.assertEqual('contents of a\n',t.get('a').read())
1640
 
        # stdin should have  been left untouched
1641
 
        self.assertEqual(stdin_content, ui.ui_factory.stdin.readline())
1642
 
        # Only one 'Authentication Required' error should occur
1643
 
        self.assertEqual(1, self.server.auth_required_errors)
1644
 
 
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
 
    def test_changing_nonce(self):
1665
 
        if self._auth_server not in (http_utils.HTTPDigestAuthServer,
1666
 
                                     http_utils.ProxyDigestAuthServer):
1667
 
            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
 
        self.server.add_user('joe', 'foo')
1672
 
        t = self.get_user_transport('joe', 'foo')
1673
 
        self.assertEqual('contents of a\n', t.get('a').read())
1674
 
        self.assertEqual('contents of b\n', t.get('b').read())
1675
 
        # Only one 'Authentication Required' error should have
1676
 
        # occured so far
1677
 
        self.assertEqual(1, self.server.auth_required_errors)
1678
 
        # The server invalidates the current nonce
1679
 
        self.server.auth_nonce = self.server.auth_nonce + '. No, now!'
1680
 
        self.assertEqual('contents of a\n', t.get('a').read())
1681
 
        # Two 'Authentication Required' errors should occur (the
1682
 
        # initial 'who are you' and a second 'who are you' with the new nonce)
1683
 
        self.assertEqual(2, self.server.auth_required_errors)
1684
 
 
 
1252
 
 
1253
class TestHTTPAuth(TestAuth):
 
1254
    """Test HTTP authentication schemes.
 
1255
 
 
1256
    Daughter classes MUST inherit from TestCaseWithWebserver too.
 
1257
    """
 
1258
 
 
1259
    _auth_header = 'Authorization'
 
1260
 
 
1261
    def setUp(self):
 
1262
        TestCaseWithWebserver.setUp(self)
 
1263
        self.server = self.get_readonly_server()
 
1264
        TestAuth.setUp(self)
 
1265
 
 
1266
    def get_user_transport(self, user=None, password=None):
 
1267
        return self._transport(self.get_user_url(user, password))
1685
1268
 
1686
1269
 
1687
1270
class TestProxyAuth(TestAuth):
1688
 
    """Test proxy authentication schemes."""
 
1271
    """Test proxy authentication schemes.
1689
1272
 
 
1273
    Daughter classes MUST also inherit from TestCaseWithWebserver.
 
1274
    """
1690
1275
    _auth_header = 'Proxy-authorization'
1691
 
    _password_prompt_prefix = 'Proxy '
1692
 
    _username_prompt_prefix = 'Proxy '
1693
1276
 
1694
1277
    def setUp(self):
1695
 
        super(TestProxyAuth, self).setUp()
 
1278
        TestCaseWithWebserver.setUp(self)
 
1279
        self.server = self.get_readonly_server()
1696
1280
        self._old_env = {}
1697
1281
        self.addCleanup(self._restore_env)
 
1282
        TestAuth.setUp(self)
1698
1283
        # Override the contents to avoid false positives
1699
1284
        self.build_tree_contents([('a', 'not proxied contents of a\n'),
1700
1285
                                  ('b', 'not proxied contents of b\n'),
1702
1287
                                  ('b-proxied', 'contents of b\n'),
1703
1288
                                  ])
1704
1289
 
1705
 
    def get_user_transport(self, user, password):
 
1290
    def get_user_transport(self, user=None, password=None):
1706
1291
        self._install_env({'all_proxy': self.get_user_url(user, password)})
1707
1292
        return self._transport(self.server.get_url())
1708
1293
 
1714
1299
        for name, value in self._old_env.iteritems():
1715
1300
            osutils.set_or_unset_env(name, value)
1716
1301
 
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()
1724
 
 
1725
 
 
1726
 
class SampleSocket(object):
1727
 
    """A socket-like object for use in testing the HTTP request handler."""
1728
 
 
1729
 
    def __init__(self, socket_read_content):
1730
 
        """Constructs a sample socket.
1731
 
 
1732
 
        :param socket_read_content: a byte sequence
1733
 
        """
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
1740
 
 
1741
 
    def makefile(self, mode='r', bufsize=None):
1742
 
        if 'r' in mode:
1743
 
            return self.readfile
1744
 
        else:
1745
 
            return self.writefile
1746
 
 
1747
 
 
1748
 
class SmartHTTPTunnellingTest(tests.TestCaseWithTransport):
1749
 
 
1750
 
    def setUp(self):
1751
 
        super(SmartHTTPTunnellingTest, self).setUp()
1752
 
        # We use the VFS layer as part of HTTP tunnelling tests.
1753
 
        self._captureVar('BZR_NO_SMART_VFS', None)
1754
 
        self.transport_readonly_server = http_utils.HTTPServerWithSmarts
1755
 
 
1756
 
    def create_transport_readonly_server(self):
1757
 
        return http_utils.HTTPServerWithSmarts(
1758
 
            protocol_version=self._protocol_version)
1759
 
 
1760
 
    def test_open_bzrdir(self):
1761
 
        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)
1765
 
        self.assertIsInstance(bd, _mod_remote.RemoteBzrDir)
1766
 
 
1767
 
    def test_bulk_data(self):
1768
 
        # We should be able to send and receive bulk data in a single message.
1769
 
        # The 'readv' command in the smart protocol both sends and receives
1770
 
        # bulk data, so we use that.
1771
 
        self.build_tree(['data-file'])
1772
 
        http_server = self.get_readonly_server()
1773
 
        http_transport = self._transport(http_server.get_url())
1774
 
        medium = http_transport.get_smart_medium()
1775
 
        # Since we provide the medium, the url below will be mostly ignored
1776
 
        # during the test, as long as the path is '/'.
1777
 
        remote_transport = remote.RemoteTransport('bzr://fake_host/',
1778
 
                                                  medium=medium)
1779
 
        self.assertEqual(
1780
 
            [(0, "c")], list(remote_transport.readv("data-file", [(0,1)])))
1781
 
 
1782
 
    def test_http_send_smart_request(self):
1783
 
 
1784
 
        post_body = 'hello\n'
1785
 
        expected_reply_body = 'ok\x012\n'
1786
 
 
1787
 
        http_server = self.get_readonly_server()
1788
 
        http_transport = self._transport(http_server.get_url())
1789
 
        medium = http_transport.get_smart_medium()
1790
 
        response = medium.send_http_smart_request(post_body)
1791
 
        reply_body = response.read()
1792
 
        self.assertEqual(expected_reply_body, reply_body)
1793
 
 
1794
 
    def test_smart_http_server_post_request_handler(self):
1795
 
        httpd = self.get_readonly_server()._get_httpd()
1796
 
 
1797
 
        socket = SampleSocket(
1798
 
            'POST /.bzr/smart %s \r\n' % self._protocol_version
1799
 
            # HTTP/1.1 posts must have a Content-Length (but it doesn't hurt
1800
 
            # for 1.0)
1801
 
            + 'Content-Length: 6\r\n'
1802
 
            '\r\n'
1803
 
            'hello\n')
1804
 
        # Beware: the ('localhost', 80) below is the
1805
 
        # client_address parameter, but we don't have one because
1806
 
        # we have defined a socket which is not bound to an
1807
 
        # address. The test framework never uses this client
1808
 
        # address, so far...
1809
 
        request_handler = http_utils.SmartRequestHandler(socket,
1810
 
                                                         ('localhost', 80),
1811
 
                                                         httpd)
1812
 
        response = socket.writefile.getvalue()
1813
 
        self.assertStartsWith(response, '%s 200 ' % self._protocol_version)
1814
 
        # This includes the end of the HTTP headers, and all the body.
1815
 
        expected_end_of_response = '\r\n\r\nok\x012\n'
1816
 
        self.assertEndsWith(response, expected_end_of_response)
1817
 
 
1818
 
 
1819
 
class ForbiddenRequestHandler(http_server.TestingHTTPRequestHandler):
1820
 
    """No smart server here request handler."""
1821
 
 
1822
 
    def do_POST(self):
1823
 
        self.send_error(403, "Forbidden")
1824
 
 
1825
 
 
1826
 
class SmartClientAgainstNotSmartServer(TestSpecificRequestHandler):
1827
 
    """Test smart client behaviour against an http server without smarts."""
1828
 
 
1829
 
    _req_handler_class = ForbiddenRequestHandler
1830
 
 
1831
 
    def test_probe_smart_server(self):
1832
 
        """Test error handling against server refusing smart requests."""
1833
 
        server = self.get_readonly_server()
1834
 
        t = self._transport(server.get_url())
1835
 
        # No need to build a valid smart request here, the server will not even
1836
 
        # try to interpret it.
1837
 
        self.assertRaises(errors.SmartProtocolError,
1838
 
                          t.get_smart_medium().send_http_smart_request,
1839
 
                          'whatever')
1840
 
 
1841
 
class Test_redirected_to(tests.TestCase):
1842
 
 
1843
 
    def test_redirected_to_subdir(self):
1844
 
        t = self._transport('http://www.example.com/foo')
1845
 
        r = t._redirected_to('http://www.example.com/foo',
1846
 
                             'http://www.example.com/foo/subdir')
1847
 
        self.assertIsInstance(r, type(t))
1848
 
        # Both transports share the some connection
1849
 
        self.assertEqual(t._get_connection(), r._get_connection())
1850
 
 
1851
 
    def test_redirected_to_self_with_slash(self):
1852
 
        t = self._transport('http://www.example.com/foo')
1853
 
        r = t._redirected_to('http://www.example.com/foo',
1854
 
                             'http://www.example.com/foo/')
1855
 
        self.assertIsInstance(r, type(t))
1856
 
        # Both transports share the some connection (one can argue that we
1857
 
        # should return the exact same transport here, but that seems
1858
 
        # overkill).
1859
 
        self.assertEqual(t._get_connection(), r._get_connection())
1860
 
 
1861
 
    def test_redirected_to_host(self):
1862
 
        t = self._transport('http://www.example.com/foo')
1863
 
        r = t._redirected_to('http://www.example.com/foo',
1864
 
                             'http://foo.example.com/foo/subdir')
1865
 
        self.assertIsInstance(r, type(t))
1866
 
 
1867
 
    def test_redirected_to_same_host_sibling_protocol(self):
1868
 
        t = self._transport('http://www.example.com/foo')
1869
 
        r = t._redirected_to('http://www.example.com/foo',
1870
 
                             'https://www.example.com/foo')
1871
 
        self.assertIsInstance(r, type(t))
1872
 
 
1873
 
    def test_redirected_to_same_host_different_protocol(self):
1874
 
        t = self._transport('http://www.example.com/foo')
1875
 
        r = t._redirected_to('http://www.example.com/foo',
1876
 
                             'ftp://www.example.com/foo')
1877
 
        self.assertNotEquals(type(r), type(t))
1878
 
 
1879
 
    def test_redirected_to_different_host_same_user(self):
1880
 
        t = self._transport('http://joe@www.example.com/foo')
1881
 
        r = t._redirected_to('http://www.example.com/foo',
1882
 
                             'https://foo.example.com/foo')
1883
 
        self.assertIsInstance(r, type(t))
1884
 
        self.assertEqual(t._user, r._user)
1885
 
 
1886
 
 
1887
 
class PredefinedRequestHandler(http_server.TestingHTTPRequestHandler):
1888
 
    """Request handler for a unique and pre-defined request.
1889
 
 
1890
 
    The only thing we care about here is how many bytes travel on the wire. But
1891
 
    since we want to measure it for a real http client, we have to send it
1892
 
    correct responses.
1893
 
 
1894
 
    We expect to receive a *single* request nothing more (and we won't even
1895
 
    check what request it is, we just measure the bytes read until an empty
1896
 
    line.
1897
 
    """
1898
 
 
1899
 
    def handle_one_request(self):
1900
 
        tcs = self.server.test_case_server
1901
 
        requestline = self.rfile.readline()
1902
 
        headers = self.MessageClass(self.rfile, 0)
1903
 
        # We just read: the request, the headers, an empty line indicating the
1904
 
        # end of the headers.
1905
 
        bytes_read = len(requestline)
1906
 
        for line in headers.headers:
1907
 
            bytes_read += len(line)
1908
 
        bytes_read += len('\r\n')
1909
 
        if requestline.startswith('POST'):
1910
 
            # The body should be a single line (or we don't know where it ends
1911
 
            # and we don't want to issue a blocking read)
1912
 
            body = self.rfile.readline()
1913
 
            bytes_read += len(body)
1914
 
        tcs.bytes_read = bytes_read
1915
 
 
1916
 
        # We set the bytes written *before* issuing the write, the client is
1917
 
        # supposed to consume every produced byte *before* checking that value.
1918
 
 
1919
 
        # Doing the oppposite may lead to test failure: we may be interrupted
1920
 
        # after the write but before updating the value. The client can then
1921
 
        # continue and read the value *before* we can update it. And yes,
1922
 
        # this has been observed -- vila 20090129
1923
 
        tcs.bytes_written = len(tcs.canned_response)
1924
 
        self.wfile.write(tcs.canned_response)
1925
 
 
1926
 
 
1927
 
class ActivityServerMixin(object):
1928
 
 
1929
 
    def __init__(self, protocol_version):
1930
 
        super(ActivityServerMixin, self).__init__(
1931
 
            request_handler=PredefinedRequestHandler,
1932
 
            protocol_version=protocol_version)
1933
 
        # Bytes read and written by the server
1934
 
        self.bytes_read = 0
1935
 
        self.bytes_written = 0
1936
 
        self.canned_response = None
1937
 
 
1938
 
 
1939
 
class ActivityHTTPServer(ActivityServerMixin, http_server.HttpServer):
1940
 
    pass
1941
 
 
1942
 
 
1943
 
if tests.HTTPSServerFeature.available():
1944
 
    from bzrlib.tests import https_server
1945
 
    class ActivityHTTPSServer(ActivityServerMixin, https_server.HTTPSServer):
1946
 
        pass
1947
 
 
1948
 
 
1949
 
class TestActivityMixin(object):
1950
 
    """Test socket activity reporting.
1951
 
 
1952
 
    We use a special purpose server to control the bytes sent and received and
1953
 
    be able to predict the activity on the client socket.
1954
 
    """
1955
 
 
1956
 
    def setUp(self):
1957
 
        tests.TestCase.setUp(self)
1958
 
        self.server = self._activity_server(self._protocol_version)
1959
 
        self.server.start_server()
1960
 
        self.activities = {}
1961
 
        def report_activity(t, bytes, direction):
1962
 
            count = self.activities.get(direction, 0)
1963
 
            count += bytes
1964
 
            self.activities[direction] = count
1965
 
 
1966
 
        # We override at class level because constructors may propagate the
1967
 
        # bound method and render instance overriding ineffective (an
1968
 
        # 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)
1976
 
 
1977
 
    def get_transport(self):
1978
 
        return self._transport(self.server.get_url())
1979
 
 
1980
 
    def assertActivitiesMatch(self):
1981
 
        self.assertEqual(self.server.bytes_read,
1982
 
                         self.activities.get('write', 0), 'written bytes')
1983
 
        self.assertEqual(self.server.bytes_written,
1984
 
                         self.activities.get('read', 0), 'read bytes')
1985
 
 
1986
 
    def test_get(self):
1987
 
        self.server.canned_response = '''HTTP/1.1 200 OK\r
1988
 
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
1989
 
Server: Apache/2.0.54 (Fedora)\r
1990
 
Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
1991
 
ETag: "56691-23-38e9ae00"\r
1992
 
Accept-Ranges: bytes\r
1993
 
Content-Length: 35\r
1994
 
Connection: close\r
1995
 
Content-Type: text/plain; charset=UTF-8\r
1996
 
\r
1997
 
Bazaar-NG meta directory, format 1
1998
 
'''
1999
 
        t = self.get_transport()
2000
 
        self.assertEqual('Bazaar-NG meta directory, format 1\n',
2001
 
                         t.get('foo/bar').read())
2002
 
        self.assertActivitiesMatch()
2003
 
 
2004
 
    def test_has(self):
2005
 
        self.server.canned_response = '''HTTP/1.1 200 OK\r
2006
 
Server: SimpleHTTP/0.6 Python/2.5.2\r
2007
 
Date: Thu, 29 Jan 2009 20:21:47 GMT\r
2008
 
Content-type: application/octet-stream\r
2009
 
Content-Length: 20\r
2010
 
Last-Modified: Thu, 29 Jan 2009 20:21:47 GMT\r
2011
 
\r
2012
 
'''
2013
 
        t = self.get_transport()
2014
 
        self.assertTrue(t.has('foo/bar'))
2015
 
        self.assertActivitiesMatch()
2016
 
 
2017
 
    def test_readv(self):
2018
 
        self.server.canned_response = '''HTTP/1.1 206 Partial Content\r
2019
 
Date: Tue, 11 Jul 2006 04:49:48 GMT\r
2020
 
Server: Apache/2.0.54 (Fedora)\r
2021
 
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
2022
 
ETag: "238a3c-16ec2-805c5540"\r
2023
 
Accept-Ranges: bytes\r
2024
 
Content-Length: 1534\r
2025
 
Connection: close\r
2026
 
Content-Type: multipart/byteranges; boundary=418470f848b63279b\r
2027
 
\r
2028
 
\r
2029
 
--418470f848b63279b\r
2030
 
Content-type: text/plain; charset=UTF-8\r
2031
 
Content-range: bytes 0-254/93890\r
2032
 
\r
2033
 
mbp@sourcefrog.net-20050309040815-13242001617e4a06
2034
 
mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e7627
2035
 
mbp@sourcefrog.net-20050309040957-6cad07f466bb0bb8
2036
 
mbp@sourcefrog.net-20050309041501-c840e09071de3b67
2037
 
mbp@sourcefrog.net-20050309044615-c24a3250be83220a
2038
 
\r
2039
 
--418470f848b63279b\r
2040
 
Content-type: text/plain; charset=UTF-8\r
2041
 
Content-range: bytes 1000-2049/93890\r
2042
 
\r
2043
 
40-fd4ec249b6b139ab
2044
 
mbp@sourcefrog.net-20050311063625-07858525021f270b
2045
 
mbp@sourcefrog.net-20050311231934-aa3776aff5200bb9
2046
 
mbp@sourcefrog.net-20050311231953-73aeb3a131c3699a
2047
 
mbp@sourcefrog.net-20050311232353-f5e33da490872c6a
2048
 
mbp@sourcefrog.net-20050312071639-0a8f59a34a024ff0
2049
 
mbp@sourcefrog.net-20050312073432-b2c16a55e0d6e9fb
2050
 
mbp@sourcefrog.net-20050312073831-a47c3335ece1920f
2051
 
mbp@sourcefrog.net-20050312085412-13373aa129ccbad3
2052
 
mbp@sourcefrog.net-20050313052251-2bf004cb96b39933
2053
 
mbp@sourcefrog.net-20050313052856-3edd84094687cb11
2054
 
mbp@sourcefrog.net-20050313053233-e30a4f28aef48f9d
2055
 
mbp@sourcefrog.net-20050313053853-7c64085594ff3072
2056
 
mbp@sourcefrog.net-20050313054757-a86c3f5871069e22
2057
 
mbp@sourcefrog.net-20050313061422-418f1f73b94879b9
2058
 
mbp@sourcefrog.net-20050313120651-497bd231b19df600
2059
 
mbp@sourcefrog.net-20050314024931-eae0170ef25a5d1a
2060
 
mbp@sourcefrog.net-20050314025438-d52099f915fe65fc
2061
 
mbp@sourcefrog.net-20050314025539-637a636692c055cf
2062
 
mbp@sourcefrog.net-20050314025737-55eb441f430ab4ba
2063
 
mbp@sourcefrog.net-20050314025901-d74aa93bb7ee8f62
2064
 
mbp@source\r
2065
 
--418470f848b63279b--\r
2066
 
'''
2067
 
        t = self.get_transport()
2068
 
        # Remember that the request is ignored and that the ranges below
2069
 
        # doesn't have to match the canned response.
2070
 
        l = list(t.readv('/foo/bar', ((0, 255), (1000, 1050))))
2071
 
        self.assertEqual(2, len(l))
2072
 
        self.assertActivitiesMatch()
2073
 
 
2074
 
    def test_post(self):
2075
 
        self.server.canned_response = '''HTTP/1.1 200 OK\r
2076
 
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
2077
 
Server: Apache/2.0.54 (Fedora)\r
2078
 
Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
2079
 
ETag: "56691-23-38e9ae00"\r
2080
 
Accept-Ranges: bytes\r
2081
 
Content-Length: 35\r
2082
 
Connection: close\r
2083
 
Content-Type: text/plain; charset=UTF-8\r
2084
 
\r
2085
 
lalala whatever as long as itsssss
2086
 
'''
2087
 
        t = self.get_transport()
2088
 
        # We must send a single line of body bytes, see
2089
 
        # PredefinedRequestHandler.handle_one_request
2090
 
        code, f = t._post('abc def end-of-body\n')
2091
 
        self.assertEqual('lalala whatever as long as itsssss\n', f.read())
2092
 
        self.assertActivitiesMatch()
2093
 
 
2094
 
 
2095
 
class TestActivity(tests.TestCase, TestActivityMixin):
2096
 
 
2097
 
    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)
2117
 
 
2118
 
 
2119
 
class TestNoReportActivity(tests.TestCase, TestActivityMixin):
2120
 
 
2121
 
    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)
2143
 
 
2144
 
    def assertActivitiesMatch(self):
2145
 
        # Nothing to check here
2146
 
        pass
2147
 
 
2148
 
 
2149
 
class TestAuthOnRedirected(http_utils.TestCaseWithRedirectedWebserver):
2150
 
    """Test authentication on the redirected http server."""
2151
 
 
2152
 
    _auth_header = 'Authorization'
2153
 
    _password_prompt_prefix = ''
2154
 
    _username_prompt_prefix = ''
2155
 
    _auth_server = http_utils.HTTPBasicAuthServer
2156
 
    _transport = _urllib.HttpTransport_urllib
2157
 
 
2158
 
    def create_transport_readonly_server(self):
2159
 
        return self._auth_server()
2160
 
 
2161
 
    def create_transport_secondary_server(self):
2162
 
        """Create the secondary server redirecting to the primary server"""
2163
 
        new = self.get_readonly_server()
2164
 
 
2165
 
        redirecting = http_utils.HTTPServerRedirecting()
2166
 
        redirecting.redirect_to(new.host, new.port)
2167
 
        return redirecting
2168
 
 
2169
 
    def setUp(self):
2170
 
        super(TestAuthOnRedirected, self).setUp()
2171
 
        self.build_tree_contents([('a','a'),
2172
 
                                  ('1/',),
2173
 
                                  ('1/a', 'redirected once'),
2174
 
                                  ],)
2175
 
        new_prefix = 'http://%s:%s' % (self.new_server.host,
2176
 
                                       self.new_server.port)
2177
 
        self.old_server.redirections = [
2178
 
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2179
 
        self.old_transport = self._transport(self.old_server.get_url())
2180
 
        self.new_server.add_user('joe', 'foo')
2181
 
 
2182
 
    def get_a(self, transport):
2183
 
        return transport.get('a')
2184
 
 
2185
 
    def test_auth_on_redirected_via_do_catching_redirections(self):
2186
 
        self.redirections = 0
2187
 
 
2188
 
        def redirected(transport, exception, redirection_notice):
2189
 
            self.redirections += 1
2190
 
            dir, file = urlutils.split(exception.target)
2191
 
            return self._transport(dir)
2192
 
 
2193
 
        stdout = tests.StringIOWrapper()
2194
 
        stderr = tests.StringIOWrapper()
2195
 
        ui.ui_factory = tests.TestUIFactory(stdin='joe\nfoo\n',
2196
 
                                            stdout=stdout, stderr=stderr)
2197
 
        self.assertEqual('redirected once',
2198
 
                         transport.do_catching_redirections(
2199
 
                self.get_a, self.old_transport, redirected).read())
2200
 
        self.assertEqual(1, self.redirections)
2201
 
        # stdin should be empty
2202
 
        self.assertEqual('', ui.ui_factory.stdin.readline())
2203
 
        # stdout should be empty, stderr will contains the prompts
2204
 
        self.assertEqual('', stdout.getvalue())
2205
 
 
2206
 
    def test_auth_on_redirected_via_following_redirections(self):
2207
 
        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)
2212
 
        t = self.old_transport
2213
 
        req = RedirectedRequest('GET', t.abspath('a'))
2214
 
        new_prefix = 'http://%s:%s' % (self.new_server.host,
2215
 
                                       self.new_server.port)
2216
 
        self.old_server.redirections = [
2217
 
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2218
 
        self.assertEqual('redirected once',t._perform(req).read())
2219
 
        # stdin should be empty
2220
 
        self.assertEqual('', ui.ui_factory.stdin.readline())
2221
 
        # stdout should be empty, stderr will contains the prompts
2222
 
        self.assertEqual('', stdout.getvalue())
2223
 
 
 
1302
 
 
1303
class TestHTTPBasicAuth(TestHTTPAuth, TestCaseWithWebserver):
 
1304
    """Test http basic authentication scheme"""
 
1305
 
 
1306
    _transport = HttpTransport_urllib
 
1307
 
 
1308
    def create_transport_readonly_server(self):
 
1309
        return HTTPBasicAuthServer()
 
1310
 
 
1311
 
 
1312
class TestHTTPProxyBasicAuth(TestProxyAuth, TestCaseWithWebserver):
 
1313
    """Test proxy basic authentication scheme"""
 
1314
 
 
1315
    _transport = HttpTransport_urllib
 
1316
 
 
1317
    def create_transport_readonly_server(self):
 
1318
        return ProxyBasicAuthServer()
 
1319
 
 
1320
 
 
1321
class TestDigestAuth(object):
 
1322
    """Digest Authentication specific tests"""
 
1323
 
 
1324
    def test_changing_nonce(self):
 
1325
        self.server.add_user('joe', 'foo')
 
1326
        t = self.get_user_transport('joe', 'foo')
 
1327
        self.assertEqual('contents of a\n', t.get('a').read())
 
1328
        self.assertEqual('contents of b\n', t.get('b').read())
 
1329
        # Only one 'Authentication Required' error should have
 
1330
        # occured so far
 
1331
        self.assertEqual(1, self.server.auth_required_errors)
 
1332
        # The server invalidates the current nonce
 
1333
        self.server.auth_nonce = self.server.auth_nonce + '. No, now!'
 
1334
        self.assertEqual('contents of a\n', t.get('a').read())
 
1335
        # Two 'Authentication Required' errors should occur (the
 
1336
        # initial 'who are you' and a second 'who are you' with the new nonce)
 
1337
        self.assertEqual(2, self.server.auth_required_errors)
 
1338
 
 
1339
 
 
1340
class TestHTTPDigestAuth(TestHTTPAuth, TestDigestAuth, TestCaseWithWebserver):
 
1341
    """Test http digest authentication scheme"""
 
1342
 
 
1343
    _transport = HttpTransport_urllib
 
1344
 
 
1345
    def create_transport_readonly_server(self):
 
1346
        return HTTPDigestAuthServer()
 
1347
 
 
1348
 
 
1349
class TestHTTPProxyDigestAuth(TestProxyAuth, TestDigestAuth,
 
1350
                              TestCaseWithWebserver):
 
1351
    """Test proxy digest authentication scheme"""
 
1352
 
 
1353
    _transport = HttpTransport_urllib
 
1354
 
 
1355
    def create_transport_readonly_server(self):
 
1356
        return ProxyDigestAuthServer()
2224
1357