← 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-22 07:59:56 UTC
  • mfrom: (1553.5.33 bzr.mbp.locks)
  • Revision ID: pqm@pqm.ubuntu.com-20060222075956-fb281c427e571da6
add LockDir and related fixes

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