/brz/remove-bazaar

# Copyright (C) 2006-2013, 2016 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 .. import (

    branch,

    bzr,

    config,

    controldir,

    errors,

    help_topics,

    lock,

    repository,

    revision as _mod_revision,

    osutils,

    transport as _mod_transport,

    urlutils,

    win32utils,

    )

from ..bzr import (

    branch as bzrbranch,

    bzrdir,

    remote,

    workingtree_3,

    workingtree_4,

    )

import breezy.branch

import breezy.bzr.branch

from ..bzr.fullhistory import BzrBranchFormat5

from ..errors import (

    NotBranchError,

    NoColocatedBranchSupport,

    UnknownFormatError,

    UnsupportedFormatError,

    )

from . import (

    TestCase,

    TestCaseWithMemoryTransport,

    TestCaseWithTransport,

    TestSkipped,

    )

from . import (

    http_server,

    http_utils,

    )

from ..transport import (

    memory,

    pathfilter,

    )

from ..transport.http import HttpTransport

from ..transport.nosmart import NoSmartTransportDecorator

from ..transport.readonly import ReadonlyTransportDecorator

from ..bzr import knitrepo, knitpack_repo

class TestDefaultFormat(TestCase):

    def test_get_set_default_format(self):

        old_format = bzrdir.BzrDirFormat.get_default_format()

        # default is BzrDirMetaFormat1

        self.assertIsInstance(old_format, bzrdir.BzrDirMetaFormat1)

        controldir.ControlDirFormat._set_default_format(SampleBzrDirFormat())

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

        try:

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

            self.assertIsInstance(result, SampleBzrDir)

        finally:

            controldir.ControlDirFormat._set_default_format(old_format)

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

class DeprecatedBzrDirFormat(bzrdir.BzrDirFormat):

    """A deprecated bzr dir format."""

