/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_http.py

[merge] bzr.dev 2255

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_http.py
1
 
# Copyright (C) 2005, 2006 Canonical
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
18
18
# implementation; at the moment we have urllib and pycurl.
19
19
 
20
20
# TODO: Should be renamed to bzrlib.transport.http.tests?
 
21
# TODO: What about renaming to bzrlib.tests.transport.http ?
21
22
 
 
23
import os
 
24
import select
22
25
import socket
 
26
import threading
23
27
 
24
28
import bzrlib
25
 
from bzrlib.errors import DependencyNotPresent
26
 
from bzrlib.tests import TestCase, TestSkipped
27
 
from bzrlib.transport import Transport
28
 
from bzrlib.transport.http import extract_auth, HttpTransportBase
 
29
from bzrlib import errors
 
30
from bzrlib import osutils
 
31
from bzrlib.tests import (
 
32
    TestCase,
 
33
    TestSkipped,
 
34
    )
 
35
from bzrlib.tests.HttpServer import (
 
36
    HttpServer,
 
37
    HttpServer_PyCurl,
 
38
    HttpServer_urllib,
 
39
    )
 
40
from bzrlib.tests.HTTPTestUtil import (
 
41
    BadProtocolRequestHandler,
 
42
    BadStatusRequestHandler,
 
43
    FakeProxyRequestHandler,
 
44
    ForbiddenRequestHandler,
 
45
    InvalidStatusRequestHandler,
 
46
    NoRangeRequestHandler,
 
47
    SingleRangeRequestHandler,
 
48
    TestCaseWithTwoWebservers,
 
49
    TestCaseWithWebserver,
 
50
    WallRequestHandler,
 
51
    )
 
52
from bzrlib.transport import (
 
53
    get_transport,
 
54
    Transport,
 
55
    )
 
56
from bzrlib.transport.http import (
 
57
    extract_auth,
 
58
    HttpTransportBase,
 
59
    )
29
60
from bzrlib.transport.http._urllib import HttpTransport_urllib
30
 
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
31
 
 
32
 
 
33
 
class FakeManager (object):
 
61
 
 
62
 
 
63
class FakeManager(object):
34
64
 
35
65
    def __init__(self):
36
66
        self.credentials = []
37
 
        
 
67
 
38
68
    def add_password(self, realm, host, username, password):
39
69
        self.credentials.append([realm, host, username, password])
40
70
 
41
71
 
 
72
class RecordingServer(object):
 
73
    """A fake HTTP server.
 
74
    
 
75
    It records the bytes sent to it, and replies with a 200.
 
76
    """
 
77
 
 
78
    def __init__(self, expect_body_tail=None):
 
79
        """Constructor.
 
80
 
 
81
        :type expect_body_tail: str
 
82
        :param expect_body_tail: a reply won't be sent until this string is
 
83
            received.
 
84
        """
 
85
        self._expect_body_tail = expect_body_tail
 
86
        self.host = None
 
87
        self.port = None
 
88
        self.received_bytes = ''
 
89
 
 
90
    def setUp(self):
 
91
        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
92
        self._sock.bind(('127.0.0.1', 0))
 
93
        self.host, self.port = self._sock.getsockname()
 
94
        self._ready = threading.Event()
 
95
        self._thread = threading.Thread(target=self._accept_read_and_reply)
 
96
        self._thread.setDaemon(True)
 
97
        self._thread.start()
 
98
        self._ready.wait(5)
 
99
 
 
100
    def _accept_read_and_reply(self):
 
101
        self._sock.listen(1)
 
102
        self._ready.set()
 
103
        self._sock.settimeout(5)
 
104
        try:
 
105
            conn, address = self._sock.accept()
 
106
            # On win32, the accepted connection will be non-blocking to start
 
107
            # with because we're using settimeout.
 
108
            conn.setblocking(True)
 
109
            while not self.received_bytes.endswith(self._expect_body_tail):
 
110
                self.received_bytes += conn.recv(4096)
 
111
            conn.sendall('HTTP/1.1 200 OK\r\n')
 
112
        except socket.timeout:
 
113
            # Make sure the client isn't stuck waiting for us to e.g. accept.
 
114
            self._sock.close()
 
115
        except socket.error:
 
116
            # The client may have already closed the socket.
 
117
            pass
 
118
 
 
119
    def tearDown(self):
 
120
        try:
 
121
            self._sock.close()
 
122
        except socket.error:
 
