← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_remote.py

  • Committer: Vincent Ladeuil
  • Date: 2016-02-07 18:23:13 UTC
  • mto: (6615.3.1 2.7)
  • mto: This revision was merged to the branch mainline in revision 6620.
  • Revision ID: v.ladeuil+lp@free.fr-20160207182313-jwz7z3vj4mpyjn7y
Ensure http://pad.lv/1323805 won't come back.

Since the 2.6.0 release pypi policy changed and release tarballs can't be
hosted on launchpad anymore, they have to be uploaded to
http://pypi.python.org/pypi


This fixes setup.py sdist to generate the right tarball with nearly the same
content as the one produced for 2.7.0.

Such a tarball have been uploaded to pypi properly signed and tested for
installation in venv.

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-2013, 2016 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
25
25
 
26
26
import bz2
27
27
from cStringIO import StringIO
 
28
import zlib
28
29
 
29
30
from bzrlib import (
 
31
    bencode,
30
32
    branch,
31
33
    bzrdir,
32
34
    config,
 
35
    controldir,
33
36
    errors,
34
 
    graph,
35
37
    inventory,
36
38
    inventory_delta,
37
 
    pack,
38
39
    remote,
39
40
    repository,
40
41
    tests,
41
42
    transport,
42
43
    treebuilder,
43
 
    urlutils,
44
44
    versionedfile,
 
45
    vf_search,
45
46
    )
46
47
from bzrlib.branch import Branch
47
 
from bzrlib.bzrdir import BzrDir, BzrDirFormat
 
48
from bzrlib.bzrdir import (
 
49
    BzrDir,
 
50
    BzrDirFormat,
 
51
    RemoteBzrProber,
 
52
    )
 
53
from bzrlib.chk_serializer import chk_bencode_serializer
48
54
from bzrlib.remote import (
49
55
    RemoteBranch,
50
56
    RemoteBranchFormat,
53
59
    RemoteRepository,
54
60
    RemoteRepositoryFormat,
55
61
    )
56
 
from bzrlib.repofmt import groupcompress_repo, pack_repo
57
 
from bzrlib.revision import NULL_REVISION
58
 
from bzrlib.smart import medium
 
62
from bzrlib.repofmt import groupcompress_repo, knitpack_repo
 
63
from bzrlib.revision import (
 
64
    NULL_REVISION,
 
65
    Revision,
 
66
    )
 
67
from bzrlib.smart import medium, request
59
68
from bzrlib.smart.client import _SmartClient
60
 
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
 
69
from bzrlib.smart.repository import (
 
70
    SmartServerRepositoryGetParentMap,
 
71
    SmartServerRepositoryGetStream_1_19,
 
72
    _stream_to_byte_stream,
 
73
    )
 
74
from bzrlib.symbol_versioning import deprecated_in
61
75
from bzrlib.tests import (
62
 
    condition_isinstance,
63
 
    split_suite_by_condition,
64
 
    multiply_tests,
65
76
    test_server,
66
77
    )
 
78
from bzrlib.tests.scenarios import load_tests_apply_scenarios
67
79
from bzrlib.transport.memory import MemoryTransport
68
80
from bzrlib.transport.remote import (
69
81
    RemoteTransport,
70
82
    RemoteSSHTransport,
71
83
    RemoteTCPTransport,
72
 
)
73
 
 
74
 
def load_tests(standard_tests, module, loader):
75
 
    to_adapt, result = split_suite_by_condition(
76
 
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
77
 
    smart_server_version_scenarios = [
 
84
    )
 
85
 
 
86
 
 
87
load_tests = load_tests_apply_scenarios
 
88
 
 
89
 
 
90
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
 
91
 
 
92
    scenarios = [
78
93
        ('HPSS-v2',
79
 
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
 
94
            {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
80
95
        ('HPSS-v3',
81
 
         {'transport_server': test_server.SmartTCPServer_for_testing})]
82
 
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
83
 
 
84
 
 
85
 
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
 
96
            {'transport_server': test_server.SmartTCPServer_for_testing})]
 
97
 
86
98
 
87
99
    def setUp(self):
88
100
        super(BasicRemoteObjectTests, self).setUp()
92
104
        self.addCleanup(self.transport.disconnect)
93
105
 
94
106
    def test_create_remote_bzrdir(self):
95
 
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
 
107
        b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
96
108
        self.assertIsInstance(b, BzrDir)
97
109
 
98
110
    def test_open_remote_branch(self):
99
111
        # open a standalone branch in the working directory
100
 
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
 
112
        b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
101
113
        branch = b.open_branch()
102
114
        self.assertIsInstance(branch, Branch)
103
115
 
109
121
        self.local_wt.commit(message='test commit', rev_id=revid)
110
122
        self.assertTrue(repo.has_revision(revid))
111
123
 
112
 
    def test_remote_branch_revision_history(self):
113
 
        b = BzrDir.open_from_transport(self.transport).open_branch()
114
 
        self.assertEqual([], b.revision_history())
115
 
        r1 = self.local_wt.commit('1st commit')
116
 
        r2 = self.local_wt.commit('1st commit', rev_id=u'\xc8'.encode('utf8'))
117
 
        self.assertEqual([r1, r2], b.revision_history())
118
 
 
119
124
    def test_find_correct_format(self):
120
125
        """Should open a RemoteBzrDir over a RemoteTransport"""
121
126
        fmt = BzrDirFormat.find_format(self.transport)
122
 
        self.assertTrue(RemoteBzrDirFormat
123
 
                        in BzrDirFormat._control_server_formats)
124
 
        self.assertIsInstance(fmt, remote.RemoteBzrDirFormat)
 
127
        self.assertTrue(bzrdir.RemoteBzrProber
 
128
                        in controldir.ControlDirFormat._server_probers)
 
129
        self.assertIsInstance(fmt, RemoteBzrDirFormat)
125
130
 
126
131
    def test_open_detected_smart_format(self):
127
132
        fmt = BzrDirFormat.find_format(self.transport)
161
166
    def test_remote_branch_set_append_revisions_only(self):
162
167
        # Make a format 1.9 branch, which supports append_revisions_only
163
168
        branch = self.make_branch('branch', format='1.9')
164
 
        config = branch.get_config()
165
169
        branch.set_append_revisions_only(True)
 
170
        config = branch.get_config_stack()
166
171
        self.assertEqual(
167
 
            'True', config.get_user_option('append_revisions_only'))
 
172
            True, config.get('append_revisions_only'))
168
173
        branch.set_append_revisions_only(False)
 
174
        config = branch.get_config_stack()
169
175
        self.assertEqual(
170
 
            'False', config.get_user_option('append_revisions_only'))
 
176
            False, config.get('append_revisions_only'))
171
177
 
172
178
    def test_remote_branch_set_append_revisions_only_upgrade_reqd(self):
173
179
        branch = self.make_branch('branch', format='knit')
174
 
        config = branch.get_config()
175
180
        self.assertRaises(
176
181
            errors.UpgradeRequired, branch.set_append_revisions_only, True)
177
182
 
335
340
class TestRemote(tests.TestCaseWithMemoryTransport):
336
341
 
337
342
    def get_branch_format(self):
338
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
343
        reference_bzrdir_format = controldir.format_registry.get('default')()
339
344
        return reference_bzrdir_format.get_branch_format()
340
345
 
341
346
    def get_repo_format(self):
342
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
347
        reference_bzrdir_format = controldir.format_registry.get('default')()
343
348
        return reference_bzrdir_format.repository_format
344
349
 
345
350
    def assertFinished(self, fake_client):
447
452
        client.add_expected_call(
448
453
            'BzrDir.open_branchV3', ('quack/',),
449
454
            'success', ('ref', self.get_url('referenced'))),
450
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
455
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
451
456
            _client=client)
452
457
        result = a_bzrdir.cloning_metadir()
453
458
        # We should have got a control dir matching the referenced branch.
461
466
        transport = transport.clone('quack')
462
467
        self.make_bzrdir('quack')
463
468
        client = FakeClient(transport.base)
464
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
469
        reference_bzrdir_format = controldir.format_registry.get('default')()
465
470
        control_name = reference_bzrdir_format.network_name()
466
471
        client.add_expected_call(
467
472
            'BzrDir.cloning_metadir', ('quack/', 'False'),
468
473
            'success', (control_name, '', ('branch', ''))),
469
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
474
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
470
475
            _client=client)
471
476
        result = a_bzrdir.cloning_metadir()
472
477
        # We should have got a reference control dir with default branch and
477
482
        self.assertEqual(None, result._branch_format)
478
483
        self.assertFinished(client)
479
484
 
 
485
    def test_unknown(self):
 
486
        transport = self.get_transport('quack')
 
487
        referenced = self.make_branch('referenced')
 
488
        expected = referenced.bzrdir.cloning_metadir()
 
489
        client = FakeClient(transport.base)
 
490
        client.add_expected_call(
 
491
            'BzrDir.cloning_metadir', ('quack/', 'False'),
 
492
            'success', ('unknown', 'unknown', ('branch', ''))),
 
493
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
494
            _client=client)
 
495
        self.assertRaises(errors.UnknownFormatError, a_bzrdir.cloning_metadir)
 
496
 
 
497
 
 
498
class TestBzrDirCheckoutMetaDir(TestRemote):
 
499
 
 
500
    def test__get_checkout_format(self):
 
501
        transport = MemoryTransport()
 
502
        client = FakeClient(transport.base)
 
503
        reference_bzrdir_format = controldir.format_registry.get('default')()
 
504
        control_name = reference_bzrdir_format.network_name()
 
505
        client.add_expected_call(
 
506
            'BzrDir.checkout_metadir', ('quack/', ),
 
507
            'success', (control_name, '', ''))
 
508
        transport.mkdir('quack')
 
509
        transport = transport.clone('quack')
 
510
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
511
            _client=client)
 
512
        result = a_bzrdir.checkout_metadir()
 
513
        # We should have got a reference control dir with default branch and
 
514
        # repository formats.
 
515
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
 
516
        self.assertEqual(None, result._repository_format)
 
517
        self.assertEqual(None, result._branch_format)
 
518
        self.assertFinished(client)
 
519
 
 
520
    def test_unknown_format(self):
 
521
        transport = MemoryTransport()
 
522
        client = FakeClient(transport.base)
 
523
        client.add_expected_call(
 
524
            'BzrDir.checkout_metadir', ('quack/',),
 
525
            'success', ('dontknow', '', ''))
 
526
        transport.mkdir('quack')
 
527
        transport = transport.clone('quack')
 
528
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
529
            _client=client)
 
530
        self.assertRaises(errors.UnknownFormatError,
 
531
            a_bzrdir.checkout_metadir)
 
532
        self.assertFinished(client)
 
533
 
 
534
 
 
535
class TestBzrDirGetBranches(TestRemote):
 
536
 
 
537
    def test_get_branches(self):
 
538
        transport = MemoryTransport()
 
539
        client = FakeClient(transport.base)
 
540
        reference_bzrdir_format = controldir.format_registry.get('default')()
 
541
        branch_name = reference_bzrdir_format.get_branch_format().network_name()
 
