← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_remote.py

  • Committer: Jelmer Vernooij
  • Date: 2011-04-19 10:42:59 UTC
  • mto: This revision was merged to the branch mainline in revision 5806.
  • Revision ID: jelmer@samba.org-20110419104259-g9exlcp1f5jdu3ci
Move Inventory._get_mutable_inventory -> mutable_inventory_from_tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
30
30
    branch,
31
31
    bzrdir,
32
32
    config,
 
33
    controldir,
33
34
    errors,
34
35
    graph,
35
36
    inventory,
36
37
    inventory_delta,
37
 
    pack,
38
38
    remote,
39
39
    repository,
40
40
    tests,
 
41
    transport,
41
42
    treebuilder,
42
 
    urlutils,
43
43
    versionedfile,
44
44
    )
45
45
from bzrlib.branch import Branch
46
 
from bzrlib.bzrdir import BzrDir, BzrDirFormat
 
46
from bzrlib.bzrdir import (
 
47
    BzrDir,
 
48
    BzrDirFormat,
 
49
    RemoteBzrProber,
 
50
    )
47
51
from bzrlib.remote import (
48
52
    RemoteBranch,
49
53
    RemoteBranchFormat,
52
56
    RemoteRepository,
53
57
    RemoteRepositoryFormat,
54
58
    )
55
 
from bzrlib.repofmt import groupcompress_repo, pack_repo
 
59
from bzrlib.repofmt import groupcompress_repo, knitpack_repo
56
60
from bzrlib.revision import NULL_REVISION
57
 
from bzrlib.smart import medium
 
61
from bzrlib.smart import medium, request
58
62
from bzrlib.smart.client import _SmartClient
59
 
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
 
63
from bzrlib.smart.repository import (
 
64
    SmartServerRepositoryGetParentMap,
 
65
    SmartServerRepositoryGetStream_1_19,
 
66
    )
60
67
from bzrlib.tests import (
61
 
    condition_isinstance,
62
 
    split_suite_by_condition,
63
 
    multiply_tests,
64
68
    test_server,
65
69
    )
66
 
from bzrlib.transport import get_transport
 
70
from bzrlib.tests.scenarios import load_tests_apply_scenarios
67
71
from bzrlib.transport.memory import MemoryTransport
68
72
from bzrlib.transport.remote import (
69
73
    RemoteTransport,
70
74
    RemoteSSHTransport,
71
75
    RemoteTCPTransport,
72
 
)
73
 
 
74
 
def load_tests(standard_tests, module, loader):
75
 
    to_adapt, result = split_suite_by_condition(
76
 
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
77
 
    smart_server_version_scenarios = [
 
76
    )
 
77
 
 
78
 
 
79
load_tests = load_tests_apply_scenarios
 
80
 
 
81
 
 
82
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
 
83
 
 
84
    scenarios = [
78
85
        ('HPSS-v2',
79
 
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
 
86
            {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
80
87
        ('HPSS-v3',
81
 
         {'transport_server': test_server.SmartTCPServer_for_testing})]
82
 
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
83
 
 
84
 
 
85
 
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
 
88
            {'transport_server': test_server.SmartTCPServer_for_testing})]
 
89
 
86
90
 
87
91
    def setUp(self):
88
92
        super(BasicRemoteObjectTests, self).setUp()
89
93
        self.transport = self.get_transport()
90
94
        # make a branch that can be opened over the smart transport
91
95
        self.local_wt = BzrDir.create_standalone_workingtree('.')
92
 
 
93
 
    def tearDown(self):
94
 
        self.transport.disconnect()
95
 
        tests.TestCaseWithTransport.tearDown(self)
 
96
        self.addCleanup(self.transport.disconnect)
96
97
 
97
98
    def test_create_remote_bzrdir(self):
98
 
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
 
99
        b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
99
100
        self.assertIsInstance(b, BzrDir)
100
101
 
101
102
    def test_open_remote_branch(self):
102
103
        # open a standalone branch in the working directory
103
 
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
 
104
        b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
104
105
        branch = b.open_branch()
105
106
        self.assertIsInstance(branch, Branch)
106
107
 
122
123
    def test_find_correct_format(self):
123
124
        """Should open a RemoteBzrDir over a RemoteTransport"""
124
125
        fmt = BzrDirFormat.find_format(self.transport)
125
 
        self.assertTrue(RemoteBzrDirFormat
126
 
                        in BzrDirFormat._control_server_formats)
127
 
        self.assertIsInstance(fmt, remote.RemoteBzrDirFormat)
 
126
        self.assertTrue(bzrdir.RemoteBzrProber
 
127
                        in controldir.ControlDirFormat._server_probers)
 
128
        self.assertIsInstance(fmt, RemoteBzrDirFormat)
128
129
 
129
130
    def test_open_detected_smart_format(self):
130
131
        fmt = BzrDirFormat.find_format(self.transport)
359
360
        a given client_base and transport_base.
360
361
        """
361
362
        client_medium = medium.SmartClientMedium(client_base)
362
 
        transport = get_transport(transport_base)
363
 
        result = client_medium.remote_path_from_transport(transport)
 
363
        t = transport.get_transport(transport_base)
 
364
        result = client_medium.remote_path_from_transport(t)
364
365
        self.assertEqual(expected, result)
365
366
 
366
367
    def test_remote_path_from_transport(self):
377
378
        a given transport_base and relpath of that transport.  (Note that
378
379
        HttpTransportBase is a subclass of SmartClientMedium)
379
380
        """
380
 
        base_transport = get_transport(transport_base)
 
381
        base_transport = transport.get_transport(transport_base)
381
382
        client_medium = base_transport.get_smart_medium()
382
383
        cloned_transport = base_transport.clone(relpath)
383
384
        result = client_medium.remote_path_from_transport(cloned_transport)
450
451
        client.add_expected_call(
451
452
            'BzrDir.open_branchV3', ('quack/',),
452
453
            'success', ('ref', self.get_url('referenced'))),
453
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
454
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
454
455
            _client=client)
