← 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: Patch Queue Manager
  • Date: 2016-01-31 13:36:59 UTC
  • mfrom: (6613.1.5 1538480-match-hostname)
  • Revision ID: pqm@pqm.ubuntu.com-20160131133659-ouy92ee2wlv9xz8m
(vila) Use ssl.match_hostname instead of our own. (Vincent Ladeuil)

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-2012 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,
33
35
    controldir,
34
36
    errors,
35
 
    graph,
36
37
    inventory,
37
38
    inventory_delta,
38
39
    remote,
41
42
    transport,
42
43
    treebuilder,
43
44
    versionedfile,
 
45
    vf_search,
44
46
    )
45
47
from bzrlib.branch import Branch
46
48
from bzrlib.bzrdir import (
48
50
    BzrDirFormat,
49
51
    RemoteBzrProber,
50
52
    )
 
53
from bzrlib.chk_serializer import chk_bencode_serializer
51
54
from bzrlib.remote import (
52
55
    RemoteBranch,
53
56
    RemoteBranchFormat,
54
57
    RemoteBzrDir,
 
58
    RemoteBzrDirFormat,
55
59
    RemoteRepository,
56
60
    RemoteRepositoryFormat,
57
61
    )
58
 
from bzrlib.repofmt import groupcompress_repo, pack_repo
59
 
from bzrlib.revision import NULL_REVISION
60
 
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
61
68
from bzrlib.smart.client import _SmartClient
62
 
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
63
75
from bzrlib.tests import (
64
 
    condition_isinstance,
65
 
    split_suite_by_condition,
66
 
    multiply_tests,
67
76
    test_server,
68
77
    )
 
78
from bzrlib.tests.scenarios import load_tests_apply_scenarios
69
79
from bzrlib.transport.memory import MemoryTransport
70
80
from bzrlib.transport.remote import (
71
81
    RemoteTransport,
72
82
    RemoteSSHTransport,
73
83
    RemoteTCPTransport,
74
 
)
75
 
 
76
 
def load_tests(standard_tests, module, loader):
77
 
    to_adapt, result = split_suite_by_condition(
78
 
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
79
 
    smart_server_version_scenarios = [
 
84
    )
 
85
 
 
86
 
 
87
load_tests = load_tests_apply_scenarios
 
88
 
 
89
 
 
90
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
 
91
 
 
92
    scenarios = [
80
93
        ('HPSS-v2',
81
 
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
 
94
            {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
82
95
        ('HPSS-v3',
83
 
         {'transport_server': test_server.SmartTCPServer_for_testing})]
84
 
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
85
 
 
86
 
 
87
 
class BasicRemoteObjectTests(tests.TestCaseWithTransport):
 
96
            {'transport_server': test_server.SmartTCPServer_for_testing})]
 
97
 
88
98
 
89
99
    def setUp(self):
90
100
        super(BasicRemoteObjectTests, self).setUp()
94
104
        self.addCleanup(self.transport.disconnect)
95
105
 
96
106
    def test_create_remote_bzrdir(self):
97
 
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
 
107
        b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
98
108
        self.assertIsInstance(b, BzrDir)
99
109
 
100
110
    def test_open_remote_branch(self):
101
111
        # open a standalone branch in the working directory
102
 
        b = remote.RemoteBzrDir(self.transport, remote.RemoteBzrDirFormat())
 
112
        b = remote.RemoteBzrDir(self.transport, RemoteBzrDirFormat())
103
113
        branch = b.open_branch()
104
114
        self.assertIsInstance(branch, Branch)
105
115
 
111
121
        self.local_wt.commit(message='test commit', rev_id=revid)
112
122
        self.assertTrue(repo.has_revision(revid))
113
123
 
114
 
    def test_remote_branch_revision_history(self):
115
 
        b = BzrDir.open_from_transport(self.transport).open_branch()
116
 
        self.assertEqual([], b.revision_history())
117
 
        r1 = self.local_wt.commit('1st commit')
118
 
        r2 = self.local_wt.commit('1st commit', rev_id=u'\xc8'.encode('utf8'))
119
 
        self.assertEqual([r1, r2], b.revision_history())
120
 
 
121
124
    def test_find_correct_format(self):
122
125
        """Should open a RemoteBzrDir over a RemoteTransport"""
123
126
        fmt = BzrDirFormat.find_format(self.transport)
124
127
        self.assertTrue(bzrdir.RemoteBzrProber
125
128
                        in controldir.ControlDirFormat._server_probers)
126
 
        self.assertIsInstance(fmt, remote.RemoteBzrDirFormat)
 
129
        self.assertIsInstance(fmt, RemoteBzrDirFormat)
127
130
 
128
131
    def test_open_detected_smart_format(self):
129
132
        fmt = BzrDirFormat.find_format(self.transport)
163
166
    def test_remote_branch_set_append_revisions_only(self):
164
167
        # Make a format 1.9 branch, which supports append_revisions_only
165
168
        branch = self.make_branch('branch', format='1.9')
166
 
        config = branch.get_config()
167
169
        branch.set_append_revisions_only(True)
 
170
        config = branch.get_config_stack()
168
171
        self.assertEqual(
169
 
            'True', config.get_user_option('append_revisions_only'))
 
172
            True, config.get('append_revisions_only'))
