/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 bzrlib/tests/test_dirstate.py

  • Committer: Robert Collins
  • Date: 2007-10-24 20:11:21 UTC
  • mto: This revision was merged to the branch mainline in revision 2967.
  • Revision ID: robertc@robertcollins.net-20071024201121-0h1xkei0p1pf4diy
Review feedback.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_dirstate.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests of the dirstate functionality being built for WorkingTreeFormat4."""
18
18
 
19
19
import bisect
20
20
import os
 
21
import time
21
22
 
22
23
from bzrlib import (
23
24
    dirstate,
24
25
    errors,
25
 
    inventory,
26
 
    memorytree,
27
26
    osutils,
28
 
    revision as _mod_revision,
29
 
    tests,
30
27
    )
31
 
from bzrlib.tests import test_osutils
 
28
from bzrlib.memorytree import MemoryTree
 
29
from bzrlib.osutils import has_symlinks
 
30
from bzrlib.tests import (
 
31
        TestCase,
 
32
        TestCaseWithTransport,
 
33
        TestSkipped,
 
34
        )
32
35
 
33
36
 
34
37
# TODO:
44
47
# set_path_id  setting id when state is in memory modified
45
48
 
46
49
 
47
 
def load_tests(basic_tests, module, loader):
48
 
    suite = loader.suiteClass()
49
 
    dir_reader_tests, remaining_tests = tests.split_suite_by_condition(
50
 
        basic_tests, tests.condition_isinstance(TestCaseWithDirState))
51
 
    tests.multiply_tests(dir_reader_tests,
52
 
                         test_osutils.dir_reader_scenarios(), suite)
53
 
    suite.addTest(remaining_tests)
54
 
    return suite
55
 
 
56
 
 
57
 
class TestCaseWithDirState(tests.TestCaseWithTransport):
 
50
class TestCaseWithDirState(TestCaseWithTransport):
58
51
    """Helper functions for creating DirState objects with various content."""
59
52
 
60
 
    # Set by load_tests
61
 
    _dir_reader_class = None
62
 
    _native_to_unicode = None # Not used yet
63
 
 
64
 
    def setUp(self):
65
 
        tests.TestCaseWithTransport.setUp(self)
66
 
 
67
 
        self.overrideAttr(osutils,
68
 
                          '_selected_dir_reader', self._dir_reader_class())
69
 
 
70
53
    def create_empty_dirstate(self):
71
54
        """Return a locked but empty dirstate"""
72
55
        state = dirstate.DirState.initialize('dirstate')
180
163
        """
181
164
        # The state should already be write locked, since we just had to do
182
165
        # some operation to get here.
183
 
        self.assertTrue(state._lock_token is not None)
 
166
        assert state._lock_token is not None
184
167
        try:
185
168
            self.assertEqual(expected_result[0],  state.get_parent_ids())
186
169
            # there should be no ghosts in this tree.
377
360
        # There are no files on disk and no parents
378
361
        tree = self.make_branch_and_tree('tree')
379
362
        expected_result = ([], [
380
 
            (('', '', tree.get_root_id()), # common details
 
363
            (('', '', tree.path2id('')), # common details
381
364
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
382
365
             ])])
383
366
        state = dirstate.DirState.from_tree(tree, 'dirstate')
390
373
        rev_id = tree.commit('first post').encode('utf8')
391
374
        root_stat_pack = dirstate.pack_stat(os.stat(tree.basedir))
392
375
        expected_result = ([rev_id], [
393
 
            (('', '', tree.get_root_id()), # common details
 
376
            (('', '', tree.path2id('')), # common details
394
377
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
395
378
              ('d', '', 0, False, rev_id), # first parent details
396
379
             ])])
410
393
        rev_id2 = tree2.commit('second post', allow_pointless=True)
411
394
        tree.merge_from_branch(tree2.branch)
412
395
        expected_result = ([rev_id, rev_id2], [
413
 
            (('', '', tree.get_root_id()), # common details
 
396
            (('', '', tree.path2id('')), # common details
414
397
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
415
398
              ('d', '', 0, False, rev_id), # first parent details
416
 
              ('d', '', 0, False, rev_id), # second parent details
 
399
              ('d', '', 0, False, rev_id2), # second parent details
417
400
             ])])
418
401
        state = dirstate.DirState.from_tree(tree, 'dirstate')
419
402
        self.check_state_with_reopen(expected_result, state)
429
412
        tree = self.make_branch_and_tree('tree')
430
413
        self.build_tree(['tree/unknown'])
431
414
        expected_result = ([], [
432
 
            (('', '', tree.get_root_id()), # common details
 
415
            (('', '', tree.path2id('')), # common details
433
416
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
434
417
             ])])
435
418
        state = dirstate.DirState.from_tree(tree, 'dirstate')
438
421
    def get_tree_with_a_file(self):
439
422
        tree = self.make_branch_and_tree('tree')
440
423
        self.build_tree(['tree/a file'])
441
 
        tree.add('a file', 'a-file-id')
 
424
        tree.add('a file', 'a file id')
442
425
        return tree
443
426
 
444
427
    def test_non_empty_no_parents_to_dirstate(self):
446
429
        # There are files on disk and no parents
447
430
        tree = self.get_tree_with_a_file()
448
431
        expected_result = ([], [
449
 
            (('', '', tree.get_root_id()), # common details
 
432
            (('', '', tree.path2id('')), # common details
450
433
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
451
434
             ]),
452
 
            (('', 'a file', 'a-file-id'), # common
 
435
            (('', 'a file', 'a file id'), # common
453
436
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
454
437
             ]),
455
438
            ])
464
447
        # and length:
465
448
        self.build_tree_contents([('tree/a file', 'new content\n')])
