← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_dirstate.py

  • Committer: John Arbash Meinel
  • Date: 2008-08-20 16:14:09 UTC
  • mfrom: (3606.5.8 1.6)
  • mto: This revision was merged to the branch mainline in revision 3642.
  • Revision ID: john@arbash-meinel.com-20080820161409-pl5tzssd7wlxi7ma
Merge in 1.6rc5 and revert disabling default stack on policy

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_dirstate.py
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
 
    revision as _mod_revision,
29
 
    tests,
30
28
    )
31
 
from bzrlib.tests import test_osutils
 
29
from bzrlib.memorytree import MemoryTree
 
30
from bzrlib.tests import (
 
31
        SymlinkFeature,
 
32
        TestCase,
 
33
        TestCaseWithTransport,
 
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
 
        # Save platform specific info and reset it
68
 
        cur_dir_reader = osutils._selected_dir_reader
69
 
 
70
 
        def restore():
71
 
            osutils._selected_dir_reader = cur_dir_reader
72
 
        self.addCleanup(restore)
73
 
 
74
 
        osutils._selected_dir_reader = self._dir_reader_class()
75
 
 
76
53
    def create_empty_dirstate(self):
77
54
        """Return a locked but empty dirstate"""
78
55
        state = dirstate.DirState.initialize('dirstate')
586
563
        state.lock_read()
587
564
        try:
588
565
            entry = state._get_entry(0, path_utf8='a-file')
589
 
            # The current size should be 0 (default)
590
 
            self.assertEqual(0, entry[1][0][2])
 
566
            # The current sha1 sum should be empty
 
567
            self.assertEqual('', entry[1][0][1])
591
568
            # We should have a real entry.
592
569
            self.assertNotEqual((None, None), entry)
593
570
            # Make sure everything is old enough
594
571
            state._sha_cutoff_time()
595
572
            state._cutoff_time += 10
596
 
            # Change the file length
597
 
            self.build_tree_contents([('a-file', 'shorter')])
598
 
            sha1sum = dirstate.update_entry(state, entry, 'a-file',
599
 
                os.lstat('a-file'))
600
 
            # new file, no cached sha:
601
 
            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)
602
577
 
603
578
            # The dirblock has been updated
604
 
            self.assertEqual(7, entry[1][0][2])
 
579
            self.assertEqual(sha1sum, entry[1][0][1])
605
580
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
606
581
                             state._dirblock_state)
607
582
 
617
592
        state.lock_read()
618
593
        try:
619
594
            entry = state._get_entry(0, path_utf8='a-file')
620
 
            self.assertEqual(7, entry[1][0][2])
 
595
            self.assertEqual(sha1sum, entry[1][0][1])
621
596
        finally:
622
597
            state.unlock()
623
598
 
636
611
        state.lock_read()
637
612
        try:
638
613
            entry = state._get_entry(0, path_utf8='a-file')
639
 
            sha1sum = dirstate.update_entry(state, entry, 'a-file',
640
 
                os.lstat('a-file'))
641
 
            # No sha - too new
642
 
            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)
643
618
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
644
619
                             state._dirblock_state)
645
620
 
662
637
                state2.unlock()
663
638
        finally:
664
639
            state.unlock()
665
 
 
 
640
        
666
641
        # The file on disk should not be modified.
667
642
        state = dirstate.DirState.on_file('dirstate')
668
643
        state.lock_read()
768
743
        # https://bugs.launchpad.net/bzr/+bug/146176
769
744
        # set_state_from_inventory should preserve the stat and hash value for
770
745
        # workingtree files that are not changed by the inventory.
771
 
 
 
746
       
772
747
        tree = self.make_branch_and_tree('.')
773
748
        # depends on the default format using dirstate...
774
749
        tree.lock_write()
775
750
        try:
776
 
            # make a dirstate with some valid hashcache data
 
751
            # make a dirstate with some valid hashcache data 
777
752
            # file on disk, but that's not needed for this test
778
753
            foo_contents = 'contents of foo'
779
754
            self.build_tree_contents([('foo', foo_contents)])
799
774
                (('', 'foo', 'foo-id',),
800
775
                 [('f', foo_sha, foo_size, False, foo_packed)]),
801
776
                tree._dirstate._get_entry(0, 'foo-id'))
802
 
 
 
