/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 bzrlib/tests/test_remote.py

  • Committer: Andrew Bennetts
  • Date: 2009-08-13 00:20:29 UTC
  • mto: This revision was merged to the branch mainline in revision 4608.
  • Revision ID: andrew.bennetts@canonical.com-20090813002029-akc5x2mtxa8rq068
Raise InventoryDeltaErrors, not generic BzrErrors, from inventory_delta.py.

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, 2007, 2008, 2009 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
27
27
from cStringIO import StringIO
28
28
 
29
29
from bzrlib import (
30
 
    branch,
31
30
    bzrdir,
32
31
    config,
33
32
    errors,
37
36
    pack,
38
37
    remote,
39
38
    repository,
 
39
    smart,
40
40
    tests,
41
41
    treebuilder,
42
42
    urlutils,
54
54
    )
55
55
from bzrlib.repofmt import groupcompress_repo, pack_repo
56
56
from bzrlib.revision import NULL_REVISION
57
 
from bzrlib.smart import medium
 
57
from bzrlib.smart import server, medium
58
58
from bzrlib.smart.client import _SmartClient
59
59
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
60
60
from bzrlib.tests import (
61
61
    condition_isinstance,
62
62
    split_suite_by_condition,
63
63
    multiply_tests,
64
 
    test_server,
 
64
    KnownFailure,
65
65
    )
66
 
from bzrlib.transport import get_transport
 
66
from bzrlib.transport import get_transport, http
67
67
from bzrlib.transport.memory import MemoryTransport
68
68
from bzrlib.transport.remote import (
69
69
    RemoteTransport,
76
76
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
77
77
    smart_server_version_scenarios = [
78
78
        ('HPSS-v2',
79
 
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
 
79
            {'transport_server': server.SmartTCPServer_for_testing_v2_only}),
80
80
        ('HPSS-v3',
81
 
         {'transport_server': test_server.SmartTCPServer_for_testing})]
 
81
            {'transport_server': server.SmartTCPServer_for_testing})]
82
82
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
83
83
 
84
84
 
135
135
        b = BzrDir.open_from_transport(self.transport).open_branch()
136
136
        self.assertStartsWith(str(b), 'RemoteBranch(')
137
137
 
138
 
    def test_remote_bzrdir_repr(self):
139
 
        b = BzrDir.open_from_transport(self.transport)
140
 
        self.assertStartsWith(str(b), 'RemoteBzrDir(')
141
 
 
142
138
    def test_remote_branch_format_supports_stacking(self):
143
139
        t = self.transport
144
140
        self.make_branch('unstackable', format='pack-0.92')
284
280
        self.expecting_body = True
285
281
        return result[1], FakeProtocol(result[2], self)
286
282
 
287
 
    def call_with_body_bytes(self, method, args, body):
288
 
        self._check_call(method, args)
289
 
        self._calls.append(('call_with_body_bytes', method, args, body))
290
 
        result = self._get_next_response()
291
 
        return result[1], FakeProtocol(result[2], self)
292
 
 
293
283
    def call_with_body_bytes_expecting_body(self, method, args, body):
294
284
        self._check_call(method, args)
295
285
        self._calls.append(('call_with_body_bytes_expecting_body', method,
418
408
        # Calling _remember_remote_is_before again with a lower value works.
419
409
        client_medium._remember_remote_is_before((1, 5))
420
410
        self.assertTrue(client_medium._is_remote_before((1, 5)))
421
 
        # If you call _remember_remote_is_before with a higher value it logs a
422
 
        # warning, and continues to remember the lower value.
423
 
        self.assertNotContainsRe(self.get_log(), '_remember_remote_is_before')
424
 
        client_medium._remember_remote_is_before((1, 9))
425
 
        self.assertContainsRe(self.get_log(), '_remember_remote_is_before')
426
 
        self.assertTrue(client_medium._is_remote_before((1, 5)))
 
411
        # You cannot call _remember_remote_is_before with a larger value.
 
412
        self.assertRaises(
 
413
            AssertionError, client_medium._remember_remote_is_before, (1, 9))
427
414
 
428
415
 
429
416
class TestBzrDirCloningMetaDir(TestRemote):
448
435
            'BzrDir.cloning_metadir', ('quack/', 'False'),
449
436
            'error', ('BranchReference',)),
450
437
        client.add_expected_call(
451
 
            'BzrDir.open_branchV3', ('quack/',),
 
438
            'BzrDir.open_branchV2', ('quack/',),
452
439
            'success', ('ref', self.get_url('referenced'))),
453
440
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
454
441
            _client=client)
481
468
        self.assertFinished(client)
482
469
 
483
470
 
484
 
class TestBzrDirOpen(TestRemote):
485
 
 
486
 
    def make_fake_client_and_transport(self, path='quack'):
487
 
        transport = MemoryTransport()
488
 
        transport.mkdir(path)
489
 
        transport = transport.clone(path)
490
 
        client = FakeClient(transport.base)
491
 
        return client, transport