466
449
        expected_result = ([rev_id], [
467
 
            (('', '', tree.get_root_id()), # common details
 
450
            (('', '', tree.path2id('')), # common details
468
451
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
469
452
              ('d', '', 0, False, rev_id), # first parent details
470
453
             ]),
471
 
            (('', 'a file', 'a-file-id'), # common
 
454
            (('', 'a file', 'a file id'), # common
472
455
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
473
456
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
474
457
               rev_id), # first parent
491
474
        # and length again, giving us three distinct values:
492
475
        self.build_tree_contents([('tree/a file', 'new content\n')])
493
476
        expected_result = ([rev_id, rev_id2], [
494
 
            (('', '', tree.get_root_id()), # common details
 
477
            (('', '', tree.path2id('')), # common details
495
478
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
496
479
              ('d', '', 0, False, rev_id), # first parent details
497
 
              ('d', '', 0, False, rev_id), # second parent details
 
480
              ('d', '', 0, False, rev_id2), # second parent details
498
481
             ]),
499
 
            (('', 'a file', 'a-file-id'), # common
 
482
            (('', 'a file', 'a file id'), # common
500
483
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
501
484
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
502
485
               rev_id), # first parent
543
526
        # get a state object
544
527
        # no parents, default tree content
545
528
        expected_result = ([], [
546
 
            (('', '', tree.get_root_id()), # common details
 
529
            (('', '', tree.path2id('')), # common details
547
530
             # current tree details, but new from_tree skips statting, it
548
531
             # uses set_state_from_inventory, and thus depends on the
549
532
             # inventory state.
580
563
        state.lock_read()
581
564
        try:
582
565
            entry = state._get_entry(0, path_utf8='a-file')
583
 
            # The current size should be 0 (default)
584
 
            self.assertEqual(0, entry[1][0][2])
 
566
            # The current sha1 sum should be empty
 
567
            self.assertEqual('', entry[1][0][1])
585
568
            # We should have a real entry.
586
569
            self.assertNotEqual((None, None), entry)
587
570
            # Make sure everything is old enough
588
571
            state._sha_cutoff_time()
589
572
            state._cutoff_time += 10
590
 
            # Change the file length
591
 
            self.build_tree_contents([('a-file', 'shorter')])
592
 
            sha1sum = dirstate.update_entry(state, entry, 'a-file',
593
 
                os.lstat('a-file'))
594
 
            # new file, no cached sha:
595
 
            self.assertEqual(None, sha1sum)
 
573
            sha1sum = state.update_entry(entry, 'a-file', os.lstat('a-file'))
 
574
            # We should have gotten a real sha1
 
575
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
 
576
                             sha1sum)
596
577
 
597
578
            # The dirblock has been updated
598
 
            self.assertEqual(7, entry[1][0][2])
 
579
            self.assertEqual(sha1sum, entry[1][0][1])
599
580
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
600
581
                             state._dirblock_state)
601
582
 
611
592
        state.lock_read()
612
593
        try:
613
594
            entry = state._get_entry(0, path_utf8='a-file')
614
 
            self.assertEqual(7, entry[1][0][2])
 
595
            self.assertEqual(sha1sum, entry[1][0][1])
615
596
        finally:
616
597
            state.unlock()
617
598
 
630
611
        state.lock_read()
631
612
        try:
632
613
            entry = state._get_entry(0, path_utf8='a-file')
633
 
            sha1sum = dirstate.update_entry(state, entry, 'a-file',
634
 
                os.lstat('a-file'))
635
 
            # No sha - too new
636
 
            self.assertEqual(None, sha1sum)
 
614
            sha1sum = state.update_entry(entry, 'a-file', os.lstat('a-file'))
 
615
            # We should have gotten a real sha1
 
616
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
 
617
                             sha1sum)
637
618
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
638
619
                             state._dirblock_state)
639
620
 
656
637
                state2.unlock()
657
638
        finally:
658
639
            state.unlock()
659
 
 
 
640
        
660
641
        # The file on disk should not be modified.
661
642
        state = dirstate.DirState.on_file('dirstate')
662
643
        state.lock_read()
666
647
        finally:
667
648
            state.unlock()
668
649
 
669
 
    def test_save_refuses_if_changes_aborted(self):
670
 
        self.build_tree(['a-file', 'a-dir/'])
671
 
        state = dirstate.DirState.initialize('dirstate')
672
 
        try:
673
 
            # No stat and no sha1 sum.
674
 
            state.add('a-file', 'a-file-id', 'file', None, '')
675
 
            state.save()
676
 
        finally:
677
 
            state.unlock()
678
 
 
679
 
        # The dirstate should include TREE_ROOT and 'a-file' and nothing else
680
 
        expected_blocks = [
681
 
            ('', [(('', '', 'TREE_ROOT'),
682
 
                   [('d', '', 0, False, dirstate.DirState.NULLSTAT)])]),
683
 
            ('', [(('', 'a-file', 'a-file-id'),
684
 
                   [('f', '', 0, False, dirstate.DirState.NULLSTAT)])]),
685
 
        ]
686
 
 
687
 
        state = dirstate.DirState.on_file('dirstate')
688
 
        state.lock_write()
689
 
        try:
690
 
            state._read_dirblocks_if_needed()
691
 
            self.assertEqual(expected_blocks, state._dirblocks)
692
 
 
693
 
            # Now modify the state, but mark it as inconsistent
694
 
            state.add('a-dir', 'a-dir-id', 'directory', None, '')
695
 
            state._changes_aborted = True
696
 
            state.save()
697
 
        finally:
698
 
            state.unlock()
699
 
 
700
 
        state = dirstate.DirState.on_file('dirstate')
701
 
        state.lock_read()
702
 
        try:
703
 
            state._read_dirblocks_if_needed()
704
 
            self.assertEqual(expected_blocks, state._dirblocks)
705
 
        finally:
706
 
            state.unlock()
707
 
 
708
650
 
709
651
class TestDirStateInitialize(TestCaseWithDirState):
710
652
 
737
679
        try:
738
680
            tree1.add('')
739
681
            revid1 = tree1.commit('foo').encode('utf8')
740
 
            root_id = tree1.get_root_id()
 
682
            root_id = tree1.inventory.root.file_id
741
683
            inv = tree1.inventory
742
684
        finally:
743
685
            tree1.unlock()
762
704
        # https://bugs.launchpad.net/bzr/+bug/146176
763
705
        # set_state_from_inventory should preserve the stat and hash value for
764
706
        # workingtree files that are not changed by the inventory.
765
 
 
 
707
       
766
708
        tree = self.make_branch_and_tree('.')
767
709
        # depends on the default format using dirstate...
768
710
        tree.lock_write()
769
711
        try:
770
 
            # make a dirstate with some valid hashcache data
 
712
            # make a dirstate with some valid hashcache data 
771
713
            # file on disk, but that's not needed for this test
772
714
            foo_contents = 'contents of foo'
773
715
            self.build_tree_contents([('foo', foo_contents)])
793
735
                (('', 'foo', 'foo-id',),
794
736
                 [('f', foo_sha, foo_size, False, foo_packed)]),
795
737
                tree._dirstate._get_entry(0, 'foo-id'))
796
 
 
 
738
           
797
739
            # extract the inventory, and add something to it
798
740
            inv = tree._get_inventory()
799
741
            # should see the file we poked in...
821
763
        finally:
822
764
            tree.unlock()
823
765
 
 
766
 
824
767
    def test_set_state_from_inventory_mixed_paths(self):
825
768
        tree1 = self.make_branch_and_tree('tree1')
826
769
        self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
867
810
        state = dirstate.DirState.initialize('dirstate')
868
811
        try:
869
812
            # check precondition to be sure the state does change appropriately.
870
 
            root_entry = (('', '', 'TREE_ROOT'), [('d', '', 0, False, 'x'*32)])
871
 
            self.assertEqual([root_entry], list(state._iter_entries()))
872
 
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
873
 
            self.assertEqual(root_entry,
874
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
875
 
            self.assertEqual((None, None),
876
 
                             state._get_entry(0, fileid_utf8='second-root-id'))
877
 
            state.set_path_id('', 'second-root-id')
878
 
            new_root_entry = (('', '', 'second-root-id'),
879
 
                              [('d', '', 0, False, 'x'*32)])
880
 
            expected_rows = [new_root_entry]
 
813
            self.assertEqual(
 
814
                [(('', '', 'TREE_ROOT'), [('d', '', 0, False,
 
815
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])],
 
816
                list(state._iter_entries()))
 
817
            state.set_path_id('', 'foobarbaz')
 
818
            expected_rows = [
 
819
                (('', '', 'foobarbaz'), [('d', '', 0, False,
 
820
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])]
881
821
            self.assertEqual(expected_rows, list(state._iter_entries()))
882
 
            self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
883
 
            self.assertEqual(new_root_entry, 
884
 
                             state._get_entry(0, fileid_utf8='second-root-id'))
885
 
            self.assertEqual((None, None),
886
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
887
822
            # should work across save too
888
823
            state.save()
889
824
        finally:
907
842
        state._validate()
908
843
        try:
909
844
            state.set_parent_trees([('parent-revid', rt)], ghosts=[])
910
 
            root_entry = (('', '', 'TREE_ROOT'),
911
 
                          [('d', '', 0, False, 'x'*32),
912
 
                           ('d', '', 0, False, 'parent-revid')])
913
 
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
914
 
            self.assertEqual(root_entry,
915
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
916
 
            self.assertEqual((None, None),
917
 
                             state._get_entry(0, fileid_utf8='Asecond-root-id'))
918
 
            state.set_path_id('', 'Asecond-root-id')
 
845
            state.set_path_id('', 'foobarbaz')
919
846
            state._validate()
920
847
            # now see that it is what we expected
921
 
            old_root_entry = (('', '', 'TREE_ROOT'),
922
 
                              [('a', '', 0, False, ''),
923
 
                               ('d', '', 0, False, 'parent-revid')])
924
 
            new_root_entry = (('', '', 'Asecond-root-id'),
925
 
                              [('d', '', 0, False, ''),
926
 
                               ('a', '', 0, False, '')])
927
 
            expected_rows = [new_root_entry, old_root_entry]
 
848
            expected_rows = [
 
849
                (('', '', 'TREE_ROOT'),
 
850
                    [('a', '', 0, False, ''),
 
851
                     ('d', '', 0, False, 'parent-revid'),
 
852
                     ]),
 
853
                (('', '', 'foobarbaz'),
 
854
                    [('d', '', 0, False, ''),
 
855
                     ('a', '', 0, False, ''),
 
856
                     ]),
 
857
                ]
928
858
            state._validate()
929
859
            self.assertEqual(expected_rows, list(state._iter_entries()))
930
 
            self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
931
 
            self.assertEqual(old_root_entry, state._get_entry(1, path_utf8=''))
932
 
            self.assertEqual((None, None),
933
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
934
 
            self.assertEqual(old_root_entry,
935
 
                             state._get_entry(1, fileid_utf8='TREE_ROOT'))
936
 
            self.assertEqual(new_root_entry,
937
 
                             state._get_entry(0, fileid_utf8='Asecond-root-id'))
938
 
            self.assertEqual((None, None),
939
 
                             state._get_entry(1, fileid_utf8='Asecond-root-id'))
940
860
            # should work across save too
941
861
            state.save()
942
862
        finally:
958
878
        finally:
959
879
            state.unlock()
960
880
 
 
881
 
961
882
    def test_set_parent_trees_no_content(self):
962
883
        # set_parent_trees is a slow but important api to support.
963
884
        tree1 = self.make_branch_and_memory_tree('tree1')
968
889
        finally:
969
890
            tree1.unlock()
970
891
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
971
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
892
        tree2 = MemoryTree.create_on_branch(branch2)
972
893
        tree2.lock_write()
973
894
        try:
974
895
            revid2 = tree2.commit('foo')
975
 
            root_id = tree2.get_root_id()
 
896
            root_id = tree2.inventory.root.file_id
976
897
        finally:
977
898
            tree2.unlock()
978
899
        state = dirstate.DirState.initialize('dirstate')
1006
927
            state.set_parent_trees(
1007
928
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
1008
929
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
1009
 
                 ('ghost-rev', tree2.branch.repository.revision_tree(
1010
 
                                   _mod_revision.NULL_REVISION))),
 
930
                 ('ghost-rev', tree2.branch.repository.revision_tree(None))),
1011
931
                ['ghost-rev'])
1012
932
            self.assertEqual([revid1, revid2, 'ghost-rev'],
1013
933
                             state.get_parent_ids())
1017
937
                [(('', '', root_id), [
1018
938
                  ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1019
939
                  ('d', '', 0, False, revid1),
1020
 
                  ('d', '', 0, False, revid1)
 
940
                  ('d', '', 0, False, revid2)
1021
941
                  ])],
1022
942
                list(state._iter_entries()))
1023
943
        finally:
1038
958
        finally:
1039
959
            tree1.unlock()
1040
960
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1041
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
961
        tree2 = MemoryTree.create_on_branch(branch2)
1042
962
        tree2.lock_write()
1043
963
        try:
1044
964
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1045
965
            revid2 = tree2.commit('foo')
1046
 
            root_id = tree2.get_root_id()
 
966
            root_id = tree2.inventory.root.file_id
1047
967
        finally:
1048
968
            tree2.unlock()
1049
969
        # check the layout in memory
1051
971
            (('', '', root_id), [
1052
972
             ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1053
973
             ('d', '', 0, False, revid1.encode('utf8')),
1054
 
             ('d', '', 0, False, revid1.encode('utf8'))
 
974
             ('d', '', 0, False, revid2.encode('utf8'))
1055
975
             ]),
1056
976
            (('', 'a file', 'file-id'), [
1057
977
             ('a', '', 0, False, ''),
1089
1009
            (('', '', 'TREE_ROOT'), [
1090
1010
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1091
1011
             ]),
1092
 
            (('', 'a file', 'a-file-id'), [
 
1012
            (('', 'a file', 'a file id'), [
1093
1013
             ('f', '1'*20, 19, False, dirstate.pack_stat(stat)), # current tree
1094
1014
             ]),
1095
1015
            ]
1096
1016
        try:
1097
 
            state.add('a file', 'a-file-id', 'file', stat, '1'*20)
 
1017
            state.add('a file', 'a file id', 'file', stat, '1'*20)
1098
1018
            # having added it, it should be in the output of iter_entries.
1099
1019
            self.assertEqual(expected_entries, list(state._iter_entries()))
1100
1020
            # saving and reloading should not affect this.
1103
1023
            state.unlock()
1104
1024
        state = dirstate.DirState.on_file('dirstate')
1105
1025
        state.lock_read()
1106
 
        self.addCleanup(state.unlock)
1107
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1026
        try:
 
1027
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1028
        finally:
 
1029
            state.unlock()
1108
1030
 
1109
1031
    def test_add_path_to_unversioned_directory(self):
1110
1032
        """Adding a path to an unversioned directory should error.
1115
1037
        """
1116
1038
        self.build_tree(['unversioned/', 'unversioned/a file'])
1117
1039
        state = dirstate.DirState.initialize('dirstate')
1118
 
        self.addCleanup(state.unlock)
1119
 
        self.assertRaises(errors.NotVersionedError, state.add,
1120
 
                          'unversioned/a file', 'a-file-id', 'file', None, None)
 
1040
        try:
 
1041
            self.assertRaises(errors.NotVersionedError, state.add,
 
1042
                'unversioned/a file', 'a file id', 'file', None, None)
 
1043
        finally:
 
1044
            state.unlock()
1121
1045
 
1122
1046
    def test_add_directory_to_root_no_parents_all_data(self):
1123
1047
        # The most trivial addition of a dir is when there are no parents and
1143
1067
            state.unlock()
1144
1068
        state = dirstate.DirState.on_file('dirstate')
1145
1069
        state.lock_read()
1146
 
        self.addCleanup(state.unlock)
1147
1070
        state._validate()
1148
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1071
        try:
 
1072
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1073
        finally:
 
1074
            state.unlock()
1149
1075
 
1150
 
    def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
 
1076
    def test_add_symlink_to_root_no_parents_all_data(self):
1151
1077
        # The most trivial addition of a symlink when there are no parents and
1152
1078
        # its in the root and all data about the file is supplied
1153
1079
        # bzr doesn't support fake symlinks on windows, yet.
1154
 
        self.requireFeature(tests.SymlinkFeature)
1155
 
        os.symlink(target, link_name)
1156
 
        stat = os.lstat(link_name)
 
1080
        if not has_symlinks():
 
1081
            raise TestSkipped("No symlink support")
 
1082
        os.symlink('target', 'a link')
 
1083
        stat = os.lstat('a link')
1157
1084
        expected_entries = [
1158
1085
            (('', '', 'TREE_ROOT'), [
1159
1086
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1160
1087
             ]),
1161
 
            (('', link_name.encode('UTF-8'), 'a link id'), [
1162
 
             ('l', target.encode('UTF-8'), stat[6],
1163
 
              False, dirstate.pack_stat(stat)), # current tree
 
1088
            (('', 'a link', 'a link id'), [
 
1089
             ('l', 'target', 6, False, dirstate.pack_stat(stat)), # current tree
1164
1090
             ]),
1165
1091
            ]
1166
1092
        state = dirstate.DirState.initialize('dirstate')
1167
1093
        try:
1168
 
            state.add(link_name, 'a link id', 'symlink', stat,
1169
 
                      target.encode('UTF-8'))
 
1094
            state.add('a link', 'a link id', 'symlink', stat, 'target')
1170
1095
            # having added it, it should be in the output of iter_entries.
1171
1096
            self.assertEqual(expected_entries, list(state._iter_entries()))
1172
1097
            # saving and reloading should not affect this.
1175
1100
            state.unlock()
1176
1101
        state = dirstate.DirState.on_file('dirstate')
1177
1102
        state.lock_read()
1178
 
        self.addCleanup(state.unlock)
1179
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
1180
 
 
1181
 
    def test_add_symlink_to_root_no_parents_all_data(self):
1182
 
        self._test_add_symlink_to_root_no_parents_all_data('a link', 'target')
1183
 
 
1184
 
    def test_add_symlink_unicode_to_root_no_parents_all_data(self):
1185
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1186
 
        self._test_add_symlink_to_root_no_parents_all_data(
1187
 
            u'\N{Euro Sign}link', u'targ\N{Euro Sign}et')
 
1103
        try:
 
1104
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1105
        finally:
 
1106
            state.unlock()
1188
1107
 
1189
1108
    def test_add_directory_and_child_no_parents_all_data(self):
1190
1109
        # after adding a directory, we should be able to add children to it.
1198
1117
            (('', 'a dir', 'a dir id'), [
1199
1118
             ('d', '', 0, False, dirstate.pack_stat(dirstat)), # current tree
1200
1119
             ]),
1201
 
            (('a dir', 'a file', 'a-file-id'), [
 
1120
            (('a dir', 'a file', 'a file id'), [
1202
1121
             ('f', '1'*20, 25, False,
1203
1122
              dirstate.pack_stat(filestat)), # current tree details
1204
1123
             ]),
1206
1125
        state = dirstate.DirState.initialize('dirstate')
1207
1126
        try:
1208
1127
            state.add('a dir', 'a dir id', 'directory', dirstat, None)
1209
 
            state.add('a dir/a file', 'a-file-id', 'file', filestat, '1'*20)
 
1128
            state.add('a dir/a file', 'a file id', 'file', filestat, '1'*20)
1210
1129
            # added it, it should be in the output of iter_entries.
1211
1130
            self.assertEqual(expected_entries, list(state._iter_entries()))
1212
1131
            # saving and reloading should not affect this.
1215
1134
            state.unlock()
1216
1135
        state = dirstate.DirState.on_file('dirstate')
1217
1136
        state.lock_read()
1218
 
        self.addCleanup(state.unlock)
1219
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1137
        try:
 
1138
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1139
        finally:
 
1140
            state.unlock()
1220
1141
 
1221
1142
    def test_add_tree_reference(self):
1222
1143
        # make a dirstate and add a tree reference
1236
1157
            state.unlock()
1237
1158
        # now check we can read it back
1238
1159
        state.lock_read()
1239
 
        self.addCleanup(state.unlock)
1240
1160
        state._validate()
1241
 
        entry2 = state._get_entry(0, 'subdir-id', 'subdir')
1242
 
        self.assertEqual(entry, entry2)
1243
 
        self.assertEqual(entry, expected_entry)
1244
 
        # and lookup by id should work too
1245
 
        entry2 = state._get_entry(0, fileid_utf8='subdir-id')
1246
 
        self.assertEqual(entry, expected_entry)
 
1161
        try:
 
1162
            entry2 = state._get_entry(0, 'subdir-id', 'subdir')
 
1163
            self.assertEqual(entry, entry2)
 
1164
            self.assertEqual(entry, expected_entry)
 
1165
            # and lookup by id should work too
 
1166
            entry2 = state._get_entry(0, fileid_utf8='subdir-id')
 
1167
            self.assertEqual(entry, expected_entry)
 
1168
        finally:
 
1169
            state.unlock()
1247
1170
 
1248
1171
    def test_add_forbidden_names(self):
1249
1172
        state = dirstate.DirState.initialize('dirstate')
1253
1176
        self.assertRaises(errors.BzrError,
1254
1177
            state.add, '..', 'ass-id', 'directory', None, None)
1255
1178
 
1256
 
    def test_set_state_with_rename_b_a_bug_395556(self):
1257
 
        # bug 395556 uncovered a bug where the dirstate ends up with a false
1258
 
        # relocation record - in a tree with no parents there should be no
1259
 
        # absent or relocated records. This then leads to further corruption
1260
 
        # when a commit occurs, as the incorrect relocation gathers an
1261
 
        # incorrect absent in tree 1, and future changes go to pot.
1262
 
        tree1 = self.make_branch_and_tree('tree1')
1263
 
        self.build_tree(['tree1/b'])
1264
 
        tree1.lock_write()
1265
 
        try:
1266
 
            tree1.add(['b'], ['b-id'])
1267
 
            root_id = tree1.get_root_id()
1268
 
            inv = tree1.inventory
1269
 
            state = dirstate.DirState.initialize('dirstate')
1270
 
            try:
1271
 
                # Set the initial state with 'b'
1272
 
                state.set_state_from_inventory(inv)
1273
 
                inv.rename('b-id', root_id, 'a')
1274
 
                # Set the new state with 'a', which currently corrupts.
1275
 
                state.set_state_from_inventory(inv)
1276
 
                expected_result1 = [('', '', root_id, 'd'),
1277
 
                                    ('', 'a', 'b-id', 'f'),
1278
 
                                   ]
1279
 
                values = []
1280
 
                for entry in state._iter_entries():
1281
 
                    values.append(entry[0] + entry[1][0][:1])
1282
 
                self.assertEqual(expected_result1, values)
1283
 
            finally:
1284
 
                state.unlock()
1285
 
        finally:
1286
 
            tree1.unlock()
1287
 
 
1288
1179
 
1289
1180
class TestGetLines(TestCaseWithDirState):
1290
1181
 
1523
1414
        There is one parent tree, which has the same shape with the following variations:
1524
1415
        b/g in the parent is gone.
1525
1416
        b/h in the parent has a different id
1526
 
        b/i is new in the parent
 
1417
        b/i is new in the parent 
1527
1418
        c is renamed to b/j in the parent
1528
1419
 
1529
1420
        :return: The dirstate, still write-locked.
1619
1510
            list(state._iter_child_entries(1, '')))
1620
1511
 
1621
1512
 
1622
 
class TestDirstateSortOrder(tests.TestCaseWithTransport):
 
1513
class TestDirstateSortOrder(TestCaseWithTransport):
1623
1514
    """Test that DirState adds entries in the right order."""
1624
1515
 
1625
1516
    def test_add_sorting(self):
1674
1565
 
1675
1566
        # *really* cheesy way to just get an empty tree
1676
1567
        repo = self.make_repository('repo')
1677
 
        empty_tree = repo.revision_tree(_mod_revision.NULL_REVISION)
 
1568
        empty_tree = repo.revision_tree(None)
1678
1569
        state.set_parent_trees([('null:', empty_tree)], [])
1679
1570
 
1680
1571
        dirblock_names = [d[0] for d in state._dirblocks]
1684
1575
class InstrumentedDirState(dirstate.DirState):
1685
1576
    """An DirState with instrumented sha1 functionality."""
1686
1577
 
1687
 
    def __init__(self, path, sha1_provider):
1688
 
        super(InstrumentedDirState, self).__init__(path, sha1_provider)
 
1578
    def __init__(self, path):
 
1579
        super(InstrumentedDirState, self).__init__(path)
1689
1580
        self._time_offset = 0
1690
1581
        self._log = []
1691
1582
        # member is dynamically set in DirState.__init__ to turn on trace
1692
 
        self._sha1_provider = sha1_provider
1693
1583
        self._sha1_file = self._sha1_file_and_log
1694
1584
 
1695
1585
    def _sha_cutoff_time(self):
1698
1588
 
1699
1589
    def _sha1_file_and_log(self, abspath):
1700
1590
        self._log.append(('sha1', abspath))
1701
 
        return self._sha1_provider.sha1(abspath)
 
1591
        return osutils.sha_file_by_name(abspath)
1702
1592
 
1703
1593
    def _read_link(self, abspath, old_link):
1704
1594
        self._log.append(('read_link', abspath, old_link))
1735
1625
        self.st_ino = ino
1736
1626
        self.st_mode = mode
1737
1627
 
1738
 
    @staticmethod
1739
 
    def from_stat(st):
1740
 
        return _FakeStat(st.st_size, st.st_mtime, st.st_ctime, st.st_dev,
1741
 
            st.st_ino, st.st_mode)
1742
 
 
1743
 
 
1744
 
class TestPackStat(tests.TestCaseWithTransport):
 
1628
 
 
1629
class TestUpdateEntry(TestCaseWithDirState):
 
1630
    """Test the DirState.update_entry functions"""
 
1631
 
 
1632
    def get_state_with_a(self):
 
1633
        """Create a DirState tracking a single object named 'a'"""
 
1634
        state = InstrumentedDirState.initialize('dirstate')
 
1635
        self.addCleanup(state.unlock)
 
1636
        state.add('a', 'a-id', 'file', None, '')
 
1637
        entry = state._get_entry(0, path_utf8='a')
 
1638
        return state, entry
 
1639
 
 
1640
    def test_update_entry(self):
 
1641
        state, entry = self.get_state_with_a()
 
1642
        self.build_tree(['a'])
 
1643
        # Add one where we don't provide the stat or sha already
 
1644
        self.assertEqual(('', 'a', 'a-id'), entry[0])
 
1645
        self.assertEqual([('f', '', 0, False, dirstate.DirState.NULLSTAT)],
 
1646
                         entry[1])
 
1647
        # Flush the buffers to disk
 
1648
        state.save()
 
1649
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1650
                         state._dirblock_state)
 
1651
 
 
1652
        stat_value = os.lstat('a')
 
1653
        packed_stat = dirstate.pack_stat(stat_value)
 
1654
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1655
                                          stat_value=stat_value)
 
1656
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1657
                         link_or_sha1)
 
1658
 
 
1659
        # The dirblock entry should not cache the file's sha1
 
1660
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1661
                         entry[1])
 
1662
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1663
                         state._dirblock_state)
 
1664
        mode = stat_value.st_mode
 
1665
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False)], state._log)
 
1666
 
 
1667
        state.save()
 
1668
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1669
                         state._dirblock_state)
 
1670
 
 
1671
        # If we do it again right away, we don't know if the file has changed
 
1672
        # so we will re-read the file. Roll the clock back so the file is
 
1673
        # guaranteed to look too new.
 
1674
        state.adjust_time(-10)
 
1675
 
 
1676
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1677
                                          stat_value=stat_value)
 
1678
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1679
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1680
                         ], state._log)
 
1681
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1682
                         link_or_sha1)
 
1683
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1684
                         state._dirblock_state)
 
