← 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: Vincent Ladeuil
  • Date: 2010-01-25 15:55:48 UTC
  • mto: (4985.1.4 add-attr-cleanup)
  • mto: This revision was merged to the branch mainline in revision 4988.
  • Revision ID: v.ladeuil+lp@free.fr-20100125155548-0l352pujvt5bzl5e
Deploy addAttrCleanup on the whole test suite.

Several use case worth mentioning:

- setting a module or any other object attribute is the majority
by far. In some cases the setting itself is deferred but most of
the time we want to set at the same time we add the cleanup.

- there multiple occurrences of protecting hooks or ui factory
which are now useless (the test framework takes care of that now),

- there was some lambda uses that can now be avoided.

That first cleanup already simplifies things a lot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
27
27
from cStringIO import StringIO
28
28
 
29
29
from bzrlib import (
 
30
    branch,
30
31
    bzrdir,
31
32
    config,
32
33
    errors,
33
34
    graph,
 
35
    inventory,
 
36
    inventory_delta,
34
37
    pack,
35
38
    remote,
36
39
    repository,
37
 
    smart,
38
40
    tests,
39
41
    treebuilder,
40
42
    urlutils,
 
43
    versionedfile,
41
44
    )
42
45
from bzrlib.branch import Branch
43
46
from bzrlib.bzrdir import BzrDir, BzrDirFormat
58
61
    condition_isinstance,
59
62
    split_suite_by_condition,
60
63
    multiply_tests,
61
 
    KnownFailure,
62
64
    )
63
 
from bzrlib.transport import get_transport, http
 
