← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_fileid_involved.py

first cut at merge from integration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_fileid_involved.py
17
17
import os
18
18
 
19
19
from bzrlib.add import smart_add
 
20
from bzrlib.branch import Branch
20
21
from bzrlib.builtins import merge
21
 
from bzrlib.errors import IllegalPath
 
22
from bzrlib.clone import copy_branch
22
23
from bzrlib.delta import compare_trees
23
 
from bzrlib.tests import TestSkipped
24
 
from bzrlib.tests.repository_implementations.test_repository import TestCaseWithRepository
 
24
from bzrlib.fetch import greedy_fetch
 
25
from bzrlib.merge import merge_inner
 
26
from bzrlib.revision import common_ancestor
 
27
from bzrlib.tests import TestCaseWithTransport
25
28
from bzrlib.workingtree import WorkingTree
26
29
 
27
30
 
28
 
class FileIdInvolvedBase(TestCaseWithRepository):
 
31
class TestFileIdInvolved(TestCaseWithTransport):
29
32
 
30
33
    def touch(self,filename):
31
34
        f = file(filename,"a")
32
35
        f.write("appended line\n")
33
36
        f.close( )
34
37
 
35
 
    def compare_tree_fileids(self, branch, old_rev, new_rev):
36
 
        old_tree = self.branch.repository.revision_tree(old_rev)
37
 
        new_tree = self.branch.repository.revision_tree(new_rev)
38
 
        delta = compare_trees(old_tree, new_tree)
39
 
 
40
 
        l2 = [id for path, id, kind in delta.added] + \
41
 
             [id for oldpath, newpath, id, kind, text_modified, \
42
 
                meta_modified in delta.renamed] + \
43
 
             [id for path, id, kind, text_modified, meta_modified in \
44
 
                delta.modified]
45
 
        return set(l2)
46
 
 
47
 
    
48
 
class TestFileIdInvolved(FileIdInvolvedBase):
 
38
    def merge(self, branch_from, wt_to):
 
39
        # minimal ui-less merge.
 
40
        greedy_fetch(to_branch=wt_to.branch, from_branch=branch_from,
 
41
                     revision=branch_from.last_revision())
 
42
        base_rev = common_ancestor(branch_from.last_revision(),
 
43
                                    wt_to.branch.last_revision(),
 
44
                                    wt_to.branch.repository)
 
45
        merge_inner(wt_to.branch, branch_from.working_tree(), 
 
46
                    wt_to.branch.repository.revision_tree(base_rev),
 
47
                    this_tree=wt_to)
 
48
        wt_to.add_pending_merge(branch_from.last_revision())
49
49
 
50
50
    def setUp(self):
51
51
        super(TestFileIdInvolved, self).setUp()
57
57
        #  \           /      /
58
58
        #   \---> E---/----> F                 (branch1)
59
59
 
60
 
        # A changes: 
61
 
        # B changes: 'a-file-id-2006-01-01-abcd'
62
 
        # C changes:  Nothing (perfect merge)
63
 
        # D changes: 'b-file-id-2006-01-01-defg'
64
 
        # E changes: 'file-d'
65
 
        # F changes: 'file-d'
66
 
        # G changes: 'b-file-id-2006-01-01-defg'
67
 
        # J changes: 'b-file-id-2006-01-01-defg'
68
 
        # K changes: 'c-funky<file-id> quiji%bo'
69
 
 
70
60
        main_wt = self.make_branch_and_tree('main')
71
61
        main_branch = main_wt.branch
72
62
        self.build_tree(["main/a","main/b","main/c"])
74
64
        main_wt.add(['a', 'b', 'c'], ['a-file-id-2006-01-01-abcd',
75
65
                                 'b-file-id-2006-01-01-defg',
76
66
                                 'c-funky<file-id> quiji%bo'])
77
 
        try:
78
 
            main_wt.commit("Commit one", rev_id="rev-A")
79
 
        except IllegalPath:
80
 
            # ("File-id with <> not supported with this format")
81
 
            # this is not a skip because newer formats do support this,
82
 
            # and nothin can done to correct this test - its not a bug.
