← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revision.py

Late bind to PatienceSequenceMatcher to allow plugin to override.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_revision.py
17
17
 
18
18
import os
19
19
 
20
 
from bzrlib.selftest import TestCaseInTempDir
21
20
from bzrlib.branch import Branch
 
21
from bzrlib.errors import NoSuchRevision
22
22
from bzrlib.commit import commit
23
 
from bzrlib.fetch import fetch
 
23
from bzrlib.graph import Graph
24
24
from bzrlib.revision import (find_present_ancestors, combined_graph,
 
25
                             common_ancestor,
25
26
                             is_ancestor, MultipleRevisionSources)
 
27
from bzrlib.tests import TestCaseWithTransport
26
28
from bzrlib.trace import mutter
27
 
from bzrlib.errors import NoSuchRevision
 
29
from bzrlib.workingtree import WorkingTree
28
30
 
29
 
def make_branches():
 
31
# XXX: Make this a method of a merge base case
 
32
def make_branches(self):
30
33
    """Create two branches
31
34
 
32
35
    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
    commit 10 is a ghosted merge merge from branch 1
36
37
 
37
38
    the object graph is
38
39
    B:     A:
47
48
    so A is missing b6 at the start
48
49
    and B is missing a3, a4, a5
49
50
    """
50
 
    os.mkdir("branch1")
51
 
    br1 = Branch.initialize("branch1")
 
51
    tree1 = self.make_branch_and_tree("branch1")
 
52
    br1 = tree1.branch
52
53
    
53
 
    commit(br1, "Commit one", rev_id="a@u-0-0")
54
 
    commit(br1, "Commit two", rev_id="a@u-0-1")
55
 
    commit(br1, "Commit three", rev_id="a@u-0-2")
 
54
    tree1.commit("Commit one", rev_id="a@u-0-0")
 
55
    tree1.commit("Commit two", rev_id="a@u-0-1")
 
56
    tree1.commit("Commit three", rev_id="a@u-0-2")
56
57
 
57
 
    os.mkdir("branch2")
58
 
    br2 = Branch.initialize("branch2")
59
 
    br2.update_revisions(br1)
60
 
    commit(br2, "Commit four", rev_id="b@u-0-3")
61
 
    commit(br2, "Commit five", rev_id="b@u-0-4")
 
58
    tree2 = tree1.bzrdir.clone("branch2").open_workingtree()
 
59
    br2 = tree2.branch
 
60
    tree2.commit("Commit four", rev_id="b@u-0-3")
 
61
    tree2.commit("Commit five", rev_id="b@u-0-4")
62
62
    revisions_2 = br2.revision_history()
63
63
    
64
 
    fetch(from_branch=br2, to_branch=br1)
65
 
    br1.add_pending_merge(revisions_2[4])
66
 
    assert revisions_2[4] == 'b@u-0-4'
67
 
    commit(br1, "Commit six", rev_id="a@u-0-3")
68
 
    commit(br1, "Commit seven", rev_id="a@u-0-4")
69
 
    commit(br2, "Commit eight", rev_id="b@u-0-5")
 
64
    br1.fetch(br2)
 
65
    tree1.add_pending_merge(revisions_2[4])
 
66
    self.assertEquals(revisions_2[4], 'b@u-0-4')
 
67
    tree1.commit("Commit six", rev_id="a@u-0-3")
 
68
    tree1.commit("Commit seven", rev_id="a@u-0-4")
 
69
    tree2.commit("Commit eight", rev_id="b@u-0-5")
70
70
    
71
 
    fetch(from_branch=br2, to_branch=br1)
72
 
    br1.add_pending_merge(br2.revision_history()[5])
73
 
    commit(br1, "Commit nine", rev_id="a@u-0-5")
 
71
    br1.fetch(br2)
 
72
    tree1.add_pending_merge(br2.revision_history()[5])
 
73
    tree1.commit("Commit nine", rev_id="a@u-0-5")
74
74
    # DO NOT FETCH HERE - we WANT a GHOST.
75
 
    #fetch(from_branch=br1, to_branch=br2)
76
 
    br2.add_pending_merge(br1.revision_history()[4])
77
 
    commit(br2, "Commit ten - ghost merge", rev_id="b@u-0-6")
 
75
    # br2.fetch(br1)
 
76
    tree2.add_pending_merge(br1.revision_history()[4])
 