170
173
        branch.set_append_revisions_only(False)
 
174
        config = branch.get_config_stack()
171
175
        self.assertEqual(
172
 
            'False', config.get_user_option('append_revisions_only'))
 
176
            False, config.get('append_revisions_only'))
173
177
 
174
178
    def test_remote_branch_set_append_revisions_only_upgrade_reqd(self):
175
179
        branch = self.make_branch('branch', format='knit')
176
 
        config = branch.get_config()
177
180
        self.assertRaises(
178
181
            errors.UpgradeRequired, branch.set_append_revisions_only, True)
179
182
 
337
340
class TestRemote(tests.TestCaseWithMemoryTransport):
338
341
 
339
342
    def get_branch_format(self):
340
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
343
        reference_bzrdir_format = controldir.format_registry.get('default')()
341
344
        return reference_bzrdir_format.get_branch_format()
342
345
 
343
346
    def get_repo_format(self):
344
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
347
        reference_bzrdir_format = controldir.format_registry.get('default')()
345
348
        return reference_bzrdir_format.repository_format
346
349
 
347
350
    def assertFinished(self, fake_client):
449
452
        client.add_expected_call(
450
453
            'BzrDir.open_branchV3', ('quack/',),
451
454
            'success', ('ref', self.get_url('referenced'))),
452
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
455
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
453
456
            _client=client)
454
457
        result = a_bzrdir.cloning_metadir()
455
458
        # We should have got a control dir matching the referenced branch.
463
466
        transport = transport.clone('quack')
464
467
        self.make_bzrdir('quack')
465
468
        client = FakeClient(transport.base)
466
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
469
        reference_bzrdir_format = controldir.format_registry.get('default')()
467
470
        control_name = reference_bzrdir_format.network_name()
468
471
        client.add_expected_call(
469
472
            'BzrDir.cloning_metadir', ('quack/', 'False'),
470
473
            'success', (control_name, '', ('branch', ''))),
471
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
474
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
472
475
            _client=client)
473
476
        result = a_bzrdir.cloning_metadir()
474
477
        # We should have got a reference control dir with default branch and
479
482
        self.assertEqual(None, result._branch_format)
480
483
        self.assertFinished(client)
481
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.assertEquals(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
 
482
622
 
483
623
class TestBzrDirOpen(TestRemote):
484
624
 
494
634
        client.add_expected_call(
495
635
            'BzrDir.open_2.1', ('quack/',), 'success', ('no',))
496
636
        self.assertRaises(errors.NotBranchError, RemoteBzrDir, transport,
497
 
                remote.RemoteBzrDirFormat(), _client=client, _force_probe=True)
 
637
                RemoteBzrDirFormat(), _client=client, _force_probe=True)
498
638
        self.assertFinished(client)
499
639
 
500
640
    def test_present_without_workingtree(self):
501
641
        client, transport = self.make_fake_client_and_transport()
502
642
        client.add_expected_call(
503
643
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'no'))
504
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
644
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
505
645
            _client=client, _force_probe=True)
506
646
        self.assertIsInstance(bd, RemoteBzrDir)
507
647
        self.assertFalse(bd.has_workingtree())
512
652
        client, transport = self.make_fake_client_and_transport()
513
653
        client.add_expected_call(
514
654
            'BzrDir.open_2.1', ('quack/',), 'success', ('yes', 'yes'))
515
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
655
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
516
656
            _client=client, _force_probe=True)
517
657
        self.assertIsInstance(bd, RemoteBzrDir)
518
658
        self.assertTrue(bd.has_workingtree())
525
665
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
526
666
        client.add_expected_call(
527
667
            'BzrDir.open', ('quack/',), 'success', ('yes',))
528
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
668
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
529
669
            _client=client, _force_probe=True)
530
670
        self.assertIsInstance(bd, RemoteBzrDir)
531
671
        self.assertFinished(client)