65
from bzrlib.transport import get_transport
64
66
from bzrlib.transport.memory import MemoryTransport
65
67
from bzrlib.transport.remote import (
66
68
    RemoteTransport,
132
134
        b = BzrDir.open_from_transport(self.transport).open_branch()
133
135
        self.assertStartsWith(str(b), 'RemoteBranch(')
134
136
 
 
137
    def test_remote_bzrdir_repr(self):
 
138
        b = BzrDir.open_from_transport(self.transport)
 
139
        self.assertStartsWith(str(b), 'RemoteBzrDir(')
 
140
 
135
141
    def test_remote_branch_format_supports_stacking(self):
136
142
        t = self.transport
137
143
        self.make_branch('unstackable', format='pack-0.92')
277
283
        self.expecting_body = True
278
284
        return result[1], FakeProtocol(result[2], self)
279
285
 
 
286
    def call_with_body_bytes(self, method, args, body):
 
287
        self._check_call(method, args)
 
288
        self._calls.append(('call_with_body_bytes', method, args, body))
 
289
        result = self._get_next_response()
 
290
        return result[1], FakeProtocol(result[2], self)
 
291
 
280
292
    def call_with_body_bytes_expecting_body(self, method, args, body):
281
293
        self._check_call(method, args)
282
294
        self._calls.append(('call_with_body_bytes_expecting_body', method,
332
344
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
333
345
        return reference_bzrdir_format.repository_format
334
346
 
335
 
    def disable_verb(self, verb):
336
 
        """Disable a verb for one test."""
337
 
        request_handlers = smart.request.request_handlers
338
 
        orig_method = request_handlers.get(verb)
339
 
        request_handlers.remove(verb)
340
 
        def restoreVerb():
341
 
            request_handlers.register(verb, orig_method)
342
 
        self.addCleanup(restoreVerb)
343
 
 
344
347
    def assertFinished(self, fake_client):
345
348
        """Assert that all of a FakeClient's expected calls have occurred."""
346
349
        fake_client.finished_test()
441
444
            'BzrDir.cloning_metadir', ('quack/', 'False'),
442
445
            'error', ('BranchReference',)),
443
446
        client.add_expected_call(
444
 
            'BzrDir.open_branchV2', ('quack/',),
 
447
            'BzrDir.open_branchV3', ('quack/',),
445
448
            'success', ('ref', self.get_url('referenced'))),
446
449
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
447
450
            _client=client)
474
477
        self.assertFinished(client)
475
478
 
476
479
 
 
480
class TestBzrDirOpen(TestRemote):
 
481
 
 
482
    def make_fake_client_and_transport(self, path='quack'):
 
483
        transport = MemoryTransport()
 
484
        transport.mkdir(path)
 
485
        transport = transport.clone(path)
 
486
        client = FakeClient(transport.base)
 
487
        return client, transport
 
488
 
 
489
    def test_absent(self):
 
490
        client, transport = self.make_fake_client_and_transport()
 
491
        client.add_expected_call(
 
492
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
 
493
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
 
494
                remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
 
495
        self.assertFinished(client)
 
496
 
 
497
    def test_present_without_workingtree(self):
 
498
        client, transport = self.make_fake_client_and_transport()
 
499
        client.add_expected_call(
 
500
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
 
501
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
502
            _client=client, _force_probe=True)
 
503
        self.assertIsInstance(bd, RemoteBzrDir)
 
504
        self.assertFalse(bd.has_workingtree())
 
505
        self.assertRaises(errors.NoWorkingTree, bd.open_workingtree)
 
506
        self.assertFinished(client)
 
507
 
 
508
    def test_present_with_workingtree(self):
 
509
        client, transport = self.make_fake_client_and_transport()
 
510
        client.add_expected_call(
 
511
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
 
512
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
513
            _client=client, _force_probe=True)
 
514
        self.assertIsInstance(bd, RemoteBzrDir)
 
515
        self.assertTrue(bd.has_workingtree())
 
516
        self.assertRaises(errors.NotLocalUrl, bd.open_workingtree)
 
517
        self.assertFinished(client)
 
518
 
 
519
    def test_backwards_compat(self):
 
520
        client, transport = self.make_fake_client_and_transport()
 
521
        client.add_expected_call(
 
522
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
 
523
        client.add_expected_call(
 
524
            'BzrDir.open', ('quack/',), 'success', ('yes',))
 
525
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
526
            _client=client, _force_probe=True)
 
527
        self.assertIsInstance(bd, RemoteBzrDir)
 
528
        self.assertFinished(client)
 
529
 
 
530
 
477
531
class TestBzrDirOpenBranch(TestRemote):
478
532
 
479
533
    def test_backwards_compat(self):
481
535
        self.make_branch('.')
482
536
        a_dir = BzrDir.open(self.get_url('.'))
483
537
        self.reset_smart_call_log()
484
 
        verb = 'BzrDir.open_branchV2'
 
538
        verb = 'BzrDir.open_branchV3'
485
539
        self.disable_verb(verb)
486
540
        format = a_dir.open_branch()
487
541
        call_count = len([call for call in self.hpss_calls if
497
551
        transport = transport.clone('quack')
498
552
        client = FakeClient(transport.base)
499
553
        client.add_expected_call(
500
 
            'BzrDir.open_branchV2', ('quack/',),
 
554
            'BzrDir.open_branchV3', ('quack/',),
501
555
            'success', ('branch', branch_network_name))
502
556
        client.add_expected_call(
503
557
            'BzrDir.find_repositoryV3', ('quack/',),
522
576
            _client=client)
523
577
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
524
578
        self.assertEqual(
525
 
            [('call', 'BzrDir.open_branchV2', ('quack/',))],
 
579
            [('call', 'BzrDir.open_branchV3', ('quack/',))],
526
580
            client._calls)
527
581
 
528
582
    def test__get_tree_branch(self):
552
606
        network_name = reference_format.network_name()
553
607
        branch_network_name = self.get_branch_format().network_name()
554
608
        client.add_expected_call(
555
 
            'BzrDir.open_branchV2', ('~hello/',),
 
609
            'BzrDir.open_branchV3', ('~hello/',),
556
610
            'success', ('branch', branch_network_name))
557
611
        client.add_expected_call(
558
612
            'BzrDir.find_repositoryV3', ('~hello/',),
667
721
        network_name = reference_format.network_name()
668
722
        client.add_expected_call(
669
723
            'BzrDir.create_repository', ('quack/',
670
 
                'Bazaar pack repository format 1 (needs bzr 0.92)\n', 'False'),
671
 
            'success', ('ok', 'no', 'no', 'no', network_name))
 
724
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
 
725
                'False'),
 
726
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
672
727
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
673
728
            _client=client)
674
729
        repo = a_bzrdir.create_repository()
676
731
        self.assertIsInstance(repo, remote.RemoteRepository)
677
732
        # its format should have the settings from the response
678
733
        format = repo._format
679
 
        self.assertFalse(format.rich_root_data)
680
 
        self.assertFalse(format.supports_tree_reference)
681
 
        self.assertFalse(format.supports_external_lookups)
 
734
        self.assertTrue(format.rich_root_data)
 
735
        self.assertTrue(format.supports_tree_reference)
 
736
        self.assertTrue(format.supports_external_lookups)
682
737
        self.assertEqual(network_name, format.network_name())
683
738
 
684
739
 
688
743
        # fallback all the way to the first version.
689
744
        reference_format = self.get_repo_format()
690
745
        network_name = reference_format.network_name()
691
 
        client = FakeClient('bzr://example.com/')
 
746
        server_url = 'bzr://example.com/'
 
747
        self.permit_url(server_url)
 
748
        client = FakeClient(server_url)
692
749
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
693
750
        client.add_unknown_method_response('BzrDir.find_repositoryV2')
694
751
        client.add_success_response('ok', '', 'no', 'no')
700
757
            reference_format.get_format_string(), 'ok')
701
758
        # PackRepository wants to do a stat
702
759
        client.add_success_response('stat', '0', '65535')
703
 
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
 
760
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
704
761
            _client=client)
705
762
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
706
763
            _client=client)
720
777
        # fallback to find_repositoryV2
721
778
        reference_format = self.get_repo_format()
722
779
        network_name = reference_format.network_name()
723
 
        client = FakeClient('bzr://example.com/')
 