77
    tree2.commit("Commit ten - ghost merge", rev_id="b@u-0-6")
78
78
    
79
79
    return br1, br2
80
80
 
81
81
 
82
 
class TestIsAncestor(TestCaseInTempDir):
 
82
class TestIsAncestor(TestCaseWithTransport):
 
83
 
83
84
    def test_recorded_ancestry(self):
84
85
        """Test that commit records all ancestors"""
85
 
        br1, br2 = make_branches()
 
86
        br1, br2 = make_branches(self)
86
87
        d = [('a@u-0-0', ['a@u-0-0']),
87
88
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
88
89
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
111
112
                if rev_id in br2_only and not branch is br2:
112
113
                    continue
113
114
                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))
 
115
                       rev_id, branch.repository.get_ancestry(rev_id))
 
116
                result = sorted(branch.repository.get_ancestry(rev_id))
 
117
                self.assertEquals(result, [None] + sorted(anc))
117
118
    
118
119
    
119
120
    def test_is_ancestor(self):
120
121
        """Test checking whether a revision is an ancestor of another revision"""
121
 
        br1, br2 = make_branches()
 
122
        br1, br2 = make_branches(self)
122
123
        revisions = br1.revision_history()
123
124
        revisions_2 = br2.revision_history()
124
125
        sources = br1
125
126
 
126
 
        assert is_ancestor(revisions[0], revisions[0], br1)
127
 
        assert is_ancestor(revisions[1], revisions[0], sources)
128
 
        assert not is_ancestor(revisions[0], revisions[1], sources)
129
 
        assert is_ancestor(revisions_2[3], revisions[0], sources)
 
127
        self.assert_(is_ancestor(revisions[0], revisions[0], br1))
 
128
        self.assert_(is_ancestor(revisions[1], revisions[0], sources))
 
129
        self.assert_(not is_ancestor(revisions[0], revisions[1], sources))
 
130
        self.assert_(is_ancestor(revisions_2[3], revisions[0], sources))
130
131
        # disabled mbp 20050914, doesn't seem to happen anymore
131
132
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
132
133
        ##                  revisions[0], br1)        
133
 
        assert is_ancestor(revisions[3], revisions_2[4], sources)
134
 
        assert is_ancestor(revisions[3], revisions_2[4], br1)
135
 
        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):
 
134
        self.assert_(is_ancestor(revisions[3], revisions_2[4], sources))
 
135
        self.assert_(is_ancestor(revisions[3], revisions_2[4], br1))
 
136
        self.assert_(is_ancestor(revisions[3], revisions_2[3], sources))
 
137
        ## self.assert_(not is_ancestor(revisions[3], revisions_2[3], br1))
 
138
 
 
139
 
 
140
class TestIntermediateRevisions(TestCaseWithTransport):
140
141
 
141
142
    def setUp(self):
142
143
        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")
 
144
        TestCaseWithTransport.setUp(self)
 
145
        self.br1, self.br2 = make_branches(self)
 
146
        wt1 = self.br1.bzrdir.open_workingtree()
 
147
        wt2 = self.br2.bzrdir.open_workingtree()
 
148
        wt2.commit("Commit eleven", rev_id="b@u-0-7")
 
149
        wt2.commit("Commit twelve", rev_id="b@u-0-8")
 
150
        wt2.commit("Commit thirtteen", rev_id="b@u-0-9")
 
151
 
 
152
        self.br1.fetch(self.br2)
 
153
        wt1.add_pending_merge(self.br2.revision_history()[6])
 
154
        wt1.commit("Commit fourtten", rev_id="a@u-0-6")
 
155
 
 
156
        self.br2.fetch(self.br1)
 
157
        wt2.add_pending_merge(self.br1.revision_history()[6])
 
158
        wt2.commit("Commit fifteen", rev_id="b@u-0-10")
157
159
 
158
160
        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
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
185
 
                         self.br1.revision_history()), 
186
 
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
187
 
                          'b@u-0-6'])
188
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
189
 
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
190
 
                          'b@u-0-5'])
191
 
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
192
 
                         self.br2.revision_history()), 
193
 
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
194
 
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
195
 
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
196
 
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
197
 
                                        self.br2.revision_history()), 
198
 
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
199
 
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
200
 
                          self.br2.revision_history())
201
 
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
202
 
                          'b@u-0-6', self.br2.revision_history())
