/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: Canonical.com Patch Queue Manager
  • Date: 2009-03-24 05:12:24 UTC
  • mfrom: (4189.1.1 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090324051224-rneg6bkbzjyd85rl
(mbp) merge update to FSF address

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,
34
33
    graph,
35
 
    inventory,
36
 
    inventory_delta,
37
34
    pack,
38
35
    remote,
39
36
    repository,
 
37
    smart,
40
38
    tests,
41
 
    treebuilder,
42
39
    urlutils,
43
 
    versionedfile,
44
40
    )
45
41
from bzrlib.branch import Branch
46
42
from bzrlib.bzrdir import BzrDir, BzrDirFormat
52
48
    RemoteRepository,
53
49
    RemoteRepositoryFormat,
54
50
    )
55
 
from bzrlib.repofmt import groupcompress_repo, pack_repo
 
51
from bzrlib.repofmt import pack_repo
56
52
from bzrlib.revision import NULL_REVISION
57
 
from bzrlib.smart import medium
 
53
from bzrlib.smart import server, medium
58
54
from bzrlib.smart.client import _SmartClient
59
 
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
60
55
from bzrlib.tests import (
61
56
    condition_isinstance,
62
57
    split_suite_by_condition,
63
58
    multiply_tests,
64
 
    test_server,
65
59
    )
66
 
from bzrlib.transport import get_transport
 
60
from bzrlib.transport import get_transport, http
67
61
from bzrlib.transport.memory import MemoryTransport
68
62
from bzrlib.transport.remote import (
69
63
    RemoteTransport,
76
70
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
77
71
    smart_server_version_scenarios = [
78
72
        ('HPSS-v2',
79
 
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
 
73
            {'transport_server': server.SmartTCPServer_for_testing_v2_only}),
80
74
        ('HPSS-v3',
81
 
         {'transport_server': test_server.SmartTCPServer_for_testing})]
 
75
            {'transport_server': server.SmartTCPServer_for_testing})]
82
76
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
83
77
 
84
78
 
135
129
        b = BzrDir.open_from_transport(self.transport).open_branch()
136
130
        self.assertStartsWith(str(b), 'RemoteBranch(')
137
131
 
138
 
    def test_remote_bzrdir_repr(self):
139
 
        b = BzrDir.open_from_transport(self.transport)
140
 
        self.assertStartsWith(str(b), 'RemoteBzrDir(')
141
 
 
142
132
    def test_remote_branch_format_supports_stacking(self):
143
133
        t = self.transport
144
134
        self.make_branch('unstackable', format='pack-0.92')
161
151
        r = BzrDir.open_from_transport(t.clone('stackable')).open_repository()
162
152
        self.assertTrue(r._format.supports_external_lookups)
163
153
 
164
 
    def test_remote_branch_set_append_revisions_only(self):
165
 
        # Make a format 1.9 branch, which supports append_revisions_only
166
 
        branch = self.make_branch('branch', format='1.9')
167
 
        config = branch.get_config()
168
 
        branch.set_append_revisions_only(True)
169
 
        self.assertEqual(
170
 
            'True', config.get_user_option('append_revisions_only'))
171
 
        branch.set_append_revisions_only(False)
172
 
        self.assertEqual(
173
 
            'False', config.get_user_option('append_revisions_only'))
174
 
 
175
 
    def test_remote_branch_set_append_revisions_only_upgrade_reqd(self):
176
 
        branch = self.make_branch('branch', format='knit')
177
 
        config = branch.get_config()
178
 
        self.assertRaises(
179
 
            errors.UpgradeRequired, branch.set_append_revisions_only, True)
180
 
 
181
154
 
182
155
class FakeProtocol(object):
183
156
    """Lookalike SmartClientRequestProtocolOne allowing body reading tests."""
284
257
        self.expecting_body = True
285
258
        return result[1], FakeProtocol(result[2], self)
286
259
 
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
260
    def call_with_body_bytes_expecting_body(self, method, args, body):
294
261
        self._check_call(method, args)
295
262
        self._calls.append(('call_with_body_bytes_expecting_body', method,
345
312
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
346
313
        return reference_bzrdir_format.repository_format
347
314
 
348
 
    def assertFinished(self, fake_client):
349
 
        """Assert that all of a FakeClient's expected calls have occurred."""
350
 
        fake_client.finished_test()
 
315
    def disable_verb(self, verb):
 
316
        """Disable a verb for one test."""
 
317
        request_handlers = smart.request.request_handlers
 
318
        orig_method = request_handlers.get(verb)
 
319
        request_handlers.remove(verb)
 
320
        def restoreVerb():
 
321
            request_handlers.register(verb, orig_method)
 
322
        self.addCleanup(restoreVerb)
351
323
 
352
324
 
353
325
class Test_ClientMedium_remote_path_from_transport(tests.TestCase):
418
390
        # Calling _remember_remote_is_before again with a lower value works.
419
391
        client_medium._remember_remote_is_before((1, 5))
420
392
        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)))
 
393
        # You cannot call _remember_remote_is_before with a larger value.
 
394
        self.assertRaises(
 
395
            AssertionError, client_medium._remember_remote_is_before, (1, 9))
427
396
 
428
397
 
429
398
class TestBzrDirCloningMetaDir(TestRemote):
439
408
            call.call.method == verb])
440
409
        self.assertEqual(1, call_count)
441
410
 
442
 
    def test_branch_reference(self):
443
 
        transport = self.get_transport('quack')
444
 
        referenced = self.make_branch('referenced')
445
 
        expected = referenced.bzrdir.cloning_metadir()
446
 
        client = FakeClient(transport.base)
447
 
        client.add_expected_call(
448
 
            'BzrDir.cloning_metadir', ('quack/', 'False'),
449
 
            'error', ('BranchReference',)),
450
 
        client.add_expected_call(
451
 
            'BzrDir.open_branchV3', ('quack/',),
452
 
            'success', ('ref', self.get_url('referenced'))),
453
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
454
 
            _client=client)
455
 
        result = a_bzrdir.cloning_metadir()
456
 
        # We should have got a control dir matching the referenced branch.
457
 
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
458
 
        self.assertEqual(expected._repository_format, result._repository_format)
459
 
        self.assertEqual(expected._branch_format, result._branch_format)
460
 
        self.assertFinished(client)
461
 
 
462
411
    def test_current_server(self):
463
412
        transport = self.get_transport('.')
464
413
        transport = transport.clone('quack')
478
427
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
479
428
        self.assertEqual(None, result._repository_format)
480
429
        self.assertEqual(None, result._branch_format)
481
 
        self.assertFinished(client)
482
 
 
483
 
 
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)
 
430
        client.finished_test()
555
431
 
556
432
 
557
433
class TestBzrDirOpenBranch(TestRemote):
561
437
        self.make_branch('.')
562
438
        a_dir = BzrDir.open(self.get_url('.'))
563
439
        self.reset_smart_call_log()
564
 
        verb = 'BzrDir.open_branchV3'
 
440
        verb = 'BzrDir.open_branchV2'
565
441
        self.disable_verb(verb)
566
442
        format = a_dir.open_branch()