780
        server_url = 'bzr://example.com/'
 
781
        self.permit_url(server_url)
 
782
        client = FakeClient(server_url)
724
783
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
725
784
        client.add_success_response('ok', '', 'no', 'no', 'no')
726
785
        # A real repository instance will be created to determine the network
731
790
            reference_format.get_format_string(), 'ok')
732
791
        # PackRepository wants to do a stat
733
792
        client.add_success_response('stat', '0', '65535')
734
 
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
 
793
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
735
794
            _client=client)
736
795
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
737
796
            _client=client)
856
915
 
857
916
class RemoteBranchTestCase(RemoteBzrDirTestCase):
858
917
 
 
918
    def lock_remote_branch(self, branch):
 
919
        """Trick a RemoteBranch into thinking it is locked."""
 
920
        branch._lock_mode = 'w'
 
921
        branch._lock_count = 2
 
922
        branch._lock_token = 'branch token'
 
923
        branch._repo_lock_token = 'repo token'
 
924
        branch.repository._lock_mode = 'w'
 
925
        branch.repository._lock_count = 2
 
926
        branch.repository._lock_token = 'repo token'
 
927
 
859
928
    def make_remote_branch(self, transport, client):
860
929
        """Make a RemoteBranch using 'client' as its _SmartClient.
861
930
 
1000
1069
        self.assertEqual({}, result)
1001
1070
 
1002
1071
 
 
1072
class TestBranchSetTagsBytes(RemoteBranchTestCase):
 
1073
 
 
1074
    def test_trivial(self):
 
1075
        transport = MemoryTransport()
 
1076
        client = FakeClient(transport.base)
 
1077
        client.add_expected_call(
 
1078
            'Branch.get_stacked_on_url', ('quack/',),
 
1079
            'error', ('NotStacked',))
 
1080
        client.add_expected_call(
 
1081
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
 
1082
            'success', ('',))
 
1083
        transport.mkdir('quack')
 
1084
        transport = transport.clone('quack')
 
1085
        branch = self.make_remote_branch(transport, client)
 
1086
        self.lock_remote_branch(branch)
 
1087
        branch._set_tags_bytes('tags bytes')
 
1088
        self.assertFinished(client)
 
1089
        self.assertEqual('tags bytes', client._calls[-1][-1])
 
1090
 
 
1091
    def test_backwards_compatible(self):
 
1092
        transport = MemoryTransport()
 
1093
        client = FakeClient(transport.base)
 
1094
        client.add_expected_call(
 
1095
            'Branch.get_stacked_on_url', ('quack/',),
 
1096
            'error', ('NotStacked',))
 
1097
        client.add_expected_call(
 
1098
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
 
1099
            'unknown', ('Branch.set_tags_bytes',))
 
1100
        transport.mkdir('quack')
 
1101
        transport = transport.clone('quack')
 
1102
        branch = self.make_remote_branch(transport, client)
 
1103
        self.lock_remote_branch(branch)
 
1104
        class StubRealBranch(object):
 
1105
            def __init__(self):
 
1106
                self.calls = []
 
1107
            def _set_tags_bytes(self, bytes):
 
1108
                self.calls.append(('set_tags_bytes', bytes))
 
1109
        real_branch = StubRealBranch()
 
1110
        branch._real_branch = real_branch
 
1111
        branch._set_tags_bytes('tags bytes')
 
1112
        # Call a second time, to exercise the 'remote version already inferred'
 
1113
        # code path.
 
1114
        branch._set_tags_bytes('tags bytes')
 
1115
        self.assertFinished(client)
 
1116
        self.assertEqual(
 
1117
            [('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
 
1118
 
 
1119
 
1003
1120
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1004
1121
 
1005
1122
    def test_empty_branch(self):
1077
1194
        client = FakeClient(self.get_url())
1078
1195
        branch_network_name = self.get_branch_format().network_name()
1079
1196
        client.add_expected_call(
1080
 
            'BzrDir.open_branchV2', ('stacked/',),
 
1197
            'BzrDir.open_branchV3', ('stacked/',),
1081
1198
            'success', ('branch', branch_network_name))
1082
1199
        client.add_expected_call(
1083
1200
            'BzrDir.find_repositoryV3', ('stacked/',),
1113
1230
        client = FakeClient(self.get_url())
1114
1231
        branch_network_name = self.get_branch_format().network_name()
1115
1232
        client.add_expected_call(
1116
 
            'BzrDir.open_branchV2', ('stacked/',),
 
1233
            'BzrDir.open_branchV3', ('stacked/',),
1117
1234
            'success', ('branch', branch_network_name))
1118
1235
        client.add_expected_call(
1119
1236
            'BzrDir.find_repositoryV3', ('stacked/',),
1347
1464
            errors.NoSuchRevision, branch.set_last_revision_info, 123, 'revid')
1348
1465
        branch.unlock()
1349
1466
 
1350
 
    def lock_remote_branch(self, branch):
1351
 
        """Trick a RemoteBranch into thinking it is locked."""
1352
 
        branch._lock_mode = 'w'
1353
 
        branch._lock_count = 2
1354
 
        branch._lock_token = 'branch token'
1355
 
        branch._repo_lock_token = 'repo token'
1356
 
        branch.repository._lock_mode = 'w'
1357
 
        branch.repository._lock_count = 2
1358
 
        branch.repository._lock_token = 'repo token'
1359
 
 
1360
1467
    def test_backwards_compatibility(self):
1361
1468
        """If the server does not support the Branch.set_last_revision_info
