← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revision.py

(vila) Calling super() instead of mentioning the base class in setUp avoid
 mistakes. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_revision.py
1
 
# (C) 2005 Canonical Ltd
2
 
 
 
1
# Copyright (C) 2005-2011 Canonical Ltd
 
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
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
 
18
 
import os
19
 
 
20
 
from bzrlib.branch import Branch
21
 
from bzrlib.errors import NoSuchRevision
22
 
from bzrlib.commit import commit
23
 
from bzrlib.graph import Graph
24
 
from bzrlib.revision import (find_present_ancestors, combined_graph,
25
 
                             common_ancestor,
26
 
                             is_ancestor, MultipleRevisionSources)
27
 
from bzrlib.tests import TestCaseWithTransport
28
 
from bzrlib.trace import mutter
29
 
from bzrlib.workingtree import WorkingTree
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
 
 
18
import warnings
 
19
 
 
20
from bzrlib import (
 
21
    bugtracker,
 
22
    revision,
 
23
    )
 
24
from bzrlib.errors import (
 
25
    InvalidBugStatus,
 
26
    InvalidLineInBugsProperty,
 
27
    )
 
28
from bzrlib.revision import NULL_REVISION
 
29
from bzrlib.tests import TestCase, TestCaseWithTransport
 
30
from bzrlib.tests.matchers import MatchesAncestry
 
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')
30
37
 
31
38
# XXX: Make this a method of a merge base case
32
 
def make_branches(self):
 
39
def make_branches(self, format=None):
33
40
    """Create two branches
34
41
 
35
42
    branch 1 has 6 commits, branch 2 has 3 commits
37
44
 
38
45
    the object graph is
39
46
    B:     A:
40
 
    a..0   a..0 
 
47
    a..0   a..0
41
48
    a..1   a..1
42
49
    a..2   a..2
43
50
    b..3   a..3 merges b..4
48
55
    so A is missing b6 at the start
49
56
    and B is missing a3, a4, a5
50
57
    """
51
 
    tree1 = self.make_branch_and_tree("branch1")
 
58
    tree1 = self.make_branch_and_tree("branch1", format=format)
52
59
    br1 = tree1.branch
53
 
    
 
60
 
54
61
    tree1.commit("Commit one", rev_id="a@u-0-0")
55
62
    tree1.commit("Commit two", rev_id="a@u-0-1")
56
63
    tree1.commit("Commit three", rev_id="a@u-0-2")
57
64
 
58
 
    tree2 = self.make_branch_and_tree("branch2")
 
65
    tree2 = tree1.bzrdir.sprout("branch2").open_workingtree()
59
66
    br2 = tree2.branch
60
 
    br2.update_revisions(br1)
61
67
    tree2.commit("Commit four", rev_id="b@u-0-3")
62
68
    tree2.commit("Commit five", rev_id="b@u-0-4")
63
 
    revisions_2 = br2.revision_history()
64
 
    
65
 
    br1.fetch(br2)
66
 
    tree1.add_pending_merge(revisions_2[4])
67
 
    self.assertEquals(revisions_2[4], 'b@u-0-4')
 
69
    self.assertEquals(br2.last_revision(), 'b@u-0-4')
 
70
 
 
71
    tree1.merge_from_branch(br2)
68
72
    tree1.commit("Commit six", rev_id="a@u-0-3")
69
73
    tree1.commit("Commit seven", rev_id="a@u-0-4")
70
74
    tree2.commit("Commit eight", rev_id="b@u-0-5")
71
 
    
72
 
    br1.fetch(br2)
73
 
    tree1.add_pending_merge(br2.revision_history()[5])
 
75
    self.assertEquals(br2.last_revision(), 'b@u-0-5')
 
76
 
 
77
    tree1.merge_from_branch(br2)
74
78
    tree1.commit("Commit nine", rev_id="a@u-0-5")
75
 
    # DO NOT FETCH HERE - we WANT a GHOST.
76
 
    # br2.fetch(br1)
77
 
    tree2.add_pending_merge(br1.revision_history()[4])
 
79
    # DO NOT MERGE HERE - we WANT a GHOST.
 
80
    br1.lock_read()
 
81
    try:
 
82
        graph = br1.repository.get_graph()
 
83
        revhistory = list(graph.iter_lefthand_ancestry(br1.last_revision(),
 
84
            [revision.NULL_REVISION]))
 
85
        revhistory.reverse()
 
86
    finally:
 
87
        br1.unlock()
 
88
    tree2.add_parent_tree_id(revhistory[4])
78
89
    tree2.commit("Commit ten - ghost merge", rev_id="b@u-0-6")
