/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_smart_transport.py

  • Committer: Martin
  • Date: 2010-05-25 17:27:52 UTC
  • mfrom: (5254 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5257.
  • Revision ID: gzlist@googlemail.com-20100525172752-amm089xcikv968sw
Merge bzr.dev to unite with similar changes already made

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart_transport.py
1
 
# Copyright (C) 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
28
28
        errors,
29
29
        osutils,
30
30
        tests,
 
31
        transport,
31
32
        urlutils,
32
33
        )
33
34
from bzrlib.smart import (
39
40
        server,
40
41
        vfs,
41
42
)
42
 
from bzrlib.tests.test_smart import TestCaseWithSmartMedium
 
43
from bzrlib.tests import test_smart
43
44
from bzrlib.transport import (
44
 
        get_transport,
 
45
        http,
45
46
        local,
46
47
        memory,
47
48
        remote,
48
49
        )
49
 
from bzrlib.transport.http import SmartClientHTTPMediumRequest
50
50
 
51
51
 
52
52
class StringIOSSHVendor(object):
557
557
        self.assertRaises(errors.ReadingCompleted, request.read_bytes, None)
558
558
 
559
559
 
560
 
class RemoteTransportTests(TestCaseWithSmartMedium):
 
560
class RemoteTransportTests(test_smart.TestCaseWithSmartMedium):
561
561
 
562
562
    def test_plausible_url(self):
563
563
        self.assert_(self.get_url().startswith('bzr://'))
657
657
        # wire-to-wire, using the whole stack, with a UTF-8 filename.
658
658
        transport = memory.MemoryTransport('memory:///')
659
659
        utf8_filename = u'testfile\N{INTERROBANG}'.encode('utf-8')
 
660
        # VFS requests use filenames, not raw UTF-8.
 
661
        hpss_path = urlutils.escape(utf8_filename)
660
662
        transport.put_bytes(utf8_filename, 'contents\nof\nfile\n')
661
 
        to_server = StringIO('get\001' + utf8_filename + '\n')
 
663
        to_server = StringIO('get\001' + hpss_path + '\n')
662
664
        from_server = StringIO()
663
665
        server = medium.SmartServerPipeStreamMedium(
664
666
            to_server, from_server, transport)
985
987
    All of these tests are run with a server running on another thread serving
986
988
    a MemoryTransport, and a connection to it already open.
987
989
 
988
 
    the server is obtained by calling self.setUpServer(readonly=False).
 
990
    the server is obtained by calling self.start_server(readonly=False).
989
991
    """
990
992
 
991
 
    def setUpServer(self, readonly=False, backing_transport=None):
 
993
    def start_server(self, readonly=False, backing_transport=None):
992
994
        """Setup the server.
993
995
 
994
996
        :param readonly: Create a readonly server.
997
999
        # tests wanting a server. The latter should be updated to use
998
1000
        # self.vfs_transport_factory etc.
999
1001
        if not backing_transport:
1000
 
            self.backing_transport = memory.MemoryTransport()
 
1002
            mem_server = memory.MemoryServer()
 
1003
            mem_server.start_server()
 
1004
            self.addCleanup(mem_server.stop_server)
 
1005
            self.permit_url(mem_server.get_url())
 
1006
            self.backing_transport = transport.get_transport(
 
1007
                mem_server.get_url())
1001
1008
        else:
1002
1009
            self.backing_transport = backing_transport
1003
1010
        if readonly:
1004
1011
            self.real_backing_transport = self.backing_transport
1005
 
            self.backing_transport = get_transport("readonly+" + self.backing_transport.abspath('.'))
 
1012
            self.backing_transport = transport.get_transport(
 
1013
                "readonly+" + self.backing_transport.abspath('.'))
1006
1014
        self.server = server.SmartTCPServer(self.backing_transport)
1007
1015
        self.server.start_background_thread('-' + self.id())
1008
1016
        self.transport = remote.RemoteTCPTransport(self.server.get_url())
1015
1023
            del self.transport
1016
1024
        if getattr(self, 'server', None):
1017
1025
            self.server.stop_background_thread()
 
1026
            # XXX: why not .stop_server() -- mbp 20100106
1018
1027
            del self.server
1019
1028
 
1020
1029
 
1022
1031
 
1023
1032
    def test_server_setup_teardown(self):
1024
1033
        """It should be safe to teardown the server with no requests."""
1025
 
        self.setUpServer()
 
1034
        self.start_server()
1026
1035
        server = self.server
1027
1036
        transport = remote.RemoteTCPTransport(self.server.get_url())
1028
1037
        self.tearDownServer()
1030
1039
 
1031
1040
    def test_server_closes_listening_sock_on_shutdown_after_request(self):
1032
1041
        """The server should close its listening socket when it's stopped."""
1033
 
        self.setUpServer()
 
1042
        self.start_server()
1034
1043
        server = self.server
1035
1044
        self.transport.has('.')
1036
1045
        self.tearDownServer()
1045
1054
 
1046
1055
    def setUp(self):
1047
1056
        super(WritableEndToEndTests, self).setUp()
1048
 
        self.setUpServer()
 