547
687
            'BzrDir.open_2.1', ('quack/',), 'unknown', ('BzrDir.open_2.1',))
548
688
        client.add_expected_call(
549
689
            'BzrDir.open', ('quack/',), 'success', ('yes',))
550
 
        bd = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
690
        bd = RemoteBzrDir(transport, RemoteBzrDirFormat(),
551
691
            _client=client, _force_probe=True)
552
692
        self.assertIsInstance(bd, RemoteBzrDir)
553
693
        self.assertFinished(client)
584
724
        client.add_expected_call(
585
725
            'Branch.get_stacked_on_url', ('quack/',),
586
726
            'error', ('NotStacked',))
587
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
727
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
588
728
            _client=client)
589
729
        result = bzrdir.open_branch()
590
730
        self.assertIsInstance(result, RemoteBranch)
597
737
        transport = transport.clone('quack')
598
738
        client = FakeClient(transport.base)
599
739
        client.add_error_response('nobranch')
600
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
740
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
601
741
            _client=client)
602
742
        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)
603
743
        self.assertEqual(
608
748
        # _get_tree_branch is a form of open_branch, but it should only ask for
609
749
        # branch opening, not any other network requests.
610
750
        calls = []
611
 
        def open_branch(name=None):
 
751
        def open_branch(name=None, possible_transports=None):
612
752
            calls.append("Called")
613
753
            return "a-branch"
614
754
        transport = MemoryTransport()
615
755
        # no requests on the network - catches other api calls being made.
616
756
        client = FakeClient(transport.base)
617
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
757
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
618
758
            _client=client)
619
759
        # patch the open_branch call to record that it was called.
620
760
        bzrdir.open_branch = open_branch
639
779
        client.add_expected_call(
640
780
            'Branch.get_stacked_on_url', ('~hello/',),
641
781
            'error', ('NotStacked',))
642
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
782
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
643
783
            _client=client)
644
784
        result = bzrdir.open_branch()
645
785
        self.assertFinished(client)
662
802
        client.add_success_response(
663
803
            'ok', '', rich_response, subtree_response, external_lookup,
664
804
            network_name)
665
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
805
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
666
806
            _client=client)
667
807
        result = bzrdir.open_repository()
668
808
        self.assertEqual(
705
845
        transport = transport.clone('quack')
706
846
        self.make_repository('quack')
707
847
        client = FakeClient(transport.base)
708
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
848
        reference_bzrdir_format = controldir.format_registry.get('default')()
709
849
        reference_format = reference_bzrdir_format.get_branch_format()
710
850
        network_name = reference_format.network_name()
711
851
        reference_repo_fmt = reference_bzrdir_format.repository_format
714
854
            'BzrDir.create_branch', ('quack/', network_name),
715
855
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
716
856
            reference_repo_name))
717
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
857
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
718
858
            _client=client)
719
859
        branch = a_bzrdir.create_branch()
720
860
        # We should have got a remote branch
723
863
        format = branch._format
724
864
        self.assertEqual(network_name, format.network_name())
725
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
 
726
894
 
727
895
class TestBzrDirCreateRepository(TestRemote):
728
896
 
741
909
        transport = transport.clone('quack')
742
910
        self.make_bzrdir('quack')
743
911
        client = FakeClient(transport.base)
744
 
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
912
        reference_bzrdir_format = controldir.format_registry.get('default')()
745
913
        reference_format = reference_bzrdir_format.repository_format
746
914
        network_name = reference_format.network_name()
747
915
        client.add_expected_call(
749
917
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
750
918
                'False'),
751
919
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
752
 
        a_bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
920
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
753
921
            _client=client)
754
922
        repo = a_bzrdir.create_repository()
755
923
        # We should have got a remote repository
778
946
        # name.
779
947
        client.add_success_response_with_body(
780
948
            "Bazaar-NG meta directory, format 1\n", 'ok')
 
949
        client.add_success_response('stat', '0', '65535')
781
950
        client.add_success_response_with_body(
782
951
            reference_format.get_format_string(), 'ok')
783
952
        # PackRepository wants to do a stat
784
953
        client.add_success_response('stat', '0', '65535')
785
954
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
786
955
            _client=client)
787
 
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
 
956
        bzrdir = RemoteBzrDir(remote_transport, RemoteBzrDirFormat(),
788
957
            _client=client)
789
958
        repo = bzrdir.open_repository()