492
 
 
493
 
    def test_absent(self):
494
 
        client, transport = self.make_fake_client_and_transport()
495
 
        client.add_expected_call(
496
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
497
 
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
498
 
                remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
499
 
        self.assertFinished(client)
500
 
 
501
 
    def test_present_without_workingtree(self):
502
 
        client, transport = self.make_fake_client_and_transport()
503
 
        client.add_expected_call(
504
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
505
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
506
 
            _client=client, _force_probe=True)
507
 
        self.assertIsInstance(bd, RemoteBzrDir)
508
 
        self.assertFalse(bd.has_workingtree())
509
 
        self.assertRaises(errors.NoWorkingTree, bd.open_workingtree)
510
 
        self.assertFinished(client)
511
 
 
512
 
    def test_present_with_workingtree(self):
513
 
        client, transport = self.make_fake_client_and_transport()
514
 
        client.add_expected_call(
515
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
516
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
517
 
            _client=client, _force_probe=True)
518
 
        self.assertIsInstance(bd, RemoteBzrDir)
519
 
        self.assertTrue(bd.has_workingtree())
520
 
        self.assertRaises(errors.NotLocalUrl, bd.open_workingtree)
521
 
        self.assertFinished(client)
522
 
 
523
 
    def test_backwards_compat(self):
524
 
        client, transport = self.make_fake_client_and_transport()
525
 
        client.add_expected_call(
526
 
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
527
 
        client.add_expected_call(
528
 
            'BzrDir.open', ('quack/',), 'success', ('yes',))
529
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
530
 
            _client=client, _force_probe=True)
531
 
        self.assertIsInstance(bd, RemoteBzrDir)
532
 
        self.assertFinished(client)
533
 
 
534
 
    def test_backwards_compat_hpss_v2(self):
535
 
        client, transport = self.make_fake_client_and_transport()
536
 
        # Monkey-patch fake client to simulate real-world behaviour with v2
537
 
        # server: upon first RPC call detect the protocol version, and because
538
 
        # the version is 2 also do _remember_remote_is_before((1, 6)) before
539
 
        # continuing with the RPC.
540
 
        orig_check_call = client._check_call
541
 
        def check_call(method, args):
542
 
            client._medium._protocol_version = 2
543
 
            client._medium._remember_remote_is_before((1, 6))
544
 
            client._check_call = orig_check_call
545
 
            client._check_call(method, args)
546
 
        client._check_call = check_call
547
 
        client.add_expected_call(
548
 
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
549
 
        client.add_expected_call(
550
 
            'BzrDir.open', ('quack/',), 'success', ('yes',))
551
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
552
 
            _client=client, _force_probe=True)
553
 
        self.assertIsInstance(bd, RemoteBzrDir)
554
 
        self.assertFinished(client)
555
 
 
556
 
 
557
471
class TestBzrDirOpenBranch(TestRemote):
558
472
 
559
473
    def test_backwards_compat(self):
561
475
        self.make_branch('.')
562
476
        a_dir = BzrDir.open(self.get_url('.'))
563
477
        self.reset_smart_call_log()
564
 
        verb = 'BzrDir.open_branchV3'
 
478
        verb = 'BzrDir.open_branchV2'
565
479
        self.disable_verb(verb)
566
480
        format = a_dir.open_branch()
567
481
        call_count = len([call for call in self.hpss_calls if
577
491
        transport = transport.clone('quack')
578
492
        client = FakeClient(transport.base)
579
493
        client.add_expected_call(
580
 
            'BzrDir.open_branchV3', ('quack/',),
 
494
            'BzrDir.open_branchV2', ('quack/',),
581
495
            'success', ('branch', branch_network_name))
582
496
        client.add_expected_call(
583
497
            'BzrDir.find_repositoryV3', ('quack/',),
602
516
            _client=client)
603
517
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
604
518
        self.assertEqual(
605
 
            [('call', 'BzrDir.open_branchV3', ('quack/',))],
 
519
            [('call', 'BzrDir.open_branchV2', ('quack/',))],
606
520
            client._calls)
607
521
 
608
522
    def test__get_tree_branch(self):
632
546
        network_name = reference_format.network_name()
633
547
        branch_network_name = self.get_branch_format().network_name()
634
548
        client.add_expected_call(
635
 
            'BzrDir.open_branchV3', ('~hello/',),
 
549
            'BzrDir.open_branchV2', ('~hello/',),
636
550
            'success', ('branch', branch_network_name))
637
551
        client.add_expected_call(
638
552
            'BzrDir.find_repositoryV3', ('~hello/',),
747
661
        network_name = reference_format.network_name()
748
662
        client.add_expected_call(
749
663
            'BzrDir.create_repository', ('quack/',
750
 
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
751
 
                'False'),
752
 
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
 
664
                'Bazaar pack repository format 1 (needs bzr 0.92)\n', 'False'),
 
665
            'success', ('ok', 'no', 'no', 'no', network_name))
753
666
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
754
667
            _client=client)
755
668
        repo = a_bzrdir.create_repository()
757
670
        self.assertIsInstance(repo, remote.RemoteRepository)
758
671
        # its format should have the settings from the response
759
672
        format = repo._format
760
 
        self.assertTrue(format.rich_root_data)
761
 
        self.assertTrue(format.supports_tree_reference)
762
 
        self.assertTrue(format.supports_external_lookups)
 
673
        self.assertFalse(format.rich_root_data)
 
674
        self.assertFalse(format.supports_tree_reference)
 
675
        self.assertFalse(format.supports_external_lookups)
763
676
        self.assertEqual(network_name, format.network_name())
764
677
 
765
678
 
769
682
        # fallback all the way to the first version.
770
683
        reference_format = self.get_repo_format()
771
684
        network_name = reference_format.network_name()
772
 
        server_url = 'bzr://example.com/'
773
 
        self.permit_url(server_url)
774
 
        client = FakeClient(server_url)
 
685
        client = FakeClient('bzr://example.com/')
775
686
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
776
687
        client.add_unknown_method_response('BzrDir.find_repositoryV2')
777
688
        client.add_success_response('ok', '', 'no', 'no')
783
694
            reference_format.get_format_string(), 'ok')
784
695
        # PackRepository wants to do a stat
785
696
        client.add_success_response('stat', '0', '65535')
786
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
697
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
787
698
            _client=client)
