/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: Canonical.com Patch Queue Manager
  • Date: 2007-11-03 09:39:11 UTC
  • mfrom: (2949.6.2 win32.os.lstat)
  • Revision ID: pqm@pqm.ubuntu.com-20071103093911-4alf7wiad3n3vfz6
windows python has os.lstat

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_dirstate.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests of the dirstate functionality being built for WorkingTreeFormat4."""
18
18
 
19
19
import bisect
20
20
import os
 
21
import time
21
22
 
22
23
from bzrlib import (
23
24
    dirstate,
24
25
    errors,
25
 
    inventory,
26
 
    memorytree,
27
26
    osutils,
28
 
    revision as _mod_revision,
29
 
    tests,
30
27
    )
31
 
from bzrlib.tests import test_osutils
 
28
from bzrlib.memorytree import MemoryTree
 
29
from bzrlib.tests import (
 
30
        SymlinkFeature,
 
31
        TestCase,
 
32
        TestCaseWithTransport,
 
33
        )
32
34
 
33
35
 
34
36
# TODO:
44
46
# set_path_id  setting id when state is in memory modified
45
47
 
46
48
 
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):
 
49
class TestCaseWithDirState(TestCaseWithTransport):
58
50
    """Helper functions for creating DirState objects with various content."""
59
51
 
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
52
    def create_empty_dirstate(self):
71
53
        """Return a locked but empty dirstate"""
72
54
        state = dirstate.DirState.initialize('dirstate')
180
162
        """
181
163
        # The state should already be write locked, since we just had to do
182
164
        # some operation to get here.
183
 
        self.assertTrue(state._lock_token is not None)
 
165
        assert state._lock_token is not None
184
166
        try:
185
167
            self.assertEqual(expected_result[0],  state.get_parent_ids())
186
168
            # there should be no ghosts in this tree.
377
359
        # There are no files on disk and no parents
378
360
        tree = self.make_branch_and_tree('tree')
379
361
        expected_result = ([], [
380
 
            (('', '', tree.get_root_id()), # common details
 
362
            (('', '', tree.path2id('')), # common details
381
363
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
382
364
             ])])
383
365
        state = dirstate.DirState.from_tree(tree, 'dirstate')
390
372
        rev_id = tree.commit('first post').encode('utf8')
391
373
        root_stat_pack = dirstate.pack_stat(os.stat(tree.basedir))
392
374
        expected_result = ([rev_id], [
393
 
            (('', '', tree.get_root_id()), # common details
 
375
            (('', '', tree.path2id('')), # common details
394
376
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
395
377
              ('d', '', 0, False, rev_id), # first parent details
396
378
             ])])
410
392
        rev_id2 = tree2.commit('second post', allow_pointless=True)
411
393
        tree.merge_from_branch(tree2.branch)
412
394
        expected_result = ([rev_id, rev_id2], [
413
 
            (('', '', tree.get_root_id()), # common details
 
395
            (('', '', tree.path2id('')), # common details
414
396
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
415
397
              ('d', '', 0, False, rev_id), # first parent details
416
 
              ('d', '', 0, False, rev_id), # second parent details
 
398
              ('d', '', 0, False, rev_id2), # second parent details
417
399
             ])])
418
400
        state = dirstate.DirState.from_tree(tree, 'dirstate')
419
401
        self.check_state_with_reopen(expected_result, state)
429
411
        tree = self.make_branch_and_tree('tree')
430
412
        self.build_tree(['tree/unknown'])
431
413
        expected_result = ([], [
432
 
            (('', '', tree.get_root_id()), # common details
 
414
            (('', '', tree.path2id('')), # common details
433
415
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
434
416
             ])])
435
417
        state = dirstate.DirState.from_tree(tree, 'dirstate')
438
420
    def get_tree_with_a_file(self):
439
421
        tree = self.make_branch_and_tree('tree')
440
422
        self.build_tree(['tree/a file'])
441
 
        tree.add('a file', 'a-file-id')
 
423
        tree.add('a file', 'a file id')
442
424
        return tree
443
425
 
444
426
    def test_non_empty_no_parents_to_dirstate(self):
446
428
        # There are files on disk and no parents
447
429
        tree = self.get_tree_with_a_file()
448
430
        expected_result = ([], [
449
 
            (('', '', tree.get_root_id()), # common details
 
431
            (('', '', tree.path2id('')), # common details
450
432
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
451
433
             ]),
452
 
            (('', 'a file', 'a-file-id'), # common
 
434
            (('', 'a file', 'a file id'), # common
453
435
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
454
436
             ]),
455
437
            ])
464
446
        # and length:
465
447
        self.build_tree_contents([('tree/a file', 'new content\n')])
