/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: Andrew Bennetts
  • Date: 2011-02-07 04:14:29 UTC
  • mfrom: (5535.4.26 fetch-all-tags-309682)
  • mto: This revision was merged to the branch mainline in revision 5648.
  • Revision ID: andrew.bennetts@canonical.com-20110207041429-3kc1blj34rvvxod9
Merge fetch-all-tags-309682.

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
35
35
    osutils,
36
36
    remote,
37
37
    symbol_versioning,
 
38
    transport as _mod_transport,
38
39
    urlutils,
39
40
    win32utils,
40
41
    workingtree,
57
58
    )
58
59
from bzrlib.tests.test_http import TestWithTransport_pycurl
59
60
from bzrlib.transport import (
60
 
    get_transport,
61
61
    memory,
62
62
    pathfilter,
63
63
    )
255
255
        # is the right format object found for a branch?
256
256
        # create a branch with a few known format objects.
257
257
        # this is not quite the same as
258
 
        t = get_transport(self.get_url())
 
258
        t = self.get_transport()
259
259
        self.build_tree(["foo/", "bar/"], transport=t)
260
260
        def check_format(format, url):
261
261
            format.initialize(url)
262
 
            t = get_transport(url)
 
262
            t = _mod_transport.get_transport(url)
263
263
            found_format = bzrdir.BzrDirFormat.find_format(t)
264
264
            self.failUnless(isinstance(found_format, format.__class__))
265
265
        check_format(bzrdir.BzrDirFormat5(), "foo")
268
268
    def test_find_format_nothing_there(self):
269
269
        self.assertRaises(NotBranchError,
270
270
                          bzrdir.BzrDirFormat.find_format,
271
 
                          get_transport('.'))
 
271
                          _mod_transport.get_transport('.'))
272
272
 
273
273
    def test_find_format_unknown_format(self):
274
 
        t = get_transport(self.get_url())
 
274
        t = self.get_transport()
275
275
        t.mkdir('.bzr')
276
276
        t.put_bytes('.bzr/branch-format', '')
277
277
        self.assertRaises(UnknownFormatError,
278
278
                          bzrdir.BzrDirFormat.find_format,
279
 
                          get_transport('.'))
 
279
                          _mod_transport.get_transport('.'))
280
280
 
281
281
    def test_register_unregister_format(self):
282
282
        format = SampleBzrDirFormat()
290
290
        # which bzrdir.open_containing will refuse (not supported)
291
291
        self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)
292
292
        # but open_downlevel will work
293
 
        t = get_transport(url)
 
293
        t = _mod_transport.get_transport(url)
294
294
        self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))
295
295
        # unregister the format
296
296
        bzrdir.BzrDirFormat.unregister_format(format)
682
682
        self.assertEqual(relpath, 'baz')
683
683
 
684
684
    def test_open_containing_from_transport(self):
685
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
686
 
                          get_transport(self.get_readonly_url('')))
687
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,
688
 
                          get_transport(self.get_readonly_url('g/p/q')))
 
685
        self.assertRaises(NotBranchError,
 
686
            bzrdir.BzrDir.open_containing_from_transport,
 
687
            _mod_transport.get_transport(self.get_readonly_url('')))
 
688
        self.assertRaises(NotBranchError,
 
689
            bzrdir.BzrDir.open_containing_from_transport,
 
690
            _mod_transport.get_transport(self.get_readonly_url('g/p/q')))
689
691
        control = bzrdir.BzrDir.create(self.get_url())
690
692
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
691
 
            get_transport(self.get_readonly_url('')))
 
693
            _mod_transport.get_transport(self.get_readonly_url('')))
692
694
        self.assertEqual('', relpath)
693
695
        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(
694
 
            get_transport(self.get_readonly_url('g/p/q')))
 
696
            _mod_transport.get_transport(self.get_readonly_url('g/p/q')))
