← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revision.py

  • Committer: Aaron Bentley
  • Date: 2006-07-10 19:23:53 UTC
  • mto: This revision was merged to the branch mainline in revision 1848.
  • Revision ID: abentley@panoramicfeedback.com-20060710192353-469477798c5c4139
Switch to John Meinel's _unescape_xml implementation

Show diffs side-by-side

added added

removed removed

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