← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test__dirstate_helpers.py

(gz) Fix test failure on alpha by correcting format string for
 gc_chk_sha1_record (Martin [gz])

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test__dirstate_helpers.py
34
34
    load_tests_apply_scenarios,
35
35
    multiply_scenarios,
36
36
    )
37
 
from bzrlib.tests import (
38
 
    features,
39
 
    )
40
37
 
41
38
 
42
39
load_tests = load_tests_apply_scenarios
43
40
 
44
41
 
45
 
compiled_dirstate_helpers_feature = features.ModuleAvailableFeature(
 
42
compiled_dirstate_helpers_feature = tests.ModuleAvailableFeature(
46
43
    'bzrlib._dirstate_helpers_pyx')
47
44
 
48
45
 
825
822
 
826
823
    def test_observed_sha1_cachable(self):
827
824
        state, entry = self.get_state_with_a()
828
 
        state.save()
829
825
        atime = time.time() - 10
830
826
        self.build_tree(['a'])
831
 
        statvalue = test_dirstate._FakeStat.from_stat(os.lstat('a'))
832
 
        statvalue.st_mtime = statvalue.st_ctime = atime
833
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
834
 
                         state._dirblock_state)
 
827
        statvalue = os.lstat('a')
 
828
        statvalue = test_dirstate._FakeStat(statvalue.st_size, atime, atime,
 
829
            statvalue.st_dev, statvalue.st_ino, statvalue.st_mode)
835
830
        state._observed_sha1(entry, "foo", statvalue)
836
831
        self.assertEqual('foo', entry[1][0][1])
837
832
        packed_stat = dirstate.pack_stat(statvalue)
838
833
        self.assertEqual(packed_stat, entry[1][0][4])
839
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
840
 
                         state._dirblock_state)
841
834
 
842
835
    def test_observed_sha1_not_cachable(self):
843
836
        state, entry = self.get_state_with_a()
844
 
        state.save()
845
837
        oldval = entry[1][0][1]
846
838
        oldstat = entry[1][0][4]
847
839
        self.build_tree(['a'])
848
840
        statvalue = os.lstat('a')
849
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
850
 
                         state._dirblock_state)
851
841
        state._observed_sha1(entry, "foo", statvalue)
852
842
        self.assertEqual(oldval, entry[1][0][1])
853
843
        self.assertEqual(oldstat, entry[1][0][4])
854
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
855
 
                         state._dirblock_state)
856
844
 
857
845
    def test_update_entry(self):
858
846
        state, _ = self.get_state_with_a()
883
871
                                          stat_value=stat_value)
884
872
        self.assertEqual(None, link_or_sha1)
885
873
 
886
 
        # The dirblock entry should not have computed or cached the file's
887
 
        # sha1, but it did update the files' st_size. However, this is not
888
 
        # worth writing a dirstate file for, so we leave the state UNMODIFIED
 
874
        # The dirblock entry should not have cached the file's sha1 (too new)
889
875
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
890
876
                         entry[1][0])
891
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
877
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
892
878
                         state._dirblock_state)
893
879
        mode = stat_value.st_mode
894
880
        self.assertEqual([('is_exec', mode, False)], state._log)
897
883
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
898
884
                         state._dirblock_state)
899
885
 
900
 
        # Roll the clock back so the file is guaranteed to look too new. We
901
 
        # should still not compute the sha1.
 
886
        # If we do it again right away, we don't know if the file has changed
 
887
        # so we will re-read the file. Roll the clock back so the file is
 
888
        # guaranteed to look too new.
902
889
        state.adjust_time(-10)
903
890
        del state._log[:]
904
891
 
906
893
                                          stat_value=stat_value)
907
894
        self.assertEqual([('is_exec', mode, False)], state._log)
908
895
        self.assertEqual(None, link_or_sha1)
909
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
896
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
910
897
                         state._dirblock_state)
911
898
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
912
899
                         entry[1][0])
922
909
        self.assertEqual([('is_exec', mode, False)], state._log)
923
910
        self.assertEqual(('f', '', 14, False, dirstate.DirState.NULLSTAT),
924
911
                         entry[1][0])
925
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
926
 
                         state._dirblock_state)
927
912
 
928
913
        # If the file is no longer new, and the clock has been moved forward
929
914
        # sufficiently, it will cache the sha.
954
939
 
955
940
    def test_update_entry_symlink(self):
956
941
        """Update entry should read symlinks."""
957
 
        self.requireFeature(features.SymlinkFeature)
 
942
        self.requireFeature(tests.SymlinkFeature)
958
943
        state, entry = self.get_state_with_a()
959
944
        state.save()
960
945
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
971
956
        # Dirblock is not updated (the link is too new)
972
957
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
973
958
                         entry[1])
974
 
        # The file entry turned into a symlink, that is considered
975
 
        # HASH modified worthy.
976
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
 
959
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
977
960
                         state._dirblock_state)
978
961
 
