~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revision.py

Add run_bzr_errors alongside run_bzr, to make it easy to check the right error is occurring.

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.graph import Graph
 
24
from bzrlib.revision import (find_present_ancestors, combined_graph,
 
25
                             common_ancestor,
 
26
                             is_ancestor, MultipleRevisionSources)
 
27
from bzrlib.tests import TestCaseWithTransport
 
28
from bzrlib.trace import mutter
 
29
from bzrlib.workingtree import WorkingTree
 
30
 
 
31
# We're allowed to test deprecated interfaces
 
32
warnings.filterwarnings('ignore',
 
33
        '.*get_intervening_revisions was deprecated',
 
34
        DeprecationWarning,
 
35
        r'bzrlib\.tests\.test_revision')
 
36
 
 
37
# XXX: Make this a method of a merge base case
 
38
def make_branches(self):
 
39
    """Create two branches
 
40
 
 
41
    branch 1 has 6 commits, branch 2 has 3 commits
 
42
    commit 10 is a ghosted merge merge from branch 1
 
43
 
 
44
    the object graph is
 
45
    B:     A:
 
46
    a..0   a..0 
 
47
    a..1   a..1
 
48
    a..2   a..2
 
49
    b..3   a..3 merges b..4
 
50
    b..4   a..4
 
51
    b..5   a..5 merges b..5
 
52
    b..6 merges a4
 
53
 
 
54
    so A is missing b6 at the start
 
55
    and B is missing a3, a4, a5
 
56
    """
 
57
    tree1 = self.make_branch_and_tree("branch1")
 
58
    br1 = tree1.branch
 
59
    
 
60
    tree1.commit("Commit one", rev_id="a@u-0-0")
 
61
    tree1.commit("Commit two", rev_id="a@u-0-1")
 
62
    tree1.commit("Commit three", rev_id="a@u-0-2")
 
63
 
 
64
    tree2 = tree1.bzrdir.clone("branch2").open_workingtree()
 
65
    br2 = tree2.branch
 
66
    tree2.commit("Commit four", rev_id="b@u-0-3")
 
67
    tree2.commit("Commit five", rev_id="b@u-0-4")
 
68
    revisions_2 = br2.revision_history()
 
69
    
 
70
    br1.fetch(br2)
 
71
    tree1.add_pending_merge(revisions_2[4])
 
72
    self.assertEquals(revisions_2[4], 'b@u-0-4')
 
73
    tree1.commit("Commit six", rev_id="a@u-0-3")
 
74
    tree1.commit("Commit seven", rev_id="a@u-0-4")
 
75
    tree2.commit("Commit eight", rev_id="b@u-0-5")
 
76
    
 
77
    br1.fetch(br2)
 
78
    tree1.add_pending_merge(br2.revision_history()[5])
 
79
    tree1.commit("Commit nine", rev_id="a@u-0-5")
 
80
    # DO NOT FETCH HERE - we WANT a GHOST.
 
81
    # br2.fetch(br1)
 
82
    tree2.add_pending_merge(br1.revision_history()[4])
 
83
    tree2.commit("Commit ten - ghost merge", rev_id="b@u-0-6")
 
84
    
 
85
    return br1, br2
 
86
 
 
87
 
 
88
class TestIsAncestor(TestCaseWithTransport):
 
89
 
 
90
    def test_recorded_ancestry(self):
 
91
        """Test that commit records all ancestors"""
 
92
        br1, br2 = make_branches(self)
 
93
        d = [('a@u-0-0', ['a@u-0-0']),
 
94
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
 
95
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
 
96
             ('b@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3']),
 
97
             ('b@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3',
 
98
                          'b@u-0-4']),
 
99
             ('a@u-0-3', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
100
                          'a@u-0-3']),
 
101
             ('a@u-0-4', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
102
                          'a@u-0-3', 'a@u-0-4']),
 
103
             ('b@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4',
 
104
                          'b@u-0-5']),
 
105
             ('a@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',
 
106
                          'b@u-0-3', 'b@u-0-4',
 
107
                          'b@u-0-5', 'a@u-0-5']),
 
