← 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: Andrew Bennetts
  • Date: 2010-09-17 04:32:50 UTC
  • mto: This revision was merged to the branch mainline in revision 5433.
  • Revision ID: andrew.bennetts@canonical.com-20100917043250-4f57ifkg0yu321t7
Reuse self._log_file rather than make new StringIO, and wrap pre-existing long line.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
32
32
    config,
33
33
    controldir,
34
34
    errors,
35
 
    graph as _mod_graph,
 
35
    graph,
36
36
    inventory,
37
37
    inventory_delta,
38
38
    remote,
52
52
    RemoteBranch,
53
53
    RemoteBranchFormat,
54
54
    RemoteBzrDir,
55
 
    RemoteBzrDirFormat,
56
55
    RemoteRepository,
57
56
    RemoteRepositoryFormat,
58
57
    )
59
 
from bzrlib.repofmt import groupcompress_repo, knitpack_repo
 
58
from bzrlib.repofmt import groupcompress_repo, pack_repo
60
59
from bzrlib.revision import NULL_REVISION
61
 
from bzrlib.smart import medium, request
 
60
from bzrlib.smart import medium
62
61
from bzrlib.smart.client import _SmartClient
63
 
from bzrlib.smart.repository import (
64
 
    SmartServerRepositoryGetParentMap,
65
 
    SmartServerRepositoryGetStream_1_19,
66
 
    )
 
62
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
67
63
from bzrlib.tests import (
 
64
    condition_isinstance,
 
65
    split_suite_by_condition,
 
66
    multiply_tests,
68
67
    test_server,
69
68
    )
70
 
from bzrlib.tests.scenarios import load_tests_apply_scenarios
71
69
from bzrlib.transport.memory import MemoryTransport
72
70
from bzrlib.transport.remote import (
73
71
    RemoteTransport,
74
72
    RemoteSSHTransport,
75
73
    RemoteTCPTransport,
76
 
    )
77
 
 
78
 
 
79
 
load_tests = load_tests_apply_scenarios
80
 
 
81
 
 
82
 
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
83
 
 
84
 
    scenarios = [
 
74
)
 
75
 
 
76
def load_tests(standard_tests, module, loader):
 
77
    to_adapt, result = split_suite_by_condition(
 
78
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
 
79
    smart_server_version_scenarios = [
85
80
        ('HPSS-v2',
86
 
            {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
 
81
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
87
82
        ('HPSS-v3',
88
 
            {'transport_server': test_server.SmartTCPServer_for_testing})]
89
 
 
 
83
         {'transport_server': test_server.SmartTCPServer_for_testing})]
 
84
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
 
85
 
 
86
 
 
87
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
90
88
 
91
89
    def setUp(self):
92
90
        super(BasicRemoteObjectTests, self).setUp()
96
94
        self.addCleanup(self.transport.disconnect)
97
95
 
98
96
    def test_create_remote_bzrdir(self):
99
 
        b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
 
97
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
100
98
        self.assertIsInstance(b, BzrDir)
101
99
 
102
100
    def test_open_remote_branch(self):
103
101
        # open a standalone branch in the working directory
104
 
        b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
 
102
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
105
103
        branch = b.open_branch()
106
104
        self.assertIsInstance(branch, Branch)
107
105
 
125
123
        fmt = BzrDirFormat.find_format(self.transport)
126
124
        self.assertTrue(bzrdir.RemoteBzrProber
127
125
                        in controldir.ControlDirFormat._server_probers)
128
 
        self.assertIsInstance(fmt, RemoteBzrDirFormat)
 
126
        self.assertIsInstance(fmt, remote.RemoteBzrDirFormat)
129
127
 
130
128
    def test_open_detected_smart_format(self):
131
129
        fmt = BzrDirFormat.find_format(self.transport)
451
449
        client.add_expected_call(
452
450
            'BzrDir.open_branchV3', ('quack/',),
453
451
            'success', ('ref', self.get_url('referenced'))),
454
 
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
452
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
455
453
            _client=client)