542
        client.add_success_response_with_body(
 
543
            bencode.bencode({
 
544
                "foo": ("branch", branch_name),
 
545
                "": ("branch", branch_name)}), "success")
 
546
        client.add_success_response(
 
547
            'ok', '', 'no', 'no', 'no',
 
548
                reference_bzrdir_format.repository_format.network_name())
 
549
        client.add_error_response('NotStacked')
 
550
        client.add_success_response(
 
551
            'ok', '', 'no', 'no', 'no',
 
552
                reference_bzrdir_format.repository_format.network_name())
 
553
        client.add_error_response('NotStacked')
 
554
        transport.mkdir('quack')
 
555
        transport = transport.clone('quack')
 
556
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
557
            _client=client)
 
558
        result = a_bzrdir.get_branches()
 
559
        self.assertEqual(set(["", "foo"]), set(result.keys()))
 
560
        self.assertEqual(
 
561
            [('call_expecting_body', 'BzrDir.get_branches', ('quack/',)),
 
562
             ('call', 'BzrDir.find_repositoryV3', ('quack/', )),
 
563
             ('call', 'Branch.get_stacked_on_url', ('quack/', )),
 
564
             ('call', 'BzrDir.find_repositoryV3', ('quack/', )),
 
565
             ('call', 'Branch.get_stacked_on_url', ('quack/', ))],
 
566
            client._calls)
 
567
 
 
568
 
 
569
class TestBzrDirDestroyBranch(TestRemote):
 
570
 
 
571
    def test_destroy_default(self):
 
572
        transport = self.get_transport('quack')
 
573
        referenced = self.make_branch('referenced')
 
574
        client = FakeClient(transport.base)
 
575
        client.add_expected_call(
 
576
            'BzrDir.destroy_branch', ('quack/', ),
 
577
            'success', ('ok',)),
 
578
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
579
            _client=client)
 
580
        a_bzrdir.destroy_branch()
 
581
        self.assertFinished(client)
 
582
 
 
583
 
 
584
class TestBzrDirHasWorkingTree(TestRemote):
 
585
 
 
586
    def test_has_workingtree(self):
 
587
        transport = self.get_transport('quack')
 
588
        client = FakeClient(transport.base)
 
589
        client.add_expected_call(
 
590
            'BzrDir.has_workingtree', ('quack/',),
 
591
            'success', ('yes',)),
 
592
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
593
            _client=client)
 
594
        self.assertTrue(a_bzrdir.has_workingtree())
 
595
        self.assertFinished(client)
 
596
 
 
597
    def test_no_workingtree(self):
 
598
        transport = self.get_transport('quack')
 
599
        client = FakeClient(transport.base)
 
600
        client.add_expected_call(
 
601
            'BzrDir.has_workingtree', ('quack/',),
 
602
            'success', ('no',)),
 
603
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
604
            _client=client)
 
605
        self.assertFalse(a_bzrdir.has_workingtree())
 
606
        self.assertFinished(client)
 
607
 
 
608
 
 
609
class TestBzrDirDestroyRepository(TestRemote):
 
610
 
 
611
    def test_destroy_repository(self):
 
612
        transport = self.get_transport('quack')
 
613
        client = FakeClient(transport.base)
 
614
        client.add_expected_call(
 
615
            'BzrDir.destroy_repository', ('quack/',),
 
616
            'success', ('ok',)),
 
617
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
618
            _client=client)
 
619
        a_bzrdir.destroy_repository()
 
620
        self.assertFinished(client)
 
621
 
480
622
 
481
623
class TestBzrDirOpen(TestRemote):
482
624
 
492
634
        client.add_expected_call(
493
635
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
494
636
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
495
 
                remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
 
637
                RemoteBzrDirFormat(), _client=client, _force_probe=True)
496
638
        self.assertFinished(client)
497
639
 
498
640
    def test_present_without_workingtree(self):
499
641
        client, transport = self.make_fake_client_and_transport()
500
642
        client.add_expected_call(
501
643
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
502
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
644
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
503
645
            _client=client, _force_probe=True)
504
646
        self.assertIsInstance(bd, RemoteBzrDir)
505
647
        self.assertFalse(bd.has_workingtree())
510
652
        client, transport = self.make_fake_client_and_transport()
511
653
        client.add_expected_call(
512
654
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
513
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
655
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
514
656
            _client=client, _force_probe=True)
515
657
        self.assertIsInstance(bd, RemoteBzrDir)
516
658
        self.assertTrue(bd.has_workingtree())
523
665
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
524
666
        client.add_expected_call(
525
667
            'BzrDir.open', ('quack/',), 'success', ('yes',))
526
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
668
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
527
669
            _client=client, _force_probe=True)
528
670
        self.assertIsInstance(bd, RemoteBzrDir)
529
671
        self.assertFinished(client)
545
687
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
546
688
        client.add_expected_call(
547
689
            'BzrDir.open', ('quack/',), 'success', ('yes',))
548
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
690
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
549
691
            _client=client, _force_probe=True)
550
692
        self.assertIsInstance(bd, RemoteBzrDir)
551
693
        self.assertFinished(client)
582
724
        client.add_expected_call(
583
725
            'Branch.get_stacked_on_url', ('quack/',),
584
726
            'error', ('NotStacked',))
585
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
727
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
586
728
            _client=client)
587
729
        result = bzrdir.open_branch()
588
730
        self.assertIsInstance(result, RemoteBranch)
595
737
        transport = transport.clone('quack')
596
738
        client = FakeClient(transport.base)
597
739
        client.add_error_response('nobranch')
598
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
740
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
599
741
            _client=client)
600
742
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
601
743
        self.assertEqual(
606
748
        # _get_tree_branch is a form of open_branch, but it should only ask for
607
749
        # branch opening, not any other network requests.
608
750
        calls = []
609
 
        def open_branch(name=None):
 
751
        def open_branch(name=None, possible_transports=None):
610
752
            calls.append("Called")
611
753
            return "a-branch"
612
754
        transport = MemoryTransport()
613
755
        # no requests on the network - catches other api calls being made.
614
756
        client = FakeClient(transport.base)
615
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
757
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
616
758
            _client=client)
617
759
        # patch the open_branch call to record that it was called.
618
760
        bzrdir.open_branch = open_branch
637
779
        client.add_expected_call(
638
780
            'Branch.get_stacked_on_url', ('~hello/',),
639
781
            'error', ('NotStacked',))
640
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
782
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
641
783
            _client=client)
642
784
        result = bzrdir.open_branch()
643
785
        self.assertFinished(client)
660
802
        client.add_success_response(
661
803
            'ok', '', rich_response, subtree_response, external_lookup,
662
804
            network_name)
663
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
805
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
664
806
            _client=client)
665
807
        result = bzrdir.open_repository()