1685
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1686
                         entry[1])
 
1687
        state.save()
 
1688
 
 
1689
        # However, if we move the clock forward so the file is considered
 
1690
        # "stable", it should just cache the value.
 
1691
        state.adjust_time(+20)
 
1692
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1693
                                          stat_value=stat_value)
 
1694
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1695
                         link_or_sha1)
 
1696
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1697
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1698
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1699
                         ], state._log)
 
1700
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1701
                         entry[1])
 
1702
 
 
1703
        # Subsequent calls will just return the cached value
 
1704
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1705
                                          stat_value=stat_value)
 
1706
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1707
                         link_or_sha1)
 
1708
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1709
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1710
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1711
                         ], state._log)
 
1712
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1713
                         entry[1])
 
1714
 
 
1715
    def test_update_entry_symlink(self):
 
1716
        """Update entry should read symlinks."""
 
1717
        if not osutils.has_symlinks():
 
1718
            # PlatformDeficiency / TestSkipped
 
1719
            raise TestSkipped("No symlink support")
 
1720
        state, entry = self.get_state_with_a()
 
1721
        state.save()
 
1722
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1723
                         state._dirblock_state)
 
1724
        os.symlink('target', 'a')
 
1725
 
 
1726
        state.adjust_time(-10) # Make the symlink look new
 
