← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

  • Committer: Robert Collins
  • Date: 2005-10-06 01:30:12 UTC
  • Revision ID: robertc@robertcollins.net-20051006013012-27a91dece71dc318
we do not need revision_trees in commit, parent inventories are sufficient

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testrevision.py
17
17
 
18
18
import os
19
19
 
 
20
from bzrlib.selftest import TestCaseInTempDir
20
21
from bzrlib.branch import Branch
21
 
from bzrlib.errors import NoSuchRevision
22
22
from bzrlib.commit import commit
23
 
from bzrlib.graph import Graph
 
23
from bzrlib.fetch import fetch
24
24
from bzrlib.revision import (find_present_ancestors, combined_graph,
25
 
                             common_ancestor,
26
25
                             is_ancestor, MultipleRevisionSources)
27
 
from bzrlib.tests import TestCaseWithTransport
28
26
from bzrlib.trace import mutter
29
 
from bzrlib.workingtree import WorkingTree
 
27
from bzrlib.errors import NoSuchRevision
30
28
 
31
 
# XXX: Make this a method of a merge base case
32
 
def make_branches(self):
 
29
def make_branches():
33
30
    """Create two branches
34
31
 
35
32
    branch 1 has 6 commits, branch 2 has 3 commits
36
 
    commit 10 is a ghosted merge merge from branch 1
 
33
    commit 10 was a psuedo merge from branch 1
 
34
    but has been disabled until ghost support is
 
35
    implemented.
37
36
 
38
37
    the object graph is
39
38
    B:     A:
48
47
    so A is missing b6 at the start
49
48
    and B is missing a3, a4, a5
50
49
    """
51
 
    tree1 = self.make_branch_and_tree("branch1")
52
 
    br1 = tree1.branch
 
50
    os.mkdir("branch1")
 
51
    br1 = Branch.initialize("branch1")
53
52
    
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")
 
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")
57
56
 
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")
 
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")
62
62
    revisions_2 = br2.revision_history()
63
63
    
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")
 
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")
70
70
    
71
 
    br1.fetch(br2)
72
 
    tree1.add_pending_merge(br2.revision_history()[5])
73
 
    tree1.commit("Commit nine", rev_id="a@u-0-5")
 
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")
74
74
    # DO NOT FETCH HERE - we WANT a GHOST.
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")
 
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")
78
78
    
79
79
    return br1, br2
80
80
 
81
81
 
82
 
class TestIsAncestor(TestCaseWithTransport):
83
 
 
 
82
class TestIsAncestor(TestCaseInTempDir):
84
83
    def test_recorded_ancestry(self):
85
84
        """Test that commit records all ancestors"""
86
 
        br1, br2 = make_branches(self)
 
85
        br1, br2 = make_branches()
87
86
        d = [('a@u-0-0', ['a@u-0-0']),
88
87
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
89
88
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
112
111
                if rev_id in br2_only and not branch is br2:
113
112
                    continue
114
113
                mutter('ancestry of {%s}: %r',
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))
 
114
                       rev_id, branch.get_ancestry(rev_id))
 
115
                self.assertEquals(sorted(branch.get_ancestry(rev_id)),
 
116
                                  [None] + sorted(anc))
118
117
    
119
118
    
120
119
    def test_is_ancestor(self):
121
120
        """Test checking whether a revision is an ancestor of another revision"""
122
 
        br1, br2 = make_branches(self)
 
121
        br1, br2 = make_branches()
123
122
        revisions = br1.revision_history()
124
123
        revisions_2 = br2.revision_history()
125
124
        sources = br1
126
125
 
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))
 
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)
131
130
        # disabled mbp 20050914, doesn't seem to happen anymore
132
131
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
133
132
        ##                  revisions[0], br1)        
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):
 
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):
141
140
 
142
141
    def setUp(self):
143
142
        from bzrlib.commit import commit
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")
 
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")
159
157
 
160
158
        from bzrlib.revision import MultipleRevisionSources
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):
 
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
        print ("testrevision.py 191 - intervene appears to return b..6 even"
 
185
               "though it is not reachable!")
 
186
#        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
 
187
#                         self.br1.revision_history()), 
 
188
#                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
189
#                          'b@u-0-6'])
 
190
#        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
 
191
#                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
 
192
#                          'b@u-0-5'])
 