567
443
        call_count = len([call for call in self.hpss_calls if
577
453
        transport = transport.clone('quack')
578
454
        client = FakeClient(transport.base)
579
455
        client.add_expected_call(
580
 
            'BzrDir.open_branchV3', ('quack/',),
 
456
            'BzrDir.open_branchV2', ('quack/',),
581
457
            'success', ('branch', branch_network_name))
582
458
        client.add_expected_call(
583
459
            'BzrDir.find_repositoryV3', ('quack/',),
590
466
        result = bzrdir.open_branch()
591
467
        self.assertIsInstance(result, RemoteBranch)
592
468
        self.assertEqual(bzrdir, result.bzrdir)
593
 
        self.assertFinished(client)
 
469
        client.finished_test()
594
470
 
595
471
    def test_branch_missing(self):
596
472
        transport = MemoryTransport()
602
478
            _client=client)
603
479
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
604
480
        self.assertEqual(
605
 
            [('call', 'BzrDir.open_branchV3', ('quack/',))],
 
481
            [('call', 'BzrDir.open_branchV2', ('quack/',))],
606
482
            client._calls)
607
483
 
608
484
    def test__get_tree_branch(self):
632
508
        network_name = reference_format.network_name()
633
509
        branch_network_name = self.get_branch_format().network_name()
634
510
        client.add_expected_call(
635
 
            'BzrDir.open_branchV3', ('~hello/',),
 
511
            'BzrDir.open_branchV2', ('~hello/',),
636
512
            'success', ('branch', branch_network_name))
637
513
        client.add_expected_call(
638
514
            'BzrDir.find_repositoryV3', ('~hello/',),
643
519
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
644
520
            _client=client)
645
521
        result = bzrdir.open_branch()
646
 
        self.assertFinished(client)
 
522
        client.finished_test()
647
523
 
648
524
    def check_open_repository(self, rich_root, subtrees, external_lookup='no'):
649
525
        reference_format = self.get_repo_format()
747
623
        network_name = reference_format.network_name()
748
624
        client.add_expected_call(
749
625
            '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))
 
626
                'Bazaar pack repository format 1 (needs bzr 0.92)\n', 'False'),
 
627
            'success', ('ok', 'no', 'no', 'no', network_name))
753
628
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
754
629
            _client=client)
755
630
        repo = a_bzrdir.create_repository()
757
632
        self.assertIsInstance(repo, remote.RemoteRepository)
758
633
        # its format should have the settings from the response
759
634
        format = repo._format
760
 
        self.assertTrue(format.rich_root_data)
761
 
        self.assertTrue(format.supports_tree_reference)
762
 
        self.assertTrue(format.supports_external_lookups)
 
635
        self.assertFalse(format.rich_root_data)
 
636
        self.assertFalse(format.supports_tree_reference)
 
637
        self.assertFalse(format.supports_external_lookups)
763
638
        self.assertEqual(network_name, format.network_name())
764
639
 
765
640
 
769
644
        # fallback all the way to the first version.
770
645
        reference_format = self.get_repo_format()
771
646
        network_name = reference_format.network_name()
772
 
        server_url = 'bzr://example.com/'
773
 
        self.permit_url(server_url)
774
 
        client = FakeClient(server_url)
 
647
        client = FakeClient('bzr://example.com/')
775
648
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
776
649
        client.add_unknown_method_response('BzrDir.find_repositoryV2')
777
650
        client.add_success_response('ok', '', 'no', 'no')
783
656
            reference_format.get_format_string(), 'ok')
784
657
        # PackRepository wants to do a stat
785
658
        client.add_success_response('stat', '0', '65535')
786
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
659
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
787
660
            _client=client)
788
661
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
789
662
            _client=client)
803
676
        # fallback to find_repositoryV2
804
677
        reference_format = self.get_repo_format()
805
678
        network_name = reference_format.network_name()
806
 
        server_url = 'bzr://example.com/'
807
 
        self.permit_url(server_url)
808
 
        client = FakeClient(server_url)
 
679
        client = FakeClient('bzr://example.com/')
809
680
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
810
681
        client.add_success_response('ok', '', 'no', 'no', 'no')
811
682
        # A real repository instance will be created to determine the network
816
687
            reference_format.get_format_string(), 'ok')
817
688
        # PackRepository wants to do a stat
818
689
        client.add_success_response('stat', '0', '65535')
819
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
690
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
820
691
            _client=client)
821
692
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
822
693
            _client=client)
848
719
        self.assertEqual(network_name, repo._format.network_name())
849
720
 
850
721
 
851
 
class TestBzrDirFormatInitializeEx(TestRemote):
852
 
 
853
 
    def test_success(self):
854
 
        """Simple test for typical successful call."""
855
 
        fmt = bzrdir.RemoteBzrDirFormat()
856
 
        default_format_name = BzrDirFormat.get_default_format().network_name()
857
 
        transport = self.get_transport()
858
 
        client = FakeClient(transport.base)
859
 
        client.add_expected_call(
860
 
            'BzrDirFormat.initialize_ex_1.16',
861
 
                (default_format_name, 'path', 'False', 'False', 'False', '',
862
 
                 '', '', '', 'False'),
863
 
            'success',
864
 
                ('.', 'no', 'no', 'yes', 'repo fmt', 'repo bzrdir fmt',
865
 
                 'bzrdir fmt', 'False', '', '', 'repo lock token'))
866
 
        # XXX: It would be better to call fmt.initialize_on_transport_ex, but
867
 
        # it's currently hard to test that without supplying a real remote
868
 
        # transport connected to a real server.
869
 
        result = fmt._initialize_on_transport_ex_rpc(client, 'path',
870
 
            transport, False, False, False, None, None, None, None, False)
871
 
        self.assertFinished(client)
872
 
 
873
 
    def test_error(self):
874
 
        """Error responses are translated, e.g. 'PermissionDenied' raises the
875
 
        corresponding error from the client.
876
 
        """
877
 
        fmt = bzrdir.RemoteBzrDirFormat()
878
 
        default_format_name = BzrDirFormat.get_default_format().network_name()
879
 
        transport = self.get_transport()
880
 
        client = FakeClient(transport.base)
881
 
        client.add_expected_call(
882
 
            'BzrDirFormat.initialize_ex_1.16',
883
 
                (default_format_name, 'path', 'False', 'False', 'False', '',
884
 
                 '', '', '', 'False'),
885
 
            'error',
886
 
                ('PermissionDenied', 'path', 'extra info'))
887
 
        # XXX: It would be better to call fmt.initialize_on_transport_ex, but
888
 
        # it's currently hard to test that without supplying a real remote
889
 
        # transport connected to a real server.
890
 
        err = self.assertRaises(errors.PermissionDenied,
891
 
            fmt._initialize_on_transport_ex_rpc, client, 'path', transport,
892
 
            False, False, False, None, None, None, None, False)
893
 
        self.assertEqual('path', err.path)
894
 
        self.assertEqual(': extra info', err.extra)
895
 
        self.assertFinished(client)
896
 
 
897
 
    def test_error_from_real_server(self):
898
 
        """Integration test for error translation."""
899
 
        transport = self.make_smart_server('foo')
900
 
        transport = transport.clone('no-such-path')
901
 
        fmt = bzrdir.RemoteBzrDirFormat()
902
 
        err = self.assertRaises(errors.NoSuchFile,
903
 
            fmt.initialize_on_transport_ex, transport, create_prefix=False)
904
 
 
905
 
 
906
722
class OldSmartClient(object):
907
723
    """A fake smart client for test_old_version that just returns a version one
908
724
    response to the 'hello' (query version) command.
931
747
        return OldSmartClient()
932
748
 
933
749
 
934
 
class RemoteBzrDirTestCase(TestRemote):
935
 
 
936
 
    def make_remote_bzrdir(self, transport, client):
937
 
        """Make a RemotebzrDir using 'client' as the _client."""
938
 
        return RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
939
 
            _client=client)
940
 
 
941
 
 
942
 
class RemoteBranchTestCase(RemoteBzrDirTestCase):
943
 
 
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'
 
750
class RemoteBranchTestCase(TestRemote):
953
751
 
954
752
    def make_remote_branch(self, transport, client):
955
753
        """Make a RemoteBranch using 'client' as its _SmartClient.
960
758
        # we do not want bzrdir to make any remote calls, so use False as its
961
759
        # _client.  If it tries to make a remote call, this will fail
962
760
        # immediately.
963
 
        bzrdir = self.make_remote_bzrdir(transport, False)
 
761
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
762
            _client=False)
964
763
        repo = RemoteRepository(bzrdir, None, _client=client)
965
764
        branch_format = self.get_branch_format()
966
765
        format = RemoteBranchFormat(network_name=branch_format.network_name())
983
782
        transport = transport.clone('quack')
984
783
        branch = self.make_remote_branch(transport, client)
985
784
        result = branch.get_parent()