203
 
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
204
 
                          'c@u-0-6', self.br2.revision_history())
205
 
 
206
 
 
207
 
class TestCommonAncestor(TestCaseInTempDir):
 
161
        self.sources = MultipleRevisionSources(self.br1.repository,
 
162
                                               self.br2.repository)
 
163
 
 
164
 
 
165
 
 
166
class MockRevisionSource(object):
 
167
    """A RevisionSource that takes a pregenerated graph.
 
168
 
 
169
    This is useful for testing revision graph algorithms where
 
170
    the actual branch existing is irrelevant.
 
171
    """
 
172
 
 
173
    def __init__(self, full_graph):
 
174
        self._full_graph = full_graph
 
175
 
 
176
    def get_revision_graph_with_ghosts(self, revision_ids):
 
177
        # This is mocked out to just return a constant graph.
 
178
        return self._full_graph
 
179
 
 
180
 
 
181
class TestCommonAncestor(TestCaseWithTransport):
208
182
    """Test checking whether a revision is an ancestor of another revision"""
209
183
 
210
 
    def test_old_common_ancestor(self):
211
 
        """Pick a resonable merge base using the old functionality"""
212
 
        from bzrlib.revision import old_common_ancestor as common_ancestor
213
 
        br1, br2 = make_branches()
214
 
        revisions = br1.revision_history()
215
 
        revisions_2 = br2.revision_history()
216
 
        sources = br1
217
 
 
218
 
        expected_ancestors_list = {revisions[3]:(0, 0), 
219
 
                                   revisions[2]:(1, 1),
220
 
                                   revisions_2[4]:(2, 1), 
221
 
                                   revisions[1]:(3, 2),
222
 
                                   revisions_2[3]:(4, 2),
223
 
                                   revisions[0]:(5, 3) }
224
 
        ancestors_list = find_present_ancestors(revisions[3], sources)
225
 
        assert len(expected_ancestors_list) == len(ancestors_list)
226
 
        for key, value in expected_ancestors_list.iteritems():
227
 
            self.assertEqual(ancestors_list[key], value, 
228
 
                              "key %r, %r != %r" % (key, ancestors_list[key],
229
 
                                                    value))
230
 
 
231
 
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
232
 
                          revisions[0])
233
 
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
234
 
                          revisions[1])
235
 
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
236
 
                          revisions[1])
237
 
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
238
 
                          revisions[2])
239
 
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
240
 
                          revisions_2[4])
241
 
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
242
 
                          revisions_2[4])
243
 
        fetch(from_branch=br2, to_branch=br1)
244
 
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
245
 
                          revisions[4]) # revisions_2[5] is equally valid
246
 
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
247
 
                          revisions_2[5])
248
 
 
249
184
    def test_common_ancestor(self):
250
185
        """Pick a reasonable merge base"""
251
 
        from bzrlib.revision import common_ancestor
252
 
        br1, br2 = make_branches()
 
186
        br1, br2 = make_branches(self)
253
187
        revisions = br1.revision_history()
254
188
        revisions_2 = br2.revision_history()
255
 
        sources = MultipleRevisionSources(br1, br2)
 
189
        sources = MultipleRevisionSources(br1.repository, br2.repository)
256
190
        expected_ancestors_list = {revisions[3]:(0, 0), 
257
191
                                   revisions[2]:(1, 1),
258
192
                                   revisions_2[4]:(2, 1), 
260
194
                                   revisions_2[3]:(4, 2),
261
195
                                   revisions[0]:(5, 3) }
262
196
        ancestors_list = find_present_ancestors(revisions[3], sources)
263
 
        assert len(expected_ancestors_list) == len(ancestors_list)
 
197
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
264
198
        for key, value in expected_ancestors_list.iteritems():
265
199
            self.assertEqual(ancestors_list[key], value, 
266
200
                              "key %r, %r != %r" % (key, ancestors_list[key],
277
211
                          revisions_2[4])
278
212
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
279
213
                          revisions_2[4])
280
 
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
281
 
                          revisions[4]) # revisions_2[5] is equally valid
282
 
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
283
 
                          revisions[4]) # revisions_2[5] is equally valid
 
214
        self.assertTrue(common_ancestor(revisions[5], revisions_2[6], sources) in
 
215
                        (revisions[4], revisions_2[5]))
 
