~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_http.py

  • Committer: Alexander Belchenko
  • Date: 2006-07-30 16:43:12 UTC
  • mto: (1711.2.111 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1906.
  • Revision ID: bialix@ukr.net-20060730164312-b025fd3ff0cee59e
rename  gpl.txt => COPYING.txt

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 Canonical
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
 
# TODO: What about renaming to bzrlib.tests.transport.http ?
25
 
 
26
 
from cStringIO import StringIO
27
 
import httplib
28
 
import os
29
 
import select
30
 
import SimpleHTTPServer
31
 
import socket
32
 
import sys
33
 
import threading
34
21
 
35
22
import bzrlib
36
 
from bzrlib import (
37
 
    bzrdir,
38
 
    config,
39
 
    errors,
40
 
    osutils,
41
 
    remote as _mod_remote,
42
 
    tests,
43
 
    transport,
44
 
    ui,
45
 
    urlutils,
46
 
    )
47
 
from bzrlib.symbol_versioning import (
48
 
    deprecated_in,
49
 
    )
50
 
from bzrlib.tests import (
51
 
    features,
52
 
    http_server,
53
 
    http_utils,
54
 
    )
55
 
from bzrlib.transport import (
56
 
    http,
57
 
    remote,
58
 
    )
59
 
from bzrlib.transport.http import (
60
 
    _urllib,
61
 
    _urllib2_wrappers,
62
 
    )
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
188
 
 
189
 
 
190
 
class FakeManager(object):
 
23
from bzrlib.errors import DependencyNotPresent
 
24
from bzrlib.tests import TestCase, TestSkipped
 
25
from bzrlib.transport import Transport
 
26
from bzrlib.transport.http import extract_auth, HttpTransportBase
 
27
from bzrlib.transport.http._urllib import HttpTransport_urllib
 
28
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
 
29
 
 
30
 
 
31
class FakeManager (object):
191
32
 
192
33
    def __init__(self):
193
34
        self.credentials = []
194
 
 
 
35
        
195
36
    def add_password(self, realm, host, username, password):
196
37
        self.credentials.append([realm, host, username, password])
197
38
 
198
39
 
199
 
class RecordingServer(object):
200
 
    """A fake HTTP server.
201
 
 
202
 
    It records the bytes sent to it, and replies with a 200.
203
 
    """
204
 
 
205
 
    def __init__(self, expect_body_tail=None, scheme=''):
206
 
        """Constructor.
207
 
 
208
 
        :type expect_body_tail: str
209
 
        :param expect_body_tail: a reply won't be sent until this string is
210
 
            received.
211
 
        """
212
 
        self._expect_body_tail = expect_body_tail
213
 
        self.host = None
214
 
        self.port = None
215
 
        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):
222
 
        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
223
 
        self._sock.bind(('127.0.0.1', 0))
224
 
        self.host, self.port = self._sock.getsockname()
225
 
        self._ready = threading.Event()
226
 
        self._thread = threading.Thread(target=self._accept_read_and_reply)
227
 
        self._thread.setDaemon(True)
228
 
        self._thread.start()
229
 
        self._ready.wait(5)
230
 
 
231
 
    def _accept_read_and_reply(self):
232
 
        self._sock.listen(1)
233
 
        self._ready.set()
234
 
        self._sock.settimeout(5)
235
 
        try:
236
 
            conn, address = self._sock.accept()
237
 
            # On win32, the accepted connection will be non-blocking to start
238
 
            # with because we're using settimeout.
239
 
            conn.setblocking(True)
240
 
            while not self.received_bytes.endswith(self._expect_body_tail):
241
 
                self.received_bytes += conn.recv(4096)
242
 
            conn.sendall('HTTP/1.1 200 OK\r\n')
243
 
        except socket.timeout:
244
 
            # Make sure the client isn't stuck waiting for us to e.g. accept.
245
 
            self._sock.close()
246
 
        except socket.error:
247
 
            # The client may have already closed the socket.
248
 
            pass
249
 
 
250
 
    def stop_server(self):
251
 
        try:
252
 
            self._sock.close()
253
 
        except socket.error:
254
 
            # We might have already closed it.  We don't care.
255
 
            pass
256
 
        self.host = None
257
 
        self.port = None
258
 
 
259
 
 
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
 
class TestWithTransport_pycurl(object):
374
 
    """Test case to inherit from if pycurl is present"""
375
 
 
376
 
    def _get_pycurl_maybe(self):
377
 
        self.requireFeature(features.pycurl)
378
 
        return PyCurlTransport
379
 
 
380
 
    _transport = property(_get_pycurl_maybe)
381
 
 
382
 
 
383
 
class TestHttpUrls(tests.TestCase):
384
 
 
385
 
    # TODO: This should be moved to authorization tests once they
386
 
    # are written.
 
40
class TestHttpUrls(TestCase):
387
41
 
388
42
    def test_url_parsing(self):
