/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_bzrdir.py

  • Committer: Vincent Ladeuil
  • Date: 2011-07-06 08:58:15 UTC
  • mfrom: (5609.48.2 2.3)
  • mto: (6012.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6013.
  • Revision ID: v.ladeuil+lp@free.fr-20110706085815-6leauod52jq2u43d
Merging in 2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_bzrdir.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 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
26
26
from bzrlib import (
27
27
    branch,
28
28
    bzrdir,
 
29
    controldir,
29
30
    errors,
30
31
    help_topics,
 
32
    lock,
31
33
    repository,
32
34
    osutils,
33
35
    remote,
 
36
    symbol_versioning,
 
37
    transport as _mod_transport,
34
38
    urlutils,
35
39
    win32utils,
36
40
    workingtree,
53
57
    )
54
58
from bzrlib.tests.test_http import TestWithTransport_pycurl
55
59
from bzrlib.transport import (
56
 
    get_transport,
57
60
    memory,
58
61
    pathfilter,
59
62
    )
67
70
 
68
71
    def test_get_set_default_format(self):
69
72
        old_format = bzrdir.BzrDirFormat.get_default_format()
70
 
        # default is BzrDirFormat6
71
 
        self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))
72
 
        bzrdir.BzrDirFormat._set_default_format(SampleBzrDirFormat())
 
73
        self.assertIsInstance(old_format, bzrdir.BzrDirMetaFormat1)
 
74
        controldir.ControlDirFormat._set_default_format(SampleBzrDirFormat())
73
75
        # creating a bzr dir should now create an instrumented dir.
74
76
        try:
75
77
            result = bzrdir.BzrDir.create('memory:///')
76
 
            self.failUnless(isinstance(result, SampleBzrDir))
 
78
            self.assertIsInstance(result, SampleBzrDir)
77
79
        finally:
78
 
            bzrdir.BzrDirFormat._set_default_format(old_format)
 
80
            controldir.ControlDirFormat._set_default_format(old_format)
79
81
        self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())
80
82
 
81
83
 
82
84
class TestFormatRegistry(TestCase):
83
85
 
84
86
    def make_format_registry(self):
85
 
        my_format_registry = bzrdir.BzrDirFormatRegistry()
 
87
        my_format_registry = controldir.ControlDirFormatRegistry()
86
88
        my_format_registry.register('weave', bzrdir.BzrDirFormat6,
87
89
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
88
90
            ' repositories', deprecated=True)
89
91
        my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir',
90
92
            'BzrDirFormat6', 'Format registered lazily', deprecated=True)
