← 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: Jelmer Vernooij
  • Date: 2009-04-10 15:58:09 UTC
  • mto: This revision was merged to the branch mainline in revision 4284.
  • Revision ID: jelmer@samba.org-20090410155809-kdibzcjvp7pdb83f
Fix missing import.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_dirstate.py
1
 
# Copyright (C) 2006-2011 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
16
16
 
17
17
"""Tests of the dirstate functionality being built for WorkingTreeFormat4."""
18
18
 
 
19
import bisect
19
20
import os
20
 
import tempfile
21
21
 
22
22
from bzrlib import (
23
 
    bzrdir,
24
23
    dirstate,
25
24
    errors,
26
25
    inventory,
27
 
    memorytree,
28
26
    osutils,
29
27
    revision as _mod_revision,
30
 
    revisiontree,
31
 
    tests,
32
 
    workingtree_4,
33
28
    )
34
 
from bzrlib.transport import memory
35
 
from bzrlib.tests import test_osutils
36
 
from bzrlib.tests.scenarios import load_tests_apply_scenarios
 
29
from bzrlib.memorytree import MemoryTree
 
30
from bzrlib.tests import (
 
31
        SymlinkFeature,
 
32
        TestCase,
 
33
        TestCaseInTempDir,
 
34
        TestCaseWithTransport,
 
35
        )
37
36
 
38
37
 
39
38
# TODO:
49
48
# set_path_id  setting id when state is in memory modified
50
49
 
51
50
 
52
 
load_tests = load_tests_apply_scenarios
53
 
 
54
 
 
55
 
class TestCaseWithDirState(tests.TestCaseWithTransport):
 
51
class TestCaseWithDirState(TestCaseWithTransport):
56
52
    """Helper functions for creating DirState objects with various content."""
57
53
 
58
 
    scenarios = test_osutils.dir_reader_scenarios()
59
 
 
60
 
    # Set by load_tests
61
 
    _dir_reader_class = None
62
 
    _native_to_unicode = None # Not used yet
63
 
 
64
 
    def setUp(self):
65
 
        tests.TestCaseWithTransport.setUp(self)
66
 
 
67
 
        self.overrideAttr(osutils,
68
 
                          '_selected_dir_reader', self._dir_reader_class())
69
 
 
70
54
    def create_empty_dirstate(self):
71
55
        """Return a locked but empty dirstate"""
72
56
        state = dirstate.DirState.initialize('dirstate')
413
397
            (('', '', tree.get_root_id()), # common details
414
398
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
415
399
              ('d', '', 0, False, rev_id), # first parent details
416
 
              ('d', '', 0, False, rev_id), # second parent details
 
400
              ('d', '', 0, False, rev_id2), # second parent details
417
401
             ])])
418
402
        state = dirstate.DirState.from_tree(tree, 'dirstate')
419
403
        self.check_state_with_reopen(expected_result, state)
494
478
            (('', '', tree.get_root_id()), # common details
495
479
             [('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
496
480
              ('d', '', 0, False, rev_id), # first parent details
497
 
              ('d', '', 0, False, rev_id), # second parent details
 
481
              ('d', '', 0, False, rev_id2), # second parent details
498
482
             ]),
499
483
            (('', 'a file', 'a-file-id'), # common
500
484
             [('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
532
516
 
533
517
class TestDirStateOnFile(TestCaseWithDirState):
534
518
 
535
 
    def create_updated_dirstate(self):
536
 
        self.build_tree(['a-file'])
537
 
        tree = self.make_branch_and_tree('.')
538
 
        tree.add(['a-file'], ['a-id'])
539
 
        tree.commit('add a-file')
540
 
        # Save and unlock the state, re-open it in readonly mode
541
 
        state = dirstate.DirState.from_tree(tree, 'dirstate')
542
 
        state.save()
543
 
        state.unlock()
544
 
        state = dirstate.DirState.on_file('dirstate')
545
 
        state.lock_read()
546
 
        return state
547
 
 
548
519
    def test_construct_with_path(self):
549
520
        tree = self.make_branch_and_tree('tree')
550
521
        state = dirstate.DirState.from_tree(tree, 'dirstate.from_tree')
579
550
            state.unlock()
580
551
 
581
552
    def test_can_save_in_read_lock(self):
582
 
        state = self.create_updated_dirstate()
 
553
        self.build_tree(['a-file'])
 
554
        state = dirstate.DirState.initialize('dirstate')
 
555
        try:
 
556
            # No stat and no sha1 sum.
 
557
            state.add('a-file', 'a-file-id', 'file', None, '')
 
558
            state.save()
 
559
        finally:
 
560
            state.unlock()
 
561
 
 
562
        # Now open in readonly mode
 
563
        state = dirstate.DirState.on_file('dirstate')
 
564
        state.lock_read()
583
565
        try:
584
566
            entry = state._get_entry(0, path_utf8='a-file')
585
567
            # The current size should be 0 (default)
586
568
            self.assertEqual(0, entry[1][0][2])
587
569
            # We should have a real entry.
588
570
            self.assertNotEqual((None, None), entry)
589
 
            # Set the cutoff-time into the future, so things look cacheable
 
571
            # Make sure everything is old enough
590
572
            state._sha_cutoff_time()
591
 
            state._cutoff_time += 10.0
592
 
            st = os.lstat('a-file')
593
 
            sha1sum = dirstate.update_entry(state, entry, 'a-file', st)
594
 
            # We updated the current sha1sum because the file is cacheable
595
 
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
596
 
                             sha1sum)
 
573
            state._cutoff_time += 10
 
574
            # Change the file length
 
575
            self.build_tree_contents([('a-file', 'shorter')])
 
576
            sha1sum = dirstate.update_entry(state, entry, 'a-file',
 
577
                os.lstat('a-file'))
 
578
            # new file, no cached sha:
 
579
            self.assertEqual(None, sha1sum)
597
580
 
598
581
            # The dirblock has been updated
599
 
            self.assertEqual(st.st_size, entry[1][0][2])
600
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
 
582
            self.assertEqual(7, entry[1][0][2])
 
583
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
601
584
                             state._dirblock_state)
602
585
 
603
586
            del entry
612
595
        state.lock_read()
613
596
        try:
614
597
            entry = state._get_entry(0, path_utf8='a-file')
615
 
            self.assertEqual(st.st_size, entry[1][0][2])
 
598
            self.assertEqual(7, entry[1][0][2])
616
599
        finally:
617
600
            state.unlock()
618
601
 
619
602
    def test_save_fails_quietly_if_locked(self):
620
603
        """If dirstate is locked, save will fail without complaining."""
621
 
        state = self.create_updated_dirstate()
 
604
        self.build_tree(['a-file'])
 
605
        state = dirstate.DirState.initialize('dirstate')
 
606
        try:
 
607
            # No stat and no sha1 sum.
 
608
            state.add('a-file', 'a-file-id', 'file', None, '')
 
609
            state.save()
 
610
        finally:
 
611
            state.unlock()
 
612
 
 
613
        state = dirstate.DirState.on_file('dirstate')
 
614
        state.lock_read()
622
615
        try:
623
616
            entry = state._get_entry(0, path_utf8='a-file')
624
 
            # No cached sha1 yet.
625
 
            self.assertEqual('', entry[1][0][1])
626
 
            # Set the cutoff-time into the future, so things look cacheable
627
 
            state._sha_cutoff_time()
628
 
            state._cutoff_time += 10.0
629
 
            st = os.lstat('a-file')
630
 
            sha1sum = dirstate.update_entry(state, entry, 'a-file', st)
631
 
            self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
632
 
                             sha1sum)
633
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
 
617
            sha1sum = dirstate.update_entry(state, entry, 'a-file',
 
618
                os.lstat('a-file'))
 
619
            # No sha - too new
 
620
            self.assertEqual(None, sha1sum)
 
621
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
634
622
                             state._dirblock_state)
