~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revision.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-09 04:51:05 UTC
  • Revision ID: mbp@sourcefrog.net-20050309045105-d02cd410a115da2c
import all docs from arch

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'))