1727
        stat_value = os.lstat('a')
 
1728
        packed_stat = dirstate.pack_stat(stat_value)
 
1729
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1730
                                          stat_value=stat_value)
 
1731
        self.assertEqual('target', link_or_sha1)
 
1732
        self.assertEqual([('read_link', 'a', '')], state._log)
 
1733
        # Dirblock is not updated (the link is too new)
 
1734
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1735
                         entry[1])
 
1736
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1737
                         state._dirblock_state)
 
1738
 
 
1739
        # Because the stat_value looks new, we should re-read the target
 
1740
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1741
                                          stat_value=stat_value)
 
1742
        self.assertEqual('target', link_or_sha1)
 
1743
        self.assertEqual([('read_link', 'a', ''),
 
1744
                          ('read_link', 'a', ''),
 
1745
                         ], state._log)
 
1746
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1747
                         entry[1])
 
1748
        state.adjust_time(+20) # Skip into the future, all files look old
 
1749
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1750
                                          stat_value=stat_value)
 
1751
        self.assertEqual('target', link_or_sha1)
 
1752
        # We need to re-read the link because only now can we cache it
 
1753
        self.assertEqual([('read_link', 'a', ''),
 
1754
                          ('read_link', 'a', ''),
 
1755
                          ('read_link', 'a', ''),
 
1756
                         ], state._log)
 