1362
1469
        verb (which is new in 1.4), then the client falls back to VFS methods.
1678
1785
        return repo, client
1679
1786
 
1680
1787
 
 
1788
def remoted_description(format):
 
1789
    return 'Remote: ' + format.get_format_description()
 
1790
 
 
1791
 
 
1792
class TestBranchFormat(tests.TestCase):
 
1793
 
 
1794
    def test_get_format_description(self):
 
1795
        remote_format = RemoteBranchFormat()
 
1796
        real_format = branch.BranchFormat.get_default_format()
 
1797
        remote_format._network_name = real_format.network_name()
 
1798
        self.assertEqual(remoted_description(real_format),
 
1799
            remote_format.get_format_description())
 
1800
 
 
1801
 
1681
1802
class TestRepositoryFormat(TestRemoteRepository):
1682
1803
 
1683
1804
    def test_fast_delta(self):
1690
1811
        false_format._network_name = false_name
1691
1812
        self.assertEqual(False, false_format.fast_deltas)
1692
1813
 
 
1814
    def test_get_format_description(self):
 
1815
        remote_repo_format = RemoteRepositoryFormat()
 
1816
        real_format = repository.RepositoryFormat.get_default_format()
 
1817
        remote_repo_format._network_name = real_format.network_name()
 
1818
        self.assertEqual(remoted_description(real_format),
 
1819
            remote_repo_format.get_format_description())
 
1820
 
1693
1821
 
1694
1822
class TestRepositoryGatherStats(TestRemoteRepository):
1695
1823
 
1880
2008
        self.assertLength(1, self.hpss_calls)
1881
2009
 
1882
2010
    def disableExtraResults(self):
1883
 
        old_flag = SmartServerRepositoryGetParentMap.no_extra_results
 
2011
        self.addAttrCleanup(SmartServerRepositoryGetParentMap,
 
2012
                            'no_extra_results')
1884
2013
        SmartServerRepositoryGetParentMap.no_extra_results = True
1885
 
        def reset_values():
1886
 
            SmartServerRepositoryGetParentMap.no_extra_results = old_flag
1887
 
        self.addCleanup(reset_values)
1888
2014
 
1889
2015
    def test_null_cached_missing_and_stop_key(self):
1890
2016
        self.setup_smart_server_with_call_log()
1950
2076
    def test_allows_new_revisions(self):
1951
2077
        """get_parent_map's results can be updated by commit."""
1952
2078
        smart_server = server.SmartTCPServer_for_testing()
1953
 
        smart_server.setUp()
1954
 
        self.addCleanup(smart_server.tearDown)
 
2079
        self.start_server(smart_server)
1955
2080
        self.make_branch('branch')
1956
2081
        branch = Branch.open(smart_server.get_url() + '/branch')
1957
2082
        tree = branch.create_checkout('tree', lightweight=True)
2098
2223
            repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
2099
2224
        self.assertFinished(client)
2100
2225
 
 
2226
    def test_branch_fallback_locking(self):
 
2227
        """RemoteBranch.get_rev_id takes a read lock, and tries to call the
 
2228
        get_rev_id_for_revno verb.  If the verb is unknown the VFS fallback
 
2229
        will be invoked, which will fail if the repo is unlocked.
 
2230
        """
 
2231
        self.setup_smart_server_with_call_log()
 
2232
        tree = self.make_branch_and_memory_tree('.')
 
2233
        tree.lock_write()
 
2234
        rev1 = tree.commit('First')
 
2235
        rev2 = tree.commit('Second')
 
2236
        tree.unlock()
 
2237
        branch = tree.branch
 
2238
        self.assertFalse(branch.is_locked())
 
2239
        self.reset_smart_call_log()
 
2240
        verb = 'Repository.get_rev_id_for_revno'
 
2241
        self.disable_verb(verb)
 
2242
        self.assertEqual(rev1, branch.get_rev_id(1))
 
2243
        self.assertLength(1, [call for call in self.hpss_calls if
 
2244
                              call.call.method == verb])
 
2245
 
2101
2246
 
2102
2247
class TestRepositoryIsShared(TestRemoteRepository):
2103
2248
 
2219
2364
        self.assertEqual([], client._calls)
2220
2365
 
2221
2366
 
2222
 
class TestRepositoryInsertStream(TestRemoteRepository):
2223
 
 
2224
 
    def test_unlocked_repo(self):
2225
 
        transport_path = 'quack'