466
448
        expected_result = ([rev_id], [
467
 
            (('', '', tree.get_root_id()), # common details
 
449
            (('', '', tree.path2id('')), # common details
468
450
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
469
451
              ('d', '', 0, False, rev_id), # first parent details
470
452
             ]),
471
 
            (('', 'a file', 'a-file-id'), # common
 
453
            (('', 'a file', 'a file id'), # common
472
454
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
473
455
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
474
456
               rev_id), # first parent
491
473
        # and length again, giving us three distinct values:
492
474
        self.build_tree_contents([('tree/a file', 'new content\n')])
493
475
        expected_result = ([rev_id, rev_id2], [
494
 
            (('', '', tree.get_root_id()), # common details
 
476
            (('', '', tree.path2id('')), # common details
495
477
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
496
478
              ('d', '', 0, False, rev_id), # first parent details
497
 
              ('d', '', 0, False, rev_id), # second parent details
 
479
              ('d', '', 0, False, rev_id2), # second parent details
498
480
             ]),
499
 
            (('', 'a file', 'a-file-id'), # common
 
481
            (('', 'a file', 'a file id'), # common
500
482
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
501
483
              ('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
502
484
               rev_id), # first parent
543
525
        # get a state object
544
526
        # no parents, default tree content
545
527
        expected_result = ([], [
546
 
            (('', '', tree.get_root_id()), # common details
 
528
            (('', '', tree.path2id('')), # common details
547
529
             # current tree details, but new from_tree skips statting, it
548
530
             # uses set_state_from_inventory, and thus depends on the
549
531
             # inventory state.
580
562
        state.lock_read()
581
563
        try:
582
564
            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])
 
565
            # The current sha1 sum should be empty
 
566
            self.assertEqual('', entry[1][0][1])
585
567
            # We should have a real entry.
586
568
            self.assertNotEqual((None, None), entry)
587
569
            # Make sure everything is old enough
588
570
            state._sha_cutoff_time()
589
571
            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)
 
572
            sha1sum = state.update_entry(entry, 'a-file', os.lstat('a-file'))
 
573
            # We should have gotten a real sha1
 
574
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
 
575
                             sha1sum)
596
576
 
597
577
            # The dirblock has been updated
598
 
            self.assertEqual(7, entry[1][0][2])
 
578
            self.assertEqual(sha1sum, entry[1][0][1])
599
579
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
600
580
                             state._dirblock_state)
601
581
 
611
591
        state.lock_read()
612
592
        try:
613
593
            entry = state._get_entry(0, path_utf8='a-file')
614
 
            self.assertEqual(7, entry[1][0][2])
 
594
            self.assertEqual(sha1sum, entry[1][0][1])
615
595
        finally:
616
596
            state.unlock()
617
597
 
630
610
        state.lock_read()
631
611
        try:
632
612
            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)
 
613
            sha1sum = state.update_entry(entry, 'a-file', os.lstat('a-file'))
 
614
            # We should have gotten a real sha1
 
615
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
 
616
                             sha1sum)
637
617
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
638
618
                             state._dirblock_state)
639
619
 
656
636
                state2.unlock()
657
637
        finally:
658
638
            state.unlock()
659
 
 
 
639
        
660
640
        # The file on disk should not be modified.
661
641
        state = dirstate.DirState.on_file('dirstate')
662
642
        state.lock_read()
666
646
        finally:
667
647
            state.unlock()
668
648
 
669
 
    def test_save_refuses_if_changes_aborted(self):
670
 
        self.build_tree(['a-file', 'a-dir/'])
671
 
        state = dirstate.DirState.initialize('dirstate')
672
 
        try:
673
 
            # No stat and no sha1 sum.
674
 
            state.add('a-file', 'a-file-id', 'file', None, '')
675
 
            state.save()
676
 
        finally:
677
 
            state.unlock()
678
 
 
679
 
        # The dirstate should include TREE_ROOT and 'a-file' and nothing else
680
 
        expected_blocks = [
681
 
            ('', [(('', '', 'TREE_ROOT'),
682
 
                   [('d', '', 0, False, dirstate.DirState.NULLSTAT)])]),
683
 
            ('', [(('', 'a-file', 'a-file-id'),
684
 
                   [('f', '', 0, False, dirstate.DirState.NULLSTAT)])]),
685
 
        ]
686
 
 
687
 
        state = dirstate.DirState.on_file('dirstate')
688
 
        state.lock_write()
689
 
        try:
690
 
            state._read_dirblocks_if_needed()
691
 
            self.assertEqual(expected_blocks, state._dirblocks)
692
 
 
693
 
            # Now modify the state, but mark it as inconsistent
694
 
            state.add('a-dir', 'a-dir-id', 'directory', None, '')
695
 
            state._changes_aborted = True
696
 
            state.save()
697
 
        finally:
698
 
            state.unlock()
699
 
 
700
 
        state = dirstate.DirState.on_file('dirstate')
701
 
        state.lock_read()
702
 
        try:
703
 
            state._read_dirblocks_if_needed()
704
 
            self.assertEqual(expected_blocks, state._dirblocks)
705
 
        finally:
706
 
            state.unlock()
707
 
 
708
649
 
709
650
class TestDirStateInitialize(TestCaseWithDirState):
710
651
 
737
678
        try:
738
679
            tree1.add('')
739
680
            revid1 = tree1.commit('foo').encode('utf8')
740
 
            root_id = tree1.get_root_id()
 
681
            root_id = tree1.inventory.root.file_id
741
682
            inv = tree1.inventory
742
683
        finally:
743
684
            tree1.unlock()
762
703
        # https://bugs.launchpad.net/bzr/+bug/146176
763
704
        # set_state_from_inventory should preserve the stat and hash value for
764
705
        # workingtree files that are not changed by the inventory.
765
 
 
 
706
       
766
707
        tree = self.make_branch_and_tree('.')
767
708
        # depends on the default format using dirstate...
768
709
        tree.lock_write()
769
710
        try:
770
 
            # make a dirstate with some valid hashcache data
 
711
            # make a dirstate with some valid hashcache data 
771
712
            # file on disk, but that's not needed for this test
772
713
            foo_contents = 'contents of foo'
773
714
            self.build_tree_contents([('foo', foo_contents)])
793
734
                (('', 'foo', 'foo-id',),
794
735
                 [('f', foo_sha, foo_size, False, foo_packed)]),
795
736
                tree._dirstate._get_entry(0, 'foo-id'))
796
 
 
 
737
           
797
738
            # extract the inventory, and add something to it
798
739
            inv = tree._get_inventory()
799
740
            # should see the file we poked in...
821
762
        finally:
822
763
            tree.unlock()
823
764
 
 
765
 
824
766
    def test_set_state_from_inventory_mixed_paths(self):
825
767
        tree1 = self.make_branch_and_tree('tree1')
826
768
        self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
867
809
        state = dirstate.DirState.initialize('dirstate')
868
810
        try:
869
811
            # 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]
 
812
            self.assertEqual(
 
813
                [(('', '', 'TREE_ROOT'), [('d', '', 0, False,
 
814
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])],
 
815
                list(state._iter_entries()))
 
816
            state.set_path_id('', 'foobarbaz')
 
817
            expected_rows = [
 
818
                (('', '', 'foobarbaz'), [('d', '', 0, False,
 
819
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])]
881
820
            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
821
            # should work across save too
888
822
            state.save()
889
823
        finally:
907
841
        state._validate()
908
842
        try:
909
843
            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')
 
844
            state.set_path_id('', 'foobarbaz')
919
845
            state._validate()
920
846
            # 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]
 
847
            expected_rows = [
 
848
                (('', '', 'TREE_ROOT'),
 
849
                    [('a', '', 0, False, ''),
 
850
                     ('d', '', 0, False, 'parent-revid'),
 
851
                     ]),
 
852
                (('', '', 'foobarbaz'),
 
853
                    [('d', '', 0, False, ''),
 
854
                     ('a', '', 0, False, ''),
 
855
                     ]),
 
856
                ]
928
857
            state._validate()
929
858
            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
859
            # should work across save too
941
860
            state.save()
942
861
        finally:
958
877
        finally:
959
878
            state.unlock()
960
879
 
 
880
 
961
881
    def test_set_parent_trees_no_content(self):
962
882
        # set_parent_trees is a slow but important api to support.
963
883
        tree1 = self.make_branch_and_memory_tree('tree1')
968
888
        finally:
969
889
            tree1.unlock()
970
890
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
971
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
891
        tree2 = MemoryTree.create_on_branch(branch2)
972
892
        tree2.lock_write()
973
893
        try:
974
894
            revid2 = tree2.commit('foo')
975
 
            root_id = tree2.get_root_id()
 
895
            root_id = tree2.inventory.root.file_id
976
896
        finally:
977
897
            tree2.unlock()
978
898
        state = dirstate.DirState.initialize('dirstate')
1006
926
            state.set_parent_trees(
1007
927
                ((revid1, tree1.branch.repository.revision_tree(revid1)),
1008
928
                 (revid2, tree2.branch.repository.revision_tree(revid2)),
1009
 
                 ('ghost-rev', tree2.branch.repository.revision_tree(
1010
 
                                   _mod_revision.NULL_REVISION))),
 
929
                 ('ghost-rev', tree2.branch.repository.revision_tree(None))),
1011
930
                ['ghost-rev'])
1012
931
            self.assertEqual([revid1, revid2, 'ghost-rev'],
1013
932
                             state.get_parent_ids())
1017
936
                [(('', '', root_id), [
1018
937
                  ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1019
938
                  ('d', '', 0, False, revid1),
1020
 
                  ('d', '', 0, False, revid1)
 
939
                  ('d', '', 0, False, revid2)
1021
940
                  ])],
1022
941
                list(state._iter_entries()))
1023
942
        finally:
1038
957
        finally:
1039
958
            tree1.unlock()
1040
959
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1041
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
960
        tree2 = MemoryTree.create_on_branch(branch2)
1042
961
        tree2.lock_write()
1043
962
        try:
1044
963
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1045
964
            revid2 = tree2.commit('foo')
1046
 
            root_id = tree2.get_root_id()
 
965
            root_id = tree2.inventory.root.file_id
1047
966
        finally:
1048
967
            tree2.unlock()
1049
968
        # check the layout in memory
1051
970
            (('', '', root_id), [
1052
971
             ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1053
972
             ('d', '', 0, False, revid1.encode('utf8')),
1054
 
             ('d', '', 0, False, revid1.encode('utf8'))
 
973
             ('d', '', 0, False, revid2.encode('utf8'))
1055
974
             ]),
1056
975
            (('', 'a file', 'file-id'), [
1057
976
             ('a', '', 0, False, ''),
1089
1008
            (('', '', 'TREE_ROOT'), [
1090
1009
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1091
1010
             ]),
1092
 
            (('', 'a file', 'a-file-id'), [
 
1011
            (('', 'a file', 'a file id'), [
1093
1012
             ('f', '1'*20, 19, False, dirstate.pack_stat(stat)), # current tree
1094
1013
             ]),
1095
1014
            ]
1096
1015
        try:
1097
 
            state.add('a file', 'a-file-id', 'file', stat, '1'*20)
 
1016
            state.add('a file', 'a file id', 'file', stat, '1'*20)
1098
1017
            # having added it, it should be in the output of iter_entries.
1099
1018
            self.assertEqual(expected_entries, list(state._iter_entries()))
1100
1019
            # saving and reloading should not affect this.
1103
1022
            state.unlock()
1104
1023
        state = dirstate.DirState.on_file('dirstate')
1105
1024
        state.lock_read()
1106
 
        self.addCleanup(state.unlock)
1107
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1025
        try:
 
1026
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1027
        finally:
 
1028
            state.unlock()
1108
1029
 
1109
1030
    def test_add_path_to_unversioned_directory(self):
1110
1031
        """Adding a path to an unversioned directory should error.
1115
1036
        """
1116
1037
        self.build_tree(['unversioned/', 'unversioned/a file'])
1117
1038
        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)
 
1039
        try:
 
1040
            self.assertRaises(errors.NotVersionedError, state.add,
 
1041
                'unversioned/a file', 'a file id', 'file', None, None)
 
1042
        finally:
 
1043
            state.unlock()
1121
1044
 
1122
1045
    def test_add_directory_to_root_no_parents_all_data(self):
1123
1046
        # The most trivial addition of a dir is when there are no parents and
1143
1066
            state.unlock()
1144
1067
        state = dirstate.DirState.on_file('dirstate')
1145
1068
        state.lock_read()
1146
 
        self.addCleanup(state.unlock)
1147
1069
        state._validate()
1148
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1070
        try:
 
1071
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1072
        finally:
 
1073
            state.unlock()
1149
1074
 
1150
 
    def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
 
1075
    def test_add_symlink_to_root_no_parents_all_data(self):
1151
1076
        # The most trivial addition of a symlink when there are no parents and
1152
1077
        # its in the root and all data about the file is supplied
1153
1078
        # 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)
 
1079
        self.requireFeature(SymlinkFeature)
 
1080
        os.symlink('target', 'a link')
 
1081
        stat = os.lstat('a link')
1157
1082
        expected_entries = [
1158
1083
            (('', '', 'TREE_ROOT'), [
1159
1084
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1160
1085
             ]),
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
 
1086
            (('', 'a link', 'a link id'), [
 
1087
             ('l', 'target', 6, False, dirstate.pack_stat(stat)), # current tree
1164
1088
             ]),
1165
1089
            ]
1166
1090
        state = dirstate.DirState.initialize('dirstate')
1167
1091
        try:
1168
 
            state.add(link_name, 'a link id', 'symlink', stat,
1169
 
                      target.encode('UTF-8'))
 
1092
            state.add('a link', 'a link id', 'symlink', stat, 'target')
1170
1093
            # having added it, it should be in the output of iter_entries.
1171
1094
            self.assertEqual(expected_entries, list(state._iter_entries()))
1172
1095
            # saving and reloading should not affect this.
1175
1098
            state.unlock()
1176
1099
        state = dirstate.DirState.on_file('dirstate')
1177
1100
        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')
 
1101
        try:
 
1102
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1103
        finally:
 
1104
            state.unlock()
1188
1105
 
1189
1106
    def test_add_directory_and_child_no_parents_all_data(self):
1190
1107
        # after adding a directory, we should be able to add children to it.
1198
1115
            (('', 'a dir', 'a dir id'), [
1199
1116
             ('d', '', 0, False, dirstate.pack_stat(dirstat)), # current tree
1200
1117
             ]),
1201
 
            (('a dir', 'a file', 'a-file-id'), [
 
1118
            (('a dir', 'a file', 'a file id'), [
1202
1119
             ('f', '1'*20, 25, False,
1203
1120
              dirstate.pack_stat(filestat)), # current tree details
1204
1121
             ]),
1206
1123
        state = dirstate.DirState.initialize('dirstate')
1207
1124
        try:
1208
1125
            state.add('a dir', 'a dir id', 'directory', dirstat, None)
1209
 
            state.add('a dir/a file', 'a-file-id', 'file', filestat, '1'*20)
 
1126
            state.add('a dir/a file', 'a file id', 'file', filestat, '1'*20)
1210
1127
            # added it, it should be in the output of iter_entries.
1211
1128
            self.assertEqual(expected_entries, list(state._iter_entries()))
1212
1129
            # saving and reloading should not affect this.
1215
1132
            state.unlock()
1216
1133
        state = dirstate.DirState.on_file('dirstate')
1217
1134
        state.lock_read()
1218
 
        self.addCleanup(state.unlock)
1219
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1135
        try:
 
1136
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1137
        finally:
 
1138
            state.unlock()
1220
1139
 
1221
1140
    def test_add_tree_reference(self):
1222
1141
        # make a dirstate and add a tree reference
1236
1155
            state.unlock()
1237
1156
        # now check we can read it back
1238
1157
        state.lock_read()
1239
 
        self.addCleanup(state.unlock)
1240
1158
        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)
 
1159
        try:
 
1160
            entry2 = state._get_entry(0, 'subdir-id', 'subdir')
 
1161
            self.assertEqual(entry, entry2)
 
1162
            self.assertEqual(entry, expected_entry)
 
1163
            # and lookup by id should work too
 
1164
            entry2 = state._get_entry(0, fileid_utf8='subdir-id')
 
1165
            self.assertEqual(entry, expected_entry)
 
1166
        finally:
 
1167
            state.unlock()
1247
1168
 
1248
1169
    def test_add_forbidden_names(self):
1249
1170
        state = dirstate.DirState.initialize('dirstate')
1253
1174
        self.assertRaises(errors.BzrError,
1254
1175
            state.add, '..', 'ass-id', 'directory', None, None)
1255
1176
 
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
1177
 
1289
1178
class TestGetLines(TestCaseWithDirState):
1290
1179
 
1503
1392
            state.unlock()
1504
1393
 
1505
1394
 
1506
 
class TestIterChildEntries(TestCaseWithDirState):
1507
 
 
1508
 
    def create_dirstate_with_two_trees(self):
1509
 
        """This dirstate contains multiple files and directories.
1510
 
 
1511
 
         /        a-root-value
1512
 
         a/       a-dir
1513
 
         b/       b-dir
1514
 
         c        c-file
1515
 
         d        d-file
1516
 
         a/e/     e-dir
1517
 
         a/f      f-file
1518
 
         b/g      g-file
1519
 
         b/h\xc3\xa5  h-\xc3\xa5-file  #This is u'\xe5' encoded into utf-8
1520
 
 
1521
 
        Notice that a/e is an empty directory.
1522
 
 
1523
 
        There is one parent tree, which has the same shape with the following variations:
1524
 
        b/g in the parent is gone.
1525
 
        b/h in the parent has a different id
1526
 
        b/i is new in the parent
1527
 
        c is renamed to b/j in the parent
1528
 
 
1529
 
        :return: The dirstate, still write-locked.
1530
 
        """
1531
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1532
 
        null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
1533
 
        NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
1534
 
        root_entry = ('', '', 'a-root-value'), [
1535
 
            ('d', '', 0, False, packed_stat),
1536
 
            ('d', '', 0, False, 'parent-revid'),
1537
 
            ]
1538
 
        a_entry = ('', 'a', 'a-dir'), [
1539
 
            ('d', '', 0, False, packed_stat),
1540
 
            ('d', '', 0, False, 'parent-revid'),
1541
 
            ]
1542
 
        b_entry = ('', 'b', 'b-dir'), [
1543
 
            ('d', '', 0, False, packed_stat),
1544
 
            ('d', '', 0, False, 'parent-revid'),
1545
 
            ]
1546
 
        c_entry = ('', 'c', 'c-file'), [
1547
 
            ('f', null_sha, 10, False, packed_stat),
1548
 
            ('r', 'b/j', 0, False, ''),
1549
 
            ]
1550
 
        d_entry = ('', 'd', 'd-file'), [
1551
 
            ('f', null_sha, 20, False, packed_stat),
1552
 
            ('f', 'd', 20, False, 'parent-revid'),
1553
 
            ]
1554
 
        e_entry = ('a', 'e', 'e-dir'), [
1555
 
            ('d', '', 0, False, packed_stat),
1556
 
            ('d', '', 0, False, 'parent-revid'),
1557
 
            ]
1558
 
        f_entry = ('a', 'f', 'f-file'), [
1559
 
            ('f', null_sha, 30, False, packed_stat),
1560
 
            ('f', 'f', 20, False, 'parent-revid'),
1561
 
            ]
1562
 
        g_entry = ('b', 'g', 'g-file'), [
1563
 
            ('f', null_sha, 30, False, packed_stat),
1564
 
            NULL_PARENT_DETAILS,
1565
 
            ]
1566
 
        h_entry1 = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file1'), [
1567
 
            ('f', null_sha, 40, False, packed_stat),
1568
 
            NULL_PARENT_DETAILS,
1569
 
            ]
1570
 
        h_entry2 = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file2'), [
1571
 
            NULL_PARENT_DETAILS,
1572
 
            ('f', 'h', 20, False, 'parent-revid'),
1573
 
            ]
1574
 
        i_entry = ('b', 'i', 'i-file'), [
1575
 
            NULL_PARENT_DETAILS,
1576
 
            ('f', 'h', 20, False, 'parent-revid'),
1577
 
            ]
1578
 
        j_entry = ('b', 'j', 'c-file'), [
1579
 
            ('r', 'c', 0, False, ''),
1580
 
            ('f', 'j', 20, False, 'parent-revid'),
1581
 
            ]
1582
 
        dirblocks = []
1583
 
        dirblocks.append(('', [root_entry]))
1584
 
        dirblocks.append(('', [a_entry, b_entry, c_entry, d_entry]))
1585
 
        dirblocks.append(('a', [e_entry, f_entry]))
1586
 
        dirblocks.append(('b', [g_entry, h_entry1, h_entry2, i_entry, j_entry]))
1587
 
        state = dirstate.DirState.initialize('dirstate')
1588
 
        state._validate()
1589
 
        try:
1590
 
            state._set_data(['parent'], dirblocks)
1591
 
        except:
1592
 
            state.unlock()
1593
 
            raise
1594
 
        return state, dirblocks
1595
 
 
1596
 
    def test_iter_children_b(self):
1597
 
        state, dirblocks = self.create_dirstate_with_two_trees()
1598
 
        self.addCleanup(state.unlock)
1599
 
        expected_result = []
1600
 
        expected_result.append(dirblocks[3][1][2]) # h2
1601
 
        expected_result.append(dirblocks[3][1][3]) # i
1602
 
        expected_result.append(dirblocks[3][1][4]) # j
1603
 
        self.assertEqual(expected_result,
1604
 
            list(state._iter_child_entries(1, 'b')))
1605
 
 
1606
 
    def test_iter_child_root(self):
1607
 
        state, dirblocks = self.create_dirstate_with_two_trees()
1608
 
        self.addCleanup(state.unlock)
1609
 
        expected_result = []
1610
 
        expected_result.append(dirblocks[1][1][0]) # a
1611
 
        expected_result.append(dirblocks[1][1][1]) # b
1612
 
        expected_result.append(dirblocks[1][1][3]) # d
1613
 
        expected_result.append(dirblocks[2][1][0]) # e
1614
 
        expected_result.append(dirblocks[2][1][1]) # f
1615
 
        expected_result.append(dirblocks[3][1][2]) # h2
1616
 
        expected_result.append(dirblocks[3][1][3]) # i
1617
 
        expected_result.append(dirblocks[3][1][4]) # j
1618
 
        self.assertEqual(expected_result,
1619
 
            list(state._iter_child_entries(1, '')))
1620
 
 
1621
 
 
1622
 
class TestDirstateSortOrder(tests.TestCaseWithTransport):
 
1395
class TestDirstateSortOrder(TestCaseWithTransport):
1623
1396
    """Test that DirState adds entries in the right order."""
1624
1397
 
1625
1398
    def test_add_sorting(self):
1674
1447
 
1675
1448
        # *really* cheesy way to just get an empty tree
1676
1449
        repo = self.make_repository('repo')
1677
 
        empty_tree = repo.revision_tree(_mod_revision.NULL_REVISION)
 
1450
        empty_tree = repo.revision_tree(None)
1678
1451
        state.set_parent_trees([('null:', empty_tree)], [])
1679
1452
 
1680
1453
        dirblock_names = [d[0] for d in state._dirblocks]
1684
1457
class InstrumentedDirState(dirstate.DirState):
1685
1458
    """An DirState with instrumented sha1 functionality."""
1686
1459
 
1687
 
    def __init__(self, path, sha1_provider):
1688
 
        super(InstrumentedDirState, self).__init__(path, sha1_provider)
 
1460
    def __init__(self, path):
 
1461
        super(InstrumentedDirState, self).__init__(path)
1689
1462
        self._time_offset = 0
1690
1463
        self._log = []
1691
1464
        # member is dynamically set in DirState.__init__ to turn on trace
1692
 
        self._sha1_provider = sha1_provider
1693
1465
        self._sha1_file = self._sha1_file_and_log
1694
1466
 
1695
1467
    def _sha_cutoff_time(self):
1698
1470
 
1699
1471
    def _sha1_file_and_log(self, abspath):
1700
1472
        self._log.append(('sha1', abspath))
1701
 
        return self._sha1_provider.sha1(abspath)
 
1473
        return osutils.sha_file_by_name(abspath)
1702
1474
 
1703
1475
    def _read_link(self, abspath, old_link):
1704
1476
        self._log.append(('read_link', abspath, old_link))
1735
1507
        self.st_ino = ino
1736
1508
        self.st_mode = mode
1737
1509
 
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):
 
1510
 
 
1511
class TestUpdateEntry(TestCaseWithDirState):
 
1512
    """Test the DirState.update_entry functions"""
 
1513
 
 
1514
    def get_state_with_a(self):
 
1515
        """Create a DirState tracking a single object named 'a'"""
 
1516
        state = InstrumentedDirState.initialize('dirstate')
 
1517
        self.addCleanup(state.unlock)
 
1518
        state.add('a', 'a-id', 'file', None, '')
 
1519
        entry = state._get_entry(0, path_utf8='a')
 
1520
        return state, entry
 
1521
 
 
1522
    def test_update_entry(self):
 
1523
        state, entry = self.get_state_with_a()
 
1524
        self.build_tree(['a'])
 
1525
        # Add one where we don't provide the stat or sha already
 
1526
        self.assertEqual(('', 'a', 'a-id'), entry[0])
 
1527
        self.assertEqual([('f', '', 0, False, dirstate.DirState.NULLSTAT)],
 
1528
                         entry[1])
 
1529
        # Flush the buffers to disk
 
1530
        state.save()
 
1531
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1532
                         state._dirblock_state)
 
1533
 
 
1534
        stat_value = os.lstat('a')
 
1535
        packed_stat = dirstate.pack_stat(stat_value)
 
1536
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1537
                                          stat_value=stat_value)
 
