/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_shelf.py

  • Committer: Jelmer Vernooij
  • Date: 2018-05-06 11:48:54 UTC
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@jelmer.uk-20180506114854-h4qd9ojaqy8wxjsd
Move .mailmap to root.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_shelf.py
70
70
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
71
71
        self.addCleanup(creator.finalize)
72
72
        self.assertEqual([('rename', b'foo-id', 'foo', 'bar')],
73
 
                         list(creator.iter_shelvable()))
 
73
                          list(creator.iter_shelvable()))
74
74
        return creator
75
75
 
76
76
    def check_shelve_rename(self, creator):
124
124
 
125
125
    def test_shelve_change_handles_move(self):
126
126
        creator, tree = self.prepare_shelve_move()
127
 
        creator.shelve_change(('rename', b'baz-id', 'foo/baz', 'bar/baz'))
 
127
        creator.shelve_change(('rename', 'baz-id', 'foo/baz', 'bar/baz'))
128
128
        self.check_shelve_move(creator, tree)
129
129
 
130
130
    def test_shelve_changed_root_id(self):
138
138
        self.addCleanup(tree.unlock)
139
139
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
140
140
        self.addCleanup(creator.finalize)
141
 
        self.expectFailure(
142
 
            'shelf doesn\'t support shelving root changes yet',
 
141
        self.expectFailure('shelf doesn\'t support shelving root changes yet',
143
142
            self.assertEqual, [
144
143
                ('delete file', b'first-root-id', 'directory', ''),
145
144
                ('add file', b'second-root-id', 'directory', ''),
149
148
        self.assertEqual([('delete file', b'first-root-id', 'directory', ''),
150
149
                          ('add file', b'second-root-id', 'directory', ''),
151
150
                          ('rename', b'foo-id', u'foo', u'foo'),
152
 
                          ], list(creator.iter_shelvable()))
 
151
                         ], list(creator.iter_shelvable()))
153
152
 
154
153
    def assertShelvedFileEqual(self, expected_content, creator, file_id):
155
154
        s_trans_id = creator.shelf_transform.trans_id_file_id(file_id)
172
171
        creator = self.prepare_content_change()
173
172
        self.assertEqual([('modify text', b'foo-id')],
174
173
                         list(creator.iter_shelvable()))
175
 
        creator.shelve_lines(b'foo-id', [b'a\n', b'c\n'])
 
174
        creator.shelve_lines(b'foo-id', ['a\n', 'c\n'])
176
175
        creator.transform()
177
 
        self.assertFileEqual(b'a\nc\n', 'foo')
178
 
        self.assertShelvedFileEqual(b'b\na\n', creator, b'foo-id')
 
176
        self.assertFileEqual('a\nc\n', 'foo')
 
177
        self.assertShelvedFileEqual('b\na\n', creator, b'foo-id')
179
178
 
180
179
    def test_shelve_change_handles_modify_text(self):
181
180
        creator = self.prepare_content_change()
182
181
        creator.shelve_change(('modify text', b'foo-id'))
183
182
        creator.transform()
184
 
        self.assertFileEqual(b'a\n', 'foo')
185
 
        self.assertShelvedFileEqual(b'b\na\nc\n', creator, b'foo-id')
 
183
        self.assertFileEqual('a\n', 'foo')
 
184
        self.assertShelvedFileEqual('b\na\nc\n', creator, b'foo-id')
186
185
 
187
186
    def test_shelve_all(self):
188
187
        creator = self.prepare_content_change()
189
188
        creator.shelve_all()
190
189
        creator.transform()
191
 
        self.assertFileEqual(b'a\n', 'foo')
192
 
        self.assertShelvedFileEqual(b'b\na\nc\n', creator, b'foo-id')
 
190
        self.assertFileEqual('a\n', 'foo')
 
191
        self.assertShelvedFileEqual('b\na\nc\n', creator, b'foo-id')
193
192
 
194
193
    def prepare_shelve_creation(self):
195
194
        tree = self.make_branch_and_tree('.')
202
201
        self.addCleanup(creator.finalize)
203
202
        self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
204
203
                          ('add file', b'foo-id', 'file', 'foo')],
205
 
                         sorted(list(creator.iter_shelvable())))
 
204
                          sorted(list(creator.iter_shelvable())))
206
205
        return creator, tree
207
206
 
208
207
    def check_shelve_creation(self, creator, tree):
209
 
        self.assertRaises(
210
 
            StopIteration, next,
211
 
            tree.iter_entries_by_dir(specific_files=['foo']))
 