2226
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2227
 
        client.add_expected_call(
2228
 
            'Repository.insert_stream', ('quack/', ''),
2229
 
            'success', ('ok',))
2230
 
        client.add_expected_call(
2231
 
            'Repository.insert_stream', ('quack/', ''),
2232
 
            'success', ('ok',))
2233
 
        sink = repo._get_sink()
2234
 
        fmt = repository.RepositoryFormat.get_default_format()
2235
 
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2236
 
        self.assertEqual([], resume_tokens)
2237
 
        self.assertEqual(set(), missing_keys)
2238
 
        self.assertFinished(client)
2239
 
 
2240
 
    def test_locked_repo_with_no_lock_token(self):
2241
 
        transport_path = 'quack'
2242
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2243
 
        client.add_expected_call(
2244
 
            'Repository.lock_write', ('quack/', ''),
2245
 
            'success', ('ok', ''))
2246
 
        client.add_expected_call(
2247
 
            'Repository.insert_stream', ('quack/', ''),
2248
 
            'success', ('ok',))
2249
 
        client.add_expected_call(
2250
 
            'Repository.insert_stream', ('quack/', ''),
2251
 
            'success', ('ok',))
2252
 
        repo.lock_write()
2253
 
        sink = repo._get_sink()
2254
 
        fmt = repository.RepositoryFormat.get_default_format()
2255
 
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2256
 
        self.assertEqual([], resume_tokens)
2257
 
        self.assertEqual(set(), missing_keys)
2258
 
        self.assertFinished(client)
2259
 
 
2260
 
    def test_locked_repo_with_lock_token(self):
2261
 
        transport_path = 'quack'
2262
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2263
 
        client.add_expected_call(
2264
 
            'Repository.lock_write', ('quack/', ''),
2265
 
            'success', ('ok', 'a token'))
2266
 
        client.add_expected_call(
2267
 
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2268
 
            'success', ('ok',))
2269
 
        client.add_expected_call(
2270
 
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2271
 
            'success', ('ok',))
2272
 
        repo.lock_write()
2273
 
        sink = repo._get_sink()
2274
 
        fmt = repository.RepositoryFormat.get_default_format()
2275
 
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2276
 
        self.assertEqual([], resume_tokens)
2277
 
        self.assertEqual(set(), missing_keys)
2278
 
        self.assertFinished(client)
 
2367
class TestRepositoryInsertStreamBase(TestRemoteRepository):
 
2368
    """Base class for Repository.insert_stream and .insert_stream_1.19
 
2369
    tests.
 
2370
    """
 
2371
    
 
2372
    def checkInsertEmptyStream(self, repo, client):
 
2373
        """Insert an empty stream, checking the result.
 
2374
 
 
2375
        This checks that there are no resume_tokens or missing_keys, and that
 
2376
        the client is finished.
 
2377
        """
 
2378
        sink = repo._get_sink()
 
2379
        fmt = repository.RepositoryFormat.get_default_format()
 
2380
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
2381
        self.assertEqual([], resume_tokens)
 
2382
        self.assertEqual(set(), missing_keys)
 
2383
        self.assertFinished(client)
 
2384
 
 
2385
 
 
2386
class TestRepositoryInsertStream(TestRepositoryInsertStreamBase):
 
2387
    """Tests for using Repository.insert_stream verb when the _1.19 variant is
 
2388
    not available.
 
2389
 
 
2390
    This test case is very similar to TestRepositoryInsertStream_1_19.
 
2391
    """
 
2392
 
 
2393
    def setUp(self):
 
2394
        TestRemoteRepository.setUp(self)
 
2395
        self.disable_verb('Repository.insert_stream_1.19')
 
2396
 
 
2397
    def test_unlocked_repo(self):
 
2398
        transport_path = 'quack'
 
2399
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2400
        client.add_expected_call(
 
2401
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2402
            'unknown', ('Repository.insert_stream_1.19',))
 
2403
        client.add_expected_call(
 
2404
            'Repository.insert_stream', ('quack/', ''),
 
2405
            'success', ('ok',))
 
2406
        client.add_expected_call(
 
2407
            'Repository.insert_stream', ('quack/', ''),
 
2408
            'success', ('ok',))
 
2409
        self.checkInsertEmptyStream(repo, client)
 
2410
 
 
2411
    def test_locked_repo_with_no_lock_token(self):
 
2412
        transport_path = 'quack'
 
2413
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2414
        client.add_expected_call(
 
2415
            'Repository.lock_write', ('quack/', ''),
 
2416
            'success', ('ok', ''))
 
2417
        client.add_expected_call(
 
2418
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2419
            'unknown', ('Repository.insert_stream_1.19',))
 
2420
        client.add_expected_call(
 
2421
            'Repository.insert_stream', ('quack/', ''),
 
2422
            'success', ('ok',))
 
2423
        client.add_expected_call(
 
2424
            'Repository.insert_stream', ('quack/', ''),
 
2425
            'success', ('ok',))
 
2426
        repo.lock_write()
 
2427
        self.checkInsertEmptyStream(repo, client)
 