1538
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1539
                         link_or_sha1)
 
1540
 
 
1541
        # The dirblock entry should not cache the file's sha1
 
1542
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1543
                         entry[1])
 
1544
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1545
                         state._dirblock_state)
 
1546
        mode = stat_value.st_mode
 
1547
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False)], state._log)
 
1548
 
 
1549
        state.save()
 
1550
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1551
                         state._dirblock_state)
 
1552
 
 
1553
        # If we do it again right away, we don't know if the file has changed
 
1554
        # so we will re-read the file. Roll the clock back so the file is
 
1555
        # guaranteed to look too new.
 
1556
        state.adjust_time(-10)
 
1557
 
 
1558
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1559
                                          stat_value=stat_value)
 
1560
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1561
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1562
                         ], state._log)
 
1563
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1564
                         link_or_sha1)
 
1565
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1566
                         state._dirblock_state)
 
1567
        self.assertEqual([('f', '', 14, False, dirstate.DirState.NULLSTAT)],
 
1568
                         entry[1])
 
1569
        state.save()
 
1570
 
 
1571
        # However, if we move the clock forward so the file is considered
 
1572
        # "stable", it should just cache the value.
 
1573
        state.adjust_time(+20)
 
1574
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1575
                                          stat_value=stat_value)
 
1576
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1577
                         link_or_sha1)
 