777
           
803
778
            # extract the inventory, and add something to it
804
779
            inv = tree._get_inventory()
805
780
            # should see the file we poked in...
953
928
        finally:
954
929
            tree1.unlock()
955
930
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
956
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
931
        tree2 = MemoryTree.create_on_branch(branch2)
957
932
        tree2.lock_write()
958
933
        try:
959
934
            revid2 = tree2.commit('foo')
991
966
            state.set_parent_trees(
992
967
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
993
968
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
994
 
                 ('ghost-rev', tree2.branch.repository.revision_tree(
995
 
                                   _mod_revision.NULL_REVISION))),
 
969
                 ('ghost-rev', tree2.branch.repository.revision_tree(None))),
996
970
                ['ghost-rev'])
997
971
            self.assertEqual([revid1, revid2, 'ghost-rev'],
998
972
                             state.get_parent_ids())
1023
997
        finally:
1024
998
            tree1.unlock()
1025
999
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1026
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
1000
        tree2 = MemoryTree.create_on_branch(branch2)
1027
1001
        tree2.lock_write()
1028
1002
        try:
1029
1003
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1088
1062
            state.unlock()
1089
1063
        state = dirstate.DirState.on_file('dirstate')
1090
1064
        state.lock_read()
1091
 
        self.addCleanup(state.unlock)
1092
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1065
        try:
 
1066
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1067
        finally:
 
1068
            state.unlock()
1093
1069
 
1094
1070
    def test_add_path_to_unversioned_directory(self):
1095
1071
        """Adding a path to an unversioned directory should error.
1100
1076
        """
1101
1077
        self.build_tree(['unversioned/', 'unversioned/a file'])
1102
1078
        state = dirstate.DirState.initialize('dirstate')
1103
 
        self.addCleanup(state.unlock)
1104
 
        self.assertRaises(errors.NotVersionedError, state.add,
1105
 
                          'unversioned/a file', 'a-file-id', 'file', None, None)
 
1079
        try:
 
1080
            self.assertRaises(errors.NotVersionedError, state.add,
 
1081
                'unversioned/a file', 'a-file-id', 'file', None, None)
 
1082
        finally:
 
1083
            state.unlock()
1106
1084
 
1107
1085
    def test_add_directory_to_root_no_parents_all_data(self):
1108
1086
        # The most trivial addition of a dir is when there are no parents and
1128
1106
            state.unlock()
1129
1107
        state = dirstate.DirState.on_file('dirstate')
1130
1108
        state.lock_read()
1131
 
        self.addCleanup(state.unlock)
1132
1109
        state._validate()
1133
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1110
        try:
 
1111
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1112
        finally:
 
1113
            state.unlock()
1134
1114
 
1135
 
    def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
 
1115
    def test_add_symlink_to_root_no_parents_all_data(self):
1136
1116
        # The most trivial addition of a symlink when there are no parents and
1137
1117
        # its in the root and all data about the file is supplied
1138
1118
        # bzr doesn't support fake symlinks on windows, yet.
1139
 
        self.requireFeature(tests.SymlinkFeature)
1140
 
        os.symlink(target, link_name)
1141
 
        stat = os.lstat(link_name)
 
1119
        self.requireFeature(SymlinkFeature)
 
1120
        os.symlink('target', 'a link')
 
1121
        stat = os.lstat('a link')