123
            # We might have already closed it.  We don't care.
 
124
            pass
 
125
        self.host = None
 
126
        self.port = None
 
127
 
 
128
 
42
129
class TestHttpUrls(TestCase):
43
130
 
 
131
    # FIXME: Some of these tests should be done for both
 
132
    # implementations
 
133
 
44
134
    def test_url_parsing(self):
45
135
        f = FakeManager()
46
136
        url = extract_auth('http://example.com', f)
49
139
        url = extract_auth('http://user:pass@www.bazaar-vcs.org/bzr/bzr.dev', f)
50
140
        self.assertEquals('http://www.bazaar-vcs.org/bzr/bzr.dev', url)
51
141
        self.assertEquals(1, len(f.credentials))
52
 
        self.assertEquals([None, 'www.bazaar-vcs.org', 'user', 'pass'], f.credentials[0])
53
 
        
 
142
        self.assertEquals([None, 'www.bazaar-vcs.org', 'user', 'pass'],
 
143
                          f.credentials[0])
 
144
 
54
145
    def test_abs_url(self):
55
146
        """Construction of absolute http URLs"""
56
147
        t = HttpTransport_urllib('http://bazaar-vcs.org/bzr/bzr.dev/')
57
148
        eq = self.assertEqualDiff
58
149
        eq(t.abspath('.'),
59
150
           'http://bazaar-vcs.org/bzr/bzr.dev')
60
 
        eq(t.abspath('foo/bar'), 
 
151
        eq(t.abspath('foo/bar'),
61
152
           'http://bazaar-vcs.org/bzr/bzr.dev/foo/bar')
62
153
        eq(t.abspath('.bzr'),
63
154
           'http://bazaar-vcs.org/bzr/bzr.dev/.bzr')
70
161
        self.assertRaises(ValueError,
71
162
            t.abspath,
72
163
            '.bzr/')
 
164
        t = HttpTransport_urllib('http://http://bazaar-vcs.org/bzr/bzr.dev/')
 
165
        self.assertRaises(errors.InvalidURL, t.has, 'foo/bar')
73
166
 
74
167
    def test_http_root_urls(self):
75
168
        """Construction of URLs from server root"""
80
173
 
81
174
    def test_http_impl_urls(self):
82
175
        """There are servers which ask for particular clients to connect"""
 
176
        server = HttpServer_PyCurl()
83
177
        try:
84
 
            from bzrlib.transport.http._pycurl import HttpServer_PyCurl
85
 
            server = HttpServer_PyCurl()
86
 
            try:
87
 
                server.setUp()
88
 
                url = server.get_url()
89
 
                self.assertTrue(url.startswith('http+pycurl://'))
90
 
            finally:
91
 
                server.tearDown()
92
 
        except DependencyNotPresent:
93
 
            raise TestSkipped('pycurl not present')
94
 
 
95
 
 
96
 
class TestHttpMixins(object):
97
 
 
98
 
    def _prep_tree(self):
 
178
            server.setUp()
 
179
            url = server.get_url()
 
180
            self.assertTrue(url.startswith('http+pycurl://'))
 
181
        finally:
 
182
            server.tearDown()
 
183
 
 
184
 
 
185
class TestHttpConnections(object):
 
186
    """Test the http connections.
 
187
 
 
188
    This MUST be used by daughter classes that also inherit from
 
189
    TestCaseWithWebserver.
 
190
 
 
191
    We can't inherit directly from TestCaseWithWebserver or the
 
192
    test framework will try to create an instance which cannot
 
193
    run, its implementation being incomplete.
 
194
    """
 
195
 
 
196
    def setUp(self):
 
197
        TestCaseWithWebserver.setUp(self)
99
198
        self.build_tree(['xxx', 'foo/', 'foo/bar'], line_endings='binary',
100
199
                        transport=self.get_transport())
101
200
 
104
203
        t = self._transport(server.get_url())
105
204
        self.assertEqual(t.has('foo/bar'), True)
106
205
        self.assertEqual(len(server.logs), 1)
107
 
        self.assertContainsRe(server.logs[0], 
 
206
        self.assertContainsRe(server.logs[0],
108
207
            r'"HEAD /foo/bar HTTP/1.." (200|302) - "-" "bzr/')
109
208
 
110
209
    def test_http_has_not_found(self):
111
210
        server = self.get_readonly_server()
112
211
        t = self._transport(server.get_url())
113
212
        self.assertEqual(t.has('not-found'), False)
114
 
        self.assertContainsRe(server.logs[1], 
 
213
        self.assertContainsRe(server.logs[1],
115
214
            r'"HEAD /not-found HTTP/1.." 404 - "-" "bzr/')
116
215
 
117
216
    def test_http_get(self):
123
222
            'contents of foo/bar\n')
124
223
        self.assertEqual(len(server.logs), 1)
125
224
        self.assertTrue(server.logs[0].find(
126
 
            '"GET /foo/bar HTTP/1.1" 200 - "-" "bzr/%s' % bzrlib.__version__) > -1)
127
 
 
128
 
 
129
 
class TestHttpConnections_urllib(TestCaseWithWebserver, TestHttpMixins):
130
 
 
131
 
    _transport = HttpTransport_urllib
132
 
 
133
 
    def setUp(self):
134
 
        TestCaseWithWebserver.setUp(self)
135
 
        self._prep_tree()
 
225
            '"GET /foo/bar HTTP/1.1" 200 - "-" "bzr/%s'
 
226
            % bzrlib.__version__) > -1)
 
