← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

Don't ignore bzrlib/plugins -- really bad idea because they can have bad 
old plugins lying around!

Show diffs side-by-side

added added

removed removed

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