/brz/remove-bazaar

# Copyright (C) 2005, 2006, 2007 Canonical Ltd

# 

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""Tests for the BzrDir facility and any format specific tests.

For interface contract tests, see tests/bzr_dir_implementations.

"""

import os.path

from StringIO import StringIO

from bzrlib import (

    bzrdir,

    errors,

    help_topics,

    repository,

    symbol_versioning,

    urlutils,

    workingtree,

    )

import bzrlib.branch

from bzrlib.errors import (NotBranchError,

                           UnknownFormatError,

                           UnsupportedFormatError,

                           )

from bzrlib.tests import TestCase, TestCaseWithTransport, test_sftp_transport

from bzrlib.tests.HttpServer import HttpServer

from bzrlib.transport import get_transport

from bzrlib.transport.memory import MemoryServer

from bzrlib.repofmt import knitrepo, weaverepo

class TestDefaultFormat(TestCase):

    def test_get_set_default_format(self):

        old_format = bzrdir.BzrDirFormat.get_default_format()

        # default is BzrDirFormat6

        self.failUnless(isinstance(old_format, bzrdir.BzrDirMetaFormat1))

        self.applyDeprecated(symbol_versioning.zero_fourteen, 

                             bzrdir.BzrDirFormat.set_default_format, 

                             SampleBzrDirFormat())

        # creating a bzr dir should now create an instrumented dir.

        try:

            result = bzrdir.BzrDir.create('memory:///')

            self.failUnless(isinstance(result, SampleBzrDir))

        finally:

            self.applyDeprecated(symbol_versioning.zero_fourteen,

                bzrdir.BzrDirFormat.set_default_format, old_format)

        self.assertEqual(old_format, bzrdir.BzrDirFormat.get_default_format())

class TestFormatRegistry(TestCase):

    def make_format_registry(self):

        my_format_registry = bzrdir.BzrDirFormatRegistry()

        my_format_registry.register('weave', bzrdir.BzrDirFormat6,

            'Pre-0.8 format.  Slower and does not support checkouts or shared'

            ' repositories', deprecated=True)

        my_format_registry.register_lazy('lazy', 'bzrlib.bzrdir', 

            'BzrDirFormat6', 'Format registered lazily', deprecated=True)

        my_format_registry.register_metadir('knit',

            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit1',

            'Format using knits',

            )

        my_format_registry.register_metadir('experimental-knit3', 

            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',

            'Format using knits', 

            tree='WorkingTreeFormatAB1')

        my_format_registry.set_default('knit')

        my_format_registry.register_metadir(

            'experimental-knit2',

            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit2',

            'Experimental successor to knit.  Use at your own risk.',

            )

        my_format_registry.register_metadir(

            'branch6',

            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit2',

            'Experimental successor to knit.  Use at your own risk.',

            branch_format='BzrBranchFormat6')

        return my_format_registry

    def test_format_registry(self):

        my_format_registry = self.make_format_registry()

        my_bzrdir = my_format_registry.make_bzrdir('lazy')

        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)

        my_bzrdir = my_format_registry.make_bzrdir('weave')

        self.assertIsInstance(my_bzrdir, bzrdir.BzrDirFormat6)

        my_bzrdir = my_format_registry.make_bzrdir('default')

        self.assertIsInstance(my_bzrdir.repository_format, 

            knitrepo.RepositoryFormatKnit1)

        my_bzrdir = my_format_registry.make_bzrdir('knit')

        self.assertIsInstance(my_bzrdir.repository_format, 

            knitrepo.RepositoryFormatKnit1)

        my_bzrdir = my_format_registry.make_bzrdir('experimental-knit3')

        self.assertIsInstance(my_bzrdir.repository_format, 

            knitrepo.RepositoryFormatKnit3)

        self.assertIsInstance(my_bzrdir.workingtree_format, 

            workingtree.WorkingTreeFormatAB1)

        my_bzrdir = my_format_registry.make_bzrdir('branch6')

        self.assertIsInstance(my_bzrdir.get_branch_format(),

                              bzrlib.branch.BzrBranchFormat6)

    def test_get_help(self):

        my_format_registry = self.make_format_registry()

        self.assertEqual('Format registered lazily',

                         my_format_registry.get_help('lazy'))

        self.assertEqual('Format using knits', 

                         my_format_registry.get_help('knit'))

        self.assertEqual('Format using knits', 

                         my_format_registry.get_help('default'))

        self.assertEqual('Pre-0.8 format.  Slower and does not support'

                         ' checkouts or shared repositories', 

                         my_format_registry.get_help('weave'))

    def test_help_topic(self):

        topics = help_topics.HelpTopicRegistry()

        topics.register('formats', self.make_format_registry().help_topic, 

                        'Directory formats')

        topic = topics.get_detail('formats')

        new, deprecated = topic.split('Deprecated formats')

        self.assertContainsRe(new, 'Bazaar directory formats')

        self.assertContainsRe(new, 

            '  knit/default:\n    \(native\) Format using knits\n')

        self.assertContainsRe(deprecated, 

            '  lazy:\n    \(native\) Format registered lazily\n')

    def test_set_default_repository(self):

        default_factory = bzrdir.format_registry.get('default')

        old_default = [k for k, v in bzrdir.format_registry.iteritems()

                       if v == default_factory and k != 'default'][0]

        bzrdir.format_registry.set_default_repository('experimental-knit2')

        try:

            self.assertIs(bzrdir.format_registry.get('experimental-knit2'),

                          bzrdir.format_registry.get('default'))

            self.assertIs(

                repository.RepositoryFormat.get_default_format().__class__,

                knitrepo.RepositoryFormatKnit2)

        finally:

            bzrdir.format_registry.set_default_repository(old_default)

class SampleBranch(bzrlib.branch.Branch):

    """A dummy branch for guess what, dummy use."""

    def __init__(self, dir):

        self.bzrdir = dir

class SampleBzrDir(bzrdir.BzrDir):

    """A sample BzrDir implementation to allow testing static methods."""

    def create_repository(self, shared=False):

        """See BzrDir.create_repository."""

        return "A repository"

    def open_repository(self):

        """See BzrDir.open_repository."""

        return "A repository"

    def create_branch(self):

        """See BzrDir.create_branch."""

        return SampleBranch(self)

    def create_workingtree(self):

        """See BzrDir.create_workingtree."""

        return "A tree"

class SampleBzrDirFormat(bzrdir.BzrDirFormat):

    """A sample format

    this format is initializable, unsupported to aid in testing the 

    open and open_downlevel routines.

    """

    def get_format_string(self):

        """See BzrDirFormat.get_format_string()."""

        return "Sample .bzr dir format."

    def initialize(self, url):

        """Create a bzr dir."""

        t = get_transport(url)

        t.mkdir('.bzr')

        t.put_bytes('.bzr/branch-format', self.get_format_string())

        return SampleBzrDir(t, self)

    def is_supported(self):

        return False

    def open(self, transport, _found=None):

        return "opened branch."

class TestBzrDirFormat(TestCaseWithTransport):

    """Tests for the BzrDirFormat facility."""

    def test_find_format(self):

        # is the right format object found for a branch?

        # create a branch with a few known format objects.

        # this is not quite the same as 

        t = get_transport(self.get_url())

        self.build_tree(["foo/", "bar/"], transport=t)

        def check_format(format, url):

            format.initialize(url)

            t = get_transport(url)

            found_format = bzrdir.BzrDirFormat.find_format(t)

            self.failUnless(isinstance(found_format, format.__class__))

        check_format(bzrdir.BzrDirFormat5(), "foo")

        check_format(bzrdir.BzrDirFormat6(), "bar")

    def test_find_format_nothing_there(self):

        self.assertRaises(NotBranchError,

                          bzrdir.BzrDirFormat.find_format,

                          get_transport('.'))

    def test_find_format_unknown_format(self):

        t = get_transport(self.get_url())

        t.mkdir('.bzr')

        t.put_bytes('.bzr/branch-format', '')

        self.assertRaises(UnknownFormatError,

                          bzrdir.BzrDirFormat.find_format,

                          get_transport('.'))

    def test_register_unregister_format(self):

        format = SampleBzrDirFormat()

        url = self.get_url()

        # make a bzrdir

        format.initialize(url)

        # register a format for it.

        bzrdir.BzrDirFormat.register_format(format)

        # which bzrdir.Open will refuse (not supported)

        self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open, url)

        # which bzrdir.open_containing will refuse (not supported)

        self.assertRaises(UnsupportedFormatError, bzrdir.BzrDir.open_containing, url)

        # but open_downlevel will work

        t = get_transport(url)

        self.assertEqual(format.open(t), bzrdir.BzrDir.open_unsupported(url))

        # unregister the format

        bzrdir.BzrDirFormat.unregister_format(format)

        # now open_downlevel should fail too.

        self.assertRaises(UnknownFormatError, bzrdir.BzrDir.open_unsupported, url)

    def test_create_repository(self):

        format = SampleBzrDirFormat()

        repo = bzrdir.BzrDir.create_repository(self.get_url(), format=format)

        self.assertEqual('A repository', repo)

    def test_create_repository_shared(self):

        old_format = bzrdir.BzrDirFormat.get_default_format()

        repo = bzrdir.BzrDir.create_repository('.', shared=True)

        self.assertTrue(repo.is_shared())

    def test_create_repository_nonshared(self):

        old_format = bzrdir.BzrDirFormat.get_default_format()

        repo = bzrdir.BzrDir.create_repository('.')

        self.assertFalse(repo.is_shared())

    def test_create_repository_under_shared(self):

        # an explicit create_repository always does so.

        # we trust the format is right from the 'create_repository test'

        format = bzrdir.format_registry.make_bzrdir('knit')

        self.make_repository('.', shared=True, format=format)

        repo = bzrdir.BzrDir.create_repository(self.get_url('child'),

                                               format=format)

        self.assertTrue(isinstance(repo, repository.Repository))

        self.assertTrue(repo.bzrdir.root_transport.base.endswith('child/'))

    def test_create_branch_and_repo_uses_default(self):

        format = SampleBzrDirFormat()

        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url(), 

                                                      format=format)

        self.assertTrue(isinstance(branch, SampleBranch))

    def test_create_branch_and_repo_under_shared(self):

        # creating a branch and repo in a shared repo uses the

        # shared repository

        format = bzrdir.format_registry.make_bzrdir('knit')

        self.make_repository('.', shared=True, format=format)

        branch = bzrdir.BzrDir.create_branch_and_repo(

            self.get_url('child'), format=format)

        self.assertRaises(errors.NoRepositoryPresent,

                          branch.bzrdir.open_repository)

    def test_create_branch_and_repo_under_shared_force_new(self):

        # creating a branch and repo in a shared repo can be forced to 

        # make a new repo

        format = bzrdir.format_registry.make_bzrdir('knit')

        self.make_repository('.', shared=True, format=format)

        branch = bzrdir.BzrDir.create_branch_and_repo(self.get_url('child'),

                                                      force_new_repo=True,

                                                      format=format)

        branch.bzrdir.open_repository()

    def test_create_standalone_working_tree(self):

        format = SampleBzrDirFormat()

        # note this is deliberately readonly, as this failure should 

        # occur before any writes.

        self.assertRaises(errors.NotLocalUrl,

                          bzrdir.BzrDir.create_standalone_workingtree,

                          self.get_readonly_url(), format=format)

        tree = bzrdir.BzrDir.create_standalone_workingtree('.', 

                                                           format=format)

        self.assertEqual('A tree', tree)

    def test_create_standalone_working_tree_under_shared_repo(self):

        # create standalone working tree always makes a repo.

        format = bzrdir.format_registry.make_bzrdir('knit')

        self.make_repository('.', shared=True, format=format)

        # note this is deliberately readonly, as this failure should 

        # occur before any writes.

        self.assertRaises(errors.NotLocalUrl,

                          bzrdir.BzrDir.create_standalone_workingtree,

                          self.get_readonly_url('child'), format=format)

        tree = bzrdir.BzrDir.create_standalone_workingtree('child', 

            format=format)

        tree.bzrdir.open_repository()

    def test_create_branch_convenience(self):

        # outside a repo the default convenience output is a repo+branch_tree

        format = bzrdir.format_registry.make_bzrdir('knit')

        branch = bzrdir.BzrDir.create_branch_convenience('.', format=format)

        branch.bzrdir.open_workingtree()

        branch.bzrdir.open_repository()

    def test_create_branch_convenience_root(self):

        """Creating a branch at the root of a fs should work."""

        self.transport_server = MemoryServer

        # outside a repo the default convenience output is a repo+branch_tree

        format = bzrdir.format_registry.make_bzrdir('knit')

        branch = bzrdir.BzrDir.create_branch_convenience(self.get_url(), 

                                                         format=format)

        self.assertRaises(errors.NoWorkingTree,

                          branch.bzrdir.open_workingtree)

        branch.bzrdir.open_repository()

    def test_create_branch_convenience_under_shared_repo(self):

        # inside a repo the default convenience output is a branch+ follow the

        # repo tree policy

        format = bzrdir.format_registry.make_bzrdir('knit')

        self.make_repository('.', shared=True, format=format)

        branch = bzrdir.BzrDir.create_branch_convenience('child',

            format=format)

        branch.bzrdir.open_workingtree()

        self.assertRaises(errors.NoRepositoryPresent,

                          branch.bzrdir.open_repository)

    def test_create_branch_convenience_under_shared_repo_force_no_tree(self):

        # inside a repo the default convenience output is a branch+ follow the

        # repo tree policy but we can override that

        format = bzrdir.format_registry.make_bzrdir('knit')

        self.make_repository('.', shared=True, format=format)

        branch = bzrdir.BzrDir.create_branch_convenience('child',

            force_new_tree=False, format=format)

        self.assertRaises(errors.NoWorkingTree,

                          branch.bzrdir.open_workingtree)

        self.assertRaises(errors.NoRepositoryPresent,

                          branch.bzrdir.open_repository)

    def test_create_branch_convenience_under_shared_repo_no_tree_policy(self):

        # inside a repo the default convenience output is a branch+ follow the

        # repo tree policy

        format = bzrdir.format_registry.make_bzrdir('knit')

        repo = self.make_repository('.', shared=True, format=format)

        repo.set_make_working_trees(False)

        branch = bzrdir.BzrDir.create_branch_convenience('child', 

                                                         format=format)

        self.assertRaises(errors.NoWorkingTree,

                          branch.bzrdir.open_workingtree)

        self.assertRaises(errors.NoRepositoryPresent,

                          branch.bzrdir.open_repository)

    def test_create_branch_convenience_under_shared_repo_no_tree_policy_force_tree(self):

        # inside a repo the default convenience output is a branch+ follow the

        # repo tree policy but we can override that

        format = bzrdir.format_registry.make_bzrdir('knit')

        repo = self.make_repository('.', shared=True, format=format)

        repo.set_make_working_trees(False)

        branch = bzrdir.BzrDir.create_branch_convenience('child',

            force_new_tree=True, format=format)

        branch.bzrdir.open_workingtree()

        self.assertRaises(errors.NoRepositoryPresent,

                          branch.bzrdir.open_repository)

    def test_create_branch_convenience_under_shared_repo_force_new_repo(self):

        # inside a repo the default convenience output is overridable to give

        # repo+branch+tree

        format = bzrdir.format_registry.make_bzrdir('knit')

        self.make_repository('.', shared=True, format=format)

        branch = bzrdir.BzrDir.create_branch_convenience('child',

            force_new_repo=True, format=format)

        branch.bzrdir.open_repository()

        branch.bzrdir.open_workingtree()

class ChrootedTests(TestCaseWithTransport):

    """A support class that provides readonly urls outside the local namespace.

    This is done by checking if self.transport_server is a MemoryServer. if it

    is then we are chrooted already, if it is not then an HttpServer is used

    for readonly urls.

    """

    def setUp(self):

        super(ChrootedTests, self).setUp()

        if not self.transport_server == MemoryServer:

            self.transport_readonly_server = HttpServer

    def test_open_containing(self):

        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,

                          self.get_readonly_url(''))

        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing,

                          self.get_readonly_url('g/p/q'))

        control = bzrdir.BzrDir.create(self.get_url())

        branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url(''))

        self.assertEqual('', relpath)

        branch, relpath = bzrdir.BzrDir.open_containing(self.get_readonly_url('g/p/q'))

        self.assertEqual('g/p/q', relpath)

    def test_open_containing_from_transport(self):

        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,

                          get_transport(self.get_readonly_url('')))

        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_containing_from_transport,

                          get_transport(self.get_readonly_url('g/p/q')))

        control = bzrdir.BzrDir.create(self.get_url())

        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(

            get_transport(self.get_readonly_url('')))

        self.assertEqual('', relpath)

        branch, relpath = bzrdir.BzrDir.open_containing_from_transport(

            get_transport(self.get_readonly_url('g/p/q')))

        self.assertEqual('g/p/q', relpath)

    def test_open_containing_tree_or_branch(self):

        def local_branch_path(branch):

             return os.path.realpath(

                urlutils.local_path_from_url(branch.base))

        self.make_branch_and_tree('topdir')

        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(

            'topdir/foo')

        self.assertEqual(os.path.realpath('topdir'),

                         os.path.realpath(tree.basedir))

        self.assertEqual(os.path.realpath('topdir'),

                         local_branch_path(branch))

        self.assertIs(tree.bzrdir, branch.bzrdir)

        self.assertEqual('foo', relpath)

        self.make_branch('topdir/foo')

        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(

            'topdir/foo')

        self.assertIs(tree, None)

        self.assertEqual(os.path.realpath('topdir/foo'),

                         local_branch_path(branch))

        self.assertEqual('', relpath)

    def test_open_from_transport(self):

        # transport pointing at bzrdir should give a bzrdir with root transport

        # set to the given transport

        control = bzrdir.BzrDir.create(self.get_url())

        transport = get_transport(self.get_url())

        opened_bzrdir = bzrdir.BzrDir.open_from_transport(transport)

        self.assertEqual(transport.base, opened_bzrdir.root_transport.base)

        self.assertIsInstance(opened_bzrdir, bzrdir.BzrDir)

    def test_open_from_transport_no_bzrdir(self):

        transport = get_transport(self.get_url())

        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,

                          transport)

    def test_open_from_transport_bzrdir_in_parent(self):

        control = bzrdir.BzrDir.create(self.get_url())

        transport = get_transport(self.get_url())

        transport.mkdir('subdir')

        transport = transport.clone('subdir')

        self.assertRaises(NotBranchError, bzrdir.BzrDir.open_from_transport,

                          transport)

    def test_sprout_recursive(self):

        tree = self.make_branch_and_tree('tree1', format='experimental-knit3')

        sub_tree = self.make_branch_and_tree('tree1/subtree',

                                             format='experimental-knit3')

        tree.add_reference(sub_tree)

        self.build_tree(['tree1/subtree/file'])

        sub_tree.add('file')

        tree.commit('Initial commit')

        tree.bzrdir.sprout('tree2')

        self.failUnlessExists('tree2/subtree/file')

    def test_cloning_metadir(self):

        """Ensure that cloning metadir is suitable"""

        bzrdir = self.make_bzrdir('bzrdir')

        bzrdir.cloning_metadir()

        branch = self.make_branch('branch', format='knit')

        format = branch.bzrdir.cloning_metadir()

        self.assertIsInstance(format.workingtree_format,

        workingtree.WorkingTreeFormat3)

        branch2 = self.make_branch('branch2', format='experimental-knit3')

        format2 = branch2.bzrdir.cloning_metadir()

        self.assertIsInstance(format2.workingtree_format,

                              workingtree.WorkingTreeFormatAB1)

    def test_sprout_recursive_treeless(self):

        tree = self.make_branch_and_tree('tree1', format='experimental-knit3')

        sub_tree = self.make_branch_and_tree('tree1/subtree',

                                             format='experimental-knit3')

        tree.add_reference(sub_tree)

        self.build_tree(['tree1/subtree/file'])

        sub_tree.add('file')

        tree.commit('Initial commit')

        tree.bzrdir.destroy_workingtree()

        repo = self.make_repository('repo', shared=True,

                                    format='experimental-knit3')

        repo.set_make_working_trees(False)

        tree.bzrdir.sprout('repo/tree2')

        self.failUnlessExists('repo/tree2/subtree')

        self.failIfExists('repo/tree2/subtree/file')

class TestMeta1DirFormat(TestCaseWithTransport):

    """Tests specific to the meta1 dir format."""

    def test_right_base_dirs(self):

        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())

        t = dir.transport

        branch_base = t.clone('branch').base

        self.assertEqual(branch_base, dir.get_branch_transport(None).base)

        self.assertEqual(branch_base,

                         dir.get_branch_transport(bzrlib.branch.BzrBranchFormat5()).base)

        repository_base = t.clone('repository').base

        self.assertEqual(repository_base, dir.get_repository_transport(None).base)

        self.assertEqual(repository_base,

                         dir.get_repository_transport(weaverepo.RepositoryFormat7()).base)

        checkout_base = t.clone('checkout').base

        self.assertEqual(checkout_base, dir.get_workingtree_transport(None).base)

        self.assertEqual(checkout_base,

                         dir.get_workingtree_transport(workingtree.WorkingTreeFormat3()).base)

    def test_meta1dir_uses_lockdir(self):

        """Meta1 format uses a LockDir to guard the whole directory, not a file."""

        dir = bzrdir.BzrDirMetaFormat1().initialize(self.get_url())

        t = dir.transport

        self.assertIsDirectory('branch-lock', t)

    def test_comparison(self):

        """Equality and inequality behave properly.

        Metadirs should compare equal iff they have the same repo, branch and

        tree formats.

        """

        mydir = bzrdir.format_registry.make_bzrdir('knit')

        self.assertEqual(mydir, mydir)

        self.assertFalse(mydir != mydir)

        otherdir = bzrdir.format_registry.make_bzrdir('knit')

        self.assertEqual(otherdir, mydir)

        self.assertFalse(otherdir != mydir)

        otherdir2 = bzrdir.format_registry.make_bzrdir('experimental-knit2')

        self.assertNotEqual(otherdir2, mydir)

        self.assertFalse(otherdir2 == mydir)

class TestFormat5(TestCaseWithTransport):

    """Tests specific to the version 5 bzrdir format."""

    def test_same_lockfiles_between_tree_repo_branch(self):

        # this checks that only a single lockfiles instance is created 

        # for format 5 objects

        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())

        def check_dir_components_use_same_lock(dir):

            ctrl_1 = dir.open_repository().control_files

            ctrl_2 = dir.open_branch().control_files

            ctrl_3 = dir.open_workingtree()._control_files

            self.assertTrue(ctrl_1 is ctrl_2)

            self.assertTrue(ctrl_2 is ctrl_3)

        check_dir_components_use_same_lock(dir)

        # and if we open it normally.

        dir = bzrdir.BzrDir.open(self.get_url())

        check_dir_components_use_same_lock(dir)

    def test_can_convert(self):

        # format 5 dirs are convertable

        dir = bzrdir.BzrDirFormat5().initialize(self.get_url())

        self.assertTrue(dir.can_convert_format())

    def test_needs_conversion(self):

        # format 5 dirs need a conversion if they are not the default.

        # and they start of not the default.

        old_format = bzrdir.BzrDirFormat.get_default_format()

        bzrdir.BzrDirFormat._set_default_format(bzrdir.BzrDirFormat5())

        try:

            dir = bzrdir.BzrDirFormat5().initialize(self.get_url())

            self.assertFalse(dir.needs_format_conversion())

        finally:

            bzrdir.BzrDirFormat._set_default_format(old_format)

        self.assertTrue(dir.needs_format_conversion())

class TestFormat6(TestCaseWithTransport):

    """Tests specific to the version 6 bzrdir format."""

    def test_same_lockfiles_between_tree_repo_branch(self):

        # this checks that only a single lockfiles instance is created 

        # for format 6 objects

        dir = bzrdir.BzrDirFormat6().initialize(self.get_url())

        def check_dir_components_use_same_lock(dir):