← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_http.py

  • Committer: Vincent Ladeuil
  • Date: 2010-06-11 16:31:34 UTC
  • mto: (5247.4.12 sftp-leaks)
  • mto: This revision was merged to the branch mainline in revision 5396.
  • Revision ID: v.ladeuil+lp@free.fr-20100611163134-6z4oydq7kw401vdl
Fix a bunch of tests that were building transport objects explicitely instead of relying on self.get_transport() leading to many wrong http implementation objects being tested.

* bzrlib/tests/test_http.py:
(load_tests): Rename _qualified_prefix into _url_protocol to
ensure it's taken into account for all created http servers (and
from there that we create the right kind of transport). Relying on
_transport for that proved to be unreliable (mixed
self.transport(), self.get_transport(),
self.get_readonly_transport, etc calls) and give the wrong
transport objects to the tests.
(TestSpecificRequestHandler.create_transport_readonly_server):
Propagate url_protocol.
(TestHTTPConnections, TestWallServer, TestBadStatusServer)
(TestBadProtocolServer, TestForbiddenServer)
(TestRangeRequestServer, TestLimitedRangeRequestServer)
(TestProxyHttpServer, TestRanges, TestHTTPRedirections)
(TestHTTPSilentRedirections, TestDoCatchRedirections, TestAuth)
(TestProxyAuth, SmartHTTPTunnellingTest, TestAuthOnRedirected):
Stop using self._transport.

* bzrlib/tests/http_utils.py:
(TestCaseWithWebserver): Define and propagate url_protocol like we
did for the http protocol version.
(TestCaseWithTwoWebservers.create_transport_secondary_server):
Propagate url_protocol.
(TestCaseWithTwoWebservers.get_secondary_url)
(TestCaseWithTwoWebservers.get_secondary_transport): Add missing
helpers.
(TestCaseWithRedirectedWebserver.create_transport_secondary_server):
Propagate url_protocol.
(TestCaseWithRedirectedWebserver.get_old_url)
(TestCaseWithRedirectedWebserver.get_old_transport)
(TestCaseWithRedirectedWebserver.get_new_url)
(TestCaseWithRedirectedWebserver.get_new_transport): Add missing
helpers

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_http.py
81
81
    transport_scenarios = [
82
82
        ('urllib', dict(_transport=_urllib.HttpTransport_urllib,
83
83
                        _server=http_server.HttpServer_urllib,
84
 
                        _qualified_prefix='http+urllib',)),
 
84
                        _url_protocol='http+urllib',)),
85
85
        ]
86
86
    if features.pycurl.available():
87
87
        transport_scenarios.append(
88
88
            ('pycurl', dict(_transport=PyCurlTransport,
89
89
                            _server=http_server.HttpServer_PyCurl,
90
 
                            _qualified_prefix='http+pycurl',)))
 
90
                            _url_protocol='http+pycurl',)))
91
91
    tests.multiply_tests(t_tests, transport_scenarios, result)
92
92
 
