← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

Change the use of run_bzr to run_bzr_captured in blackbox tests - inspired by David Clymers patch to change run_bzr usage to runbzr

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testrevision.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
 
18
 
import os
19
 
 
20
17
from bzrlib.selftest import TestCaseInTempDir
21
 
from bzrlib.branch import Branch
22
 
from bzrlib.commit import commit
23
 
from bzrlib.fetch import fetch
24
 
from bzrlib.revision import (find_present_ancestors, combined_graph,
25
 
                             is_ancestor, MultipleRevisionSources)
26
 
from bzrlib.trace import mutter
27
 
from bzrlib.errors import NoSuchRevision
 
18
 
28
19
 
29
20
def make_branches():
30
 
    """Create two branches
31
 
 
32
 
    branch 1 has 6 commits, branch 2 has 3 commits
33
 
    commit 10 was a psuedo merge from branch 1
34
 
    but has been disabled until ghost support is
35
 
    implemented.
36
 
 
37
 
    the object graph is
38
 
    B:     A:
39
 
    a..0   a..0 
40
 
    a..1   a..1
41
 
    a..2   a..2
42
 
    b..3   a..3 merges b..4
43
 
    b..4   a..4
44
 
    b..5   a..5 merges b..5
45
 
    b..6 merges a4
46
 
 
47
 
    so A is missing b6 at the start
48
 
    and B is missing a3, a4, a5
49
 
    """
 
21
    from bzrlib.branch import Branch
 
22
    from bzrlib.commit import commit
 
23
    import os
50
24
    os.mkdir("branch1")
51
25
    br1 = Branch.initialize("branch1")
52
26
    
60
34
    commit(br2, "Commit four", rev_id="b@u-0-3")
61
35
    commit(br2, "Commit five", rev_id="b@u-0-4")
62
36
    revisions_2 = br2.revision_history()
63
 
    
64
 
    fetch(from_branch=br2, to_branch=br1)
65
37
    br1.add_pending_merge(revisions_2[4])
66
 
    assert revisions_2[4] == 'b@u-0-4'
67
38
    commit(br1, "Commit six", rev_id="a@u-0-3")
68
39
    commit(br1, "Commit seven", rev_id="a@u-0-4")
69
40
    commit(br2, "Commit eight", rev_id="b@u-0-5")
70
 
    
71
 
    fetch(from_branch=br2, to_branch=br1)
72
41
    br1.add_pending_merge(br2.revision_history()[5])
73
42
    commit(br1, "Commit nine", rev_id="a@u-0-5")
74
 
    # DO NOT FETCH HERE - we WANT a GHOST.
75
 
    #fetch(from_branch=br1, to_branch=br2)
76
43
    br2.add_pending_merge(br1.revision_history()[4])
77
 
    commit(br2, "Commit ten - ghost merge", rev_id="b@u-0-6")
78
 
    
 
44
    commit(br2, "Commit ten", rev_id="b@u-0-6")
79
45
    return br1, br2
80
46
 
81
47
 
82
48
class TestIsAncestor(TestCaseInTempDir):
83
 
    def test_recorded_ancestry(self):
84
 
        """Test that commit records all ancestors"""
85
 
        br1, br2 = make_branches()
86
 
        d = [('a@u-0-0', ['a@u-0-0']),
87
 
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
88
 
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
89
 
             ('b@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3']),
90
 
             ('b@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3',
91
 
                          'b@u-0-4']),
92
 
             ('a@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
93
 
                          'a@u-0-3']),
94
 
             ('a@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
95
 
                          'a@u-0-3', 'a@u-0-4']),
96
 
             ('b@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
97
 
                          'b@u-0-5']),
98
 
             ('a@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',
99
 
                          'b@u-0-3', 'b@u-0-4',
100
 
                          'b@u-0-5', 'a@u-0-5']),
101
 
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2',
102
 
                          'b@u-0-3', 'b@u-0-4',
103
 
                          'b@u-0-5', 'b@u-0-6']),
104
 
             ]
105
 
        br1_only = ('a@u-0-3', 'a@u-0-4', 'a@u-0-5')
106
 
        br2_only = ('b@u-0-6',)