695
697
        self.assertEqual('g/p/q', relpath)
696
698
 
697
699
    def test_open_containing_tree_or_branch(self):
741
743
        # transport pointing at bzrdir should give a bzrdir with root transport
742
744
        # set to the given transport
743
745
        control = bzrdir.BzrDir.create(self.get_url())
744
 
        transport = get_transport(self.get_url())
745
 
        opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)
746
 
        self.assertEqual(transport.base, opened_bzrdir.root_transport.base)
 
746
        t = self.get_transport()
 
747
        opened_bzrdir = bzrdir.BzrDir.open_from_transport(t)
 
748
        self.assertEqual(t.base, opened_bzrdir.root_transport.base)
747
749
        self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)
748
750
 
749
751
    def test_open_from_transport_no_bzrdir(self):
750
 
        transport = get_transport(self.get_url())
751
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
752
 
                          transport)
 
752
        t = self.get_transport()
 
753
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport, t)
753
754
 
754
755
    def test_open_from_transport_bzrdir_in_parent(self):
755
756
        control = bzrdir.BzrDir.create(self.get_url())
756
 
        transport = get_transport(self.get_url())
757
 
        transport.mkdir('subdir')
758
 
        transport = transport.clone('subdir')
759
 
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,
760
 
                          transport)
 
757
        t = self.get_transport()
 
758
        t.mkdir('subdir')
 
759
        t = t.clone('subdir')
 
760
        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport, t)
761
761
 
762
762
    def test_sprout_recursive(self):
763
763
        tree = self.make_branch_and_tree('tree1',
823
823
 
824
824
    def test_find_bzrdirs(self):
825
825
        foo, bar, baz = self.make_foo_bar_baz()
826
 
        transport = get_transport(self.get_url())
827
 
        self.assertEqualBzrdirs([baz, foo, bar],
828
 
                                bzrdir.BzrDir.find_bzrdirs(transport))
 
826
        t = self.get_transport()
 
827
        self.assertEqualBzrdirs([baz, foo, bar], bzrdir.BzrDir.find_bzrdirs(t))
829
828
 
830
829
    def make_fake_permission_denied_transport(self, transport, paths):
831
830
        """Create a transport that raises PermissionDenied for some paths."""
847
846
 
848
847
    def test_find_bzrdirs_permission_denied(self):
849
848
        foo, bar, baz = self.make_foo_bar_baz()
850
 
        transport = get_transport(self.get_url())
 
849
        t = self.get_transport()
851
850
        path_filter_server, path_filter_transport = \
852
 
            self.make_fake_permission_denied_transport(transport, ['foo'])
 
851
            self.make_fake_permission_denied_transport(t, ['foo'])
853
852
        # local transport
854
853
        self.assertBranchUrlsEndWith('/baz/',
855
854
            bzrdir.BzrDir.find_bzrdirs(path_filter_transport))
864
863
            return [s for s in transport.list_dir('') if s != 'baz']
865
864
 
866
865
        foo, bar, baz = self.make_foo_bar_baz()
867
 
        transport = get_transport(self.get_url())
868
 
        self.assertEqualBzrdirs([foo, bar],
869
 
                                bzrdir.BzrDir.find_bzrdirs(transport,
870
 
                                    list_current=list_current))
 
866
        t = self.get_transport()
 
867
        self.assertEqualBzrdirs(
 
868
            [foo, bar],
 
869
            bzrdir.BzrDir.find_bzrdirs(t, list_current=list_current))
871
870
 
872
871
    def test_find_bzrdirs_evaluate(self):
873
872
        def evaluate(bzrdir):
879
878
                return False, bzrdir.root_transport.base
880
879
 
881
880
        foo, bar, baz = self.make_foo_bar_baz()
882
 
        transport = get_transport(self.get_url())
 
881
        t = self.get_transport()
883
882
        self.assertEqual([baz.root_transport.base, foo.root_transport.base],
884
 
                         list(bzrdir.BzrDir.find_bzrdirs(transport,
885
 
                                                         evaluate=evaluate)))
 
883
                         list(bzrdir.BzrDir.find_bzrdirs(t, evaluate=evaluate)))