456
454
        result = a_bzrdir.cloning_metadir()
457
455
        # We should have got a control dir matching the referenced branch.
470
468
        client.add_expected_call(
471
469
            'BzrDir.cloning_metadir', ('quack/', 'False'),
472
470
            'success', (control_name, '', ('branch', ''))),
473
 
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
471
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
474
472
            _client=client)
475
473
        result = a_bzrdir.cloning_metadir()
476
474
        # We should have got a reference control dir with default branch and
496
494
        client.add_expected_call(
497
495
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
498
496
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
499
 
                RemoteBzrDirFormat(), _client=client, _force_probe=True)
 
497
                remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
500
498
        self.assertFinished(client)
501
499
 
502
500
    def test_present_without_workingtree(self):
503
501
        client, transport = self.make_fake_client_and_transport()
504
502
        client.add_expected_call(
505
503
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
506
 
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
504
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
507
505
            _client=client, _force_probe=True)
508
506
        self.assertIsInstance(bd, RemoteBzrDir)
509
507
        self.assertFalse(bd.has_workingtree())
514
512
        client, transport = self.make_fake_client_and_transport()
515
513
        client.add_expected_call(
516
514
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
517
 
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
515
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
518
516
            _client=client, _force_probe=True)
519
517
        self.assertIsInstance(bd, RemoteBzrDir)
520
518
        self.assertTrue(bd.has_workingtree())
527
525
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
528
526
        client.add_expected_call(
529
527
            'BzrDir.open', ('quack/',), 'success', ('yes',))
530
 
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
528
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
531
529
            _client=client, _force_probe=True)
532
530
        self.assertIsInstance(bd, RemoteBzrDir)
533
531
        self.assertFinished(client)
549
547
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
550
548
        client.add_expected_call(
551
549
            'BzrDir.open', ('quack/',), 'success', ('yes',))
552
 
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
550
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
553
551
            _client=client, _force_probe=True)
554
552
        self.assertIsInstance(bd, RemoteBzrDir)
555
553
        self.assertFinished(client)
586
584
        client.add_expected_call(
587
585
            'Branch.get_stacked_on_url', ('quack/',),
588
586
            'error', ('NotStacked',))
589
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
587
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
590
588
            _client=client)
591
589
        result = bzrdir.open_branch()
592
590
        self.assertIsInstance(result, RemoteBranch)
599
597
        transport = transport.clone('quack')
600
598
        client = FakeClient(transport.base)
601
599
        client.add_error_response('nobranch')
602
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
600
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
603
601
            _client=client)
604
602
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
605
603
        self.assertEqual(
616
614
        transport = MemoryTransport()
617
615
        # no requests on the network - catches other api calls being made.
618
616
        client = FakeClient(transport.base)
619
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
617
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
620
618
            _client=client)
621
619
        # patch the open_branch call to record that it was called.
622
620
        bzrdir.open_branch = open_branch
641
639
        client.add_expected_call(
642
640
            'Branch.get_stacked_on_url', ('~hello/',),
643
641
            'error', ('NotStacked',))
644
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
642
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
645
643
            _client=client)
646
644
        result = bzrdir.open_branch()
647
645
        self.assertFinished(client)
664
662
        client.add_success_response(
665
663
            'ok', '', rich_response, subtree_response, external_lookup,
666
664
            network_name)
667
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
665
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
668
666
            _client=client)
669
667
        result = bzrdir.open_repository()
670
668
        self.assertEqual(
716
714
            'BzrDir.create_branch', ('quack/', network_name),
717
715
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
718
716
            reference_repo_name))
719
 
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
717
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
720
718
            _client=client)
721
719
        branch = a_bzrdir.create_branch()
722
720
        # We should have got a remote branch
725
723
        format = branch._format
726
724
        self.assertEqual(network_name, format.network_name())
727
725
 
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
 
 
756
726
 
757
727
class TestBzrDirCreateRepository(TestRemote):
758
728
 
779
749
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
780
750
                'False'),
