/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: 2008-09-19 06:53:41 UTC
  • mto: (3696.5.1 commit-updates)
  • mto: This revision was merged to the branch mainline in revision 3741.
  • Revision ID: robertc@robertcollins.net-20080919065341-5t5w1p2gi926nfia
First cut - make it work - at updating the tree stat cache during commit.

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
26
    inventory,
26
 
    memorytree,
27
27
    osutils,
28
28
    revision as _mod_revision,
29
 
    tests,
30
29
    )
31
 
from bzrlib.tests import test_osutils
 
30
from bzrlib.memorytree import MemoryTree
 
31
from bzrlib.tests import (
 
32
        SymlinkFeature,
 
33
        TestCase,
 
34
        TestCaseWithTransport,
 
35
        )
32
36
 
33
37
 
34
38
# TODO:
44
48
# set_path_id  setting id when state is in memory modified
45
49
 
46
50
 
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):
 
51
class TestCaseWithDirState(TestCaseWithTransport):
58
52
    """Helper functions for creating DirState objects with various content."""
59
53
 
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
54
    def create_empty_dirstate(self):
71
55
        """Return a locked but empty dirstate"""
72
56
        state = dirstate.DirState.initialize('dirstate')
413
397
            (('', '', tree.get_root_id()), # common details
414
398
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
415
399
              ('d', '', 0, False, rev_id), # first parent details
416
 
              ('d', '', 0, False, rev_id), # second parent details
 
400
              ('d', '', 0, False, rev_id2), # second parent details
417
401
             ])])
418
402
        state = dirstate.DirState.from_tree(tree, 'dirstate')
419
403
        self.check_state_with_reopen(expected_result, state)
494
478
            (('', '', tree.get_root_id()), # common details
495
479
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
496
480
              ('d', '', 0, False, rev_id), # first parent details
497
 
              ('d', '', 0, False, rev_id), # second parent details
 
481
              ('d', '', 0, False, rev_id2), # second parent details
498
482
             ]),
499
483
            (('', 'a file', 'a-file-id'), # common
500
484
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
580
564
        state.lock_read()
581
565
        try:
582
566
            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])
 
567
            # The current sha1 sum should be empty
 
568
            self.assertEqual('', entry[1][0][1])
585
569
            # We should have a real entry.
586
570
            self.assertNotEqual((None, None), entry)
587
571
            # Make sure everything is old enough
588
572
            state._sha_cutoff_time()
589
573
            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)
 
574
            sha1sum = state.update_entry(entry, 'a-file', os.lstat('a-file'))
 
575
            # We should have gotten a real sha1
 
576
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
 
577
                             sha1sum)
596
578
 
597
579
            # The dirblock has been updated
598
 
            self.assertEqual(7, entry[1][0][2])
 
580
            self.assertEqual(sha1sum, entry[1][0][1])
599
581
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
600
582
                             state._dirblock_state)
601
583
 
611
593
        state.lock_read()
612
594
        try:
613
595
            entry = state._get_entry(0, path_utf8='a-file')
614
 
            self.assertEqual(7, entry[1][0][2])
 
596
            self.assertEqual(sha1sum, entry[1][0][1])
615
597
        finally:
616
598
            state.unlock()
617
599
 
630
612
        state.lock_read()
631
613
        try:
632
614
            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)
 
615
            sha1sum = state.update_entry(entry, 'a-file', os.lstat('a-file'))
 
616
            # We should have gotten a real sha1
 
617
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
 
618
                             sha1sum)
637
619
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
638
620
                             state._dirblock_state)
639
621
 
656
638
                state2.unlock()
657
639
        finally:
658
640
            state.unlock()
659
 
 
 
641
        
660
642
        # The file on disk should not be modified.
661
643
        state = dirstate.DirState.on_file('dirstate')
662
644
        state.lock_read()
762
744
        # https://bugs.launchpad.net/bzr/+bug/146176
763
745
        # set_state_from_inventory should preserve the stat and hash value for
764
746
        # workingtree files that are not changed by the inventory.
765
 
 
 
747
       
766
748
        tree = self.make_branch_and_tree('.')
767
749
        # depends on the default format using dirstate...
768
750
        tree.lock_write()
769
751
        try:
770
 
            # make a dirstate with some valid hashcache data
 
752
            # make a dirstate with some valid hashcache data 
