← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_remote.py

  • Committer: Vincent Ladeuil
  • Date: 2012-02-24 12:50:51 UTC
  • mfrom: (6437.23.15 2.5)
  • mto: This revision was merged to the branch mainline in revision 6475.
  • Revision ID: v.ladeuil+lp@free.fr-20120224125051-i7p1xmjxw56jhmj3
Merge 2.5 branch

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
1
 
# Copyright (C) 2006-2011 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,
57
60
    RemoteRepositoryFormat,
58
61
    )
59
62
from bzrlib.repofmt import groupcompress_repo, knitpack_repo
60
 
from bzrlib.revision import NULL_REVISION
 
63
from bzrlib.revision import (
 
64
    NULL_REVISION,
 
65
    Revision,
 
66
    )
61
67
from bzrlib.smart import medium, request
62
68
from bzrlib.smart.client import _SmartClient
63
69
from bzrlib.smart.repository import (
64
70
    SmartServerRepositoryGetParentMap,
65
71
    SmartServerRepositoryGetStream_1_19,
 
72
    _stream_to_byte_stream,
66
73
    )
 
74
from bzrlib.symbol_versioning import deprecated_in
67
75
from bzrlib.tests import (
68
76
    test_server,
69
77
    )
115
123
 
116
124
    def test_remote_branch_revision_history(self):
117
125
        b = BzrDir.open_from_transport(self.transport).open_branch()
118
 
        self.assertEqual([], b.revision_history())
 
126
        self.assertEqual([],
 
127
            self.applyDeprecated(deprecated_in((2, 5, 0)), b.revision_history))
119
128
        r1 = self.local_wt.commit('1st commit')
120
129
        r2 = self.local_wt.commit('1st commit', rev_id=u'\xc8'.encode('utf8'))
121
 
        self.assertEqual([r1, r2], b.revision_history())
 
130
        self.assertEqual([r1, r2],
 
131
            self.applyDeprecated(deprecated_in((2, 5, 0)), b.revision_history))
122
132
 
123
133
    def test_find_correct_format(self):
124
134
        """Should open a RemoteBzrDir over a RemoteTransport"""
165
175
    def test_remote_branch_set_append_revisions_only(self):
166
176
        # Make a format 1.9 branch, which supports append_revisions_only
167
177
        branch = self.make_branch('branch', format='1.9')
168
 
        config = branch.get_config()
169
178
        branch.set_append_revisions_only(True)
 
179
        config = branch.get_config_stack()
170
180
        self.assertEqual(
171
 
            'True', config.get_user_option('append_revisions_only'))
 
181
            True, config.get('append_revisions_only'))
172
182
        branch.set_append_revisions_only(False)
 
183
        config = branch.get_config_stack()
173
184
        self.assertEqual(
174
 
            'False', config.get_user_option('append_revisions_only'))
 
185
            False, config.get('append_revisions_only'))
175
186
 
176
187
    def test_remote_branch_set_append_revisions_only_upgrade_reqd(self):
177
188
        branch = self.make_branch('branch', format='knit')
178
 
        config = branch.get_config()
179
189
        self.assertRaises(
180
190
            errors.UpgradeRequired, branch.set_append_revisions_only, True)
181
191
 
481
491
        self.assertEqual(None, result._branch_format)
482
492
        self.assertFinished(client)
483
493
 
 
494
    def test_unknown(self):
 
495
        transport = self.get_transport('quack')
 
496
        referenced = self.make_branch('referenced')
 
497
        expected = referenced.bzrdir.cloning_metadir()
 
498
        client = FakeClient(transport.base)
 
499
        client.add_expected_call(
 
500
            'BzrDir.cloning_metadir', ('quack/', 'False'),
 
501
            'success', ('unknown', 'unknown', ('branch', ''))),
 
502
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
503
            _client=client)
 
504
        self.assertRaises(errors.UnknownFormatError, a_bzrdir.cloning_metadir)
 
505
 
 
506
 
 
507
class TestBzrDirCheckoutMetaDir(TestRemote):
 
508
 
 
509
    def test__get_checkout_format(self):
 
510
        transport = MemoryTransport()
 
511
        client = FakeClient(transport.base)
 
512
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
513
        control_name = reference_bzrdir_format.network_name()
 
514
        client.add_expected_call(
 
515
            'BzrDir.checkout_metadir', ('quack/', ),
 
516
            'success', (control_name, '', ''))
 
517
        transport.mkdir('quack')
 
518
        transport = transport.clone('quack')
 
519
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
520
            _client=client)
 
521
        result = a_bzrdir.checkout_metadir()
 
522
        # We should have got a reference control dir with default branch and
 
523
        # repository formats.
 
524
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
 
525
        self.assertEqual(None, result._repository_format)
 
526
        self.assertEqual(None, result._branch_format)
 
527
        self.assertFinished(client)
 
528
 
 
529
    def test_unknown_format(self):
 
530
        transport = MemoryTransport()
 
531
        client = FakeClient(transport.base)
 
532
        client.add_expected_call(
 
533
            'BzrDir.checkout_metadir', ('quack/',),
 
534
            'success', ('dontknow', '', ''))
 
535
        transport.mkdir('quack')
 
536
        transport = transport.clone('quack')
 
537
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
538
            _client=client)
 
539
        self.assertRaises(errors.UnknownFormatError,
 
540
            a_bzrdir.checkout_metadir)
 
541
        self.assertFinished(client)
 
542
 
 
543
 
 
544
class TestBzrDirGetBranches(TestRemote):
 
545
 
 
546
    def test_get_branches(self):
 
547
        transport = MemoryTransport()
 
548
        client = FakeClient(transport.base)
 
549
        reference_bzrdir_format = bzrdir.format_registry.get('default')()
 
550
        branch_name = reference_bzrdir_format.get_branch_format().network_name()
 
551
        client.add_success_response_with_body(
 
552
            bencode.bencode({
 
553
                "foo": ("branch", branch_name),
 
554
                "": ("branch", branch_name)}), "success")
 
555
        client.add_success_response(
 
556
            'ok', '', 'no', 'no', 'no',
 
557
                reference_bzrdir_format.repository_format.network_name())
 
558
        client.add_error_response('NotStacked')
 
559
        client.add_success_response(
 
560
            'ok', '', 'no', 'no', 'no',
 
561
                reference_bzrdir_format.repository_format.network_name())
 
562
        client.add_error_response('NotStacked')
 
563
        transport.mkdir('quack')
 
564
        transport = transport.clone('quack')
 
565
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
566
            _client=client)
 
567
        result = a_bzrdir.get_branches()
 
568
        self.assertEquals(set(["", "foo"]), set(result.keys()))
 
569
        self.assertEqual(
 
570
            [('call_expecting_body', 'BzrDir.get_branches', ('quack/',)),
 
571
             ('call', 'BzrDir.find_repositoryV3', ('quack/', )),
 
572
             ('call', 'Branch.get_stacked_on_url', ('quack/', )),
 
573
             ('call', 'BzrDir.find_repositoryV3', ('quack/', )),
 
574
             ('call', 'Branch.get_stacked_on_url', ('quack/', ))],
 
575
            client._calls)
 
576
 
 
577
 
 
578
class TestBzrDirDestroyBranch(TestRemote):
 
579
 
 
580
    def test_destroy_default(self):
 
581
        transport = self.get_transport('quack')
 
582
        referenced = self.make_branch('referenced')
 
583
        client = FakeClient(transport.base)
 
584
        client.add_expected_call(
 
585
            'BzrDir.destroy_branch', ('quack/', ),
 
586
            'success', ('ok',)),
 
587
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
588
            _client=client)
 
589
        a_bzrdir.destroy_branch()
 
