~ursinha/lp-qa-tools/bzr-tarmacland

« back to all changes in this revision

Viewing changes to tests/test_lpland.py

  • Committer: Ursula Junque (Ursinha)
  • Date: 2010-12-16 03:14:26 UTC
  • Revision ID: ursinha@canonical.com-20101216031426-bbk2xmnt9vs8hvqz
Removing unnecessary files for the tarmac-land command.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright 2010 Canonical Ltd.  This software is licensed under the
2
 
# GNU Affero General Public License version 3 (see the file LICENSE).
3
 
 
4
 
"""Tests for automatic landing thing."""
5
 
 
6
 
__metaclass__ = type
7
 
 
8
 
import unittest
9
 
 
10
 
from launchpadlib.uris import (
11
 
    DEV_SERVICE_ROOT, EDGE_SERVICE_ROOT, LPNET_SERVICE_ROOT,
12
 
    STAGING_SERVICE_ROOT)
13
 
 
14
 
from bzrlib.plugins.pqm.lpland import (
15
 
    get_bugs_clause, get_reviewer_clause,
16
 
    get_reviewer_handle, get_testfix_clause, get_qa_clause,
17
 
    MissingReviewError, MissingBugsError, MissingBugsIncrementalError, 
18
 
    MergeProposal)
19
 
 
20
 
from fakemethod import FakeMethod
21
 
 
22
 
 
23
 
class FakeBug:
24
 
    """Fake launchpadlib Bug object.
25
 
 
26
 
    Only used for the purposes of testing.
27
 
    """
28
 
 
29
 
    def __init__(self, id):
30
 
        self.id = id
31
 
 
32
 
 
33
 
class FakePerson:
34
 
    """Fake launchpadlib Person object.
35
 
 
36
 
    Only used for the purposes of testing.
37
 
    """
38
 
 
39
 
    def __init__(self, name, irc_handles):
40
 
        self.name = name
41
 
        self.irc_nicknames = list(irc_handles)
42
 
 
43
 
 
44
 
class FakeIRC:
45
 
    """Fake IRC handle.
46
 
 
47
 
    Only used for the purposes of testing.
48
 
    """
49
 
 
50
 
    def __init__(self, nickname, network):
51
 
        self.nickname = nickname
52
 
        self.network = network
53
 
 
54
 
 
55
 
class FakeLPMergeProposal:
56
 
    """Fake launchpadlib MergeProposal object.
57
 
 
58
 
    Only used for the purposes of testing.
59
 
    """
60
 
 
61
 
    def __init__(self, root=None):
62
 
        self._root = root
63
 
        self.commit_message = None
64
 
 
65
 
    def lp_save(self):
66
 
        pass
67
 
 
68
 
 
69
 
class TestBugsClaused(unittest.TestCase):
70
 
    """Tests for `get_bugs_clause`."""
71
 
 
72
 
    def test_no_bugs(self):
73
 
        # If there are no bugs, then there is no bugs clause.
74
 
        bugs_clause = get_bugs_clause([])
75
 
        self.assertEqual('', bugs_clause)
76
 
 
77
 
    def test_one_bug(self):
78
 
        # If there's a bug, then the bugs clause is [bug=$ID].
79
 
        bug = FakeBug(45)
80
 
        bugs_clause = get_bugs_clause([bug])
81
 
        self.assertEqual('[bug=45]', bugs_clause)
82
 
 
83
 
    def test_two_bugs(self):
84
 
        # If there are two bugs, then the bugs clause is [bug=$ID,$ID].
85
 
        bug1 = FakeBug(20)
86
 
        bug2 = FakeBug(45)
87
 
        bugs_clause = get_bugs_clause([bug1, bug2])
88
 
        self.assertEqual('[bug=20,45]', bugs_clause)
89
 
 
90
 
 
91
 
class TestGetTestfixClause(unittest.TestCase):
92
 
    """Tests for `get_testfix_clause`"""
93
 
 
94
 
    def test_no_testfix(self):
95
 
        testfix = False
96
 
        self.assertEqual('', get_testfix_clause(testfix))
97
 
 
98
 
    def test_is_testfix(self):
99
 
        testfix = True
100
 
        self.assertEqual('[testfix]', get_testfix_clause(testfix))
101
 
 
102
 
 
103
 
class TestGetQaClause(unittest.TestCase):
104
 
    """Tests for `get_qa_clause`"""
105
 
 
106
 
    def test_no_bugs_no_option_given(self):
107
 
        bugs = None