771
753
            # file on disk, but that's not needed for this test
772
754
            foo_contents = 'contents of foo'
773
755
            self.build_tree_contents([('foo', foo_contents)])
793
775
                (('', 'foo', 'foo-id',),
794
776
                 [('f', foo_sha, foo_size, False, foo_packed)]),
795
777
                tree._dirstate._get_entry(0, 'foo-id'))
796
 
 
 
778
           
797
779
            # extract the inventory, and add something to it
798
780
            inv = tree._get_inventory()
799
781
            # should see the file we poked in...
821
803
        finally:
822
804
            tree.unlock()
823
805
 
 
806
 
824
807
    def test_set_state_from_inventory_mixed_paths(self):
825
808
        tree1 = self.make_branch_and_tree('tree1')
826
809
        self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
867
850
        state = dirstate.DirState.initialize('dirstate')
868
851
        try:
869
852
            # 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]
 
853
            self.assertEqual(
 
854
                [(('', '', 'TREE_ROOT'), [('d', '', 0, False,
 
855
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])],
 
856
                list(state._iter_entries()))
 
857
            state.set_path_id('', 'foobarbaz')
 
858
            expected_rows = [
 
859
                (('', '', 'foobarbaz'), [('d', '', 0, False,
 
860
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])]
881
861
            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
862
            # should work across save too
888
863
            state.save()
889
864
        finally:
907
882
        state._validate()
908
883
        try:
909
884
            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')
 
885
            state.set_path_id('', 'foobarbaz')
919
886
            state._validate()
920
887
            # 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]
 
888
            expected_rows = [
 
889
                (('', '', 'TREE_ROOT'),
 
890
                    [('a', '', 0, False, ''),
 
891
                     ('d', '', 0, False, 'parent-revid'),
 
892
                     ]),
 
893
                (('', '', 'foobarbaz'),
 
894
                    [('d', '', 0, False, ''),
 
895
                     ('a', '', 0, False, ''),
 
896
                     ]),
 
897
                ]
928
898
            state._validate()
929
899
            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
900
            # should work across save too
941
901
            state.save()
942
902
        finally:
958
918
        finally:
959
919
            state.unlock()
960
920
 
 
921
 
961
922
    def test_set_parent_trees_no_content(self):
962
923
        # set_parent_trees is a slow but important api to support.
963
924
        tree1 = self.make_branch_and_memory_tree('tree1')
968
929
        finally:
969
930
            tree1.unlock()
970
931
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
971
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
932
        tree2 = MemoryTree.create_on_branch(branch2)
972
933
        tree2.lock_write()
973
934
        try:
974
935
            revid2 = tree2.commit('foo')
1017
978
                [(('', '', root_id), [
1018
979
                  ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1019
980
                  ('d', '', 0, False, revid1),
1020
 
                  ('d', '', 0, False, revid1)
 
981
                  ('d', '', 0, False, revid2)
1021
982
                  ])],
1022
983
                list(state._iter_entries()))
1023
984
        finally:
1038
999
        finally:
1039
1000
            tree1.unlock()
1040
1001
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1041
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
1002
        tree2 = MemoryTree.create_on_branch(branch2)
1042
1003
        tree2.lock_write()
1043
1004
        try:
1044
1005
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1051
1012
            (('', '', root_id), [
1052
1013
             ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1053
1014
             ('d', '', 0, False, revid1.encode('utf8')),
1054
 
             ('d', '', 0, False, revid1.encode('utf8'))
 
1015
             ('d', '', 0, False, revid2.encode('utf8'))
1055
1016
             ]),
1056
1017
            (('', 'a file', 'file-id'), [
1057
1018
             ('a', '', 0, False, ''),
1103
1064
            state.unlock()
1104
1065
        state = dirstate.DirState.on_file('dirstate')
1105
1066
        state.lock_read()
1106
 
        self.addCleanup(state.unlock)
1107
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1067
        try:
 
1068
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1069
        finally:
 
1070
            state.unlock()
1108
1071
 
1109
1072
    def test_add_path_to_unversioned_directory(self):
1110
1073
        """Adding a path to an unversioned directory should error.
1115
1078
        """
1116
1079
        self.build_tree(['unversioned/', 'unversioned/a file'])
1117
1080
        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)
 
1081
        try:
 
1082
            self.assertRaises(errors.NotVersionedError, state.add,
 
1083
                'unversioned/a file', 'a-file-id', 'file', None, None)
 
1084
        finally:
 
1085
            state.unlock()
1121
1086
 
1122
1087
    def test_add_directory_to_root_no_parents_all_data(self):
1123
1088
        # The most trivial addition of a dir is when there are no parents and
1143
1108
            state.unlock()
1144
1109
        state = dirstate.DirState.on_file('dirstate')
1145
1110
        state.lock_read()
1146
 
        self.addCleanup(state.unlock)
1147
1111
        state._validate()
1148
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1112
        try:
 
1113
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1114
        finally:
 
1115
            state.unlock()
1149
1116
 
1150
 
    def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
 
1117
    def test_add_symlink_to_root_no_parents_all_data(self):
1151
1118
        # The most trivial addition of a symlink when there are no parents and
1152
1119
        # its in the root and all data about the file is supplied
1153
1120
        # 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)
 
1121
        self.requireFeature(SymlinkFeature)
 
1122
        os.symlink('target', 'a link')
 
1123
        stat = os.lstat('a link')
1157
1124
        expected_entries = [
1158
1125
            (('', '', 'TREE_ROOT'), [
1159
1126
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1160
1127
             ]),
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
 
1128
            (('', 'a link', 'a link id'), [
 
1129
             ('l', 'target', 6, False, dirstate.pack_stat(stat)), # current tree
1164
1130
             ]),
1165
1131
            ]
1166
1132
        state = dirstate.DirState.initialize('dirstate')
1167
1133
        try:
1168
 
            state.add(link_name, 'a link id', 'symlink', stat,
1169
 
                      target.encode('UTF-8'))
 
1134
            state.add('a link', 'a link id', 'symlink', stat, 'target')
1170
1135
            # having added it, it should be in the output of iter_entries.
1171
1136
            self.assertEqual(expected_entries, list(state._iter_entries()))
1172
1137
            # saving and reloading should not affect this.
1175
1140
            state.unlock()
1176
1141
        state = dirstate.DirState.on_file('dirstate')
1177
1142
        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')
 
1143
        try:
 
1144
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1145
        finally:
 
1146
            state.unlock()
1188
1147
 
1189
1148
    def test_add_directory_and_child_no_parents_all_data(self):
1190
1149
        # after adding a directory, we should be able to add children to it.
1215
1174
            state.unlock()
1216
1175
        state = dirstate.DirState.on_file('dirstate')
1217
1176
        state.lock_read()
1218
 
        self.addCleanup(state.unlock)
1219
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1177
        try:
 
1178
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1179
        finally:
 
1180
            state.unlock()
1220
1181
 
1221
1182
    def test_add_tree_reference(self):
1222
1183
        # make a dirstate and add a tree reference
1236
1197
            state.unlock()
1237
1198
        # now check we can read it back
1238
1199
        state.lock_read()
1239
 
        self.addCleanup(state.unlock)
1240
1200
        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)
 
1201
        try:
 
1202
            entry2 = state._get_entry(0, 'subdir-id', 'subdir')
 
1203
            self.assertEqual(entry, entry2)
 
1204
            self.assertEqual(entry, expected_entry)
 
1205
            # and lookup by id should work too
 
1206
            entry2 = state._get_entry(0, fileid_utf8='subdir-id')
 
1207
            self.assertEqual(entry, expected_entry)
 
1208
        finally:
 
1209
            state.unlock()
1247
1210
 
1248
1211
    def test_add_forbidden_names(self):
1249
1212
        state = dirstate.DirState.initialize('dirstate')
1253
1216
        self.assertRaises(errors.BzrError,
1254
1217
            state.add, '..', 'ass-id', 'directory', None, None)
1255
1218
 
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
1219
 
1289
1220
class TestGetLines(TestCaseWithDirState):
1290
1221
 
1523
1454
        There is one parent tree, which has the same shape with the following variations:
1524
1455
        b/g in the parent is gone.
1525
1456
        b/h in the parent has a different id
1526
 
        b/i is new in the parent
 
1457
        b/i is new in the parent 
1527
1458
        c is renamed to b/j in the parent
1528
1459
 
1529
1460
        :return: The dirstate, still write-locked.
1619
1550
            list(state._iter_child_entries(1, '')))
