/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 breezy/tests/test_tree.py

  • Committer: Jelmer Vernooij
  • Date: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

Show diffs side-by-side

added added

removed removed

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