91
 
        my_format_registry.register_metadir('knit',
 
93
        bzrdir.register_metadir(my_format_registry, 'knit',
92
94
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',
93
95
            'Format using knits',
94
96
            )
95
97
        my_format_registry.set_default('knit')
96
 
        my_format_registry.register_metadir(
 
98
        bzrdir.register_metadir(my_format_registry,
97
99
            'branch6',
98
100
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
99
101
            'Experimental successor to knit.  Use at your own risk.',
100
102
            branch_format='bzrlib.branch.BzrBranchFormat6',
101
103
            experimental=True)
102
 
        my_format_registry.register_metadir(
 
104
        bzrdir.register_metadir(my_format_registry,
103
105
            'hidden format',
104
106
            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',
105
107
            'Experimental successor to knit.  Use at your own risk.',
174
176
            bzrdir.format_registry.set_default_repository(old_default)
175
177
 
176
178
    def test_aliases(self):
177
 
        a_registry = bzrdir.BzrDirFormatRegistry()
 
179
        a_registry = controldir.ControlDirFormatRegistry()
178
180
        a_registry.register('weave', bzrdir.BzrDirFormat6,
179
181
            'Pre-0.8 format.  Slower and does not support checkouts or shared'
180
182
            ' repositories', deprecated=True)
251
253
        # is the right format object found for a branch?
252
254
        # create a branch with a few known format objects.
253
255
        # this is not quite the same as
254
 
        t = get_transport(self.get_url())
 
256
        t = self.get_transport()
255
257
        self.build_tree(["foo/", "bar/"], transport=t)
256
258
        def check_format(format, url):
257
259
            format.initialize(url)
258
 
            t = get_transport(url)
 
260
            t = _mod_transport.get_transport(url)
259
261
            found_format = bzrdir.BzrDirFormat.find_format(t)
260
 
            self.failUnless(isinstance(found_format, format.__class__))
 
262
            self.assertIsInstance(found_format, format.__class__)
261
263
        check_format(bzrdir.BzrDirFormat5(), "foo")
262
264
        check_format(bzrdir.BzrDirFormat6(), "bar")
263
265
 
264
266
    def test_find_format_nothing_there(self):
265
267
        self.assertRaises(NotBranchError,
266
268
                          bzrdir.BzrDirFormat.find_format,
267
 
                          get_transport('.'))
 
269
                          _mod_transport.get_transport('.'))
268
270
 
269
271
    def test_find_format_unknown_format(self):
270
 
        t = get_transport(self.get_url())
 
272
        t = self.get_transport()
271
273
        t.mkdir('.bzr')
272
274
        t.put_bytes('.bzr/branch-format', '')
273
275
        self.assertRaises(UnknownFormatError,
274
276
                          bzrdir.BzrDirFormat.find_format,
275
 
                          get_transport('.'))
 
277
                          _mod_transport.get_transport('.'))
276
278
 
277
279
    def test_register_unregister_format(self):
278
280
        format = SampleBzrDirFormat()
286
288
        # which bzrdir.open_containing will refuse (not supported)
287
289
        self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)
288
290
        # but open_downlevel will work
289
 
        t = get_transport(url)
 
291
        t = _mod_transport.get_transport(url)
290
292
        self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))
291
293
        # unregister the format
292
294
        bzrdir.BzrDirFormat.unregister_format(format)
678
680
        self.assertEqual(relpath, 'baz')
679
681
 
680
682
    def test_open_containing_from_transport(self):
681
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
682
 
                          get_transport(self.get_readonly_url('')))
683
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
684
 
                          get_transport(self.get_readonly_url('g/p/q')))
 
683
        self.assertRaises(NotBranchError,
 
684
            bzrdir.BzrDir.open_containing_from_transport,
 
685
            _mod_transport.get_transport(self.get_readonly_url('')))
 
686
        self.assertRaises(NotBranchError,
 
687
            bzrdir.BzrDir.open_containing_from_transport,
 
688
            _mod_transport.get_transport(self.get_readonly_url('g/p/q')))
685
689
        control = bzrdir.BzrDir.create(self.get_url())
686
690
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
687
 
            get_transport(self.get_readonly_url('')))
 
691
            _mod_transport.get_transport(self.get_readonly_url('')))
688
692
        self.assertEqual('', relpath)
689
693
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
690
 
            get_transport(self.get_readonly_url('g/p/q')))
 
694
            _mod_transport.get_transport(self.get_readonly_url('g/p/q')))
691
695
        self.assertEqual('g/p/q', relpath)
692
696
 
693
697
    def test_open_containing_tree_or_branch(self):
737
741
        # transport pointing at bzrdir should give a bzrdir with root transport
738
742
        # set to the given transport
739
743
        control = bzrdir.BzrDir.create(self.get_url())
740
 
        transport = get_transport(self.get_url())
741
 
        opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)
742
 
        self.assertEqual(transport.base, opened_bzrdir.root_transport.base)
 
744
        t = self.get_transport()
 
745
        opened_bzrdir = bzrdir.BzrDir.open_from_transport(t)
 
746
        self.assertEqual(t.base, opened_bzrdir.root_transport.base)
743
747
        self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
744
748
 
745
749
    def test_open_from_transport_no_bzrdir(self):
746
 
        transport = get_transport(self.get_url())
747
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
748
 
                          transport)
 
750
        t = self.get_transport()
 
751
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport, t)
749
752
 
750
753
    def test_open_from_transport_bzrdir_in_parent(self):
