/brz/remove-bazaar

# Copyright (C) 2006-2011 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

from cStringIO import StringIO

import errno

import os

from bzrlib import (

    branch,

    branchbuilder,

    bzrdir,

    errors,

    osutils,

    symbol_versioning,

    tests,

    urlutils,

    )

from bzrlib.errors import (

    UnsupportedOperation,

    PathsNotVersionedError,

    )

from bzrlib.inventory import Inventory

from bzrlib.osutils import pathjoin, getcwd, has_symlinks

from bzrlib.tests import TestSkipped, TestNotApplicable

from bzrlib.tests.per_workingtree import TestCaseWithWorkingTree

from bzrlib.workingtree import (

    TreeDirectory,

    TreeFile,

    TreeLink,

    InventoryWorkingTree,

    WorkingTree,

    )

from bzrlib.conflicts import ConflictList, TextConflict, ContentsConflict

class TestWorkingTree(TestCaseWithWorkingTree):

    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('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', 'file-id')

        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', 'file-id'),

                         result[0][:4])

    def test_open_containing(self):

        branch = self.make_branch_and_tree('.').branch

        local_base = urlutils.local_path_from_url(branch.base)

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

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

        file('hello.txt', 'w').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')

        file('hello.txt', 'w').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

        file('hello.txt', 'w').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('.')

        file('hello.txt', 'w').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.assertEquals(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.assertEquals(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.revision_history()[0]

        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 bzrlib.errors import NotVersionedError

        wt = self.make_branch_and_tree('.')

        self.build_tree(['foo/',

                         'foo/hello'])

        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 = StringIO()

        stderr = StringIO()

        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.bzrdir.clone('target')

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

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

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

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

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

        # None 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.

        try:

            self.applyDeprecated(symbol_versioning.deprecated_in((2, 4, 0)),

                wt.branch.set_revision_history, ['A', 'B'])

        except errors.NoSuchRevision, e:

            self.assertEqual('B', e.revision)

            raise TestSkipped("Branch format does not permit arbitrary"

                              " history")

        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.

        branch = self.make_branch('tree')

        try:

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

            branch.bzrdir.open_workingtree()

            return

        except errors.NoWorkingTree:

            pass

        wt = branch.bzrdir.create_workingtree()

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

        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.bzrdir.clone('target')

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

        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.bzrdir.transport.clone('..'))

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

        wt.commit('add deleted')

        wt.remove('deleted')

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

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

        cloned = cloned_dir.open_workingtree()

        cloned_transport = cloned.bzrdir.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', 'foo-id')

        wt.commit('A', rev_id='A')

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

        wt.commit('B', rev_id='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')

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

        source.commit('b', rev_id='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_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.

        main_branch = self.make_branch('tree')

        try:

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

            main_branch.bzrdir.open_workingtree()

            return

        except errors.NoWorkingTree:

            pass

        wt = main_branch.bzrdir.create_workingtree()

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

        branch.BranchReferenceFormat().initialize(checkout,

            target_branch=main_branch)

        old_tree = self.workingtree_format.initialize(checkout)

        # now commit to 'tree'

        wt.add('file')

        wt.commit('A', rev_id='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')

        wt.commit('A', rev_id='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.

        main_branch = self.make_branch('tree')

        try:

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

            main_branch.bzrdir.open_workingtree()

            return

        except errors.NoWorkingTree:

            pass

        wt = main_branch.bzrdir.create_workingtree()

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

        branch.BranchReferenceFormat().initialize(checkout,

            target_branch=main_branch)

        old_tree = self.workingtree_format.initialize(checkout)

        # now commit to 'tree'

        wt.add('file')

        wt.commit('A', rev_id='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 bzrlib.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')])

        this.add(['a', 'b'])

        this.commit(message='')

        base = this.bzrdir.clone('b2').open_workingtree()

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

        other = this.bzrdir.clone('b3').open_workingtree()

        self.build_tree_contents([('b3/a', 'c test\n'), ('b3/c', 'c test\n')])

        other.add('c')

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

        # Note: If we don't lock this before calling merge_inner, then we get a

        #       lock-contention failure. This probably indicates something

        #       weird going on inside merge_inner. Probably something about

        #       calling bt = this_tree.basis_tree() in one lock, and then

        #       locking both this_tree and bt separately, causing a dirstate

        #       locking race.

        this.lock_write()

        self.addCleanup(this.unlock)

        merge_inner(this.branch, other, base, this_tree=this)

        a = open('b1/a', 'rb')

        try:

            self.assertNotEqual(a.read(), 'a test\n')

        finally:

            a.close()

        this.revert()

        self.assertFileEqual('a test\n', 'b1/a')

        self.assertPathExists('b1/b.~1~')

        self.assertPathDoesNotExist('b1/c')

        self.assertPathDoesNotExist('b1/a.~1~')

        self.assertPathExists('b1/d')

    def test_update_updates_bound_branch_no_local_commits(self):

        # doing an update in a tree updates the branch its bound to too.

        master_tree = self.make_branch_and_tree('master')

        tree = self.make_branch_and_tree('tree')

        try:

            tree.branch.bind(master_tree.branch)

        except errors.UpgradeRequired:

            # legacy branches cannot bind

            return

        master_tree.commit('foo', rev_id='foo', allow_pointless=True)

        tree.update()

        self.assertEqual(['foo'], tree.get_parent_ids())

        self.assertEqual('foo', tree.branch.last_revision())

    def test_update_turns_local_commit_into_merge(self):

        # doing an update with a few local commits and no master commits

        # makes pending-merges.

        # this is done so that 'bzr update; bzr revert' will always produce

        # an exact copy of the 'logical branch' - the referenced branch for

        # a checkout, and the master for a bound branch.

        # its possible that we should instead have 'bzr update' when there

        # is nothing new on the master leave the current commits intact and

        # alter 'revert' to revert to the master always. But for now, its

        # good.

        master_tree = self.make_branch_and_tree('master')

        master_tip = master_tree.commit('first master commit')

        tree = self.make_branch_and_tree('tree')

        try:

            tree.branch.bind(master_tree.branch)

        except errors.UpgradeRequired:

            # legacy branches cannot bind

            return

        # sync with master

        tree.update()

        # work locally