666
808
        self.assertEqual(
683
825
        old.
684
826
        """
685
827
        self.assertRaises(errors.NotBranchError,
686
 
            RemoteBzrDirFormat.probe_transport, OldServerTransport())
 
828
            RemoteBzrProber.probe_transport, OldServerTransport())
687
829
 
688
830
 
689
831
class TestBzrDirCreateBranch(TestRemote):
703
845
        transport = transport.clone('quack')
704
846
        self.make_repository('quack')
705
847
        client = FakeClient(transport.base)
706
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
848
        reference_bzrdir_format = controldir.format_registry.get('default')()
707
849
        reference_format = reference_bzrdir_format.get_branch_format()
708
850
        network_name = reference_format.network_name()
709
851
        reference_repo_fmt = reference_bzrdir_format.repository_format
712
854
            'BzrDir.create_branch', ('quack/', network_name),
713
855
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
714
856
            reference_repo_name))
715
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
857
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
716
858
            _client=client)
717
859
        branch = a_bzrdir.create_branch()
718
860
        # We should have got a remote branch
721
863
        format = branch._format
722
864
        self.assertEqual(network_name, format.network_name())
723
865
 
 
866
    def test_already_open_repo_and_reused_medium(self):
 
867
        """Bug 726584: create_branch(..., repository=repo) should work
 
868
        regardless of what the smart medium's base URL is.
 
869
        """
 
870
        self.transport_server = test_server.SmartTCPServer_for_testing
 
871
        transport = self.get_transport('.')
 
872
        repo = self.make_repository('quack')
 
873
        # Client's medium rooted a transport root (not at the bzrdir)
 
874
        client = FakeClient(transport.base)
 
875
        transport = transport.clone('quack')
 
876
        reference_bzrdir_format = controldir.format_registry.get('default')()
 
877
        reference_format = reference_bzrdir_format.get_branch_format()
 
878
        network_name = reference_format.network_name()
 
879
        reference_repo_fmt = reference_bzrdir_format.repository_format
 
880
        reference_repo_name = reference_repo_fmt.network_name()
 
881
        client.add_expected_call(
 
882
            'BzrDir.create_branch', ('extra/quack/', network_name),
 
883
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
 
884
            reference_repo_name))
 
885
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
886
            _client=client)
 
887
        branch = a_bzrdir.create_branch(repository=repo)
 
888
        # We should have got a remote branch
 
889
        self.assertIsInstance(branch, remote.RemoteBranch)
 
890
        # its format should have the settings from the response
 
891
        format = branch._format
 
892
        self.assertEqual(network_name, format.network_name())
 
893
 
724
894
 
725
895
class TestBzrDirCreateRepository(TestRemote):
726
896
 
739
909
        transport = transport.clone('quack')
740
910
        self.make_bzrdir('quack')
741
911
        client = FakeClient(transport.base)
742
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
912
        reference_bzrdir_format = controldir.format_registry.get('default')()
743
913
        reference_format = reference_bzrdir_format.repository_format
744
914
        network_name = reference_format.network_name()
745
915
        client.add_expected_call(
747
917
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
748
918
                'False'),
749
919
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
750
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
920
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
751
921
            _client=client)
752
922
        repo = a_bzrdir.create_repository()
753
923
        # We should have got a remote repository
776
946
        # name.
777
947
        client.add_success_response_with_body(
778
948
            "Bazaar-NG meta directory, format 1\n", 'ok')
 
949
        client.add_success_response('stat', '0', '65535')
779
950
        client.add_success_response_with_body(
780
951
            reference_format.get_format_string(), 'ok')
781
952
        # PackRepository wants to do a stat
782
953
        client.add_success_response('stat', '0', '65535')
783
954
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
784
955
            _client=client)
785
 
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
 
956
        bzrdir = RemoteBzrDir(remote_transport, RemoteBzrDirFormat(),
786
957
            _client=client)
787
958
        repo = bzrdir.open_repository()
788
959
        self.assertEqual(
790
961
             ('call', 'BzrDir.find_repositoryV2', ('quack/',)),
791
962
             ('call', 'BzrDir.find_repository', ('quack/',)),
792
963
             ('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
 
964
             ('call', 'stat', ('/quack/.bzr',)),
793
965
             ('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
794
966
             ('call', 'stat', ('/quack/.bzr/repository',)),
795
967
             ],
809
981
        # name.
810
982
        client.add_success_response_with_body(
811
983
            "Bazaar-NG meta directory, format 1\n", 'ok')
 
984
        client.add_success_response('stat', '0', '65535')
812
985
        client.add_success_response_with_body(
813
986
            reference_format.get_format_string(), 'ok')
814
987
        # PackRepository wants to do a stat
815
988
        client.add_success_response('stat', '0', '65535')
816
989
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
817
990
            _client=client)
818
 
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
 
991
        bzrdir = RemoteBzrDir(remote_transport, RemoteBzrDirFormat(),
819
992
            _client=client)
820
993
        repo = bzrdir.open_repository()
821
994
        self.assertEqual(
822
995
            [('call', 'BzrDir.find_repositoryV3', ('quack/',)),
823
996
             ('call', 'BzrDir.find_repositoryV2', ('quack/',)),
824
997
             ('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
 
998
             ('call', 'stat', ('/quack/.bzr',)),
825
999
             ('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
826
1000
             ('call', 'stat', ('/quack/.bzr/repository',)),
827
1001
             ],
836
1010
        transport = transport.clone('quack')
837
1011
        client = FakeClient(transport.base)
838
1012
        client.add_success_response('ok', '', 'no', 'no', 'no', network_name)
839
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
1013
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
840
1014
            _client=client)
841
1015
        repo = bzrdir.open_repository()
842
1016
        self.assertEqual(
849
1023
 
850
1024
    def test_success(self):
851
1025
        """Simple test for typical successful call."""
852
 
        fmt = bzrdir.RemoteBzrDirFormat()
 
1026
        fmt = RemoteBzrDirFormat()
853
1027
        default_format_name = BzrDirFormat.get_default_format().network_name()
854
1028
        transport = self.get_transport()
855
1029
        client = FakeClient(transport.base)
871
1045
        """Error responses are translated, e.g. 'PermissionDenied' raises the
872
1046
        corresponding error from the client.
873
1047
        """
874
 
        fmt = bzrdir.RemoteBzrDirFormat()
 
1048
        fmt = RemoteBzrDirFormat()
875
1049
        default_format_name = BzrDirFormat.get_default_format().network_name()
876
1050
        transport = self.get_transport()
877
1051
        client = FakeClient(transport.base)
895
1069
        """Integration test for error translation."""
896
1070
        transport = self.make_smart_server('foo')
897
1071
        transport = transport.clone('no-such-path')
898
 
        fmt = bzrdir.RemoteBzrDirFormat()
 
1072
        fmt = RemoteBzrDirFormat()
899
1073
        err = self.assertRaises(errors.NoSuchFile,
900
1074
            fmt.initialize_on_transport_ex, transport, create_prefix=False)
901
1075
 
932
1106
 
933
1107
    def make_remote_bzrdir(self, transport, client):
934
1108
        """Make a RemotebzrDir using 'client' as the _client."""
935
 
        return RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
1109
        return RemoteBzrDir(transport, RemoteBzrDirFormat(),
936
1110
            _client=client)
937
1111
 
938
1112
 
964
1138
        return RemoteBranch(bzrdir, repo, _client=client, format=format)
965
1139
 
966
1140
 
 
1141
class TestBranchBreakLock(RemoteBranchTestCase):
 
1142
 
 
1143
    def test_break_lock(self):
 
1144
        transport_path = 'quack'
 
1145
        transport = MemoryTransport()
 
1146
        client = FakeClient(transport.base)
 
1147
        client.add_expected_call(
 
1148
            'Branch.get_stacked_on_url', ('quack/',),
 
1149
            'error', ('NotStacked',))
 
1150
        client.add_expected_call(
 
1151
            'Branch.break_lock', ('quack/',),
 
1152
            'success', ('ok',))
 
1153
        transport.mkdir('quack')
 
1154
        transport = transport.clone('quack')
 
1155
        branch = self.make_remote_branch(transport, client)
 
1156
        branch.break_lock()
 
1157
        self.assertFinished(client)
 
1158
 
 
1159
 
 
1160
class TestBranchGetPhysicalLockStatus(RemoteBranchTestCase):
 
1161
 
 
1162
    def test_get_physical_lock_status_yes(self):
 
1163
        transport = MemoryTransport()
 
1164
        client = FakeClient(transport.base)
 
1165
        client.add_expected_call(
 
1166
            'Branch.get_stacked_on_url', ('quack/',),
 
1167
            'error', ('NotStacked',))
 
1168
        client.add_expected_call(
 
1169
            'Branch.get_physical_lock_status', ('quack/',),
 
1170
            'success', ('yes',))
 
1171
        transport.mkdir('quack')
 
1172
        transport = transport.clone('quack')
 
1173
        branch = self.make_remote_branch(transport, client)
 
1174
        result = branch.get_physical_lock_status()
 
1175
        self.assertFinished(client)
 
1176
        self.assertEqual(True, result)
 
1177
 
 
1178
    def test_get_physical_lock_status_no(self):
 
1179
        transport = MemoryTransport()
 
1180
        client = FakeClient(transport.base)
 
1181
        client.add_expected_call(
 
1182
            'Branch.get_stacked_on_url', ('quack/',),
 
1183
            'error', ('NotStacked',))
 
1184
        client.add_expected_call(
 
1185
            'Branch.get_physical_lock_status', ('quack/',),
 
1186
            'success', ('no',))
 
1187
        transport.mkdir('quack')
 
1188
        transport = transport.clone('quack')
 
1189
        branch = self.make_remote_branch(transport, client)
 
1190
        result = branch.get_physical_lock_status()
 
1191
        self.assertFinished(client)
 
1192
        self.assertEqual(False, result)
 
1193
 
 
1194
 
967
1195
class TestBranchGetParent(RemoteBranchTestCase):
968
1196
 
969
1197
    def test_no_parent(self):
1059
1287
        verb = 'Branch.set_parent_location'
1060
1288
        self.disable_verb(verb)
1061
1289
        branch.set_parent('http://foo/')
1062
 
        self.assertLength(12, self.hpss_calls)
 
1290
        self.assertLength(14, self.hpss_calls)
1063
1291
 
1064
1292
 
1065
1293
class TestBranchGetTagsBytes(RemoteBranchTestCase):
1140
1368
            [('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1141
1369
 
1142
1370
 
 
1371
class TestBranchHeadsToFetch(RemoteBranchTestCase):
 
1372
 
 
1373
    def test_uses_last_revision_info_and_tags_by_default(self):
 
1374
        transport = MemoryTransport()
 
1375
        client = FakeClient(transport.base)
 
1376
        client.add_expected_call(
 
1377
            'Branch.get_stacked_on_url', ('quack/',),
 
1378
            'error', ('NotStacked',))
 
1379
        client.add_expected_call(
 
1380
            'Branch.last_revision_info', ('quack/',),
 
1381
            'success', ('ok', '1', 'rev-tip'))
 
1382
        client.add_expected_call(
 
1383
            'Branch.get_config_file', ('quack/',),
 
1384
            'success', ('ok',), '')
 
1385
        transport.mkdir('quack')
 
1386
        transport = transport.clone('quack')
 
1387
        branch = self.make_remote_branch(transport, client)
 
1388
        result = branch.heads_to_fetch()
 
1389
        self.assertFinished(client)
 
1390
        self.assertEqual((set(['rev-tip']), set()), result)
 
1391
 
 
1392
    def test_uses_last_revision_info_and_tags_when_set(self):
 
1393
        transport = MemoryTransport()
 
1394
        client = FakeClient(transport.base)
 
1395
        client.add_expected_call(
 
1396
            'Branch.get_stacked_on_url', ('quack/',),
 
1397
            'error', ('NotStacked',))
 
1398
        client.add_expected_call(
 
1399
            'Branch.last_revision_info', ('quack/',),
 
1400
            'success', ('ok', '1', 'rev-tip'))
 
1401
        client.add_expected_call(
 
1402
            'Branch.get_config_file', ('quack/',),
 
1403
            'success', ('ok',), 'branch.fetch_tags = True')
 
1404
        # XXX: this will break if the default format's serialization of tags
 
1405
        # changes, or if the RPC for fetching tags changes from get_tags_bytes.
 
1406
        client.add_expected_call(
 
1407
            'Branch.get_tags_bytes', ('quack/',),
 
1408
            'success', ('d5:tag-17:rev-foo5:tag-27:rev-bare',))
 
1409
        transport.mkdir('quack')
 
1410
        transport = transport.clone('quack')
 
1411
        branch = self.make_remote_branch(transport, client)
 
1412
        result = branch.heads_to_fetch()
 
1413
        self.assertFinished(client)
 
1414
        self.assertEqual(
 
1415
            (set(['rev-tip']), set(['rev-foo', 'rev-bar'])), result)
 
1416
 
 
1417
    def test_uses_rpc_for_formats_with_non_default_heads_to_fetch(self):
 
1418
        transport = MemoryTransport()
 
1419
        client = FakeClient(transport.base)
 
1420
        client.add_expected_call(
 
1421
            'Branch.get_stacked_on_url', ('quack/',),
 
1422
            'error', ('NotStacked',))
 
1423
        client.add_expected_call(
 
1424
            'Branch.heads_to_fetch', ('quack/',),
 
1425
            'success', (['tip'], ['tagged-1', 'tagged-2']))
 
1426
        transport.mkdir('quack')
 
1427
        transport = transport.clone('quack')
 
1428
        branch = self.make_remote_branch(transport, client)
 
1429
        branch._format._use_default_local_heads_to_fetch = lambda: False
 
1430
        result = branch.heads_to_fetch()
 
1431
        self.assertFinished(client)
 
1432
        self.assertEqual((set(['tip']), set(['tagged-1', 'tagged-2'])), result)
 
1433
 
 
1434
    def make_branch_with_tags(self):
 
1435
        self.setup_smart_server_with_call_log()
 
1436
        # Make a branch with a single revision.
 
1437
        builder = self.make_branch_builder('foo')
 
1438
        builder.start_series()
 
1439
        builder.build_snapshot('tip', None, [
 
1440
            ('add', ('', 'root-id', 'directory', ''))])
 
1441
        builder.finish_series()
 
1442
        branch = builder.get_branch()
 
1443
        # Add two tags to that branch
 
1444
        branch.tags.set_tag('tag-1', 'rev-1')
 
1445
        branch.tags.set_tag('tag-2', 'rev-2')
 
1446
        return branch
 
1447
 
 
1448
    def test_backwards_compatible(self):
 
1449
        br = self.make_branch_with_tags()
 
1450
        br.get_config_stack().set('branch.fetch_tags', True)
 
1451
        self.addCleanup(br.lock_read().unlock)
 
1452
        # Disable the heads_to_fetch verb
 
1453
        verb = 'Branch.heads_to_fetch'
 
1454
        self.disable_verb(verb)
 
1455
        self.reset_smart_call_log()
 
1456
        result = br.heads_to_fetch()
 
1457
        self.assertEqual((set(['tip']), set(['rev-1', 'rev-2'])), result)
 
1458
        self.assertEqual(
 
1459
            ['Branch.last_revision_info', 'Branch.get_tags_bytes'],
 
1460
            [call.call.method for call in self.hpss_calls])
 
1461
 
 
1462
    def test_backwards_compatible_no_tags(self):
 
1463
        br = self.make_branch_with_tags()
 
1464
        br.get_config_stack().set('branch.fetch_tags', False)
 
1465
        self.addCleanup(br.lock_read().unlock)
 
1466
        # Disable the heads_to_fetch verb
 
1467
        verb = 'Branch.heads_to_fetch'
 
1468
        self.disable_verb(verb)
 
1469
        self.reset_smart_call_log()
 
1470
        result = br.heads_to_fetch()
 
1471
        self.assertEqual((set(['tip']), set()), result)
 
1472
        self.assertEqual(
 
1473
            ['Branch.last_revision_info'],
 
1474
            [call.call.method for call in self.hpss_calls])
 
1475
 
 
1476
 
1143
1477
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1144
1478
 
1145
1479
    def test_empty_branch(self):
1200
1534
        client.add_expected_call(
1201
1535
            'Branch.get_stacked_on_url', ('stacked/',),
1202
1536
            'success', ('ok', vfs_url))
1203
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
1537
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
1204
1538
            _client=client)
1205
1539
        repo_fmt = remote.RemoteRepositoryFormat()
1206
1540
        repo_fmt._custom_format = stacked_branch.repository._format
1233
1567
        # this will also do vfs access, but that goes direct to the transport
1234
1568
        # and isn't seen by the FakeClient.
1235
1569
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1236
 
            remote.RemoteBzrDirFormat(), _client=client)
 
1570
            RemoteBzrDirFormat(), _client=client)
1237
1571
        branch = bzrdir.open_branch()
1238
1572
        result = branch.get_stacked_on_url()
1239
1573
        self.assertEqual('../base', result)
1266
1600
            'Branch.get_stacked_on_url', ('stacked/',),
1267
1601
            'success', ('ok', '../base'))
1268
1602
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1269
 
            remote.RemoteBzrDirFormat(), _client=client)
 
1603
            RemoteBzrDirFormat(), _client=client)
1270
1604
        branch = bzrdir.open_branch()
1271
1605
        result = branch.get_stacked_on_url()
1272
1606
        self.assertEqual('../base', result)
1280
1614
class TestBranchSetLastRevision(RemoteBranchTestCase):
1281
1615
 
1282
1616
    def test_set_empty(self):
1283
 
        # set_revision_history([]) is translated to calling
 
1617
        # _set_last_revision_info('null:') is translated to calling
1284
1618
        # Branch.set_last_revision(path, '') on the wire.
1285
1619
        transport = MemoryTransport()
1286
1620
        transport.mkdir('branch')
1304
1638
            'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1305
1639
            'success', ('ok',))
1306
1640
        branch = self.make_remote_branch(transport, client)
1307
 
        # This is a hack to work around the problem that RemoteBranch currently
1308
 
        # unnecessarily invokes _ensure_real upon a call to lock_write.
1309
 
        branch._ensure_real = lambda: None
1310
1641
        branch.lock_write()
1311
 
        result = branch.set_revision_history([])
 
1642
        result = branch._set_last_revision(NULL_REVISION)
1312
1643
        branch.unlock()
1313
1644
        self.assertEqual(None, result)
1314
1645
        self.assertFinished(client)
1315
1646
 
1316
1647
    def test_set_nonempty(self):
1317
 
        # set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
 
1648
        # set_last_revision_info(N, rev-idN) is translated to calling
1318
1649
        # Branch.set_last_revision(path, rev-idN) on the wire.
1319
1650
        transport = MemoryTransport()
1320
1651
        transport.mkdir('branch')
1341
1672
            'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1342
1673
            'success', ('ok',))
1343
1674
        branch = self.make_remote_branch(transport, client)
1344
 
        # This is a hack to work around the problem that RemoteBranch currently
1345
 
        # unnecessarily invokes _ensure_real upon a call to lock_write.
1346
 
        branch._ensure_real = lambda: None
1347
1675
        # Lock the branch, reset the record of remote calls.
1348
1676
        branch.lock_write()
1349
 
        result = branch.set_revision_history(['rev-id1', 'rev-id2'])
 
1677
        result = branch._set_last_revision('rev-id2')
1350
1678
        branch.unlock()
1351
1679
        self.assertEqual(None, result)
1352
1680
        self.assertFinished(client)
1382
1710
        branch = self.make_remote_branch(transport, client)
1383
1711
        branch.lock_write()
1384
1712
        self.assertRaises(
1385
 
            errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
 
1713
            errors.NoSuchRevision, branch._set_last_revision, 'rev-id')
1386
1714
        branch.unlock()
1387
1715
        self.assertFinished(client)
1388
1716
 
1416
1744
            'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1417
1745
            'success', ('ok',))
1418
1746
        branch = self.make_remote_branch(transport, client)
1419
 
        branch._ensure_real = lambda: None
1420
1747
        branch.lock_write()
1421
1748
        # The 'TipChangeRejected' error response triggered by calling
1422
 
        # set_revision_history causes a TipChangeRejected exception.
 
1749
        # set_last_revision_info causes a TipChangeRejected exception.
1423
1750
        err = self.assertRaises(
1424
 
            errors.TipChangeRejected, branch.set_revision_history, ['rev-id'])
 
1751
            errors.TipChangeRejected,
 
1752
            branch._set_last_revision, 'rev-id')
1425
1753
        # The UTF-8 message from the response has been decoded into a unicode
1426
1754
        # object.
1427
1755
        self.assertIsInstance(err.msg, unicode)
1684
2012
        self.addCleanup(branch.unlock)
1685
2013
        self.reset_smart_call_log()
1686
2014
        branch._get_config().set_option('value', 'name')
1687
 
        self.assertLength(10, self.hpss_calls)
 
2015
        self.assertLength(11, self.hpss_calls)
1688
2016
        self.assertEqual('value', branch._get_config().get_option('name'))
1689
2017
 
1690
2018
    def test_backwards_compat_set_option_with_dict(self):
1698
2026
        config = branch._get_config()
1699
2027
        value_dict = {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
1700
2028
        config.set_option(value_dict, 'name')
1701
 
        self.assertLength(10, self.hpss_calls)
 
2029
        self.assertLength(11, self.hpss_calls)
1702
2030
        self.assertEqual(value_dict, branch._get_config().get_option('name'))
1703
2031
 
1704
2032
 
 
2033
class TestBranchGetPutConfigStore(RemoteBranchTestCase):
 
2034
 
 
2035
    def test_get_branch_conf(self):
 
2036
        # in an empty branch we decode the response properly
 
2037
        client = FakeClient()
 
2038
        client.add_expected_call(
 
2039
            'Branch.get_stacked_on_url', ('memory:///',),
 
2040
            'error', ('NotStacked',),)
 
2041
        client.add_success_response_with_body('# config file body', 'ok')
 
2042
        transport = MemoryTransport()
 
2043
        branch = self.make_remote_branch(transport, client)
 
2044
        config = branch.get_config_stack()
 
2045
        config.get("email")
 
2046
        config.get("log_format")
 
2047
        self.assertEqual(
 
2048
            [('call', 'Branch.get_stacked_on_url', ('memory:///',)),
 
2049
             ('call_expecting_body', 'Branch.get_config_file', ('memory:///',))],
 
2050
            client._calls)
 
2051
 
 
2052
    def test_set_branch_conf(self):
 
2053
        client = FakeClient()
 
2054
        client.add_expected_call(
 
2055
            'Branch.get_stacked_on_url', ('memory:///',),
 
2056
            'error', ('NotStacked',),)
 
2057
        client.add_expected_call(
 
2058
            'Branch.lock_write', ('memory:///', '', ''),
 
2059
            'success', ('ok', 'branch token', 'repo token'))
 
2060
        client.add_expected_call(
 
2061
            'Branch.get_config_file', ('memory:///', ),
 
2062
            'success', ('ok', ), "# line 1\n")
 
2063
        client.add_expected_call(
 
2064
            'Branch.get_config_file', ('memory:///', ),
 
2065
            'success', ('ok', ), "# line 1\n")
 
2066
        client.add_expected_call(
 
2067
            'Branch.put_config_file', ('memory:///', 'branch token',
 
2068
            'repo token'),
 
2069
            'success', ('ok',))
 
2070
        client.add_expected_call(
 
2071
            'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
 
2072
            'success', ('ok',))
 
2073
        transport = MemoryTransport()
 
2074
        branch = self.make_remote_branch(transport, client)
 
2075
        branch.lock_write()
 
2076
        config = branch.get_config_stack()
 
2077
        config.set('email', 'The Dude <lebowski@example.com>')
 
2078
        branch.unlock()
 
2079
        self.assertFinished(client)
 
2080
        self.assertEqual(
 
2081
            [('call', 'Branch.get_stacked_on_url', ('memory:///',)),
 
2082
             ('call', 'Branch.lock_write', ('memory:///', '', '')),
 
2083
             ('call_expecting_body', 'Branch.get_config_file', ('memory:///',)),
 
2084
             ('call_expecting_body', 'Branch.get_config_file', ('memory:///',)),
 
2085
             ('call_with_body_bytes_expecting_body', 'Branch.put_config_file',
 
2086
                 ('memory:///', 'branch token', 'repo token'),
 
2087
                 '# line 1\nemail = The Dude <lebowski@example.com>\n'),
 
2088
             ('call', 'Branch.unlock', ('memory:///', 'branch token', 'repo token'))],
 
2089
            client._calls)
 
2090
 
 
2091
 
1705
2092
class TestBranchLockWrite(RemoteBranchTestCase):
1706
2093
 
1707
2094
    def test_lock_write_unlockable(self):
1720
2107
        self.assertFinished(client)
1721
2108
 
1722
2109
 
 
2110
class TestBranchRevisionIdToRevno(RemoteBranchTestCase):
 
2111
 
 
2112
    def test_simple(self):
 
2113
        transport = MemoryTransport()
 
2114
        client = FakeClient(transport.base)
 
2115
        client.add_expected_call(
 
2116
            'Branch.get_stacked_on_url', ('quack/',),
 
2117
            'error', ('NotStacked',),)
 
2118
        client.add_expected_call(
 
2119
            'Branch.revision_id_to_revno', ('quack/', 'null:'),
 
2120
            'success', ('ok', '0',),)
 
2121
        client.add_expected_call(
 
2122
            'Branch.revision_id_to_revno', ('quack/', 'unknown'),
 
2123
            'error', ('NoSuchRevision', 'unknown',),)
 
2124
        transport.mkdir('quack')
 
2125
        transport = transport.clone('quack')
 
2126
        branch = self.make_remote_branch(transport, client)
 
2127
        self.assertEqual(0, branch.revision_id_to_revno('null:'))
 
2128
        self.assertRaises(errors.NoSuchRevision,
 
2129
            branch.revision_id_to_revno, 'unknown')
 
2130
        self.assertFinished(client)
 
2131
 
 
2132
    def test_dotted(self):
 
2133
        transport = MemoryTransport()
 
2134
        client = FakeClient(transport.base)
 
2135
        client.add_expected_call(
 
2136
            'Branch.get_stacked_on_url', ('quack/',),
 
2137
            'error', ('NotStacked',),)
 
2138
        client.add_expected_call(
 
2139
            'Branch.revision_id_to_revno', ('quack/', 'null:'),
 
2140
            'success', ('ok', '0',),)
 
2141
        client.add_expected_call(
 
2142
            'Branch.revision_id_to_revno', ('quack/', 'unknown'),
 
2143
            'error', ('NoSuchRevision', 'unknown',),)
 
2144
        transport.mkdir('quack')
 
2145
        transport = transport.clone('quack')
 
2146
        branch = self.make_remote_branch(transport, client)
 
2147
        self.assertEqual((0, ), branch.revision_id_to_dotted_revno('null:'))
 
2148
        self.assertRaises(errors.NoSuchRevision,
 
2149
            branch.revision_id_to_dotted_revno, 'unknown')
 
2150
        self.assertFinished(client)
 
2151
 
 
2152
    def test_dotted_no_smart_verb(self):
 
2153
        self.setup_smart_server_with_call_log()
 
2154
        branch = self.make_branch('.')
 
2155
        self.disable_verb('Branch.revision_id_to_revno')
 
2156
        self.reset_smart_call_log()
 
2157
        self.assertEqual((0, ),
 
2158
            branch.revision_id_to_dotted_revno('null:'))
 
2159
        self.assertLength(8, self.hpss_calls)
 
2160
 
 
2161
 
1723
2162
class TestBzrDirGetSetConfig(RemoteBzrDirTestCase):
1724
2163
 
1725
2164
    def test__get_config(self):
1739
2178
        self.reset_smart_call_log()
1740
2179
        config = bzrdir.get_config()
1741
2180
        config.set_default_stack_on('/')
1742
 
        self.assertLength(3, self.hpss_calls)
 
2181
        self.assertLength(4, self.hpss_calls)
1743
2182
 
1744
2183
    def test_backwards_compat_get_option(self):
1745
2184
        self.setup_smart_server_with_call_log()
1749
2188
        self.reset_smart_call_log()
1750
2189
        self.assertEqual(None,
1751
2190
            bzrdir._get_config().get_option('default_stack_on'))
1752
 
        self.assertLength(3, self.hpss_calls)
 
2191
        self.assertLength(4, self.hpss_calls)
1753
2192
 
1754
2193
 
1755
2194
class TestTransportIsReadonly(tests.TestCase):
1842
2281
        client = FakeClient(transport.base)
1843
2282
        transport = transport.clone(transport_path)
1844
2283
        # we do not want bzrdir to make any remote calls
1845
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
2284
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
1846
2285
            _client=False)
1847
2286
        repo = RemoteRepository(bzrdir, None, _client=client)
1848
2287
        return repo, client
1856
2295
 
1857
2296
    def test_get_format_description(self):
1858
2297
        remote_format = RemoteBranchFormat()
1859
 
        real_format = branch.BranchFormat.get_default_format()
 
2298
        real_format = branch.format_registry.get_default()
1860
2299
        remote_format._network_name = real_format.network_name()
1861
2300
        self.assertEqual(remoted_description(real_format),
1862
2301
            remote_format.get_format_description())
1865
2304
class TestRepositoryFormat(TestRemoteRepository):
1866
2305
 
1867
2306
    def test_fast_delta(self):
1868
 
        true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
 
2307
        true_name = groupcompress_repo.RepositoryFormat2a().network_name()
1869
2308
        true_format = RemoteRepositoryFormat()
1870
2309
        true_format._network_name = true_name
1871
2310
        self.assertEqual(True, true_format.fast_deltas)
1872
 
        false_name = pack_repo.RepositoryFormatKnitPack1().network_name()
 
2311
        false_name = knitpack_repo.RepositoryFormatKnitPack1().network_name()
1873
2312
        false_format = RemoteRepositoryFormat()
1874
2313
        false_format._network_name = false_name
1875
2314
        self.assertEqual(False, false_format.fast_deltas)
1876
2315
 
1877
2316
    def test_get_format_description(self):
1878
2317
        remote_repo_format = RemoteRepositoryFormat()
1879
 
        real_format = repository.RepositoryFormat.get_default_format()
 
2318
        real_format = repository.format_registry.get_default()
1880
2319
        remote_repo_format._network_name = real_format.network_name()
1881
2320
        self.assertEqual(remoted_description(real_format),
1882
2321
            remote_repo_format.get_format_description())
1883
2322
 
1884
2323
 
 
2324
class TestRepositoryAllRevisionIds(TestRemoteRepository):
 
2325
 
 
2326
    def test_empty(self):
 
2327
        transport_path = 'quack'
 
2328
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2329
        client.add_success_response_with_body('', 'ok')
 
2330
        self.assertEqual([], repo.all_revision_ids())
 
2331
        self.assertEqual(
 
2332
            [('call_expecting_body', 'Repository.all_revision_ids',
 
2333
             ('quack/',))],
 
2334
            client._calls)
 
2335
 
 
2336
    def test_with_some_content(self):
 
2337
        transport_path = 'quack'
 
2338
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2339
        client.add_success_response_with_body(
 
2340
            'rev1\nrev2\nanotherrev\n', 'ok')
 
2341
        self.assertEqual(["rev1", "rev2", "anotherrev"],
 
2342
            repo.all_revision_ids())
 
2343
        self.assertEqual(
 
2344
            [('call_expecting_body', 'Repository.all_revision_ids',
 
2345
             ('quack/',))],
 
2346
            client._calls)
 
2347
 
 
2348
 
1885
2349
class TestRepositoryGatherStats(TestRemoteRepository):
1886
2350
 
1887
2351
    def test_revid_none(self):
1940
2404
                         result)
1941
2405
 
1942
2406
 
 
2407
class TestRepositoryBreakLock(TestRemoteRepository):
 
2408
 
 
2409
    def test_break_lock(self):
 
2410
        transport_path = 'quack'
 
2411
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2412
        client.add_success_response('ok')
 
2413
        repo.break_lock()
 
2414
        self.assertEqual(
 
2415
            [('call', 'Repository.break_lock', ('quack/',))],
 
2416
            client._calls)
 
2417
 
 
2418
 
 
2419
class TestRepositoryGetSerializerFormat(TestRemoteRepository):
 
2420
 
 
2421
    def test_get_serializer_format(self):
 
2422
        transport_path = 'hill'
 
2423
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2424
        client.add_success_response('ok', '7')
 
2425
        self.assertEqual('7', repo.get_serializer_format())
 
2426
        self.assertEqual(
 
2427
            [('call', 'VersionedFileRepository.get_serializer_format',
 
2428
              ('hill/', ))],
 
2429
            client._calls)
 
2430
 
 
2431
 
 
2432
class TestRepositoryReconcile(TestRemoteRepository):
 
2433
 
 
2434
    def test_reconcile(self):
 
2435
        transport_path = 'hill'
 
2436
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2437
        body = ("garbage_inventories: 2\n"
 
2438
                "inconsistent_parents: 3\n")
 
2439
        client.add_expected_call(
 
2440
            'Repository.lock_write', ('hill/', ''),
 
2441
            'success', ('ok', 'a token'))
 
2442
        client.add_success_response_with_body(body, 'ok')
 
2443
        reconciler = repo.reconcile()
 
2444
        self.assertEqual(
 
2445
            [('call', 'Repository.lock_write', ('hill/', '')),
 
2446
             ('call_expecting_body', 'Repository.reconcile',
 
2447
                ('hill/', 'a token'))],
 
2448
            client._calls)
 
2449
        self.assertEqual(2, reconciler.garbage_inventories)
 
2450
        self.assertEqual(3, reconciler.inconsistent_parents)
 
2451
 
 
2452
 
 
2453
class TestRepositoryGetRevisionSignatureText(TestRemoteRepository):
 
2454
 
 
2455
    def test_text(self):
 
2456
        # ('ok',), body with signature text
 
2457
        transport_path = 'quack'
 
2458
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2459
        client.add_success_response_with_body(
 
2460
            'THETEXT', 'ok')
 
2461
        self.assertEqual("THETEXT", repo.get_signature_text("revid"))
 
2462
        self.assertEqual(
 
2463
            [('call_expecting_body', 'Repository.get_revision_signature_text',
 
2464
             ('quack/', 'revid'))],
 
2465
            client._calls)
 
2466
 
 
2467
    def test_no_signature(self):
 
2468
        transport_path = 'quick'
 
2469
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2470
        client.add_error_response('nosuchrevision', 'unknown')
 
2471
        self.assertRaises(errors.NoSuchRevision, repo.get_signature_text,
 
2472
                "unknown")
 
2473
        self.assertEqual(
 
2474
            [('call_expecting_body', 'Repository.get_revision_signature_text',
 
2475
              ('quick/', 'unknown'))],
 
2476
            client._calls)
 
2477
 
 
2478
 
1943
2479
class TestRepositoryGetGraph(TestRemoteRepository):
1944
2480
 
1945
2481
    def test_get_graph(self):
1950
2486
        self.assertNotEqual(graph._parents_provider, repo)
1951
2487
 
1952
2488
 
 
2489
class TestRepositoryAddSignatureText(TestRemoteRepository):
 
2490
 
 
2491
    def test_add_signature_text(self):
 
2492
        transport_path = 'quack'
 
2493
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2494
        client.add_expected_call(
 
2495
            'Repository.lock_write', ('quack/', ''),
 
2496
            'success', ('ok', 'a token'))
 
2497
        client.add_expected_call(
 
2498
            'Repository.start_write_group', ('quack/', 'a token'),
 
2499
            'success', ('ok', ('token1', )))
 
2500
        client.add_expected_call(
 
2501
            'Repository.add_signature_text', ('quack/', 'a token', 'rev1',
 
2502
                'token1'),
 
2503
            'success', ('ok', ), None)
 
2504
        repo.lock_write()
 
2505
        repo.start_write_group()
 
2506
        self.assertIs(None,
 
2507
            repo.add_signature_text("rev1", "every bloody emperor"))
 
2508
        self.assertEqual(
 
2509
            ('call_with_body_bytes_expecting_body',
 
2510
              'Repository.add_signature_text',
 
2511
                ('quack/', 'a token', 'rev1', 'token1'),
 
2512
              'every bloody emperor'),
 
2513
            client._calls[-1])
 
2514
 
 
2515
 
1953
2516
class TestRepositoryGetParentMap(TestRemoteRepository):
1954
2517
 
1955
2518
    def test_get_parent_map_caching(self):
2005
2568
        parents = repo.get_parent_map([rev_id])
2006
2569
        self.assertEqual(
2007
2570
            [('call_with_body_bytes_expecting_body',
2008
 
              'Repository.get_parent_map', ('quack/', 'include-missing:',
2009
 
              rev_id), '\n\n0'),
 
2571
              'Repository.get_parent_map',
 
2572
              ('quack/', 'include-missing:', rev_id), '\n\n0'),
2010
2573
             ('disconnect medium',),
2011
2574
             ('call_expecting_body', 'Repository.get_revision_graph',
2012
2575
              ('quack/', ''))],
2132
2695
        self.assertEqual({}, repo.get_parent_map(['non-existant']))
2133
2696
        self.assertLength(0, self.hpss_calls)
2134
2697
 
 
2698
    def test_exposes_get_cached_parent_map(self):
 
2699
        """RemoteRepository exposes get_cached_parent_map from
 
2700
        _unstacked_provider
 
2701
        """
 
2702
        r1 = u'\u0e33'.encode('utf8')
 
2703
        r2 = u'\u0dab'.encode('utf8')
 
2704
        lines = [' '.join([r2, r1]), r1]
 
2705
        encoded_body = bz2.compress('\n'.join(lines))
 
2706
 
 
2707
        transport_path = 'quack'
 
2708
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2709
        client.add_success_response_with_body(encoded_body, 'ok')
 
2710
        repo.lock_read()
 
2711
        # get_cached_parent_map should *not* trigger an RPC
 
2712
        self.assertEqual({}, repo.get_cached_parent_map([r1]))
 
2713
        self.assertEqual([], client._calls)
 
2714
        self.assertEqual({r2: (r1,)}, repo.get_parent_map([r2]))
 
2715
        self.assertEqual({r1: (NULL_REVISION,)},
 
2716
            repo.get_cached_parent_map([r1]))
 
2717
        self.assertEqual(
 
2718
            [('call_with_body_bytes_expecting_body',
 
2719
              'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
 
2720
              '\n\n0')],
 
2721
            client._calls)
 
2722
        repo.unlock()
 
2723
 
2135
2724
 
2136
2725
class TestGetParentMapAllowsNew(tests.TestCaseWithTransport):
2137
2726
 
2152
2741
        self.assertEqual({'rev1': ('null:',)}, graph.get_parent_map(['rev1']))
2153
2742
 
2154
2743
 
 
2744
class TestRepositoryGetRevisions(TestRemoteRepository):
 
2745
 
 
2746
    def test_hpss_missing_revision(self):
 
2747
        transport_path = 'quack'
 
2748
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2749
        client.add_success_response_with_body(
 
2750
            '', 'ok', '10')
 
2751
        self.assertRaises(errors.NoSuchRevision, repo.get_revisions,
 
2752
            ['somerev1', 'anotherrev2'])
 
2753
        self.assertEqual(
 
2754
            [('call_with_body_bytes_expecting_body', 'Repository.iter_revisions',
 
2755
             ('quack/', ), "somerev1\nanotherrev2")],
 
2756
            client._calls)
 
2757
 
 
2758
    def test_hpss_get_single_revision(self):
 
2759
        transport_path = 'quack'
 
2760
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2761
        somerev1 = Revision("somerev1")
 
2762
        somerev1.committer = "Joe Committer <joe@example.com>"
 
2763
        somerev1.timestamp = 1321828927
 
2764
        somerev1.timezone = -60
 
2765
        somerev1.inventory_sha1 = "691b39be74c67b1212a75fcb19c433aaed903c2b"
 
2766
        somerev1.message = "Message"
 
2767
        body = zlib.compress(chk_bencode_serializer.write_revision_to_string(
 
2768
            somerev1))
 
2769
        # Split up body into two bits to make sure the zlib compression object
 
2770
        # gets data fed twice.
 
2771
        client.add_success_response_with_body(
 
2772
                [body[:10], body[10:]], 'ok', '10')
 
2773
        revs = repo.get_revisions(['somerev1'])
 
2774
        self.assertEqual(revs, [somerev1])
 
2775
        self.assertEqual(
 
2776
            [('call_with_body_bytes_expecting_body', 'Repository.iter_revisions',
 
2777
             ('quack/', ), "somerev1")],
 
2778
            client._calls)
 
2779
 
 
2780
 
2155
2781
class TestRepositoryGetRevisionGraph(TestRemoteRepository):
2156
2782
 
2157
2783
    def test_null_revision(self):
2308
2934
                              call.call.method == verb])
2309
2935
 
2310
2936
 
 
2937
class TestRepositoryHasSignatureForRevisionId(TestRemoteRepository):
 
2938
 
 
2939
    def test_has_signature_for_revision_id(self):
 
2940
        # ('yes', ) for Repository.has_signature_for_revision_id -> 'True'.
 
2941
        transport_path = 'quack'
 
2942
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2943
        client.add_success_response('yes')
 
2944
        result = repo.has_signature_for_revision_id('A')
 
2945
        self.assertEqual(
 
2946
            [('call', 'Repository.has_signature_for_revision_id',
 
2947
              ('quack/', 'A'))],
 
2948
            client._calls)
 
2949
        self.assertEqual(True, result)
 
2950
 
 
2951
    def test_is_not_shared(self):
 
2952
        # ('no', ) for Repository.has_signature_for_revision_id -> 'False'.
 
2953
        transport_path = 'qwack'
 
2954
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2955
        client.add_success_response('no')
 
2956
        result = repo.has_signature_for_revision_id('A')
 
2957
        self.assertEqual(
 
2958
            [('call', 'Repository.has_signature_for_revision_id',
 
2959
              ('qwack/', 'A'))],
 
2960
            client._calls)
 
2961
        self.assertEqual(False, result)
 
2962
 
 
2963
 
 
2964
class TestRepositoryPhysicalLockStatus(TestRemoteRepository):
 
2965
 
 
2966
    def test_get_physical_lock_status_yes(self):
 
2967
        transport_path = 'qwack'
 
2968
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2969
        client.add_success_response('yes')
 
2970
        result = repo.get_physical_lock_status()
 
2971
        self.assertEqual(
 
2972
            [('call', 'Repository.get_physical_lock_status',
 
2973
              ('qwack/', ))],
 
2974
            client._calls)
 
2975
        self.assertEqual(True, result)
 
2976
 
 
2977
    def test_get_physical_lock_status_no(self):
 
2978
        transport_path = 'qwack'
 
2979
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2980
        client.add_success_response('no')
 
2981
        result = repo.get_physical_lock_status()
 
2982
        self.assertEqual(
 
2983
            [('call', 'Repository.get_physical_lock_status',
 
2984
              ('qwack/', ))],
 
2985
            client._calls)
 
2986
        self.assertEqual(False, result)
 
2987
 
 
2988
 
2311
2989
class TestRepositoryIsShared(TestRemoteRepository):
2312
2990
 
2313
2991
    def test_is_shared(self):
2333
3011
        self.assertEqual(False, result)
2334
3012
 
2335
3013
 
 
3014
class TestRepositoryMakeWorkingTrees(TestRemoteRepository):
 
3015
 
 
3016
    def test_make_working_trees(self):
 
3017
        # ('yes', ) for Repository.make_working_trees -> 'True'.
 
3018
        transport_path = 'quack'
 
3019
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3020
        client.add_success_response('yes')
 
3021
        result = repo.make_working_trees()
 
3022
        self.assertEqual(
 
3023
            [('call', 'Repository.make_working_trees', ('quack/',))],
 
3024
            client._calls)
 
3025
        self.assertEqual(True, result)
 
3026
 
 
3027
    def test_no_working_trees(self):
 
3028
        # ('no', ) for Repository.make_working_trees -> 'False'.
 
3029
        transport_path = 'qwack'
 
3030
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3031
        client.add_success_response('no')
 
3032
        result = repo.make_working_trees()
 
3033
        self.assertEqual(
 
3034
            [('call', 'Repository.make_working_trees', ('qwack/',))],
 
3035
            client._calls)
 
3036
        self.assertEqual(False, result)
 
3037
 
 
3038
 
2336
3039
class TestRepositoryLockWrite(TestRemoteRepository):
2337
3040
 
2338
3041
    def test_lock_write(self):
2364
3067
            client._calls)
2365
3068
 
2366
3069
 
 
3070
class TestRepositoryWriteGroups(TestRemoteRepository):
 
3071
 
 
3072
    def test_start_write_group(self):
 
3073
        transport_path = 'quack'
 
3074
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3075
        client.add_expected_call(
 
3076
            'Repository.lock_write', ('quack/', ''),
 
3077
            'success', ('ok', 'a token'))
 
3078
        client.add_expected_call(
 
3079
            'Repository.start_write_group', ('quack/', 'a token'),
 
3080
            'success', ('ok', ('token1', )))
 
3081
        repo.lock_write()
 
3082
        repo.start_write_group()
 
3083
 
 
3084
    def test_start_write_group_unsuspendable(self):
 
3085
        # Some repositories do not support suspending write
 
3086
        # groups. For those, fall back to the "real" repository.
 
3087
        transport_path = 'quack'
 
3088
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3089
        def stub_ensure_real():
 
3090
            client._calls.append(('_ensure_real',))
 
3091
            repo._real_repository = _StubRealPackRepository(client._calls)
 
3092
        repo._ensure_real = stub_ensure_real
 
3093
        client.add_expected_call(
 
3094
            'Repository.lock_write', ('quack/', ''),
 
3095
            'success', ('ok', 'a token'))
 
3096
        client.add_expected_call(
 
3097
            'Repository.start_write_group', ('quack/', 'a token'),
 
3098
            'error', ('UnsuspendableWriteGroup',))
 
3099
        repo.lock_write()
 
3100
        repo.start_write_group()
 
3101
        self.assertEqual(client._calls[-2:], [ 
 
3102
            ('_ensure_real',),
 
3103
            ('start_write_group',)])
 
3104
 
 
3105
    def test_commit_write_group(self):
 
3106
        transport_path = 'quack'
 
3107
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3108
        client.add_expected_call(
 
3109
            'Repository.lock_write', ('quack/', ''),
 
3110
            'success', ('ok', 'a token'))
 
3111
        client.add_expected_call(
 
3112
            'Repository.start_write_group', ('quack/', 'a token'),
 
3113
            'success', ('ok', ['token1']))
 
3114
        client.add_expected_call(
 
3115
            'Repository.commit_write_group', ('quack/', 'a token', ['token1']),
 
3116
            'success', ('ok',))
 
3117
        repo.lock_write()
 
3118
        repo.start_write_group()
 
3119
        repo.commit_write_group()
 
3120
 
 
3121
    def test_abort_write_group(self):
 
3122
        transport_path = 'quack'
 
3123
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3124
        client.add_expected_call(
 
3125
            'Repository.lock_write', ('quack/', ''),
 
3126
            'success', ('ok', 'a token'))
 
3127
        client.add_expected_call(
 
3128
            'Repository.start_write_group', ('quack/', 'a token'),
 
3129
            'success', ('ok', ['token1']))
 
3130
        client.add_expected_call(
 
3131
            'Repository.abort_write_group', ('quack/', 'a token', ['token1']),
 
3132
            'success', ('ok',))
 
3133
        repo.lock_write()
 
3134
        repo.start_write_group()
 
3135
        repo.abort_write_group(False)
 
3136
 
 
3137
    def test_suspend_write_group(self):
 
3138
        transport_path = 'quack'
 
3139
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3140
        self.assertEqual([], repo.suspend_write_group())
 
3141
 
 
3142
    def test_resume_write_group(self):
 
3143
        transport_path = 'quack'
 
3144
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3145
        client.add_expected_call(
 
3146
            'Repository.lock_write', ('quack/', ''),
 
3147
            'success', ('ok', 'a token'))
 
3148
        client.add_expected_call(
 
3149
            'Repository.check_write_group', ('quack/', 'a token', ['token1']),
 
3150
            'success', ('ok',))
 
3151
        repo.lock_write()
 
3152
        repo.resume_write_group(['token1'])
 
3153
 
 
3154
 
2367
3155
class TestRepositorySetMakeWorkingTrees(TestRemoteRepository):
2368
3156
 
2369
3157
    def test_backwards_compat(self):
2428
3216
        self.assertEqual([], client._calls)
2429
3217
 
2430
3218
 
 
3219
class TestRepositoryIterFilesBytes(TestRemoteRepository):
 
3220
    """Test Repository.iter_file_bytes."""
 
3221
 
 
3222
    def test_single(self):
 
3223
        transport_path = 'quack'
 
3224
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3225
        client.add_expected_call(
 
3226
            'Repository.iter_files_bytes', ('quack/', ),
 
3227
            'success', ('ok',), iter(["ok\x000", "\n", zlib.compress("mydata" * 10)]))
 
3228
        for (identifier, byte_stream) in repo.iter_files_bytes([("somefile",
 
3229
                "somerev", "myid")]):
 
3230
            self.assertEqual("myid", identifier)
 
3231
            self.assertEqual("".join(byte_stream), "mydata" * 10)
 
3232
 
 
3233
    def test_missing(self):
 
3234
        transport_path = 'quack'
 
3235
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3236
        client.add_expected_call(
 
3237
            'Repository.iter_files_bytes',
 
3238
                ('quack/', ),
 
3239
            'error', ('RevisionNotPresent', 'somefile', 'somerev'),
 
3240
            iter(["absent\0somefile\0somerev\n"]))
 
3241
        self.assertRaises(errors.RevisionNotPresent, list,
 
3242
                repo.iter_files_bytes(
 
3243
                [("somefile", "somerev", "myid")]))
 
3244
 
 
3245
 
2431
3246
class TestRepositoryInsertStreamBase(TestRemoteRepository):
2432
3247
    """Base class for Repository.insert_stream and .insert_stream_1.19
2433
3248
    tests.
2440
3255
        the client is finished.
2441
3256
        """
2442
3257
        sink = repo._get_sink()
2443
 
        fmt = repository.RepositoryFormat.get_default_format()
 
3258
        fmt = repository.format_registry.get_default()
2444
3259
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2445
3260
        self.assertEqual([], resume_tokens)
2446
3261
        self.assertEqual(set(), missing_keys)
2455
3270
    """
2456
3271
 
2457
3272
    def setUp(self):
2458
 
        TestRemoteRepository.setUp(self)
 
3273
        super(TestRepositoryInsertStream, self).setUp()
2459
3274
        self.disable_verb('Repository.insert_stream_1.19')
2460
3275
 
2461
3276
    def test_unlocked_repo(self):
2546
3361
                return True
2547
3362
        repo._real_repository = FakeRealRepository()
2548
3363
        sink = repo._get_sink()
2549
 
        fmt = repository.RepositoryFormat.get_default_format()
 
3364
        fmt = repository.format_registry.get_default()
2550
3365
        stream = self.make_stream_with_inv_deltas(fmt)
2551
3366
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2552
3367
        # Every record from the first inventory delta should have been sent to
2708
3523
        self.calls = calls
2709
3524
        self._pack_collection = _StubPackCollection(calls)
2710
3525
 
 
3526
    def start_write_group(self):
 
3527
        self.calls.append(('start_write_group',))
 
3528
 
2711
3529
    def is_in_write_group(self):
2712
3530
        return False
2713
3531
 
2772
3590
             ('pack collection autopack',)],