389
43
        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."""
403
 
 
 
44
        url = extract_auth('http://example.com', f)
 
45
        self.assertEquals('http://example.com', url)
 
46
        self.assertEquals(0, len(f.credentials))
 
47
        url = extract_auth('http://user:pass@www.bazaar-vcs.org/bzr/bzr.dev', f)
 
48
        self.assertEquals('http://www.bazaar-vcs.org/bzr/bzr.dev', url)
 
49
        self.assertEquals(1, len(f.credentials))
 
50
        self.assertEquals([None, 'www.bazaar-vcs.org', 'user', 'pass'], f.credentials[0])
 
51
        
404
52
    def test_abs_url(self):
405
53
        """Construction of absolute http URLs"""
406
 
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
 
54
        t = HttpTransport_urllib('http://bazaar-vcs.org/bzr/bzr.dev/')
407
55
        eq = self.assertEqualDiff
408
 
        eq(t.abspath('.'), 'http://bazaar-vcs.org/bzr/bzr.dev')
409
 
        eq(t.abspath('foo/bar'), 'http://bazaar-vcs.org/bzr/bzr.dev/foo/bar')
410
 
        eq(t.abspath('.bzr'), 'http://bazaar-vcs.org/bzr/bzr.dev/.bzr')
 
56
        eq(t.abspath('.'),
 
57
           'http://bazaar-vcs.org/bzr/bzr.dev')
 
58
        eq(t.abspath('foo/bar'), 
 
59
           'http://bazaar-vcs.org/bzr/bzr.dev/foo/bar')
 
60
        eq(t.abspath('.bzr'),
 
61
           'http://bazaar-vcs.org/bzr/bzr.dev/.bzr')
411
62
        eq(t.abspath('.bzr/1//2/./3'),
412
63
           'http://bazaar-vcs.org/bzr/bzr.dev/.bzr/1/2/3')
413
64
 
414
65
    def test_invalid_http_urls(self):
415
66
        """Trap invalid construction of urls"""
416
 
        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/')
 
67
        t = HttpTransport_urllib('http://bazaar-vcs.org/bzr/bzr.dev/')
 
68
        self.assertRaises(ValueError,
 
69
            t.abspath,
 
70
            '.bzr/')
 
71
        self.assertRaises(ValueError,
 
72
            t.abspath,
 
73
            '/.bzr')
420
74
 
421
75
    def test_http_root_urls(self):
422
76
        """Construction of URLs from server root"""
423
 
        t = self._transport('http://bzr.ozlabs.org/')
 
77
        t = HttpTransport_urllib('http://bzr.ozlabs.org/')
424
78
        eq = self.assertEqualDiff
425
79
        eq(t.abspath('.bzr/tree-version'),
426
80
           'http://bzr.ozlabs.org/.bzr/tree-version')
427
81
 
428
82
    def test_http_impl_urls(self):
429
83
        """There are servers which ask for particular clients to connect"""
430
 
        server = self._server()
431
 
        server.start_server()
432
84
        try:
433
 
            url = server.get_url()
434
 
            self.assertTrue(url.startswith('%s://' % self._qualified_prefix))
435
 
        finally:
436
 
            server.stop_server()
437
 
 
438
 
 
439
 
class TestHttps_pycurl(TestWithTransport_pycurl, tests.TestCase):
440
 
 
441
 
    # TODO: This should really be moved into another pycurl
442
 
    # specific test. When https tests will be implemented, take
443
 
    # this one into account.
444
 
    def test_pycurl_without_https_support(self):
445
 
        """Test that pycurl without SSL do not fail with a traceback.
446
 
 
447
 
        For the purpose of the test, we force pycurl to ignore
448
 
        https by supplying a fake version_info that do not
449
 
        support it.
