/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_remote.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
1
 
# Copyright (C) 2006-2013, 2016 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
23
23
These tests correspond to tests.test_smart, which exercises the server side.
24
24
"""
25
25
 
26
 
import base64
27
26
import bz2
 
27
from cStringIO import StringIO
28
28
import zlib
29
29
 
30
 
from .. import (
 
30
from bzrlib import (
31
31
    bencode,
32
32
    branch,
 
33
    bzrdir,
33
34
    config,
34
35
    controldir,
35
36
    errors,
 
37
    inventory,
 
38
    inventory_delta,
 
39
    remote,
36
40
    repository,
37
41
    tests,
38
42
    transport,
39
43
    treebuilder,
40
 
    )
41
 
from ..branch import Branch
42
 
from ..bzr import (
43
 
    bzrdir,
44
 
    inventory,
45
 
    inventory_delta,
46
 
    remote,
47
44
    versionedfile,
48
45
    vf_search,
49
46
    )
50
 
from ..bzr.bzrdir import (
 
47
from bzrlib.branch import Branch
 
48
from bzrlib.bzrdir import (
51
49
    BzrDir,
52
50
    BzrDirFormat,
53
 
    )
54
 
from ..bzr import (
55
51
    RemoteBzrProber,
56
52
    )
57
 
from ..bzr.chk_serializer import chk_bencode_serializer
58
 
from ..bzr.remote import (
 
53
from bzrlib.chk_serializer import chk_bencode_serializer
 
54
from bzrlib.remote import (
59
55
    RemoteBranch,
60
56
    RemoteBranchFormat,
61
57
    RemoteBzrDir,
63
59
    RemoteRepository,
64
60
    RemoteRepositoryFormat,
65
61
    )
66
 
from ..bzr import groupcompress_repo, knitpack_repo
67
 
from ..revision import (
 
62
from bzrlib.repofmt import groupcompress_repo, knitpack_repo
 
63
from bzrlib.revision import (
68
64
    NULL_REVISION,
69
65
    Revision,
70
66
    )
71
 
from ..sixish import (
72
 
    BytesIO,
73
 
    )
74
 
from ..bzr.smart import medium, request
75
 
from ..bzr.smart.client import _SmartClient
76
 
from ..bzr.smart.repository import (
 
67
from bzrlib.smart import medium, request
 
68
from bzrlib.smart.client import _SmartClient
 
69
from bzrlib.smart.repository import (
77
70
    SmartServerRepositoryGetParentMap,
78
71
    SmartServerRepositoryGetStream_1_19,
79
72
    _stream_to_byte_stream,
80
73
    )
81
 
from . import (
 
74
from bzrlib.symbol_versioning import deprecated_in
 
75
from bzrlib.tests import (
82
76
    test_server,
83
77
    )
84
 
from .scenarios import load_tests_apply_scenarios
85
 
from ..transport.memory import MemoryTransport
86
 
from ..transport.remote import (
 
78
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
79
from bzrlib.transport.memory import MemoryTransport
 
80
from bzrlib.transport.remote import (
87
81
    RemoteTransport,
88
82
    RemoteSSHTransport,
89
83
    RemoteTCPTransport,
130
124
    def test_find_correct_format(self):
131
125
        """Should open a RemoteBzrDir over a RemoteTransport"""
132
126
        fmt = BzrDirFormat.find_format(self.transport)
133
 
        self.assertTrue(RemoteBzrProber
 
127
        self.assertTrue(bzrdir.RemoteBzrProber
134
128
                        in controldir.ControlDirFormat._server_probers)
135
129
        self.assertIsInstance(fmt, RemoteBzrDirFormat)
136
130
 
158
152
 
159
153
    def test_remote_repo_format_supports_external_references(self):
160
154
        t = self.transport
161
 
        bd = self.make_controldir('unstackable', format='pack-0.92')
 
155
        bd = self.make_bzrdir('unstackable', format='pack-0.92')
162
156
        r = bd.create_repository()
163
157
        self.assertFalse(r._format.supports_external_lookups)
164
158
        r = BzrDir.open_from_transport(t.clone('unstackable')).open_repository()
165
159
        self.assertFalse(r._format.supports_external_lookups)
166
 
        bd = self.make_controldir('stackable', format='1.9')
 
160
        bd = self.make_bzrdir('stackable', format='1.9')
167
161
        r = bd.create_repository()
168
162
        self.assertTrue(r._format.supports_external_lookups)
169
163
        r = BzrDir.open_from_transport(t.clone('stackable')).open_repository()
197
191
 
198
192
    def read_body_bytes(self, count=-1):
199
193
        if self._body_buffer is None:
200
 
            self._body_buffer = BytesIO(self.body)
 
194
            self._body_buffer = StringIO(self.body)
201
195
        bytes = self._body_buffer.read(count)
202
196
        if self._body_buffer.tell() == len(self._body_buffer.getvalue()):
203
197
            self._fake_client.expecting_body = False
254
248
    def _get_next_response(self):
255
249
        try:
256
250
            response_tuple = self.responses.pop(0)
257
 
        except IndexError as e:
 
251
        except IndexError, e:
258
252
            raise AssertionError("%r didn't expect any more calls"
259
253
                % (self,))
260
254
        if response_tuple[0] == 'unknown':
438
432
 
439
433
    def test_backwards_compat(self):
440
434
        self.setup_smart_server_with_call_log()
441
 
        a_dir = self.make_controldir('.')
 
435
        a_dir = self.make_bzrdir('.')
442
436
        self.reset_smart_call_log()
443
437
        verb = 'BzrDir.cloning_metadir'
444
438
        self.disable_verb(verb)
450
444
    def test_branch_reference(self):
451
445
        transport = self.get_transport('quack')
452
446
        referenced = self.make_branch('referenced')
453
 
        expected = referenced.controldir.cloning_metadir()
 
447
        expected = referenced.bzrdir.cloning_metadir()
454
448
        client = FakeClient(transport.base)
455
449
        client.add_expected_call(
456
450
            'BzrDir.cloning_metadir', ('quack/', 'False'),
458
452
        client.add_expected_call(
459
453
            'BzrDir.open_branchV3', ('quack/',),
460
454
            'success', ('ref', self.get_url('referenced'))),
461
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
455
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
462
456
            _client=client)
463
 
        result = a_controldir.cloning_metadir()
 
457
        result = a_bzrdir.cloning_metadir()
464
458
        # We should have got a control dir matching the referenced branch.
465
459
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
466
460
        self.assertEqual(expected._repository_format, result._repository_format)
470
464
    def test_current_server(self):
471
465
        transport = self.get_transport('.')
472
466
        transport = transport.clone('quack')
473
 
        self.make_controldir('quack')
 
467
        self.make_bzrdir('quack')
474
468
        client = FakeClient(transport.base)
475
469
        reference_bzrdir_format = controldir.format_registry.get('default')()
476
470
        control_name = reference_bzrdir_format.network_name()
477
471
        client.add_expected_call(
478
472
            'BzrDir.cloning_metadir', ('quack/', 'False'),
479
473
            'success', (control_name, '', ('branch', ''))),
480
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
474
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
481
475
            _client=client)
482
 
        result = a_controldir.cloning_metadir()
 
476
        result = a_bzrdir.cloning_metadir()
483
477
        # We should have got a reference control dir with default branch and
484
478
        # repository formats.
485
479
        # This pokes a little, just to be sure.
491
485
    def test_unknown(self):
492
486
        transport = self.get_transport('quack')
493
487
        referenced = self.make_branch('referenced')
494
 
        expected = referenced.controldir.cloning_metadir()
 
488
        expected = referenced.bzrdir.cloning_metadir()
495
489
        client = FakeClient(transport.base)
496
490
        client.add_expected_call(
497
491
            'BzrDir.cloning_metadir', ('quack/', 'False'),
498
492
            'success', ('unknown', 'unknown', ('branch', ''))),
499
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
493
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
500
494
            _client=client)
501
 
        self.assertRaises(errors.UnknownFormatError, a_controldir.cloning_metadir)
 
495
        self.assertRaises(errors.UnknownFormatError, a_bzrdir.cloning_metadir)
502
496
 
503
497
 
504
498
class TestBzrDirCheckoutMetaDir(TestRemote):
513
507
            'success', (control_name, '', ''))
514
508
        transport.mkdir('quack')
515
509
        transport = transport.clone('quack')
516
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
510
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
517
511
            _client=client)
518
 
        result = a_controldir.checkout_metadir()
 
512
        result = a_bzrdir.checkout_metadir()
519
513
        # We should have got a reference control dir with default branch and
520
514
        # repository formats.
521
515
        self.assertEqual(bzrdir.BzrDirMetaFormat1, type(result))
531
525
            'success', ('dontknow', '', ''))
532
526
        transport.mkdir('quack')
533
527
        transport = transport.clone('quack')
534
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
528
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
535
529
            _client=client)
536
530
        self.assertRaises(errors.UnknownFormatError,
537
 
            a_controldir.checkout_metadir)
 
531
            a_bzrdir.checkout_metadir)
538
532
        self.assertFinished(client)
539
533
 
540
534
 
559
553
        client.add_error_response('NotStacked')
560
554
        transport.mkdir('quack')
561
555
        transport = transport.clone('quack')
562
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
556
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
563
557
            _client=client)
564
 
        result = a_controldir.get_branches()
565
 
        self.assertEqual({"", "foo"}, set(result.keys()))
 
558
        result = a_bzrdir.get_branches()
 
559
        self.assertEquals(set(["", "foo"]), set(result.keys()))
566
560
        self.assertEqual(
567
561
            [('call_expecting_body', 'BzrDir.get_branches', ('quack/',)),
568
562
             ('call', 'BzrDir.find_repositoryV3', ('quack/', )),
581
575
        client.add_expected_call(
582
576
            'BzrDir.destroy_branch', ('quack/', ),
583
577
            'success', ('ok',)),
584
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
578
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
585
579
            _client=client)
586
 
        a_controldir.destroy_branch()
 
580
        a_bzrdir.destroy_branch()
587
581
        self.assertFinished(client)
588
582
 
589
583
 
595
589
        client.add_expected_call(
596
590
            'BzrDir.has_workingtree', ('quack/',),
597
591
            'success', ('yes',)),
598
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
592
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
599
593
            _client=client)
600
 
        self.assertTrue(a_controldir.has_workingtree())
 
594
        self.assertTrue(a_bzrdir.has_workingtree())
601
595
        self.assertFinished(client)
602
596
 
603
597
    def test_no_workingtree(self):
606
600
        client.add_expected_call(
607
601
            'BzrDir.has_workingtree', ('quack/',),
608
602
            'success', ('no',)),
609
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
603
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
610
604
            _client=client)
611
 
        self.assertFalse(a_controldir.has_workingtree())
 
605
        self.assertFalse(a_bzrdir.has_workingtree())
612
606
        self.assertFinished(client)
613
607
 
614
608
 
620
614
        client.add_expected_call(
621
615
            'BzrDir.destroy_repository', ('quack/',),
622
616
            'success', ('ok',)),
623
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
617
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
624
618
            _client=client)
625
 
        a_controldir.destroy_repository()
 
619
        a_bzrdir.destroy_repository()
626
620
        self.assertFinished(client)
627
621
 
628
622
 
734
728
            _client=client)
735
729
        result = bzrdir.open_branch()
736
730
        self.assertIsInstance(result, RemoteBranch)
737
 
        self.assertEqual(bzrdir, result.controldir)
 
731
        self.assertEqual(bzrdir, result.bzrdir)
738
732
        self.assertFinished(client)
739
733
 
740
734
    def test_branch_missing(self):
815
809
            [('call', 'BzrDir.find_repositoryV3', ('quack/',))],
816
810
            client._calls)
817
811
        self.assertIsInstance(result, RemoteRepository)
818
 
        self.assertEqual(bzrdir, result.controldir)
 
812
        self.assertEqual(bzrdir, result.bzrdir)
819
813
        self.assertEqual(rich_root, result._format.rich_root_data)
820
814
        self.assertEqual(subtrees, result._format.supports_tree_reference)
821
815
 
841
835
        repo = self.make_repository('.')
842
836
        self.reset_smart_call_log()
843
837
        self.disable_verb('BzrDir.create_branch')
844
 
        branch = repo.controldir.create_branch()
 
838
        branch = repo.bzrdir.create_branch()
845
839
        create_branch_call_count = len([call for call in self.hpss_calls if
846
840
            call.call.method == 'BzrDir.create_branch'])
847
841
        self.assertEqual(1, create_branch_call_count)
860
854
            'BzrDir.create_branch', ('quack/', network_name),
861
855
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
862
856
            reference_repo_name))
863
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
857
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
864
858
            _client=client)
865
 
        branch = a_controldir.create_branch()
 
859
        branch = a_bzrdir.create_branch()
866
860
        # We should have got a remote branch
867
861
        self.assertIsInstance(branch, remote.RemoteBranch)
868
862
        # its format should have the settings from the response
888
882
            'BzrDir.create_branch', ('extra/quack/', network_name),
889
883
            'success', ('ok', network_name, '', 'no', 'no', 'yes',
890
884
            reference_repo_name))
891
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
885
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
892
886
            _client=client)
893
 
        branch = a_controldir.create_branch(repository=repo)
 
887
        branch = a_bzrdir.create_branch(repository=repo)
894
888
        # We should have got a remote branch
895
889
        self.assertIsInstance(branch, remote.RemoteBranch)
896
890
        # its format should have the settings from the response
902
896
 
903
897
    def test_backwards_compat(self):
904
898
        self.setup_smart_server_with_call_log()
905
 
        bzrdir = self.make_controldir('.')
 
899
        bzrdir = self.make_bzrdir('.')
906
900
        self.reset_smart_call_log()
907
901
        self.disable_verb('BzrDir.create_repository')
908
902
        repo = bzrdir.create_repository()
913
907
    def test_current_server(self):
914
908
        transport = self.get_transport('.')
915
909
        transport = transport.clone('quack')
916
 
        self.make_controldir('quack')
 
910
        self.make_bzrdir('quack')
917
911
        client = FakeClient(transport.base)
918
912
        reference_bzrdir_format = controldir.format_registry.get('default')()
919
913
        reference_format = reference_bzrdir_format.repository_format
923
917
                'Bazaar repository format 2a (needs bzr 1.16 or later)\n',
924
918
                'False'),
925
919
            'success', ('ok', 'yes', 'yes', 'yes', network_name))
926
 
        a_controldir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
 
920
        a_bzrdir = RemoteBzrDir(transport, RemoteBzrDirFormat(),
927
921
            _client=client)
928
 
        repo = a_controldir.create_repository()
 
922
        repo = a_bzrdir.create_repository()
929
923
        # We should have got a remote repository
930
924
        self.assertIsInstance(repo, remote.RemoteRepository)
931
925
        # its format should have the settings from the response
1086
1080
    """