208
        self.assertRaises(StopIteration,
 
209
                          next, tree.iter_entries_by_dir(specific_files=['foo']))
212
210
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
213
211
        self.assertEqual(b'foo-id',
214
212
                         creator.shelf_transform.final_file_id(s_trans_id))
217
215
        self.assertShelvedFileEqual('a\n', creator, b'foo-id')
218
216
        s_bar_trans_id = creator.shelf_transform.trans_id_file_id(b'bar-id')
219
217
        self.assertEqual('directory',
220
 
                         creator.shelf_transform.final_kind(s_bar_trans_id))
 
218
            creator.shelf_transform.final_kind(s_bar_trans_id))
221
219
 
222
220
    def test_shelve_creation(self):
223
221
        creator, tree = self.prepare_shelve_creation()
238
236
        tree.lock_write()
239
237
        self.addCleanup(tree.unlock)
240
238
        tree.commit('Empty tree')
241
 
        self.build_tree_contents(
242
 
            [('foo', b'a\n'), ('bar/',), ('bar/ignored', b'ign\n')])
 
239
        self.build_tree_contents([('foo', b'a\n'), ('bar/',), ('bar/ignored', b'ign\n')])
243
240
        tree.add(['foo', 'bar'], [b'foo-id', b'bar-id'])
244
241
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
245
242
        self.addCleanup(creator.finalize)
246
243
        self.assertEqual([('add file', b'bar-id', 'directory', 'bar'),
247
244
                          ('add file', b'foo-id', 'file', 'foo')],
248
 
                         sorted(list(creator.iter_shelvable())))
 
245
                          sorted(list(creator.iter_shelvable())))
249
246
        ignores._set_user_ignores([])
250
 
        in_patterns = ['ignored', ]
 
247
        in_patterns = ['ignored',]
251
248
        ignores.add_unique_user_ignores(in_patterns)
252
249
 
253
250
        creator.shelve_change(('add file', b'bar-id', 'directory', 'bar'))
255
252
            creator.transform()
256
253
            self.check_shelve_creation(creator, tree)
257
254
        except MalformedTransform:
258
 
            raise KnownFailure(
259
 
                'shelving directory with ignored file: see bug #611739')
 
255
            raise KnownFailure('shelving directory with ignored file: see bug #611739')
260
256
 
261
257
    def _test_shelve_symlink_creation(self, link_name, link_target,
262
258
                                      shelve_change=False):
272
268
        self.assertEqual([('add file', b'foo-id', 'symlink', link_name)],
273
269
                         list(creator.iter_shelvable()))
274
270
        if shelve_change:
275
 
            creator.shelve_change(
276
 
                ('add file', b'foo-id', 'symlink', link_name))
 
271
            creator.shelve_change(('add file', b'foo-id', 'symlink', link_name))
277
272
        else:
278
273
            creator.shelve_creation(b'foo-id')
279
274
        creator.transform()
283
278
        self.assertEqual(link_target, osutils.readlink(limbo_name))
284
279
        ptree = creator.shelf_transform.get_preview_tree()
285
280
        self.assertEqual(
286
 
            link_target,
287
 
            ptree.get_symlink_target(ptree.id2path(b'foo-id')))
 
281
                link_target,
 
282
                ptree.get_symlink_target(ptree.id2path(b'foo-id'), b'foo-id'))
288
283
 
289
284
    def test_shelve_symlink_creation(self):
290
285
        self._test_shelve_symlink_creation('foo', 'bar')
325
320
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
326
321
        self.assertEqual(new_target, osutils.readlink(limbo_name))
327
322
        ptree = creator.shelf_transform.get_preview_tree()
328
 
        self.assertEqual(new_target, ptree.get_symlink_target(
329
 
            ptree.id2path(b'foo-id')))
 
323
        self.assertEqual(new_target, ptree.get_symlink_target(ptree.id2path(b'foo-id')))
330
324
 
331
325
    def test_shelve_symlink_target_change(self):
332
326
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
354
348
                         sorted(list(creator.iter_shelvable())))
355
349
        creator.shelve_creation(b'foo-id')
356
350
        creator.transform()
357
 
        self.assertRaises(
358
 
            StopIteration, next,
359
 
            tree.iter_entries_by_dir(specific_files=['foo']))
 
351
        self.assertRaises(StopIteration,
 
352
                          next, tree.iter_entries_by_dir(specific_files=['foo']))
360
353
        self.assertShelvedFileEqual('', creator, b'foo-id')
