/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: 2017-08-29 21:07:17 UTC
  • mfrom: (6772 brz)
  • mto: This revision was merged to the branch mainline in revision 6773.
  • Revision ID: jelmer@jelmer.uk-20170829210717-ud3w6rh8x8fv48l9
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_shelf.py
1
 
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2008-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
import os
18
18
 
19
 
from bzrlib import (
 
19
from .. import (
20
20
    errors,
21
21
    osutils,
22
 
    pack,
23
22
    shelf,
24
23
    tests,
25
24
    transform,
26
25
    workingtree,
27
26
    )
 
27
from ..bzr import (
 
28
    pack,
 
29
    )
 
30
from . import (
 
31
    features,
 
32
    )
28
33
 
29
34
 
30
35
EMPTY_SHELF = ("Bazaar pack format 1 (introduced in 0.18)\n"
38
43
               "17:_removed_contentsle11:_removed_idle14:_tree_path_idsdeeE")
39
44
 
40
45
 
 
46
class TestErrors(tests.TestCase):
 
47
 
 
48
    def test_invalid_shelf_id(self):
 
49
        invalid_id = "foo"
 
50
        err = shelf.InvalidShelfId(invalid_id)
 
51
        self.assertEqual('"foo" is not a valid shelf id, '
 
52
                         'try a number instead.', str(err))
 
53
 
 
54
 
41
55
class TestPrepareShelf(tests.TestCaseWithTransport):
42
56
 
43
57
    def prepare_shelve_rename(self):
187
201
 
188
202
    def check_shelve_creation(self, creator, tree):
189
203
        self.assertRaises(StopIteration,
190
 
                          tree.iter_entries_by_dir(['foo-id']).next)
 
204
                          next, tree.iter_entries_by_dir(['foo-id']))
191
205
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
192
206
        self.assertEqual('foo-id',
193
207
                         creator.shelf_transform.final_file_id(s_trans_id))
194
 
        self.failIfExists('foo')
195
 
        self.failIfExists('bar')
 
208
        self.assertPathDoesNotExist('foo')
 
209
        self.assertPathDoesNotExist('bar')
196
210
        self.assertShelvedFileEqual('a\n', creator, 'foo-id')
197
211
        s_bar_trans_id = creator.shelf_transform.trans_id_file_id('bar-id')
198
212
        self.assertEqual('directory',
214
228
 
215
229
    def _test_shelve_symlink_creation(self, link_name, link_target,
216
230
                                      shelve_change=False):
217
 
        self.requireFeature(tests.SymlinkFeature)
 
231
        self.requireFeature(features.SymlinkFeature)
218
232
        tree = self.make_branch_and_tree('.')
219
233
        tree.lock_write()
220
234
        self.addCleanup(tree.unlock)
231
245
            creator.shelve_creation('foo-id')
232
246
        creator.transform()
233
247
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
234
 
        self.failIfExists(link_name)
 
248
        self.assertPathDoesNotExist(link_name)
235
249
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
236
250
        self.assertEqual(link_target, osutils.readlink(limbo_name))
237
251
        ptree = creator.shelf_transform.get_preview_tree()
241
255
        self._test_shelve_symlink_creation('foo', 'bar')
242
256
 
243
257
    def test_shelve_unicode_symlink_creation(self):
244
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
258
        self.requireFeature(features.UnicodeFilenameFeature)
245
259
        self._test_shelve_symlink_creation(u'fo\N{Euro Sign}o',
246
260
                                           u'b\N{Euro Sign}ar')
247
261
 
251
265
    def _test_shelve_symlink_target_change(self, link_name,
252
266
                                           old_target, new_target,
253
267
                                           shelve_change=False):
254
 
        self.requireFeature(tests.SymlinkFeature)
 
268
        self.requireFeature(features.SymlinkFeature)
255
269
        tree = self.make_branch_and_tree('.')
256
270
        tree.lock_write()
257
271
        self.addCleanup(tree.unlock)
282
296
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
283
297
 
284
298
    def test_shelve_unicode_symlink_target_change(self):
285
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
299
        self.requireFeature(features.UnicodeFilenameFeature)
286
300
        self._test_shelve_symlink_target_change(
287
301
            u'fo\N{Euro Sign}o', u'b\N{Euro Sign}ar', u'b\N{Euro Sign}az')
288
302
 
305
319
        creator.shelve_creation('foo-id')
306
320
        creator.transform()
307
321
        self.assertRaises(StopIteration,
308
 
                          tree.iter_entries_by_dir(['foo-id']).next)
 
322
                          next, tree.iter_entries_by_dir(['foo-id']))
309
323
        self.assertShelvedFileEqual('', creator, 'foo-id')
310
324
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
311
325
        self.assertEqual('foo-id',
312
326
                         creator.shelf_transform.final_file_id(s_trans_id))
313
 
        self.failIfExists('foo')
 
327
        self.assertPathDoesNotExist('foo')
314
328
 
315
329
    def prepare_shelve_deletion(self):
316
330
        tree = self.make_branch_and_tree('tree')
330
344
        return creator, tree
331
345
 
332
346
    def check_shelve_deletion(self, tree):
333
 
        self.assertTrue('foo-id' in tree)
334
 
        self.assertTrue('bar-id' in tree)
 
347
        self.assertTrue(tree.has_id('foo-id'))
 
348
        self.assertTrue(tree.has_id('bar-id'))
335
349
        self.assertFileEqual('baz', 'tree/foo/bar')
336
350
 
337
351
    def test_shelve_deletion(self):
362
376
                         sorted(list(creator.iter_shelvable())))