93
93
    protocol_scenarios = [
434
434
        server.start_server()
435
435
        try:
436
436
            url = server.get_url()
437
 
            self.assertTrue(url.startswith('%s://' % self._qualified_prefix))
 
437
            self.assertTrue(url.startswith('%s://' % self._url_protocol))
438
438
        finally:
439
439
            server.stop_server()
440
440
 
485
485
 
486
486
    def test_http_has(self):
487
487
        server = self.get_readonly_server()
488
 
        t = self._transport(server.get_url())
 
488
        t = self.get_readonly_transport()
489
489
        self.assertEqual(t.has('foo/bar'), True)
490
490
        self.assertEqual(len(server.logs), 1)
491
491
        self.assertContainsRe(server.logs[0],
493
493
 
494
494
    def test_http_has_not_found(self):
495
495
        server = self.get_readonly_server()
496
 
        t = self._transport(server.get_url())
 
496
        t = self.get_readonly_transport()
497
497
        self.assertEqual(t.has('not-found'), False)
498
498
        self.assertContainsRe(server.logs[1],
499
499
            r'"HEAD /not-found HTTP/1.." 404 - "-" "bzr/')
500
500
 
501
501
    def test_http_get(self):
502
502
        server = self.get_readonly_server()
503
 
        t = self._transport(server.get_url())
 
503
        t = self.get_readonly_transport()
504
504
        fp = t.get('foo/bar')
505
505
        self.assertEqualDiff(
506
506
            fp.read(),
529
529
    """Test registrations of various http implementations"""
530
530
 
531
531
    def test_http_registered(self):
532
 
        t = transport.get_transport('%s://foo.com/' % self._qualified_prefix)
 
532
        t = transport.get_transport('%s://foo.com/' % self._url_protocol)
533
533
        self.assertIsInstance(t, transport.Transport)
534
534
        self.assertIsInstance(t, self._transport)
535
535
 
538
538
 
539
539
    def test_post_body_is_received(self):
540
540
        server = RecordingServer(expect_body_tail='end-of-body',
541
 
            scheme=self._qualified_prefix)
 
541
                                 scheme=self._url_protocol)
542
542
        self.start_server(server)
543
543
        url = server.get_url()
544
 
        http_transport = self._transport(url)
 
544
        # FIXME: needs a cleanup -- vila 20100611
 
545
        http_transport = transport.get_transport(url)
545
546
        code, response = http_transport._post('abc def end-of-body')
546
547
        self.assertTrue(
547
548
            server.received_bytes.startswith('POST /.bzr/smart HTTP/1.'))
591
592
    _req_handler_class = http_server.TestingHTTPRequestHandler
592
593
 
593
594
    def create_transport_readonly_server(self):
594
 
        return http_server.HttpServer(self._req_handler_class,
595
 
                                      protocol_version=self._protocol_version)
 
595
        server = http_server.HttpServer(self._req_handler_class,
 
596
                                        protocol_version=self._protocol_version)
 
597
        server._url_protocol = self._url_protocol
 
598
        return server
596
599
 
597
600
    def _testing_pycurl(self):
598
601
        # TODO: This is duplicated for lots of the classes in this file
614
617
    _req_handler_class = WallRequestHandler
615
618
 
616
619
    def test_http_has(self):
617
 
        server = self.get_readonly_server()
618
 
        t = self._transport(server.get_url())
 
620
        t = self.get_readonly_transport()
619
621
        # Unfortunately httplib (see HTTPResponse._read_status
620
622
        # for details) make no distinction between a closed
621
623
        # socket and badly formatted status line, so we can't
627
629
                          t.has, 'foo/bar')
628
630
 
629
631
    def test_http_get(self):
630
 
        server = self.get_readonly_server()
631
 
        t = self._transport(server.get_url())
 
632
        t = self.get_readonly_transport()
632
633
        self.assertRaises((errors.ConnectionError, errors.ConnectionReset,
633
634
                           errors.InvalidHttpResponse),
634
635
                          t.get, 'foo/bar')
651
652
    _req_handler_class = BadStatusRequestHandler
652
653
 
653
654
    def test_http_has(self):
654
 
        server = self.get_readonly_server()
655
 
        t = self._transport(server.get_url())
 
655
        t = self.get_readonly_transport()
656
656
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
657
657
 
658
658
    def test_http_get(self):
659
 
        server = self.get_readonly_server()
660
 
        t = self._transport(server.get_url())
 
659
        t = self.get_readonly_transport()
661
660
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
662
661
 
663
662
 
680
679
    _req_handler_class = InvalidStatusRequestHandler
681
680
 
682
681
    def test_http_has(self):
 
682
        # FIXME: that should be fixed now, needs testing -- vila 20100611
683
683
        if self._testing_pycurl() and self._protocol_version == 'HTTP/1.1':
684
684
            raise tests.KnownFailure(
685
685
                'pycurl hangs if the server send back garbage')
718
718
        super(TestBadProtocolServer, self).setUp()
719
719
 
720
720
    def test_http_has(self):
721
 
        server = self.get_readonly_server()
722
 
        t = self._transport(server.get_url())
 
721
        t = self.get_readonly_transport()
723
722
        self.assertRaises(errors.InvalidHttpResponse, t.has, 'foo/bar')
724
723
 
725
724
    def test_http_get(self):
726
 
        server = self.get_readonly_server()
727
 
        t = self._transport(server.get_url())
 
725
        t = self.get_readonly_transport()
728
726
        self.assertRaises(errors.InvalidHttpResponse, t.get, 'foo/bar')
729
727
 
730
728
 
744
742
    _req_handler_class = ForbiddenRequestHandler
745
743
 
746
744
    def test_http_has(self):
747
 
        server = self.get_readonly_server()
748
 
        t = self._transport(server.get_url())
 
745
        t = self.get_readonly_transport()
749
746
        self.assertRaises(errors.TransportError, t.has, 'foo/bar')
750
747
 
751
748
    def test_http_get(self):
752
 
        server = self.get_readonly_server()
753
 
        t = self._transport(server.get_url())
 
749
        t = self.get_readonly_transport()
754
750
        self.assertRaises(errors.TransportError, t.get, 'foo/bar')
755
751
 
756
752
 
795
791
        self.build_tree_contents([('a', '0123456789')],)
796
792
 
797
793
    def test_readv(self):
798
 
        server = self.get_readonly_server()
799
 
        t = self._transport(server.get_url())
 
794
        t = self.get_readonly_transport()
800
795
        l = list(t.readv('a', ((0, 1), (1, 1), (3, 2), (9, 1))))
801
796
        self.assertEqual(l[0], (0, '0'))
802
797
        self.assertEqual(l[1], (1, '1'))
804
799
        self.assertEqual(l[3], (9, '9'))
805
800
 
806
801
    def test_readv_out_of_order(self):
807
 
        server = self.get_readonly_server()
808
 
        t = self._transport(server.get_url())
 
802
        t = self.get_readonly_transport()
809
803
        l = list(t.readv('a', ((1, 1), (9, 1), (0, 1), (3, 2))))
810
804
        self.assertEqual(l[0], (1, '1'))
811
805
        self.assertEqual(l[1], (9, '9'))
813
807
        self.assertEqual(l[3], (3, '34'))
814
808
 
815
809
    def test_readv_invalid_ranges(self):
816
 
        server = self.get_readonly_server()
817
 
        t = self._transport(server.get_url())
 
810
        t = self.get_readonly_transport()
818
811
 
819
812
        # This is intentionally reading off the end of the file
820
813
        # since we are sure that it cannot get there
828
821
 
829
822
    def test_readv_multiple_get_requests(self):
830
823
        server = self.get_readonly_server()
831
 
        t = self._transport(server.get_url())
 
824
        t = self.get_readonly_transport()
832
825
        # force transport to issue multiple requests
833
826
        t._max_readv_combine = 1
834
827
        t._max_get_ranges = 1
842
835
 
843
836
    def test_readv_get_max_size(self):
844
837
        server = self.get_readonly_server()
845
 
        t = self._transport(server.get_url())
 
838
        t = self.get_readonly_transport()
846
839
        # force transport to issue multiple requests by limiting the number of
847
840
        # bytes by request. Note that this apply to coalesced offsets only, a
848
841
        # single range will keep its size even if bigger than the limit.
857
850
 
858
851
    def test_complete_readv_leave_pipe_clean(self):
859
852
        server = self.get_readonly_server()
860
 
        t = self._transport(server.get_url())
 
853
        t = self.get_readonly_transport()
861
854
        # force transport to issue multiple requests
862
855
        t._get_max_size = 2
863
856
        l = list(t.readv('a', ((0, 1), (1, 1), (2, 4), (6, 4))))
868
861
 
869
862
    def test_incomplete_readv_leave_pipe_clean(self):
870
863
        server = self.get_readonly_server()
871
 
        t = self._transport(server.get_url())
 
864
        t = self.get_readonly_transport()
872
865
        # force transport to issue multiple requests
873
866
        t._get_max_size = 2
874
867
        # Don't collapse readv results into a list so that we leave unread
1024
1017
 
1025
1018
    def test_readv_with_short_reads(self):
1026
1019
        server = self.get_readonly_server()
1027
 
        t = self._transport(server.get_url())
 
1020
        t = self.get_readonly_transport()
1028
1021
        # Force separate ranges for each offset
1029
1022
        t._bytes_to_read_before_seek = 0
1030
1023
        ireadv = iter(t.readv('a', ((0, 1), (2, 1), (4, 2), (9, 1))))
1081
1074
        return LimitedRangeHTTPServer(range_limit=self.range_limit,
1082
1075
                                      protocol_version=self._protocol_version)
1083
1076
 
1084
 
    def get_transport(self):
1085
 
        return self._transport(self.get_readonly_server().get_url())
1086
 
 
1087
1077
    def setUp(self):
1088
1078
        http_utils.TestCaseWithWebserver.setUp(self)
1089
1079
        # We need to manipulate ranges that correspond to real chunks in the
1093
1083
        self.build_tree_contents([('a', content)],)
1094
1084
 
1095
1085
    def test_few_ranges(self):
1096
 
        t = self.get_transport()
 
1086
        t = self.get_readonly_transport()
1097
1087
        l = list(t.readv('a', ((0, 4), (1024, 4), )))
1098
1088
        self.assertEqual(l[0], (0, '0000'))
1099
1089
        self.assertEqual(l[1], (1024, '0001'))
1100
1090
        self.assertEqual(1, self.get_readonly_server().GET_request_nb)
1101
1091
 
1102
1092
    def test_more_ranges(self):
1103
 
        t = self.get_transport()
 
1093
        t = self.get_readonly_transport()
1104
1094
        l = list(t.readv('a', ((0, 4), (1024, 4), (4096, 4), (8192, 4))))
1105
1095
        self.assertEqual(l[0], (0, '0000'))
1106
1096
        self.assertEqual(l[1], (1024, '0001'))
1160
1150
    """
1161
1151
 
1162
1152
    # FIXME: We don't have an https server available, so we don't
1163
 
    # test https connections.
 
1153
    # test https connections. --vila toolongago
1164
1154
 
1165
1155
    def setUp(self):
1166
1156
        super(TestProxyHttpServer, self).setUp()
 
1157
        self.transport_secondary_server = http_utils.ProxyServer
1167
1158
        self.build_tree_contents([('foo', 'contents of foo\n'),
1168
1159
                                  ('foo-proxied', 'proxied contents of foo\n')])
1169
1160
        # Let's setup some attributes for tests
1170
 
        self.server = self.get_readonly_server()
1171
 
        self.proxy_address = '%s:%d' % (self.server.host, self.server.port)
 
1161
        server = self.get_readonly_server()
 
1162
        self.server_host_port = '%s:%d' % (server.host, server.port)
1172
1163
        if self._testing_pycurl():
1173
1164
            # Oh my ! pycurl does not check for the port as part of
1174
1165
            # no_proxy :-( So we just test the host part
1175
 
            self.no_proxy_host = self.server.host
 
1166
            self.no_proxy_host = server.host
1176
1167
        else:
1177
 
            self.no_proxy_host = self.proxy_address
 
1168
            self.no_proxy_host = self.server_host_port
1178
1169
        # The secondary server is the proxy
1179
 
        self.proxy = self.get_secondary_server()
1180
 
        self.proxy_url = self.proxy.get_url()
 
1170
        self.proxy_url = self.get_secondary_url()
1181
1171
        self._old_env = {}
1182
1172
 
1183
1173
    def _testing_pycurl(self):
1185
1175
        return (features.pycurl.available()
1186
1176
                and self._transport == PyCurlTransport)
1187
1177
 
1188
 
    def create_transport_secondary_server(self):
1189
 
        """Creates an http server that will serve files with
1190
 
        '-proxied' appended to their names.
1191
 
        """
1192
 
        return http_utils.ProxyServer(protocol_version=self._protocol_version)
1193
 
 
1194
1178
    def _install_env(self, env):
1195
1179
        for name, value in env.iteritems():
1196
1180
            self._old_env[name] = osutils.set_or_unset_env(name, value)
1201
1185
 
1202
1186
    def proxied_in_env(self, env):
1203
1187
        self._install_env(env)
1204
 
        url = self.server.get_url()
1205
 
        t = self._transport(url)
 
1188
        t = self.get_readonly_transport()
1206
1189
        try:
1207
1190
            self.assertEqual('proxied contents of foo\n', t.get('foo').read())
1208
1191
        finally:
1210
1193
 
1211
1194
    def not_proxied_in_env(self, env):
1212
1195
        self._install_env(env)
1213
 
        url = self.server.get_url()
1214
 
        t = self._transport(url)
 
1196
        t = self.get_readonly_transport()
1215
1197
        try:
1216
1198
            self.assertEqual('contents of foo\n', t.get('foo').read())
1217
1199
        finally:
1259
1241
            # pycurl *ignores* invalid proxy env variables. If that ever change
1260
1242
            # in the future, this test will fail indicating that pycurl do not
1261
1243
            # ignore anymore such variables.
1262
 
            self.not_proxied_in_env({'http_proxy': self.proxy_address})
 
1244
            self.not_proxied_in_env({'http_proxy': self.server_host_port})
1263
1245
        else:
1264
1246
            self.assertRaises(errors.InvalidURL,
1265
1247
                              self.proxied_in_env,
1266
 
                              {'http_proxy': self.proxy_address})
 
1248
                              {'http_proxy': self.server_host_port})
1267
1249
 
1268
1250
 
1269
1251
class TestRanges(http_utils.TestCaseWithWebserver):
1272
1254
    def setUp(self):
1273
1255
        http_utils.TestCaseWithWebserver.setUp(self)
1274
1256
        self.build_tree_contents([('a', '0123456789')],)
1275
 
        server = self.get_readonly_server()
1276
 
        self.transport = self._transport(server.get_url())
1277
1257
 
1278
1258
    def create_transport_readonly_server(self):
1279
1259
        return http_server.HttpServer(protocol_version=self._protocol_version)
1280
1260
 
1281
1261
    def _file_contents(self, relpath, ranges):
 
1262
        t = self.get_readonly_transport()
1282
1263
        offsets = [ (start, end - start + 1) for start, end in ranges]
1283
 
        coalesce = self.transport._coalesce_offsets
 
1264
        coalesce = t._coalesce_offsets
1284
1265
        coalesced = list(coalesce(offsets, limit=0, fudge_factor=0))
1285
 
        code, data = self.transport._get(relpath, coalesced)
 
1266
        code, data = t._get(relpath, coalesced)
1286
1267
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
1287
1268
        for start, end in ranges:
1288
1269
            data.seek(start)
1289
1270
            yield data.read(end - start + 1)
1290
1271
 
1291
1272
    def _file_tail(self, relpath, tail_amount):
1292
 
        code, data = self.transport._get(relpath, [], tail_amount)
 
1273
        t = self.get_readonly_transport()
 
1274
        code, data = t._get(relpath, [], tail_amount)
1293
1275
        self.assertTrue(code in (200, 206),'_get returns: %d' % code)
1294
1276
        data.seek(-tail_amount, 2)
1295
1277
        return data.read(tail_amount)
1314
1296
class TestHTTPRedirections(http_utils.TestCaseWithRedirectedWebserver):
1315
1297
    """Test redirection between http servers."""
1316
1298
 
1317
 
    def create_transport_secondary_server(self):
1318
 
        """Create the secondary server redirecting to the primary server"""
1319
 
        new = self.get_readonly_server()
1320
 
 
1321
 
        redirecting = http_utils.HTTPServerRedirecting(
1322
 
            protocol_version=self._protocol_version)
1323
 
        redirecting.redirect_to(new.host, new.port)
1324
 
        return redirecting
1325
 
 
1326
1299
    def setUp(self):
1327
1300
        super(TestHTTPRedirections, self).setUp()
1328
1301
        self.build_tree_contents([('a', '0123456789'),
1329
1302
                                  ('bundle',
1330
1303
                                  '# Bazaar revision bundle v0.9\n#\n')
1331
1304
                                  ],)
1332
 
        # The requests to the old server will be redirected to the new server
1333
 
        self.old_transport = self._transport(self.old_server.get_url())
1334
1305
 
1335
1306
    def test_redirected(self):
1336
 
        self.assertRaises(errors.RedirectRequested, self.old_transport.get, 'a')
1337
 
        t = self._transport(self.new_server.get_url())
1338
 
        self.assertEqual('0123456789', t.get('a').read())
 
1307
        self.assertRaises(errors.RedirectRequested,
 
1308
                          self.get_old_transport().get, 'a')
 
1309
        self.assertEqual('0123456789', self.get_new_transport().get('a').read())
1339
1310
 
1340
1311
    def test_read_redirected_bundle_from_url(self):
1341
1312
        from bzrlib.bundle import read_bundle_from_url
1342
 
        url = self.old_transport.abspath('bundle')
 
1313
        url = self.get_old_url('bundle')
1343
1314
        bundle = self.applyDeprecated(deprecated_in((1, 12, 0)),
1344
1315
                read_bundle_from_url, url)
1345
1316
        # If read_bundle_from_url was successful we get an empty bundle
1384
1355
        if (features.pycurl.available()
1385
1356
            and self._transport == PyCurlTransport):
1386
1357
            raise tests.TestNotApplicable(
1387
 
                "pycurl doesn't redirect silently annymore")
 
1358
                "pycurl doesn't redirect silently anymore")
1388
1359
        super(TestHTTPSilentRedirections, self).setUp()
1389
1360
        install_redirected_request(self)
1390
1361
        self.build_tree_contents([('a','a'),
1400
1371
                                  ('5/a', 'redirected 5 times'),
1401
1372
                                  ],)
1402
1373
 
1403
 
        self.old_transport = self._transport(self.old_server.get_url())
1404
 
 
1405
 
    def create_transport_secondary_server(self):
1406
 
        """Create the secondary server, redirections are defined in the tests"""
1407
 
        return http_utils.HTTPServerRedirecting(
1408
 
            protocol_version=self._protocol_version)
1409
 
 
1410
1374
    def test_one_redirection(self):
1411
 
        t = self.old_transport
1412
 
 
1413
 
        req = RedirectedRequest('GET', t.abspath('a'))
 
1375
        t = self.get_old_transport()
 
1376
        req = RedirectedRequest('GET', t._remote_path('a'))
1414
1377
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1415
1378
                                       self.new_server.port)
1416
1379
        self.old_server.redirections = \
1417
1380
            [('(.*)', r'%s/1\1' % (new_prefix), 301),]
1418
 
        self.assertEqual('redirected once',t._perform(req).read())
 
1381
        self.assertEqual('redirected once', t._perform(req).read())
1419
1382
 
1420
1383
    def test_five_redirections(self):
1421
 
        t = self.old_transport
1422
 
 
1423
 
        req = RedirectedRequest('GET', t.abspath('a'))
 
1384
        t = self.get_old_transport()
 
1385
        req = RedirectedRequest('GET', t._remote_path('a'))
1424
1386
        old_prefix = 'http://%s:%s' % (self.old_server.host,
1425
1387
                                       self.old_server.port)
1426
1388
        new_prefix = 'http://%s:%s' % (self.new_server.host,
1432
1394
            ('/4(.*)', r'%s/5\1' % (new_prefix), 301),
1433
1395
            ('(/[^/]+)', r'%s/1\1' % (old_prefix), 301),
1434
1396
            ]
1435
 
        self.assertEqual('redirected 5 times',t._perform(req).read())
 
1397
        self.assertEqual('redirected 5 times', t._perform(req).read())
1436
1398
 
1437
1399
 
1438
1400
class TestDoCatchRedirections(http_utils.TestCaseWithRedirectedWebserver):
1442
1404
        super(TestDoCatchRedirections, self).setUp()
1443
1405
        self.build_tree_contents([('a', '0123456789'),],)
1444
1406
 
1445
 
        self.old_transport = self._transport(self.old_server.get_url())
 
1407
        self.old_transport = self.get_old_transport()
1446
1408
 
1447
1409
    def get_a(self, transport):
1448
1410
        return transport.get('a')
1449
1411
 
1450
1412
    def test_no_redirection(self):
1451
 
        t = self._transport(self.new_server.get_url())
 
1413
        t = self.get_new_transport()
1452
1414
 
1453
1415
        # We use None for redirected so that we fail if redirected
1454
1416
        self.assertEqual('0123456789',
1458
1420
    def test_one_redirection(self):
1459
1421
        self.redirections = 0
1460
1422
 
1461
 
        def redirected(transport, exception, redirection_notice):
 
1423
        def redirected(t, exception, redirection_notice):
1462
1424
            self.redirections += 1
1463
 
            dir, file = urlutils.split(exception.target)
1464
 
            return self._transport(dir)
 
1425
            redirected_t = t._redirected_to(exception.source, exception.target)
 
1426
            return redirected_t
1465
1427
 
1466
1428
        self.assertEqual('0123456789',
1467
1429
                         transport.do_catching_redirections(
1497
1459
                                  ('b', 'contents of b\n'),])
1498
1460
 
1499
1461
    def create_transport_readonly_server(self):
1500
 
        return self._auth_server(protocol_version=self._protocol_version)
 
1462
        server = self._auth_server(protocol_version=self._protocol_version)
 
1463
        server._url_protocol = self._url_protocol
 
1464
        return server
1501
1465
 
1502
1466
    def _testing_pycurl(self):
1503
1467
        # TODO: This is duplicated for lots of the classes in this file
1516
1480
        return url
1517
1481
 
1518
1482
    def get_user_transport(self, user, password):
1519
 
        return self._transport(self.get_user_url(user, password))
 
1483
        t = transport.get_transport(self.get_user_url(user, password))
 
1484
        return t
1520
1485
 
1521
1486
    def test_no_user(self):
1522
1487
        self.server.add_user('joe', 'foo')
1707
1672
 
1708
1673
    def get_user_transport(self, user, password):
1709
1674
        self._install_env({'all_proxy': self.get_user_url(user, password)})
1710
 
        return self._transport(self.server.get_url())
 
1675
        return TestAuth.get_user_transport(self, user, password)
1711
1676
 
1712
1677
    def _install_env(self, env):
1713
1678
        for name, value in env.iteritems():
1756
1721
        # We use the VFS layer as part of HTTP tunnelling tests.
1757
1722
        self._captureVar('BZR_NO_SMART_VFS', None)
1758
1723
        self.transport_readonly_server = http_utils.HTTPServerWithSmarts
 
1724
        self.http_server = self.get_readonly_server()
1759
1725
 
1760
1726
    def create_transport_readonly_server(self):
1761
 
        return http_utils.HTTPServerWithSmarts(
 
1727
        server = http_utils.HTTPServerWithSmarts(
1762
1728
            protocol_version=self._protocol_version)
 
1729
        server._url_protocol = self._url_protocol
 
1730
        return server
1763
1731
 
1764
1732
    def test_open_bzrdir(self):
1765
1733
        branch = self.make_branch('relpath')
1766
 
        http_server = self.get_readonly_server()
1767
 
        url = http_server.get_url() + 'relpath'
 
1734
        url = self.http_server.get_url() + 'relpath'
1768
1735
        bd = bzrdir.BzrDir.open(url)
1769
1736
        self.assertIsInstance(bd, _mod_remote.RemoteBzrDir)
1770
1737
 
1773
1740
        # The 'readv' command in the smart protocol both sends and receives
1774
1741
        # bulk data, so we use that.
1775
1742
        self.build_tree(['data-file'])
1776
 
        http_server = self.get_readonly_server()
1777
 
        http_transport = self._transport(http_server.get_url())
 
1743
        http_transport = transport.get_transport(self.http_server.get_url())
1778
1744
        medium = http_transport.get_smart_medium()
1779
1745
        # Since we provide the medium, the url below will be mostly ignored
1780
1746
        # during the test, as long as the path is '/'.
1788
1754
        post_body = 'hello\n'
1789
1755
        expected_reply_body = 'ok\x012\n'
1790
1756
 
1791
 
        http_server = self.get_readonly_server()
1792
 
        http_transport = self._transport(http_server.get_url())
 
1757
        http_transport = transport.get_transport(self.http_server.get_url())
1793
1758
        medium = http_transport.get_smart_medium()
1794
1759
        response = medium.send_http_smart_request(post_body)
1795
1760
        reply_body = response.read()
1796
1761
        self.assertEqual(expected_reply_body, reply_body)
1797
1762
 
1798
1763
    def test_smart_http_server_post_request_handler(self):
1799
 
        httpd = self.get_readonly_server().server
 
1764
        httpd = self.http_server.server
1800
1765
 
1801
1766
        socket = SampleSocket(
1802
1767
            'POST /.bzr/smart %s \r\n' % self._protocol_version
1834
1799
 
1835
1800
    def test_probe_smart_server(self):
1836
1801
        """Test error handling against server refusing smart requests."""
1837
 
        server = self.get_readonly_server()
1838
 
        t = self._transport(server.get_url())
 
1802
        t = self.get_readonly_transport()
1839
1803
        # No need to build a valid smart request here, the server will not even
1840
1804
        # try to interpret it.
1841
1805
        self.assertRaises(errors.SmartProtocolError,
1957
1921
    We use a special purpose server to control the bytes sent and received and
1958
1922
    be able to predict the activity on the client socket.
1959
1923
    """
1960
 
 
1961
 
    def setUp(self):
1962
 
        tests.TestCase.setUp(self)
1963
 
        self.server = self._activity_server(self._protocol_version)
1964
 
        self.server.start_server()
1965
 
        self.activities = {}
1966
 
        def report_activity(t, bytes, direction):
1967
 
            count = self.activities.get(direction, 0)
1968
 
            count += bytes
1969
 
            self.activities[direction] = count
1970
 
 
1971
 
        # We override at class level because constructors may propagate the
1972
 
        # bound method and render instance overriding ineffective (an
1973
 
        # alternative would be to define a specific ui factory instead...)
1974
 
        self.orig_report_activity = self._transport._report_activity
1975
 
        self._transport._report_activity = report_activity
1976
 
 
1977
 
    def tearDown(self):
1978
 
        self._transport._report_activity = self.orig_report_activity
1979
 
        self.server.stop_server()
1980
 
        tests.TestCase.tearDown(self)
1981
 
 
1982
1924
    def get_transport(self):
1983
 
        return self._transport(self.server.get_url())
 
1925
        t = self._transport(self.server.get_url())
 
1926
        # FIXME: Needs cleanup -- vila 20100611
 
1927
        return t
1984
1928
 
1985
1929
    def assertActivitiesMatch(self):
1986
1930
        self.assertEqual(self.server.bytes_read,
2103
2047
        tests.TestCase.setUp(self)
2104
2048
        self.server = self._activity_server(self._protocol_version)
2105
2049
        self.server.start_server()
 
2050
        self.addCleanup(self.server.stop_server)
 
2051
 
2106
2052
        self.activities = {}
2107
2053
        def report_activity(t, bytes, direction):
2108
2054
            count = self.activities.get(direction, 0)
2109
2055
            count += bytes
2110
2056
            self.activities[direction] = count
2111
 
 
2112
2057
        # We override at class level because constructors may propagate the
2113
2058
        # bound method and render instance overriding ineffective (an
2114
2059
        # alternative would be to define a specific ui factory instead...)
2115
 
        self.orig_report_activity = self._transport._report_activity
2116
 
        self._transport._report_activity = report_activity
2117
 
 
2118
 
    def tearDown(self):
2119
 
        self._transport._report_activity = self.orig_report_activity
2120
 
        self.server.stop_server()
2121
 
        tests.TestCase.tearDown(self)
 
2060
        self.overrideAttr(self._transport, '_report_activity', report_activity)
2122
2061
 
2123
2062
 
2124
2063
class TestNoReportActivity(tests.TestCase, TestActivityMixin):
2131
2070
        # test them through their use by the transport than directly (that's a
2132
2071
        # bit less clean but far more simpler and effective).
2133
2072
        self.server = ActivityHTTPServer('HTTP/1.1')
2134
 
        self._transport=_urllib.HttpTransport_urllib
 
2073
        self._transport = _urllib.HttpTransport_urllib
2135
2074
 
2136
2075
        self.server.start_server()
 
2076
        self.addCleanup(self.server.stop_server)
2137
2077
 
2138
2078
        # We override at class level because constructors may propagate the
2139
2079
        # bound method and render instance overriding ineffective (an
2140
2080
        # alternative would be to define a specific ui factory instead...)
2141
 
        self.orig_report_activity = self._transport._report_activity
2142
 
        self._transport._report_activity = None
2143
 
 
2144
 
    def tearDown(self):
2145
 
        self._transport._report_activity = self.orig_report_activity
2146
 
        self.server.stop_server()
2147
 
        tests.TestCase.tearDown(self)
 
2081
        self.overrideAttr(self._transport, '_report_activity', None)
2148
2082
 
2149
2083
    def assertActivitiesMatch(self):
2150
2084
        # Nothing to check here
2160
2094
    _auth_server = http_utils.HTTPBasicAuthServer
2161
2095
    _transport = _urllib.HttpTransport_urllib
2162
2096
 
2163
 
    def create_transport_readonly_server(self):
2164
 
        return self._auth_server(protocol_version=self._protocol_version)
2165
 
 
2166
 
    def create_transport_secondary_server(self):
2167
 
        """Create the secondary server redirecting to the primary server"""
2168
 
        new = self.get_readonly_server()
2169
 
 
2170
 
        redirecting = http_utils.HTTPServerRedirecting(
2171
 
            protocol_version=self._protocol_version)
2172
 
        redirecting.redirect_to(new.host, new.port)
2173
 
        return redirecting
2174
 
 
2175
2097
    def setUp(self):
2176
2098
        super(TestAuthOnRedirected, self).setUp()
2177
2099
        self.build_tree_contents([('a','a'),
2182
2104
                                       self.new_server.port)
2183
2105
        self.old_server.redirections = [
2184
2106
            ('(.*)', r'%s/1\1' % (new_prefix), 301),]
2185
 
        self.old_transport = self._transport(self.old_server.get_url())
 
2107
        self.old_transport = self.get_old_transport()
2186
2108
        self.new_server.add_user('joe', 'foo')
2187
2109
 
2188
 
    def get_a(self, transport):
2189
 
        return transport.get('a')
 
2110
    def create_transport_readonly_server(self):
 
2111
        server = self._auth_server(protocol_version=self._protocol_version)
 
2112
        server._url_protocol = self._url_protocol
 
2113
        return server
 
2114
 
 
2115
    def get_a(self, t):
 
2116
        return t.get('a')
2190
2117
 
2191
2118
    def test_auth_on_redirected_via_do_catching_redirections(self):
2192
2119
        self.redirections = 0
2193
2120
 
2194
 
        def redirected(transport, exception, redirection_notice):
 
2121
        def redirected(t, exception, redirection_notice):
2195
2122
            self.redirections += 1
2196
 
            dir, file = urlutils.split(exception.target)
2197
 
            return self._transport(dir)
 
2123
            redirected_t = t._redirected_to(exception.source, exception.target)
 
2124
            return redirected_t
2198
2125
 
2199
2126
        stdout = tests.StringIOWrapper()
2200
2127
        stderr = tests.StringIOWrapper()