/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

  • Committer: Vincent Ladeuil
  • Date: 2010-10-13 08:01:36 UTC
  • mfrom: (5447.5.1 config-read)
  • mto: This revision was merged to the branch mainline in revision 5499.
  • Revision ID: v.ladeuil+lp@free.fr-20101013080136-7o5qbbwgxhgncsj8
Merge config-read into config-modify

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_http.py
23
23
# TODO: Should be renamed to bzrlib.transport.http.tests?
24
24
# TODO: What about renaming to bzrlib.tests.transport.http ?
25
25
 
26
 
from cStringIO import StringIO
27
26
import httplib
28
 
import os
29
 
import select
30
27
import SimpleHTTPServer
31
28
import socket
32
29
import sys
42
39
    tests,
43
40
    transport,
44
41
    ui,
45
 
    urlutils,
46
 
    )
47
 
from bzrlib.symbol_versioning import (
48
 
    deprecated_in,
49
42
    )
50
43
from bzrlib.tests import (
51
44
    features,
52
45
    http_server,
53
46
    http_utils,
 
47
    test_server,
 
48
    )
 
49
from bzrlib.tests.scenarios import (
 
50
    load_tests_apply_scenarios,
 
51
    multiply_scenarios,
54
52
    )
55
53
from bzrlib.transport import (
56
54
    http,
66
64
    from bzrlib.transport.http._pycurl import PyCurlTransport
67
65
 
68
66
 
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
 
                )))
 
67
load_tests = load_tests_apply_scenarios
 
68
 
 
69
 
 
70
def vary_by_http_client_implementation():
 
71
    """Test the two libraries we can use, pycurl and urllib."""
80
72
    transport_scenarios = [
81
73
        ('urllib', dict(_transport=_urllib.HttpTransport_urllib,
82
74
                        _server=http_server.HttpServer_urllib,
83
 
                        _qualified_prefix='http+urllib',)),
 
75
                        _url_protocol='http+urllib',)),
84
76
        ]
85
77
    if features.pycurl.available():
86
78
        transport_scenarios.append(
87
79
            ('pycurl', dict(_transport=PyCurlTransport,
88
80
                            _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 = [
 
81
                            _url_protocol='http+pycurl',)))
 
82
    return transport_scenarios
 
83
 
 
84
 
 
85
def vary_by_http_protocol_version():
 
86
    """Test on http/1.0 and 1.1"""
 
87
    return [
 
88
        ('HTTP/1.0',  dict(_protocol_version='HTTP/1.0')),
 
89
        ('HTTP/1.1',  dict(_protocol_version='HTTP/1.1')),
 
90
        ]
 
91
 
 
92
 
 
93
def vary_by_http_proxy_auth_scheme():
 
94
    return [
120
95
        ('basic', dict(_auth_server=http_utils.ProxyBasicAuthServer)),
121
96
        ('digest', dict(_auth_server=http_utils.ProxyDigestAuthServer)),
122
97
        ('basicdigest',
123
 
         dict(_auth_server=http_utils.ProxyBasicAndDigestAuthServer)),
 
98
            dict(_auth_server=http_utils.ProxyBasicAndDigestAuthServer)),
124
99
        ]
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 = [
 
100
 
 
101
 
 
102
def vary_by_http_auth_scheme():
 
103
    return [
135
104
        ('basic', dict(_auth_server=http_utils.HTTPBasicAuthServer)),
136
105
        ('digest', dict(_auth_server=http_utils.HTTPDigestAuthServer)),
137
106
        ('basicdigest',
138
 
         dict(_auth_server=http_utils.HTTPBasicAndDigestAuthServer)),
 
107
            dict(_auth_server=http_utils.HTTPBasicAndDigestAuthServer)),
139
108
        ]
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
 
                )))
 
109
 
 
110
 
 
111
def vary_by_http_activity():
149
112
    activity_scenarios = [
150
113
        ('urllib,http', dict(_activity_server=ActivityHTTPServer,
151
 
                             _transport=_urllib.HttpTransport_urllib,)),
 
114
                            _transport=_urllib.HttpTransport_urllib,)),
152
115
        ]
153
116
    if tests.HTTPSServerFeature.available():
154
117
        activity_scenarios.append(
155
118
            ('urllib,https', dict(_activity_server=ActivityHTTPSServer,
156
 
                                  _transport=_urllib.HttpTransport_urllib,)),)
 
119
                                _transport=_urllib.HttpTransport_urllib,)),)
157
120
    if features.pycurl.available():
158
121
        activity_scenarios.append(
159
122
            ('pycurl,http', dict(_activity_server=ActivityHTTPServer,
160
 
                                 _transport=PyCurlTransport,)),)
 
123
                                _transport=PyCurlTransport,)),)
161
124
        if tests.HTTPSServerFeature.available():
162
125
            from bzrlib.tests import (
163
126
                ssl_certs,
175
138
 
176
139
            activity_scenarios.append(
177
140
                ('pycurl,https', dict(_activity_server=ActivityHTTPSServer,
178
 
                                      _transport=HTTPS_pycurl_transport,)),)
179
 
 
180
 
    tpact_scenarios = tests.multiply_scenarios(activity_scenarios,
181
 
                                               protocol_scenarios)
182
 
    tests.multiply_tests(tpact_tests, tpact_scenarios, result)
183
 
 
184
 
    # No parametrization for the remaining tests
185
 
    result.addTests(remaining_tests)
186
 
 
187
 
    return result
 
141
                                    _transport=HTTPS_pycurl_transport,)),)
 
142
    return activity_scenarios
188
143
 
189
144
 
190
145
class FakeManager(object):
223
178
        self._sock.bind(('127.0.0.1', 0))
224
179
        self.host, self.port = self._sock.getsockname()
225
180
        self._ready = threading.Event()
226
 
        self._thread = threading.Thread(target=self._accept_read_and_reply)
227
 
        self._thread.setDaemon(True)
 
181
        self._thread = test_server.ThreadWithException(
 
182
            event=self._ready, target=self._accept_read_and_reply)
228
183
        self._thread.start()
229
 
        self._ready.wait(5)
 
184
        if 'threads' in tests.selftest_debug_flags:
 
185
            sys.stderr.write('Thread started: %s\n' % (self._thread.ident,))
 
186
        self._ready.wait()
230
187
 
231
188
    def _accept_read_and_reply(self):
232
189
        self._sock.listen(1)
233
190
        self._ready.set()
234
 
        self._sock.settimeout(5)
235
 
        try:
236
 
            conn, address = self._sock.accept()
237
 
            # On win32, the accepted connection will be non-blocking to start
238
 
            # with because we're using settimeout.
