← 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

Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_smart_transport.py
42
42
        HTTPServerWithSmarts,
43
43
        SmartRequestHandler,
44
44
        )
 
45
from bzrlib.tests.test_smart import TestCaseWithSmartMedium
45
46
from bzrlib.transport import (
46
47
        get_transport,
47
48
        local,
520
521
        self.assertRaises(errors.ReadingCompleted, request.read_bytes, None)
521
522
 
522
523
 
523
 
class RemoteTransportTests(tests.TestCaseWithTransport):
524
 
 
525
 
    def setUp(self):
526
 
        super(RemoteTransportTests, self).setUp()
527
 
        # We're allowed to set  the transport class here, so that we don't use
528
 
        # the default or a parameterized class, but rather use the
529
 
        # TestCaseWithTransport infrastructure to set up a smart server and
530
 
        # transport.
531
 
        self.transport_server = server.SmartTCPServer_for_testing
 
524
class RemoteTransportTests(TestCaseWithSmartMedium):
532
525
 
533
526
    def test_plausible_url(self):
534
527
        self.assert_(self.get_url().startswith('bzr://'))
540
533
    def test_get_medium_from_transport(self):
541
534
        """Remote transport has a medium always, which it can return."""
542
535
        t = self.get_transport()
543
 
        smart_medium = t.get_smart_medium()
544
 
        self.assertIsInstance(smart_medium, medium.SmartClientMedium)
 
536
        client_medium = t.get_smart_medium()
 
537
        self.assertIsInstance(client_medium, medium.SmartClientMedium)
545
538
 
546
539
 
547
540
class ErrorRaisingProtocol(object):
746
739
        self.assertTrue(server.finished)
747
740
        
748
741
    def test_socket_stream_error_handling(self):
749
 
        # Use plain python StringIO so we can monkey-patch the close method to
750
 
        # not discard the contents.
751
 
        from StringIO import StringIO
752
742
        server_sock, client_sock = self.portable_socket_pair()
753
743
        server = medium.SmartServerSocketStreamMedium(
754
744
            server_sock, None)
760
750
        self.assertTrue(server.finished)
761
751
        
762
752
    def test_pipe_like_stream_keyboard_interrupt_handling(self):
763
 
        # Use plain python StringIO so we can monkey-patch the close method to
764
 
        # not discard the contents.
765
753
        to_server = StringIO('')
766
754
        from_server = StringIO()
767
755
        server = medium.SmartServerPipeStreamMedium(
801
789
                self.assertContainsRe(str(e), 'some random exception')
802
790
            else:
803
791
                self.fail("get did not raise expected error")
 
792
            transport.disconnect()
804
793
        finally:
805
794
            smart_server.stop_background_thread()
806
795
 
1022
1011
 
1023
1012
    def build_handler(self, transport):
1024
1013
        """Returns a handler for the commands in protocol version one."""
1025
 
        return request.SmartServerRequestHandler(transport, request.request_handlers)
 
1014
        return request.SmartServerRequestHandler(transport,
 
1015
                                                 request.request_handlers)
1026
1016
 
1027
1017
    def test_construct_request_handler(self):
1028
1018
        """Constructing a request handler should be easy and set defaults."""
1036
1026
        self.assertEqual(None, handler.response.body)
1037
1027
        
1038
1028
    def test_disable_vfs_handler_classes_via_environment(self):
1039
 
        # VFS handler classes will raise an error from "execute" if BZR_NO_SMART_VFS
1040
 
        # is set.
 
1029
        # VFS handler classes will raise an error from "execute" if
 
1030
        # BZR_NO_SMART_VFS is set.
1041
1031
        handler = vfs.HasRequest(None)
1042
1032
        # set environment variable after construction to make sure it's
1043
1033
        # examined.
1044
 
        # Note that we can safely clobber BZR_NO_SMART_VFS here, because setUp has
1045
 
        # called _captureVar, so it will be restored to the right state
 
1034
        # Note that we can safely clobber BZR_NO_SMART_VFS here, because setUp
 
1035
        # has called _captureVar, so it will be restored to the right state
1046
1036
        # afterwards.
1047
1037
        os.environ['BZR_NO_SMART_VFS'] = ''
1048
1038
        self.assertRaises(errors.DisabledMethod, handler.execute)
1453
1443
 
1454
1444
 
1455
1445
class TestSmartClientUnicode(tests.TestCase):
1456
 
    """SmartClient tests for unicode arguments.
 
1446
    """_SmartClient tests for unicode arguments.
1457
1447
 
1458
1448
    Unicode arguments to call_with_body_bytes are not correct (remote method
1459
1449
    names, arguments, and bodies must all be expressed as byte strings), but
1460
 
    SmartClient should gracefully reject them, rather than getting into a broken
1461
 
    state that prevents future correct calls from working.  That is, it should
1462
 
    be possible to issue more requests on the medium afterwards, rather than
1463
 
    allowing one bad call to call_with_body_bytes to cause later calls to
 
1450
    _SmartClient should gracefully reject them, rather than getting into a
 
1451
    broken state that prevents future correct calls from working.  That is, it
 
1452
    should be possible to issue more requests on the medium afterwards, rather
 
1453
    than allowing one bad call to call_with_body_bytes to cause later calls to
1464
1454
    mysteriously fail with TooManyConcurrentRequests.
1465
1455
    """
1466
1456
 
1472
1462
        input = StringIO("\n")
1473
1463
        output = StringIO()
1474
1464
        client_medium = medium.SmartSimplePipesClientMedium(input, output)
1475
 
        smart_client = client.SmartClient(client_medium)
 
1465
        smart_client = client._SmartClient(client_medium)
1476
1466
        self.assertRaises(TypeError,
1477
1467
            smart_client.call_with_body_bytes, method, args, body)
1478
1468
        self.assertEqual("", output.getvalue())