781
751
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
782
 
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
752
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
783
753
            _client=client)
784
754
        repo = a_bzrdir.create_repository()
785
755
        # We should have got a remote repository
814
784
        client.add_success_response('stat', '0', '65535')
815
785
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
816
786
            _client=client)
817
 
        bzrdir = RemoteBzrDir(remote_transport, RemoteBzrDirFormat(),
 
787
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
818
788
            _client=client)
819
789
        repo = bzrdir.open_repository()
820
790
        self.assertEqual(
847
817
        client.add_success_response('stat', '0', '65535')
848
818
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
849
819
            _client=client)
850
 
        bzrdir = RemoteBzrDir(remote_transport, RemoteBzrDirFormat(),
 
820
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
851
821
            _client=client)
852
822
        repo = bzrdir.open_repository()
853
823
        self.assertEqual(
868
838
        transport = transport.clone('quack')
869
839
        client = FakeClient(transport.base)
870
840
        client.add_success_response('ok', '', 'no', 'no', 'no', network_name)
871
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
841
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
872
842
            _client=client)
873
843
        repo = bzrdir.open_repository()
874
844
        self.assertEqual(
881
851
 
882
852
    def test_success(self):
883
853
        """Simple test for typical successful call."""
884
 
        fmt = RemoteBzrDirFormat()
 
854
        fmt = bzrdir.RemoteBzrDirFormat()
885
855
        default_format_name = BzrDirFormat.get_default_format().network_name()
886
856
        transport = self.get_transport()
887
857
        client = FakeClient(transport.base)
903
873
        """Error responses are translated, e.g. 'PermissionDenied' raises the
904
874
        corresponding error from the client.
905
875
        """
906
 
        fmt = RemoteBzrDirFormat()
 
876
        fmt = bzrdir.RemoteBzrDirFormat()
907
877
        default_format_name = BzrDirFormat.get_default_format().network_name()
908
878
        transport = self.get_transport()
909
879
        client = FakeClient(transport.base)
927
897
        """Integration test for error translation."""
928
898
        transport = self.make_smart_server('foo')
929
899
        transport = transport.clone('no-such-path')
930
 
        fmt = RemoteBzrDirFormat()
 
900
        fmt = bzrdir.RemoteBzrDirFormat()
931
901
        err = self.assertRaises(errors.NoSuchFile,
932
902
            fmt.initialize_on_transport_ex, transport, create_prefix=False)
933
903
 
964
934
 
965
935
    def make_remote_bzrdir(self, transport, client):
966
936
        """Make a RemotebzrDir using 'client' as the _client."""
967
 
        return RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
937
        return RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
968
938
            _client=client)
969
939
 
970
940
 
1172
1142
            [('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1173
1143
 
1174
1144
 
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
 
 
1240
1145
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1241
1146
 
1242
1147
    def test_empty_branch(self):
1297
1202
        client.add_expected_call(
1298
1203
            'Branch.get_stacked_on_url', ('stacked/',),
1299
1204
            'success', ('ok', vfs_url))
1300
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
1205
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
1301
1206
            _client=client)
1302
1207
        repo_fmt = remote.RemoteRepositoryFormat()
1303
1208
        repo_fmt._custom_format = stacked_branch.repository._format
1330
1235
        # this will also do vfs access, but that goes direct to the transport
1331
1236
        # and isn't seen by the FakeClient.
1332
1237
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1333
 
            RemoteBzrDirFormat(), _client=client)
 
1238
            remote.RemoteBzrDirFormat(), _client=client)
1334
1239
        branch = bzrdir.open_branch()
1335
1240
        result = branch.get_stacked_on_url()
1336
1241
        self.assertEqual('../base', result)
1363
1268
            'Branch.get_stacked_on_url', ('stacked/',),
1364
1269
            'success', ('ok', '../base'))
1365
1270
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1366
 
            RemoteBzrDirFormat(), _client=client)
 
1271
            remote.RemoteBzrDirFormat(), _client=client)
1367
1272
        branch = bzrdir.open_branch()
