← 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) Bzr config should save the changes explicitly when needed (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.selftest import TestCaseInTempDir
21
 
from bzrlib.branch import Branch
22
 
from bzrlib.commit import commit
23
 
from bzrlib.fetch import fetch
24
 
from bzrlib.revision import (find_present_ancestors, combined_graph,
25
 
                             is_ancestor, MultipleRevisionSources)
26
 
from bzrlib.trace import mutter
27
 
from bzrlib.errors import NoSuchRevision
28
 
 
29
 
def make_branches():
 
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')
 
37
 
 
38
# XXX: Make this a method of a merge base case
 
39
def make_branches(self, format=None):
30
40
    """Create two branches
31
41
 
32
42
    branch 1 has 6 commits, branch 2 has 3 commits
33
 
    commit 10 was a psuedo merge from branch 1
34
 
    but has been disabled until ghost support is
35
 
    implemented.
 
43
    commit 10 is a ghosted merge merge from branch 1
36
44
 
37
45
    the object graph is
38
46
    B:     A:
39
 
    a..0   a..0 
 
47
    a..0   a..0
40
48
    a..1   a..1
41
49
    a..2   a..2
42
50
    b..3   a..3 merges b..4
47
55
    so A is missing b6 at the start
48
56
    and B is missing a3, a4, a5
49
57
    """
50
 
    os.mkdir("branch1")
51
 
    br1 = Branch.initialize("branch1")
52
 
    
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")
56
 
 
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")
62
 
    revisions_2 = br2.revision_history()
63
 
    
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")
70
 
    
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")
74
 
    # 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")
78
 
    
 
58
    tree1 = self.make_branch_and_tree("branch1", format=format)
 
59
    br1 = tree1.branch
 
60
 
 
61
    tree1.commit("Commit one", rev_id="a@u-0-0")
 
62
    tree1.commit("Commit two", rev_id="a@u-0-1")
 
63
    tree1.commit("Commit three", rev_id="a@u-0-2")
 
64
 
 
65
    tree2 = tree1.bzrdir.sprout("branch2").open_workingtree()
 
66
    br2 = tree2.branch
 
67
    tree2.commit("Commit four", rev_id="b@u-0-3")
 
68
    tree2.commit("Commit five", rev_id="b@u-0-4")
 
69
    self.assertEquals(br2.last_revision(), 'b@u-0-4')
 
70
 
 
71
    tree1.merge_from_branch(br2)
 
72
    tree1.commit("Commit six", rev_id="a@u-0-3")
 
73
    tree1.commit("Commit seven", rev_id="a@u-0-4")
 
74
    tree2.commit("Commit eight", rev_id="b@u-0-5")
 
75
    self.assertEquals(br2.last_revision(), 'b@u-0-5')
 
76
 
 
77
    tree1.merge_from_branch(br2)
 
78
    tree1.commit("Commit nine", rev_id="a@u-0-5")
 
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])
 
89
    tree2.commit("Commit ten - ghost merge", rev_id="b@u-0-6")
 
90
 
79
91
    return br1, br2
80
92
 
81
93
 
82
 
class TestIsAncestor(TestCaseInTempDir):
 
94
class TestIsAncestor(TestCaseWithTransport):
 
95
 
83
96
    def test_recorded_ancestry(self):
84
97
        """Test that commit records all ancestors"""
85
 
        br1, br2 = make_branches()
 
98
        br1, br2 = make_branches(self)
86
99
        d = [('a@u-0-0', ['a@u-0-0']),
87
100
             ('a@u-0-1', ['a@u-0-0', 'a@u-0-1']),
88
101
             ('a@u-0-2', ['a@u-0-0', 'a@u-0-1', 'a@u-0-2']),
98
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',
99
112
                          'b@u-0-3', 'b@u-0-4',
100
113
                          'b@u-0-5', 'a@u-0-5']),
101
 
             ('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',
102
115
                          'b@u-0-3', 'b@u-0-4',
103
116
                          'b@u-0-5', 'b@u-0-6']),
104
117
             ]
110
123
                    continue
111
124
                if rev_id in br2_only and not branch is br2:
112
125
                    continue
113
 
                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))
117
 
    
118
 
    
119
 
    def test_is_ancestor(self):
120
 
        """Test checking whether a revision is an ancestor of another revision"""
121
 
        br1, br2 = make_branches()
122
 
        revisions = br1.revision_history()
123
 
        revisions_2 = br2.revision_history()
124
 
        sources = br1
125
 
 
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)
130
 
        # disabled mbp 20050914, doesn't seem to happen anymore
131
 
        ## self.assertRaises(NoSuchRevision, is_ancestor, revisions_2[3],
132
 
        ##                  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):
 
126
                self.assertThat(anc,
 
127
                    MatchesAncestry(branch.repository, rev_id))
 
128
 
 
129
 
 
130
class TestIntermediateRevisions(TestCaseWithTransport):
140
131
 
141
132
    def setUp(self):
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")
157
 
 
158
 
        from bzrlib.revision import MultipleRevisionSources
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):
 