1087
1081
 
1088
1082
    def get_request(self):
1089
 
        input_file = BytesIO(b'ok\x011\n')
1090
 
        output_file = BytesIO()
 
1083
        input_file = StringIO('ok\x011\n')
 
1084
        output_file = StringIO()
1091
1085
        client_medium = medium.SmartSimplePipesClientMedium(
1092
1086
            input_file, output_file)
1093
1087
        return medium.SmartClientStreamMediumRequest(client_medium)
1393
1387
        branch = self.make_remote_branch(transport, client)
1394
1388
        result = branch.heads_to_fetch()
1395
1389
        self.assertFinished(client)
1396
 
        self.assertEqual(({'rev-tip'}, set()), result)
 
1390
        self.assertEqual((set(['rev-tip']), set()), result)
1397
1391
 
1398
1392
    def test_uses_last_revision_info_and_tags_when_set(self):
1399
1393
        transport = MemoryTransport()
1418
1412
        result = branch.heads_to_fetch()
1419
1413
        self.assertFinished(client)
1420
1414
        self.assertEqual(
1421
 
            ({'rev-tip'}, {'rev-foo', 'rev-bar'}), result)
 
1415
            (set(['rev-tip']), set(['rev-foo', 'rev-bar'])), result)
1422
1416
 