455
456
        result = a_bzrdir.cloning_metadir()
456
457
        # We should have got a control dir matching the referenced branch.
469
470
        client.add_expected_call(
470
471
            'BzrDir.cloning_metadir', ('quack/', 'False'),
471
472
            'success', (control_name, '', ('branch', ''))),
472
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
473
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
473
474
            _client=client)
474
475
        result = a_bzrdir.cloning_metadir()
475
476
        # We should have got a reference control dir with default branch and
495
496
        client.add_expected_call(
496
497
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
497
498
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
498
 
                remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
 
499
                RemoteBzrDirFormat(), _client=client, _force_probe=True)
499
500
        self.assertFinished(client)
500
501
 
501
502
    def test_present_without_workingtree(self):
502
503
        client, transport = self.make_fake_client_and_transport()
503
504
        client.add_expected_call(
504
505
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
505
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
506
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
506
507
            _client=client, _force_probe=True)
507
508
        self.assertIsInstance(bd, RemoteBzrDir)
508
509
        self.assertFalse(bd.has_workingtree())
513
514
        client, transport = self.make_fake_client_and_transport()
514
515
        client.add_expected_call(
515
516
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
516
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
517
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
517
518
            _client=client, _force_probe=True)
518
519
        self.assertIsInstance(bd, RemoteBzrDir)
519
520
        self.assertTrue(bd.has_workingtree())
526
527
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
527
528
        client.add_expected_call(
528
529
            'BzrDir.open', ('quack/',), 'success', ('yes',))
529
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
530
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
530
531
            _client=client, _force_probe=True)
531
532
        self.assertIsInstance(bd, RemoteBzrDir)
532
533
        self.assertFinished(client)
548
549
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
549
550
        client.add_expected_call(
550
551
            'BzrDir.open', ('quack/',), 'success', ('yes',))
551
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
552
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
552
553
            _client=client, _force_probe=True)
553
554
        self.assertIsInstance(bd, RemoteBzrDir)
554
555
        self.assertFinished(client)
585
586
        client.add_expected_call(
586
587
            'Branch.get_stacked_on_url', ('quack/',),
587
588
            'error', ('NotStacked',))
588
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
589
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
589
590
            _client=client)
590
591
        result = bzrdir.open_branch()
591
592
        self.assertIsInstance(result, RemoteBranch)
598
599
        transport = transport.clone('quack')
599
600
        client = FakeClient(transport.base)
600
601
        client.add_error_response('nobranch')
601
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
602
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
602
603
            _client=client)
603
604
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
604
605
        self.assertEqual(
609
610
        # _get_tree_branch is a form of open_branch, but it should only ask for
610
611
        # branch opening, not any other network requests.
611
612
        calls = []
612
 
        def open_branch():
 
613
        def open_branch(name=None):
613
614
            calls.append("Called")
614
615
            return "a-branch"
615
616
        transport = MemoryTransport()
616
617
        # no requests on the network - catches other api calls being made.
617
618
        client = FakeClient(transport.base)
618
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
619
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
619
620
            _client=client)