788
699
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
789
700
            _client=client)
803
714
        # fallback to find_repositoryV2
804
715
        reference_format = self.get_repo_format()
805
716
        network_name = reference_format.network_name()
806
 
        server_url = 'bzr://example.com/'
807
 
        self.permit_url(server_url)
808
 
        client = FakeClient(server_url)
 
717
        client = FakeClient('bzr://example.com/')
809
718
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
810
719
        client.add_success_response('ok', '', 'no', 'no', 'no')
811
720
        # A real repository instance will be created to determine the network
816
725
            reference_format.get_format_string(), 'ok')
817
726
        # PackRepository wants to do a stat
818
727
        client.add_success_response('stat', '0', '65535')
819
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
728
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
820
729
            _client=client)
821
730
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
822
731
            _client=client)
941
850
 
942
851
class RemoteBranchTestCase(RemoteBzrDirTestCase):
943
852
 
944
 
    def lock_remote_branch(self, branch):
945
 
        """Trick a RemoteBranch into thinking it is locked."""
946
 
        branch._lock_mode = 'w'
947
 
        branch._lock_count = 2
948
 
        branch._lock_token = 'branch token'
949
 
        branch._repo_lock_token = 'repo token'
950
 
        branch.repository._lock_mode = 'w'
951
 
        branch.repository._lock_count = 2
952
 
        branch.repository._lock_token = 'repo token'
953
 
 
954
853
    def make_remote_branch(self, transport, client):