590
        self.assertFinished(client)
 
591
 
 
592
 
 
593
class TestBzrDirHasWorkingTree(TestRemote):
 
594
 
 
595
    def test_has_workingtree(self):
 
596
        transport = self.get_transport('quack')
 
597
        client = FakeClient(transport.base)
 
598
        client.add_expected_call(
 
599
            'BzrDir.has_workingtree', ('quack/',),
 
600
            'success', ('yes',)),
 
601
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
602
            _client=client)
 
603
        self.assertTrue(a_bzrdir.has_workingtree())
 
604
        self.assertFinished(client)
 
605
 
 
606
    def test_no_workingtree(self):
 
607
        transport = self.get_transport('quack')
 
608
        client = FakeClient(transport.base)
 
609
        client.add_expected_call(
 
610
            'BzrDir.has_workingtree', ('quack/',),
 
611
            'success', ('no',)),
 
612
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
613
            _client=client)
 
614
        self.assertFalse(a_bzrdir.has_workingtree())
 
615
        self.assertFinished(client)
 
616
 
 
617
 
 
618
class TestBzrDirDestroyRepository(TestRemote):
 
619
 
 
620
    def test_destroy_repository(self):
 
621
        transport = self.get_transport('quack')
 
622
        client = FakeClient(transport.base)
 
623
        client.add_expected_call(
 
624
            'BzrDir.destroy_repository', ('quack/',),
 
625
            'success', ('ok',)),
 
626
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
627
            _client=client)
 
628
        a_bzrdir.destroy_repository()
 
629
        self.assertFinished(client)
 
630
 
484
631
 
485
632
class TestBzrDirOpen(TestRemote):
486
633
 
610
757
        # _get_tree_branch is a form of open_branch, but it should only ask for
611
758
        # branch opening, not any other network requests.
612
759
        calls = []
613
 
        def open_branch(name=None):
 
760
        def open_branch(name=None, possible_transports=None):
614
761
            calls.append("Called")
615
762
            return "a-branch"
616
763
        transport = MemoryTransport()
808
955
        # name.
809
956
        client.add_success_response_with_body(
810
957
            "Bazaar-NG meta directory, format 1\n", 'ok')
 
958
        client.add_success_response('stat', '0', '65535')
811
959
        client.add_success_response_with_body(
812
960
            reference_format.get_format_string(), 'ok')
813
961
        # PackRepository wants to do a stat
822
970
             ('call', 'BzrDir.find_repositoryV2', ('quack/',)),
823
971
             ('call', 'BzrDir.find_repository', ('quack/',)),
824
972
             ('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
 
973
             ('call', 'stat', ('/quack/.bzr',)),
825
974
             ('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
826
975
             ('call', 'stat', ('/quack/.bzr/repository',)),
827
976
             ],
841
990
        # name.
842
991
        client.add_success_response_with_body(
843
992
            "Bazaar-NG meta directory, format 1\n", 'ok')
 
993
        client.add_success_response('stat', '0', '65535')
844
994
        client.add_success_response_with_body(
845
995
            reference_format.get_format_string(), 'ok')
846
996
        # PackRepository wants to do a stat
854
1004
            [('call', 'BzrDir.find_repositoryV3', ('quack/',)),
855
1005
             ('call', 'BzrDir.find_repositoryV2', ('quack/',)),
856
1006
             ('call_expecting_body', 'get', ('/quack/.bzr/branch-format',)),
 
1007
             ('call', 'stat', ('/quack/.bzr',)),
857
1008
             ('call_expecting_body', 'get', ('/quack/.bzr/repository/format',)),
858
1009
             ('call', 'stat', ('/quack/.bzr/repository',)),
859
1010
             ],
996
1147
        return RemoteBranch(bzrdir, repo, _client=client, format=format)
997
1148
 
998
1149
 
 
1150
class TestBranchBreakLock(RemoteBranchTestCase):
 
1151
 
 
1152
    def test_break_lock(self):
 
1153
        transport_path = 'quack'
 
1154
        transport = MemoryTransport()
 
1155
        client = FakeClient(transport.base)
 
1156
        client.add_expected_call(
 
1157
            'Branch.get_stacked_on_url', ('quack/',),
 
1158
            'error', ('NotStacked',))
 
1159
        client.add_expected_call(
 
1160
            'Branch.break_lock', ('quack/',),
 
1161
            'success', ('ok',))
 
1162
        transport.mkdir('quack')
 
1163
        transport = transport.clone('quack')
 
1164
        branch = self.make_remote_branch(transport, client)
 
1165
        branch.break_lock()
 
1166
        self.assertFinished(client)
 
1167
 
 
1168
 
 
1169
class TestBranchGetPhysicalLockStatus(RemoteBranchTestCase):
 
1170
 
 
1171
    def test_get_physical_lock_status_yes(self):
 
1172
        transport = MemoryTransport()
 
1173
        client = FakeClient(transport.base)
 
1174
        client.add_expected_call(
 
1175
            'Branch.get_stacked_on_url', ('quack/',),
 
1176
            'error', ('NotStacked',))
 
1177
        client.add_expected_call(
 
1178
            'Branch.get_physical_lock_status', ('quack/',),
 
1179
            'success', ('yes',))
 
1180
        transport.mkdir('quack')
 
1181
        transport = transport.clone('quack')
 
1182
        branch = self.make_remote_branch(transport, client)
 
1183
        result = branch.get_physical_lock_status()
 
1184
        self.assertFinished(client)
 
1185
        self.assertEqual(True, result)
 
1186
 
 
1187
    def test_get_physical_lock_status_no(self):
 
1188
        transport = MemoryTransport()
 
1189
        client = FakeClient(transport.base)
 
1190
        client.add_expected_call(
 
1191
            'Branch.get_stacked_on_url', ('quack/',),
 
1192
            'error', ('NotStacked',))
 
1193
        client.add_expected_call(
 
1194
            'Branch.get_physical_lock_status', ('quack/',),
 
1195
            'success', ('no',))
 
1196
        transport.mkdir('quack')
 
1197
        transport = transport.clone('quack')
 
1198
        branch = self.make_remote_branch(transport, client)
 
1199
        result = branch.get_physical_lock_status()
 
1200
        self.assertFinished(client)
 
1201
        self.assertEqual(False, result)
 
1202
 
 
1203
 
999
1204
class TestBranchGetParent(RemoteBranchTestCase):
1000
1205
 
1001
1206
    def test_no_parent(self):
1091
1296
        verb = 'Branch.set_parent_location'
1092
1297
        self.disable_verb(verb)
1093
1298
        branch.set_parent('http://foo/')
1094
 
        self.assertLength(12, self.hpss_calls)
 
1299
        self.assertLength(14, self.hpss_calls)
1095
1300
 
1096
1301
 
1097
1302
class TestBranchGetTagsBytes(RemoteBranchTestCase):
1183
1388
        client.add_expected_call(
1184
1389
            'Branch.last_revision_info', ('quack/',),
1185
1390
            'success', ('ok', '1', 'rev-tip'))
 
1391
        client.add_expected_call(
 
1392
            'Branch.get_config_file', ('quack/',),
 
1393
            'success', ('ok',), '')
 
1394
        transport.mkdir('quack')
 
1395
        transport = transport.clone('quack')
 
1396
        branch = self.make_remote_branch(transport, client)
 
1397
        result = branch.heads_to_fetch()
 
1398
        self.assertFinished(client)
 
1399
        self.assertEqual((set(['rev-tip']), set()), result)
 
1400
 
 
1401
    def test_uses_last_revision_info_and_tags_when_set(self):
 
1402
        transport = MemoryTransport()
 
1403
        client = FakeClient(transport.base)
 
1404
        client.add_expected_call(
 
1405
            'Branch.get_stacked_on_url', ('quack/',),
 
1406
            'error', ('NotStacked',))
 
1407
        client.add_expected_call(
 
1408
            'Branch.last_revision_info', ('quack/',),
 
1409
            'success', ('ok', '1', 'rev-tip'))
 
1410
        client.add_expected_call(
 
1411
            'Branch.get_config_file', ('quack/',),
 
1412
            'success', ('ok',), 'branch.fetch_tags = True')
1186
1413
        # XXX: this will break if the default format's serialization of tags
1187
1414
        # changes, or if the RPC for fetching tags changes from get_tags_bytes.
1188
1415
        client.add_expected_call(
1213
1440
        self.assertFinished(client)
1214
1441
        self.assertEqual((set(['tip']), set(['tagged-1', 'tagged-2'])), result)
1215
1442
 
1216
 
    def test_backwards_compatible(self):
 
1443
    def make_branch_with_tags(self):
1217
1444
        self.setup_smart_server_with_call_log()
1218
1445
        # Make a branch with a single revision.
1219
1446
        builder = self.make_branch_builder('foo')
1225
1452
        # Add two tags to that branch
1226
1453
        branch.tags.set_tag('tag-1', 'rev-1')
1227
1454
        branch.tags.set_tag('tag-2', 'rev-2')
1228
 
        self.addCleanup(branch.lock_read().unlock)
 
1455
        return branch
 
1456
 
 
1457
    def test_backwards_compatible(self):
 
1458
        br = self.make_branch_with_tags()
 
1459
        br.get_config_stack().set('branch.fetch_tags', True)
 
1460
        self.addCleanup(br.lock_read().unlock)
1229
1461
        # Disable the heads_to_fetch verb
1230
1462
        verb = 'Branch.heads_to_fetch'
1231
1463
        self.disable_verb(verb)
1232
1464
        self.reset_smart_call_log()
1233
 
        result = branch.heads_to_fetch()
 
1465
        result = br.heads_to_fetch()
1234
1466
        self.assertEqual((set(['tip']), set(['rev-1', 'rev-2'])), result)
1235
1467
        self.assertEqual(
1236
1468
            ['Branch.last_revision_info', 'Branch.get_tags_bytes'],
1237
1469
            [call.call.method for call in self.hpss_calls])
1238
1470
 
 
1471
    def test_backwards_compatible_no_tags(self):
 
1472
        br = self.make_branch_with_tags()
 
1473
        br.get_config_stack().set('branch.fetch_tags', False)
 
1474
        self.addCleanup(br.lock_read().unlock)
 
1475
        # Disable the heads_to_fetch verb
 
1476
        verb = 'Branch.heads_to_fetch'
 
1477
        self.disable_verb(verb)
 
1478
        self.reset_smart_call_log()
 
1479
        result = br.heads_to_fetch()
 
1480
        self.assertEqual((set(['tip']), set()), result)
 
1481
        self.assertEqual(
 
1482
            ['Branch.last_revision_info'],
 
1483
            [call.call.method for call in self.hpss_calls])
 
1484
 
1239
1485
 
1240
1486
class TestBranchLastRevisionInfo(RemoteBranchTestCase):
1241
1487
 
1401
1647
            'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1402
1648
            'success', ('ok',))
1403
1649
        branch = self.make_remote_branch(transport, client)
1404
 
        # This is a hack to work around the problem that RemoteBranch currently
1405
 
        # unnecessarily invokes _ensure_real upon a call to lock_write.
1406
 
        branch._ensure_real = lambda: None
1407
1650
        branch.lock_write()
1408
1651
        result = branch._set_last_revision(NULL_REVISION)
1409
1652
        branch.unlock()
1438
1681
            'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1439
1682
            'success', ('ok',))