2428
 
 
2429
    def test_locked_repo_with_lock_token(self):
 
2430
        transport_path = 'quack'
 
2431
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2432
        client.add_expected_call(
 
2433
            'Repository.lock_write', ('quack/', ''),
 
2434
            'success', ('ok', 'a token'))
 
2435
        client.add_expected_call(
 
2436
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
 
2437
            'unknown', ('Repository.insert_stream_1.19',))
 
2438
        client.add_expected_call(
 
2439
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
 
2440
            'success', ('ok',))
 
2441
        client.add_expected_call(
 
2442
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
 
2443
            'success', ('ok',))
 
2444
        repo.lock_write()
 
2445
        self.checkInsertEmptyStream(repo, client)
 
2446
 
 
2447
    def test_stream_with_inventory_deltas(self):
 
2448
        """'inventory-deltas' substreams cannot be sent to the
 
2449
        Repository.insert_stream verb, because not all servers that implement
 
2450
        that verb will accept them.  So when one is encountered the RemoteSink
 
2451
        immediately stops using that verb and falls back to VFS insert_stream.
 
2452
        """
 
2453
        transport_path = 'quack'
 
2454
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2455
        client.add_expected_call(
 
2456
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2457
            'unknown', ('Repository.insert_stream_1.19',))
 
2458
        client.add_expected_call(
 
2459
            'Repository.insert_stream', ('quack/', ''),
 
2460
            'success', ('ok',))
 
2461
        client.add_expected_call(
 
2462
            'Repository.insert_stream', ('quack/', ''),
 
2463
            'success', ('ok',))
 
2464
        # Create a fake real repository for insert_stream to fall back on, so
 
2465
        # that we can directly see the records the RemoteSink passes to the
 
2466
        # real sink.
 
2467
        class FakeRealSink:
 
2468
            def __init__(self):
 
2469
                self.records = []
 
2470
            def insert_stream(self, stream, src_format, resume_tokens):
 
2471
                for substream_kind, substream in stream:
 
2472
                    self.records.append(
 
2473
                        (substream_kind, [record.key for record in substream]))
 
2474
                return ['fake tokens'], ['fake missing keys']
 
2475
        fake_real_sink = FakeRealSink()
 
2476
        class FakeRealRepository:
 
2477
            def _get_sink(self):
 
2478
                return fake_real_sink
 
2479
            def is_in_write_group(self):
 
2480
                return False
 
2481
            def refresh_data(self):
 
2482
                return True
 
2483
        repo._real_repository = FakeRealRepository()
 
2484
        sink = repo._get_sink()
 
2485
        fmt = repository.RepositoryFormat.get_default_format()
 
2486
        stream = self.make_stream_with_inv_deltas(fmt)
 
2487
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
 
2488
        # Every record from the first inventory delta should have been sent to
 
2489
        # the VFS sink.
 
2490
        expected_records = [
 
2491
            ('inventory-deltas', [('rev2',), ('rev3',)]),
 
2492
            ('texts', [('some-rev', 'some-file')])]
 
2493
        self.assertEqual(expected_records, fake_real_sink.records)
 
2494
        # The return values from the real sink's insert_stream are propagated
 
2495
        # back to the original caller.
 
2496
        self.assertEqual(['fake tokens'], resume_tokens)
 
2497
        self.assertEqual(['fake missing keys'], missing_keys)
 
2498
        self.assertFinished(client)
 
2499
 
 
2500
    def make_stream_with_inv_deltas(self, fmt):
 
2501
        """Make a simple stream with an inventory delta followed by more
 
2502
        records and more substreams to test that all records and substreams
 
2503
        from that point on are used.
 
2504
 
 
2505
        This sends, in order:
 
2506
           * inventories substream: rev1, rev2, rev3.  rev2 and rev3 are
 
2507
             inventory-deltas.
 
2508
           * texts substream: (some-rev, some-file)
 
2509
        """
 
2510
        # Define a stream using generators so that it isn't rewindable.
 
2511
        inv = inventory.Inventory(revision_id='rev1')
 
2512
        inv.root.revision = 'rev1'
 
2513
        def stream_with_inv_delta():
 
2514
            yield ('inventories', inventories_substream())
 
2515
            yield ('inventory-deltas', inventory_delta_substream())
 
2516
            yield ('texts', [
 
2517
                versionedfile.FulltextContentFactory(
 
2518
                    ('some-rev', 'some-file'), (), None, 'content')])
 
2519
        def inventories_substream():
 
2520
            # An empty inventory fulltext.  This will be streamed normally.
 
2521
            text = fmt._serializer.write_inventory_to_string(inv)
 
2522
            yield versionedfile.FulltextContentFactory(
 
2523
                ('rev1',), (), None, text)
 
2524
        def inventory_delta_substream():
 
2525
            # An inventory delta.  This can't be streamed via this verb, so it
 
2526
            # will trigger a fallback to VFS insert_stream.
 
2527
            entry = inv.make_entry(
 
2528
                'directory', 'newdir', inv.root.file_id, 'newdir-id')
 