751
754
        control = bzrdir.BzrDir.create(self.get_url())
752
 
        transport = get_transport(self.get_url())
753
 
        transport.mkdir('subdir')
754
 
        transport = transport.clone('subdir')
755
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
756
 
                          transport)
 
755
        t = self.get_transport()
 
756
        t.mkdir('subdir')
 
757
        t = t.clone('subdir')
 
758
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport, t)
757
759
 
758
760
    def test_sprout_recursive(self):
759
761
        tree = self.make_branch_and_tree('tree1',
768
770
        tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
769
771
        tree2.lock_read()
770
772
        self.addCleanup(tree2.unlock)
771
 
        self.failUnlessExists('tree2/subtree/file')
 
773
        self.assertPathExists('tree2/subtree/file')
772
774
        self.assertEqual('tree-reference', tree2.kind('subtree-root'))
773
775
 
774
776
    def test_cloning_metadir(self):
789
791
        self.build_tree(['tree1/subtree/file'])
790
792
        sub_tree.add('file')
791
793
        tree.commit('Initial commit')
 
794
        # The following line force the orhaning to reveal bug #634470
 
795
        tree.branch.get_config().set_user_option(
 
796
            'bzr.transform.orphan_policy', 'move')
792
797
        tree.bzrdir.destroy_workingtree()
 
798
        # FIXME: subtree/.bzr is left here which allows the test to pass (or
 
799
        # fail :-( ) -- vila 20100909
793
800
        repo = self.make_repository('repo', shared=True,
794
801
            format='dirstate-with-subtree')
795
802
        repo.set_make_working_trees(False)
796
 
        tree.bzrdir.sprout('repo/tree2')
797
 
        self.failUnlessExists('repo/tree2/subtree')
798
 
        self.failIfExists('repo/tree2/subtree/file')
 
803
        # FIXME: we just deleted the workingtree and now we want to use it ????
 
804
        # At a minimum, we should use tree.branch below (but this fails too
 
805
        # currently) or stop calling this test 'treeless'. Specifically, I've
 
806
        # turn the line below into an assertRaises when 'subtree/.bzr' is
 
807
        # orphaned and sprout tries to access the branch there (which is left
 
808
        # by bzrdir.BzrDirMeta1.destroy_workingtree when it ignores the
 
809
        # [DeletingParent('Not deleting', u'subtree', None)] conflict). See bug
 
810
        # #634470.  -- vila 20100909
 
811
        self.assertRaises(errors.NotBranchError,
 
812
                          tree.bzrdir.sprout, 'repo/tree2')
 
813
#        self.assertPathExists('repo/tree2/subtree')
 
814
#        self.assertPathDoesNotExist('repo/tree2/subtree/file')
799
815
 
800
816
    def make_foo_bar_baz(self):
801
817
        foo = bzrdir.BzrDir.create_branch_convenience('foo').bzrdir
805
821
 
806
822
    def test_find_bzrdirs(self):
807
823
        foo, bar, baz = self.make_foo_bar_baz()
808
 
        transport = get_transport(self.get_url())
809
 
        self.assertEqualBzrdirs([baz, foo, bar],
810
 
                                bzrdir.BzrDir.find_bzrdirs(transport))
 
824
        t = self.get_transport()
 
825
        self.assertEqualBzrdirs([baz, foo, bar], bzrdir.BzrDir.find_bzrdirs(t))
811
826
 
812
827
    def make_fake_permission_denied_transport(self, transport, paths):
813
828
        """Create a transport that raises PermissionDenied for some paths."""
829
844
 
830
845
    def test_find_bzrdirs_permission_denied(self):
831
846
        foo, bar, baz = self.make_foo_bar_baz()
832
 
        transport = get_transport(self.get_url())
 
847
        t = self.get_transport()
833
848
        path_filter_server, path_filter_transport = \
834
 
            self.make_fake_permission_denied_transport(transport, ['foo'])
 
849
            self.make_fake_permission_denied_transport(t, ['foo'])
835
850
        # local transport
836
851
        self.assertBranchUrlsEndWith('/baz/',
837
852
            bzrdir.BzrDir.find_bzrdirs(path_filter_transport))
846
861
            return [s for s in transport.list_dir('') if s != 'baz']
847
862
 
848
863
        foo, bar, baz = self.make_foo_bar_baz()
849
 
        transport = get_transport(self.get_url())
850
 
        self.assertEqualBzrdirs([foo, bar],
851
 
                                bzrdir.BzrDir.find_bzrdirs(transport,
852
 
                                    list_current=list_current))
 
864
        t = self.get_transport()
 
865
        self.assertEqualBzrdirs(
 
866
            [foo, bar],
 
867
            bzrdir.BzrDir.find_bzrdirs(t, list_current=list_current))
853
868
 
854
869
    def test_find_bzrdirs_evaluate(self):
855
870
        def evaluate(bzrdir):
861
876
                return False, bzrdir.root_transport.base
862
877
 
863
878
        foo, bar, baz = self.make_foo_bar_baz()
864
 
        transport = get_transport(self.get_url())
 
879
        t = self.get_transport()
865
880
        self.assertEqual([baz.root_transport.base, foo.root_transport.base],
866
 
                         list(bzrdir.BzrDir.find_bzrdirs(transport,
867
 
                                                         evaluate=evaluate)))
 
881
                         list(bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate)))