108
 
        no_qa = False
109
 
        incr = False
110
 
        self.assertRaises(MissingBugsError, get_qa_clause, bugs, no_qa,
111
 
            incr)
112
 
 
113
 
    def test_bugs_noqa_option_given(self):
114
 
        bug1 = FakeBug(20)
115
 
        no_qa = True
116
 
        incr = False
117
 
        self.assertEqual('[no-qa]',
118
 
            get_qa_clause([bug1], no_qa, incr))
119
 
 
120
 
    def test_no_bugs_noqa_option_given(self):
121
 
        bugs = None
122
 
        no_qa = True
123
 
        incr = False
124
 
        self.assertEqual('[no-qa]',
125
 
            get_qa_clause(bugs, no_qa, incr))
126
 
 
127
 
    def test_bugs_no_option_given(self):
128
 
        bug1 = FakeBug(20)
129
 
        no_qa = False
130
 
        incr = False
131
 
        self.assertEqual('',
132
 
            get_qa_clause([bug1], no_qa, incr))
133
 
 
134
 
    def test_bugs_incr_option_given(self):
135
 
        bug1 = FakeBug(20)
136
 
        no_qa = False
137
 
        incr = True
138
 
        self.assertEqual('[incr]',
139
 
            get_qa_clause([bug1], no_qa, incr))
140
 
 
141
 
    def test_no_bugs_incr_option_given(self):
142
 
        bugs = None
143
 
        no_qa = False
144
 
        incr = True
145
 
        self.assertRaises(MissingBugsIncrementalError,
146
 
            get_qa_clause, bugs, no_qa, incr)
147
 
 
148
 
    def test_bugs_incr_and_noqa_option_given(self):
149
 
        bug1 = FakeBug(20)
150
 
        no_qa = True
151
 
        incr = True
152
 
        self.assertEqual('[no-qa][incr]',
153
 
            get_qa_clause([bug1], no_qa, incr))
154
 
 
155
 
    def test_rollback_given(self):
156
 
        bugs = None
157
 
        self.assertEqual('[rollback=123]',
158
 
            get_qa_clause(bugs, rollback=123))
159
 
 
160
 
    def test_rollback_and_noqa_and_incr_given(self):
161
 
        bugs = None
162
 
        no_qa = True
163
 
        incr = True
164
 
        self.assertEqual('[rollback=123]',
165
 
            get_qa_clause(bugs, rollback=123))
166
 
 
167
 
 
168
 
class TestGetReviewerHandle(unittest.TestCase):
169
 
    """Tests for `get_reviewer_handle`."""
170
 
 
171
 
    def makePerson(self, name, irc_handles):
172
 
        return FakePerson(name, irc_handles)
173
 
 
174
 
    def test_no_irc_nicknames(self):
175
 
        # If the person has no IRC nicknames, their reviewer handle is their
176
 
        # Launchpad user name.
177
 
        person = self.makePerson(name='foo', irc_handles=[])
178
 
        self.assertEqual('foo', get_reviewer_handle(person))
179
 
 
180
 
    def test_freenode_irc_nick_preferred(self):
181
 
        # If the person has a Freenode IRC nickname, then that is preferred as
182
 
        # their user handle.
183
 
        person = self.makePerson(
184
 
            name='foo', irc_handles=[FakeIRC('bar', 'irc.freenode.net')])
185
 
        self.assertEqual('bar', get_reviewer_handle(person))
186
 
 
187
 
    def test_non_freenode_nicks_ignored(self):
188
 
        # If the person has IRC nicks that aren't freenode, we ignore them.
189
 
        person = self.makePerson(
190
 
            name='foo', irc_handles=[FakeIRC('bar', 'irc.efnet.net')])
191
 
        self.assertEqual('foo', get_reviewer_handle(person))
192
 
 
193
 
 
194
 
class TestGetCommitMessage(unittest.TestCase):
195
 
 
196
 
    def setUp(self):
197
 
        self.mp = MergeProposal(FakeLPMergeProposal())
198
 
        self.fake_bug = FakeBug(20)
199
 
        self.fake_person = self.makePerson('foo')
200
 
 
201
 
    def makePerson(self, name):
202
 
        return FakePerson(name, [])
203
 
 
204
 
    def test_commit_with_bugs(self):
205
 
        incr = False
206
 
        no_qa = False
207
 
        testfix = False
208
 
 
209
 
        self.mp.get_bugs = FakeMethod([self.fake_bug])
210
 
        self.mp.get_reviews = FakeMethod({None : [self.fake_person]})
