← 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: Canonical.com Patch Queue Manager
  • Date: 2006-02-18 02:33:47 UTC
  • mfrom: (1534.1.24 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060218023347-0952c65f668bfd68
Merge Robert Collins integration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_revision.py
17
17
 
18
18
import os
19
19
 
20
 
from bzrlib.selftest import TestCaseInTempDir
21
20
from bzrlib.branch import Branch
 
21
from bzrlib.errors import NoSuchRevision
22
22
from bzrlib.commit import commit
23
23
from bzrlib.fetch import fetch
24
24
from bzrlib.revision import (find_present_ancestors, combined_graph,
25
25
                             is_ancestor, MultipleRevisionSources)
 
26
from bzrlib.tests import TestCaseWithTransport
26
27
from bzrlib.trace import mutter
27
 
from bzrlib.errors import NoSuchRevision
 
28
from bzrlib.workingtree import WorkingTree
28
29
 
29
 
def make_branches():
 
30
# XXX: Make this a method of a merge base case
 
31
def make_branches(self):
30
32
    """Create two branches
31
33
 
32
34
    branch 1 has 6 commits, branch 2 has 3 commits
47
49
    so A is missing b6 at the start
48
50
    and B is missing a3, a4, a5
49
51
    """
50
 
    os.mkdir("branch1")
51
 
    br1 = Branch.initialize("branch1")
 
52
    tree1 = self.make_branch_and_tree("branch1")
 
53
    br1 = tree1.branch
52
54
    
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")
 
55
    tree1.commit("Commit one", rev_id="a@u-0-0")
 
56
    tree1.commit("Commit two", rev_id="a@u-0-1")
 
57
    tree1.commit("Commit three", rev_id="a@u-0-2")
56
58
 
57
 
    os.mkdir("branch2")
58
 
    br2 = Branch.initialize("branch2")
 
59
    tree2 = self.make_branch_and_tree("branch2")
 
60
    br2 = tree2.branch
59
61
    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
    tree2.commit("Commit four", rev_id="b@u-0-3")
 
63
    tree2.commit("Commit five", rev_id="b@u-0-4")
62
64
    revisions_2 = br2.revision_history()
63
65
    
64
66
    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")
 
67
    tree1.add_pending_merge(revisions_2[4])
 
68
    self.assertEquals(revisions_2[4], 'b@u-0-4')
 
69
    tree1.commit("Commit six", rev_id="a@u-0-3")
 
70
    tree1.commit("Commit seven", rev_id="a@u-0-4")
 
71
    tree2.commit("Commit eight", rev_id="b@u-0-5")
70
72
    
71
73
    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
    tree1.add_pending_merge(br2.revision_history()[5])
 
75
    tree1.commit("Commit nine", rev_id="a@u-0-5")
74
76
    # DO NOT FETCH HERE - we WANT a GHOST.
75
77
    #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
    tree2.add_pending_merge(br1.revision_history()[4])
 
79
    tree2.commit("Commit ten - ghost merge", rev_id="b@u-0-6")
78
80
    
79
81
    return br1, br2
80
82
 
81
83
 
82
 
class TestIsAncestor(TestCaseInTempDir):
 
84
class TestIsAncestor(TestCaseWithTransport):
 
85
 
83
86
    def test_recorded_ancestry(self):
84
87
        """Test that commit records all ancestors"""
85
 
        br1, br2 = make_branches()
 
88
        br1, br2 = make_branches(self)
86
89
        d = [('a@u-0-0', ['a@u-0-0']),
87
90
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
88
91
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
111
114
                if rev_id in br2_only and not branch is br2:
112
115
                    continue
113
116
                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))
 
117
                       rev_id, branch.repository.get_ancestry(rev_id))
 
118
                result = sorted(branch.repository.get_ancestry(rev_id))
 
119
                self.assertEquals(result, [None] + sorted(anc))
117
120
    
118
121
    
119
122
    def test_is_ancestor(self):
120
123
        """Test checking whether a revision is an ancestor of another revision"""