986
 
        self.assertFinished(client)
 
785
        client.finished_test()
987
786
        self.assertEqual(None, result)
988
787
 
989
788
    def test_parent_relative(self):
1015
814
        branch = self.make_remote_branch(transport, client)
1016
815
        result = branch.get_parent()
1017
816
        self.assertEqual('http://foo/', result)
1018
 
        self.assertFinished(client)
1019
 
 
1020
 
 
1021
 
class TestBranchSetParentLocation(RemoteBranchTestCase):
1022
 
 
1023
 
    def test_no_parent(self):
1024
 
        # We call the verb when setting parent to None
1025
 
        transport = MemoryTransport()
1026
 
        client = FakeClient(transport.base)
1027
 
        client.add_expected_call(
1028
 
            'Branch.get_stacked_on_url', ('quack/',),
1029
 
            'error', ('NotStacked',))
1030
 
        client.add_expected_call(
1031
 
            'Branch.set_parent_location', ('quack/', 'b', 'r', ''),
1032
 
            'success', ())
1033
 
        transport.mkdir('quack')
1034
 
        transport = transport.clone('quack')
1035
 
        branch = self.make_remote_branch(transport, client)
1036
 
        branch._lock_token = 'b'
1037
 
        branch._repo_lock_token = 'r'
1038
 
        branch._set_parent_location(None)
1039
 
        self.assertFinished(client)
1040
 
 
1041
 
    def test_parent(self):
1042
 
        transport = MemoryTransport()
1043
 
        client = FakeClient(transport.base)
1044
 
        client.add_expected_call(
1045
 
            'Branch.get_stacked_on_url', ('kwaak/',),
1046
 
            'error', ('NotStacked',))
1047
 
        client.add_expected_call(
1048
 
            'Branch.set_parent_location', ('kwaak/', 'b', 'r', 'foo'),
1049
 
            'success', ())
1050
 
        transport.mkdir('kwaak')
1051
 
        transport = transport.clone('kwaak')
1052
 
        branch = self.make_remote_branch(transport, client)
1053
 
        branch._lock_token = 'b'
1054
 
        branch._repo_lock_token = 'r'
1055
 
        branch._set_parent_location('foo')
1056
 
        self.assertFinished(client)
1057
 
 
1058
 
    def test_backwards_compat(self):
1059
 
        self.setup_smart_server_with_call_log()
1060
 
        branch = self.make_branch('.')
1061
 
        self.reset_smart_call_log()
1062
 
        verb = 'Branch.set_parent_location'
1063
 
        self.disable_verb(verb)
1064
 
        branch.set_parent('http://foo/')
1065
 
        self.assertLength(12, self.hpss_calls)
1066
817
 
1067
818
 
1068
819
class TestBranchGetTagsBytes(RemoteBranchTestCase):
1091
842
        transport = transport.clone('quack')
1092
843
        branch = self.make_remote_branch(transport, client)
1093
844
        result = branch.tags.get_tag_dict()
1094
 
        self.assertFinished(client)
 
845
        client.finished_test()
1095
846
        self.assertEqual({}, result)
1096
847
 
1097
848
 
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
849
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1147
850
 
1148
851
    def test_empty_branch(self):
1159
862
        transport = transport.clone('quack')
1160
863
        branch = self.make_remote_branch(transport, client)
1161
864
        result = branch.last_revision_info()
1162
 
        self.assertFinished(client)
 
865
        client.finished_test()
1163
866
        self.assertEqual((0, NULL_REVISION), result)
1164
867
 
1165
868
    def test_non_empty_branch(self):
1220
923
        client = FakeClient(self.get_url())
1221
924
        branch_network_name = self.get_branch_format().network_name()
1222
925
        client.add_expected_call(
1223
 
            'BzrDir.open_branchV3', ('stacked/',),
 
926
            'BzrDir.open_branchV2', ('stacked/',),
1224
927
            'success', ('branch', branch_network_name))
1225
928
        client.add_expected_call(
1226
929
            'BzrDir.find_repositoryV3', ('stacked/',),
1240
943
        branch = bzrdir.open_branch()
1241
944
        result = branch.get_stacked_on_url()
1242
945
        self.assertEqual('../base', result)
1243
 
        self.assertFinished(client)
 
946
        client.finished_test()
1244
947
        # it's in the fallback list both for the RemoteRepository and its vfs
1245
948
        # repository
1246
949
        self.assertEqual(1, len(branch.repository._fallback_repositories))
1248
951
            len(branch.repository._real_repository._fallback_repositories))
1249
952
 
1250
953
    def test_get_stacked_on_real_branch(self):
1251
 
        base_branch = self.make_branch('base')
1252
 
        stacked_branch = self.make_branch('stacked')
 
954
        base_branch = self.make_branch('base', format='1.6')
 
955
        stacked_branch = self.make_branch('stacked', format='1.6')
1253
956
        stacked_branch.set_stacked_on_url('../base')
1254
957
        reference_format = self.get_repo_format()
1255
958
        network_name = reference_format.network_name()
1256
959
        client = FakeClient(self.get_url())
1257
960
        branch_network_name = self.get_branch_format().network_name()
1258
961
        client.add_expected_call(
1259
 
            'BzrDir.open_branchV3', ('stacked/',),
 
962
            'BzrDir.open_branchV2', ('stacked/',),
1260
963
            'success', ('branch', branch_network_name))
1261
964
        client.add_expected_call(
1262
965
            'BzrDir.find_repositoryV3', ('stacked/',),
1263
 
            'success', ('ok', '', 'yes', 'no', 'yes', network_name))
 
966
            'success', ('ok', '', 'no', 'no', 'yes', network_name))
1264
967
        # called twice, once from constructor and then again by us