1440
1683
        branch = self.make_remote_branch(transport, client)
1441
 
        # This is a hack to work around the problem that RemoteBranch currently
1442
 
        # unnecessarily invokes _ensure_real upon a call to lock_write.
1443
 
        branch._ensure_real = lambda: None
1444
1684
        # Lock the branch, reset the record of remote calls.
1445
1685
        branch.lock_write()
1446
1686
        result = branch._set_last_revision('rev-id2')
1513
1753
            'Branch.unlock', ('branch/', 'branch token', 'repo token'),
1514
1754
            'success', ('ok',))
1515
1755
        branch = self.make_remote_branch(transport, client)
1516
 
        branch._ensure_real = lambda: None
1517
1756
        branch.lock_write()
1518
1757
        # The 'TipChangeRejected' error response triggered by calling
1519
1758
        # set_last_revision_info causes a TipChangeRejected exception.
1782
2021
        self.addCleanup(branch.unlock)
1783
2022
        self.reset_smart_call_log()
1784
2023
        branch._get_config().set_option('value', 'name')
1785
 
        self.assertLength(10, self.hpss_calls)
 
2024
        self.assertLength(11, self.hpss_calls)
1786
2025
        self.assertEqual('value', branch._get_config().get_option('name'))
1787
2026
 
1788
2027
    def test_backwards_compat_set_option_with_dict(self):
1796
2035
        config = branch._get_config()