1142
1122
        expected_entries = [
1143
1123
            (('', '', 'TREE_ROOT'), [
1144
1124
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1145
1125
             ]),
1146
 
            (('', link_name.encode('UTF-8'), 'a link id'), [
1147
 
             ('l', target.encode('UTF-8'), stat[6],
1148
 
              False, dirstate.pack_stat(stat)), # current tree
 
1126
            (('', 'a link', 'a link id'), [
 
1127
             ('l', 'target', 6, False, dirstate.pack_stat(stat)), # current tree
1149
1128
             ]),
1150
1129
            ]
1151
1130
        state = dirstate.DirState.initialize('dirstate')
1152
1131
        try:
1153
 
            state.add(link_name, 'a link id', 'symlink', stat,
1154
 
                      target.encode('UTF-8'))
 
1132
            state.add('a link', 'a link id', 'symlink', stat, 'target')
1155
1133
            # having added it, it should be in the output of iter_entries.
1156
1134
            self.assertEqual(expected_entries, list(state._iter_entries()))
1157
1135
            # saving and reloading should not affect this.
1160
1138
            state.unlock()
1161
1139
        state = dirstate.DirState.on_file('dirstate')
1162
1140
        state.lock_read()
1163
 
        self.addCleanup(state.unlock)
1164
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
1165
 
 
1166
 
    def test_add_symlink_to_root_no_parents_all_data(self):
1167
 
        self._test_add_symlink_to_root_no_parents_all_data('a link', 'target')
1168
 
 
1169
 
    def test_add_symlink_unicode_to_root_no_parents_all_data(self):
1170
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1171
 
        self._test_add_symlink_to_root_no_parents_all_data(
1172
 
            u'\N{Euro Sign}link', u'targ\N{Euro Sign}et')
 
1141
        try:
 
1142
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1143
        finally:
 
1144
            state.unlock()
1173
1145
 
1174
1146
    def test_add_directory_and_child_no_parents_all_data(self):
1175
1147
        # after adding a directory, we should be able to add children to it.
1200
1172
            state.unlock()
1201
1173
        state = dirstate.DirState.on_file('dirstate')
1202
1174
        state.lock_read()
1203
 
        self.addCleanup(state.unlock)
1204
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1175
        try:
 
1176
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1177
        finally:
 
1178
            state.unlock()
1205
1179
 
1206
1180
    def test_add_tree_reference(self):
1207
1181
        # make a dirstate and add a tree reference
1221
1195
            state.unlock()
1222
1196
        # now check we can read it back
1223
1197
        state.lock_read()
1224
 
        self.addCleanup(state.unlock)
1225
1198
        state._validate()
1226
 
        entry2 = state._get_entry(0, 'subdir-id', 'subdir')
1227
 
        self.assertEqual(entry, entry2)
1228
 
        self.assertEqual(entry, expected_entry)
1229
 
        # and lookup by id should work too
1230
 
        entry2 = state._get_entry(0, fileid_utf8='subdir-id')
1231
 
        self.assertEqual(entry, expected_entry)
 
1199
        try:
 
1200
            entry2 = state._get_entry(0, 'subdir-id', 'subdir')
 
1201
            self.assertEqual(entry, entry2)
 
1202
            self.assertEqual(entry, expected_entry)
 
1203
            # and lookup by id should work too
 
1204
            entry2 = state._get_entry(0, fileid_utf8='subdir-id')
 
1205
            self.assertEqual(entry, expected_entry)
 
1206
        finally:
 
1207
            state.unlock()
1232
1208
 
1233
1209
    def test_add_forbidden_names(self):
1234
1210
        state = dirstate.DirState.initialize('dirstate')
1476
1452
        There is one parent tree, which has the same shape with the following variations:
1477
1453
        b/g in the parent is gone.
1478
1454
        b/h in the parent has a different id
1479
 
        b/i is new in the parent
 
1455
        b/i is new in the parent 
1480
1456
        c is renamed to b/j in the parent
1481
1457
 
1482
1458
        :return: The dirstate, still write-locked.
1572
1548
            list(state._iter_child_entries(1, '')))
1573
1549
 
1574
1550
 
1575
 
class TestDirstateSortOrder(tests.TestCaseWithTransport):
 
1551
class TestDirstateSortOrder(TestCaseWithTransport):
1576
1552
    """Test that DirState adds entries in the right order."""
1577
1553
 
1578
1554
    def test_add_sorting(self):
1627
1603
 
1628
1604
        # *really* cheesy way to just get an empty tree
1629
1605
        repo = self.make_repository('repo')
1630
 
        empty_tree = repo.revision_tree(_mod_revision.NULL_REVISION)
 
1606
        empty_tree = repo.revision_tree(None)
1631
1607
        state.set_parent_trees([('null:', empty_tree)], [])
1632
1608
 
1633
1609
        dirblock_names = [d[0] for d in state._dirblocks]
1637
1613
class InstrumentedDirState(dirstate.DirState):
1638
1614
    """An DirState with instrumented sha1 functionality."""
1639
1615
 
1640
 
    def __init__(self, path, sha1_provider):
1641
 
        super(InstrumentedDirState, self).__init__(path, sha1_provider)
 
1616
    def __init__(self, path):
 
1617
        super(InstrumentedDirState, self).__init__(path)
1642
1618
        self._time_offset = 0
1643
1619
        self._log = []
1644
1620
        # member is dynamically set in DirState.__init__ to turn on trace
1645
 
        self._sha1_provider = sha1_provider
1646
1621
        self._sha1_file = self._sha1_file_and_log
1647
1622
 
1648
1623
    def _sha_cutoff_time(self):
1651
1626
 
1652
1627
    def _sha1_file_and_log(self, abspath):
1653
1628
        self._log.append(('sha1', abspath))
1654
 
        return self._sha1_provider.sha1(abspath)
 
1629
        return osutils.sha_file_by_name(abspath)
1655
1630
 
1656
1631
    def _read_link(self, abspath, old_link):
1657
1632
        self._log.append(('read_link', abspath, old_link))
1688
1663
        self.st_ino = ino
1689
1664
        self.st_mode = mode
1690
1665
 
1691
 
    @staticmethod
1692
 
    def from_stat(st):
1693
 
        return _FakeStat(st.st_size, st.st_mtime, st.st_ctime, st.st_dev,
1694
 
            st.st_ino, st.st_mode)
1695
 
 
1696
 
 
1697
 
class TestPackStat(tests.TestCaseWithTransport):
 
1666
 
 
1667
class TestUpdateEntry(TestCaseWithDirState):
 
1668
    """Test the DirState.update_entry functions"""
 
1669
 
 
1670
    def get_state_with_a(self):
 
1671
        """Create a DirState tracking a single object named 'a'"""
 
1672
        state = InstrumentedDirState.initialize('dirstate')
 
1673
        self.addCleanup(state.unlock)
 
1674
        state.add('a', 'a-id', 'file', None, '')
 
1675
        entry = state._get_entry(0, path_utf8='a')
 
1676
        return state, entry
 
1677
 
 
1678
    def test_update_entry(self):
 
1679
        state, entry = self.get_state_with_a()
 
1680
        self.build_tree(['a'])
 
1681
        # Add one where we don't provide the stat or sha already
 
1682
        self.assertEqual(('', 'a', 'a-id'), entry[0])
 
1683
        self.assertEqual([('f', '', 0, False, dirstate.DirState.NULLSTAT)],
 
1684
                         entry[1])
 
1685
        # Flush the buffers to disk
 
1686
        state.save()
 
1687
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1688
                         state._dirblock_state)
 