79
 
    
 
90
 
80
91
    return br1, br2
81
92
 
82
93
 
100
111
             ('a@u-0-5', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4',
101
112
                          'b@u-0-3', 'b@u-0-4',
102
113
                          'b@u-0-5', 'a@u-0-5']),
103
 
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2',
 
114
             ('b@u-0-6', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2', 'a@u-0-4',
104
115
                          'b@u-0-3', 'b@u-0-4',
105
116
                          'b@u-0-5', 'b@u-0-6']),
106
117
             ]
112
123
                    continue
113
124
                if rev_id in br2_only and not branch is br2:
114
125
                    continue
115
 
                mutter('ancestry of {%s}: %r',
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))
119
 
    
120
 
    
121
 
    def test_is_ancestor(self):
122
 
        """Test checking whether a revision is an ancestor of another revision"""
123
 
        br1, br2 = make_branches(self)
124
 
        revisions = br1.revision_history()
125
 
        revisions_2 = br2.revision_history()
126
 
        sources = br1
127
 
 
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))
132
 
        # disabled mbp 20050914, doesn't seem to happen anymore
133
 
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
134
 
        ##                  revisions[0], br1)        
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))
 
126
                self.assertThat(anc,
 
127
                    MatchesAncestry(branch.repository, rev_id))
139
128
 
140
129
 
141
130
class TestIntermediateRevisions(TestCaseWithTransport):
142
131
 
143
132
    def setUp(self):
144
 
        from bzrlib.commit import commit
145
133
        TestCaseWithTransport.setUp(self)
146
134
        self.br1, self.br2 = make_branches(self)
147
135
        wt1 = self.br1.bzrdir.open_workingtree()
150
138
        wt2.commit("Commit twelve", rev_id="b@u-0-8")
151
139
        wt2.commit("Commit thirtteen", rev_id="b@u-0-9")
152
140
 
153
 
        self.br1.fetch(self.br2)
154
 
        wt1.add_pending_merge(self.br2.revision_history()[6])
 
141
        wt1.merge_from_branch(self.br2)
155
142
        wt1.commit("Commit fourtten", rev_id="a@u-0-6")
156
143
 
157
 
        self.br2.fetch(self.br1)
158
 
        wt2.add_pending_merge(self.br1.revision_history()[6])
 
144
        wt2.merge_from_branch(self.br1)
159
145
        wt2.commit("Commit fifteen", rev_id="b@u-0-10")
160
146
 
161
 
        from bzrlib.revision import MultipleRevisionSources
162
 
        self.sources = MultipleRevisionSources(self.br1.repository,
163
 
                                               self.br2.repository)
164
 
 
165
 
    def intervene(self, ancestor, revision, revision_history=None):
166
 
        from bzrlib.revision import get_intervening_revisions
167
 
        return get_intervening_revisions(ancestor,revision, self.sources, 
168
 
                                         revision_history)
169
 
 
170
 
    def test_intervene(self):
171
 
        """Find intermediate revisions, without requiring history"""
172
 
        from bzrlib.errors import NotAncestor, NoSuchRevision
173
 
        self.assertEquals(len(self.intervene('a@u-0-0', 'a@u-0-0')), 0)
174
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-1'), ['a@u-0-1'])
175
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-2'), 
176
 
                         ['a@u-0-1', 'a@u-0-2'])
177
 
        self.assertEqual(self.intervene('a@u-0-0', 'b@u-0-3'), 
178
 
                         ['a@u-0-1', 'a@u-0-2', 'b@u-0-3'])
179
 
        self.assertEqual(self.intervene('b@u-0-3', 'a@u-0-3'), 
180
 
                         ['b@u-0-4', 'a@u-0-3'])
181
 
        self.assertEqual(self.intervene('a@u-0-2', 'a@u-0-3', 
182
 
                                        self.br1.revision_history()), 
183
 
                         ['a@u-0-3'])
184
 
        self.assertEqual(self.intervene('a@u-0-0', 'a@u-0-5', 
185
 
                                        self.br1.revision_history()), 
186
 
                         ['a@u-0-1', 'a@u-0-2', 'a@u-0-3', 'a@u-0-4', 
187
 
                          'a@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'])
195
 
        self.assertEqual(self.intervene('b@u-0-3', 'b@u-0-6', 
196
 
                         self.br2.revision_history()), 
197
 
                         ['b@u-0-4', 'b@u-0-5', 'b@u-0-6'])
198
 
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10'), 
199
 
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
200
 
        self.assertEqual(self.intervene('b@u-0-6', 'b@u-0-10', 
201
 
                                        self.br2.revision_history()), 
202
 
                         ['b@u-0-7', 'b@u-0-8', 'b@u-0-9', 'b@u-0-10'])