1797
2036
        value_dict = {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
1798
2037
        config.set_option(value_dict, 'name')
1799
 
        self.assertLength(10, self.hpss_calls)
 
2038
        self.assertLength(11, self.hpss_calls)
1800
2039
        self.assertEqual(value_dict, branch._get_config().get_option('name'))
1801
2040
 
1802
2041
 
 
2042
class TestBranchGetPutConfigStore(RemoteBranchTestCase):
 
2043
 
 
2044
    def test_get_branch_conf(self):
 
2045
        # in an empty branch we decode the response properly
 
2046
        client = FakeClient()
 
2047
        client.add_expected_call(
 
2048
            'Branch.get_stacked_on_url', ('memory:///',),
 
2049
            'error', ('NotStacked',),)
 
2050
        client.add_success_response_with_body('# config file body', 'ok')
 
2051
        transport = MemoryTransport()
 
2052
        branch = self.make_remote_branch(transport, client)
 
2053
        config = branch.get_config_stack()
 
2054
        config.get("email")
 
2055
        config.get("log_format")
 
2056
        self.assertEqual(
 
2057
            [('call', 'Branch.get_stacked_on_url', ('memory:///',)),
 
2058
             ('call_expecting_body', 'Branch.get_config_file', ('memory:///',))],
 
2059
            client._calls)
 
2060
 
 
2061
    def test_set_branch_conf(self):
 
2062
        client = FakeClient()
 
2063
        client.add_expected_call(
 
2064
            'Branch.get_stacked_on_url', ('memory:///',),
 
2065
            'error', ('NotStacked',),)
 
2066
        client.add_expected_call(
 
2067
            'Branch.lock_write', ('memory:///', '', ''),
 
2068
            'success', ('ok', 'branch token', 'repo token'))
 
2069
        client.add_expected_call(
 
2070
            'Branch.get_config_file', ('memory:///', ),
 
2071
            'success', ('ok', ), "# line 1\n")
 
2072
        client.add_expected_call(
 
2073
            'Branch.get_config_file', ('memory:///', ),
 
2074
            'success', ('ok', ), "# line 1\n")
 
2075
        client.add_expected_call(
 
2076
            'Branch.put_config_file', ('memory:///', 'branch token',
 
2077
            'repo token'),
 
2078
            'success', ('ok',))
 
2079
        client.add_expected_call(
 
2080
            'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
 
2081
            'success', ('ok',))
 
2082
        transport = MemoryTransport()
 
2083
        branch = self.make_remote_branch(transport, client)
 
2084
        branch.lock_write()
 
2085
        config = branch.get_config_stack()
 
2086
        config.set('email', 'The Dude <lebowski@example.com>')
 
2087
        branch.unlock()
 
2088
        self.assertFinished(client)
 
2089
        self.assertEqual(
 
2090
            [('call', 'Branch.get_stacked_on_url', ('memory:///',)),
 
2091
             ('call', 'Branch.lock_write', ('memory:///', '', '')),
 
2092
             ('call_expecting_body', 'Branch.get_config_file', ('memory:///',)),
 
2093
             ('call_expecting_body', 'Branch.get_config_file', ('memory:///',)),
 
2094
             ('call_with_body_bytes_expecting_body', 'Branch.put_config_file',
 
2095
                 ('memory:///', 'branch token', 'repo token'),
 
2096
                 '# line 1\nemail = The Dude <lebowski@example.com>\n'),
 
2097
             ('call', 'Branch.unlock', ('memory:///', 'branch token', 'repo token'))],
 
2098
            client._calls)
 
2099
 
 
2100
 
1803
2101
class TestBranchLockWrite(RemoteBranchTestCase):
1804
2102
 
1805
2103
    def test_lock_write_unlockable(self):
1818
2116
        self.assertFinished(client)
1819
2117
 
1820
2118
 
 
2119
class TestBranchRevisionIdToRevno(RemoteBranchTestCase):
 
2120
 
 
2121
    def test_simple(self):
 
2122
        transport = MemoryTransport()
 
2123
        client = FakeClient(transport.base)
 
2124
        client.add_expected_call(
 
2125
            'Branch.get_stacked_on_url', ('quack/',),
 
2126
            'error', ('NotStacked',),)
 
2127
        client.add_expected_call(
 
2128
            'Branch.revision_id_to_revno', ('quack/', 'null:'),
 
2129
            'success', ('ok', '0',),)
 
2130
        client.add_expected_call(
 
2131
            'Branch.revision_id_to_revno', ('quack/', 'unknown'),
 
2132
            'error', ('NoSuchRevision', 'unknown',),)
 
2133
        transport.mkdir('quack')
 
2134
        transport = transport.clone('quack')
 
2135
        branch = self.make_remote_branch(transport, client)
 
2136
        self.assertEquals(0, branch.revision_id_to_revno('null:'))
 
2137
        self.assertRaises(errors.NoSuchRevision,
 
2138
            branch.revision_id_to_revno, 'unknown')
 
2139
        self.assertFinished(client)
 
2140
 
 
2141
    def test_dotted(self):
 
2142
        transport = MemoryTransport()
 
2143
        client = FakeClient(transport.base)
 
2144
        client.add_expected_call(
 
2145
            'Branch.get_stacked_on_url', ('quack/',),
 
2146
            'error', ('NotStacked',),)
 
2147
        client.add_expected_call(
 
2148
            'Branch.revision_id_to_revno', ('quack/', 'null:'),
 
2149
            'success', ('ok', '0',),)
 
2150
        client.add_expected_call(
 
2151
            'Branch.revision_id_to_revno', ('quack/', 'unknown'),
 
2152
            'error', ('NoSuchRevision', 'unknown',),)
 
2153
        transport.mkdir('quack')
 
2154
        transport = transport.clone('quack')
 
2155
        branch = self.make_remote_branch(transport, client)
 
2156
        self.assertEquals((0, ), branch.revision_id_to_dotted_revno('null:'))
 
2157
        self.assertRaises(errors.NoSuchRevision,
 
2158
            branch.revision_id_to_dotted_revno, 'unknown')
 
2159
        self.assertFinished(client)
 
2160
 
 
2161
    def test_dotted_no_smart_verb(self):
 
2162
        self.setup_smart_server_with_call_log()
 
2163
        branch = self.make_branch('.')
 
2164
        self.disable_verb('Branch.revision_id_to_revno')
 
2165
        self.reset_smart_call_log()
 
2166
        self.assertEquals((0, ),
 
2167
            branch.revision_id_to_dotted_revno('null:'))
 
2168
        self.assertLength(8, self.hpss_calls)
 
2169
 
 
2170
 
1821
2171
class TestBzrDirGetSetConfig(RemoteBzrDirTestCase):
1822
2172
 
1823
2173
    def test__get_config(self):
1837
2187
        self.reset_smart_call_log()
1838
2188
        config = bzrdir.get_config()
1839
2189
        config.set_default_stack_on('/')
1840
 
        self.assertLength(3, self.hpss_calls)
 
2190
        self.assertLength(4, self.hpss_calls)
1841
2191
 
1842
2192
    def test_backwards_compat_get_option(self):
1843
2193
        self.setup_smart_server_with_call_log()
1847
2197
        self.reset_smart_call_log()
1848
2198
        self.assertEqual(None,
1849
2199
            bzrdir._get_config().get_option('default_stack_on'))
1850
 
        self.assertLength(3, self.hpss_calls)
 
2200
        self.assertLength(4, self.hpss_calls)
1851
2201
 
1852
2202
 
1853
2203
class TestTransportIsReadonly(tests.TestCase):
1980
2330
            remote_repo_format.get_format_description())
1981
2331
 
1982
2332
 
 
2333
class TestRepositoryAllRevisionIds(TestRemoteRepository):
 
2334
 
 
2335
    def test_empty(self):
 
2336
        transport_path = 'quack'
 
2337
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2338
        client.add_success_response_with_body('', 'ok')
 
2339
        self.assertEquals([], repo.all_revision_ids())
 
2340
        self.assertEqual(
 
2341
            [('call_expecting_body', 'Repository.all_revision_ids',
 
2342
             ('quack/',))],
 
2343
            client._calls)
 
2344
 
 
2345
    def test_with_some_content(self):
 
2346
        transport_path = 'quack'
 
2347
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2348
        client.add_success_response_with_body(
 
2349
            'rev1\nrev2\nanotherrev\n', 'ok')
 
2350
        self.assertEquals(["rev1", "rev2", "anotherrev"],
 
2351
            repo.all_revision_ids())
 
2352
        self.assertEqual(
 
2353
            [('call_expecting_body', 'Repository.all_revision_ids',
 
2354
             ('quack/',))],
 
2355
            client._calls)
 
2356
 
 
2357
 
1983
2358
class TestRepositoryGatherStats(TestRemoteRepository):
1984
2359
 
1985
2360
    def test_revid_none(self):
2038
2413
                         result)
2039
2414
 
2040
2415
 
 
2416
class TestRepositoryBreakLock(TestRemoteRepository):
 
2417
 
 
2418
    def test_break_lock(self):
 
2419
        transport_path = 'quack'
 
2420
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2421
        client.add_success_response('ok')
 
2422
        repo.break_lock()
 
2423
        self.assertEqual(
 
2424
            [('call', 'Repository.break_lock', ('quack/',))],
 
2425
            client._calls)
 
2426
 
 
2427
 
 
2428
class TestRepositoryGetSerializerFormat(TestRemoteRepository):
 
2429
 
 
2430
    def test_get_serializer_format(self):
 
2431
        transport_path = 'hill'
 
2432
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2433
        client.add_success_response('ok', '7')
 
2434
        self.assertEquals('7', repo.get_serializer_format())
 
2435
        self.assertEqual(
 
2436
            [('call', 'VersionedFileRepository.get_serializer_format',
 
2437
              ('hill/', ))],
 
2438
            client._calls)
 
2439
 
 
2440
 
 
2441
class TestRepositoryReconcile(TestRemoteRepository):
 
2442
 
 
2443
    def test_reconcile(self):
 
2444
        transport_path = 'hill'
 
2445
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2446
        body = ("garbage_inventories: 2\n"
 
2447
                "inconsistent_parents: 3\n")
 
