/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-03-24 17:48:04 UTC
  • mfrom: (6921 work)
  • mto: This revision was merged to the branch mainline in revision 6923.
  • Revision ID: jelmer@jelmer.uk-20180324174804-xf22o05byoj12x1q
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_tree.py
183
183
    def test__step_one(self):
184
184
        tree = self.make_branch_and_tree('tree')
185
185
        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'])
 
186
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
187
187
 
188
188
        iterator = tree.iter_entries_by_dir()
189
189
        tree.lock_read()
191
191
 
192
192
        root_id = tree.path2id('')
193
193
        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)
 
194
        self.assertStepOne(True, 'a', 'a-id', iterator)
 
195
        self.assertStepOne(True, 'b', 'b-id', iterator)
 
196
        self.assertStepOne(True, 'b/c', 'c-id', iterator)
197
197
        self.assertStepOne(False, None, None, iterator)
198
198
        self.assertStepOne(False, None, None, iterator)
199
199
 
247
247
    def test_simple_stepping(self):
248
248
        tree = self.make_branch_and_tree('tree')
249
249
        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'])
 
250
        tree.add(['a', 'b', 'b/c'], ['a-id', 'b-id', 'c-id'])
251
251
 
252
 
        tree.commit('first', rev_id=b'first-rev-id')
 
252
        tree.commit('first', rev_id='first-rev-id')
253
253
 
254
254
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
255
255
 
256
256
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
257
257
        iterator = walker.iter_all()
258
258
        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)
 
259
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
260
        self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
 
261
        self.assertWalkerNext(u'b/c', 'c-id', True, [u'b/c'], iterator)
262
262
        self.assertRaises(StopIteration, next, iterator)
263
263
 
264
264
    def test_master_has_extra(self):
265
265
        tree = self.make_branch_and_tree('tree')
266
266
        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'])
 
267
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
268
 
 
269
        tree.commit('first', rev_id='first-rev-id')
 
270
 
 
271
        tree.add(['c'], ['c-id'])
272
272
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
273
273
 
274
274
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
275
275
        iterator = walker.iter_all()
276
276
        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)
 
277
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
278
        self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
 
279
        self.assertWalkerNext(u'c', 'c-id', True, [None], iterator)
 
280
        self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
281
281
        self.assertRaises(StopIteration, next, iterator)
282
282
 
283
283
    def test_master_renamed_to_earlier(self):
284
284
        """The record is still present, it just shows up early."""
285
285
        tree = self.make_branch_and_tree('tree')
286
286
        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')
 
287
        tree.add(['a', 'c', 'd'], ['a-id', 'c-id', 'd-id'])
 
288
        tree.commit('first', rev_id='first-rev-id')
289
289
        tree.rename_one('d', 'b')
290
290
 
291
291
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
293
293
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
294
294
        iterator = walker.iter_all()
295
295
        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)
 
296
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
297
        self.assertWalkerNext(u'b', 'd-id', True, [u'd'], iterator)
 
298
        self.assertWalkerNext(u'c', 'c-id', True, [u'c'], iterator)
299
299
        self.assertRaises(StopIteration, next, iterator)
300
300
 
301
301
    def test_master_renamed_to_later(self):
302
302
        tree = self.make_branch_and_tree('tree')
303
303
        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')
 
304
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
305
        tree.commit('first', rev_id='first-rev-id')
306
306
        tree.rename_one('b', 'e')
307
307
 
308
308
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
310
310
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
311
311
        iterator = walker.iter_all()
312
312
        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)
 
313
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
314
        self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
 
315
        self.assertWalkerNext(u'e', 'b-id', True, [u'b'], iterator)
316
316
        self.assertRaises(StopIteration, next, iterator)
317
317
 
318
318
    def test_other_extra_in_middle(self):
319
319
        tree = self.make_branch_and_tree('tree')
320
320
        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')
 
321
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
322
        tree.commit('first', rev_id='first-rev-id')
323
323
        tree.remove(['b'])
324
324
 
325
325
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
326
326
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
327
327
        iterator = walker.iter_all()
328
328
        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)
 
329
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
330
        self.assertWalkerNext(u'd', 'd-id', True, [u'd'], iterator)
 
331
        self.assertWalkerNext(u'b', 'b-id', False, [u'b'], iterator)
332
332
        self.assertRaises(StopIteration, next, iterator)
333
333
 
334
334
    def test_other_extra_at_end(self):
335
335
        tree = self.make_branch_and_tree('tree')
336
336
        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')
 
