/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: Martin Pool
  • Date: 2007-10-03 08:06:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2901.
  • Revision ID: mbp@sourcefrog.net-20071003080644-oivy0gkg98sex0ed
Avoid internal error tracebacks on failure to lock on readonly transport (#129701).

Add new LockFailed, which doesn't imply that we failed to get it because of
contention.  Raise this if we fail to create the pending or lock directories
because of Transport errors.

UnlockableTransport is not an internal error.

ReadOnlyLockError has a message which didn't match its name or usage; it's now
deprecated and callers are updated to use LockFailed which is more appropriate.

Add zero_ninetytwo deprecation symbol.

Unify assertMatchesRe with TestCase.assertContainsRe.

When the constructor is deprecated, just say that the class is deprecated, not
the __init__ method - this works better with applyDeprecated in tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_revision.py
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
19
import warnings
20
20
 
21
21
from bzrlib import (
22
 
    bugtracker,
23
22
    revision,
24
 
    symbol_versioning,
25
23
    )
26
24
from bzrlib.branch import Branch
27
 
from bzrlib.errors import (
28
 
    InvalidBugStatus,
29
 
    InvalidLineInBugsProperty,
30
 
    NoSuchRevision,
31
 
    )
 
25
from bzrlib.errors import NoSuchRevision
32
26
from bzrlib.deprecated_graph import Graph
33
 
from bzrlib.revision import (find_present_ancestors,
 
27
from bzrlib.revision import (find_present_ancestors, combined_graph,
 
28
                             common_ancestor,
 
29
                             is_ancestor, MultipleRevisionSources,
34
30
                             NULL_REVISION)
35
31
from bzrlib.tests import TestCase, TestCaseWithTransport
36
32
from bzrlib.trace import mutter
51
47
 
52
48
    the object graph is
53
49
    B:     A:
54
 
    a..0   a..0
 
50
    a..0   a..0 
55
51
    a..1   a..1
56
52
    a..2   a..2
57
53
    b..3   a..3 merges b..4
64
60
    """
65
61
    tree1 = self.make_branch_and_tree("branch1", format=format)
66
62
    br1 = tree1.branch
67
 
 
 
63
    
68
64
    tree1.commit("Commit one", rev_id="a@u-0-0")
69
65
    tree1.commit("Commit two", rev_id="a@u-0-1")
70
66
    tree1.commit("Commit three", rev_id="a@u-0-2")
71
67
 
72
 
    tree2 = tree1.bzrdir.sprout("branch2").open_workingtree()
 
68
    tree2 = tree1.bzrdir.clone("branch2").open_workingtree()
73
69
    br2 = tree2.branch
74
70
    tree2.commit("Commit four", rev_id="b@u-0-3")
75
71
    tree2.commit("Commit five", rev_id="b@u-0-4")
76
72
    revisions_2 = br2.revision_history()
77
73
    self.assertEquals(revisions_2[-1], 'b@u-0-4')
78
 
 
 
74
    
79
75
    tree1.merge_from_branch(br2)
80
76
    tree1.commit("Commit six", rev_id="a@u-0-3")
81
77
    tree1.commit("Commit seven", rev_id="a@u-0-4")
82
78
    tree2.commit("Commit eight", rev_id="b@u-0-5")
83
79
    self.assertEquals(br2.revision_history()[-1], 'b@u-0-5')
84
 
 
 
80
    
85
81
    tree1.merge_from_branch(br2)
86
82
    tree1.commit("Commit nine", rev_id="a@u-0-5")
87
83
    # DO NOT MERGE HERE - we WANT a GHOST.
88
84
    tree2.add_parent_tree_id(br1.revision_history()[4])
89
85
    tree2.commit("Commit ten - ghost merge", rev_id="b@u-0-6")
90
 
 
 
86
    
91
87
    return br1, br2
92
88
 
93
89
 
127
123
                       rev_id, branch.repository.get_ancestry(rev_id))
128
124
                result = sorted(branch.repository.get_ancestry(rev_id))
129
125
                self.assertEquals(result, [None] + sorted(anc))
 
126
    
 
127
    
 
128
    def test_is_ancestor(self):
 
129
        """Test checking whether a revision is an ancestor of another revision"""
 
130
        br1, br2 = make_branches(self)
 
131
        revisions = br1.revision_history()
 
132
        revisions_2 = br2.revision_history()
 
133
        sources = br1
 
134
 
 
135
        self.assert_(is_ancestor(revisions[0], revisions[0], br1))
 
136
        self.assert_(is_ancestor(revisions[1], revisions[0], sources))
 
137
        self.assert_(not is_ancestor(revisions[0], revisions[1], sources))
 
138
        self.assert_(is_ancestor(revisions_2[3], revisions[0], sources))
 
139
        # disabled mbp 20050914, doesn't seem to happen anymore
 
140
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
 
141
        ##                  revisions[0], br1)        
 
142
        self.assert_(is_ancestor(revisions[3], revisions_2[4], sources))
 
143
        self.assert_(is_ancestor(revisions[3], revisions_2[4], br1))
 
144
        self.assert_(is_ancestor(revisions[3], revisions_2[3], sources))
 
145
        ## self.assert_(not is_ancestor(revisions[3], revisions_2[3], br1))
130
146
 
131
147
 
132
148
class TestIntermediateRevisions(TestCaseWithTransport):
146
162
        wt2.merge_from_branch(self.br1)
147
163
        wt2.commit("Commit fifteen", rev_id="b@u-0-10")
148
164
 
 
165
        from bzrlib.revision import MultipleRevisionSources
 
166
        self.sources = MultipleRevisionSources(self.br1.repository,
 
167
                                               self.br2.repository)
 
168
 
 
169
 
149
170
 
150
171
class MockRevisionSource(object):
151
172
    """A RevisionSource that takes a pregenerated graph.
165
186
class TestCommonAncestor(TestCaseWithTransport):
166
187
    """Test checking whether a revision is an ancestor of another revision"""
167
188
 
 
189
    def test_common_ancestor(self):
 
190
        """Pick a reasonable merge base"""
 
191
        br1, br2 = make_branches(self)
 
192
        revisions = br1.revision_history()
 
193
        revisions_2 = br2.revision_history()
 
194
        sources = MultipleRevisionSources(br1.repository, br2.repository)
 
195
        expected_ancestors_list = {revisions[3]:(0, 0), 
 
196
                                   revisions[2]:(1, 1),
 
197
                                   revisions_2[4]:(2, 1), 
 
198
                                   revisions[1]:(3, 2),
 
199
                                   revisions_2[3]:(4, 2),
 
200
                                   revisions[0]:(5, 3) }
 
201
        ancestors_list = find_present_ancestors(revisions[3], sources)
 
202
        self.assertEquals(len(expected_ancestors_list), len(ancestors_list))
 
203
        for key, value in expected_ancestors_list.iteritems():
 
204
            self.assertEqual(ancestors_list[key], value, 
 
205
                              "key %r, %r != %r" % (key, ancestors_list[key],
 
206
                                                    value))
 
207
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
 
208
                          revisions[0])
 
209
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
 
210
                          revisions[1])
 