1757
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1758
                         entry[1])
 
1759
 
 
1760
        # Another call won't re-read the link
 
1761
        self.assertEqual([('read_link', 'a', ''),
 
1762
                          ('read_link', 'a', ''),
 
1763
                          ('read_link', 'a', ''),
 
1764
                         ], state._log)
 
1765
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1766
                                          stat_value=stat_value)
 
1767
        self.assertEqual('target', link_or_sha1)
 
1768
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1769
                         entry[1])
 
1770
 
 
1771
    def do_update_entry(self, state, entry, abspath):
 
1772
        stat_value = os.lstat(abspath)
 
1773
        return state.update_entry(entry, abspath, stat_value)
 
1774
 
 
1775
    def test_update_entry_dir(self):
 
1776
        state, entry = self.get_state_with_a()
 
1777
        self.build_tree(['a/'])
 
1778
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1779
 
 
1780
    def test_update_entry_dir_unchanged(self):
 
1781
        state, entry = self.get_state_with_a()
 
1782
        self.build_tree(['a/'])
 
1783
        state.adjust_time(+20)
 
1784
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1785
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1786
                         state._dirblock_state)
 
1787
        state.save()
 
1788
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1789
                         state._dirblock_state)
 
1790
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1791
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1792
                         state._dirblock_state)
 