2773
3591
            client._calls)
2774
3592
 
 
3593
    def test_oom_error_reporting(self):
 
3594
        """An out-of-memory condition on the server is reported clearly"""
 
3595
        transport_path = 'quack'
 
3596
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3597
        client.add_expected_call(
 
3598
            'PackRepository.autopack', ('quack/',),
 
3599
            'error', ('MemoryError',))
 
3600
        err = self.assertRaises(errors.BzrError, repo.autopack)
 
3601
        self.assertContainsRe(str(err), "^remote server out of mem")
 
3602
 
2775
3603
 
2776
3604
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
2777
3605
    """Base class for unit tests for bzrlib.remote._translate_error."""
2850
3678
            detail='extra detail')
2851
3679
        self.assertEqual(expected_error, translated_error)
2852
3680
 
 
3681
    def test_norepository(self):
 
3682
        bzrdir = self.make_bzrdir('')
 
3683
        translated_error = self.translateTuple(('norepository',),
 
3684
            bzrdir=bzrdir)
 
3685
        expected_error = errors.NoRepositoryPresent(bzrdir)
 
3686
        self.assertEqual(expected_error, translated_error)
 
3687
 
2853
3688
    def test_LockContention(self):
2854
3689
        translated_error = self.translateTuple(('LockContention',))