1620
1551
 
1621
1552
 
1622
 
class TestDirstateSortOrder(tests.TestCaseWithTransport):
 
1553
class TestDirstateSortOrder(TestCaseWithTransport):
1623
1554
    """Test that DirState adds entries in the right order."""
1624
1555
 
1625
1556
    def test_add_sorting(self):
1684
1615
class InstrumentedDirState(dirstate.DirState):
1685
1616
    """An DirState with instrumented sha1 functionality."""
1686
1617
 
1687
 
    def __init__(self, path, sha1_provider):
1688
 
        super(InstrumentedDirState, self).__init__(path, sha1_provider)
 
1618
    def __init__(self, path):
 
1619
        super(InstrumentedDirState, self).__init__(path)
1689
1620
        self._time_offset = 0
1690
1621
        self._log = []
1691
1622
        # member is dynamically set in DirState.__init__ to turn on trace
1692
 
        self._sha1_provider = sha1_provider
1693
1623
        self._sha1_file = self._sha1_file_and_log
1694
1624
 
1695
1625
    def _sha_cutoff_time(self):
1698
1628
 
1699
1629
    def _sha1_file_and_log(self, abspath):
1700
1630
        self._log.append(('sha1', abspath))
1701
 
        return self._sha1_provider.sha1(abspath)
 
