# Copyright (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 from bzrlib import dirstate, ignores import bzrlib from bzrlib.branch import Branch from bzrlib import bzrdir, conflicts, errors, workingtree from bzrlib.bzrdir import BzrDir from bzrlib.errors import NotBranchError, NotVersionedError from bzrlib.lockdir import LockDir from bzrlib.mutabletree import needs_tree_write_lock from bzrlib.osutils import pathjoin, getcwd, has_symlinks from bzrlib.symbol_versioning import zero_thirteen from bzrlib.tests import TestCase, TestCaseWithTransport, TestSkipped from bzrlib.trace import mutter from bzrlib.transport import get_transport from bzrlib.workingtree import ( TreeEntry, TreeDirectory, TreeFile, TreeLink, WorkingTree, ) class TestTreeDirectory(TestCaseWithTransport): def test_kind_character(self): self.assertEqual(TreeDirectory().kind_character(), '/') class TestTreeEntry(TestCaseWithTransport): def test_kind_character(self): self.assertEqual(TreeEntry().kind_character(), '???') class TestTreeFile(TestCaseWithTransport): def test_kind_character(self): self.assertEqual(TreeFile().kind_character(), '') class TestTreeLink(TestCaseWithTransport): def test_kind_character(self): self.assertEqual(TreeLink().kind_character(), '') class TestDefaultFormat(TestCaseWithTransport): def test_get_set_default_format(self): old_format = workingtree.WorkingTreeFormat.get_default_format() # default is 3 self.assertTrue(isinstance(old_format, workingtree.WorkingTreeFormat3)) workingtree.WorkingTreeFormat.set_default_format(SampleTreeFormat()) try: # the default branch format is used by the meta dir format # which is not the default bzrdir format at this point dir = bzrdir.BzrDirMetaFormat1().initialize('.') dir.create_repository() dir.create_branch() result = dir.create_workingtree() self.assertEqual(result, 'A tree') finally: workingtree.WorkingTreeFormat.set_default_format(old_format) self.assertEqual(old_format, workingtree.WorkingTreeFormat.get_default_format()) class SampleTreeFormat(workingtree.WorkingTreeFormat): """A sample format this format is initializable, unsupported to aid in testing the open and open_downlevel routines. """ def get_format_string(self): """See WorkingTreeFormat.get_format_string().""" return "Sample tree format." def initialize(self, a_bzrdir, revision_id=None): """Sample branches cannot be created.""" t = a_bzrdir.get_workingtree_transport(self) t.put_bytes('format', self.get_format_string()) return 'A tree' def is_supported(self): return False def open(self, transport, _found=False): return "opened tree." class TestWorkingTreeFormat(TestCaseWithTransport): """Tests for the WorkingTreeFormat facility.""" def test_find_format(self): # is the right format object found for a working tree? # create a branch with a few known format objects. self.build_tree(["foo/", "bar/"]) def check_format(format, url): dir = format._matchingbzrdir.initialize(url) dir.create_repository() dir.create_branch() format.initialize(dir) t = get_transport(url) found_format = workingtree.WorkingTreeFormat.find_format(dir) self.failUnless(isinstance(found_format, format.__class__)) check_format(workingtree.WorkingTreeFormat3(), "bar") def test_find_format_no_tree(self): dir = bzrdir.BzrDirMetaFormat1().initialize('.') self.assertRaises(errors.NoWorkingTree, workingtree.WorkingTreeFormat.find_format, dir) def test_find_format_unknown_format(self): dir = bzrdir.BzrDirMetaFormat1().initialize('.') dir.create_repository() dir.create_branch() SampleTreeFormat().initialize(dir) self.assertRaises(errors.UnknownFormatError, workingtree.WorkingTreeFormat.find_format, dir) def test_register_unregister_format(self): format = SampleTreeFormat() # make a control dir dir = bzrdir.BzrDirMetaFormat1().initialize('.') dir.create_repository() dir.create_branch() # make a branch format.initialize(dir) # register a format for it. workingtree.WorkingTreeFormat.register_format(format) # which branch.Open will refuse (not supported) self.assertRaises(errors.UnsupportedFormatError, workingtree.WorkingTree.open, '.') # but open_downlevel will work self.assertEqual(format.open(dir), workingtree.WorkingTree.open_downlevel('.')) # unregister the format workingtree.WorkingTreeFormat.unregister_format(format) class TestWorkingTreeFormat3(TestCaseWithTransport): """Tests specific to WorkingTreeFormat3.""" def test_disk_layout(self): control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url()) control.create_repository() control.create_branch() tree = workingtree.WorkingTreeFormat3().initialize(control) # we want: # format 'Bazaar-NG Working Tree format 3' # inventory = blank inventory # pending-merges = '' # stat-cache = ?? # no inventory.basis yet t = control.get_workingtree_transport(None) self.assertEqualDiff('Bazaar-NG Working Tree format 3', t.get('format').read()) # self.assertContainsRe(t.get('inventory').read(), # '\n' # '\n', # ) # WorkingTreeFormat3 doesn't default to creating a unique root id, # because it is incompatible with older bzr versions self.assertContainsRe(t.get('inventory').read(), '\n' '\n', ) self.assertEqualDiff('### bzr hashcache v5\n', t.get('stat-cache').read()) self.assertFalse(t.has('inventory.basis')) # no last-revision file means 'None' or 'NULLREVISION' self.assertFalse(t.has('last-revision')) # TODO RBC 20060210 do a commit, check the inventory.basis is created # correctly and last-revision file becomes present. def test_uses_lockdir(self): """WorkingTreeFormat3 uses its own LockDir: - lock is a directory - when the WorkingTree is locked, LockDir can see that """ t = self.get_transport() url = self.get_url() dir = bzrdir.BzrDirMetaFormat1().initialize(url) repo = dir.create_repository() branch = dir.create_branch() try: tree = workingtree.WorkingTreeFormat3().initialize(dir) except errors.NotLocalUrl: raise TestSkipped('Not a local URL') self.assertIsDirectory('.bzr', t) self.assertIsDirectory('.bzr/checkout', t) self.assertIsDirectory('.bzr/checkout/lock', t) our_lock = LockDir(t, '.bzr/checkout/lock') self.assertEquals(our_lock.peek(), None) tree.lock_write() self.assertTrue(our_lock.peek()) tree.unlock() self.assertEquals(our_lock.peek(), None) def test_missing_pending_merges(self): control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url()) control.create_repository() control.create_branch() tree = workingtree.WorkingTreeFormat3().initialize(control) tree._control_files._transport.delete("pending-merges") self.assertEqual([], tree.get_parent_ids()) class TestWorkingTreeFormat4(TestCaseWithTransport): """Tests specific to WorkingTreeFormat4.""" def test_disk_layout(self): control = bzrdir.BzrDirMetaFormat1().initialize(self.get_url()) control.create_repository() control.create_branch() tree = workingtree.WorkingTreeFormat4().initialize(control) # we want: # format 'Bazaar Working Tree format 4' # stat-cache = ?? t = control.get_workingtree_transport(None) self.assertEqualDiff('Bazaar Working Tree format 4\n', t.get('format').read()) self.assertEqualDiff('### bzr hashcache v5\n', t.get('stat-cache').read()) self.assertFalse(t.has('inventory.basis')) # no last-revision file means 'None' or 'NULLREVISION' self.assertFalse(t.has('last-revision')) # TODO RBC 20060210 do a commit, check the inventory.basis is created # correctly and last-revision file becomes present. # manually make a dirstate toc check the format is as desired. state = dirstate.DirState.on_file(t.local_abspath('dirstate')) self.assertEqual([], state.get_parent_ids()) def test_uses_lockdir(self): """WorkingTreeFormat4 uses its own LockDir: - lock is a directory - when the WorkingTree is locked, LockDir can see that """ # this test could be factored into a subclass of tests common to both # format 3 and 4, but for now its not much of an issue as there is only one in common. t = self.get_transport() tree = self.make_workingtree() self.assertIsDirectory('.bzr', t) self.assertIsDirectory('.bzr/checkout', t) self.assertIsDirectory('.bzr/checkout/lock', t) our_lock = LockDir(t, '.bzr/checkout/lock') self.assertEquals(our_lock.peek(), None) tree.lock_write() self.assertTrue(our_lock.peek()) tree.unlock() self.assertEquals(our_lock.peek(), None) def make_workingtree(self): url = self.get_url() dir = bzrdir.BzrDirMetaFormat1().initialize(url) repo = dir.create_repository() branch = dir.create_branch() try: return workingtree.WorkingTreeFormat4().initialize(dir) except errors.NotLocalUrl: raise TestSkipped('Not a local URL') # TODO: test that dirstate also stores & retrieves the parent list of # workingtree-parent revisions, including when they have multiple parents. # (in other words, the case when we're constructing a merge of # revisions which are themselves merges.) # The simplest case is that the the workingtree's primary # parent tree can be retrieved. This is required for all WorkingTrees, # and covered by the generic tests. def test_dirstate_stores_all_parent_inventories(self): tree = self.make_workingtree() # We're going to build in tree a working tree # with three parent trees, with some files in common. # We really don't want to do commit or merge in the new dirstate-based # tree, because that might not work yet. So instead we build # revisions elsewhere and pull them across, doing by hand part of the # work that merge would do. subtree = self.make_branch_and_tree('subdir') # writelock the tree so its repository doesn't get readlocked by # the revision tree locks. This works around the bug where we dont # permit lock upgrading. subtree.lock_write() self.addCleanup(subtree.unlock) self.build_tree(['subdir/file-a',]) subtree.add(['file-a'], ['id-a']) rev1 = subtree.commit('commit in subdir') rev1_tree = subtree.basis_tree() rev1_tree.lock_read() self.addCleanup(rev1_tree.unlock) subtree2 = subtree.bzrdir.sprout('subdir2').open_workingtree() self.build_tree(['subdir2/file-b']) subtree2.add(['file-b'], ['id-b']) rev2 = subtree2.commit('commit in subdir2') rev2_tree = subtree2.basis_tree() rev2_tree.lock_read() self.addCleanup(rev2_tree.unlock) subtree.merge_from_branch(subtree2.branch) rev3 = subtree.commit('merge from subdir2') rev3_tree = subtree.basis_tree() rev3_tree.lock_read() self.addCleanup(rev3_tree.unlock) repo = tree.branch.repository repo.fetch(subtree.branch.repository, rev3) # will also pull the others... # tree doesn't contain a text merge yet but we'll just # set the parents as if a merge had taken place. # this should cause the tree data to be folded into the # dirstate. tree.set_parent_trees([ (rev1, rev1_tree), (rev2, rev2_tree), (rev3, rev3_tree), ]) # now we should be able to get them back out self.assertTreesEqual(tree.revision_tree(rev1), rev1_tree) self.assertTreesEqual(tree.revision_tree(rev2), rev2_tree) self.assertTreesEqual(tree.revision_tree(rev3), rev3_tree) def test_dirstate_doesnt_read_parents_from_repo_when_setting(self): """Setting parent trees on a dirstate working tree takes the trees it's given and doesn't need to read them from the repository. """ tree = self.make_workingtree() subtree = self.make_branch_and_tree('subdir') rev1 = subtree.commit('commit in subdir') rev1_tree = subtree.basis_tree() rev1_tree.lock_read() self.addCleanup(rev1_tree.unlock) tree.branch.pull(subtree.branch) # break the repository's legs to make sure it only uses the trees # it's given; any calls to forbidden methods will raise an # AssertionError repo = tree.branch.repository repo.get_revision = self.fail repo.get_inventory = self.fail repo.get_inventory_xml = self.fail # try to set the parent trees. tree.set_parent_trees([(rev1, rev1_tree)]) def test_dirstate_doesnt_read_from_repo_when_returning_cache_tree(self): """Getting parent trees from a dirstate tree does not read from the repos inventory store. This is an important part of the dirstate performance optimisation work. """ tree = self.make_workingtree() subtree = self.make_branch_and_tree('subdir') # writelock the tree so its repository doesn't get readlocked by # the revision tree locks. This works around the bug where we dont # permit lock upgrading. subtree.lock_write() self.addCleanup(subtree.unlock) rev1 = subtree.commit('commit in subdir') rev1_tree = subtree.basis_tree() rev1_tree.lock_read() self.addCleanup(rev1_tree.unlock) rev2 = subtree.commit('second commit in subdir', allow_pointless=True) rev2_tree = subtree.basis_tree() rev2_tree.lock_read() self.addCleanup(rev2_tree.unlock) tree.branch.pull(subtree.branch) # break the repository's legs to make sure it only uses the trees # it's given; any calls to forbidden methods will raise an # AssertionError repo = tree.branch.repository # dont uncomment this: the revision object must be accessed to # answer 'get_parent_ids' for the revision tree- dirstate does not # cache the parents of a parent tree at this point. #repo.get_revision = self.fail repo.get_inventory = self.fail repo.get_inventory_xml = self.fail # set the parent trees. tree.set_parent_trees([(rev1, rev1_tree), (rev2, rev2_tree)]) # read the first tree result_rev1_tree = tree.revision_tree(rev1) # read the second result_rev2_tree = tree.revision_tree(rev2) # compare - there should be no differences between the handed and # returned trees self.assertTreesEqual(rev1_tree, result_rev1_tree) self.assertTreesEqual(rev2_tree, result_rev2_tree) def test_dirstate_doesnt_cache_non_parent_trees(self): """Getting parent trees from a dirstate tree does not read from the repos inventory store. This is an important part of the dirstate performance optimisation work. """ tree = self.make_workingtree() # make a tree that we can try for, which is able to be returned but # must not be subtree = self.make_branch_and_tree('subdir') rev1 = subtree.commit('commit in subdir') tree.branch.pull(subtree.branch) # check it fails self.assertRaises(errors.NoSuchRevision, tree.revision_tree, rev1) def test_no_dirstate_outside_lock(self): # temporary test until the code is mature enough to test from outside. """Getting a dirstate object fails if there is no lock.""" def lock_and_call_current_dirstate(tree, lock_method): getattr(tree, lock_method)() tree.current_dirstate() tree.unlock() tree = self.make_workingtree() self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate) lock_and_call_current_dirstate(tree, 'lock_read') self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate) lock_and_call_current_dirstate(tree, 'lock_write') self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate) lock_and_call_current_dirstate(tree, 'lock_tree_write') self.assertRaises(errors.ObjectNotLocked, tree.current_dirstate) def test_new_dirstate_on_new_lock(self): # until we have detection for when a dirstate can be reused, we # want to reparse dirstate on every new lock. known_dirstates = set() def lock_and_compare_all_current_dirstate(tree, lock_method): getattr(tree, lock_method)() state = tree.current_dirstate() self.assertFalse(state in known_dirstates) known_dirstates.add(state) tree.unlock() tree = self.make_workingtree() # lock twice with each type to prevent silly per-lock-type bugs. # each lock and compare looks for a unique state object. lock_and_compare_all_current_dirstate(tree, 'lock_read') lock_and_compare_all_current_dirstate(tree, 'lock_read') lock_and_compare_all_current_dirstate(tree, 'lock_tree_write') lock_and_compare_all_current_dirstate(tree, 'lock_tree_write') lock_and_compare_all_current_dirstate(tree, 'lock_write') lock_and_compare_all_current_dirstate(tree, 'lock_write') class TestFormat2WorkingTree(TestCaseWithTransport): """Tests that are specific to format 2 trees.""" def create_format2_tree(self, url): return self.make_branch_and_tree( url, format=bzrlib.bzrdir.BzrDirFormat6()) def test_conflicts(self): # test backwards compatability tree = self.create_format2_tree('.') self.assertRaises(errors.UnsupportedOperation, tree.set_conflicts, None) file('lala.BASE', 'wb').write('labase') expected = conflicts.ContentsConflict('lala') self.assertEqual(list(tree.conflicts()), [expected]) file('lala', 'wb').write('la') tree.add('lala', 'lala-id') expected = conflicts.ContentsConflict('lala', file_id='lala-id') self.assertEqual(list(tree.conflicts()), [expected]) file('lala.THIS', 'wb').write('lathis') file('lala.OTHER', 'wb').write('laother') # When "text conflict"s happen, stem, THIS and OTHER are text expected = conflicts.TextConflict('lala', file_id='lala-id') self.assertEqual(list(tree.conflicts()), [expected]) os.unlink('lala.OTHER') os.mkdir('lala.OTHER') expected = conflicts.ContentsConflict('lala', file_id='lala-id') self.assertEqual(list(tree.conflicts()), [expected]) class TestNonFormatSpecificCode(TestCaseWithTransport): """This class contains tests of workingtree that are not format specific.""" def test_gen_file_id(self): file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_file_id, 'filename') self.assertStartsWith(file_id, 'filename-') def test_gen_root_id(self): file_id = self.applyDeprecated(zero_thirteen, workingtree.gen_root_id) self.assertStartsWith(file_id, 'tree_root-') class InstrumentedTree(object): """A instrumented tree to check the needs_tree_write_lock decorator.""" def __init__(self): self._locks = [] def lock_tree_write(self): self._locks.append('t') @needs_tree_write_lock def method_with_tree_write_lock(self, *args, **kwargs): """A lock_tree_write decorated method that returns its arguments.""" return args, kwargs @needs_tree_write_lock def method_that_raises(self): """This method causes an exception when called with parameters. This allows the decorator code to be checked - it should still call unlock. """ def unlock(self): self._locks.append('u') class TestInstrumentedTree(TestCase): def test_needs_tree_write_lock(self): """@needs_tree_write_lock should be semantically transparent.""" tree = InstrumentedTree() self.assertEqual( 'method_with_tree_write_lock', tree.method_with_tree_write_lock.__name__) self.assertEqual( "A lock_tree_write decorated method that returns its arguments.", tree.method_with_tree_write_lock.__doc__) args = (1, 2, 3) kwargs = {'a':'b'} result = tree.method_with_tree_write_lock(1,2,3, a='b') self.assertEqual((args, kwargs), result) self.assertEqual(['t', 'u'], tree._locks) self.assertRaises(TypeError, tree.method_that_raises, 'foo') self.assertEqual(['t', 'u', 't', 'u'], tree._locks)