1423
1417
    def test_uses_rpc_for_formats_with_non_default_heads_to_fetch(self):
1424
1418
        transport = MemoryTransport()
1435
1429
        branch._format._use_default_local_heads_to_fetch = lambda: False
1436
1430
        result = branch.heads_to_fetch()
1437
1431
        self.assertFinished(client)
1438
 
        self.assertEqual(({'tip'}, {'tagged-1', 'tagged-2'}), result)
 
1432
        self.assertEqual((set(['tip']), set(['tagged-1', 'tagged-2'])), result)
1439
1433
 
1440
1434
    def make_branch_with_tags(self):
1441
1435
        self.setup_smart_server_with_call_log()
1442
1436
        # Make a branch with a single revision.
1443
1437
        builder = self.make_branch_builder('foo')
1444
1438
        builder.start_series()
1445
 
        builder.build_snapshot(None, [
1446
 
            ('add', ('', 'root-id', 'directory', ''))],
1447
 
            revision_id='tip')
 
1439
        builder.build_snapshot('tip', None, [
 
1440
            ('add', ('', 'root-id', 'directory', ''))])
1448
1441
        builder.finish_series()
1449
1442
        branch = builder.get_branch()
1450
1443
        # Add two tags to that branch
1461
1454
        self.disable_verb(verb)