2855
3690
        expected_error = errors.LockContention('(remote lock)')
2883
3718
        expected_error = errors.DivergedBranches(branch, other_branch)
2884
3719
        self.assertEqual(expected_error, translated_error)
2885
3720
 
 
3721
    def test_NotStacked(self):
 
3722
        branch = self.make_branch('')
 
3723
        translated_error = self.translateTuple(('NotStacked',), branch=branch)
 
3724
        expected_error = errors.NotStacked(branch)
 
3725
        self.assertEqual(expected_error, translated_error)
 
3726
 
2886
3727
    def test_ReadError_no_args(self):
2887
3728
        path = 'a path'
2888
3729
        translated_error = self.translateTuple(('ReadError',), path=path)
2904
3745
 
2905
3746
    def test_PermissionDenied_no_args(self):
2906
3747
        path = 'a path'
2907
 
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
 
3748
        translated_error = self.translateTuple(('PermissionDenied',),
 
3749
            path=path)
2908
3750
        expected_error = errors.PermissionDenied(path)
2909
3751
        self.assertEqual(expected_error, translated_error)
2910
3752
 
2933
3775
        expected_error = errors.PermissionDenied(path, extra)
2934
3776
        self.assertEqual(expected_error, translated_error)
2935
3777
 
 
3778
    # GZ 2011-03-02: TODO test for PermissionDenied with non-ascii 'extra'
 