2448
        client.add_expected_call(
 
2449
            'Repository.lock_write', ('hill/', ''),
 
2450
            'success', ('ok', 'a token'))
 
2451
        client.add_success_response_with_body(body, 'ok')
 
2452
        reconciler = repo.reconcile()
 
2453
        self.assertEqual(
 
2454
            [('call', 'Repository.lock_write', ('hill/', '')),
 
2455
             ('call_expecting_body', 'Repository.reconcile',
 
2456
                ('hill/', 'a token'))],
 
2457
            client._calls)
 
2458
        self.assertEquals(2, reconciler.garbage_inventories)
 
2459
        self.assertEquals(3, reconciler.inconsistent_parents)
 
2460
 
 
2461
 
 
2462
class TestRepositoryGetRevisionSignatureText(TestRemoteRepository):
 
2463
 
 
2464
    def test_text(self):
 
2465
        # ('ok',), body with signature text
 
2466
        transport_path = 'quack'
 
2467
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2468
        client.add_success_response_with_body(
 
2469
            'THETEXT', 'ok')
 
2470
        self.assertEquals("THETEXT", repo.get_signature_text("revid"))
 
2471
        self.assertEqual(
 
2472
            [('call_expecting_body', 'Repository.get_revision_signature_text',
 
2473
             ('quack/', 'revid'))],
 
2474
            client._calls)
 
2475
 
 
2476
    def test_no_signature(self):
 
2477
        transport_path = 'quick'
 
2478
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2479
        client.add_error_response('nosuchrevision', 'unknown')
 
2480
        self.assertRaises(errors.NoSuchRevision, repo.get_signature_text,
 
2481
                "unknown")
 
2482
        self.assertEqual(
 
2483
            [('call_expecting_body', 'Repository.get_revision_signature_text',
 
2484
              ('quick/', 'unknown'))],
 
2485
            client._calls)
 
2486
 
 
2487
 
2041
2488
class TestRepositoryGetGraph(TestRemoteRepository):
2042
2489
 
2043
2490
    def test_get_graph(self):
2048
2495
        self.assertNotEqual(graph._parents_provider, repo)
2049
2496
 
2050
2497
 
 
2498
class TestRepositoryAddSignatureText(TestRemoteRepository):
 
2499
 
 
2500
    def test_add_signature_text(self):
 
2501
        transport_path = 'quack'
 
2502
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2503
        client.add_expected_call(
 
2504
            'Repository.lock_write', ('quack/', ''),
 
2505
            'success', ('ok', 'a token'))
 
2506
        client.add_expected_call(
 
2507
            'Repository.start_write_group', ('quack/', 'a token'),
 
2508
            'success', ('ok', ('token1', )))
 
2509
        client.add_expected_call(
 
2510
            'Repository.add_signature_text', ('quack/', 'a token', 'rev1',
 
2511
                'token1'),
 
2512
            'success', ('ok', ), None)
 
2513
        repo.lock_write()
 
2514
        repo.start_write_group()
 
2515
        self.assertIs(None,
 
2516
            repo.add_signature_text("rev1", "every bloody emperor"))
 
2517
        self.assertEqual(
 
2518
            ('call_with_body_bytes_expecting_body',
 
2519
              'Repository.add_signature_text',
 
2520
                ('quack/', 'a token', 'rev1', 'token1'),
 
2521
              'every bloody emperor'),
 
2522
            client._calls[-1])
 
2523
 
 
2524
 
2051
2525
class TestRepositoryGetParentMap(TestRemoteRepository):
2052
2526
 
2053
2527
    def test_get_parent_map_caching(self):
2103
2577
        parents = repo.get_parent_map([rev_id])
2104
2578
        self.assertEqual(
2105
2579
            [('call_with_body_bytes_expecting_body',
2106
 
              'Repository.get_parent_map', ('quack/', 'include-missing:',
2107
 
              rev_id), '\n\n0'),
 
2580
              'Repository.get_parent_map',
 
2581
              ('quack/', 'include-missing:', rev_id), '\n\n0'),
2108
2582
             ('disconnect medium',),
2109
2583
             ('call_expecting_body', 'Repository.get_revision_graph',
2110
2584
              ('quack/', ''))],
2230
2704
        self.assertEqual({}, repo.get_parent_map(['non-existant']))
2231
2705
        self.assertLength(0, self.hpss_calls)
2232
2706
 
 
2707
    def test_exposes_get_cached_parent_map(self):
 
2708
        """RemoteRepository exposes get_cached_parent_map from
 
2709
        _unstacked_provider
 
2710
        """
 
2711
        r1 = u'\u0e33'.encode('utf8')
 
2712
        r2 = u'\u0dab'.encode('utf8')
 
2713
        lines = [' '.join([r2, r1]), r1]
 
2714
        encoded_body = bz2.compress('\n'.join(lines))
 
2715
 
 
2716
        transport_path = 'quack'
 
2717
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2718
        client.add_success_response_with_body(encoded_body, 'ok')
 
2719
        repo.lock_read()
 
2720
        # get_cached_parent_map should *not* trigger an RPC
 
2721
        self.assertEqual({}, repo.get_cached_parent_map([r1]))
 
2722
        self.assertEqual([], client._calls)
 
2723
        self.assertEqual({r2: (r1,)}, repo.get_parent_map([r2]))
 
2724
        self.assertEqual({r1: (NULL_REVISION,)},
 
2725
            repo.get_cached_parent_map([r1]))
 
2726
        self.assertEqual(
 
2727
            [('call_with_body_bytes_expecting_body',
 
2728
              'Repository.get_parent_map', ('quack/', 'include-missing:', r2),
 
2729
              '\n\n0')],
 
2730
            client._calls)
 
2731
        repo.unlock()
 
2732
 
2233
2733
 
2234
2734
class TestGetParentMapAllowsNew(tests.TestCaseWithTransport):
2235
2735
 
2250
2750
        self.assertEqual({'rev1': ('null:',)}, graph.get_parent_map(['rev1']))
2251
2751
 
2252
2752
 
 
2753
class TestRepositoryGetRevisions(TestRemoteRepository):
 
2754
 
 
2755
    def test_hpss_missing_revision(self):
 
2756
        transport_path = 'quack'
 
2757
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2758
        client.add_success_response_with_body(
 
2759
            '', 'ok', '10')
 
2760
        self.assertRaises(errors.NoSuchRevision, repo.get_revisions,
 
2761
            ['somerev1', 'anotherrev2'])
 
2762
        self.assertEqual(
 
2763
            [('call_with_body_bytes_expecting_body', 'Repository.iter_revisions',
 
2764
             ('quack/', ), "somerev1\nanotherrev2")],
 
2765
            client._calls)
 
2766
 
 
2767
    def test_hpss_get_single_revision(self):
 
2768
        transport_path = 'quack'
 
2769
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2770
        somerev1 = Revision("somerev1")
 
2771
        somerev1.committer = "Joe Committer <joe@example.com>"
 
2772
        somerev1.timestamp = 1321828927
 
2773
        somerev1.timezone = -60
 
2774
        somerev1.inventory_sha1 = "691b39be74c67b1212a75fcb19c433aaed903c2b"
 
2775
        somerev1.message = "Message"
 
2776
        body = zlib.compress(chk_bencode_serializer.write_revision_to_string(
 
2777
            somerev1))
 
2778
        # Split up body into two bits to make sure the zlib compression object
 
2779
        # gets data fed twice.
 
2780
        client.add_success_response_with_body(
 
2781
                [body[:10], body[10:]], 'ok', '10')
 
2782
        revs = repo.get_revisions(['somerev1'])
 
2783
        self.assertEquals(revs, [somerev1])
 
