← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testrevision.py

- refactor handling of short option names

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'])
184
181
                                        self.br1.revision_history()), 
185
182
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
186
183
                          'a@u-0-5'])
187
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
188
 
                         self.br1.revision_history()), 
189
 
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
190
 
                          'b@u-0-6'])
191
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
192
 
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
193
 
                          'b@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'])
194
193
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
195
194
                         self.br2.revision_history()), 
196
195
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
207
206
                          'c@u-0-6', self.br2.revision_history())
208
207
 
209
208
 
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):
 
209
class TestCommonAncestor(TestCaseInTempDir):
226
210
    """Test checking whether a revision is an ancestor of another revision"""
227
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
 
228
251
    def test_common_ancestor(self):
229
252
        """Pick a reasonable merge base"""
230
 
        br1, br2 = make_branches(self)
 
253
        from bzrlib.revision import common_ancestor
 
254
        br1, br2 = make_branches()
231
255
        revisions = br1.revision_history()
232
256
        revisions_2 = br2.revision_history()
233
 
        sources = MultipleRevisionSources(br1.repository, br2.repository)
 
257
        sources = MultipleRevisionSources(br1, br2)
234
258
        expected_ancestors_list = {revisions[3]:(0, 0), 
235
259
                                   revisions[2]:(1, 1),
236
260
                                   revisions_2[4]:(2, 1), 
238
262
                                   revisions_2[3]:(4, 2),
239
263
                                   revisions[0]:(5, 3) }
240
264
        ancestors_list = find_present_ancestors(revisions[3], sources)
241
 
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
 
265
        assert len(expected_ancestors_list) == len(ancestors_list)
242
266
        for key, value in expected_ancestors_list.iteritems():
243
267
            self.assertEqual(ancestors_list[key], value, 
244
268
                              "key %r, %r != %r" % (key, ancestors_list[key],
255
279
                          revisions_2[4])
256
280
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
257
281
                          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))
 
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
263
286
 
264
287
    def test_combined(self):
265
288
        """combined_graph
266
289
        Ensure it's not order-sensitive
267
290
        """
268
 
        br1, br2 = make_branches(self)
269
 
        source = MultipleRevisionSources(br1.repository, br2.repository)
 
291
        br1, br2 = make_branches()
 
292
        source = MultipleRevisionSources(br1, br2)
270
293
        combined_1 = combined_graph(br1.last_revision(), 
271
294
                                    br2.last_revision(), source)
272
295
        combined_2 = combined_graph(br2.last_revision(),
273
296
                                    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'))
 
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