450
 
        """
451
 
        self.requireFeature(features.pycurl)
452
 
        # Import the module locally now that we now it's available.
453
 
        pycurl = features.pycurl.module
454
 
 
455
 
        self.overrideAttr(pycurl, 'version_info',
456
 
                          # Fake the pycurl version_info This was taken from
457
 
                          # a windows pycurl without SSL (thanks to bialix)
458
 
                          lambda : (2,
459
 
                                    '7.13.2',
460
 
                                    462082,
461
 
                                    'i386-pc-win32',
462
 
                                    2576,
463
 
                                    None,
464
 
                                    0,
465
 
                                    None,
466
 
                                    ('ftp', 'gopher', 'telnet',
467
 
                                     'dict', 'ldap', 'http', 'file'),
468
 
                                    None,
469
 
                                    0,
470
 
                                    None))
471
 
        self.assertRaises(errors.DependencyNotPresent, self._transport,
472
 
                          'https://launchpad.net')
473
 
 
474
 
 
475
 
class TestHTTPConnections(http_utils.TestCaseWithWebserver):
476
 
    """Test the http connections."""
477
 
 
478
 
    def setUp(self):
479
 
        http_utils.TestCaseWithWebserver.setUp(self)
480
 
        self.build_tree(['foo/', 'foo/bar'], line_endings='binary',
 
85
            from bzrlib.transport.http._pycurl import HttpServer_PyCurl
 
86
            server = HttpServer_PyCurl()
 
87
            try:
 
88
                server.setUp()
 
89
                url = server.get_url()
 
90
                self.assertTrue(url.startswith('http+pycurl://'))
 
91
            finally:
 
92
                server.tearDown()
 
93
        except DependencyNotPresent:
 
94
            raise TestSkipped('pycurl not present')
 
95
 
 
96
 
 
97
class TestHttpMixins(object):
 
98
 
 
99
    def _prep_tree(self):
 
100
        self.build_tree(['xxx', 'foo/', 'foo/bar'], line_endings='binary',
481
101
                        transport=self.get_transport())
482
102
 
483
103
    def test_http_has(self):
485
105
        t = self._transport(server.get_url())
486
106
        self.assertEqual(t.has('foo/bar'), True)
487
107
        self.assertEqual(len(server.logs), 1)
488
 
        self.assertContainsRe(server.logs[0],
 
108
        self.assertContainsRe(server.logs[0], 
489
109
            r'"HEAD /foo/bar HTTP/1.." (200|302) - "-" "bzr/')
490
110
 
491
111
    def test_http_has_not_found(self):
492
112
        server = self.get_readonly_server()
493
113
        t = self._transport(server.get_url())
494
114
        self.assertEqual(t.has('not-found'), False)
495
 
        self.assertContainsRe(server.logs[1],
 
115
        self.assertContainsRe(server.logs[1], 
496
116
            r'"HEAD /not-found HTTP/1.." 404 - "-" "bzr/')
497
117
 
498
118
    def test_http_get(self):
504
124
            'contents of foo/bar\n')
505
125
        self.assertEqual(len(server.logs), 1)
506
126
        self.assertTrue(server.logs[0].find(
507
 
            '"GET /foo/bar HTTP/1.1" 200 - "-" "bzr/%s'
508
 
            % bzrlib.__version__) > -1)
509
 
 
510
 
    def test_has_on_bogus_host(self):
511
 
        # Get a free address and don't 'accept' on it, so that we
512
 
        # can be sure there is no http handler there, but set a
513
 
        # reasonable timeout to not slow down tests too much.
514
 
        default_timeout = socket.getdefaulttimeout()
 
127
            '"GET /foo/bar HTTP/1.1" 200 - "-" "bzr/%s' % bzrlib.__version__) > -1)
 
128
 
 
129
 
 
130
class TestHttpConnections_urllib(TestCaseWithWebserver, TestHttpMixins):
 
131
 
 
132
    _transport = HttpTransport_urllib
 
133
 
 
134
    def setUp(self):
 
135
        TestCaseWithWebserver.setUp(self)
 
136
        self._prep_tree()
 
137
 
 
138
 
 
139
 
 
140
class TestHttpConnections_pycurl(TestCaseWithWebserver, TestHttpMixins):
 
141
 
 
142
    def _get_pycurl_maybe(self):
515
143
        try:
516
 
            socket.setdefaulttimeout(2)
517
 
            s = socket.socket()
518
 
            s.bind(('localhost', 0))
519
 
            t = self._transport('http://%s:%s/' % s.getsockname())
520
 
            self.assertRaises(errors.ConnectionError, t.has, 'foo/bar')
521
 
        finally:
522
 
            socket.setdefaulttimeout(default_timeout)
523
 
 
524
 
 
525
 
class TestHttpTransportRegistration(tests.TestCase):
 
144
            from bzrlib.transport.http._pycurl import PyCurlTransport
 
145
            return PyCurlTransport
 
146
        except DependencyNotPresent:
 
147
            raise TestSkipped('pycurl not present')
 
148
 
 
149
    _transport = property(_get_pycurl_maybe)
 
150
 
 
151
    def setUp(self):
 
152
        TestCaseWithWebserver.setUp(self)
 
153
        self._prep_tree()
 
154
 
 
155
 
 
156
 
 
157
class TestHttpTransportRegistration(TestCase):
526
158
    """Test registrations of various http implementations"""
527
159
 
528
160
    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)
542
 
        code, response = http_transport._post('abc def end-of-body')
543
 
        self.assertTrue(
544
 
            server.received_bytes.startswith('POST /.bzr/smart HTTP/1.'))
545
 
        self.assertTrue('content-length: 19\r' in server.received_bytes.lower())
546
 
        # The transport should not be assuming that the server can accept
547
 
        # chunked encoding the first time it connects, because HTTP/1.1, so we
548
 
        # check for the literal string.
549
 
        self.assertTrue(
550
 
            server.received_bytes.endswith('\r\n\r\nabc def end-of-body'))
551
 
 
552
 
 
553
 
class TestRangeHeader(tests.TestCase):
 
161
        import bzrlib.transport.http._urllib
 
162
        from bzrlib.transport import get_transport
 
163
        # urlllib should always be present
 
164
        t = get_transport('http+urllib://bzr.google.com/')
 
165
        self.assertIsInstance(t, Transport)
 
166
        self.assertIsInstance(t, bzrlib.transport.http._urllib.HttpTransport_urllib)
 
167
 
 
168
 
 
169
class TestOffsets(TestCase):
 
170
    """Test offsets_to_ranges method"""
 
171
 
 
172
    def test_offsets_to_ranges_simple(self):
 
173
        to_range = HttpTransportBase.offsets_to_ranges
 
174
        ranges = to_range([(10, 1)])
 
175
        self.assertEqual([[10, 10]], ranges)
 
176
 
 
177
        ranges = to_range([(0, 1), (1, 1)])
 
178
        self.assertEqual([[0, 1]], ranges)
 
179
 
 
180
        ranges = to_range([(1, 1), (0, 1)])
 
181
        self.assertEqual([[0, 1]], ranges)
 
182
 
 
183
    def test_offset_to_ranges_overlapped(self):
 
184
        to_range = HttpTransportBase.offsets_to_ranges
 
185
 
 
186
        ranges = to_range([(10, 1), (20, 2), (22, 5)])
 
187
        self.assertEqual([[10, 10], [20, 26]], ranges)
 
188
 
 
189
        ranges = to_range([(10, 1), (11, 2), (22, 5)])
 
190
        self.assertEqual([[10, 12], [22, 26]], ranges)
 
191
 
 
192
 
 
193
class TestRangeHeader(TestCase):
554
194
    """Test range_header method"""
555
195
 
556
196
    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))
 
197
        range_header = HttpTransportBase.range_header
 
198
        self.assertEqual(value, range_header(ranges, tail))
562
199
 
563
200
    def test_range_header_single(self):
564
 
        self.check_header('0-9', ranges=[(0,9)])
565
 
        self.check_header('100-109', ranges=[(100,109)])
 
201
        self.check_header('0-9', ranges=[[0,9]])
 
202
        self.check_header('100-109', ranges=[[100,109]])
566
203
 
567
204
    def test_range_header_tail(self):
568
205
        self.check_header('-10', tail=10)
576
213
        self.check_header('0-9,300-5000,-50',
577
214
                          ranges=[(0,9), (300,5000)],
578
215
                          tail=50)
579
 
 
580
 
 
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):
609
 
    """Tests exceptions during the connection phase"""
610
 
 
611
 
    _req_handler_class = WallRequestHandler
612
 
 
613
 
    def test_http_has(self):
614
 
        server = self.get_readonly_server()
615
 
        t = self._transport(server.get_url())
616
 
        # Unfortunately httplib (see HTTPResponse._read_status
617
 
        # for details) make no distinction between a closed
618
 
        # socket and badly formatted status line, so we can't
619
 
        # 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),
624
 
                          t.has, 'foo/bar')
625
 
 
626
 
    def test_http_get(self):
627
 
        server = self.get_readonly_server()
628
 
        t = self._transport(server.get_url())
629
 
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
630
 
                           errors.InvalidHttpResponse),
631
 
                          t.get, 'foo/bar')
632
 
 
633
 
 
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):
646
 
    """Tests bad status from server."""
647
 
 
648
 
    _req_handler_class = BadStatusRequestHandler
649
 
 
650
 
    def test_http_has(self):
651
 
        server = self.get_readonly_server()
652
 
        t = self._transport(server.get_url())
653
 
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
654
 
 
655
 
    def test_http_get(self):
656
 
        server = self.get_readonly_server()
657
 
        t = self._transport(server.get_url())
658
 
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
659
 
 
660
 
 
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
669
 
 
670
 
 
671
 
class TestInvalidStatusServer(TestBadStatusServer):
672
 
    """Tests invalid status from server.