620
621
        # patch the open_branch call to record that it was called.
621
622
        bzrdir.open_branch = open_branch
640
641
        client.add_expected_call(
641
642
            'Branch.get_stacked_on_url', ('~hello/',),
642
643
            'error', ('NotStacked',))
643
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
644
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
644
645
            _client=client)
645
646
        result = bzrdir.open_branch()
646
647
        self.assertFinished(client)
663
664
        client.add_success_response(
664
665
            'ok', '', rich_response, subtree_response, external_lookup,
665
666
            network_name)
666
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
667
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
667
668
            _client=client)
668
669
        result = bzrdir.open_repository()
669
670
        self.assertEqual(
686
687
        old.
687
688
        """
688
689
        self.assertRaises(errors.NotBranchError,
689
 
            RemoteBzrDirFormat.probe_transport, OldServerTransport())
 
690
            RemoteBzrProber.probe_transport, OldServerTransport())
690
691
 
691
692
 
692
693
class TestBzrDirCreateBranch(TestRemote):
715
716
            'BzrDir.create_branch', ('quack/', network_name),
716
717
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
717
718
            reference_repo_name))
718
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
719
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
719
720
            _client=client)
720
721
        branch = a_bzrdir.create_branch()
721
722
        # We should have got a remote branch
724
725
        format = branch._format
725
726
        self.assertEqual(network_name, format.network_name())
726
727
 
 
728
    def test_already_open_repo_and_reused_medium(self):
 
729
        """Bug 726584: create_branch(..., repository=repo) should work
 
730
        regardless of what the smart medium's base URL is.
 
731
        """
 
732
        self.transport_server = test_server.SmartTCPServer_for_testing
 
733
        transport = self.get_transport('.')
 
734
        repo = self.make_repository('quack')
 
735
        # Client's medium rooted a transport root (not at the bzrdir)
 
736
        client = FakeClient(transport.base)
 
737
        transport = transport.clone('quack')
 
738
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
739
        reference_format = reference_bzrdir_format.get_branch_format()
 
740
        network_name = reference_format.network_name()
 
741
        reference_repo_fmt = reference_bzrdir_format.repository_format
 
742
        reference_repo_name = reference_repo_fmt.network_name()
 
743
        client.add_expected_call(
 
744
            'BzrDir.create_branch', ('extra/quack/', network_name),
 
745
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
 
746
            reference_repo_name))
 
747
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
748
            _client=client)
 
749
        branch = a_bzrdir.create_branch(repository=repo)
 
750
        # We should have got a remote branch
 
751
        self.assertIsInstance(branch, remote.RemoteBranch)
 
752
        # its format should have the settings from the response
 
753
        format = branch._format
 
754
        self.assertEqual(network_name, format.network_name())
 
755
 
727
756
 
728
757
class TestBzrDirCreateRepository(TestRemote):
729
758
 
750
779
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
751
780
                'False'),
752
781
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
753
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
782
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
754
783
            _client=client)
755
784
        repo = a_bzrdir.create_repository()
756
785
        # We should have got a remote repository
785
814
        client.add_success_response('stat', '0', '65535')
786
815
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
787
816
            _client=client)
788
 
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
 
817
        bzrdir = RemoteBzrDir(remote_transport, RemoteBzrDirFormat(),
789
818
            _client=client)
790
819
        repo = bzrdir.open_repository()
791
820
        self.assertEqual(
818
847
        client.add_success_response('stat', '0', '65535')
819
848
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
820
849
            _client=client)
821
 
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
 
850
        bzrdir = RemoteBzrDir(remote_transport, RemoteBzrDirFormat(),
822
851
            _client=client)
823
852
        repo = bzrdir.open_repository()
824
853
        self.assertEqual(
839
868
        transport = transport.clone('quack')
840
869
        client = FakeClient(transport.base)
841
870
        client.add_success_response('ok', '', 'no', 'no', 'no', network_name)
842
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
871
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
843
872
            _client=client)
844
873
        repo = bzrdir.open_repository()
845
874
        self.assertEqual(
852
881
 
853
882
    def test_success(self):
854
883
        """Simple test for typical successful call."""
855
 
        fmt = bzrdir.RemoteBzrDirFormat()
 
884
        fmt = RemoteBzrDirFormat()
856
885
        default_format_name = BzrDirFormat.get_default_format().network_name()
857
886
        transport = self.get_transport()
858
887
        client = FakeClient(transport.base)
874
903
        """Error responses are translated, e.g. 'PermissionDenied' raises the
875
904
        corresponding error from the client.
876
905
        """
877
 
        fmt = bzrdir.RemoteBzrDirFormat()
 
906
        fmt = RemoteBzrDirFormat()
878
907
        default_format_name = BzrDirFormat.get_default_format().network_name()
879
908
        transport = self.get_transport()
880
909
        client = FakeClient(transport.base)
898
927
        """Integration test for error translation."""
899
928
        transport = self.make_smart_server('foo')
900
929
        transport = transport.clone('no-such-path')
901
 
        fmt = bzrdir.RemoteBzrDirFormat()
 
930
        fmt = RemoteBzrDirFormat()
902
931
        err = self.assertRaises(errors.NoSuchFile,
903
932
            fmt.initialize_on_transport_ex, transport, create_prefix=False)
904
933
 
935
964
 
936
965
    def make_remote_bzrdir(self, transport, client):
937
966
        """Make a RemotebzrDir using 'client' as the _client."""
938
 
        return RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
967
        return RemoteBzrDir(transport, RemoteBzrDirFormat(),
939
968
            _client=client)
940
969
 
941
970
 
1143
1172
            [('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1144
1173
 
1145
1174
 
 
1175
class TestBranchHeadsToFetch(RemoteBranchTestCase):
 
1176
 
 
1177
    def test_uses_last_revision_info_and_tags_by_default(self):
 
1178
        transport = MemoryTransport()
 
1179
        client = FakeClient(transport.base)
 
1180
        client.add_expected_call(
 
1181
            'Branch.get_stacked_on_url', ('quack/',),
 
1182
            'error', ('NotStacked',))
 
1183
        client.add_expected_call(
 
1184
            'Branch.last_revision_info', ('quack/',),
 
1185
            'success', ('ok', '1', 'rev-tip'))
 
1186
        # XXX: this will break if the default format's serialization of tags
 
1187
        # changes, or if the RPC for fetching tags changes from get_tags_bytes.
 
1188
        client.add_expected_call(
 
1189
            'Branch.get_tags_bytes', ('quack/',),
 
1190
            'success', ('d5:tag-17:rev-foo5:tag-27:rev-bare',))
 
1191
        transport.mkdir('quack')
 
1192
        transport = transport.clone('quack')
 
1193
        branch = self.make_remote_branch(transport, client)
 
1194
        result = branch.heads_to_fetch()
 
1195
        self.assertFinished(client)
 
1196
        self.assertEqual(
 
1197
            (set(['rev-tip']), set(['rev-foo', 'rev-bar'])), result)
 
1198
 
 
1199
    def test_uses_rpc_for_formats_with_non_default_heads_to_fetch(self):
 
1200
        transport = MemoryTransport()
 
1201
        client = FakeClient(transport.base)
 
1202
        client.add_expected_call(
 
1203
            'Branch.get_stacked_on_url', ('quack/',),
 
1204
            'error', ('NotStacked',))
 
1205
        client.add_expected_call(
 
1206
            'Branch.heads_to_fetch', ('quack/',),
 
1207
            'success', (['tip'], ['tagged-1', 'tagged-2']))
 
1208
        transport.mkdir('quack')
 
1209
        transport = transport.clone('quack')
 
1210
        branch = self.make_remote_branch(transport, client)
 
1211
        branch._format._use_default_local_heads_to_fetch = lambda: False
 
1212
        result = branch.heads_to_fetch()
 
1213
        self.assertFinished(client)
 
1214
        self.assertEqual((set(['tip']), set(['tagged-1', 'tagged-2'])), result)
 
1215
 
 
1216
    def test_backwards_compatible(self):
 
1217
        self.setup_smart_server_with_call_log()
 
1218
        # Make a branch with a single revision.
 
1219
        builder = self.make_branch_builder('foo')
 
1220
        builder.start_series()
 
1221
        builder.build_snapshot('tip', None, [
 
1222
            ('add', ('', 'root-id', 'directory', ''))])
 
1223
        builder.finish_series()
 
1224
        branch = builder.get_branch()
 
1225
        # Add two tags to that branch
 
1226
        branch.tags.set_tag('tag-1', 'rev-1')
 
1227
        branch.tags.set_tag('tag-2', 'rev-2')
 
1228
        self.addCleanup(branch.lock_read().unlock)
 
1229
        # Disable the heads_to_fetch verb
 
1230
        verb = 'Branch.heads_to_fetch'
 
1231
        self.disable_verb(verb)
 
1232
        self.reset_smart_call_log()
 
1233
        result = branch.heads_to_fetch()
 
1234
        self.assertEqual((set(['tip']), set(['rev-1', 'rev-2'])), result)
 
1235
        self.assertEqual(
 
1236
            ['Branch.last_revision_info', 'Branch.get_tags_bytes'],
 
1237
            [call.call.method for call in self.hpss_calls])
 
1238
 
 
1239
 
1146
1240
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1147
1241
 
1148
1242
    def test_empty_branch(self):
1203
1297
        client.add_expected_call(
1204
1298
            'Branch.get_stacked_on_url', ('stacked/',),
1205
1299
            'success', ('ok', vfs_url))
1206
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
1300
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
1207
1301
            _client=client)
1208
1302
        repo_fmt = remote.RemoteRepositoryFormat()
1209
1303
        repo_fmt._custom_format = stacked_branch.repository._format
1236
1330
        # this will also do vfs access, but that goes direct to the transport
1237
1331
        # and isn't seen by the FakeClient.
1238
1332
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1239
 
            remote.RemoteBzrDirFormat(), _client=client)
 
1333
            RemoteBzrDirFormat(), _client=client)
1240
1334
        branch = bzrdir.open_branch()
1241
1335
        result = branch.get_stacked_on_url()
1242
1336
        self.assertEqual('../base', result)
1269
1363
            'Branch.get_stacked_on_url', ('stacked/',),
1270
1364
            'success', ('ok', '../base'))
1271
1365
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1272
 
            remote.RemoteBzrDirFormat(), _client=client)
 
1366
            RemoteBzrDirFormat(), _client=client)
1273
1367
        branch = bzrdir.open_branch()
1274
1368
        result = branch.get_stacked_on_url()
1275
1369
        self.assertEqual('../base', result)
1618
1712
    def test_get_multi_line_branch_conf(self):
1619
1713
        # Make sure that multiple-line branch.conf files are supported
1620
1714
        #
1621
 
        # https://bugs.edge.launchpad.net/bzr/+bug/354075
 
1715
        # https://bugs.launchpad.net/bzr/+bug/354075
1622
1716
        client = FakeClient()
1623
1717
        client.add_expected_call(
1624
1718
            'Branch.get_stacked_on_url', ('memory:///',),
1652
1746
        branch.unlock()
1653
1747
        self.assertFinished(client)
1654
1748
 
 
1749
    def test_set_option_with_dict(self):
 
1750
        client = FakeClient()
 
1751
        client.add_expected_call(
 
1752
            'Branch.get_stacked_on_url', ('memory:///',),
 
1753
            'error', ('NotStacked',),)
 
1754
        client.add_expected_call(
 
1755
            'Branch.lock_write', ('memory:///', '', ''),
 
1756
            'success', ('ok', 'branch token', 'repo token'))
 
1757
        encoded_dict_value = 'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde'
 
1758
        client.add_expected_call(
 
1759
            'Branch.set_config_option_dict', ('memory:///', 'branch token',
 
1760
            'repo token', encoded_dict_value, 'foo', ''),
 
1761
            'success', ())
 
1762
        client.add_expected_call(
 
1763
            'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
 
1764
            'success', ('ok',))
 
1765
        transport = MemoryTransport()
 
1766
        branch = self.make_remote_branch(transport, client)
 
1767
        branch.lock_write()
 
1768
        config = branch._get_config()
 
1769
        config.set_option(
 
1770
            {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'},
 
1771
            'foo')
 
1772
        branch.unlock()
 
1773
        self.assertFinished(client)
 
1774
 
1655
1775
    def test_backwards_compat_set_option(self):
1656
1776
        self.setup_smart_server_with_call_log()
1657
1777
        branch = self.make_branch('.')
1664
1784
        self.assertLength(10, self.hpss_calls)
1665
1785
        self.assertEqual('value', branch._get_config().get_option('name'))
1666
1786
 
 
1787
    def test_backwards_compat_set_option_with_dict(self):
 
1788
        self.setup_smart_server_with_call_log()
 
1789
        branch = self.make_branch('.')
 
1790
        verb = 'Branch.set_config_option_dict'
 
1791
        self.disable_verb(verb)
 
1792
        branch.lock_write()
 
1793
        self.addCleanup(branch.unlock)
 
1794
        self.reset_smart_call_log()
 
1795
        config = branch._get_config()
 
1796
        value_dict = {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
 
1797
        config.set_option(value_dict, 'name')
 
1798
        self.assertLength(10, self.hpss_calls)
 
1799
        self.assertEqual(value_dict, branch._get_config().get_option('name'))
 
1800
 
1667
1801
 
1668
1802
class TestBranchLockWrite(RemoteBranchTestCase):
1669
1803
 
1805
1939
        client = FakeClient(transport.base)
1806
1940
        transport = transport.clone(transport_path)
1807
1941
        # we do not want bzrdir to make any remote calls
1808
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
1942
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
1809
1943
            _client=False)
1810
1944
        repo = RemoteRepository(bzrdir, None, _client=client)
1811
1945
        return repo, client
1819
1953
 
1820
1954
    def test_get_format_description(self):
1821
1955
        remote_format = RemoteBranchFormat()
1822
 
        real_format = branch.BranchFormat.get_default_format()
 
1956
        real_format = branch.format_registry.get_default()
1823
1957
        remote_format._network_name = real_format.network_name()
1824
1958
        self.assertEqual(remoted_description(real_format),
1825
1959
            remote_format.get_format_description())
1828
1962
class TestRepositoryFormat(TestRemoteRepository):
1829
1963
 
1830
1964
    def test_fast_delta(self):
1831
 
        true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
 
1965
        true_name = groupcompress_repo.RepositoryFormat2a().network_name()
1832
1966
        true_format = RemoteRepositoryFormat()
1833
1967
        true_format._network_name = true_name
1834
1968
        self.assertEqual(True, true_format.fast_deltas)
1835
 
        false_name = pack_repo.RepositoryFormatKnitPack1().network_name()
 
1969
        false_name = knitpack_repo.RepositoryFormatKnitPack1().network_name()
1836
1970
        false_format = RemoteRepositoryFormat()
1837
1971
        false_format._network_name = false_name
1838
1972
        self.assertEqual(False, false_format.fast_deltas)
1839
1973
 
1840
1974
    def test_get_format_description(self):
1841
1975
        remote_repo_format = RemoteRepositoryFormat()
1842
 
        real_format = repository.RepositoryFormat.get_default_format()
 
1976
        real_format = repository.format_registry.get_default()
1843
1977
        remote_repo_format._network_name = real_format.network_name()
1844
1978
        self.assertEqual(remoted_description(real_format),
1845
1979
            remote_repo_format.get_format_description())
2257
2391
        self.setup_smart_server_with_call_log()
2258
2392
        tree = self.make_branch_and_memory_tree('.')
2259
2393
        tree.lock_write()
 
2394
        tree.add('')
2260
2395
        rev1 = tree.commit('First')
2261
2396
        rev2 = tree.commit('Second')
2262
2397
        tree.unlock()
2301
2436
        transport_path = 'quack'
2302
2437
        repo, client = self.setup_fake_client_and_repository(transport_path)
2303
2438
        client.add_success_response('ok', 'a token')
2304
 
        result = repo.lock_write()
 
2439
        token = repo.lock_write().repository_token
2305
2440
        self.assertEqual(
2306
2441
            [('call', 'Repository.lock_write', ('quack/', ''))],
2307
2442
            client._calls)
2308
 
        self.assertEqual('a token', result)
 
2443
        self.assertEqual('a token', token)
2309
2444
 
2310
2445
    def test_lock_write_already_locked(self):
2311
2446
        transport_path = 'quack'
2402
2537
        the client is finished.
2403
2538
        """
2404
2539
        sink = repo._get_sink()
2405
 
        fmt = repository.RepositoryFormat.get_default_format()
 
2540
        fmt = repository.format_registry.get_default()
2406
2541
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2407
2542
        self.assertEqual([], resume_tokens)
2408
2543
        self.assertEqual(set(), missing_keys)
2508
2643
                return True
2509
2644
        repo._real_repository = FakeRealRepository()
2510
2645
        sink = repo._get_sink()
2511
 
        fmt = repository.RepositoryFormat.get_default_format()
 
2646
        fmt = repository.format_registry.get_default()
2512
2647
        stream = self.make_stream_with_inv_deltas(fmt)
2513
2648
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2514
2649
        # Every record from the first inventory delta should have been sent to
2734
2869
             ('pack collection autopack',)],