1631
        return osutils.sha_file_by_name(abspath)
1702
1632
 
1703
1633
    def _read_link(self, abspath, old_link):
1704
1634
        self._log.append(('read_link', abspath, old_link))
1735
1665
        self.st_ino = ino
1736
1666
        self.st_mode = mode
1737
1667
 
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):
 
1668
 
 
1669
class TestUpdateEntry(TestCaseWithDirState):
 
1670
    """Test the DirState.update_entry functions"""
 
1671
 
 
1672
    def get_state_with_a(self):
 
1673
        """Create a DirState tracking a single object named 'a'"""
 
1674
        state = InstrumentedDirState.initialize('dirstate')
 
1675
        self.addCleanup(state.unlock)
 
1676
        state.add('a', 'a-id', 'file', None, '')
 
1677
        entry = state._get_entry(0, path_utf8='a')
 
1678
        return state, entry
 
1679
 
 
1680
    def test_observed_sha1_cachable(self):
 
1681
        state, entry = self.get_state_with_a()
 
1682
        atime = time.time() - 10
 
1683
        self.build_tree(['a'])
 
1684
        statvalue = os.lstat('a')
 
1685
        statvalue = _FakeStat(statvalue.st_size, atime, atime,
 
1686
            statvalue.st_dev, statvalue.st_ino, statvalue.st_mode)
 
1687
        state._observed_sha1(entry, "foo", statvalue)
 
1688
        self.assertEqual('foo', entry[1][0][1])
 
1689
        packed_stat = dirstate.pack_stat(statvalue)
 
1690
        self.assertEqual(packed_stat, entry[1][0][4])
 
1691
 
 
1692
    def test_observed_sha1_not_cachable(self):
 
1693
        state, entry = self.get_state_with_a()
 
1694
        oldval = entry[1][0][1]
 
1695
        oldstat = entry[1][0][4]
 
1696
        self.build_tree(['a'])
 
1697
        statvalue = os.lstat('a')
 
1698
        state._observed_sha1(entry, "foo", statvalue)
 
1699
        self.assertEqual(oldval, entry[1][0][1])
 
1700
        self.assertEqual(oldstat, entry[1][0][4])
 
1701
 
 
1702
    def test_update_entry(self):
 
1703
        state, entry = self.get_state_with_a()
 
1704
        self.build_tree(['a'])
 
1705
        # Add one where we don't provide the stat or sha already
 
1706
        self.assertEqual(('', 'a', 'a-id'), entry[0])
 
1707
        self.assertEqual([('f', '', 0, False, dirstate.DirState.NULLSTAT)],
 
1708
                         entry[1])
 
1709
        # Flush the buffers to disk
 
1710
        state.save()
 
1711
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1712
                         state._dirblock_state)
 
1713
 
 
1714
        stat_value = os.lstat('a')
 
1715
        packed_stat = dirstate.pack_stat(stat_value)
 
1716
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1717
                                          stat_value=stat_value)
 
1718
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1719
                         link_or_sha1)
 