2784
        self.assertEqual(
 
2785
            [('call_with_body_bytes_expecting_body', 'Repository.iter_revisions',
 
2786
             ('quack/', ), "somerev1")],
 
2787
            client._calls)
 
2788
 
 
2789
 
2253
2790
class TestRepositoryGetRevisionGraph(TestRemoteRepository):
2254
2791
 
2255
2792
    def test_null_revision(self):
2406
2943
                              call.call.method == verb])
2407
2944
 
2408
2945
 
 
2946
class TestRepositoryHasSignatureForRevisionId(TestRemoteRepository):
 
2947
 
 
2948
    def test_has_signature_for_revision_id(self):
 
2949
        # ('yes', ) for Repository.has_signature_for_revision_id -> 'True'.
 
2950
        transport_path = 'quack'
 
2951
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2952
        client.add_success_response('yes')
 
2953
        result = repo.has_signature_for_revision_id('A')
 
2954
        self.assertEqual(
 
2955
            [('call', 'Repository.has_signature_for_revision_id',
 
2956
              ('quack/', 'A'))],
 
2957
            client._calls)
 
2958
        self.assertEqual(True, result)
 
2959
 
 
2960
    def test_is_not_shared(self):
 
2961
        # ('no', ) for Repository.has_signature_for_revision_id -> 'False'.
 
2962
        transport_path = 'qwack'
 
2963
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2964
        client.add_success_response('no')
 
2965
        result = repo.has_signature_for_revision_id('A')
 
2966
        self.assertEqual(
 
2967
            [('call', 'Repository.has_signature_for_revision_id',
 
2968
              ('qwack/', 'A'))],
 
2969
            client._calls)
 
2970
        self.assertEqual(False, result)
 
2971
 
 
2972
 
 
2973
class TestRepositoryPhysicalLockStatus(TestRemoteRepository):
 
2974
 
 
2975
    def test_get_physical_lock_status_yes(self):
 
2976
        transport_path = 'qwack'
 
2977
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2978
        client.add_success_response('yes')
 
2979
        result = repo.get_physical_lock_status()
 
2980
        self.assertEqual(
 
2981
            [('call', 'Repository.get_physical_lock_status',
 
2982
              ('qwack/', ))],
 
2983
            client._calls)
 
2984
        self.assertEqual(True, result)
 
2985
 
 
2986
    def test_get_physical_lock_status_no(self):
 
2987
        transport_path = 'qwack'
 
2988
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
2989
        client.add_success_response('no')
 
2990
        result = repo.get_physical_lock_status()
 
2991
        self.assertEqual(
 
2992
            [('call', 'Repository.get_physical_lock_status',
 
2993
              ('qwack/', ))],
 
2994
            client._calls)
 
2995
        self.assertEqual(False, result)
 
2996
 
 
2997
 
2409
2998
class TestRepositoryIsShared(TestRemoteRepository):
2410
2999
 
2411
3000
    def test_is_shared(self):
2431
3020
        self.assertEqual(False, result)
2432
3021
 
2433
3022
 
 
3023
class TestRepositoryMakeWorkingTrees(TestRemoteRepository):
 
3024
 
 
3025
    def test_make_working_trees(self):
 
3026
        # ('yes', ) for Repository.make_working_trees -> 'True'.
 
3027
        transport_path = 'quack'
 
3028
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3029
        client.add_success_response('yes')
 
3030
        result = repo.make_working_trees()
 
3031
        self.assertEqual(
 
3032
            [('call', 'Repository.make_working_trees', ('quack/',))],
 
3033
            client._calls)
 
3034
        self.assertEqual(True, result)
 
3035
 
 
3036
    def test_no_working_trees(self):
 
3037
        # ('no', ) for Repository.make_working_trees -> 'False'.
 
3038
        transport_path = 'qwack'
 
3039
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3040
        client.add_success_response('no')
 
3041
        result = repo.make_working_trees()
 
3042
        self.assertEqual(
 
3043
            [('call', 'Repository.make_working_trees', ('qwack/',))],
 
3044
            client._calls)
 
3045
        self.assertEqual(False, result)
 
3046
 
 
3047
 
2434
3048
class TestRepositoryLockWrite(TestRemoteRepository):
2435
3049
 
2436
3050
    def test_lock_write(self):
2462
3076
            client._calls)
2463
3077
 
2464
3078
 
 
3079
class TestRepositoryWriteGroups(TestRemoteRepository):
 
3080
 
 
3081
    def test_start_write_group(self):
 
3082
        transport_path = 'quack'
 
3083
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3084
        client.add_expected_call(
 
3085
            'Repository.lock_write', ('quack/', ''),
 
3086
            'success', ('ok', 'a token'))
 
3087
        client.add_expected_call(
 
3088
            'Repository.start_write_group', ('quack/', 'a token'),
 
3089
            'success', ('ok', ('token1', )))
 
3090
        repo.lock_write()
 
3091
        repo.start_write_group()
 
3092
 
 
3093
    def test_start_write_group_unsuspendable(self):
 
3094
        # Some repositories do not support suspending write
 
3095
        # groups. For those, fall back to the "real" repository.
 
3096
        transport_path = 'quack'
 
3097
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3098
        def stub_ensure_real():
 
3099
            client._calls.append(('_ensure_real',))
 
3100
            repo._real_repository = _StubRealPackRepository(client._calls)
 
3101
        repo._ensure_real = stub_ensure_real
 
3102
        client.add_expected_call(
 
3103
            'Repository.lock_write', ('quack/', ''),
 
3104
            'success', ('ok', 'a token'))
 
3105
        client.add_expected_call(
 
3106
            'Repository.start_write_group', ('quack/', 'a token'),
 
3107
            'error', ('UnsuspendableWriteGroup',))
 
3108
        repo.lock_write()
 
3109
        repo.start_write_group()
 
3110
        self.assertEquals(client._calls[-2:], [ 
 
3111
            ('_ensure_real',),
 
3112
            ('start_write_group',)])
 
3113
 
 
3114
    def test_commit_write_group(self):
 
3115
        transport_path = 'quack'
 
3116
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3117
        client.add_expected_call(
 
3118
            'Repository.lock_write', ('quack/', ''),
 
3119
            'success', ('ok', 'a token'))
 
3120
        client.add_expected_call(
 
3121
            'Repository.start_write_group', ('quack/', 'a token'),
 
3122
            'success', ('ok', ['token1']))
 
3123
        client.add_expected_call(
 
3124
            'Repository.commit_write_group', ('quack/', 'a token', ['token1']),
 
3125
            'success', ('ok',))
 
3126
        repo.lock_write()
 
3127
        repo.start_write_group()
 
3128
        repo.commit_write_group()
 
3129
 
 
3130
    def test_abort_write_group(self):
 
3131
        transport_path = 'quack'
 
3132
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3133
        client.add_expected_call(
 
3134
            'Repository.lock_write', ('quack/', ''),
 
3135
            'success', ('ok', 'a token'))
 
3136
        client.add_expected_call(
 
3137
            'Repository.start_write_group', ('quack/', 'a token'),
 
3138
            'success', ('ok', ['token1']))
 
3139
        client.add_expected_call(
 
3140
            'Repository.abort_write_group', ('quack/', 'a token', ['token1']),
 
3141
            'success', ('ok',))
 
3142
        repo.lock_write()
 
3143
        repo.start_write_group()
 
3144
        repo.abort_write_group(False)
 
3145
 
 
3146
    def test_suspend_write_group(self):
 
3147
        transport_path = 'quack'
 
3148
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3149
        self.assertEquals([], repo.suspend_write_group())
 
3150
 
 
3151
    def test_resume_write_group(self):
 