635
623
 
636
624
            # Now, before we try to save, grab another dirstate, and take out a
726
714
 
727
715
class TestDirStateManipulations(TestCaseWithDirState):
728
716
 
729
 
    def make_minimal_tree(self):
730
 
        tree1 = self.make_branch_and_memory_tree('tree1')
731
 
        tree1.lock_write()
732
 
        self.addCleanup(tree1.unlock)
733
 
        tree1.add('')
734
 
        revid1 = tree1.commit('foo')
735
 
        return tree1, revid1
736
 
 
737
 
    def test_update_minimal_updates_id_index(self):
738
 
        state = self.create_dirstate_with_root_and_subdir()
739
 
        self.addCleanup(state.unlock)
740
 
        id_index = state._get_id_index()
741
 
        self.assertEqual(['a-root-value', 'subdir-id'], sorted(id_index))
742
 
        state.add('file-name', 'file-id', 'file', None, '')
743
 
        self.assertEqual(['a-root-value', 'file-id', 'subdir-id'],
744
 
                         sorted(id_index))
745
 
        state.update_minimal(('', 'new-name', 'file-id'), 'f',
746
 
                             path_utf8='new-name')
747
 
        self.assertEqual(['a-root-value', 'file-id', 'subdir-id'],
748
 
                         sorted(id_index))
749
 
        self.assertEqual([('', 'new-name', 'file-id')],
750
 
                         sorted(id_index['file-id']))
751
 
        state._validate()
752
 
 
753
717
    def test_set_state_from_inventory_no_content_no_parents(self):
754
718
        # setting the current inventory is a slow but important api to support.
755
 
        tree1, revid1 = self.make_minimal_tree()
756
 
        inv = tree1.inventory
757
 
        root_id = inv.path2id('')
 
719
        tree1 = self.make_branch_and_memory_tree('tree1')
 
720
        tree1.lock_write()
 
721
        try:
 
722
            tree1.add('')
 
723
            revid1 = tree1.commit('foo').encode('utf8')
 
724
            root_id = tree1.get_root_id()
 
725
            inv = tree1.inventory
 
726
        finally:
 
727
            tree1.unlock()
758
728
        expected_result = [], [
759
729
            (('', '', root_id), [
760
730
             ('d', '', 0, False, dirstate.DirState.NULLSTAT)])]
772
742
            # This will unlock it
773
743
            self.check_state_with_reopen(expected_result, state)
774
744
 
775
 
    def test_set_state_from_scratch_no_parents(self):
776
 
        tree1, revid1 = self.make_minimal_tree()
777
 
        inv = tree1.inventory
778
 
        root_id = inv.path2id('')
779
 
        expected_result = [], [
780
 
            (('', '', root_id), [
781
 
             ('d', '', 0, False, dirstate.DirState.NULLSTAT)])]
782
 
        state = dirstate.DirState.initialize('dirstate')
783
 
        try:
784
 
            state.set_state_from_scratch(inv, [], [])
785
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
786
 
                             state._header_state)
787
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
788
 
                             state._dirblock_state)
789
 
        except:
790
 
            state.unlock()
791
 
            raise
792
 
        else:
793
 
            # This will unlock it
794
 
            self.check_state_with_reopen(expected_result, state)
795
 
 
796
 
    def test_set_state_from_scratch_identical_parent(self):
797
 
        tree1, revid1 = self.make_minimal_tree()
798
 
        inv = tree1.inventory
799
 
        root_id = inv.path2id('')
800
 
        rev_tree1 = tree1.branch.repository.revision_tree(revid1)
801
 
        d_entry = ('d', '', 0, False, dirstate.DirState.NULLSTAT)
802
 
        parent_entry = ('d', '', 0, False, revid1)
803
 
        expected_result = [revid1], [
804
 
            (('', '', root_id), [d_entry, parent_entry])]
805
 
        state = dirstate.DirState.initialize('dirstate')
806
 
        try:
807
 
            state.set_state_from_scratch(inv, [(revid1, rev_tree1)], [])
808
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
809
 
                             state._header_state)
810
 
            self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
811
 
                             state._dirblock_state)
812
 
        except:
813
 
            state.unlock()
814
 
            raise
815
 
        else:
816
 
            # This will unlock it
817
 
            self.check_state_with_reopen(expected_result, state)
818
 
 
819
745
    def test_set_state_from_inventory_preserves_hashcache(self):
820
746
        # https://bugs.launchpad.net/bzr/+bug/146176
821
747
        # set_state_from_inventory should preserve the stat and hash value for
879
805
        finally:
880
806
            tree.unlock()
881
807
 
 
808
 
882
809
    def test_set_state_from_inventory_mixed_paths(self):
883
810
        tree1 = self.make_branch_and_tree('tree1')
884
811
        self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
925
852
        state = dirstate.DirState.initialize('dirstate')
926
853
        try:
927
854
            # check precondition to be sure the state does change appropriately.
928
 
            root_entry = (('', '', 'TREE_ROOT'), [('d', '', 0, False, 'x'*32)])
929
 
            self.assertEqual([root_entry], list(state._iter_entries()))