1720
 
 
1721
        # The dirblock entry should not cache the file's sha1
 
1722
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1723
                         entry[1])
 
1724
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1725
                         state._dirblock_state)
 
1726
        mode = stat_value.st_mode
 
1727
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False)], state._log)
 
1728
 
 
1729
        state.save()
 
1730
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1731
                         state._dirblock_state)
 
1732
 
 
1733
        # If we do it again right away, we don't know if the file has changed
 
1734
        # so we will re-read the file. Roll the clock back so the file is
 
1735
        # guaranteed to look too new.
 
1736
        state.adjust_time(-10)
 
1737
 
 
1738
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1739
                                          stat_value=stat_value)
 
1740
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1741
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1742
                         ], state._log)
 
1743
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1744
                         link_or_sha1)
 
1745
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1746
                         state._dirblock_state)
 
1747
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1748
                         entry[1])
 
1749
        state.save()
 
1750
 
 
1751
        # However, if we move the clock forward so the file is considered
 
1752
        # "stable", it should just cache the value.
 
1753
        state.adjust_time(+20)
 
1754
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1755
                                          stat_value=stat_value)
 
1756
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1757
                         link_or_sha1)
 
1758
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1759
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1760
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1761
                         ], state._log)
 
1762
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1763
                         entry[1])
 
1764
 
 
1765
        # Subsequent calls will just return the cached value
 
1766
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1767
                                          stat_value=stat_value)
 
1768
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1769
                         link_or_sha1)
 
1770
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1771
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1772
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1773
                         ], state._log)
 
1774
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1775
                         entry[1])
 
1776
 
 
1777
    def test_update_entry_symlink(self):
 
1778
        """Update entry should read symlinks."""
 
1779
        self.requireFeature(SymlinkFeature)
 
1780
        state, entry = self.get_state_with_a()
 
1781
        state.save()
 
1782
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1783
                         state._dirblock_state)
 
1784
        os.symlink('target', 'a')
 
1785
 
 
1786
        state.adjust_time(-10) # Make the symlink look new
 
1787
        stat_value = os.lstat('a')
 
1788
        packed_stat = dirstate.pack_stat(stat_value)
 
1789
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1790
                                          stat_value=stat_value)
 
1791
        self.assertEqual('target', link_or_sha1)
 
1792
        self.assertEqual([('read_link', 'a', '')], state._log)
 
1793
        # Dirblock is not updated (the link is too new)
 
1794
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1795
                         entry[1])
 
1796
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1797
                         state._dirblock_state)
 
1798
 
 
1799
        # Because the stat_value looks new, we should re-read the target
 
1800
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1801
                                          stat_value=stat_value)
 
1802
        self.assertEqual('target', link_or_sha1)
 
1803
        self.assertEqual([('read_link', 'a', ''),
 
1804
                          ('read_link', 'a', ''),
 
1805
                         ], state._log)
 
1806
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1807
                         entry[1])
 
1808
        state.adjust_time(+20) # Skip into the future, all files look old
 
1809
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1810
                                          stat_value=stat_value)
 
1811
        self.assertEqual('target', link_or_sha1)
 
1812
        # We need to re-read the link because only now can we cache it
 
1813
        self.assertEqual([('read_link', 'a', ''),
 
1814
                          ('read_link', 'a', ''),
 
1815
                          ('read_link', 'a', ''),
 
1816
                         ], state._log)
 
1817
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1818
                         entry[1])
 
1819
 
 
1820
        # Another call won't re-read the link
 
1821
        self.assertEqual([('read_link', 'a', ''),
 
1822
                          ('read_link', 'a', ''),
 
1823
                          ('read_link', 'a', ''),
 
1824
                         ], state._log)
 
1825
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1826
                                          stat_value=stat_value)
 
1827
        self.assertEqual('target', link_or_sha1)
 
1828
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1829
                         entry[1])
 
1830
 
 
1831
    def do_update_entry(self, state, entry, abspath):
 
1832
        stat_value = os.lstat(abspath)
 
1833
        return state.update_entry(entry, abspath, stat_value)
 
1834
 
 
1835
    def test_update_entry_dir(self):
 
1836
        state, entry = self.get_state_with_a()
 
1837
        self.build_tree(['a/'])
 
1838
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1839
 
 
1840
    def test_update_entry_dir_unchanged(self):
 