1265
968
        client.add_expected_call(
1266
969
            'Branch.get_stacked_on_url', ('stacked/',),
1273
976
        branch = bzrdir.open_branch()
1274
977
        result = branch.get_stacked_on_url()
1275
978
        self.assertEqual('../base', result)
1276
 
        self.assertFinished(client)
1277
 
        # it's in the fallback list both for the RemoteRepository.
 
979
        client.finished_test()
 
980
        # it's in the fallback list both for the RemoteRepository and its vfs
 
981
        # repository
1278
982
        self.assertEqual(1, len(branch.repository._fallback_repositories))
1279
 
        # And we haven't had to construct a real repository.
1280
 
        self.assertEqual(None, branch.repository._real_repository)
 
983
        self.assertEqual(1,
 
984
            len(branch.repository._real_repository._fallback_repositories))
1281
985
 
1282
986
 
1283
987
class TestBranchSetLastRevision(RemoteBranchTestCase):
1314
1018
        result = branch.set_revision_history([])
1315
1019
        branch.unlock()
1316
1020
        self.assertEqual(None, result)
1317
 
        self.assertFinished(client)
 
1021
        client.finished_test()
1318
1022
 
1319
1023
    def test_set_nonempty(self):
1320
1024
        # set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
1352
1056
        result = branch.set_revision_history(['rev-id1', 'rev-id2'])
1353
1057
        branch.unlock()
1354
1058
        self.assertEqual(None, result)
1355
 
        self.assertFinished(client)
 
1059
        client.finished_test()
1356
1060
 
1357
1061
    def test_no_such_revision(self):
1358
1062
        transport = MemoryTransport()
1387
1091
        self.assertRaises(
1388
1092
            errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
1389
1093
        branch.unlock()
1390
 
        self.assertFinished(client)
 
1094
        client.finished_test()
1391
1095
 
1392
1096
    def test_tip_change_rejected(self):
1393
1097
        """TipChangeRejected responses cause a TipChangeRejected exception to
1430
1134
        self.assertIsInstance(err.msg, unicode)
1431
1135
        self.assertEqual(rejection_msg_unicode, err.msg)
1432
1136
        branch.unlock()
1433
 
        self.assertFinished(client)
 
1137
        client.finished_test()
1434
1138
 
1435
1139
 
1436
1140
class TestBranchSetLastRevisionInfo(RemoteBranchTestCase):
1490
1194
            errors.NoSuchRevision, branch.set_last_revision_info, 123, 'revid')
1491
1195
        branch.unlock()
1492
1196
 
 
1197
    def lock_remote_branch(self, branch):
 
1198
        """Trick a RemoteBranch into thinking it is locked."""
 
1199
        branch._lock_mode = 'w'
 
1200
        branch._lock_count = 2
 
1201
        branch._lock_token = 'branch token'
 
1202
        branch._repo_lock_token = 'repo token'
 
1203
        branch.repository._lock_mode = 'w'
 
1204
        branch.repository._lock_count = 2
 
1205
        branch.repository._lock_token = 'repo token'
 
1206
 
1493
1207
    def test_backwards_compatibility(self):
1494
1208
        """If the server does not support the Branch.set_last_revision_info
1495
1209
        verb (which is new in 1.4), then the client falls back to VFS methods.
1536
1250
        self.assertEqual(
1537
1251
            [('set_last_revision_info', 1234, 'a-revision-id')],
1538
1252
            real_branch.calls)
1539
 
        self.assertFinished(client)
 
1253
        client.finished_test()
1540
1254
 
1541
1255
    def test_unexpected_error(self):
1542
1256
        # If the server sends an error the client doesn't understand, it gets
1597
1311
        self.assertEqual('rejection message', err.msg)
1598
1312
 
1599
1313
 
1600
 
class TestBranchGetSetConfig(RemoteBranchTestCase):
 
1314
class TestBranchControlGetBranchConf(tests.TestCaseWithMemoryTransport):
 
1315
    """Getting the branch configuration should use an abstract method not vfs.
 
1316
    """
1601
1317
 
1602
1318
    def test_get_branch_conf(self):
1603
 
        # in an empty branch we decode the response properly
1604
 
        client = FakeClient()
1605
 
        client.add_expected_call(
1606
 
            'Branch.get_stacked_on_url', ('memory:///',),
1607
 
            'error', ('NotStacked',),)
1608
 
        client.add_success_response_with_body('# config file body', 'ok')
1609
 
        transport = MemoryTransport()
1610
 
        branch = self.make_remote_branch(transport, client)
1611
 
        config = branch.get_config()
1612
 
        config.has_explicit_nickname()
1613
 
        self.assertEqual(
1614
 
            [('call', 'Branch.get_stacked_on_url', ('memory:///',)),
1615
 
             ('call_expecting_body', 'Branch.get_config_file', ('memory:///',))],
1616
 
            client._calls)
1617
 
 
1618
 
    def test_get_multi_line_branch_conf(self):
1619
 
        # Make sure that multiple-line branch.conf files are supported
1620
 
        #
1621
 
        # https://bugs.edge.launchpad.net/bzr/+bug/354075
1622
 
        client = FakeClient()
1623
 
        client.add_expected_call(
1624
 
            'Branch.get_stacked_on_url', ('memory:///',),
1625
 
            'error', ('NotStacked',),)
1626
 
        client.add_success_response_with_body('a = 1\nb = 2\nc = 3\n', 'ok')
1627
 
        transport = MemoryTransport()
1628
 
        branch = self.make_remote_branch(transport, client)
1629
 
        config = branch.get_config()
1630
 
        self.assertEqual(u'2', config.get_user_option('b'))
1631
 
 
1632
 
    def test_set_option(self):
1633
 
        client = FakeClient()
1634
 
        client.add_expected_call(
1635
 
            'Branch.get_stacked_on_url', ('memory:///',),
1636
 
            'error', ('NotStacked',),)
1637
 
        client.add_expected_call(
1638
 
            'Branch.lock_write', ('memory:///', '', ''),
1639
 
            'success', ('ok', 'branch token', 'repo token'))
1640
 
        client.add_expected_call(
1641
 
            'Branch.set_config_option', ('memory:///', 'branch token',
1642
 
            'repo token', 'foo', 'bar', ''),
1643
 
            'success', ())
1644
 
        client.add_expected_call(
1645
 
            'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
1646
 
            'success', ('ok',))
1647
 
        transport = MemoryTransport()
1648
 
        branch = self.make_remote_branch(transport, client)
1649
 
        branch.lock_write()
1650
 
        config = branch._get_config()
1651
 
        config.set_option('foo', 'bar')
1652
 
        branch.unlock()
1653
 
        self.assertFinished(client)
1654
 
 
1655
 
    def test_backwards_compat_set_option(self):
1656
 
        self.setup_smart_server_with_call_log()
1657
 
        branch = self.make_branch('.')
1658
 
        verb = 'Branch.set_config_option'
1659
 
        self.disable_verb(verb)
1660
 
        branch.lock_write()
1661
 
        self.addCleanup(branch.unlock)
1662
 
        self.reset_smart_call_log()
1663
 
        branch._get_config().set_option('value', 'name')
1664
 
        self.assertLength(10, self.hpss_calls)
1665
 
        self.assertEqual('value', branch._get_config().get_option('name'))
 
1319
        raise tests.KnownFailure('branch.conf is not retrieved by get_config_file')
 
1320
        ## # We should see that branch.get_config() does a single rpc to get the
 
1321
        ## # remote configuration file, abstracting away where that is stored on
 
1322
        ## # the server.  However at the moment it always falls back to using the
 
1323
        ## # vfs, and this would need some changes in config.py.
 
1324
 
 
1325
        ## # in an empty branch we decode the response properly
 
1326
        ## client = FakeClient([(('ok', ), '# config file body')], self.get_url())
 
1327
        ## # we need to make a real branch because the remote_branch.control_files
 
1328
        ## # will trigger _ensure_real.
 
1329
        ## branch = self.make_branch('quack')
 
1330
        ## transport = branch.bzrdir.root_transport
 
1331
        ## # we do not want bzrdir to make any remote calls
 
1332
        ## bzrdir = RemoteBzrDir(transport, _client=False)
 
1333
        ## branch = RemoteBranch(bzrdir, None, _client=client)
 
1334
        ## config = branch.get_config()
 
1335
        ## self.assertEqual(
 
1336
        ##     [('call_expecting_body', 'Branch.get_config_file', ('quack/',))],
 
1337
        ##     client._calls)
1666
1338
 
1667
1339
 
1668
1340
class TestBranchLockWrite(RemoteBranchTestCase):
1680
1352
        transport = transport.clone('quack')
1681
1353
        branch = self.make_remote_branch(transport, client)
1682
1354
        self.assertRaises(errors.UnlockableTransport, branch.lock_write)
1683
 
        self.assertFinished(client)
1684
 
 
1685
 
 
1686
 
class TestBzrDirGetSetConfig(RemoteBzrDirTestCase):
1687
 
 
1688
 
    def test__get_config(self):
1689
 
        client = FakeClient()
1690
 
        client.add_success_response_with_body('default_stack_on = /\n', 'ok')
1691
 
        transport = MemoryTransport()
1692
 
        bzrdir = self.make_remote_bzrdir(transport, client)
1693
 
        config = bzrdir.get_config()
1694
 
        self.assertEqual('/', config.get_default_stack_on())
1695
 
        self.assertEqual(
1696
 
            [('call_expecting_body', 'BzrDir.get_config_file', ('memory:///',))],
1697
 
            client._calls)
1698
 
 
1699
 
    def test_set_option_uses_vfs(self):
1700
 
        self.setup_smart_server_with_call_log()
1701
 
        bzrdir = self.make_bzrdir('.')
1702
 
        self.reset_smart_call_log()
1703
 
        config = bzrdir.get_config()
1704
 
        config.set_default_stack_on('/')
1705
 
        self.assertLength(3, self.hpss_calls)
1706
 
 
1707
 
    def test_backwards_compat_get_option(self):
1708
 
        self.setup_smart_server_with_call_log()
1709
 
        bzrdir = self.make_bzrdir('.')
1710
 
        verb = 'BzrDir.get_config_file'
1711
 
        self.disable_verb(verb)
1712
 
        self.reset_smart_call_log()
1713
 
        self.assertEqual(None,
1714
 
            bzrdir._get_config().get_option('default_stack_on'))
1715
 
        self.assertLength(3, self.hpss_calls)
 
1355
        client.finished_test()
1716
1356
 
1717
1357
 
1718
1358
class TestTransportIsReadonly(tests.TestCase):
1811
1451
        return repo, client
1812
1452
 
1813
1453
 
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
1454
class TestRepositoryFormat(TestRemoteRepository):
1829
1455
 
1830
1456
    def test_fast_delta(self):
1831
 
        true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
 
1457
        true_name = pack_repo.RepositoryFormatPackDevelopment2().network_name()
1832
1458
        true_format = RemoteRepositoryFormat()
1833
1459
        true_format._network_name = true_name
1834
1460
        self.assertEqual(True, true_format.fast_deltas)
1837
1463
        false_format._network_name = false_name
1838
1464
        self.assertEqual(False, false_format.fast_deltas)
1839
1465
 
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
1466
 
1848
1467
class TestRepositoryGatherStats(TestRemoteRepository):
1849
1468
 
1938
1557
        self.assertEqual({r1: (NULL_REVISION,)}, parents)
1939
1558
        self.assertEqual(
1940
1559
            [('call_with_body_bytes_expecting_body',
1941
 
              'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
1942
 
              '\n\n0')],
 
1560
              'Repository.get_parent_map', ('quack/', r2), '\n\n0')],
1943
1561
            client._calls)