1793
 
 
1794
    def test_update_entry_file_unchanged(self):
 
1795
        state, entry = self.get_state_with_a()
 
1796
        self.build_tree(['a'])
 
1797
        sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1798
        state.adjust_time(+20)
 
1799
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1800
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1801
                         state._dirblock_state)
 
1802
        state.save()
 
1803
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1804
                         state._dirblock_state)
 
1805
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1806
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1807
                         state._dirblock_state)
 
1808
 
 
1809
    def create_and_test_file(self, state, entry):
 
1810
        """Create a file at 'a' and verify the state finds it.
 
1811
 
 
1812
        The state should already be versioning *something* at 'a'. This makes
 
1813
        sure that state.update_entry recognizes it as a file.
 
1814
        """
 
1815
        self.build_tree(['a'])
 
1816
        stat_value = os.lstat('a')
 
1817
        packed_stat = dirstate.pack_stat(stat_value)
 
1818
 
 
1819
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1820
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1821
                         link_or_sha1)
 
1822
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1823
                         entry[1])
 
1824
        return packed_stat
 
1825
 
 
1826
    def create_and_test_dir(self, state, entry):
 
1827
        """Create a directory at 'a' and verify the state finds it.
 
1828
 
 
1829
        The state should already be versioning *something* at 'a'. This makes
 
1830
        sure that state.update_entry recognizes it as a directory.
 
1831
        """
 
1832
        self.build_tree(['a/'])
 
1833
        stat_value = os.lstat('a')
 
1834
        packed_stat = dirstate.pack_stat(stat_value)
 
1835
 
 
1836
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1837
        self.assertIs(None, link_or_sha1)
 
1838
        self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
 
1839
 
 
1840
        return packed_stat
 
1841
 
 
1842
    def create_and_test_symlink(self, state, entry):
 
1843
        """Create a symlink at 'a' and verify the state finds it.
 
1844
 
 
1845
        The state should already be versioning *something* at 'a'. This makes
 
1846
        sure that state.update_entry recognizes it as a symlink.
 
1847
 
 
1848
        This should not be called if this platform does not have symlink
 
1849
        support.
 
1850
        """
 
1851
        # caller should care about skipping test on platforms without symlinks
 
1852
        os.symlink('path/to/foo', 'a')
 
1853
 
 
1854
        stat_value = os.lstat('a')
 
1855
        packed_stat = dirstate.pack_stat(stat_value)
 
1856
 
 
1857
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1858
        self.assertEqual('path/to/foo', link_or_sha1)
 
1859
        self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
 
1860
                         entry[1])
 
1861
        return packed_stat
 
1862
 
 
1863
    def test_update_file_to_dir(self):
 
1864
        """If a file changes to a directory we return None for the sha.
 
1865
        We also update the inventory record.
 
1866
        """
 
1867
        state, entry = self.get_state_with_a()
 
1868
        # The file sha1 won't be cached unless the file is old
 
1869
        state.adjust_time(+10)
 
1870
        self.create_and_test_file(state, entry)
 
1871
        os.remove('a')
 
1872
        self.create_and_test_dir(state, entry)
 
1873
 
 
1874
    def test_update_file_to_symlink(self):
 
1875
        """File becomes a symlink"""
 
1876
        if not osutils.has_symlinks():
 
1877
            # PlatformDeficiency / TestSkipped
 
1878
            raise TestSkipped("No symlink support")
 
1879
        state, entry = self.get_state_with_a()
 
1880
        # The file sha1 won't be cached unless the file is old
 
1881
        state.adjust_time(+10)
 
1882
        self.create_and_test_file(state, entry)
 
1883
        os.remove('a')
 
1884
        self.create_and_test_symlink(state, entry)
 
1885
 
 
1886
    def test_update_dir_to_file(self):
 
1887
        """Directory becoming a file updates the entry."""
 
1888
        state, entry = self.get_state_with_a()
 
1889
        # The file sha1 won't be cached unless the file is old
 
1890
        state.adjust_time(+10)
 
1891
        self.create_and_test_dir(state, entry)
 
1892
        os.rmdir('a')
 
1893
        self.create_and_test_file(state, entry)
 
1894
 
 
1895
    def test_update_dir_to_symlink(self):
 
1896
        """Directory becomes a symlink"""
 
1897
        if not osutils.has_symlinks():
 
1898
            # PlatformDeficiency / TestSkipped
 
1899
            raise TestSkipped("No symlink support")
 
1900
        state, entry = self.get_state_with_a()
 
1901
        # The symlink target won't be cached if it isn't old
 
1902
        state.adjust_time(+10)
 
1903
        self.create_and_test_dir(state, entry)
 
1904
        os.rmdir('a')
 
1905
        self.create_and_test_symlink(state, entry)
 