1689
 
 
1690
        stat_value = os.lstat('a')
 
1691
        packed_stat = dirstate.pack_stat(stat_value)
 
1692
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1693
                                          stat_value=stat_value)
 
1694
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1695
                         link_or_sha1)
 
1696
 
 
1697
        # The dirblock entry should not cache the file's sha1
 
1698
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1699
                         entry[1])
 
1700
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1701
                         state._dirblock_state)
 
1702
        mode = stat_value.st_mode
 
1703
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False)], state._log)
 
1704
 
 
1705
        state.save()
 
1706
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1707
                         state._dirblock_state)
 
1708
 
 
1709
        # If we do it again right away, we don't know if the file has changed
 
1710
        # so we will re-read the file. Roll the clock back so the file is
 
1711
        # guaranteed to look too new.
 
1712
        state.adjust_time(-10)
 
1713
 
 
1714
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1715
                                          stat_value=stat_value)
 
1716
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1717
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1718
                         ], state._log)
 
1719
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1720
                         link_or_sha1)
 
1721
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1722
                         state._dirblock_state)
 
1723
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1724
                         entry[1])
 
1725
        state.save()
 
1726
 
 
1727
        # However, if we move the clock forward so the file is considered
 
1728
        # "stable", it should just cache the value.
 
1729
        state.adjust_time(+20)
 
1730
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1731
                                          stat_value=stat_value)
 
1732
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1733
                         link_or_sha1)
 
1734
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1735
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1736
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1737
                         ], state._log)
 
1738
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1739
                         entry[1])
 
1740
 
 
1741
        # Subsequent calls will just return the cached value
 
1742
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1743
                                          stat_value=stat_value)
 
1744
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1745
                         link_or_sha1)
 
1746
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1747
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1748
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1749
                         ], state._log)
 
1750
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1751
                         entry[1])
 
