← 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: Canonical.com Patch Queue Manager
  • Date: 2009-03-17 07:05:37 UTC
  • mfrom: (4152.1.2 branch.stacked.streams)
  • Revision ID: pqm@pqm.ubuntu.com-20090317070537-zaud24vjs2szna87
(robertc) Add client-side streaming from stacked branches (over
        bzr:// protocols) when the sort order is compatible with doing
        that. (Robert Collins, Andrew Bennetts)

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 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for remote bzrdir/branch/repo/etc
18
18
 
27
27
from cStringIO import StringIO
28
28
 
29
29
from bzrlib import (
30
 
    branch,
31
30
    bzrdir,
32
31
    config,
33
 
    controldir,
34
32
    errors,
35
33
    graph,
36
 
    inventory,
37
 
    inventory_delta,
 
34
    pack,
38
35
    remote,
39
36
    repository,
 
37
    smart,
40
38
    tests,
41
 
    transport,
42
 
    treebuilder,
43
 
    versionedfile,
 
39
    urlutils,
44
40
    )
45
41
from bzrlib.branch import Branch
46
 
from bzrlib.bzrdir import (
47
 
    BzrDir,
48
 
    BzrDirFormat,
49
 
    RemoteBzrProber,
50
 
    )
 
42
from bzrlib.bzrdir import BzrDir, BzrDirFormat
51
43
from bzrlib.remote import (
52
44
    RemoteBranch,
53
45
    RemoteBranchFormat,
54
46
    RemoteBzrDir,
 
47
    RemoteBzrDirFormat,
55
48
    RemoteRepository,
56
 
    RemoteRepositoryFormat,
57
49
    )
58
 
from bzrlib.repofmt import groupcompress_repo, pack_repo
59
50
from bzrlib.revision import NULL_REVISION
60
 
from bzrlib.smart import medium
 
51
from bzrlib.smart import server, medium
61
52
from bzrlib.smart.client import _SmartClient
62
 
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
 
53
from bzrlib.symbol_versioning import one_four
63
54
from bzrlib.tests import (
64
55
    condition_isinstance,
65
56
    split_suite_by_condition,
66
57
    multiply_tests,
67
 
    test_server,
68
58
    )
 
59
from bzrlib.transport import get_transport, http
69
60
from bzrlib.transport.memory import MemoryTransport
70
61
from bzrlib.transport.remote import (
71
62
    RemoteTransport,
77
68
    to_adapt, result = split_suite_by_condition(
78
69
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
79
70
    smart_server_version_scenarios = [
80
 
        ('HPSS-v2',
81
 
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
82
 
        ('HPSS-v3',
83
 
         {'transport_server': test_server.SmartTCPServer_for_testing})]
 
71
        ('HPSS-v2', 
 
72
            {'transport_server': server.SmartTCPServer_for_testing_v2_only}),
 
73
        ('HPSS-v3', 
 
74
            {'transport_server': server.SmartTCPServer_for_testing})]
84
75
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
85
76
 
86
77
 
91
82
        self.transport = self.get_transport()
92
83
        # make a branch that can be opened over the smart transport
93
84
        self.local_wt = BzrDir.create_standalone_workingtree('.')
94
 
        self.addCleanup(self.transport.disconnect)
 
85
 
 
86
    def tearDown(self):
 
87
        self.transport.disconnect()
 
88
        tests.TestCaseWithTransport.tearDown(self)
95
89
 
96
90
    def test_create_remote_bzrdir(self):
97
91
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
121
115
    def test_find_correct_format(self):
122
116
        """Should open a RemoteBzrDir over a RemoteTransport"""
123
117
        fmt = BzrDirFormat.find_format(self.transport)
124
 
        self.assertTrue(bzrdir.RemoteBzrProber
125
 
                        in controldir.ControlDirFormat._server_probers)
 
118
        self.assertTrue(RemoteBzrDirFormat
 
119
                        in BzrDirFormat._control_server_formats)
126
120
        self.assertIsInstance(fmt, remote.RemoteBzrDirFormat)
127
121
 
128
122
    def test_open_detected_smart_format(self):
134
128
        b = BzrDir.open_from_transport(self.transport).open_branch()
135
129
        self.assertStartsWith(str(b), 'RemoteBranch(')
136
130
 
137
 
    def test_remote_bzrdir_repr(self):
138
 
        b = BzrDir.open_from_transport(self.transport)
139
 
        self.assertStartsWith(str(b), 'RemoteBzrDir(')
140
 
 
141
131
    def test_remote_branch_format_supports_stacking(self):
142
132
        t = self.transport
143
133
        self.make_branch('unstackable', format='pack-0.92')
160
150
        r = BzrDir.open_from_transport(t.clone('stackable')).open_repository()
161
151
        self.assertTrue(r._format.supports_external_lookups)
162
152
 
163
 
    def test_remote_branch_set_append_revisions_only(self):
164
 
        # Make a format 1.9 branch, which supports append_revisions_only
165
 
        branch = self.make_branch('branch', format='1.9')
166
 
        config = branch.get_config()
167
 
        branch.set_append_revisions_only(True)
168
 
        self.assertEqual(
169
 
            'True', config.get_user_option('append_revisions_only'))
170
 
        branch.set_append_revisions_only(False)
171
 
        self.assertEqual(
172
 
            'False', config.get_user_option('append_revisions_only'))
173
 
 
174
 
    def test_remote_branch_set_append_revisions_only_upgrade_reqd(self):
175
 
        branch = self.make_branch('branch', format='knit')
176
 
        config = branch.get_config()
177
 
        self.assertRaises(
178
 
            errors.UpgradeRequired, branch.set_append_revisions_only, True)
179
 
 
180
153
 
181
154
class FakeProtocol(object):
182
155
    """Lookalike SmartClientRequestProtocolOne allowing body reading tests."""
283
256
        self.expecting_body = True
284
257
        return result[1], FakeProtocol(result[2], self)
285
258
 
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
 
 
292
259
    def call_with_body_bytes_expecting_body(self, method, args, body):
293
260
        self._check_call(method, args)
294
261
        self._calls.append(('call_with_body_bytes_expecting_body', method,
344
311
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
345
312
        return reference_bzrdir_format.repository_format
346
313
 
347
 
    def assertFinished(self, fake_client):
348
 
        """Assert that all of a FakeClient's expected calls have occurred."""
349
 
        fake_client.finished_test()
 
314
    def disable_verb(self, verb):
 
315
        """Disable a verb for one test."""
 
316
        request_handlers = smart.request.request_handlers
 
317
        orig_method = request_handlers.get(verb)
 
318
        request_handlers.remove(verb)
 
319
        def restoreVerb():
 
320
            request_handlers.register(verb, orig_method)
 
321
        self.addCleanup(restoreVerb)
350
322
 
351
323
 
352
324
class Test_ClientMedium_remote_path_from_transport(tests.TestCase):
358
330
        a given client_base and transport_base.
359
331
        """
360
332
        client_medium = medium.SmartClientMedium(client_base)
361
 
        t = transport.get_transport(transport_base)
362
 
        result = client_medium.remote_path_from_transport(t)
 
333
        transport = get_transport(transport_base)
 
334
        result = client_medium.remote_path_from_transport(transport)
363
335
        self.assertEqual(expected, result)
364
336
 
365
337
    def test_remote_path_from_transport(self):
376
348
        a given transport_base and relpath of that transport.  (Note that
377
349
        HttpTransportBase is a subclass of SmartClientMedium)
378
350
        """
379
 
        base_transport = transport.get_transport(transport_base)
 
351
        base_transport = get_transport(transport_base)
380
352
        client_medium = base_transport.get_smart_medium()
381
353
        cloned_transport = base_transport.clone(relpath)
382
354
        result = client_medium.remote_path_from_transport(cloned_transport)
417
389
        # Calling _remember_remote_is_before again with a lower value works.
418
390
        client_medium._remember_remote_is_before((1, 5))
419
391
        self.assertTrue(client_medium._is_remote_before((1, 5)))
420
 
        # If you call _remember_remote_is_before with a higher value it logs a
421
 
        # warning, and continues to remember the lower value.
422
 
        self.assertNotContainsRe(self.get_log(), '_remember_remote_is_before')
423
 
        client_medium._remember_remote_is_before((1, 9))
424
 
        self.assertContainsRe(self.get_log(), '_remember_remote_is_before')
425
 
        self.assertTrue(client_medium._is_remote_before((1, 5)))
 
392
        # You cannot call _remember_remote_is_before with a larger value.
 
393
        self.assertRaises(
 
394
            AssertionError, client_medium._remember_remote_is_before, (1, 9))
426
395
 
427
396
 
428
397
class TestBzrDirCloningMetaDir(TestRemote):
438
407
            call.call.method == verb])
439
408
        self.assertEqual(1, call_count)
440
409
 
441
 
    def test_branch_reference(self):
442
 
        transport = self.get_transport('quack')
443
 
        referenced = self.make_branch('referenced')
444
 
        expected = referenced.bzrdir.cloning_metadir()
445
 
        client = FakeClient(transport.base)
446
 
        client.add_expected_call(
447
 
            'BzrDir.cloning_metadir', ('quack/', 'False'),
448
 
            'error', ('BranchReference',)),
449
 
        client.add_expected_call(
450
 
            'BzrDir.open_branchV3', ('quack/',),
451
 
            'success', ('ref', self.get_url('referenced'))),
452
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
453
 
            _client=client)
454
 
        result = a_bzrdir.cloning_metadir()
455
 
        # We should have got a control dir matching the referenced branch.
456
 
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
457
 
        self.assertEqual(expected._repository_format, result._repository_format)
458
 
        self.assertEqual(expected._branch_format, result._branch_format)
459
 
        self.assertFinished(client)
460
 
 
461
410
    def test_current_server(self):
462
411
        transport = self.get_transport('.')
463
412
        transport = transport.clone('quack')
477
426
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
478
427
        self.assertEqual(None, result._repository_format)
479
428
        self.assertEqual(None, result._branch_format)
480
 
        self.assertFinished(client)
481
 
 
482
 
 
483
 
class TestBzrDirOpen(TestRemote):
484
 
 
485
 
    def make_fake_client_and_transport(self, path='quack'):
486
 
        transport = MemoryTransport()
487
 
        transport.mkdir(path)
488
 
        transport = transport.clone(path)
489
 
        client = FakeClient(transport.base)
490
 
        return client, transport
491
 
 
492
 
    def test_absent(self):
493
 
        client, transport = self.make_fake_client_and_transport()
494
 
        client.add_expected_call(
495
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
496
 
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
497
 
                remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
498
 
        self.assertFinished(client)
499
 
 
500
 
    def test_present_without_workingtree(self):
501
 
        client, transport = self.make_fake_client_and_transport()
502
 
        client.add_expected_call(
503
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
504
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
505
 
            _client=client, _force_probe=True)
506
 
        self.assertIsInstance(bd, RemoteBzrDir)
507
 
        self.assertFalse(bd.has_workingtree())
508
 
        self.assertRaises(errors.NoWorkingTree, bd.open_workingtree)
509
 
        self.assertFinished(client)
510
 
 
511
 
    def test_present_with_workingtree(self):
512
 
        client, transport = self.make_fake_client_and_transport()
513
 
        client.add_expected_call(
514
 
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
515
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
516
 
            _client=client, _force_probe=True)
517
 
        self.assertIsInstance(bd, RemoteBzrDir)
518
 
        self.assertTrue(bd.has_workingtree())
519
 
        self.assertRaises(errors.NotLocalUrl, bd.open_workingtree)
520
 
        self.assertFinished(client)
521
 
 
522
 
    def test_backwards_compat(self):
523
 
        client, transport = self.make_fake_client_and_transport()
524
 
        client.add_expected_call(
525
 
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
526
 
        client.add_expected_call(
527
 
            'BzrDir.open', ('quack/',), 'success', ('yes',))
528
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
529
 
            _client=client, _force_probe=True)
530
 
        self.assertIsInstance(bd, RemoteBzrDir)
531
 
        self.assertFinished(client)
532
 
 
533
 
    def test_backwards_compat_hpss_v2(self):
534
 
        client, transport = self.make_fake_client_and_transport()
535
 
        # Monkey-patch fake client to simulate real-world behaviour with v2
536
 
        # server: upon first RPC call detect the protocol version, and because
537
 
        # the version is 2 also do _remember_remote_is_before((1, 6)) before
538
 
        # continuing with the RPC.
539
 
        orig_check_call = client._check_call
540
 
        def check_call(method, args):
541
 
            client._medium._protocol_version = 2
542
 
            client._medium._remember_remote_is_before((1, 6))
543
 
            client._check_call = orig_check_call
544
 
            client._check_call(method, args)
545
 
        client._check_call = check_call
546
 
        client.add_expected_call(
547
 
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
548
 
        client.add_expected_call(
549
 
            'BzrDir.open', ('quack/',), 'success', ('yes',))
550
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
551
 
            _client=client, _force_probe=True)
552
 
        self.assertIsInstance(bd, RemoteBzrDir)
553
 
        self.assertFinished(client)
 
429
        client.finished_test()
554
430
 
555
431
 
556
432
class TestBzrDirOpenBranch(TestRemote):
560
436
        self.make_branch('.')
561
437
        a_dir = BzrDir.open(self.get_url('.'))
562
438
        self.reset_smart_call_log()
563
 
        verb = 'BzrDir.open_branchV3'
 
439
        verb = 'BzrDir.open_branchV2'
564
440
        self.disable_verb(verb)
565
441
        format = a_dir.open_branch()
566
442
        call_count = len([call for call in self.hpss_calls if
576
452
        transport = transport.clone('quack')
577
453
        client = FakeClient(transport.base)
578
454
        client.add_expected_call(
579
 
            'BzrDir.open_branchV3', ('quack/',),
 
455
            'BzrDir.open_branchV2', ('quack/',),
580
456
            'success', ('branch', branch_network_name))
581
457
        client.add_expected_call(
582
458
            'BzrDir.find_repositoryV3', ('quack/',),
589
465
        result = bzrdir.open_branch()
590
466
        self.assertIsInstance(result, RemoteBranch)
591
467
        self.assertEqual(bzrdir, result.bzrdir)
592
 
        self.assertFinished(client)
 
468
        client.finished_test()
593
469
 
594
470
    def test_branch_missing(self):
595
471
        transport = MemoryTransport()
601
477
            _client=client)
602
478
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
603
479
        self.assertEqual(
604
 
            [('call', 'BzrDir.open_branchV3', ('quack/',))],
 
480
            [('call', 'BzrDir.open_branchV2', ('quack/',))],
605
481
            client._calls)
606
482
 
607
483
    def test__get_tree_branch(self):
608
484
        # _get_tree_branch is a form of open_branch, but it should only ask for
609
485
        # branch opening, not any other network requests.
610
486
        calls = []
611
 
        def open_branch(name=None):
 
487
        def open_branch():
612
488
            calls.append("Called")
613
489
            return "a-branch"
614
490
        transport = MemoryTransport()
631
507
        network_name = reference_format.network_name()
632
508
        branch_network_name = self.get_branch_format().network_name()
633
509
        client.add_expected_call(
634
 
            'BzrDir.open_branchV3', ('~hello/',),
 
510
            'BzrDir.open_branchV2', ('~hello/',),
635
511
            'success', ('branch', branch_network_name))
636
512
        client.add_expected_call(
637
513
            'BzrDir.find_repositoryV3', ('~hello/',),
642
518
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
643
519
            _client=client)
644
520
        result = bzrdir.open_branch()
645
 
        self.assertFinished(client)
 
521
        client.finished_test()
646
522
 
647
523
    def check_open_repository(self, rich_root, subtrees, external_lookup='no'):
648
524
        reference_format = self.get_repo_format()
685
561
        old.
686
562
        """
687
563
        self.assertRaises(errors.NotBranchError,
688
 
            RemoteBzrProber.probe_transport, OldServerTransport())
 
564
            RemoteBzrDirFormat.probe_transport, OldServerTransport())
689
565
 
690
566
 
691
567
class TestBzrDirCreateBranch(TestRemote):
746
622
        network_name = reference_format.network_name()
747
623
        client.add_expected_call(
748
624
            'BzrDir.create_repository', ('quack/',
749
 
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
750
 
                'False'),
751
 
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
 
625
                'Bazaar pack repository format 1 (needs bzr 0.92)\n', 'False'),
 
626
            'success', ('ok', 'no', 'no', 'no', network_name))
752
627
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
753
628
            _client=client)
754
629
        repo = a_bzrdir.create_repository()
756
631
        self.assertIsInstance(repo, remote.RemoteRepository)
757
632
        # its format should have the settings from the response
758
633
        format = repo._format
759
 
        self.assertTrue(format.rich_root_data)
760
 
        self.assertTrue(format.supports_tree_reference)
761
 
        self.assertTrue(format.supports_external_lookups)
 
634
        self.assertFalse(format.rich_root_data)
 
635
        self.assertFalse(format.supports_tree_reference)
 
636
        self.assertFalse(format.supports_external_lookups)
762
637
        self.assertEqual(network_name, format.network_name())
763
638
 
764
639
 
768
643
        # fallback all the way to the first version.
769
644
        reference_format = self.get_repo_format()
770
645
        network_name = reference_format.network_name()
771
 
        server_url = 'bzr://example.com/'
772
 
        self.permit_url(server_url)
773
 
        client = FakeClient(server_url)
 
646
        client = FakeClient('bzr://example.com/')
774
647
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
775
648
        client.add_unknown_method_response('BzrDir.find_repositoryV2')
776
649
        client.add_success_response('ok', '', 'no', 'no')
782
655
            reference_format.get_format_string(), 'ok')
783
656
        # PackRepository wants to do a stat
784
657
        client.add_success_response('stat', '0', '65535')
785
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
658
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
786
659
            _client=client)
787
660
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
788
661
            _client=client)
802
675
        # fallback to find_repositoryV2
803
676
        reference_format = self.get_repo_format()
804
677
        network_name = reference_format.network_name()
805
 
        server_url = 'bzr://example.com/'
806
 
        self.permit_url(server_url)
807
 
        client = FakeClient(server_url)
 
678
        client = FakeClient('bzr://example.com/')
808
679
        client.add_unknown_method_response('BzrDir.find_repositoryV3')
809
680
        client.add_success_response('ok', '', 'no', 'no', 'no')
810
681
        # A real repository instance will be created to determine the network
815
686
            reference_format.get_format_string(), 'ok')
816
687
        # PackRepository wants to do a stat
817
688
        client.add_success_response('stat', '0', '65535')
818
 
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
 
689
        remote_transport = RemoteTransport('bzr://example.com/quack/', medium=False,
819
690
            _client=client)
820
691
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
821
692
            _client=client)
847
718
        self.assertEqual(network_name, repo._format.network_name())
848
719
 
849
720
 
850
 
class TestBzrDirFormatInitializeEx(TestRemote):
851
 
 
852
 
    def test_success(self):
853
 
        """Simple test for typical successful call."""
854
 
        fmt = bzrdir.RemoteBzrDirFormat()
855
 
        default_format_name = BzrDirFormat.get_default_format().network_name()
856
 
        transport = self.get_transport()
857
 
        client = FakeClient(transport.base)
858
 
        client.add_expected_call(
859
 
            'BzrDirFormat.initialize_ex_1.16',
860
 
                (default_format_name, 'path', 'False', 'False', 'False', '',
861
 
                 '', '', '', 'False'),
862
 
            'success',
863
 
                ('.', 'no', 'no', 'yes', 'repo fmt', 'repo bzrdir fmt',
864
 
                 'bzrdir fmt', 'False', '', '', 'repo lock token'))
865
 
        # XXX: It would be better to call fmt.initialize_on_transport_ex, but
866
 
        # it's currently hard to test that without supplying a real remote
867
 
        # transport connected to a real server.
868
 
        result = fmt._initialize_on_transport_ex_rpc(client, 'path',
869
 
            transport, False, False, False, None, None, None, None, False)
870
 
        self.assertFinished(client)
871
 
 
872
 
    def test_error(self):
873
 
        """Error responses are translated, e.g. 'PermissionDenied' raises the
874
 
        corresponding error from the client.
875
 
        """
876
 
        fmt = bzrdir.RemoteBzrDirFormat()
877
 
        default_format_name = BzrDirFormat.get_default_format().network_name()
878
 
        transport = self.get_transport()
879
 
        client = FakeClient(transport.base)
880
 
        client.add_expected_call(
881
 
            'BzrDirFormat.initialize_ex_1.16',
882
 
                (default_format_name, 'path', 'False', 'False', 'False', '',
883
 
                 '', '', '', 'False'),
884
 
            'error',
885
 
                ('PermissionDenied', 'path', 'extra info'))
886
 
        # XXX: It would be better to call fmt.initialize_on_transport_ex, but
887
 
        # it's currently hard to test that without supplying a real remote
888
 
        # transport connected to a real server.
889
 
        err = self.assertRaises(errors.PermissionDenied,
890
 
            fmt._initialize_on_transport_ex_rpc, client, 'path', transport,
891
 
            False, False, False, None, None, None, None, False)
892
 
        self.assertEqual('path', err.path)
893
 
        self.assertEqual(': extra info', err.extra)
894
 
        self.assertFinished(client)
895
 
 
896
 
    def test_error_from_real_server(self):
897
 
        """Integration test for error translation."""
898
 
        transport = self.make_smart_server('foo')
899
 
        transport = transport.clone('no-such-path')
900
 
        fmt = bzrdir.RemoteBzrDirFormat()
901
 
        err = self.assertRaises(errors.NoSuchFile,
902
 
            fmt.initialize_on_transport_ex, transport, create_prefix=False)
903
 
 
904
 
 
905
721
class OldSmartClient(object):
906
722
    """A fake smart client for test_old_version that just returns a version one
907
723
    response to the 'hello' (query version) command.
930
746
        return OldSmartClient()
931
747
 
932
748
 
933
 
class RemoteBzrDirTestCase(TestRemote):
934
 
 
935
 
    def make_remote_bzrdir(self, transport, client):
936
 
        """Make a RemotebzrDir using 'client' as the _client."""
937
 
        return RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
938
 
            _client=client)
939
 
 
940
 
 
941
 
class RemoteBranchTestCase(RemoteBzrDirTestCase):
942
 
 
943
 
    def lock_remote_branch(self, branch):
944
 
        """Trick a RemoteBranch into thinking it is locked."""
945
 
        branch._lock_mode = 'w'
946
 
        branch._lock_count = 2
947
 
        branch._lock_token = 'branch token'
948
 
        branch._repo_lock_token = 'repo token'
949
 
        branch.repository._lock_mode = 'w'
950
 
        branch.repository._lock_count = 2
951
 
        branch.repository._lock_token = 'repo token'
 
749
class RemoteBranchTestCase(TestRemote):
952
750
 
953
751
    def make_remote_branch(self, transport, client):
954
752
        """Make a RemoteBranch using 'client' as its _SmartClient.
959
757
        # we do not want bzrdir to make any remote calls, so use False as its
960
758
        # _client.  If it tries to make a remote call, this will fail
961
759
        # immediately.
962
 
        bzrdir = self.make_remote_bzrdir(transport, False)
 
760
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
761
            _client=False)
963
762
        repo = RemoteRepository(bzrdir, None, _client=client)
964
763
        branch_format = self.get_branch_format()
965
764
        format = RemoteBranchFormat(network_name=branch_format.network_name())
982
781
        transport = transport.clone('quack')
983
782
        branch = self.make_remote_branch(transport, client)
984
783
        result = branch.get_parent()
985
 
        self.assertFinished(client)
 
784
        client.finished_test()
986
785
        self.assertEqual(None, result)
987
786
 
988
787
    def test_parent_relative(self):
1014
813
        branch = self.make_remote_branch(transport, client)
1015
814
        result = branch.get_parent()
1016
815
        self.assertEqual('http://foo/', result)
1017
 
        self.assertFinished(client)
1018
 
 
1019
 
 
1020
 
class TestBranchSetParentLocation(RemoteBranchTestCase):
1021
 
 
1022
 
    def test_no_parent(self):
1023
 
        # We call the verb when setting parent to None
1024
 
        transport = MemoryTransport()
1025
 
        client = FakeClient(transport.base)
1026
 
        client.add_expected_call(
1027
 
            'Branch.get_stacked_on_url', ('quack/',),
1028
 
            'error', ('NotStacked',))
1029
 
        client.add_expected_call(
1030
 
            'Branch.set_parent_location', ('quack/', 'b', 'r', ''),
1031
 
            'success', ())
1032
 
        transport.mkdir('quack')
1033
 
        transport = transport.clone('quack')
1034
 
        branch = self.make_remote_branch(transport, client)
1035
 
        branch._lock_token = 'b'
1036
 
        branch._repo_lock_token = 'r'
1037
 
        branch._set_parent_location(None)
1038
 
        self.assertFinished(client)
1039
 
 
1040
 
    def test_parent(self):
1041
 
        transport = MemoryTransport()
1042
 
        client = FakeClient(transport.base)
1043
 
        client.add_expected_call(
1044
 
            'Branch.get_stacked_on_url', ('kwaak/',),
1045
 
            'error', ('NotStacked',))
1046
 
        client.add_expected_call(
1047
 
            'Branch.set_parent_location', ('kwaak/', 'b', 'r', 'foo'),
1048
 
            'success', ())
1049
 
        transport.mkdir('kwaak')
1050
 
        transport = transport.clone('kwaak')
1051
 
        branch = self.make_remote_branch(transport, client)
1052
 
        branch._lock_token = 'b'
1053
 
        branch._repo_lock_token = 'r'
1054
 
        branch._set_parent_location('foo')
1055
 
        self.assertFinished(client)
1056
 
 
1057
 
    def test_backwards_compat(self):
1058
 
        self.setup_smart_server_with_call_log()
1059
 
        branch = self.make_branch('.')
1060
 
        self.reset_smart_call_log()
1061
 
        verb = 'Branch.set_parent_location'
1062
 
        self.disable_verb(verb)
1063
 
        branch.set_parent('http://foo/')
1064
 
        self.assertLength(12, self.hpss_calls)
1065
816
 
1066
817
 
1067
818
class TestBranchGetTagsBytes(RemoteBranchTestCase):
1090
841
        transport = transport.clone('quack')
1091
842
        branch = self.make_remote_branch(transport, client)
1092
843
        result = branch.tags.get_tag_dict()
1093
 
        self.assertFinished(client)
 
844
        client.finished_test()
1094
845
        self.assertEqual({}, result)
1095
846
 
1096
847
 
1097
 
class TestBranchSetTagsBytes(RemoteBranchTestCase):
1098
 
 
1099
 
    def test_trivial(self):
1100
 
        transport = MemoryTransport()
1101
 
        client = FakeClient(transport.base)
1102
 
        client.add_expected_call(
1103
 
            'Branch.get_stacked_on_url', ('quack/',),
1104
 
            'error', ('NotStacked',))
1105
 
        client.add_expected_call(
1106
 
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1107
 
            'success', ('',))
1108
 
        transport.mkdir('quack')
1109
 
        transport = transport.clone('quack')
1110
 
        branch = self.make_remote_branch(transport, client)
1111
 
        self.lock_remote_branch(branch)
1112
 
        branch._set_tags_bytes('tags bytes')
1113
 
        self.assertFinished(client)
1114
 
        self.assertEqual('tags bytes', client._calls[-1][-1])
1115
 
 
1116
 
    def test_backwards_compatible(self):
1117
 
        transport = MemoryTransport()
1118
 
        client = FakeClient(transport.base)
1119
 
        client.add_expected_call(
1120
 
            'Branch.get_stacked_on_url', ('quack/',),
1121
 
            'error', ('NotStacked',))
1122
 
        client.add_expected_call(
1123
 
            'Branch.set_tags_bytes', ('quack/', 'branch token', 'repo token'),
1124
 
            'unknown', ('Branch.set_tags_bytes',))
1125
 
        transport.mkdir('quack')
1126
 
        transport = transport.clone('quack')
1127
 
        branch = self.make_remote_branch(transport, client)
1128
 
        self.lock_remote_branch(branch)
1129
 
        class StubRealBranch(object):
1130
 
            def __init__(self):
1131
 
                self.calls = []
1132
 
            def _set_tags_bytes(self, bytes):
1133
 
                self.calls.append(('set_tags_bytes', bytes))
1134
 
        real_branch = StubRealBranch()
1135
 
        branch._real_branch = real_branch
1136
 
        branch._set_tags_bytes('tags bytes')
1137
 
        # Call a second time, to exercise the 'remote version already inferred'
1138
 
        # code path.
1139
 
        branch._set_tags_bytes('tags bytes')
1140
 
        self.assertFinished(client)
1141
 
        self.assertEqual(
1142
 
            [('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1143
 
 
1144
 
 
1145
848
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1146
849
 
1147
850
    def test_empty_branch(self):
1158
861
        transport = transport.clone('quack')
1159
862
        branch = self.make_remote_branch(transport, client)
1160
863
        result = branch.last_revision_info()
1161
 
        self.assertFinished(client)
 
864
        client.finished_test()
1162
865
        self.assertEqual((0, NULL_REVISION), result)
1163
866
 
1164
867
    def test_non_empty_branch(self):
1219
922
        client = FakeClient(self.get_url())
1220
923
        branch_network_name = self.get_branch_format().network_name()
1221
924
        client.add_expected_call(
1222
 
            'BzrDir.open_branchV3', ('stacked/',),
 
925
            'BzrDir.open_branchV2', ('stacked/',),
1223
926
            'success', ('branch', branch_network_name))
1224
927
        client.add_expected_call(
1225
928
            'BzrDir.find_repositoryV3', ('stacked/',),
1239
942
        branch = bzrdir.open_branch()
1240
943
        result = branch.get_stacked_on_url()
1241
944
        self.assertEqual('../base', result)
1242
 
        self.assertFinished(client)
 
945
        client.finished_test()
1243
946
        # it's in the fallback list both for the RemoteRepository and its vfs
1244
947
        # repository
1245
948
        self.assertEqual(1, len(branch.repository._fallback_repositories))
1247
950
            len(branch.repository._real_repository._fallback_repositories))
1248
951
 
1249
952
    def test_get_stacked_on_real_branch(self):
1250
 
        base_branch = self.make_branch('base')
1251
 
        stacked_branch = self.make_branch('stacked')
 
953
        base_branch = self.make_branch('base', format='1.6')
 
954
        stacked_branch = self.make_branch('stacked', format='1.6')
1252
955
        stacked_branch.set_stacked_on_url('../base')
1253
956
        reference_format = self.get_repo_format()
1254
957
        network_name = reference_format.network_name()
1255
958
        client = FakeClient(self.get_url())
1256
959
        branch_network_name = self.get_branch_format().network_name()
1257
960
        client.add_expected_call(
1258
 
            'BzrDir.open_branchV3', ('stacked/',),
 
961
            'BzrDir.open_branchV2', ('stacked/',),
1259
962
            'success', ('branch', branch_network_name))
1260
963
        client.add_expected_call(
1261
964
            'BzrDir.find_repositoryV3', ('stacked/',),
1262
 
            'success', ('ok', '', 'yes', 'no', 'yes', network_name))
 
965
            'success', ('ok', '', 'no', 'no', 'yes', network_name))
1263
966
        # called twice, once from constructor and then again by us
1264
967
        client.add_expected_call(
1265
968
            'Branch.get_stacked_on_url', ('stacked/',),
1272
975
        branch = bzrdir.open_branch()
1273
976
        result = branch.get_stacked_on_url()
1274
977
        self.assertEqual('../base', result)
1275
 
        self.assertFinished(client)
1276
 
        # it's in the fallback list both for the RemoteRepository.
 
978
        client.finished_test()
 
979
        # it's in the fallback list both for the RemoteRepository and its vfs
 
980
        # repository
1277
981
        self.assertEqual(1, len(branch.repository._fallback_repositories))
1278
 
        # And we haven't had to construct a real repository.
1279
 
        self.assertEqual(None, branch.repository._real_repository)
 
982
        self.assertEqual(1,
 
983
            len(branch.repository._real_repository._fallback_repositories))
1280
984
 
1281
985
 
1282
986
class TestBranchSetLastRevision(RemoteBranchTestCase):
1313
1017
        result = branch.set_revision_history([])
1314
1018
        branch.unlock()
1315
1019
        self.assertEqual(None, result)
1316
 
        self.assertFinished(client)
 
1020
        client.finished_test()
1317
1021
 
1318
1022
    def test_set_nonempty(self):
1319
1023
        # set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
1351
1055
        result = branch.set_revision_history(['rev-id1', 'rev-id2'])
1352
1056
        branch.unlock()
1353
1057
        self.assertEqual(None, result)
1354
 
        self.assertFinished(client)
 
1058
        client.finished_test()
1355
1059
 
1356
1060
    def test_no_such_revision(self):
1357
1061
        transport = MemoryTransport()
1386
1090
        self.assertRaises(
1387
1091
            errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
1388
1092
        branch.unlock()
1389
 
        self.assertFinished(client)
 
1093
        client.finished_test()
1390
1094
 
1391
1095
    def test_tip_change_rejected(self):
1392
1096
        """TipChangeRejected responses cause a TipChangeRejected exception to
1429
1133
        self.assertIsInstance(err.msg, unicode)
1430
1134
        self.assertEqual(rejection_msg_unicode, err.msg)
1431
1135
        branch.unlock()
1432
 
        self.assertFinished(client)
 
1136
        client.finished_test()
1433
1137
 
1434
1138
 
1435
1139
class TestBranchSetLastRevisionInfo(RemoteBranchTestCase):
1489
1193
            errors.NoSuchRevision, branch.set_last_revision_info, 123, 'revid')
1490
1194
        branch.unlock()
1491
1195
 
 
1196
    def lock_remote_branch(self, branch):
 
1197
        """Trick a RemoteBranch into thinking it is locked."""
 
1198
        branch._lock_mode = 'w'
 
1199
        branch._lock_count = 2
 
1200
        branch._lock_token = 'branch token'
 
1201
        branch._repo_lock_token = 'repo token'
 
1202
        branch.repository._lock_mode = 'w'
 
1203
        branch.repository._lock_count = 2
 
1204
        branch.repository._lock_token = 'repo token'
 
1205
 
1492
1206
    def test_backwards_compatibility(self):
1493
1207
        """If the server does not support the Branch.set_last_revision_info
1494
1208
        verb (which is new in 1.4), then the client falls back to VFS methods.
1535
1249
        self.assertEqual(
1536
1250
            [('set_last_revision_info', 1234, 'a-revision-id')],
1537
1251
            real_branch.calls)
1538
 
        self.assertFinished(client)
 
1252
        client.finished_test()
1539
1253
 
1540
1254
    def test_unexpected_error(self):
1541
1255
        # If the server sends an error the client doesn't understand, it gets
1596
1310
        self.assertEqual('rejection message', err.msg)
1597
1311
 
1598
1312
 
1599
 
class TestBranchGetSetConfig(RemoteBranchTestCase):
 
1313
class TestBranchControlGetBranchConf(tests.TestCaseWithMemoryTransport):
 
1314
    """Getting the branch configuration should use an abstract method not vfs.
 
1315
    """
1600
1316
 
1601
1317
    def test_get_branch_conf(self):
1602
 
        # in an empty branch we decode the response properly
1603
 
        client = FakeClient()
1604
 
        client.add_expected_call(
1605
 
            'Branch.get_stacked_on_url', ('memory:///',),
1606
 
            'error', ('NotStacked',),)
1607
 
        client.add_success_response_with_body('# config file body', 'ok')
1608
 
        transport = MemoryTransport()
1609
 
        branch = self.make_remote_branch(transport, client)
1610
 
        config = branch.get_config()
1611
 
        config.has_explicit_nickname()
1612
 
        self.assertEqual(
1613
 
            [('call', 'Branch.get_stacked_on_url', ('memory:///',)),
1614
 
             ('call_expecting_body', 'Branch.get_config_file', ('memory:///',))],
1615
 
            client._calls)
1616
 
 
1617
 
    def test_get_multi_line_branch_conf(self):
1618
 
        # Make sure that multiple-line branch.conf files are supported
1619
 
        #
1620
 
        # https://bugs.launchpad.net/bzr/+bug/354075
1621
 
        client = FakeClient()
1622
 
        client.add_expected_call(
1623
 
            'Branch.get_stacked_on_url', ('memory:///',),
1624
 
            'error', ('NotStacked',),)
1625
 
        client.add_success_response_with_body('a = 1\nb = 2\nc = 3\n', 'ok')
1626
 
        transport = MemoryTransport()
1627
 
        branch = self.make_remote_branch(transport, client)
1628
 
        config = branch.get_config()
1629
 
        self.assertEqual(u'2', config.get_user_option('b'))
1630
 
 
1631
 
    def test_set_option(self):
1632
 
        client = FakeClient()
1633
 
        client.add_expected_call(
1634
 
            'Branch.get_stacked_on_url', ('memory:///',),
1635
 
            'error', ('NotStacked',),)
1636
 
        client.add_expected_call(
1637
 
            'Branch.lock_write', ('memory:///', '', ''),
1638
 
            'success', ('ok', 'branch token', 'repo token'))
1639
 
        client.add_expected_call(
1640
 
            'Branch.set_config_option', ('memory:///', 'branch token',
1641
 
            'repo token', 'foo', 'bar', ''),
1642
 
            'success', ())
1643
 
        client.add_expected_call(
1644
 
            'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
1645
 
            'success', ('ok',))
1646
 
        transport = MemoryTransport()
1647
 
        branch = self.make_remote_branch(transport, client)
1648
 
        branch.lock_write()
1649
 
        config = branch._get_config()
1650
 
        config.set_option('foo', 'bar')
1651
 
        branch.unlock()
1652
 
        self.assertFinished(client)
1653
 
 
1654
 
    def test_set_option_with_dict(self):
1655
 
        client = FakeClient()
1656
 
        client.add_expected_call(
1657
 
            'Branch.get_stacked_on_url', ('memory:///',),
1658
 
            'error', ('NotStacked',),)
1659
 
        client.add_expected_call(
1660
 
            'Branch.lock_write', ('memory:///', '', ''),
1661
 
            'success', ('ok', 'branch token', 'repo token'))
1662
 
        encoded_dict_value = 'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde'
1663
 
        client.add_expected_call(
1664
 
            'Branch.set_config_option_dict', ('memory:///', 'branch token',
1665
 
            'repo token', encoded_dict_value, 'foo', ''),
1666
 
            'success', ())
1667
 
        client.add_expected_call(
1668
 
            'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
1669
 
            'success', ('ok',))
1670
 
        transport = MemoryTransport()
1671
 
        branch = self.make_remote_branch(transport, client)
1672
 
        branch.lock_write()
1673
 
        config = branch._get_config()
1674
 
        config.set_option(
1675
 
            {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'},
1676
 
            'foo')
1677
 
        branch.unlock()
1678
 
        self.assertFinished(client)
1679
 
 
1680
 
    def test_backwards_compat_set_option(self):
1681
 
        self.setup_smart_server_with_call_log()
1682
 
        branch = self.make_branch('.')
1683
 
        verb = 'Branch.set_config_option'
1684
 
        self.disable_verb(verb)
1685
 
        branch.lock_write()
1686
 
        self.addCleanup(branch.unlock)
1687
 
        self.reset_smart_call_log()
1688
 
        branch._get_config().set_option('value', 'name')
1689
 
        self.assertLength(10, self.hpss_calls)
1690
 
        self.assertEqual('value', branch._get_config().get_option('name'))
1691
 
 
1692
 
    def test_backwards_compat_set_option_with_dict(self):
1693
 
        self.setup_smart_server_with_call_log()
1694
 
        branch = self.make_branch('.')
1695
 
        verb = 'Branch.set_config_option_dict'
1696
 
        self.disable_verb(verb)
1697
 
        branch.lock_write()
1698
 
        self.addCleanup(branch.unlock)
1699
 
        self.reset_smart_call_log()
1700
 
        config = branch._get_config()
1701
 
        value_dict = {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
1702
 
        config.set_option(value_dict, 'name')
1703
 
        self.assertLength(10, self.hpss_calls)
1704
 
        self.assertEqual(value_dict, branch._get_config().get_option('name'))
 
1318
        raise tests.KnownFailure('branch.conf is not retrieved by get_config_file')
 
1319
        ## # We should see that branch.get_config() does a single rpc to get the
 
1320
        ## # remote configuration file, abstracting away where that is stored on
 
1321
        ## # the server.  However at the moment it always falls back to using the
 
1322
        ## # vfs, and this would need some changes in config.py.
 
1323
 
 
1324
        ## # in an empty branch we decode the response properly
 
1325
        ## client = FakeClient([(('ok', ), '# config file body')], self.get_url())
 
1326
        ## # we need to make a real branch because the remote_branch.control_files
 
1327
        ## # will trigger _ensure_real.
 
1328
        ## branch = self.make_branch('quack')
 
1329
        ## transport = branch.bzrdir.root_transport
 
1330
        ## # we do not want bzrdir to make any remote calls
 
1331
        ## bzrdir = RemoteBzrDir(transport, _client=False)
 
1332
        ## branch = RemoteBranch(bzrdir, None, _client=client)
 
1333
        ## config = branch.get_config()
 
1334
        ## self.assertEqual(
 
1335
        ##     [('call_expecting_body', 'Branch.get_config_file', ('quack/',))],
 
1336
        ##     client._calls)
1705
1337
 
1706
1338
 
1707
1339
class TestBranchLockWrite(RemoteBranchTestCase):
1719
1351
        transport = transport.clone('quack')
1720
1352
        branch = self.make_remote_branch(transport, client)
1721
1353
        self.assertRaises(errors.UnlockableTransport, branch.lock_write)
1722
 
        self.assertFinished(client)
1723
 
 
1724
 
 
1725
 
class TestBzrDirGetSetConfig(RemoteBzrDirTestCase):
1726
 
 
1727
 
    def test__get_config(self):
1728
 
        client = FakeClient()
1729
 
        client.add_success_response_with_body('default_stack_on = /\n', 'ok')
1730
 
        transport = MemoryTransport()
1731
 
        bzrdir = self.make_remote_bzrdir(transport, client)
1732
 
        config = bzrdir.get_config()
1733
 
        self.assertEqual('/', config.get_default_stack_on())
1734
 
        self.assertEqual(
1735
 
            [('call_expecting_body', 'BzrDir.get_config_file', ('memory:///',))],
1736
 
            client._calls)
1737
 
 
1738
 
    def test_set_option_uses_vfs(self):
1739
 
        self.setup_smart_server_with_call_log()
1740
 
        bzrdir = self.make_bzrdir('.')
1741
 
        self.reset_smart_call_log()
1742
 
        config = bzrdir.get_config()
1743
 
        config.set_default_stack_on('/')
1744
 
        self.assertLength(3, self.hpss_calls)
1745
 
 
1746
 
    def test_backwards_compat_get_option(self):
1747
 
        self.setup_smart_server_with_call_log()
1748
 
        bzrdir = self.make_bzrdir('.')
1749
 
        verb = 'BzrDir.get_config_file'
1750
 
        self.disable_verb(verb)
1751
 
        self.reset_smart_call_log()
1752
 
        self.assertEqual(None,
1753
 
            bzrdir._get_config().get_option('default_stack_on'))
1754
 
        self.assertLength(3, self.hpss_calls)
 
1354
        client.finished_test()
1755
1355
 
1756
1356
 
1757
1357
class TestTransportIsReadonly(tests.TestCase):
1850
1450
        return repo, client
1851
1451
 
1852
1452
 
1853
 
def remoted_description(format):
1854
 
    return 'Remote: ' + format.get_format_description()
1855
 
 
1856
 
 
1857
 
class TestBranchFormat(tests.TestCase):
1858
 
 
1859
 
    def test_get_format_description(self):
1860
 
        remote_format = RemoteBranchFormat()
1861
 
        real_format = branch.BranchFormat.get_default_format()
1862
 
        remote_format._network_name = real_format.network_name()
1863
 
        self.assertEqual(remoted_description(real_format),
1864
 
            remote_format.get_format_description())
1865
 
 
1866
 
 
1867
 
class TestRepositoryFormat(TestRemoteRepository):
1868
 
 
1869
 
    def test_fast_delta(self):
1870
 
        true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
1871
 
        true_format = RemoteRepositoryFormat()
1872
 
        true_format._network_name = true_name
1873
 
        self.assertEqual(True, true_format.fast_deltas)
1874
 
        false_name = pack_repo.RepositoryFormatKnitPack1().network_name()
1875
 
        false_format = RemoteRepositoryFormat()
1876
 
        false_format._network_name = false_name
1877
 
        self.assertEqual(False, false_format.fast_deltas)
1878
 
 
1879
 
    def test_get_format_description(self):
1880
 
        remote_repo_format = RemoteRepositoryFormat()
1881
 
        real_format = repository.RepositoryFormat.get_default_format()
1882
 
        remote_repo_format._network_name = real_format.network_name()
1883
 
        self.assertEqual(remoted_description(real_format),
1884
 
            remote_repo_format.get_format_description())
1885
 
 
1886
 
 
1887
1453
class TestRepositoryGatherStats(TestRemoteRepository):
1888
1454
 
1889
1455
    def test_revid_none(self):
1977
1543
        self.assertEqual({r1: (NULL_REVISION,)}, parents)
1978
1544
        self.assertEqual(
1979
1545
            [('call_with_body_bytes_expecting_body',
1980
 
              'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
1981
 
              '\n\n0')],
 
1546
              'Repository.get_parent_map', ('quack/', r2), '\n\n0')],
1982
1547
            client._calls)
1983
1548
        repo.unlock()
1984
1549
        # now we call again, and it should use the second response.
1988
1553
        self.assertEqual({r1: (NULL_REVISION,)}, parents)
1989
1554
        self.assertEqual(
1990
1555
            [('call_with_body_bytes_expecting_body',
1991
 
              'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
1992
 
              '\n\n0'),
 
1556
              'Repository.get_parent_map', ('quack/', r2), '\n\n0'),
1993
1557
             ('call_with_body_bytes_expecting_body',
1994
 
              'Repository.get_parent_map', ('quack/', 'include-missing:', r1),
1995
 
              '\n\n0'),
 
1558
              'Repository.get_parent_map', ('quack/', r1), '\n\n0'),
1996
1559
            ],
1997
1560
            client._calls)
1998
1561
        repo.unlock()
1999
1562
 
2000
1563
    def test_get_parent_map_reconnects_if_unknown_method(self):
2001
1564
        transport_path = 'quack'
2002
 
        rev_id = 'revision-id'
2003
1565
        repo, client = self.setup_fake_client_and_repository(transport_path)
2004
 
        client.add_unknown_method_response('Repository.get_parent_map')
2005
 
        client.add_success_response_with_body(rev_id, 'ok')
 
1566
        client.add_unknown_method_response('Repository,get_parent_map')
 
1567
        client.add_success_response_with_body('', 'ok')
2006
1568
        self.assertFalse(client._medium._is_remote_before((1, 2)))
2007
 
        parents = repo.get_parent_map([rev_id])
 
1569
        rev_id = 'revision-id'
 
1570
        expected_deprecations = [
 
1571
            'bzrlib.remote.RemoteRepository.get_revision_graph was deprecated '
 
1572
            'in version 1.4.']
 
1573
        parents = self.callDeprecated(
 
1574
            expected_deprecations, repo.get_parent_map, [rev_id])
2008
1575
        self.assertEqual(
2009
1576
            [('call_with_body_bytes_expecting_body',
2010
 
              'Repository.get_parent_map', ('quack/', 'include-missing:',
2011
 
              rev_id), '\n\n0'),
 
1577
              'Repository.get_parent_map', ('quack/', rev_id), '\n\n0'),
2012
1578
             ('disconnect medium',),
2013
1579
             ('call_expecting_body', 'Repository.get_revision_graph',
2014
1580
              ('quack/', ''))],
2015
1581
            client._calls)
2016
1582
        # The medium is now marked as being connected to an older server
2017
1583
        self.assertTrue(client._medium._is_remote_before((1, 2)))
2018
 
        self.assertEqual({rev_id: ('null:',)}, parents)
2019
1584
 
2020
1585
    def test_get_parent_map_fallback_parentless_node(self):
2021
1586
        """get_parent_map falls back to get_revision_graph on old servers.  The
2033
1598
        repo, client = self.setup_fake_client_and_repository(transport_path)
2034
1599
        client.add_success_response_with_body(rev_id, 'ok')
2035
1600
        client._medium._remember_remote_is_before((1, 2))
2036
 
        parents = repo.get_parent_map([rev_id])
 
1601
        expected_deprecations = [
 
1602
            'bzrlib.remote.RemoteRepository.get_revision_graph was deprecated '
 
1603
            'in version 1.4.']
 
1604
        parents = self.callDeprecated(
 
1605
            expected_deprecations, repo.get_parent_map, [rev_id])
2037
1606
        self.assertEqual(
2038
1607
            [('call_expecting_body', 'Repository.get_revision_graph',
2039
1608
             ('quack/', ''))],
2047
1616
            errors.UnexpectedSmartServerResponse,
2048
1617
            repo.get_parent_map, ['a-revision-id'])
2049
1618
 
2050
 
    def test_get_parent_map_negative_caches_missing_keys(self):
2051
 
        self.setup_smart_server_with_call_log()
2052
 
        repo = self.make_repository('foo')
2053
 
        self.assertIsInstance(repo, RemoteRepository)
2054
 
        repo.lock_read()
2055
 
        self.addCleanup(repo.unlock)
2056
 
        self.reset_smart_call_log()
2057
 
        graph = repo.get_graph()
2058
 
        self.assertEqual({},
2059
 
            graph.get_parent_map(['some-missing', 'other-missing']))
2060
 
        self.assertLength(1, self.hpss_calls)
2061
 
        # No call if we repeat this
2062
 
        self.reset_smart_call_log()
2063
 
        graph = repo.get_graph()
2064
 
        self.assertEqual({},
2065
 
            graph.get_parent_map(['some-missing', 'other-missing']))
2066
 
        self.assertLength(0, self.hpss_calls)
2067
 
        # Asking for more unknown keys makes a request.
2068
 
        self.reset_smart_call_log()
2069
 
        graph = repo.get_graph()
2070
 
        self.assertEqual({},
2071
 
            graph.get_parent_map(['some-missing', 'other-missing',
2072
 
                'more-missing']))
2073
 
        self.assertLength(1, self.hpss_calls)
2074
 
 
2075
 
    def disableExtraResults(self):
2076
 
        self.overrideAttr(SmartServerRepositoryGetParentMap,
2077
 
                          'no_extra_results', True)
2078
 
 
2079
 
    def test_null_cached_missing_and_stop_key(self):
2080
 
        self.setup_smart_server_with_call_log()
2081
 
        # Make a branch with a single revision.
2082
 
        builder = self.make_branch_builder('foo')
2083
 
        builder.start_series()
2084
 
        builder.build_snapshot('first', None, [
2085
 
            ('add', ('', 'root-id', 'directory', ''))])
2086
 
        builder.finish_series()
2087
 
        branch = builder.get_branch()
2088
 
        repo = branch.repository
2089
 
        self.assertIsInstance(repo, RemoteRepository)
2090
 
        # Stop the server from sending extra results.
2091
 
        self.disableExtraResults()
2092
 
        repo.lock_read()
2093
 
        self.addCleanup(repo.unlock)
2094
 
        self.reset_smart_call_log()
2095
 
        graph = repo.get_graph()
2096
 
        # Query for 'first' and 'null:'.  Because 'null:' is a parent of
2097
 
        # 'first' it will be a candidate for the stop_keys of subsequent
2098
 
        # requests, and because 'null:' was queried but not returned it will be
2099
 
        # cached as missing.
2100
 
        self.assertEqual({'first': ('null:',)},
2101
 
            graph.get_parent_map(['first', 'null:']))
2102
 
        # Now query for another key.  This request will pass along a recipe of
2103
 
        # start and stop keys describing the already cached results, and this
2104
 
        # recipe's revision count must be correct (or else it will trigger an
2105
 
        # error from the server).
2106
 
        self.assertEqual({}, graph.get_parent_map(['another-key']))
2107
 
        # This assertion guards against disableExtraResults silently failing to
2108
 
        # work, thus invalidating the test.
2109
 
        self.assertLength(2, self.hpss_calls)
2110
 
 
2111
 
    def test_get_parent_map_gets_ghosts_from_result(self):
2112
 
        # asking for a revision should negatively cache close ghosts in its
2113
 
        # ancestry.
2114
 
        self.setup_smart_server_with_call_log()
2115
 
        tree = self.make_branch_and_memory_tree('foo')
2116
 
        tree.lock_write()
2117
 
        try:
2118
 
            builder = treebuilder.TreeBuilder()
2119
 
            builder.start_tree(tree)
2120
 
            builder.build([])
2121
 
            builder.finish_tree()
2122
 
            tree.set_parent_ids(['non-existant'], allow_leftmost_as_ghost=True)
2123
 
            rev_id = tree.commit('')
2124
 
        finally:
2125
 
            tree.unlock()
2126
 
        tree.lock_read()
2127
 
        self.addCleanup(tree.unlock)
2128
 
        repo = tree.branch.repository
2129
 
        self.assertIsInstance(repo, RemoteRepository)
2130
 
        # ask for rev_id
2131
 
        repo.get_parent_map([rev_id])
2132
 
        self.reset_smart_call_log()
2133
 
        # Now asking for rev_id's ghost parent should not make calls
2134
 
        self.assertEqual({}, repo.get_parent_map(['non-existant']))
2135
 
        self.assertLength(0, self.hpss_calls)
2136
 
 
2137
1619
 
2138
1620
class TestGetParentMapAllowsNew(tests.TestCaseWithTransport):
2139
1621
 
2140
1622
    def test_allows_new_revisions(self):
2141
1623
        """get_parent_map's results can be updated by commit."""
2142
 
        smart_server = test_server.SmartTCPServer_for_testing()
2143
 
        self.start_server(smart_server)
 
1624
        smart_server = server.SmartTCPServer_for_testing()
 
1625
        smart_server.setUp()
 
1626
        self.addCleanup(smart_server.tearDown)
2144
1627
        self.make_branch('branch')
2145
1628
        branch = Branch.open(smart_server.get_url() + '/branch')
2146
1629
        tree = branch.create_checkout('tree', lightweight=True)
2162
1645
        transport_path = 'empty'
2163
1646
        repo, client = self.setup_fake_client_and_repository(transport_path)
2164
1647
        client.add_success_response('notused')
2165
 
        # actual RemoteRepository.get_revision_graph is gone, but there's an
2166
 
        # equivalent private method for testing
2167
 
        result = repo._get_revision_graph(NULL_REVISION)
 
1648
        result = self.applyDeprecated(one_four, repo.get_revision_graph,
 
1649
            NULL_REVISION)
2168
1650
        self.assertEqual([], client._calls)
2169
1651
        self.assertEqual({}, result)
2170
1652
 
2178
1660
        transport_path = 'sinhala'
2179
1661
        repo, client = self.setup_fake_client_and_repository(transport_path)
2180
1662
        client.add_success_response_with_body(encoded_body, 'ok')
2181
 
        # actual RemoteRepository.get_revision_graph is gone, but there's an
2182
 
        # equivalent private method for testing
2183
 
        result = repo._get_revision_graph(None)
 
1663
        result = self.applyDeprecated(one_four, repo.get_revision_graph)
2184
1664
        self.assertEqual(
2185
1665
            [('call_expecting_body', 'Repository.get_revision_graph',
2186
1666
             ('sinhala/', ''))],
2199
1679
        transport_path = 'sinhala'
2200
1680
        repo, client = self.setup_fake_client_and_repository(transport_path)
2201
1681
        client.add_success_response_with_body(encoded_body, 'ok')
2202
 
        result = repo._get_revision_graph(r2)
 
1682
        result = self.applyDeprecated(one_four, repo.get_revision_graph, r2)
2203
1683
        self.assertEqual(
2204
1684
            [('call_expecting_body', 'Repository.get_revision_graph',
2205
1685
             ('sinhala/', r2))],
2213
1693
        client.add_error_response('nosuchrevision', revid)
2214
1694
        # also check that the right revision is reported in the error
2215
1695
        self.assertRaises(errors.NoSuchRevision,
2216
 
            repo._get_revision_graph, revid)
 
1696
            self.applyDeprecated, one_four, repo.get_revision_graph, revid)
2217
1697
        self.assertEqual(
2218
1698
            [('call_expecting_body', 'Repository.get_revision_graph',
2219
1699
             ('sinhala/', revid))],
2225
1705
        repo, client = self.setup_fake_client_and_repository(transport_path)
2226
1706
        client.add_error_response('AnUnexpectedError')
2227
1707
        e = self.assertRaises(errors.UnknownErrorFromSmartServer,
2228
 
            repo._get_revision_graph, revid)
 
1708
            self.applyDeprecated, one_four, repo.get_revision_graph, revid)
2229
1709
        self.assertEqual(('AnUnexpectedError',), e.error_tuple)
2230
1710
 
2231
1711
 
2232
 
class TestRepositoryGetRevIdForRevno(TestRemoteRepository):
2233
 
 
2234
 
    def test_ok(self):
2235
 
        repo, client = self.setup_fake_client_and_repository('quack')
2236
 
        client.add_expected_call(
2237
 
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2238
 
            'success', ('ok', 'rev-five'))
2239
 
        result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
2240
 
        self.assertEqual((True, 'rev-five'), result)
2241
 
        self.assertFinished(client)
2242
 
 
2243
 
    def test_history_incomplete(self):
2244
 
        repo, client = self.setup_fake_client_and_repository('quack')
2245
 
        client.add_expected_call(
2246
 
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2247
 
            'success', ('history-incomplete', 10, 'rev-ten'))
2248
 
        result = repo.get_rev_id_for_revno(5, (42, 'rev-foo'))
2249
 
        self.assertEqual((False, (10, 'rev-ten')), result)
2250
 
        self.assertFinished(client)
2251
 
 
2252
 
    def test_history_incomplete_with_fallback(self):
2253
 
        """A 'history-incomplete' response causes the fallback repository to be
2254
 
        queried too, if one is set.
2255
 
        """
2256
 
        # Make a repo with a fallback repo, both using a FakeClient.
2257
 
        format = remote.response_tuple_to_repo_format(
2258
 
            ('yes', 'no', 'yes', self.get_repo_format().network_name()))
2259
 
        repo, client = self.setup_fake_client_and_repository('quack')
2260
 
        repo._format = format
2261
 
        fallback_repo, ignored = self.setup_fake_client_and_repository(
2262
 
            'fallback')
2263
 
        fallback_repo._client = client
2264
 
        fallback_repo._format = format
2265
 
        repo.add_fallback_repository(fallback_repo)
2266
 
        # First the client should ask the primary repo
2267
 
        client.add_expected_call(
2268
 
            'Repository.get_rev_id_for_revno', ('quack/', 1, (42, 'rev-foo')),
2269
 
            'success', ('history-incomplete', 2, 'rev-two'))
2270
 
        # Then it should ask the fallback, using revno/revid from the
2271
 
        # history-incomplete response as the known revno/revid.
2272
 
        client.add_expected_call(
2273
 
            'Repository.get_rev_id_for_revno',('fallback/', 1, (2, 'rev-two')),
2274
 
            'success', ('ok', 'rev-one'))
2275
 
        result = repo.get_rev_id_for_revno(1, (42, 'rev-foo'))
2276
 
        self.assertEqual((True, 'rev-one'), result)
2277
 
        self.assertFinished(client)
2278
 
 
2279
 
    def test_nosuchrevision(self):
2280
 
        # 'nosuchrevision' is returned when the known-revid is not found in the
2281
 
        # remote repo.  The client translates that response to NoSuchRevision.
2282
 
        repo, client = self.setup_fake_client_and_repository('quack')
2283
 
        client.add_expected_call(
2284
 
            'Repository.get_rev_id_for_revno', ('quack/', 5, (42, 'rev-foo')),
2285
 
            'error', ('nosuchrevision', 'rev-foo'))
2286
 
        self.assertRaises(
2287
 
            errors.NoSuchRevision,
2288
 
            repo.get_rev_id_for_revno, 5, (42, 'rev-foo'))
2289
 
        self.assertFinished(client)
2290
 
 
2291
 
    def test_branch_fallback_locking(self):
2292
 
        """RemoteBranch.get_rev_id takes a read lock, and tries to call the
2293
 
        get_rev_id_for_revno verb.  If the verb is unknown the VFS fallback
2294
 
        will be invoked, which will fail if the repo is unlocked.
2295
 
        """
2296
 
        self.setup_smart_server_with_call_log()
2297
 
        tree = self.make_branch_and_memory_tree('.')
2298
 
        tree.lock_write()
2299
 
        tree.add('')
2300
 
        rev1 = tree.commit('First')
2301
 
        rev2 = tree.commit('Second')
2302
 
        tree.unlock()
2303
 
        branch = tree.branch
2304
 
        self.assertFalse(branch.is_locked())
2305
 
        self.reset_smart_call_log()
2306
 
        verb = 'Repository.get_rev_id_for_revno'
2307
 
        self.disable_verb(verb)
2308
 
        self.assertEqual(rev1, branch.get_rev_id(1))
2309
 
        self.assertLength(1, [call for call in self.hpss_calls if
2310
 
                              call.call.method == verb])
2311
 
 
2312
 
 
2313
1712
class TestRepositoryIsShared(TestRemoteRepository):
2314
1713
 
2315
1714
    def test_is_shared(self):
2341
1740
        transport_path = 'quack'
2342
1741
        repo, client = self.setup_fake_client_and_repository(transport_path)
2343
1742
        client.add_success_response('ok', 'a token')
2344
 
        token = repo.lock_write().repository_token
 
1743
        result = repo.lock_write()
2345
1744
        self.assertEqual(
2346
1745
            [('call', 'Repository.lock_write', ('quack/', ''))],
2347
1746
            client._calls)
2348
 
        self.assertEqual('a token', token)
 
1747
        self.assertEqual('a token', result)
2349
1748
 
2350
1749
    def test_lock_write_already_locked(self):
2351
1750
        transport_path = 'quack'
2430
1829
        self.assertEqual([], client._calls)
2431
1830
 
2432
1831
 
2433
 
class TestRepositoryInsertStreamBase(TestRemoteRepository):
2434
 
    """Base class for Repository.insert_stream and .insert_stream_1.19
2435
 
    tests.
2436
 
    """
2437
 
    
2438
 
    def checkInsertEmptyStream(self, repo, client):
2439
 
        """Insert an empty stream, checking the result.
2440
 
 
2441
 
        This checks that there are no resume_tokens or missing_keys, and that
2442
 
        the client is finished.
2443
 
        """
2444
 
        sink = repo._get_sink()
2445
 
        fmt = repository.RepositoryFormat.get_default_format()
2446
 
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2447
 
        self.assertEqual([], resume_tokens)
2448
 
        self.assertEqual(set(), missing_keys)
2449
 
        self.assertFinished(client)
2450
 
 
2451
 
 
2452
 
class TestRepositoryInsertStream(TestRepositoryInsertStreamBase):
2453
 
    """Tests for using Repository.insert_stream verb when the _1.19 variant is
2454
 
    not available.
2455
 
 
2456
 
    This test case is very similar to TestRepositoryInsertStream_1_19.
2457
 
    """
2458
 
 
2459
 
    def setUp(self):
2460
 
        TestRemoteRepository.setUp(self)
2461
 
        self.disable_verb('Repository.insert_stream_1.19')
2462
 
 
2463
 
    def test_unlocked_repo(self):
2464
 
        transport_path = 'quack'
2465
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2466
 
        client.add_expected_call(
2467
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2468
 
            'unknown', ('Repository.insert_stream_1.19',))
2469
 
        client.add_expected_call(
2470
 
            'Repository.insert_stream', ('quack/', ''),
2471
 
            'success', ('ok',))
2472
 
        client.add_expected_call(
2473
 
            'Repository.insert_stream', ('quack/', ''),
2474
 
            'success', ('ok',))
2475
 
        self.checkInsertEmptyStream(repo, client)
2476
 
 
2477
 
    def test_locked_repo_with_no_lock_token(self):
2478
 
        transport_path = 'quack'
2479
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2480
 
        client.add_expected_call(
2481
 
            'Repository.lock_write', ('quack/', ''),
2482
 
            'success', ('ok', ''))
2483
 
        client.add_expected_call(
2484
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2485
 
            'unknown', ('Repository.insert_stream_1.19',))
2486
 
        client.add_expected_call(
2487
 
            'Repository.insert_stream', ('quack/', ''),
2488
 
            'success', ('ok',))
2489
 
        client.add_expected_call(
2490
 
            'Repository.insert_stream', ('quack/', ''),
2491
 
            'success', ('ok',))
2492
 
        repo.lock_write()
2493
 
        self.checkInsertEmptyStream(repo, client)
2494
 
 
2495
 
    def test_locked_repo_with_lock_token(self):
2496
 
        transport_path = 'quack'
2497
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2498
 
        client.add_expected_call(
2499
 
            'Repository.lock_write', ('quack/', ''),
2500
 
            'success', ('ok', 'a token'))
2501
 
        client.add_expected_call(
2502
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2503
 
            'unknown', ('Repository.insert_stream_1.19',))
2504
 
        client.add_expected_call(
2505
 
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2506
 
            'success', ('ok',))
2507
 
        client.add_expected_call(
2508
 
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
2509
 
            'success', ('ok',))
2510
 
        repo.lock_write()
2511
 
        self.checkInsertEmptyStream(repo, client)
2512
 
 
2513
 
    def test_stream_with_inventory_deltas(self):
2514
 
        """'inventory-deltas' substreams cannot be sent to the
2515
 
        Repository.insert_stream verb, because not all servers that implement
2516
 
        that verb will accept them.  So when one is encountered the RemoteSink
2517
 
        immediately stops using that verb and falls back to VFS insert_stream.
2518
 
        """
2519
 
        transport_path = 'quack'
2520
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2521
 
        client.add_expected_call(
2522
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2523
 
            'unknown', ('Repository.insert_stream_1.19',))
2524
 
        client.add_expected_call(
2525
 
            'Repository.insert_stream', ('quack/', ''),
2526
 
            'success', ('ok',))
2527
 
        client.add_expected_call(
2528
 
            'Repository.insert_stream', ('quack/', ''),
2529
 
            'success', ('ok',))
2530
 
        # Create a fake real repository for insert_stream to fall back on, so
2531
 
        # that we can directly see the records the RemoteSink passes to the
2532
 
        # real sink.
2533
 
        class FakeRealSink:
2534
 
            def __init__(self):
2535
 
                self.records = []
2536
 
            def insert_stream(self, stream, src_format, resume_tokens):
2537
 
                for substream_kind, substream in stream:
2538
 
                    self.records.append(
2539
 
                        (substream_kind, [record.key for record in substream]))
2540
 
                return ['fake tokens'], ['fake missing keys']
2541
 
        fake_real_sink = FakeRealSink()
2542
 
        class FakeRealRepository:
2543
 
            def _get_sink(self):
2544
 
                return fake_real_sink
2545
 
            def is_in_write_group(self):
2546
 
                return False
2547
 
            def refresh_data(self):
2548
 
                return True
2549
 
        repo._real_repository = FakeRealRepository()
2550
 
        sink = repo._get_sink()
2551
 
        fmt = repository.RepositoryFormat.get_default_format()
2552
 
        stream = self.make_stream_with_inv_deltas(fmt)
2553
 
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2554
 
        # Every record from the first inventory delta should have been sent to
2555
 
        # the VFS sink.
2556
 
        expected_records = [
2557
 
            ('inventory-deltas', [('rev2',), ('rev3',)]),
2558
 
            ('texts', [('some-rev', 'some-file')])]
2559
 
        self.assertEqual(expected_records, fake_real_sink.records)
2560
 
        # The return values from the real sink's insert_stream are propagated
2561
 
        # back to the original caller.
2562
 
        self.assertEqual(['fake tokens'], resume_tokens)
2563
 
        self.assertEqual(['fake missing keys'], missing_keys)
2564
 
        self.assertFinished(client)
2565
 
 
2566
 
    def make_stream_with_inv_deltas(self, fmt):
2567
 
        """Make a simple stream with an inventory delta followed by more
2568
 
        records and more substreams to test that all records and substreams
2569
 
        from that point on are used.
2570
 
 
2571
 
        This sends, in order:
2572
 
           * inventories substream: rev1, rev2, rev3.  rev2 and rev3 are
2573
 
             inventory-deltas.
2574
 
           * texts substream: (some-rev, some-file)
2575
 
        """
2576
 
        # Define a stream using generators so that it isn't rewindable.
2577
 
        inv = inventory.Inventory(revision_id='rev1')
2578
 
        inv.root.revision = 'rev1'
2579
 
        def stream_with_inv_delta():
2580
 
            yield ('inventories', inventories_substream())
2581
 
            yield ('inventory-deltas', inventory_delta_substream())
2582
 
            yield ('texts', [
2583
 
                versionedfile.FulltextContentFactory(
2584
 
                    ('some-rev', 'some-file'), (), None, 'content')])
2585
 
        def inventories_substream():
2586
 
            # An empty inventory fulltext.  This will be streamed normally.
2587
 
            text = fmt._serializer.write_inventory_to_string(inv)
2588
 
            yield versionedfile.FulltextContentFactory(
2589
 
                ('rev1',), (), None, text)
2590
 
        def inventory_delta_substream():
2591
 
            # An inventory delta.  This can't be streamed via this verb, so it
2592
 
            # will trigger a fallback to VFS insert_stream.
2593
 
            entry = inv.make_entry(
2594
 
                'directory', 'newdir', inv.root.file_id, 'newdir-id')
2595
 
            entry.revision = 'ghost'
2596
 
            delta = [(None, 'newdir', 'newdir-id', entry)]
2597
 
            serializer = inventory_delta.InventoryDeltaSerializer(
2598
 
                versioned_root=True, tree_references=False)
2599
 
            lines = serializer.delta_to_lines('rev1', 'rev2', delta)
2600
 
            yield versionedfile.ChunkedContentFactory(
2601
 
                ('rev2',), (('rev1',)), None, lines)
2602
 
            # Another delta.
2603
 
            lines = serializer.delta_to_lines('rev1', 'rev3', delta)
2604
 
            yield versionedfile.ChunkedContentFactory(
2605
 
                ('rev3',), (('rev1',)), None, lines)
2606
 
        return stream_with_inv_delta()
2607
 
 
2608
 
 
2609
 
class TestRepositoryInsertStream_1_19(TestRepositoryInsertStreamBase):
2610
 
 
2611
 
    def test_unlocked_repo(self):
2612
 
        transport_path = 'quack'
2613
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2614
 
        client.add_expected_call(
2615
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2616
 
            'success', ('ok',))
2617
 
        client.add_expected_call(
2618
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2619
 
            'success', ('ok',))
2620
 
        self.checkInsertEmptyStream(repo, client)
2621
 
 
2622
 
    def test_locked_repo_with_no_lock_token(self):
2623
 
        transport_path = 'quack'
2624
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2625
 
        client.add_expected_call(
2626
 
            'Repository.lock_write', ('quack/', ''),
2627
 
            'success', ('ok', ''))
2628
 
        client.add_expected_call(
2629
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2630
 
            'success', ('ok',))
2631
 
        client.add_expected_call(
2632
 
            'Repository.insert_stream_1.19', ('quack/', ''),
2633
 
            'success', ('ok',))
2634
 
        repo.lock_write()
2635
 
        self.checkInsertEmptyStream(repo, client)
2636
 
 
2637
 
    def test_locked_repo_with_lock_token(self):
2638
 
        transport_path = 'quack'
2639
 
        repo, client = self.setup_fake_client_and_repository(transport_path)
2640
 
        client.add_expected_call(
2641
 
            'Repository.lock_write', ('quack/', ''),
2642
 
            'success', ('ok', 'a token'))
2643
 
        client.add_expected_call(
2644
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2645
 
            'success', ('ok',))
2646
 
        client.add_expected_call(
2647
 
            'Repository.insert_stream_1.19', ('quack/', '', 'a token'),
2648
 
            'success', ('ok',))
2649
 
        repo.lock_write()
2650
 
        self.checkInsertEmptyStream(repo, client)
 
1832
class TestRepositoryInsertStream(TestRemoteRepository):
 
1833
 
 
1834
    def test_unlocked_repo(self):
 
1835
        transport_path = 'quack'
 
1836
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
1837
        client.add_expected_call(
 
1838
            'Repository.insert_stream', ('quack/', ''),
 
1839
            'success', ('ok',))
 
1840
        client.add_expected_call(
 
1841
            'Repository.insert_stream', ('quack/', ''),
 
1842
            'success', ('ok',))
 
1843
        sink = repo._get_sink()
 
1844
        fmt = repository.RepositoryFormat.get_default_format()
 
1845
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
1846
        self.assertEqual([], resume_tokens)
 
1847
        self.assertEqual(set(), missing_keys)
 
1848
        client.finished_test()
 
1849
 
 
1850
    def test_locked_repo_with_no_lock_token(self):
 
1851
        transport_path = 'quack'
 
1852
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
1853
        client.add_expected_call(
 
1854
            'Repository.lock_write', ('quack/', ''),
 
1855
            'success', ('ok', ''))
 
1856
        client.add_expected_call(
 
1857
            'Repository.insert_stream', ('quack/', ''),
 
1858
            'success', ('ok',))
 
1859
        client.add_expected_call(
 
1860
            'Repository.insert_stream', ('quack/', ''),
 
1861
            'success', ('ok',))
 
1862
        repo.lock_write()
 
1863
        sink = repo._get_sink()
 
1864
        fmt = repository.RepositoryFormat.get_default_format()
 
1865
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
1866
        self.assertEqual([], resume_tokens)
 
1867
        self.assertEqual(set(), missing_keys)
 
1868
        client.finished_test()
 
1869
 
 
1870
    def test_locked_repo_with_lock_token(self):
 
1871
        transport_path = 'quack'
 
1872
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
1873
        client.add_expected_call(
 
1874
            'Repository.lock_write', ('quack/', ''),
 
1875
            'success', ('ok', 'a token'))
 
1876
        client.add_expected_call(
 
1877
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
 
1878
            'success', ('ok',))
 
1879
        client.add_expected_call(
 
1880
            'Repository.insert_stream_locked', ('quack/', '', 'a token'),
 
1881
            'success', ('ok',))
 
1882
        repo.lock_write()
 
1883
        sink = repo._get_sink()
 
1884
        fmt = repository.RepositoryFormat.get_default_format()
 
1885
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
 
1886
        self.assertEqual([], resume_tokens)
 
1887
        self.assertEqual(set(), missing_keys)
 
1888
        client.finished_test()
2651
1889
 
2652
1890
 
2653
1891
class TestRepositoryTarball(TestRemoteRepository):
2689
1927
    """RemoteRepository.copy_content_into optimizations"""
2690
1928
 
2691
1929
    def test_copy_content_remote_to_local(self):
2692
 
        self.transport_server = test_server.SmartTCPServer_for_testing
 
1930
        self.transport_server = server.SmartTCPServer_for_testing
2693
1931
        src_repo = self.make_repository('repo1')
2694
1932
        src_repo = repository.Repository.open(self.get_url('repo1'))
2695
1933
        # At the moment the tarball-based copy_content_into can't write back
2738
1976
        client.add_expected_call(
2739
1977
            'PackRepository.autopack', ('quack/',), 'success', ('ok',))
2740
1978
        repo.autopack()
2741
 
        self.assertFinished(client)
 
1979
        client.finished_test()
2742
1980
 
2743
1981
    def test_ok_with_real_repo(self):
2744
1982
        """When the server returns 'ok' and there is a _real_repository, then
2843
2081
        expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
2844
2082
        self.assertEqual(expected_error, translated_error)
2845
2083
 
2846
 
    def test_nobranch_one_arg(self):
2847
 
        bzrdir = self.make_bzrdir('')
2848
 
        translated_error = self.translateTuple(
2849
 
            ('nobranch', 'extra detail'), bzrdir=bzrdir)
2850
 
        expected_error = errors.NotBranchError(
2851
 
            path=bzrdir.root_transport.base,
2852
 
            detail='extra detail')
2853
 
        self.assertEqual(expected_error, translated_error)
2854
 
 
2855
2084
    def test_LockContention(self):
2856
2085
        translated_error = self.translateTuple(('LockContention',))
2857
2086
        expected_error = errors.LockContention('(remote lock)')
2897
2126
        expected_error = errors.ReadError(path)
2898
2127
        self.assertEqual(expected_error, translated_error)
2899
2128
 
2900
 
    def test_IncompatibleRepositories(self):
2901
 
        translated_error = self.translateTuple(('IncompatibleRepositories',
2902
 
            "repo1", "repo2", "details here"))
2903
 
        expected_error = errors.IncompatibleRepositories("repo1", "repo2",
2904
 
            "details here")
2905
 
        self.assertEqual(expected_error, translated_error)
2906
 
 
2907
2129
    def test_PermissionDenied_no_args(self):
2908
2130
        path = 'a path'
2909
2131
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
2970
2192
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2971
2193
        # been muttered to the log file for developer to look at.
2972
2194
        self.assertContainsRe(
2973
 
            self.get_log(),
 
2195
            self._get_log(keep_log_file=True),
2974
2196
            "Missing key 'branch' in context")
2975
2197
 
2976
2198
    def test_path_missing(self):
2984
2206
        self.assertEqual(server_error, translated_error)
2985
2207
        # In addition to re-raising ErrorFromSmartServer, some debug info has
2986
2208
        # been muttered to the log file for developer to look at.
2987
 
        self.assertContainsRe(self.get_log(), "Missing key 'path' in context")
 
2209
        self.assertContainsRe(
 
2210
            self._get_log(keep_log_file=True), "Missing key 'path' in context")
2988
2211
 
2989
2212
 
2990
2213
class TestStacking(tests.TestCaseWithTransport):
3008
2231
        stacked_branch = self.make_branch('stacked', format='1.9')
3009
2232
        stacked_branch.set_stacked_on_url('../base')
3010
2233
        # start a server looking at this
3011
 
        smart_server = test_server.SmartTCPServer_for_testing()
3012
 
        self.start_server(smart_server)
 
2234
        smart_server = server.SmartTCPServer_for_testing()
 
2235
        smart_server.setUp()
 
2236
        self.addCleanup(smart_server.tearDown)
3013
2237
        remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
3014
2238
        # can get its branch and repository
3015
2239
        remote_branch = remote_bzrdir.open_branch()
3018
2242
        try:
3019
2243
            # it should have an appropriate fallback repository, which should also
3020
2244
            # be a RemoteRepository
3021
 
            self.assertLength(1, remote_repo._fallback_repositories)
 
2245
            self.assertEquals(len(remote_repo._fallback_repositories), 1)
3022
2246
            self.assertIsInstance(remote_repo._fallback_repositories[0],
3023
2247
                RemoteRepository)
3024
2248
            # and it has the revision committed to the underlying repository;
3037
2261
        tree1.commit('rev1', rev_id='rev1')
3038
2262
        tree2 = tree1.branch.bzrdir.sprout('tree2', stacked=True
3039
2263
            ).open_workingtree()
3040
 
        local_tree = tree2.branch.create_checkout('local')
3041
 
        local_tree.commit('local changes make me feel good.')
 
2264
        tree2.commit('local changes make me feel good.')
3042
2265
        branch2 = Branch.open(self.get_url('tree2'))
3043
2266
        branch2.lock_read()
3044
2267
        self.addCleanup(branch2.unlock)
3066
2289
                    result.append(content.key[-1])
3067
2290
        return result
3068
2291
 
3069
 
    def get_ordered_revs(self, format, order, branch_factory=None):
 
2292
    def get_ordered_revs(self, format, order):
3070
2293
        """Get a list of the revisions in a stream to format format.
3071
2294
 
3072
2295
        :param format: The format of the target.
3073
2296
        :param order: the order that target should have requested.
3074
 
        :param branch_factory: A callable to create a trunk and stacked branch
3075
 
            to fetch from. If none, self.prepare_stacked_remote_branch is used.
3076
2297
        :result: The revision ids in the stream, in the order seen,
3077
2298
            the topological order of revisions in the source.
3078
2299
        """
3080
2301
        target_repository_format = unordered_format.repository_format
3081
2302
        # Cross check
3082
2303
        self.assertEqual(order, target_repository_format._fetch_order)
3083
 
        if branch_factory is None:
3084
 
            branch_factory = self.prepare_stacked_remote_branch
3085
 
        _, stacked = branch_factory()
 
2304
        trunk, stacked = self.prepare_stacked_remote_branch()
3086
2305
        source = stacked.repository._get_source(target_repository_format)
3087
2306
        tip = stacked.last_revision()
3088
2307
        revs = stacked.repository.get_ancestry(tip)
3107
2326
        # from the server, then one from the backing branch.
3108
2327
        self.assertLength(2, self.hpss_calls)
3109
2328
 
3110
 
    def test_stacked_on_stacked_get_stream_unordered(self):
3111
 
        # Repository._get_source.get_stream() from a stacked repository which
3112
 
        # is itself stacked yields the full data from all three sources.
3113
 
        def make_stacked_stacked():
3114
 
            _, stacked = self.prepare_stacked_remote_branch()
3115
 
            tree = stacked.bzrdir.sprout('tree3', stacked=True
3116
 
                ).open_workingtree()
3117
 
            local_tree = tree.branch.create_checkout('local-tree3')
3118
 
            local_tree.commit('more local changes are better')
3119
 
            branch = Branch.open(self.get_url('tree3'))
3120
 
            branch.lock_read()
3121
 
            self.addCleanup(branch.unlock)
3122
 
            return None, branch
3123
 
        rev_ord, expected_revs = self.get_ordered_revs('1.9', 'unordered',
3124
 
            branch_factory=make_stacked_stacked)
3125
 
        self.assertEqual(set(expected_revs), set(rev_ord))
3126
 
        # Getting unordered results should have made a streaming data request
3127
 
        # from the server, and one from each backing repo
3128
 
        self.assertLength(3, self.hpss_calls)
3129
 
 
3130
2329
    def test_stacked_get_stream_topological(self):
3131
2330
        # Repository._get_source.get_stream() from a stacked repository with
3132
2331
        # topological sorting yields the full data from both stacked and
3133
2332
        # stacked upon sources in topological order.
3134
2333
        rev_ord, expected_revs = self.get_ordered_revs('knit', 'topological')
3135
2334
        self.assertEqual(expected_revs, rev_ord)
3136
 
        # Getting topological sort requires VFS calls still - one of which is
3137
 
        # pushing up from the bound branch.
3138
 
        self.assertLength(13, self.hpss_calls)
 
2335
        # Getting topological sort requires VFS calls still
 
2336
        self.assertLength(14, self.hpss_calls)
3139
2337
 
3140
2338
    def test_stacked_get_stream_groupcompress(self):
3141
2339
        # Repository._get_source.get_stream() from a stacked repository with
3148
2346
        # from the backing branch, and one from the stacked on branch.
3149
2347
        self.assertLength(2, self.hpss_calls)
3150
2348
 
3151
 
    def test_stacked_pull_more_than_stacking_has_bug_360791(self):
3152
 
        # When pulling some fixed amount of content that is more than the
3153
 
        # source has (because some is coming from a fallback branch, no error
3154
 
        # should be received. This was reported as bug 360791.
3155
 
        # Need three branches: a trunk, a stacked branch, and a preexisting
3156
 
        # branch pulling content from stacked and trunk.
3157
 
        self.setup_smart_server_with_call_log()
3158
 
        trunk = self.make_branch_and_tree('trunk', format="1.9-rich-root")
3159
 
        r1 = trunk.commit('start')
3160
 
        stacked_branch = trunk.branch.create_clone_on_transport(
3161
 
            self.get_transport('stacked'), stacked_on=trunk.branch.base)
3162
 
        local = self.make_branch('local', format='1.9-rich-root')
3163
 
        local.repository.fetch(stacked_branch.repository,
3164
 
            stacked_branch.last_revision())
3165
 
 
3166
2349
 
3167
2350
class TestRemoteBranchEffort(tests.TestCaseWithTransport):
3168
2351
 
3170
2353
        super(TestRemoteBranchEffort, self).setUp()
3171
2354
        # Create a smart server that publishes whatever the backing VFS server
3172
2355
        # does.
3173
 
        self.smart_server = test_server.SmartTCPServer_for_testing()
3174
 
        self.start_server(self.smart_server, self.get_server())
 
2356
        self.smart_server = server.SmartTCPServer_for_testing()
 
2357
        self.smart_server.setUp(self.get_server())
 
2358
        self.addCleanup(self.smart_server.tearDown)
3175
2359
        # Log all HPSS calls into self.hpss_calls.
3176
2360
        _SmartClient.hooks.install_named_hook(
3177
2361
            'call', self.capture_hpss_call, None)