955
854
        """Make a RemoteBranch using 'client' as its _SmartClient.
956
855
 
1095
994
        self.assertEqual({}, result)
1096
995
 
1097
996
 
1098
 
class TestBranchSetTagsBytes(RemoteBranchTestCase):
1099
 
 
1100
 
    def test_trivial(self):
1101
 
        transport = MemoryTransport()
1102
 
        client = FakeClient(transport.base)
1103
 
        client.add_expected_call(
1104
 
            'Branch.get_stacked_on_url', ('quack/',),
1105
 
            'error', ('NotStacked',))
1106
 
        client.add_expected_call(
1107
 
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1108
 
            'success', ('',))
1109
 
        transport.mkdir('quack')
1110
 
        transport = transport.clone('quack')
1111
 
        branch = self.make_remote_branch(transport, client)
1112
 
        self.lock_remote_branch(branch)
1113
 
        branch._set_tags_bytes('tags bytes')
1114
 
        self.assertFinished(client)
1115
 
        self.assertEqual('tags bytes', client._calls[-1][-1])
1116
 
 
1117
 
    def test_backwards_compatible(self):
1118
 
        transport = MemoryTransport()
1119
 
        client = FakeClient(transport.base)
1120
 
        client.add_expected_call(
1121
 
            'Branch.get_stacked_on_url', ('quack/',),
1122
 
            'error', ('NotStacked',))
1123
 
        client.add_expected_call(
1124
 
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1125
 
            'unknown', ('Branch.set_tags_bytes',))
1126
 
        transport.mkdir('quack')
1127
 
        transport = transport.clone('quack')
1128
 
        branch = self.make_remote_branch(transport, client)
1129
 
        self.lock_remote_branch(branch)
1130
 
        class StubRealBranch(object):
1131
 
            def __init__(self):
1132
 
                self.calls = []
1133
 
            def _set_tags_bytes(self, bytes):
1134
 
                self.calls.append(('set_tags_bytes', bytes))
1135
 
        real_branch = StubRealBranch()
1136
 
        branch._real_branch = real_branch
1137
 
        branch._set_tags_bytes('tags bytes')
1138
 
        # Call a second time, to exercise the 'remote version already inferred'
1139
 
        # code path.
1140
 
        branch._set_tags_bytes('tags bytes')
1141
 
        self.assertFinished(client)
1142
 
        self.assertEqual(
1143
 
            [('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1144
 
 
1145
 
 
1146
997
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1147
998
 
1148
999
    def test_empty_branch(self):
1220
1071
        client = FakeClient(self.get_url())
1221
1072
        branch_network_name = self.get_branch_format().network_name()
1222
1073
        client.add_expected_call(
1223
 
            'BzrDir.open_branchV3', ('stacked/',),
 
1074
            'BzrDir.open_branchV2', ('stacked/',),
1224
1075
            'success', ('branch', branch_network_name))
1225
1076
        client.add_expected_call(
1226
1077
            'BzrDir.find_repositoryV3', ('stacked/',),
1248
1099
            len(branch.repository._real_repository._fallback_repositories))
1249
1100
 
1250
1101
    def test_get_stacked_on_real_branch(self):
1251
 
        base_branch = self.make_branch('base')
1252
 
        stacked_branch = self.make_branch('stacked')
 
1102
        base_branch = self.make_branch('base', format='1.6')
 
1103
        stacked_branch = self.make_branch('stacked', format='1.6')
1253
1104
        stacked_branch.set_stacked_on_url('../base')
1254
1105
        reference_format = self.get_repo_format()
1255
1106
        network_name = reference_format.network_name()
1256
1107
        client = FakeClient(self.get_url())
1257
1108
        branch_network_name = self.get_branch_format().network_name()
1258
1109
        client.add_expected_call(
1259
 
            'BzrDir.open_branchV3', ('stacked/',),
 
1110
            'BzrDir.open_branchV2', ('stacked/',),
1260
1111
            'success', ('branch', branch_network_name))
1261
1112
        client.add_expected_call(
1262
1113
            'BzrDir.find_repositoryV3', ('stacked/',),
1263
 
            'success', ('ok', '', 'yes', 'no', 'yes', network_name))
 
1114
            'success', ('ok', '', 'no', 'no', 'yes', network_name))
1264
1115
        # called twice, once from constructor and then again by us
1265
1116
        client.add_expected_call(
1266
1117
            'Branch.get_stacked_on_url', ('stacked/',),
1490
1341
            errors.NoSuchRevision, branch.set_last_revision_info, 123, 'revid')
1491
1342
        branch.unlock()
1492
1343
 
 
1344
    def lock_remote_branch(self, branch):
 
1345
        """Trick a RemoteBranch into thinking it is locked."""
 
1346
        branch._lock_mode = 'w'
 
1347
        branch._lock_count = 2
 
1348
        branch._lock_token = 'branch token'
 
1349
        branch._repo_lock_token = 'repo token'
 
1350
        branch.repository._lock_mode = 'w'
 
1351
        branch.repository._lock_count = 2
 
1352
        branch.repository._lock_token = 'repo token'
 
1353
 
1493
1354
    def test_backwards_compatibility(self):
1494
1355
        """If the server does not support the Branch.set_last_revision_info
1495
1356
        verb (which is new in 1.4), then the client falls back to VFS methods.
1811
1672
        return repo, client
1812
1673
 
1813
1674
 
1814
 
def remoted_description(format):
1815
 
    return 'Remote: ' + format.get_format_description()
1816
 
 
1817
 
 
1818
 
class TestBranchFormat(tests.TestCase):
1819
 
 
1820
 
    def test_get_format_description(self):
1821
 
        remote_format = RemoteBranchFormat()
1822
 
        real_format = branch.BranchFormat.get_default_format()
1823
 
        remote_format._network_name = real_format.network_name()
1824
 
        self.assertEqual(remoted_description(real_format),
1825
 
            remote_format.get_format_description())
1826
 
 
1827
 
 
1828
1675
class TestRepositoryFormat(TestRemoteRepository):
1829
1676
 
1830
1677
    def test_fast_delta(self):
1837
1684
        false_format._network_name = false_name
1838
1685
        self.assertEqual(False, false_format.fast_deltas)
1839
1686
 
1840
 
    def test_get_format_description(self):
1841
 
        remote_repo_format = RemoteRepositoryFormat()
1842
 
        real_format = repository.RepositoryFormat.get_default_format()
1843
 
        remote_repo_format._network_name = real_format.network_name()
1844
 
        self.assertEqual(remoted_description(real_format),
1845
 
            remote_repo_format.get_format_description())
1846
 
 
1847
1687
 
1848
1688
class TestRepositoryGatherStats(TestRemoteRepository):
1849
1689
 
2034
1874
        self.assertLength(1, self.hpss_calls)
2035
1875
 
2036
1876
    def disableExtraResults(self):
2037
 
        self.overrideAttr(SmartServerRepositoryGetParentMap,
2038
 
                          'no_extra_results', True)
 
1877
        old_flag = SmartServerRepositoryGetParentMap.no_extra_results
 
1878
        SmartServerRepositoryGetParentMap.no_extra_results = True
 