979
962
        # Because the stat_value looks new, we should re-read the target
980
 
        del state._log[:]
981
963
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
982
964
                                          stat_value=stat_value)
983
965
        self.assertEqual('target', link_or_sha1)
984
 
        self.assertEqual([('read_link', 'a', '')], state._log)
 
966
        self.assertEqual([('read_link', 'a', ''),
 
967
                          ('read_link', 'a', ''),
 
968
                         ], state._log)
985
969
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
986
970
                         entry[1])
987
 
        state.save()
988
971
        state.adjust_time(+20) # Skip into the future, all files look old
989
 
        del state._log[:]
990
972
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
991
973
                                          stat_value=stat_value)
992
 
        # The symlink stayed a symlink. So while it is new enough to cache, we
993
 
        # don't bother setting the flag, because it is not really worth saving
994
 
        # (when we stat the symlink, we'll have paged in the target.)
995
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
996
 
                         state._dirblock_state)
997
974
        self.assertEqual('target', link_or_sha1)
998
975
        # We need to re-read the link because only now can we cache it
999
 
        self.assertEqual([('read_link', 'a', '')], state._log)
 
976
        self.assertEqual([('read_link', 'a', ''),
 
977
                          ('read_link', 'a', ''),
 
978
                          ('read_link', 'a', ''),
 
979
                         ], state._log)
1000
980
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
1001
981
                         entry[1])
1002
982
 
1003
 
        del state._log[:]
1004
983
        # Another call won't re-read the link
1005
 
        self.assertEqual([], state._log)
 
984
        self.assertEqual([('read_link', 'a', ''),
 
985
                          ('read_link', 'a', ''),
 
986
                          ('read_link', 'a', ''),
 
987
                         ], state._log)
1006
988
        link_or_sha1 = self.update_entry(state, entry, abspath='a',
1007
989
                                          stat_value=stat_value)
1008
990
        self.assertEqual('target', link_or_sha1)
1023
1005
        self.build_tree(['a/'])
1024
1006
        state.adjust_time(+20)
1025
1007
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1026
 
        # a/ used to be a file, but is now a directory, worth saving
1027
1008
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
1028
1009
                         state._dirblock_state)
1029
1010
        state.save()
1030
1011
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1031
1012
                         state._dirblock_state)
1032
 
        # No changes to a/ means not worth saving.
1033
 
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1034
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1035
 
                         state._dirblock_state)
1036
 
        # Change the last-modified time for the directory
1037
 
        t = time.time() - 100.0
1038
 
        try:
1039
 
            os.utime('a', (t, t))
1040
 
        except OSError:
1041
 
            # It looks like Win32 + FAT doesn't allow to change times on a dir.
1042
 
            raise tests.TestSkipped("can't update mtime of a dir on FAT")
1043
 
        saved_packed_stat = entry[1][0][-1]
1044
 
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1045
 
        # We *do* go ahead and update the information in the dirblocks, but we
1046
 
        # don't bother setting IN_MEMORY_MODIFIED because it is trivial to
1047
 
        # recompute.
1048
 
        self.assertNotEqual(saved_packed_stat, entry[1][0][-1])
 
1013
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
1049
1014
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1050
1015
                         state._dirblock_state)
1051
1016
 
1151
1116
 
1152
1117
    def test_update_file_to_symlink(self):
1153
1118
        """File becomes a symlink"""
1154
 
        self.requireFeature(features.SymlinkFeature)
 
1119
        self.requireFeature(tests.SymlinkFeature)
1155
1120
        state, entry = self.get_state_with_a()
1156
1121
        # The file sha1 won't be cached unless the file is old
1157
1122
        state.adjust_time(+10)
1170
1135
 
1171
1136
    def test_update_dir_to_symlink(self):
1172
1137
        """Directory becomes a symlink"""
1173
 
        self.requireFeature(features.SymlinkFeature)
 
1138
        self.requireFeature(tests.SymlinkFeature)
1174
1139
        state, entry = self.get_state_with_a()
1175
1140
        # The symlink target won't be cached if it isn't old
1176
1141
        state.adjust_time(+10)
1180
1145
 
1181
1146
    def test_update_symlink_to_file(self):
1182
1147
        """Symlink becomes a file"""
1183
 
        self.requireFeature(features.SymlinkFeature)
 
1148
        self.requireFeature(tests.SymlinkFeature)
1184
1149
        state, entry = self.get_state_with_a()
1185
1150
        # The symlink and file info won't be cached unless old
1186
1151
        state.adjust_time(+10)
1190
1155
 
1191
1156
    def test_update_symlink_to_dir(self):
1192
1157
        """Symlink becomes a directory"""
1193
 
        self.requireFeature(features.SymlinkFeature)
 
1158
        self.requireFeature(tests.SymlinkFeature)
1194
1159
        state, entry = self.get_state_with_a()
1195
1160
        # The symlink target won't be cached if it isn't old
1196
1161
        state.adjust_time(+10)