/brz/remove-bazaar

# Copyright (C) 2006-2012, 2016 Canonical Ltd

# Authors:  Robert Collins <robert.collins@canonical.com>

#           and others

#

# 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

import errno

import os

from ... import (

    branch,

    config,

    controldir,

    errors,

    osutils,

    revision as _mod_revision,

    tests,

    trace,

    urlutils,

    )

from...bzr import (

    bzrdir,

    )

from ...errors import (

    UnsupportedOperation,

    PathsNotVersionedError,

    )

from ...bzr.inventory import Inventory

from ...mutabletree import MutableTree

from ...osutils import pathjoin, getcwd, has_symlinks

from ...sixish import (

    BytesIO,

    )

from .. import (

    features,

    TestSkipped,

    TestNotApplicable,

    )

from .  import TestCaseWithWorkingTree

from ...bzr.workingtree import (

    InventoryWorkingTree,

    )

from ...workingtree import (

    TreeDirectory,

    TreeFile,

    TreeLink,

    WorkingTree,

    )

from ...conflicts import ConflictList, TextConflict, ContentsConflict

class TestWorkingTree(TestCaseWithWorkingTree):

    def requireBranchReference(self):

        test_branch = self.make_branch('test-branch')

        try:

            # if there is a working tree now, this is not supported.

            test_branch.controldir.open_workingtree()

            raise TestNotApplicable("only on trees that can be separate"

                " from their branch.")

        except (errors.NoWorkingTree, errors.NotLocalUrl):

            pass

    def test_branch_builder(self):

        # Just a smoke test that we get a branch at the specified relpath

        builder = self.make_branch_builder('foobar')

        br = branch.Branch.open(self.get_url('foobar'))

    def test_list_files(self):

        tree = self.make_branch_and_tree('.')

        self.build_tree(['dir/', 'file'])

        if has_symlinks():

            os.symlink('target', 'symlink')

        tree.lock_read()

        files = list(tree.list_files())

        tree.unlock()

        self.assertEqual(files[0], ('dir', '?', 'directory', None, TreeDirectory()))

        self.assertEqual(files[1], ('file', '?', 'file', None, TreeFile()))

        if has_symlinks():

            self.assertEqual(files[2], ('symlink', '?', 'symlink', None, TreeLink()))

    def test_list_files_sorted(self):

        tree = self.make_branch_and_tree('.')

        self.build_tree(['dir/', 'file', 'dir/file', 'dir/b',

                         'dir/subdir/', 'a', 'dir/subfile',

                         'zz_dir/', 'zz_dir/subfile'])

        tree.lock_read()

        files = [(path, kind) for (path, v, kind, file_id, entry)

                               in tree.list_files()]

        tree.unlock()

        self.assertEqual([

            ('a', 'file'),

            ('dir', 'directory'),

            ('file', 'file'),

            ('zz_dir', 'directory'),

            ], files)

        tree.add(['dir', 'zz_dir'])

        tree.lock_read()

        files = [(path, kind) for (path, v, kind, file_id, entry)

                               in tree.list_files()]

        tree.unlock()

        self.assertEqual([

            ('a', 'file'),

            ('dir', 'directory'),

            ('dir/b', 'file'),

            ('dir/file', 'file'),

            ('dir/subdir', 'directory'),

            ('dir/subfile', 'file'),

            ('file', 'file'),

            ('zz_dir', 'directory'),

            ('zz_dir/subfile', 'file'),

            ], files)

    def test_list_files_kind_change(self):

        tree = self.make_branch_and_tree('tree')

        self.build_tree(['tree/filename'])

        tree.add('filename')

        os.unlink('tree/filename')

        self.build_tree(['tree/filename/'])

        tree.lock_read()

        self.addCleanup(tree.unlock)

        result = list(tree.list_files())

        self.assertEqual(1, len(result))

        self.assertEqual(

                ('filename', 'V', 'directory', tree.path2id('filename')),

                result[0][:4])

    def test_get_config_stack(self):

        # Smoke test that all working trees succeed getting a config

        wt = self.make_branch_and_tree('.')

        conf = wt.get_config_stack()

        self.assertIsInstance(conf, config.Stack)

    def test_open_containing(self):

        local_wt = self.make_branch_and_tree('.')

        local_url = local_wt.controldir.root_transport.base

        local_base = urlutils.local_path_from_url(local_url)

        del local_wt

        # Empty opens '.'

        wt, relpath = WorkingTree.open_containing()

        self.assertEqual('', relpath)

        self.assertEqual(wt.basedir + '/', local_base)

        # '.' opens this dir

        wt, relpath = WorkingTree.open_containing(u'.')

        self.assertEqual('', relpath)

        self.assertEqual(wt.basedir + '/', local_base)

        # './foo' finds '.' and a relpath of 'foo'

        wt, relpath = WorkingTree.open_containing('./foo')

        self.assertEqual('foo', relpath)

        self.assertEqual(wt.basedir + '/', local_base)

        # abspath(foo) finds '.' and relpath of 'foo'

        wt, relpath = WorkingTree.open_containing('./foo')

        wt, relpath = WorkingTree.open_containing(getcwd() + '/foo')

        self.assertEqual('foo', relpath)

        self.assertEqual(wt.basedir + '/', local_base)

        # can even be a url: finds '.' and relpath of 'foo'

        wt, relpath = WorkingTree.open_containing('./foo')

        wt, relpath = WorkingTree.open_containing(

                    urlutils.local_path_to_url(getcwd() + '/foo'))

        self.assertEqual('foo', relpath)

        self.assertEqual(wt.basedir + '/', local_base)

    def test_basic_relpath(self):

        # for comprehensive relpath tests, see whitebox.py.

        tree = self.make_branch_and_tree('.')

        self.assertEqual('child',

                         tree.relpath(pathjoin(getcwd(), 'child')))

    def test_lock_locks_branch(self):

        tree = self.make_branch_and_tree('.')

        self.assertEqual(None, tree.branch.peek_lock_mode())

        tree.lock_read()

        self.assertEqual('r', tree.branch.peek_lock_mode())

        tree.unlock()

        self.assertEqual(None, tree.branch.peek_lock_mode())

        tree.lock_write()

        self.assertEqual('w', tree.branch.peek_lock_mode())

        tree.unlock()

        self.assertEqual(None, tree.branch.peek_lock_mode())

    def test_revert(self):

        """Test selected-file revert"""

        tree = self.make_branch_and_tree('.')

        self.build_tree(['hello.txt'])

        with file('hello.txt', 'w') as f: f.write('initial hello')

        self.assertRaises(PathsNotVersionedError,

                          tree.revert, ['hello.txt'])

        tree.add(['hello.txt'])

        tree.commit('create initial hello.txt')

        self.check_file_contents('hello.txt', 'initial hello')

        with file('hello.txt', 'w') as f: f.write('new hello')

        self.check_file_contents('hello.txt', 'new hello')

        # revert file modified since last revision

        tree.revert(['hello.txt'])

        self.check_file_contents('hello.txt', 'initial hello')

        self.check_file_contents('hello.txt.~1~', 'new hello')

        # reverting again does not clobber the backup

        tree.revert(['hello.txt'])

        self.check_file_contents('hello.txt', 'initial hello')

        self.check_file_contents('hello.txt.~1~', 'new hello')

        # backup files are numbered

        with file('hello.txt', 'w') as f: f.write('new hello2')

        tree.revert(['hello.txt'])

        self.check_file_contents('hello.txt', 'initial hello')

        self.check_file_contents('hello.txt.~1~', 'new hello')

        self.check_file_contents('hello.txt.~2~', 'new hello2')

    def test_revert_missing(self):

        # Revert a file that has been deleted since last commit

        tree = self.make_branch_and_tree('.')

        with file('hello.txt', 'w') as f: f.write('initial hello')

        tree.add('hello.txt')

        tree.commit('added hello.txt')

        os.unlink('hello.txt')

        tree.remove('hello.txt')

        tree.revert(['hello.txt'])

        self.assertPathExists('hello.txt')

    def test_versioned_files_not_unknown(self):

        tree = self.make_branch_and_tree('.')

        self.build_tree(['hello.txt'])

        tree.add('hello.txt')

        self.assertEqual(list(tree.unknowns()),

                          [])

    def test_unknowns(self):

        tree = self.make_branch_and_tree('.')

        self.build_tree(['hello.txt',

                         'hello.txt.~1~'])

        self.build_tree_contents([('.bzrignore', '*.~*\n')])

        tree.add('.bzrignore')

        self.assertEqual(list(tree.unknowns()),

                          ['hello.txt'])

    def test_initialize(self):

        # initialize should create a working tree and branch in an existing dir

        t = self.make_branch_and_tree('.')

        b = branch.Branch.open('.')

        self.assertEqual(t.branch.base, b.base)

        t2 = WorkingTree.open('.')

        self.assertEqual(t.basedir, t2.basedir)

        self.assertEqual(b.base, t2.branch.base)

        # TODO maybe we should check the branch format? not sure if its

        # appropriate here.

    def test_rename_dirs(self):

        """Test renaming directories and the files within them."""

        wt = self.make_branch_and_tree('.')

        b = wt.branch

        self.build_tree(['dir/', 'dir/sub/', 'dir/sub/file'])

        wt.add(['dir', 'dir/sub', 'dir/sub/file'])

        wt.commit('create initial state')

        revid = b.last_revision()

        self.log('first revision_id is {%s}' % revid)

        tree = b.repository.revision_tree(revid)

        self.log('contents of tree: %r' % list(tree.iter_entries_by_dir()))

        self.check_tree_shape(tree, ['dir/', 'dir/sub/', 'dir/sub/file'])

        wt.rename_one('dir', 'newdir')

        wt.lock_read()

        self.check_tree_shape(wt,

                                   ['newdir/', 'newdir/sub/', 'newdir/sub/file'])

        wt.unlock()

        wt.rename_one('newdir/sub', 'newdir/newsub')

        wt.lock_read()

        self.check_tree_shape(wt, ['newdir/', 'newdir/newsub/',

                                    'newdir/newsub/file'])

        wt.unlock()

    def test_add_in_unversioned(self):

        """Try to add a file in an unversioned directory.

        "bzr add" adds the parent as necessary, but simple working tree add

        doesn't do that.

        """

        from breezy.errors import NotVersionedError

        wt = self.make_branch_and_tree('.')

        self.build_tree(['foo/',

                         'foo/hello'])

        if not wt._format.supports_versioned_directories:

            wt.add('foo/hello')

        else:

            self.assertRaises(NotVersionedError,

                              wt.add,

                              'foo/hello')

    def test_add_missing(self):

        # adding a msising file -> NoSuchFile

        wt = self.make_branch_and_tree('.')

        self.assertRaises(errors.NoSuchFile, wt.add, 'fpp')

    def test_remove_verbose(self):

        #FIXME the remove api should not print or otherwise depend on the

        # text UI - RBC 20060124

        wt = self.make_branch_and_tree('.')

        self.build_tree(['hello'])

        wt.add(['hello'])

        wt.commit(message='add hello')

        stdout = BytesIO()

        stderr = BytesIO()

        self.assertEqual(None, self.apply_redirected(None, stdout, stderr,

                                                     wt.remove,

                                                     ['hello'],

                                                     verbose=True))

        self.assertEqual('?       hello\n', stdout.getvalue())

        self.assertEqual('', stderr.getvalue())

    def test_clone_trivial(self):

        wt = self.make_branch_and_tree('source')

        cloned_dir = wt.controldir.clone('target')

        cloned = cloned_dir.open_workingtree()

        self.assertEqual(cloned.get_parent_ids(), wt.get_parent_ids())

    def test_clone_empty(self):

        wt = self.make_branch_and_tree('source')

        cloned_dir = wt.controldir.clone('target', revision_id=_mod_revision.NULL_REVISION)

        cloned = cloned_dir.open_workingtree()

        self.assertEqual(cloned.get_parent_ids(), wt.get_parent_ids())

    def test_last_revision(self):

        wt = self.make_branch_and_tree('source')

        self.assertEqual([], wt.get_parent_ids())

        a = wt.commit('A', allow_pointless=True)

        parent_ids = wt.get_parent_ids()

        self.assertEqual([a], parent_ids)

        for parent_id in parent_ids:

            self.assertIsInstance(parent_id, str)

    def test_set_last_revision(self):

        wt = self.make_branch_and_tree('source')

        # set last-revision to one not in the history

        wt.set_last_revision('A')

        # set it back to None for an empty tree.

        wt.set_last_revision('null:')

        a = wt.commit('A', allow_pointless=True)

        self.assertEqual([a], wt.get_parent_ids())

        # null: is aways in the branch

        wt.set_last_revision('null:')

        self.assertEqual([], wt.get_parent_ids())

        # and now we can set it to 'A'

        # because some formats mutate the branch to set it on the tree

        # we need to alter the branch to let this pass.

        if getattr(wt.branch, "_set_revision_history", None) is None:

            raise TestSkipped("Branch format does not permit arbitrary"

                              " history")

        wt.branch._set_revision_history([a, 'B'])

        wt.set_last_revision(a)

        self.assertEqual([a], wt.get_parent_ids())

        self.assertRaises(errors.ReservedId, wt.set_last_revision, 'A:')

    def test_set_last_revision_different_to_branch(self):

        # working tree formats from the meta-dir format and newer support

        # setting the last revision on a tree independently of that on the

        # branch. Its concievable that some future formats may want to

        # couple them again (i.e. because its really a smart server and

        # the working tree will always match the branch). So we test

        # that formats where initialising a branch does not initialise a

        # tree - and thus have separable entities - support skewing the

        # two things.

        self.requireBranchReference()

        wt = self.make_branch_and_tree('tree')

        a = wt.commit('A', allow_pointless=True)

        wt.set_last_revision(None)

        self.assertEqual([], wt.get_parent_ids())

        self.assertEqual(a, wt.branch.last_revision())

        # and now we can set it back to 'A'

        wt.set_last_revision(a)

        self.assertEqual([a], wt.get_parent_ids())

        self.assertEqual(a, wt.branch.last_revision())

    def test_clone_and_commit_preserves_last_revision(self):

        """Doing a commit into a clone tree does not affect the source."""

        wt = self.make_branch_and_tree('source')

        cloned_dir = wt.controldir.clone('target')

        wt.commit('A', allow_pointless=True)

        self.assertNotEqual(cloned_dir.open_workingtree().get_parent_ids(),

                            wt.get_parent_ids())

    def test_clone_preserves_content(self):

        wt = self.make_branch_and_tree('source')

        self.build_tree(['added', 'deleted', 'notadded'],

                        transport=wt.controldir.transport.clone('..'))

        wt.add('deleted', 'deleted')

        wt.commit('add deleted')

        wt.remove('deleted')

        wt.add('added', 'added')

        cloned_dir = wt.controldir.clone('target')

        cloned = cloned_dir.open_workingtree()

        cloned_transport = cloned.controldir.transport.clone('..')

        self.assertFalse(cloned_transport.has('deleted'))

        self.assertTrue(cloned_transport.has('added'))

        self.assertFalse(cloned_transport.has('notadded'))

        self.assertEqual('added', cloned.path2id('added'))

        self.assertEqual(None, cloned.path2id('deleted'))

        self.assertEqual(None, cloned.path2id('notadded'))

    def test_basis_tree_returns_last_revision(self):

        wt = self.make_branch_and_tree('.')

        self.build_tree(['foo'])

        wt.add('foo')

        a = wt.commit('A')

        wt.rename_one('foo', 'bar')

        b = wt.commit('B')

        wt.set_parent_ids([b])

        tree = wt.basis_tree()

        tree.lock_read()

        self.assertTrue(tree.has_filename('bar'))

        tree.unlock()

        wt.set_parent_ids([a])

        tree = wt.basis_tree()

        tree.lock_read()

        self.assertTrue(tree.has_filename('foo'))

        tree.unlock()

    def test_clone_tree_revision(self):

        # make a tree with a last-revision,

        # and clone it with a different last-revision, this should switch

        # do it.

        #

        # also test that the content is merged

        # and conflicts recorded.

        # This should merge between the trees - local edits should be preserved

        # but other changes occured.

        # we test this by having one file that does

        # not change between two revisions, and another that does -

        # if the changed one is not changed, fail,

        # if the one that did not change has lost a local change, fail.

        #

        raise TestSkipped('revision limiting is not implemented yet.')

    def test_initialize_with_revision_id(self):

        # a bzrdir can construct a working tree for itself @ a specific revision.

        source = self.make_branch_and_tree('source')

        a = source.commit('a', allow_pointless=True)

        source.commit('b', allow_pointless=True)

        self.build_tree(['new/'])

        made_control = self.bzrdir_format.initialize('new')

        source.branch.repository.clone(made_control)

        source.branch.clone(made_control)

        made_tree = self.workingtree_format.initialize(made_control,

            revision_id=a)

        self.assertEqual([a], made_tree.get_parent_ids())

    def test_post_build_tree_hook(self):

        calls = []

        def track_post_build_tree(tree):

            calls.append(tree.last_revision())

        source = self.make_branch_and_tree('source')

        a = source.commit('a', allow_pointless=True)

        source.commit('b', allow_pointless=True)

        self.build_tree(['new/'])

        made_control = self.bzrdir_format.initialize('new')

        source.branch.repository.clone(made_control)

        source.branch.clone(made_control)

        MutableTree.hooks.install_named_hook("post_build_tree",

            track_post_build_tree, "Test")

        made_tree = self.workingtree_format.initialize(made_control,

            revision_id=a)

        self.assertEqual([a], calls)

    def test_update_sets_last_revision(self):

        # working tree formats from the meta-dir format and newer support

        # setting the last revision on a tree independently of that on the

        # branch. Its concievable that some future formats may want to

        # couple them again (i.e. because its really a smart server and

        # the working tree will always match the branch). So we test

        # that formats where initialising a branch does not initialise a

        # tree - and thus have separable entities - support skewing the

        # two things.

        self.requireBranchReference()

        wt = self.make_branch_and_tree('tree')

        # create an out of date working tree by making a checkout in this

        # current format

        self.build_tree(['checkout/', 'tree/file'])

        checkout = bzrdir.BzrDirMetaFormat1().initialize('checkout')

        checkout.set_branch_reference(wt.branch)

        old_tree = self.workingtree_format.initialize(checkout)

        # now commit to 'tree'

        wt.add('file')

        a = wt.commit('A')

        # and update old_tree

        self.assertEqual(0, old_tree.update())

        self.assertPathExists('checkout/file')

        self.assertEqual([a], old_tree.get_parent_ids())

    def test_update_sets_root_id(self):

        """Ensure tree root is set properly by update.

        Since empty trees don't have root_ids, but workingtrees do,

        an update of a checkout of revision 0 to a new revision,  should set

        the root id.

        """

        wt = self.make_branch_and_tree('tree')

        main_branch = wt.branch

        # create an out of date working tree by making a checkout in this

        # current format

        self.build_tree(['checkout/', 'tree/file'])

        checkout = main_branch.create_checkout('checkout')

        # now commit to 'tree'

        wt.add('file')

        a = wt.commit('A')

        # and update checkout

        self.assertEqual(0, checkout.update())

        self.assertPathExists('checkout/file')

        self.assertEqual(wt.get_root_id(), checkout.get_root_id())

        self.assertNotEqual(None, wt.get_root_id())

    def test_update_sets_updated_root_id(self):

        wt = self.make_branch_and_tree('tree')

        wt.set_root_id('first_root_id')

        self.assertEqual('first_root_id', wt.get_root_id())

        self.build_tree(['tree/file'])

        wt.add(['file'])

        wt.commit('first')

        co = wt.branch.create_checkout('checkout')

        wt.set_root_id('second_root_id')

        wt.commit('second')

        self.assertEqual('second_root_id', wt.get_root_id())

        self.assertEqual(0, co.update())

        self.assertEqual('second_root_id', co.get_root_id())

    def test_update_returns_conflict_count(self):

        # working tree formats from the meta-dir format and newer support

        # setting the last revision on a tree independently of that on the

        # branch. Its concievable that some future formats may want to

        # couple them again (i.e. because its really a smart server and

        # the working tree will always match the branch). So we test

        # that formats where initialising a branch does not initialise a

        # tree - and thus have separable entities - support skewing the

        # two things.

        self.requireBranchReference()

        wt = self.make_branch_and_tree('tree')

        # create an out of date working tree by making a checkout in this

        # current format

        self.build_tree(['checkout/', 'tree/file'])

        checkout = bzrdir.BzrDirMetaFormat1().initialize('checkout')

        checkout.set_branch_reference(wt.branch)

        old_tree = self.workingtree_format.initialize(checkout)

        # now commit to 'tree'

        wt.add('file')

        a = wt.commit('A')

        # and add a file file to the checkout

        self.build_tree(['checkout/file'])

        old_tree.add('file')

        # and update old_tree

        self.assertEqual(1, old_tree.update())

        self.assertEqual([a], old_tree.get_parent_ids())

    def test_merge_revert(self):

        from breezy.merge import merge_inner

        this = self.make_branch_and_tree('b1')

        self.build_tree_contents([('b1/a', 'a test\n'), ('b1/b', 'b test\n')])