1879
        def reset_values():
 
1880
            SmartServerRepositoryGetParentMap.no_extra_results = old_flag
 
1881
        self.addCleanup(reset_values)
2039
1882
 
2040
1883
    def test_null_cached_missing_and_stop_key(self):
2041
1884
        self.setup_smart_server_with_call_log()
2100
1943
 
2101
1944
    def test_allows_new_revisions(self):
2102
1945
        """get_parent_map's results can be updated by commit."""
2103
 
        smart_server = test_server.SmartTCPServer_for_testing()
2104
 
        self.start_server(smart_server)
 
1946
        smart_server = server.SmartTCPServer_for_testing()
 
1947
        smart_server.setUp()
 
1948
        self.addCleanup(smart_server.tearDown)
2105
1949
        self.make_branch('branch')
2106
1950
        branch = Branch.open(smart_server.get_url() + '/branch')
2107
1951
        tree = branch.create_checkout('tree', lightweight=True)
2216
2060
        """
2217
2061
        # Make a repo with a fallback repo, both using a FakeClient.
2218
2062
        format = remote.response_tuple_to_repo_format(
2219
 
            ('yes', 'no', 'yes', self.get_repo_format().network_name()))
 
2063
            ('yes', 'no', 'yes', 'fake-network-name'))
2220
2064
        repo, client = self.setup_fake_client_and_repository('quack')
2221
2065
        repo._format = format
2222
2066
        fallback_repo, ignored = self.setup_fake_client_and_repository(
2223
2067
            'fallback')
2224
2068
        fallback_repo._client = client
2225
 
        fallback_repo._format = format
2226
2069
        repo.add_fallback_repository(fallback_repo)
2227
2070
        # First the client should ask the primary repo
2228
2071
        client.add_expected_call(
2249
2092
            repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
2250
2093
        self.assertFinished(client)
2251
2094
 
2252
 
    def test_branch_fallback_locking(self):
2253
 
        """RemoteBranch.get_rev_id takes a read lock, and tries to call the
2254
 
        get_rev_id_for_revno verb.  If the verb is unknown the VFS fallback
2255
 
        will be invoked, which will fail if the repo is unlocked.
2256
 
        """
2257
 
        self.setup_smart_server_with_call_log()
2258
 
        tree = self.make_branch_and_memory_tree('.')
2259
 
        tree.lock_write()
2260
 
        rev1 = tree.commit('First')
2261
 
        rev2 = tree.commit('Second')
2262
 
        tree.unlock()
2263
 
        branch = tree.branch
2264
 
        self.assertFalse(branch.is_locked())
2265
 
        self.reset_smart_call_log()
2266
 
        verb = 'Repository.get_rev_id_for_revno'
2267
 
        self.disable_verb(verb)
2268
 
        self.assertEqual(rev1, branch.get_rev_id(1))
2269
 
        self.assertLength(1, [call for call in self.hpss_calls if
2270
 
                              call.call.method == verb])
2271
 
 
2272
2095
 
2273
2096
class TestRepositoryIsShared(TestRemoteRepository):
2274
2097
 
2301
2124
        transport_path = 'quack'
2302
2125
        repo, client = self.setup_fake_client_and_repository(transport_path)
2303
2126
        client.add_success_response('ok', 'a token')
2304
 
        token = repo.lock_write().repository_token
 
2127
        result = repo.lock_write()
2305
2128
        self.assertEqual(
2306
2129
            [('call', 'Repository.lock_write', ('quack/', ''))],
2307
2130
            client._calls)
2308
 
        self.assertEqual('a token', token)
 
2131
        self.assertEqual('a token', result)
2309
2132
 
2310
2133
    def test_lock_write_already_locked(self):
2311
2134
        transport_path = 'quack'
2390
2213
        self.assertEqual([], client._calls)
2391
2214
 
2392
2215
 
2393
 
class TestRepositoryInsertStreamBase(TestRemoteRepository):
2394
 
    """Base class for Repository.insert_stream and .insert_stream_1.19
2395
 
    tests.
2396
 
    """
2397
 
    
2398
 
    def checkInsertEmptyStream(self, repo, client):
2399
 
        """Insert an empty stream, checking the result.
2400
 
 
2401
 
        This checks that there are no resume_tokens or missing_keys, and that
2402
 
        the client is finished.
2403
 
        """
2404
 
        sink = repo._get_sink()
2405
 
        fmt = repository.RepositoryFormat.get_default_format()
2406
 
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2407
 
        self.assertEqual([], resume_tokens)
2408
 
        self.assertEqual(set(), missing_keys)
2409
 
        self.assertFinished(client)
2410
 
 
2411
 
 
2412
 
class TestRepositoryInsertStream(TestRepositoryInsertStreamBase):
2413
 
    """Tests for using Repository.insert_stream verb when the _1.19 variant is
 
2216
class TestRepositoryInsertStream(TestRemoteRepository):
 