83
 
            return
 
67
        main_wt.commit("Commit one", rev_id="rev-A")
84
68
        #-------- end A -----------
85
69
 
86
 
        d1 = main_branch.bzrdir.clone('branch1')
87
 
        b1 = d1.open_branch()
 
70
        b1 = main_branch.clone("branch1")
88
71
        self.build_tree(["branch1/d"])
89
 
        bt1 = d1.open_workingtree()
90
 
        bt1.add(['d'], ['file-d'])
91
 
        bt1.commit("branch1, Commit one", rev_id="rev-E")
 
72
        b1.working_tree().add('d')
 
73
        b1.working_tree().commit("branch1, Commit one", rev_id="rev-E")
92
74
 
93
75
        #-------- end E -----------
94
76
 
97
79
 
98
80
        #-------- end B -----------
99
81
 
100
 
        d2 = main_branch.bzrdir.clone('branch2')
101
 
        branch2_branch = d2.open_branch()
102
 
        bt2 = d2.open_workingtree()
 
82
        branch2_branch = main_branch.clone("branch2")
103
83
        os.chmod("branch2/b",0770)
104
 
        bt2.commit("branch2, Commit one", rev_id="rev-J")
 
84
        branch2_branch.working_tree().commit("branch2, Commit one", 
 
85
                                             rev_id="rev-J")
105
86
 
106
87
        #-------- end J -----------
107
88
 
110
91
 
111
92
        #-------- end C -----------
112
93
 
113
 
        bt1.rename_one("d","e")
114
 
        bt1.commit("branch1, commit two", rev_id="rev-F")
 
94
        tree = WorkingTree('branch1', b1)
 
95
        tree.rename_one("d","e")
 
96
        tree.commit("branch1, commit two", rev_id="rev-F")
115
97
 
116
98
        #-------- end F -----------
117
99
 
118
100
        self.touch("branch2/c")
119
 
        bt2.commit("branch2, commit two", rev_id="rev-K")
 
101
        branch2_branch.working_tree().commit("branch2, commit two", rev_id="rev-K")
120
102
 
121
103
        #-------- end K -----------
122
104
 
133
115
        # end G
134
116
        self.branch = main_branch
135
117
 
136
 
    def test_fileids_altered_between_two_revs(self):
137
 
        def foo(old, new):
138
 
            print set(self.branch.repository.get_ancestry(new)).difference(set(self.branch.repository.get_ancestry(old)))
139
 
 
140
 
        self.assertEqual(
141
 
            {'b-file-id-2006-01-01-defg':set(['rev-J']),
142
 
             'c-funky<file-id> quiji%bo':set(['rev-K'])
143
 
             },
144
 
            self.branch.repository.fileids_altered_by_revision_ids(["rev-J","rev-K"]))
145
 
 
146
 
        self.assertEqual(
147
 
            {'b-file-id-2006-01-01-defg': set(['rev-<D>']),
148
 
             'file-d': set(['rev-F']),
149
 
             },
150
 
            self.branch.repository.fileids_altered_by_revision_ids(['rev-<D>', 'rev-F']))
151
 
 
152
 
        self.assertEqual(
153
 
            {
154
 
             'b-file-id-2006-01-01-defg': set(['rev-<D>', 'rev-G', 'rev-J']), 
155
 
             'c-funky<file-id> quiji%bo': set(['rev-K']),
156
 
             'file-d': set(['rev-F']), 
157
 
             },
158
 
            self.branch.repository.fileids_altered_by_revision_ids(
159
 
                ['rev-<D>', 'rev-G', 'rev-F', 'rev-K', 'rev-J']))
160
 
 
161
 
        self.assertEqual(
162
 
            {'a-file-id-2006-01-01-abcd': set(['rev-B']),
163
 
             'b-file-id-2006-01-01-defg': set(['rev-<D>', 'rev-G', 'rev-J']),
164
 
             'c-funky<file-id> quiji%bo': set(['rev-K']),
165
 
             'file-d': set(['rev-F']),
166
 
             },
167
 
            self.branch.repository.fileids_altered_by_revision_ids(
168
 
                ['rev-G', 'rev-F', 'rev-C', 'rev-B', 'rev-<D>', 'rev-K', 'rev-J']))