216
        self.assertTrue(common_ancestor(revisions_2[6], revisions[5], sources),
 
217
                        (revisions[4], revisions_2[5]))
 
218
        self.assertEqual(None, common_ancestor(None, revisions[5], sources))
284
219
 
285
220
    def test_combined(self):
286
221
        """combined_graph
287
222
        Ensure it's not order-sensitive
288
223
        """
289
 
        br1, br2 = make_branches()
290
 
        source = MultipleRevisionSources(br1, br2)
 
224
        br1, br2 = make_branches(self)
 
225
        source = MultipleRevisionSources(br1.repository, br2.repository)
291
226
        combined_1 = combined_graph(br1.last_revision(), 
292
227
                                    br2.last_revision(), source)
293
228
        combined_2 = combined_graph(br2.last_revision(),
294
229
                                    br1.last_revision(), source)
295
 
        assert combined_1[1] == combined_2[1]
296
 
        assert combined_1[2] == combined_2[2]
297
 
        assert combined_1[3] == combined_2[3]
298
 
        assert combined_1 == combined_2
 
230
        self.assertEquals(combined_1[1], combined_2[1])
 
231
        self.assertEquals(combined_1[2], combined_2[2])
 
232
        self.assertEquals(combined_1[3], combined_2[3])
 
233
        self.assertEquals(combined_1, combined_2)
 
234
 
 
235
    def test_get_history(self):
 
236
        # TODO: test ghosts on the left hand branch's impact
 
237
        # TODO: test ghosts on all parents, we should get some
 
238
        # indicator. i.e. NULL_REVISION
 
239
        # RBC 20060608
 
240
        tree = self.make_branch_and_tree('.')
 
241
        tree.commit('1', rev_id = '1', allow_pointless=True)
 
242
        tree.commit('2', rev_id = '2', allow_pointless=True)
 
243
        tree.commit('3', rev_id = '3', allow_pointless=True)
 
244
        rev = tree.branch.repository.get_revision('1')
 
245
        history = rev.get_history(tree.branch.repository)
 
246
        self.assertEqual([None, '1'], history)
 
247
        rev = tree.branch.repository.get_revision('2')
 
248
        history = rev.get_history(tree.branch.repository)
 
249
        self.assertEqual([None, '1', '2'], history)
 
250
        rev = tree.branch.repository.get_revision('3')
 
251
        history = rev.get_history(tree.branch.repository)
 
252
        self.assertEqual([None, '1', '2' ,'3'], history)
 
253
 
 
254
    def test_common_ancestor_rootless_graph(self):
 
255
        # common_ancestor on a graph with no reachable roots - only
 
256
        # ghosts - should still return a useful value.
 
257
        graph = Graph()
 
258
        # add a ghost node which would be a root if it wasn't a ghost.
 
259
        graph.add_ghost('a_ghost')
 
260
        # add a normal commit on top of that
 
261
        graph.add_node('rev1', ['a_ghost'])
 
262
        # add a left-branch revision
 
263
        graph.add_node('left', ['rev1'])
 
264
        # add a right-branch revision
 
265
        graph.add_node('right', ['rev1'])
 
266
        source = MockRevisionSource(graph)
 
267
        self.assertEqual('rev1', common_ancestor('left', 'right', source))
 
268
 
 
269
 
 
270
class TestMultipleRevisionSources(TestCaseWithTransport):
 
271
    """Tests for the MultipleRevisionSources adapter."""
 
272
 
 
273
    def test_get_revision_graph_merges_ghosts(self):
 
274
        # when we ask for the revision graph for B, which
 
275
        # is in repo 1 with a ghost of A, and which is not
 
276
        # in repo 2, which has A, the revision_graph()
 
277
        # should return A and B both.
 
278
        tree_1 = self.make_branch_and_tree('1')
 
279
        tree_1.add_pending_merge('A')
 
280
        tree_1.commit('foo', rev_id='B', allow_pointless=True)
 
281
        tree_2 = self.make_branch_and_tree('2')
 
282
        tree_2.commit('bar', rev_id='A', allow_pointless=True)
 
283
        source = MultipleRevisionSources(tree_1.branch.repository,
 
284
                                         tree_2.branch.repository)
 
285
        self.assertEqual({'B':['A'],
 
286
                          'A':[]},
 
287
                         source.get_revision_graph('B'))