/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-12-21 16:44:19 UTC
  • mto: This revision was merged to the branch mainline in revision 6842.
  • Revision ID: jelmer@jelmer.uk-20171221164419-wn90kwu2uismpznf
Revert custom gmtime implementation without tests.

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
    ignores,
21
22
    osutils,
22
 
    pack,
23
23
    shelf,
24
24
    tests,
25
25
    transform,
26
26
    workingtree,
27
27
    )
 
28
from ..bzr import (
 
29
    pack,
 
30
    )
 
31
from . import (
 
32
    features,
 
33
    KnownFailure,
 
34
    )
 
35
from ..errors import (
 
36
    MalformedTransform,
 
37
    )
28
38
 
29
39
 
30
40
EMPTY_SHELF = ("Bazaar pack format 1 (introduced in 0.18)\n"
38
48
               "17:_removed_contentsle11:_removed_idle14:_tree_path_idsdeeE")
39
49
 
40
50
 
 
51
class TestErrors(tests.TestCase):
 
52
 
 
53
    def test_invalid_shelf_id(self):
 
54
        invalid_id = "foo"
 
55
        err = shelf.InvalidShelfId(invalid_id)
 
56
        self.assertEqual('"foo" is not a valid shelf id, '
 
57
                         'try a number instead.', str(err))
 
58
 
 
59
 
41
60
class TestPrepareShelf(tests.TestCaseWithTransport):
42
61
 
43
62
    def prepare_shelve_rename(self):
187
206
 
188
207
    def check_shelve_creation(self, creator, tree):
189
208
        self.assertRaises(StopIteration,
190
 
                          tree.iter_entries_by_dir(['foo-id']).next)
 
209
                          next, tree.iter_entries_by_dir(['foo-id']))
191
210
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
192
211
        self.assertEqual('foo-id',
193
212
                         creator.shelf_transform.final_file_id(s_trans_id))
194
 
        self.failIfExists('foo')
195
 
        self.failIfExists('bar')
 
213
        self.assertPathDoesNotExist('foo')
 
214
        self.assertPathDoesNotExist('bar')
196
215
        self.assertShelvedFileEqual('a\n', creator, 'foo-id')
197
216
        s_bar_trans_id = creator.shelf_transform.trans_id_file_id('bar-id')
198
217
        self.assertEqual('directory',
212
231
        creator.transform()
213
232
        self.check_shelve_creation(creator, tree)
214
233
 
 
234
    def test_shelve_directory_with_ignored(self):
 
235
        tree = self.make_branch_and_tree('.')
 
236
        tree.lock_write()
 
237
        self.addCleanup(tree.unlock)
 
238
        tree.commit('Empty tree')
 
239
        self.build_tree_contents([('foo', 'a\n'), ('bar/',), ('bar/ignored','ign\n')])
 
240
        tree.add(['foo', 'bar'], ['foo-id', 'bar-id'])
 
241
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
 
242
        self.addCleanup(creator.finalize)
 
243
        self.assertEqual([('add file', 'bar-id', 'directory', 'bar'),
 
244
                          ('add file', 'foo-id', 'file', 'foo')],
 
245
                          sorted(list(creator.iter_shelvable())))
 
246
        ignores._set_user_ignores([])
 
247
        in_patterns = ['ignored',]
 
248
        ignores.add_unique_user_ignores(in_patterns)
 
249
 
 
250
        creator.shelve_change(('add file', 'bar-id', 'directory', 'bar'))
 
251
        try:
 
252
            creator.transform()
 
253
            self.check_shelve_creation(creator, tree)
 
254
        except MalformedTransform:
 
255
            raise KnownFailure('shelving directory with ignored file: see bug #611739')
 
256
 
215
257
    def _test_shelve_symlink_creation(self, link_name, link_target,
216
258
                                      shelve_change=False):
217
 
        self.requireFeature(tests.SymlinkFeature)
 
259
        self.requireFeature(features.SymlinkFeature)
218
260
        tree = self.make_branch_and_tree('.')
219
261
        tree.lock_write()
220
262
        self.addCleanup(tree.unlock)
231
273
            creator.shelve_creation('foo-id')
232
274
        creator.transform()
233
275
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
234
 
        self.failIfExists(link_name)
 
276
        self.assertPathDoesNotExist(link_name)
235
277
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
236
278
        self.assertEqual(link_target, osutils.readlink(limbo_name))
237
279
        ptree = creator.shelf_transform.get_preview_tree()
238
 
        self.assertEqual(link_target, ptree.get_symlink_target('foo-id'))
 
280
        self.assertEqual(
 
281
                link_target,
 
282
                ptree.get_symlink_target(ptree.id2path('foo-id'), 'foo-id'))
239
283
 
240
284
    def test_shelve_symlink_creation(self):
241
285
        self._test_shelve_symlink_creation('foo', 'bar')
242
286
 
243
287
    def test_shelve_unicode_symlink_creation(self):
244
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
288
        self.requireFeature(features.UnicodeFilenameFeature)
245
289
        self._test_shelve_symlink_creation(u'fo\N{Euro Sign}o',
246
290
                                           u'b\N{Euro Sign}ar')
247
291
 
251
295
    def _test_shelve_symlink_target_change(self, link_name,
252
296
                                           old_target, new_target,
253
297
                                           shelve_change=False):
254
 
        self.requireFeature(tests.SymlinkFeature)
 
298
        self.requireFeature(features.SymlinkFeature)
255
299
        tree = self.make_branch_and_tree('.')
256
300
        tree.lock_write()
257
301
        self.addCleanup(tree.unlock)
276
320
        limbo_name = creator.shelf_transform._limbo_name(s_trans_id)
277
321
        self.assertEqual(new_target, osutils.readlink(limbo_name))
278
322
        ptree = creator.shelf_transform.get_preview_tree()
279
 
        self.assertEqual(new_target, ptree.get_symlink_target('foo-id'))
 
323
        self.assertEqual(new_target, ptree.get_symlink_target(ptree.id2path('foo-id')))
280
324
 
281
325
    def test_shelve_symlink_target_change(self):
282
326
        self._test_shelve_symlink_target_change('foo', 'bar', 'baz')
283
327
 
284
328
    def test_shelve_unicode_symlink_target_change(self):
285
 
        self.requireFeature(tests.UnicodeFilenameFeature)
 
329
        self.requireFeature(features.UnicodeFilenameFeature)
286
330
        self._test_shelve_symlink_target_change(
287
331
            u'fo\N{Euro Sign}o', u'b\N{Euro Sign}ar', u'b\N{Euro Sign}az')
288
332
 
305
349
        creator.shelve_creation('foo-id')
306
350
        creator.transform()
307
351
        self.assertRaises(StopIteration,
308
 
                          tree.iter_entries_by_dir(['foo-id']).next)
 
352
                          next, tree.iter_entries_by_dir(['foo-id']))
