← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_smart_transport.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-08-24 21:59:21 UTC
  • mfrom: (5363.2.22 controldir-1)
  • Revision ID: pqm@pqm.ubuntu.com-20100824215921-p4nheij9k4x6i1jw
(jelmer) Split generic interface code out of bzrlib.bzrdir.BzrDir into
 bzrlib.controldir.ControlDir. (Jelmer Vernooij)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart_transport.py
40
40
        server,
41
41
        vfs,
42
42
)
43
 
from bzrlib.tests import (
44
 
    test_smart,
45
 
    test_server,
46
 
    )
 
43
from bzrlib.tests import test_smart
47
44
from bzrlib.transport import (
48
45
        http,
49
46
        local,
975
972
            base = 'a_url'
976
973
            def external_url(self):
977
974
                return self.base
978
 
            def get(self, path):
 
975
            def get_bytes(self, path):
979
976
                raise Exception("some random exception from inside server")
980
 
 
981
 
        class FlakyServer(test_server.SmartTCPServer_for_testing):
982
 
            def get_backing_transport(self, backing_transport_server):
983
 
                return FlakyTransport()
984
 
 
985
 
        smart_server = FlakyServer()
986
 
        smart_server.start_server()
987
 
        self.addCleanup(smart_server.stop_server)
988
 
        t = remote.RemoteTCPTransport(smart_server.get_url())
989
 
        self.addCleanup(t.disconnect)
990
 
        err = self.assertRaises(errors.UnknownErrorFromSmartServer,
991
 
                                t.get, 'something')
992
 
        self.assertContainsRe(str(err), 'some random exception')
 
977
        smart_server = server.SmartTCPServer(backing_transport=FlakyTransport())
 
978
        smart_server.start_background_thread('-' + self.id())
 
979
        try:
 
980
            transport = remote.RemoteTCPTransport(smart_server.get_url())
 
981
            err = self.assertRaises(errors.UnknownErrorFromSmartServer,
 
982
                transport.get, 'something')
 
983
            self.assertContainsRe(str(err), 'some random exception')
 
984
            transport.disconnect()
 
985
        finally:
 
986
            smart_server.stop_background_thread()
993
987
 
994
988
 
995
989
class SmartTCPTests(tests.TestCase):
996
990
    """Tests for connection/end to end behaviour using the TCP server.
997
991
 
998
 
    All of these tests are run with a server running in another thread serving
 
992
    All of these tests are run with a server running on another thread serving
999
993
    a MemoryTransport, and a connection to it already open.
1000
994
 
1001
995
    the server is obtained by calling self.start_server(readonly=False).
1009
1003
        # NB: Tests using this fall into two categories: tests of the server,
1010
1004
        # tests wanting a server. The latter should be updated to use
1011
1005
        # self.vfs_transport_factory etc.
1012
 
        if backing_transport is None:
 
1006
        if not backing_transport:
1013
1007
            mem_server = memory.MemoryServer()
1014
1008
            mem_server.start_server()
1015
1009
            self.addCleanup(mem_server.stop_server)
1023
1017
            self.backing_transport = transport.get_transport(
1024
1018
                "readonly+" + self.backing_transport.abspath('.'))
1025
1019
        self.server = server.SmartTCPServer(self.backing_transport)
1026
 
        self.server.start_server('127.0.0.1', 0)
1027
1020
        self.server.start_background_thread('-' + self.id())
1028
1021
        self.transport = remote.RemoteTCPTransport(self.server.get_url())
1029
 
        self.addCleanup(self.stop_server)
 
1022
        self.addCleanup(self.tearDownServer)
1030
1023
        self.permit_url(self.server.get_url())
1031
1024
 
1032
 
    def stop_server(self):
1033
 
        """Disconnect the client and stop the server.
1034
 
 
1035
 
        This must be re-entrant as some tests will call it explicitly in
1036
 
        addition to the normal cleanup.
1037
 
        """
 
1025
    def tearDownServer(self):
1038
1026
        if getattr(self, 'transport', None):
1039
1027
            self.transport.disconnect()
1040
1028
            del self.transport
1041
1029
        if getattr(self, 'server', None):
1042
1030
            self.server.stop_background_thread()
 
1031
            # XXX: why not .stop_server() -- mbp 20100106
1043
1032
            del self.server
1044
1033
 
1045
1034
 
1046
1035
class TestServerSocketUsage(SmartTCPTests):
1047
1036
 
1048
 
    def test_server_start_stop(self):
1049
 
        """It should be safe to stop the server with no requests."""
 
1037
    def test_server_setup_teardown(self):
 
1038
        """It should be safe to teardown the server with no requests."""
1050
1039
        self.start_server()
1051
 
        t = remote.RemoteTCPTransport(self.server.get_url())
1052
 
        self.stop_server()
1053
 
        self.assertRaises(errors.ConnectionError, t.has, '.')
 
1040
        server = self.server
 
1041
        transport = remote.RemoteTCPTransport(self.server.get_url())
 
1042
        self.tearDownServer()
 
1043
        self.assertRaises(errors.ConnectionError, transport.has, '.')
1054
1044
 
1055
1045
    def test_server_closes_listening_sock_on_shutdown_after_request(self):
1056
1046
        """The server should close its listening socket when it's stopped."""
1057
1047
        self.start_server()
1058
 
        server_url = self.server.get_url()
 
1048
        server = self.server
1059
1049
        self.transport.has('.')
1060
 
        self.stop_server()
 
1050
        self.tearDownServer()
1061
1051
        # if the listening socket has closed, we should get a BADFD error
1062
1052
        # when connecting, rather than a hang.
1063
 
        t = remote.RemoteTCPTransport(server_url)
1064
 
        self.assertRaises(errors.ConnectionError, t.has, '.')
 
1053
        transport = remote.RemoteTCPTransport(server.get_url())
 
1054
        self.assertRaises(errors.ConnectionError, transport.has, '.')
1065
1055
 
1066
1056
 
1067
1057
class WritableEndToEndTests(SmartTCPTests):
1202
1192
        self.transport.has('.')
1203
1193
        self.assertEqual([], self.hook_calls)
1204
1194
        # clean up the server
1205
 
        self.stop_server()
 
1195
        self.tearDownServer()
1206
1196
        # now it should have fired.
1207
1197
        self.assertEqual(result, self.hook_calls)
1208
1198
 
1221
1211
        self.transport.has('.')
1222
1212
        self.assertEqual([], self.hook_calls)
1223
1213
        # clean up the server
1224
 
        self.stop_server()
 
1214
        self.tearDownServer()
1225
1215
        # now it should have fired.
1226
1216
        self.assertEqual(result, self.hook_calls)
1227
1217