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

  • Committer: Jelmer Vernooij
  • Date: 2017-05-22 00:56:52 UTC
  • mfrom: (6621.2.26 py3_pokes)
  • Revision ID: jelmer@jelmer.uk-20170522005652-yjahcr9hwmjkno7n
Merge Python3 porting work ('py3 pokes')

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_remote.py
24
24
"""
25
25
 
26
26
import bz2
27
 
from cStringIO import StringIO
28
27
import zlib
29
28
 
30
 
from breezy import (
 
29
from .. import (
31
30
    bencode,
32
31
    branch,
33
32
    bzrdir,
44
43
    versionedfile,
45
44
    vf_search,
46
45
    )
47
 
from breezy.branch import Branch
48
 
from breezy.bzrdir import (
 
46
from ..branch import Branch
 
47
from ..bzrdir import (
49
48
    BzrDir,
50
49
    BzrDirFormat,
51
50
    RemoteBzrProber,
52
51
    )
53
 
from breezy.chk_serializer import chk_bencode_serializer
54
 
from breezy.remote import (
 
52
from ..chk_serializer import chk_bencode_serializer
 
53
from ..remote import (
55
54
    RemoteBranch,
56
55
    RemoteBranchFormat,
57
56
    RemoteBzrDir,
59
58
    RemoteRepository,
60
59
    RemoteRepositoryFormat,
61
60
    )
62
 
from breezy.repofmt import groupcompress_repo, knitpack_repo
63
 
from breezy.revision import (
 
61
from ..repofmt import groupcompress_repo, knitpack_repo
 
62
from ..revision import (
64
63
    NULL_REVISION,
65
64
    Revision,
66
65
    )
67
 
from breezy.smart import medium, request
68
 
from breezy.smart.client import _SmartClient
69
 
from breezy.smart.repository import (
 
66
from ..sixish import (
 
67
    BytesIO,
 
68
    )
 
69
from ..smart import medium, request
 
70
from ..smart.client import _SmartClient
 
71
from ..smart.repository import (
70
72
    SmartServerRepositoryGetParentMap,
71
73
    SmartServerRepositoryGetStream_1_19,
72
74
    _stream_to_byte_stream,
73
75
    )
74
 
from breezy.symbol_versioning import deprecated_in
75
 
from breezy.tests import (
 
76
from ..symbol_versioning import deprecated_in
 
77
from . import (
76
78
    test_server,
77
79
    )
78
 
from breezy.tests.scenarios import load_tests_apply_scenarios
79
 
from breezy.transport.memory import MemoryTransport
80
 
from breezy.transport.remote import (
 
80
from .scenarios import load_tests_apply_scenarios
 
81
from ..transport.memory import MemoryTransport
 
82
from ..transport.remote import (
81
83
    RemoteTransport,
82
84
    RemoteSSHTransport,
83
85
    RemoteTCPTransport,
191
193
 
192
194
    def read_body_bytes(self, count=-1):
193
195
        if self._body_buffer is None:
194
 
            self._body_buffer = StringIO(self.body)
 
196
            self._body_buffer = BytesIO(self.body)
195
197
        bytes = self._body_buffer.read(count)
196
198
        if self._body_buffer.tell() == len(self._body_buffer.getvalue()):
197
199
            self._fake_client.expecting_body = False
248
250
    def _get_next_response(self):
249
251
        try:
250
252
            response_tuple = self.responses.pop(0)
251
 
        except IndexError, e:
 
253
        except IndexError as e:
252
254
            raise AssertionError("%r didn't expect any more calls"
253
255
                % (self,))
254
256
        if response_tuple[0] == 'unknown':
556
558
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
557
559
            _client=client)
558
560
        result = a_bzrdir.get_branches()
559
 
        self.assertEqual(set(["", "foo"]), set(result.keys()))
 
561
        self.assertEqual({"", "foo"}, set(result.keys()))
560
562
        self.assertEqual(
561
563
            [('call_expecting_body', 'BzrDir.get_branches', ('quack/',)),
562
564
             ('call', 'BzrDir.find_repositoryV3', ('quack/', )),
1080
1082
    """
1081
1083
 
1082
1084
    def get_request(self):
1083
 
        input_file = StringIO('ok\x011\n')
1084
 
        output_file = StringIO()
 
1085
        input_file = BytesIO(b'ok\x011\n')
 
1086
        output_file = BytesIO()
1085
1087
        client_medium = medium.SmartSimplePipesClientMedium(
1086
1088
            input_file, output_file)
1087
1089
        return medium.SmartClientStreamMediumRequest(client_medium)
1387
1389
        branch = self.make_remote_branch(transport, client)
1388
1390
        result = branch.heads_to_fetch()
1389
1391
        self.assertFinished(client)
1390
 
        self.assertEqual((set(['rev-tip']), set()), result)
 
1392
        self.assertEqual(({'rev-tip'}, set()), result)
1391
1393
 
1392
1394
    def test_uses_last_revision_info_and_tags_when_set(self):
1393
1395
        transport = MemoryTransport()
1412
1414
        result = branch.heads_to_fetch()
1413
1415
        self.assertFinished(client)
1414
1416
        self.assertEqual(
1415
 
            (set(['rev-tip']), set(['rev-foo', 'rev-bar'])), result)
 
1417
            ({'rev-tip'}, {'rev-foo', 'rev-bar'}), result)
1416
1418
 
1417
1419
    def test_uses_rpc_for_formats_with_non_default_heads_to_fetch(self):
1418
1420
        transport = MemoryTransport()
1429
1431
        branch._format._use_default_local_heads_to_fetch = lambda: False
1430
1432
        result = branch.heads_to_fetch()
1431
1433
        self.assertFinished(client)
1432
 
        self.assertEqual((set(['tip']), set(['tagged-1', 'tagged-2'])), result)
 
1434
        self.assertEqual(({'tip'}, {'tagged-1', 'tagged-2'}), result)
1433
1435
 
1434
1436
    def make_branch_with_tags(self):
1435
1437
        self.setup_smart_server_with_call_log()
1454
1456
        self.disable_verb(verb)
1455
1457
        self.reset_smart_call_log()
1456
1458
        result = br.heads_to_fetch()
1457
 
        self.assertEqual((set(['tip']), set(['rev-1', 'rev-2'])), result)
 
1459
        self.assertEqual(({'tip'}, {'rev-1', 'rev-2'}), result)
1458
1460
        self.assertEqual(
1459
1461
            ['Branch.last_revision_info', 'Branch.get_tags_bytes'],
1460
1462
            [call.call.method for call in self.hpss_calls])
1468
1470
        self.disable_verb(verb)
1469
1471
        self.reset_smart_call_log()
1470
1472
        result = br.heads_to_fetch()
1471
 
        self.assertEqual((set(['tip']), set()), result)
 
1473
        self.assertEqual(({'tip'}, set()), result)
1472
1474
        self.assertEqual(
1473
1475
            ['Branch.last_revision_info'],
1474
1476
            [call.call.method for call in self.hpss_calls])
3628
3630
        """
3629
3631
        try:
3630
3632
            raise error_object
3631
 
        except errors.ErrorFromSmartServer, server_error:
 
3633
        except errors.ErrorFromSmartServer as server_error:
3632
3634
            translated_error = self.assertRaises(
3633
3635
                errors.BzrError, remote._translate_error, server_error,
3634
3636
                **context)