3779
 
 
3780
    def test_NoSuchFile_context_path(self):
 
3781
        local_path = "local path"
 
3782
        translated_error = self.translateTuple(('ReadError', "remote path"),
 
3783
            path=local_path)
 
3784
        expected_error = errors.ReadError(local_path)
 
3785
        self.assertEqual(expected_error, translated_error)
 
3786
 
 
3787
    def test_NoSuchFile_without_context(self):
 
3788
        remote_path = "remote path"
 
3789
        translated_error = self.translateTuple(('ReadError', remote_path))
 
3790
        expected_error = errors.ReadError(remote_path)
 
3791
        self.assertEqual(expected_error, translated_error)
 
3792
 
 
3793
    def test_ReadOnlyError(self):
 
3794
        translated_error = self.translateTuple(('ReadOnlyError',))
 
3795
        expected_error = errors.TransportNotPossible("readonly transport")
 
3796
        self.assertEqual(expected_error, translated_error)
 
3797
 
 
3798
    def test_MemoryError(self):
 
3799
        translated_error = self.translateTuple(('MemoryError',))
 
3800
        self.assertStartsWith(str(translated_error),
 
3801
            "remote server out of memory")
 
3802
 
 
3803
    def test_generic_IndexError_no_classname(self):
 
3804
        err = errors.ErrorFromSmartServer(('error', "list index out of range"))
 