673
 
 
674
 
    Both implementations raises the same error as for a bad status.
675
 
    """
676
 
 
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):
707
 
    """Tests bad protocol from server."""
708
 
 
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()
716
 
 
717
 
    def test_http_has(self):
718
 
        server = self.get_readonly_server()
719
 
        t = self._transport(server.get_url())
720
 
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
721
 
 
722
 
    def test_http_get(self):
723
 
        server = self.get_readonly_server()
724
 
        t = self._transport(server.get_url())
725
 
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
726
 
 
727
 
 
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):
739
 
    """Tests forbidden server"""
740
 
 
741
 
    _req_handler_class = ForbiddenRequestHandler
742
 
 
743
 
    def test_http_has(self):
744
 
        server = self.get_readonly_server()
745
 
        t = self._transport(server.get_url())
746
 
        self.assertRaises(errors.TransportError, t.has, 'foo/bar')
747
 
 
748
 
    def test_http_get(self):
749
 
        server = self.get_readonly_server()
750
 
        t = self._transport(server.get_url())
751
 
        self.assertRaises(errors.TransportError, t.get, 'foo/bar')
752
 
 
753
 
 
754
 
class TestRecordingServer(tests.TestCase):
755
 
 
756
 
    def test_create(self):
757
 
        server = RecordingServer(expect_body_tail=None)
758
 
        self.assertEqual('', server.received_bytes)
759
 
        self.assertEqual(None, server.host)
760
 
        self.assertEqual(None, server.port)
761
 
 
762
 
    def test_setUp_and_stop(self):
763
 
        server = RecordingServer(expect_body_tail=None)
764
 
        server.start_server()
765
 
        try:
766
 
            self.assertNotEqual(None, server.host)
767
 
            self.assertNotEqual(None, server.port)
768
 
        finally:
769
 
            server.stop_server()
770
 
        self.assertEqual(None, server.host)
771
 
        self.assertEqual(None, server.port)
772
 
 
773
 
    def test_send_receive_bytes(self):
774
 
        server = RecordingServer(expect_body_tail='c', scheme='http')
775
 
        self.start_server(server)
776
 
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
777
 
        sock.connect((server.host, server.port))
778
 
        sock.sendall('abc')
779
 
        self.assertEqual('HTTP/1.1 200 OK\r\n',
780
 
                         osutils.recv_all(sock, 4096))
781
 
        self.assertEqual('abc', server.received_bytes)
782
 
 
783
 
 
784
 
class TestRangeRequestServer(TestSpecificRequestHandler):
785
 
    """Tests readv requests against server.
786
 
 
787
 
    We test against default "normal" server.