211
 
 
212
 
        self.assertEqual("[r=foo][ui=none][bug=20] Foobaring the sbrubble.",
213
 
            self.mp.build_commit_message("Foobaring the sbrubble.",
214
 
                testfix, no_qa, incr))
215
 
 
216
 
    def test_commit_no_bugs_no_noqa(self):
217
 
        incr = False
218
 
        no_qa = False
219
 
        testfix = False
220
 
 
221
 
        self.mp.get_bugs = FakeMethod([])
222
 
        self.mp.get_reviews = FakeMethod({None : [self.fake_person]})
223
 
 
224
 
        self.assertRaises(MissingBugsError, self.mp.build_commit_message,
225
 
            testfix, no_qa, incr)
226
 
 
227
 
    def test_commit_no_bugs_with_noqa(self):
228
 
        incr = False
229
 
        no_qa = True
230
 
        testfix = False
231
 
 
232
 
        self.mp.get_bugs = FakeMethod([])
233
 
        self.mp.get_reviews = FakeMethod({None : [self.fake_person]})
234
 
 
235
 
        self.assertEqual("[r=foo][ui=none][no-qa] Foobaring the sbrubble.",
236
 
            self.mp.build_commit_message("Foobaring the sbrubble.",
237
 
                testfix, no_qa, incr))
238
 
 
239
 
    def test_commit_bugs_with_noqa(self):
240
 
        incr = False
241
 
        no_qa = True
242
 
        testfix = False
243
 
 
244
 
        self.mp.get_bugs = FakeMethod([self.fake_bug])
245
 
        self.mp.get_reviews = FakeMethod({None : [self.fake_person]})
246
 
 
247
 
        self.assertEqual(
248
 
            "[r=foo][ui=none][bug=20][no-qa] Foobaring the sbrubble.",
249
 
            self.mp.build_commit_message("Foobaring the sbrubble.",
250
 
                testfix, no_qa, incr))
251
 
 
252
 
    def test_commit_bugs_with_incr(self):
253
 
        incr = True
254
 
        no_qa = False
255
 
        testfix = False
256
 
 
257
 
        self.mp.get_bugs = FakeMethod([self.fake_bug])
258
 
        self.mp.get_reviews = FakeMethod({None : [self.fake_person]})
259
 
 
260
 
        self.assertEqual(
261
 
            "[r=foo][ui=none][bug=20][incr] Foobaring the sbrubble.",
262
 
            self.mp.build_commit_message("Foobaring the sbrubble.",
263
 
                testfix, no_qa, incr))
264
 
 
265
 
    def test_commit_no_bugs_with_incr(self):
266
 
        incr = True
267
 
        no_qa = False
268
 
        testfix = False
269
 
 
270
 
        self.mp.get_bugs = FakeMethod([self.fake_bug])
271
 
        self.mp.get_reviews = FakeMethod({None : [self.fake_person]})
272
 
 
273
 
        self.assertEqual(
274
 
            "[r=foo][ui=none][bug=20][incr] Foobaring the sbrubble.",
275
 
            self.mp.build_commit_message("Foobaring the sbrubble.",
276
 
                testfix, no_qa, incr))
277
 
 
278
 
    def test_commit_with_noqa_and_incr(self):
279
 
        incr = True
280
 
        no_qa = True
281
 
        testfix = False
282
 
 
283
 
        self.mp.get_bugs = FakeMethod([self.fake_bug])
284
 
        self.mp.get_reviews = FakeMethod({None : [self.fake_person]})
285
 
 
286
 
        self.assertEqual(
287
 
            "[r=foo][ui=none][bug=20][no-qa][incr] Foobaring the sbrubble.",
288
 
            self.mp.build_commit_message("Foobaring the sbrubble.", 
289
 
                testfix, no_qa, incr))
290
 
 
291
 
    def test_commit_with_rollback(self):
292
 
        self.mp.get_bugs = FakeMethod([self.fake_bug])
293
 
        self.mp.get_reviews = FakeMethod({None : [self.fake_person]})
294
 
 
295
 
        self.assertEqual(
296
 
            "[r=foo][ui=none][bug=20][rollback=123] Foobaring the sbrubble.",
297
 
            self.mp.build_commit_message("Foobaring the sbrubble.", 
298
 
                rollback=123))
299
 
 
300
 
    def test_takes_into_account_existing_tags_on_commit_text(self):
301
 
        self.mp.get_bugs = FakeMethod([self.fake_bug])