227
 
 
228
    def test_get_smart_medium(self):
 
229
        # For HTTP, get_smart_medium should return the transport object.
 
230
        server = self.get_readonly_server()
 
231
        http_transport = self._transport(server.get_url())
 
232
        medium = http_transport.get_smart_medium()
 
233
        self.assertIs(medium, http_transport)
136
234
 
137
235
    def test_has_on_bogus_host(self):
138
 
        import urllib2
139
 
        # Get a random address, so that we can be sure there is no
140
 
        # http handler there.
141
 
        s = socket.socket()
142
 
        s.bind(('localhost', 0))
143
 
        t = self._transport('http://%s:%s/' % s.getsockname())
144
 
        self.assertRaises(urllib2.URLError, t.has, 'foo/bar')
145
 
 
146
 
 
147
 
class TestHttpConnections_pycurl(TestCaseWithWebserver, TestHttpMixins):
 
236
        # Get a free address and don't 'accept' on it, so that we
 
237
        # can be sure there is no http handler there, but set a
 
238
        # reasonable timeout to not slow down tests too much.
 
239
        default_timeout = socket.getdefaulttimeout()
 
240
        try:
 
241
            socket.setdefaulttimeout(2)
 
242
            s = socket.socket()
 
243
            s.bind(('localhost', 0))
 
244
            t = self._transport('http://%s:%s/' % s.getsockname())
 
245
            self.assertRaises(errors.ConnectionError, t.has, 'foo/bar')
 
246
        finally:
 
247
            socket.setdefaulttimeout(default_timeout)
 
248
 
 
249
 
 
250
class TestWithTransport_pycurl(object):
 
251
    """Test case to inherit from if pycurl is present"""
148
252
 
149
253
    def _get_pycurl_maybe(self):
150
254
        try:
151
255
            from bzrlib.transport.http._pycurl import PyCurlTransport
152
256
            return PyCurlTransport
153
 
        except DependencyNotPresent:
 
257
        except errors.DependencyNotPresent:
154
258
            raise TestSkipped('pycurl not present')
155
259
 
156
260
    _transport = property(_get_pycurl_maybe)
157
261
 
158
 
    def setUp(self):
159
 
        TestCaseWithWebserver.setUp(self)
160
 
        self._prep_tree()
161
 
 
 
262
 
 
263
class TestHttpConnections_urllib(TestHttpConnections, TestCaseWithWebserver):
 
264
    """Test http connections with urllib"""
 
265
 
 
266
    _transport = HttpTransport_urllib
 
267
 
 
268
 
 
269
 
 
270
class TestHttpConnections_pycurl(TestWithTransport_pycurl,
 
271
                                 TestHttpConnections,
 
272
                                 TestCaseWithWebserver):
 
273
    """Test http connections with pycurl"""
162
274
 
163
275
 
164
276
class TestHttpTransportRegistration(TestCase):
165
277
    """Test registrations of various http implementations"""
166
278
 
167
279
    def test_http_registered(self):
168
 
        import bzrlib.transport.http._urllib
169
 
        from bzrlib.transport import get_transport
170
280
        # urlllib should always be present
171
281
        t = get_transport('http+urllib://bzr.google.com/')
172
282
        self.assertIsInstance(t, Transport)
173
 
        self.assertIsInstance(t, bzrlib.transport.http._urllib.HttpTransport_urllib)
 
