« back to all changes in this revision
Viewing changes to bzrlib/tests/intertree_implementations/test_compare.py
- browse files at revision 2322
- compare with another revision
- compare with revision 2255.7.47
- download diff
- download tarball
- view history from revision 2322
- Committer: Canonical.com Patch Queue Manager
- Date: 2007-03-07 10:45:44 UTC
- mfrom: (2321.1.2 integration)
- Revision ID: pqm@pqm.ubuntu.com-20070307104544-59e3e6358e4bdb29
(robertc) Merge dirstate and subtrees. (Robert Collins, Martin Pool, Aaaron Bentley, John A Meinel, James Westby)
- files added:
- bzrlib/dirstate.py
- files modified:
- BRANCH.TODO
added
removed
bzrlib/tests/intertree_implementations/test_compare.py
1
# Copyright (C) 2006 Canonical Ltd
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
17
17
"""Tests for the InterTree.compare() function."""
18
18
19
19
import os
20
import shutil
20
21
21
from bzrlib import errors
22
from bzrlib import errors, tests, workingtree_4
23
from bzrlib.osutils import file_kind
22
24
from bzrlib.tests.intertree_implementations import TestCaseWithTwoTrees
23
25
26
# TODO: test the include_root option.
27
# TODO: test that renaming a directory x->y does not emit a rename for the
28
# child x/a->y/a.
29
# TODO: test that renaming a directory x-> does not emit a rename for the child
30
# x/a -> y/a when a supplied_files argument gives either 'x/' or 'y/a'
31
# -> that is, when the renamed parent is not processed by the function.
32
# TODO: test items are only emitted once when a specific_files list names a dir
33
# whose parent is now a child.
34
# TODO: test specific_files when the target tree has a file and the source a
35
# dir with children, same id and same path.
36
# TODO: test comparisons between trees with different root ids. mbp 20070301
37
#
38
# TODO: More comparisons between trees with subtrees in different states.
39
#
40
# TODO: Many tests start out by setting the tree roots ids the same, maybe
41
# that should just be the default for these tests, by changing
42
# make_branch_and_tree. mbp 20070307
24
43
25
44
class TestCompare(TestCaseWithTwoTrees):
26
45
27
46
def test_compare_empty_trees(self):
28
47
tree1 = self.make_branch_and_tree('1')
29
48
tree2 = self.make_to_branch_and_tree('2')
49
tree2.set_root_id(tree1.get_root_id())
30
50
tree1 = self.get_tree_no_parents_no_content(tree1)
31
tree2 = self.get_to_tree_no_parents_no_content(tree2)
51
tree2 = self.get_tree_no_parents_no_content(tree2)
52
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
32
53
d = self.intertree_class(tree1, tree2).compare()
33
54
self.assertEqual([], d.added)
34
55
self.assertEqual([], d.modified)
39
60
def test_empty_to_abc_content(self):
40
61
tree1 = self.make_branch_and_tree('1')
41
62
tree2 = self.make_to_branch_and_tree('2')
63
tree2.set_root_id(tree1.get_root_id())
42
64
tree1 = self.get_tree_no_parents_no_content(tree1)
43
tree2 = self.get_to_tree_no_parents_abc_content(tree2)
65
tree2 = self.get_tree_no_parents_abc_content(tree2)
66
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
44
67
d = self.intertree_class(tree1, tree2).compare()
45
68
self.assertEqual([('a', 'a-id', 'file'),
46
69
('b', 'b-id', 'directory'),
52
75
self.assertEqual([], d.unchanged)
53
76
54
77
def test_dangling(self):
78
# This test depends on the ability for some trees to have a difference
79
# between a 'versioned present' and 'versioned not present' (aka
80
# dangling) file. In this test there are two trees each with a separate
81
# dangling file, and the dangling files should be considered absent for
82
# the test.
55
83
tree1 = self.make_branch_and_tree('1')
56
tree2 = self.make_branch_and_tree('2')
84
tree2 = self.make_to_branch_and_tree('2')
85
tree2.set_root_id(tree1.get_root_id())
57
86
self.build_tree(['2/a'])
58
87
tree2.add('a')
59
88
os.unlink('2/a')
60
89
self.build_tree(['1/b'])
61
90
tree1.add('b')
62
91
os.unlink('1/b')
92
# the conversion to test trees here will leave the trees intact for the
93
# default intertree, but may perform a commit for other tree types,
94
# which may reduce the validity of the test. XXX: Think about how to
95
# address this.
96
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
63
97
d = self.intertree_class(tree1, tree2).compare()
64
98
self.assertEqual([], d.added)
65
99
self.assertEqual([], d.modified)
70
104
def test_abc_content_to_empty(self):
71
105
tree1 = self.make_branch_and_tree('1')
72
106
tree2 = self.make_to_branch_and_tree('2')
107
tree2.set_root_id(tree1.get_root_id())
73
108
tree1 = self.get_tree_no_parents_abc_content(tree1)
74
tree2 = self.get_to_tree_no_parents_no_content(tree2)
109
tree2 = self.get_tree_no_parents_no_content(tree2)
110
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
75
111
d = self.intertree_class(tree1, tree2).compare()
76
112
self.assertEqual([], d.added)
77
113
self.assertEqual([], d.modified)
85
121
def test_content_modification(self):
86
122
tree1 = self.make_branch_and_tree('1')
87
123
tree2 = self.make_to_branch_and_tree('2')
124
tree2.set_root_id(tree1.get_root_id())
88
125
tree1 = self.get_tree_no_parents_abc_content(tree1)
89
tree2 = self.get_to_tree_no_parents_abc_content_2(tree2)
126
tree2 = self.get_tree_no_parents_abc_content_2(tree2)
127
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
90
128
d = self.intertree_class(tree1, tree2).compare()
91
129
self.assertEqual([], d.added)
92
130
self.assertEqual([('a', 'a-id', 'file', True, False)], d.modified)
97
135
def test_meta_modification(self):
98
136
tree1 = self.make_branch_and_tree('1')
99
137
tree2 = self.make_to_branch_and_tree('2')
138
tree2.set_root_id(tree1.get_root_id())
100
139
tree1 = self.get_tree_no_parents_abc_content(tree1)
101
tree2 = self.get_to_tree_no_parents_abc_content_3(tree2)
140
tree2 = self.get_tree_no_parents_abc_content_3(tree2)
141
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
102
142
d = self.intertree_class(tree1, tree2).compare()
103
143
self.assertEqual([], d.added)
104
144
self.assertEqual([('b/c', 'c-id', 'file', False, True)], d.modified)
109
149
def test_file_rename(self):
110
150
tree1 = self.make_branch_and_tree('1')
111
151
tree2 = self.make_to_branch_and_tree('2')
152
tree2.set_root_id(tree1.get_root_id())
112
153
tree1 = self.get_tree_no_parents_abc_content(tree1)
113
tree2 = self.get_to_tree_no_parents_abc_content_4(tree2)
154
tree2 = self.get_tree_no_parents_abc_content_4(tree2)
155
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
114
156
d = self.intertree_class(tree1, tree2).compare()
115
157
self.assertEqual([], d.added)
116
158
self.assertEqual([], d.modified)
121
163
def test_file_rename_and_modification(self):
122
164
tree1 = self.make_branch_and_tree('1')
123
165
tree2 = self.make_to_branch_and_tree('2')
166
tree2.set_root_id(tree1.get_root_id())
124
167
tree1 = self.get_tree_no_parents_abc_content(tree1)
125
tree2 = self.get_to_tree_no_parents_abc_content_5(tree2)
168
tree2 = self.get_tree_no_parents_abc_content_5(tree2)
169
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
126
170
d = self.intertree_class(tree1, tree2).compare()
127
171
self.assertEqual([], d.added)
128
172
self.assertEqual([], d.modified)
133
177
def test_file_rename_and_meta_modification(self):
134
178
tree1 = self.make_branch_and_tree('1')
135
179
tree2 = self.make_to_branch_and_tree('2')
180
tree2.set_root_id(tree1.get_root_id())
136
181
tree1 = self.get_tree_no_parents_abc_content(tree1)
137
tree2 = self.get_to_tree_no_parents_abc_content_6(tree2)
182
tree2 = self.get_tree_no_parents_abc_content_6(tree2)
183
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
138
184
d = self.intertree_class(tree1, tree2).compare()
139
185
self.assertEqual([], d.added)
140
186
self.assertEqual([], d.modified)
145
191
def test_empty_to_abc_content_a_only(self):
146
192
tree1 = self.make_branch_and_tree('1')
147
193
tree2 = self.make_to_branch_and_tree('2')
194
tree2.set_root_id(tree1.get_root_id())
148
195
tree1 = self.get_tree_no_parents_no_content(tree1)
149
tree2 = self.get_to_tree_no_parents_abc_content(tree2)
196
tree2 = self.get_tree_no_parents_abc_content(tree2)
197
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
150
198
d = self.intertree_class(tree1, tree2).compare(specific_files=['a'])
151
199
self.assertEqual([('a', 'a-id', 'file')], d.added)
152
200
self.assertEqual([], d.modified)
158
206
tree1 = self.make_branch_and_tree('1')
159
207
tree2 = self.make_to_branch_and_tree('2')
160
208
tree1 = self.get_tree_no_parents_no_content(tree1)
161
tree2 = self.get_to_tree_no_parents_abc_content(tree2)
209
tree2 = self.get_tree_no_parents_abc_content(tree2)
210
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
162
211
d = self.intertree_class(tree1, tree2).compare(
163
212
specific_files=['a', 'b/c'])
164
213
self.assertEqual(
174
223
tree1 = self.make_branch_and_tree('1')
175
224
tree2 = self.make_to_branch_and_tree('2')
176
225
tree1 = self.get_tree_no_parents_no_content(tree1)
177
tree2 = self.get_to_tree_no_parents_abc_content(tree2)
226
tree2 = self.get_tree_no_parents_abc_content(tree2)
227
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
178
228
d = self.intertree_class(tree1, tree2).compare(specific_files=['b'])
179
229
self.assertEqual(
180
230
[('b', 'b-id', 'directory'),('b/c', 'c-id', 'file')],
189
239
tree1 = self.make_branch_and_tree('1')
190
240
tree2 = self.make_to_branch_and_tree('2')
191
241
tree1 = self.get_tree_no_parents_abc_content(tree1)
192
tree2 = self.get_to_tree_no_parents_abc_content_5(tree2)
242
tree2 = self.get_tree_no_parents_abc_content_5(tree2)
243
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
193
244
d = self.intertree_class(tree1, tree2).compare(want_unchanged=True)
194
245
self.assertEqual([], d.added)
195
246
self.assertEqual([], d.modified)
204
255
tree1 = self.make_branch_and_tree('1')
205
256
tree2 = self.make_to_branch_and_tree('2')
206
257
tree1 = self.get_tree_no_parents_abc_content(tree1)
207
tree2 = self.get_to_tree_no_parents_abc_content_3(tree2)
258
tree2 = self.get_tree_no_parents_abc_content_3(tree2)
259
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
260
d = self.intertree_class(tree1, tree2).compare(specific_files=['b'])
208
261
# the type of tree-3 does not matter - it is used as a lookup, not
209
# a dispatch
262
# a dispatch. XXX: For dirstate it does speak to the optimisability of
263
# the lookup, in merged trees it can be fast-pathed. We probably want
264
# two tests: one as is, and one with it as a pending merge.
210
265
tree3 = self.make_branch_and_tree('3')
211
266
tree3 = self.get_tree_no_parents_abc_content_6(tree3)
267
tree3.lock_read()
268
self.addCleanup(tree3.unlock)
212
269
# tree 3 has 'e' which is 'c-id'. Tree 1 has c-id at b/c, and Tree 2
213
270
# has c-id at b/c with its exec flag toggled.
214
271
# without extra_trees, we should get no modifications from this
233
290
tree1 = self.make_branch_and_tree('1')
234
291
tree2 = self.make_to_branch_and_tree('2')
235
292
tree1 = self.get_tree_no_parents_no_content(tree1)
236
tree2 = self.get_to_tree_no_parents_abc_content(tree2)
293
tree2 = self.get_tree_no_parents_abc_content(tree2)
294
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
237
295
self.assertRaises(errors.PathsNotVersionedError,
238
296
self.intertree_class(tree1, tree2).compare,
239
297
specific_files=['d'],
240
298
require_versioned=True)
241
299
300
def test_default_ignores_unversioned_files(self):
301
tree1 = self.make_branch_and_tree('tree1')
302
tree2 = self.make_to_branch_and_tree('tree2')
303
tree2.set_root_id(tree1.get_root_id())
304
self.build_tree(['tree1/a', 'tree1/c',
305
'tree2/a', 'tree2/b', 'tree2/c'])
306
tree1.add(['a', 'c'], ['a-id', 'c-id'])
307
tree2.add(['a', 'c'], ['a-id', 'c-id'])
308
309
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
310
d = self.intertree_class(tree1, tree2).compare()
311
self.assertEqual([], d.added)
312
self.assertEqual([(u'a', 'a-id', 'file', True, False),
313
(u'c', 'c-id', 'file', True, False)], d.modified)
314
self.assertEqual([], d.removed)
315
self.assertEqual([], d.renamed)
316
self.assertEqual([], d.unchanged)
317
self.assertEqual([], d.unversioned)
318
319
def test_unversioned_paths_in_tree(self):
320
tree1 = self.make_branch_and_tree('tree1')
321
tree2 = self.make_to_branch_and_tree('tree2')
322
tree2.set_root_id(tree1.get_root_id())
323
self.build_tree(['tree2/file', 'tree2/dir/'])
324
# try:
325
os.symlink('target', 'tree2/link')
326
links_supported = True
327
# except ???:
328
# links_supported = False
329
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
330
d = self.intertree_class(tree1, tree2).compare(want_unversioned=True)
331
self.assertEqual([], d.added)
332
self.assertEqual([], d.modified)
333
self.assertEqual([], d.removed)
334
self.assertEqual([], d.renamed)
335
self.assertEqual([], d.unchanged)
336
self.assertEqual([(u'dir', None, 'directory'), (u'file', None, 'file'),
337
(u'link', None, 'symlink')], d.unversioned)
338
242
339
243
340
class TestIterChanges(TestCaseWithTwoTrees):
244
341
"""Test the comparison iterator"""
245
342
343
def do_iter_changes(self, tree1, tree2, **extra_args):
344
"""Helper to run _iter_changes from tree1 to tree2.
345
346
:param tree1, tree2: The source and target trees. These will be locked
347
automatically.
348
:param **extra_args: Extra args to pass to _iter_changes. This is not
349
inspected by this test helper.
350
"""
351
tree1.lock_read()
352
tree2.lock_read()
353
try:
354
# sort order of output is not strictly defined
355
return sorted(self.intertree_class(tree1, tree2)
356
._iter_changes(**extra_args))
357
finally:
358
tree1.unlock()
359
tree2.unlock()
360
361
def make_tree_with_special_names(self):
362
"""Create a tree with filenames chosen to exercise the walk order."""
363
tree1 = self.make_branch_and_tree('tree1')
364
tree2 = self.make_to_branch_and_tree('tree2')
365
tree2.set_root_id(tree1.get_root_id())
366
paths, path_ids = self._create_special_names(tree2, 'tree2')
367
tree2.commit('initial', rev_id='rev-1')
368
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
369
return (tree1, tree2, paths, path_ids)
370
371
def make_trees_with_special_names(self):
372
"""Both trees will use the special names.
373
374
But the contents will differ for each file.
375
"""
376
tree1 = self.make_branch_and_tree('tree1')
377
tree2 = self.make_to_branch_and_tree('tree2')
378
tree2.set_root_id(tree1.get_root_id())
379
paths, path_ids = self._create_special_names(tree1, 'tree1')
380
paths, path_ids = self._create_special_names(tree2, 'tree2')
381
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
382
return (tree1, tree2, paths, path_ids)
383
384
def _create_special_names(self, tree, base_path):
385
"""Create a tree with paths that expose differences in sort orders."""
386
# Each directory will have a single file named 'f' inside
387
dirs = ['a',
388
'a-a',
389
'a/a',
390
'a/a-a',
391
'a/a/a',
392
'a/a/a-a',
393
'a/a/a/a',
394
'a/a/a/a-a',
395
'a/a/a/a/a',
396
]
397
with_slashes = []
398
paths = []
399
path_ids = []
400
for d in dirs:
401
with_slashes.append(base_path + '/' + d + '/')
402
with_slashes.append(base_path + '/' + d + '/f')
403
paths.append(d)
404
paths.append(d+'/f')
405
path_ids.append(d.replace('/', '_') + '-id')
406
path_ids.append(d.replace('/', '_') + '_f-id')
407
self.build_tree(with_slashes)
408
tree.add(paths, path_ids)
409
return paths, path_ids
410
246
411
def test_compare_empty_trees(self):
247
412
tree1 = self.make_branch_and_tree('1')
248
413
tree2 = self.make_to_branch_and_tree('2')
249
414
tree1 = self.get_tree_no_parents_no_content(tree1)
250
tree2 = self.get_to_tree_no_parents_no_content(tree2)
251
self.assertEqual([], list(tree2._iter_changes(tree1)))
415
tree2 = self.get_tree_no_parents_no_content(tree2)
416
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
417
self.assertEqual([], self.do_iter_changes(tree1, tree2))
252
418
253
419
def added(self, tree, file_id):
254
420
entry = tree.inventory[file_id]
255
421
path = tree.id2path(file_id)
256
return (file_id, path, True, (False, True), (None, entry.parent_id),
257
(None, entry.name), (None, entry.kind),
422
return (file_id, (None, path), True, (False, True), (None, entry.parent_id),
423
(None, entry.name), (None, entry.kind),
258
424
(None, entry.executable))
259
425
426
def content_changed(self, tree, file_id):
427
entry = tree.inventory[file_id]
428
path = tree.id2path(file_id)
429
return (file_id, (path, path), True, (True, True), (entry.parent_id, entry.parent_id),
430
(entry.name, entry.name), (entry.kind, entry.kind),
431
(entry.executable, entry.executable))
432
433
def kind_changed(self, from_tree, to_tree, file_id):
434
old_entry = from_tree.inventory[file_id]
435
new_entry = to_tree.inventory[file_id]
436
path = to_tree.id2path(file_id)
437
from_path = from_tree.id2path(file_id)
438
return (file_id, (from_path, path), True, (True, True), (old_entry.parent_id, new_entry.parent_id),
439
(old_entry.name, new_entry.name), (old_entry.kind, new_entry.kind),
440
(old_entry.executable, new_entry.executable))
441
442
def missing(self, file_id, from_path, to_path, parent_id, kind):
443
_, from_basename = os.path.split(from_path)
444
_, to_basename = os.path.split(to_path)
445
# missing files have both paths, but no kind.
446
return (file_id, (from_path, to_path), True, (True, True),
447
(parent_id, parent_id),
448
(from_basename, to_basename), (kind, None), (False, False))
449
260
450
def deleted(self, tree, file_id):
261
451
entry = tree.inventory[file_id]
262
452
path = tree.id2path(file_id)
263
return (file_id, path, True, (True, False), (entry.parent_id, None),
264
(entry.name, None), (entry.kind, None),
453
return (file_id, (path, None), True, (True, False), (entry.parent_id, None),
454
(entry.name, None), (entry.kind, None),
265
455
(entry.executable, None))
266
456
457
def renamed(self, from_tree, to_tree, file_id, content_changed):
458
from_entry = from_tree.inventory[file_id]
459
to_entry = to_tree.inventory[file_id]
460
from_path = from_tree.id2path(file_id)
461
to_path = to_tree.id2path(file_id)
462
return (file_id, (from_path, to_path), content_changed, (True, True),
463
(from_entry.parent_id, to_entry.parent_id),
464
(from_entry.name, to_entry.name),
465
(from_entry.kind, to_entry.kind),
466
(from_entry.executable, to_entry.executable))
467
468
def unchanged(self, tree, file_id):
469
entry = tree.inventory[file_id]
470
parent = entry.parent_id
471
name = entry.name
472
kind = entry.kind
473
executable = entry.executable
474
path = tree.id2path(file_id)
475
return (file_id, (path, path), False, (True, True),
476
(parent, parent), (name, name), (kind, kind),
477
(executable, executable))
478
479
def unversioned(self, tree, path):
480
"""Create an unversioned result."""
481
_, basename = os.path.split(path)
482
kind = file_kind(tree.abspath(path))
483
return (None, (None, path), True, (False, False), (None, None),
484
(None, basename), (None, kind),
485
(None, False))
486
267
487
def test_empty_to_abc_content(self):
268
488
tree1 = self.make_branch_and_tree('1')
269
489
tree2 = self.make_to_branch_and_tree('2')
270
490
tree1 = self.get_tree_no_parents_no_content(tree1)
271
tree2 = self.get_to_tree_no_parents_abc_content(tree2)
272
273
self.assertEqual([self.added(tree2, 'root-id'),
274
self.added(tree2, 'a-id'),
275
self.added(tree2, 'b-id'),
276
self.added(tree2, 'c-id'),
277
self.deleted(tree1, 'empty-root-id')],
278
list(tree2._iter_changes(tree1)))
491
tree2 = self.get_tree_no_parents_abc_content(tree2)
492
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
493
tree1.lock_read()
494
tree2.lock_read()
495
expected_results = sorted([
496
self.added(tree2, 'root-id'),
497
self.added(tree2, 'a-id'),
498
self.added(tree2, 'b-id'),
499
self.added(tree2, 'c-id'),
500
self.deleted(tree1, 'empty-root-id')])
501
tree1.unlock()
502
tree2.unlock()
503
self.assertEqual(expected_results, self.do_iter_changes(tree1, tree2))
279
504
280
505
def test_empty_to_abc_content_a_only(self):
281
506
tree1 = self.make_branch_and_tree('1')
282
507
tree2 = self.make_to_branch_and_tree('2')
283
508
tree1 = self.get_tree_no_parents_no_content(tree1)
284
tree2 = self.get_to_tree_no_parents_abc_content(tree2)
285
self.assertEqual([self.added(tree2, 'a-id')],
286
list(tree2._iter_changes(tree1,
287
specific_file_ids=['a-id'])))
288
self.assertEqual([self.deleted(tree2, 'a-id')],
289
list(tree1._iter_changes(tree2,
290
specific_file_ids=['a-id'])))
509
tree2 = self.get_tree_no_parents_abc_content(tree2)
510
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
511
tree1.lock_read()
512
tree2.lock_read()
513
self.assertEqual(
514
[self.added(tree2, 'a-id')],
515
self.do_iter_changes(tree1, tree2, specific_files=['a']))
516
tree1.unlock()
517
tree2.unlock()
518
519
def test_abc_content_to_empty_to_abc_content_a_only(self):
520
tree1 = self.make_branch_and_tree('1')
521
tree2 = self.make_to_branch_and_tree('2')
522
tree1 = self.get_tree_no_parents_abc_content(tree1)
523
tree2 = self.get_tree_no_parents_no_content(tree2)
524
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
525
tree1.lock_read()
526
tree2.lock_read()
527
self.assertEqual(
528
[self.deleted(tree1, 'a-id')],
529
self.do_iter_changes(tree1, tree2, specific_files=['a']))
530
tree1.unlock()
531
tree2.unlock()
291
532
292
533
def test_empty_to_abc_content_a_and_c_only(self):
293
534
tree1 = self.make_branch_and_tree('1')
294
535
tree2 = self.make_to_branch_and_tree('2')
295
536
tree1 = self.get_tree_no_parents_no_content(tree1)
296
tree2 = self.get_to_tree_no_parents_abc_content(tree2)
297
self.assertEqual([self.added(tree2, 'a-id'),
298
self.added(tree2, 'c-id')],
299
list(tree2._iter_changes(tree1,
300
specific_file_ids=['a-id',
301
'c-id'])))
302
d = self.intertree_class(tree1, tree2).compare(
303
specific_files=['a', 'b/c'])
537
tree2 = self.get_tree_no_parents_abc_content(tree2)
538
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
539
tree1.lock_read()
540
tree2.lock_read()
541
expected_result = [self.added(tree2, 'a-id'), self.added(tree2, 'c-id')]
542
tree1.unlock()
543
tree2.unlock()
544
self.assertEqual(expected_result,
545
self.do_iter_changes(tree1, tree2, specific_files=['a', 'b/c']))
304
546
305
def test_abc_content(self):
547
def test_abc_content_to_empty(self):
306
548
tree1 = self.make_branch_and_tree('1')
307
549
tree2 = self.make_to_branch_and_tree('2')
308
tree1 = self.get_tree_no_parents_no_content(tree1)
309
tree2 = self.get_to_tree_no_parents_abc_content(tree2)
550
tree1 = self.get_tree_no_parents_abc_content(tree1)
551
tree2 = self.get_tree_no_parents_no_content(tree2)
552
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
553
tree1.lock_read()
554
tree2.lock_read()
310
555
def deleted(file_id):
311
entry = tree2.inventory[file_id]
312
path = tree2.id2path(file_id)
313
return (file_id, path, True, (True, False),
556
entry = tree1.inventory[file_id]
557
path = tree1.id2path(file_id)
558
return (file_id, (path, None), True, (True, False),
314
559
(entry.parent_id, None),
315
(entry.name, None), (entry.kind, None),
560
(entry.name, None), (entry.kind, None),
316
561
(entry.executable, None))
317
self.assertEqual([self.added(tree1, 'empty-root-id'),
318
deleted('root-id'), deleted('a-id'),
319
deleted('b-id'), deleted('c-id')],
320
list(tree1._iter_changes(tree2)))
562
expected_results = sorted([
563
self.added(tree2, 'empty-root-id'),
564
deleted('root-id'), deleted('a-id'),
565
deleted('b-id'), deleted('c-id')])
566
tree1.unlock()
567
tree2.unlock()
568
self.assertEqual(
569
expected_results,
570
self.do_iter_changes(tree1, tree2))
321
571
322
572
def test_content_modification(self):
323
573
tree1 = self.make_branch_and_tree('1')
324
574
tree2 = self.make_to_branch_and_tree('2')
325
575
tree1 = self.get_tree_no_parents_abc_content(tree1)
326
tree2 = self.get_to_tree_no_parents_abc_content_2(tree2)
327
root_id = tree1.inventory.root.file_id
328
self.assertEqual([('a-id', 'a', True, (True, True),
329
(root_id, root_id), ('a', 'a'),
330
('file', 'file'), (False, False))],
331
list(tree2._iter_changes(tree1)))
576
tree2 = self.get_tree_no_parents_abc_content_2(tree2)
577
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
578
root_id = tree1.path2id('')
579
self.assertEqual([('a-id', ('a', 'a'), True, (True, True),
580
(root_id, root_id), ('a', 'a'),
581
('file', 'file'), (False, False))],
582
self.do_iter_changes(tree1, tree2))
332
583
333
584
def test_meta_modification(self):
334
585
tree1 = self.make_branch_and_tree('1')
335
586
tree2 = self.make_to_branch_and_tree('2')
336
587
tree1 = self.get_tree_no_parents_abc_content(tree1)
337
tree2 = self.get_to_tree_no_parents_abc_content_3(tree2)
338
self.assertEqual([('c-id', 'b/c', False, (True, True),
339
('b-id', 'b-id'), ('c', 'c'), ('file', 'file'),
340
(False, True))], list(tree2._iter_changes(tree1)))
588
tree2 = self.get_tree_no_parents_abc_content_3(tree2)
589
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
590
self.assertEqual([('c-id', ('b/c', 'b/c'), False, (True, True),
591
('b-id', 'b-id'), ('c', 'c'), ('file', 'file'),
592
(False, True))],
593
self.do_iter_changes(tree1, tree2))
594
595
def test_empty_dir(self):
596
"""an empty dir should not cause glitches to surrounding files."""
597
tree1 = self.make_branch_and_tree('1')
598
tree2 = self.make_to_branch_and_tree('2')
599
tree1 = self.get_tree_no_parents_abc_content(tree1)
600
tree2 = self.get_tree_no_parents_abc_content(tree2)
601
# the pathname is chosen to fall between 'a' and 'b'.
602
self.build_tree(['1/a-empty/', '2/a-empty/'])
603
tree1.add(['a-empty'], ['a-empty'])
604
tree2.add(['a-empty'], ['a-empty'])
605
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
606
expected = []
607
self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
341
608
342
609
def test_file_rename(self):
343
610
tree1 = self.make_branch_and_tree('1')
344
611
tree2 = self.make_to_branch_and_tree('2')
345
612
tree1 = self.get_tree_no_parents_abc_content(tree1)
346
tree2 = self.get_to_tree_no_parents_abc_content_4(tree2)
347
root_id = tree1.inventory.root.file_id
348
self.assertEqual([('a-id', 'd', False, (True, True),
349
(root_id, root_id), ('a', 'd'), ('file', 'file'),
350
(False, False))], list(tree2._iter_changes(tree1)))
613
tree2 = self.get_tree_no_parents_abc_content_4(tree2)
614
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
615
root_id = tree1.path2id('')
616
self.assertEqual([('a-id', ('a', 'd'), False, (True, True),
617
(root_id, root_id), ('a', 'd'), ('file', 'file'),
618
(False, False))],
619
self.do_iter_changes(tree1, tree2))
351
620
352
621
def test_file_rename_and_modification(self):
353
622
tree1 = self.make_branch_and_tree('1')
354
623
tree2 = self.make_to_branch_and_tree('2')
355
624
tree1 = self.get_tree_no_parents_abc_content(tree1)
356
tree2 = self.get_to_tree_no_parents_abc_content_5(tree2)
357
root_id = tree1.inventory.root.file_id
358
self.assertEqual([('a-id', 'd', True, (True, True),
359
(root_id, root_id), ('a', 'd'), ('file', 'file'),
360
(False, False))], list(tree2._iter_changes(tree1)))
625
tree2 = self.get_tree_no_parents_abc_content_5(tree2)
626
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
627
root_id = tree1.path2id('')
628
self.assertEqual([('a-id', ('a', 'd'), True, (True, True),
629
(root_id, root_id), ('a', 'd'), ('file', 'file'),
630
(False, False))],
631
self.do_iter_changes(tree1, tree2))
361
632
362
633
def test_file_rename_and_meta_modification(self):
363
634
tree1 = self.make_branch_and_tree('1')
364
635
tree2 = self.make_to_branch_and_tree('2')
365
636
tree1 = self.get_tree_no_parents_abc_content(tree1)
366
tree2 = self.get_to_tree_no_parents_abc_content_6(tree2)
367
root_id = tree1.inventory.root.file_id
368
self.assertEqual([('c-id', 'e', False, (True, True),
369
('b-id', root_id), ('c', 'e'), ('file', 'file'),
370
(False, True))], list(tree2._iter_changes(tree1)))
637
tree2 = self.get_tree_no_parents_abc_content_6(tree2)
638
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
639
root_id = tree1.path2id('')
640
self.assertEqual([('c-id', ('b/c', 'e'), False, (True, True),
641
('b-id', root_id), ('c', 'e'), ('file', 'file'),
642
(False, True))],
643
self.do_iter_changes(tree1, tree2))
644
645
def test_missing_in_target(self):
646
"""Test with the target files versioned but absent from disk."""
647
tree1 = self.make_branch_and_tree('1')
648
tree2 = self.make_to_branch_and_tree('2')
649
tree1 = self.get_tree_no_parents_abc_content(tree1)
650
tree2 = self.get_tree_no_parents_abc_content(tree2)
651
os.unlink('2/a')
652
shutil.rmtree('2/b')
653
# TODO ? have a symlink here?
654
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
655
root_id = tree1.path2id('')
656
expected = sorted([
657
self.missing('a-id', 'a', 'a', root_id, 'file'),
658
self.missing('b-id', 'b', 'b', root_id, 'directory'),
659
self.missing('c-id', 'b/c', 'b/c', 'b-id', 'file'),
660
])
661
self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
662
663
def test_missing_and_renamed(self):
664
tree1 = self.make_branch_and_tree('tree1')
665
tree2 = self.make_to_branch_and_tree('tree2')
666
tree2.set_root_id(tree1.get_root_id())
667
self.build_tree(['tree1/file'])
668
tree1.add(['file'], ['file-id'])
669
self.build_tree(['tree2/directory/'])
670
tree2.add(['directory'], ['file-id'])
671
os.rmdir('tree2/directory')
672
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
673
tree1.lock_read()
674
self.addCleanup(tree1.unlock)
675
tree2.lock_read()
676
self.addCleanup(tree2.unlock)
677
root_id = tree1.path2id('')
678
expected = sorted([
679
self.missing('file-id', 'file', 'directory', root_id, 'file'),
680
])
681
self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
371
682
372
683
def test_unchanged_with_renames_and_modifications(self):
373
684
"""want_unchanged should generate a list of unchanged entries."""
374
685
tree1 = self.make_branch_and_tree('1')
375
686
tree2 = self.make_to_branch_and_tree('2')
376
687
tree1 = self.get_tree_no_parents_abc_content(tree1)
377
tree2 = self.get_to_tree_no_parents_abc_content_5(tree2)
378
root_id = tree1.inventory.root.file_id
379
def unchanged(file_id):
380
entry = tree1.inventory[file_id]
381
parent = entry.parent_id
382
name = entry.name
383
kind = entry.kind
384
executable = entry.executable
385
return (file_id, tree1.id2path(file_id), False, (True, True),
386
(parent, parent), (name, name), (kind, kind),
387
(executable, executable))
388
self.assertEqual([unchanged(root_id), unchanged('b-id'),
389
('a-id', 'd', True, (True, True),
390
(root_id, root_id), ('a', 'd'), ('file', 'file'),
391
(False, False)), unchanged('c-id')],
392
list(tree2._iter_changes(tree1,
393
include_unchanged=True)))
688
tree2 = self.get_tree_no_parents_abc_content_5(tree2)
689
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
690
root_id = tree1.path2id('')
691
tree1.lock_read()
692
self.addCleanup(tree1.unlock)
693
tree2.lock_read()
694
self.addCleanup(tree2.unlock)
695
self.assertEqual(sorted([self.unchanged(tree1, root_id),
696
self.unchanged(tree1, 'b-id'),
697
('a-id', ('a', 'd'), True, (True, True),
698
(root_id, root_id), ('a', 'd'), ('file', 'file'),
699
(False, False)), self.unchanged(tree1, 'c-id')]),
700
self.do_iter_changes(tree1, tree2, include_unchanged=True))
701
702
def test_compare_subtrees(self):
703
"""want_unchanged should generate a list of unchanged entries."""
704
tree1 = self.make_branch_and_tree('1')
705
if not tree1.supports_tree_reference():
706
raise tests.TestSkipped('Tree %s does not support references'
707
% (tree1,))
708
tree1.set_root_id('root-id')
709
subtree1 = self.make_branch_and_tree('1/sub')
710
subtree1.set_root_id('subtree-id')
711
tree1.add_reference(subtree1)
712
713
tree2 = self.make_to_branch_and_tree('2')
714
if not tree2.supports_tree_reference():
715
raise tests.TestSkipped('Tree %s does not support references'
716
% (tree2,))
717
tree2.set_root_id('root-id')
718
subtree2 = self.make_to_branch_and_tree('2/sub')
719
subtree2.set_root_id('subtree-id')
720
tree2.add_reference(subtree2)
721
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
722
tree1.lock_read()
723
self.addCleanup(tree1.unlock)
724
tree2.lock_read()
725
self.addCleanup(tree2.unlock)
726
self.assertEqual([], list(tree2._iter_changes(tree1)))
727
subtree1.commit('commit', rev_id='commit-a')
728
self.assertEqual([
729
('root-id',
730
(u'', u''),
731
False,
732
(True, True),
733
(None, None),
734
(u'', u''),
735
('directory', 'directory'),
736
(False, False)),
737
('subtree-id',
738
('sub', 'sub',),
739
False,
740
(True, True),
741
('root-id', 'root-id'),
742
('sub', 'sub'),
743
('tree-reference', 'tree-reference'),
744
(False, False))],
745
list(tree2._iter_changes(tree1,
746
include_unchanged=True)))
747
748
def test_default_ignores_unversioned_files(self):
749
tree1 = self.make_branch_and_tree('tree1')
750
tree2 = self.make_to_branch_and_tree('tree2')
751
tree2.set_root_id(tree1.get_root_id())
752
self.build_tree(['tree1/a', 'tree1/c',
753
'tree2/a', 'tree2/b', 'tree2/c'])
754
tree1.add(['a', 'c'], ['a-id', 'c-id'])
755
tree2.add(['a', 'c'], ['a-id', 'c-id'])
756
757
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
758
tree1.lock_read()
759
self.addCleanup(tree1.unlock)
760
tree2.lock_read()
761
self.addCleanup(tree2.unlock)
762
763
# We should ignore the fact that 'b' exists in tree-2
764
# because the want_unversioned parameter was not given.
765
expected = sorted([
766
self.content_changed(tree2, 'a-id'),
767
self.content_changed(tree2, 'c-id'),
768
])
769
self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
770
771
def test_unversioned_paths_in_tree(self):
772
tree1 = self.make_branch_and_tree('tree1')
773
tree2 = self.make_to_branch_and_tree('tree2')
774
tree2.set_root_id(tree1.get_root_id())
775
self.build_tree(['tree2/file', 'tree2/dir/'])
776
# try:
777
os.symlink('target', 'tree2/link')
778
links_supported = True
779
# except ???:
780
# links_supported = False
781
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
782
tree1.lock_read()
783
self.addCleanup(tree1.unlock)
784
tree2.lock_read()
785
self.addCleanup(tree2.unlock)
786
expected = [
787
self.unversioned(tree2, 'file'),
788
self.unversioned(tree2, 'dir'),
789
]
790
if links_supported:
791
expected.append(self.unversioned(tree2, 'link'))
792
expected = sorted(expected)
793
self.assertEqual(expected, self.do_iter_changes(tree1, tree2,
794
want_unversioned=True))
795
796
def test_unversioned_paths_in_tree_specific_files(self):
797
tree1 = self.make_branch_and_tree('tree1')
798
tree2 = self.make_to_branch_and_tree('tree2')
799
self.build_tree(['tree2/file', 'tree2/dir/'])
800
# try:
801
os.symlink('target', 'tree2/link')
802
links_supported = True
803
# except ???:
804
# links_supported = False
805
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
806
tree1.lock_read()
807
self.addCleanup(tree1.unlock)
808
tree2.lock_read()
809
self.addCleanup(tree2.unlock)
810
expected = [
811
self.unversioned(tree2, 'file'),
812
self.unversioned(tree2, 'dir'),
813
]
814
specific_files=['file', 'dir']
815
if links_supported:
816
expected.append(self.unversioned(tree2, 'link'))
817
specific_files.append('link')
818
expected = sorted(expected)
819
self.assertEqual(expected, self.do_iter_changes(tree1, tree2,
820
specific_files=specific_files, require_versioned=False,
821
want_unversioned=True))
822
823
def test_unversioned_paths_in_target_matching_source_old_names(self):
824
# its likely that naive implementations of unversioned file support
825
# will fail if the path was versioned, but is not any more,
826
# due to a rename, not due to unversioning it.
827
# That is, if the old tree has a versioned file 'foo', and
828
# the new tree has the same file but versioned as 'bar', and also
829
# has an unknown file 'foo', we should get back output for
830
# both foo and bar.
831
tree1 = self.make_branch_and_tree('tree1')
832
tree2 = self.make_to_branch_and_tree('tree2')
833
tree2.set_root_id(tree1.get_root_id())
834
self.build_tree(['tree2/file', 'tree2/dir/',
835
'tree1/file', 'tree2/movedfile',
836
'tree1/dir/', 'tree2/moveddir/'])
837
# try:
838
os.symlink('target', 'tree1/link')
839
os.symlink('target', 'tree2/link')
840
os.symlink('target', 'tree2/movedlink')
841
links_supported = True
842
# except ???:
843
# links_supported = False
844
tree1.add(['file', 'dir', 'link'], ['file-id', 'dir-id', 'link-id'])
845
tree2.add(['movedfile', 'moveddir', 'movedlink'],
846
['file-id', 'dir-id', 'link-id'])
847
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
848
root_id = tree1.path2id('')
849
tree1.lock_read()
850
self.addCleanup(tree1.unlock)
851
tree2.lock_read()
852
self.addCleanup(tree2.unlock)
853
expected = [
854
self.renamed(tree1, tree2, 'dir-id', False),
855
self.renamed(tree1, tree2, 'file-id', True),
856
self.unversioned(tree2, 'file'),
857
self.unversioned(tree2, 'dir'),
858
]
859
specific_files=['file', 'dir']
860
if links_supported:
861
expected.append(self.renamed(tree1, tree2, 'link-id', False))
862
expected.append(self.unversioned(tree2, 'link'))
863
specific_files.append('link')
864
expected = sorted(expected)
865
# run once with, and once without specific files, to catch
866
# potentially different code paths.
867
self.assertEqual(expected, self.do_iter_changes(tree1, tree2,
868
require_versioned=False,
869
want_unversioned=True))
870
self.assertEqual(expected, self.do_iter_changes(tree1, tree2,
871
specific_files=specific_files, require_versioned=False,
872
want_unversioned=True))
873
874
def test_unversioned_subtree_only_emits_root(self):
875
tree1 = self.make_branch_and_tree('tree1')
876
tree2 = self.make_to_branch_and_tree('tree2')
877
tree2.set_root_id(tree1.get_root_id())
878
self.build_tree(['tree2/dir/', 'tree2/dir/file'])
879
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
880
expected = [
881
self.unversioned(tree2, 'dir'),
882
]
883
self.assertEqual(expected, self.do_iter_changes(tree1, tree2,
884
want_unversioned=True))
885
886
def make_trees_with_symlinks(self):
887
tree1 = self.make_branch_and_tree('tree1')
888
tree2 = self.make_to_branch_and_tree('tree2')
889
tree2.set_root_id(tree1.get_root_id())
890
self.build_tree(['tree1/fromfile', 'tree1/fromdir/'])
891
self.build_tree(['tree2/tofile', 'tree2/todir/', 'tree2/unknown'])
892
# try:
893
os.symlink('original', 'tree1/changed')
894
os.symlink('original', 'tree1/removed')
895
os.symlink('original', 'tree1/tofile')
896
os.symlink('original', 'tree1/todir')
897
# we make the unchanged link point at unknown to catch incorrect
898
# symlink-following code in the specified_files test.
899
os.symlink('unknown', 'tree1/unchanged')
900
os.symlink('new', 'tree2/added')
901
os.symlink('new', 'tree2/changed')
902
os.symlink('new', 'tree2/fromfile')
903
os.symlink('new', 'tree2/fromdir')
904
os.symlink('unknown', 'tree2/unchanged')
905
from_paths_and_ids = [
906
'fromdir',
907
'fromfile',
908
'changed',
909
'removed',
910
'todir',
911
'tofile',
912
'unchanged',
913
]
914
to_paths_and_ids = [
915
'added',
916
'fromdir',
917
'fromfile',
918
'changed',
919
'todir',
920
'tofile',
921
'unchanged',
922
]
923
tree1.add(from_paths_and_ids, from_paths_and_ids)
924
tree2.add(to_paths_and_ids, to_paths_and_ids)
925
# except ???:
926
# raise TestSkipped('OS does not support symlinks')
927
# links_supported = False
928
return self.mutable_trees_to_test_trees(tree1, tree2)
929
930
def test_versioned_symlinks(self):
931
tree1, tree2 = self.make_trees_with_symlinks()
932
root_id = tree1.path2id('')
933
tree1.lock_read()
934
self.addCleanup(tree1.unlock)
935
tree2.lock_read()
936
self.addCleanup(tree2.unlock)
937
expected = [
938
self.unchanged(tree1, tree1.path2id('')),
939
self.added(tree2, 'added'),
940
self.content_changed(tree2, 'changed'),
941
self.kind_changed(tree1, tree2, 'fromdir'),
942
self.kind_changed(tree1, tree2, 'fromfile'),
943
self.deleted(tree1, 'removed'),
944
self.unchanged(tree2, 'unchanged'),
945
self.unversioned(tree2, 'unknown'),
946
self.kind_changed(tree1, tree2, 'todir'),
947
self.kind_changed(tree1, tree2, 'tofile'),
948
]
949
expected = sorted(expected)
950
self.assertEqual(expected,
951
self.do_iter_changes(tree1, tree2, include_unchanged=True,
952
want_unversioned=True))
953
954
def test_versioned_symlinks_specific_files(self):
955
tree1, tree2 = self.make_trees_with_symlinks()
956
root_id = tree1.path2id('')
957
tree1.lock_read()
958
self.addCleanup(tree1.unlock)
959
tree2.lock_read()
960
self.addCleanup(tree2.unlock)
961
expected = [
962
self.added(tree2, 'added'),
963
self.content_changed(tree2, 'changed'),
964
self.kind_changed(tree1, tree2, 'fromdir'),
965
self.kind_changed(tree1, tree2, 'fromfile'),
966
self.deleted(tree1, 'removed'),
967
self.kind_changed(tree1, tree2, 'todir'),
968
self.kind_changed(tree1, tree2, 'tofile'),
969
]
970
expected = sorted(expected)
971
# we should get back just the changed links. We pass in 'unchanged' to
972
# make sure that it is correctly not returned - and neither is the
973
# unknown path 'unknown' which it points at.
974
self.assertEqual(expected, self.do_iter_changes(tree1, tree2,
975
specific_files=['added', 'changed', 'fromdir', 'fromfile',
976
'removed', 'unchanged', 'todir', 'tofile']))
977
978
def test_tree_with_special_names(self):
979
tree1, tree2, paths, path_ids = self.make_tree_with_special_names()
980
tree1.lock_read()
981
self.addCleanup(tree1.unlock)
982
tree2.lock_read()
983
self.addCleanup(tree2.unlock)
984
expected = sorted(self.added(tree2, f_id) for f_id in path_ids)
985
self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
986
987
def test_trees_with_special_names(self):
988
tree1, tree2, paths, path_ids = self.make_trees_with_special_names()
989
tree1.lock_read()
990
self.addCleanup(tree1.unlock)
991
tree2.lock_read()
992
self.addCleanup(tree2.unlock)
993
expected = sorted(self.content_changed(tree2, f_id) for f_id in path_ids
994
if f_id.endswith('_f-id'))
995
self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
996
997
def test_trees_with_deleted_dir(self):
998
tree1 = self.make_branch_and_tree('tree1')
999
tree2 = self.make_to_branch_and_tree('tree2')
1000
tree2.set_root_id(tree1.get_root_id())
1001
self.build_tree(['tree1/a', 'tree1/b/', 'tree1/b/c',
1002
'tree1/b/d/', 'tree1/b/d/e', 'tree1/f/', 'tree1/f/g',
1003
'tree2/a', 'tree2/f/', 'tree2/f/g'])
1004
tree1.add(['a', 'b', 'b/c', 'b/d/', 'b/d/e', 'f', 'f/g'],
1005
['a-id', 'b-id', 'c-id', 'd-id', 'e-id', 'f-id', 'g-id'])
1006
tree2.add(['a', 'f', 'f/g'], ['a-id', 'f-id', 'g-id'])
1007
1008
tree1, tree2 = self.mutable_trees_to_test_trees(tree1, tree2)
1009
tree1.lock_read()
1010
self.addCleanup(tree1.unlock)
1011
tree2.lock_read()
1012
self.addCleanup(tree2.unlock)
1013
# We should notice that 'b' and all its children are deleted
1014
expected = sorted([
1015
self.content_changed(tree2, 'a-id'),
1016
self.content_changed(tree2, 'g-id'),
1017
self.deleted(tree1, 'b-id'),
1018
self.deleted(tree1, 'c-id'),
1019
self.deleted(tree1, 'd-id'),
1020
self.deleted(tree1, 'e-id'),
1021
])
1022
self.assertEqual(expected, self.do_iter_changes(tree1, tree2))
Loggerhead is a web-based interface for Breezy
Version: 2.0.1