239
 
            conn.setblocking(True)
 
191
        conn, address = self._sock.accept()
 
192
        if self._expect_body_tail is not None:
240
193
            while not self.received_bytes.endswith(self._expect_body_tail):
241
194
                self.received_bytes += conn.recv(4096)
242
195
            conn.sendall('HTTP/1.1 200 OK\r\n')
243
 
        except socket.timeout:
244
 
            # Make sure the client isn't stuck waiting for us to e.g. accept.
 
196
        try:
245
197
            self._sock.close()
246
198
        except socket.error:
247
199
            # The client may have already closed the socket.
249
201
 
250
202
    def stop_server(self):
251
203
        try:
252
 
            self._sock.close()
 
204
            # Issue a fake connection to wake up the server and allow it to
 
205
            # finish quickly
 
206
            fake_conn = osutils.connect_socket((self.host, self.port))
 
207
            fake_conn.close()
253
208
        except socket.error:
254
209
            # We might have already closed it.  We don't care.
255
210
            pass
256
211
        self.host = None
257
212
        self.port = None
 
213
        self._thread.join()
 
214
        if 'threads' in tests.selftest_debug_flags:
 
215
            sys.stderr.write('Thread  joined: %s\n' % (self._thread.ident,))
258
216
 
259
217
 
260
218
class TestAuthHeader(tests.TestCase):
304
262
 
305
263
            protocol_version = 'HTTP/0.1'
306
264
 
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')
 
265
        self.assertRaises(httplib.UnknownProtocol,
 
266
                          http_server.HttpServer, BogusRequestHandler)
313
267
 
314
268
    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')
 
269
        self.assertRaises(httplib.UnknownProtocol,
 
270
                          http_server.HttpServer, protocol_version='HTTP/0.1')
321
271
 
322
272
    def test_server_start_and_stop(self):
323
273
        server = http_server.HttpServer()
 
274
        self.addCleanup(server.stop_server)
324
275
        server.start_server()
325
 
        try:
326
 
            self.assertTrue(server._http_running)
327
 
        finally:
328
 
            server.stop_server()
329
 
        self.assertFalse(server._http_running)
 
276
        self.assertTrue(server.server is not None)
 
277
        self.assertTrue(server.server.serving is not None)
 
278
        self.assertTrue(server.server.serving)
330
279
 
331
280
    def test_create_http_server_one_zero(self):
332
281
        class RequestHandlerOneZero(http_server.TestingHTTPRequestHandler):
335
284
 
336
285
        server = http_server.HttpServer(RequestHandlerOneZero)
337
286
        self.start_server(server)
338
 
        self.assertIsInstance(server._httpd, http_server.TestingHTTPServer)
 
287
        self.assertIsInstance(server.server, http_server.TestingHTTPServer)
339
288
 
340
289
    def test_create_http_server_one_one(self):
341
290
        class RequestHandlerOneOne(http_server.TestingHTTPRequestHandler):
344
293
 
345
294
        server = http_server.HttpServer(RequestHandlerOneOne)
346
295
        self.start_server(server)