790
959
        self.assertEqual(
792
961
             ('call', 'BzrDir.find_repositoryV2', ('quack/',)),
793
962
             ('call', 'BzrDir.find_repository', ('quack/',)),
794
963
             ('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
 
964
             ('call', 'stat', ('/quack/.bzr',)),
795
965
             ('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
796
966
             ('call', 'stat', ('/quack/.bzr/repository',)),
797
967
             ],
811
981
        # name.
812
982
        client.add_success_response_with_body(
813
983
            "Bazaar-NG meta directory, format 1\n", 'ok')
 
984
        client.add_success_response('stat', '0', '65535')
814
985
        client.add_success_response_with_body(
815
986
            reference_format.get_format_string(), 'ok')
816
987
        # PackRepository wants to do a stat
817
988
        client.add_success_response('stat', '0', '65535')
818
989
        remote_transport = RemoteTransport(server_url + 'quack/', medium=False,
819
990
            _client=client)
820
 
        bzrdir = RemoteBzrDir(remote_transport, remote.RemoteBzrDirFormat(),
 
991
        bzrdir = RemoteBzrDir(remote_transport, RemoteBzrDirFormat(),
821
992
            _client=client)
822
993
        repo = bzrdir.open_repository()
823
994
        self.assertEqual(
824
995
            [('call', 'BzrDir.find_repositoryV3', ('quack/',)),
825
996
             ('call', 'BzrDir.find_repositoryV2', ('quack/',)),
826
997
             ('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
 
998
             ('call', 'stat', ('/quack/.bzr',)),
827
999
             ('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
828
1000
             ('call', 'stat', ('/quack/.bzr/repository',)),
829
1001
             ],
838
1010
        transport = transport.clone('quack')
839
1011
        client = FakeClient(transport.base)
840
1012
        client.add_success_response('ok', '', 'no', 'no', 'no', network_name)
841
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
1013
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
842
1014
            _client=client)
843
1015
        repo = bzrdir.open_repository()
844
1016
        self.assertEqual(
851
1023
 
852
1024
    def test_success(self):
853
1025
        """Simple test for typical successful call."""
854
 
        fmt = bzrdir.RemoteBzrDirFormat()
 
1026
        fmt = RemoteBzrDirFormat()
855
1027
        default_format_name = BzrDirFormat.get_default_format().network_name()
856
1028
        transport = self.get_transport()
857
1029
        client = FakeClient(transport.base)
873
1045
        """Error responses are translated, e.g. 'PermissionDenied' raises the
874
1046
        corresponding error from the client.
875
1047
        """
876
 
        fmt = bzrdir.RemoteBzrDirFormat()
 
1048
        fmt = RemoteBzrDirFormat()
877
1049
        default_format_name = BzrDirFormat.get_default_format().network_name()
878
1050
        transport = self.get_transport()
879
1051
        client = FakeClient(transport.base)
897
1069
        """Integration test for error translation."""
898
1070
        transport = self.make_smart_server('foo')
899
1071
        transport = transport.clone('no-such-path')
900
 
        fmt = bzrdir.RemoteBzrDirFormat()
 
1072
        fmt = RemoteBzrDirFormat()
901
1073
        err = self.assertRaises(errors.NoSuchFile,
902
1074
            fmt.initialize_on_transport_ex, transport, create_prefix=False)
903
1075
 
934
1106
 
935
1107
    def make_remote_bzrdir(self, transport, client):
936
1108
        """Make a RemotebzrDir using 'client' as the _client."""
937
 
        return RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
1109
        return RemoteBzrDir(transport, RemoteBzrDirFormat(),
938
1110
            _client=client)
939
1111
 
940
1112
 
966
1138
        return RemoteBranch(bzrdir, repo, _client=client, format=format)
967
1139
 
968
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
 
969
1195
class TestBranchGetParent(RemoteBranchTestCase):
970
1196
 
971
1197
    def test_no_parent(self):
1061
1287
        verb = 'Branch.set_parent_location'
1062
1288
        self.disable_verb(verb)
1063
1289
        branch.set_parent('http://foo/')
1064
 
        self.assertLength(12, self.hpss_calls)
 
1290
        self.assertLength(14, self.hpss_calls)
1065
1291
 
1066
1292
 
1067
1293
class TestBranchGetTagsBytes(RemoteBranchTestCase):
1142
1368
            [('set_tags_bytes', 'tags bytes')] * 2, real_branch.calls)
1143
1369
 
1144
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
 
1145
1477
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1146
1478
 
1147
1479
    def test_empty_branch(self):
1202
1534
        client.add_expected_call(
1203
1535
            'Branch.get_stacked_on_url', ('stacked/',),
1204
1536
            'success', ('ok', vfs_url))
1205
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
1537
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
1206
1538
            _client=client)
1207
1539
        repo_fmt = remote.RemoteRepositoryFormat()
1208
1540
        repo_fmt._custom_format = stacked_branch.repository._format
1235
1567
        # this will also do vfs access, but that goes direct to the transport
1236
1568
        # and isn't seen by the FakeClient.
1237
1569
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1238
 
            remote.RemoteBzrDirFormat(), _client=client)
 
1570
            RemoteBzrDirFormat(), _client=client)
1239
1571
        branch = bzrdir.open_branch()
1240
1572
        result = branch.get_stacked_on_url()
1241
1573
        self.assertEqual('../base', result)
1268
1600
            'Branch.get_stacked_on_url', ('stacked/',),
1269
1601
            'success', ('ok', '../base'))
1270
1602
        bzrdir = RemoteBzrDir(self.get_transport('stacked'),
1271
 
            remote.RemoteBzrDirFormat(), _client=client)
 
1603
            RemoteBzrDirFormat(), _client=client)