2735
2870
            client._calls)
2736
2871
 
 
2872
    def test_oom_error_reporting(self):
 
2873
        """An out-of-memory condition on the server is reported clearly"""
 
2874
        transport_path = 'quack'
 
2875
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2876
        client.add_expected_call(
 
2877
            'PackRepository.autopack', ('quack/',),
 
2878
            'error', ('MemoryError',))
 
2879
        err = self.assertRaises(errors.BzrError, repo.autopack)
 
2880
        self.assertContainsRe(str(err), "^remote server out of mem")
 
2881
 
2737
2882
 
2738
2883
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
2739
2884
    """Base class for unit tests for bzrlib.remote._translate_error."""
2812
2957
            detail='extra detail')
2813
2958
        self.assertEqual(expected_error, translated_error)
2814
2959
 
 
2960
    def test_norepository(self):
 
2961
        bzrdir = self.make_bzrdir('')
 
2962
        translated_error = self.translateTuple(('norepository',),
 
2963
            bzrdir=bzrdir)
 
2964
        expected_error = errors.NoRepositoryPresent(bzrdir)
 
2965
        self.assertEqual(expected_error, translated_error)
 
2966
 
2815
2967
    def test_LockContention(self):
2816
2968
        translated_error = self.translateTuple(('LockContention',))
