/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 breezy/tests/test_smart_transport.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 19:09:26 UTC
  • mfrom: (6622.1.36 breezy)
  • Revision ID: jelmer@jelmer.uk-20170521190926-5vtz8xaf0e9ylrpc
Merge rename to breezy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_smart_transport.py
29
29
 
30
30
from testtools.matchers import DocTestMatches
31
31
 
32
 
import bzrlib
33
 
from bzrlib import (
 
32
import breezy
 
33
from breezy import (
34
34
        bzrdir,
35
35
        controldir,
36
36
        debug,
40
40
        transport as _mod_transport,
41
41
        urlutils,
42
42
        )
43
 
from bzrlib.smart import (
 
43
from breezy.smart import (
44
44
        client,
45
45
        medium,
46
46
        message,
49
49
        server as _mod_server,
50
50
        vfs,
51
51
)
52
 
from bzrlib.tests import (
 
52
from breezy.tests import (
53
53
    features,
54
54
    test_smart,
55
55
    test_server,
56
56
    )
57
 
from bzrlib.transport import (
 
57
from breezy.transport import (
58
58
        http,
59
59
        local,
60
60
        memory,
820
820
 
821
821
    def setUp(self):
822
822
        super(TestSmartServerStreamMedium, self).setUp()
823
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
823
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
824
824
 
825
825
    def create_pipe_medium(self, to_server, from_server, transport,
826
826
                           timeout=4.0):
1333
1333
 
1334
1334
    def test_get_error_unexpected(self):
1335
1335
        """Error reported by server with no specific representation"""
1336
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1336
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1337
1337
        class FlakyTransport(object):
1338
1338
            base = 'a_url'
1339
1339
            def external_url(self):
1564
1564
 
1565
1565
    def test_smart_transport_has(self):
1566
1566
        """Checking for file existence over smart."""
1567
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1567
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1568
1568
        self.backing_transport.put_bytes("foo", "contents of foo\n")
1569
1569
        self.assertTrue(self.transport.has("foo"))
1570
1570
        self.assertFalse(self.transport.has("non-foo"))
1571
1571
 
1572
1572
    def test_smart_transport_get(self):
1573
1573
        """Read back a file over smart."""
1574
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1574
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1575
1575
        self.backing_transport.put_bytes("foo", "contents\nof\nfoo\n")
1576
1576
        fp = self.transport.get("foo")
1577
1577
        self.assertEqual('contents\nof\nfoo\n', fp.read())
1581
1581
        # The path in a raised NoSuchFile exception should be the precise path
1582
1582
        # asked for by the client. This gives meaningful and unsurprising errors
1583
1583
        # for users.
1584
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1584
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1585
1585
        err = self.assertRaises(
1586
1586
            errors.NoSuchFile, self.transport.get, 'not%20a%20file')
1587
1587
        self.assertSubset([err.path], ['not%20a%20file', './not%20a%20file'])
1606
1606
 
1607
1607
    def test_open_dir(self):
1608
1608
        """Test changing directory"""
1609
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1609
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1610
1610
        transport = self.transport
1611
1611
        self.backing_transport.mkdir('toffee')
1612
1612
        self.backing_transport.mkdir('toffee/apple')
1635
1635
 
1636
1636
    def test_mkdir_error_readonly(self):
1637
1637
        """TransportNotPossible should be preserved from the backing transport."""
1638
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1638
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1639
1639
        self.start_server(readonly=True)
1640
1640
        self.assertRaises(errors.TransportNotPossible, self.transport.mkdir,
1641
1641
            'foo')
1642
1642
 
1643
1643
    def test_rename_error_readonly(self):
1644
1644
        """TransportNotPossible should be preserved from the backing transport."""
1645
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1645
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1646
1646
        self.start_server(readonly=True)
1647
1647
        self.assertRaises(errors.TransportNotPossible, self.transport.rename,
1648
1648
                          'foo', 'bar')
1649
1649
 
1650
1650
    def test_open_write_stream_error_readonly(self):
1651
1651
        """TransportNotPossible should be preserved from the backing transport."""
1652
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1652
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1653
1653
        self.start_server(readonly=True)
1654
1654
        self.assertRaises(
1655
1655
            errors.TransportNotPossible, self.transport.open_write_stream,
1749
1749
        self.assertEqual(None, response.body)
1750
1750
 
1751
1751
    def test_get_bundle(self):
1752
 
        from bzrlib.bundle import serializer
 
1752
        from breezy.bundle import serializer
1753
1753
        wt = self.make_branch_and_tree('.')
1754
1754
        self.build_tree_contents([('hello', 'hello world')])
1755
1755
        wt.add('hello')
1766
1766
 
1767
1767
    def setUp(self):
1768
1768
        super(SmartServerRequestHandlerTests, self).setUp()
1769
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
1769
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
1770
1770
 
1771
1771
    def build_handler(self, transport):
1772
1772
        """Returns a handler for the commands in protocol version one."""
1787
1787
 
1788
1788
    def test_disable_vfs_handler_classes_via_environment(self):
1789
1789
        # VFS handler classes will raise an error from "execute" if
1790
 
        # BZR_NO_SMART_VFS is set.
 
1790
        # BRZ_NO_SMART_VFS is set.
1791
1791
        handler = vfs.HasRequest(None, '/')
1792
1792
        # set environment variable after construction to make sure it's
1793
1793
        # examined.
1794
 
        self.overrideEnv('BZR_NO_SMART_VFS', '')
 
1794
        self.overrideEnv('BRZ_NO_SMART_VFS', '')
1795
1795
        self.assertRaises(errors.DisabledMethod, handler.execute)
1796
1796
 
1797
1797
    def test_readonly_exception_becomes_transport_not_possible(self):
1933
1933
        :returns: a Request
1934
1934
        """
1935
1935
        # This is very similar to
1936
 
        # bzrlib.smart.client._SmartClient._build_client_protocol
 
1936
        # breezy.smart.client._SmartClient._build_client_protocol
1937
1937
        # XXX: make this use _SmartClient!
1938
1938
        if input_bytes is None:
1939
1939
            input = StringIO()
2105
2105
        self.assertTrue(self.end_received)
2106
2106
 
2107
2107
    def test_accept_request_and_body_all_at_once(self):
2108
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
2108
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
2109
2109
        mem_transport = memory.MemoryTransport()
2110
2110
        mem_transport.put_bytes('foo', 'abcdefghij')
2111
2111
        out_stream = StringIO()
2371
2371
        self.assertTrue(self.end_received)
2372
2372
 
2373
2373
    def test_accept_request_and_body_all_at_once(self):
2374
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
2374
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
2375
2375
        mem_transport = memory.MemoryTransport()
2376
2376
        mem_transport.put_bytes('foo', 'abcdefghij')
2377
2377
        out_stream = StringIO()
2898
2898
class TestConventionalResponseHandlerBodyStream(tests.TestCase):
2899
2899
 
2900
2900
    def make_response_handler(self, response_bytes):
2901
 
        from bzrlib.smart.message import ConventionalResponseHandler
 
2901
        from breezy.smart.message import ConventionalResponseHandler
2902
2902
        response_handler = ConventionalResponseHandler()
2903
2903
        protocol_decoder = protocol.ProtocolThreeDecoder(response_handler)
2904
2904
        # put decoder in desired state (waiting for message parts)
2973
2973
        """Make a ConventionalRequestHandler for the given bytes using test
2974
2974
        doubles for the request_handler and the responder.
2975
2975
        """
2976
 
        from bzrlib.smart.message import ConventionalRequestHandler
 
2976
        from breezy.smart.message import ConventionalRequestHandler
2977
2977
        request_handler = InstrumentedRequestHandler()
2978
2978
        request_handler.response = _mod_request.SuccessfulSmartServerResponse(('arg', 'arg'))
2979
2979
        responder = FakeResponder()
3365
3365
        encoder, out_stream = self.make_response_encoder()
3366
3366
        encoder.send_error(errors.UnknownSmartMethod('method name'))
3367
3367
        # Use assertEndsWith so that we don't compare the header, which varies
3368
 
        # by bzrlib.__version__.
 
3368
        # by breezy.__version__.
3369
3369
        self.assertEndsWith(
3370
3370
            out_stream.getvalue(),
3371
3371
            # error status
3745
3745
        """
3746
3746
        smart_client = client._SmartClient('dummy medium')
3747
3747
        self.assertEqual(
3748
 
            bzrlib.__version__, smart_client._headers['Software version'])
 
3748
            breezy.__version__, smart_client._headers['Software version'])
3749
3749
        # XXX: need a test that smart_client._headers is passed to the request
3750
3750
        # encoder.
3751
3751
 
4235
4235
    def setUp(self):
4236
4236
        super(HTTPTunnellingSmokeTest, self).setUp()
4237
4237
        # We use the VFS layer as part of HTTP tunnelling tests.
4238
 
        self.overrideEnv('BZR_NO_SMART_VFS', None)
 
4238
        self.overrideEnv('BRZ_NO_SMART_VFS', None)
4239
4239
 
4240
4240
    def test_smart_http_medium_request_accept_bytes(self):
4241
4241
        medium = FakeHTTPMedium()