1906
 
 
1907
    def test_update_symlink_to_file(self):
 
1908
        """Symlink becomes a file"""
 
1909
        if not has_symlinks():
 
1910
            raise TestSkipped("No symlink support")
 
1911
        state, entry = self.get_state_with_a()
 
1912
        # The symlink and file info won't be cached unless old
 
1913
        state.adjust_time(+10)
 
1914
        self.create_and_test_symlink(state, entry)
 
1915
        os.remove('a')
 
1916
        self.create_and_test_file(state, entry)
 
1917
 
 
1918
    def test_update_symlink_to_dir(self):
 
1919
        """Symlink becomes a directory"""
 
1920
        if not has_symlinks():
 
1921
            raise TestSkipped("No symlink support")
 
1922
        state, entry = self.get_state_with_a()
 
1923
        # The symlink target won't be cached if it isn't old
 
1924
        state.adjust_time(+10)
 
1925
        self.create_and_test_symlink(state, entry)
 
1926
        os.remove('a')
 
1927
        self.create_and_test_dir(state, entry)
 
1928
 
 
1929
    def test__is_executable_win32(self):
 
1930
        state, entry = self.get_state_with_a()
 
1931
        self.build_tree(['a'])
 
1932
 
 
1933
        # Make sure we are using the win32 implementation of _is_executable
 
1934
        state._is_executable = state._is_executable_win32
 
1935
 
 
1936
        # The file on disk is not executable, but we are marking it as though
 
1937
        # it is. With _is_executable_win32 we ignore what is on disk.
 
1938
        entry[1][0] = ('f', '', 0, True, dirstate.DirState.NULLSTAT)
 
1939
 
 
1940
        stat_value = os.lstat('a')
 
1941
        packed_stat = dirstate.pack_stat(stat_value)
 
1942
 
 
1943
        state.adjust_time(-10) # Make sure everything is new
 
1944
        state.update_entry(entry, abspath='a', stat_value=stat_value)
 
1945
 
 
1946
        # The row is updated, but the executable bit stays set.
 
1947
        self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
 
1948
                         entry[1])
 
1949
 
 
1950
        # Make the disk object look old enough to cache
 
1951
        state.adjust_time(+20)
 
1952
        digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1953
        state.update_entry(entry, abspath='a', stat_value=stat_value)
 
1954
        self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
 
1955
 
 
1956
 
 
1957
class TestPackStat(TestCaseWithTransport):
1745
1958
 
1746
1959
    def assertPackStat(self, expected, stat_value):
1747
1960
        """Check the packed and serialized form of a stat value."""
1812
2025
        # the end it would still be fairly arbitrary, and we don't want the
1813
2026
        # extra overhead if we can avoid it. So sort everything to make sure
1814
2027
        # equality is true
1815
 
        self.assertEqual(len(map_keys), len(paths))
 
2028
        assert len(map_keys) == len(paths)
1816
2029
        expected = {}
1817
2030
        for path, keys in zip(paths, map_keys):
1818
2031
            if keys is None:
1837
2050
        :param paths: A list of directories