1841
        state, entry = self.get_state_with_a()
 
1842
        self.build_tree(['a/'])
 
1843
        state.adjust_time(+20)
 
1844
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1845
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1846
                         state._dirblock_state)
 
1847
        state.save()
 
1848
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1849
                         state._dirblock_state)
 
1850
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1851
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1852
                         state._dirblock_state)
 
1853
 
 
1854
    def test_update_entry_file_unchanged(self):
 
1855
        state, entry = self.get_state_with_a()
 
1856
        self.build_tree(['a'])
 
1857
        sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1858
        state.adjust_time(+20)
 
1859
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1860
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1861
                         state._dirblock_state)
 
1862
        state.save()
 
1863
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1864
                         state._dirblock_state)
 
1865
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1866
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1867
                         state._dirblock_state)
 
1868
 
 
1869
    def create_and_test_file(self, state, entry):
 
1870
        """Create a file at 'a' and verify the state finds it.
 
1871
 
 
1872
        The state should already be versioning *something* at 'a'. This makes
 
1873
        sure that state.update_entry recognizes it as a file.
 
1874
        """
 
1875
        self.build_tree(['a'])
 
1876
        stat_value = os.lstat('a')
 
1877
        packed_stat = dirstate.pack_stat(stat_value)
 
1878
 
 
1879
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1880
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1881
                         link_or_sha1)
 
1882
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1883
                         entry[1])
 
1884
        return packed_stat
 
1885
 
 
1886
    def create_and_test_dir(self, state, entry):
 
1887
        """Create a directory at 'a' and verify the state finds it.
 
1888
 
 
1889
        The state should already be versioning *something* at 'a'. This makes
 
1890
        sure that state.update_entry recognizes it as a directory.
 
1891
        """
 
1892
        self.build_tree(['a/'])
 
1893
        stat_value = os.lstat('a')
 
1894
        packed_stat = dirstate.pack_stat(stat_value)
 
1895
 
 
1896
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1897
        self.assertIs(None, link_or_sha1)
 
1898
        self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
 
1899
 
 
1900
        return packed_stat
 
1901
 
 
1902
    def create_and_test_symlink(self, state, entry):
 
1903
        """Create a symlink at 'a' and verify the state finds it.
 
1904
 
 
1905
        The state should already be versioning *something* at 'a'. This makes
 
1906
        sure that state.update_entry recognizes it as a symlink.
 
1907
 
 
1908
        This should not be called if this platform does not have symlink
 
1909
        support.
 
1910
        """
 
1911
        # caller should care about skipping test on platforms without symlinks
 
1912
        os.symlink('path/to/foo', 'a')
 
1913
 
 
1914
        stat_value = os.lstat('a')
 
1915
        packed_stat = dirstate.pack_stat(stat_value)
 
1916
 
 
1917
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1918
        self.assertEqual('path/to/foo', link_or_sha1)
 
1919
        self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
 
1920
                         entry[1])
 
1921
        return packed_stat
 
1922
 
 
1923
    def test_update_file_to_dir(self):
 
1924
        """If a file changes to a directory we return None for the sha.
 
1925
        We also update the inventory record.
 
1926
        """
 
1927
        state, entry = self.get_state_with_a()
 
1928
        # The file sha1 won't be cached unless the file is old
 
1929
        state.adjust_time(+10)
 
1930
        self.create_and_test_file(state, entry)
 
1931
        os.remove('a')
 
1932
        self.create_and_test_dir(state, entry)
 
1933
 
 
1934
    def test_update_file_to_symlink(self):
 
1935
        """File becomes a symlink"""
 
1936
        self.requireFeature(SymlinkFeature)
 
1937
        state, entry = self.get_state_with_a()
 
1938
        # The file sha1 won't be cached unless the file is old
 
1939
        state.adjust_time(+10)
 
1940
        self.create_and_test_file(state, entry)
 
1941
        os.remove('a')
 
1942
        self.create_and_test_symlink(state, entry)
 
1943
 
 
1944
    def test_update_dir_to_file(self):
 
1945
        """Directory becoming a file updates the entry."""
 
1946
        state, entry = self.get_state_with_a()
 
1947
        # The file sha1 won't be cached unless the file is old
 
1948
        state.adjust_time(+10)
 
1949
        self.create_and_test_dir(state, entry)
 
