← Back to branch summary

~andrewjbeach/juju-ci-tools/make-local-patcher

« back to all changes in this revision

Viewing changes to test_check_blockers.py

  • Committer: Curtis Hovey
  • Date: 2015-06-11 19:35:22 UTC
  • mto: This revision was merged to the branch mainline in revision 983.
  • Revision ID: curtis@canonical.com-20150611193522-o2nqkqb04o2i75wv
Remove euca_dump_logs because it has not been used this year.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test_check_blockers.py
16
16
    ]}
17
17
 
18
18
 
19
 
def make_fake_lp(series=False, bugs=False, project_name='juju', tags=[]):
 
19
def make_fake_lp(series=False, bugs=False):
20
20
    """Return a fake Lp lib object based on Mocks"""
21
21
    if bugs:
22
22
        task_1 = Mock(
23
23
            self_link='https://lp/j/98765', title='one', status='Triaged')
24
 
        task_1.bug.tags = tags
25
24
        task_2 = Mock(
26
25
            self_link='https://lp/j/54321', title='two', status='Triaged')
27
 
        task_2.bug.tags = tags
28
26
        bugs = [task_1, task_2]
29
27
    else:
30
28
        bugs = []
39
37
        project.searchTasks.return_value = bugs
40
38
        lp._target = project
41
39
    project.getSeries.return_value = series
42
 
    lp.projects[project_name] = project
 
40
    lp.projects['juju-core'] = project
43
41
    return lp
44
42
 
45
43
 
46
44
class CheckBlockers(TestCase):
47
45
 
48
46
    def test_parse_args_check(self):
49
 
        args = check_blockers.parse_args(['check', 'MASTER', '17'])
 
47
        args = check_blockers.parse_args(['check', 'master', '17'])
50
48
        self.assertEqual('check', args.command)
51
49
        self.assertEqual('master', args.branch)
52
50
        self.assertEqual('17', args.pull_request)
55
53
        args = check_blockers.parse_args(['check', 'master'])
56
54
        self.assertEqual('check', args.command)
57
55
        self.assertEqual('master', args.branch)
58
 
        self.assertIsNone(args.pull_request)
59
 
 
60
 
    def test_parse_args_block_ci_testing(self):
61
 
        args = check_blockers.parse_args(['block-ci-testing', 'FEATURE'])
62
 
        self.assertEqual('block-ci-testing', args.command)
63
 
        self.assertEqual('feature', args.branch)
64
 
        self.assertIsNone(args.pull_request)
 
56
        self.assertEqual(None, args.pull_request)
65
57
 
66
58
    def test_parse_args_check_branch_optional(self):
67
59
        args = check_blockers.parse_args(['check'])
68
60
        self.assertEqual('check', args.command)
69
61
        self.assertEqual('master', args.branch)
70
 
        self.assertIsNone(args.pull_request)
 
62
        self.assertEqual(None, args.pull_request)
71
63
 
72
64
    def test_parse_args_update(self):
73
65
        args = check_blockers.parse_args(
74
 
            ['-c', './foo.cred', 'update', 'MASTER', '1234'])
 
66
            ['-c', './foo.cred', 'update', 'master', '1234'])
75
67
        self.assertEqual('update', args.command)
76
68
        self.assertEqual('master', args.branch)
77
69
        self.assertEqual('1234', args.build)
88
80
                           return_value=(0, 'foo')) as gr:
89
81
                    code = check_blockers.main(['check', 'master', '17'])
90
82
        gl.assert_called_with('check_blockers', credentials_file=None)
91
 
        glb.assert_called_with('lp', 'master', ['blocker'])
92
 
        gr.assert_called_with(bugs, args)
93
 
        self.assertEqual(0, code)
94
 
 
95
 
    def test_main_block_ci_testing(self):
96
 
        bugs = {}
97
 
        args = check_blockers.parse_args(['block-ci-testing', 'feature'])
98
 
        with patch('check_blockers.get_lp', autospec=True,
99
 
                   return_value='lp') as gl:
100
 
            with patch('check_blockers.get_lp_bugs', autospec=True,
101
 
                       return_value=bugs) as glb:
102
 
                with patch('check_blockers.get_reason', autospec=True,
103
 
                           return_value=(0, 'foo')) as gr:
104
 
                    code = check_blockers.main(['block-ci-testing', 'feature'])
105
 
        gl.assert_called_with('check_blockers', credentials_file=None)
106
 
        glb.assert_called_with('lp', 'feature', ['block-ci-testing'])
 
83
        glb.assert_called_with('lp', 'master', with_ci=False)
107
84
        gr.assert_called_with(bugs, args)
108
85
        self.assertEqual(0, code)
109
86
 
118
95
                           return_value=[0, 'Updating']) as ub:
119
96
                    code = check_blockers.main(argv)
120
97
        gl.assert_called_with('check_blockers', credentials_file='./foo.cred')
121
 
        glb.assert_called_with('lp', 'master', ['blocker', 'ci'])
 
98
        glb.assert_called_with('lp', 'master', with_ci=True)
122
99
        ub.assert_called_with(bugs, 'master', '1234', dry_run=True)
123
100
        self.assertEqual(0, code)
124
101
 
125
102
    def test_get_lp_bugs_with_master_branch(self):
126
 
        lp = make_fake_lp(series=False, bugs=True, tags=['blocker'])
127
 
        bugs = check_blockers.get_lp_bugs(lp, 'master', ['blocker'])
 
103
        lp = make_fake_lp(series=False, bugs=True)
 
