/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_tree.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_tree.py
16
16
 
17
17
"""Tests for Tree and InterTree."""
18
18
 
19
 
from breezy import (
 
19
from bzrlib import (
20
20
    errors,
21
21
    revision,
22
22
    tree as _mod_tree,
23
23
    )
24
 
from breezy.tests import (
25
 
    TestCase,
26
 
    TestCaseWithTransport,
27
 
    )
28
 
from breezy.tree import (
29
 
    FileTimestampUnavailable,
30
 
    InterTree,
31
 
    find_previous_paths,
32
 
    )
33
 
 
34
 
 
35
 
class TestErrors(TestCase):
36
 
 
37
 
    def test_file_timestamp_unavailable(self):
38
 
        e = FileTimestampUnavailable("/path/foo")
39
 
        self.assertEqual("The filestamp for /path/foo is not available.",
40
 
                         str(e))
 
24
from bzrlib.tests import TestCaseWithTransport
 
25
from bzrlib.tree import InterTree
41
26
 
42
27
 
43
28
class TestInterTree(TestCaseWithTransport):
154
139
        # we need to pass a known file with an unknown file to get this to
155
140
        # fail when expected.
156
141
        delta = wt.changes_from(wt.basis_tree(),
157
 
            specific_files=['known_file', 'unknown_file'],
 
142
            specific_files=['known_file', 'unknown_file'] ,
158
143
            require_versioned=False)
159
144
        self.assertEqual(len(delta.added), 1)
160
145
 
183
168
    def test__step_one(self):
184
169
        tree = self.make_branch_and_tree('tree')
185
170
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
186
 
        tree.add(['a', 'b', 'b/c'], [b'a-id', b'b-id', b'c-id'])
 
171
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
187
172
 
188
173
        iterator = tree.iter_entries_by_dir()
189
174
        tree.lock_read()
191
176
 
192
177
        root_id = tree.path2id('')
193
178
        self.assertStepOne(True, '', root_id, iterator)
194
 
        self.assertStepOne(True, 'a', b'a-id', iterator)
195
 
        self.assertStepOne(True, 'b', b'b-id', iterator)
196
 
        self.assertStepOne(True, 'b/c', b'c-id', iterator)
 
179
        self.assertStepOne(True, 'a', 'a-id', iterator)
 
180
        self.assertStepOne(True, 'b', 'b-id', iterator)
 
181
        self.assertStepOne(True, 'b/c', 'c-id', iterator)
197
182
        self.assertStepOne(False, None, None, iterator)
198
183
        self.assertStepOne(False, None, None, iterator)
199
184
 
207
192
        :param exp_other_paths: A list of other_path values.
208
193
        :param iterator: The iterator to step
209
194
        """
210
 
        path, file_id, master_ie, other_values = next(iterator)
 
195
        path, file_id, master_ie, other_values = iterator.next()
211
196
        self.assertEqual((exp_path, exp_file_id), (path, file_id),
212
197
                         'Master entry did not match')
213
198
        if master_has_node:
247
232
    def test_simple_stepping(self):
248
233
        tree = self.make_branch_and_tree('tree')
249
234
        self.build_tree(['tree/a', 'tree/b/', 'tree/b/c'])
250
 
        tree.add(['a', 'b', 'b/c'], [b'a-id', b'b-id', b'c-id'])
 
235
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
251
236
 
252
 
        tree.commit('first', rev_id=b'first-rev-id')
 
237
        tree.commit('first', rev_id='first-rev-id')
253
238
 
254
239
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
255
240
 
256
241
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
257
242
        iterator = walker.iter_all()
258
243
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
259
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
260
 
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
261
 
        self.assertWalkerNext(u'b/c', b'c-id', True, [u'b/c'], iterator)
262
 
        self.assertRaises(StopIteration, next, iterator)
 
244
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
245
        self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
 
246
        self.assertWalkerNext(u'b/c', 'c-id', True, [u'b/c'], iterator)
 
247
        self.assertRaises(StopIteration, iterator.next)
263
248
 
264
249
    def test_master_has_extra(self):
265
250
        tree = self.make_branch_and_tree('tree')
266
251
        self.build_tree(['tree/a', 'tree/b/', 'tree/c', 'tree/d'])
267
 
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
268
 
 
269
 
        tree.commit('first', rev_id=b'first-rev-id')
270
 
 
271
 
        tree.add(['c'], [b'c-id'])
 
252
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
253
 
 
254
        tree.commit('first', rev_id='first-rev-id')
 
255
 
 
256
        tree.add(['c'], ['c-id'])
272
257
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
273
258
 
274
259
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
275
260
        iterator = walker.iter_all()
276
261
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
277
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
278
 
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
279
 
        self.assertWalkerNext(u'c', b'c-id', True, [None], iterator)
280
 
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
281
 
        self.assertRaises(StopIteration, next, iterator)
 
262
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
263
        self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
 
264
        self.assertWalkerNext(u'c', 'c-id', True, [None], iterator)
 
265
        self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
 
266
        self.assertRaises(StopIteration, iterator.next)
282
267
 
283
268
    def test_master_renamed_to_earlier(self):
284
269
        """The record is still present, it just shows up early."""
285
270
        tree = self.make_branch_and_tree('tree')
286
271
        self.build_tree(['tree/a', 'tree/c', 'tree/d'])
287
 
        tree.add(['a', 'c', 'd'], [b'a-id', b'c-id', b'd-id'])
288
 
        tree.commit('first', rev_id=b'first-rev-id')
 
272
        tree.add(['a', 'c', 'd'], ['a-id', 'c-id', 'd-id'])
 
273
        tree.commit('first', rev_id='first-rev-id')
289
274
        tree.rename_one('d', 'b')
290
275
 
291
276
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
293
278
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
294
279
        iterator = walker.iter_all()
295
280
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
296
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
297
 
        self.assertWalkerNext(u'b', b'd-id', True, [u'd'], iterator)
298
 
        self.assertWalkerNext(u'c', b'c-id', True, [u'c'], iterator)
299
 
        self.assertRaises(StopIteration, next, iterator)
 
281
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
282
        self.assertWalkerNext(u'b', 'd-id', True, [u'd'], iterator)
 
283
        self.assertWalkerNext(u'c', 'c-id', True, [u'c'], iterator)
 
284
        self.assertRaises(StopIteration, iterator.next)
300
285
 
301
286
    def test_master_renamed_to_later(self):
302
287
        tree = self.make_branch_and_tree('tree')
303
288
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
304
 
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
305
 
        tree.commit('first', rev_id=b'first-rev-id')
 
289
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
290
        tree.commit('first', rev_id='first-rev-id')
306
291
        tree.rename_one('b', 'e')
307
292
 
308
293
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
310
295
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
311
296
        iterator = walker.iter_all()
312
297
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
313
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
314
 
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
315
 
        self.assertWalkerNext(u'e', b'b-id', True, [u'b'], iterator)
316
 
        self.assertRaises(StopIteration, next, iterator)
 
298
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
299
        self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
 
300
        self.assertWalkerNext(u'e', 'b-id', True, [u'b'], iterator)
 
301
        self.assertRaises(StopIteration, iterator.next)
317
302
 
318
303
    def test_other_extra_in_middle(self):
319
304
        tree = self.make_branch_and_tree('tree')
320
305
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
321
 
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
322
 
        tree.commit('first', rev_id=b'first-rev-id')
 
306
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
307
        tree.commit('first', rev_id='first-rev-id')
323
308
        tree.remove(['b'])
324
309
 
325
310
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
326
311
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
327
312
        iterator = walker.iter_all()
328
313
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
329
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
330
 
        self.assertWalkerNext(u'd', b'd-id', True, [u'd'], iterator)
331
 
        self.assertWalkerNext(u'b', b'b-id', False, [u'b'], iterator)
332
 
        self.assertRaises(StopIteration, next, iterator)
 
314
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
315
        self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
 
316
        self.assertWalkerNext(u'b', 'b-id', False, [u'b'], iterator)
 
317
        self.assertRaises(StopIteration, iterator.next)
333
318
 
334
319
    def test_other_extra_at_end(self):
335
320
        tree = self.make_branch_and_tree('tree')
336
321
        self.build_tree(['tree/a', 'tree/b', 'tree/d'])
337
 
        tree.add(['a', 'b', 'd'], [b'a-id', b'b-id', b'd-id'])
338
 
        tree.commit('first', rev_id=b'first-rev-id')
 
322
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
323
        tree.commit('first', rev_id='first-rev-id')
339
324
        tree.remove(['d'])
340
325
 
341
326
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
342
327
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
343
328
        iterator = walker.iter_all()
344
329
        self.assertWalkerNext(u'', root_id, True, [u''], iterator)
345
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a'], iterator)
346
 
        self.assertWalkerNext(u'b', b'b-id', True, [u'b'], iterator)
347
 
        self.assertWalkerNext(u'd', b'd-id', False, [u'd'], iterator)
348
 
        self.assertRaises(StopIteration, next, iterator)
 
330
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
331
        self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
 
332
        self.assertWalkerNext(u'd', 'd-id', False, [u'd'], iterator)
 
333
        self.assertRaises(StopIteration, iterator.next)
349
334
 
350
335
    def test_others_extra_at_end(self):
351
336
        tree = self.make_branch_and_tree('tree')
352
337
        self.build_tree(['tree/a', 'tree/b', 'tree/c', 'tree/d', 'tree/e'])
353
338
        tree.add(['a', 'b', 'c', 'd', 'e'],
354
 
                 [b'a-id', b'b-id', b'c-id', b'd-id', b'e-id'])
355
 
        tree.commit('first', rev_id=b'first-rev-id')
 
339
                 ['a-id', 'b-id', 'c-id', 'd-id', 'e-id'])
 
340
        tree.commit('first', rev_id='first-rev-id')
356
341
        tree.remove(['e'])
357
 
        tree.commit('second', rev_id=b'second-rev-id')
 
342
        tree.commit('second', rev_id='second-rev-id')
358
343
        tree.remove(['d'])
359
 
        tree.commit('third', rev_id=b'third-rev-id')
 
344
        tree.commit('third', rev_id='third-rev-id')
360
345
        tree.remove(['c'])
361
346
 
362
347
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
363
 
        first_tree = tree.branch.repository.revision_tree(b'first-rev-id')
364
 
        second_tree = tree.branch.repository.revision_tree(b'second-rev-id')
 
348
        first_tree = tree.branch.repository.revision_tree('first-rev-id')
 
349
        second_tree = tree.branch.repository.revision_tree('second-rev-id')
365
350
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree,
366
351
                                              second_tree])
367
352
        iterator = walker.iter_all()
368
353
        self.assertWalkerNext(u'', root_id, True, [u'', u'', u''], iterator)
369
 
        self.assertWalkerNext(u'a', b'a-id', True, [u'a', u'a', u'a'], iterator)
370
 
        self.assertWalkerNext(u'b', b'b-id', True, [u'b', u'b', u'b'], iterator)
371
 
        self.assertWalkerNext(u'c', b'c-id', False, [u'c', u'c', u'c'], iterator)
372
 
        self.assertWalkerNext(u'd', b'd-id', False, [None, u'd', u'd'], iterator)
373
 
        self.assertWalkerNext(u'e', b'e-id', False, [None, u'e', None], iterator)
374
 
        self.assertRaises(StopIteration, next, iterator)
 
354
        self.assertWalkerNext(u'a', 'a-id', True, [u'a', u'a', u'a'], iterator)
 
355
        self.assertWalkerNext(u'b', 'b-id', True, [u'b', u'b', u'b'], iterator)
 
356
        self.assertWalkerNext(u'c', 'c-id', False, [u'c', u'c', u'c'], iterator)
 
357
        self.assertWalkerNext(u'd', 'd-id', False, [None, u'd', u'd'], iterator)
 
358
        self.assertWalkerNext(u'e', 'e-id', False, [None, u'e', None], iterator)
 
359
        self.assertRaises(StopIteration, iterator.next)
375
360
 
376
361
    def test_different_file_id_in_others(self):
377
362
        tree = self.make_branch_and_tree('tree')
378
363
        self.build_tree(['tree/a', 'tree/b', 'tree/c/'])
379
 
        tree.add(['a', 'b', 'c'], [b'a-id', b'b-id', b'c-id'])
380
 
        tree.commit('first', rev_id=b'first-rev-id')
 
364
        tree.add(['a', 'b', 'c'], ['a-id', 'b-id', 'c-id'])
 
365
        tree.commit('first', rev_id='first-rev-id')
381
366
 
382
367
        tree.rename_one('b', 'c/d')
383
368
        self.build_tree(['tree/b'])
384
 
        tree.add(['b'], [b'b2-id'])
385
 
        tree.commit('second', rev_id=b'second-rev-id')
 
369
        tree.add(['b'], ['b2-id'])
 
370
        tree.commit('second', rev_id='second-rev-id')
386
371
 
387
372
        tree.rename_one('a', 'c/e')
388
373
        self.build_tree(['tree/a'])
389
 
        tree.add(['a'], [b'a2-id'])
 
374
        tree.add(['a'], ['a2-id'])
390
375
 
391
376
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
392
 
        first_tree = tree.branch.repository.revision_tree(b'first-rev-id')
 
377
        first_tree = tree.branch.repository.revision_tree('first-rev-id')
393
378
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree])
394
379
 
395
380
        iterator = walker.iter_all()
396
381
        self.assertWalkerNext(u'', root_id, True, [u'', u''], iterator)
397
 
        self.assertWalkerNext(u'a', b'a2-id', True, [None, None], iterator)
398
 
        self.assertWalkerNext(u'b', b'b2-id', True, [u'b', None], iterator)
399
 
        self.assertWalkerNext(u'c', b'c-id', True, [u'c', u'c'], iterator)
400
 
        self.assertWalkerNext(u'c/d', b'b-id', True, [u'c/d', u'b'], iterator)
401
 
        self.assertWalkerNext(u'c/e', b'a-id', True, [u'a', u'a'], iterator)
402
 
        self.assertRaises(StopIteration, next, iterator)
 
382
        self.assertWalkerNext(u'a', 'a2-id', True, [None, None], iterator)
 
383
        self.assertWalkerNext(u'b', 'b2-id', True, [u'b', None], iterator)
 
384
        self.assertWalkerNext(u'c', 'c-id', True, [u'c', u'c'], iterator)
 
385
        self.assertWalkerNext(u'c/d', 'b-id', True, [u'c/d', u'b'], iterator)
 
386
        self.assertWalkerNext(u'c/e', 'a-id', True, [u'a', u'a'], iterator)
 
387
        self.assertRaises(StopIteration, iterator.next)
403
388
 
404
389
    def assertCmpByDirblock(self, cmp_val, path1, path2):
405
390
        self.assertEqual(cmp_val,
431
416
        self.assertPathToKey(([u''], u'a'), u'a')
432
417
        self.assertPathToKey(([u'a'], u'b'), u'a/b')
433
418
        self.assertPathToKey(([u'a', u'b'], u'c'), u'a/b/c')
434
 
 
435
 
 
436
 
class FindPreviousPathsTests(TestCaseWithTransport):
437
 
 
438
 
    def test_new(self):
439
 
        tree = self.make_branch_and_tree('tree')
440
 
        self.build_tree(['tree/b'])
441
 
        tree.add(['b'])
442
 
        revid1 = tree.commit('first')
443
 
        tree1 = tree.branch.repository.revision_tree(revid1)
444
 
 
445
 
        tree0 = tree.branch.repository.revision_tree(revision.NULL_REVISION)
446
 
 
447
 
        self.assertEqual({'b': None}, find_previous_paths(tree1, tree0, ['b']))
448
 
 
449
 
    def test_find_previous_paths(self):
450
 
        tree = self.make_branch_and_tree('tree')
451
 
        self.build_tree(['tree/b'])
452
 
        tree.add(['b'])
453
 
        revid1 = tree.commit('first')
454
 
        tree1 = tree.branch.repository.revision_tree(revid1)
455
 
 
456
 
        tree.rename_one('b', 'c')
457
 
        self.build_tree(['tree/b'])
458
 
        tree.add(['b'])
459
 
        revid2 = tree.commit('second')
460
 
        tree2 = tree.branch.repository.revision_tree(revid2)
461
 
 
462
 
        self.assertEqual({'c': 'b', 'b': None},
463
 
                         find_previous_paths(tree2, tree1, ['b', 'c']))