1272
1604
        branch = bzrdir.open_branch()
1273
1605
        result = branch.get_stacked_on_url()
1274
1606
        self.assertEqual('../base', result)
1282
1614
class TestBranchSetLastRevision(RemoteBranchTestCase):
1283
1615
 
1284
1616
    def test_set_empty(self):
1285
 
        # set_revision_history([]) is translated to calling
 
1617
        # _set_last_revision_info('null:') is translated to calling
1286
1618
        # Branch.set_last_revision(path, '') on the wire.
1287
1619
        transport = MemoryTransport()
1288
1620
        transport.mkdir('branch')
1306
1638
            'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1307
1639
            'success', ('ok',))
1308
1640
        branch = self.make_remote_branch(transport, client)
1309
 
        # This is a hack to work around the problem that RemoteBranch currently
1310
 
        # unnecessarily invokes _ensure_real upon a call to lock_write.
1311
 
        branch._ensure_real = lambda: None
1312
1641
        branch.lock_write()
1313
 
        result = branch.set_revision_history([])
 
1642
        result = branch._set_last_revision(NULL_REVISION)
1314
1643
        branch.unlock()
1315
1644
        self.assertEqual(None, result)
1316
1645
        self.assertFinished(client)
1317
1646
 
1318
1647
    def test_set_nonempty(self):
1319
 
        # set_revision_history([rev-id1, ..., rev-idN]) is translated to calling
 
1648
        # set_last_revision_info(N, rev-idN) is translated to calling
1320
1649
        # Branch.set_last_revision(path, rev-idN) on the wire.
1321
1650
        transport = MemoryTransport()
1322
1651
        transport.mkdir('branch')
1343
1672
            'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1344
1673
            'success', ('ok',))
1345
1674
        branch = self.make_remote_branch(transport, client)
1346
 
        # This is a hack to work around the problem that RemoteBranch currently
1347
 
        # unnecessarily invokes _ensure_real upon a call to lock_write.
1348
 
        branch._ensure_real = lambda: None
1349
1675
        # Lock the branch, reset the record of remote calls.
1350
1676
        branch.lock_write()
1351
 
        result = branch.set_revision_history(['rev-id1', 'rev-id2'])
 
1677
        result = branch._set_last_revision('rev-id2')
1352
1678
        branch.unlock()
1353
1679
        self.assertEqual(None, result)
1354
1680
        self.assertFinished(client)
1384
1710
        branch = self.make_remote_branch(transport, client)
1385
1711
        branch.lock_write()
1386
1712
        self.assertRaises(
1387
 
            errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])
 
1713
            errors.NoSuchRevision, branch._set_last_revision, 'rev-id')
1388
1714
        branch.unlock()
1389
1715
        self.assertFinished(client)
1390
1716
 
1418
1744
            'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1419
1745
            'success', ('ok',))
1420
1746
        branch = self.make_remote_branch(transport, client)
1421
 
        branch._ensure_real = lambda: None
1422
1747
        branch.lock_write()
1423
1748
        # The 'TipChangeRejected' error response triggered by calling
1424
 
        # set_revision_history causes a TipChangeRejected exception.
 
1749
        # set_last_revision_info causes a TipChangeRejected exception.
1425
1750
        err = self.assertRaises(
1426
 
            errors.TipChangeRejected, branch.set_revision_history, ['rev-id'])
 
1751
            errors.TipChangeRejected,
 
1752
            branch._set_last_revision, 'rev-id')
1427
1753
        # The UTF-8 message from the response has been decoded into a unicode
1428
1754
        # object.