104
        bugs = check_blockers.get_lp_bugs(lp, 'master')
128
105
        self.assertEqual(['54321', '98765'], sorted(bugs.keys()))
129
 
        project = lp.projects['juju']
 
106
        project = lp.projects['juju-core']
130
107
        self.assertEqual(0, project.getSeries.call_count)
131
108
        project.searchTasks.assert_called_with(
132
109
            status=check_blockers.BUG_STATUSES,
134
111
            tags=check_blockers.BUG_TAGS, tags_combinator='All')
135
112
 
136
113
    def test_get_lp_bugs_with_supported_branch(self):
137
 
        lp = make_fake_lp(series=True, bugs=True,
138
 
                          project_name='juju-core', tags=['blocker'])
139
 
        bugs = check_blockers.get_lp_bugs(lp, '1.20', ['blocker'])
 
114
        lp = make_fake_lp(series=True, bugs=True)
 
115
        bugs = check_blockers.get_lp_bugs(lp, '1.20')
140
116
        self.assertEqual(['54321', '98765'], sorted(bugs.keys()))
141
117
        project = lp.projects['juju-core']
142
118
        project.getSeries.assert_called_with(name='1.20')
148
124
 
149
125
    def test_get_lp_bugs_with_unsupported_branch(self):
150
126
        lp = make_fake_lp(series=False, bugs=False)
151
 
        bugs = check_blockers.get_lp_bugs(lp, 'foo', ['blocker'])
 
127
        bugs = check_blockers.get_lp_bugs(lp, 'foo')
152
128
        self.assertEqual({}, bugs)
153
 
        project = lp.projects['juju']
 
129
        project = lp.projects['juju-core']
154
130
        project.getSeries.assert_called_with(name='foo')
155
131
        self.assertEqual(0, project.searchTasks.call_count)
156
132
 
157
133
    def test_get_lp_bugs_without_blocking_bugs(self):
158
134
        lp = make_fake_lp(series=False, bugs=False)
159
 
        bugs = check_blockers.get_lp_bugs(lp, 'master', ['blocker'])
 
135
        bugs = check_blockers.get_lp_bugs(lp, 'master')
160
136
        self.assertEqual({}, bugs)
161
 
        project = lp.projects['juju']
 
137
        project = lp.projects['juju-core']
162
138
        project.searchTasks.assert_called_with(
163
139
            status=check_blockers.BUG_STATUSES,
164
140
            importance=check_blockers.BUG_IMPORTANCES,
165
141
            tags=check_blockers.BUG_TAGS, tags_combinator='All')
166
142
 
167
 
    def test_get_lp_bugs_error(self):
 
143
    def test_get_lp_bugs_with_ci(self):
168
144
        lp = make_fake_lp(series=False, bugs=True)
169
 
        with self.assertRaises(ValueError):
170
 
            check_blockers.get_lp_bugs(lp, 'master', [])
 
145
        check_blockers.get_lp_bugs(lp, 'master', with_ci=True)
 
146
        project = lp.projects['juju-core']
 
147
        bug_tags = check_blockers.BUG_TAGS + ['ci']
 
148
        project.searchTasks.assert_called_with(
 
149
            status=check_blockers.BUG_STATUSES,
 
150
            importance=check_blockers.BUG_IMPORTANCES,
 
151
            tags=bug_tags, tags_combinator='All')
171
152
 
172
153
    def test_get_reason_without_blocking_bugs(self):
173
154
        args = check_blockers.parse_args(['check', 'master', '17'])
254
235
            self.assertEqual(json, {"result": []})
255
236
 
256
237
    def test_update_bugs(self):
257
 
        lp = make_fake_lp(series=False, bugs=True, tags=['blocker'])
258
 
        bugs = check_blockers.get_lp_bugs(lp, 'master', ['blocker'])
 
238
        lp = make_fake_lp(series=False, bugs=True)
 
239
        bugs = check_blockers.get_lp_bugs(lp, 'master')
259
240
        code, changes = check_blockers.update_bugs(
260
241
            bugs, 'master', '1234', dry_run=False)
261
242
        self.assertEqual(0, code)
269
250
        bugs['54321'].bug.newMessage.assert_called_with(
270
251
            subject=expected_subject, content=expected_content)
271
252
 
272
 
    def test_update_bugs_skipped(self):
273
 
        lp = make_fake_lp(
274
 
            series=False, bugs=True, tags=['blocker', 'intermittent-failure'])
275
 
        bugs = check_blockers.get_lp_bugs(lp, 'master', ['blocker'])
276
 
        code, changes = check_blockers.update_bugs(
277
 
            bugs, 'master', '1234', dry_run=False)
278
 
        self.assertEqual(0, code)
279
 
        self.assertIn('Skipping intermittent-failure', changes)
280
 
        self.assertEqual('Triaged', bugs['54321'].status)
281
 
        self.assertEqual(0, bugs['54321'].lp_save.call_count)
282
 
        self.assertEqual(0, bugs['54321'].bug.newMessage.call_count)
283
 
 
284
253
    def test_update_bugs_with_dry_run(self):
285
254
        lp = make_fake_lp(series=False, bugs=True)
286
 
        bugs = check_blockers.get_lp_bugs(lp, 'master', ['blocker'])
 
255
        bugs = check_blockers.get_lp_bugs(lp, 'master')
287
256
        code, changes = check_blockers.update_bugs(
288
257
            bugs, 'master', '1234', dry_run=True)
289
258
        self.assertEqual(0, bugs['54321'].lp_save.call_count)