347
 
        self.assertIsInstance(server._httpd,
 
296
        self.assertIsInstance(server.server,
348
297
                              http_server.TestingThreadingHTTPServer)
349
298
 
350
299
    def test_create_http_server_force_one_one(self):
355
304
        server = http_server.HttpServer(RequestHandlerOneZero,
356
305
                                        protocol_version='HTTP/1.1')
357
306
        self.start_server(server)
358
 
        self.assertIsInstance(server._httpd,
 
307
        self.assertIsInstance(server.server,
359
308
                              http_server.TestingThreadingHTTPServer)
360
309
 
361
310
    def test_create_http_server_force_one_zero(self):
366
315
        server = http_server.HttpServer(RequestHandlerOneOne,
367
316
                                        protocol_version='HTTP/1.0')
368
317
        self.start_server(server)
369
 
        self.assertIsInstance(server._httpd,
 
318
        self.assertIsInstance(server.server,
370
319
                              http_server.TestingHTTPServer)
371
320
 
372
321
 
401
350
class TestHttpTransportUrls(tests.TestCase):
402
351
    """Test the http urls."""
403
352
 
 
353
    scenarios = vary_by_http_client_implementation()
 
354
 
404
355
    def test_abs_url(self):
405
356
        """Construction of absolute http URLs"""
406
357
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
413
364
 
414
365
    def test_invalid_http_urls(self):
415
366
        """Trap invalid construction of urls"""
416
 
        t = self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
 
367
        self._transport('http://bazaar-vcs.org/bzr/bzr.dev/')
417
368
        self.assertRaises(errors.InvalidURL,
418
369
                          self._transport,
419
370
                          'http://http://bazaar-vcs.org/bzr/bzr.dev/')
431
382
        server.start_server()
432
383
        try:
433
384
            url = server.get_url()
434
 
            self.assertTrue(url.startswith('%s://' % self._qualified_prefix))
 
385
            self.assertTrue(url.startswith('%s://' % self._url_protocol))
435
386
        finally:
436
387
            server.stop_server()
437
388
 
475
426
class TestHTTPConnections(http_utils.TestCaseWithWebserver):
476
427
    """Test the http connections."""
477
428
 
 
429
    scenarios = multiply_scenarios(
 
430
        vary_by_http_client_implementation(), 
 
431
        vary_by_http_protocol_version(),
 
432
        )
 
433
 
478
434
    def setUp(self):
479
435
        http_utils.TestCaseWithWebserver.setUp(self)
480
436
        self.build_tree(['foo/', 'foo/bar'], line_endings='binary',
482
438
 
483
439
    def test_http_has(self):
484
440
        server = self.get_readonly_server()
485
 
        t = self._transport(server.get_url())
 
441
        t = self.get_readonly_transport()
486
442
        self.assertEqual(t.has('foo/bar'), True)
487
443
        self.assertEqual(len(server.logs), 1)
488
444
        self.assertContainsRe(server.logs[0],
490
446
 
491
447
    def test_http_has_not_found(self):
492
448
        server = self.get_readonly_server()
493
 
        t = self._transport(server.get_url())
 
449
        t = self.get_readonly_transport()
494
450
        self.assertEqual(t.has('not-found'), False)
495
451
        self.assertContainsRe(server.logs[1],
496
452
            r'"HEAD /not-found HTTP/1.." 404 - "-" "bzr/')
497
453
 
498
454
    def test_http_get(self):
499
455
        server = self.get_readonly_server()
500
 
        t = self._transport(server.get_url())
 
456
        t = self.get_readonly_transport()
501
457
        fp = t.get('foo/bar')
502
458
        self.assertEqualDiff(
503
459
            fp.read(),
525
481
class TestHttpTransportRegistration(tests.TestCase):
526
482
    """Test registrations of various http implementations"""
527
483
 
 
484
    scenarios = vary_by_http_client_implementation()
 
485
 
528
486
    def test_http_registered(self):
529
 
        t = transport.get_transport('%s://foo.com/' % self._qualified_prefix)
 
487
        t = transport.get_transport('%s://foo.com/' % self._url_protocol)
530
488
        self.assertIsInstance(t, transport.Transport)
531
489
        self.assertIsInstance(t, self._transport)
532
490
 
533
491
 
534
492
class TestPost(tests.TestCase):
535
493
 
 
494
    scenarios = multiply_scenarios(
 
495
        vary_by_http_client_implementation(), 
 
496
        vary_by_http_protocol_version(),
 
497
        )
 
498
 
536
499
    def test_post_body_is_received(self):
537
500
        server = RecordingServer(expect_body_tail='end-of-body',
538
 
            scheme=self._qualified_prefix)
 
501
                                 scheme=self._url_protocol)
539
502
        self.start_server(server)
540
503
        url = server.get_url()
541
 
        http_transport = self._transport(url)
 
504
        # FIXME: needs a cleanup -- vila 20100611
 
505
        http_transport = transport.get_transport(url)
542
506
        code, response = http_transport._post('abc def end-of-body')
543
507
        self.assertTrue(
544
508
            server.received_bytes.startswith('POST /.bzr/smart HTTP/1.'))
584
548
    Daughter classes are expected to override _req_handler_class
585
549
    """
586
550
 
 
551
    scenarios = multiply_scenarios(
 
552
        vary_by_http_client_implementation(), 
 
553
        vary_by_http_protocol_version(),
 
554
        )
 
555
 
587
556
    # Provide a useful default
588
557
    _req_handler_class = http_server.TestingHTTPRequestHandler
589
558
 
590
559
    def create_transport_readonly_server(self):
591
 
        return http_server.HttpServer(self._req_handler_class,
592
 
                                      protocol_version=self._protocol_version)
 
560
        server = http_server.HttpServer(self._req_handler_class,
 
561
                                        protocol_version=self._protocol_version)
 
562
        server._url_protocol = self._url_protocol
 
563
        return server
593
564
 
594
565
    def _testing_pycurl(self):
595
566
        # TODO: This is duplicated for lots of the classes in this file
600
571
class WallRequestHandler(http_server.TestingHTTPRequestHandler):
601
572
    """Whatever request comes in, close the connection"""
602
573
 
603
 
    def handle_one_request(self):
 
574
    def _handle_one_request(self):
604
575
        """Handle a single HTTP request, by abruptly closing the connection"""
605
576
        self.close_connection = 1
606
577
 
611
582
    _req_handler_class = WallRequestHandler
612
583
 
613
584
    def test_http_has(self):
614
 
        server = self.get_readonly_server()
615
 
        t = self._transport(server.get_url())
 
585
        t = self.get_readonly_transport()
616
586
        # Unfortunately httplib (see HTTPResponse._read_status
617
587
        # for details) make no distinction between a closed
618
588
        # socket and badly formatted status line, so we can't
624
594
                          t.has, 'foo/bar')
625
595
 
626
596
    def test_http_get(self):
627
 
        server = self.get_readonly_server()
628
 
        t = self._transport(server.get_url())
 
597
        t = self.get_readonly_transport()
629
598
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
630
599
                           errors.InvalidHttpResponse),
631
600
                          t.get, 'foo/bar')
648
617
    _req_handler_class = BadStatusRequestHandler
649
618
 
650
619
    def test_http_has(self):
651
 
        server = self.get_readonly_server()
652
 
        t = self._transport(server.get_url())
 
620
        t = self.get_readonly_transport()
653
621
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
654
622
 
655
623
    def test_http_get(self):
656
 
        server = self.get_readonly_server()
657
 
        t = self._transport(server.get_url())
 
624
        t = self.get_readonly_transport()
658
625
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
659
626
 
660
627
 
665
632
        """Fakes handling a single HTTP request, returns a bad status"""
666
633
        ignored = http_server.TestingHTTPRequestHandler.parse_request(self)
667
634
        self.wfile.write("Invalid status line\r\n")
 
635
        # If we don't close the connection pycurl will hang. Since this is a
 
636
        # stress test we don't *have* to respect the protocol, but we don't
 
637
        # have to sabotage it too much either.
 
638
        self.close_connection = True
668
639
        return False
669
640
 
670
641
 
676
647
 
677
648
    _req_handler_class = InvalidStatusRequestHandler
678
649
 
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
650
 
692
651
class BadProtocolRequestHandler(http_server.TestingHTTPRequestHandler):
693
652
    """Whatever request comes in, returns a bad protocol version"""
715
674
        super(TestBadProtocolServer, self).setUp()
716
675
 
717
676
    def test_http_has(self):
718
 
        server = self.get_readonly_server()
719
 
        t = self._transport(server.get_url())
 
677
        t = self.get_readonly_transport()
720
678
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
721
679
 
722
680
    def test_http_get(self):
723
 
        server = self.get_readonly_server()
724
 
        t = self._transport(server.get_url())
 
681
        t = self.get_readonly_transport()
725
682
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
726
683
 
727
684
 
741
698
    _req_handler_class = ForbiddenRequestHandler
742
699
 
743
700
    def test_http_has(self):
744
 
        server = self.get_readonly_server()
745
 
        t = self._transport(server.get_url())
 
701
        t = self.get_readonly_transport()
746
702
        self.assertRaises(errors.TransportError, t.has, 'foo/bar')
747
703
 
748
704
    def test_http_get(self):
749
 
        server = self.get_readonly_server()
750
 
        t = self._transport(server.get_url())
 
705
        t = self.get_readonly_transport()
751
706
        self.assertRaises(errors.TransportError, t.get, 'foo/bar')
752
707
 
753
708
 
792
747
        self.build_tree_contents([('a', '0123456789')],)
793
748
 
794
749
    def test_readv(self):
795
 
        server = self.get_readonly_server()
796
 
        t = self._transport(server.get_url())
 
750
        t = self.get_readonly_transport()
797
751
        l = list(t.readv('a', ((0, 1), (1, 1), (3, 2), (9, 1))))
798
752
        self.assertEqual(l[0], (0, '0'))
799
753
        self.assertEqual(l[1], (1, '1'))
801
755
        self.assertEqual(l[3], (9, '9'))
802
756
 
803
757
    def test_readv_out_of_order(self):
804
 
        server = self.get_readonly_server()
805
 
        t = self._transport(server.get_url())
 
758
        t = self.get_readonly_transport()
806
759
        l = list(t.readv('a', ((1, 1), (9, 1), (0, 1), (3, 2))))
807
760
        self.assertEqual(l[0], (1, '1'))
808
761
        self.assertEqual(l[1], (9, '9'))
810
763
        self.assertEqual(l[3], (3, '34'))
811
764
 
812
765
    def test_readv_invalid_ranges(self):
813
 
        server = self.get_readonly_server()
814
 
        t = self._transport(server.get_url())
 
766
        t = self.get_readonly_transport()
815
767
 
816
768
        # This is intentionally reading off the end of the file
817
769
        # since we are sure that it cannot get there
825
777
 
826
778
    def test_readv_multiple_get_requests(self):
827
779
        server = self.get_readonly_server()
828
 
        t = self._transport(server.get_url())
 
780
        t = self.get_readonly_transport()
829
781
        # force transport to issue multiple requests
830
782
        t._max_readv_combine = 1
831
783
        t._max_get_ranges = 1
839
791
 
840
792
    def test_readv_get_max_size(self):
841
793
        server = self.get_readonly_server()
842
 
        t = self._transport(server.get_url())
 
794
        t = self.get_readonly_transport()
843
795
        # force transport to issue multiple requests by limiting the number of
844
796
        # bytes by request. Note that this apply to coalesced offsets only, a
845
797
        # single range will keep its size even if bigger than the limit.
854
806
 
855
807
    def test_complete_readv_leave_pipe_clean(self):
856
808
        server = self.get_readonly_server()
857
 
        t = self._transport(server.get_url())
 
809
        t = self.get_readonly_transport()
858
810
        # force transport to issue multiple requests
859
811
        t._get_max_size = 2
860
 
        l = list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
 
812
        list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
861
813
        # The server should have issued 3 requests
862
814
        self.assertEqual(3, server.GET_request_nb)
863
815
        self.assertEqual('0123456789', t.get_bytes('a'))
865
817
 
866
818
    def test_incomplete_readv_leave_pipe_clean(self):
867
819
        server = self.get_readonly_server()
868
 
        t = self._transport(server.get_url())
 
820
        t = self.get_readonly_transport()
869
821
        # force transport to issue multiple requests
870
822
        t._get_max_size = 2
871
823
        # Don't collapse readv results into a list so that we leave unread
940
892
    def get_multiple_ranges(self, file, file_size, ranges):
941
893
        self.send_response(206)
942
894
        self.send_header('Accept-Ranges', 'bytes')
 
895
        # XXX: this is strange; the 'random' name below seems undefined and
 
896
        # yet the tests pass -- mbp 2010-10-11 bug 658773
943
897
        boundary = "%d" % random.randint(0,0x7FFFFFFF)
944
898
        self.send_header("Content-Type",
945
899
                         "multipart/byteranges; boundary=%s" % boundary)
1021
975
 
1022
976
    def test_readv_with_short_reads(self):
1023
977
        server = self.get_readonly_server()
1024
 
        t = self._transport(server.get_url())
 
978
        t = self.get_readonly_transport()
1025
979
        # Force separate ranges for each offset
1026
980
        t._bytes_to_read_before_seek = 0
1027
981
        ireadv = iter(t.readv('a', ((0, 1), (2, 1), (4, 2), (9, 1))))
1071
1025
class TestLimitedRangeRequestServer(http_utils.TestCaseWithWebserver):
1072
1026
    """Tests readv requests against a server erroring out on too much ranges."""
1073
1027
 
 
1028
    scenarios = multiply_scenarios(
 
1029
        vary_by_http_client_implementation(), 
 
1030
        vary_by_http_protocol_version(),
 
1031
        )
 
1032
 
1074
1033
    # Requests with more range specifiers will error out
1075
1034
    range_limit = 3
1076
1035
 
1078
1037
        return LimitedRangeHTTPServer(range_limit=self.range_limit,
1079
1038
                                      protocol_version=self._protocol_version)
1080
1039
 
1081
 
    def get_transport(self):
1082
 
        return self._transport(self.get_readonly_server().get_url())
1083
 
 
1084
1040
    def setUp(self):
1085
1041
        http_utils.TestCaseWithWebserver.setUp(self)
1086
1042
        # We need to manipulate ranges that correspond to real chunks in the
1090
1046
        self.build_tree_contents([('a', content)],)
1091
1047
 
1092
1048
    def test_few_ranges(self):
1093
 
        t = self.get_transport()
 
1049
        t = self.get_readonly_transport()
1094
1050
        l = list(t.readv('a', ((0, 4), (1024, 4), )))
1095
1051
        self.assertEqual(l[0], (0, '0000'))
1096
1052
        self.assertEqual(l[1], (1024, '0001'))
1097
1053
        self.assertEqual(1, self.get_readonly_server().GET_request_nb)
1098
1054
 
1099
1055
    def test_more_ranges(self):
1100
 
        t = self.get_transport()
 
1056
        t = self.get_readonly_transport()
1101
1057
        l = list(t.readv('a', ((0, 4), (1024, 4), (4096, 4), (8192, 4))))
1102
1058
        self.assertEqual(l[0], (0, '0000'))
1103
1059
        self.assertEqual(l[1], (1024, '0001'))
1117
1073
    def setUp(self):
1118
1074
        tests.TestCase.setUp(self)
1119
1075
        self._old_env = {}
1120
 
 
1121
 
    def tearDown(self):
1122
 
        self._restore_env()
1123
 
        tests.TestCase.tearDown(self)
 
1076
        self.addCleanup(self._restore_env)
1124
1077
 
1125
1078
    def _install_env(self, env):
1126
1079
        for name, value in env.iteritems():
1156
1109
    to the file names).
1157
1110
    """
1158
1111
 
 
1112
    scenarios = multiply_scenarios(
 
1113
        vary_by_http_client_implementation(), 
 
1114
        vary_by_http_protocol_version(),
 
1115
        )
 
1116
 
1159
1117
    # FIXME: We don't have an https server available, so we don't
1160
 
    # test https connections.
 
1118
    # test https connections. --vila toolongago
1161
1119
 
1162
1120
    def setUp(self):
1163
1121
        super(TestProxyHttpServer, self).setUp()
 
1122
        self.transport_secondary_server = http_utils.ProxyServer
1164
1123
        self.build_tree_contents([('foo', 'contents of foo\n'),
1165
1124
                                  ('foo-proxied', 'proxied contents of foo\n')])
1166
1125
        # 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)
 
1126
        server = self.get_readonly_server()
 
1127
        self.server_host_port = '%s:%d' % (server.host, server.port)
1169
1128
        if self._testing_pycurl():
1170
1129
            # Oh my ! pycurl does not check for the port as part of
1171
1130
            # no_proxy :-( So we just test the host part
1172
 
            self.no_proxy_host = self.server.host
 
1131
            self.no_proxy_host = server.host
1173
1132
        else:
1174
 
            self.no_proxy_host = self.proxy_address
 
1133
            self.no_proxy_host = self.server_host_port
1175
1134
        # The secondary server is the proxy
1176
 
        self.proxy = self.get_secondary_server()
1177
 
        self.proxy_url = self.proxy.get_url()
 
1135
        self.proxy_url = self.get_secondary_url()
1178
1136
        self._old_env = {}
1179
1137
 
1180
1138
    def _testing_pycurl(self):
1182
1140
        return (features.pycurl.available()
1183
1141
                and self._transport == PyCurlTransport)
1184
1142
 
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
1143
    def _install_env(self, env):
1192
1144
        for name, value in env.iteritems():
1193
1145
            self._old_env[name] = osutils.set_or_unset_env(name, value)
1198
1150
 
1199
1151
    def proxied_in_env(self, env):
1200
1152
        self._install_env(env)
1201
 
        url = self.server.get_url()
1202
 
        t = self._transport(url)
 
1153
        t = self.get_readonly_transport()
1203
1154
        try:
1204
1155
            self.assertEqual('proxied contents of foo\n', t.get('foo').read())
1205
1156
        finally:
1207
1158
 
1208
1159
    def not_proxied_in_env(self, env):
1209
1160
        self._install_env(env)
1210
 
        url = self.server.get_url()
1211
 
        t = self._transport(url)
 
1161
        t = self.get_readonly_transport()
1212
1162
        try:
1213
1163
            self.assertEqual('contents of foo\n', t.get('foo').read())
1214
1164
        finally:
1256
1206
            # pycurl *ignores* invalid proxy env variables. If that ever change
1257
1207
            # in the future, this test will fail indicating that pycurl do not
1258
1208
            # ignore anymore such variables.
1259
 
            self.not_proxied_in_env({'http_proxy': self.proxy_address})
 
1209
            self.not_proxied_in_env({'http_proxy': self.server_host_port})
1260
1210
        else:
1261
1211
            self.assertRaises(errors.InvalidURL,
1262
1212
                              self.proxied_in_env,
1263
 
                              {'http_proxy': self.proxy_address})
 
1213
                              {'http_proxy': self.server_host_port})
1264
1214
 
1265
1215
 
1266
1216
class TestRanges(http_utils.TestCaseWithWebserver):
1267
1217
    """Test the Range header in GET methods."""
1268
1218
 
 
1219
    scenarios = multiply_scenarios(
 
1220
        vary_by_http_client_implementation(), 
 
1221
        vary_by_http_protocol_version(),
 
1222
        )
 
1223
 
1269
1224
    def setUp(self):
1270
1225
        http_utils.TestCaseWithWebserver.setUp(self)
1271
1226
        self.build_tree_contents([('a', '0123456789')],)
1272
 
        server = self.get_readonly_server()
1273
 
        self.transport = self._transport(server.get_url())
1274
1227
 
1275
1228
    def create_transport_readonly_server(self):
1276
1229
        return http_server.HttpServer(protocol_version=self._protocol_version)
1277
1230
 
1278
1231
    def _file_contents(self, relpath, ranges):
 
1232
        t = self.get_readonly_transport()
1279
1233
        offsets = [ (start, end - start + 1) for start, end in ranges]
1280
 
        coalesce = self.transport._coalesce_offsets
 
1234
        coalesce = t._coalesce_offsets
1281
1235
        coalesced = list(coalesce(offsets, limit=0, fudge_factor=0))
1282
 
        code, data = self.transport._get(relpath, coalesced)
 
1236
        code, data = t._get(relpath, coalesced)
1283
1237
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
1284
1238
        for start, end in ranges:
1285
1239
            data.seek(start)
1286
1240
            yield data.read(end - start + 1)
1287
1241
 
1288
1242
    def _file_tail(self, relpath, tail_amount):
1289
 
        code, data = self.transport._get(relpath, [], tail_amount)
 
1243
        t = self.get_readonly_transport()
 
1244
        code, data = t._get(relpath, [], tail_amount)
1290
1245
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
1291
1246
        data.seek(-tail_amount, 2)
1292
1247
        return data.read(tail_amount)
1311
1266
class TestHTTPRedirections(http_utils.TestCaseWithRedirectedWebserver):
1312
1267
    """Test redirection between http servers."""
1313
1268
 
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
 
1269
    scenarios = multiply_scenarios(
 
1270
        vary_by_http_client_implementation(), 
 
1271
        vary_by_http_protocol_version(),
 
1272
        )
1322
1273
 
1323
1274
    def setUp(self):
1324
1275
        super(TestHTTPRedirections, self).setUp()
1326
1277
                                  ('bundle',
1327
1278
                                  '# Bazaar revision bundle v0.9\n#\n')
1328
1279
                                  ],)
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
1280
 
1332
1281
    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)
 
1282
        self.assertRaises(errors.RedirectRequested,
 
1283
                          self.get_old_transport().get, 'a')
 
1284
        self.assertEqual('0123456789', self.get_new_transport().get('a').read())
1344
1285
 
1345
1286
 
1346
1287
class RedirectedRequest(_urllib2_wrappers.Request):
1363
1304
    test.overrideAttr(_urllib2_wrappers, 'Request', RedirectedRequest)
1364
1305
 
1365
1306
 
 
1307
def cleanup_http_redirection_connections(test):
 
1308
    # Some sockets are opened but never seen by _urllib, so we trap them at
 
1309
    # the _urllib2_wrappers level to be able to clean them up.
 
1310
    def socket_disconnect(sock):
 
1311
        try:
 
1312
            sock.shutdown(socket.SHUT_RDWR)
 
1313
            sock.close()
 
1314
        except socket.error:
 
1315
            pass
 
1316
    def connect(connection):
 
1317
        test.http_connect_orig(connection)
 
1318
        test.addCleanup(socket_disconnect, connection.sock)
 
1319
    test.http_connect_orig = test.overrideAttr(
 
1320
        _urllib2_wrappers.HTTPConnection, 'connect', connect)
 
1321
    def connect(connection):
 
1322
        test.https_connect_orig(connection)
 
1323
        test.addCleanup(socket_disconnect, connection.sock)
 
1324
    test.https_connect_orig = test.overrideAttr(
 
1325
        _urllib2_wrappers.HTTPSConnection, 'connect', connect)
 
1326
 
 
1327
 
1366
1328
class TestHTTPSilentRedirections(http_utils.TestCaseWithRedirectedWebserver):
1367
1329
    """Test redirections.
1368
1330
 
1377
1339
    -- vila 20070212
1378
1340
    """
1379
1341
 
 
1342
    scenarios = multiply_scenarios(
 
1343
        vary_by_http_client_implementation(), 
 
1344
        vary_by_http_protocol_version(),
 
1345
        )
 
1346
 
1380
1347
    def setUp(self):
1381
1348
        if (features.pycurl.available()
1382
1349
            and self._transport == PyCurlTransport):
1383
1350
            raise tests.TestNotApplicable(
1384
 
                "pycurl doesn't redirect silently annymore")
 
1351
                "pycurl doesn't redirect silently anymore")