133
        TestCaseWithTransport.setUp(self)
 
134
        self.br1, self.br2 = make_branches(self)
 
135
        wt1 = self.br1.bzrdir.open_workingtree()
 
136
        wt2 = self.br2.bzrdir.open_workingtree()
 
137
        wt2.commit("Commit eleven", rev_id="b@u-0-7")
 
138
        wt2.commit("Commit twelve", rev_id="b@u-0-8")
 
139
        wt2.commit("Commit thirtteen", rev_id="b@u-0-9")
 
140
 
 
141
        wt1.merge_from_branch(self.br2)
 
142
        wt1.commit("Commit fourtten", rev_id="a@u-0-6")
 
143
 
 
144
        wt2.merge_from_branch(self.br1)
 
145
        wt2.commit("Commit fifteen", rev_id="b@u-0-10")
 
146
 
 
147
 
 
148
class MockRevisionSource(object):
 
149
    """A RevisionSource that takes a pregenerated graph.
 
150
 
 
151
    This is useful for testing revision graph algorithms where
 
152
    the actual branch existing is irrelevant.
 
153
    """
 
154
 
 
155
    def __init__(self, full_graph):
 
156
        self._full_graph = full_graph
 
157
 
 
158
    def get_revision_graph_with_ghosts(self, revision_ids):
 
159
        # This is mocked out to just return a constant graph.
 
160
        return self._full_graph
 
161
 
 
162
 
 
163
class TestCommonAncestor(TestCaseWithTransport):
210
164
    """Test checking whether a revision is an ancestor of another revision"""
211
165
 
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
 
 
251
 
    def test_common_ancestor(self):
252
 
        """Pick a reasonable merge base"""
253
 
        from bzrlib.revision import common_ancestor
254
 
        br1, br2 = make_branches()
255
 
        revisions = br1.revision_history()
256
 
        revisions_2 = br2.revision_history()
257
 
        sources = MultipleRevisionSources(br1, br2)
258
 
        expected_ancestors_list = {revisions[3]:(0, 0), 
259
 
                                   revisions[2]:(1, 1),
260
 
                                   revisions_2[4]:(2, 1), 
261
 
                                   revisions[1]:(3, 2),
262
 
                                   revisions_2[3]:(4, 2),
263
 
                                   revisions[0]:(5, 3) }
264
 
        ancestors_list = find_present_ancestors(revisions[3], sources)
265
 
        assert len(expected_ancestors_list) == len(ancestors_list)
266
 
        for key, value in expected_ancestors_list.iteritems():
267
 
            self.assertEqual(ancestors_list[key], value, 
268
 
                              "key %r, %r != %r" % (key, ancestors_list[key],
269
 
                                                    value))
270
 
        self.assertEqual(common_ancestor(revisions[0], revisions[0], sources),
271
 
                          revisions[0])
272
 
        self.assertEqual(common_ancestor(revisions[1], revisions[2], sources),
273
 
                          revisions[1])
274
 
        self.assertEqual(common_ancestor(revisions[1], revisions[1], sources),
275
 
                          revisions[1])
276
 
        self.assertEqual(common_ancestor(revisions[2], revisions_2[4], sources),
277
 
                          revisions[2])
278
 
        self.assertEqual(common_ancestor(revisions[3], revisions_2[4], sources),
279
 
                          revisions_2[4])
280
 
        self.assertEqual(common_ancestor(revisions[4], revisions_2[5], sources),
281
 
                          revisions_2[4])
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
286
 
 
287
 
    def test_combined(self):
288
 
        """combined_graph
289
 
        Ensure it's not order-sensitive
290
 
        """
291
 
        br1, br2 = make_branches()
292
 
        source = MultipleRevisionSources(br1, br2)
293
 
        combined_1 = combined_graph(br1.last_revision(), 
294
 
                                    br2.last_revision(), source)
295
 
        combined_2 = combined_graph(br2.last_revision(),
296
 
                                    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
 
166
    def test_get_history(self):
 
167
        # TODO: test ghosts on the left hand branch's impact
 
168
        # TODO: test ghosts on all parents, we should get some
 
169
        # indicator. i.e. NULL_REVISION
 
170
        # RBC 20060608
 
171
        tree = self.make_branch_and_tree('.')
 
172
        tree.commit('1', rev_id = '1', allow_pointless=True)
 
173
        tree.commit('2', rev_id = '2', allow_pointless=True)
 
174
        tree.commit('3', rev_id = '3', allow_pointless=True)
 
175
        rev = tree.branch.repository.get_revision('1')
 
176
        history = rev.get_history(tree.branch.repository)
 
177
        self.assertEqual([None, '1'], history)
 
178
        rev = tree.branch.repository.get_revision('2')
 
179
        history = rev.get_history(tree.branch.repository)
 
180
        self.assertEqual([None, '1', '2'], history)
 
181
        rev = tree.branch.repository.get_revision('3')
 
182
        history = rev.get_history(tree.branch.repository)
 
183
        self.assertEqual([None, '1', '2' ,'3'], history)
 
184
 
 
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())