788
 
    """
789
 
 
790
 
    def setUp(self):
791
 
        super(TestRangeRequestServer, self).setUp()
792
 
        self.build_tree_contents([('a', '0123456789')],)
793
 
 
794
 
    def test_readv(self):
795
 
        server = self.get_readonly_server()
796
 
        t = self._transport(server.get_url())
797
 
        l = list(t.readv('a', ((0, 1), (1, 1), (3, 2), (9, 1))))
798
 
        self.assertEqual(l[0], (0, '0'))
799
 
        self.assertEqual(l[1], (1, '1'))
800
 
        self.assertEqual(l[2], (3, '34'))
801
 
        self.assertEqual(l[3], (9, '9'))
802
 
 
803
 
    def test_readv_out_of_order(self):
804
 
        server = self.get_readonly_server()
805
 
        t = self._transport(server.get_url())
806
 
        l = list(t.readv('a', ((1, 1), (9, 1), (0, 1), (3, 2))))
807
 
        self.assertEqual(l[0], (1, '1'))
808
 
        self.assertEqual(l[1], (9, '9'))
809
 
        self.assertEqual(l[2], (0, '0'))
810
 
        self.assertEqual(l[3], (3, '34'))
811
 
 
812
 
    def test_readv_invalid_ranges(self):
813
 
        server = self.get_readonly_server()
814
 
        t = self._transport(server.get_url())
815
 
 
816
 
        # This is intentionally reading off the end of the file
817
 
        # since we are sure that it cannot get there
818
 
        self.assertListRaises((errors.InvalidRange, errors.ShortReadvError,),
819
 
                              t.readv, 'a', [(1,1), (8,10)])
820
 
 
821
 
        # This is trying to seek past the end of the file, it should
822
 
        # also raise a special error
823
 
        self.assertListRaises((errors.InvalidRange, errors.ShortReadvError,),
824
 
                              t.readv, 'a', [(12,2)])
825
 
 
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
 
 
895
 
class TestSingleRangeRequestServer(TestRangeRequestServer):
896
 
    """Test readv against a server which accept only single range requests"""
897
 
 
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)
912
 
 
913
 
 
914
 
class TestSingleOnlyRangeRequestServer(TestRangeRequestServer):
915
 
    """Test readv against a server which only accept single range requests"""
916
 
 
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)
928
 
 
929
 
 
930
 
class TestNoRangeRequestServer(TestRangeRequestServer):
931
 
    """Test readv against a server which do not accept range requests"""
932
 
 
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
 
    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):
1112
 
    """Whitebox test proxy http authorization.
1113
 
 
1114
 
    Only the urllib implementation is tested here.
1115
 
    """
1116
 
 
1117
 
    def setUp(self):
1118
 
        tests.TestCase.setUp(self)
1119
 
        self._old_env = {}
1120
 
 
1121
 
    def tearDown(self):
1122
 
        self._restore_env()
1123
 
        tests.TestCase.tearDown(self)
1124
 
 
1125
 
    def _install_env(self, env):
1126
 
        for name, value in env.iteritems():
1127
 
            self._old_env[name] = osutils.set_or_unset_env(name, value)
1128
 
 
1129
 
    def _restore_env(self):
1130
 
        for name, value in self._old_env.iteritems():
1131
 
            osutils.set_or_unset_env(name, value)
1132
 
 
1133
 
    def _proxied_request(self):
1134
 
        handler = _urllib2_wrappers.ProxyHandler()
1135
 
        request = _urllib2_wrappers.Request('GET','http://baz/buzzle')
1136
 
        handler.set_proxy(request, 'http')
1137
 
        return request
1138
 
 
1139
 
    def test_empty_user(self):
1140
 
        self._install_env({'http_proxy': 'http://bar.com'})
1141
 
        request = self._proxied_request()
1142
 
        self.assertFalse(request.headers.has_key('Proxy-authorization'))
1143
 
 
1144
 
    def test_invalid_proxy(self):
1145
 
        """A proxy env variable without scheme"""
1146
 
        self._install_env({'http_proxy': 'host:1234'})
1147
 
        self.assertRaises(errors.InvalidURL, self._proxied_request)
1148
 
 
1149
 
 
1150
 
class TestProxyHttpServer(http_utils.TestCaseWithTwoWebservers):
1151
 
    """Tests proxy server.
1152
 
 
1153
 
    Be aware that we do not setup a real proxy here. Instead, we
1154
 
    check that the *connection* goes through the proxy by serving
1155
 
    different content (the faked proxy server append '-proxied'
1156
 
    to the file names).
1157
 
    """
1158
 
 
1159
 
    # FIXME: We don't have an https server available, so we don't
1160
 
    # test https connections.
1161
 
 
1162
 
    def setUp(self):
1163
 
        super(TestProxyHttpServer, self).setUp()
1164
 
        self.build_tree_contents([('foo', 'contents of foo\n'),
1165
 
                                  ('foo-proxied', 'proxied contents of foo\n')])
1166
 
        # Let's setup some attributes for tests
1167
 
        self.server = self.get_readonly_server()
1168
 
        self.proxy_address = '%s:%d' % (self.server.host, self.server.port)
1169
 
        if self._testing_pycurl():
1170
 
            # Oh my ! pycurl does not check for the port as part of
1171
 
            # no_proxy :-( So we just test the host part
1172
 
            self.no_proxy_host = self.server.host
1173
 
        else:
1174
 
            self.no_proxy_host = self.proxy_address
1175
 
        # The secondary server is the proxy
1176
 
        self.proxy = self.get_secondary_server()
1177
 
        self.proxy_url = self.proxy.get_url()
1178
 
        self._old_env = {}
1179
 
 
1180
 
    def _testing_pycurl(self):
1181
 
        # TODO: This is duplicated for lots of the classes in this file
1182
 
        return (features.pycurl.available()
1183
 
                and self._transport == PyCurlTransport)
1184
 
 
1185
 
    def create_transport_secondary_server(self):
1186
 
        """Creates an http server that will serve files with