1385
1352
        super(TestHTTPSilentRedirections, self).setUp()
1386
1353
        install_redirected_request(self)
 
1354
        cleanup_http_redirection_connections(self)
1387
1355
        self.build_tree_contents([('a','a'),
1388
1356
                                  ('1/',),
1389
1357
                                  ('1/a', 'redirected once'),
1397
1365
                                  ('5/a', 'redirected 5 times'),
1398
1366
                                  ],)
1399
1367
 
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
1368
    def test_one_redirection(self):
1408
 
        t = self.old_transport
1409
 
 
1410
 
        req = RedirectedRequest('GET', t.abspath('a'))
 
1369
        t = self.get_old_transport()
 
1370
        req = RedirectedRequest('GET', t._remote_path('a'))
1411
1371
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1412
1372
                                       self.new_server.port)
1413
1373
        self.old_server.redirections = \
1414
1374
            [('(.*)', r'%s/1\1' % (new_prefix), 301),]
1415
 
        self.assertEqual('redirected once',t._perform(req).read())
 
1375
        self.assertEqual('redirected once', t._perform(req).read())
1416
1376
 
1417
1377
    def test_five_redirections(self):
1418
 
        t = self.old_transport
1419
 
 
1420
 
        req = RedirectedRequest('GET', t.abspath('a'))
 