1950
        os.rmdir('a')
 
1951
        self.create_and_test_file(state, entry)
 
1952
 
 
1953
    def test_update_dir_to_symlink(self):
 
1954
        """Directory becomes a symlink"""
 
1955
        self.requireFeature(SymlinkFeature)
 
1956
        state, entry = self.get_state_with_a()
 
1957
        # The symlink target won't be cached if it isn't old
 
1958
        state.adjust_time(+10)
 
1959
        self.create_and_test_dir(state, entry)
 
1960
        os.rmdir('a')
 
1961
        self.create_and_test_symlink(state, entry)
 
1962
 
 
1963
    def test_update_symlink_to_file(self):
 
1964
        """Symlink becomes a file"""
 
1965
        self.requireFeature(SymlinkFeature)
 
1966
        state, entry = self.get_state_with_a()
 
1967
        # The symlink and file info won't be cached unless old
 
1968
        state.adjust_time(+10)
 
1969
        self.create_and_test_symlink(state, entry)
 
1970
        os.remove('a')
 
1971
        self.create_and_test_file(state, entry)
 
1972
 
 
1973
    def test_update_symlink_to_dir(self):
 
1974
        """Symlink becomes a directory"""
 
1975
        self.requireFeature(SymlinkFeature)
 
1976
        state, entry = self.get_state_with_a()
 
1977
        # The symlink target won't be cached if it isn't old
 
1978
        state.adjust_time(+10)
 
1979
        self.create_and_test_symlink(state, entry)
 
1980
        os.remove('a')
 
1981
        self.create_and_test_dir(state, entry)
 
1982
 
 
1983
    def test__is_executable_win32(self):
 
1984
        state, entry = self.get_state_with_a()
 
1985
        self.build_tree(['a'])
 
1986
 
 
1987
        # Make sure we are using the win32 implementation of _is_executable
 
1988
        state._is_executable = state._is_executable_win32
 
1989
 
 
1990
        # The file on disk is not executable, but we are marking it as though
 
1991
        # it is. With _is_executable_win32 we ignore what is on disk.
 
1992
        entry[1][0] = ('f', '', 0, True, dirstate.DirState.NULLSTAT)
 
1993
 
 
1994
        stat_value = os.lstat('a')
 
1995
        packed_stat = dirstate.pack_stat(stat_value)
 
1996
 
 
1997
        state.adjust_time(-10) # Make sure everything is new
 
1998
        state.update_entry(entry, abspath='a', stat_value=stat_value)
 
1999
 
 
2000
        # The row is updated, but the executable bit stays set.
 
2001
        self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
 
2002
                         entry[1])
 
2003
 
 
2004
        # Make the disk object look old enough to cache
 
2005
        state.adjust_time(+20)
 
2006
        digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
2007
        state.update_entry(entry, abspath='a', stat_value=stat_value)
 
2008
        self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
 
2009
 
 
2010
 
 
2011
class TestPackStat(TestCaseWithTransport):
1745
2012
 
1746
2013
    def assertPackStat(self, expected, stat_value):
1747
2014
        """Check the packed and serialized form of a stat value."""
2274
2541
        self.assertEqual(exp_dirblocks, state._dirblocks)
2275
2542
 
2276
2543
 
2277
 
class Test_InvEntryToDetails(tests.TestCase):
 
2544
class Test_InvEntryToDetails(TestCaseWithDirState):
2278
2545
 
2279
2546
    def assertDetails(self, expected, inv_entry):
2280
2547
        details = dirstate.DirState._inv_entry_to_details(inv_entry)
2287
2554
        self.assertIsInstance(tree_data, str)
2288
2555
 
2289
2556
    def test_unicode_symlink(self):
2290
 
        inv_entry = inventory.InventoryLink('link-file-id',
2291
 
                                            u'nam\N{Euro Sign}e',
 
2557
        # In general, the code base doesn't support a target that contains
 
2558
        # non-ascii characters. So we just assert tha 
 
2559
        inv_entry = inventory.InventoryLink('link-file-id', 'name',
2292
2560
                                            'link-parent-id')
2293
2561
        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)
 
2562
        inv_entry.symlink_target = u'link-target'
 
2563
        details = self.assertDetails(('l', 'link-target', 0, False,
 
2564
                                      'link-revision-id'), inv_entry)