1187
 
        '-proxied' appended to their names.
1188
 
        """
1189
 
        return http_utils.ProxyServer(protocol_version=self._protocol_version)
1190
 
 
1191
 
    def _install_env(self, env):
1192
 
        for name, value in env.iteritems():
1193
 
            self._old_env[name] = osutils.set_or_unset_env(name, value)
1194
 
 
1195
 
    def _restore_env(self):
1196
 
        for name, value in self._old_env.iteritems():
1197
 
            osutils.set_or_unset_env(name, value)
1198
 
 
1199
 
    def proxied_in_env(self, env):
1200
 
        self._install_env(env)
1201
 
        url = self.server.get_url()
1202
 
        t = self._transport(url)
1203
 
        try:
1204
 
            self.assertEqual('proxied contents of foo\n', t.get('foo').read())
1205
 
        finally:
1206
 
            self._restore_env()
1207
 
 
1208
 
    def not_proxied_in_env(self, env):
1209
 
        self._install_env(env)
1210
 
        url = self.server.get_url()
1211
 
        t = self._transport(url)
1212
 
        try:
1213
 
            self.assertEqual('contents of foo\n', t.get('foo').read())
1214
 
        finally:
1215
 
            self._restore_env()
1216
 
 
1217
 
    def test_http_proxy(self):
1218
 
        self.proxied_in_env({'http_proxy': self.proxy_url})
1219
 
 
1220
 
    def test_HTTP_PROXY(self):
1221
 
        if self._testing_pycurl():
1222
 
            # pycurl does not check HTTP_PROXY for security reasons
1223
 
            # (for use in a CGI context that we do not care
1224
 
            # about. Should we ?)
1225
 
            raise tests.TestNotApplicable(
1226
 
                'pycurl does not check HTTP_PROXY for security reasons')
1227
 
        self.proxied_in_env({'HTTP_PROXY': self.proxy_url})
1228
 
 
1229
 
    def test_all_proxy(self):
1230
 
        self.proxied_in_env({'all_proxy': self.proxy_url})
1231
 
 
1232
 
    def test_ALL_PROXY(self):
1233
 
        self.proxied_in_env({'ALL_PROXY': self.proxy_url})
1234
 
 
1235
 
    def test_http_proxy_with_no_proxy(self):
1236
 
        self.not_proxied_in_env({'http_proxy': self.proxy_url,
1237
 
                                 'no_proxy': self.no_proxy_host})
1238
 
 
1239
 
    def test_HTTP_PROXY_with_NO_PROXY(self):
1240
 
        if self._testing_pycurl():
1241
 
            raise tests.TestNotApplicable(
1242
 
                'pycurl does not check HTTP_PROXY for security reasons')
1243
 
        self.not_proxied_in_env({'HTTP_PROXY': self.proxy_url,
1244
 
                                 'NO_PROXY': self.no_proxy_host})
1245
 
 
1246
 
    def test_all_proxy_with_no_proxy(self):
1247
 
        self.not_proxied_in_env({'all_proxy': self.proxy_url,
1248
 
                                 'no_proxy': self.no_proxy_host})
1249
 
 
1250
 
    def test_ALL_PROXY_with_NO_PROXY(self):
1251
 
        self.not_proxied_in_env({'ALL_PROXY': self.proxy_url,
1252
 
                                 'NO_PROXY': self.no_proxy_host})
1253
 
 
1254
 
    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)
1271
 
        self.build_tree_contents([('a', '0123456789')],)
1272
 
        server = self.get_readonly_server()
1273
 
        self.transport = self._transport(server.get_url())
1274
 
 
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)
1287
 
 
1288
 
    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)
1293
 
 
1294
 
    def test_range_header(self):
1295
 
        # Valid ranges
1296
 
        map(self.assertEqual,['0', '234'],
1297
 
            list(self._file_contents('a', [(0,0), (2,4)])),)
1298
 
 
1299
 
    def test_range_header_tail(self):
1300
 
        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."""
1313
 
 
1314
 
    def create_transport_secondary_server(self):
1315
 
        """Create the secondary server redirecting to the primary server"""
1316
 
        new = self.get_readonly_server()
1317
 
 
1318
 
        redirecting = http_utils.HTTPServerRedirecting(
1319
 
            protocol_version=self._protocol_version)
1320
 
        redirecting.redirect_to(new.host, new.port)
1321
 
        return redirecting
1322
 
 
1323
 
    def setUp(self):
1324
 
        super(TestHTTPRedirections, self).setUp()
1325
 
        self.build_tree_contents([('a', '0123456789'),
1326
 
                                  ('bundle',
1327
 
                                  '# Bazaar revision bundle v0.9\n#\n')
1328
 
                                  ],)
1329
 
        # The requests to the old server will be redirected to the new server
1330
 
        self.old_transport = self._transport(self.old_server.get_url())
1331
 
 
1332
 
    def test_redirected(self):
1333
 
        self.assertRaises(errors.RedirectRequested, self.old_transport.get, 'a')
1334
 
        t = self._transport(self.new_server.get_url())
1335
 
        self.assertEqual('0123456789', t.get('a').read())