337
        tree.add(['a', 'b', 'd'], ['a-id', 'b-id', 'd-id'])
 
338
        tree.commit('first', rev_id='first-rev-id')
339
339
        tree.remove(['d'])
340
340
 
341
341
        basis_tree, root_id = self.lock_and_get_basis_and_root_id(tree)
342
342
        walker = _mod_tree.MultiWalker(tree, [basis_tree])
343
343
        iterator = walker.iter_all()
344
344
        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)
 
345
        self.assertWalkerNext(u'a', 'a-id', True, [u'a'], iterator)
 
346
        self.assertWalkerNext(u'b', 'b-id', True, [u'b'], iterator)
 
347
        self.assertWalkerNext(u'd', 'd-id', False, [u'd'], iterator)
348
348
        self.assertRaises(StopIteration, next, iterator)
349
349
 
350
350
    def test_others_extra_at_end(self):
351
351
        tree = self.make_branch_and_tree('tree')
352
352
        self.build_tree(['tree/a', 'tree/b', 'tree/c', 'tree/d', 'tree/e'])
353
353
        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')
 
354
                 ['a-id', 'b-id', 'c-id', 'd-id', 'e-id'])
 
355
        tree.commit('first', rev_id='first-rev-id')
356
356
        tree.remove(['e'])
357
 
        tree.commit('second', rev_id=b'second-rev-id')
 
357
        tree.commit('second', rev_id='second-rev-id')
358
358
        tree.remove(['d'])
359
 
        tree.commit('third', rev_id=b'third-rev-id')
 
359
        tree.commit('third', rev_id='third-rev-id')
360
360
        tree.remove(['c'])
361
361
 
362
362
        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')
 
363
        first_tree = tree.branch.repository.revision_tree('first-rev-id')
 
364
        second_tree = tree.branch.repository.revision_tree('second-rev-id')
365
365
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree,
366
366
                                              second_tree])
367
367
        iterator = walker.iter_all()
368
368
        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)
 
369
        self.assertWalkerNext(u'a', 'a-id', True, [u'a', u'a', u'a'], iterator)
 
370
        self.assertWalkerNext(u'b', 'b-id', True, [u'b', u'b', u'b'], iterator)
 
371
        self.assertWalkerNext(u'c', 'c-id', False, [u'c', u'c', u'c'], iterator)
 
372
        self.assertWalkerNext(u'd', 'd-id', False, [None, u'd', u'd'], iterator)
 
373
        self.assertWalkerNext(u'e', 'e-id', False, [None, u'e', None], iterator)
374
374
        self.assertRaises(StopIteration, next, iterator)
375
375
 
376
376
    def test_different_file_id_in_others(self):
377
377
        tree = self.make_branch_and_tree('tree')
378
378
        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')
 
379
        tree.add(['a', 'b', 'c'], ['a-id', 'b-id', 'c-id'])
 
380
        tree.commit('first', rev_id='first-rev-id')
381
381
 
382
382
        tree.rename_one('b', 'c/d')
383
383
        self.build_tree(['tree/b'])
384
 
        tree.add(['b'], [b'b2-id'])
385
 
        tree.commit('second', rev_id=b'second-rev-id')
 
384
        tree.add(['b'], ['b2-id'])
 
385
        tree.commit('second', rev_id='second-rev-id')
386
386
 
387
387
        tree.rename_one('a', 'c/e')
388
388
        self.build_tree(['tree/a'])
389
 
        tree.add(['a'], [b'a2-id'])
 
389
        tree.add(['a'], ['a2-id'])
390
390
 
391
391
        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')
 
392
        first_tree = tree.branch.repository.revision_tree('first-rev-id')
393
393
        walker = _mod_tree.MultiWalker(tree, [basis_tree, first_tree])
394
394
 
395
395
        iterator = walker.iter_all()
396
396
        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)
 
397
        self.assertWalkerNext(u'a', 'a2-id', True, [None, None], iterator)
 
398
        self.assertWalkerNext(u'b', 'b2-id', True, [u'b', None], iterator)
 
399
        self.assertWalkerNext(u'c', 'c-id', True, [u'c', u'c'], iterator)
 
400
        self.assertWalkerNext(u'c/d', 'b-id', True, [u'c/d', u'b'], iterator)
 
401
        self.assertWalkerNext(u'c/e', 'a-id', True, [u'a', u'a'], iterator)
402
402
        self.assertRaises(StopIteration, next, iterator)
403
403
 
404
404
    def assertCmpByDirblock(self, cmp_val, path1, path2):