2529
            entry.revision = 'ghost'
 
2530
            delta = [(None, 'newdir', 'newdir-id', entry)]
 
2531
            serializer = inventory_delta.InventoryDeltaSerializer(
 
2532
                versioned_root=True, tree_references=False)
 
2533
            lines = serializer.delta_to_lines('rev1', 'rev2', delta)
 
2534
            yield versionedfile.ChunkedContentFactory(
 
2535
                ('rev2',), (('rev1',)), None, lines)
 
2536
            # Another delta.
 
2537
            lines = serializer.delta_to_lines('rev1', 'rev3', delta)
 
2538
            yield versionedfile.ChunkedContentFactory(
 
2539
                ('rev3',), (('rev1',)), None, lines)
 
2540
        return stream_with_inv_delta()
 
2541
 
 
2542
 
 
2543
class TestRepositoryInsertStream_1_19(TestRepositoryInsertStreamBase):
 
2544
 
 
2545
    def test_unlocked_repo(self):
 
2546
        transport_path = 'quack'
 
2547
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2548
        client.add_expected_call(
 
2549
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2550
            'success', ('ok',))
 
2551
        client.add_expected_call(
 
2552
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2553
            'success', ('ok',))
 
2554
        self.checkInsertEmptyStream(repo, client)
 
2555
 
 
2556
    def test_locked_repo_with_no_lock_token(self):
 
2557
        transport_path = 'quack'
 
2558
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2559
        client.add_expected_call(
 
2560
            'Repository.lock_write', ('quack/', ''),
 
2561
            'success', ('ok', ''))
 
2562
        client.add_expected_call(
 
2563
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2564
            'success', ('ok',))
 
2565
        client.add_expected_call(
 
2566
            'Repository.insert_stream_1.19', ('quack/', ''),
 
2567
            'success', ('ok',))
 
2568
        repo.lock_write()
 
2569
        self.checkInsertEmptyStream(repo, client)
 
2570
 
 
2571
    def test_locked_repo_with_lock_token(self):
 
2572
        transport_path = 'quack'
 
2573
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2574
        client.add_expected_call(
 
2575
            'Repository.lock_write', ('quack/', ''),
 
2576
            'success', ('ok', 'a token'))
 
2577
        client.add_expected_call(
 
2578
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
 
2579
            'success', ('ok',))
 
2580
        client.add_expected_call(
 
2581
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
 
2582
            'success', ('ok',))
 
2583
        repo.lock_write()
 
2584
        self.checkInsertEmptyStream(repo, client)
2279
2585
 
2280
2586
 
2281
2587
class TestRepositoryTarball(TestRemoteRepository):
2471
2777
        expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
2472
2778
        self.assertEqual(expected_error, translated_error)
2473
2779
 
 
2780
    def test_nobranch_one_arg(self):
 
2781
        bzrdir = self.make_bzrdir('')
 
2782
        translated_error = self.translateTuple(
 
2783
            ('nobranch', 'extra detail'), bzrdir=bzrdir)
 
2784
        expected_error = errors.NotBranchError(
 
2785
            path=bzrdir.root_transport.base,
 
2786
            detail='extra detail')
 
2787
        self.assertEqual(expected_error, translated_error)
 
2788
 
2474
2789
    def test_LockContention(self):
2475
2790
        translated_error = self.translateTuple(('LockContention',))
2476
2791
        expected_error = errors.LockContention('(remote lock)')
2516
2831
        expected_error = errors.ReadError(path)
2517
2832
        self.assertEqual(expected_error, translated_error)
2518
2833
 
 
2834
    def test_IncompatibleRepositories(self):
 
2835
        translated_error = self.translateTuple(('IncompatibleRepositories',
 
2836
            "repo1", "repo2", "details here"))
 
2837
        expected_error = errors.IncompatibleRepositories("repo1", "repo2",
 
2838
            "details here")
 
2839
        self.assertEqual(expected_error, translated_error)
 
2840
 
2519
2841
    def test_PermissionDenied_no_args(self):
2520
2842
        path = 'a path'
2521
2843
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
2582
2904
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2583
2905
        # been muttered to the log file for developer to look at.
2584
2906
        self.assertContainsRe(
2585
 
            self._get_log(keep_log_file=True),
 
2907
            self.get_log(),
2586
2908
            "Missing key 'branch' in context")
2587
2909
 
2588
2910
    def test_path_missing(self):
2596
2918
        self.assertEqual(server_error, translated_error)
2597
2919
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2598
2920
        # been muttered to the log file for developer to look at.
2599
 
        self.assertContainsRe(
2600
 
            self._get_log(keep_log_file=True), "Missing key 'path' in context")
 
2921
        self.assertContainsRe(self.get_log(), "Missing key 'path' in context")
2601
2922
 
2602
2923
 
2603
2924
class TestStacking(tests.TestCaseWithTransport):
2622
2943
        stacked_branch.set_stacked_on_url('../base')
2623
2944
        # start a server looking at this