363
377
        creator.shelve_deletion('foo-id')
364
378
        creator.transform()
365
 
        self.failUnlessExists('tree/foo')
 
379
        self.assertPathExists('tree/foo')
366
380
 
367
381
    def prepare_shelve_change_kind(self):
368
382
        tree = self.make_branch_and_tree('tree')
421
435
                         sorted(list(creator.iter_shelvable())))
422
436
        creator.shelve_deletion('foo-id')
423
437
        creator.transform()
424
 
        self.failUnlessExists('tree/foo')
 
438
        self.assertPathExists('tree/foo')
425
439
 
426
440
    def test_shelve_serialization(self):
427
441
        tree = self.make_branch_and_tree('.')
462
476
        self.addCleanup(tt.finalize)
463
477
        records = iter(parser.read_pending_records())
464
478
        #skip revision-id
465
 
        records.next()
 
479
        next(records)
466
480
        tt.deserialize(records)
467
481
 
468
482
    def test_shelve_unversioned(self):
568
582
        list(creator.iter_shelvable())
569
583
        creator.shelve_deletion('foo-id')
570
584
        creator.shelve_deletion('bar-id')
571
 
        shelf_file = open('shelf', 'w+b')
572
 
        self.addCleanup(shelf_file.close)
573
 
        creator.write_shelf(shelf_file)
574
 
        creator.transform()
575
 
        creator.finalize()
 
585
        with open('shelf', 'w+b') as shelf_file:
 
586
            creator.write_shelf(shelf_file)
 
587
            creator.transform()
 
588
            creator.finalize()
576
589
        # validate the test setup
577
 
        self.assertTrue('foo-id' in tree)
578
 
        self.assertTrue('bar-id' in tree)
 
590
        self.assertTrue(tree.has_id('foo-id'))
 
591
        self.assertTrue(tree.has_id('bar-id'))
579
592
        self.assertFileEqual('baz', 'tree/foo/bar')
580
 
        shelf_file.seek(0)
581
 
        unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
582
 
        self.addCleanup(unshelver.finalize)
583
 
        unshelver.make_merger().do_merge()
584
 
        self.assertFalse('foo-id' in tree)
585
 
        self.assertFalse('bar-id' in tree)
 
593
        with open('shelf', 'r+b') as shelf_file:
 
594
            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
 
595
            self.addCleanup(unshelver.finalize)
 
596
            unshelver.make_merger().do_merge()
 
597
        self.assertFalse(tree.has_id('foo-id'))
 
598
        self.assertFalse(tree.has_id('bar-id'))
586
599
 
587
600
    def test_unshelve_base(self):
588
601
        tree = self.make_branch_and_tree('tree')
618
631
                                                                'foo'))])
619
632
        shelf_file = open('shelf', 'rb')
620
633
        self.addCleanup(shelf_file.close)
621
 
        e = self.assertRaises(errors.ShelfCorrupt,
 
634
        e = self.assertRaises(shelf.ShelfCorrupt,
622
635
                              shelf.Unshelver.from_tree_and_shelf, tree,
623
636
                              shelf_file)
624
637
        self.assertEqual('Shelf corrupt.', str(e))
625
638
 
 
639
    def test_unshelve_subdir_in_now_removed_dir(self):
 
640
        tree = self.make_branch_and_tree('.')
 
641
        self.addCleanup(tree.lock_write().unlock)
 
642
        self.build_tree(['dir/', 'dir/subdir/', 'dir/subdir/foo'])
 
643
        tree.add(['dir'], ['dir-id'])
 
644
        tree.commit('versioned dir')
 
645
        tree.add(['dir/subdir', 'dir/subdir/foo'], ['subdir-id', 'foo-id'])
 
646
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
 
647
        self.addCleanup(creator.finalize)
 
648
        for change in creator.iter_shelvable():
 
649
            creator.shelve_change(change)
 
650
        shelf_manager = tree.get_shelf_manager()
 
651
        shelf_id = shelf_manager.shelve_changes(creator)
 
652
        self.assertPathDoesNotExist('dir/subdir')
 
653
        tree.remove(['dir'])
 
654
        unshelver = shelf_manager.get_unshelver(shelf_id)
 
655
        self.addCleanup(unshelver.finalize)
 
656
        unshelver.make_merger().do_merge()
 
657
        self.assertPathExists('dir/subdir/foo')
 
658
        self.assertEqual('dir-id', tree.path2id('dir'))
 
659
        self.assertEqual('subdir-id', tree.path2id('dir/subdir'))
 
660
        self.assertEqual('foo-id', tree.path2id('dir/subdir/foo'))
 
661
 
626
662
 
627
663
class TestShelfManager(tests.TestCaseWithTransport):
628
664
 
706
742
 
707
743
    def test_read_non_existant(self):
708
744
        manager = self.get_manager()
709
 
        e = self.assertRaises(errors.NoSuchShelfId, manager.read_shelf, 1)
 
745
        e = self.assertRaises(shelf.NoSuchShelfId, manager.read_shelf, 1)
710
746
        self.assertEqual('No changes are shelved with id "1".', str(e))
711
747
 
712
748
    def test_shelve_changes(self):
723
759
        creator.shelve_creation('foo-id')
724
760
        shelf_manager = tree.get_shelf_manager()
725
761
        shelf_id = shelf_manager.shelve_changes(creator)
726
 
        self.failIfExists('tree/foo')
 
762
        self.assertPathDoesNotExist('tree/foo')
727
763
        unshelver = shelf_manager.get_unshelver(shelf_id)
728
764
        self.addCleanup(unshelver.finalize)
729
765
        unshelver.make_merger().do_merge()