2217
    """Tests for using Repository.insert_stream verb when the _1.18 variant is
2414
2218
    not available.
2415
2219
 
2416
 
    This test case is very similar to TestRepositoryInsertStream_1_19.
 
2220
    This test case is very similar to TestRepositoryInsertStream_1_18.
2417
2221
    """
2418
2222
 
2419
2223
    def setUp(self):
2420
2224
        TestRemoteRepository.setUp(self)
2421
 
        self.disable_verb('Repository.insert_stream_1.19')
 
2225
        self.disable_verb('Repository.insert_stream_1.18')
2422
2226
 
2423
2227
    def test_unlocked_repo(self):
2424
2228
        transport_path = 'quack'
2425
2229
        repo, client = self.setup_fake_client_and_repository(transport_path)
2426
2230
        client.add_expected_call(
2427
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2428
 
            'unknown', ('Repository.insert_stream_1.19',))
2429
 
        client.add_expected_call(
2430
 
            'Repository.insert_stream', ('quack/', ''),
2431
 
            'success', ('ok',))
2432
 
        client.add_expected_call(
2433
 
            'Repository.insert_stream', ('quack/', ''),
2434
 
            'success', ('ok',))
2435
 
        self.checkInsertEmptyStream(repo, client)
 
2231
            'Repository.insert_stream_1.18', ('quack/', ''),
 
2232
            'unknown', ('Repository.insert_stream_1.18',))
 
2233
        client.add_expected_call(
 
2234
            'Repository.insert_stream', ('quack/', ''),
 
2235
            'success', ('ok',))
 
2236
        client.add_expected_call(
 
2237
            'Repository.insert_stream', ('quack/', ''),
 
2238
            'success', ('ok',))
 
2239
        sink = repo._get_sink()
 
2240
        fmt = repository.RepositoryFormat.get_default_format()
 
2241
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2242
        self.assertEqual([], resume_tokens)
 
2243
        self.assertEqual(set(), missing_keys)
 
2244
        self.assertFinished(client)
2436
2245
 
2437
2246
    def test_locked_repo_with_no_lock_token(self):
2438
2247
        transport_path = 'quack'
2441
2250
            'Repository.lock_write', ('quack/', ''),
2442
2251
            'success', ('ok', ''))
2443
2252
        client.add_expected_call(
2444
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2445
 
            'unknown', ('Repository.insert_stream_1.19',))
 
2253
            'Repository.insert_stream_1.18', ('quack/', ''),
 
2254
            'unknown', ('Repository.insert_stream_1.18',))
2446
2255
        client.add_expected_call(
2447
2256
            'Repository.insert_stream', ('quack/', ''),
2448
2257
            'success', ('ok',))
2450
2259
            'Repository.insert_stream', ('quack/', ''),
2451
2260
            'success', ('ok',))
2452
2261
        repo.lock_write()
2453
 
        self.checkInsertEmptyStream(repo, client)
 
2262
        sink = repo._get_sink()
 
2263
        fmt = repository.RepositoryFormat.get_default_format()
 
2264
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2265
        self.assertEqual([], resume_tokens)
 
2266
        self.assertEqual(set(), missing_keys)
 
2267
        self.assertFinished(client)
2454
2268
 
2455
2269
    def test_locked_repo_with_lock_token(self):
2456
2270
        transport_path = 'quack'
2459
2273
            'Repository.lock_write', ('quack/', ''),
2460
2274
            'success', ('ok', 'a token'))
2461
2275
        client.add_expected_call(
2462
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2463
 
            'unknown', ('Repository.insert_stream_1.19',))
 
2276
            'Repository.insert_stream_1.18', ('quack/', '', 'a token'),
 
2277
            'unknown', ('Repository.insert_stream_1.18',))
2464
2278
        client.add_expected_call(
2465
2279
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2466
2280
            'success', ('ok',))
2468
2282
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2469
2283
            'success', ('ok',))
2470
2284
        repo.lock_write()
2471
 
        self.checkInsertEmptyStream(repo, client)
 
2285
        sink = repo._get_sink()
 
2286
        fmt = repository.RepositoryFormat.get_default_format()
 
2287
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2288
        self.assertEqual([], resume_tokens)
 
2289
        self.assertEqual(set(), missing_keys)
 
2290
        self.assertFinished(client)
2472
2291
 
2473
2292
    def test_stream_with_inventory_deltas(self):
2474
2293
        """'inventory-deltas' substreams cannot be sent to the
2479
2298
        transport_path = 'quack'
2480
2299
        repo, client = self.setup_fake_client_and_repository(transport_path)
2481
2300
        client.add_expected_call(
2482
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2483
 
            'unknown', ('Repository.insert_stream_1.19',))
 
2301
            'Repository.insert_stream_1.18', ('quack/', ''),
 
2302
            'unknown', ('Repository.insert_stream_1.18',))
2484
2303
        client.add_expected_call(
2485
2304
            'Repository.insert_stream', ('quack/', ''),
2486
2305
            'success', ('ok',))
2502
2321
        class FakeRealRepository:
2503
2322
            def _get_sink(self):
2504
2323
                return fake_real_sink
2505
 
            def is_in_write_group(self):
2506
 
                return False
2507
 
            def refresh_data(self):
2508
 
                return True
2509
2324
        repo._real_repository = FakeRealRepository()
2510
2325
        sink = repo._get_sink()
2511
2326
        fmt = repository.RepositoryFormat.get_default_format()
2535
2350
        """