1336
 
 
1337
 
    def test_read_redirected_bundle_from_url(self):
1338
 
        from bzrlib.bundle import read_bundle_from_url
1339
 
        url = self.old_transport.abspath('bundle')
1340
 
        bundle = self.applyDeprecated(deprecated_in((1, 12, 0)),
1341
 
                read_bundle_from_url, url)
1342
 
        # If read_bundle_from_url was successful we get an empty bundle
1343
 
        self.assertEqual([], bundle.revisions)
1344
 
 
1345
 
 
1346
 
class RedirectedRequest(_urllib2_wrappers.Request):
1347
 
    """Request following redirections. """
1348
 
 
1349
 
    init_orig = _urllib2_wrappers.Request.__init__
1350
 
 
1351
 
    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)
1359
 
        self.follow_redirections = True
1360
 
 
1361
 
 
1362
 
def install_redirected_request(test):
1363
 
    test.overrideAttr(_urllib2_wrappers, 'Request', RedirectedRequest)
1364
 
 
1365
 
 
1366
 
class TestHTTPSilentRedirections(http_utils.TestCaseWithRedirectedWebserver):
1367
 
    """Test redirections.
1368
 
 
1369
 
    http implementations do not redirect silently anymore (they
1370
 
    do not redirect at all in fact). The mechanism is still in
1371
 
    place at the _urllib2_wrappers.Request level and these tests
1372
 
    exercise it.
1373
 
 
1374
 
    For the pycurl implementation
1375
 
    the redirection have been deleted as we may deprecate pycurl
1376
 
    and I have no place to keep a working implementation.
1377
 
    -- vila 20070212
1378
 
    """
1379
 
 
1380
 
    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)
1387
 
        self.build_tree_contents([('a','a'),
1388
 
                                  ('1/',),
1389
 
                                  ('1/a', 'redirected once'),
1390
 
                                  ('2/',),
1391
 
                                  ('2/a', 'redirected twice'),
1392
 
                                  ('3/',),
1393
 
                                  ('3/a', 'redirected thrice'),
1394
 
                                  ('4/',),
1395
 
                                  ('4/a', 'redirected 4 times'),
1396
 
                                  ('5/',),
1397
 
                                  ('5/a', 'redirected 5 times'),
1398
 
                                  ],)
1399
 
 
1400
 
        self.old_transport = self._transport(self.old_server.get_url())
1401
 
 
1402
 
    def create_transport_secondary_server(self):
1403
 
        """Create the secondary server, redirections are defined in the tests"""
1404
 
        return http_utils.HTTPServerRedirecting(
1405
 
            protocol_version=self._protocol_version)
1406
 
 
1407
 
    def test_one_redirection(self):
1408
 
        t = self.old_transport
1409
 
 
1410
 
        req = RedirectedRequest('GET', t.abspath('a'))
1411
 
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1412
 
                                       self.new_server.port)
1413
 
        self.old_server.redirections = \
1414
 
            [('(.*)', r'%s/1\1' % (new_prefix), 301),]
1415
 
        self.assertEqual('redirected once',t._perform(req).read())
1416
 
 
1417
 
    def test_five_redirections(self):
1418
 
        t = self.old_transport
1419
 
 
1420
 
        req = RedirectedRequest('GET', t.abspath('a'))
1421
 
        old_prefix = 'http://%s:%s' % (self.old_server.host,
1422
 
                                       self.old_server.port)