169
 
 
170
 
    def test_fileids_altered_by_revision_ids(self):
171
 
        self.assertEqual(
172
 
            {'a-file-id-2006-01-01-abcd':set(['rev-A']),
173
 
             'b-file-id-2006-01-01-defg': set(['rev-A']),
174
 
             'c-funky<file-id> quiji%bo': set(['rev-A']),
175
 
             }, 
176
 
            self.branch.repository.fileids_altered_by_revision_ids(["rev-A"]))
177
 
        self.assertEqual(
178
 
            {'a-file-id-2006-01-01-abcd':set(['rev-B'])
179
 
             }, 
180
 
            self.branch.repository.fileids_altered_by_revision_ids(["rev-B"]))
181
 
        self.assertEqual(
182
 
            {'b-file-id-2006-01-01-defg':set(['rev-<D>'])
183
 
             },
184
 
            self.branch.repository.fileids_altered_by_revision_ids(["rev-<D>"]))
185
 
 
186
 
    def test_fileids_involved_full_compare(self):
187
 
        # this tests that the result of each fileid_involved calculation 
188
 
        # along a revision history selects only the fileids selected by
189
 
        # comparing the trees - no less, and no more. This is correct 
190
 
        # because in our sample data we do not revert any file ids along
191
 
        # the revision history.
 
118
 
 
119
    def test_fileid_involved_all_revs(self):
 
120
 
 
121
        l = self.branch.fileid_involved( )
 
122
        self.assertEquals( sorted(map( lambda x: x[0], l )), ["a","b","c","d"])
 
123
 
 
124
    def test_fileid_involved_one_rev(self):
 
125
 
 
126
        l = self.branch.fileid_involved("rev-B" )
 
127
        self.assertEquals( sorted(map( lambda x: x[0], l )), ["a","b","c"])
 
128
 
 
129
    def test_fileid_involved_two_revs(self):
 
130
 
 
131
        l = self.branch.fileid_involved_between_revs("rev-B","rev-K" )
 
132
        self.assertEquals( sorted(map( lambda x: x[0], l )), ["b","c"])
 
133
 
 
134
        l = self.branch.fileid_involved_between_revs("rev-C","rev-<D>" )
 
135
        self.assertEquals( sorted(map( lambda x: x[0], l )), ["b","d"])
 
136
 
 
137
        l = self.branch.fileid_involved_between_revs("rev-C","rev-G" )
 
138
        self.assertEquals( sorted(map( lambda x: x[0], l )), ["b","c","d"])
 
139
 
 
140
        l = self.branch.fileid_involved_between_revs("rev-E","rev-G" )
 
141
        self.assertEquals( sorted(map( lambda x: x[0], l )), ["a", "b","c","d"])
 
142
 
 
143
    def test_fileid_involved_sets(self):
 
144
 
 
145
        l = self.branch.fileid_involved_by_set(set(["rev-B"]))
 
146
        self.assertEquals( sorted(map( lambda x: x[0], l )), ["a"])
 
147
 
 
148
        l = self.branch.fileid_involved_by_set(set(["rev-<D>"]))
 
149
        self.assertEquals( sorted(map( lambda x: x[0], l )), ["b"])
 
150
 
 
151
    def test_fileid_involved_compare(self):
 
152
 
 
153
        l1 = self.branch.fileid_involved_between_revs("rev-E", "rev-<D>")
 
154
        l2 = self.branch.fileid_involved_by_set(set(["rev-<D>","rev-F","rev-C","rev-B"]))
 
155
        self.assertEquals( l1, l2 )
 
156
 
 
157
        l1 = self.branch.fileid_involved_between_revs("rev-C", "rev-G")
 
158
        l2 = self.branch.fileid_involved_by_set(
 
159
            set(["rev-G","rev-<D>","rev-F","rev-K","rev-J"]))
 
160
        self.assertEquals( l1, l2 )
 
161
 
 
162
    def test_fileid_involved_full_compare(self):
 