1752
 
 
1753
    def test_update_entry_symlink(self):
 
1754
        """Update entry should read symlinks."""
 
1755
        self.requireFeature(SymlinkFeature)
 
1756
        state, entry = self.get_state_with_a()
 
1757
        state.save()
 
1758
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1759
                         state._dirblock_state)
 
1760
        os.symlink('target', 'a')
 
1761
 
 
1762
        state.adjust_time(-10) # Make the symlink look new
 
1763
        stat_value = os.lstat('a')
 
1764
        packed_stat = dirstate.pack_stat(stat_value)
 
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([('read_link', 'a', '')], state._log)
 
1769
        # Dirblock is not updated (the link is too new)
 
1770
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1771
                         entry[1])
 
1772
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1773
                         state._dirblock_state)
 
1774
 
 
1775
        # Because the stat_value looks new, we should re-read the target
 
1776
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1777
                                          stat_value=stat_value)
 
1778
        self.assertEqual('target', link_or_sha1)
 
1779
        self.assertEqual([('read_link', 'a', ''),
 
1780
                          ('read_link', 'a', ''),
 
1781
                         ], state._log)
 
1782
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1783
                         entry[1])
 
1784
        state.adjust_time(+20) # Skip into the future, all files look old
 
1785
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1786
                                          stat_value=stat_value)
 
1787
        self.assertEqual('target', link_or_sha1)
 
1788
        # We need to re-read the link because only now can we cache it
 
1789
        self.assertEqual([('read_link', 'a', ''),
 
1790
                          ('read_link', 'a', ''),
 
1791
                          ('read_link', 'a', ''),
 
1792
                         ], state._log)
 
1793
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1794
                         entry[1])
 
1795
 
 
1796
        # Another call won't re-read the link
 
1797
        self.assertEqual([('read_link', 'a', ''),
 
1798
                          ('read_link', 'a', ''),
 
1799
                          ('read_link', 'a', ''),
 
1800
                         ], state._log)
 
1801
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1802
                                          stat_value=stat_value)
 
1803
        self.assertEqual('target', link_or_sha1)
 
1804
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1805
                         entry[1])
 
1806
 
 
1807
    def do_update_entry(self, state, entry, abspath):
 
1808
        stat_value = os.lstat(abspath)
 
1809
        return state.update_entry(entry, abspath, stat_value)
 
1810
 
 
1811
    def test_update_entry_dir(self):
 
1812
        state, entry = self.get_state_with_a()
 
1813
        self.build_tree(['a/'])
 
1814
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1815
 
 
1816
    def test_update_entry_dir_unchanged(self):
 
1817
        state, entry = self.get_state_with_a()
 
1818
        self.build_tree(['a/'])
 
1819
        state.adjust_time(+20)
 
1820
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1821
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1822
                         state._dirblock_state)
 
1823
        state.save()
 
1824
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1825
                         state._dirblock_state)
 
1826
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1827
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1828
                         state._dirblock_state)
 
1829
 
 
1830
    def test_update_entry_file_unchanged(self):
 
1831
        state, entry = self.get_state_with_a()
 
1832
        self.build_tree(['a'])
 
1833
        sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1834
        state.adjust_time(+20)
 
1835
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1836
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1837
                         state._dirblock_state)
 
1838
        state.save()
 
1839
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1840
                         state._dirblock_state)
 
1841
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1842
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1843
                         state._dirblock_state)
 
1844
 
 
1845
    def create_and_test_file(self, state, entry):
 
1846
        """Create a file at 'a' and verify the state finds it.
 
1847
 
 
1848
        The state should already be versioning *something* at 'a'. This makes
 
1849
        sure that state.update_entry recognizes it as a file.
 
1850
        """
 
1851
        self.build_tree(['a'])
 
1852
        stat_value = os.lstat('a')
 
1853
        packed_stat = dirstate.pack_stat(stat_value)
 
1854
 
 
1855
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1856
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1857
                         link_or_sha1)
 
1858
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1859
                         entry[1])
 
1860
        return packed_stat
 
1861
 
 
1862
    def create_and_test_dir(self, state, entry):
 
1863
        """Create a directory at 'a' and verify the state finds it.
 
1864
 
 
1865
        The state should already be versioning *something* at 'a'. This makes
 
1866
        sure that state.update_entry recognizes it as a directory.
 
1867
        """
 