1578
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1579
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1580
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1581
                         ], state._log)
 
1582
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1583
                         entry[1])
 
1584
 
 
1585
        # Subsequent calls will just return the cached value
 
1586
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1587
                                          stat_value=stat_value)
 
1588
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1589
                         link_or_sha1)
 
1590
        self.assertEqual([('sha1', 'a'), ('is_exec', mode, False),
 
1591
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1592
                          ('sha1', 'a'), ('is_exec', mode, False),
 
1593
                         ], state._log)
 
1594
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1595
                         entry[1])
 
1596
 
 
1597
    def test_update_entry_symlink(self):
 
1598
        """Update entry should read symlinks."""
 
1599
        self.requireFeature(SymlinkFeature)
 
1600
        state, entry = self.get_state_with_a()
 
1601
        state.save()
 
1602
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1603
                         state._dirblock_state)
 
1604
        os.symlink('target', 'a')
 
1605
 
 
1606
        state.adjust_time(-10) # Make the symlink look new
 
1607
        stat_value = os.lstat('a')
 
1608
        packed_stat = dirstate.pack_stat(stat_value)
 
1609
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1610
                                          stat_value=stat_value)
 
1611
        self.assertEqual('target', link_or_sha1)
 
1612
        self.assertEqual([('read_link', 'a', '')], state._log)
 