283
        self.assertIsInstance(t, HttpTransport_urllib)
174
284
 
175
285
 
176
286
class TestOffsets(TestCase):
197
307
        self.assertEqual([[10, 12], [22, 26]], ranges)
198
308
 
199
309
 
 
310
class TestPost(object):
 
311
 
 
312
    def _test_post_body_is_received(self, scheme):
 
313
        server = RecordingServer(expect_body_tail='end-of-body')
 
314
        server.setUp()
 
315
        self.addCleanup(server.tearDown)
 
316
        url = '%s://%s:%s/' % (scheme, server.host, server.port)
 
317
        try:
 
318
            http_transport = get_transport(url)
 
319
        except errors.UnsupportedProtocol:
 
320
            raise TestSkipped('%s not available' % scheme)
 
321
        code, response = http_transport._post('abc def end-of-body')
 
322
        self.assertTrue(
 
323
            server.received_bytes.startswith('POST /.bzr/smart HTTP/1.'))
 
324
        self.assertTrue('content-length: 19\r' in server.received_bytes.lower())
 
325
        # The transport should not be assuming that the server can accept
 
326
        # chunked encoding the first time it connects, because HTTP/1.1, so we
 
327
        # check for the literal string.
 
328
        self.assertTrue(
 
329
            server.received_bytes.endswith('\r\n\r\nabc def end-of-body'))
 
330
 
 
331
 
 
332
class TestPost_urllib(TestCase, TestPost):
 
333
    """TestPost for urllib implementation"""
 
334
 
 
335
    _transport = HttpTransport_urllib
 
336
 
 
337
    def test_post_body_is_received_urllib(self):
 
338
        self._test_post_body_is_received('http+urllib')
 
339
 
 
340
 
 
341
class TestPost_pycurl(TestWithTransport_pycurl, TestCase, TestPost):
 
342
    """TestPost for pycurl implementation"""
 
343
 
 
344
    def test_post_body_is_received_pycurl(self):
 
345
        self._test_post_body_is_received('http+pycurl')
 
346
 
 
347
 
200
348
class TestRangeHeader(TestCase):
201
349
    """Test range_header method"""
202
350
 
220
368
        self.check_header('0-9,300-5000,-50',
221
369
                          ranges=[(0,9), (300,5000)],
222
370
                          tail=50)
 
371
 
 
372
 
 
373
class TestWallServer(object):
 
374
    """Tests exceptions during the connection phase"""
 
375
 
 
376
    def create_transport_readonly_server(self):
 
377
        return HttpServer(WallRequestHandler)
 
378
 
 
379
    def test_http_has(self):
 
380
        server = self.get_readonly_server()
 
381
        t = self._transport(server.get_url())
 
382
        # Unfortunately httplib (see HTTPResponse._read_status
 
383
        # for details) make no distinction between a closed
 
384
        # socket and badly formatted status line, so we can't
 
385
        # just test for ConnectionError, we have to test
 
386
        # InvalidHttpResponse too.
 
387
        self.assertRaises((errors.ConnectionError, errors.InvalidHttpResponse),
 
388
                          t.has, 'foo/bar')
 
389
 
 
390
    def test_http_get(self):
 
391
        server = self.get_readonly_server()
 
392
        t = self._transport(server.get_url())
 
393
        self.assertRaises((errors.ConnectionError, errors.InvalidHttpResponse),
 
394
                          t.get, 'foo/bar')
 
395
 
 
396
 
 
397
class TestWallServer_urllib(TestWallServer, TestCaseWithWebserver):
 
398
    """Tests "wall" server for urllib implementation"""
 
399
 
 
400
    _transport = HttpTransport_urllib
 
401
 
 
402
 
 
403
class TestWallServer_pycurl(TestWithTransport_pycurl,
 
404
                            TestWallServer,
 
405
                            TestCaseWithWebserver):
 
406
    """Tests "wall" server for pycurl implementation"""
 
407
 
 
408
 
 
409
class TestBadStatusServer(object):
 
410
    """Tests bad status from server."""
 
411
 
 
412
    def create_transport_readonly_server(self):
 
413
        return HttpServer(BadStatusRequestHandler)
 
414
 
 
415
    def test_http_has(self):
 
416
        server = self.get_readonly_server()
 
417
        t = self._transport(server.get_url())
 
418
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
 
419
 
 
420
    def test_http_get(self):
 