1868
        self.build_tree(['a/'])
 
1869
        stat_value = os.lstat('a')
 
1870
        packed_stat = dirstate.pack_stat(stat_value)
 
1871
 
 
1872
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1873
        self.assertIs(None, link_or_sha1)
 
1874
        self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
 
1875
 
 
1876
        return packed_stat
 
1877
 
 
1878
    def create_and_test_symlink(self, state, entry):
 
1879
        """Create a symlink at 'a' and verify the state finds it.
 
1880
 
 
1881
        The state should already be versioning *something* at 'a'. This makes
 
1882
        sure that state.update_entry recognizes it as a symlink.
 
1883
 
 
1884
        This should not be called if this platform does not have symlink
 
1885
        support.
 
1886
        """
 
1887
        # caller should care about skipping test on platforms without symlinks
 
1888
        os.symlink('path/to/foo', 'a')
 
1889
 
 
1890
        stat_value = os.lstat('a')
 
1891
        packed_stat = dirstate.pack_stat(stat_value)
 
1892
 
 
1893
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1894
        self.assertEqual('path/to/foo', link_or_sha1)
 
1895
        self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
 
1896
                         entry[1])
 
1897
        return packed_stat
 
1898
 
 
1899
    def test_update_file_to_dir(self):
 
1900
        """If a file changes to a directory we return None for the sha.
 
1901
        We also update the inventory record.
 
1902
        """
 
1903
        state, entry = self.get_state_with_a()
 
1904
        # The file sha1 won't be cached unless the file is old
 
1905
        state.adjust_time(+10)
 
1906
        self.create_and_test_file(state, entry)
 
1907
        os.remove('a')
 
1908
        self.create_and_test_dir(state, entry)
 
1909
 
 
1910
    def test_update_file_to_symlink(self):
 
1911
        """File becomes a symlink"""
 
1912
        self.requireFeature(SymlinkFeature)
 
1913
        state, entry = self.get_state_with_a()
 
1914
        # The file sha1 won't be cached unless the file is old
 
1915
        state.adjust_time(+10)
 
1916
        self.create_and_test_file(state, entry)
 
1917
        os.remove('a')
 
1918
        self.create_and_test_symlink(state, entry)
 
1919
 
 
1920
    def test_update_dir_to_file(self):
 
1921
        """Directory becoming a file updates the entry."""
 
1922
        state, entry = self.get_state_with_a()
 
1923
        # The file sha1 won't be cached unless the file is old
 
1924
        state.adjust_time(+10)
 
1925
        self.create_and_test_dir(state, entry)
 
1926
        os.rmdir('a')
 
1927
        self.create_and_test_file(state, entry)
 
1928
 
 
1929
    def test_update_dir_to_symlink(self):
 
1930
        """Directory becomes a symlink"""
 
1931
        self.requireFeature(SymlinkFeature)
 
1932
        state, entry = self.get_state_with_a()
 
1933
        # The symlink target won't be cached if it isn't old
 
1934
        state.adjust_time(+10)
 
1935
        self.create_and_test_dir(state, entry)
 
1936
        os.rmdir('a')
 
1937
        self.create_and_test_symlink(state, entry)
 
1938
 
 
1939
    def test_update_symlink_to_file(self):
 
1940
        """Symlink becomes a file"""
 
1941
        self.requireFeature(SymlinkFeature)
 
1942
        state, entry = self.get_state_with_a()
 
1943
        # The symlink and file info won't be cached unless old
 
1944
        state.adjust_time(+10)
 
1945
        self.create_and_test_symlink(state, entry)
 
1946
        os.remove('a')
 
1947
        self.create_and_test_file(state, entry)
 
1948
 
 
1949
    def test_update_symlink_to_dir(self):
 
1950
        """Symlink becomes a directory"""
 
1951
        self.requireFeature(SymlinkFeature)
 
1952
        state, entry = self.get_state_with_a()
 
1953
        # The symlink target won't be cached if it isn't old
 
1954
        state.adjust_time(+10)
 
1955
        self.create_and_test_symlink(state, entry)
 
1956
        os.remove('a')
 
1957
        self.create_and_test_dir(state, entry)
 
1958
 
 
1959
    def test__is_executable_win32(self):
 