361
354
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
362
355
        self.assertEqual(b'foo-id',
377
370
        self.addCleanup(creator.finalize)
378
371
        self.assertEqual([('delete file', b'bar-id', 'file', 'foo/bar'),
379
372
                          ('delete file', b'foo-id', 'directory', 'foo')],
380
 
                         sorted(list(creator.iter_shelvable())))
 
373
                          sorted(list(creator.iter_shelvable())))
381
374
        return creator, tree
382
375
 
383
376
    def check_shelve_deletion(self, tree):
384
 
        self.assertEqual(tree.id2path(b'foo-id'), 'foo')
385
 
        self.assertEqual(tree.id2path(b'bar-id'), 'foo/bar')
386
 
        self.assertFileEqual(b'baz', 'tree/foo/bar')
 
377
        self.assertTrue(tree.has_id(b'foo-id'))
 
378
        self.assertTrue(tree.has_id(b'bar-id'))
 
379
        self.assertFileEqual('baz', 'tree/foo/bar')
387
380
 
388
381
    def test_shelve_deletion(self):
389
382
        creator, tree = self.prepare_shelve_deletion()
401
394
 
402
395
    def test_shelve_delete_contents(self):
403
396
        tree = self.make_branch_and_tree('tree')
404
 
        self.build_tree(['tree/foo', ])
 
397
        self.build_tree(['tree/foo',])
405
398
        tree.add('foo', b'foo-id')
406
399
        tree.commit('Added file and directory')
407
400
        os.unlink('tree/foo')
431
424
        return creator
432
425
 
433
426
    def check_shelve_change_kind(self, creator):
434
 
        self.assertFileEqual(b'bar', 'tree/foo')
 
427
        self.assertFileEqual('bar', 'tree/foo')
435
428
        s_trans_id = creator.shelf_transform.trans_id_file_id(b'foo-id')
436
429
        self.assertEqual('directory',
437
430
                         creator.shelf_transform._new_contents[s_trans_id])
460
453
 
461
454
    def test_shelve_unversion(self):
462
455
        tree = self.make_branch_and_tree('tree')
463
 
        self.build_tree(['tree/foo', ])
 
456
        self.build_tree(['tree/foo',])
464
457
        tree.add('foo', b'foo-id')
465
458
        tree.commit('Added file and directory')
466
459
        tree.unversion(['foo'])
506
499
        tt = transform.TransformPreview(tree)
507
500
        self.addCleanup(tt.finalize)
508
501
        records = iter(parser.read_pending_records())
509
 
        # skip revision-id
 
502
        #skip revision-id
510
503
        next(records)
511
504
        tt.deserialize(records)
512
505
 
513
506
    def test_shelve_unversioned(self):
514
507
        tree = self.make_branch_and_tree('tree')
515
 
        with tree.lock_tree_write():
 
508
        tree.lock_tree_write()
 
509
        try:
516
510
            self.assertRaises(errors.PathsNotVersionedError,
517
 
                              shelf.ShelfCreator, tree, tree.basis_tree(),
518
 
                              ['foo'])
 
511
                              shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
 
512
        finally:
 
513
            tree.unlock()
519
514
        # We should be able to lock/unlock the tree if ShelfCreator cleaned
520
515
        # after itself.
521
516
        wt = workingtree.WorkingTree.open('tree')
523
518
        wt.unlock()
524
519
        # And a second tentative should raise the same error (no
525
520
        # limbo/pending_deletion leftovers).
526
 
        with tree.lock_tree_write():
 
521
        tree.lock_tree_write()
 
522
        try:
527
523
            self.assertRaises(errors.PathsNotVersionedError,
528
 
                              shelf.ShelfCreator, tree, tree.basis_tree(),
529
 
                              ['foo'])
 
524
                              shelf.ShelfCreator, tree, tree.basis_tree(), ['foo'])
 
525
        finally:
 
526
            tree.unlock()
530
527
 
531
528
    def test_shelve_skips_added_root(self):
532
529
        """Skip adds of the root when iterating through shelvable changes."""
567
564
            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
568
565
            unshelver.make_merger().do_merge()
569
566
            self.addCleanup(unshelver.finalize)
570
 
            self.assertFileEqual(b'bar', 'tree/foo')
 
567
            self.assertFileEqual('bar', 'tree/foo')
571
568
 
572
569
    def test_unshelve_changed(self):
573
570
        tree = self.make_branch_and_tree('tree')
580
577
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
581
578
        self.addCleanup(creator.finalize)