1378
        t = self.get_old_transport()
 
1379
        req = RedirectedRequest('GET', t._remote_path('a'))
1421
1380
        old_prefix = 'http://%s:%s' % (self.old_server.host,
1422
1381
                                       self.old_server.port)
1423
1382
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1429
1388
            ('/4(.*)', r'%s/5\1' % (new_prefix), 301),
1430
1389
            ('(/[^/]+)', r'%s/1\1' % (old_prefix), 301),
1431
1390
            ]
1432
 
        self.assertEqual('redirected 5 times',t._perform(req).read())
 
1391
        self.assertEqual('redirected 5 times', t._perform(req).read())
1433
1392
 
1434
1393
 
1435
1394
class TestDoCatchRedirections(http_utils.TestCaseWithRedirectedWebserver):
1436
1395
    """Test transport.do_catching_redirections."""
1437
1396
 
 
1397
    scenarios = multiply_scenarios(
 
1398
        vary_by_http_client_implementation(), 
 
1399
        vary_by_http_protocol_version(),
 
1400
        )
 
1401
 
1438
1402
    def setUp(self):
1439
1403
        super(TestDoCatchRedirections, self).setUp()
1440
1404
        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')
 
1405
        cleanup_http_redirection_connections(self)
 
1406
 
 
1407
        self.old_transport = self.get_old_transport()
 
