← 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-18 05:26:22 UTC
  • mto: This revision was merged to the branch mainline in revision 1463.
  • Revision ID: robertc@robertcollins.net-20051018052622-653d638c9e26fde4
fix broken tests

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)
 
159
        self.sources = MultipleRevisionSources(self.br1, self.br2)
163
160
 
164
161
    def intervene(self, ancestor, revision, revision_history=None):
165
162
        from bzrlib.revision import get_intervening_revisions
169
166
    def test_intervene(self):
170
167
        """Find intermediate revisions, without requiring history"""
171
168
        from bzrlib.errors import NotAncestor, NoSuchRevision
172
 
        self.assertEquals(len(self.intervene('a@u-0-0', 'a@u-0-0')), 0)
 
169
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
173
170
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
174
171
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
175
172
                         ['a@u-0-1', 'a@u-0-2'])
207
204
                          'c@u-0-6', self.br2.revision_history())
208
205
 
209
206
 
210
 
class MockRevisionSource(object):
211
 
    """A RevisionSource that takes a pregenerated graph.
212
 
 
213
 
    This is useful for testing revision graph algorithms where
214
 
    the actual branch existing is irrelevant.
215
 
    """
216
 
 
217
 
    def __init__(self, full_graph):
218
 
        self._full_graph = full_graph
219
 
 
220
 
    def get_revision_graph_with_ghosts(self, revision_ids):
221
 
        # This is mocked out to just return a constant graph.
222
 
        return self._full_graph
223
 
 
224
 
 
225
 
class TestCommonAncestor(TestCaseWithTransport):
 
207
class TestCommonAncestor(TestCaseInTempDir):
226
208
    """Test checking whether a revision is an ancestor of another revision"""
227
209
 
 
210
    def test_old_common_ancestor(self):
 
211
        """Pick a resonable merge base using the old functionality"""
 
212
        from bzrlib.revision import old_common_ancestor as common_ancestor
 
213
        br1, br2 = make_branches()
 
214
        revisions = br1.revision_history()
 
215
        revisions_2 = br2.revision_history()
 
216
        sources = br1
 
217
 
 
218
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
219
                                   revisions[2]:(1, 1),
 
220
                                   revisions_2[4]:(2, 1), 
 
221
                                   revisions[1]:(3, 2),
 
222
                                   revisions_2[3]:(4, 2),
 
223
                                   revisions[0]:(5, 3) }
 
224
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
225
        assert len(expected_ancestors_list) == len(ancestors_list)
 
226
        for key, value in expected_ancestors_list.iteritems():
 
227
            self.assertEqual(ancestors_list[key], value, 
 
228
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
229
                                                    value))
 
230
 
 
231
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
232
                          revisions[0])
 
233
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
234
                          revisions[1])
 
235
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
236
                          revisions[1])
 
237
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
238
                          revisions[2])
 
239
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
240
                          revisions_2[4])
 
241
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
242
                          revisions_2[4])
 
243
        fetch(from_branch=br2, to_branch=br1)
 
244
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
245
                          revisions[4]) # revisions_2[5] is equally valid
 
246
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
247
                          revisions_2[5])
 
248
 
228
249
    def test_common_ancestor(self):
229
250
        """Pick a reasonable merge base"""
230
 
        br1, br2 = make_branches(self)
 
251
        from bzrlib.revision import common_ancestor
 
252
        br1, br2 = make_branches()
231
253
        revisions = br1.revision_history()
232
254
        revisions_2 = br2.revision_history()
233
 
        sources = MultipleRevisionSources(br1.repository, br2.repository)
 
255
        sources = MultipleRevisionSources(br1, br2)
234
256
        expected_ancestors_list = {revisions[3]:(0, 0), 
235
257
                                   revisions[2]:(1, 1),
236
258
                                   revisions_2[4]:(2, 1), 
238
260
                                   revisions_2[3]:(4, 2),
239
261
                                   revisions[0]:(5, 3) }
240
262
        ancestors_list = find_present_ancestors(revisions[3], sources)
241
 
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
 
263
        assert len(expected_ancestors_list) == len(ancestors_list)
242
264
        for key, value in expected_ancestors_list.iteritems():
243
265
            self.assertEqual(ancestors_list[key], value, 
244
266
                              "key %r, %r != %r" % (key, ancestors_list[key],
255
277
                          revisions_2[4])
256
278
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
257
279
                          revisions_2[4])
258
 
        self.assertTrue(common_ancestor(revisions[5], revisions_2[6], sources) in
259
 
                        (revisions[4], revisions_2[5]))
