/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_revision.py

  • Committer: Michael Ellerman
  • Date: 2006-05-31 08:44:29 UTC
  • mto: (1711.2.63 jam-integration)
  • mto: This revision was merged to the branch mainline in revision 1792.
  • Revision ID: michael@ellerman.id.au-20060531084429-35e5429abda9f560
Add optional location to ancestry and fix behaviour for checkouts.

This adds an optional location parameter to the ancestry command. It also
changes the behaviour of ancestry on checkouts such that if they have
been created with a subset of the branch history, only the subset is
shown by 'bzr ancestry'. Tests for all of that as well.

Show diffs side-by-side

added added

removed removed

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