121
 
        br1, br2 = make_branches()
 
124
        br1, br2 = make_branches(self)
122
125
        revisions = br1.revision_history()
123
126
        revisions_2 = br2.revision_history()
124
127
        sources = br1
125
128
 
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)
 
129
        self.assert_(is_ancestor(revisions[0], revisions[0], br1))
 
130
        self.assert_(is_ancestor(revisions[1], revisions[0], sources))
 
131
        self.assert_(not is_ancestor(revisions[0], revisions[1], sources))
 
132
        self.assert_(is_ancestor(revisions_2[3], revisions[0], sources))
130
133
        # disabled mbp 20050914, doesn't seem to happen anymore
131
134
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
132
135
        ##                  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):
 
136
        self.assert_(is_ancestor(revisions[3], revisions_2[4], sources))
 
137
        self.assert_(is_ancestor(revisions[3], revisions_2[4], br1))
 
138
        self.assert_(is_ancestor(revisions[3], revisions_2[3], sources))
 
139
        ## self.assert_(not is_ancestor(revisions[3], revisions_2[3], br1))
 
140
 
 
141
 
 
142
class TestIntermediateRevisions(TestCaseWithTransport):
140
143
 
141
144
    def setUp(self):
142
145
        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")
 
146
        TestCaseWithTransport.setUp(self)
 
147
        self.br1, self.br2 = make_branches(self)
 
148
        wt1 = self.br1.bzrdir.open_workingtree()
 
149
        wt2 = self.br2.bzrdir.open_workingtree()
 
150
        wt2.commit("Commit eleven", rev_id="b@u-0-7")
 
151
        wt2.commit("Commit twelve", rev_id="b@u-0-8")
 
152
        wt2.commit("Commit thirtteen", rev_id="b@u-0-9")
149
153
 
150
154
        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")
 
155
        wt1.add_pending_merge(self.br2.revision_history()[6])
 
156
        wt1.commit("Commit fourtten", rev_id="a@u-0-6")
153
157
 
154
158
        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
        wt2.add_pending_merge(self.br1.revision_history()[6])
 
160
        wt2.commit("Commit fifteen", rev_id="b@u-0-10")
157
161
 
158
162
        from bzrlib.revision import MultipleRevisionSources
159
 
        self.sources = MultipleRevisionSources(self.br1, self.br2)
 
163
        self.sources = MultipleRevisionSources(self.br1.repository,
 
164
                                               self.br2.repository)
160
165
 
161
166
    def intervene(self, ancestor, revision, revision_history=None):
162
167
        from bzrlib.revision import get_intervening_revisions
166
171
    def test_intervene(self):
167
172
        """Find intermediate revisions, without requiring history"""
168
173
        from bzrlib.errors import NotAncestor, NoSuchRevision
169
 
        assert len(self.intervene('a@u-0-0', 'a@u-0-0')) == 0
 
174
        self.assertEquals(len(self.intervene('a@u-0-0', 'a@u-0-0')), 0)
170
175
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
171
176
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
172
177
                         ['a@u-0-1', 'a@u-0-2'])
181
186
                                        self.br1.revision_history()), 
182
187
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
183
188
                          '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'])
 
189
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-6', 
 
190
                         self.br1.revision_history()), 
 
191
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
 
192
                          'b@u-0-6'])
 
193
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-5'), 
 
194
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3', 'b@u-0-4', 
 
195
                          'b@u-0-5'])
193
196
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
194
197
                         self.br2.revision_history()), 
195
198
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
206
209
                          'c@u-0-6', self.br2.revision_history())
207
210
 
208
211
 
209
 
class TestCommonAncestor(TestCaseInTempDir):
 
212
class TestCommonAncestor(TestCaseWithTransport):
210
213
    """Test checking whether a revision is an ancestor of another revision"""
211
214
 
212
215
    def test_old_common_ancestor(self):
213
216
        """Pick a resonable merge base using the old functionality"""
214
217
        from bzrlib.revision import old_common_ancestor as common_ancestor