421
        server = self.get_readonly_server()
 
422
        t = self._transport(server.get_url())
 
423
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
 
424
 
 
425
 
 
426
class TestBadStatusServer_urllib(TestBadStatusServer, TestCaseWithWebserver):
 
427
    """Tests bad status server for urllib implementation"""
 
428
 
 
429
    _transport = HttpTransport_urllib
 
430
 
 
431
 
 
432
class TestBadStatusServer_pycurl(TestWithTransport_pycurl,
 
433
                                 TestBadStatusServer,
 
434
                                 TestCaseWithWebserver):
 
435
    """Tests bad status server for pycurl implementation"""
 
436
 
 
437
 
 
438
class TestInvalidStatusServer(TestBadStatusServer):
 
439
    """Tests invalid status from server.
 
440
 
 
441
    Both implementations raises the same error as for a bad status.
 
442
    """
 
443
 
 
444
    def create_transport_readonly_server(self):
 
445
        return HttpServer(InvalidStatusRequestHandler)
 
446
 
 
447
 
 
448
class TestInvalidStatusServer_urllib(TestInvalidStatusServer,
 
449
                                     TestCaseWithWebserver):
 
450
    """Tests invalid status server for urllib implementation"""
 
451
 
 
452
    _transport = HttpTransport_urllib
 
453
 
 
454
 
 
455
class TestInvalidStatusServer_pycurl(TestWithTransport_pycurl,
 
456
                                     TestInvalidStatusServer,
 
457
                                     TestCaseWithWebserver):
 
458
    """Tests invalid status server for pycurl implementation"""
 
459
 
 
460
 
 
461
class TestBadProtocolServer(object):
 
462
    """Tests bad protocol from server."""
 
463
 
 
464
    def create_transport_readonly_server(self):
 
465
        return HttpServer(BadProtocolRequestHandler)
 
466
 
 
467
    def test_http_has(self):
 
468
        server = self.get_readonly_server()
 
469
        t = self._transport(server.get_url())
 
470
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
 
471
 
 
472
    def test_http_get(self):
 
473
        server = self.get_readonly_server()
 
474
        t = self._transport(server.get_url())
 
475
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
 
476
 
 
477
 
 
478
class TestBadProtocolServer_urllib(TestBadProtocolServer,
 
479
                                   TestCaseWithWebserver):
 
480
    """Tests bad protocol server for urllib implementation"""
 
481
 
 
482
    _transport = HttpTransport_urllib
 
483
 
 
484
# curl don't check the protocol version
 
485
#class TestBadProtocolServer_pycurl(TestWithTransport_pycurl,
 
486
#                                   TestBadProtocolServer,
 
487
#                                   TestCaseWithWebserver):
 
488
#    """Tests bad protocol server for pycurl implementation"""
 
489
 
 
490
 
 
491
class TestForbiddenServer(object):
 
492
    """Tests forbidden server"""
 
493
 
 
494
    def create_transport_readonly_server(self):
 
495
        return HttpServer(ForbiddenRequestHandler)
 
496
 
 
497
    def test_http_has(self):
 
498
        server = self.get_readonly_server()
 
499
        t = self._transport(server.get_url())
 
500
        self.assertRaises(errors.TransportError, t.has, 'foo/bar')
 
501
 
 
502
    def test_http_get(self):
 
503
        server = self.get_readonly_server()
 
504
        t = self._transport(server.get_url())
 
505
        self.assertRaises(errors.TransportError, t.get, 'foo/bar')
 
506
 
 
507
 
 
508
class TestForbiddenServer_urllib(TestForbiddenServer, TestCaseWithWebserver):
 
509
    """Tests forbidden server for urllib implementation"""
 
510
 
 
511
    _transport = HttpTransport_urllib
 
512
 
 
513
 
 
514
class TestForbiddenServer_pycurl(TestWithTransport_pycurl,
 
515
                                 TestForbiddenServer,
 
516
                                 TestCaseWithWebserver):
 
517
    """Tests forbidden server for pycurl implementation"""
 
518
 
 
519
 
 
520
class TestRecordingServer(TestCase):
 
521
 
 
522
    def test_create(self):
 
523
        server = RecordingServer(expect_body_tail=None)
 
524
        self.assertEqual('', server.received_bytes)
 
525
        self.assertEqual(None, server.host)
 
526
        self.assertEqual(None, server.port)
 
527
 
 
528
    def test_setUp_and_tearDown(self):
 