582
579
        list(creator.iter_shelvable())
583
 
        creator.shelve_lines(b'foo-id', [b'a\n', b'b\n', b'c\n'])
 
580
        creator.shelve_lines(b'foo-id', ['a\n', 'b\n', 'c\n'])
584
581
        shelf_file = open('shelf', 'w+b')
585
582
        self.addCleanup(shelf_file.close)
586
583
        creator.write_shelf(shelf_file)
590
587
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
591
588
        self.addCleanup(unshelver.finalize)
592
589
        unshelver.make_merger().do_merge()
593
 
        self.assertFileEqual(b'z\na\nb\nd\n', 'tree/foo')
 
590
        self.assertFileEqual('z\na\nb\nd\n', 'tree/foo')
594
591
 
595
592
    def test_unshelve_deleted(self):
596
593
        tree = self.make_branch_and_tree('tree')
611
608
            creator.transform()
612
609
            creator.finalize()
613
610
        # validate the test setup
614
 
        self.assertEqual(tree.id2path(b'foo-id'), 'foo')
615
 
        self.assertEqual(tree.id2path(b'bar-id'), 'foo/bar')
616
 
        self.assertFileEqual(b'baz', 'tree/foo/bar')
 
611
        self.assertTrue(tree.has_id(b'foo-id'))
 
612
        self.assertTrue(tree.has_id(b'bar-id'))
 
613
        self.assertFileEqual('baz', 'tree/foo/bar')
617
614
        with open('shelf', 'r+b') as shelf_file:
618
615
            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
619
616
            self.addCleanup(unshelver.finalize)
620
617
            unshelver.make_merger().do_merge()
621
 
        self.assertRaises(errors.NoSuchId, tree.id2path, b'foo-id')
622
 
        self.assertRaises(errors.NoSuchId, tree.id2path, b'bar-id')
 
618
        self.assertFalse(tree.has_id(b'foo-id'))
 
619
        self.assertFalse(tree.has_id(b'bar-id'))
623
620
 
624
621
    def test_unshelve_base(self):
625
622
        tree = self.make_branch_and_tree('tree')
745
742
        manager = self.get_manager()
746
743
        shelf_id, shelf_file = manager.new_shelf()
747
744
        try:
748
 
            shelf_file.write(b'foo')
 
745
            shelf_file.write('foo')
749
746
        finally:
750
747
            shelf_file.close()
751
748
        shelf_id, shelf_file = manager.new_shelf()
752
749
        try:
753
 
            shelf_file.write(b'bar')
 
750
            shelf_file.write('bar')
754
751
        finally:
755
752
            shelf_file.close()
756
753
        shelf_file = manager.read_shelf(1)
757
754
        try:
758
 
            self.assertEqual(b'foo', shelf_file.read())
 
755
            self.assertEqual('foo', shelf_file.read())
759
756
        finally:
760
757
            shelf_file.close()
761
758
        shelf_file = manager.read_shelf(2)
762
759
        try:
763
 
            self.assertEqual(b'bar', shelf_file.read())
 
760
            self.assertEqual('bar', shelf_file.read())
764
761
        finally:
765
762
            shelf_file.close()
766
763
 
775
772
        tree.lock_write()
776
773
        self.addCleanup(tree.unlock)
777
774
        self.build_tree_contents([('tree/foo', b'bar')])
778
 
        self.assertFileEqual(b'bar', 'tree/foo')
 
775
        self.assertFileEqual('bar', 'tree/foo')
779
776
        tree.add('foo', b'foo-id')
780
777
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
781
778
        self.addCleanup(creator.finalize)
787
784
        unshelver = shelf_manager.get_unshelver(shelf_id)
788
785
        self.addCleanup(unshelver.finalize)
789
786
        unshelver.make_merger().do_merge()
790
 
        self.assertFileEqual(b'bar', 'tree/foo')
 
787
        self.assertFileEqual('bar', 'tree/foo')
791
788
 
792
789
    def test_get_metadata(self):
793
790
        tree = self.make_branch_and_tree('.')
798
795
        shelf_manager = tree.get_shelf_manager()
799
796
        shelf_id = shelf_manager.shelve_changes(creator, 'foo')
800
797
        metadata = shelf_manager.get_metadata(shelf_id)
801
 
        self.assertEqual('foo', metadata[b'message'])
802
 
        self.assertEqual(b'null:', metadata[b'revision_id'])
 
798
        self.assertEqual('foo', metadata['message'])
 
799
        self.assertEqual('null:', metadata['revision_id'])