211
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
 
212
                          revisions[1])
 
213
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
 
214
                          revisions[2])
 
215
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
 
216
                          revisions_2[4])
 
217
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
 
218
                          revisions_2[4])
 
219
        self.assertTrue(common_ancestor(revisions[5], revisions_2[6], sources) in
 
220
                        (revisions[4], revisions_2[5]))
 
221
        self.assertTrue(common_ancestor(revisions_2[6], revisions[5], sources),
 
222
                        (revisions[4], revisions_2[5]))
 
223
        self.assertEqual(None, common_ancestor(None, revisions[5], sources))
 
224
        self.assertEqual(NULL_REVISION,
 
225
            common_ancestor(NULL_REVISION, NULL_REVISION, sources))
 
226
        self.assertEqual(NULL_REVISION,
 
227
            common_ancestor(revisions[0], NULL_REVISION, sources))
 
228
        self.assertEqual(NULL_REVISION,
 
229
            common_ancestor(NULL_REVISION, revisions[0], sources))
 
230
 
 
231
    def test_combined(self):
 
232
        """combined_graph
 
233
        Ensure it's not order-sensitive
 
234
        """
 
235
        br1, br2 = make_branches(self)
 
236
        source = MultipleRevisionSources(br1.repository, br2.repository)
 
237
        combined_1 = combined_graph(br1.last_revision(),
 
238
                                    br2.last_revision(), source)
 
