~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-06 11:40:12 UTC
  • mto: This revision was merged to the branch mainline in revision 1420.
  • Revision ID: robertc@robertcollins.net-20051006114012-c0acdb4146f9ea26
add sample test script

Show diffs side-by-side

added added

removed removed

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