108
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2',
 
109
                          'b@u-0-3', 'b@u-0-4',
 
110
                          'b@u-0-5', 'b@u-0-6']),
 
111
             ]
 
112
        br1_only = ('a@u-0-3', 'a@u-0-4', 'a@u-0-5')
 
113
        br2_only = ('b@u-0-6',)
 
114
        for branch in br1, br2:
 
115
            for rev_id, anc in d:
 
116
                if rev_id in br1_only and not branch is br1:
 
117
                    continue
 
118
                if rev_id in br2_only and not branch is br2:
 
119
                    continue
 
120
                mutter('ancestry of {%s}: %r',
 
121
                       rev_id, branch.repository.get_ancestry(rev_id))
 
122
                result = sorted(branch.repository.get_ancestry(rev_id))
 
123
                self.assertEquals(result, [None] + sorted(anc))
 
124
    
 
125
    
 
126
    def test_is_ancestor(self):
 
127
        """Test checking whether a revision is an ancestor of another revision"""
 
128
        br1, br2 = make_branches(self)
 
129
        revisions = br1.revision_history()
 
130
        revisions_2 = br2.revision_history()
 
131
        sources = br1
 
132
 
 
133
        self.assert_(is_ancestor(revisions[0], revisions[0], br1))
 
134
        self.assert_(is_ancestor(revisions[1], revisions[0], sources))
 
135
        self.assert_(not is_ancestor(revisions[0], revisions[1], sources))
 
136
        self.assert_(is_ancestor(revisions_2[3], revisions[0], sources))
 
137
        # disabled mbp 20050914, doesn't seem to happen anymore
 
138
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
 
139
        ##                  revisions[0], br1)        
 
140
        self.assert_(is_ancestor(revisions[3], revisions_2[4], sources))
 
141
        self.assert_(is_ancestor(revisions[3], revisions_2[4], br1))
 
142
        self.assert_(is_ancestor(revisions[3], revisions_2[3], sources))
 
143
        ## self.assert_(not is_ancestor(revisions[3], revisions_2[3], br1))
 
144
 
 
145
 
 
146
class TestIntermediateRevisions(TestCaseWithTransport):
 
147
 
 
148
    def setUp(self):
 
149
        TestCaseWithTransport.setUp(self)
 
150
        self.br1, self.br2 = make_branches(self)
 
151
        wt1 = self.br1.bzrdir.open_workingtree()
 
152
        wt2 = self.br2.bzrdir.open_workingtree()
 
153
        wt2.commit("Commit eleven", rev_id="b@u-0-7")
 
154
        wt2.commit("Commit twelve", rev_id="b@u-0-8")
 
155
        wt2.commit("Commit thirtteen", rev_id="b@u-0-9")
 
156
 
 
157
        self.br1.fetch(self.br2)
 
158
        wt1.add_pending_merge(self.br2.revision_history()[6])
 
159
        wt1.commit("Commit fourtten", rev_id="a@u-0-6")
 
160
 
 
161
        self.br2.fetch(self.br1)
 
162
        wt2.add_pending_merge(self.br1.revision_history()[6])
 
163
        wt2.commit("Commit fifteen", rev_id="b@u-0-10")
 
164
 
 
165
        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):
 
187
    """Test checking whether a revision is an ancestor of another revision"""
 
188
 
 
189
    def test_common_ancestor(self):
 
190
        """Pick a reasonable merge base"""
 
191
        br1, br2 = make_branches(self)
 
192
        revisions = br1.revision_history()
 
193
        revisions_2 = br2.revision_history()
 
194
        sources = MultipleRevisionSources(br1.repository, br2.repository)
 
195
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
196
                                   revisions[2]:(1, 1),
 
197
                                   revisions_2[4]:(2, 1), 
 
198
                                   revisions[1]:(3, 2),
 
199
                                   revisions_2[3]:(4, 2),
 
200
                                   revisions[0]:(5, 3) }
 
201
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
202
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
 
203
        for key, value in expected_ancestors_list.iteritems():
 
