/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: 2019-03-05 07:32:38 UTC
  • mto: (7290.1.21 work)
  • mto: This revision was merged to the branch mainline in revision 7311.
  • Revision ID: jelmer@jelmer.uk-20190305073238-zlqn981opwnqsmzi
Add appveyor configuration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_remote.py
25
25
 
26
26
import base64
27
27
import bz2
28
 
from io import BytesIO
29
28
import tarfile
30
29
import zlib
31
30
 
32
 
from ... import (
 
31
from .. import (
33
32
    bencode,
34
33
    branch,
35
34
    config,
40
39
    transport,
41
40
    treebuilder,
42
41
    )
43
 
from ...branch import Branch
44
 
from .. import (
 
42
from ..branch import Branch
 
43
from ..bzr import (
45
44
    bzrdir,
46
45
    inventory,
47
46
    inventory_delta,
49
48
    versionedfile,
50
49
    vf_search,
51
50
    )
52
 
from ..bzrdir import (
 
51
from ..bzr.bzrdir import (
53
52
    BzrDir,
54
53
    BzrDirFormat,
55
54
    )
56
 
from .. import (
 
55
from ..bzr import (
57
56
    RemoteBzrProber,
58
57
    )
59
 
from ..chk_serializer import chk_bencode_serializer
60
 
from ..remote import (
 
58
from ..bzr.chk_serializer import chk_bencode_serializer
 
59
from ..bzr.remote import (
61
60
    RemoteBranch,
62
61
    RemoteBranchFormat,
63
62
    RemoteBzrDir,
65
64
    RemoteRepository,
66
65
    RemoteRepositoryFormat,
67
66
    )
68
 
from .. import groupcompress_repo, knitpack_repo
69
 
from ...revision import (
 
67
from ..bzr import groupcompress_repo, knitpack_repo
 
68
from ..revision import (
70
69
    NULL_REVISION,
71
70
    Revision,
72
71
    )
73
 
from ..smart import medium, request
74
 
from ..smart.client import _SmartClient
75
 
from ..smart.repository import (
 
72
from ..sixish import (
 
73
    BytesIO,
 
74
    PY3,
 
75
    text_type,
 
76
    )
 
77
from ..bzr.smart import medium, request
 
78
from ..bzr.smart.client import _SmartClient
 
79
from ..bzr.smart.repository import (
76
80
    SmartServerRepositoryGetParentMap,
77
81
    SmartServerRepositoryGetStream_1_19,
78
82
    _stream_to_byte_stream,
79
83
    )
80
 
from ...tests import (
 
84
from . import (
81
85
    test_server,
82
86
    )
83
 
from ...tests.scenarios import load_tests_apply_scenarios
84
 
from ...transport.memory import MemoryTransport
85
 
from ...transport.remote import (
 
87
from .scenarios import load_tests_apply_scenarios
 
88
from ..transport.memory import MemoryTransport
 
89
from ..transport.remote import (
86
90
    RemoteTransport,
87
91
    RemoteSSHTransport,
88
92
    RemoteTCPTransport,
129
133
    def test_find_correct_format(self):
130
134
        """Should open a RemoteBzrDir over a RemoteTransport"""
131
135
        fmt = BzrDirFormat.find_format(self.transport)
132
 
        self.assertIn(RemoteBzrProber, controldir.ControlDirFormat._probers)
 
136
        self.assertTrue(RemoteBzrProber
 
137
                        in controldir.ControlDirFormat._server_probers)
133
138
        self.assertIsInstance(fmt, RemoteBzrDirFormat)
134
139
 
135
140
    def test_open_detected_smart_format(self):
335
340
        client.add_success_response(b'yes',)
336
341
        transport = RemoteTransport('bzr://localhost/', _client=client)
337
342
        filename = u'/hell\u00d8'
338
 
        result = transport.has(filename)
 
343
        if PY3:
 
344
            result = transport.has(filename)
 
345
        else:
 
346
            result = transport.has(filename.encode('utf-8'))
339
347
        self.assertEqual(
340
348
            [('call', b'has', (filename.encode('utf-8'),))],
341
349
            client._calls)
1780
1788
            branch._set_last_revision, b'rev-id')
1781
1789
        # The UTF-8 message from the response has been decoded into a unicode
1782
1790
        # object.
1783
 
        self.assertIsInstance(err.msg, str)
 
1791
        self.assertIsInstance(err.msg, text_type)
1784
1792
        self.assertEqual(rejection_msg_unicode, err.msg)
1785
1793
        branch.unlock()
1786
1794
        self.assertFinished(client)
2206
2214
                          branch.revision_id_to_dotted_revno, b'unknown')
2207
2215
        self.assertFinished(client)
2208
2216
 
2209
 
    def test_ghost_revid(self):
2210
 
        transport = MemoryTransport()
2211
 
        client = FakeClient(transport.base)
2212
 
        client.add_expected_call(
2213
 
            b'Branch.get_stacked_on_url', (b'quack/',),
2214
 
            b'error', (b'NotStacked',),)
2215
 
        # Some older versions of bzr/brz didn't explicitly return
2216
 
        # GhostRevisionsHaveNoRevno
2217
 
        client.add_expected_call(
2218
 
            b'Branch.revision_id_to_revno', (b'quack/', b'revid'),
2219
 
            b'error', (b'error', b'GhostRevisionsHaveNoRevno',
2220
 
                       b'The reivison {revid} was not found because there was '
2221
 
                       b'a ghost at {ghost-revid}'))
2222
 
        client.add_expected_call(
2223
 
            b'Branch.revision_id_to_revno', (b'quack/', b'revid'),
2224
 
            b'error', (b'GhostRevisionsHaveNoRevno', b'revid', b'ghost-revid',))
2225
 
        transport.mkdir('quack')
2226
 
        transport = transport.clone('quack')
2227
 
        branch = self.make_remote_branch(transport, client)
2228
 
        self.assertRaises(errors.GhostRevisionsHaveNoRevno,
2229
 
                          branch.revision_id_to_dotted_revno, b'revid')
2230
 
        self.assertRaises(errors.GhostRevisionsHaveNoRevno,
2231
 
                          branch.revision_id_to_dotted_revno, b'revid')
2232
 
        self.assertFinished(client)
2233
 
 
2234
2217
    def test_dotted_no_smart_verb(self):
2235
2218
        self.setup_smart_server_with_call_log()
2236
2219
        branch = self.make_branch('.')
2854
2837
        somerev1.timezone = -60
2855
2838
        somerev1.inventory_sha1 = b"691b39be74c67b1212a75fcb19c433aaed903c2b"
2856
2839
        somerev1.message = "Message"
2857
 
        body = zlib.compress(b''.join(chk_bencode_serializer.write_revision_to_lines(
2858
 
            somerev1)))
 
2840
        body = zlib.compress(chk_bencode_serializer.write_revision_to_string(
 
2841
            somerev1))
2859
2842
        # Split up body into two bits to make sure the zlib compression object
2860
2843
        # gets data fed twice.
2861
2844
        client.add_success_response_with_body(
3008
2991
            repo.get_rev_id_for_revno, 5, (42, b'rev-foo'))
3009
2992
        self.assertFinished(client)
3010
2993
 
3011
 
    def test_outofbounds(self):
3012
 
        repo, client = self.setup_fake_client_and_repository('quack')
3013
 
        client.add_expected_call(
3014
 
            b'Repository.get_rev_id_for_revno', (b'quack/',
3015
 
                                                 43, (42, b'rev-foo')),
3016
 
            b'error', (b'revno-outofbounds', 43, 0, 42))
3017
 
        self.assertRaises(
3018
 
            errors.RevnoOutOfBounds,
3019
 
            repo.get_rev_id_for_revno, 43, (42, b'rev-foo'))
3020
 
        self.assertFinished(client)
3021
 
 
3022
 
    def test_outofbounds_old(self):
3023
 
        # Older versions of bzr didn't support RevnoOutOfBounds
3024
 
        repo, client = self.setup_fake_client_and_repository('quack')
3025
 
        client.add_expected_call(
3026
 
            b'Repository.get_rev_id_for_revno', (b'quack/',
3027
 
                                                 43, (42, b'rev-foo')),
3028
 
            b'error', (
3029
 
                b'error', b'ValueError',
3030
 
                b'requested revno (43) is later than given known revno (42)'))
3031
 
        self.assertRaises(
3032
 
            errors.RevnoOutOfBounds,
3033
 
            repo.get_rev_id_for_revno, 43, (42, b'rev-foo'))
3034
 
        self.assertFinished(client)
3035
 
 
3036
2994
    def test_branch_fallback_locking(self):
3037
2995
        """RemoteBranch.get_rev_id takes a read lock, and tries to call the
3038
2996
        get_rev_id_for_revno verb.  If the verb is unknown the VFS fallback
3529
3487
 
3530
3488
        def inventories_substream():
3531
3489
            # An empty inventory fulltext.  This will be streamed normally.
3532
 
            chunks = fmt._serializer.write_inventory_to_lines(inv)
3533
 
            yield versionedfile.ChunkedContentFactory(
3534
 
                (b'rev1',), (), None, chunks, chunks_are_lines=True)
 
3490
            text = fmt._serializer.write_inventory_to_string(inv)
 
3491
            yield versionedfile.FulltextContentFactory(
 
3492
                (b'rev1',), (), None, text)
3535
3493
 
3536
3494
        def inventory_delta_substream():
3537
3495
            # An inventory delta.  This can't be streamed via this verb, so it
3960
3918
        expected_error = errors.UnknownErrorFromSmartServer(err)
3961
3919
        self.assertEqual(expected_error, translated_error)
3962
3920
 
3963
 
    def test_RevnoOutOfBounds(self):
3964
 
        translated_error = self.translateTuple(
3965
 
            ((b'revno-outofbounds', 5, 0, 3)), path=b'path')
3966
 
        expected_error = errors.RevnoOutOfBounds(5, (0, 3))
3967
 
        self.assertEqual(expected_error, translated_error)
3968
 
 
3969
3921
 
3970
3922
class TestErrorTranslationRobustness(TestErrorTranslationBase):
3971
3923
    """Unit tests for breezy.bzr.remote._translate_error's robustness.
4522
4474
            (b'baserevid', b'line 1\n'),
4523
4475
            (b'somerevid', b'line2\n')],
4524
4476
            list(tree.annotate_iter('filename')))
4525
 
 
4526
 
 
4527
 
class TestBranchGetAllReferenceInfo(RemoteBranchTestCase):
4528
 
 
4529
 
    def test_get_all_reference_info(self):
4530
 
        transport = MemoryTransport()
4531
 
        client = FakeClient(transport.base)
4532
 
        client.add_expected_call(
4533
 
            b'Branch.get_stacked_on_url', (b'quack/',),
4534
 
            b'error', (b'NotStacked',))
4535
 
        client.add_expected_call(
4536
 
            b'Branch.get_all_reference_info', (b'quack/',),
4537
 
            b'success', (b'ok',), bencode.bencode([
4538
 
                (b'file-id', b'https://www.example.com/', b'')]))
4539
 
        transport.mkdir('quack')
4540
 
        transport = transport.clone('quack')
4541
 
        branch = self.make_remote_branch(transport, client)
4542
 
        result = branch._get_all_reference_info()
4543
 
        self.assertFinished(client)
4544
 
        self.assertEqual({b'file-id': ('https://www.example.com/', None)}, result)