1368
1273
        result = branch.get_stacked_on_url()
1369
1274
        self.assertEqual('../base', result)
1377
1282
class TestBranchSetLastRevision(RemoteBranchTestCase):
1378
1283
 
1379
1284
    def test_set_empty(self):
1380
 
        # _set_last_revision_info('null:') is translated to calling
 
1285
        # set_revision_history([]) is translated to calling
1381
1286
        # Branch.set_last_revision(path, '') on the wire.
1382
1287
        transport = MemoryTransport()
1383
1288
        transport.mkdir('branch')
1405
1310
        # unnecessarily invokes _ensure_real upon a call to lock_write.
1406
1311
        branch._ensure_real = lambda: None
1407
1312
        branch.lock_write()
1408
 
        result = branch._set_last_revision(NULL_REVISION)
 
1313
        result = branch.set_revision_history([])
1409
1314
        branch.unlock()
1410
1315
        self.assertEqual(None, result)
1411
1316
        self.assertFinished(client)
1412
1317
 
1413
1318
    def test_set_nonempty(self):
1414
 
        # set_last_revision_info(N, rev-idN) is translated to calling
 
1319
        # set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
1415
1320
        # Branch.set_last_revision(path, rev-idN) on the wire.
1416
1321
        transport = MemoryTransport()
1417
1322
        transport.mkdir('branch')
1443
1348
        branch._ensure_real = lambda: None
1444
1349
        # Lock the branch, reset the record of remote calls.
1445
1350
        branch.lock_write()
1446
 
        result = branch._set_last_revision('rev-id2')
 
1351
        result = branch.set_revision_history(['rev-id1', 'rev-id2'])
1447
1352
        branch.unlock()
1448
1353
        self.assertEqual(None, result)
1449
1354
        self.assertFinished(client)
1479
1384
        branch = self.make_remote_branch(transport, client)
1480
1385
        branch.lock_write()
1481
1386
        self.assertRaises(
1482
 
            errors.NoSuchRevision, branch._set_last_revision, 'rev-id')
 
1387
            errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
1483
1388
        branch.unlock()
1484
1389
        self.assertFinished(client)
1485
1390
 
1516
1421
        branch._ensure_real = lambda: None
1517
1422
        branch.lock_write()
1518
1423
        # The 'TipChangeRejected' error response triggered by calling
1519
 
        # set_last_revision_info causes a TipChangeRejected exception.
 
1424
        # set_revision_history causes a TipChangeRejected exception.
1520
1425
        err = self.assertRaises(
1521
 
            errors.TipChangeRejected,
1522
 
            branch._set_last_revision, 'rev-id')
 
1426
            errors.TipChangeRejected, branch.set_revision_history, ['rev-id'])
1523
1427
        # The UTF-8 message from the response has been decoded into a unicode
1524
1428
        # object.
1525
1429
        self.assertIsInstance(err.msg, unicode)
1940
1844
        client = FakeClient(transport.base)
1941
1845
        transport = transport.clone(transport_path)
1942
1846
        # we do not want bzrdir to make any remote calls
1943
 
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
1847
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
1944
1848
            _client=False)
1945
1849
        repo = RemoteRepository(bzrdir, None, _client=client)
1946
1850
        return repo, client
1954
1858
 
1955
1859
    def test_get_format_description(self):
1956
1860
        remote_format = RemoteBranchFormat()
1957
 
        real_format = branch.format_registry.get_default()
 
1861
        real_format = branch.BranchFormat.get_default_format()
1958
1862
        remote_format._network_name = real_format.network_name()
1959
1863
        self.assertEqual(remoted_description(real_format),
1960
1864
            remote_format.get_format_description())
1963
1867
class TestRepositoryFormat(TestRemoteRepository):
1964
1868
 
1965
1869
    def test_fast_delta(self):
1966
 
        true_name = groupcompress_repo.RepositoryFormat2a().network_name()
 
1870
        true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
1967
1871
        true_format = RemoteRepositoryFormat()
1968
1872
        true_format._network_name = true_name