868
882
 
869
883
    def assertEqualBzrdirs(self, first, second):
870
884
        first = list(first)
877
891
        root = self.make_repository('', shared=True)
878
892
        foo, bar, baz = self.make_foo_bar_baz()
879
893
        qux = self.make_bzrdir('foo/qux')
880
 
        transport = get_transport(self.get_url())
881
 
        branches = bzrdir.BzrDir.find_branches(transport)
 
894
        t = self.get_transport()
 
895
        branches = bzrdir.BzrDir.find_branches(t)
882
896
        self.assertEqual(baz.root_transport.base, branches[0].base)
883
897
        self.assertEqual(foo.root_transport.base, branches[1].base)
884
898
        self.assertEqual(bar.root_transport.base, branches[2].base)
885
899
 
886
900
        # ensure this works without a top-level repo
887
 
        branches = bzrdir.BzrDir.find_branches(transport.clone('foo'))
 
901
        branches = bzrdir.BzrDir.find_branches(t.clone('foo'))
888
902
        self.assertEqual(foo.root_transport.base, branches[0].base)
889
903
        self.assertEqual(bar.root_transport.base, branches[1].base)
890
904
 
892
906
class TestMissingRepoBranchesSkipped(TestCaseWithMemoryTransport):
893
907
 
894
908
    def test_find_bzrdirs_missing_repo(self):
895
 
        transport = get_transport(self.get_url())
 
909
        t = self.get_transport()
896
910
        arepo = self.make_repository('arepo', shared=True)
897
911
        abranch_url = arepo.user_url + '/abranch'
898
912
        abranch = bzrdir.BzrDir.create(abranch_url).create_branch()
899
 
        transport.delete_tree('arepo/.bzr')
 
913
        t.delete_tree('arepo/.bzr')
900
914
        self.assertRaises(errors.NoRepositoryPresent,
901
915
            branch.Branch.open, abranch_url)
902
916
        self.make_branch('baz')
903
 
        for actual_bzrdir in bzrdir.BzrDir.find_branches(transport):
 
917
        for actual_bzrdir in bzrdir.BzrDir.find_branches(t):
904
918
            self.assertEndsWith(actual_bzrdir.user_url, '/baz/')
905
919
 
906
920
 
1058
1072
    def _known_formats(self):
1059
1073
        return set([NotBzrDirFormat()])
1060
1074
 
1061
 
    @classmethod
 
1075
 
 
1076
class NotBzrDirProber(controldir.Prober):
 
1077
 
1062
1078
    def probe_transport(self, transport):
1063
1079
        """Our format is present if the transport ends in '.not/'."""
1064
1080
        if transport.has('.not'):
1078
1094
        dir = format.initialize(self.get_url())
