/brz/remove-bazaar

# Copyright (C) 2006-2010 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

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

For interface contract tests, see tests/per_bzr_dir.

"""

import os

import subprocess

import sys

from bzrlib import (

    bzrdir,

    errors,

    help_topics,

    repository,

    osutils,

    remote,

    urlutils,

    win32utils,

    workingtree,

    )

import bzrlib.branch

from bzrlib.errors import (NotBranchError,

                           NoColocatedBranchSupport,

                           UnknownFormatError,

                           UnsupportedFormatError,

                           )

from bzrlib.tests import (

    TestCase,

    TestCaseWithMemoryTransport,

    TestCaseWithTransport,

    TestSkipped,

    )

from bzrlib.tests import(

    http_server,

    http_utils,

    )

from bzrlib.tests.test_http import TestWithTransport_pycurl

from bzrlib.transport import (

    get_transport,

    memory,

    pathfilter,

    )

from bzrlib.transport.http._urllib import HttpTransport_urllib

from bzrlib.transport.nosmart import NoSmartTransportDecorator

from bzrlib.transport.readonly import ReadonlyTransportDecorator

from bzrlib.repofmt import knitrepo, weaverepo, pack_repo

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))

        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:

            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.set_default('knit')

        my_format_registry.register_metadir(

            'branch6',

            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',

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

            branch_format='bzrlib.branch.BzrBranchFormat6',

            experimental=True)

        my_format_registry.register_metadir(

            'hidden format',

            'bzrlib.repofmt.knitrepo.RepositoryFormatKnit3',

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

            branch_format='bzrlib.branch.BzrBranchFormat6', hidden=True)

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

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

            ' repositories', hidden=True)

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

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

            hidden=True)

        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('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()

        registry = self.make_format_registry()

        topics.register('current-formats', registry.help_topic,

                        'Current formats')

        topics.register('other-formats', registry.help_topic,

                        'Other formats')

        new = topics.get_detail('current-formats')

        rest = topics.get_detail('other-formats')

        experimental, deprecated = rest.split('Deprecated formats')

        self.assertContainsRe(new, 'formats-help')

        self.assertContainsRe(new,

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

        self.assertContainsRe(experimental,

                ':branch6:\n    \(native\) Experimental successor to knit')

        self.assertContainsRe(deprecated,

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

        self.assertNotContainsRe(new, 'hidden')

    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('dirstate-with-subtree')

        try:

            self.assertIs(bzrdir.format_registry.get('dirstate-with-subtree'),

                          bzrdir.format_registry.get('default'))

            self.assertIs(

                repository.RepositoryFormat.get_default_format().__class__,

                knitrepo.RepositoryFormatKnit3)

        finally:

            bzrdir.format_registry.set_default_repository(old_default)

    def test_aliases(self):

        a_registry = bzrdir.BzrDirFormatRegistry()

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

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

            ' repositories', deprecated=True)

        a_registry.register('weavealias', bzrdir.BzrDirFormat6,

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

            ' repositories', deprecated=True, alias=True)

        self.assertEqual(frozenset(['weavealias']), a_registry.aliases())

class SampleBranch(bzrlib.branch.Branch):

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

    def __init__(self, dir):

        self.bzrdir = dir

class SampleRepository(bzrlib.repository.Repository):

    """A dummy repo."""

    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 SampleRepository(self)

    def create_branch(self, name=None):

        """See BzrDir.create_branch."""

        if name is not None:

            raise NoColocatedBranchSupport(self)

        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_on_transport(self, t):

        """Create a bzr dir."""

        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_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_possible_transports(self):

        """Check that the optional 'possible_transports' is recognized"""

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

        t = self.get_transport()

        branch = bzrdir.BzrDir.create_branch_convenience(

            '.', format=format, possible_transports=[t])

        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.vfs_transport_factory = memory.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 TestRepositoryAcquisitionPolicy(TestCaseWithTransport):

    def test_acquire_repository_standalone(self):

        """The default acquisition policy should create a standalone branch."""

        my_bzrdir = self.make_bzrdir('.')

        repo_policy = my_bzrdir.determine_repository_policy()

        repo, is_new = repo_policy.acquire_repository()

        self.assertEqual(repo.bzrdir.root_transport.base,

                         my_bzrdir.root_transport.base)

        self.assertFalse(repo.is_shared())

    def test_determine_stacking_policy(self):

        parent_bzrdir = self.make_bzrdir('.')

        child_bzrdir = self.make_bzrdir('child')

        parent_bzrdir.get_config().set_default_stack_on('http://example.org')

        repo_policy = child_bzrdir.determine_repository_policy()

        self.assertEqual('http://example.org', repo_policy._stack_on)

    def test_determine_stacking_policy_relative(self):

        parent_bzrdir = self.make_bzrdir('.')

        child_bzrdir = self.make_bzrdir('child')

        parent_bzrdir.get_config().set_default_stack_on('child2')

        repo_policy = child_bzrdir.determine_repository_policy()

        self.assertEqual('child2', repo_policy._stack_on)

        self.assertEqual(parent_bzrdir.root_transport.base,

                         repo_policy._stack_on_pwd)

    def prepare_default_stacking(self, child_format='1.6'):

        parent_bzrdir = self.make_bzrdir('.')

        child_branch = self.make_branch('child', format=child_format)

        parent_bzrdir.get_config().set_default_stack_on(child_branch.base)

        new_child_transport = parent_bzrdir.transport.clone('child2')

        return child_branch, new_child_transport

    def test_clone_on_transport_obeys_stacking_policy(self):

        child_branch, new_child_transport = self.prepare_default_stacking()

        new_child = child_branch.bzrdir.clone_on_transport(new_child_transport)

        self.assertEqual(child_branch.base,

                         new_child.open_branch().get_stacked_on_url())

    def test_default_stacking_with_stackable_branch_unstackable_repo(self):

        # Make stackable source branch with an unstackable repo format.

        source_bzrdir = self.make_bzrdir('source')

        pack_repo.RepositoryFormatKnitPack1().initialize(source_bzrdir)

        source_branch = bzrlib.branch.BzrBranchFormat7().initialize(

            source_bzrdir)

        # Make a directory with a default stacking policy

        parent_bzrdir = self.make_bzrdir('parent')

        stacked_on = self.make_branch('parent/stacked-on', format='pack-0.92')

        parent_bzrdir.get_config().set_default_stack_on(stacked_on.base)

        # Clone source into directory

        target = source_bzrdir.clone(self.get_url('parent/target'))

    def test_sprout_obeys_stacking_policy(self):

        child_branch, new_child_transport = self.prepare_default_stacking()

        new_child = child_branch.bzrdir.sprout(new_child_transport.base)

        self.assertEqual(child_branch.base,

                         new_child.open_branch().get_stacked_on_url())

    def test_clone_ignores_policy_for_unsupported_formats(self):

        child_branch, new_child_transport = self.prepare_default_stacking(

            child_format='pack-0.92')

        new_child = child_branch.bzrdir.clone_on_transport(new_child_transport)

        self.assertRaises(errors.UnstackableBranchFormat,

                          new_child.open_branch().get_stacked_on_url)

    def test_sprout_ignores_policy_for_unsupported_formats(self):

        child_branch, new_child_transport = self.prepare_default_stacking(

            child_format='pack-0.92')

        new_child = child_branch.bzrdir.sprout(new_child_transport.base)

        self.assertRaises(errors.UnstackableBranchFormat,

                          new_child.open_branch().get_stacked_on_url)

    def test_sprout_upgrades_format_if_stacked_specified(self):

        child_branch, new_child_transport = self.prepare_default_stacking(

            child_format='pack-0.92')

        new_child = child_branch.bzrdir.sprout(new_child_transport.base,

                                               stacked=True)

        self.assertEqual(child_branch.bzrdir.root_transport.base,

                         new_child.open_branch().get_stacked_on_url())

        repo = new_child.open_repository()

        self.assertTrue(repo._format.supports_external_lookups)

        self.assertFalse(repo.supports_rich_root())

    def test_clone_on_transport_upgrades_format_if_stacked_on_specified(self):

        child_branch, new_child_transport = self.prepare_default_stacking(

            child_format='pack-0.92')

        new_child = child_branch.bzrdir.clone_on_transport(new_child_transport,

            stacked_on=child_branch.bzrdir.root_transport.base)

        self.assertEqual(child_branch.bzrdir.root_transport.base,

                         new_child.open_branch().get_stacked_on_url())

        repo = new_child.open_repository()

        self.assertTrue(repo._format.supports_external_lookups)

        self.assertFalse(repo.supports_rich_root())

    def test_sprout_upgrades_to_rich_root_format_if_needed(self):

        child_branch, new_child_transport = self.prepare_default_stacking(

            child_format='rich-root-pack')

        new_child = child_branch.bzrdir.sprout(new_child_transport.base,

                                               stacked=True)

        repo = new_child.open_repository()

        self.assertTrue(repo._format.supports_external_lookups)

        self.assertTrue(repo.supports_rich_root())

    def test_add_fallback_repo_handles_absolute_urls(self):

        stack_on = self.make_branch('stack_on', format='1.6')

        repo = self.make_repository('repo', format='1.6')

        policy = bzrdir.UseExistingRepository(repo, stack_on.base)

        policy._add_fallback(repo)

    def test_add_fallback_repo_handles_relative_urls(self):

        stack_on = self.make_branch('stack_on', format='1.6')

        repo = self.make_repository('repo', format='1.6')

        policy = bzrdir.UseExistingRepository(repo, '.', stack_on.base)

        policy._add_fallback(repo)

    def test_configure_relative_branch_stacking_url(self):

        stack_on = self.make_branch('stack_on', format='1.6')

        stacked = self.make_branch('stack_on/stacked', format='1.6')

        policy = bzrdir.UseExistingRepository(stacked.repository,

            '.', stack_on.base)

        policy.configure_branch(stacked)

        self.assertEqual('..', stacked.get_stacked_on_url())

    def test_relative_branch_stacking_to_absolute(self):

        stack_on = self.make_branch('stack_on', format='1.6')

        stacked = self.make_branch('stack_on/stacked', format='1.6')

        policy = bzrdir.UseExistingRepository(stacked.repository,

            '.', self.get_readonly_url('stack_on'))

        policy.configure_branch(stacked)

        self.assertEqual(self.get_readonly_url('stack_on'),

                         stacked.get_stacked_on_url())

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.vfs_transport_factory == memory.MemoryServer:

            self.transport_readonly_server = http_server.HttpServer

    def local_branch_path(self, branch):

         return os.path.realpath(urlutils.local_path_from_url(branch.base))

    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)