529
        server = RecordingServer(expect_body_tail=None)
 
530
        server.setUp()
 
531
        try:
 
532
            self.assertNotEqual(None, server.host)
 
533
            self.assertNotEqual(None, server.port)
 
534
        finally:
 
535
            server.tearDown()
 
536
        self.assertEqual(None, server.host)
 
537
        self.assertEqual(None, server.port)
 
538
 
 
539
    def test_send_receive_bytes(self):
 
540
        server = RecordingServer(expect_body_tail='c')
 
541
        server.setUp()
 
542
        self.addCleanup(server.tearDown)
 
543
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
544
        sock.connect((server.host, server.port))
 
545
        sock.sendall('abc')
 
546
        self.assertEqual('HTTP/1.1 200 OK\r\n',
 
547
                         osutils.recv_all(sock, 4096))
 
548
        self.assertEqual('abc', server.received_bytes)
 
549
 
 
550
 
 
551
class TestRangeRequestServer(object):
 
552
    """Tests readv requests against server.
 
553
 
 
554
    This MUST be used by daughter classes that also inherit from
 
555
    TestCaseWithWebserver.
 
556
 
 
557
    We can't inherit directly from TestCaseWithWebserver or the
 
558
    test framework will try to create an instance which cannot
 
559
    run, its implementation being incomplete.
 
560
    """
 
561
 
 
562
    def setUp(self):
 
563
        TestCaseWithWebserver.setUp(self)
 
564
        self.build_tree_contents([('a', '0123456789')],)
 
565
 
 
566
    def test_readv(self):
 
567
        server = self.get_readonly_server()
 
568
        t = self._transport(server.get_url())
 
569
        l = list(t.readv('a', ((0, 1), (1, 1), (3, 2), (9, 1))))
 
570
        self.assertEqual(l[0], (0, '0'))
 
571
        self.assertEqual(l[1], (1, '1'))
 
572
        self.assertEqual(l[2], (3, '34'))
 
573
        self.assertEqual(l[3], (9, '9'))
 
574
 
 
575
    def test_readv_out_of_order(self):
 
576
        server = self.get_readonly_server()
 
577
        t = self._transport(server.get_url())
 
578
        l = list(t.readv('a', ((1, 1), (9, 1), (0, 1), (3, 2))))
 
579
        self.assertEqual(l[0], (1, '1'))
 
580
        self.assertEqual(l[1], (9, '9'))
 
581
        self.assertEqual(l[2], (0, '0'))
 
582
        self.assertEqual(l[3], (3, '34'))
 
583
 
 
584
    def test_readv_invalid_ranges(self):
 
585
        server = self.get_readonly_server()
 
586
        t = self._transport(server.get_url())
 
587
 
 
588
        # This is intentionally reading off the end of the file
 
589
        # since we are sure that it cannot get there
 
590
        self.assertListRaises((errors.InvalidRange, errors.ShortReadvError,),
 
591
                              t.readv, 'a', [(1,1), (8,10)])
 
592
 
 
593
        # This is trying to seek past the end of the file, it should
 
594
        # also raise a special error
 
595
        self.assertListRaises((errors.InvalidRange, errors.ShortReadvError,),
 
596
                              t.readv, 'a', [(12,2)])
 
597
 
 
598
 
 
599
class TestSingleRangeRequestServer(TestRangeRequestServer):
 
600
    """Test readv against a server which accept only single range requests"""
 
601
 
 
602
    def create_transport_readonly_server(self):
 
603
        return HttpServer(SingleRangeRequestHandler)
 
604
 
 
605
 
 
606
class TestSingleRangeRequestServer_urllib(TestSingleRangeRequestServer,
 
607
                                          TestCaseWithWebserver):
 
608
    """Tests single range requests accepting server for urllib implementation"""
 
609
 
 
610
    _transport = HttpTransport_urllib
 
611
 
 
612
 
 
613
class TestSingleRangeRequestServer_pycurl(TestWithTransport_pycurl,
 
614
                                          TestSingleRangeRequestServer,
 
615
                                          TestCaseWithWebserver):
 
616
    """Tests single range requests accepting server for pycurl implementation"""
 
617
 
 
618
 
 
619
class TestNoRangeRequestServer(TestRangeRequestServer):
 
620
    """Test readv against a server which do not accept range requests"""
 
621
 
 
622
    def create_transport_readonly_server(self):
 
623
        return HttpServer(NoRangeRequestHandler)
 