1423
 
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1424
 
                                       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."""
1437
 
 
1438
 
    def setUp(self):
1439
 
        super(TestDoCatchRedirections, self).setUp()
1440
 
        self.build_tree_contents([('a', '0123456789'),],)
1441
 
 
1442
 
        self.old_transport = self._transport(self.old_server.get_url())
1443
 
 
1444
 
    def get_a(self, transport):
1445
 
        return transport.get('a')
1446
 
 
1447
 
    def test_no_redirection(self):
1448
 
        t = self._transport(self.new_server.get_url())
1449
 
 
1450
 
        # 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())
1454
 
 
1455
 
    def test_one_redirection(self):
1456
 
        self.redirections = 0
1457
 
 
1458
 
        def redirected(transport, exception, redirection_notice):
1459
 
            self.redirections += 1
1460
 
            dir, file = urlutils.split(exception.target)
1461
 
            return self._transport(dir)
1462
 
 
1463
 
        self.assertEqual('0123456789',
1464
 
                         transport.do_catching_redirections(
1465
 
                self.get_a, self.old_transport, redirected).read())
1466
 
        self.assertEqual(1, self.redirections)
1467
 
 
1468
 
    def test_redirection_loop(self):
1469
 
 
1470
 
        def redirected(transport, exception, redirection_notice):
1471
 
            # By using the redirected url as a base dir for the
1472
 
            # *old* transport, we create a loop: a => a/a =>
1473
 
            # a/a/a
1474
 
            return self.old_transport.clone(exception.target)
1475
 
 
1476
 
        self.assertRaises(errors.TooManyRedirections,
1477
 
                          transport.do_catching_redirections,
1478
 
                          self.get_a, self.old_transport, redirected)
1479
 
 
1480
 
 
1481
 
class TestAuth(http_utils.TestCaseWithWebserver):
1482
 
    """Test authentication scheme"""
1483
 
 
1484
 
    _auth_header = 'Authorization'
1485
 
    _password_prompt_prefix = ''
1486
 
    _username_prompt_prefix = ''
1487
 
    # Set by load_tests
1488
 
    _auth_server = None
1489
 
 
1490
 
    def setUp(self):
1491
 
        super(TestAuth, self).setUp()
1492
 
        self.server = self.get_readonly_server()
1493
 
        self.build_tree_contents([('a', 'contents of a\n'),
1494
 
                                  ('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):
1505
 
        """Build an url embedding user and password"""
1506
 
        url = '%s://' % self.server._url_protocol
1507
 
        if user is not None:
1508
 
            url += user
1509
 
            if password is not None:
1510
 
                url += ':' + password
1511
 
            url += '@'
1512
 
        url += '%s:%s/' % (self.server.host, self.server.port)
1513
 
        return url
1514
 
 
1515
 
    def get_user_transport(self, user, password):
1516
 
        return self._transport(self.get_user_url(user, password))
1517
 
 
1518
 
    def test_no_user(self):
1519
 
        self.server.add_user('joe', 'foo')
1520
 
        t = self.get_user_transport(None, None)
1521
 
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'a')
1522
 
        # Only one 'Authentication Required' error should occur
1523
 
        self.assertEqual(1, self.server.auth_required_errors)
1524
 
 
1525
 
    def test_empty_pass(self):
1526
 
        self.server.add_user('joe', '')
1527
 
        t = self.get_user_transport('joe', '')
1528
 
        self.assertEqual('contents of a\n', t.get('a').read())
1529
 
        # Only one 'Authentication Required' error should occur
1530
 
        self.assertEqual(1, self.server.auth_required_errors)
1531
 
 
1532
 
    def test_user_pass(self):
1533
 
        self.server.add_user('joe', 'foo')
1534
 
        t = self.get_user_transport('joe', 'foo')
1535
 
        self.assertEqual('contents of a\n', t.get('a').read())
1536
 
        # Only one 'Authentication Required' error should occur
1537
 
        self.assertEqual(1, self.server.auth_required_errors)
1538
 
 
1539
 
    def test_unknown_user(self):
1540
 
        self.server.add_user('joe', 'foo')
1541
 
        t = self.get_user_transport('bill', 'foo')
1542
 
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'a')
1543
 
        # Two 'Authentication Required' errors should occur (the
1544
 
        # initial 'who are you' and 'I don't know you, who are
1545
 
        # you').
1546
 
        self.assertEqual(2, self.server.auth_required_errors)
1547
 
 
1548
 
    def test_wrong_pass(self):
1549
 
        self.server.add_user('joe', 'foo')
1550
 
        t = self.get_user_transport('joe', 'bar')
1551
 
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'a')
1552
 
        # Two 'Authentication Required' errors should occur (the
1553
 
        # initial 'who are you' and 'this is not you, who are you')
1554
 
        self.assertEqual(2, self.server.auth_required_errors)
1555
 
 
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
 
    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
 
        self.server.add_user('joe', 'foo')
1585
 
        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())
1591
 
        # stdin should be empty
1592
 
        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
 
        # And we shouldn't prompt again for a different request
1597
 
        # against the same transport.
1598
 
        self.assertEqual('contents of b\n',t.get('b').read())
1599
 
        t2 = t.clone()
1600
 
        # And neither against a clone
1601
 
        self.assertEqual('contents of b\n',t2.get('b').read())
1602
 
        # Only one 'Authentication Required' error should occur
1603
 
        self.assertEqual(1, self.server.auth_required_errors)
1604
 
 
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
 
 
1685
 
 
1686
 
 
1687
 
class TestProxyAuth(TestAuth):
1688
 
    """Test proxy authentication schemes."""
1689
 
 
1690
 
    _auth_header = 'Proxy-authorization'
1691
 
    _password_prompt_prefix = 'Proxy '
1692
 
    _username_prompt_prefix = 'Proxy '
1693
 
 
1694
 
    def setUp(self):
1695
 
        super(TestProxyAuth, self).setUp()
1696
 
        self._old_env = {}
1697
 
        self.addCleanup(self._restore_env)
1698
 
        # Override the contents to avoid false positives
1699
 
        self.build_tree_contents([('a', 'not proxied contents of a\n'),
1700
 
                                  ('b', 'not proxied contents of b\n'),
1701
 
                                  ('a-proxied', 'contents of a\n'),
1702
 
                                  ('b-proxied', 'contents of b\n'),
1703
 
                                  ])
1704
 
 
1705
 
    def get_user_transport(self, user, password):
1706
 
        self._install_env({'all_proxy': self.get_user_url(user, password)})
1707
 
        return self._transport(self.server.get_url())
1708
 
 
1709
 
    def _install_env(self, env):
1710
 
        for name, value in env.iteritems():
1711
 
            self._old_env[name] = osutils.set_or_unset_env(name, value)
1712
 
 
1713
 
    def _restore_env(self):
1714
 
        for name, value in self._old_env.iteritems():
1715
 
            osutils.set_or_unset_env(name, value)
1716
 
 
1717
 
    def test_empty_pass(self):
1718
 
        if self._testing_pycurl():
1719
 
            import pycurl
1720
 
            if pycurl.version_info()[1] < '7.16.0':
1721
 
                raise tests.KnownFailure(
1722
 
                    'pycurl < 7.16.0 does not handle empty proxy passwords')
1723
 
        super(TestProxyAuth, self).test_empty_pass()
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
 
 
2224