1944
1562
        repo.unlock()
1945
1563
        # now we call again, and it should use the second response.
1949
1567
        self.assertEqual({r1: (NULL_REVISION,)}, parents)
1950
1568
        self.assertEqual(
1951
1569
            [('call_with_body_bytes_expecting_body',
1952
 
              'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
1953
 
              '\n\n0'),
 
1570
              'Repository.get_parent_map', ('quack/', r2), '\n\n0'),
1954
1571
             ('call_with_body_bytes_expecting_body',
1955
 
              'Repository.get_parent_map', ('quack/', 'include-missing:', r1),
1956
 
              '\n\n0'),
 
1572
              'Repository.get_parent_map', ('quack/', r1), '\n\n0'),
1957
1573
            ],
1958
1574
            client._calls)
1959
1575
        repo.unlock()
1968
1584
        parents = repo.get_parent_map([rev_id])
1969
1585
        self.assertEqual(
1970
1586
            [('call_with_body_bytes_expecting_body',
1971
 
              'Repository.get_parent_map', ('quack/', 'include-missing:',
1972
 
              rev_id), '\n\n0'),
 
1587
              'Repository.get_parent_map', ('quack/', rev_id), '\n\n0'),
1973
1588
             ('disconnect medium',),
1974
1589
             ('call_expecting_body', 'Repository.get_revision_graph',
1975
1590
              ('quack/', ''))],
2008
1623
            errors.UnexpectedSmartServerResponse,
2009
1624
            repo.get_parent_map, ['a-revision-id'])
2010
1625
 
2011
 
    def test_get_parent_map_negative_caches_missing_keys(self):
2012
 
        self.setup_smart_server_with_call_log()
2013
 
        repo = self.make_repository('foo')
2014
 
        self.assertIsInstance(repo, RemoteRepository)
2015
 
        repo.lock_read()
2016
 
        self.addCleanup(repo.unlock)
2017
 
        self.reset_smart_call_log()
2018
 
        graph = repo.get_graph()
2019
 
        self.assertEqual({},
2020
 
            graph.get_parent_map(['some-missing', 'other-missing']))
2021
 
        self.assertLength(1, self.hpss_calls)
2022
 
        # No call if we repeat this
2023
 
        self.reset_smart_call_log()
2024
 
        graph = repo.get_graph()
2025
 
        self.assertEqual({},
2026
 
            graph.get_parent_map(['some-missing', 'other-missing']))
2027
 
        self.assertLength(0, self.hpss_calls)
2028
 
        # Asking for more unknown keys makes a request.
2029
 
        self.reset_smart_call_log()
2030
 
        graph = repo.get_graph()
2031
 
        self.assertEqual({},
2032
 
            graph.get_parent_map(['some-missing', 'other-missing',
2033
 
                'more-missing']))
2034
 
        self.assertLength(1, self.hpss_calls)
2035
 
 
2036
 
    def disableExtraResults(self):
2037
 
        self.overrideAttr(SmartServerRepositoryGetParentMap,
2038
 
                          'no_extra_results', True)
2039
 
 
2040
 
    def test_null_cached_missing_and_stop_key(self):
2041
 
        self.setup_smart_server_with_call_log()
2042
 
        # Make a branch with a single revision.
2043
 
        builder = self.make_branch_builder('foo')
2044
 
        builder.start_series()
2045
 
        builder.build_snapshot('first', None, [
2046
 
            ('add', ('', 'root-id', 'directory', ''))])
2047
 
        builder.finish_series()
2048
 
        branch = builder.get_branch()
2049
 
        repo = branch.repository
2050
 
        self.assertIsInstance(repo, RemoteRepository)
2051
 
        # Stop the server from sending extra results.
2052
 
        self.disableExtraResults()
2053
 
        repo.lock_read()
2054
 
        self.addCleanup(repo.unlock)
2055
 
        self.reset_smart_call_log()
2056
 
        graph = repo.get_graph()
2057
 
        # Query for 'first' and 'null:'.  Because 'null:' is a parent of
2058
 
        # 'first' it will be a candidate for the stop_keys of subsequent
2059
 
        # requests, and because 'null:' was queried but not returned it will be
2060
 
        # cached as missing.
2061
 
        self.assertEqual({'first': ('null:',)},
2062
 
            graph.get_parent_map(['first', 'null:']))
2063
 
        # Now query for another key.  This request will pass along a recipe of
2064
 
        # start and stop keys describing the already cached results, and this
2065
 
        # recipe's revision count must be correct (or else it will trigger an
2066
 
        # error from the server).
2067
 
        self.assertEqual({}, graph.get_parent_map(['another-key']))
2068
 
        # This assertion guards against disableExtraResults silently failing to
2069
 
        # work, thus invalidating the test.
2070
 
        self.assertLength(2, self.hpss_calls)
2071
 
 
2072
 
    def test_get_parent_map_gets_ghosts_from_result(self):
2073
 
        # asking for a revision should negatively cache close ghosts in its
2074
 
        # ancestry.
2075
 
        self.setup_smart_server_with_call_log()
2076
 
        tree = self.make_branch_and_memory_tree('foo')
2077
 
        tree.lock_write()
2078
 
        try:
2079
 
            builder = treebuilder.TreeBuilder()
2080
 
            builder.start_tree(tree)
2081
 
            builder.build([])
2082
 
            builder.finish_tree()
2083
 
            tree.set_parent_ids(['non-existant'], allow_leftmost_as_ghost=True)
2084
 
            rev_id = tree.commit('')
2085
 
        finally:
2086
 
            tree.unlock()
2087
 
        tree.lock_read()
2088
 
        self.addCleanup(tree.unlock)
2089
 
        repo = tree.branch.repository
2090
 
        self.assertIsInstance(repo, RemoteRepository)
2091
 
        # ask for rev_id
2092
 
        repo.get_parent_map([rev_id])
2093
 
        self.reset_smart_call_log()
2094
 
        # Now asking for rev_id's ghost parent should not make calls
2095
 
        self.assertEqual({}, repo.get_parent_map(['non-existant']))
2096
 
        self.assertLength(0, self.hpss_calls)
2097
 
 
2098
1626
 
2099
1627
class TestGetParentMapAllowsNew(tests.TestCaseWithTransport):
2100
1628
 
2101
1629
    def test_allows_new_revisions(self):
2102
1630
        """get_parent_map's results can be updated by commit."""
2103
 
        smart_server = test_server.SmartTCPServer_for_testing()
2104
 
        self.start_server(smart_server)
 
1631
        smart_server = server.SmartTCPServer_for_testing()
 