1960
        state, entry = self.get_state_with_a()
 
1961
        self.build_tree(['a'])
 
1962
 
 
1963
        # Make sure we are using the win32 implementation of _is_executable
 
1964
        state._is_executable = state._is_executable_win32
 
1965
 
 
1966
        # The file on disk is not executable, but we are marking it as though
 
1967
        # it is. With _is_executable_win32 we ignore what is on disk.
 
1968
        entry[1][0] = ('f', '', 0, True, dirstate.DirState.NULLSTAT)
 
1969
 
 
1970
        stat_value = os.lstat('a')
 
1971
        packed_stat = dirstate.pack_stat(stat_value)
 
1972
 
 
1973
        state.adjust_time(-10) # Make sure everything is new
 
1974
        state.update_entry(entry, abspath='a', stat_value=stat_value)
 
1975
 
 
1976
        # The row is updated, but the executable bit stays set.
 
1977
        self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
 
1978
                         entry[1])
 
1979
 
 
1980
        # Make the disk object look old enough to cache
 
1981
        state.adjust_time(+20)
 
1982
        digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1983
        state.update_entry(entry, abspath='a', stat_value=stat_value)
 
1984
        self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
 
1985
 
 
1986
 
 
1987
class TestPackStat(TestCaseWithTransport):
1698
1988
 
1699
1989
    def assertPackStat(self, expected, stat_value):
1700
1990
        """Check the packed and serialized form of a stat value."""
2227
2517
        self.assertEqual(exp_dirblocks, state._dirblocks)
2228
2518
 
2229
2519
 
2230
 
class Test_InvEntryToDetails(tests.TestCase):
 
2520
class Test_InvEntryToDetails(TestCaseWithDirState):
2231
2521
 
2232
2522
    def assertDetails(self, expected, inv_entry):
2233
2523
        details = dirstate.DirState._inv_entry_to_details(inv_entry)
2240
2530
        self.assertIsInstance(tree_data, str)
2241
2531
 
2242
2532
    def test_unicode_symlink(self):
2243
 
        inv_entry = inventory.InventoryLink('link-file-id',
2244
 
                                            u'nam\N{Euro Sign}e',
 
2533
        # In general, the code base doesn't support a target that contains
 
2534
        # non-ascii characters. So we just assert tha 
 
2535
        inv_entry = inventory.InventoryLink('link-file-id', 'name',
2245
2536
                                            'link-parent-id')
2246
2537
        inv_entry.revision = 'link-revision-id'
2247
 
        target = u'link-targ\N{Euro Sign}t'
2248
 
        inv_entry.symlink_target = target
2249
 
        self.assertDetails(('l', target.encode('UTF-8'), 0, False,
2250
 
                            'link-revision-id'), inv_entry)
2251
 
 
2252
 
 
2253
 
class TestSHA1Provider(tests.TestCaseInTempDir):
2254
 
 
2255
 
    def test_sha1provider_is_an_interface(self):
2256
 
        p = dirstate.SHA1Provider()
2257
 
        self.assertRaises(NotImplementedError, p.sha1, "foo")
2258
 
        self.assertRaises(NotImplementedError, p.stat_and_sha1, "foo")
2259
 
 
2260
 
    def test_defaultsha1provider_sha1(self):
2261
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
2262
 
        self.build_tree_contents([('foo', text)])
2263
 
        expected_sha = osutils.sha_string(text)
2264
 
        p = dirstate.DefaultSHA1Provider()
2265
 
        self.assertEqual(expected_sha, p.sha1('foo'))
2266
 
 
2267
 
    def test_defaultsha1provider_stat_and_sha1(self):
2268
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
2269
 
        self.build_tree_contents([('foo', text)])
2270
 
        expected_sha = osutils.sha_string(text)
2271
 
        p = dirstate.DefaultSHA1Provider()
2272
 
        statvalue, sha1 = p.stat_and_sha1('foo')
2273
 
        self.assertTrue(len(statvalue) >= 10)
2274
 
        self.assertEqual(len(text), statvalue.st_size)
2275
 
        self.assertEqual(expected_sha, sha1)
 
2538
        inv_entry.symlink_target = u'link-target'
 
2539
        details = self.assertDetails(('l', 'link-target', 0, False,
 
2540
                                      'link-revision-id'), inv_entry)