107
 
        for branch in br1, br2:
108
 
            for rev_id, anc in d:
109
 
                if rev_id in br1_only and not branch is br1:
110
 
                    continue
111
 
                if rev_id in br2_only and not branch is br2:
112
 
                    continue
113
 
                mutter('ancestry of {%s}: %r',
114
 
                       rev_id, branch.get_ancestry(rev_id))
115
 
                self.assertEquals(sorted(branch.get_ancestry(rev_id)),
116
 
                                  [None] + sorted(anc))
117
 
    
118
 
    
119
49
    def test_is_ancestor(self):
120
50
        """Test checking whether a revision is an ancestor of another revision"""
 
51
        from bzrlib.revision import is_ancestor, MultipleRevisionSources
 
52
        from bzrlib.errors import NoSuchRevision
121
53
        br1, br2 = make_branches()
122
54
        revisions = br1.revision_history()
123
55
        revisions_2 = br2.revision_history()
124
 
        sources = br1
 
56
        sources = MultipleRevisionSources(br1, br2)
125
57
 
126
 
        assert is_ancestor(revisions[0], revisions[0], br1)
 
58
        assert is_ancestor(revisions[0], revisions[0], sources)
127
59
        assert is_ancestor(revisions[1], revisions[0], sources)
128
60
        assert not is_ancestor(revisions[0], revisions[1], sources)
129
61
        assert is_ancestor(revisions_2[3], revisions[0], sources)
130
 
        # disabled mbp 20050914, doesn't seem to happen anymore
131
 
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
132
 
        ##                  revisions[0], br1)        
 
62
        self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
 
63
                          revisions[0], br1)        
133
64
        assert is_ancestor(revisions[3], revisions_2[4], sources)
134
65
        assert is_ancestor(revisions[3], revisions_2[4], br1)
135
66
        assert is_ancestor(revisions[3], revisions_2[3], sources)
136
 
        ## assert not is_ancestor(revisions[3], revisions_2[3], br1)
137
 
 
138
 
 
139
 
class TestIntermediateRevisions(TestCaseInTempDir):
140
 
 
141
 
    def setUp(self):
142
 
        from bzrlib.commit import commit
143
 
        TestCaseInTempDir.setUp(self)
144
 
        self.br1, self.br2 = make_branches()
145
 
 
146
 
        self.br2.commit("Commit eleven", rev_id="b@u-0-7")
147
 
        self.br2.commit("Commit twelve", rev_id="b@u-0-8")
148
 
        self.br2.commit("Commit thirtteen", rev_id="b@u-0-9")
149
 
 
150
 
        fetch(from_branch=self.br2, to_branch=self.br1)
151
 
        self.br1.add_pending_merge(self.br2.revision_history()[6])
152
 
        self.br1.commit("Commit fourtten", rev_id="a@u-0-6")
153
 
 
154
 
        fetch(from_branch=self.br1, to_branch=self.br2)
155
 
        self.br2.add_pending_merge(self.br1.revision_history()[6])
156
 
        self.br2.commit("Commit fifteen", rev_id="b@u-0-10")
157
 
 
158
 
        from bzrlib.revision import MultipleRevisionSources
159
 
        self.sources = MultipleRevisionSources(self.br1, self.br2)
160
 
 
161
 
    def intervene(self, ancestor, revision, revision_history=None):
162
 
        from bzrlib.revision import get_intervening_revisions
163
 
        return get_intervening_revisions(ancestor,revision, self.sources, 
164
 
                                         revision_history)
165
 
 
166
 
    def test_intervene(self):
167
 
        """Find intermediate revisions, without requiring history"""
168
 
        from bzrlib.errors import NotAncestor, NoSuchRevision
169
 
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
170
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
171
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
172
 
                         ['a@u-0-1', 'a@u-0-2'])
173
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
174
 
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
175
 
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
176
 
                         ['b@u-0-4', 'a@u-0-3'])
177
 
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
178
 
                                        self.br1.revision_history()), 
179
 
                         ['a@u-0-3'])
180
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
181
 
                                        self.br1.revision_history()), 
182
 
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
183
 
                          'a@u-0-5'])