1969
1873
        self.assertEqual(True, true_format.fast_deltas)
1970
 
        false_name = knitpack_repo.RepositoryFormatKnitPack1().network_name()
 
1874
        false_name = pack_repo.RepositoryFormatKnitPack1().network_name()
1971
1875
        false_format = RemoteRepositoryFormat()
1972
1876
        false_format._network_name = false_name
1973
1877
        self.assertEqual(False, false_format.fast_deltas)
1974
1878
 
1975
1879
    def test_get_format_description(self):
1976
1880
        remote_repo_format = RemoteRepositoryFormat()
1977
 
        real_format = repository.format_registry.get_default()
 
1881
        real_format = repository.RepositoryFormat.get_default_format()
1978
1882
        remote_repo_format._network_name = real_format.network_name()
1979
1883
        self.assertEqual(remoted_description(real_format),
1980
1884
            remote_repo_format.get_format_description())
2538
2442
        the client is finished.
2539
2443
        """
2540
2444
        sink = repo._get_sink()
2541
 
        fmt = repository.format_registry.get_default()
 
2445
        fmt = repository.RepositoryFormat.get_default_format()
2542
2446
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2543
2447
        self.assertEqual([], resume_tokens)
2544
2448
        self.assertEqual(set(), missing_keys)
2644
2548
                return True
2645
2549
        repo._real_repository = FakeRealRepository()
2646
2550
        sink = repo._get_sink()
2647
 
        fmt = repository.format_registry.get_default()
 
2551
        fmt = repository.RepositoryFormat.get_default_format()
2648
2552
        stream = self.make_stream_with_inv_deltas(fmt)
2649
2553
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2650
2554
        # Every record from the first inventory delta should have been sent to
2870
2774
             ('pack collection autopack',)],
2871
2775
            client._calls)
2872
2776
 
2873
 
    def test_oom_error_reporting(self):
2874
 
        """An out-of-memory condition on the server is reported clearly"""
2875
 
        transport_path = 'quack'
2876
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2877
 
        client.add_expected_call(
2878
 
            'PackRepository.autopack', ('quack/',),
2879
 
            'error', ('MemoryError',))
2880
 
        err = self.assertRaises(errors.BzrError, repo.autopack)
2881
 
        self.assertContainsRe(str(err), "^remote server out of mem")
2882
 
 
2883
2777
 
2884
2778
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
2885
2779
    """Base class for unit tests for bzrlib.remote._translate_error."""
2958
2852
            detail='extra detail')
2959
2853
        self.assertEqual(expected_error, translated_error)
2960
2854
 
2961
 
    def test_norepository(self):
2962
 
        bzrdir = self.make_bzrdir('')
2963
 
        translated_error = self.translateTuple(('norepository',),
2964
 
            bzrdir=bzrdir)
2965
 
        expected_error = errors.NoRepositoryPresent(bzrdir)
2966
 
        self.assertEqual(expected_error, translated_error)
2967
 
 
2968
2855
    def test_LockContention(self):
2969
2856
        translated_error = self.translateTuple(('LockContention',))
2970
2857
        expected_error = errors.LockContention('(remote lock)')
2998
2885
        expected_error = errors.DivergedBranches(branch, other_branch)
2999
2886
        self.assertEqual(expected_error, translated_error)
3000
2887
 
3001
 
    def test_NotStacked(self):
3002
 
        branch = self.make_branch('')
3003
 
        translated_error = self.translateTuple(('NotStacked',), branch=branch)
3004
 
        expected_error = errors.NotStacked(branch)
3005
 
        self.assertEqual(expected_error, translated_error)
3006
 
 
3007
2888
    def test_ReadError_no_args(self):
3008
2889
        path = 'a path'
3009
2890
        translated_error = self.translateTuple(('ReadError',), path=path)
3025
2906
 
3026
2907
    def test_PermissionDenied_no_args(self):
3027
2908
        path = 'a path'
3028
 
        translated_error = self.translateTuple(('PermissionDenied',),
3029
 
            path=path)
 
2909
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
3030
2910
        expected_error = errors.PermissionDenied(path)
3031
2911
        self.assertEqual(expected_error, translated_error)
3032
2912
 
3055
2935
        expected_error = errors.PermissionDenied(path, extra)
3056
2936
        self.assertEqual(expected_error, translated_error)
3057
2937
 
3058
 
    # GZ 2011-03-02: TODO test for PermissionDenied with non-ascii 'extra'
3059
 
 
3060
 
    def test_NoSuchFile_context_path(self):
3061
 
        local_path = "local path"
3062
 
        translated_error = self.translateTuple(('ReadError', "remote path"),
3063
 
            path=local_path)
3064
 
        expected_error = errors.ReadError(local_path)
3065
 
        self.assertEqual(expected_error, translated_error)
3066
 
 
3067
 
    def test_NoSuchFile_without_context(self):
3068
 
        remote_path = "remote path"
3069
 
        translated_error = self.translateTuple(('ReadError', remote_path))
3070
 
        expected_error = errors.ReadError(remote_path)
3071
 
        self.assertEqual(expected_error, translated_error)
3072
 
 
3073
 
    def test_ReadOnlyError(self):
3074
 
        translated_error = self.translateTuple(('ReadOnlyError',))
3075
 
        expected_error = errors.TransportNotPossible("readonly transport")
3076
 
        self.assertEqual(expected_error, translated_error)
3077
 
 
3078
 
    def test_MemoryError(self):
3079
 
        translated_error = self.translateTuple(('MemoryError',))
3080
 
        self.assertStartsWith(str(translated_error),
3081
 
            "remote server out of memory")
3082
 
 
3083
 
    def test_generic_IndexError_no_classname(self):
3084
 
        err = errors.ErrorFromSmartServer(('error', "list index out of range"))
3085
 
        translated_error = self.translateErrorFromSmartServer(err)
3086
 
        expected_error = errors.UnknownErrorFromSmartServer(err)
3087
 
        self.assertEqual(expected_error, translated_error)
3088
 
 
3089
 
    # GZ 2011-03-02: TODO test generic non-ascii error string
3090
 
 
3091
 
    def test_generic_KeyError(self):
3092
 
        err = errors.ErrorFromSmartServer(('error', 'KeyError', "1"))
3093
 
        translated_error = self.translateErrorFromSmartServer(err)
3094
 
        expected_error = errors.UnknownErrorFromSmartServer(err)
3095
 
        self.assertEqual(expected_error, translated_error)
3096
 
 
3097
2938
 
3098
2939
class TestErrorTranslationRobustness(TestErrorTranslationBase):
3099
2940
    """Unit tests for bzrlib.remote._translate_error's robustness.