624
 
 
625
 
 
626
class TestNoRangeRequestServer_urllib(TestNoRangeRequestServer,
 
627
                                      TestCaseWithWebserver):
 
628
    """Tests range requests refusing server for urllib implementation"""
 
629
 
 
630
    _transport = HttpTransport_urllib
 
631
 
 
632
 
 
633
class TestNoRangeRequestServer_pycurl(TestWithTransport_pycurl,
 
634
                               TestNoRangeRequestServer,
 
635
                               TestCaseWithWebserver):
 
636
    """Tests range requests refusing server for pycurl implementation"""
 
637
 
 
638
 
 
639
class TestProxyHttpServer(object):
 
640
    """Tests proxy server.
 
641
 
 
642
    This MUST be used by daughter classes that also inherit from
 
643
    TestCaseWithTwoWebservers.
 
644
 
 
645
    We can't inherit directly from TestCaseWithTwoWebservers or
 
646
    the test framework will try to create an instance which
 
647
    cannot run, its implementation being incomplete.
 
648
 
 
649
    Be aware that we do not setup a real proxy here. Instead, we
 
650
    check that the *connection* goes through the proxy by serving
 
651
    different content (the faked proxy server append '-proxied'
 
652
    to the file names).
 
653
    """
 
654
 
 
655
    # FIXME: We don't have an https server available, so we don't
 
656
    # test https connections.
 
657
 
 
658
    def setUp(self):
 
659
        TestCaseWithTwoWebservers.setUp(self)
 
660
        self.build_tree_contents([('foo', 'contents of foo\n'),
 
661
                                  ('foo-proxied', 'proxied contents of foo\n')])
 
662
        # Let's setup some attributes for tests
 
663
        self.server = self.get_readonly_server()
 
664
        self.no_proxy_host = 'localhost:%d' % self.server.port
 
665
        # The secondary server is the proxy
 
666
        self.proxy = self.get_secondary_server()
 
667
        self.proxy_url = self.proxy.get_url()
 
668
        self._old_env = {}
 
669
 
 
670
    def create_transport_secondary_server(self):
 
671
        """Creates an http server that will serve files with
 
672
        '-proxied' appended to their names.
 
673
        """
 
674
        return HttpServer(FakeProxyRequestHandler)
 
675
 
 
676
    def _set_and_capture_env_var(self, name, new_value):
 
677
        """Set an environment variable, and reset it when finished."""
 
678
        self._old_env[name] = osutils.set_or_unset_env(name, new_value)
 
679
 
 
680
    def _install_env(self, env):
 
681
        for name, value in env.iteritems():
 
682
            self._set_and_capture_env_var(name, value)
 
683
 
 
684
    def _restore_env(self):
 
685
        for name, value in self._old_env.iteritems():
 
686
            osutils.set_or_unset_env(name, value)
 
687
 
 
688
    def proxied_in_env(self, env):
 
689
        self._install_env(env)
 
690
        url = self.server.get_url()
 
691
        t = self._transport(url)
 
692
        try:
 
693
            self.assertEqual(t.get('foo').read(), 'proxied contents of foo\n')
 
694
        finally:
 
695
            self._restore_env()
 
696
 
 
697
    def not_proxied_in_env(self, env):
 
698
        self._install_env(env)
 
699
        url = self.server.get_url()
 
700
        t = self._transport(url)
 
701
        try:
 
702
            self.assertEqual(t.get('foo').read(), 'contents of foo\n')
 
703
        finally:
 
704
            self._restore_env()
 
705
 
 
706
    def test_http_proxy(self):
 
707
        self.proxied_in_env({'http_proxy': self.proxy_url})
 
708
 
 
709
    def test_HTTP_PROXY(self):
 
710
        self.proxied_in_env({'HTTP_PROXY': self.proxy_url})
 
711
 
 
712
    def test_all_proxy(self):
 
713
        self.proxied_in_env({'all_proxy': self.proxy_url})
 
714
 
 
715
    def test_ALL_PROXY(self):
 
716
        self.proxied_in_env({'ALL_PROXY': self.proxy_url})
 
717
 
 
718
    def test_http_proxy_with_no_proxy(self):
 
719
        self.not_proxied_in_env({'http_proxy': self.proxy_url,
 
720
                                 'no_proxy': self.no_proxy_host})
 
721
 
 
722
    def test_HTTP_PROXY_with_NO_PROXY(self):
 