2536
2351
        # Define a stream using generators so that it isn't rewindable.
2537
2352
        inv = inventory.Inventory(revision_id='rev1')
2538
 
        inv.root.revision = 'rev1'
2539
2353
        def stream_with_inv_delta():
2540
2354
            yield ('inventories', inventories_substream())
2541
2355
            yield ('inventory-deltas', inventory_delta_substream())
2566
2380
        return stream_with_inv_delta()
2567
2381
 
2568
2382
 
2569
 
class TestRepositoryInsertStream_1_19(TestRepositoryInsertStreamBase):
 
2383
class TestRepositoryInsertStream_1_18(TestRemoteRepository):
2570
2384
 
2571
2385
    def test_unlocked_repo(self):
2572
2386
        transport_path = 'quack'
2573
2387
        repo, client = self.setup_fake_client_and_repository(transport_path)
2574
2388
        client.add_expected_call(
2575
 
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2389
            'Repository.insert_stream_1.18', ('quack/', ''),
2576
2390
            'success', ('ok',))
2577
2391
        client.add_expected_call(
2578
 
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2392
            'Repository.insert_stream_1.18', ('quack/', ''),
2579
2393
            'success', ('ok',))
2580
 
        self.checkInsertEmptyStream(repo, client)
 
2394
        sink = repo._get_sink()
 
2395
        fmt = repository.RepositoryFormat.get_default_format()
 
2396
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2397
        self.assertEqual([], resume_tokens)
 
2398
        self.assertEqual(set(), missing_keys)
 
2399
        self.assertFinished(client)
2581
2400
 
2582
2401
    def test_locked_repo_with_no_lock_token(self):
2583
2402
        transport_path = 'quack'
2586
2405
            'Repository.lock_write', ('quack/', ''),
2587
2406
            'success', ('ok', ''))
2588
2407
        client.add_expected_call(
2589
 
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2408
            'Repository.insert_stream_1.18', ('quack/', ''),
2590
2409
            'success', ('ok',))
2591
2410
        client.add_expected_call(
2592
 
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2411
            'Repository.insert_stream_1.18', ('quack/', ''),
2593
2412
            'success', ('ok',))
2594
2413
        repo.lock_write()
2595
 
        self.checkInsertEmptyStream(repo, client)
 
2414
        sink = repo._get_sink()
 
2415
        fmt = repository.RepositoryFormat.get_default_format()
 
2416
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2417
        self.assertEqual([], resume_tokens)
 
2418
        self.assertEqual(set(), missing_keys)
 
2419
        self.assertFinished(client)
2596
2420
 
2597
2421
    def test_locked_repo_with_lock_token(self):
2598
2422
        transport_path = 'quack'
2601
2425
            'Repository.lock_write', ('quack/', ''),
2602
2426
            'success', ('ok', 'a token'))
2603
2427
        client.add_expected_call(
2604
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
 
2428
            'Repository.insert_stream_1.18', ('quack/', '', 'a token'),
2605
2429
            'success', ('ok',))
2606
2430
        client.add_expected_call(
2607
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
 
2431
            'Repository.insert_stream_1.18', ('quack/', '', 'a token'),
2608
2432
            'success', ('ok',))
2609
2433
        repo.lock_write()
2610
 
        self.checkInsertEmptyStream(repo, client)
 
2434
        sink = repo._get_sink()
 
2435
        fmt = repository.RepositoryFormat.get_default_format()
 
2436
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2437
        self.assertEqual([], resume_tokens)
 
2438
        self.assertEqual(set(), missing_keys)
 
2439
        self.assertFinished(client)
2611
2440
 
2612
2441
 
2613
2442
class TestRepositoryTarball(TestRemoteRepository):
2649
2478
    """RemoteRepository.copy_content_into optimizations"""
2650
2479
 
2651
2480
    def test_copy_content_remote_to_local(self):
2652
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
2481
        self.transport_server = server.SmartTCPServer_for_testing
2653
2482
        src_repo = self.make_repository('repo1')
2654
2483
        src_repo = repository.Repository.open(self.get_url('repo1'))
2655
2484
        # At the moment the tarball-based copy_content_into can't write back
2803
2632
        expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
2804
2633
        self.assertEqual(expected_error, translated_error)
2805
2634
 
2806
 
    def test_nobranch_one_arg(self):
2807
 
        bzrdir = self.make_bzrdir('')
2808
 
        translated_error = self.translateTuple(
2809
 
            ('nobranch', 'extra detail'), bzrdir=bzrdir)
2810
 
        expected_error = errors.NotBranchError(
2811
 
            path=bzrdir.root_transport.base,
2812
 
            detail='extra detail')