886
884
 
887
885
    def assertEqualBzrdirs(self, first, second):
888
886
        first = list(first)
895
893
        root = self.make_repository('', shared=True)
896
894
        foo, bar, baz = self.make_foo_bar_baz()
897
895
        qux = self.make_bzrdir('foo/qux')
898
 
        transport = get_transport(self.get_url())
899
 
        branches = bzrdir.BzrDir.find_branches(transport)
 
896
        t = self.get_transport()
 
897
        branches = bzrdir.BzrDir.find_branches(t)
900
898
        self.assertEqual(baz.root_transport.base, branches[0].base)
901
899
        self.assertEqual(foo.root_transport.base, branches[1].base)
902
900
        self.assertEqual(bar.root_transport.base, branches[2].base)
903
901
 
904
902
        # ensure this works without a top-level repo
905
 
        branches = bzrdir.BzrDir.find_branches(transport.clone('foo'))
 
903
        branches = bzrdir.BzrDir.find_branches(t.clone('foo'))
906
904
        self.assertEqual(foo.root_transport.base, branches[0].base)
907
905
        self.assertEqual(bar.root_transport.base, branches[1].base)
908
906
 
910
908
class TestMissingRepoBranchesSkipped(TestCaseWithMemoryTransport):
911
909
 
912
910
    def test_find_bzrdirs_missing_repo(self):
913
 
        transport = get_transport(self.get_url())
 
911
        t = self.get_transport()
914
912
        arepo = self.make_repository('arepo', shared=True)
915
913
        abranch_url = arepo.user_url + '/abranch'
916
914
        abranch = bzrdir.BzrDir.create(abranch_url).create_branch()
917
 
        transport.delete_tree('arepo/.bzr')
 
915
        t.delete_tree('arepo/.bzr')
918
916
        self.assertRaises(errors.NoRepositoryPresent,
919
917
            branch.Branch.open, abranch_url)
920
918
        self.make_branch('baz')
921
 
        for actual_bzrdir in bzrdir.BzrDir.find_branches(transport):
 
919
        for actual_bzrdir in bzrdir.BzrDir.find_branches(t):
922
920
            self.assertEndsWith(actual_bzrdir.user_url, '/baz/')
923
921
 
924
922
 
1100
1098
        # now probe for it.
1101
1099
        controldir.ControlDirFormat.register_prober(NotBzrDirProber)
1102
1100
        try:
1103
 
            found = bzrlib.bzrdir.BzrDirFormat.find_format(
1104
 
                get_transport(self.get_url()))
 
1101
            found = bzrlib.bzrdir.BzrDirFormat.find_format(self.get_transport())
1105
1102
            self.assertIsInstance(found, NotBzrDirFormat)
1106
1103
        finally:
1107
1104
            controldir.ControlDirFormat.unregister_prober(NotBzrDirProber)
1143
1140
            self.get_url('foo'),
1144
1141
            force_new_tree=True,
1145
1142
            format=format)
1146
 
        t = get_transport(self.get_url('.'))
 
1143
        t = self.get_transport()
1147
1144
        self.assertFalse(t.has('foo'))
1148
1145
 
1149
1146
    def test_clone(self):
1449
1446
 
1450
1447
    def setUp(self):
1451
1448
        super(TestGenerateBackupName, self).setUp()
1452
 
        self._transport = get_transport(self.get_url())
 
1449
        self._transport = self.get_transport()
1453
1450
        bzrdir.BzrDir.create(self.get_url(),
1454
1451
            possible_transports=[self._transport])
1455
1452
        self._bzrdir = bzrdir.BzrDir.open_from_transport(self._transport)