1462
1455
        self.reset_smart_call_log()
1463
1456
        result = br.heads_to_fetch()
1464
 
        self.assertEqual(({'tip'}, {'rev-1', 'rev-2'}), result)
 
1457
        self.assertEqual((set(['tip']), set(['rev-1', 'rev-2'])), result)
1465
1458
        self.assertEqual(
1466
1459
            ['Branch.last_revision_info', 'Branch.get_tags_bytes'],
1467
1460
            [call.call.method for call in self.hpss_calls])
1475
1468
        self.disable_verb(verb)
1476
1469
        self.reset_smart_call_log()
1477
1470
        result = br.heads_to_fetch()
1478
 
        self.assertEqual(({'tip'}, set()), result)
 
1471
        self.assertEqual((set(['tip']), set()), result)
1479
1472
        self.assertEqual(
1480
1473
            ['Branch.last_revision_info'],
1481
1474
            [call.call.method for call in self.hpss_calls])
1531
1524
        memory_branch = self.make_branch('base', format='1.9')
1532
1525
        vfs_url = self.get_vfs_only_url('base')
1533
1526
        stacked_branch.set_stacked_on_url(vfs_url)
1534
 
        transport = stacked_branch.controldir.root_transport
 
1527
        transport = stacked_branch.bzrdir.root_transport