184
 
        print ("testrevision.py 191 - intervene appears to return b..6 even"
185
 
               "though it is not reachable!")
186
 
#        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
187
 
#                         self.br1.revision_history()), 
188
 
#                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
189
 
#                          'b@u-0-6'])
190
 
#        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
191
 
#                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
192
 
#                          'b@u-0-5'])
 
67
        assert not is_ancestor(revisions[3], revisions_2[3], br1)
 
68
 
 
69
class TestIntermediateRevisions(TestCaseInTempDir):
 
70
 
 
71
    def setUp(self):
 
72
        from bzrlib.commit import commit
 
73
        TestCaseInTempDir.setUp(self)
 
74
        self.br1, self.br2 = make_branches()
 
75
        commit(self.br2, "Commit eleven", rev_id="b@u-0-7")
 
76
        commit(self.br2, "Commit twelve", rev_id="b@u-0-8")
 
77
        commit(self.br2, "Commit thirtteen", rev_id="b@u-0-9")
 
78
        self.br1.add_pending_merge(self.br2.revision_history()[6])
 
79
        commit(self.br1, "Commit fourtten", rev_id="a@u-0-6")
 
80
        self.br2.add_pending_merge(self.br1.revision_history()[6])
 
81
        commit(self.br2, "Commit fifteen", rev_id="b@u-0-10")
 
82
 
 
83
        from bzrlib.revision import MultipleRevisionSources
 
84
        self.sources = MultipleRevisionSources(self.br1, self.br2)
 
85
 
 
86
    def intervene(self, ancestor, revision, revision_history=None):
 
87
        from bzrlib.revision import get_intervening_revisions
 
88
        return get_intervening_revisions(ancestor,revision, self.sources, 
 
89
                                         revision_history)
 
90
 
 
91
    def test_intervene(self):
 
92
        """Find intermediate revisions, without requiring history"""
 
93
        from bzrlib.errors import NotAncestor, NoSuchRevision
 
94
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
 
95
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
 
96
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
 
97
                         ['a@u-0-1', 'a@u-0-2'])
 
98
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
 
99
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
 
100
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
 
101
                         ['b@u-0-4', 'a@u-0-3'])
 
102
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
 
103
                                        self.br1.revision_history()), 
 
104
                         ['a@u-0-3'])
 
105
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
 
106
                                        self.br1.revision_history()), 
 
107
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
108
                          'a@u-0-5'])
 
109
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
 
110
                         self.br1.revision_history()), 
 
111
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
112
                          'b@u-0-6'])
 
113
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
 
114
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
 
115
                          'b@u-0-5'])
 
116
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
 
117
                         self.br2.revision_history()), 
 
118
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
 
119
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
 
120
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
121
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
 
122
                                        self.br2.revision_history()), 
 
123
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
124
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
 
125
                          self.br2.revision_history())
 
126
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
 
127
                          'b@u-0-6', self.br2.revision_history())
 
128
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
 
129
                          'c@u-0-6', self.br2.revision_history())
 
130
 
 
131
class TestIntermediateRevisions(TestCaseInTempDir):
 
132
 
 
133
    def setUp(self):
 
134
        from bzrlib.commit import commit
 
135
        TestCaseInTempDir.setUp(self)
 
136
        self.br1, self.br2 = make_branches()
 
137
        commit(self.br2, "Commit eleven", rev_id="b@u-0-7")
 
138
        commit(self.br2, "Commit twelve", rev_id="b@u-0-8")
 
139
        commit(self.br2, "Commit thirtteen", rev_id="b@u-0-9")
 
140
        self.br1.add_pending_merge(self.br2.revision_history()[6])
 
141
        commit(self.br1, "Commit fourtten", rev_id="a@u-0-6")
 
142
        self.br2.add_pending_merge(self.br1.revision_history()[6])
 
143
        commit(self.br2, "Commit fifteen", rev_id="b@u-0-10")
 
144
 
 
145
        from bzrlib.revision import MultipleRevisionSources
 
146
        self.sources = MultipleRevisionSources(self.br1, self.br2)
 