2624
2945
        smart_server = server.SmartTCPServer_for_testing()
2625
 
        smart_server.setUp()
2626
 
        self.addCleanup(smart_server.tearDown)
 
2946
        self.start_server(smart_server)
2627
2947
        remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
2628
2948
        # can get its branch and repository
2629
2949
        remote_branch = remote_bzrdir.open_branch()
2651
2971
        tree1.commit('rev1', rev_id='rev1')
2652
2972
        tree2 = tree1.branch.bzrdir.sprout('tree2', stacked=True
2653
2973
            ).open_workingtree()
2654
 
        tree2.commit('local changes make me feel good.')
 
2974
        local_tree = tree2.branch.create_checkout('local')
 
2975
        local_tree.commit('local changes make me feel good.')
2655
2976
        branch2 = Branch.open(self.get_url('tree2'))
2656
2977
        branch2.lock_read()
2657
2978
        self.addCleanup(branch2.unlock)
2679
3000
                    result.append(content.key[-1])
2680
3001
        return result
2681
3002
 
2682
 
    def get_ordered_revs(self, format, order):
 
3003
    def get_ordered_revs(self, format, order, branch_factory=None):
2683
3004
        """Get a list of the revisions in a stream to format format.
2684
3005
 
2685
3006
        :param format: The format of the target.
2686
3007
        :param order: the order that target should have requested.
 
3008
        :param branch_factory: A callable to create a trunk and stacked branch
 
3009
            to fetch from. If none, self.prepare_stacked_remote_branch is used.
2687
3010
        :result: The revision ids in the stream, in the order seen,
2688
3011
            the topological order of revisions in the source.
2689
3012
        """
2691
3014
        target_repository_format = unordered_format.repository_format
2692
3015
        # Cross check
2693
3016
        self.assertEqual(order, target_repository_format._fetch_order)
2694
 
        trunk, stacked = self.prepare_stacked_remote_branch()
 
3017
        if branch_factory is None:
 
3018
            branch_factory = self.prepare_stacked_remote_branch
 
3019
        _, stacked = branch_factory()
2695
3020
        source = stacked.repository._get_source(target_repository_format)
2696
3021
        tip = stacked.last_revision()
2697
3022
        revs = stacked.repository.get_ancestry(tip)
2716
3041
        # from the server, then one from the backing branch.
2717
3042
        self.assertLength(2, self.hpss_calls)
2718
3043
 
 
3044
    def test_stacked_on_stacked_get_stream_unordered(self):
 
3045
        # Repository._get_source.get_stream() from a stacked repository which
 
3046
        # is itself stacked yields the full data from all three sources.
 
3047
        def make_stacked_stacked():
 
3048
            _, stacked = self.prepare_stacked_remote_branch()
 
3049
            tree = stacked.bzrdir.sprout('tree3', stacked=True
 
3050
                ).open_workingtree()
 
3051
            local_tree = tree.branch.create_checkout('local-tree3')
 
3052
            local_tree.commit('more local changes are better')
 
3053
            branch = Branch.open(self.get_url('tree3'))
 
3054
            branch.lock_read()
 
3055
            self.addCleanup(branch.unlock)
 
3056
            return None, branch
 
3057
        rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
 
3058
            branch_factory=make_stacked_stacked)
 
3059
        self.assertEqual(set(expected_revs), set(rev_ord))
 
3060
        # Getting unordered results should have made a streaming data request
 
3061
        # from the server, and one from each backing repo
 
3062
        self.assertLength(3, self.hpss_calls)
 
3063
 
2719
3064
    def test_stacked_get_stream_topological(self):
2720
3065
        # Repository._get_source.get_stream() from a stacked repository with
2721
3066
        # topological sorting yields the full data from both stacked and
2722
3067
        # stacked upon sources in topological order.
2723
3068
        rev_ord, expected_revs = self.get_ordered_revs('knit', 'topological')
2724
3069
        self.assertEqual(expected_revs, rev_ord)
2725
 
        # Getting topological sort requires VFS calls still
2726
 
        self.assertLength(12, self.hpss_calls)
 
3070
        # Getting topological sort requires VFS calls still - one of which is
 
3071
        # pushing up from the bound branch.
 
3072
        self.assertLength(13, self.hpss_calls)
2727
3073
 
2728
3074
    def test_stacked_get_stream_groupcompress(self):
2729
3075
        # Repository._get_source.get_stream() from a stacked repository with
2759
3105
        # Create a smart server that publishes whatever the backing VFS server
2760
3106
        # does.
2761
3107
        self.smart_server = server.SmartTCPServer_for_testing()
2762
 
        self.smart_server.setUp(self.get_server())
2763
 
        self.addCleanup(self.smart_server.tearDown)
 
3108
        self.start_server(self.smart_server, self.get_server())
2764
3109
        # Log all HPSS calls into self.hpss_calls.
2765
3110
        _SmartClient.hooks.install_named_hook(
2766
3111
            'call', self.capture_hpss_call, None)