239
        combined_2 = combined_graph(br2.last_revision(),
 
240
                                    br1.last_revision(), source)
 
241
        self.assertEquals(combined_1[1], combined_2[1])
 
242
        self.assertEquals(combined_1[2], combined_2[2])
 
243
        self.assertEquals(combined_1[3], combined_2[3])
 
244
        self.assertEquals(combined_1, combined_2)
 
245
 
168
246
    def test_get_history(self):
169
247
        # TODO: test ghosts on the left hand branch's impact
170
248
        # TODO: test ghosts on all parents, we should get some
184
262
        history = rev.get_history(tree.branch.repository)
185
263
        self.assertEqual([None, '1', '2' ,'3'], history)
186
264
 
 
265
    def test_common_ancestor_rootless_graph(self):
 
266
        # common_ancestor on a graph with no reachable roots - only
 
267
        # ghosts - should still return a useful value.
 
268
        graph = Graph()
 
269
        # add a ghost node which would be a root if it wasn't a ghost.
 
270
        graph.add_ghost('a_ghost')
 
271
        # add a normal commit on top of that
 
272
        graph.add_node('rev1', ['a_ghost'])
 
273
        # add a left-branch revision
 
274
        graph.add_node('left', ['rev1'])
 
275
        # add a right-branch revision
 
276
        graph.add_node('right', ['rev1'])
 
277
        source = MockRevisionSource(graph)
 
278
        self.assertEqual('rev1', common_ancestor('left', 'right', source))
 
279
 
 
280
 
 
281
class TestMultipleRevisionSources(TestCaseWithTransport):
 
282
    """Tests for the MultipleRevisionSources adapter."""
 
283
 
 
284
    def test_get_revision_graph_merges_ghosts(self):
 
285
        # when we ask for the revision graph for B, which
 
286
        # is in repo 1 with a ghost of A, and which is not
 
287
        # in repo 2, which has A, the revision_graph()
 
288
        # should return A and B both.
 
289
        tree_1 = self.make_branch_and_tree('1')
 
290
        tree_1.set_parent_ids(['A'], allow_leftmost_as_ghost=True)
 
291
        tree_1.commit('foo', rev_id='B', allow_pointless=True)
 
292
        tree_2 = self.make_branch_and_tree('2')
 
293
        tree_2.commit('bar', rev_id='A', allow_pointless=True)
 
294
        source = MultipleRevisionSources(tree_1.branch.repository,
 
295
                                         tree_2.branch.repository)
 
296
        self.assertEqual({'B':['A'],
 
297
                          'A':[]},
 
298
                         source.get_revision_graph('B'))
 
299
 
187
300
 
188
301
class TestReservedId(TestCase):
189
302
 
208
321
        self.assertEqual('a', r.get_summary())
209
322
        r.message = '\na\nb'
210
323
        self.assertEqual('a', r.get_summary())
211
 
        r.message = None
212
 
        self.assertEqual('', r.get_summary())
213
324
 
214
325
    def test_get_apparent_author(self):
215
326
        r = revision.Revision('1')
216
327
        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())
 
328
        self.assertEqual('A', r.get_apparent_author())
 
329
        r.properties['author'] = 'B'
 
330
        self.assertEqual('B', r.get_apparent_author())