193
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
 
194
                         self.br2.revision_history()), 
 
195
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
 
196
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
 
197
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
198
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
 
199
                                        self.br2.revision_history()), 
 
200
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
 
201
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
 
202
                          self.br2.revision_history())
 
203
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
 
204
                          'b@u-0-6', self.br2.revision_history())
 
205
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
 
206
                          'c@u-0-6', self.br2.revision_history())
 
207
 
 
208
 
 
209
class TestCommonAncestor(TestCaseInTempDir):
182
210
    """Test checking whether a revision is an ancestor of another revision"""
183
211
 
 
212
    def test_old_common_ancestor(self):
 
213
        """Pick a resonable merge base using the old functionality"""
 
214
        from bzrlib.revision import old_common_ancestor as common_ancestor
 
215
        br1, br2 = make_branches()
 
216
        revisions = br1.revision_history()
 
217
        revisions_2 = br2.revision_history()
 
218
        sources = br1
 
219
 
 
220
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
221
                                   revisions[2]:(1, 1),
 
222
                                   revisions_2[4]:(2, 1), 
 
223
                                   revisions[1]:(3, 2),
 
224
                                   revisions_2[3]:(4, 2),
 
225
                                   revisions[0]:(5, 3) }
 
226
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
227
        assert len(expected_ancestors_list) == len(ancestors_list)
 
228
        for key, value in expected_ancestors_list.iteritems():
 
229
            self.assertEqual(ancestors_list[key], value, 
 
230
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
231
                                                    value))
 
232
 
 
233
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
234
                          revisions[0])
 
235
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
236
                          revisions[1])
 
237
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
238
                          revisions[1])
 
239
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
240
                          revisions[2])
 
241
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
242
                          revisions_2[4])
 
243
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
244
                          revisions_2[4])
 
245
        fetch(from_branch=br2, to_branch=br1)
 
246
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
247
                          revisions[4]) # revisions_2[5] is equally valid
 
248
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
249
                          revisions_2[5])
 
250
 
184
251
    def test_common_ancestor(self):
185
252
        """Pick a reasonable merge base"""
186
 
        br1, br2 = make_branches(self)
 
253
        from bzrlib.revision import common_ancestor
 
254
        br1, br2 = make_branches()
187
255
        revisions = br1.revision_history()
188
256
        revisions_2 = br2.revision_history()
189
 
        sources = MultipleRevisionSources(br1.repository, br2.repository)
 
257
        sources = MultipleRevisionSources(br1, br2)
190
258
        expected_ancestors_list = {revisions[3]:(0, 0), 
191
259
                                   revisions[2]:(1, 1),
192
260
                                   revisions_2[4]:(2, 1), 
194
262
                                   revisions_2[3]:(4, 2),
195
263
                                   revisions[0]:(5, 3) }
196
264
        ancestors_list = find_present_ancestors(revisions[3], sources)
197
 
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
 
265
        assert len(expected_ancestors_list) == len(ancestors_list)
198
266
        for key, value in expected_ancestors_list.iteritems():
199
267
            self.assertEqual(ancestors_list[key], value, 
200
268
                              "key %r, %r != %r" % (key, ancestors_list[key],
211
279
                          revisions_2[4])
212
280
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
213
281
                          revisions_2[4])
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))
 
282
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
283
                          revisions[4]) # revisions_2[5] is equally valid
 
284
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
285
                          revisions[4]) # revisions_2[5] is equally valid
219
286
 
220
287
    def test_combined(self):
221
288
        """combined_graph
222
289
        Ensure it's not order-sensitive
223
290
        """
224
 
        br1, br2 = make_branches(self)
225
 
        source = MultipleRevisionSources(br1.repository, br2.repository)
 
291
        br1, br2 = make_branches()
 
292
        source = MultipleRevisionSources(br1, br2)
226
293
        combined_1 = combined_graph(br1.last_revision(), 
227
294
                                    br2.last_revision(), source)
228
295
        combined_2 = combined_graph(br2.last_revision(),
229
296
                                    br1.last_revision(), source)
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'))
 
297
        assert combined_1[1] == combined_2[1]
 
298
        assert combined_1[2] == combined_2[2]
 
299
        assert combined_1[3] == combined_2[3]
 
300
        assert combined_1 == combined_2