1613
        # Dirblock is not updated (the link is too new)
 
1614
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1615
                         entry[1])
 
1616
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1617
                         state._dirblock_state)
 
1618
 
 
1619
        # Because the stat_value looks new, we should re-read the target
 
1620
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1621
                                          stat_value=stat_value)
 
1622
        self.assertEqual('target', link_or_sha1)
 
1623
        self.assertEqual([('read_link', 'a', ''),
 
1624
                          ('read_link', 'a', ''),
 
1625
                         ], state._log)
 
1626
        self.assertEqual([('l', '', 6, False, dirstate.DirState.NULLSTAT)],
 
1627
                         entry[1])
 
1628
        state.adjust_time(+20) # Skip into the future, all files look old
 
1629
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1630
                                          stat_value=stat_value)
 
1631
        self.assertEqual('target', link_or_sha1)
 
1632
        # We need to re-read the link because only now can we cache it
 
1633
        self.assertEqual([('read_link', 'a', ''),
 
1634
                          ('read_link', 'a', ''),
 
1635
                          ('read_link', 'a', ''),
 
1636
                         ], state._log)
 
1637
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1638
                         entry[1])
 
1639
 
 
1640
        # Another call won't re-read the link
 
1641
        self.assertEqual([('read_link', 'a', ''),
 
1642
                          ('read_link', 'a', ''),
 
1643
                          ('read_link', 'a', ''),
 
1644
                         ], state._log)
 