302
 
        self.mp.get_reviews = FakeMethod({None : [self.fake_person]})
303
 
 
304
 
        self.assertEqual(
305
 
            "[r=foo][ui=none][bug=20][rollback=123] Foobaring the sbrubble.",
306
 
            self.mp.build_commit_message(
307
 
                "[r=foo][ui=none][bug=20][rollback=123] Foobaring the sbrubble.",
308
 
                rollback=123))
309
 
 
310
 
 
311
 
class TestSetCommitMessage(unittest.TestCase):
312
 
 
313
 
    def setUp(self):
314
 
        self.mp = MergeProposal(FakeLPMergeProposal())
315
 
 
316
 
    def test_set_commit_message(self):
317
 
        commit_message = "Foobaring the sbrubble."
318
 
        self.mp.set_commit_message(commit_message)
319
 
        self.assertEqual(self.mp._mp.commit_message, commit_message)
320
 
 
321
 
 
322
 
class TestGetReviewerClause(unittest.TestCase):
323
 
    """Tests for `get_reviewer_clause`."""
324
 
 
325
 
    def makePerson(self, name):
326
 
        return FakePerson(name, [])
327
 
 
328
 
    def get_reviewer_clause(self, reviewers):
329
 
        return get_reviewer_clause(reviewers)
330
 
 
331
 
    def test_one_reviewer_no_type(self):
332
 
        # It's very common for a merge proposal to be reviewed by one person
333
 
        # with no specified type of review. It such cases the review clause is
334
 
        # '[r=<person>][ui=none]'.
335
 
        clause = self.get_reviewer_clause({None: [self.makePerson('foo')]})
336
 
        self.assertEqual('[r=foo][ui=none]', clause)
337
 
 
338
 
    def test_two_reviewers_no_type(self):
339
 
        # Branches can have more than one reviewer.
340
 
        clause = self.get_reviewer_clause(
341
 
            {None: [self.makePerson('foo'), self.makePerson('bar')]})
342
 
        self.assertEqual('[r=bar,foo][ui=none]', clause)
343
 
 
344
 
    def test_mentat_reviewers(self):
345
 
        # A mentat review sometimes is marked like 'ui*'.  Due to the
346
 
        # unordered nature of dictionaries, the reviewers are sorted before
347
 
        # being put into the clause for predictability.
348
 
        clause = self.get_reviewer_clause(
349
 
            {None: [self.makePerson('foo')],
350
 
             'code*': [self.makePerson('newguy')],
351
 
             'ui': [self.makePerson('beuno')],
352
 
             'ui*': [self.makePerson('bac')]})
353
 
        self.assertEqual('[r=foo,newguy][ui=bac,beuno]', clause)
354
 
 
355
 
    def test_code_reviewer_counts(self):
356
 
        # Some people explicitly specify the 'code' type when they do code
357
 
        # reviews, these are treated in the same way as reviewers without any
358
 
        # given type.
359
 
        clause = self.get_reviewer_clause({'code': [self.makePerson('foo')]})
360
 
        self.assertEqual('[r=foo][ui=none]', clause)
361
 
 
362
 
    def test_release_critical(self):
363
 
        # Reviews that are marked as release-critical are included in a
364
 
        # separate clause.
365
 
        clause = self.get_reviewer_clause(
366
 
            {'code': [self.makePerson('foo')],
367
 
             'release-critical': [self.makePerson('bar')]})
368
 
        self.assertEqual('[release-critical=bar][r=foo][ui=none]', clause)
369
 
 
370
 
    def test_db_reviewer_counts(self):
371
 
        # There's no special way of annotating database reviews in Launchpad
372
 
        # commit messages, so they are included with the code reviews.
373
 
        clause = self.get_reviewer_clause({'db': [self.makePerson('foo')]})
374
 
        self.assertEqual('[r=foo][ui=none]', clause)
375
 
 
376
 
    def test_ui_reviewers(self):
377
 
        # If someone has done a UI review, then that appears in the clause
378
 
        # separately from the code reviews.
379
 
        clause = self.get_reviewer_clause(
380
 
            {'code': [self.makePerson('foo')],
381
 
             'ui': [self.makePerson('bar')],
382
 
             })
383
 
        self.assertEqual('[r=foo][ui=bar]', clause)
384
 
 
385
 
    def test_no_reviewers(self):
386
 
        # If the merge proposal hasn't been approved by anyone, we cannot
387
 
        # generate a valid clause.
388
 
        self.assertRaises(MissingReviewError, self.get_reviewer_clause, {})