1057
        self.start_server()
1049
1058
 
1050
1059
    def test_start_tcp_server(self):
1051
1060
        url = self.server.get_url()
1124
1133
    def test_mkdir_error_readonly(self):
1125
1134
        """TransportNotPossible should be preserved from the backing transport."""
1126
1135
        self._captureVar('BZR_NO_SMART_VFS', None)
1127
 
        self.setUpServer(readonly=True)
 
1136
        self.start_server(readonly=True)
1128
1137
        self.assertRaises(errors.TransportNotPossible, self.transport.mkdir,
1129
1138
            'foo')
1130
1139
 
1140
1149
        self.hook_calls = []
1141
1150
        server.SmartTCPServer.hooks.install_named_hook('server_started',
1142
1151
            self.capture_server_call, None)
1143
 
        self.setUpServer()
 
1152
        self.start_server()
1144
1153
        # at this point, the server will be starting a thread up.
1145
1154
        # there is no indicator at the moment, so bodge it by doing a request.
1146
1155
        self.transport.has('.')
1154
1163
        self.hook_calls = []
1155
1164
        server.SmartTCPServer.hooks.install_named_hook('server_started',
1156
1165
            self.capture_server_call, None)
1157
 
        self.setUpServer(backing_transport=get_transport("."))
 
1166
        self.start_server(backing_transport=transport.get_transport("."))
1158
1167
        # at this point, the server will be starting a thread up.
1159
1168
        # there is no indicator at the moment, so bodge it by doing a request.
1160
1169
        self.transport.has('.')
1170
1179
        self.hook_calls = []
1171
1180
        server.SmartTCPServer.hooks.install_named_hook('server_stopped',
1172
1181
            self.capture_server_call, None)
1173
 
        self.setUpServer()
 
1182
        self.start_server()
1174
1183
        result = [([self.backing_transport.base], self.transport.base)]
1175
1184
        # check the stopping message isn't emitted up front.
1176
1185
        self.assertEqual([], self.hook_calls)
1187
1196
        self.hook_calls = []
1188
1197
        server.SmartTCPServer.hooks.install_named_hook('server_stopped',
1189
1198
            self.capture_server_call, None)
1190
 
        self.setUpServer(backing_transport=get_transport("."))
 
1199
        self.start_server(backing_transport=transport.get_transport("."))
1191
1200
        result = [(
1192
1201
            [self.backing_transport.base, self.backing_transport.external_url()]
1193
1202
            , self.transport.base)]
1332
1341
class RemoteTransportRegistration(tests.TestCase):
1333
1342
 
1334
1343
    def test_registration(self):
1335
 
        t = get_transport('bzr+ssh://example.com/path')
 
1344
        t = transport.get_transport('bzr+ssh://example.com/path')
1336
1345
        self.assertIsInstance(t, remote.RemoteSSHTransport)
1337
1346
        self.assertEqual('example.com', t._host)
1338
1347
 
1339
1348
    def test_bzr_https(self):
1340
1349
        # https://bugs.launchpad.net/bzr/+bug/128456
1341
 
        t = get_transport('bzr+https://example.com/path')
 
1350
        t = transport.get_transport('bzr+https://example.com/path')
1342
1351
        self.assertIsInstance(t, remote.RemoteHTTPTransport)
1343
1352
        self.assertStartsWith(
1344
1353
            t._http_transport.base,
2886
2895
        self.assertWriteCount(1)
2887
2896
 
2888
2897
    def test_send_response_with_body_stream_flushes_buffers_sometimes(self):
2889
 
        """When there are many chunks (>100), multiple writes will occur rather
 
2898
        """When there are many bytes (>1MB), multiple writes will occur rather
2890
2899
        than buffering indefinitely.
2891
2900
        """
2892
 
        # Construct a response with stream with 40 chunks in it.  Every chunk
2893
 
        # triggers 3 buffered writes, so we expect > 100 buffered writes, but <
2894
 
        # 200.
2895
 
        body_stream = ['chunk %d' % count for count in range(40)]
 
2901
        # Construct a response with stream with ~1.5MB in it. This should
 
2902
        # trigger 2 writes, but not 3
 
2903
        onekib = '12345678' * 128
 
2904
        body_stream = [onekib] * (1024 + 512)
2896
2905
        response = _mod_request.SuccessfulSmartServerResponse(
2897
2906
            ('arg', 'arg'), body_stream=body_stream)
2898
2907
        self.responder.send_response(response)
2899
 
        # The write buffer is flushed every 100 buffered writes, so we expect 2
2900
 
        # actual writes.
2901
2908
        self.assertWriteCount(2)
2902
2909
 
2903
2910
 
3511
3518
 
3512
3519
    def test_smart_http_medium_request_accept_bytes(self):
3513
3520
        medium = FakeHTTPMedium()
3514
 
        request = SmartClientHTTPMediumRequest(medium)
 
3521
        request = http.SmartClientHTTPMediumRequest(medium)
3515
3522
        request.accept_bytes('abc')
3516
3523
        request.accept_bytes('def')
3517
3524
        self.assertEqual(None, medium.written_request)