1645
        link_or_sha1 = state.update_entry(entry, abspath='a',
 
1646
                                          stat_value=stat_value)
 
1647
        self.assertEqual('target', link_or_sha1)
 
1648
        self.assertEqual([('l', 'target', 6, False, packed_stat)],
 
1649
                         entry[1])
 
1650
 
 
1651
    def do_update_entry(self, state, entry, abspath):
 
1652
        stat_value = os.lstat(abspath)
 
1653
        return state.update_entry(entry, abspath, stat_value)
 
1654
 
 
1655
    def test_update_entry_dir(self):
 
1656
        state, entry = self.get_state_with_a()
 
1657
        self.build_tree(['a/'])
 
1658
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1659
 
 
1660
    def test_update_entry_dir_unchanged(self):
 
1661
        state, entry = self.get_state_with_a()
 
1662
        self.build_tree(['a/'])
 
1663
        state.adjust_time(+20)
 
1664
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1665
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1666
                         state._dirblock_state)
 
1667
        state.save()
 
1668
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1669
                         state._dirblock_state)
 
1670
        self.assertIs(None, self.do_update_entry(state, entry, 'a'))
 
1671
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1672
                         state._dirblock_state)
 
1673
 
 
1674
    def test_update_entry_file_unchanged(self):
 
1675
        state, entry = self.get_state_with_a()
 
1676
        self.build_tree(['a'])
 
1677
        sha1sum = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1678
        state.adjust_time(+20)
 
1679
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1680
        self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
 
1681
                         state._dirblock_state)
 
1682
        state.save()
 
1683
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1684
                         state._dirblock_state)
 
1685
        self.assertEqual(sha1sum, self.do_update_entry(state, entry, 'a'))
 
1686
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
 
1687
                         state._dirblock_state)
 
1688
 
 
1689
    def create_and_test_file(self, state, entry):
 
1690
        """Create a file at 'a' and verify the state finds it.
 
1691
 
 
1692
        The state should already be versioning *something* at 'a'. This makes
 
1693
        sure that state.update_entry recognizes it as a file.
 
1694
        """
 
1695
        self.build_tree(['a'])
 
1696
        stat_value = os.lstat('a')
 
1697
        packed_stat = dirstate.pack_stat(stat_value)
 
1698
 
 
1699
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1700
        self.assertEqual('b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6',
 
1701
                         link_or_sha1)
 
1702
        self.assertEqual([('f', link_or_sha1, 14, False, packed_stat)],
 
1703
                         entry[1])
 
1704
        return packed_stat
 
1705
 
 
1706
    def create_and_test_dir(self, state, entry):
 
1707
        """Create a directory at 'a' and verify the state finds it.
 
1708
 
 
1709
        The state should already be versioning *something* at 'a'. This makes
 
1710
        sure that state.update_entry recognizes it as a directory.
 
1711
        """
 
1712
        self.build_tree(['a/'])
 
1713
        stat_value = os.lstat('a')
 
1714
        packed_stat = dirstate.pack_stat(stat_value)
 
1715
 
 
1716
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1717
        self.assertIs(None, link_or_sha1)
 
1718
        self.assertEqual([('d', '', 0, False, packed_stat)], entry[1])
 
1719
 
 
1720
        return packed_stat
 
1721
 
 
1722
    def create_and_test_symlink(self, state, entry):
 
1723
        """Create a symlink at 'a' and verify the state finds it.
 
1724
 
 
1725
        The state should already be versioning *something* at 'a'. This makes
 
1726
        sure that state.update_entry recognizes it as a symlink.
 
1727
 
 
1728
        This should not be called if this platform does not have symlink
 
1729
        support.
 
1730
        """
 
1731
        # caller should care about skipping test on platforms without symlinks
 
1732
        os.symlink('path/to/foo', 'a')
 
1733
 
 
1734
        stat_value = os.lstat('a')
 
1735
        packed_stat = dirstate.pack_stat(stat_value)
 
1736
 
 
1737
        link_or_sha1 = self.do_update_entry(state, entry, abspath='a')
 
1738
        self.assertEqual('path/to/foo', link_or_sha1)
 
1739
        self.assertEqual([('l', 'path/to/foo', 11, False, packed_stat)],
 
1740
                         entry[1])
 
1741
        return packed_stat
 
1742
 
 
1743
    def test_update_file_to_dir(self):
 
1744
        """If a file changes to a directory we return None for the sha.
 
1745
        We also update the inventory record.
 
1746
        """
 
1747
        state, entry = self.get_state_with_a()
 
1748
        # The file sha1 won't be cached unless the file is old
 
1749
        state.adjust_time(+10)
 
1750
        self.create_and_test_file(state, entry)
 
1751
        os.remove('a')
 
1752
        self.create_and_test_dir(state, entry)
 
1753
 
 
1754
    def test_update_file_to_symlink(self):
 
1755
        """File becomes a symlink"""
 
1756
        self.requireFeature(SymlinkFeature)
 
1757
        state, entry = self.get_state_with_a()
 
1758
        # The file sha1 won't be cached unless the file is old
 
1759
        state.adjust_time(+10)
 
1760
        self.create_and_test_file(state, entry)
 
1761
        os.remove('a')
 
1762
        self.create_and_test_symlink(state, entry)
 
1763
 
 
1764
    def test_update_dir_to_file(self):
 
1765
        """Directory becoming a file updates the entry."""
 
1766
        state, entry = self.get_state_with_a()
 
1767
        # The file sha1 won't be cached unless the file is old
 
1768
        state.adjust_time(+10)
 
1769
        self.create_and_test_dir(state, entry)
 
1770
        os.rmdir('a')
 
1771
        self.create_and_test_file(state, entry)
 
1772
 
 
1773
    def test_update_dir_to_symlink(self):
 
1774
        """Directory becomes a symlink"""
 
1775
        self.requireFeature(SymlinkFeature)
 
1776
        state, entry = self.get_state_with_a()
 
1777
        # The symlink target won't be cached if it isn't old
 
1778
        state.adjust_time(+10)
 
1779
        self.create_and_test_dir(state, entry)
 
1780
        os.rmdir('a')
 
1781
        self.create_and_test_symlink(state, entry)
 
1782
 
 
1783
    def test_update_symlink_to_file(self):
 
1784
        """Symlink becomes a file"""
 
1785
        self.requireFeature(SymlinkFeature)
 
1786
        state, entry = self.get_state_with_a()
 
1787
        # The symlink and file info won't be cached unless old
 
1788
        state.adjust_time(+10)
 
1789
        self.create_and_test_symlink(state, entry)
 
1790
        os.remove('a')
 
1791
        self.create_and_test_file(state, entry)
 
1792
 
 
1793
    def test_update_symlink_to_dir(self):
 
1794
        """Symlink becomes a directory"""
 
1795
        self.requireFeature(SymlinkFeature)
 