2813
 
        self.assertEqual(expected_error, translated_error)
2814
 
 
2815
2635
    def test_LockContention(self):
2816
2636
        translated_error = self.translateTuple(('LockContention',))
2817
2637
        expected_error = errors.LockContention('(remote lock)')
2857
2677
        expected_error = errors.ReadError(path)
2858
2678
        self.assertEqual(expected_error, translated_error)
2859
2679
 
2860
 
    def test_IncompatibleRepositories(self):
2861
 
        translated_error = self.translateTuple(('IncompatibleRepositories',
2862
 
            "repo1", "repo2", "details here"))
2863
 
        expected_error = errors.IncompatibleRepositories("repo1", "repo2",
2864
 
            "details here")
2865
 
        self.assertEqual(expected_error, translated_error)
2866
 
 
2867
2680
    def test_PermissionDenied_no_args(self):
2868
2681
        path = 'a path'
2869
2682
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
2930
2743
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2931
2744
        # been muttered to the log file for developer to look at.
2932
2745
        self.assertContainsRe(
2933
 
            self.get_log(),
 
2746
            self._get_log(keep_log_file=True),
2934
2747
            "Missing key 'branch' in context")
2935
2748
 
2936
2749
    def test_path_missing(self):
2944
2757
        self.assertEqual(server_error, translated_error)
2945
2758
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2946
2759
        # been muttered to the log file for developer to look at.
2947
 
        self.assertContainsRe(self.get_log(), "Missing key 'path' in context")
 
2760
        self.assertContainsRe(
 
2761
            self._get_log(keep_log_file=True), "Missing key 'path' in context")
2948
2762
 
2949
2763
 
2950
2764
class TestStacking(tests.TestCaseWithTransport):
2968
2782
        stacked_branch = self.make_branch('stacked', format='1.9')
2969
2783
        stacked_branch.set_stacked_on_url('../base')
2970
2784
        # start a server looking at this
2971
 
        smart_server = test_server.SmartTCPServer_for_testing()
2972
 
        self.start_server(smart_server)
 
2785
        smart_server = server.SmartTCPServer_for_testing()
 
2786
        smart_server.setUp()
 
2787
        self.addCleanup(smart_server.tearDown)
2973
2788
        remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
2974
2789
        # can get its branch and repository
2975
2790
        remote_branch = remote_bzrdir.open_branch()
2997
2812
        tree1.commit('rev1', rev_id='rev1')
2998
2813
        tree2 = tree1.branch.bzrdir.sprout('tree2', stacked=True
2999
2814
            ).open_workingtree()
3000
 
        local_tree = tree2.branch.create_checkout('local')
3001
 
        local_tree.commit('local changes make me feel good.')
 
2815
        tree2.commit('local changes make me feel good.')
3002
2816
        branch2 = Branch.open(self.get_url('tree2'))
3003
2817
        branch2.lock_read()
3004
2818
        self.addCleanup(branch2.unlock)
3074
2888
            _, stacked = self.prepare_stacked_remote_branch()
3075
2889
            tree = stacked.bzrdir.sprout('tree3', stacked=True
3076
2890
                ).open_workingtree()
3077
 
            local_tree = tree.branch.create_checkout('local-tree3')
3078
 
            local_tree.commit('more local changes are better')
 
2891
            tree.commit('more local changes are better')
3079
2892
            branch = Branch.open(self.get_url('tree3'))
3080
2893
            branch.lock_read()
3081
 
            self.addCleanup(branch.unlock)
3082
2894
            return None, branch
3083
2895
        rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
3084
2896
            branch_factory=make_stacked_stacked)
3093
2905
        # stacked upon sources in topological order.
3094
2906
        rev_ord, expected_revs = self.get_ordered_revs('knit', 'topological')
3095
2907
        self.assertEqual(expected_revs, rev_ord)
3096
 
        # Getting topological sort requires VFS calls still - one of which is
3097
 
        # pushing up from the bound branch.
3098
 
        self.assertLength(13, self.hpss_calls)
 
2908
        # Getting topological sort requires VFS calls still
 
2909
        self.assertLength(12, self.hpss_calls)
3099
2910
 
3100
2911
    def test_stacked_get_stream_groupcompress(self):
3101
2912
        # Repository._get_source.get_stream() from a stacked repository with
3130
2941
        super(TestRemoteBranchEffort, self).setUp()
3131
2942
        # Create a smart server that publishes whatever the backing VFS server
3132
2943
        # does.
3133
 
        self.smart_server = test_server.SmartTCPServer_for_testing()
3134
 
        self.start_server(self.smart_server, self.get_server())
 
2944
        self.smart_server = server.SmartTCPServer_for_testing()
 
2945
        self.smart_server.setUp(self.get_server())
 
2946
        self.addCleanup(self.smart_server.tearDown)
3135
2947
        # Log all HPSS calls into self.hpss_calls.
3136
2948
        _SmartClient.hooks.install_named_hook(
3137
2949
            'call', self.capture_hpss_call, None)