# (C) 2005,2006 Canonical Ltd # Authors: Robert Collins # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA from cStringIO import StringIO import os import bzrlib import bzrlib.branch from bzrlib.branch import Branch import bzrlib.bzrdir as bzrdir from bzrlib.bzrdir import BzrDir import bzrlib.errors as errors from bzrlib.errors import NotBranchError, NotVersionedError from bzrlib.osutils import pathjoin, getcwd, has_symlinks from bzrlib.tests import TestSkipped from bzrlib.tests.workingtree_implementations import TestCaseWithWorkingTree from bzrlib.trace import mutter import bzrlib.workingtree as workingtree from bzrlib.workingtree import (TreeEntry, TreeDirectory, TreeFile, TreeLink, WorkingTree) class TestWorkingTree(TestCaseWithWorkingTree): def test_listfiles(self): tree = self.make_branch_and_tree('.') os.mkdir('dir') print >> open('file', 'w'), "content" if has_symlinks(): os.symlink('target', 'symlink') files = list(tree.list_files()) 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_open_containing(self): branch = self.make_branch_and_tree('.').branch wt, relpath = WorkingTree.open_containing() self.assertEqual('', relpath) self.assertEqual(wt.basedir + '/', branch.base) wt, relpath = WorkingTree.open_containing(u'.') self.assertEqual('', relpath) self.assertEqual(wt.basedir + '/', branch.base) wt, relpath = WorkingTree.open_containing('./foo') self.assertEqual('foo', relpath) self.assertEqual(wt.basedir + '/', branch.base) wt, relpath = WorkingTree.open_containing('file://' + getcwd() + '/foo') self.assertEqual('foo', relpath) self.assertEqual(wt.basedir + '/', branch.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 get_pullable_trees(self): self.build_tree(['from/', 'from/file', 'to/']) tree = self.make_branch_and_tree('from') tree.add('file') tree.commit('foo', rev_id='A') tree_b = self.make_branch_and_tree('to') return tree, tree_b def test_pull(self): tree_a, tree_b = self.get_pullable_trees() tree_b.pull(tree_a.branch) self.failUnless(tree_b.branch.repository.has_revision('A')) self.assertEqual('A', tree_b.last_revision()) def test_pull_overwrites(self): tree_a, tree_b = self.get_pullable_trees() tree_b.commit('foo', rev_id='B') self.assertEqual(['B'], tree_b.branch.revision_history()) tree_b.pull(tree_a.branch, overwrite=True) self.failUnless(tree_b.branch.repository.has_revision('A')) self.failUnless(tree_b.branch.repository.has_revision('B')) self.assertEqual('A', tree_b.last_revision()) 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(NotVersionedError, 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~', '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~', 'new hello') def test_unknowns(self): tree = self.make_branch_and_tree('.') self.build_tree(['hello.txt', 'hello.txt~']) self.assertEquals(list(tree.unknowns()), ['hello.txt']) def test_hashcache(self): from bzrlib.tests.test_hashcache import pause tree = self.make_branch_and_tree('.') self.build_tree(['hello.txt', 'hello.txt~']) tree.add('hello.txt') pause() sha = tree.get_file_sha1(tree.path2id('hello.txt')) self.assertEqual(1, tree._hashcache.miss_count) tree2 = WorkingTree.open('.') sha2 = tree2.get_file_sha1(tree2.path2id('hello.txt')) self.assertEqual(0, tree2._hashcache.miss_count) self.assertEqual(1, tree2._hashcache.hit_count) def test_initialize(self): # initialize should create a working tree and branch in an existing dir t = self.make_branch_and_tree('.') b = 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) inv = b.repository.get_revision_inventory(revid) self.log('contents of inventory: %r' % inv.entries()) self.check_inventory_shape(inv, ['dir', 'dir/sub', 'dir/sub/file']) wt.rename_one('dir', 'newdir') self.check_inventory_shape(wt.read_working_inventory(), ['newdir', 'newdir/sub', 'newdir/sub/file']) wt.rename_one('newdir/sub', 'newdir/newsub') self.check_inventory_shape(wt.read_working_inventory(), ['newdir', 'newdir/newsub', 'newdir/newsub/file']) 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.last_revision(), wt.last_revision()) def test_last_revision(self): wt = self.make_branch_and_tree('source') self.assertEqual(None, wt.last_revision()) wt.commit('A', allow_pointless=True, rev_id='A') self.assertEqual('A', wt.last_revision()) def test_set_last_revision(self): wt = self.make_branch_and_tree('source') self.assertEqual(None, wt.last_revision()) # cannot set the last revision to one not in the branch history. self.assertRaises(errors.NoSuchRevision, wt.set_last_revision, 'A') wt.commit('A', allow_pointless=True, rev_id='A') self.assertEqual('A', wt.last_revision()) # None is aways in the branch wt.set_last_revision(None) self.assertEqual(None, wt.last_revision()) # 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. wt.branch.set_revision_history(['A', 'B']) wt.set_last_revision('A') self.assertEqual('A', wt.last_revision()) 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(None, wt.last_revision()) 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.last_revision()) self.assertEqual('A', wt.branch.last_revision()) def test_clone_and_commit_preserves_last_revision(self): 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().last_revision(), wt.last_revision()) 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_last_revision('B') tree = wt.basis_tree() self.failUnless(tree.has_filename('bar')) wt.set_last_revision('A') tree = wt.basis_tree() self.failUnless(tree.has_filename('foo')) 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.last_revision()) def test_commit_sets_last_revision(self): tree = self.make_branch_and_tree('tree') tree.commit('foo', rev_id='foo', allow_pointless=True) self.assertEqual('foo', tree.last_revision()) 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') bzrlib.branch.BranchReferenceFormat().initialize(checkout, 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.failUnlessExists('checkout/file') self.assertEqual('A', old_tree.last_revision()) 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') bzrlib.branch.BranchReferenceFormat().initialize(checkout, 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.last_revision())