203
 
        self.assertRaises(NotAncestor, self.intervene, 'b@u-0-10', 'b@u-0-6', 
204
 
                          self.br2.revision_history())
205
 
        self.assertRaises(NoSuchRevision, self.intervene, 'c@u-0-10', 
206
 
                          'b@u-0-6', self.br2.revision_history())
207
 
        self.assertRaises(NoSuchRevision, self.intervene, 'b@u-0-10', 
208
 
                          'c@u-0-6', self.br2.revision_history())
209
 
 
210
147
 
211
148
class MockRevisionSource(object):
212
149
    """A RevisionSource that takes a pregenerated graph.
226
163
class TestCommonAncestor(TestCaseWithTransport):
227
164
    """Test checking whether a revision is an ancestor of another revision"""
228
165
 
229
 
    def test_common_ancestor(self):
230
 
        """Pick a reasonable merge base"""
231
 
        br1, br2 = make_branches(self)
232
 
        revisions = br1.revision_history()
233
 
        revisions_2 = br2.revision_history()
234
 
        sources = MultipleRevisionSources(br1.repository, br2.repository)
235
 
        expected_ancestors_list = {revisions[3]:(0, 0), 
236
 
                                   revisions[2]:(1, 1),
237
 
                                   revisions_2[4]:(2, 1), 
238
 
                                   revisions[1]:(3, 2),
239
 
                                   revisions_2[3]:(4, 2),
240
 
                                   revisions[0]:(5, 3) }
241
 
        ancestors_list = find_present_ancestors(revisions[3], sources)
242
 
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
243
 
        for key, value in expected_ancestors_list.iteritems():
244
 
            self.assertEqual(ancestors_list[key], value, 
245
 
                              "key %r, %r != %r" % (key, ancestors_list[key],
246
 
                                                    value))
247
 
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
248
 
                          revisions[0])
249
 
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
250
 
                          revisions[1])
251
 
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
252
 
                          revisions[1])
253
 
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
254
 
                          revisions[2])
255
 
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
256
 
                          revisions_2[4])
257
 
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
258
 
                          revisions_2[4])
259
 
        self.assertTrue(common_ancestor(revisions[5], revisions_2[6], sources) in
260
 
                        (revisions[4], revisions_2[5]))
261
 
        self.assertTrue(common_ancestor(revisions_2[6], revisions[5], sources),
262
 
                        (revisions[4], revisions_2[5]))
263
 
        self.assertEqual(None, common_ancestor(None, revisions[5], sources))
264
 
 
265
 
    def test_combined(self):
266
 
        """combined_graph
267
 
        Ensure it's not order-sensitive
