1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
# Copyright (C) 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 WorkingTree.paths2ids.
This API probably needs to be exposed as a tree implementation test, but these
initial tests are for the specific cases being refactored from
find_ids_across_trees.
"""
from operator import attrgetter
from bzrlib import errors
from bzrlib.tests.per_workingtree import TestCaseWithWorkingTree
# TODO: This needs an additional test: do a merge, then do a
# paths2id(trees=left parent only), and also with (trees=all parents) to check
# that only the requested trees are considered - i.e. have an unversioned path
# in the unlisted tree, or an extra file that moves into the selected path but
# should not be returned
# TODO: test that supplying paths with duplication - i.e. foo, foo, foo/bar -
# does not result in garbage out.
# TODO: Are we meant to raise the precise unversioned paths when some are
# unversioned - if so, test this.
class TestPaths2Ids(TestCaseWithWorkingTree):
def assertExpectedIds(self, ids, tree, paths, trees=None,
require_versioned=True):
"""Run paths2ids for tree, and check the result."""
tree.lock_read()
if trees:
map(apply, map(attrgetter('lock_read'), trees))
result = tree.paths2ids(paths, trees,
require_versioned=require_versioned)
map(apply, map(attrgetter('unlock'), trees))
else:
result = tree.paths2ids(paths,
require_versioned=require_versioned)
self.assertEqual(set(ids), result)
tree.unlock()
def test_paths_none_result_none(self):
tree = self.make_branch_and_tree('tree')
tree.lock_read()
self.assertEqual(None, tree.paths2ids(None))
tree.unlock()
def test_find_single_root(self):
tree = self.make_branch_and_tree('tree')
self.assertExpectedIds([tree.path2id('')], tree, [''])
def test_find_tree_and_clone_roots(self):
tree = self.make_branch_and_tree('tree')
clone = tree.bzrdir.clone('clone').open_workingtree()
clone.lock_tree_write()
clone_root_id = 'new-id'
clone.set_root_id(clone_root_id)
tree_root_id = tree.path2id('')
clone.unlock()
self.assertExpectedIds([tree_root_id, clone_root_id], tree, [''], [clone])
def test_find_tree_basis_roots(self):
tree = self.make_branch_and_tree('tree')
tree.commit('basis')
basis = tree.basis_tree()
basis_root_id = basis.path2id('')
tree.lock_tree_write()
tree_root_id = 'new-id'
tree.set_root_id(tree_root_id)
tree.unlock()
self.assertExpectedIds([tree_root_id, basis_root_id], tree, [''], [basis])
def test_find_children_of_moved_directories(self):
"""Check the basic nasty corner case that path2ids should handle.
This is the following situation:
basis:
/ ROOT
/dir dir
/dir/child-moves child-moves
/dir/child-stays child-stays
/dir/child-goes child-goes
current tree:
/ ROOT
/child-moves child-moves
/newdir newdir
/newdir/dir dir
/newdir/dir/child-stays child-stays
/newdir/dir/new-child new-child
In english: we move a directory under a directory that was a sibling,
and at the same time remove, or move out of the directory, some of its
children, and give it a new child previous absent or a sibling.
current_tree.path2ids(['newdir'], [basis]) is meant to handle this
correctly: that is it should return the ids:
newdir because it was provided
dir, because its under newdir in current
child-moves because its under dir in old
child-stays either because its under newdir/dir in current, or under dir in old
child-goes because its under dir in old.
new-child because its under dir in new
Symmetrically, current_tree.path2ids(['dir'], [basis]) is meant to show
new-child, even though its not under the path 'dir' in current, because
its under a path selected by 'dir' in basis:
dir because its selected in basis.
child-moves because its under dir in old
child-stays either because its under newdir/dir in current, or under dir in old
child-goes because its under dir in old.
new-child because its under dir in new.
"""
tree = self.make_branch_and_tree('tree')
self.build_tree(
['tree/dir/', 'tree/dir/child-moves', 'tree/dir/child-stays',
'tree/dir/child-goes'])
tree.add(['dir', 'dir/child-moves', 'dir/child-stays', 'dir/child-goes'],
['dir', 'child-moves', 'child-stays', 'child-goes'])
tree.commit('create basis')
basis = tree.basis_tree()
tree.unversion(['child-goes'])
tree.rename_one('dir/child-moves', 'child-moves')
self.build_tree(['tree/newdir/'])
tree.add(['newdir'], ['newdir'])
tree.rename_one('dir/child-stays', 'child-stays')
tree.rename_one('dir', 'newdir/dir')
tree.rename_one('child-stays', 'newdir/dir/child-stays')
self.build_tree(['tree/newdir/dir/new-child'])
tree.add(['newdir/dir/new-child'], ['new-child'])
self.assertExpectedIds(
['newdir', 'dir', 'child-moves', 'child-stays', 'child-goes',
'new-child'], tree, ['newdir'], [basis])
self.assertExpectedIds(
['dir', 'child-moves', 'child-stays', 'child-goes', 'new-child'],
tree, ['dir'], [basis])
def test_unversioned_one_tree(self):
tree = self.make_branch_and_tree('tree')
self.build_tree(['tree/unversioned'])
self.assertExpectedIds([], tree, ['unversioned'], require_versioned=False)
tree.lock_read()
self.assertRaises(errors.PathsNotVersionedError, tree.paths2ids, ['unversioned'])
tree.unlock()
def test_unversioned_in_one_of_multiple_trees(self):
# in this test, the path is unversioned in only one tree, and thus
# should not raise an error: it must be unversioned in *all* trees to
# error.
tree = self.make_branch_and_tree('tree')
tree.commit('make basis')
basis = tree.basis_tree()
self.build_tree(['tree/in-one'])
tree.add(['in-one'], ['in-one'])
self.assertExpectedIds(['in-one'], tree, ['in-one'], [basis])
def test_unversioned_all_of_multiple_trees(self):
# in this test, the path is unversioned in every tree, and thus
# should not raise an error: it must be unversioned in *all* trees to
# error.
tree = self.make_branch_and_tree('tree')
tree.commit('make basis')
basis = tree.basis_tree()
self.assertExpectedIds([], tree, ['unversioned'], [basis],
require_versioned=False)
tree.lock_read()
basis.lock_read()
self.assertRaises(errors.PathsNotVersionedError, tree.paths2ids,
['unversioned'], [basis])
self.assertRaises(errors.PathsNotVersionedError, basis.paths2ids,
['unversioned'], [tree])
basis.unlock()
tree.unlock()
|