1796
        state, entry = self.get_state_with_a()
 
1797
        # The symlink target won't be cached if it isn't old
 
1798
        state.adjust_time(+10)
 
1799
        self.create_and_test_symlink(state, entry)
 
1800
        os.remove('a')
 
1801
        self.create_and_test_dir(state, entry)
 
1802
 
 
1803
    def test__is_executable_win32(self):
 
1804
        state, entry = self.get_state_with_a()
 
1805
        self.build_tree(['a'])
 
1806
 
 
1807
        # Make sure we are using the win32 implementation of _is_executable
 
1808
        state._is_executable = state._is_executable_win32
 
1809
 
 
1810
        # The file on disk is not executable, but we are marking it as though
 
1811
        # it is. With _is_executable_win32 we ignore what is on disk.
 
1812
        entry[1][0] = ('f', '', 0, True, dirstate.DirState.NULLSTAT)
 
1813
 
 
1814
        stat_value = os.lstat('a')
 
1815
        packed_stat = dirstate.pack_stat(stat_value)
 
1816
 
 
1817
        state.adjust_time(-10) # Make sure everything is new
 
1818
        state.update_entry(entry, abspath='a', stat_value=stat_value)
 
1819
 
 
1820
        # The row is updated, but the executable bit stays set.
 
1821
        self.assertEqual([('f', '', 14, True, dirstate.DirState.NULLSTAT)],
 
1822
                         entry[1])
 
1823
 
 
1824
        # Make the disk object look old enough to cache
 
1825
        state.adjust_time(+20)
 
1826
        digest = 'b50e5406bb5e153ebbeb20268fcf37c87e1ecfb6'
 
1827
        state.update_entry(entry, abspath='a', stat_value=stat_value)
 
1828
        self.assertEqual([('f', digest, 14, True, packed_stat)], entry[1])
 
1829
 
 
1830
 
 
1831
class TestPackStat(TestCaseWithTransport):
1745
1832
 
1746
1833
    def assertPackStat(self, expected, stat_value):
1747
1834
        """Check the packed and serialized form of a stat value."""
1812
1899
        # the end it would still be fairly arbitrary, and we don't want the
1813
1900
        # extra overhead if we can avoid it. So sort everything to make sure
1814
1901
        # equality is true
1815
 
        self.assertEqual(len(map_keys), len(paths))
 
1902
        assert len(map_keys) == len(paths)
1816
1903
        expected = {}
1817
1904
        for path, keys in zip(paths, map_keys):
1818
1905
            if keys is None:
1837
1924
        :param paths: A list of directories