309
353
        self.assertShelvedFileEqual('', creator, 'foo-id')
310
354
        s_trans_id = creator.shelf_transform.trans_id_file_id('foo-id')
311
355
        self.assertEqual('foo-id',
312
356
                         creator.shelf_transform.final_file_id(s_trans_id))
313
 
        self.failIfExists('foo')
 
357
        self.assertPathDoesNotExist('foo')
314
358
 
315
359
    def prepare_shelve_deletion(self):
316
360
        tree = self.make_branch_and_tree('tree')
319
363
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', 'baz')])
320
364
        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
321
365
        tree.commit('Added file and directory')
322
 
        tree.unversion(['foo-id', 'bar-id'])
 
366
        tree.unversion(['foo', 'foo/bar'])
323
367
        os.unlink('tree/foo/bar')
324
368
        os.rmdir('tree/foo')
325
369
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
330
374
        return creator, tree
331
375
 
332
376
    def check_shelve_deletion(self, tree):
333
 
        self.assertTrue('foo-id' in tree)
334
 
        self.assertTrue('bar-id' in tree)
 
377
        self.assertTrue(tree.has_id('foo-id'))
 
378
        self.assertTrue(tree.has_id('bar-id'))
335
379
        self.assertFileEqual('baz', 'tree/foo/bar')
336
380
 
337
381
    def test_shelve_deletion(self):
362
406
                         sorted(list(creator.iter_shelvable())))
363
407
        creator.shelve_deletion('foo-id')
364
408
        creator.transform()
365
 
        self.failUnlessExists('tree/foo')
 
409
        self.assertPathExists('tree/foo')
366
410
 
367
411
    def prepare_shelve_change_kind(self):
368
412
        tree = self.make_branch_and_tree('tree')
412
456
        self.build_tree(['tree/foo',])
413
457
        tree.add('foo', 'foo-id')
414
458
        tree.commit('Added file and directory')
415
 
        tree.unversion(['foo-id'])
 
459
        tree.unversion(['foo'])
416
460
        tree.lock_tree_write()
417
461
        self.addCleanup(tree.unlock)
418
462
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
421
465
                         sorted(list(creator.iter_shelvable())))
422
466
        creator.shelve_deletion('foo-id')
423
467
        creator.transform()
424
 
        self.failUnlessExists('tree/foo')
 
468
        self.assertPathExists('tree/foo')
425
469
 
426
470
    def test_shelve_serialization(self):
427
471
        tree = self.make_branch_and_tree('.')
462
506
        self.addCleanup(tt.finalize)
463
507
        records = iter(parser.read_pending_records())
464
508
        #skip revision-id
465
 
        records.next()
 
509
        next(records)