163
        from bzrlib.tsort import topo_sort
192
164
        pp=[]
193
165
        history = self.branch.revision_history( )
194
166
 
195
167
        if len(history) < 2: return
196
168
 
197
169
        for start in range(0,len(history)-1):
198
 
            start_id = history[start]
199
170
            for end in range(start+1,len(history)):
200
 
                end_id = history[end]
201
 
                old_revs = set(self.branch.repository.get_ancestry(start_id))
202
 
                new_revs = set(self.branch.repository.get_ancestry(end_id))
203
 
                l1 = self.branch.repository.fileids_altered_by_revision_ids(
204
 
                    new_revs.difference(old_revs))
205
 
                l1 = set(l1.keys())
206
 
 
207
 
                l2 = self.compare_tree_fileids(self.branch, start_id, end_id)
208
 
                self.assertEquals(l1, l2)
209
 
 
210
 
 
211
 
class TestFileIdInvolvedSuperset(FileIdInvolvedBase):
212
 
 
213
 
    def setUp(self):
214
 
        super(TestFileIdInvolvedSuperset, self).setUp()
215
 
 
216
 
        main_wt = self.make_branch_and_tree('main')
217
 
        main_branch = main_wt.branch
218
 
        self.build_tree(["main/a","main/b","main/c"])
219
 
 
220
 
        main_wt.add(['a', 'b', 'c'], ['a-file-id-2006-01-01-abcd',
221
 
                                 'b-file-id-2006-01-01-defg',
222
 
                                 'c-funky<file-id> quiji%bo'])
223
 
        try:
224
 
            main_wt.commit("Commit one", rev_id="rev-A")
225
 
        except IllegalPath: 
226
 
            return # not an error, and not fixable. New formats are fixed.
227
 
 
228
 
        branch2_bzrdir = main_branch.bzrdir.sprout("branch2")
229
 
        branch2_branch = branch2_bzrdir.open_branch()
230
 
        branch2_wt = branch2_bzrdir.open_workingtree()
231
 
        os.chmod("branch2/b",0770)
232
 
        branch2_wt.commit("branch2, Commit one", rev_id="rev-J")
233
 
 
234
 
        self.merge(branch2_branch, main_wt)
235
 
        os.chmod("main/b",0660)
236
 
        main_wt.commit("merge branch1, rev-22",  rev_id="rev-G")
237
 
 
238
 
        # end G
239
 
        self.branch = main_branch
240
 
 
241
 
    def test_fileid_involved_full_compare2(self):
242
 
        # this tests that fileids_alteted_by_revision_ids returns 
243
 
        # more information than compare_tree can, because it 
244
 
        # sees each change rather than the aggregate delta.
245
 
        history = self.branch.revision_history()
246
 
        old_rev = history[0]
247
 
        new_rev = history[1]
248
 
        old_revs = set(self.branch.repository.get_ancestry(old_rev))
249
 
        new_revs = set(self.branch.repository.get_ancestry(new_rev))
250
 
 
251
 
        l1 = self.branch.repository.fileids_altered_by_revision_ids(
252
 
            new_revs.difference(old_revs))
253
 
        l1 = set(l1.keys())
254
 
 
255
 
        l2 = self.compare_tree_fileids(self.branch, old_rev, new_rev)
256
 
        self.assertNotEqual(l2, l1)
257
 
        self.assertSubset(l2, l1)
 
171
 
 
172
                l1 = self.branch.fileid_involved_between_revs(
 
173
                    history[start], history[end])
 
174
 
 
175
                old_tree = self.branch.repository.revision_tree(history[start])
 
176
                new_tree = self.branch.repository.revision_tree(history[end])
 
177
                delta = compare_trees(old_tree, new_tree )
 
178
 
 
179
                l2 = [id for path, id, kind in delta.added] + \
 
180
                     [id for oldpath, newpath, id, kind, text_modified, \
 
181
                        meta_modified in delta.renamed] + \
 
182
                     [id for path, id, kind, text_modified, meta_modified in \
 
183
                        delta.modified]
 
184
 
 
185
                self.assertEquals(l1, set(l2))
 
186
 
 
187