1838
1925
        """
1839
1926
        result = state._bisect_dirblocks(paths)
1840
 
        self.assertEqual(len(map_keys), len(paths))
 
1927
        assert len(map_keys) == len(paths)
 
1928
 
1841
1929
        expected = {}
1842
1930
        for path, keys in zip(paths, map_keys):
1843
1931
            if keys is None:
2107
2195
            self.assertEqual(expected, state._find_block(key))
2108
2196
        finally:
2109
2197
            state.unlock()
2110
 
 
2111
 
 
2112
 
class TestDiscardMergeParents(TestCaseWithDirState):
2113
 
 
2114
 
    def test_discard_no_parents(self):
2115
 
        # This should be a no-op
2116
 
        state = self.create_empty_dirstate()
2117
 
        self.addCleanup(state.unlock)
2118
 
        state._discard_merge_parents()
2119
 
        state._validate()
2120
 
 
2121
 
    def test_discard_one_parent(self):
2122
 
        # No-op
2123
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2124
 
        root_entry_direntry = ('', '', 'a-root-value'), [
2125
 
            ('d', '', 0, False, packed_stat),
2126
 
            ('d', '', 0, False, packed_stat),
2127
 
            ]
2128
 
        dirblocks = []
2129
 
        dirblocks.append(('', [root_entry_direntry]))
2130
 
        dirblocks.append(('', []))
2131
 
 
2132
 
        state = self.create_empty_dirstate()
2133
 
        self.addCleanup(state.unlock)
2134
 
        state._set_data(['parent-id'], dirblocks[:])
2135
 
        state._validate()
2136
 
 
2137
 
        state._discard_merge_parents()
2138
 
        state._validate()
2139
 
        self.assertEqual(dirblocks, state._dirblocks)
2140
 
 
2141
 
    def test_discard_simple(self):
2142
 
        # No-op
2143
 
        packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2144
 
        root_entry_direntry = ('', '', 'a-root-value'), [
2145
 
            ('d', '', 0, False, packed_stat),
2146
 
            ('d', '', 0, False, packed_stat),
2147
 
            ('d', '', 0, False, packed_stat),
2148
 
            ]
2149
 
        expected_root_entry_direntry = ('', '', 'a-root-value'), [
2150
 
            ('d', '', 0, False, packed_stat),
2151
 
            ('d', '', 0, False, packed_stat),
2152
 
            ]
2153
 
        dirblocks = []
2154
 
        dirblocks.append(('', [root_entry_direntry]))
2155
 
        dirblocks.append(('', []))
2156
 
 
2157
 
        state = self.create_empty_dirstate()
2158
 
        self.addCleanup(state.unlock)
2159
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2160
 
        state._validate()
2161
 
 
2162
 
        # This should strip of the extra column
2163
 
        state._discard_merge_parents()
2164
 
        state._validate()
2165
 
        expected_dirblocks = [('', [expected_root_entry_direntry]), ('', [])]
2166
 
        self.assertEqual(expected_dirblocks, state._dirblocks)
2167
 
 
2168
 
    def test_discard_absent(self):
2169
 
        """If entries are only in a merge, discard should remove the entries"""
2170
 
        null_stat = dirstate.DirState.NULLSTAT
2171
 
        present_dir = ('d', '', 0, False, null_stat)
2172
 
        present_file = ('f', '', 0, False, null_stat)
2173
 
        absent = dirstate.DirState.NULL_PARENT_DETAILS
2174
 
        root_key = ('', '', 'a-root-value')
2175
 
        file_in_root_key = ('', 'file-in-root', 'a-file-id')
2176
 
        file_in_merged_key = ('', 'file-in-merged', 'b-file-id')
2177
 
        dirblocks = [('', [(root_key, [present_dir, present_dir, present_dir])]),
2178
 
                     ('', [(file_in_merged_key,
2179
 
                            [absent, absent, present_file]),
2180
 
                           (file_in_root_key,
2181
 
                            [present_file, present_file, present_file]),
2182
 
                          ]),
2183
 
                    ]
2184
 
 
2185
 
        state = self.create_empty_dirstate()
2186
 
        self.addCleanup(state.unlock)
2187
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2188
 
        state._validate()
2189
 
 
2190
 
        exp_dirblocks = [('', [(root_key, [present_dir, present_dir])]),
2191
 
                         ('', [(file_in_root_key,
2192
 
                                [present_file, present_file]),
2193
 
                              ]),
2194
 
                        ]
2195
 
        state._discard_merge_parents()
2196
 
        state._validate()
2197
 
        self.assertEqual(exp_dirblocks, state._dirblocks)
2198
 
 
2199
 
    def test_discard_renamed(self):
2200
 
        null_stat = dirstate.DirState.NULLSTAT
2201
 
        present_dir = ('d', '', 0, False, null_stat)
2202
 
        present_file = ('f', '', 0, False, null_stat)
2203
 
        absent = dirstate.DirState.NULL_PARENT_DETAILS
2204
 
        root_key = ('', '', 'a-root-value')
2205
 
        file_in_root_key = ('', 'file-in-root', 'a-file-id')
2206
 
        # Renamed relative to parent
2207
 
        file_rename_s_key = ('', 'file-s', 'b-file-id')
2208
 
        file_rename_t_key = ('', 'file-t', 'b-file-id')
2209
 
        # And one that is renamed between the parents, but absent in this
2210
 
        key_in_1 = ('', 'file-in-1', 'c-file-id')
2211
 
        key_in_2 = ('', 'file-in-2', 'c-file-id')
2212
 
 
2213
 
        dirblocks = [
2214
 
            ('', [(root_key, [present_dir, present_dir, present_dir])]),
2215
 
            ('', [(key_in_1,
2216
 
                   [absent, present_file, ('r', 'file-in-2', 'c-file-id')]),
2217
 
                  (key_in_2,
2218
 
                   [absent, ('r', 'file-in-1', 'c-file-id'), present_file]),
2219
 
                  (file_in_root_key,
2220
 
                   [present_file, present_file, present_file]),
2221
 
                  (file_rename_s_key,
2222
 
                   [('r', 'file-t', 'b-file-id'), absent, present_file]),
2223
 
                  (file_rename_t_key,
2224
 
                   [present_file, absent, ('r', 'file-s', 'b-file-id')]),
2225
 
                 ]),
2226
 
        ]
2227
 
        exp_dirblocks = [
2228
 
            ('', [(root_key, [present_dir, present_dir])]),
2229
 
            ('', [(key_in_1, [absent, present_file]),
2230
 
                  (file_in_root_key, [present_file, present_file]),
2231
 
                  (file_rename_t_key, [present_file, absent]),
2232
 
                 ]),
2233
 
        ]
2234
 
        state = self.create_empty_dirstate()
2235
 
        self.addCleanup(state.unlock)
2236
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2237
 
        state._validate()
2238
 
 
2239
 
        state._discard_merge_parents()
2240
 
        state._validate()
2241
 
        self.assertEqual(exp_dirblocks, state._dirblocks)
2242
 
 
2243
 
    def test_discard_all_subdir(self):
2244
 
        null_stat = dirstate.DirState.NULLSTAT
2245
 
        present_dir = ('d', '', 0, False, null_stat)
2246
 
        present_file = ('f', '', 0, False, null_stat)
2247
 
        absent = dirstate.DirState.NULL_PARENT_DETAILS
2248
 
        root_key = ('', '', 'a-root-value')
2249
 
        subdir_key = ('', 'sub', 'dir-id')
2250
 
        child1_key = ('sub', 'child1', 'child1-id')
2251
 
        child2_key = ('sub', 'child2', 'child2-id')
2252
 
        child3_key = ('sub', 'child3', 'child3-id')
2253
 
 
2254
 
        dirblocks = [
2255
 
            ('', [(root_key, [present_dir, present_dir, present_dir])]),
2256
 
            ('', [(subdir_key, [present_dir, present_dir, present_dir])]),
2257
 
            ('sub', [(child1_key, [absent, absent, present_file]),
2258
 
                     (child2_key, [absent, absent, present_file]),
2259
 
                     (child3_key, [absent, absent, present_file]),
2260
 
                    ]),
2261
 
        ]
2262
 
        exp_dirblocks = [
2263
 
            ('', [(root_key, [present_dir, present_dir])]),
2264
 
            ('', [(subdir_key, [present_dir, present_dir])]),
2265
 
            ('sub', []),
2266
 
        ]
2267
 
        state = self.create_empty_dirstate()
2268
 
        self.addCleanup(state.unlock)
2269
 
        state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2270
 
        state._validate()
2271
 
 
2272
 
        state._discard_merge_parents()
2273
 
        state._validate()
2274
 
        self.assertEqual(exp_dirblocks, state._dirblocks)
2275
 
 
2276
 
 
2277
 
class Test_InvEntryToDetails(tests.TestCase):
2278
 
 
2279
 
    def assertDetails(self, expected, inv_entry):
2280
 
        details = dirstate.DirState._inv_entry_to_details(inv_entry)
2281
 
        self.assertEqual(expected, details)
2282
 
        # details should always allow join() and always be a plain str when
2283
 
        # finished
2284
 
        (minikind, fingerprint, size, executable, tree_data) = details
2285
 
        self.assertIsInstance(minikind, str)
2286
 
        self.assertIsInstance(fingerprint, str)
2287
 
        self.assertIsInstance(tree_data, str)
2288
 
 
2289
 
    def test_unicode_symlink(self):
2290
 
        inv_entry = inventory.InventoryLink('link-file-id',
2291
 
                                            u'nam\N{Euro Sign}e',
2292
 
                                            'link-parent-id')
2293
 
        inv_entry.revision = 'link-revision-id'
2294
 
        target = u'link-targ\N{Euro Sign}t'
2295
 
        inv_entry.symlink_target = target
2296
 
        self.assertDetails(('l', target.encode('UTF-8'), 0, False,
2297
 
                            'link-revision-id'), inv_entry)
2298
 
 
2299
 
 
2300
 
class TestSHA1Provider(tests.TestCaseInTempDir):
2301
 
 
2302
 
    def test_sha1provider_is_an_interface(self):
2303
 
        p = dirstate.SHA1Provider()
2304
 
        self.assertRaises(NotImplementedError, p.sha1, "foo")
2305
 
        self.assertRaises(NotImplementedError, p.stat_and_sha1, "foo")
2306
 
 
2307
 
    def test_defaultsha1provider_sha1(self):
2308
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
2309
 
        self.build_tree_contents([('foo', text)])
2310
 
        expected_sha = osutils.sha_string(text)
2311
 
        p = dirstate.DefaultSHA1Provider()
2312
 
        self.assertEqual(expected_sha, p.sha1('foo'))
2313
 
 
2314
 
    def test_defaultsha1provider_stat_and_sha1(self):
2315
 
        text = 'test\r\nwith\nall\rpossible line endings\r\n'
2316
 
        self.build_tree_contents([('foo', text)])
2317
 
        expected_sha = osutils.sha_string(text)
2318
 
        p = dirstate.DefaultSHA1Provider()
2319
 
        statvalue, sha1 = p.stat_and_sha1('foo')
2320
 
        self.assertTrue(len(statvalue) >= 10)
2321
 
        self.assertEqual(len(text), statvalue.st_size)
2322
 
        self.assertEqual(expected_sha, sha1)