1408
 
 
1409
    def get_a(self, t):
 
1410
        return t.get('a')
1446
1411
 
1447
1412
    def test_no_redirection(self):
1448
 
        t = self._transport(self.new_server.get_url())
 
1413
        t = self.get_new_transport()
1449
1414
 
1450
1415
        # We use None for redirected so that we fail if redirected
1451
1416
        self.assertEqual('0123456789',
1455
1420
    def test_one_redirection(self):
1456
1421
        self.redirections = 0
1457
1422
 
1458
 
        def redirected(transport, exception, redirection_notice):
 
1423
        def redirected(t, exception, redirection_notice):
1459
1424
            self.redirections += 1
1460
 
            dir, file = urlutils.split(exception.target)
1461
 
            return self._transport(dir)
 
1425
            redirected_t = t._redirected_to(exception.source, exception.target)
 
1426
            return redirected_t
1462
1427
 
1463
1428
        self.assertEqual('0123456789',
1464
1429
                         transport.do_catching_redirections(
1481
1446
class TestAuth(http_utils.TestCaseWithWebserver):
1482
1447
    """Test authentication scheme"""
1483
1448
 
 
1449
    scenarios = multiply_scenarios(
 
1450
        vary_by_http_client_implementation(),
 
1451
        vary_by_http_protocol_version(),
 
1452
        vary_by_http_auth_scheme(),
 
1453
        )
 
1454
 
1484
1455
    _auth_header = 'Authorization'
1485
1456
    _password_prompt_prefix = ''
1486
1457
    _username_prompt_prefix = ''
1494
1465
                                  ('b', 'contents of b\n'),])
1495
1466
 
1496
1467
    def create_transport_readonly_server(self):
1497
 
        return self._auth_server(protocol_version=self._protocol_version)
 
1468
        server = self._auth_server(protocol_version=self._protocol_version)
 
1469
        server._url_protocol = self._url_protocol
 
1470
        return server
1498
1471
 
1499
1472
    def _testing_pycurl(self):
1500
1473
        # TODO: This is duplicated for lots of the classes in this file
1513
1486
        return url
1514
1487
 
1515
1488
    def get_user_transport(self, user, password):
1516
 
        return self._transport(self.get_user_url(user, password))
 
1489
        t = transport.get_transport(self.get_user_url(user, password))
 
1490
        return t
1517
1491
 
1518
1492
    def test_no_user(self):
1519
1493
        self.server.add_user('joe', 'foo')
1630
1604
        ui.ui_factory = tests.TestUIFactory(stdin=stdin_content,
1631
1605
                                            stderr=tests.StringIOWrapper())
1632
1606
        # 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()
 
1607
        _setup_authentication_config(
 
1608
            scheme='http', 
 
1609
            port=self.server.port,
 
1610
            user=user,
 
1611
            password=password)
1638
1612
        # Issue a request to the server to connect
1639
1613
        self.assertEqual('contents of a\n',t.get('a').read())
1640
1614
        # stdin should have  been left untouched
1642
1616
        # Only one 'Authentication Required' error should occur
1643
1617
        self.assertEqual(1, self.server.auth_required_errors)
1644
1618
 
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
1619
    def test_changing_nonce(self):
1665
1620
        if self._auth_server not in (http_utils.HTTPDigestAuthServer,
1666
1621
                                     http_utils.ProxyDigestAuthServer):
1682
1637
        # initial 'who are you' and a second 'who are you' with the new nonce)
1683
1638
        self.assertEqual(2, self.server.auth_required_errors)
1684
1639
 
 
1640
    def test_user_from_auth_conf(self):
 
1641
        if self._testing_pycurl():
 
1642
            raise tests.TestNotApplicable(
 
1643
                'pycurl does not support authentication.conf')
 
1644
        user = 'joe'
 
1645
        password = 'foo'
 
1646
        self.server.add_user(user, password)
 
1647
        _setup_authentication_config(
 
1648
            scheme='http', 
 
1649
            port=self.server.port,
 
1650
            user=user,
 
1651
            password=password)
 
1652
        t = self.get_user_transport(None, None)
 
1653
        # Issue a request to the server to connect
 
1654
        self.assertEqual('contents of a\n', t.get('a').read())
 
1655
        # Only one 'Authentication Required' error should occur
 
1656
        self.assertEqual(1, self.server.auth_required_errors)
 
1657
 
 
1658
 
 
1659
def _setup_authentication_config(**kwargs):
 
1660
    conf = config.AuthenticationConfig()
 
1661
    conf._get_config().update({'httptest': kwargs})
 
1662
    conf._save()
 
1663
 
 
1664
 
 
1665
 
 
1666
class TestUrllib2AuthHandler(tests.TestCaseWithTransport):
 
1667
    """Unit tests for glue by which urllib2 asks us for authentication"""
 
1668
 
 
1669
    def test_get_user_password_without_port(self):
 
1670
        """We cope if urllib2 doesn't tell us the port.
 
1671
 
 
1672
        See https://bugs.launchpad.net/bzr/+bug/654684
 
1673
        """
 
1674
        user = 'joe'
 
1675
        password = 'foo'
 
1676
        _setup_authentication_config(
 
1677
            scheme='http', 
 
1678
            host='localhost',
 
1679
            user=user,
 
1680
            password=password)
 
1681
        handler = _urllib2_wrappers.HTTPAuthHandler()
 
1682
        got_pass = handler.get_user_password(dict(
 
1683
            user='joe',
 
1684
            protocol='http',
 
1685
            host='localhost',
 
1686
            path='/',
 
1687
            realm='Realm',
 
1688
            ))
 
1689
        self.assertEquals((user, password), got_pass)
1685
1690
 
1686
1691
 
1687
1692
class TestProxyAuth(TestAuth):
1688
1693
    """Test proxy authentication schemes."""
1689
1694
 
 
1695
    scenarios = multiply_scenarios(
 
1696
        vary_by_http_client_implementation(),
 
1697
        vary_by_http_protocol_version(),
 
1698
        vary_by_http_proxy_auth_scheme(),
 
1699
        )
 
1700
 
1690
1701
    _auth_header = 'Proxy-authorization'
1691
1702
    _password_prompt_prefix = 'Proxy '
1692
1703
    _username_prompt_prefix = 'Proxy '
1704
1715
 
1705
1716
    def get_user_transport(self, user, password):
1706
1717
        self._install_env({'all_proxy': self.get_user_url(user, password)})
1707
 
        return self._transport(self.server.get_url())
 
1718
        return TestAuth.get_user_transport(self, user, password)
1708
1719
 
1709
1720
    def _install_env(self, env):
1710
1721
        for name, value in env.iteritems():
1737
1748
        self.readfile = StringIO(socket_read_content)
1738
1749
        self.writefile = StringIO()
1739
1750
        self.writefile.close = lambda: None
 
1751
        self.close = lambda: None
1740
1752
 
1741
1753
    def makefile(self, mode='r', bufsize=None):
1742
1754
        if 'r' in mode:
1747
1759
 
1748
1760
class SmartHTTPTunnellingTest(tests.TestCaseWithTransport):
1749
1761
 
 
1762
    scenarios = multiply_scenarios(
 
1763
        vary_by_http_client_implementation(), 
 
1764
        vary_by_http_protocol_version(),
 
1765
        )
 
1766
 
1750
1767
    def setUp(self):
1751
1768
        super(SmartHTTPTunnellingTest, self).setUp()
1752
1769
        # We use the VFS layer as part of HTTP tunnelling tests.
1753
1770
        self._captureVar('BZR_NO_SMART_VFS', None)
1754
1771
        self.transport_readonly_server = http_utils.HTTPServerWithSmarts
 
1772
        self.http_server = self.get_readonly_server()
1755
1773
 
1756
1774
    def create_transport_readonly_server(self):
1757
 
        return http_utils.HTTPServerWithSmarts(
 
1775
        server = http_utils.HTTPServerWithSmarts(
1758
1776
            protocol_version=self._protocol_version)
 
1777
        server._url_protocol = self._url_protocol
 
1778
        return server
1759
1779
 
1760
1780
    def test_open_bzrdir(self):
1761
1781
        branch = self.make_branch('relpath')
1762
 
        http_server = self.get_readonly_server()
1763
 
        url = http_server.get_url() + 'relpath'
 
1782
        url = self.http_server.get_url() + 'relpath'
1764
1783
        bd = bzrdir.BzrDir.open(url)
 
1784
        self.addCleanup(bd.transport.disconnect)
1765
1785
        self.assertIsInstance(bd, _mod_remote.RemoteBzrDir)
1766
1786
 
1767
1787
    def test_bulk_data(self):
1769
1789
        # The 'readv' command in the smart protocol both sends and receives
1770
1790
        # bulk data, so we use that.
1771
1791
        self.build_tree(['data-file'])
1772
 
        http_server = self.get_readonly_server()
1773
 
        http_transport = self._transport(http_server.get_url())
 
1792
        http_transport = transport.get_transport(self.http_server.get_url())
1774
1793
        medium = http_transport.get_smart_medium()
1775
1794
        # Since we provide the medium, the url below will be mostly ignored
1776
1795
        # during the test, as long as the path is '/'.
1784
1803
        post_body = 'hello\n'
1785
1804
        expected_reply_body = 'ok\x012\n'
1786
1805
 
1787
 
        http_server = self.get_readonly_server()
1788
 
        http_transport = self._transport(http_server.get_url())
 
1806
        http_transport = transport.get_transport(self.http_server.get_url())
1789
1807
        medium = http_transport.get_smart_medium()
1790
1808
        response = medium.send_http_smart_request(post_body)
1791
1809
        reply_body = response.read()
1792
1810
        self.assertEqual(expected_reply_body, reply_body)
1793
1811
 
1794
1812
    def test_smart_http_server_post_request_handler(self):
1795
 
        httpd = self.get_readonly_server()._get_httpd()
 
1813
        httpd = self.http_server.server
1796
1814
 
1797
1815
        socket = SampleSocket(
1798
1816
            'POST /.bzr/smart %s \r\n' % self._protocol_version
1830
1848
 
1831
1849
    def test_probe_smart_server(self):
1832
1850
        """Test error handling against server refusing smart requests."""
1833
 
        server = self.get_readonly_server()
1834
 
        t = self._transport(server.get_url())
 
1851
        t = self.get_readonly_transport()
1835
1852
        # No need to build a valid smart request here, the server will not even
1836
1853
        # try to interpret it.
1837
1854
        self.assertRaises(errors.SmartProtocolError,
1838
1855
                          t.get_smart_medium().send_http_smart_request,
1839
1856
                          'whatever')
1840
1857
 
 
1858
 
1841
1859
class Test_redirected_to(tests.TestCase):
1842
1860
 
 
1861
    scenarios = vary_by_http_client_implementation()
 
1862
 
1843
1863
    def test_redirected_to_subdir(self):
1844
1864
        t = self._transport('http://www.example.com/foo')
1845
1865
        r = t._redirected_to('http://www.example.com/foo',
1896
1916
    line.
1897
1917
    """
1898
1918
 
1899
 
    def handle_one_request(self):
 
1919
    def _handle_one_request(self):
1900
1920
        tcs = self.server.test_case_server
1901
1921
        requestline = self.rfile.readline()
1902
1922
        headers = self.MessageClass(self.rfile, 0)
1966
1986
        # We override at class level because constructors may propagate the
1967
1987
        # bound method and render instance overriding ineffective (an
1968
1988
        # 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)
 
1989
        self.overrideAttr(self._transport, '_report_activity', report_activity)
 
1990
        self.addCleanup(self.server.stop_server)
1976
1991
 
1977
1992
    def get_transport(self):
1978
 
        return self._transport(self.server.get_url())
 
1993
        t = self._transport(self.server.get_url())
 
1994
        # FIXME: Needs cleanup -- vila 20100611
 
1995
        return t
1979
1996
 
1980
1997
    def assertActivitiesMatch(self):
1981
1998
        self.assertEqual(self.server.bytes_read,
2086
2103
'''
2087
2104
        t = self.get_transport()
2088
2105
        # We must send a single line of body bytes, see
2089
 
        # PredefinedRequestHandler.handle_one_request
 
2106
        # PredefinedRequestHandler._handle_one_request
2090
2107
        code, f = t._post('abc def end-of-body\n')
2091
2108
        self.assertEqual('lalala whatever as long as itsssss\n', f.read())
2092
2109
        self.assertActivitiesMatch()
2094
2111
 
2095
2112
class TestActivity(tests.TestCase, TestActivityMixin):
2096
2113
 
 
2114
    scenarios = multiply_scenarios(
 
2115
        vary_by_http_activity(),
 
2116
        vary_by_http_protocol_version(),
 
2117
        )
 
2118
 
2097
2119
    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)
 
2120
        TestActivityMixin.setUp(self)
2117
2121
 
2118
2122
 
2119
2123
class TestNoReportActivity(tests.TestCase, TestActivityMixin):
2120
2124
 
 
2125
    # Unlike TestActivity, we are really testing ReportingFileSocket and
 
2126
    # ReportingSocket, so we don't need all the parametrization. Since
 
2127
    # ReportingFileSocket and ReportingSocket are wrappers, it's easier to
 
2128
    # test them through their use by the transport than directly (that's a
 
2129
    # bit less clean but far more simpler and effective).
 
2130
    _activity_server = ActivityHTTPServer
 
2131
    _protocol_version = 'HTTP/1.1'
 
2132
 
2121
2133
    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)
 
2134
        self._transport =_urllib.HttpTransport_urllib
 
2135
        TestActivityMixin.setUp(self)
2143
2136
 
2144
2137
    def assertActivitiesMatch(self):
2145
2138
        # Nothing to check here
2149
2142
class TestAuthOnRedirected(http_utils.TestCaseWithRedirectedWebserver):
2150
2143
    """Test authentication on the redirected http server."""
2151
2144
 
 
2145
    scenarios = vary_by_http_protocol_version()
 
2146
 
2152
2147
    _auth_header = 'Authorization'
2153
2148
    _password_prompt_prefix = ''
2154
2149
    _username_prompt_prefix = ''
2155
2150
    _auth_server = http_utils.HTTPBasicAuthServer
2156
2151
    _transport = _urllib.HttpTransport_urllib
2157
2152
 
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
2153
    def setUp(self):
2170
2154
        super(TestAuthOnRedirected, self).setUp()
2171
2155
        self.build_tree_contents([('a','a'),
2176
2160
                                       self.new_server.port)
2177
2161
        self.old_server.redirections = [
2178
2162
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2179
 
        self.old_transport = self._transport(self.old_server.get_url())
 
2163
        self.old_transport = self.get_old_transport()
2180
2164
        self.new_server.add_user('joe', 'foo')
2181
 
 
2182
 
    def get_a(self, transport):
2183
 
        return transport.get('a')
 
2165
        cleanup_http_redirection_connections(self)
 
2166
 
 
2167
    def create_transport_readonly_server(self):
 
2168
        server = self._auth_server(protocol_version=self._protocol_version)
 
2169
        server._url_protocol = self._url_protocol
 
2170
        return server
 
2171
 
 
2172
    def get_a(self, t):
 
2173
        return t.get('a')
2184
2174
 
2185
2175
    def test_auth_on_redirected_via_do_catching_redirections(self):
2186
2176
        self.redirections = 0
2187
2177
 
2188
 
        def redirected(transport, exception, redirection_notice):
 
2178
        def redirected(t, exception, redirection_notice):
2189
2179
            self.redirections += 1
2190
 
            dir, file = urlutils.split(exception.target)
2191
 
            return self._transport(dir)
 
2180
            redirected_t = t._redirected_to(exception.source, exception.target)
 
2181
            self.addCleanup(redirected_t.disconnect)
 
2182
            return redirected_t
2192
2183
 
2193
2184
        stdout = tests.StringIOWrapper()
2194
2185
        stderr = tests.StringIOWrapper()
2215
2206
                                       self.new_server.port)
2216
2207
        self.old_server.redirections = [
2217
2208
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2218
 
        self.assertEqual('redirected once',t._perform(req).read())
 
2209
        self.assertEqual('redirected once', t._perform(req).read())
2219
2210
        # stdin should be empty
2220
2211
        self.assertEqual('', ui.ui_factory.stdin.readline())
2221
2212
        # stdout should be empty, stderr will contains the prompts