3152
        transport_path = 'quack'
 
3153
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3154
        client.add_expected_call(
 
3155
            'Repository.lock_write', ('quack/', ''),
 
3156
            'success', ('ok', 'a token'))
 
3157
        client.add_expected_call(
 
3158
            'Repository.check_write_group', ('quack/', 'a token', ['token1']),
 
3159
            'success', ('ok',))
 
3160
        repo.lock_write()
 
3161
        repo.resume_write_group(['token1'])
 
3162
 
 
3163
 
2465
3164
class TestRepositorySetMakeWorkingTrees(TestRemoteRepository):
2466
3165
 
2467
3166
    def test_backwards_compat(self):
2526
3225
        self.assertEqual([], client._calls)
2527
3226
 
2528
3227
 
 
3228
class TestRepositoryIterFilesBytes(TestRemoteRepository):
 
3229
    """Test Repository.iter_file_bytes."""
 
3230
 
 
3231
    def test_single(self):
 
3232
        transport_path = 'quack'
 
3233
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3234
        client.add_expected_call(
 
3235
            'Repository.iter_files_bytes', ('quack/', ),
 
3236
            'success', ('ok',), iter(["ok\x000", "\n", zlib.compress("mydata" * 10)]))
 
3237
        for (identifier, byte_stream) in repo.iter_files_bytes([("somefile",
 
3238
                "somerev", "myid")]):
 
3239
            self.assertEquals("myid", identifier)
 
3240
            self.assertEquals("".join(byte_stream), "mydata" * 10)
 
3241
 
 
3242
    def test_missing(self):
 
3243
        transport_path = 'quack'
 
3244
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
3245
        client.add_expected_call(
 
3246
            'Repository.iter_files_bytes',
 
3247
                ('quack/', ),
 
3248
            'error', ('RevisionNotPresent', 'somefile', 'somerev'),
 
3249
            iter(["absent\0somefile\0somerev\n"]))
 
3250
        self.assertRaises(errors.RevisionNotPresent, list,
 
3251
                repo.iter_files_bytes(
 
3252
                [("somefile", "somerev", "myid")]))
 
3253
 
 
3254
 
2529
3255
class TestRepositoryInsertStreamBase(TestRemoteRepository):
2530
3256
    """Base class for Repository.insert_stream and .insert_stream_1.19
2531
3257
    tests.
2806
3532
        self.calls = calls
2807
3533
        self._pack_collection = _StubPackCollection(calls)
2808
3534
 
 
3535
    def start_write_group(self):
 
3536
        self.calls.append(('start_write_group',))
 
3537
 
2809
3538
    def is_in_write_group(self):
2810
3539
        return False
2811
3540
 
3244
3973
        _, stacked = branch_factory()
3245
3974
        source = stacked.repository._get_source(target_repository_format)
3246
3975
        tip = stacked.last_revision()
3247
 
        revs = stacked.repository.get_ancestry(tip)
3248
 
        search = graph.PendingAncestryResult([tip], stacked.repository)
 
3976
        stacked.repository._ensure_real()
 
3977
        graph = stacked.repository.get_graph()
 
3978
        revs = [r for (r,ps) in graph.iter_ancestry([tip])
 
3979
                if r != NULL_REVISION]
 
3980
        revs.reverse()
 
3981
        search = vf_search.PendingAncestryResult([tip], stacked.repository)
3249
3982
        self.reset_smart_call_log()
3250
3983
        stream = source.get_stream(search)
3251
 
        if None in revs:
3252
 
            revs.remove(None)
3253
3984
        # We trust that if a revision is in the stream the rest of the new
3254
3985
        # content for it is too, as per our main fetch tests; here we are
3255
3986
        # checking that the revisions are actually included at all, and their
3294
4025
        self.assertEqual(expected_revs, rev_ord)
3295
4026
        # Getting topological sort requires VFS calls still - one of which is
3296
4027
        # pushing up from the bound branch.
3297
 
        self.assertLength(13, self.hpss_calls)
 
4028
        self.assertLength(14, self.hpss_calls)
3298
4029
 
3299
4030
    def test_stacked_get_stream_groupcompress(self):
3300
4031
        # Repository._get_source.get_stream() from a stacked repository with
3357
4088
        remote_branch_url = self.smart_server.get_url() + 'remote'
3358
4089
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3359
4090
        self.hpss_calls = []
3360
 
        local.repository.fetch(remote_branch.repository,
3361
 
                fetch_spec=graph.EverythingResult(remote_branch.repository))
 
4091
        local.repository.fetch(
 
4092
            remote_branch.repository,
 
4093
            fetch_spec=vf_search.EverythingResult(remote_branch.repository))
3362
4094
        self.assertEqual(['Repository.get_stream_1.19'], self.hpss_calls)
3363
4095
 
3364
4096
    def override_verb(self, verb_name, verb):
3365
4097
        request_handlers = request.request_handlers
3366
4098
        orig_verb = request_handlers.get(verb_name)
 
4099
        orig_info = request_handlers.get_info(verb_name)
3367
4100
        request_handlers.register(verb_name, verb, override_existing=True)
3368
4101
        self.addCleanup(request_handlers.register, verb_name, orig_verb,
3369
 
                override_existing=True)
 
4102
                override_existing=True, info=orig_info)
3370
4103
 
3371
4104
    def test_fetch_everything_backwards_compat(self):
3372
4105
        """Can fetch with EverythingResult even with pre 2.4 servers.
3379
4112
            """A version of the Repository.get_stream_1.19 verb patched to
3380
4113
            reject 'everything' searches the way 2.3 and earlier do.
3381
4114
            """
3382
 
            def recreate_search(self, repository, search_bytes, discard_excess=False):
 
4115
            def recreate_search(self, repository, search_bytes,
 
4116
                                discard_excess=False):
3383
4117
                verb_log.append(search_bytes.split('\n', 1)[0])
3384
4118
                if search_bytes == 'everything':
3385
 
                    return (None, request.FailedSmartServerResponse(('BadSearch',)))
 
4119
                    return (None,
 
4120
                            request.FailedSmartServerResponse(('BadSearch',)))
3386
4121
                return super(OldGetStreamVerb,
3387
4122
                        self).recreate_search(repository, search_bytes,
3388
4123
                            discard_excess=discard_excess)
3393
4128
        remote_branch_url = self.smart_server.get_url() + 'remote'
3394
4129
        remote_branch = bzrdir.BzrDir.open(remote_branch_url).open_branch()
3395
4130
        self.hpss_calls = []
3396
 
        local.repository.fetch(remote_branch.repository,
3397
 
                fetch_spec=graph.EverythingResult(remote_branch.repository))
 
4131
        local.repository.fetch(
 
4132
            remote_branch.repository,
 
4133
            fetch_spec=vf_search.EverythingResult(remote_branch.repository))
3398
4134
        # make sure the overridden verb was used
3399
4135
        self.assertLength(1, verb_log)
3400
4136
        # more than one HPSS call is needed, but because it's a VFS callback
3401
4137
        # its hard to predict exactly how many.
3402
4138
        self.assertTrue(len(self.hpss_calls) > 1)
3403
4139
 
 
4140
 
 
4141
class TestUpdateBoundBranchWithModifiedBoundLocation(
 
4142
    tests.TestCaseWithTransport):
 
4143
    """Ensure correct handling of bound_location modifications.
 
4144
 
 
4145
    This is tested against a smart server as http://pad.lv/786980 was about a
 
4146
    ReadOnlyError (write attempt during a read-only transaction) which can only
 
4147
    happen in this context.
 
4148
    """
 
4149
 
 
4150
    def setUp(self):
 
4151
        super(TestUpdateBoundBranchWithModifiedBoundLocation, self).setUp()
 
