~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revision.py

  • Committer: Martin Pool
  • Date: 2006-06-05 18:00:36 UTC
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: mbp@sourcefrog.net-20060605180036-04f5d0cea94ed999
clean up test kipple

Show diffs side-by-side

added added

removed removed

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