215
 
        br1, br2 = make_branches()
 
218
        br1, br2 = make_branches(self)
216
219
        revisions = br1.revision_history()
217
220
        revisions_2 = br2.revision_history()
218
 
        sources = br1
 
221
        sources = br1.repository
219
222
 
220
223
        expected_ancestors_list = {revisions[3]:(0, 0), 
221
224
                                   revisions[2]:(1, 1),
224
227
                                   revisions_2[3]:(4, 2),
225
228
                                   revisions[0]:(5, 3) }
226
229
        ancestors_list = find_present_ancestors(revisions[3], sources)
227
 
        assert len(expected_ancestors_list) == len(ancestors_list)
 
230
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
228
231
        for key, value in expected_ancestors_list.iteritems():
229
232
            self.assertEqual(ancestors_list[key], value, 
230
233
                              "key %r, %r != %r" % (key, ancestors_list[key],
251
254
    def test_common_ancestor(self):
252
255
        """Pick a reasonable merge base"""
253
256
        from bzrlib.revision import common_ancestor
254
 
        br1, br2 = make_branches()
 
257
        br1, br2 = make_branches(self)
255
258
        revisions = br1.revision_history()
256
259
        revisions_2 = br2.revision_history()
257
 
        sources = MultipleRevisionSources(br1, br2)
 
260
        sources = MultipleRevisionSources(br1.repository, br2.repository)
258
261
        expected_ancestors_list = {revisions[3]:(0, 0), 
259
262
                                   revisions[2]:(1, 1),
260
263
                                   revisions_2[4]:(2, 1), 
262
265
                                   revisions_2[3]:(4, 2),
263
266
                                   revisions[0]:(5, 3) }
264
267
        ancestors_list = find_present_ancestors(revisions[3], sources)
265
 
        assert len(expected_ancestors_list) == len(ancestors_list)
 
268
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
266
269
        for key, value in expected_ancestors_list.iteritems():
267
270
            self.assertEqual(ancestors_list[key], value, 
268
271
                              "key %r, %r != %r" % (key, ancestors_list[key],
288
291
        """combined_graph
289
292
        Ensure it's not order-sensitive
290
293
        """
291
 
        br1, br2 = make_branches()
292
 
        source = MultipleRevisionSources(br1, br2)
 
294
        br1, br2 = make_branches(self)
 
295
        source = MultipleRevisionSources(br1.repository, br2.repository)
293
296
        combined_1 = combined_graph(br1.last_revision(), 
294
297
                                    br2.last_revision(), source)
295
298
        combined_2 = combined_graph(br2.last_revision(),
296
299
                                    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
 
300
        self.assertEquals(combined_1[1], combined_2[1])
 
301
        self.assertEquals(combined_1[2], combined_2[2])
 
302
        self.assertEquals(combined_1[3], combined_2[3])
 
303
        self.assertEquals(combined_1, combined_2)
 
304
 
 
305
    def test_get_history(self):
 
306
        # TODO: test ghosts on the left hand branch's impact
 
307
        # TODO: test ghosts on all parents, we should get some
 
308
        # indicator. i.e. NULL_REVISION
 
309
        # RBC 20060608
 
310
        tree = self.make_branch_and_tree('.')
 
311
        tree.commit('1', rev_id = '1', allow_pointless=True)
 
312
        tree.commit('2', rev_id = '2', allow_pointless=True)
 
313
        tree.commit('3', rev_id = '3', allow_pointless=True)
 
314
        rev = tree.branch.repository.get_revision('1')
 
315
        history = rev.get_history(tree.branch.repository)
 
316
        self.assertEqual([None, '1'], history)
 
317
        rev = tree.branch.repository.get_revision('2')
 
318
        history = rev.get_history(tree.branch.repository)
 
319
        self.assertEqual([None, '1', '2'], history)
 
320
        rev = tree.branch.repository.get_revision('3')
 
321
        history = rev.get_history(tree.branch.repository)
 
322
        self.assertEqual([None, '1', '2' ,'3'], history)