147
 
 
148
    def intervene(self, ancestor, revision, revision_history=None):
 
149
        from bzrlib.revision import get_intervening_revisions
 
150
        return get_intervening_revisions(ancestor,revision, self.sources, 
 
151
                                         revision_history)
 
152
 
 
153
    def test_intervene(self):
 
154
        """Find intermediate revisions, without requiring history"""
 
155
        from bzrlib.errors import NotAncestor, NoSuchRevision
 
156
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
 
157
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
 
158
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
 
159
                         ['a@u-0-1', 'a@u-0-2'])
 
160
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
 
161
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
 
162
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
 
163
                         ['b@u-0-4', 'a@u-0-3'])
 
164
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
 
165
                                        self.br1.revision_history()), 
 
166
                         ['a@u-0-3'])
 
167
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
 
168
                                        self.br1.revision_history()), 
 
169
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
170
                          'a@u-0-5'])
 
171
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
 
172
                         self.br1.revision_history()), 
 
173
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
174
                          'b@u-0-6'])
 
175
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
 
176
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
 
177
                          'b@u-0-5'])
193
178
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
194
179
                         self.br2.revision_history()), 
195
180
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
211
196
 
212
197
    def test_old_common_ancestor(self):
213
198
        """Pick a resonable merge base using the old functionality"""
 
199
        from bzrlib.revision import find_present_ancestors
214
200
        from bzrlib.revision import old_common_ancestor as common_ancestor
 
201
        from bzrlib.revision import MultipleRevisionSources
215
202
        br1, br2 = make_branches()
216
203
        revisions = br1.revision_history()
217
204
        revisions_2 = br2.revision_history()
218
 
        sources = br1
 
205
        sources = MultipleRevisionSources(br1, br2)
219
206
 
220
207
        expected_ancestors_list = {revisions[3]:(0, 0), 
221
208
                                   revisions[2]:(1, 1),
242
229
                          revisions_2[4])
243
230
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
244
231
                          revisions_2[4])
245
 
        fetch(from_branch=br2, to_branch=br1)
246
232
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
247
 
                          revisions[4]) # revisions_2[5] is equally valid
 
233
                          revisions[4])
248
234
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
249
235
                          revisions_2[5])
250
236
 
251
237
    def test_common_ancestor(self):
252
238
        """Pick a reasonable merge base"""
 
239
        from bzrlib.revision import find_present_ancestors
253
240
        from bzrlib.revision import common_ancestor
 
241
        from bzrlib.revision import MultipleRevisionSources
254
242
        br1, br2 = make_branches()
255
243
        revisions = br1.revision_history()
256
244
        revisions_2 = br2.revision_history()
257
245
        sources = MultipleRevisionSources(br1, br2)
 
246
 
258
247
        expected_ancestors_list = {revisions[3]:(0, 0), 
259
248
                                   revisions[2]:(1, 1),
260
249
                                   revisions_2[4]:(2, 1), 
267
256
            self.assertEqual(ancestors_list[key], value, 
268
257
                              "key %r, %r != %r" % (key, ancestors_list[key],
269
258
                                                    value))
 
259
 
270
260
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
271
261
                          revisions[0])
272
262
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
280
270
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
281
271
                          revisions_2[4])
282
272
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
283
 
                          revisions[4]) # revisions_2[5] is equally valid
 
273
                          revisions[4])
284
274
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
285
 
                          revisions[4]) # revisions_2[5] is equally valid
 
275
                          revisions[4])
286
276
 
287
 
    def test_combined(self):
288
 
        """combined_graph
289
 
        Ensure it's not order-sensitive
290
 
        """
291
 
        br1, br2 = make_branches()
292
 
        source = MultipleRevisionSources(br1, br2)
293
 
        combined_1 = combined_graph(br1.last_revision(), 
294
 
                                    br2.last_revision(), source)
295
 
        combined_2 = combined_graph(br2.last_revision(),
296
 
                                    br1.last_revision(), source)
297
 
        assert combined_1[1] == combined_2[1]
298
 
        assert combined_1[2] == combined_2[2]
299
 
        assert combined_1[3] == combined_2[3]
300
 
        assert combined_1 == combined_2