← 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: Andrew Bennetts
  • Date: 2009-04-02 05:53:12 UTC
  • mto: This revision was merged to the branch mainline in revision 4242.
  • Revision ID: andrew.bennetts@canonical.com-20090402055312-h7mvgumvm7e620mj
Fix nits in spelling and naming.

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