2817
2969
        expected_error = errors.LockContention('(remote lock)')
2845
2997
        expected_error = errors.DivergedBranches(branch, other_branch)
2846
2998
        self.assertEqual(expected_error, translated_error)
2847
2999
 
 
3000
    def test_NotStacked(self):
 
3001
        branch = self.make_branch('')
 
3002
        translated_error = self.translateTuple(('NotStacked',), branch=branch)
 
3003
        expected_error = errors.NotStacked(branch)
 
3004
        self.assertEqual(expected_error, translated_error)
 
3005
 
2848
3006
    def test_ReadError_no_args(self):
2849
3007
        path = 'a path'
2850
3008
        translated_error = self.translateTuple(('ReadError',), path=path)
2866
3024
 
2867
3025
    def test_PermissionDenied_no_args(self):
2868
3026
        path = 'a path'
2869
 
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
 
3027
        translated_error = self.translateTuple(('PermissionDenied',),
 
3028
            path=path)
2870
3029
        expected_error = errors.PermissionDenied(path)
2871
3030
        self.assertEqual(expected_error, translated_error)
2872
3031
 
2895
3054
        expected_error = errors.PermissionDenied(path, extra)
2896
3055
        self.assertEqual(expected_error, translated_error)
2897
3056
 
 
3057
    # GZ 2011-03-02: TODO test for PermissionDenied with non-ascii 'extra'
 