1429
1755
        self.assertIsInstance(err.msg, unicode)
1686
2012
        self.addCleanup(branch.unlock)
1687
2013
        self.reset_smart_call_log()
1688
2014
        branch._get_config().set_option('value', 'name')
1689
 
        self.assertLength(10, self.hpss_calls)
 
2015
        self.assertLength(11, self.hpss_calls)
1690
2016
        self.assertEqual('value', branch._get_config().get_option('name'))
1691
2017
 
1692
2018
    def test_backwards_compat_set_option_with_dict(self):
1700
2026
        config = branch._get_config()
1701
2027
        value_dict = {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
1702
2028
        config.set_option(value_dict, 'name')
1703
 
        self.assertLength(10, self.hpss_calls)
 
2029
        self.assertLength(11, self.hpss_calls)
1704
2030
        self.assertEqual(value_dict, branch._get_config().get_option('name'))
1705
2031
 
1706
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
 
1707
2092
class TestBranchLockWrite(RemoteBranchTestCase):
1708
2093
 
1709
2094
    def test_lock_write_unlockable(self):
1722
2107
        self.assertFinished(client)
1723
2108
 
1724
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.assertEquals(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.assertEquals((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.assertEquals((0, ),
 
2158
            branch.revision_id_to_dotted_revno('null:'))
 
2159
        self.assertLength(8, self.hpss_calls)
 
2160
 
 
2161
 
1725
2162
class TestBzrDirGetSetConfig(RemoteBzrDirTestCase):
1726
2163
 
1727
2164
    def test__get_config(self):
1741
2178
        self.reset_smart_call_log()
1742
2179
        config = bzrdir.get_config()
1743
2180
        config.set_default_stack_on('/')
1744
 
        self.assertLength(3, self.hpss_calls)
 
2181
        self.assertLength(4, self.hpss_calls)
1745
2182
 
1746
2183
    def test_backwards_compat_get_option(self):
1747
2184
        self.setup_smart_server_with_call_log()
1751
2188
        self.reset_smart_call_log()
1752
2189
        self.assertEqual(None,
1753
2190
            bzrdir._get_config().get_option('default_stack_on'))
1754
 
        self.assertLength(3, self.hpss_calls)
 
2191
        self.assertLength(4, self.hpss_calls)
1755
2192
 
1756
2193
 
1757
2194
class TestTransportIsReadonly(tests.TestCase):
1844
2281
        client = FakeClient(transport.base)
1845
2282
        transport = transport.clone(transport_path)
1846
2283
        # we do not want bzrdir to make any remote calls
1847
 
        bzrdir = RemoteBzrDir(transport, remote.RemoteBzrDirFormat(),
 
2284
        bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
1848
2285
            _client=False)
1849
2286
        repo = RemoteRepository(bzrdir, None, _client=client)
1850
2287
        return repo, client
1858
2295
 
1859
2296
    def test_get_format_description(self):
1860
2297
        remote_format = RemoteBranchFormat()
1861
 
        real_format = branch.BranchFormat.get_default_format()
 
2298
        real_format = branch.format_registry.get_default()
1862
2299
        remote_format._network_name = real_format.network_name()
1863
2300
        self.assertEqual(remoted_description(real_format),
1864
2301
            remote_format.get_format_description())
1867
2304
class TestRepositoryFormat(TestRemoteRepository):
1868
2305
 
1869
2306
    def test_fast_delta(self):
1870
 
        true_name = groupcompress_repo.RepositoryFormatCHK1().network_name()
 
2307
        true_name = groupcompress_repo.RepositoryFormat2a().network_name()
1871
2308
        true_format = RemoteRepositoryFormat()
1872
2309
        true_format._network_name = true_name
1873
2310
        self.assertEqual(True, true_format.fast_deltas)
1874
 
        false_name = pack_repo.RepositoryFormatKnitPack1().network_name()
 
2311
        false_name = knitpack_repo.RepositoryFormatKnitPack1().network_name()
1875
2312
        false_format = RemoteRepositoryFormat()
1876
2313
        false_format._network_name = false_name
1877
2314
        self.assertEqual(False, false_format.fast_deltas)
1878
2315
 
1879
2316
    def test_get_format_description(self):
1880
2317
        remote_repo_format = RemoteRepositoryFormat()
1881
 
        real_format = repository.RepositoryFormat.get_default_format()
 
2318
        real_format = repository.format_registry.get_default()
1882
2319
        remote_repo_format._network_name = real_format.network_name()
1883
2320
        self.assertEqual(remoted_description(real_format),
1884
2321
            remote_repo_format.get_format_description())
1885
2322
 
1886
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.assertEquals([], 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.assertEquals(["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
 
1887
2349
class TestRepositoryGatherStats(TestRemoteRepository):
1888
2350
 
1889
2351
    def test_revid_none(self):
1942
2404
                         result)
1943
2405
 
1944
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.assertEquals('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.assertEquals(2, reconciler.garbage_inventories)
 
2450
        self.assertEquals(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.assertEquals("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
 
1945
2479
class TestRepositoryGetGraph(TestRemoteRepository):
1946
2480
 
1947
2481
    def test_get_graph(self):
1952
2486
        self.assertNotEqual(graph._parents_provider, repo)
1953
2487
 
1954
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
 
1955
2516
class TestRepositoryGetParentMap(TestRemoteRepository):
1956
2517
 
1957
2518
    def test_get_parent_map_caching(self):
2007
2568
        parents = repo.get_parent_map([rev_id])
2008
2569
        self.assertEqual(
2009
2570
            [('call_with_body_bytes_expecting_body',
2010
 
              'Repository.get_parent_map', ('quack/', 'include-missing:',
2011
 
              rev_id), '\n\n0'),
 
2571
              'Repository.get_parent_map',
 
2572
              ('quack/', 'include-missing:', rev_id), '\n\n0'),
2012
2573
             ('disconnect medium',),
2013
2574
             ('call_expecting_body', 'Repository.get_revision_graph',
2014
2575
              ('quack/', ''))],
2134
2695
        self.assertEqual({}, repo.get_parent_map(['non-existant']))
2135
2696
        self.assertLength(0, self.hpss_calls)
2136
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
 
2137
2724
 
2138
2725
class TestGetParentMapAllowsNew(tests.TestCaseWithTransport):
2139
2726
 
2154
2741
        self.assertEqual({'rev1': ('null:',)}, graph.get_parent_map(['rev1']))
2155
2742
 
2156
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.assertEquals(revs, [somerev1])
 
2775
        self.assertEqual(
 
2776
            [('call_with_body_bytes_expecting_body', 'Repository.iter_revisions',
 
2777
             ('quack/', ), "somerev1")],
 
2778
            client._calls)
 
2779
 
 
2780
 
2157
2781
class TestRepositoryGetRevisionGraph(TestRemoteRepository):
2158
2782
 
2159
2783
    def test_null_revision(self):
2310
2934
                              call.call.method == verb])
2311
2935
 
2312
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
 
2313
2989
class TestRepositoryIsShared(TestRemoteRepository):
2314
2990
 
2315
2991
    def test_is_shared(self):
2335
3011
        self.assertEqual(False, result)
2336
3012
 
2337
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
 
2338
3039
class TestRepositoryLockWrite(TestRemoteRepository):
2339
3040
 
2340
3041
    def test_lock_write(self):
2366
3067
            client._calls)
2367
3068
 
2368
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.assertEquals(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.assertEquals([], 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
 
2369
3155
class TestRepositorySetMakeWorkingTrees(TestRemoteRepository):
2370
3156
 
2371
3157
    def test_backwards_compat(self):
2430
3216
        self.assertEqual([], client._calls)
2431
3217
 
2432
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.assertEquals("myid", identifier)
 
3231
            self.assertEquals("".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
 
2433
3246
class TestRepositoryInsertStreamBase(TestRemoteRepository):
2434
3247
    """Base class for Repository.insert_stream and .insert_stream_1.19
2435
3248
    tests.
2442
3255
        the client is finished.
2443
3256
        """
2444
3257
        sink = repo._get_sink()
2445
 
        fmt = repository.RepositoryFormat.get_default_format()
 
3258
        fmt = repository.format_registry.get_default()
2446
3259
        resume_tokens, missing_keys = sink.insert_stream([], fmt, [])
2447
3260
        self.assertEqual([], resume_tokens)
2448
3261
        self.assertEqual(set(), missing_keys)
2457
3270
    """
2458
3271
 
2459
3272
    def setUp(self):
2460
 
        TestRemoteRepository.setUp(self)
 
3273
        super(TestRepositoryInsertStream, self).setUp()
2461
3274
        self.disable_verb('Repository.insert_stream_1.19')
2462
3275
 
2463
3276
    def test_unlocked_repo(self):
2548
3361
                return True
2549
3362
        repo._real_repository = FakeRealRepository()
2550
3363
        sink = repo._get_sink()
2551
 
        fmt = repository.RepositoryFormat.get_default_format()
 
3364
        fmt = repository.format_registry.get_default()
2552
3365
        stream = self.make_stream_with_inv_deltas(fmt)
2553
3366
        resume_tokens, missing_keys = sink.insert_stream(stream, fmt, [])
2554
3367
        # Every record from the first inventory delta should have been sent to
2710
3523
        self.calls = calls
2711
3524
        self._pack_collection = _StubPackCollection(calls)
2712
3525
 
 
3526
    def start_write_group(self):
 
3527
        self.calls.append(('start_write_group',))
 
3528
 
2713
3529
    def is_in_write_group(self):
2714
3530
        return False
2715
3531
 
2774
3590
             ('pack collection autopack',)],
2775
3591
            client._calls)
2776
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
 
2777
3603
 
2778
3604
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
2779
3605
    """Base class for unit tests for bzrlib.remote._translate_error."""
2852
3678
            detail='extra detail')
2853
3679
        self.assertEqual(expected_error, translated_error)
2854
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
 
2855
3688
    def test_LockContention(self):
2856
3689
        translated_error = self.translateTuple(('LockContention',))
2857
3690
        expected_error = errors.LockContention('(remote lock)')
2885
3718
        expected_error = errors.DivergedBranches(branch, other_branch)
2886
3719
        self.assertEqual(expected_error, translated_error)
2887
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
 
2888
3727
    def test_ReadError_no_args(self):
2889
3728
        path = 'a path'
2890
3729
        translated_error = self.translateTuple(('ReadError',), path=path)
2906
3745
 
2907
3746
    def test_PermissionDenied_no_args(self):
2908
3747
        path = 'a path'
2909
 
        translated_error = self.translateTuple(('PermissionDenied',), path=path)
 
3748
        translated_error = self.translateTuple(('PermissionDenied',),
 
3749
            path=path)
2910
3750
        expected_error = errors.PermissionDenied(path)
2911
3751
        self.assertEqual(expected_error, translated_error)
2912
3752
 
2935
3775
        expected_error = errors.PermissionDenied(path, extra)
2936
3776
        self.assertEqual(expected_error, translated_error)
2937
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
 
2938
3817
 
2939
3818
class TestErrorTranslationRobustness(TestErrorTranslationBase):
2940
3819
    """Unit tests for bzrlib.remote._translate_error's robustness.
3076
3955
        :result: The revision ids in the stream, in the order seen,
3077
3956
            the topological order of revisions in the source.
3078
3957
        """
3079
 
        unordered_format = bzrdir.format_registry.get(format)()
 
3958
        unordered_format = controldir.format_registry.get(format)()
3080
3959
        target_repository_format = unordered_format.repository_format
3081
3960
        # Cross check
3082
3961
        self.assertEqual(order, target_repository_format._fetch_order)
3085
3964
        _, stacked = branch_factory()
3086
3965
        source = stacked.repository._get_source(target_repository_format)
3087
3966
        tip = stacked.last_revision()
3088
 
        revs = stacked.repository.get_ancestry(tip)
3089
 
        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)
3090
3973
        self.reset_smart_call_log()
3091
3974
        stream = source.get_stream(search)
3092
 
        if None in revs:
3093
 
            revs.remove(None)
3094
3975
        # We trust that if a revision is in the stream the rest of the new
3095
3976
        # content for it is too, as per our main fetch tests; here we are
3096
3977
        # checking that the revisions are actually included at all, and their
3135
4016
        self.assertEqual(expected_revs, rev_ord)
3136
4017
        # Getting topological sort requires VFS calls still - one of which is
3137
4018
        # pushing up from the bound branch.
3138
 
        self.assertLength(13, self.hpss_calls)
 
4019
        self.assertLength(14, self.hpss_calls)
3139
4020
 
3140
4021
    def test_stacked_get_stream_groupcompress(self):
3141
4022
        # Repository._get_source.get_stream() from a stacked repository with
3182
4063
 
3183
4064
    def test_copy_content_into_avoids_revision_history(self):
3184
4065
        local = self.make_branch('local')
3185
 
        remote_backing_tree = self.make_branch_and_tree('remote')
3186
 
        remote_backing_tree.commit("Commit.")
 
4066
        builder = self.make_branch_builder('remote')
 
4067
        builder.build_commit(message="Commit.")
3187
4068
        remote_branch_url = self.smart_server.get_url() + 'remote'
3188
4069
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3189
4070
        local.repository.fetch(remote_branch.repository)
3190
4071
        self.hpss_calls = []
3191
4072
        remote_branch.copy_content_into(local)
3192
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.assertEquals(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.assertEquals("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.assertEquals(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"]))