204
            self.assertEqual(ancestors_list[key], value, 
 
205
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
206
                                                    value))
 
207
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
208
                          revisions[0])
 
209
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
210
                          revisions[1])
 
211
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
212
                          revisions[1])
 
213
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
214
                          revisions[2])
 
215
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
216
                          revisions_2[4])
 
217
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
218
                          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
 
 
225
    def test_combined(self):
 
226
        """combined_graph
 
227
        Ensure it's not order-sensitive
 
228
        """
 
229
        br1, br2 = make_branches(self)
 
230
        source = MultipleRevisionSources(br1.repository, br2.repository)
 
231
        combined_1 = combined_graph(br1.last_revision(), 
 
232
                                    br2.last_revision(), source)
 
233
        combined_2 = combined_graph(br2.last_revision(),
 
234
                                    br1.last_revision(), source)
 
235
        self.assertEquals(combined_1[1], combined_2[1])
 
236
        self.assertEquals(combined_1[2], combined_2[2])
 
237
        self.assertEquals(combined_1[3], combined_2[3])
 
238
        self.assertEquals(combined_1, combined_2)
 
239
 
 
240
    def test_get_history(self):
 
241
        # TODO: test ghosts on the left hand branch's impact
 
242
        # TODO: test ghosts on all parents, we should get some
 
243
        # indicator. i.e. NULL_REVISION
 
244
        # RBC 20060608
 
245
        tree = self.make_branch_and_tree('.')
 
246
        tree.commit('1', rev_id = '1', allow_pointless=True)
 
247
        tree.commit('2', rev_id = '2', allow_pointless=True)
 
248
        tree.commit('3', rev_id = '3', allow_pointless=True)
 
249
        rev = tree.branch.repository.get_revision('1')
 
250
        history = rev.get_history(tree.branch.repository)
 
251
        self.assertEqual([None, '1'], history)
 
252
        rev = tree.branch.repository.get_revision('2')
 
253
        history = rev.get_history(tree.branch.repository)
 
254
        self.assertEqual([None, '1', '2'], history)
 
255
        rev = tree.branch.repository.get_revision('3')
 
256
        history = rev.get_history(tree.branch.repository)
 
257
        self.assertEqual([None, '1', '2' ,'3'], history)
 
258
 
 
259
    def test_common_ancestor_rootless_graph(self):
 
260
        # common_ancestor on a graph with no reachable roots - only
 
261
        # ghosts - should still return a useful value.
 
262
        graph = Graph()
 
263
        # add a ghost node which would be a root if it wasn't a ghost.
 
264
        graph.add_ghost('a_ghost')
 
265
        # add a normal commit on top of that
 
266
        graph.add_node('rev1', ['a_ghost'])
 
267
        # add a left-branch revision
 
268
        graph.add_node('left', ['rev1'])
 
269
        # add a right-branch revision
 
270
        graph.add_node('right', ['rev1'])
 
271
        source = MockRevisionSource(graph)
 
272
        self.assertEqual('rev1', common_ancestor('left', 'right', source))
 
273
 
 
274
 
 
275
class TestMultipleRevisionSources(TestCaseWithTransport):
 
276
    """Tests for the MultipleRevisionSources adapter."""
 
277
 
 
278
    def test_get_revision_graph_merges_ghosts(self):
 
279
        # when we ask for the revision graph for B, which
 
280
        # is in repo 1 with a ghost of A, and which is not
 
281
        # in repo 2, which has A, the revision_graph()
 
282
        # should return A and B both.
 
283
        tree_1 = self.make_branch_and_tree('1')
 
284
        tree_1.add_pending_merge('A')
 
285
        tree_1.commit('foo', rev_id='B', allow_pointless=True)
 
286
        tree_2 = self.make_branch_and_tree('2')
 
287
        tree_2.commit('bar', rev_id='A', allow_pointless=True)
 
288
        source = MultipleRevisionSources(tree_1.branch.repository,
 
289
                                         tree_2.branch.repository)
 
290
        self.assertEqual({'B':['A'],
 
291
                          'A':[]},
 
292
                         source.get_revision_graph('B'))