930
 
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
931
 
            self.assertEqual(root_entry,
932
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
933
 
            self.assertEqual((None, None),
934
 
                             state._get_entry(0, fileid_utf8='second-root-id'))
935
 
            state.set_path_id('', 'second-root-id')
936
 
            new_root_entry = (('', '', 'second-root-id'),
937
 
                              [('d', '', 0, False, 'x'*32)])
938
 
            expected_rows = [new_root_entry]
 
855
            self.assertEqual(
 
856
                [(('', '', 'TREE_ROOT'), [('d', '', 0, False,
 
857
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])],
 
858
                list(state._iter_entries()))
 
859
            state.set_path_id('', 'foobarbaz')
 
860
            expected_rows = [
 
861
                (('', '', 'foobarbaz'), [('d', '', 0, False,
 
862
                   'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])]
939
863
            self.assertEqual(expected_rows, list(state._iter_entries()))
940
 
            self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
941
 
            self.assertEqual(new_root_entry, 
942
 
                             state._get_entry(0, fileid_utf8='second-root-id'))
943
 
            self.assertEqual((None, None),
944
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
945
864
            # should work across save too
946
865
            state.save()
947
866
        finally:
965
884
        state._validate()
966
885
        try:
967
886
            state.set_parent_trees([('parent-revid', rt)], ghosts=[])
968
 
            root_entry = (('', '', 'TREE_ROOT'),
969
 
                          [('d', '', 0, False, 'x'*32),
970
 
                           ('d', '', 0, False, 'parent-revid')])
971
 
            self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
972
 
            self.assertEqual(root_entry,
973
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
974
 
            self.assertEqual((None, None),
975
 
                             state._get_entry(0, fileid_utf8='Asecond-root-id'))
976
 
            state.set_path_id('', 'Asecond-root-id')
 
887
            state.set_path_id('', 'foobarbaz')
977
888
            state._validate()
978
889
            # now see that it is what we expected
979
 
            old_root_entry = (('', '', 'TREE_ROOT'),
980
 
                              [('a', '', 0, False, ''),
981
 
                               ('d', '', 0, False, 'parent-revid')])
982
 
            new_root_entry = (('', '', 'Asecond-root-id'),
983
 
                              [('d', '', 0, False, ''),
984
 
                               ('a', '', 0, False, '')])
985
 
            expected_rows = [new_root_entry, old_root_entry]
 
890
            expected_rows = [
 
891
                (('', '', 'TREE_ROOT'),
 
892
                    [('a', '', 0, False, ''),
 
893
                     ('d', '', 0, False, 'parent-revid'),
 
894
                     ]),
 
895
                (('', '', 'foobarbaz'),
 
896
                    [('d', '', 0, False, ''),
 
897
                     ('a', '', 0, False, ''),
 
898
                     ]),
 
899
                ]
986
900
            state._validate()
987
901
            self.assertEqual(expected_rows, list(state._iter_entries()))
988
 
            self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
989
 
            self.assertEqual(old_root_entry, state._get_entry(1, path_utf8=''))
990
 
            self.assertEqual((None, None),
991
 
                             state._get_entry(0, fileid_utf8='TREE_ROOT'))
992
 
            self.assertEqual(old_root_entry,
993
 
                             state._get_entry(1, fileid_utf8='TREE_ROOT'))
994
 
            self.assertEqual(new_root_entry,
995
 
                             state._get_entry(0, fileid_utf8='Asecond-root-id'))
996
 
            self.assertEqual((None, None),
997
 
                             state._get_entry(1, fileid_utf8='Asecond-root-id'))
998
902
            # should work across save too
999
903
            state.save()
1000
904
        finally:
1016
920
        finally:
1017
921
            state.unlock()
1018
922
 
 
923
 
1019
924
    def test_set_parent_trees_no_content(self):
1020
925
        # set_parent_trees is a slow but important api to support.
1021
926
        tree1 = self.make_branch_and_memory_tree('tree1')
1026
931
        finally:
1027
932
            tree1.unlock()
1028
933
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1029
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
934
        tree2 = MemoryTree.create_on_branch(branch2)
1030
935
        tree2.lock_write()
1031
936
        try:
1032
937
            revid2 = tree2.commit('foo')
1075
980
                [(('', '', root_id), [
1076
981
                  ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1077
982
                  ('d', '', 0, False, revid1),
1078
 
                  ('d', '', 0, False, revid1)
 
983
                  ('d', '', 0, False, revid2)
1079
984
                  ])],
1080
985
                list(state._iter_entries()))
1081
986
        finally:
1096
1001
        finally:
1097
1002
            tree1.unlock()
1098
1003
        branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1099
 
        tree2 = memorytree.MemoryTree.create_on_branch(branch2)
 
1004
        tree2 = MemoryTree.create_on_branch(branch2)
1100
1005
        tree2.lock_write()
1101
1006
        try:
1102
1007
            tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1109
1014
            (('', '', root_id), [
1110
1015
             ('d', '', 0, False, dirstate.DirState.NULLSTAT),
1111
1016
             ('d', '', 0, False, revid1.encode('utf8')),
1112
 
             ('d', '', 0, False, revid1.encode('utf8'))
 
1017
             ('d', '', 0, False, revid2.encode('utf8'))
1113
1018
             ]),
1114
1019
            (('', 'a file', 'file-id'), [
1115
1020
             ('a', '', 0, False, ''),
1161
1066
            state.unlock()
1162
1067
        state = dirstate.DirState.on_file('dirstate')
1163
1068
        state.lock_read()
1164
 
        self.addCleanup(state.unlock)
1165
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1069
        try:
 
1070
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1071
        finally:
 
1072
            state.unlock()
1166
1073
 
1167
1074
    def test_add_path_to_unversioned_directory(self):
1168
1075
        """Adding a path to an unversioned directory should error.
1173
1080
        """
1174
1081
        self.build_tree(['unversioned/', 'unversioned/a file'])
1175
1082
        state = dirstate.DirState.initialize('dirstate')
1176
 
        self.addCleanup(state.unlock)
1177
 
        self.assertRaises(errors.NotVersionedError, state.add,
1178
 
                          'unversioned/a file', 'a-file-id', 'file', None, None)
 
1083
        try:
 
1084
            self.assertRaises(errors.NotVersionedError, state.add,
 
1085
                'unversioned/a file', 'a-file-id', 'file', None, None)
 
1086
        finally:
 
1087
            state.unlock()
1179
1088
 
1180
1089
    def test_add_directory_to_root_no_parents_all_data(self):
1181
1090
        # The most trivial addition of a dir is when there are no parents and
1201
1110
            state.unlock()
1202
1111
        state = dirstate.DirState.on_file('dirstate')
1203
1112
        state.lock_read()
1204
 
        self.addCleanup(state.unlock)
1205
1113
        state._validate()
1206
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1114
        try:
 
1115
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1116
        finally:
 
1117
            state.unlock()
1207
1118
 
1208
 
    def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
 
1119
    def test_add_symlink_to_root_no_parents_all_data(self):
1209
1120
        # The most trivial addition of a symlink when there are no parents and
1210
1121
        # its in the root and all data about the file is supplied
1211
1122
        # bzr doesn't support fake symlinks on windows, yet.
1212
 
        self.requireFeature(tests.SymlinkFeature)
1213
 
        os.symlink(target, link_name)
1214
 
        stat = os.lstat(link_name)
 
1123
        self.requireFeature(SymlinkFeature)
 
1124
        os.symlink('target', 'a link')
 
1125
        stat = os.lstat('a link')
1215
1126
        expected_entries = [
1216
1127
            (('', '', 'TREE_ROOT'), [
1217
1128
             ('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1218
1129
             ]),
1219
 
            (('', link_name.encode('UTF-8'), 'a link id'), [
1220
 
             ('l', target.encode('UTF-8'), stat[6],
1221
 
              False, dirstate.pack_stat(stat)), # current tree
 
1130
            (('', 'a link', 'a link id'), [
 
1131
             ('l', 'target', 6, False, dirstate.pack_stat(stat)), # current tree
1222
1132
             ]),
1223
1133
            ]
1224
1134
        state = dirstate.DirState.initialize('dirstate')
1225
1135
        try:
1226
 
            state.add(link_name, 'a link id', 'symlink', stat,
1227
 
                      target.encode('UTF-8'))
 
1136
            state.add('a link', 'a link id', 'symlink', stat, 'target')
1228
1137
            # having added it, it should be in the output of iter_entries.
1229
1138
            self.assertEqual(expected_entries, list(state._iter_entries()))
1230
1139
            # saving and reloading should not affect this.
1233
1142
            state.unlock()
1234
1143
        state = dirstate.DirState.on_file('dirstate')
1235
1144
        state.lock_read()
1236
 
        self.addCleanup(state.unlock)
1237
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
1238
 
 
1239
 
    def test_add_symlink_to_root_no_parents_all_data(self):
1240
 
        self._test_add_symlink_to_root_no_parents_all_data('a link', 'target')
1241
 
 
1242
 
    def test_add_symlink_unicode_to_root_no_parents_all_data(self):
1243
 
        self.requireFeature(tests.UnicodeFilenameFeature)
1244
 
        self._test_add_symlink_to_root_no_parents_all_data(
1245
 
            u'\N{Euro Sign}link', u'targ\N{Euro Sign}et')
 
1145
        try:
 
1146
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1147
        finally:
 
1148
            state.unlock()
1246
1149
 
1247
1150
    def test_add_directory_and_child_no_parents_all_data(self):
1248
1151
        # after adding a directory, we should be able to add children to it.
1273
1176
            state.unlock()
1274
1177
        state = dirstate.DirState.on_file('dirstate')
1275
1178
        state.lock_read()
1276
 
        self.addCleanup(state.unlock)
1277
 
        self.assertEqual(expected_entries, list(state._iter_entries()))
 
1179
        try:
 
1180
            self.assertEqual(expected_entries, list(state._iter_entries()))
 
1181
        finally:
 
1182
            state.unlock()
1278
1183
 
1279
1184
    def test_add_tree_reference(self):
1280
1185
        # make a dirstate and add a tree reference
1294
1199
            state.unlock()
1295
1200
        # now check we can read it back
1296
1201
        state.lock_read()
1297
 
        self.addCleanup(state.unlock)
1298
1202
        state._validate()
1299
 
        entry2 = state._get_entry(0, 'subdir-id', 'subdir')
1300
 
        self.assertEqual(entry, entry2)
1301
 
        self.assertEqual(entry, expected_entry)
1302
 
        # and lookup by id should work too
1303
 
        entry2 = state._get_entry(0, fileid_utf8='subdir-id')
1304
 
        self.assertEqual(entry, expected_entry)
 
1203
        try:
 
1204
            entry2 = state._get_entry(0, 'subdir-id', 'subdir')
 
1205
            self.assertEqual(entry, entry2)
 
1206
            self.assertEqual(entry, expected_entry)
 
1207
            # and lookup by id should work too
 
1208
            entry2 = state._get_entry(0, fileid_utf8='subdir-id')
 
1209
            self.assertEqual(entry, expected_entry)
 
1210
        finally:
 
1211
            state.unlock()
1305
1212
 
1306
1213
    def test_add_forbidden_names(self):
1307
1214
        state = dirstate.DirState.initialize('dirstate')
1311
1218
        self.assertRaises(errors.BzrError,
1312
1219
            state.add, '..', 'ass-id', 'directory', None, None)
1313
1220
 
1314
 
    def test_set_state_with_rename_b_a_bug_395556(self):
1315
 
        # bug 395556 uncovered a bug where the dirstate ends up with a false
1316
 
        # relocation record - in a tree with no parents there should be no
1317
 
        # absent or relocated records. This then leads to further corruption
1318
 
        # when a commit occurs, as the incorrect relocation gathers an
1319
 
        # incorrect absent in tree 1, and future changes go to pot.
1320
 
        tree1 = self.make_branch_and_tree('tree1')
1321
 
        self.build_tree(['tree1/b'])
1322
 
        tree1.lock_write()
1323
 
        try:
1324
 
            tree1.add(['b'], ['b-id'])
1325
 
            root_id = tree1.get_root_id()
1326
 
            inv = tree1.inventory
1327
 
            state = dirstate.DirState.initialize('dirstate')
1328
 
            try:
1329
 
                # Set the initial state with 'b'
1330
 
                state.set_state_from_inventory(inv)
1331
 
                inv.rename('b-id', root_id, 'a')
1332
 
                # Set the new state with 'a', which currently corrupts.
1333
 
                state.set_state_from_inventory(inv)
1334
 
                expected_result1 = [('', '', root_id, 'd'),
1335
 
                                    ('', 'a', 'b-id', 'f'),
1336
 
                                   ]
1337
 
                values = []
1338
 
                for entry in state._iter_entries():
1339
 
                    values.append(entry[0] + entry[1][0][:1])
1340
 
                self.assertEqual(expected_result1, values)
1341
 
            finally:
1342
 
                state.unlock()
1343
 
        finally:
1344
 
            tree1.unlock()
1345
 
 
1346
 
 
1347
 
class TestDirStateHashUpdates(TestCaseWithDirState):
1348
 
 
1349
 
    def do_update_entry(self, state, path):
1350
 
        entry = state._get_entry(0, path_utf8=path)
1351
 
        stat = os.lstat(path)
1352
 
        return dirstate.update_entry(state, entry, os.path.abspath(path), stat)
1353
 
 
1354
 
    def _read_state_content(self, state):
1355
 
        """Read the content of the dirstate file.
1356
 
 
1357
 
        On Windows when one process locks a file, you can't even open() the
1358
 
        file in another process (to read it). So we go directly to
1359
 
        state._state_file. This should always be the exact disk representation,
1360
 
        so it is reasonable to do so.
1361
 
        DirState also always seeks before reading, so it doesn't matter if we
1362
 
        bump the file pointer.
1363
 
        """
1364
 
        state._state_file.seek(0)
1365
 
        return state._state_file.read()
1366
 
 
1367
 
    def test_worth_saving_limit_avoids_writing(self):
1368
 
        tree = self.make_branch_and_tree('.')
1369
 
        self.build_tree(['c', 'd'])
1370
 
        tree.lock_write()
1371
 
        tree.add(['c', 'd'], ['c-id', 'd-id'])
1372
 
        tree.commit('add c and d')
1373
 
        state = InstrumentedDirState.on_file(tree.current_dirstate()._filename,
1374
 
                                             worth_saving_limit=2)
1375
 
        tree.unlock()
1376
 
        state.lock_write()
1377
 
        self.addCleanup(state.unlock)
1378
 
        state._read_dirblocks_if_needed()
1379
 
        state.adjust_time(+20) # Allow things to be cached
1380
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1381
 
                         state._dirblock_state)
1382
 
        content = self._read_state_content(state)
1383
 
        self.do_update_entry(state, 'c')
1384
 
        self.assertEqual(1, len(state._known_hash_changes))
1385
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
1386
 
                         state._dirblock_state)
1387
 
        state.save()
1388
 
        # It should not have set the state to IN_MEMORY_UNMODIFIED because the
1389
 
        # hash values haven't been written out.
1390
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
1391
 
                         state._dirblock_state)
1392
 
        self.assertEqual(content, self._read_state_content(state))
1393
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
1394
 
                         state._dirblock_state)
1395
 
        self.do_update_entry(state, 'd')
1396
 
        self.assertEqual(2, len(state._known_hash_changes))
1397
 
        state.save()
1398
 
        self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1399
 
                         state._dirblock_state)
1400
 
        self.assertEqual(0, len(state._known_hash_changes))
1401
 
 
1402
1221
 
1403
1222
class TestGetLines(TestCaseWithDirState):
1404
1223
 
1733
1552
            list(state._iter_child_entries(1, '')))
1734
1553
 
1735
1554
 
1736
 
class TestDirstateSortOrder(tests.TestCaseWithTransport):
 
1555
class TestDirstateSortOrder(TestCaseWithTransport):
1737
1556
    """Test that DirState adds entries in the right order."""
1738
1557
 
1739
1558
    def test_add_sorting(self):
1798
1617
class InstrumentedDirState(dirstate.DirState):
1799
1618
    """An DirState with instrumented sha1 functionality."""
1800
1619
 
1801
 
    def __init__(self, path, sha1_provider, worth_saving_limit=0):
1802
 
        super(InstrumentedDirState, self).__init__(path, sha1_provider,
1803
 
            worth_saving_limit=worth_saving_limit)
 
1620
    def __init__(self, path, sha1_provider):
 
1621
        super(InstrumentedDirState, self).__init__(path, sha1_provider)
1804
1622
        self._time_offset = 0
1805
1623
        self._log = []
1806
1624
        # member is dynamically set in DirState.__init__ to turn on trace
1856
1674
            st.st_ino, st.st_mode)
1857
1675
 
1858
1676
 
1859
 
class TestPackStat(tests.TestCaseWithTransport):
 
1677
class TestPackStat(TestCaseWithTransport):
1860
1678
 
1861
1679
    def assertPackStat(self, expected, stat_value):
1862
1680
        """Check the packed and serialized form of a stat value."""
2389
2207
        self.assertEqual(exp_dirblocks, state._dirblocks)
2390
2208
 
2391
2209
 
2392
 
class Test_InvEntryToDetails(tests.TestCase):
 
2210
class Test_InvEntryToDetails(TestCaseWithDirState):
2393
2211
 
2394
2212
    def assertDetails(self, expected, inv_entry):
2395
2213
        details = dirstate.DirState._inv_entry_to_details(inv_entry)
2402
2220
        self.assertIsInstance(tree_data, str)
2403
2221
 
2404
2222
    def test_unicode_symlink(self):
2405
 
        inv_entry = inventory.InventoryLink('link-file-id',
2406
 
                                            u'nam\N{Euro Sign}e',
 
2223
        # In general, the code base doesn't support a target that contains
 
2224
        # non-ascii characters. So we just assert tha
 
2225
        inv_entry = inventory.InventoryLink('link-file-id', 'name',
2407
2226
                                            'link-parent-id')
2408
2227
        inv_entry.revision = 'link-revision-id'
2409
 
        target = u'link-targ\N{Euro Sign}t'
2410
 
        inv_entry.symlink_target = target
2411
 
        self.assertDetails(('l', target.encode('UTF-8'), 0, False,
2412
 
                            'link-revision-id'), inv_entry)
2413
 
 
2414
 
 
2415
 
class TestSHA1Provider(tests.TestCaseInTempDir):
 
2228
        inv_entry.symlink_target = u'link-target'
 
2229
        details = self.assertDetails(('l', 'link-target', 0, False,
 
2230
                                      'link-revision-id'), inv_entry)
 
2231
 
 
2232
 
 
2233
class TestSHA1Provider(TestCaseInTempDir):
2416
2234
 
2417
2235
    def test_sha1provider_is_an_interface(self):
2418
2236
        p = dirstate.SHA1Provider()
2435
2253
        self.assertTrue(len(statvalue) >= 10)
2436
2254
        self.assertEqual(len(text), statvalue.st_size)
2437
2255
        self.assertEqual(expected_sha, sha1)
2438
 
 
2439
 
 
2440
 
class _Repo(object):
2441
 
    """A minimal api to get InventoryRevisionTree to work."""
2442
 
 
2443
 
    def __init__(self):
2444
 
        default_format = bzrdir.format_registry.make_bzrdir('default')
2445
 
        self._format = default_format.repository_format
2446
 
 
2447
 
    def lock_read(self):
2448
 
        pass
2449
 
 
2450
 
    def unlock(self):
2451
 
        pass
2452
 
 
2453
 
 
2454
 
class TestUpdateBasisByDelta(tests.TestCase):
2455
 
 
2456
 
    def path_to_ie(self, path, file_id, rev_id, dir_ids):
2457
 
        if path.endswith('/'):
2458
 
            is_dir = True
2459
 
            path = path[:-1]
2460
 
        else:
2461
 
            is_dir = False
2462
 
        dirname, basename = osutils.split(path)
2463
 
        try:
2464
 
            dir_id = dir_ids[dirname]
2465
 
        except KeyError:
2466
 
            dir_id = osutils.basename(dirname) + '-id'
2467
 
        if is_dir:
2468
 
            ie = inventory.InventoryDirectory(file_id, basename, dir_id)
2469
 
            dir_ids[path] = file_id
2470
 
        else:
2471
 
            ie = inventory.InventoryFile(file_id, basename, dir_id)
2472
 
            ie.text_size = 0
2473
 
            ie.text_sha1 = ''
2474
 
        ie.revision = rev_id
2475
 
        return ie
2476
 
 
2477
 
    def create_tree_from_shape(self, rev_id, shape):
2478
 
        dir_ids = {'': 'root-id'}
2479
 
        inv = inventory.Inventory('root-id', rev_id)
2480
 
        for path, file_id in shape:
2481
 
            if path == '':
2482
 
                # Replace the root entry
2483
 
                del inv._byid[inv.root.file_id]
2484
 
                inv.root.file_id = file_id
2485
 
                inv._byid[file_id] = inv.root
2486
 
                dir_ids[''] = file_id
2487
 
                continue
2488
 
            inv.add(self.path_to_ie(path, file_id, rev_id, dir_ids))
2489
 
        return revisiontree.InventoryRevisionTree(_Repo(), inv, rev_id)
2490
 
 
2491
 
    def create_empty_dirstate(self):
2492
 
        fd, path = tempfile.mkstemp(prefix='bzr-dirstate')
2493
 
        self.addCleanup(os.remove, path)
2494
 
        os.close(fd)
2495
 
        state = dirstate.DirState.initialize(path)
2496
 
        self.addCleanup(state.unlock)
2497
 
        return state
2498
 
 
2499
 
    def create_inv_delta(self, delta, rev_id):
2500
 
        """Translate a 'delta shape' into an actual InventoryDelta"""
2501
 
        dir_ids = {'': 'root-id'}
2502
 
        inv_delta = []
2503
 
        for old_path, new_path, file_id in delta:
2504
 
            if old_path is not None and old_path.endswith('/'):
2505
 
                # Don't have to actually do anything for this, because only
2506
 
                # new_path creates InventoryEntries
2507
 
                old_path = old_path[:-1]
2508
 
            if new_path is None: # Delete
2509
 
                inv_delta.append((old_path, None, file_id, None))
2510
 
                continue
2511
 
            ie = self.path_to_ie(new_path, file_id, rev_id, dir_ids)
2512
 
            inv_delta.append((old_path, new_path, file_id, ie))
2513
 
        return inv_delta
2514
 
 
2515
 
    def assertUpdate(self, active, basis, target):
2516
 
        """Assert that update_basis_by_delta works how we want.
2517
 
 
2518
 
        Set up a DirState object with active_shape for tree 0, basis_shape for
2519
 
        tree 1. Then apply the delta from basis_shape to target_shape,
2520
 
        and assert that the DirState is still valid, and that its stored
2521
 
        content matches the target_shape.
2522
 
        """
2523
 
        active_tree = self.create_tree_from_shape('active', active)
2524
 
        basis_tree = self.create_tree_from_shape('basis', basis)
2525
 
        target_tree = self.create_tree_from_shape('target', target)
2526
 
        state = self.create_empty_dirstate()
2527
 
        state.set_state_from_scratch(active_tree.inventory,
2528
 
            [('basis', basis_tree)], [])
2529
 
        delta = target_tree.inventory._make_delta(basis_tree.inventory)
2530
 
        state.update_basis_by_delta(delta, 'target')
2531
 
        state._validate()
2532
 
        dirstate_tree = workingtree_4.DirStateRevisionTree(state,
2533
 
            'target', _Repo())
2534
 
        # The target now that delta has been applied should match the
2535
 
        # RevisionTree
2536
 
        self.assertEqual([], list(dirstate_tree.iter_changes(target_tree)))
2537
 
        # And the dirblock state should be identical to the state if we created
2538
 
        # it from scratch.
2539
 
        state2 = self.create_empty_dirstate()
2540
 
        state2.set_state_from_scratch(active_tree.inventory,
2541
 
            [('target', target_tree)], [])
2542
 
        self.assertEqual(state2._dirblocks, state._dirblocks)
2543
 
        return state
2544
 
 
2545
 
    def assertBadDelta(self, active, basis, delta):
2546
 
        """Test that we raise InconsistentDelta when appropriate.
2547
 
 
2548
 
        :param active: The active tree shape
2549
 
        :param basis: The basis tree shape
2550
 
        :param delta: A description of the delta to apply. Similar to the form
2551
 
            for regular inventory deltas, but omitting the InventoryEntry.
2552
 
            So adding a file is: (None, 'path', 'file-id')
2553
 
            Adding a directory is: (None, 'path/', 'dir-id')
2554
 
            Renaming a dir is: ('old/', 'new/', 'dir-id')
2555
 
            etc.
2556
 
        """
2557
 
        active_tree = self.create_tree_from_shape('active', active)
2558
 
        basis_tree = self.create_tree_from_shape('basis', basis)
2559
 
        inv_delta = self.create_inv_delta(delta, 'target')
2560
 
        state = self.create_empty_dirstate()
2561
 
        state.set_state_from_scratch(active_tree.inventory,
2562
 
            [('basis', basis_tree)], [])
2563
 
        self.assertRaises(errors.InconsistentDelta,
2564
 
            state.update_basis_by_delta, inv_delta, 'target')
2565
 
        ## try:
2566
 
        ##     state.update_basis_by_delta(inv_delta, 'target')
2567
 
        ## except errors.InconsistentDelta, e:
2568
 
        ##     import pdb; pdb.set_trace()
2569
 
        ## else:
2570
 
        ##     import pdb; pdb.set_trace()
2571
 
        self.assertTrue(state._changes_aborted)
2572
 
 
2573
 
    def test_remove_file_matching_active_state(self):
2574
 
        state = self.assertUpdate(
2575
 
            active=[],
2576
 
            basis =[('file', 'file-id')],
2577
 
            target=[],
2578
 
            )
2579
 
 
2580
 
    def test_remove_file_present_in_active_state(self):
2581
 
        state = self.assertUpdate(
2582
 
            active=[('file', 'file-id')],
2583
 
            basis =[('file', 'file-id')],
2584
 
            target=[],
2585
 
            )
2586
 
 
2587
 
    def test_remove_file_present_elsewhere_in_active_state(self):
2588
 
        state = self.assertUpdate(
2589
 
            active=[('other-file', 'file-id')],
2590
 
            basis =[('file', 'file-id')],
2591
 
            target=[],
2592
 
            )
2593
 
 
2594
 
    def test_remove_file_active_state_has_diff_file(self):
2595
 
        state = self.assertUpdate(
2596
 
            active=[('file', 'file-id-2')],
2597
 
            basis =[('file', 'file-id')],
2598
 
            target=[],
2599
 
            )
2600
 
 
2601
 
    def test_remove_file_active_state_has_diff_file_and_file_elsewhere(self):
2602
 
        state = self.assertUpdate(
2603
 
            active=[('file', 'file-id-2'),
2604
 
                    ('other-file', 'file-id')],
2605
 
            basis =[('file', 'file-id')],
2606
 
            target=[],
2607
 
            )
2608
 
 
2609
 
    def test_add_file_matching_active_state(self):
2610
 
        state = self.assertUpdate(
2611
 
            active=[('file', 'file-id')],
2612
 
            basis =[],
2613
 
            target=[('file', 'file-id')],
2614
 
            )
2615
 
 
2616
 
    def test_add_file_missing_in_active_state(self):
2617
 
        state = self.assertUpdate(
2618
 
            active=[],
2619
 
            basis =[],
2620
 
            target=[('file', 'file-id')],
2621
 
            )
2622
 
 
2623
 
    def test_add_file_elsewhere_in_active_state(self):
2624
 
        state = self.assertUpdate(
2625
 
            active=[('other-file', 'file-id')],
2626
 
            basis =[],
2627
 
            target=[('file', 'file-id')],
2628
 
            )
2629
 
 
2630
 
    def test_add_file_active_state_has_diff_file_and_file_elsewhere(self):
2631
 
        state = self.assertUpdate(
2632
 
            active=[('other-file', 'file-id'),
2633
 
                    ('file', 'file-id-2')],
2634
 
            basis =[],
2635
 
            target=[('file', 'file-id')],
2636
 
            )
2637
 
 
2638
 
    def test_rename_file_matching_active_state(self):
2639
 
        state = self.assertUpdate(
2640
 
            active=[('other-file', 'file-id')],
2641
 
            basis =[('file', 'file-id')],
2642
 
            target=[('other-file', 'file-id')],
2643
 
            )
2644
 
 
2645
 
    def test_rename_file_missing_in_active_state(self):
2646
 
        state = self.assertUpdate(
2647
 
            active=[],
2648
 
            basis =[('file', 'file-id')],
2649
 
            target=[('other-file', 'file-id')],
2650
 
            )
2651
 
 
2652
 
    def test_rename_file_present_elsewhere_in_active_state(self):
2653
 
        state = self.assertUpdate(
2654
 
            active=[('third', 'file-id')],
2655
 
            basis =[('file', 'file-id')],
2656
 
            target=[('other-file', 'file-id')],
2657
 
            )
2658
 
 
2659
 
    def test_rename_file_active_state_has_diff_source_file(self):
2660
 
        state = self.assertUpdate(
2661
 
            active=[('file', 'file-id-2')],
2662
 
            basis =[('file', 'file-id')],
2663
 
            target=[('other-file', 'file-id')],
2664
 
            )
2665
 
 
2666
 
    def test_rename_file_active_state_has_diff_target_file(self):
2667
 
        state = self.assertUpdate(
2668
 
            active=[('other-file', 'file-id-2')],
2669
 
            basis =[('file', 'file-id')],
2670
 
            target=[('other-file', 'file-id')],
2671
 
            )
2672
 
 
2673
 
    def test_rename_file_active_has_swapped_files(self):
2674
 
        state = self.assertUpdate(
2675
 
            active=[('file', 'file-id'),
2676
 
                    ('other-file', 'file-id-2')],
2677
 
            basis= [('file', 'file-id'),
2678
 
                    ('other-file', 'file-id-2')],
2679
 
            target=[('file', 'file-id-2'),
2680
 
                    ('other-file', 'file-id')])
2681
 
 
2682
 
    def test_rename_file_basis_has_swapped_files(self):
2683
 
        state = self.assertUpdate(
2684
 
            active=[('file', 'file-id'),
2685
 
                    ('other-file', 'file-id-2')],
2686
 
            basis= [('file', 'file-id-2'),
2687
 
                    ('other-file', 'file-id')],
2688
 
            target=[('file', 'file-id'),
2689
 
                    ('other-file', 'file-id-2')])
2690
 
 
2691
 
    def test_rename_directory_with_contents(self):
2692
 
        state = self.assertUpdate( # active matches basis
2693
 
            active=[('dir1/', 'dir-id'),
2694
 
                    ('dir1/file', 'file-id')],
2695
 
            basis= [('dir1/', 'dir-id'),
2696
 
                    ('dir1/file', 'file-id')],
2697
 
            target=[('dir2/', 'dir-id'),
2698
 
                    ('dir2/file', 'file-id')])
2699
 
        state = self.assertUpdate( # active matches target
2700
 
            active=[('dir2/', 'dir-id'),
2701
 
                    ('dir2/file', 'file-id')],
2702
 
            basis= [('dir1/', 'dir-id'),
2703
 
                    ('dir1/file', 'file-id')],
2704
 
            target=[('dir2/', 'dir-id'),
2705
 
                    ('dir2/file', 'file-id')])
2706
 
        state = self.assertUpdate( # active empty
2707
 
            active=[],
2708
 
            basis= [('dir1/', 'dir-id'),
2709
 
                    ('dir1/file', 'file-id')],
2710
 
            target=[('dir2/', 'dir-id'),
2711
 
                    ('dir2/file', 'file-id')])
2712
 
        state = self.assertUpdate( # active present at other location
2713
 
            active=[('dir3/', 'dir-id'),
2714
 
                    ('dir3/file', 'file-id')],
2715
 
            basis= [('dir1/', 'dir-id'),
2716
 
                    ('dir1/file', 'file-id')],
2717
 
            target=[('dir2/', 'dir-id'),
2718
 
                    ('dir2/file', 'file-id')])
2719
 
        state = self.assertUpdate( # active has different ids
2720
 
            active=[('dir1/', 'dir1-id'),
2721
 
                    ('dir1/file', 'file1-id'),
2722
 
                    ('dir2/', 'dir2-id'),
2723
 
                    ('dir2/file', 'file2-id')],
2724
 
            basis= [('dir1/', 'dir-id'),
2725
 
                    ('dir1/file', 'file-id')],
2726
 
            target=[('dir2/', 'dir-id'),
2727
 
                    ('dir2/file', 'file-id')])
2728
 
 
2729
 
    def test_invalid_file_not_present(self):
2730
 
        state = self.assertBadDelta(
2731
 
            active=[('file', 'file-id')],
2732
 
            basis= [('file', 'file-id')],
2733
 
            delta=[('other-file', 'file', 'file-id')])
2734
 
 
2735
 
    def test_invalid_new_id_same_path(self):
2736
 
        # The bad entry comes after
2737
 
        state = self.assertBadDelta(
2738
 
            active=[('file', 'file-id')],
2739
 
            basis= [('file', 'file-id')],
2740
 
            delta=[(None, 'file', 'file-id-2')])
2741
 
        # The bad entry comes first
2742
 
        state = self.assertBadDelta(
2743
 
            active=[('file', 'file-id-2')],
2744
 
            basis=[('file', 'file-id-2')],
2745
 
            delta=[(None, 'file', 'file-id')])
2746
 
 
2747
 
    def test_invalid_existing_id(self):
2748
 
        state = self.assertBadDelta(
2749
 
            active=[('file', 'file-id')],
2750
 
            basis= [('file', 'file-id')],
2751
 
            delta=[(None, 'file', 'file-id')])
2752
 
 
2753
 
    def test_invalid_parent_missing(self):
2754
 
        state = self.assertBadDelta(
2755
 
            active=[],
2756
 
            basis= [],
2757
 
            delta=[(None, 'path/path2', 'file-id')])
2758
 
        # Note: we force the active tree to have the directory, by knowing how
2759
 
        #       path_to_ie handles entries with missing parents
2760
 
        state = self.assertBadDelta(
2761
 
            active=[('path/', 'path-id')],
2762
 
            basis= [],
2763
 
            delta=[(None, 'path/path2', 'file-id')])
2764
 
        state = self.assertBadDelta(
2765
 
            active=[('path/', 'path-id'),
2766
 
                    ('path/path2', 'file-id')],
2767
 
            basis= [],
2768
 
            delta=[(None, 'path/path2', 'file-id')])
2769
 
 
2770
 
    def test_renamed_dir_same_path(self):
2771
 
        # We replace the parent directory, with another parent dir. But the C
2772
 
        # file doesn't look like it has been moved.
2773
 
        state = self.assertUpdate(# Same as basis
2774
 
            active=[('dir/', 'A-id'),
2775
 
                    ('dir/B', 'B-id')],
2776
 
            basis= [('dir/', 'A-id'),
2777
 
                    ('dir/B', 'B-id')],
2778
 
            target=[('dir/', 'C-id'),
2779
 
                    ('dir/B', 'B-id')])
2780
 
        state = self.assertUpdate(# Same as target
2781
 
            active=[('dir/', 'C-id'),
2782
 
                    ('dir/B', 'B-id')],
2783
 
            basis= [('dir/', 'A-id'),
2784
 
                    ('dir/B', 'B-id')],
2785
 
            target=[('dir/', 'C-id'),
2786
 
                    ('dir/B', 'B-id')])
2787
 
        state = self.assertUpdate(# empty active
2788
 
            active=[],
2789
 
            basis= [('dir/', 'A-id'),
2790
 
                    ('dir/B', 'B-id')],
2791
 
            target=[('dir/', 'C-id'),
2792
 
                    ('dir/B', 'B-id')])
2793
 
        state = self.assertUpdate(# different active
2794
 
            active=[('dir/', 'D-id'),
2795
 
                    ('dir/B', 'B-id')],
2796
 
            basis= [('dir/', 'A-id'),
2797
 
                    ('dir/B', 'B-id')],
2798
 
            target=[('dir/', 'C-id'),
2799
 
                    ('dir/B', 'B-id')])
2800
 
 
2801
 
    def test_parent_child_swap(self):
2802
 
        state = self.assertUpdate(# Same as basis
2803
 
            active=[('A/', 'A-id'),
2804
 
                    ('A/B/', 'B-id'),
2805
 
                    ('A/B/C', 'C-id')],
2806
 
            basis= [('A/', 'A-id'),
2807
 
                    ('A/B/', 'B-id'),
2808
 
                    ('A/B/C', 'C-id')],
2809
 
            target=[('A/', 'B-id'),
2810
 
                    ('A/B/', 'A-id'),
2811
 
                    ('A/B/C', 'C-id')])
2812
 
        state = self.assertUpdate(# Same as target
2813
 
            active=[('A/', 'B-id'),
2814
 
                    ('A/B/', 'A-id'),
2815
 
                    ('A/B/C', 'C-id')],
2816
 
            basis= [('A/', 'A-id'),
2817
 
                    ('A/B/', 'B-id'),
2818
 
                    ('A/B/C', 'C-id')],
2819
 
            target=[('A/', 'B-id'),
2820
 
                    ('A/B/', 'A-id'),
2821
 
                    ('A/B/C', 'C-id')])
2822
 
        state = self.assertUpdate(# empty active
2823
 
            active=[],
2824
 
            basis= [('A/', 'A-id'),
2825
 
                    ('A/B/', 'B-id'),
2826
 
                    ('A/B/C', 'C-id')],
2827
 
            target=[('A/', 'B-id'),
2828
 
                    ('A/B/', 'A-id'),
2829
 
                    ('A/B/C', 'C-id')])
2830
 
        state = self.assertUpdate(# different active
2831
 
            active=[('D/', 'A-id'),
2832
 
                    ('D/E/', 'B-id'),
2833
 
                    ('F', 'C-id')],
2834
 
            basis= [('A/', 'A-id'),
2835
 
                    ('A/B/', 'B-id'),
2836
 
                    ('A/B/C', 'C-id')],
2837
 
            target=[('A/', 'B-id'),
2838
 
                    ('A/B/', 'A-id'),
2839
 
                    ('A/B/C', 'C-id')])
2840
 
 
2841
 
    def test_change_root_id(self):
2842
 
        state = self.assertUpdate( # same as basis
2843
 
            active=[('', 'root-id'),
2844
 
                    ('file', 'file-id')],
2845
 
            basis= [('', 'root-id'),
2846
 
                    ('file', 'file-id')],
2847
 
            target=[('', 'target-root-id'),
2848
 
                    ('file', 'file-id')])
2849
 
        state = self.assertUpdate( # same as target
2850
 
            active=[('', 'target-root-id'),
2851
 
                    ('file', 'file-id')],
2852
 
            basis= [('', 'root-id'),
2853
 
                    ('file', 'file-id')],
2854
 
            target=[('', 'target-root-id'),
2855
 
                    ('file', 'root-id')])
2856
 
        state = self.assertUpdate( # all different
2857
 
            active=[('', 'active-root-id'),
2858
 
                    ('file', 'file-id')],
2859
 
            basis= [('', 'root-id'),
2860
 
                    ('file', 'file-id')],
2861
 
            target=[('', 'target-root-id'),
2862
 
                    ('file', 'root-id')])
2863
 
 
2864
 
    def test_change_file_absent_in_active(self):
2865
 
        state = self.assertUpdate(
2866
 
            active=[],
2867
 
            basis= [('file', 'file-id')],
2868
 
            target=[('file', 'file-id')])
2869
 
 
2870
 
    def test_invalid_changed_file(self):
2871
 
        state = self.assertBadDelta( # Not present in basis
2872
 
            active=[('file', 'file-id')],
2873
 
            basis= [],
2874
 
            delta=[('file', 'file', 'file-id')])
2875
 
        state = self.assertBadDelta( # present at another location in basis
2876
 
            active=[('file', 'file-id')],
2877
 
            basis= [('other-file', 'file-id')],
2878
 
            delta=[('file', 'file', 'file-id')])