723
        self.not_proxied_in_env({'HTTP_PROXY': self.proxy_url,
 
724
                                 'NO_PROXY': self.no_proxy_host})
 
725
 
 
726
    def test_all_proxy_with_no_proxy(self):
 
727
        self.not_proxied_in_env({'all_proxy': self.proxy_url,
 
728
                                 'no_proxy': self.no_proxy_host})
 
729
 
 
730
    def test_ALL_PROXY_with_NO_PROXY(self):
 
731
        self.not_proxied_in_env({'ALL_PROXY': self.proxy_url,
 
732
                                 'NO_PROXY': self.no_proxy_host})
 
733
 
 
734
 
 
735
class TestProxyHttpServer_urllib(TestProxyHttpServer,
 
736
                                 TestCaseWithTwoWebservers):
 
737
    """Tests proxy server for urllib implementation"""
 
738
 
 
739
    _transport = HttpTransport_urllib
 
740
 
 
741
 
 
742
class TestProxyHttpServer_pycurl(TestWithTransport_pycurl,
 
743
                                 TestProxyHttpServer,
 
744
                                 TestCaseWithTwoWebservers):
 
745
    """Tests proxy server for pycurl implementation"""
 
746
 
 
747
    def setUp(self):
 
748
        TestProxyHttpServer.setUp(self)
 
749
        # Oh my ! pycurl does not check for the port as part of
 
750
        # no_proxy :-( So we just test the host part
 
751
        self.no_proxy_host = 'localhost'
 
752
 
 
753
    def test_HTTP_PROXY(self):
 
754
        # pycurl do not check HTTP_PROXY for security reasons
 
755
        # (for use in a CGI context that we do not care
 
756
        # about. Should we ?)
 
757
        raise TestSkipped()
 
758
 
 
759
    def test_HTTP_PROXY_with_NO_PROXY(self):
 
760
        raise TestSkipped()
 
761
 
 
762
 
 
763
class TestRanges(object):
 
764
    """Test the Range header in GET methods..
 
765
 
 
766
    This MUST be used by daughter classes that also inherit from
 
767
    TestCaseWithWebserver.
 
768
 
 
769
    We can't inherit directly from TestCaseWithWebserver or the
 
770
    test framework will try to create an instance which cannot
 
771
    run, its implementation being incomplete.
 
772
    """
 
773
 
 
774
    def setUp(self):
 
775
        TestCaseWithWebserver.setUp(self)
 
776
        self.build_tree_contents([('a', '0123456789')],)
 
777
        server = self.get_readonly_server()
 
778
        self.transport = self._transport(server.get_url())
 
779
 
 
780
    def _file_contents(self, relpath, ranges, tail_amount=0):
 
781
         code, data = self.transport._get(relpath, ranges)
 
782
         self.assertTrue(code in (200, 206),'_get returns: %d' % code)
 
783
         for start, end in ranges:
 
784
             data.seek(start)
 
785
             yield data.read(end - start + 1)
 
786
 
 
787
    def _file_tail(self, relpath, tail_amount):
 
788
         code, data = self.transport._get(relpath, [], tail_amount)
 
789
         self.assertTrue(code in (200, 206),'_get returns: %d' % code)
 
790
         data.seek(-tail_amount + 1, 2)
 
791
         return data.read(tail_amount)
 
792
 
 
793
    def test_range_header(self):
 
794
        # Valid ranges
 
795
        map(self.assertEqual,['0', '234'],
 
796
            list(self._file_contents('a', [(0,0), (2,4)])),)
 
797
        # Tail
 
798
        self.assertEqual('789', self._file_tail('a', 3))
 
799
        # Syntactically invalid range
 
800
        self.assertRaises(errors.InvalidRange,
 
801
                          self.transport._get, 'a', [(4, 3)])
 
802
        # Semantically invalid range
 
803
        self.assertRaises(errors.InvalidRange,
 
804
                          self.transport._get, 'a', [(42, 128)])
 
805
 
 
806
 
 
807
class TestRanges_urllib(TestRanges, TestCaseWithWebserver):
 
808
    """Test the Range header in GET methods for urllib implementation"""
 
809
 
 
810
    _transport = HttpTransport_urllib
 
811
 
 
812
 
 
813
class TestRanges_pycurl(TestWithTransport_pycurl,
 
814
                        TestRanges,
 
815
                        TestCaseWithWebserver):
 
816
    """Test the Range header in GET methods for pycurl implementation"""