3244
3085
        _, stacked = branch_factory()
3245
3086
        source = stacked.repository._get_source(target_repository_format)
3246
3087
        tip = stacked.last_revision()
3247
 
        stacked.repository._ensure_real()
3248
 
        graph = stacked.repository.get_graph()
3249
 
        revs = [r for (r,ps) in graph.iter_ancestry([tip])
3250
 
                if r != NULL_REVISION]
3251
 
        revs.reverse()
3252
 
        search = _mod_graph.PendingAncestryResult([tip], stacked.repository)
 
3088
        revs = stacked.repository.get_ancestry(tip)
 
3089
        search = graph.PendingAncestryResult([tip], stacked.repository)
3253
3090
        self.reset_smart_call_log()
3254
3091
        stream = source.get_stream(search)
 
3092
        if None in revs:
 
3093
            revs.remove(None)
3255
3094
        # We trust that if a revision is in the stream the rest of the new
3256
3095
        # content for it is too, as per our main fetch tests; here we are
3257
3096
        # checking that the revisions are actually included at all, and their
3296
3135
        self.assertEqual(expected_revs, rev_ord)
3297
3136
        # Getting topological sort requires VFS calls still - one of which is
3298
3137
        # pushing up from the bound branch.
3299
 
        self.assertLength(14, self.hpss_calls)
 