1632
        smart_server.setUp()
 
1633
        self.addCleanup(smart_server.tearDown)
2105
1634
        self.make_branch('branch')
2106
1635
        branch = Branch.open(smart_server.get_url() + '/branch')
2107
1636
        tree = branch.create_checkout('tree', lightweight=True)
2190
1719
        self.assertEqual(('AnUnexpectedError',), e.error_tuple)
2191
1720
 
2192
1721
 
2193
 
class TestRepositoryGetRevIdForRevno(TestRemoteRepository):
2194
 
 
2195
 
    def test_ok(self):
2196
 
        repo, client = self.setup_fake_client_and_repository('quack')
2197
 
        client.add_expected_call(
2198
 
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2199
 
            'success', ('ok', 'rev-five'))
2200
 
        result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
2201
 
        self.assertEqual((True, 'rev-five'), result)
2202
 
        self.assertFinished(client)
2203
 
 
2204
 
    def test_history_incomplete(self):
2205
 
        repo, client = self.setup_fake_client_and_repository('quack')
2206
 
        client.add_expected_call(
2207
 
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2208
 
            'success', ('history-incomplete', 10, 'rev-ten'))
2209
 
        result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
2210
 
        self.assertEqual((False, (10, 'rev-ten')), result)
2211
 
        self.assertFinished(client)
2212
 
 
2213
 
    def test_history_incomplete_with_fallback(self):
2214
 
        """A 'history-incomplete' response causes the fallback repository to be
2215
 
        queried too, if one is set.
2216
 
        """
2217
 
        # Make a repo with a fallback repo, both using a FakeClient.
2218
 
        format = remote.response_tuple_to_repo_format(
2219
 
            ('yes', 'no', 'yes', self.get_repo_format().network_name()))
2220
 
        repo, client = self.setup_fake_client_and_repository('quack')
2221
 
        repo._format = format
2222
 
        fallback_repo, ignored = self.setup_fake_client_and_repository(
2223
 
            'fallback')
2224
 
        fallback_repo._client = client
2225
 
        fallback_repo._format = format
2226
 
        repo.add_fallback_repository(fallback_repo)
2227
 
        # First the client should ask the primary repo
2228
 
        client.add_expected_call(
2229
 
            'Repository.get_rev_id_for_revno', ('quack/', 1, (42, 'rev-foo')),
2230
 
            'success', ('history-incomplete', 2, 'rev-two'))
2231
 
        # Then it should ask the fallback, using revno/revid from the
2232
 
        # history-incomplete response as the known revno/revid.
2233
 
        client.add_expected_call(
2234
 
            'Repository.get_rev_id_for_revno',('fallback/', 1, (2, 'rev-two')),
2235
 
            'success', ('ok', 'rev-one'))
2236
 
        result = repo.get_rev_id_for_revno(1, (42, 'rev-foo'))
2237
 
        self.assertEqual((True, 'rev-one'), result)
2238
 
        self.assertFinished(client)
2239
 
 
2240
 
    def test_nosuchrevision(self):
2241
 
        # 'nosuchrevision' is returned when the known-revid is not found in the
2242
 
        # remote repo.  The client translates that response to NoSuchRevision.
2243
 
        repo, client = self.setup_fake_client_and_repository('quack')
2244
 
        client.add_expected_call(
2245
 
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2246
 
            'error', ('nosuchrevision', 'rev-foo'))