class TestFormatRegistry(TestCase):

    def make_format_registry(self):

        my_format_registry = controldir.ControlDirFormatRegistry()

        my_format_registry.register('deprecated', DeprecatedBzrDirFormat,

                                    'Some format.  Slower and unawesome and deprecated.',

                                    deprecated=True)

        my_format_registry.register_lazy('lazy', 'breezy.tests.test_bzrdir',

                                         'DeprecatedBzrDirFormat', 'Format registered lazily',

                                         deprecated=True)

        bzr.register_metadir(my_format_registry, 'knit',

                             'breezy.bzr.knitrepo.RepositoryFormatKnit1',

                             'Format using knits',

                             )

        my_format_registry.set_default('knit')

        bzr.register_metadir(my_format_registry,

                             'branch6',

                             'breezy.bzr.knitrepo.RepositoryFormatKnit3',

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

                             branch_format='breezy.bzr.branch.BzrBranchFormat6',

                             experimental=True)

        bzr.register_metadir(my_format_registry,

                             'hidden format',

                             'breezy.bzr.knitrepo.RepositoryFormatKnit3',

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

                             branch_format='breezy.bzr.branch.BzrBranchFormat6', hidden=True)

        my_format_registry.register('hiddendeprecated', DeprecatedBzrDirFormat,

                                    'Old format.  Slower and does not support things. ', hidden=True)

        my_format_registry.register_lazy('hiddenlazy', 'breezy.tests.test_bzrdir',

                                         'DeprecatedBzrDirFormat', '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_controldir('lazy')

        self.assertIsInstance(my_bzrdir, DeprecatedBzrDirFormat)

        my_bzrdir = my_format_registry.make_controldir('deprecated')

        self.assertIsInstance(my_bzrdir, DeprecatedBzrDirFormat)

        my_bzrdir = my_format_registry.make_controldir('default')

        self.assertIsInstance(my_bzrdir.repository_format,

                              knitrepo.RepositoryFormatKnit1)

        my_bzrdir = my_format_registry.make_controldir('knit')

        self.assertIsInstance(my_bzrdir.repository_format,

                              knitrepo.RepositoryFormatKnit1)

        my_bzrdir = my_format_registry.make_controldir('branch6')

        self.assertIsInstance(my_bzrdir.get_branch_format(),

                              breezy.bzr.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('Some format.  Slower and unawesome and deprecated.',

                         my_format_registry.get_help('deprecated'))

    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 = controldir.format_registry.get('default')

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

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

        controldir.format_registry.set_default_repository(

            'dirstate-with-subtree')

        try:

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

                          controldir.format_registry.get('default'))

            self.assertIs(

                repository.format_registry.get_default().__class__,

                knitrepo.RepositoryFormatKnit3)

        finally:

            controldir.format_registry.set_default_repository(old_default)

    def test_aliases(self):

        a_registry = controldir.ControlDirFormatRegistry()

        a_registry.register('deprecated', DeprecatedBzrDirFormat,

                            'Old format.  Slower and does not support stuff',

                            deprecated=True)

        a_registry.register_alias('deprecatedalias', 'deprecated')

        self.assertEqual({'deprecatedalias': 'deprecated'},

                         a_registry.aliases())

class SampleBranch(breezy.branch.Branch):

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

    def __init__(self, dir):

        self.controldir = dir

class SampleRepository(breezy.repository.Repository):

    """A dummy repo."""

    def __init__(self, dir):

        self.controldir = dir

class SampleBzrDir(bzrdir.BzrDir):

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

    def create_repository(self, shared=False):

        """See ControlDir.create_repository."""

        return "A repository"

    def open_repository(self):

        """See ControlDir.open_repository."""

        return SampleRepository(self)

    def create_branch(self, name=None):

        """See ControlDir.create_branch."""

        if name is not None:

            raise NoColocatedBranchSupport(self)

        return SampleBranch(self)

    def create_workingtree(self):

        """See ControlDir.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 b"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."

    @classmethod

    def from_string(cls, format_string):

        return cls()

class BzrDirFormatTest1(bzrdir.BzrDirMetaFormat1):

    @staticmethod

    def get_format_string():

        return b"Test format 1"

class BzrDirFormatTest2(bzrdir.BzrDirMetaFormat1):

    @staticmethod

    def get_format_string():

        return b"Test format 2"

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.

        bzr.BzrProber.formats.register(BzrDirFormatTest1.get_format_string(),

                                       BzrDirFormatTest1())

        self.addCleanup(bzr.BzrProber.formats.remove,

                        BzrDirFormatTest1.get_format_string())

        bzr.BzrProber.formats.register(BzrDirFormatTest2.get_format_string(),

                                       BzrDirFormatTest2())

        self.addCleanup(bzr.BzrProber.formats.remove,

                        BzrDirFormatTest2.get_format_string())

        t = self.get_transport()

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

        def check_format(format, url):

            format.initialize(url)

            t = _mod_transport.get_transport_from_path(url)

            found_format = bzrdir.BzrDirFormat.find_format(t)

            self.assertIsInstance(found_format, format.__class__)

        check_format(BzrDirFormatTest1(), "foo")

        check_format(BzrDirFormatTest2(), "bar")

    def test_find_format_nothing_there(self):

        self.assertRaises(NotBranchError,

                          bzrdir.BzrDirFormat.find_format,

                          _mod_transport.get_transport_from_path('.'))

    def test_find_format_unknown_format(self):

        t = self.get_transport()

        t.mkdir('.bzr')

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

        self.assertRaises(UnknownFormatError,

                          bzrdir.BzrDirFormat.find_format,

                          _mod_transport.get_transport_from_path('.'))

    def test_find_format_line_endings(self):

        t = self.get_transport()

        t.mkdir('.bzr')

        t.put_bytes('.bzr/branch-format', b'Corrupt line endings\r\n')

        self.assertRaises(errors.LineEndingError,

                          bzrdir.BzrDirFormat.find_format,

                          _mod_transport.get_transport_from_path('.'))

    def test_register_unregister_format(self):

        format = SampleBzrDirFormat()

        url = self.get_url()

        # make a bzrdir

        format.initialize(url)

        # register a format for it.

        bzr.BzrProber.formats.register(format.get_format_string(), 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 = _mod_transport.get_transport_from_url(url)

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

        # unregister the format

        bzr.BzrProber.formats.remove(format.get_format_string())

        # 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 = controldir.format_registry.make_controldir('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.controldir.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 = controldir.format_registry.make_controldir('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.controldir.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 = controldir.format_registry.make_controldir('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.controldir.open_repository()

    def test_create_branch_convenience(self):

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

        format = controldir.format_registry.make_controldir('knit')

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

        branch.controldir.open_workingtree()

        branch.controldir.open_repository()

    def test_create_branch_convenience_possible_transports(self):

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

        format = controldir.format_registry.make_controldir('knit')

        t = self.get_transport()

        branch = bzrdir.BzrDir.create_branch_convenience(

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

        branch.controldir.open_workingtree()

        branch.controldir.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 = controldir.format_registry.make_controldir('knit')

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

                                                         format=format)

        self.assertRaises(errors.NoWorkingTree,

                          branch.controldir.open_workingtree)

        branch.controldir.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 = controldir.format_registry.make_controldir('knit')

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

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

                                                         format=format)

        branch.controldir.open_workingtree()

        self.assertRaises(errors.NoRepositoryPresent,

                          branch.controldir.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 = controldir.format_registry.make_controldir('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.controldir.open_workingtree)

        self.assertRaises(errors.NoRepositoryPresent,

                          branch.controldir.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 = controldir.format_registry.make_controldir('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.controldir.open_workingtree)

        self.assertRaises(errors.NoRepositoryPresent,

                          branch.controldir.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 = controldir.format_registry.make_controldir('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.controldir.open_workingtree()

        self.assertRaises(errors.NoRepositoryPresent,

                          branch.controldir.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 = controldir.format_registry.make_controldir('knit')

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

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

                                                         force_new_repo=True, format=format)

        branch.controldir.open_repository()

        branch.controldir.open_workingtree()

class TestRepositoryAcquisitionPolicy(TestCaseWithTransport):

    def test_acquire_repository_standalone(self):

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

        my_bzrdir = self.make_controldir('.')

        repo_policy = my_bzrdir.determine_repository_policy()

        repo, is_new = repo_policy.acquire_repository()

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

                         my_bzrdir.root_transport.base)

        self.assertFalse(repo.is_shared())

    def test_determine_stacking_policy(self):

        parent_bzrdir = self.make_controldir('.')

        child_bzrdir = self.make_controldir('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_controldir('.')

        child_bzrdir = self.make_controldir('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_controldir('.')

        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.controldir.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_controldir('source')

        knitpack_repo.RepositoryFormatKnitPack1().initialize(source_bzrdir)

        source_branch = breezy.bzr.branch.BzrBranchFormat7().initialize(

            source_bzrdir)

        # Make a directory with a default stacking policy

        parent_bzrdir = self.make_controldir('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_format_initialize_on_transport_ex_stacked_on(self):

        # trunk is a stackable format.  Note that its in the same server area

        # which is what launchpad does, but not sufficient to exercise the

        # general case.

        trunk = self.make_branch('trunk', format='1.9')

        t = self.get_transport('stacked')

        old_fmt = controldir.format_registry.make_controldir('pack-0.92')

        repo_name = old_fmt.repository_format.network_name()

        # Should end up with a 1.9 format (stackable)

        repo, control, require_stacking, repo_policy = \

            old_fmt.initialize_on_transport_ex(t,

                                               repo_format_name=repo_name, stacked_on='../trunk',

                                               stack_on_pwd=t.base)

        if repo is not None:

            # Repositories are open write-locked

            self.assertTrue(repo.is_write_locked())

            self.addCleanup(repo.unlock)

        else:

            repo = control.open_repository()

        self.assertIsInstance(control, bzrdir.BzrDir)

        opened = bzrdir.BzrDir.open(t.base)

        if not isinstance(old_fmt, remote.RemoteBzrDirFormat):

            self.assertEqual(control._format.network_name(),

                             old_fmt.network_name())

            self.assertEqual(control._format.network_name(),

                             opened._format.network_name())

        self.assertEqual(control.__class__, opened.__class__)

        self.assertLength(1, repo._fallback_repositories)

    def test_sprout_obeys_stacking_policy(self):

        child_branch, new_child_transport = self.prepare_default_stacking()