/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/intertree_implementations/test_compare.py

Add minimal test for Tree.compare(extra_trees=...).

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/intertree_implementations/test_compare.py
32
32
        self.assertEqual([], d.modified)
33
33
        self.assertEqual([], d.removed)
34
34
        self.assertEqual([], d.renamed)
 
35
        self.assertEqual([], d.unchanged)
35
36
 
36
37
    def test_empty_to_abc_content(self):
37
38
        tree1 = self.make_branch_and_tree('1')
46
47
        self.assertEqual([], d.modified)
47
48
        self.assertEqual([], d.removed)
48
49
        self.assertEqual([], d.renamed)
 
50
        self.assertEqual([], d.unchanged)
49
51
 
50
52
    def test_abc_content_to_empty(self):
51
53
        tree1 = self.make_branch_and_tree('1')
60
62
                          ('b/c', 'c-id', 'file'),
61
63
                         ], d.removed)
62
64
        self.assertEqual([], d.renamed)
 
65
        self.assertEqual([], d.unchanged)
63
66
 
64
67
    def test_content_modification(self):
65
68
        tree1 = self.make_branch_and_tree('1')
71
74
        self.assertEqual([('a', 'a-id', 'file', True, False)], d.modified)
72
75
        self.assertEqual([], d.removed)
73
76
        self.assertEqual([], d.renamed)
 
77
        self.assertEqual([], d.unchanged)
74
78
        
75
79
    def test_meta_modification(self):
76
80
        tree1 = self.make_branch_and_tree('1')
82
86
        self.assertEqual([('b/c', 'c-id', 'file', False, True)], d.modified)
83
87
        self.assertEqual([], d.removed)
84
88
        self.assertEqual([], d.renamed)
 
89
        self.assertEqual([], d.unchanged)
85
90
 
86
91
    def test_file_rename(self):
87
92
        tree1 = self.make_branch_and_tree('1')
93
98
        self.assertEqual([], d.modified)
94
99
        self.assertEqual([], d.removed)
95
100
        self.assertEqual([('a', 'd', 'a-id', 'file', False, False)], d.renamed)
 
101
        self.assertEqual([], d.unchanged)
96
102
 
97
103
    def test_file_rename_and_modification(self):
98
104
        tree1 = self.make_branch_and_tree('1')
104
110
        self.assertEqual([], d.modified)
105
111
        self.assertEqual([], d.removed)
106
112
        self.assertEqual([('a', 'd', 'a-id', 'file', True, False)], d.renamed)
 
113
        self.assertEqual([], d.unchanged)
107
114
 
108
115
    def test_file_rename_and_meta_modification(self):
109
116
        tree1 = self.make_branch_and_tree('1')
115
122
        self.assertEqual([], d.modified)
116
123
        self.assertEqual([], d.removed)
117
124
        self.assertEqual([('b/c', 'e', 'c-id', 'file', False, True)], d.renamed)
 
125
        self.assertEqual([], d.unchanged)
118
126
 
119
127
    def test_empty_to_abc_content_a_only(self):
120
128
        tree1 = self.make_branch_and_tree('1')
126
134
        self.assertEqual([], d.modified)
127
135
        self.assertEqual([], d.removed)
128
136
        self.assertEqual([], d.renamed)
 
137
        self.assertEqual([], d.unchanged)
129
138
 
130
139
    def test_empty_to_abc_content_a_and_c_only(self):
131
140
        tree1 = self.make_branch_and_tree('1')
140
149
        self.assertEqual([], d.modified)
141
150
        self.assertEqual([], d.removed)
142
151
        self.assertEqual([], d.renamed)
 
152
        self.assertEqual([], d.unchanged)
143
153
 
144
154
    def test_empty_to_abc_content_b_only(self):
145
155
        """Restricting to a dir matches the children of the dir."""
154
164
        self.assertEqual([], d.modified)
155
165
        self.assertEqual([], d.removed)
156
166
        self.assertEqual([], d.renamed)
 
167
        self.assertEqual([], d.unchanged)
 
168
 
 
169
    def test_unchanged_with_renames_and_modifications(self):
 
170
        """want_unchanged should generate a list of unchanged entries."""
 
171
        tree1 = self.make_branch_and_tree('1')
 
172
        tree2 = self.make_to_branch_and_tree('2')
 
173
        tree1 = self.get_tree_no_parents_abc_content(tree1)
 
174
        tree2 = self.get_to_tree_no_parents_abc_content_5(tree2)
 
175
        d = self.intertree_class(tree1, tree2).compare(want_unchanged=True)
 
176
        self.assertEqual([], d.added)
 
177
        self.assertEqual([], d.modified)
 
178
        self.assertEqual([], d.removed)
 
179
        self.assertEqual([('a', 'd', 'a-id', 'file', True, False)], d.renamed)
 
180
        self.assertEqual(
 
181
            [(u'b', 'b-id', 'directory'), (u'b/c', 'c-id', 'file')],
 
182
            d.unchanged)
 
183
 
 
184
    def test_extra_trees_finds_ids(self):
 
185
        """Ask for a delta between two trees with a path present in a third."""
 
186
        tree1 = self.make_branch_and_tree('1')
 
187
        tree2 = self.make_to_branch_and_tree('2')
 
188
        tree1 = self.get_tree_no_parents_abc_content(tree1)
 
189
        tree2 = self.get_to_tree_no_parents_abc_content_3(tree2)
 
190
        # the type of tree-3 does not matter - it is used as a lookup, not
 
191
        # a dispatch
 
192
        tree3 = self.make_branch_and_tree('3')
 
193
        tree3 = self.get_tree_no_parents_abc_content_6(tree3)
 
194
        # tree 3 has 'e' which is 'c-id'. Tree 1 has c-id at b/c, and Tree 2
 
195
        # has c-id at b/c with its exec flag toggled.
 
196
        # without extra_trees, we should get no modifications from this
 
197
        # so do one, to be sure the test is valid.
 
198
        d = self.intertree_class(tree1, tree2).compare(
 
199
            specific_files=['e'])
 
200
        self.assertEqual([], d.modified)
 
201
        # now give it an additional lookup:
 
202
        d = self.intertree_class(tree1, tree2).compare(
 
203
            specific_files=['e'], extra_trees=[tree3])
 
204
        self.assertEqual([], d.added)
 
205
        self.assertEqual([('b/c', 'c-id', 'file', False, True)], d.modified)
 
206
        self.assertEqual([], d.removed)
 
207
        self.assertEqual([], d.renamed)
 
208
        self.assertEqual([], d.unchanged)