3805
        translated_error = self.translateErrorFromSmartServer(err)
 
3806
        expected_error = errors.UnknownErrorFromSmartServer(err)
 
3807
        self.assertEqual(expected_error, translated_error)
 
3808
 
 
3809
    # GZ 2011-03-02: TODO test generic non-ascii error string
 
3810
 
 
3811
    def test_generic_KeyError(self):
 
3812
        err = errors.ErrorFromSmartServer(('error', 'KeyError', "1"))
 
3813
        translated_error = self.translateErrorFromSmartServer(err)
 
3814
        expected_error = errors.UnknownErrorFromSmartServer(err)
 
3815
        self.assertEqual(expected_error, translated_error)
 
3816
 
2936
3817
 
2937
3818
class TestErrorTranslationRobustness(TestErrorTranslationBase):
2938
3819
    """Unit tests for bzrlib.remote._translate_error's robustness.
3074
3955
        :result: The revision ids in the stream, in the order seen,
3075
3956
            the topological order of revisions in the source.
3076
3957
        """
3077
 
        unordered_format = bzrdir.format_registry.get(format)()
 
3958
        unordered_format = controldir.format_registry.get(format)()
3078
3959
        target_repository_format = unordered_format.repository_format
3079
3960
        # Cross check
3080
3961
        self.assertEqual(order, target_repository_format._fetch_order)
3083
3964
        _, stacked = branch_factory()
3084
3965
        source = stacked.repository._get_source(target_repository_format)
3085
3966
        tip = stacked.last_revision()
3086
 
        revs = stacked.repository.get_ancestry(tip)
3087
 
        search = graph.PendingAncestryResult([tip], stacked.repository)
 
3967
        stacked.repository._ensure_real()
 
3968
        graph = stacked.repository.get_graph()
 
3969
        revs = [r for (r,ps) in graph.iter_ancestry([tip])
 
3970
                if r != NULL_REVISION]
 
3971
        revs.reverse()
 
3972
        search = vf_search.PendingAncestryResult([tip], stacked.repository)
3088
3973
        self.reset_smart_call_log()
3089
3974
        stream = source.get_stream(search)
3090
 
        if None in revs:
3091
 
            revs.remove(None)
3092
3975
        # We trust that if a revision is in the stream the rest of the new
3093
3976
        # content for it is too, as per our main fetch tests; here we are
3094
3977
        # checking that the revisions are actually included at all, and their
3133
4016
        self.assertEqual(expected_revs, rev_ord)
3134
4017
        # Getting topological sort requires VFS calls still - one of which is
3135
4018
        # pushing up from the bound branch.
3136
 
        self.assertLength(13, self.hpss_calls)
 
4019
        self.assertLength(14, self.hpss_calls)
3137
4020
 
3138
4021
    def test_stacked_get_stream_groupcompress(self):
3139
4022
        # Repository._get_source.get_stream() from a stacked repository with
3180
4063
 
3181
4064
    def test_copy_content_into_avoids_revision_history(self):
3182
4065
        local = self.make_branch('local')
3183
 
        remote_backing_tree = self.make_branch_and_tree('remote')
3184
 
        remote_backing_tree.commit("Commit.")
 
4066
        builder = self.make_branch_builder('remote')
 
4067
        builder.build_commit(message="Commit.")
3185
4068
        remote_branch_url = self.smart_server.get_url() + 'remote'
3186
4069
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3187
4070
        local.repository.fetch(remote_branch.repository)
3188
4071
        self.hpss_calls = []
3189
4072
        remote_branch.copy_content_into(local)
3190
4073
        self.assertFalse('Branch.revision_history' in self.hpss_calls)
 
4074
 
 
4075
    def test_fetch_everything_needs_just_one_call(self):
 