466
510
        tt.deserialize(records)
467
511
 
468
512
    def test_shelve_unversioned(self):
561
605
        self.build_tree_contents([('tree/foo/',), ('tree/foo/bar', 'baz')])
562
606
        tree.add(['foo', 'foo/bar'], ['foo-id', 'bar-id'])
563
607
        tree.commit('Added file and directory')
564
 
        tree.unversion(['foo-id', 'bar-id'])
 
608
        tree.unversion(['foo', 'foo/bar'])
565
609
        os.unlink('tree/foo/bar')
566
610
        os.rmdir('tree/foo')
567
611
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
568
612
        list(creator.iter_shelvable())
569
613
        creator.shelve_deletion('foo-id')
570
614
        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()
 
615
        with open('shelf', 'w+b') as shelf_file:
 
616
            creator.write_shelf(shelf_file)
 
617
            creator.transform()
 
618
            creator.finalize()
576
619
        # validate the test setup
577
 
        self.assertTrue('foo-id' in tree)
578
 
        self.assertTrue('bar-id' in tree)
 
620
        self.assertTrue(tree.has_id('foo-id'))
 
621
        self.assertTrue(tree.has_id('bar-id'))
579
622
        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)
 
623
        with open('shelf', 'r+b') as shelf_file:
 
624
            unshelver = shelf.Unshelver.from_tree_and_shelf(tree, shelf_file)
 
625
            self.addCleanup(unshelver.finalize)
 
626
            unshelver.make_merger().do_merge()
 
627
        self.assertFalse(tree.has_id('foo-id'))
 
628
        self.assertFalse(tree.has_id('bar-id'))
586
629
 
587
630
    def test_unshelve_base(self):
588
631
        tree = self.make_branch_and_tree('tree')
618
661
                                                                'foo'))])
619
662
        shelf_file = open('shelf', 'rb')
620
663
        self.addCleanup(shelf_file.close)
621
 
        e = self.assertRaises(errors.ShelfCorrupt,
 
664
        e = self.assertRaises(shelf.ShelfCorrupt,
622
665
                              shelf.Unshelver.from_tree_and_shelf, tree,
623
666
                              shelf_file)
624
667
        self.assertEqual('Shelf corrupt.', str(e))
625
668
 
 
669
    def test_unshelve_subdir_in_now_removed_dir(self):
 
670
        tree = self.make_branch_and_tree('.')
 
671
        self.addCleanup(tree.lock_write().unlock)
 
672
        self.build_tree(['dir/', 'dir/subdir/', 'dir/subdir/foo'])
 
673
        tree.add(['dir'], ['dir-id'])
 
674
        tree.commit('versioned dir')
 
675
        tree.add(['dir/subdir', 'dir/subdir/foo'], ['subdir-id', 'foo-id'])
 
676
        creator = shelf.ShelfCreator(tree, tree.basis_tree())
 
677
        self.addCleanup(creator.finalize)
 
678
        for change in creator.iter_shelvable():
 
679
            creator.shelve_change(change)
 
680
        shelf_manager = tree.get_shelf_manager()
 
681
        shelf_id = shelf_manager.shelve_changes(creator)
 
682
        self.assertPathDoesNotExist('dir/subdir')
 
683
        tree.remove(['dir'])
 
684
        unshelver = shelf_manager.get_unshelver(shelf_id)
 
685
        self.addCleanup(unshelver.finalize)
 
686
        unshelver.make_merger().do_merge()
 
687
        self.assertPathExists('dir/subdir/foo')
 
688
        self.assertEqual('dir-id', tree.path2id('dir'))
 
689
        self.assertEqual('subdir-id', tree.path2id('dir/subdir'))
 
690
        self.assertEqual('foo-id', tree.path2id('dir/subdir/foo'))
 
691
 
626
692
 
627
693
class TestShelfManager(tests.TestCaseWithTransport):
628
694
 
706
772
 
707
773
    def test_read_non_existant(self):
708
774
        manager = self.get_manager()
709
 
        e = self.assertRaises(errors.NoSuchShelfId, manager.read_shelf, 1)
 
775
        e = self.assertRaises(shelf.NoSuchShelfId, manager.read_shelf, 1)
710
776
        self.assertEqual('No changes are shelved with id "1".', str(e))
711
777
 
712
778
    def test_shelve_changes(self):
723
789
        creator.shelve_creation('foo-id')
724
790
        shelf_manager = tree.get_shelf_manager()
725
791
        shelf_id = shelf_manager.shelve_changes(creator)
726
 
        self.failIfExists('tree/foo')
 
792
        self.assertPathDoesNotExist('tree/foo')
727
793
        unshelver = shelf_manager.get_unshelver(shelf_id)
728
794
        self.addCleanup(unshelver.finalize)
729
795
        unshelver.make_merger().do_merge()