1535
1528
        client = FakeClient(transport.base)
1536
1529
        client.add_expected_call(
1537
1530
            'Branch.get_stacked_on_url', ('stacked/',),
2131
2124
        transport.mkdir('quack')
2132
2125
        transport = transport.clone('quack')
2133
2126
        branch = self.make_remote_branch(transport, client)
2134
 
        self.assertEqual(0, branch.revision_id_to_revno('null:'))
 
2127
        self.assertEquals(0, branch.revision_id_to_revno('null:'))
2135
2128
        self.assertRaises(errors.NoSuchRevision,
2136
2129
            branch.revision_id_to_revno, 'unknown')
2137
2130
        self.assertFinished(client)
2151
2144
        transport.mkdir('quack')
2152
2145
        transport = transport.clone('quack')
2153
2146
        branch = self.make_remote_branch(transport, client)
2154
 
        self.assertEqual((0, ), branch.revision_id_to_dotted_revno('null:'))
 
2147
        self.assertEquals((0, ), branch.revision_id_to_dotted_revno('null:'))
2155
2148
        self.assertRaises(errors.NoSuchRevision,
2156
2149
            branch.revision_id_to_dotted_revno, 'unknown')
2157
2150
        self.assertFinished(client)
2161
2154
        branch = self.make_branch('.')
2162
2155
        self.disable_verb('Branch.revision_id_to_revno')
2163
2156
        self.reset_smart_call_log()
2164
 
        self.assertEqual((0, ),
 
2157
        self.assertEquals((0, ),
2165
2158
            branch.revision_id_to_dotted_revno('null:'))
2166
2159
        self.assertLength(8, self.hpss_calls)
2167
2160
 
2181
2174
 
2182
2175
    def test_set_option_uses_vfs(self):
2183
2176
        self.setup_smart_server_with_call_log()
2184
 
        bzrdir = self.make_controldir('.')
 
2177
        bzrdir = self.make_bzrdir('.')
2185
2178
        self.reset_smart_call_log()
2186
2179
        config = bzrdir.get_config()
2187
2180
        config.set_default_stack_on('/')
2189
2182
 
2190
2183
    def test_backwards_compat_get_option(self):
2191
2184
        self.setup_smart_server_with_call_log()
2192
 
        bzrdir = self.make_controldir('.')
 
2185
        bzrdir = self.make_bzrdir('.')
2193
2186
        verb = 'BzrDir.get_config_file'
2194
2187
        self.disable_verb(verb)
2195
2188
        self.reset_smart_call_log()
2334
2327
        transport_path = 'quack'
2335
2328
        repo, client = self.setup_fake_client_and_repository(transport_path)
2336
2329
        client.add_success_response_with_body('', 'ok')
2337
 
        self.assertEqual([], repo.all_revision_ids())
 
2330
        self.assertEquals([], repo.all_revision_ids())
2338
2331
        self.assertEqual(
2339
2332
            [('call_expecting_body', 'Repository.all_revision_ids',
2340
2333
             ('quack/',))],
2345
2338
        repo, client = self.setup_fake_client_and_repository(transport_path)
2346
2339
        client.add_success_response_with_body(
2347
2340
            'rev1\nrev2\nanotherrev\n', 'ok')
2348
 
        self.assertEqual(["rev1", "rev2", "anotherrev"],
 
2341
        self.assertEquals(["rev1", "rev2", "anotherrev"],
2349
2342
            repo.all_revision_ids())
2350
2343
        self.assertEqual(
2351
2344
            [('call_expecting_body', 'Repository.all_revision_ids',
2364
2357
        result = repo.gather_stats(None)
2365
2358
        self.assertEqual(
2366
2359
            [('call_expecting_body', 'Repository.gather_stats',
2367
 
             ('quack/', '', 'no'))],
 
2360
             ('quack/','','no'))],
2368
2361
            client._calls)
2369
2362
        self.assertEqual({'revisions': 2, 'size': 18}, result)
2370
2363
 
2429
2422
        transport_path = 'hill'
2430
2423
        repo, client = self.setup_fake_client_and_repository(transport_path)
2431
2424
        client.add_success_response('ok', '7')
2432
 
        self.assertEqual('7', repo.get_serializer_format())
 
2425
        self.assertEquals('7', repo.get_serializer_format())
2433
2426
        self.assertEqual(
2434
2427
            [('call', 'VersionedFileRepository.get_serializer_format',
2435
2428
              ('hill/', ))],
2453
2446
             ('call_expecting_body', 'Repository.reconcile',
2454
2447
                ('hill/', 'a token'))],
2455
2448
            client._calls)
2456
 
        self.assertEqual(2, reconciler.garbage_inventories)
2457
 
        self.assertEqual(3, reconciler.inconsistent_parents)
 
2449
        self.assertEquals(2, reconciler.garbage_inventories)
 
2450
        self.assertEquals(3, reconciler.inconsistent_parents)
2458
2451
 
2459
2452
 
2460
2453
class TestRepositoryGetRevisionSignatureText(TestRemoteRepository):
2465
2458
        repo, client = self.setup_fake_client_and_repository(transport_path)
2466
2459
        client.add_success_response_with_body(
2467
2460
            'THETEXT', 'ok')
2468
 
        self.assertEqual("THETEXT", repo.get_signature_text("revid"))
 
2461
        self.assertEquals("THETEXT", repo.get_signature_text("revid"))
2469
2462
        self.assertEqual(
2470
2463
            [('call_expecting_body', 'Repository.get_revision_signature_text',
2471
2464
             ('quack/', 'revid'))],
2649
2642
        # Make a branch with a single revision.
2650
2643
        builder = self.make_branch_builder('foo')
2651
2644
        builder.start_series()
2652
 
        builder.build_snapshot(None, [
2653
 
            ('add', ('', 'root-id', 'directory', ''))],
2654
 
            revision_id='first')
 
2645
        builder.build_snapshot('first', None, [
 
2646
            ('add', ('', 'root-id', 'directory', ''))])
2655
2647
        builder.finish_series()
2656
2648
        branch = builder.get_branch()
2657
2649
        repo = branch.repository
2744
2736
        graph = tree.branch.repository.get_graph()
2745
2737
        # This provides an opportunity for the missing rev-id to be cached.
2746
2738
        self.assertEqual({}, graph.get_parent_map(['rev1']))
2747
 
        tree.commit('message', rev_id=b'rev1')
 
2739
        tree.commit('message', rev_id='rev1')
2748
2740
        graph = tree.branch.repository.get_graph()
2749
2741
        self.assertEqual({'rev1': ('null:',)}, graph.get_parent_map(['rev1']))
2750
2742
 
2779
2771
        client.add_success_response_with_body(
2780
2772
                [body[:10], body[10:]], 'ok', '10')
2781
2773
        revs = repo.get_revisions(['somerev1'])
2782
 
        self.assertEqual(revs, [somerev1])
 
2774
        self.assertEquals(revs, [somerev1])
2783
2775
        self.assertEqual(
2784
2776
            [('call_with_body_bytes_expecting_body', 'Repository.iter_revisions',
2785
2777
             ('quack/', ), "somerev1")],
2902
2894
        # Then it should ask the fallback, using revno/revid from the
2903
2895
        # history-incomplete response as the known revno/revid.
2904
2896
        client.add_expected_call(
2905
 
            'Repository.get_rev_id_for_revno', ('fallback/', 1, (2, 'rev-two')),
 
2897
            'Repository.get_rev_id_for_revno',('fallback/', 1, (2, 'rev-two')),
2906
2898
            'success', ('ok', 'rev-one'))
2907
2899
        result = repo.get_rev_id_for_revno(1, (42, 'rev-foo'))
2908
2900
        self.assertEqual((True, 'rev-one'), result)
3106
3098
            'error', ('UnsuspendableWriteGroup',))
3107
3099
        repo.lock_write()
3108
3100
        repo.start_write_group()
3109
 
        self.assertEqual(client._calls[-2:], [ 
 
3101
        self.assertEquals(client._calls[-2:], [ 
3110
3102
            ('_ensure_real',),
3111
3103
            ('start_write_group',)])
3112
3104
 
3145
3137
    def test_suspend_write_group(self):
3146
3138
        transport_path = 'quack'
3147
3139
        repo, client = self.setup_fake_client_and_repository(transport_path)
3148
 
        self.assertEqual([], repo.suspend_write_group())
 
3140
        self.assertEquals([], repo.suspend_write_group())
3149
3141
 
3150
3142
    def test_resume_write_group(self):
3151
3143
        transport_path = 'quack'
3235
3227
            'success', ('ok',), iter(["ok\x000", "\n", zlib.compress("mydata" * 10)]))
3236
3228
        for (identifier, byte_stream) in repo.iter_files_bytes([("somefile",
3237
3229
                "somerev", "myid")]):
3238
 
            self.assertEqual("myid", identifier)
3239
 
            self.assertEqual("".join(byte_stream), "mydata" * 10)
 
3230
            self.assertEquals("myid", identifier)
 
3231
            self.assertEquals("".join(byte_stream), "mydata" * 10)
3240
3232
 
3241
3233
    def test_missing(self):
3242
3234
        transport_path = 'quack'
3474
3466
class TestRepositoryTarball(TestRemoteRepository):
3475
3467
 
3476
3468
    # This is a canned tarball reponse we can validate against
3477
 
    tarball_content = base64.b64decode(
 
3469
    tarball_content = (
3478
3470
        'QlpoOTFBWSZTWdGkj3wAAWF/k8aQACBIB//A9+8cIX/v33AACEAYABAECEACNz'
3479
3471
        'JqsgJJFPTSnk1A3qh6mTQAAAANPUHkagkSTEkaA09QaNAAAGgAAAcwCYCZGAEY'
3480
3472
        'mJhMJghpiaYBUkKammSHqNMZQ0NABkNAeo0AGneAevnlwQoGzEzNVzaYxp/1Uk'
3487
3479
        'QplPKp2nqBWAfwBGaOwVrz3y1T+UZZNismXHsb2Jq18T+VaD9k4P8DqE3g70qV'
3488
3480
        'JLurpnDI6VS5oqDDPVbtVjMxMxMg4rzQVipn2Bv1fVNK0iq3Gl0hhnnHKm/egy'
3489
3481
        'nWQ7QH/F3JFOFCQ0aSPfA='
3490
 
        )
 
3482
        ).decode('base64')
3491
3483
 
3492
3484
    def test_repository_tarball(self):
3493
3485
        # Test that Repository.tarball generates the right operations
3610
3602
 
3611
3603
 
3612
3604
class TestErrorTranslationBase(tests.TestCaseWithMemoryTransport):
3613
 
    """Base class for unit tests for breezy.bzr.remote._translate_error."""
 
3605
    """Base class for unit tests for bzrlib.remote._translate_error."""
3614
3606
 
3615
3607
    def translateTuple(self, error_tuple, **context):
3616
3608
        """Call _translate_error with an ErrorFromSmartServer built from the
3636
3628
        """
3637
3629
        try:
3638
3630
            raise error_object
3639
 
        except errors.ErrorFromSmartServer as server_error:
 
3631
        except errors.ErrorFromSmartServer, server_error:
3640
3632
            translated_error = self.assertRaises(
3641
3633
                errors.BzrError, remote._translate_error, server_error,
3642
3634
                **context)
3644
3636
 
3645
3637
 
3646
3638
class TestErrorTranslationSuccess(TestErrorTranslationBase):
3647
 
    """Unit tests for breezy.bzr.remote._translate_error.
 
3639
    """Unit tests for bzrlib.remote._translate_error.
3648
3640
 
3649
3641
    Given an ErrorFromSmartServer (which has an error tuple from a smart
3650
3642
    server) and some context, _translate_error raises more specific errors from
3651
 
    breezy.errors.
 
3643
    bzrlib.errors.
3652
3644
 
3653
3645
    This test case covers the cases where _translate_error succeeds in
3654
3646
    translating an ErrorFromSmartServer to something better.  See
3672
3664
        self.assertEqual(expected_error, translated_error)
3673
3665
 
3674
3666
    def test_nobranch(self):
3675
 
        bzrdir = self.make_controldir('')
 
3667
        bzrdir = self.make_bzrdir('')
3676
3668
        translated_error = self.translateTuple(('nobranch',), bzrdir=bzrdir)
3677
3669
        expected_error = errors.NotBranchError(path=bzrdir.root_transport.base)
3678
3670
        self.assertEqual(expected_error, translated_error)
3679
3671
 
3680
3672
    def test_nobranch_one_arg(self):
3681
 
        bzrdir = self.make_controldir('')
 
3673
        bzrdir = self.make_bzrdir('')
3682
3674
        translated_error = self.translateTuple(
3683
3675
            ('nobranch', 'extra detail'), bzrdir=bzrdir)
3684
3676
        expected_error = errors.NotBranchError(
3687
3679
        self.assertEqual(expected_error, translated_error)
3688
3680
 
3689
3681
    def test_norepository(self):
3690
 
        bzrdir = self.make_controldir('')
 
3682
        bzrdir = self.make_bzrdir('')
3691
3683
        translated_error = self.translateTuple(('norepository',),
3692
3684
            bzrdir=bzrdir)
3693
3685
        expected_error = errors.NoRepositoryPresent(bzrdir)
3699
3691
        self.assertEqual(expected_error, translated_error)
3700
3692
 
3701
3693
    def test_UnlockableTransport(self):
3702
 
        bzrdir = self.make_controldir('')
 
3694
        bzrdir = self.make_bzrdir('')
3703
3695
        translated_error = self.translateTuple(
3704
3696
            ('UnlockableTransport',), bzrdir=bzrdir)
3705
3697
        expected_error = errors.UnlockableTransport(bzrdir.root_transport)
3824
3816
 
3825
3817
 
3826
3818
class TestErrorTranslationRobustness(TestErrorTranslationBase):
3827
 
    """Unit tests for breezy.bzr.remote._translate_error's robustness.
 
3819
    """Unit tests for bzrlib.remote._translate_error's robustness.
3828
3820
 
3829
3821
    TestErrorTranslationSuccess is for cases where _translate_error can
3830
3822
    translate successfully.  This class about how _translate_err behaves when
3888
3880
        base_transport = self.get_transport()
3889
3881
        base_builder = self.make_branch_builder('base', format='1.9')
3890
3882
        base_builder.start_series()
3891
 
        base_revid = base_builder.build_snapshot(None,
 
3883
        base_revid = base_builder.build_snapshot('rev-id', None,
3892
3884
            [('add', ('', None, 'directory', None))],
3893
 
            'message', revision_id='rev-id')
 
3885
            'message')
3894
3886
        base_builder.finish_series()
3895
3887
        stacked_branch = self.make_branch('stacked', format='1.9')
3896
3888
        stacked_branch.set_stacked_on_url('../base')
3921
3913
        """Get stacked_upon and stacked branches with content in each."""
3922
3914
        self.setup_smart_server_with_call_log()
3923
3915
        tree1 = self.make_branch_and_tree('tree1', format='1.9')
3924
 
        tree1.commit('rev1', rev_id=b'rev1')
3925
 
        tree2 = tree1.branch.controldir.sprout('tree2', stacked=True
 
3916
        tree1.commit('rev1', rev_id='rev1')
 
3917
        tree2 = tree1.branch.bzrdir.sprout('tree2', stacked=True
3926
3918
            ).open_workingtree()
3927
3919
        local_tree = tree2.branch.create_checkout('local')
3928
3920
        local_tree.commit('local changes make me feel good.')
3935
3927
        # the public implementation of get_parent_map obeys stacking
3936
3928
        _, branch = self.prepare_stacked_remote_branch()
3937
3929
        repo = branch.repository
3938
 
        self.assertEqual({'rev1'}, set(repo.get_parent_map(['rev1'])))
 
3930
        self.assertEqual(['rev1'], repo.get_parent_map(['rev1']).keys())
3939
3931
 
3940
3932
    def test_unstacked_get_parent_map(self):
3941
3933
        # _unstacked_provider.get_parent_map ignores stacking
3942
3934
        _, branch = self.prepare_stacked_remote_branch()
3943
3935
        provider = branch.repository._unstacked_provider
3944
 
        self.assertEqual(set(), set(provider.get_parent_map(['rev1'])))
 
3936
        self.assertEqual([], provider.get_parent_map(['rev1']).keys())
3945
3937
 
3946
3938
    def fetch_stream_to_rev_order(self, stream):
3947
3939
        result = []
3974
3966
        tip = stacked.last_revision()
3975
3967
        stacked.repository._ensure_real()
3976
3968
        graph = stacked.repository.get_graph()
3977
 
        revs = [r for (r, ps) in graph.iter_ancestry([tip])
 
3969
        revs = [r for (r,ps) in graph.iter_ancestry([tip])
3978
3970
                if r != NULL_REVISION]
3979
3971
        revs.reverse()
3980
3972
        search = vf_search.PendingAncestryResult([tip], stacked.repository)
4001
3993
        # is itself stacked yields the full data from all three sources.
4002
3994
        def make_stacked_stacked():
4003
3995
            _, stacked = self.prepare_stacked_remote_branch()
4004
 
            tree = stacked.controldir.sprout('tree3', stacked=True
 
3996
            tree = stacked.bzrdir.sprout('tree3', stacked=True
4005
3997
                ).open_workingtree()
4006
3998
            local_tree = tree.branch.create_checkout('local-tree3')
4007
3999
            local_tree.commit('more local changes are better')
4162
4154
    def assertUpdateSucceeds(self, new_location):
4163
4155
        self.checkout.branch.set_bound_location(new_location)
4164
4156
        self.checkout.update()
4165
 
        self.assertEqual(self.last_revid, self.checkout.last_revision())
 
4157
        self.assertEquals(self.last_revid, self.checkout.last_revision())
4166
4158
 
4167
4159
    def test_without_final_slash(self):
4168
4160
        self.make_master_and_checkout('master', 'checkout')
4284
4276
        ret = list(repo.iter_inventories(["somerevid"]))
4285
4277
        self.assertLength(1, ret)
4286
4278
        inv = ret[0]
4287
 
        self.assertEqual("somerevid", inv.revision_id)
 
4279
        self.assertEquals("somerevid", inv.revision_id)
4288
4280
 
4289
4281
    def test_empty(self):
4290
4282
        transport_path = 'quack'
4291
4283
        repo, client = self.setup_fake_client_and_repository(transport_path)
4292
4284
        ret = list(repo.iter_inventories([]))
4293
 
        self.assertEqual(ret, [])
 
4285
        self.assertEquals(ret, [])
4294
4286
 
4295
4287
    def test_missing(self):
4296
4288
        transport_path = 'quack'