3058
 
 
3059
    def test_NoSuchFile_context_path(self):
 
3060
        local_path = "local path"
 
3061
        translated_error = self.translateTuple(('ReadError', "remote path"),
 
3062
            path=local_path)
 
3063
        expected_error = errors.ReadError(local_path)
 
3064
        self.assertEqual(expected_error, translated_error)
 
3065
 
 
3066
    def test_NoSuchFile_without_context(self):
 
3067
        remote_path = "remote path"
 
3068
        translated_error = self.translateTuple(('ReadError', remote_path))
 
3069
        expected_error = errors.ReadError(remote_path)
 
3070
        self.assertEqual(expected_error, translated_error)
 
3071
 
 
3072
    def test_ReadOnlyError(self):
 
3073
        translated_error = self.translateTuple(('ReadOnlyError',))
 
3074
        expected_error = errors.TransportNotPossible("readonly transport")
 
3075
        self.assertEqual(expected_error, translated_error)
 
3076
 
 
3077
    def test_MemoryError(self):
 
3078
        translated_error = self.translateTuple(('MemoryError',))
 
3079
        self.assertStartsWith(str(translated_error),
 
3080
            "remote server out of memory")
 
3081
 
 
3082
    def test_generic_IndexError_no_classname(self):
 
3083
        err = errors.ErrorFromSmartServer(('error', "list index out of range"))
 