3138
        self.assertLength(13, self.hpss_calls)
3300
3139
 
3301
3140
    def test_stacked_get_stream_groupcompress(self):
3302
3141
        # Repository._get_source.get_stream() from a stacked repository with
3343
3182
 
3344
3183
    def test_copy_content_into_avoids_revision_history(self):
3345
3184
        local = self.make_branch('local')
3346
 
        builder = self.make_branch_builder('remote')
3347
 
        builder.build_commit(message="Commit.")
 
3185
        remote_backing_tree = self.make_branch_and_tree('remote')
 
3186
        remote_backing_tree.commit("Commit.")
3348
3187
        remote_branch_url = self.smart_server.get_url() + 'remote'
3349
3188
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3350
3189
        local.repository.fetch(remote_branch.repository)
3351
3190
        self.hpss_calls = []
3352
3191
        remote_branch.copy_content_into(local)
3353
3192
        self.assertFalse('Branch.revision_history' in self.hpss_calls)
3354
 
 
3355
 
    def test_fetch_everything_needs_just_one_call(self):
3356
 
        local = self.make_branch('local')
3357
 
        builder = self.make_branch_builder('remote')
3358
 
        builder.build_commit(message="Commit.")
3359
 
        remote_branch_url = self.smart_server.get_url() + 'remote'
3360
 
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3361
 
        self.hpss_calls = []
3362
 
        local.repository.fetch(remote_branch.repository,
3363
 
                fetch_spec=_mod_graph.EverythingResult(remote_branch.repository))
3364
 
        self.assertEqual(['Repository.get_stream_1.19'], self.hpss_calls)
3365
 
 
3366
 
    def override_verb(self, verb_name, verb):
3367
 
        request_handlers = request.request_handlers
3368
 
        orig_verb = request_handlers.get(verb_name)
3369
 
        request_handlers.register(verb_name, verb, override_existing=True)
3370
 
        self.addCleanup(request_handlers.register, verb_name, orig_verb,
3371
 
                override_existing=True)
3372
 
 
3373
 
    def test_fetch_everything_backwards_compat(self):
3374
 
        """Can fetch with EverythingResult even with pre 2.4 servers.
3375
 
        
3376
 
        Pre-2.4 do not support 'everything' searches with the
3377
 
        Repository.get_stream_1.19 verb.
3378
 
        """
3379
 
        verb_log = []
3380
 
        class OldGetStreamVerb(SmartServerRepositoryGetStream_1_19):
3381
 
            """A version of the Repository.get_stream_1.19 verb patched to
3382
 
            reject 'everything' searches the way 2.3 and earlier do.
3383
 
            """
3384
 
            def recreate_search(self, repository, search_bytes, discard_excess=False):
3385
 
                verb_log.append(search_bytes.split('\n', 1)[0])
3386
 
                if search_bytes == 'everything':
3387
 
                    return (None, request.FailedSmartServerResponse(('BadSearch',)))
3388
 
                return super(OldGetStreamVerb,
3389
 
                        self).recreate_search(repository, search_bytes,
3390
 
                            discard_excess=discard_excess)
3391
 
        self.override_verb('Repository.get_stream_1.19', OldGetStreamVerb)
3392
 
        local = self.make_branch('local')
3393
 
        builder = self.make_branch_builder('remote')
3394
 
        builder.build_commit(message="Commit.")
3395
 
        remote_branch_url = self.smart_server.get_url() + 'remote'
3396
 
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3397
 
        self.hpss_calls = []
3398
 
        local.repository.fetch(remote_branch.repository,
3399
 
                fetch_spec=_mod_graph.EverythingResult(remote_branch.repository))
3400
 
        # make sure the overridden verb was used
3401
 
        self.assertLength(1, verb_log)
3402
 
        # more than one HPSS call is needed, but because it's a VFS callback
3403
 
        # its hard to predict exactly how many.
3404
 
        self.assertTrue(len(self.hpss_calls) > 1)
3405