4152
        self.transport_server = test_server.SmartTCPServer_for_testing
 
4153
 
 
4154
    def make_master_and_checkout(self, master_name, checkout_name):
 
4155
        # Create the master branch and its associated checkout
 
4156
        self.master = self.make_branch_and_tree(master_name)
 
4157
        self.checkout = self.master.branch.create_checkout(checkout_name)
 
4158
        # Modify the master branch so there is something to update
 
4159
        self.master.commit('add stuff')
 
4160
        self.last_revid = self.master.commit('even more stuff')
 
4161
        self.bound_location = self.checkout.branch.get_bound_location()
 
4162
 
 
4163
    def assertUpdateSucceeds(self, new_location):
 
4164
        self.checkout.branch.set_bound_location(new_location)
 
4165
        self.checkout.update()
 
4166
        self.assertEquals(self.last_revid, self.checkout.last_revision())
 
4167
 
 
4168
    def test_without_final_slash(self):
 
4169
        self.make_master_and_checkout('master', 'checkout')
 
4170
        # For unclear reasons some users have a bound_location without a final
 
4171
        # '/', simulate that by forcing such a value
 
4172
        self.assertEndsWith(self.bound_location, '/')
 
4173
        self.assertUpdateSucceeds(self.bound_location.rstrip('/'))
 
4174
 
 
4175
    def test_plus_sign(self):
 
4176
        self.make_master_and_checkout('+master', 'checkout')
 
4177
        self.assertUpdateSucceeds(self.bound_location.replace('%2B', '+', 1))
 
4178
 
 
4179
    def test_tilda(self):
 
4180
        # Embed ~ in the middle of the path just to avoid any $HOME
 
4181
        # interpretation
 
4182
        self.make_master_and_checkout('mas~ter', 'checkout')
 
4183
        self.assertUpdateSucceeds(self.bound_location.replace('%2E', '~', 1))
 
4184
 
 
4185
 
 
4186
class TestWithCustomErrorHandler(RemoteBranchTestCase):
 
4187
 
 
4188
    def test_no_context(self):
 
4189
        class OutOfCoffee(errors.BzrError):
 
4190
            """A dummy exception for testing."""
 
4191
 
 
4192
            def __init__(self, urgency):
 
4193
                self.urgency = urgency
 
4194
        remote.no_context_error_translators.register("OutOfCoffee",
 
4195
            lambda err: OutOfCoffee(err.error_args[0]))
 
4196
        transport = MemoryTransport()
 
4197
        client = FakeClient(transport.base)
 
4198
        client.add_expected_call(
 
4199
            'Branch.get_stacked_on_url', ('quack/',),
 
4200
            'error', ('NotStacked',))
 
4201
        client.add_expected_call(
 
4202
            'Branch.last_revision_info',
 
4203
            ('quack/',),
 
4204
            'error', ('OutOfCoffee', 'low'))
 
4205
        transport.mkdir('quack')
 
4206
        transport = transport.clone('quack')
 
4207
        branch = self.make_remote_branch(transport, client)
 
4208
        self.assertRaises(OutOfCoffee, branch.last_revision_info)
 
4209
        self.assertFinished(client)
 
4210
 
 
4211
    def test_with_context(self):
 
4212
        class OutOfTea(errors.BzrError):
 
4213
            def __init__(self, branch, urgency):
 
4214
                self.branch = branch
 
4215
                self.urgency = urgency
 
4216
        remote.error_translators.register("OutOfTea",
 
4217
            lambda err, find, path: OutOfTea(err.error_args[0],
 
4218
                find("branch")))
 
4219
        transport = MemoryTransport()
 
4220
        client = FakeClient(transport.base)
 
4221
        client.add_expected_call(
 
4222
            'Branch.get_stacked_on_url', ('quack/',),
 
4223
            'error', ('NotStacked',))
 
4224
        client.add_expected_call(
 
4225
            'Branch.last_revision_info',
 
4226
            ('quack/',),
 
4227
            'error', ('OutOfTea', 'low'))
 
4228
        transport.mkdir('quack')
 
4229
        transport = transport.clone('quack')
 
4230
        branch = self.make_remote_branch(transport, client)
 
4231
        self.assertRaises(OutOfTea, branch.last_revision_info)
 
4232
        self.assertFinished(client)
 
4233
 
 
4234
 
 
4235
class TestRepositoryPack(TestRemoteRepository):
 
4236
 
 
4237
    def test_pack(self):
 
4238
        transport_path = 'quack'
 
4239
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
4240
        client.add_expected_call(
 
4241
            'Repository.lock_write', ('quack/', ''),
 
4242
            'success', ('ok', 'token'))
 
4243
        client.add_expected_call(
 
4244
            'Repository.pack', ('quack/', 'token', 'False'),
 
4245
            'success', ('ok',), )
 
4246
        client.add_expected_call(
 
4247
            'Repository.unlock', ('quack/', 'token'),
 
4248
            'success', ('ok', ))
 
4249
        repo.pack()
 
4250
 
 
4251
    def test_pack_with_hint(self):
 
4252
        transport_path = 'quack'
 
4253
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
4254
        client.add_expected_call(
 
4255
            'Repository.lock_write', ('quack/', ''),
 
4256
            'success', ('ok', 'token'))
 
4257
        client.add_expected_call(
 
4258
            'Repository.pack', ('quack/', 'token', 'False'),
 
4259
            'success', ('ok',), )
 
4260
        client.add_expected_call(
 
4261
            'Repository.unlock', ('quack/', 'token', 'False'),
 
4262
            'success', ('ok', ))
 
4263
        repo.pack(['hinta', 'hintb'])
 
4264
 
 
4265
 
 
4266
class TestRepositoryIterInventories(TestRemoteRepository):
 
4267
    """Test Repository.iter_inventories."""
 
4268
 
 
4269
    def _serialize_inv_delta(self, old_name, new_name, delta):
 
4270
        serializer = inventory_delta.InventoryDeltaSerializer(True, False)
 
4271
        return "".join(serializer.delta_to_lines(old_name, new_name, delta))
 
4272
 
 
4273
    def test_single_empty(self):
 
4274
        transport_path = 'quack'
 
4275
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
4276
        fmt = bzrdir.format_registry.get('2a')().repository_format
 
4277
        repo._format = fmt
 
4278
        stream = [('inventory-deltas', [
 
4279
            versionedfile.FulltextContentFactory('somerevid', None, None,
 
4280
                self._serialize_inv_delta('null:', 'somerevid', []))])]
 
4281
        client.add_expected_call(
 
4282
            'VersionedFileRepository.get_inventories', ('quack/', 'unordered'),
 
4283
            'success', ('ok', ),
 
4284
            _stream_to_byte_stream(stream, fmt))
 
4285
        ret = list(repo.iter_inventories(["somerevid"]))
 
4286
        self.assertLength(1, ret)
 
4287
        inv = ret[0]
 
4288
        self.assertEquals("somerevid", inv.revision_id)
 
4289
 
 
4290
    def test_empty(self):
 
4291
        transport_path = 'quack'
 
4292
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
4293
        ret = list(repo.iter_inventories([]))
 
4294
        self.assertEquals(ret, [])
 
4295
 
 
4296
    def test_missing(self):
 
4297
        transport_path = 'quack'
 
4298
        repo, client = self.setup_fake_client_and_repository(transport_path)
 
4299
        client.add_expected_call(
 
4300
            'VersionedFileRepository.get_inventories', ('quack/', 'unordered'),
 
4301
            'success', ('ok', ), iter([]))
 
4302
        self.assertRaises(errors.NoSuchRevision, list, repo.iter_inventories(
 
4303
            ["somerevid"]))