4076
        local = self.make_branch('local')
 
4077
        builder = self.make_branch_builder('remote')
 
4078
        builder.build_commit(message="Commit.")
 
4079
        remote_branch_url = self.smart_server.get_url() + 'remote'
 
4080
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
 
4081
        self.hpss_calls = []
 
4082
        local.repository.fetch(
 
4083
            remote_branch.repository,
 
4084
            fetch_spec=vf_search.EverythingResult(remote_branch.repository))
 
4085
        self.assertEqual(['Repository.get_stream_1.19'], self.hpss_calls)
 
4086
 
 
4087
    def override_verb(self, verb_name, verb):
 
4088
        request_handlers = request.request_handlers
 
4089
        orig_verb = request_handlers.get(verb_name)
 
4090
        orig_info = request_handlers.get_info(verb_name)
 
4091
        request_handlers.register(verb_name, verb, override_existing=True)
 
4092
        self.addCleanup(request_handlers.register, verb_name, orig_verb,
 
4093
                override_existing=True, info=orig_info)
 
4094
 
 
4095
    def test_fetch_everything_backwards_compat(self):
 
4096
        """Can fetch with EverythingResult even with pre 2.4 servers.
 
4097
        
 
4098
        Pre-2.4 do not support 'everything' searches with the
 
4099
        Repository.get_stream_1.19 verb.
 
4100
        """
 
4101
        verb_log = []
 
4102
        class OldGetStreamVerb(SmartServerRepositoryGetStream_1_19):
 
4103
            """A version of the Repository.get_stream_1.19 verb patched to
 
4104
            reject 'everything' searches the way 2.3 and earlier do.
 
4105
            """
 
4106
            def recreate_search(self, repository, search_bytes,
 
4107
                                discard_excess=False):
 
4108
                verb_log.append(search_bytes.split('\n', 1)[0])
 
4109
                if search_bytes == 'everything':
 
4110
                    return (None,
 
4111
                            request.FailedSmartServerResponse(('BadSearch',)))
 
4112
                return super(OldGetStreamVerb,
 
4113
                        self).recreate_search(repository, search_bytes,
 
4114
                            discard_excess=discard_excess)
 
4115
        self.override_verb('Repository.get_stream_1.19', OldGetStreamVerb)
 
4116
        local = self.make_branch('local')
 
4117
        builder = self.make_branch_builder('remote')
 
4118
        builder.build_commit(message="Commit.")
 
4119
        remote_branch_url = self.smart_server.get_url() + 'remote'
 
4120
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
 
4121
        self.hpss_calls = []
 
4122
        local.repository.fetch(
 
4123
            remote_branch.repository,
 
4124
            fetch_spec=vf_search.EverythingResult(remote_branch.repository))
 
4125
        # make sure the overridden verb was used
 
4126
        self.assertLength(1, verb_log)
 
4127
        # more than one HPSS call is needed, but because it's a VFS callback
 
4128
        # its hard to predict exactly how many.
 
4129
        self.assertTrue(len(self.hpss_calls) > 1)
 
4130
 
 
4131
 
 
4132
class TestUpdateBoundBranchWithModifiedBoundLocation(
 
4133
    tests.TestCaseWithTransport):
 
4134
    """Ensure correct handling of bound_location modifications.
 
4135
 
 
4136
    This is tested against a smart server as http://pad.lv/786980 was about a
 
4137
    ReadOnlyError (write attempt during a read-only transaction) which can only
 
4138
    happen in this context.
 
4139
    """
 
4140
 
 
4141
    def setUp(self):
 
4142
        super(TestUpdateBoundBranchWithModifiedBoundLocation, self).setUp()
 
4143
        self.transport_server = test_server.SmartTCPServer_for_testing
 
4144
 
 
4145
    def make_master_and_checkout(self, master_name, checkout_name):
 
4146
        # Create the master branch and its associated checkout
 
4147
        self.master = self.make_branch_and_tree(master_name)
 
4148
        self.checkout = self.master.branch.create_checkout(checkout_name)
 
4149
        # Modify the master branch so there is something to update
 
4150
        self.master.commit('add stuff')
 
4151
        self.last_revid = self.master.commit('even more stuff')
 
4152
        self.bound_location = self.checkout.branch.get_bound_location()
 
4153
 
 
4154
    def assertUpdateSucceeds(self, new_location):
 
4155
        self.checkout.branch.set_bound_location(new_location)
 
4156
        self.checkout.update()
 
4157
        self.assertEqual(self.last_revid, self.checkout.last_revision())
 
4158
 
 
4159
    def test_without_final_slash(self):
 
4160
        self.make_master_and_checkout('master', 'checkout')
 
4161
        # For unclear reasons some users have a bound_location without a final
 
4162
        # '/', simulate that by forcing such a value
 
4163
        self.assertEndsWith(self.bound_location, '/')
 
4164
        self.assertUpdateSucceeds(self.bound_location.rstrip('/'))
 
4165
 
 
4166
    def test_plus_sign(self):
 
4167
        self.make_master_and_checkout('+master', 'checkout')
 
4168
        self.assertUpdateSucceeds(self.bound_location.replace('%2B', '+', 1))
 
4169
 
 
4170
    def test_tilda(self):
 
4171
        # Embed ~ in the middle of the path just to avoid any $HOME
 
4172
        # interpretation
 
4173
        self.make_master_and_checkout('mas~ter', 'checkout')
 
4174
        self.assertUpdateSucceeds(self.bound_location.replace('%2E', '~', 1))
 
4175
 
 
4176
 
 
4177
class TestWithCustomErrorHandler(RemoteBranchTestCase):
 
4178
 
 
4179
    def test_no_context(self):
 
4180
        class OutOfCoffee(errors.BzrError):
 
4181
            """A dummy exception for testing."""
 
4182
 
 
4183
            def __init__(self, urgency):
 
4184
                self.urgency = urgency
 
4185
        remote.no_context_error_translators.register("OutOfCoffee",
 
4186
            lambda err: OutOfCoffee(err.error_args[0]))
 
4187
        transport = MemoryTransport()
 
4188
        client = FakeClient(transport.base)
 
4189
        client.add_expected_call(
 
4190
            'Branch.get_stacked_on_url', ('quack/',),
 
4191
            'error', ('NotStacked',))
 
4192
        client.add_expected_call(
 
4193
            'Branch.last_revision_info',
 
4194
            ('quack/',),
 
4195
            'error', ('OutOfCoffee', 'low'))
 
4196
        transport.mkdir('quack')
 
4197
        transport = transport.clone('quack')
 
4198
        branch = self.make_remote_branch(transport, client)
 
4199
        self.assertRaises(OutOfCoffee, branch.last_revision_info)
 
4200
        self.assertFinished(client)
 
4201
 
 
4202
    def test_with_context(self):
 
4203
        class OutOfTea(errors.BzrError):
 
4204
            def __init__(self, branch, urgency):
 
4205
                self.branch = branch
 
4206
                self.urgency = urgency
 
4207
        remote.error_translators.register("OutOfTea",
 
4208
            lambda err, find, path: OutOfTea(err.error_args[0],
 
4209
                find("branch")))
 
4210
        transport = MemoryTransport()
 
4211
        client = FakeClient(transport.base)
 
4212
        client.add_expected_call(
 
4213
            'Branch.get_stacked_on_url', ('quack/',),
 
4214
            'error', ('NotStacked',))
 
4215
        client.add_expected_call(
 
4216
            'Branch.last_revision_info',
 
4217
            ('quack/',),
 
4218
            'error', ('OutOfTea', 'low'))
 
4219
        transport.mkdir('quack')
 
4220
        transport = transport.clone('quack')
 
4221
        branch = self.make_remote_branch(transport, client)
 
4222
        self.assertRaises(OutOfTea, branch.last_revision_info)
 
4223
        self.assertFinished(client)
 
4224
 
 
4225
 
 
4226
class TestRepositoryPack(TestRemoteRepository):
 
4227
 
 
4228
    def test_pack(self):
 
4229
        transport_path = 'quack'
 
4230
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
4231
        client.add_expected_call(
 
4232
            'Repository.lock_write', ('quack/', ''),
 
4233
            'success', ('ok', 'token'))
 
4234
        client.add_expected_call(
 
4235
            'Repository.pack', ('quack/', 'token', 'False'),
 
4236
            'success', ('ok',), )
 
4237
        client.add_expected_call(
 
4238
            'Repository.unlock', ('quack/', 'token'),
 
4239
            'success', ('ok', ))
 
4240
        repo.pack()
 
4241
 
 
4242
    def test_pack_with_hint(self):
 
4243
        transport_path = 'quack'
 
4244
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
4245
        client.add_expected_call(
 
4246
            'Repository.lock_write', ('quack/', ''),
 
4247
            'success', ('ok', 'token'))
 
4248
        client.add_expected_call(
 
4249
            'Repository.pack', ('quack/', 'token', 'False'),
 
4250
            'success', ('ok',), )
 
4251
        client.add_expected_call(
 
4252
            'Repository.unlock', ('quack/', 'token', 'False'),
 
4253
            'success', ('ok', ))
 
4254
        repo.pack(['hinta', 'hintb'])
 
4255
 
 
4256
 
 
4257
class TestRepositoryIterInventories(TestRemoteRepository):
 
4258
    """Test Repository.iter_inventories."""
 
4259
 
 
4260
    def _serialize_inv_delta(self, old_name, new_name, delta):
 
4261
        serializer = inventory_delta.InventoryDeltaSerializer(True, False)
 
4262
        return "".join(serializer.delta_to_lines(old_name, new_name, delta))
 
4263
 
 
4264
    def test_single_empty(self):
 
4265
        transport_path = 'quack'
 
4266
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
4267
        fmt = controldir.format_registry.get('2a')().repository_format
 
4268
        repo._format = fmt
 
4269
        stream = [('inventory-deltas', [
 
4270
            versionedfile.FulltextContentFactory('somerevid', None, None,
 
4271
                self._serialize_inv_delta('null:', 'somerevid', []))])]
 
4272
        client.add_expected_call(
 
4273
            'VersionedFileRepository.get_inventories', ('quack/', 'unordered'),
 
4274
            'success', ('ok', ),
 
4275
            _stream_to_byte_stream(stream, fmt))
 
4276
        ret = list(repo.iter_inventories(["somerevid"]))
 
4277
        self.assertLength(1, ret)
 
4278
        inv = ret[0]
 
4279
        self.assertEqual("somerevid", inv.revision_id)
 
4280
 
 
4281
    def test_empty(self):
 
4282
        transport_path = 'quack'
 
4283
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
4284
        ret = list(repo.iter_inventories([]))
 
4285
        self.assertEqual(ret, [])
 
4286
 
 
4287
    def test_missing(self):
 
4288
        transport_path = 'quack'
 
4289
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
4290
        client.add_expected_call(
 
4291
            'VersionedFileRepository.get_inventories', ('quack/', 'unordered'),
 
4292
            'success', ('ok', ), iter([]))
 
4293
        self.assertRaises(errors.NoSuchRevision, list, repo.iter_inventories(
 
4294
            ["somerevid"]))