1838
2051
        """
1839
2052
        result = state._bisect_dirblocks(paths)
1840
 
        self.assertEqual(len(map_keys), len(paths))
 
2053
        assert len(map_keys) == len(paths)
 
2054
 
1841
2055
        expected = {}
1842
2056
        for path, keys in zip(paths, map_keys):
1843
2057
            if keys is None:
2107
2321
            self.assertEqual(expected, state._find_block(key))
2108
2322
        finally:
2109
2323
            state.unlock()
2110
 
 
2111
 
 
2112
 
class TestDiscardMergeParents(TestCaseWithDirState):
2113
 
 
2114
 
    def test_discard_no_parents(self):
2115
 
        # This should be a no-op
2116
 
        state = self.create_empty_dirstate()
2117
 
        self.addCleanup(state.unlock)
2118
 
        state._discard_merge_parents()
2119
 
        state._validate()
2120
 
 
2121
 
    def test_discard_one_parent(self):
2122
 
        # No-op
2123
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2124
 
        root_entry_direntry = ('', '', 'a-root-value'), [
2125
 
            ('d', '', 0, False, packed_stat),
2126
 
            ('d', '', 0, False, packed_stat),
2127
 
            ]
2128
 
        dirblocks = []
2129
 
        dirblocks.append(('', [root_entry_direntry]))
2130
 
        dirblocks.append(('', []))
2131
 
 
2132
 
        state = self.create_empty_dirstate()
2133
 
        self.addCleanup(state.unlock)
2134
 
        state._set_data(['parent-id'], dirblocks[:])
2135
 
        state._validate()
2136
 
 
2137
 
        state._discard_merge_parents()
2138
 
        state._validate()
2139
 
        self.assertEqual(dirblocks, state._dirblocks)
2140
 
 
2141
 
    def test_discard_simple(self):
2142
 
        # No-op
2143
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2144
 
        root_entry_direntry = ('', '', 'a-root-value'), [
2145
 
            ('d', '', 0, False, packed_stat),
2146
 
            ('d', '', 0, False, packed_stat),
2147
 
            ('d', '', 0, False, packed_stat),
2148
 
            ]
2149
 
        expected_root_entry_direntry = ('', '', 'a-root-value'), [
2150
 
            ('d', '', 0, False, packed_stat),
2151
 
            ('d', '', 0, False, packed_stat),
2152
 
            ]
2153
 
        dirblocks = []
2154
 
        dirblocks.append(('', [root_entry_direntry]))
2155
 
        dirblocks.append(('', []))
2156
 
 
2157
 
        state = self.create_empty_dirstate()
2158
 
        self.addCleanup(state.unlock)
2159
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2160
 
        state._validate()
2161
 
 
2162
 
        # This should strip of the extra column
2163
 
        state._discard_merge_parents()
2164
 
        state._validate()
2165
 
        expected_dirblocks = [('', [expected_root_entry_direntry]), ('', [])]
2166
 
        self.assertEqual(expected_dirblocks, state._dirblocks)
2167
 
 
2168
 
    def test_discard_absent(self):
2169
 
        """If entries are only in a merge, discard should remove the entries"""
2170
 
        null_stat = dirstate.DirState.NULLSTAT
2171
 
        present_dir = ('d', '', 0, False, null_stat)
2172
 
        present_file = ('f', '', 0, False, null_stat)
2173
 
        absent = dirstate.DirState.NULL_PARENT_DETAILS
2174
 
        root_key = ('', '', 'a-root-value')
2175
 
        file_in_root_key = ('', 'file-in-root', 'a-file-id')
2176
 
        file_in_merged_key = ('', 'file-in-merged', 'b-file-id')
2177
 
        dirblocks = [('', [(root_key, [present_dir, present_dir, present_dir])]),
2178
 
                     ('', [(file_in_merged_key,
2179
 
                            [absent, absent, present_file]),
2180
 
                           (file_in_root_key,
2181
 
                            [present_file, present_file, present_file]),
2182
 
                          ]),
2183
 
                    ]
2184
 
 
2185
 
        state = self.create_empty_dirstate()
2186
 
        self.addCleanup(state.unlock)
2187
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2188
 
        state._validate()
2189
 
 
2190
 
        exp_dirblocks = [('', [(root_key, [present_dir, present_dir])]),
2191
 
                         ('', [(file_in_root_key,
2192
 
                                [present_file, present_file]),
2193
 
                              ]),
2194
 
                        ]
2195
 
        state._discard_merge_parents()
2196
 
        state._validate()
2197
 
        self.assertEqual(exp_dirblocks, state._dirblocks)
2198
 
 
2199
 
    def test_discard_renamed(self):
2200
 
        null_stat = dirstate.DirState.NULLSTAT
2201
 
        present_dir = ('d', '', 0, False, null_stat)
2202
 
        present_file = ('f', '', 0, False, null_stat)
2203
 
        absent = dirstate.DirState.NULL_PARENT_DETAILS
2204
 
        root_key = ('', '', 'a-root-value')
2205
 
        file_in_root_key = ('', 'file-in-root', 'a-file-id')
2206
 
        # Renamed relative to parent
2207
 
        file_rename_s_key = ('', 'file-s', 'b-file-id')
2208
 
        file_rename_t_key = ('', 'file-t', 'b-file-id')
2209
 
        # And one that is renamed between the parents, but absent in this
2210
 
        key_in_1 = ('', 'file-in-1', 'c-file-id')
2211
 
        key_in_2 = ('', 'file-in-2', 'c-file-id')
2212
 
 
2213
 
        dirblocks = [
2214
 
            ('', [(root_key, [present_dir, present_dir, present_dir])]),
2215
 
            ('', [(key_in_1,
2216
 
                   [absent, present_file, ('r', 'file-in-2', 'c-file-id')]),
2217
 
                  (key_in_2,
2218
 
                   [absent, ('r', 'file-in-1', 'c-file-id'), present_file]),
2219
 
                  (file_in_root_key,
2220
 
                   [present_file, present_file, present_file]),
2221
 
                  (file_rename_s_key,
2222
 
                   [('r', 'file-t', 'b-file-id'), absent, present_file]),
2223
 
                  (file_rename_t_key,
2224
 
                   [present_file, absent, ('r', 'file-s', 'b-file-id')]),
2225
 
                 ]),
2226
 
        ]
2227
 
        exp_dirblocks = [
2228
 
            ('', [(root_key, [present_dir, present_dir])]),
2229
 
            ('', [(key_in_1, [absent, present_file]),
2230
 
                  (file_in_root_key, [present_file, present_file]),
2231
 
                  (file_rename_t_key, [present_file, absent]),
2232
 
                 ]),
2233
 
        ]
2234
 
        state = self.create_empty_dirstate()
2235
 
        self.addCleanup(state.unlock)
2236
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2237
 
        state._validate()
2238
 
 
2239
 
        state._discard_merge_parents()
2240
 
        state._validate()
2241
 
        self.assertEqual(exp_dirblocks, state._dirblocks)
2242
 
 
2243
 
    def test_discard_all_subdir(self):
2244
 
        null_stat = dirstate.DirState.NULLSTAT
2245
 
        present_dir = ('d', '', 0, False, null_stat)
2246
 
        present_file = ('f', '', 0, False, null_stat)
2247
 
        absent = dirstate.DirState.NULL_PARENT_DETAILS
2248
 
        root_key = ('', '', 'a-root-value')
2249
 
        subdir_key = ('', 'sub', 'dir-id')
2250
 
        child1_key = ('sub', 'child1', 'child1-id')
2251
 
        child2_key = ('sub', 'child2', 'child2-id')
2252
 
        child3_key = ('sub', 'child3', 'child3-id')
2253
 
 
2254
 
        dirblocks = [
2255
 
            ('', [(root_key, [present_dir, present_dir, present_dir])]),
2256
 
            ('', [(subdir_key, [present_dir, present_dir, present_dir])]),
2257
 
            ('sub', [(child1_key, [absent, absent, present_file]),
2258
 
                     (child2_key, [absent, absent, present_file]),
2259
 
                     (child3_key, [absent, absent, present_file]),
2260
 
                    ]),
2261
 
        ]
2262
 
        exp_dirblocks = [
2263
 
            ('', [(root_key, [present_dir, present_dir])]),
2264
 
            ('', [(subdir_key, [present_dir, present_dir])]),
2265
 
            ('sub', []),
2266
 
        ]
2267
 
        state = self.create_empty_dirstate()
2268
 
        self.addCleanup(state.unlock)
2269
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2270
 
        state._validate()
2271
 
 
2272
 
        state._discard_merge_parents()
2273
 
        state._validate()
2274
 
        self.assertEqual(exp_dirblocks, state._dirblocks)
2275
 
 
2276
 
 
2277
 
class Test_InvEntryToDetails(tests.TestCase):
2278
 
 
2279
 
    def assertDetails(self, expected, inv_entry):
2280
 
        details = dirstate.DirState._inv_entry_to_details(inv_entry)
2281
 
        self.assertEqual(expected, details)
2282
 
        # details should always allow join() and always be a plain str when
2283
 
        # finished
2284
 
        (minikind, fingerprint, size, executable, tree_data) = details
2285
 
        self.assertIsInstance(minikind, str)
2286
 
        self.assertIsInstance(fingerprint, str)
2287
 
        self.assertIsInstance(tree_data, str)
2288
 
 
2289
 
    def test_unicode_symlink(self):
2290
 
        inv_entry = inventory.InventoryLink('link-file-id',
2291
 
                                            u'nam\N{Euro Sign}e',
2292
 
                                            'link-parent-id')
2293
 
        inv_entry.revision = 'link-revision-id'
2294
 
        target = u'link-targ\N{Euro Sign}t'
2295
 
        inv_entry.symlink_target = target
2296
 
        self.assertDetails(('l', target.encode('UTF-8'), 0, False,
2297
 
                            'link-revision-id'), inv_entry)
2298
 
 
2299
 
 
2300
 
class TestSHA1Provider(tests.TestCaseInTempDir):
2301
 
 
2302
 
    def test_sha1provider_is_an_interface(self):
2303
 
        p = dirstate.SHA1Provider()
2304
 
        self.assertRaises(NotImplementedError, p.sha1, "foo")
2305
 
        self.assertRaises(NotImplementedError, p.stat_and_sha1, "foo")
2306
 
 
2307
 
    def test_defaultsha1provider_sha1(self):
2308
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
2309
 
        self.build_tree_contents([('foo', text)])
2310
 
        expected_sha = osutils.sha_string(text)
2311
 
        p = dirstate.DefaultSHA1Provider()
2312
 
        self.assertEqual(expected_sha, p.sha1('foo'))
2313
 
 
2314
 
    def test_defaultsha1provider_stat_and_sha1(self):
2315
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
2316
 
        self.build_tree_contents([('foo', text)])
2317
 
        expected_sha = osutils.sha_string(text)
2318
 
        p = dirstate.DefaultSHA1Provider()
2319
 
        statvalue, sha1 = p.stat_and_sha1('foo')
2320
 
        self.assertTrue(len(statvalue) >= 10)
2321
 
        self.assertEqual(len(text), statvalue.st_size)
2322
 
        self.assertEqual(expected_sha, sha1)