2247
 
        self.assertRaises(
2248
 
            errors.NoSuchRevision,
2249
 
            repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
2250
 
        self.assertFinished(client)
2251
 
 
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
 
 
2273
1722
class TestRepositoryIsShared(TestRemoteRepository):
2274
1723
 
2275
1724
    def test_is_shared(self):
2390
1839
        self.assertEqual([], client._calls)
2391
1840
 
2392
1841
 
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
2414
 
    not available.
2415
 
 
2416
 
    This test case is very similar to TestRepositoryInsertStream_1_19.
2417
 
    """
2418
 
 
2419
 
    def setUp(self):
2420
 
        TestRemoteRepository.setUp(self)
2421
 
        self.disable_verb('Repository.insert_stream_1.19')
2422
 
 
2423
 
    def test_unlocked_repo(self):
2424
 
        transport_path = 'quack'
2425
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2426
 
        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)
2436
 
 
2437
 
    def test_locked_repo_with_no_lock_token(self):
2438
 
        transport_path = 'quack'
2439
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2440
 
        client.add_expected_call(
2441
 
            'Repository.lock_write', ('quack/', ''),
2442
 
            'success', ('ok', ''))
2443
 
        client.add_expected_call(
2444
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2445
 
            'unknown', ('Repository.insert_stream_1.19',))
2446
 
        client.add_expected_call(
2447
 
            'Repository.insert_stream', ('quack/', ''),
2448
 
            'success', ('ok',))
2449
 
        client.add_expected_call(
2450
 
            'Repository.insert_stream', ('quack/', ''),
2451
 
            'success', ('ok',))
2452
 
        repo.lock_write()
2453
 
        self.checkInsertEmptyStream(repo, client)
2454
 
 
2455
 
    def test_locked_repo_with_lock_token(self):
2456
 
        transport_path = 'quack'
2457
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2458
 
        client.add_expected_call(
2459
 
            'Repository.lock_write', ('quack/', ''),
2460
 
            'success', ('ok', 'a token'))
2461
 
        client.add_expected_call(
2462
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2463
 
            'unknown', ('Repository.insert_stream_1.19',))
2464
 
        client.add_expected_call(
2465
 
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2466
 
            'success', ('ok',))
2467
 
        client.add_expected_call(
2468
 
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2469
 
            'success', ('ok',))
2470
 
        repo.lock_write()
2471
 
        self.checkInsertEmptyStream(repo, client)
2472
 
 
2473
 
    def test_stream_with_inventory_deltas(self):
2474
 
        """'inventory-deltas' substreams cannot be sent to the
2475
 
        Repository.insert_stream verb, because not all servers that implement
2476
 
        that verb will accept them.  So when one is encountered the RemoteSink
2477
 
        immediately stops using that verb and falls back to VFS insert_stream.
2478
 
        """
2479
 
        transport_path = 'quack'
2480
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2481
 
        client.add_expected_call(
2482
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2483
 
            'unknown', ('Repository.insert_stream_1.19',))
2484
 
        client.add_expected_call(
2485
 
            'Repository.insert_stream', ('quack/', ''),
2486
 
            'success', ('ok',))
2487
 
        client.add_expected_call(
2488
 
            'Repository.insert_stream', ('quack/', ''),
2489
 
            'success', ('ok',))
2490
 
        # Create a fake real repository for insert_stream to fall back on, so
2491
 
        # that we can directly see the records the RemoteSink passes to the
2492
 
        # real sink.
2493
 
        class FakeRealSink:
2494
 
            def __init__(self):
2495
 
                self.records = []
2496
 
            def insert_stream(self, stream, src_format, resume_tokens):
2497
 
                for substream_kind, substream in stream:
2498
 
                    self.records.append(
2499
 
                        (substream_kind, [record.key for record in substream]))
2500
 
                return ['fake tokens'], ['fake missing keys']
2501
 
        fake_real_sink = FakeRealSink()
2502
 
        class FakeRealRepository:
2503
 
            def _get_sink(self):
2504
 
                return fake_real_sink
2505
 
            def is_in_write_group(self):
2506
 
                return False
2507
 
            def refresh_data(self):
2508
 
                return True
2509
 
        repo._real_repository = FakeRealRepository()
2510
 
        sink = repo._get_sink()
2511
 
        fmt = repository.RepositoryFormat.get_default_format()
2512
 
        stream = self.make_stream_with_inv_deltas(fmt)
2513
 
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2514
 
        # Every record from the first inventory delta should have been sent to
2515
 
        # the VFS sink.
2516
 
        expected_records = [
2517
 
            ('inventory-deltas', [('rev2',), ('rev3',)]),
2518
 
            ('texts', [('some-rev', 'some-file')])]
2519
 
        self.assertEqual(expected_records, fake_real_sink.records)
2520
 
        # The return values from the real sink's insert_stream are propagated
2521
 
        # back to the original caller.
2522
 
        self.assertEqual(['fake tokens'], resume_tokens)
2523
 
        self.assertEqual(['fake missing keys'], missing_keys)
2524
 
        self.assertFinished(client)
2525
 
 
2526
 
    def make_stream_with_inv_deltas(self, fmt):
2527
 
        """Make a simple stream with an inventory delta followed by more
2528
 
        records and more substreams to test that all records and substreams
2529
 
        from that point on are used.
2530
 
 
2531
 
        This sends, in order:
2532
 
           * inventories substream: rev1, rev2, rev3.  rev2 and rev3 are
2533
 
             inventory-deltas.
2534
 
           * texts substream: (some-rev, some-file)
2535
 
        """
2536
 
        # Define a stream using generators so that it isn't rewindable.
2537
 
        inv = inventory.Inventory(revision_id='rev1')
2538
 
        inv.root.revision = 'rev1'
2539
 
        def stream_with_inv_delta():
2540
 
            yield ('inventories', inventories_substream())
2541
 
            yield ('inventory-deltas', inventory_delta_substream())
2542
 
            yield ('texts', [
2543
 
                versionedfile.FulltextContentFactory(
2544
 
                    ('some-rev', 'some-file'), (), None, 'content')])
2545
 
        def inventories_substream():
2546
 
            # An empty inventory fulltext.  This will be streamed normally.
2547
 
            text = fmt._serializer.write_inventory_to_string(inv)
2548
 
            yield versionedfile.FulltextContentFactory(
2549
 
                ('rev1',), (), None, text)
2550
 
        def inventory_delta_substream():
2551
 
            # An inventory delta.  This can't be streamed via this verb, so it
2552
 
            # will trigger a fallback to VFS insert_stream.
2553
 
            entry = inv.make_entry(
2554
 
                'directory', 'newdir', inv.root.file_id, 'newdir-id')
2555
 
            entry.revision = 'ghost'
2556
 
            delta = [(None, 'newdir', 'newdir-id', entry)]
2557
 
            serializer = inventory_delta.InventoryDeltaSerializer(
2558
 
                versioned_root=True, tree_references=False)
2559
 
            lines = serializer.delta_to_lines('rev1', 'rev2', delta)
2560
 
            yield versionedfile.ChunkedContentFactory(
2561
 
                ('rev2',), (('rev1',)), None, lines)
2562
 
            # Another delta.
2563
 
            lines = serializer.delta_to_lines('rev1', 'rev3', delta)
2564
 
            yield versionedfile.ChunkedContentFactory(
2565
 
                ('rev3',), (('rev1',)), None, lines)
2566
 
        return stream_with_inv_delta()
2567
 
 
2568
 
 
2569
 
class TestRepositoryInsertStream_1_19(TestRepositoryInsertStreamBase):
2570
 
 
2571
 
    def test_unlocked_repo(self):
2572
 
        transport_path = 'quack'
2573
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2574
 
        client.add_expected_call(
2575
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2576
 
            'success', ('ok',))
2577
 
        client.add_expected_call(
2578
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2579
 
            'success', ('ok',))
2580
 
        self.checkInsertEmptyStream(repo, client)
2581
 
 
2582
 
    def test_locked_repo_with_no_lock_token(self):
2583
 
        transport_path = 'quack'
2584
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2585
 
        client.add_expected_call(
2586
 
            'Repository.lock_write', ('quack/', ''),
2587
 
            'success', ('ok', ''))
2588
 
        client.add_expected_call(
2589
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2590
 
            'success', ('ok',))
2591
 
        client.add_expected_call(
2592
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2593
 
            'success', ('ok',))
2594
 
        repo.lock_write()
2595
 
        self.checkInsertEmptyStream(repo, client)
2596
 
 
2597
 
    def test_locked_repo_with_lock_token(self):
2598
 
        transport_path = 'quack'
2599
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2600
 
        client.add_expected_call(
2601
 
            'Repository.lock_write', ('quack/', ''),
2602
 
            'success', ('ok', 'a token'))
2603
 
        client.add_expected_call(
2604
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2605
 
            'success', ('ok',))
2606
 
        client.add_expected_call(
2607
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2608
 
            'success', ('ok',))
2609
 
        repo.lock_write()
2610
 
        self.checkInsertEmptyStream(repo, client)
 
1842
class TestRepositoryInsertStream(TestRemoteRepository):
 
1843
 
 
1844
    def test_unlocked_repo(self):
 
1845
        transport_path = 'quack'
 
1846
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
1847
        client.add_expected_call(
 
1848
            'Repository.insert_stream', ('quack/', ''),
 
1849
            'success', ('ok',))
 
1850
        client.add_expected_call(
 
1851
            'Repository.insert_stream', ('quack/', ''),
 
1852
            'success', ('ok',))
 
1853
        sink = repo._get_sink()
 
1854
        fmt = repository.RepositoryFormat.get_default_format()
 
1855
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
1856
        self.assertEqual([], resume_tokens)
 
1857
        self.assertEqual(set(), missing_keys)
 
1858
        client.finished_test()
 
1859
 
 
1860
    def test_locked_repo_with_no_lock_token(self):
 
1861
        transport_path = 'quack'
 
1862
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
1863
        client.add_expected_call(
 
1864
            'Repository.lock_write', ('quack/', ''),
 
1865
            'success', ('ok', ''))
 
1866
        client.add_expected_call(
 
1867
            'Repository.insert_stream', ('quack/', ''),
 
1868
            'success', ('ok',))
 
1869
        client.add_expected_call(
 
1870
            'Repository.insert_stream', ('quack/', ''),
 
1871
            'success', ('ok',))
 
1872
        repo.lock_write()
 
1873
        sink = repo._get_sink()
 
1874
        fmt = repository.RepositoryFormat.get_default_format()
 
1875
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
1876
        self.assertEqual([], resume_tokens)
 
1877
        self.assertEqual(set(), missing_keys)
 
1878
        client.finished_test()
 
1879
 
 
1880
    def test_locked_repo_with_lock_token(self):
 
1881
        transport_path = 'quack'
 
1882
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
1883
        client.add_expected_call(
 
1884
            'Repository.lock_write', ('quack/', ''),
 
1885
            'success', ('ok', 'a token'))
 
1886
        client.add_expected_call(
 
1887
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
 
1888
            'success', ('ok',))
 
1889
        client.add_expected_call(
 
1890
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
 
1891
            'success', ('ok',))
 
1892
        repo.lock_write()
 
1893
        sink = repo._get_sink()
 
1894
        fmt = repository.RepositoryFormat.get_default_format()
 
1895
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
1896
        self.assertEqual([], resume_tokens)
 
1897
        self.assertEqual(set(), missing_keys)
 
1898
        client.finished_test()
2611
1899
 
2612
1900
 
2613
1901
class TestRepositoryTarball(TestRemoteRepository):
2649
1937
    """RemoteRepository.copy_content_into optimizations"""
2650
1938
 
2651
1939
    def test_copy_content_remote_to_local(self):
2652
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
1940
        self.transport_server = server.SmartTCPServer_for_testing
2653
1941
        src_repo = self.make_repository('repo1')
2654
1942
        src_repo = repository.Repository.open(self.get_url('repo1'))
2655
1943
        # At the moment the tarball-based copy_content_into can't write back
2698
1986
        client.add_expected_call(
2699
1987
            'PackRepository.autopack', ('quack/',), 'success', ('ok',))
2700
1988
        repo.autopack()
2701
 
        self.assertFinished(client)
 
1989
        client.finished_test()
2702
1990
 
2703
1991
    def test_ok_with_real_repo(self):
2704
1992
        """When the server returns 'ok' and there is a _real_repository, then
2803
2091
        expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
2804
2092
        self.assertEqual(expected_error, translated_error)
2805
2093
 
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
2094
    def test_LockContention(self):
2816
2095
        translated_error = self.translateTuple(('LockContention',))
2817
2096
        expected_error = errors.LockContention('(remote lock)')
2857
2136
        expected_error = errors.ReadError(path)
2858
2137
        self.assertEqual(expected_error, translated_error)
2859
2138
 
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
2139
    def test_PermissionDenied_no_args(self):
2868
2140
        path = 'a path'
2869
2141
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
2930
2202
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2931
2203
        # been muttered to the log file for developer to look at.
2932
2204
        self.assertContainsRe(
2933
 
            self.get_log(),
 
2205
            self._get_log(keep_log_file=True),
2934
2206
            "Missing key 'branch' in context")
2935
2207
 
2936
2208
    def test_path_missing(self):
2944
2216
        self.assertEqual(server_error, translated_error)
2945
2217
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2946
2218
        # been muttered to the log file for developer to look at.
2947
 
        self.assertContainsRe(self.get_log(), "Missing key 'path' in context")
 
2219
        self.assertContainsRe(
 
2220
            self._get_log(keep_log_file=True), "Missing key 'path' in context")
2948
2221
 
2949
2222
 
2950
2223
class TestStacking(tests.TestCaseWithTransport):
2968
2241
        stacked_branch = self.make_branch('stacked', format='1.9')
2969
2242
        stacked_branch.set_stacked_on_url('../base')
2970
2243
        # start a server looking at this
2971
 
        smart_server = test_server.SmartTCPServer_for_testing()
2972
 
        self.start_server(smart_server)
 
2244
        smart_server = server.SmartTCPServer_for_testing()
 
2245
        smart_server.setUp()
 
2246
        self.addCleanup(smart_server.tearDown)
2973
2247
        remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
2974
2248
        # can get its branch and repository
2975
2249
        remote_branch = remote_bzrdir.open_branch()
2978
2252
        try:
2979
2253
            # it should have an appropriate fallback repository, which should also
2980
2254
            # be a RemoteRepository
2981
 
            self.assertLength(1, remote_repo._fallback_repositories)
 
2255
            self.assertEquals(len(remote_repo._fallback_repositories), 1)
2982
2256
            self.assertIsInstance(remote_repo._fallback_repositories[0],
2983
2257
                RemoteRepository)
2984
2258
            # and it has the revision committed to the underlying repository;
2997
2271
        tree1.commit('rev1', rev_id='rev1')
2998
2272
        tree2 = tree1.branch.bzrdir.sprout('tree2', stacked=True
2999
2273
            ).open_workingtree()
3000
 
        local_tree = tree2.branch.create_checkout('local')
3001
 
        local_tree.commit('local changes make me feel good.')
 
2274
        tree2.commit('local changes make me feel good.')
3002
2275
        branch2 = Branch.open(self.get_url('tree2'))
3003
2276
        branch2.lock_read()
3004
2277
        self.addCleanup(branch2.unlock)
3026
2299
                    result.append(content.key[-1])
3027
2300
        return result
3028
2301
 
3029
 
    def get_ordered_revs(self, format, order, branch_factory=None):
 
2302
    def get_ordered_revs(self, format, order):
3030
2303
        """Get a list of the revisions in a stream to format format.
3031
2304
 
3032
2305
        :param format: The format of the target.
3033
2306
        :param order: the order that target should have requested.
3034
 
        :param branch_factory: A callable to create a trunk and stacked branch
3035
 
            to fetch from. If none, self.prepare_stacked_remote_branch is used.
3036
2307
        :result: The revision ids in the stream, in the order seen,
3037
2308
            the topological order of revisions in the source.
3038
2309
        """
3040
2311
        target_repository_format = unordered_format.repository_format
3041
2312
        # Cross check
3042
2313
        self.assertEqual(order, target_repository_format._fetch_order)
3043
 
        if branch_factory is None:
3044
 
            branch_factory = self.prepare_stacked_remote_branch
3045
 
        _, stacked = branch_factory()
 
2314
        trunk, stacked = self.prepare_stacked_remote_branch()
3046
2315
        source = stacked.repository._get_source(target_repository_format)
3047
2316
        tip = stacked.last_revision()
3048
2317
        revs = stacked.repository.get_ancestry(tip)
3067
2336
        # from the server, then one from the backing branch.
3068
2337
        self.assertLength(2, self.hpss_calls)
3069
2338
 
3070
 
    def test_stacked_on_stacked_get_stream_unordered(self):
3071
 
        # Repository._get_source.get_stream() from a stacked repository which
3072
 
        # is itself stacked yields the full data from all three sources.
3073
 
        def make_stacked_stacked():
3074
 
            _, stacked = self.prepare_stacked_remote_branch()
3075
 
            tree = stacked.bzrdir.sprout('tree3', stacked=True
3076
 
                ).open_workingtree()
3077
 
            local_tree = tree.branch.create_checkout('local-tree3')
3078
 
            local_tree.commit('more local changes are better')
3079
 
            branch = Branch.open(self.get_url('tree3'))
3080
 
            branch.lock_read()
3081
 
            self.addCleanup(branch.unlock)
3082
 
            return None, branch
3083
 
        rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
3084
 
            branch_factory=make_stacked_stacked)