268
 
        """
269
 
        br1, br2 = make_branches(self)
270
 
        source = MultipleRevisionSources(br1.repository, br2.repository)
271
 
        combined_1 = combined_graph(br1.last_revision(), 
272
 
                                    br2.last_revision(), source)
273
 
        combined_2 = combined_graph(br2.last_revision(),
274
 
                                    br1.last_revision(), source)
275
 
        self.assertEquals(combined_1[1], combined_2[1])
276
 
        self.assertEquals(combined_1[2], combined_2[2])
277
 
        self.assertEquals(combined_1[3], combined_2[3])
278
 
        self.assertEquals(combined_1, combined_2)
279
 
 
280
166
    def test_get_history(self):
281
167
        # TODO: test ghosts on the left hand branch's impact
282
168
        # TODO: test ghosts on all parents, we should get some
296
182
        history = rev.get_history(tree.branch.repository)
297
183
        self.assertEqual([None, '1', '2' ,'3'], history)
298
184
 
299
 
    def test_common_ancestor_rootless_graph(self):
300
 
        # common_ancestor on a graph with no reachable roots - only
301
 
        # ghosts - should still return a useful value.
302
 
        graph = Graph()
303
 
        # add a ghost node which would be a root if it wasn't a ghost.
304
 
        graph.add_ghost('a_ghost')
305
 
        # add a normal commit on top of that
306
 
        graph.add_node('rev1', ['a_ghost'])
307
 
        # add a left-branch revision
308
 
        graph.add_node('left', ['rev1'])
309
 
        # add a right-branch revision
310
 
        graph.add_node('right', ['rev1'])
311
 
        source = MockRevisionSource(graph)
312
 
        self.assertEqual('rev1', common_ancestor('left', 'right', source))
313
 
 
314
 
 
315
 
class TestMultipleRevisionSources(TestCaseWithTransport):
316
 
    """Tests for the MultipleRevisionSources adapter."""
317
 
 
318
 
    def test_get_revision_graph_merges_ghosts(self):
319
 
        # when we ask for the revision graph for B, which
320
 
        # is in repo 1 with a ghost of A, and which is not
321
 
        # in repo 2, which has A, the revision_graph()
322
 
        # should return A and B both.
323
 
        tree_1 = self.make_branch_and_tree('1')
324
 
        tree_1.add_pending_merge('A')
325
 
        tree_1.commit('foo', rev_id='B', allow_pointless=True)
326
 
        tree_2 = self.make_branch_and_tree('2')
327
 
        tree_2.commit('bar', rev_id='A', allow_pointless=True)
328
 
        source = MultipleRevisionSources(tree_1.branch.repository,
329
 
                                         tree_2.branch.repository)
330
 
        self.assertEqual({'B':['A'],
331
 
                          'A':[]},
332
 
                         source.get_revision_graph('B'))
 
185
 
 
186
class TestReservedId(TestCase):
 
187
 
 
188
    def test_is_reserved_id(self):
 
189
        self.assertEqual(True, revision.is_reserved_id(NULL_REVISION))
 
190
        self.assertEqual(True, revision.is_reserved_id(
 
191
            revision.CURRENT_REVISION))
 
192
        self.assertEqual(True, revision.is_reserved_id('arch:'))
 
193
        self.assertEqual(False, revision.is_reserved_id('null'))
 
194
        self.assertEqual(False, revision.is_reserved_id(
 
195
            'arch:a@example.com/c--b--v--r'))
 
196
        self.assertEqual(False, revision.is_reserved_id(None))
 
197
 
 
198
 
 
199
class TestRevisionMethods(TestCase):
 
200
 
 
201
    def test_get_summary(self):
 
202
        r = revision.Revision('1')
 
203
        r.message = 'a'
 
204
        self.assertEqual('a', r.get_summary())
 
205
        r.message = 'a\nb'
 
206
        self.assertEqual('a', r.get_summary())
 
207
        r.message = '\na\nb'
 
208
        self.assertEqual('a', r.get_summary())
 
209
        r.message = None
 
210
        self.assertEqual('', r.get_summary())
 
211
 
 
212
    def test_get_apparent_authors(self):
 
213
        r = revision.Revision('1')
 
214
        r.committer = 'A'
 
215
        self.assertEqual(['A'], r.get_apparent_authors())
 
216
        r.properties['author'] = 'B'
 
217
        self.assertEqual(['B'], r.get_apparent_authors())
 
218
        r.properties['authors'] = 'C\nD'
 
219
        self.assertEqual(['C', 'D'], r.get_apparent_authors())
 
220
 
 
221
    def test_get_apparent_authors_no_committer(self):
 
222
        r = revision.Revision('1')
 
223
        self.assertEqual([], r.get_apparent_authors())
 
224
 
 
225
 
 
226
class TestRevisionBugs(TestCase):
 
227
    """Tests for getting the bugs that a revision is linked to."""
 
228
 
 
229
    def test_no_bugs(self):
 
230
        r = revision.Revision('1')
 
231
        self.assertEqual([], list(r.iter_bugs()))
 
232
 
 
233
    def test_some_bugs(self):
 
234
        r = revision.Revision(
 
235
            '1', properties={
 
236
                'bugs': bugtracker.encode_fixes_bug_urls(
 
237
                    ['http://example.com/bugs/1',
 
238
                     'http://launchpad.net/bugs/1234'])})
 
239
        self.assertEqual(
 
240
            [('http://example.com/bugs/1', bugtracker.FIXED),
 
241
             ('http://launchpad.net/bugs/1234', bugtracker.FIXED)],
 
242
            list(r.iter_bugs()))
 
243
 
 
244
    def test_no_status(self):
 
245
        r = revision.Revision(
 
246
            '1', properties={'bugs': 'http://example.com/bugs/1'})
 
247
        self.assertRaises(InvalidLineInBugsProperty, list, r.iter_bugs())
 
248
 
 
249
    def test_too_much_information(self):
 
250
        r = revision.Revision(
 
251
            '1', properties={'bugs': 'http://example.com/bugs/1 fixed bar'})
 
252
        self.assertRaises(InvalidLineInBugsProperty, list, r.iter_bugs())
 
253
 
 
254
    def test_invalid_status(self):
 
255
        r = revision.Revision(
 
256
            '1', properties={'bugs': 'http://example.com/bugs/1 faxed'})
 
257
        self.assertRaises(InvalidBugStatus, list, r.iter_bugs())