# Copyright (C) 2006, 2007 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 InterTree.compare() function.""" import os import shutil from bzrlib import ( errors, mutabletree, tests, workingtree_4, ) from bzrlib.osutils import file_kind, has_symlinks from bzrlib.tests import TestNotApplicable from bzrlib.tests.per_intertree import TestCaseWithTwoTrees # TODO: test the include_root option. # TODO: test that renaming a directory x->y does not emit a rename for the # child x/a->y/a. # TODO: test that renaming a directory x-> does not emit a rename for the child # x/a -> y/a when a supplied_files argument gives either 'x/' or 'y/a' # -> that is, when the renamed parent is not processed by the function. # TODO: test items are only emitted once when a specific_files list names a dir # whose parent is now a child. # TODO: test comparisons between trees with different root ids. mbp 20070301 # # TODO: More comparisons between trees with subtrees in different states. # # TODO: Many tests start out by setting the tree roots ids the same, maybe # that should just be the default for these tests, by changing # make_branch_and_tree. mbp 20070307 class TestCompare(TestCaseWithTwoTrees): def test_compare_empty_trees(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_no_content(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare() self.assertEqual([], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_empty_to_abc_content(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare() self.assertEqual([('a', 'a-id', 'file'), ('b', 'b-id', 'directory'), ('b/c', 'c-id', 'file'), ], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_dangling(self): # This test depends on the ability for some trees to have a difference # between a 'versioned present' and 'versioned not present' (aka # dangling) file. In this test there are two trees each with a separate # dangling file, and the dangling files should be considered absent for # the test. tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['2/a']) tree2.add('a') os.unlink('2/a') self.build_tree(['1/b']) tree1.add('b') os.unlink('1/b') # the conversion to test trees here will leave the trees intact for the # default intertree, but may perform a commit for other tree types, # which may reduce the validity of the test. XXX: Think about how to # address this. tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare() self.assertEqual([], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_abc_content_to_empty(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_no_content(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare() self.assertEqual([], d.added) self.assertEqual([], d.modified) self.assertEqual([('a', 'a-id', 'file'), ('b', 'b-id', 'directory'), ('b/c', 'c-id', 'file'), ], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_content_modification(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_2(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare() self.assertEqual([], d.added) self.assertEqual([('a', 'a-id', 'file', True, False)], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_meta_modification(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_3(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare() self.assertEqual([], d.added) self.assertEqual([('b/c', 'c-id', 'file', False, True)], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_file_rename(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_4(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare() self.assertEqual([], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([('a', 'd', 'a-id', 'file', False, False)], d.renamed) self.assertEqual([], d.unchanged) def test_file_rename_and_modification(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_5(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare() self.assertEqual([], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([('a', 'd', 'a-id', 'file', True, False)], d.renamed) self.assertEqual([], d.unchanged) def test_file_rename_and_meta_modification(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_6(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare() self.assertEqual([], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([('b/c', 'e', 'c-id', 'file', False, True)], d.renamed) self.assertEqual([], d.unchanged) def test_empty_to_abc_content_a_only(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare(specific_files=['a']) self.assertEqual([('a', 'a-id', 'file')], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_empty_to_abc_content_a_and_c_only(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare( specific_files=['a', 'b/c']) self.assertEqual( [('a', 'a-id', 'file'), (u'b', 'b-id', 'directory'), ('b/c', 'c-id', 'file')], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_empty_to_abc_content_c_only(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare( specific_files=['b/c']) self.assertEqual( [(u'b', 'b-id', 'directory'), ('b/c', 'c-id', 'file')], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_empty_to_abc_content_b_only(self): """Restricting to a dir matches the children of the dir.""" tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare(specific_files=['b']) self.assertEqual( [('b', 'b-id', 'directory'), ('b/c', 'c-id', 'file')], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_unchanged_with_renames_and_modifications(self): """want_unchanged should generate a list of unchanged entries.""" tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_5(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare(want_unchanged=True) self.assertEqual([], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([('a', 'd', 'a-id', 'file', True, False)], d.renamed) self.assertEqual( [(u'b', 'b-id', 'directory'), (u'b/c', 'c-id', 'file')], d.unchanged) def test_extra_trees_finds_ids(self): """Ask for a delta between two trees with a path present in a third.""" tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_3(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare(specific_files=['b']) # the type of tree-3 does not matter - it is used as a lookup, not # a dispatch. XXX: For dirstate it does speak to the optimisability of # the lookup, in merged trees it can be fast-pathed. We probably want # two tests: one as is, and one with it as a pending merge. tree3 = self.make_branch_and_tree('3') tree3 = self.get_tree_no_parents_abc_content_6(tree3) tree3.lock_read() self.addCleanup(tree3.unlock) # tree 3 has 'e' which is 'c-id'. Tree 1 has c-id at b/c, and Tree 2 # has c-id at b/c with its exec flag toggled. # without extra_trees, we should get no modifications from this # so do one, to be sure the test is valid. d = self.intertree_class(tree1, tree2).compare( specific_files=['e']) self.assertEqual([], d.modified) # now give it an additional lookup: d = self.intertree_class(tree1, tree2).compare( specific_files=['e'], extra_trees=[tree3]) self.assertEqual([], d.added) self.assertEqual([('b/c', 'c-id', 'file', False, True)], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) def test_require_versioned(self): # this does not quite robustly test, as it is passing in missing paths # rather than present-but-not-versioned paths. At the moment there is # no mechanism for managing the test trees (which are readonly) to # get present-but-not-versioned files for trees that can do that. tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) self.assertRaises(errors.PathsNotVersionedError, self.intertree_class(tree1, tree2).compare, specific_files=['d'], require_versioned=True) def test_default_ignores_unversioned_files(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree1/a', 'tree1/c', 'tree2/a', 'tree2/b', 'tree2/c']) tree1.add(['a', 'c'], ['a-id', 'c-id']) tree2.add(['a', 'c'], ['a-id', 'c-id']) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) d = self.intertree_class(tree1, tree2).compare() self.assertEqual([], d.added) self.assertEqual([(u'a', 'a-id', 'file', True, False), (u'c', 'c-id', 'file', True, False)], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) self.assertEqual([], d.unversioned) def test_unversioned_paths_in_tree(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree2/file', 'tree2/dir/']) if has_symlinks(): os.symlink('target', 'tree2/link') links_supported = True else: links_supported = False tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) self.not_applicable_if_cannot_represent_unversioned(tree2) d = self.intertree_class(tree1, tree2).compare(want_unversioned=True) self.assertEqual([], d.added) self.assertEqual([], d.modified) self.assertEqual([], d.removed) self.assertEqual([], d.renamed) self.assertEqual([], d.unchanged) expected_unversioned = [(u'dir', None, 'directory'), (u'file', None, 'file')] if links_supported: expected_unversioned.append((u'link', None, 'symlink')) self.assertEqual(expected_unversioned, d.unversioned) class TestIterChanges(TestCaseWithTwoTrees): """Test the comparison iterator""" def assertEqualIterChanges(self, left_changes, right_changes): """Assert that left_changes == right_changes. :param left_changes: A list of the output from iter_changes. :param right_changes: A list of the output from iter_changes. """ left_changes = sorted(left_changes) right_changes = sorted(right_changes) if left_changes == right_changes: return # setify to get item by item differences, but we can only do this # when all the ids are unique on both sides. left_dict = dict((item[0], item) for item in left_changes) right_dict = dict((item[0], item) for item in right_changes) if (len(left_dict) != len(left_changes) or len(right_dict) != len(right_changes)): # Can't do a direct comparison. We could do a sequence diff, but # for now just do a regular assertEqual for now. self.assertEqual(left_changes, right_changes) keys = set(left_dict).union(set(right_dict)) different = [] same = [] for key in keys: left_item = left_dict.get(key) right_item = right_dict.get(key) if left_item == right_item: same.append(str(left_item)) else: different.append(" %s\n %s" % (left_item, right_item)) self.fail("iter_changes output different. Unchanged items:\n" + "\n".join(same) + "\nChanged items:\n" + "\n".join(different)) def do_iter_changes(self, tree1, tree2, **extra_args): """Helper to run iter_changes from tree1 to tree2. :param tree1, tree2: The source and target trees. These will be locked automatically. :param **extra_args: Extra args to pass to iter_changes. This is not inspected by this test helper. """ tree1.lock_read() tree2.lock_read() try: # sort order of output is not strictly defined return sorted(self.intertree_class(tree1, tree2) .iter_changes(**extra_args)) finally: tree1.unlock() tree2.unlock() def check_has_changes(self, expected, tree1, tree2): # has_changes is defined for mutable trees only if not isinstance(tree2, mutabletree.MutableTree): if isinstance(tree1, mutabletree.MutableTree): # Let's switch the trees since has_changes() is commutative # (where we can apply it) tree2, tree1 = tree1, tree2 else: # Neither tree can be used return tree1.lock_read() try: tree2.lock_read() try: return tree2.has_changes(tree1) finally: tree2.unlock() finally: tree1.unlock() def mutable_trees_to_locked_test_trees(self, tree1, tree2): """Convert the working trees into test trees. Read lock them, and add the unlock to the cleanup. """ tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) tree1.lock_read() self.addCleanup(tree1.unlock) tree2.lock_read() self.addCleanup(tree2.unlock) return tree1, tree2 def make_tree_with_special_names(self): """Create a tree with filenames chosen to exercise the walk order.""" tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) paths, path_ids = self._create_special_names(tree2, 'tree2') tree2.commit('initial', rev_id='rev-1') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) return (tree1, tree2, paths, path_ids) def make_trees_with_special_names(self): """Both trees will use the special names. But the contents will differ for each file. """ tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) paths, path_ids = self._create_special_names(tree1, 'tree1') paths, path_ids = self._create_special_names(tree2, 'tree2') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) return (tree1, tree2, paths, path_ids) def _create_special_names(self, tree, base_path): """Create a tree with paths that expose differences in sort orders.""" # Each directory will have a single file named 'f' inside dirs = ['a', 'a-a', 'a/a', 'a/a-a', 'a/a/a', 'a/a/a-a', 'a/a/a/a', 'a/a/a/a-a', 'a/a/a/a/a', ] with_slashes = [] paths = [] path_ids = [] for d in dirs: with_slashes.append(base_path + '/' + d + '/') with_slashes.append(base_path + '/' + d + '/f') paths.append(d) paths.append(d+'/f') path_ids.append(d.replace('/', '_') + '-id') path_ids.append(d.replace('/', '_') + '_f-id') self.build_tree(with_slashes) tree.add(paths, path_ids) return paths, path_ids def test_compare_empty_trees(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_no_content(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) self.assertEqual([], self.do_iter_changes(tree1, tree2)) self.check_has_changes(False, tree1, tree2) def added(self, tree, file_id): path, entry = self.get_path_entry(tree, file_id) return (file_id, (None, path), True, (False, True), (None, entry.parent_id), (None, entry.name), (None, entry.kind), (None, entry.executable)) @staticmethod def get_path_entry(tree, file_id): iterator = tree.iter_entries_by_dir(specific_file_ids=[file_id]) return iterator.next() def content_changed(self, tree, file_id): path, entry = self.get_path_entry(tree, file_id) return (file_id, (path, path), True, (True, True), (entry.parent_id, entry.parent_id), (entry.name, entry.name), (entry.kind, entry.kind), (entry.executable, entry.executable)) def kind_changed(self, from_tree, to_tree, file_id): from_path, old_entry = self.get_path_entry(from_tree, file_id) path, new_entry = self.get_path_entry(to_tree, file_id) return (file_id, (from_path, path), True, (True, True), (old_entry.parent_id, new_entry.parent_id), (old_entry.name, new_entry.name), (old_entry.kind, new_entry.kind), (old_entry.executable, new_entry.executable)) def missing(self, file_id, from_path, to_path, parent_id, kind): _, from_basename = os.path.split(from_path) _, to_basename = os.path.split(to_path) # missing files have both paths, but no kind. return (file_id, (from_path, to_path), True, (True, True), (parent_id, parent_id), (from_basename, to_basename), (kind, None), (False, False)) def deleted(self, tree, file_id): entry = tree.inventory[file_id] path = tree.id2path(file_id) return (file_id, (path, None), True, (True, False), (entry.parent_id, None), (entry.name, None), (entry.kind, None), (entry.executable, None)) def renamed(self, from_tree, to_tree, file_id, content_changed): from_path, from_entry = self.get_path_entry(from_tree, file_id) to_path, to_entry = self.get_path_entry(to_tree, file_id) return (file_id, (from_path, to_path), content_changed, (True, True), (from_entry.parent_id, to_entry.parent_id), (from_entry.name, to_entry.name), (from_entry.kind, to_entry.kind), (from_entry.executable, to_entry.executable)) def unchanged(self, tree, file_id): path, entry = self.get_path_entry(tree, file_id) parent = entry.parent_id name = entry.name kind = entry.kind executable = entry.executable return (file_id, (path, path), False, (True, True), (parent, parent), (name, name), (kind, kind), (executable, executable)) def unversioned(self, tree, path): """Create an unversioned result.""" _, basename = os.path.split(path) kind = tree._comparison_data(None, path)[0] return (None, (None, path), True, (False, False), (None, None), (None, basename), (None, kind), (None, False)) def test_empty_to_abc_content(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) expected_results = sorted([ self.added(tree2, 'root-id'), self.added(tree2, 'a-id'), self.added(tree2, 'b-id'), self.added(tree2, 'c-id'), self.deleted(tree1, 'empty-root-id')]) self.assertEqual(expected_results, self.do_iter_changes(tree1, tree2)) self.check_has_changes(True, tree1, tree2) def test_empty_specific_files(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.assertEqual([], self.do_iter_changes(tree1, tree2, specific_files=[])) def test_no_specific_files(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) expected_results = sorted([ self.added(tree2, 'root-id'), self.added(tree2, 'a-id'), self.added(tree2, 'b-id'), self.added(tree2, 'c-id'), self.deleted(tree1, 'empty-root-id')]) self.assertEqual(expected_results, self.do_iter_changes(tree1, tree2)) self.check_has_changes(True, tree1, tree2) def test_empty_to_abc_content_a_only(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.assertEqual( sorted([self.added(tree2, 'root-id'), self.added(tree2, 'a-id'), self.deleted(tree1, 'empty-root-id')]), self.do_iter_changes(tree1, tree2, specific_files=['a'])) def test_abc_content_to_empty_a_only(self): # For deletes we don't need to pickup parents. tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_no_content(tree2) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.assertEqual( [self.deleted(tree1, 'a-id')], self.do_iter_changes(tree1, tree2, specific_files=['a'])) def test_abc_content_to_empty_b_only(self): # When b stops being a directory we have to pick up b/c as well. tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_no_content(tree2) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.assertEqual( [self.deleted(tree1, 'b-id'), self.deleted(tree1, 'c-id')], self.do_iter_changes(tree1, tree2, specific_files=['b'])) def test_empty_to_abc_content_a_and_c_only(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_no_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) expected_result = sorted([self.added(tree2, 'root-id'), self.added(tree2, 'a-id'), self.added(tree2, 'b-id'), self.added(tree2, 'c-id'), self.deleted(tree1, 'empty-root-id')]) self.assertEqual(expected_result, self.do_iter_changes(tree1, tree2, specific_files=['a', 'b/c'])) def test_abc_content_to_empty(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_no_content(tree2) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) expected_results = sorted([ self.added(tree2, 'empty-root-id'), self.deleted(tree1, 'root-id'), self.deleted(tree1, 'a-id'), self.deleted(tree1, 'b-id'), self.deleted(tree1, 'c-id')]) self.assertEqual( expected_results, self.do_iter_changes(tree1, tree2)) self.check_has_changes(True, tree1, tree2) def test_content_modification(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_2(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) root_id = tree1.path2id('') self.assertEqual([('a-id', ('a', 'a'), True, (True, True), (root_id, root_id), ('a', 'a'), ('file', 'file'), (False, False))], self.do_iter_changes(tree1, tree2)) self.check_has_changes(True, tree1, tree2) def test_meta_modification(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_3(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) self.assertEqual([('c-id', ('b/c', 'b/c'), False, (True, True), ('b-id', 'b-id'), ('c', 'c'), ('file', 'file'), (False, True))], self.do_iter_changes(tree1, tree2)) def test_empty_dir(self): """an empty dir should not cause glitches to surrounding files.""" tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) # the pathname is chosen to fall between 'a' and 'b'. self.build_tree(['1/a-empty/', '2/a-empty/']) tree1.add(['a-empty'], ['a-empty']) tree2.add(['a-empty'], ['a-empty']) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) expected = [] self.assertEqual(expected, self.do_iter_changes(tree1, tree2)) def test_file_rename(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_4(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) root_id = tree1.path2id('') self.assertEqual([('a-id', ('a', 'd'), False, (True, True), (root_id, root_id), ('a', 'd'), ('file', 'file'), (False, False))], self.do_iter_changes(tree1, tree2)) def test_file_rename_and_modification(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_5(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) root_id = tree1.path2id('') self.assertEqual([('a-id', ('a', 'd'), True, (True, True), (root_id, root_id), ('a', 'd'), ('file', 'file'), (False, False))], self.do_iter_changes(tree1, tree2)) def test_specific_content_modification_grabs_parents(self): # WHen the only direct change to a specified file is a content change, # and its in a reparented subtree, the parents are grabbed. tree1 = self.make_branch_and_tree('1') tree1.mkdir('changing', 'parent-id') tree1.mkdir('changing/unchanging', 'mid-id') tree1.add(['changing/unchanging/file'], ['file-id'], ['file']) tree1.put_file_bytes_non_atomic('file-id', 'a file') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree2.mkdir('changed', 'parent-id') tree2.mkdir('changed/unchanging', 'mid-id') tree2.add(['changed/unchanging/file'], ['file-id'], ['file']) tree2.put_file_bytes_non_atomic('file-id', 'changed content') tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) # parent-id has changed, as has file-id root_id = tree1.path2id('') self.assertEqualIterChanges( [self.renamed(tree1, tree2, 'parent-id', False), self.renamed(tree1, tree2, 'file-id', True)], self.do_iter_changes(tree1, tree2, specific_files=['changed/unchanging/file'])) def test_specific_content_modification_grabs_parents_root_changes(self): # WHen the only direct change to a specified file is a content change, # and its in a reparented subtree, the parents are grabbed, even if # that includes the root. tree1 = self.make_branch_and_tree('1') tree1.set_root_id('old') tree1.mkdir('changed', 'parent-id') tree1.mkdir('changed/unchanging', 'mid-id') tree1.add(['changed/unchanging/file'], ['file-id'], ['file']) tree1.put_file_bytes_non_atomic('file-id', 'a file') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id('new') tree2.mkdir('changed', 'parent-id') tree2.mkdir('changed/unchanging', 'mid-id') tree2.add(['changed/unchanging/file'], ['file-id'], ['file']) tree2.put_file_bytes_non_atomic('file-id', 'changed content') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) # old is gone, new is added, parent-id has changed(reparented), as has # file-id(content) root_id = tree1.path2id('') self.assertEqualIterChanges( [self.renamed(tree1, tree2, 'parent-id', False), self.added(tree2, 'new'), self.deleted(tree1, 'old'), self.renamed(tree1, tree2, 'file-id', True)], self.do_iter_changes(tree1, tree2, specific_files=['changed/unchanging/file'])) def test_specific_with_rename_under_new_dir_reports_new_dir(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_7(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) # d(d-id) is new, e is b-id renamed. root_id = tree1.path2id('') self.assertEqualIterChanges( [self.renamed(tree1, tree2, 'b-id', False), self.added(tree2, 'd-id')], self.do_iter_changes(tree1, tree2, specific_files=['d/e'])) def test_specific_with_rename_under_dir_under_new_dir_reports_new_dir(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_7(tree2) tree2.rename_one('a', 'd/e/a') tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) # d is new, d/e is b-id renamed, d/e/a is a-id renamed root_id = tree1.path2id('') self.assertEqualIterChanges( [self.renamed(tree1, tree2, 'b-id', False), self.added(tree2, 'd-id'), self.renamed(tree1, tree2, 'a-id', False)], self.do_iter_changes(tree1, tree2, specific_files=['d/e/a'])) def test_specific_old_parent_same_path_new_parent(self): # when a parent is new at its path, if the path was used in the source # it must be emitted as a change. tree1 = self.make_branch_and_tree('1') tree1.add(['a'], ['a-id'], ['file']) tree1.put_file_bytes_non_atomic('a-id', 'a file') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree2.mkdir('a', 'b-id') tree2.add(['a/c'], ['c-id'], ['file']) tree2.put_file_bytes_non_atomic('c-id', 'another file') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) # a-id is gone, b-id and c-id are added. self.assertEqualIterChanges( [self.deleted(tree1, 'a-id'), self.added(tree2, 'b-id'), self.added(tree2, 'c-id')], self.do_iter_changes(tree1, tree2, specific_files=['a/c'])) def test_specific_old_parent_becomes_file(self): # When an old parent included because of a path conflict becomes a # non-directory, its children have to be all included in the delta. tree1 = self.make_branch_and_tree('1') tree1.mkdir('a', 'a-old-id') tree1.mkdir('a/reparented', 'reparented-id') tree1.mkdir('a/deleted', 'deleted-id') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree2.mkdir('a', 'a-new-id') tree2.mkdir('a/reparented', 'reparented-id') tree2.add(['b'], ['a-old-id'], ['file']) tree2.put_file_bytes_non_atomic('a-old-id', '') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) # a-old-id is kind-changed, a-new-id is added, reparented-id is renamed, # deleted-id is gone self.assertEqualIterChanges( [self.kind_changed(tree1, tree2, 'a-old-id'), self.added(tree2, 'a-new-id'), self.renamed(tree1, tree2, 'reparented-id', False), self.deleted(tree1, 'deleted-id')], self.do_iter_changes(tree1, tree2, specific_files=['a/reparented'])) def test_specific_old_parent_is_deleted(self): # When an old parent included because of a path conflict is removed, # its children have to be all included in the delta. tree1 = self.make_branch_and_tree('1') tree1.mkdir('a', 'a-old-id') tree1.mkdir('a/reparented', 'reparented-id') tree1.mkdir('a/deleted', 'deleted-id') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree2.mkdir('a', 'a-new-id') tree2.mkdir('a/reparented', 'reparented-id') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) # a-old-id is gone, a-new-id is added, reparented-id is renamed, # deleted-id is gone self.assertEqualIterChanges( [self.deleted(tree1, 'a-old-id'), self.added(tree2, 'a-new-id'), self.renamed(tree1, tree2, 'reparented-id', False), self.deleted(tree1, 'deleted-id')], self.do_iter_changes(tree1, tree2, specific_files=['a/reparented'])) def test_specific_old_parent_child_collides_with_unselected_new(self): # When the child of an old parent because of a path conflict becomes a # path conflict with some unselected item in the source, that item also # needs to be included (because otherwise the output of applying the # delta to the source would have two items at that path). tree1 = self.make_branch_and_tree('1') tree1.mkdir('a', 'a-old-id') tree1.mkdir('a/reparented', 'reparented-id') tree1.mkdir('collides', 'collides-id') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree2.mkdir('a', 'a-new-id') tree2.mkdir('a/selected', 'selected-id') tree2.mkdir('collides', 'reparented-id') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) # a-old-id is one, a-new-id is added, reparented-id is renamed, # collides-id is gone, selected-id is new. self.assertEqualIterChanges( [self.deleted(tree1, 'a-old-id'), self.added(tree2, 'a-new-id'), self.renamed(tree1, tree2, 'reparented-id', False), self.deleted(tree1, 'collides-id'), self.added(tree2, 'selected-id')], self.do_iter_changes(tree1, tree2, specific_files=['a/selected'])) def test_specific_old_parent_child_dir_stops_being_dir(self): # When the child of an old parent also stops being a directory, its # children must also be included. This test checks that downward # recursion is done appropriately by starting at a child of the root of # a deleted subtree (a/reparented), and checking that a sibling # directory (a/deleted) has its children included in the delta. tree1 = self.make_branch_and_tree('1') tree1.mkdir('a', 'a-old-id') tree1.mkdir('a/reparented', 'reparented-id-1') tree1.mkdir('a/deleted', 'deleted-id-1') tree1.mkdir('a/deleted/reparented', 'reparented-id-2') tree1.mkdir('a/deleted/deleted', 'deleted-id-2') tree2 = self.make_to_branch_and_tree('2') tree2.set_root_id(tree1.get_root_id()) tree2.mkdir('a', 'a-new-id') tree2.mkdir('a/reparented', 'reparented-id-1') tree2.mkdir('reparented', 'reparented-id-2') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) # a-old-id is gone, a-new-id is added, reparented-id-1, -2 are renamed, # deleted-id-1 and -2 are gone. self.assertEqualIterChanges( [self.deleted(tree1, 'a-old-id'), self.added(tree2, 'a-new-id'), self.renamed(tree1, tree2, 'reparented-id-1', False), self.renamed(tree1, tree2, 'reparented-id-2', False), self.deleted(tree1, 'deleted-id-1'), self.deleted(tree1, 'deleted-id-2')], self.do_iter_changes(tree1, tree2, specific_files=['a/reparented'])) def test_file_rename_and_meta_modification(self): tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_6(tree2) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) root_id = tree1.path2id('') self.assertEqual([('c-id', ('b/c', 'e'), False, (True, True), ('b-id', root_id), ('c', 'e'), ('file', 'file'), (False, True))], self.do_iter_changes(tree1, tree2)) def test_file_becomes_unversionable_bug_438569(self): # This isn't strictly a intertree problem, but its the intertree code # path that triggers all stat cache updates on both xml and dirstate # trees. # In bug 438569, a file becoming a fifo causes an assert. Fifo's are # not versionable or diffable. For now, we simply stop cold when they # are detected (because we don't know how far through the code the # assumption 'fifo's do not exist' goes). In future we could report # the kind change and have commit refuse to go futher, or something # similar. One particular reason for choosing this approach is that # there is no minikind for 'fifo' in dirstate today, so we can't # actually update records that way. # To add confusion, the totally generic code path works - but it # doesn't update persistent metadata. So this test permits InterTrees # to either work, or fail with BadFileKindError. self.requireFeature(tests.OsFifoFeature) tree1 = self.make_branch_and_tree('1') self.build_tree(['1/a']) tree1.set_root_id('root-id') tree1.add(['a'], ['a-id']) tree2 = self.make_branch_and_tree('2') os.mkfifo('2/a') tree2.add(['a'], ['a-id'], ['file']) try: tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) except (KeyError,): raise tests.TestNotApplicable( "Cannot represent a FIFO in this case %s" % self.id()) try: self.do_iter_changes(tree1, tree2) except errors.BadFileKindError: pass def test_missing_in_target(self): """Test with the target files versioned but absent from disk.""" tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content(tree2) os.unlink('2/a') shutil.rmtree('2/b') # TODO ? have a symlink here? tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) self.not_applicable_if_missing_in('a', tree2) self.not_applicable_if_missing_in('b', tree2) root_id = tree1.path2id('') expected = sorted([ self.missing('a-id', 'a', 'a', root_id, 'file'), self.missing('b-id', 'b', 'b', root_id, 'directory'), self.missing('c-id', 'b/c', 'b/c', 'b-id', 'file'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2)) def test_missing_and_renamed(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree1/file']) tree1.add(['file'], ['file-id']) self.build_tree(['tree2/directory/']) tree2.add(['directory'], ['file-id']) os.rmdir('tree2/directory') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_missing_in('directory', tree2) root_id = tree1.path2id('') expected = sorted([ self.missing('file-id', 'file', 'directory', root_id, 'file'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2)) def test_only_in_source_and_missing(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree1/file']) tree1.add(['file'], ['file-id']) os.unlink('tree1/file') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_missing_in('file', tree1) root_id = tree1.path2id('') expected = [('file-id', ('file', None), False, (True, False), (root_id, None), ('file', None), (None, None), (False, None))] self.assertEqual(expected, self.do_iter_changes(tree1, tree2)) def test_only_in_target_and_missing(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree2/file']) tree2.add(['file'], ['file-id']) os.unlink('tree2/file') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_missing_in('file', tree2) root_id = tree1.path2id('') expected = [('file-id', (None, 'file'), False, (False, True), (None, root_id), (None, 'file'), (None, None), (None, False))] self.assertEqual(expected, self.do_iter_changes(tree1, tree2)) def test_only_in_target_missing_subtree_specific_bug_367632(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree2/a-dir/', 'tree2/a-dir/a-file']) tree2.add(['a-dir', 'a-dir/a-file'], ['dir-id', 'file-id']) os.unlink('tree2/a-dir/a-file') os.rmdir('tree2/a-dir') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_missing_in('a-dir', tree2) root_id = tree1.path2id('') expected = [ ('dir-id', (None, 'a-dir'), False, (False, True), (None, root_id), (None, 'a-dir'), (None, None), (None, False)), ('file-id', (None, 'a-dir/a-file'), False, (False, True), (None, 'dir-id'), (None, 'a-file'), (None, None), (None, False)) ] # bug 367632 showed that specifying the root broke some code paths, # so we check this contract with and without it. self.assertEqual(expected, self.do_iter_changes(tree1, tree2)) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, specific_files=[''])) def test_unchanged_with_renames_and_modifications(self): """want_unchanged should generate a list of unchanged entries.""" tree1 = self.make_branch_and_tree('1') tree2 = self.make_to_branch_and_tree('2') tree1 = self.get_tree_no_parents_abc_content(tree1) tree2 = self.get_tree_no_parents_abc_content_5(tree2) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) root_id = tree1.path2id('') self.assertEqual(sorted([self.unchanged(tree1, root_id), self.unchanged(tree1, 'b-id'), ('a-id', ('a', 'd'), True, (True, True), (root_id, root_id), ('a', 'd'), ('file', 'file'), (False, False)), self.unchanged(tree1, 'c-id')]), self.do_iter_changes(tree1, tree2, include_unchanged=True)) def test_compare_subtrees(self): tree1 = self.make_branch_and_tree('1') if not tree1.supports_tree_reference(): return tree1.set_root_id('root-id') subtree1 = self.make_branch_and_tree('1/sub') subtree1.set_root_id('subtree-id') tree1.add_reference(subtree1) tree2 = self.make_to_branch_and_tree('2') if not tree2.supports_tree_reference(): return tree2.set_root_id('root-id') subtree2 = self.make_to_branch_and_tree('2/sub') subtree2.set_root_id('subtree-id') tree2.add_reference(subtree2) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.assertEqual([], list(tree2.iter_changes(tree1))) subtree1.commit('commit', rev_id='commit-a') self.assertEqual([ ('root-id', (u'', u''), False, (True, True), (None, None), (u'', u''), ('directory', 'directory'), (False, False)), ('subtree-id', ('sub', 'sub',), False, (True, True), ('root-id', 'root-id'), ('sub', 'sub'), ('tree-reference', 'tree-reference'), (False, False))], list(tree2.iter_changes(tree1, include_unchanged=True))) def test_disk_in_subtrees_skipped(self): """subtrees are considered not-in-the-current-tree. This test tests the trivial case, where the basis has no paths in the current trees subtree. """ tree1 = self.make_branch_and_tree('1') tree1.set_root_id('root-id') tree2 = self.make_to_branch_and_tree('2') if not tree2.supports_tree_reference(): return tree2.set_root_id('root-id') subtree2 = self.make_to_branch_and_tree('2/sub') subtree2.set_root_id('subtree-id') tree2.add_reference(subtree2) self.build_tree(['2/sub/file']) subtree2.add(['file']) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) # this should filter correctly from above self.assertEqual([self.added(tree2, 'subtree-id')], self.do_iter_changes(tree1, tree2, want_unversioned=True)) # and when the path is named self.assertEqual([self.added(tree2, 'subtree-id')], self.do_iter_changes(tree1, tree2, specific_files=['sub'], want_unversioned=True)) def test_default_ignores_unversioned_files(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree1/a', 'tree1/c', 'tree2/a', 'tree2/b', 'tree2/c']) tree1.add(['a', 'c'], ['a-id', 'c-id']) tree2.add(['a', 'c'], ['a-id', 'c-id']) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) # We should ignore the fact that 'b' exists in tree-2 # because the want_unversioned parameter was not given. expected = sorted([ self.content_changed(tree2, 'a-id'), self.content_changed(tree2, 'c-id'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2)) self.check_has_changes(True, tree1, tree2) def test_unversioned_paths_in_tree(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree2/file', 'tree2/dir/']) if has_symlinks(): os.symlink('target', 'tree2/link') links_supported = True else: links_supported = False tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_cannot_represent_unversioned(tree2) expected = [ self.unversioned(tree2, 'file'), self.unversioned(tree2, 'dir'), ] if links_supported: expected.append(self.unversioned(tree2, 'link')) expected = sorted(expected) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, want_unversioned=True)) def test_unversioned_paths_in_tree_specific_files(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') self.build_tree(['tree2/file', 'tree2/dir/']) if has_symlinks(): os.symlink('target', 'tree2/link') links_supported = True else: links_supported = False tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_cannot_represent_unversioned(tree2) expected = [ self.unversioned(tree2, 'file'), self.unversioned(tree2, 'dir'), ] specific_files=['file', 'dir'] if links_supported: expected.append(self.unversioned(tree2, 'link')) specific_files.append('link') expected = sorted(expected) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, specific_files=specific_files, require_versioned=False, want_unversioned=True)) def test_unversioned_paths_in_target_matching_source_old_names(self): # its likely that naive implementations of unversioned file support # will fail if the path was versioned, but is not any more, # due to a rename, not due to unversioning it. # That is, if the old tree has a versioned file 'foo', and # the new tree has the same file but versioned as 'bar', and also # has an unknown file 'foo', we should get back output for # both foo and bar. tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree2/file', 'tree2/dir/', 'tree1/file', 'tree2/movedfile', 'tree1/dir/', 'tree2/moveddir/']) if has_symlinks(): os.symlink('target', 'tree1/link') os.symlink('target', 'tree2/link') os.symlink('target', 'tree2/movedlink') links_supported = True else: links_supported = False tree1.add(['file', 'dir'], ['file-id', 'dir-id']) tree2.add(['movedfile', 'moveddir'], ['file-id', 'dir-id']) if links_supported: tree1.add(['link'], ['link-id']) tree2.add(['movedlink'], ['link-id']) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_cannot_represent_unversioned(tree2) root_id = tree1.path2id('') expected = [ self.renamed(tree1, tree2, 'dir-id', False), self.renamed(tree1, tree2, 'file-id', True), self.unversioned(tree2, 'file'), self.unversioned(tree2, 'dir'), ] specific_files=['file', 'dir'] if links_supported: expected.append(self.renamed(tree1, tree2, 'link-id', False)) expected.append(self.unversioned(tree2, 'link')) specific_files.append('link') expected = sorted(expected) # run once with, and once without specific files, to catch # potentially different code paths. self.assertEqual(expected, self.do_iter_changes(tree1, tree2, require_versioned=False, want_unversioned=True)) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, specific_files=specific_files, require_versioned=False, want_unversioned=True)) def test_similar_filenames(self): """Test when we have a few files with similar names.""" tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) # The trees are actually identical, but they happen to contain # similarly named files. self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a/b/c/', 'tree1/a/b/c/d/', 'tree1/a-c/', 'tree1/a-c/e/', 'tree2/a/', 'tree2/a/b/', 'tree2/a/b/c/', 'tree2/a/b/c/d/', 'tree2/a-c/', 'tree2/a-c/e/', ]) tree1.add(['a', 'a/b', 'a/b/c', 'a/b/c/d', 'a-c', 'a-c/e'], ['a-id', 'b-id', 'c-id', 'd-id', 'a-c-id', 'e-id']) tree2.add(['a', 'a/b', 'a/b/c', 'a/b/c/d', 'a-c', 'a-c/e'], ['a-id', 'b-id', 'c-id', 'd-id', 'a-c-id', 'e-id']) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_cannot_represent_unversioned(tree2) self.assertEqual([], self.do_iter_changes(tree1, tree2, want_unversioned=True)) expected = sorted([ self.unchanged(tree2, tree2.get_root_id()), self.unchanged(tree2, 'a-id'), self.unchanged(tree2, 'b-id'), self.unchanged(tree2, 'c-id'), self.unchanged(tree2, 'd-id'), self.unchanged(tree2, 'a-c-id'), self.unchanged(tree2, 'e-id'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, want_unversioned=True, include_unchanged=True)) def test_unversioned_subtree_only_emits_root(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree2/dir/', 'tree2/dir/file']) tree1, tree2 = self.mutable_trees_to_test_trees(self, tree1, tree2) self.not_applicable_if_cannot_represent_unversioned(tree2) expected = [ self.unversioned(tree2, 'dir'), ] self.assertEqual(expected, self.do_iter_changes(tree1, tree2, want_unversioned=True)) def make_trees_with_symlinks(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree1/fromfile', 'tree1/fromdir/']) self.build_tree(['tree2/tofile', 'tree2/todir/', 'tree2/unknown']) os.symlink('original', 'tree1/changed') os.symlink('original', 'tree1/removed') os.symlink('original', 'tree1/tofile') os.symlink('original', 'tree1/todir') # we make the unchanged link point at unknown to catch incorrect # symlink-following code in the specified_files test. os.symlink('unknown', 'tree1/unchanged') os.symlink('new', 'tree2/added') os.symlink('new', 'tree2/changed') os.symlink('new', 'tree2/fromfile') os.symlink('new', 'tree2/fromdir') os.symlink('unknown', 'tree2/unchanged') from_paths_and_ids = [ 'fromdir', 'fromfile', 'changed', 'removed', 'todir', 'tofile', 'unchanged', ] to_paths_and_ids = [ 'added', 'fromdir', 'fromfile', 'changed', 'todir', 'tofile', 'unchanged', ] tree1.add(from_paths_and_ids, from_paths_and_ids) tree2.add(to_paths_and_ids, to_paths_and_ids) return self.mutable_trees_to_locked_test_trees(tree1, tree2) def test_versioned_symlinks(self): self.requireFeature(tests.SymlinkFeature) tree1, tree2 = self.make_trees_with_symlinks() self.not_applicable_if_cannot_represent_unversioned(tree2) root_id = tree1.path2id('') expected = [ self.unchanged(tree1, tree1.path2id('')), self.added(tree2, 'added'), self.content_changed(tree2, 'changed'), self.kind_changed(tree1, tree2, 'fromdir'), self.kind_changed(tree1, tree2, 'fromfile'), self.deleted(tree1, 'removed'), self.unchanged(tree2, 'unchanged'), self.unversioned(tree2, 'unknown'), self.kind_changed(tree1, tree2, 'todir'), self.kind_changed(tree1, tree2, 'tofile'), ] expected = sorted(expected) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, include_unchanged=True, want_unversioned=True)) self.check_has_changes(True, tree1, tree2) def test_versioned_symlinks_specific_files(self): self.requireFeature(tests.SymlinkFeature) tree1, tree2 = self.make_trees_with_symlinks() root_id = tree1.path2id('') expected = [ self.added(tree2, 'added'), self.content_changed(tree2, 'changed'), self.kind_changed(tree1, tree2, 'fromdir'), self.kind_changed(tree1, tree2, 'fromfile'), self.deleted(tree1, 'removed'), self.kind_changed(tree1, tree2, 'todir'), self.kind_changed(tree1, tree2, 'tofile'), ] expected = sorted(expected) # we should get back just the changed links. We pass in 'unchanged' to # make sure that it is correctly not returned - and neither is the # unknown path 'unknown' which it points at. self.assertEqual(expected, self.do_iter_changes(tree1, tree2, specific_files=['added', 'changed', 'fromdir', 'fromfile', 'removed', 'unchanged', 'todir', 'tofile'])) self.check_has_changes(True, tree1, tree2) def test_tree_with_special_names(self): tree1, tree2, paths, path_ids = self.make_tree_with_special_names() expected = sorted(self.added(tree2, f_id) for f_id in path_ids) self.assertEqual(expected, self.do_iter_changes(tree1, tree2)) self.check_has_changes(True, tree1, tree2) def test_trees_with_special_names(self): tree1, tree2, paths, path_ids = self.make_trees_with_special_names() expected = sorted(self.content_changed(tree2, f_id) for f_id in path_ids if f_id.endswith('_f-id')) self.assertEqual(expected, self.do_iter_changes(tree1, tree2)) self.check_has_changes(True, tree1, tree2) def test_trees_with_deleted_dir(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') tree2.set_root_id(tree1.get_root_id()) self.build_tree(['tree1/a', 'tree1/b/', 'tree1/b/c', 'tree1/b/d/', 'tree1/b/d/e', 'tree1/f/', 'tree1/f/g', 'tree2/a', 'tree2/f/', 'tree2/f/g']) tree1.add(['a', 'b', 'b/c', 'b/d/', 'b/d/e', 'f', 'f/g'], ['a-id', 'b-id', 'c-id', 'd-id', 'e-id', 'f-id', 'g-id']) tree2.add(['a', 'f', 'f/g'], ['a-id', 'f-id', 'g-id']) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) # We should notice that 'b' and all its children are deleted expected = [ self.content_changed(tree2, 'a-id'), self.content_changed(tree2, 'g-id'), self.deleted(tree1, 'b-id'), self.deleted(tree1, 'c-id'), self.deleted(tree1, 'd-id'), self.deleted(tree1, 'e-id'), ] self.assertEqualIterChanges(expected, self.do_iter_changes(tree1, tree2)) self.check_has_changes(True, tree1, tree2) def test_added_unicode(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # u'\u03b1' == GREEK SMALL LETTER ALPHA # u'\u03c9' == GREEK SMALL LETTER OMEGA a_id = u'\u03b1-id'.encode('utf8') added_id = u'\u03c9_added_id'.encode('utf8') try: self.build_tree([u'tree1/\u03b1/', u'tree2/\u03b1/', u'tree2/\u03b1/\u03c9-added', ]) except UnicodeError: raise tests.TestSkipped("Could not create Unicode files.") tree1.add([u'\u03b1'], [a_id]) tree2.add([u'\u03b1', u'\u03b1/\u03c9-added'], [a_id, added_id]) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.assertEqual([self.added(tree2, added_id)], self.do_iter_changes(tree1, tree2)) self.assertEqual([self.added(tree2, added_id)], self.do_iter_changes(tree1, tree2, specific_files=[u'\u03b1'])) self.check_has_changes(True, tree1, tree2) def test_deleted_unicode(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # u'\u03b1' == GREEK SMALL LETTER ALPHA # u'\u03c9' == GREEK SMALL LETTER OMEGA a_id = u'\u03b1-id'.encode('utf8') deleted_id = u'\u03c9_deleted_id'.encode('utf8') try: self.build_tree([u'tree1/\u03b1/', u'tree1/\u03b1/\u03c9-deleted', u'tree2/\u03b1/', ]) except UnicodeError: raise tests.TestSkipped("Could not create Unicode files.") tree1.add([u'\u03b1', u'\u03b1/\u03c9-deleted'], [a_id, deleted_id]) tree2.add([u'\u03b1'], [a_id]) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.assertEqual([self.deleted(tree1, deleted_id)], self.do_iter_changes(tree1, tree2)) self.assertEqual([self.deleted(tree1, deleted_id)], self.do_iter_changes(tree1, tree2, specific_files=[u'\u03b1'])) self.check_has_changes(True, tree1, tree2) def test_modified_unicode(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # u'\u03b1' == GREEK SMALL LETTER ALPHA # u'\u03c9' == GREEK SMALL LETTER OMEGA a_id = u'\u03b1-id'.encode('utf8') mod_id = u'\u03c9_mod_id'.encode('utf8') try: self.build_tree([u'tree1/\u03b1/', u'tree1/\u03b1/\u03c9-modified', u'tree2/\u03b1/', u'tree2/\u03b1/\u03c9-modified', ]) except UnicodeError: raise tests.TestSkipped("Could not create Unicode files.") tree1.add([u'\u03b1', u'\u03b1/\u03c9-modified'], [a_id, mod_id]) tree2.add([u'\u03b1', u'\u03b1/\u03c9-modified'], [a_id, mod_id]) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.assertEqual([self.content_changed(tree1, mod_id)], self.do_iter_changes(tree1, tree2)) self.assertEqual([self.content_changed(tree1, mod_id)], self.do_iter_changes(tree1, tree2, specific_files=[u'\u03b1'])) self.check_has_changes(True, tree1, tree2) def test_renamed_unicode(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # u'\u03b1' == GREEK SMALL LETTER ALPHA # u'\u03c9' == GREEK SMALL LETTER OMEGA a_id = u'\u03b1-id'.encode('utf8') rename_id = u'\u03c9_rename_id'.encode('utf8') try: self.build_tree([u'tree1/\u03b1/', u'tree2/\u03b1/', ]) except UnicodeError: raise tests.TestSkipped("Could not create Unicode files.") self.build_tree_contents([(u'tree1/\u03c9-source', 'contents\n'), (u'tree2/\u03b1/\u03c9-target', 'contents\n'), ]) tree1.add([u'\u03b1', u'\u03c9-source'], [a_id, rename_id]) tree2.add([u'\u03b1', u'\u03b1/\u03c9-target'], [a_id, rename_id]) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.assertEqual([self.renamed(tree1, tree2, rename_id, False)], self.do_iter_changes(tree1, tree2)) self.assertEqualIterChanges( [self.renamed(tree1, tree2, rename_id, False)], self.do_iter_changes(tree1, tree2, specific_files=[u'\u03b1'])) self.check_has_changes(True, tree1, tree2) def test_unchanged_unicode(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # u'\u03b1' == GREEK SMALL LETTER ALPHA # u'\u03c9' == GREEK SMALL LETTER OMEGA a_id = u'\u03b1-id'.encode('utf8') subfile_id = u'\u03c9-subfile-id'.encode('utf8') rootfile_id = u'\u03c9-root-id'.encode('utf8') try: self.build_tree([u'tree1/\u03b1/', u'tree2/\u03b1/', ]) except UnicodeError: raise tests.TestSkipped("Could not create Unicode files.") self.build_tree_contents([ (u'tree1/\u03b1/\u03c9-subfile', 'sub contents\n'), (u'tree2/\u03b1/\u03c9-subfile', 'sub contents\n'), (u'tree1/\u03c9-rootfile', 'root contents\n'), (u'tree2/\u03c9-rootfile', 'root contents\n'), ]) tree1.add([u'\u03b1', u'\u03b1/\u03c9-subfile', u'\u03c9-rootfile'], [a_id, subfile_id, rootfile_id]) tree2.add([u'\u03b1', u'\u03b1/\u03c9-subfile', u'\u03c9-rootfile'], [a_id, subfile_id, rootfile_id]) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) expected = sorted([ self.unchanged(tree1, root_id), self.unchanged(tree1, a_id), self.unchanged(tree1, subfile_id), self.unchanged(tree1, rootfile_id), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, include_unchanged=True)) # We should also be able to select just a subset expected = sorted([ self.unchanged(tree1, a_id), self.unchanged(tree1, subfile_id), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, specific_files=[u'\u03b1'], include_unchanged=True)) def test_unknown_unicode(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # u'\u03b1' == GREEK SMALL LETTER ALPHA # u'\u03c9' == GREEK SMALL LETTER OMEGA a_id = u'\u03b1-id'.encode('utf8') try: self.build_tree([u'tree1/\u03b1/', u'tree2/\u03b1/', u'tree2/\u03b1/unknown_dir/', u'tree2/\u03b1/unknown_file', u'tree2/\u03b1/unknown_dir/file', u'tree2/\u03c9-unknown_root_file', ]) except UnicodeError: raise tests.TestSkipped("Could not create Unicode files.") tree1.add([u'\u03b1'], [a_id]) tree2.add([u'\u03b1'], [a_id]) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_cannot_represent_unversioned(tree2) expected = sorted([ self.unversioned(tree2, u'\u03b1/unknown_dir'), self.unversioned(tree2, u'\u03b1/unknown_file'), self.unversioned(tree2, u'\u03c9-unknown_root_file'), # a/unknown_dir/file should not be included because we should not # recurse into unknown_dir # self.unversioned(tree2, 'a/unknown_dir/file'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, require_versioned=False, want_unversioned=True)) self.assertEqual([], # Without want_unversioned we should get nothing self.do_iter_changes(tree1, tree2)) self.check_has_changes(False, tree1, tree2) # We should also be able to select just a subset expected = sorted([ self.unversioned(tree2, u'\u03b1/unknown_dir'), self.unversioned(tree2, u'\u03b1/unknown_file'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, specific_files=[u'\u03b1'], require_versioned=False, want_unversioned=True)) self.assertEqual([], # Without want_unversioned we should get nothing self.do_iter_changes(tree1, tree2, specific_files=[u'\u03b1'])) def test_unknown_empty_dir(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # Start with 2 identical trees self.build_tree(['tree1/a/', 'tree1/b/', 'tree2/a/', 'tree2/b/']) self.build_tree_contents([('tree1/b/file', 'contents\n'), ('tree2/b/file', 'contents\n')]) tree1.add(['a', 'b', 'b/file'], ['a-id', 'b-id', 'b-file-id']) tree2.add(['a', 'b', 'b/file'], ['a-id', 'b-id', 'b-file-id']) # Now create some unknowns in tree2 # We should find both a/file and a/dir as unknown, but we shouldn't # recurse into a/dir to find that a/dir/subfile is also unknown. self.build_tree(['tree2/a/file', 'tree2/a/dir/', 'tree2/a/dir/subfile']) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_cannot_represent_unversioned(tree2) expected = sorted([ self.unversioned(tree2, u'a/file'), self.unversioned(tree2, u'a/dir'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, require_versioned=False, want_unversioned=True)) def test_rename_over_deleted(self): tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # The final changes should be: # touch a b c d # add a b c d # commit # rm a d # mv b a # mv c d self.build_tree_contents([ ('tree1/a', 'a contents\n'), ('tree1/b', 'b contents\n'), ('tree1/c', 'c contents\n'), ('tree1/d', 'd contents\n'), ('tree2/a', 'b contents\n'), ('tree2/d', 'c contents\n'), ]) tree1.add(['a', 'b', 'c', 'd'], ['a-id', 'b-id', 'c-id', 'd-id']) tree2.add(['a', 'd'], ['b-id', 'c-id']) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) expected = sorted([ self.deleted(tree1, 'a-id'), self.deleted(tree1, 'd-id'), self.renamed(tree1, tree2, 'b-id', False), self.renamed(tree1, tree2, 'c-id', False), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2)) self.check_has_changes(True, tree1, tree2) def test_deleted_and_unknown(self): """Test a file marked removed, but still present on disk.""" tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # The final changes should be: # bzr add a b c # bzr rm --keep b self.build_tree_contents([ ('tree1/a', 'a contents\n'), ('tree1/b', 'b contents\n'), ('tree1/c', 'c contents\n'), ('tree2/a', 'a contents\n'), ('tree2/b', 'b contents\n'), ('tree2/c', 'c contents\n'), ]) tree1.add(['a', 'b', 'c'], ['a-id', 'b-id', 'c-id']) tree2.add(['a', 'c'], ['a-id', 'c-id']) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_cannot_represent_unversioned(tree2) expected = sorted([ self.deleted(tree1, 'b-id'), self.unversioned(tree2, 'b'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, want_unversioned=True)) expected = sorted([ self.deleted(tree1, 'b-id'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, want_unversioned=False)) def test_renamed_and_added(self): """Test when we have renamed a file, and put another in its place.""" tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # The final changes are: # bzr add b c # bzr mv b a # bzr mv c d # bzr add b c self.build_tree_contents([ ('tree1/b', 'b contents\n'), ('tree1/c', 'c contents\n'), ('tree2/a', 'b contents\n'), ('tree2/b', 'new b contents\n'), ('tree2/c', 'new c contents\n'), ('tree2/d', 'c contents\n'), ]) tree1.add(['b', 'c'], ['b1-id', 'c1-id']) tree2.add(['a', 'b', 'c', 'd'], ['b1-id', 'b2-id', 'c2-id', 'c1-id']) tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) expected = sorted([ self.renamed(tree1, tree2, 'b1-id', False), self.renamed(tree1, tree2, 'c1-id', False), self.added(tree2, 'b2-id'), self.added(tree2, 'c2-id'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, want_unversioned=True)) def test_renamed_and_unknown(self): """A file was moved on the filesystem, but not in bzr.""" tree1 = self.make_branch_and_tree('tree1') tree2 = self.make_to_branch_and_tree('tree2') root_id = tree1.get_root_id() tree2.set_root_id(root_id) # The final changes are: # bzr add a b # mv a a2 self.build_tree_contents([ ('tree1/a', 'a contents\n'), ('tree1/b', 'b contents\n'), ('tree2/a', 'a contents\n'), ('tree2/b', 'b contents\n'), ]) tree1.add(['a', 'b'], ['a-id', 'b-id']) tree2.add(['a', 'b'], ['a-id', 'b-id']) os.rename('tree2/a', 'tree2/a2') tree1, tree2 = self.mutable_trees_to_locked_test_trees(tree1, tree2) self.not_applicable_if_missing_in('a', tree2) expected = sorted([ self.missing('a-id', 'a', 'a', tree2.get_root_id(), 'file'), self.unversioned(tree2, 'a2'), ]) self.assertEqual(expected, self.do_iter_changes(tree1, tree2, want_unversioned=True))