1079
1095
        self.assertIsInstance(dir, NotBzrDir)
1080
1096
        # now probe for it.
1081
 
        bzrlib.bzrdir.BzrDirFormat.register_control_format(format)
 
1097
        controldir.ControlDirFormat.register_prober(NotBzrDirProber)
1082
1098
        try:
1083
 
            found = bzrlib.bzrdir.BzrDirFormat.find_format(
1084
 
                get_transport(self.get_url()))
 
1099
            found = bzrlib.bzrdir.BzrDirFormat.find_format(self.get_transport())
1085
1100
            self.assertIsInstance(found, NotBzrDirFormat)
1086
1101
        finally:
1087
 
            bzrlib.bzrdir.BzrDirFormat.unregister_control_format(format)
 
1102
            controldir.ControlDirFormat.unregister_prober(NotBzrDirProber)
1088
1103
 
1089
1104
    def test_included_in_known_formats(self):
1090
 
        bzrlib.bzrdir.BzrDirFormat.register_control_format(NotBzrDirFormat)
 
1105
        not_format = NotBzrDirFormat()
 
1106
        bzrlib.controldir.ControlDirFormat.register_format(not_format)
1091
1107
        try:
1092
1108
            formats = bzrlib.bzrdir.BzrDirFormat.known_formats()
1093
1109
            for format in formats:
1095
1111
                    return
1096
1112
            self.fail("No NotBzrDirFormat in %s" % formats)
1097
1113
        finally:
1098
 
            bzrlib.bzrdir.BzrDirFormat.unregister_control_format(NotBzrDirFormat)
 
1114
            bzrlib.controldir.ControlDirFormat.unregister_format(not_format)
1099
1115
 
1100
1116
 
1101
1117
class NonLocalTests(TestCaseWithTransport):
1122
1138
            self.get_url('foo'),
1123
1139
            force_new_tree=True,
1124
1140
            format=format)
1125
 
        t = get_transport(self.get_url('.'))
 
1141
        t = self.get_transport()
1126
1142
        self.assertFalse(t.has('foo'))
1127
1143
 
1128
1144
    def test_clone(self):
1330
1346
    def set_parent(self, parent):
1331
1347
        self._parent = parent
1332
1348
 
 
1349
    def lock_read(self):
 
1350
        return lock.LogicalLockResult(self.unlock)
 
1351
 
 
1352
    def unlock(self):
 
1353
        return
 
1354
 
1333
1355
 
1334
1356
class TestBzrDirSprout(TestCaseWithMemoryTransport):
1335
1357
 
1411
1433
        param_repr = param_reprs[0]
1412
1434
        self.assertStartsWith(param_repr, '<RepoInitHookParams for ')
1413
1435
 
 
1436
 
 
1437
class TestGenerateBackupName(TestCaseWithMemoryTransport):
 
1438
    # FIXME: This may need to be unified with test_osutils.TestBackupNames or
 
1439
    # moved to per_bzrdir or per_transport for better coverage ?
 
1440
    # -- vila 20100909
 
1441
 
 
1442
    def setUp(self):
 
1443
        super(TestGenerateBackupName, self).setUp()
 
1444
        self._transport = self.get_transport()
 
1445
        bzrdir.BzrDir.create(self.get_url(),
 
1446
            possible_transports=[self._transport])
 
1447
        self._bzrdir = bzrdir.BzrDir.open_from_transport(self._transport)
 
1448
 
 
1449
    def test_deprecated_generate_backup_name(self):
 
1450
        res = self.applyDeprecated(
 
1451
                symbol_versioning.deprecated_in((2, 3, 0)),
 
1452
                self._bzrdir.generate_backup_name, 'whatever')
 
1453
 
 
1454
    def test_new(self):
 
1455
        self.assertEqual("a.~1~", self._bzrdir._available_backup_name("a"))
 
1456
 
 
1457
    def test_exiting(self):
 
1458
        self._transport.put_bytes("a.~1~", "some content")
 
1459
        self.assertEqual("a.~2~", self._bzrdir._available_backup_name("a"))