3085
 
        self.assertEqual(set(expected_revs), set(rev_ord))
3086
 
        # Getting unordered results should have made a streaming data request
3087
 
        # from the server, and one from each backing repo
3088
 
        self.assertLength(3, self.hpss_calls)
3089
 
 
3090
2339
    def test_stacked_get_stream_topological(self):
3091
2340
        # Repository._get_source.get_stream() from a stacked repository with
3092
2341
        # topological sorting yields the full data from both stacked and
3093
2342
        # stacked upon sources in topological order.
3094
2343
        rev_ord, expected_revs = self.get_ordered_revs('knit', 'topological')
3095
2344
        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)
 
2345
        # Getting topological sort requires VFS calls still
 
2346
        self.assertLength(14, self.hpss_calls)
3099
2347
 
3100
2348
    def test_stacked_get_stream_groupcompress(self):
3101
2349
        # Repository._get_source.get_stream() from a stacked repository with
3108
2356
        # from the backing branch, and one from the stacked on branch.
3109
2357
        self.assertLength(2, self.hpss_calls)
3110
2358
 
3111
 
    def test_stacked_pull_more_than_stacking_has_bug_360791(self):
3112
 
        # When pulling some fixed amount of content that is more than the
3113
 
        # source has (because some is coming from a fallback branch, no error
3114
 
        # should be received. This was reported as bug 360791.
3115
 
        # Need three branches: a trunk, a stacked branch, and a preexisting
3116
 
        # branch pulling content from stacked and trunk.
3117
 
        self.setup_smart_server_with_call_log()
3118
 
        trunk = self.make_branch_and_tree('trunk', format="1.9-rich-root")
3119
 
        r1 = trunk.commit('start')
3120
 
        stacked_branch = trunk.branch.create_clone_on_transport(
3121
 
            self.get_transport('stacked'), stacked_on=trunk.branch.base)
3122
 
        local = self.make_branch('local', format='1.9-rich-root')
3123
 
        local.repository.fetch(stacked_branch.repository,
3124
 
            stacked_branch.last_revision())
3125
 
 
3126
2359
 
3127
2360
class TestRemoteBranchEffort(tests.TestCaseWithTransport):
3128
2361
 
3130
2363
        super(TestRemoteBranchEffort, self).setUp()
3131
2364
        # Create a smart server that publishes whatever the backing VFS server
3132
2365
        # does.
3133
 
        self.smart_server = test_server.SmartTCPServer_for_testing()
3134
 
        self.start_server(self.smart_server, self.get_server())
 
2366
        self.smart_server = server.SmartTCPServer_for_testing()
 
2367
        self.smart_server.setUp(self.get_server())
 
2368
        self.addCleanup(self.smart_server.tearDown)
3135
2369
        # Log all HPSS calls into self.hpss_calls.
3136
2370
        _SmartClient.hooks.install_named_hook(
3137
2371
            'call', self.capture_hpss_call, None)