3084
        translated_error = self.translateErrorFromSmartServer(err)
 
3085
        expected_error = errors.UnknownErrorFromSmartServer(err)
 
3086
        self.assertEqual(expected_error, translated_error)
 
3087
 
 
3088
    # GZ 2011-03-02: TODO test generic non-ascii error string
 
3089
 
 
3090
    def test_generic_KeyError(self):
 
3091
        err = errors.ErrorFromSmartServer(('error', 'KeyError', "1"))
 
3092
        translated_error = self.translateErrorFromSmartServer(err)
 
3093
        expected_error = errors.UnknownErrorFromSmartServer(err)
 
3094
        self.assertEqual(expected_error, translated_error)
 
3095
 
2898
3096
 
2899
3097
class TestErrorTranslationRobustness(TestErrorTranslationBase):
2900
3098
    """Unit tests for bzrlib.remote._translate_error's robustness.
3142
3340
 
3143
3341
    def test_copy_content_into_avoids_revision_history(self):
3144
3342
        local = self.make_branch('local')
3145
 
        remote_backing_tree = self.make_branch_and_tree('remote')
3146
 
        remote_backing_tree.commit("Commit.")
 
3343
        builder = self.make_branch_builder('remote')
 
3344
        builder.build_commit(message="Commit.")
3147
3345
        remote_branch_url = self.smart_server.get_url() + 'remote'
3148
3346
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3149
3347
        local.repository.fetch(remote_branch.repository)
3150
3348
        self.hpss_calls = []
3151
3349
        remote_branch.copy_content_into(local)
3152
3350
        self.assertFalse('Branch.revision_history' in self.hpss_calls)
 
3351
 
 
3352
    def test_fetch_everything_needs_just_one_call(self):
 
3353
        local = self.make_branch('local')
 
3354
        builder = self.make_branch_builder('remote')
 
3355
        builder.build_commit(message="Commit.")
 
3356
        remote_branch_url = self.smart_server.get_url() + 'remote'
 
3357
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
 
3358
        self.hpss_calls = []
 
3359
        local.repository.fetch(remote_branch.repository,
 
3360
                fetch_spec=graph.EverythingResult(remote_branch.repository))
 
3361
        self.assertEqual(['Repository.get_stream_1.19'], self.hpss_calls)
 
3362
 
 
3363
    def override_verb(self, verb_name, verb):
 
3364
        request_handlers = request.request_handlers
 
3365
        orig_verb = request_handlers.get(verb_name)
 
3366
        request_handlers.register(verb_name, verb, override_existing=True)
 
3367
        self.addCleanup(request_handlers.register, verb_name, orig_verb,
 
3368
                override_existing=True)
 
3369
 
 
3370
    def test_fetch_everything_backwards_compat(self):
 
3371
        """Can fetch with EverythingResult even with pre 2.4 servers.
 