260
 
        self.assertTrue(common_ancestor(revisions_2[6], revisions[5], sources),
261
 
                        (revisions[4], revisions_2[5]))
262
 
        self.assertEqual(None, common_ancestor(None, revisions[5], sources))
 
280
        self.assertEqual(common_ancestor(revisions[5], revisions_2[6], sources),
 
281
                          revisions[4]) # revisions_2[5] is equally valid
 
282
        self.assertEqual(common_ancestor(revisions_2[6], revisions[5], sources),
 
283
                          revisions[4]) # revisions_2[5] is equally valid
263
284
 
264
285
    def test_combined(self):
265
286
        """combined_graph
266
287
        Ensure it's not order-sensitive
267
288
        """
268
 
        br1, br2 = make_branches(self)
269
 
        source = MultipleRevisionSources(br1.repository, br2.repository)
 
289
        br1, br2 = make_branches()
 
290
        source = MultipleRevisionSources(br1, br2)
270
291
        combined_1 = combined_graph(br1.last_revision(), 
271
292
                                    br2.last_revision(), source)
272
293
        combined_2 = combined_graph(br2.last_revision(),
273
294
                                    br1.last_revision(), source)
274
 
        self.assertEquals(combined_1[1], combined_2[1])
275
 
        self.assertEquals(combined_1[2], combined_2[2])
276
 
        self.assertEquals(combined_1[3], combined_2[3])
277
 
        self.assertEquals(combined_1, combined_2)
278
 
 
279
 
    def test_get_history(self):
280
 
        # TODO: test ghosts on the left hand branch's impact
281
 
        # TODO: test ghosts on all parents, we should get some
282
 
        # indicator. i.e. NULL_REVISION
283
 
        # RBC 20060608
284
 
        tree = self.make_branch_and_tree('.')
285
 
        tree.commit('1', rev_id = '1', allow_pointless=True)
286
 
        tree.commit('2', rev_id = '2', allow_pointless=True)
287
 
        tree.commit('3', rev_id = '3', allow_pointless=True)
288
 
        rev = tree.branch.repository.get_revision('1')
289
 
        history = rev.get_history(tree.branch.repository)
290
 
        self.assertEqual([None, '1'], history)
291
 
        rev = tree.branch.repository.get_revision('2')
292
 
        history = rev.get_history(tree.branch.repository)
293
 
        self.assertEqual([None, '1', '2'], history)
294
 
        rev = tree.branch.repository.get_revision('3')
295
 
        history = rev.get_history(tree.branch.repository)
296
 
        self.assertEqual([None, '1', '2' ,'3'], history)
297
 
 
298
 
    def test_common_ancestor_rootless_graph(self):
299
 
        # common_ancestor on a graph with no reachable roots - only
300
 
        # ghosts - should still return a useful value.
301
 
        graph = Graph()
302
 
        # add a ghost node which would be a root if it wasn't a ghost.
303
 
        graph.add_ghost('a_ghost')
304
 
        # add a normal commit on top of that
305
 
        graph.add_node('rev1', ['a_ghost'])
306
 
        # add a left-branch revision
307
 
        graph.add_node('left', ['rev1'])
308
 
        # add a right-branch revision
309
 
        graph.add_node('right', ['rev1'])
310
 
        source = MockRevisionSource(graph)
311
 
        self.assertEqual('rev1', common_ancestor('left', 'right', source))
312
 
 
313
 
 
314
 
class TestMultipleRevisionSources(TestCaseWithTransport):
315
 
    """Tests for the MultipleRevisionSources adapter."""
316
 
 
317
 
    def test_get_revision_graph_merges_ghosts(self):
318
 
        # when we ask for the revision graph for B, which
319
 
        # is in repo 1 with a ghost of A, and which is not
320
 
        # in repo 2, which has A, the revision_graph()
321
 
        # should return A and B both.
322
 
        tree_1 = self.make_branch_and_tree('1')
323
 
        tree_1.add_pending_merge('A')
324
 
        tree_1.commit('foo', rev_id='B', allow_pointless=True)
325
 
        tree_2 = self.make_branch_and_tree('2')
326
 
        tree_2.commit('bar', rev_id='A', allow_pointless=True)
327
 
        source = MultipleRevisionSources(tree_1.branch.repository,
328
 
                                         tree_2.branch.repository)
329
 
        self.assertEqual({'B':['A'],
330
 
                          'A':[]},
331
 
                         source.get_revision_graph('B'))
 
295
        assert combined_1[1] == combined_2[1]
 
296
        assert combined_1[2] == combined_2[2]
 
297
        assert combined_1[3] == combined_2[3]
 
298
        assert combined_1 == combined_2