3372
        
 
3373
        Pre-2.4 do not support 'everything' searches with the
 
3374
        Repository.get_stream_1.19 verb.
 
3375
        """
 
3376
        verb_log = []
 
3377
        class OldGetStreamVerb(SmartServerRepositoryGetStream_1_19):
 
3378
            """A version of the Repository.get_stream_1.19 verb patched to
 
3379
            reject 'everything' searches the way 2.3 and earlier do.
 
3380
            """
 
3381
            def recreate_search(self, repository, search_bytes, discard_excess=False):
 
3382
                verb_log.append(search_bytes.split('\n', 1)[0])
 
3383
                if search_bytes == 'everything':
 
3384
                    return (None, request.FailedSmartServerResponse(('BadSearch',)))
 
3385
                return super(OldGetStreamVerb,
 
3386
                        self).recreate_search(repository, search_bytes,
 
3387
                            discard_excess=discard_excess)
 
3388
        self.override_verb('Repository.get_stream_1.19', OldGetStreamVerb)
 
3389
        local = self.make_branch('local')
 
3390
        builder = self.make_branch_builder('remote')
 
3391
        builder.build_commit(message="Commit.")
 
3392
        remote_branch_url = self.smart_server.get_url() + 'remote'
 
3393
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
 
3394
        self.hpss_calls = []
 
3395
        local.repository.fetch(remote_branch.repository,
 
3396
                fetch_spec=graph.EverythingResult(remote_branch.repository))
 
3397
        # make sure the overridden verb was used
 
3398
        self.assertLength(1, verb_log)
 
3399
        # more than one HPSS call is needed, but because it's a VFS callback
 
3400
        # its hard to predict exactly how many.
 
3401
        self.assertTrue(len(self.hpss_calls) > 1)
 
3402