1
=== added directory 'coverage-extractor'
2
=== added directory 'coverage-extractor/coverageextractor'
3
=== added file 'coverage-extractor/coverageextractor/__init__.py'
4
--- coverage-extractor/coverageextractor/__init__.py	1970-01-01 00:00:00 +0000
5
+++ coverage-extractor/coverageextractor/__init__.py	2014-10-23 21:46:26 +0000
6
@@ -0,0 +1,75 @@
7
1
# Ubuntu CI Engine
8
2
# Copyright 2014 Canonical Ltd.
9
3
#
10
4
# This program is free software: you can redistribute it and/or modify it
11
5
# under the terms of the GNU Affero General Public License version 3, as
12
6
# published by the Free Software Foundation.
13
7
#
14
8
# This program is distributed in the hope that it will be useful, but
15
9
# WITHOUT ANY WARRANTY; without even the implied warranties of
16
10
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
17
11
# PURPOSE.  See the GNU Affero General Public License for more details.
18
12
#
19
13
# You should have received a copy of the GNU Affero General Public License
20
14
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
21
15
22
16
from functools import wraps
23
17
import time
24
18
import xml.etree.ElementTree as etree
25
19
26
20
27
21
class CoverageExtractorException(ValueError):
28
22
    """Bad things happen to good extractors."""
29
23
30
24
31
25
def extract_coverage_data(coverage_xml):
32
26
    """Return line and branch numbers from coverage.xml.
33
27
34
28
    :param coverage_xml: coverage.xml string
35
29
    """
36
30
    try:
37
31
        # root node is coverage, more complex patterns possible later
38
32
        coverage_node = etree.fromstring(coverage_xml)
39
33
        return (
40
34
            float(coverage_node.attrib['line-rate']),
41
35
            float(coverage_node.attrib['branch-rate']),
42
36
        )
43
37
    except etree.ParseError as e:
44
38
        raise CoverageExtractorException(
45
39
            "Failed to parse coverage.xml: {}".format(e.message)
46
40
        )
47
41
    except ValueError as e:
48
42
        raise CoverageExtractorException(
49
43
            "Failed to parse coverage numbers: {}".format(e.message)
50
44
        )
51
45
52
46
53
47
def retry(ExceptionToCheck, tries=4, delay=3, backoff=2, logger=None):
54
48
    """Retry calling the decorated function using an exponential backoff.
55
49
56
50
    http://www.saltycrane.com/blog/2009/11/trying-out-retry-decorator-python/
57
51
    Original from: http://wiki.python.org/moin/PythonDecoratorLibrary#Retry
58
52
59
53
    :param ExceptionToCheck: the exception to check. may be a tuple of
60
54
        exceptions to check
61
55
    :param tries: number of times to try (not retry) before giving up
62
56
    :param delay: initial delay between retries in seconds
63
57
    :param backoff: backoff multiplier e.g. value of 2 will double the delay
64
58
        each retry
65
59
    :param logger: logger.Logger to use.
66
60
    """
67
61
    def deco_retry(f):
68
62
        @wraps(f)
69
63
        def f_retry(*args, **kwargs):
70
64
            for i in range(tries):
71
65
                try:
72
66
                    return f(*args, **kwargs)
73
67
                except ExceptionToCheck as e:
74
68
                    d = delay * backoff ** i
75
69
                    if logger:
76
70
                        logger.warning(
77
71
                            "%s, retrying in %d seconds. . . ." % (e, d))
78
72
                    time.sleep(d)
79
73
            return f(*args, **kwargs)
80
74
        return f_retry  # true decorator
81
75
    return deco_retry
82
0
76
83
=== added file 'coverage-extractor/coverageextractor/extraction.py'
84
--- coverage-extractor/coverageextractor/extraction.py	1970-01-01 00:00:00 +0000
85
+++ coverage-extractor/coverageextractor/extraction.py	2014-10-23 21:46:26 +0000
86
@@ -0,0 +1,226 @@
87
1
#!/usr/bin/env python
88
2
# Ubuntu CI Engine
89
3
# Copyright 2014 Canonical Ltd.
90
4
#
91
5
# This program is free software: you can redistribute it and/or modify it
92
6
# under the terms of the GNU Affero General Public License version 3, as
93
7
# published by the Free Software Foundation.
94
8
#
95
9
# This program is distributed in the hope that it will be useful, but
96
10
# WITHOUT ANY WARRANTY; without even the implied warranties of
97
11
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
98
12
# PURPOSE.  See the GNU Affero General Public License for more details.
99
13
#
100
14
# You should have received a copy of the GNU Affero General Public License
101
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
102
16
103
17
import json
104
18
105
19
from ci_utils import amqp_utils
106
20
from ci_utils.data_store import DataStoreException
107
21
from coverageextractor import (
108
22
    CoverageExtractorException,
109
23
    extract_coverage_data,
110
24
    retry,
111
25
)
112
26
113
27
from nfss_client import (
114
28
    NfssClient,
115
29
    NfssClientError,
116
30
    NFSS_CONFIG_PATH,
117
31
)
118
32
119
33
SUCCESS_TEMPLATE = u'Deposited coverage.xml into swift for ticket %s.'
120
34
MISSING_PARAMS_TEMPLATE = (u'Failed to handle request: missing coverage.xml '
121
35
                           'filename for ticket %s')
122
36
PARSE_FAILURE_TEMPLATE = u'Failed to parse coverage.xml for ticket %s: %s'
123
37
SWIFT_GET_FAILURE_TEMPLATE = (u'Failed to retrieve coverage.xml from swift '
124
38
                              'for ticket %s: %s')
125
39
SWIFT_PUT_FAILURE_TEMPLATE = (u'Failed to put coverage.xml into swift for '
126
40
                              'ticket %s: %s')
127
41
JSON_ENCODING_FAILURE_TEMPLATE = (u'Failed to encode JSON for '
128
42
                                  'ticket %s: %s')
129
43
NFSS_CLIENT_ERROR_TEMPLATE = u'Failed to POST to NFSS for ticket %s: %s'
130
44
131
45
132
46
def generate_and_put_artifact(
133
47
        data_store,
134
48
        name='coverage-extractor.output.log',
135
49
        type='LOGS',
136
50
        message=None,
137
51
        reference=None):
138
52
    """Return a uci-artifact generated and deposited in swift.
139
53
140
54
    NOTE that if no reference is supplied, the artifact is deposited
141
55
    into swift and the resulting link is reported in the returned
142
56
    artifact; provided for convenience in logging.
143
57
144
58
    :param data_store: DataStore into which to put
145
59
    :param name: filename of artifact in swift
146
60
    :param type: 'LOGS' for logs or 'RESULTS' for coverage.xml
147
61
    :param message: a log message
148
62
    :param reference: swift link; supplied upon deposit if not specified
149
63
    """
150
64
    artifact = {
151
65
        'name': name,
152
66
        'type': type,
153
67
    }
154
68
    if message is not None:
155
69
        artifact['message'] = message
156
70
    if reference is None:
157
71
        reference = data_store.put_file(name, str(artifact), 'text/plain')
158
72
    artifact['reference'] = reference
159
73
    return artifact
160
74
161
75
162
76
class ExtractionFailed(Exception):
163
77
    """Return a dict upon operation failure.."""
164
78
165
79
    def __init__(self, return_tuple):
166
80
        self.return_tuple = return_tuple
167
81
168
82
169
83
class Extraction(object):
170
84
171
85
    def __init__(self, ticket_id, logger, data_store, nfss_config_path=None):
172
86
        self.ticket_id = ticket_id
173
87
        self.logger = logger
174
88
        self.data_store = data_store
175
89
        # XXX alesage 20141022
176
90
        # Possibly we want to own the NFSS client here instead?
177
91
        self.nfss_config_path = nfss_config_path or NFSS_CONFIG_PATH
178
92
        self.result = dict(artifacts=[])
179
93
180
94
    def try_get_project_and_version(self, params):
181
95
        """Extract project name and version from params.
182
96
183
97
        :param params: ticket system handle_request calling params
184
98
        """
185
99
        # XXX alesage 20141022
186
100
        # for the moment we treat the one-subticket case; a ticket may
187
101
        # report multiple builds corresponding to architectures, e.g.
188
102
        subticket = params['subtickets'][0]
189
103
        return subticket['name'], subticket['version']
190
104
191
105
    def try_get_coverage_xml_path(self, params):
192
106
        """Extract coverage.xml path from dict of params.
193
107
194
108
        :param params: dict, hopefully with 'coverage_xml_path' as key
195
109
        """
196
110
        # XXX alesage 20141022
197
111
        # Consider the case of multiple coverage.xml?
198
112
        try:
199
113
            return params['coverage_xml_path']
200
114
        except KeyError:
201
115
            self.report_failed(
202
116
                MISSING_PARAMS_TEMPLATE,
203
117
                self.ticket_id
204
118
            )
205
119
206
120
    def try_get_coverage_xml(self, coverage_xml_path):
207
121
        """Get coverage.xml at given path from swift.
208
122
209
123
        :param coverage_xml_path: swift path from which to get
210
124
        """
211
125
        try:
212
126
            @retry(DataStoreException, logger=self.logger)
213
127
            def get_build_log_actual():
214
128
                return self.data_store.get_file(coverage_xml_path)
215
129
            return get_build_log_actual()
216
130
        except DataStoreException as e:
217
131
            self.report_failed(
218
132
                SWIFT_GET_FAILURE_TEMPLATE,
219
133
                self.ticket_id,
220
134
                e.message,
221
135
            )
222
136
223
137
    def try_extract_coverage_data(self, coverage_xml):
224
138
        """Get line and branch percentages from coverage.xml.
225
139
226
140
        :param coverage_xml: coverage_xml string
227
141
        """
228
142
        try:
229
143
            return extract_coverage_data(coverage_xml)
230
144
        except CoverageExtractorException as e:
231
145
            self.report_failed(
232
146
                PARSE_FAILURE_TEMPLATE,
233
147
                self.ticket_id,
234
148
                e.message,
235
149
            )
236
150
237
151
    def try_compose_nfss_json(
238
152
            self,
239
153
            name,
240
154
            version,
241
155
            line_coverage,
242
156
            branch_coverage):
243
157
        """Compose a JSON string of data for submission to NFSS.
244
158
245
159
        :param name: package name
246
160
        :param version: package version string
247
161
        :param line_coverage: line coverage (float)
248
162
        :param branch_coverage: branch coverage (float)
249
163
        """
250
164
        try:
251
165
            return json.dumps({
252
166
                'name': name,
253
167
                'version': version,
254
168
                'line_coverage': line_coverage,
255
169
                'branch_coverage': branch_coverage,
256
170
            })
257
171
        except ValueError as e:
258
172
            # This is pretty unlikely.
259
173
            self.report_failed(
260
174
                JSON_ENCODING_FAILURE_TEMPLATE,
261
175
                self.ticket_id,
262
176
                e.message
263
177
            )
264
178
265
179
    def try_post_data_to_nfss(self, json, test_name, project_name='coverage'):
266
180
        """Post a JSON string of coverage data to NFSS.
267
181
268
182
        :param json: coverage data JSON to post to NFSS
269
183
        """
270
184
        try:
271
185
            nfss_client = NfssClient(self.nfss_config_path)
272
186
            nfss_client.post_data(json, test_name, project_name)
273
187
        except NfssClientError as e:
274
188
            self.report_failed(
275
189
                NFSS_CLIENT_ERROR_TEMPLATE,
276
190
                self.ticket_id,
277
191
                e.message
278
192
            )
279
193
280
194
    def report_failed(self, format_str, *str_args):
281
195
        """Convenience function to raise and log a failiure.
282
196
283
197
        :param format_str: template to log
284
198
        :str_args str_args: items with which to format format_str
285
199
        """
286
200
        message = format_str % str_args
287
201
        self.logger.error(message)
288
202
        self.result['message'] = message
289
203
        self.result['artifacts'].append(
290
204
            generate_and_put_artifact(self.data_store, message=message)
291
205
        )
292
206
        raise ExtractionFailed(
293
207
            (amqp_utils.progress_failed, self.result)
294
208
        )
295
209
296
210
    def report_succeeded(self, ticket_id):
297
211
        """Deposit a result artifact and return a log artifact.
298
212
299
213
        :param ticket_id: ticket for which to report retrieval success
300
214
        """
301
215
        message = SUCCESS_TEMPLATE % ticket_id
302
216
        # NOTE that logging compels us to pass params to info (can't
303
217
        # reuse message declared above)
304
218
        self.logger.info(SUCCESS_TEMPLATE, ticket_id)
305
219
        self.result['artifacts'].append(
306
220
            generate_and_put_artifact(
307
221
                self.data_store,
308
222
                message=message
309
223
            )
310
224
        )
311
225
        self.result['message'] = message
312
226
        return amqp_utils.progress_completed, self.result
313
0
227
314
=== added file 'coverage-extractor/coverageextractor/nfss_client.py'
315
--- coverage-extractor/coverageextractor/nfss_client.py	1970-01-01 00:00:00 +0000
316
+++ coverage-extractor/coverageextractor/nfss_client.py	2014-10-23 21:46:26 +0000
317
@@ -0,0 +1,80 @@
318
1
#!/usr/bin/env python
319
2
# Ubuntu CI Engine
320
3
# Copyright 2014 Canonical Ltd.
321
4
#
322
5
# This program is free software: you can redistribute it and/or modify it
323
6
# under the terms of the GNU Affero General Public License version 3, as
324
7
# published by the Free Software Foundation.
325
8
#
326
9
# This program is distributed in the hope that it will be useful, but
327
10
# WITHOUT ANY WARRANTY; without even the implied warranties of
328
11
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
329
12
# PURPOSE.  See the GNU Affero General Public License for more details.
330
13
#
331
14
# You should have received a copy of the GNU Affero General Public License
332
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
333
16
334
17
from ConfigParser import ConfigParser
335
18
336
19
from requests_oauthlib import OAuth1Session
337
20
338
21
# XXX alesage 20141022
339
22
# thomi, where to find this config?
340
23
NFSS_CONFIG_PATH = "TODO-fake-nfss-config-path"
341
24
342
25
343
26
class NfssClientError(Exception):
344
27
    """Non-functional non-functional stats service."""
345
28
346
29
347
30
def parse_nfss_config(nfss_config_path):
348
31
    """Return a ConfigParser config from NFSS config filepath.
349
32
350
33
    NOTE that we only return the 'nfss' section of the config.
351
34
352
35
    :param nfss_config_path: path to NFSS config
353
36
    """
354
37
    # XXX alesage 20141022
355
38
    # Discussed with thomi and fginther, need to sort the details of
356
39
    # the config deployment, defer for the moment; an Asana task has
357
40
    # been created to discuss in D.C.
358
41
    config = ConfigParser()
359
42
    config.read(nfss_config_path)
360
43
    # are all of our ducks in a row?
361
44
    for config_item in (
362
45
            'client_access_key',
363
46
            'resource_owner_key',
364
47
            'resource_owner_secret',
365
48
            'backend'):
366
49
        # (we'll also raise KeyError on missing 'nfss' section)
367
50
        if config_item not in config['nfss']:
368
51
            raise KeyError(config_item)
369
52
    return config['nfss']
370
53
371
54
372
55
class NfssClient(object):
373
56
374
57
    def __init__(self, nfss_config_path=None):
375
58
        if nfss_config_path is None:
376
59
            self.nfss_config_path = NFSS_CONFIG_PATH
377
60
        try:
378
61
            # XXX alesage 20141022
379
62
            # Discuss how to deploy this config properly with thomi
380
63
            # and fginther, following from
381
64
            # https://code.launchpad.net/~allanlesage/uci-engine/coverage-extractor/+merge/238782.  # NOQA
382
65
            self.config = parse_nfss_config(nfss_config_path)
383
66
        except KeyError as e:
384
67
            raise NfssClientError('Failed to parse NFSS config: '
385
68
                                  '%s' % e.message)
386
69
        self.session = OAuth1Session(
387
70
            self.config['client_access_key'],
388
71
            resource_owner_key=self.config['resource_owner_key'],
389
72
            resource_owner_secret=self.config['resource_owner_secret'],
390
73
        )
391
74
392
75
    def post_data(self, json, project_name, test_name):
393
76
        """POST JSON result data to NFSS at a given project and test."""
394
77
        url = '/'.join((self.config['backend'], project_name, test_name))
395
78
        r = self.session.post(url, dict(data=json))
396
79
        if r.status_code != 200:
397
80
            raise NfssClientError("Failed to POST to NFSS: %s" % r.content)
398
0
81
399
=== added file 'coverage-extractor/coverageextractor/run_worker.py'
400
--- coverage-extractor/coverageextractor/run_worker.py	1970-01-01 00:00:00 +0000
401
+++ coverage-extractor/coverageextractor/run_worker.py	2014-10-23 21:46:26 +0000
402
@@ -0,0 +1,64 @@
403
1
#!/usr/bin/env python
404
2
# Ubuntu CI Engine
405
3
# Copyright 2014 Canonical Ltd.
406
4
#
407
5
# This program is free software: you can redistribute it and/or modify it
408
6
# under the terms of the GNU Affero General Public License version 3, as
409
7
# published by the Free Software Foundation.
410
8
#
411
9
# This program is distributed in the hope that it will be useful, but
412
10
# WITHOUT ANY WARRANTY; without even the implied warranties of
413
11
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
414
12
# PURPOSE.  See the GNU Affero General Public License for more details.
415
13
#
416
14
# You should have received a copy of the GNU Affero General Public License
417
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
418
16
419
17
from ci_utils import amqp_utils, amqp_worker
420
18
from coverageextractor.extraction import Extraction, ExtractionFailed
421
19
422
20
423
21
class CoverageExtractorWorker(amqp_worker.AMQPWorker):
424
22
425
23
    def __init__(self):
426
24
        super(CoverageExtractorWorker, self).__init__('coverageextractor')
427
25
428
26
    def handle_request(self, params, logger):
429
27
        """Extract coverage numbers from coverage.xml and post to NFSS.
430
28
431
29
        :param params: dictionary of params from incoming message
432
30
        :param logger: logging.Logger for reporting
433
31
        """
434
32
        # XXX alesage 20141022
435
33
        # Consider multi-coverage.xml builds, e.g. tickets reporting
436
34
        # builds of a package for more than one architecture.  These
437
35
        # could each initiate an Extraction, e.g.?  Also beware naming
438
36
        # overlap for results.
439
37
        ticket_id = params['ticket_id']
440
38
        data_store = self._create_data_store(ticket_id)
441
39
        extraction = Extraction(
442
40
            ticket_id,
443
41
            logger,
444
42
            data_store,
445
43
        )
446
44
        try:
447
45
            project, version = extraction.try_get_project_and_version(params)
448
46
            coverage_xml_path = extraction.try_get_coverage_xml_path(params)
449
47
            coverage_xml = extraction.try_get_coverage_xml(coverage_xml_path)
450
48
            line_data, branch_data = extraction.try_extract_coverage_data(
451
49
                coverage_xml
452
50
            )
453
51
            data = extraction.try_compose_nfss_json(
454
52
                project,
455
53
                version,
456
54
                line_data,
457
55
                branch_data,
458
56
            )
459
57
            extraction.try_post_data_to_nfss(data, project)
460
58
        except ExtractionFailed as e:
461
59
            return e.return_tuple
462
60
        return extraction.report_succeeded(ticket_id)
463
61
464
62
465
63
if __name__ == '__main__':
466
64
    CoverageExtractorWorker().main(amqp_utils.COVERAGE_RETRIEVER_QUEUE)
467
0
65
468
=== added directory 'coverage-extractor/coverageextractor/tests'
469
=== added file 'coverage-extractor/coverageextractor/tests/__init__.py'
470
--- coverage-extractor/coverageextractor/tests/__init__.py	1970-01-01 00:00:00 +0000
471
+++ coverage-extractor/coverageextractor/tests/__init__.py	2014-10-23 21:46:26 +0000
472
@@ -0,0 +1,86 @@
473
1
# Ubuntu CI Engine
474
2
# Copyright 2014 Canonical Ltd.
475
3
#
476
4
# This program is free software: you can redistribute it and/or modify it
477
5
# under the terms of the GNU Affero General Public License version 3, as
478
6
# published by the Free Software Foundation.
479
7
#
480
8
# This program is distributed in the hope that it will be useful, but
481
9
# WITHOUT ANY WARRANTY; without even the implied warranties of
482
10
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
483
11
# PURPOSE.  See the GNU Affero General Public License for more details.
484
12
#
485
13
# You should have received a copy of the GNU Affero General Public License
486
14
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
487
15
488
16
from contextlib import contextmanager
489
17
import unittest
490
18
491
19
from mock import patch
492
20
493
21
from ci_utils.amqp_worker import AMQPWorker
494
22
from ci_utils.testing.fixtures import FakeDataStore
495
23
496
24
vanilla_coverage_xml = u"""<?xml version="1.0" ?>
497
25
<!DOCTYPE coverage
498
26
  SYSTEM 'http://cobertura.sourceforge.net/xml/coverage-03.dtd'>
499
27
<coverage branch-rate="1.0" line-rate="1.0" timestamp="1410387089" version="gcovr 2.4 (r2774)">
500
28
	<sources>
501
29
		<source>/tmp/tmpz8yrh4tz/dummy</source>
502
30
	</sources>
503
31
	<packages>
504
32
		<package branch-rate="1.0" complexity="0.0" line-rate="1.0" name="">
505
33
			<classes>
506
34
				<class branch-rate="1.0" complexity="0.0" filename="fibonacci.cpp" line-rate="1.0" name="fibonacci_cpp">
507
35
					<lines>
508
36
						<line branch="false" hits="10" number="4"/>
509
37
						<line branch="true" condition-coverage="100% (2/2)" hits="10" number="6">
510
38
							<conditions>
511
39
								<condition coverage="100%" number="0" type="jump"/>
512
40
							</conditions>
513
41
						</line>
514
42
						<line branch="false" hits="3" number="7"/>
515
43
						<line branch="true" condition-coverage="100% (2/2)" hits="7" number="8">
516
44
							<conditions>
517
45
								<condition coverage="100%" number="0" type="jump"/>
518
46
							</conditions>
519
47
						</line>
520
48
						<line branch="false" hits="4" number="9"/>
521
49
						<line branch="false" hits="3" number="10"/>
522
50
					</lines>
523
51
				</class>
524
52
			</classes>
525
53
		</package>
526
54
	</packages>
527
55
</coverage>
528
56
529
57
"""  # NOQA
530
58
531
59
532
60
class CoverageExtractorTestCase(unittest.TestCase):
533
61
534
62
    @contextmanager
535
63
    def patch_create_data_store(self):
536
64
        """Patch in a FakeDataStore for testing."""
537
65
        self.fake_data_store = FakeDataStore('fake_ticket_id')
538
66
        self.addCleanup(self.fake_data_store.delete)
539
67
        with patch.object(
540
68
                AMQPWorker,
541
69
                '_create_data_store',
542
70
                return_value=self.fake_data_store) as create_data_store_patch:
543
71
            yield create_data_store_patch
544
72
545
73
    def put_fake_coverage_xml(
546
74
            self,
547
75
            data_store,
548
76
            coverage_xml=vanilla_coverage_xml):
549
77
        """Put a build log into our fake data store.
550
78
551
79
        :param data_store: FakeDataStore into which to put
552
80
        :param coverage_xml: str defaults to vanilla_coverage_xml
553
81
        """
554
82
        data_store.put_file(
555
83
            'coverage.xml',
556
84
            coverage_xml,
557
85
            content_type='text/plain'
558
86
        )
559
0
87
560
=== added file 'coverage-extractor/coverageextractor/tests/test_extract_coverage_data.py'
561
--- coverage-extractor/coverageextractor/tests/test_extract_coverage_data.py	1970-01-01 00:00:00 +0000
562
+++ coverage-extractor/coverageextractor/tests/test_extract_coverage_data.py	2014-10-23 21:46:26 +0000
563
@@ -0,0 +1,162 @@
564
1
# Ubuntu CI Engine
565
2
# Copyright 2014 Canonical Ltd.
566
3
#
567
4
# This program is free software: you can redistribute it and/or modify it
568
5
# under the terms of the GNU Affero General Public License version 3, as
569
6
# published by the Free Software Foundation.
570
7
#
571
8
# This program is distributed in the hope that it will be useful, but
572
9
# WITHOUT ANY WARRANTY; without even the implied warranties of
573
10
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
574
11
# PURPOSE.  See the GNU Affero General Public License for more details.
575
12
#
576
13
# You should have received a copy of the GNU Affero General Public License
577
14
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
578
15
579
16
import unittest
580
17
581
18
from coverageextractor import (
582
19
    CoverageExtractorException,
583
20
    extract_coverage_data,
584
21
)
585
22
from coverageextractor.tests import vanilla_coverage_xml
586
23
587
24
588
25
# here we refuse to close our <sources> tag :|
589
26
invalid_xml_coverage_xml = u"""<?xml version="1.0" ?>
590
27
<!DOCTYPE coverage
591
28
  SYSTEM 'http://cobertura.sourceforge.net/xml/coverage-03.dtd'>
592
29
<coverage branch-rate="1.0" line-rate="1.0" timestamp="1410387089" version="gcovr 2.4 (r2774)">
593
30
	<sources>
594
31
		<source>/tmp/tmpz8yrh4tz/dummy</source>
595
32
	<packages>
596
33
		<package branch-rate="1.0" complexity="0.0" line-rate="1.0" name="">
597
34
			<classes>
598
35
				<class branch-rate="1.0" complexity="0.0" filename="fibonacci.cpp" line-rate="1.0" name="fibonacci_cpp">
599
36
					<lines>
600
37
						<line branch="false" hits="10" number="4"/>
601
38
						<line branch="true" condition-coverage="100% (2/2)" hits="10" number="6">
602
39
							<conditions>
603
40
								<condition coverage="100%" number="0" type="jump"/>
604
41
							</conditions>
605
42
						</line>
606
43
						<line branch="false" hits="3" number="7"/>
607
44
						<line branch="true" condition-coverage="100% (2/2)" hits="7" number="8">
608
45
							<conditions>
609
46
								<condition coverage="100%" number="0" type="jump"/>
610
47
							</conditions>
611
48
						</line>
612
49
						<line branch="false" hits="4" number="9"/>
613
50
						<line branch="false" hits="3" number="10"/>
614
51
					</lines>
615
52
				</class>
616
53
			</classes>
617
54
		</package>
618
55
	</packages>
619
56
</coverage>
620
57
"""  # NOQA
621
58
622
59
# NOTE a *baseball* dingbat in sources filepath
623
60
unicode_coverage_xml = unicode("""<?xml version="1.0" ?>
624
61
<!DOCTYPE coverage
625
62
  SYSTEM 'http://cobertura.sourceforge.net/xml/coverage-03.dtd'>
626
63
<coverage branch-rate="1.0" line-rate="1.0" timestamp="1410387089" version="gcovr 2.4 (r2774)">
627
64
	<sources>
628
65
		<source>/tmp/\u26BE/dummy</source>
629
66
	</sources>
630
67
	<packages>
631
68
		<package branch-rate="1.0" complexity="0.0" line-rate="1.0" name="">
632
69
			<classes>
633
70
				<class branch-rate="1.0" complexity="0.0" filename="fibonacci.cpp" line-rate="1.0" name="fibonacci_cpp">
634
71
					<lines>
635
72
						<line branch="false" hits="10" number="4"/>
636
73
						<line branch="true" condition-coverage="100% (2/2)" hits="10" number="6">
637
74
							<conditions>
638
75
								<condition coverage="100%" number="0" type="jump"/>
639
76
							</conditions>
640
77
						</line>
641
78
						<line branch="false" hits="3" number="7"/>
642
79
						<line branch="true" condition-coverage="100% (2/2)" hits="7" number="8">
643
80
							<conditions>
644
81
								<condition coverage="100%" number="0" type="jump"/>
645
82
							</conditions>
646
83
						</line>
647
84
						<line branch="false" hits="4" number="9"/>
648
85
						<line branch="false" hits="3" number="10"/>
649
86
					</lines>
650
87
				</class>
651
88
			</classes>
652
89
		</package>
653
90
	</packages>
654
91
</coverage>
655
92
""")  # NOQA
656
93
657
94
# we'll almost certainly never see garbled coverage data but hey
658
95
garbled_numbers_coverage_xml = u"""<?xml version="1.0" ?>
659
96
<!DOCTYPE coverage
660
97
  SYSTEM 'http://cobertura.sourceforge.net/xml/coverage-03.dtd'>
661
98
<coverage branch-rate="garblegarble" line-rate="1.0" timestamp="1410387089" version="gcovr 2.4 (r2774)">
662
99
	<sources>
663
100
		<source>/tmp/tmpz8yrh4tz/dummy</source>
664
101
        </sources>
665
102
	<packages>
666
103
		<package branch-rate="1.0" complexity="0.0" line-rate="1.0" name="">
667
104
			<classes>
668
105
				<class branch-rate="1.0" complexity="0.0" filename="fibonacci.cpp" line-rate="1.0" name="fibonacci_cpp">
669
106
					<lines>
670
107
						<line branch="false" hits="10" number="4"/>
671
108
						<line branch="true" condition-coverage="100% (2/2)" hits="10" number="6">
672
109
							<conditions>
673
110
								<condition coverage="100%" number="0" type="jump"/>
674
111
							</conditions>
675
112
						</line>
676
113
						<line branch="false" hits="3" number="7"/>
677
114
						<line branch="true" condition-coverage="100% (2/2)" hits="7" number="8">
678
115
							<conditions>
679
116
								<condition coverage="100%" number="0" type="jump"/>
680
117
							</conditions>
681
118
						</line>
682
119
						<line branch="false" hits="4" number="9"/>
683
120
						<line branch="false" hits="3" number="10"/>
684
121
					</lines>
685
122
				</class>
686
123
			</classes>
687
124
		</package>
688
125
	</packages>
689
126
</coverage>
690
127
"""  # NOQA
691
128
692
129
693
130
class ExtractCoverageDataTestCase(unittest.TestCase):
694
131
695
132
    def test_extract_coverage_data(self):
696
133
        """Extract coverage data from a vanilla build log bytestring."""
697
134
        line_coverage, branch_coverage = extract_coverage_data(
698
135
            vanilla_coverage_xml
699
136
        )
700
137
        self.assertAlmostEqual(1.0, line_coverage)
701
138
        self.assertAlmostEqual(1.0, branch_coverage)
702
139
703
140
    def test_invalid_xml_raises(self):
704
141
        """We raise an exception if we find invalid XML."""
705
142
        self.assertRaises(
706
143
            CoverageExtractorException,
707
144
            extract_coverage_data,
708
145
            invalid_xml_coverage_xml
709
146
        )
710
147
711
148
    def test_garbled_numbers_raise(self):
712
149
        """We raise an exception if coverage numbers don't float."""
713
150
        self.assertRaises(
714
151
            CoverageExtractorException,
715
152
            extract_coverage_data,
716
153
            garbled_numbers_coverage_xml
717
154
        )
718
155
719
156
    def test_unicode_parses(self):
720
157
        """Extract coverage data from a build log with unicode characters."""
721
158
        line_coverage, branch_coverage = extract_coverage_data(
722
159
            unicode_coverage_xml
723
160
        )
724
161
        self.assertAlmostEqual(1.0, line_coverage)
725
162
        self.assertAlmostEqual(1.0, branch_coverage)
726
0
163
727
=== added file 'coverage-extractor/coverageextractor/tests/test_extraction.py'
728
--- coverage-extractor/coverageextractor/tests/test_extraction.py	1970-01-01 00:00:00 +0000
729
+++ coverage-extractor/coverageextractor/tests/test_extraction.py	2014-10-23 21:46:26 +0000
730
@@ -0,0 +1,233 @@
731
1
#!/usr/bin/env python
732
2
# Ubuntu CI Engine
733
3
# Copyright 2014 Canonical Ltd.
734
4
#
735
5
# This program is free software: you can redistribute it and/or modify it
736
6
# under the terms of the GNU Affero General Public License version 3, as
737
7
# published by the Free Software Foundation.
738
8
#
739
9
# This program is distributed in the hope that it will be useful, but
740
10
# WITHOUT ANY WARRANTY; without even the implied warranties of
741
11
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
742
12
# PURPOSE.  See the GNU Affero General Public License for more details.
743
13
#
744
14
# You should have received a copy of the GNU Affero General Public License
745
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
746
16
747
17
import logging
748
18
749
19
from mock import patch, Mock
750
20
751
21
from ci_utils.data_store import DataStoreException
752
22
from coverageextractor import CoverageExtractorException
753
23
from coverageextractor.nfss_client import NfssClient, NfssClientError
754
24
from coverageextractor.tests import (
755
25
    CoverageExtractorTestCase,
756
26
    vanilla_coverage_xml,
757
27
)
758
28
from coverageextractor.extraction import (
759
29
    Extraction,
760
30
    ExtractionFailed,
761
31
    JSON_ENCODING_FAILURE_TEMPLATE,
762
32
    NFSS_CLIENT_ERROR_TEMPLATE,
763
33
    PARSE_FAILURE_TEMPLATE,
764
34
    SUCCESS_TEMPLATE,
765
35
    SWIFT_GET_FAILURE_TEMPLATE,
766
36
)
767
37
768
38
769
39
class ExtractionTestCase(CoverageExtractorTestCase):
770
40
771
41
    def test_try_get_project_and_version(self):
772
42
        """Vanilla get project and version from subticket."""
773
43
        params = {
774
44
            'subtickets': [
775
45
                {
776
46
                    'name': 'libfibonacci',
777
47
                    'version': '0.1-0ubuntu1',
778
48
                },
779
49
            ]
780
50
        }
781
51
        ext = Extraction('fake-ticket-id', 'fake-logger', 'fake-data-store')
782
52
        self.assertEqual(
783
53
            ('libfibonacci', '0.1-0ubuntu1'),
784
54
            ext.try_get_project_and_version(params)
785
55
        )
786
56
787
57
    def test_try_get_project_and_version_raises(self):
788
58
        """Failure to find project and version raises."""
789
59
790
60
    def test_try_get_coverage_xml_path(self):
791
61
        """We get the coverage.xml path from params."""
792
62
        with self.patch_create_data_store() as fake_data_store:
793
63
            params = {'coverage_xml_path': 'coverage.xml'}
794
64
            ext = Extraction('fake-ticket-id', 'fake-logger', fake_data_store)
795
65
            self.assertEqual(
796
66
                'coverage.xml',
797
67
                ext.try_get_coverage_xml_path(params),
798
68
            )
799
69
800
70
    @patch.object(Extraction, 'report_failed')
801
71
    def test_extract_coverage_xml_path_failure(self, report_failed):
802
72
        """Failure to get the coverage.xml path from params fails."""
803
73
        with self.patch_create_data_store() as fake_data_store:
804
74
            malevolent_params = {'gibberish': 'coverage.xml'}
805
75
            ext = Extraction('fake-ticket-id', 'fake-logger', fake_data_store)
806
76
            ext.try_get_coverage_xml_path(malevolent_params)
807
77
        report_failed.assert_called()
808
78
809
79
    def test_try_get_coverage_xml(self):
810
80
        """Retrieve our coverage.xml from swift."""
811
81
        with self.patch_create_data_store() as fake_data_store:
812
82
            fake_data_store.get_file.return_value = vanilla_coverage_xml
813
83
            ext = Extraction('fake-ticket-id', 'fake-logger', fake_data_store)
814
84
            self.assertEqual(
815
85
                vanilla_coverage_xml,
816
86
                ext.try_get_coverage_xml('coverage.xml'),
817
87
            )
818
88
819
89
    def test_try_get_coverage_xml_retries(self):
820
90
        """Retry if swift fails to yield our coverage.xml."""
821
91
        fake_logger = Mock(spec_set=logging.Logger)
822
92
        with self.patch_create_data_store() as fake_data_store:
823
93
            ext = Extraction('fake-ticket-id', fake_logger, fake_data_store)
824
94
            fake_data_store.get_file.side_effect = [
825
95
                DataStoreException("No log!"),
826
96
                DataStoreException("Still no log!"),
827
97
                vanilla_coverage_xml
828
98
            ]
829
99
            with patch('coverageextractor.time.sleep'):  # for the impatient
830
100
                self.assertEqual(
831
101
                    vanilla_coverage_xml,
832
102
                    ext.try_get_coverage_xml('coverage.xml')
833
103
                )
834
104
        self.assertEqual(3, fake_data_store.get_file.call_count)
835
105
        fake_logger.warning.assert_called()
836
106
837
107
    @patch.object(Extraction, 'report_failed')
838
108
    def test_try_get_coverage_xml_raises(self, report_failed):
839
109
        """Return failure if swift fails to yield our coverage.xml."""
840
110
        fake_logger = Mock(spec_set=logging.Logger)
841
111
        with self.patch_create_data_store() as fake_data_store:
842
112
            ext = Extraction('fake-ticket-id', fake_logger, fake_data_store)
843
113
            fake_data_store.get_file.side_effect = DataStoreException(
844
114
                'Drool...'
845
115
            )
846
116
            with patch('coverageextractor.time.sleep'):  # for the impatient
847
117
                ext.try_get_coverage_xml('coverage.xml')
848
118
        report_failed.assert_called_with(
849
119
            SWIFT_GET_FAILURE_TEMPLATE,
850
120
            'fake-ticket-id',
851
121
            'Drool...',
852
122
        )
853
123
854
124
    def test_try_extract_coverage_data(self):
855
125
        """Extract coverage data from coverage.xml."""
856
126
        ext = Extraction('fake-ticket-id', 'fake-logger', 'fake-data-store')
857
127
        line_coverage, branch_coverage = ext.try_extract_coverage_data(
858
128
            vanilla_coverage_xml
859
129
        )
860
130
        self.assertAlmostEqual(1.0, line_coverage)
861
131
        self.assertAlmostEqual(1.0, branch_coverage)
862
132
863
133
    @patch.object(Extraction, 'report_failed')
864
134
    @patch('coverageextractor.extraction.extract_coverage_data')
865
135
    def test_try_extract_coverage_data_raises(
866
136
            self,
867
137
            extract_coverage_data,
868
138
            report_failed):
869
139
        """Report failure when we fail to extract coverage data."""
870
140
        extract_coverage_data.side_effect = CoverageExtractorException(
871
141
            "No data for you!"
872
142
        )
873
143
        ext = Extraction('fake-ticket-id', 'fake-logger', 'fake-data-store')
874
144
        ext.try_extract_coverage_data(vanilla_coverage_xml)
875
145
        report_failed.assert_called_with(
876
146
            PARSE_FAILURE_TEMPLATE,
877
147
            'fake-ticket-id',
878
148
            "No data for you!",
879
149
        )
880
150
881
151
    def test_compose_nfss_json(self):
882
152
        """Dump a string of data to put to NFSS."""
883
153
        ext = Extraction('fake-ticket-id', 'fake-logger', 'fake-data-store')
884
154
        json = ext.try_compose_nfss_json(
885
155
            'fake-package-name',
886
156
            '0.1.PBJ.BBQ-0ubuntu1',
887
157
            1.0,
888
158
            0.572,
889
159
        )
890
160
        self.assertEqual(
891
161
            '{"version": "0.1.PBJ.BBQ-0ubuntu1", "name": "fake-package-name", "line_coverage": 1.0, "branch_coverage": 0.572}',  # NOQA
892
162
            json
893
163
        )
894
164
895
165
    @patch.object(Extraction, 'report_failed')
896
166
    @patch('coverageextractor.extraction.json.dumps')
897
167
    def test_compose_nfss_json_raises(self, dumps, report_failed):
898
168
        """Handle the error from un-jsonnable params.
899
169
900
170
        This is pretty unlikely.
901
171
        """
902
172
        dumps.side_effect = ValueError('This is pretty unlikely.')
903
173
        ext = Extraction('fake-ticket-id', 'fake-logger', 'fake-data-store')
904
174
        ext.try_compose_nfss_json(
905
175
            'fake-package-name',
906
176
            '0.1.PBJ.BBQ-0ubuntu1',
907
177
            1.0,
908
178
            0.572,
909
179
        )
910
180
        report_failed.assert_called_with(
911
181
            JSON_ENCODING_FAILURE_TEMPLATE,
912
182
            'fake-ticket-id',
913
183
            "This is pretty unlikely.",
914
184
        )
915
185
916
186
    @patch.object(NfssClient, 'post_data')
917
187
    def test_try_post_data_to_nfss(self, post_data):
918
188
        """Post JSON result to NFSS."""
919
189
        ext = Extraction('fake-ticket-id', 'fake-logger', 'fake-data-store')
920
190
        with patch.object(NfssClient, '__init__', new=Mock(return_value=None)):
921
191
            ext.try_post_data_to_nfss({'foo': 42}, 'libfibonacci', 'coverage')
922
192
        post_data.assert_called_with({'foo': 42}, 'libfibonacci', 'coverage')
923
193
924
194
    @patch.object(Extraction, 'report_failed')
925
195
    @patch.object(NfssClient, 'post_data')
926
196
    def test_nfss_doesnt_love_us(self, post_data, report_failed):
927
197
        """Bad post to NFSS reports failure."""
928
198
        ext = Extraction('fake-ticket-id', 'fake-logger', 'fake-data-store')
929
199
        post_data.side_effect = NfssClientError('NFSS luvs u <3 .')
930
200
        with patch.object(NfssClient, '__init__', new=Mock(return_value=None)):
931
201
            ext.try_post_data_to_nfss({'foo': 42}, 'libfibonacci', 'coverage')
932
202
        report_failed.assert_called_with(
933
203
            NFSS_CLIENT_ERROR_TEMPLATE,
934
204
            'fake-ticket-id',
935
205
            'NFSS luvs u <3 .',
936
206
        )
937
207
938
208
    def test_report_failed_raises(self):
939
209
        """Internal catch-all handler raises ExtractionFailed."""
940
210
        with self.patch_create_data_store() as fake_data_store:
941
211
            fake_logger = Mock(spec_set=logging.Logger)
942
212
            ext = Extraction('fake-ticket-id', fake_logger, fake_data_store)
943
213
            self.assertRaises(
944
214
                ExtractionFailed,
945
215
                lambda: ext.report_failed("%s %s", 'foo', 'bar')
946
216
            )
947
217
        fake_logger.error.assert_called_with("foo bar")
948
218
949
219
    @patch('coverageextractor.extraction.generate_and_put_artifact')
950
220
    def test_report_succeeded(self, generate_and_put_artifact):
951
221
        """Report success to swift and logging."""
952
222
        generate_and_put_artifact.side_effect = ['coverage.xml',
953
223
                                                 'success-message']
954
224
        with self.patch_create_data_store() as fake_data_store:
955
225
            fake_logger = Mock(spec_set=logging.Logger)
956
226
            ext = Extraction('fake-ticket-id', fake_logger, fake_data_store)
957
227
            ext.report_succeeded('fake-ticket-id')
958
228
        fake_logger.info.assert_called_with(SUCCESS_TEMPLATE, 'fake-ticket-id')
959
229
        generate_and_put_artifact.assert_any_call(
960
230
            fake_data_store,
961
231
            message=(SUCCESS_TEMPLATE % 'fake-ticket-id'),
962
232
        )
963
233
        self.assertEqual(1, generate_and_put_artifact.call_count)
964
0
234
965
=== added file 'coverage-extractor/coverageextractor/tests/test_handle_request.py'
966
--- coverage-extractor/coverageextractor/tests/test_handle_request.py	1970-01-01 00:00:00 +0000
967
+++ coverage-extractor/coverageextractor/tests/test_handle_request.py	2014-10-23 21:46:26 +0000
968
@@ -0,0 +1,121 @@
969
1
# Ubuntu CI Engine
970
2
# Copyright 2014 Canonical Ltd.
971
3
#
972
4
# This program is free software: you can redistribute it and/or modify it
973
5
# under the terms of the GNU Affero General Public License version 3, as
974
6
# published by the Free Software Foundation.
975
7
#
976
8
# This program is distributed in the hope that it will be useful, but
977
9
# WITHOUT ANY WARRANTY; without even the implied warranties of
978
10
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
979
11
# PURPOSE.  See the GNU Affero General Public License for more details.
980
12
#
981
13
# You should have received a copy of the GNU Affero General Public License
982
14
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
983
15
984
16
import logging
985
17
import os
986
18
987
19
from mock import Mock, patch
988
20
989
21
from ci_utils import amqp_utils
990
22
from coverageextractor.extraction import Extraction
991
23
from coverageextractor.tests import CoverageExtractorTestCase
992
24
from coverageextractor.extraction import (
993
25
    MISSING_PARAMS_TEMPLATE,
994
26
    SUCCESS_TEMPLATE,
995
27
)
996
28
from coverageextractor.run_worker import CoverageExtractorWorker
997
29
998
30
999
31
class HandleRequestTestCase(CoverageExtractorTestCase):
1000
32
1001
33
    @patch.object(Extraction, 'try_post_data_to_nfss')
1002
34
    def test_vanilla_handle_request(self, try_post_data_to_nfss):
1003
35
        """Large integration test for coverage extraction.
1004
36
1005
37
        NOTE that we do patch the NFSS call.
1006
38
        """
1007
39
        fake_logger = Mock(spec_set=logging.Logger)
1008
40
        with self.patch_create_data_store():
1009
41
            self.put_fake_coverage_xml(self.fake_data_store)
1010
42
            worker = CoverageExtractorWorker()
1011
43
            fake_params = {
1012
44
                'coverage_xml_path': 'coverage.xml',
1013
45
                'ticket_id': 'fake_ticket_id',
1014
46
                'subtickets': [
1015
47
                    {
1016
48
                        'name': 'libfibonacci',
1017
49
                        'version': '0.1-0ubuntu1',
1018
50
                    },
1019
51
                ],
1020
52
            }
1021
53
            amqp_result, result_data = worker.handle_request(
1022
54
                fake_params,
1023
55
                fake_logger,
1024
56
            )
1025
57
        self.assertEqual(amqp_utils.progress_completed, amqp_result)
1026
58
        self.assertEqual(
1027
59
            SUCCESS_TEMPLATE % 'fake_ticket_id',
1028
60
            result_data['message'],
1029
61
        )
1030
62
        fake_logger.info.assert_called_with(
1031
63
            SUCCESS_TEMPLATE, 'fake_ticket_id'
1032
64
        )
1033
65
        self.assertEqual(1, len(result_data['artifacts']))
1034
66
        # find a log message as our only artifact
1035
67
        log_artifact = result_data['artifacts'][0]
1036
68
        self.assertEqual(
1037
69
            SUCCESS_TEMPLATE % 'fake_ticket_id',
1038
70
            log_artifact['message'],
1039
71
        )
1040
72
        self.assertEqual('LOGS', log_artifact['type'])
1041
73
        self.assertEqual(
1042
74
            'file://' + os.path.join(
1043
75
                os.path.abspath(os.curdir),
1044
76
                'fake_ticket_id/coverage-extractor.output.log'),
1045
77
            log_artifact['reference']
1046
78
        )
1047
79
1048
80
    def test_exception_returns_failure(self):
1049
81
        """An exception in our imperatives returns a failure.
1050
82
1051
83
        Actuate a KeyError in try_extract_coverage_xml_path, inspect our
1052
84
        results to make sure we're logging, depositing a log in swift.
1053
85
        """
1054
86
        fake_logger = Mock(spec_set=logging.Logger)
1055
87
        with self.patch_create_data_store() as fake_data_store:
1056
88
            self.put_fake_coverage_xml(fake_data_store)
1057
89
            worker = CoverageExtractorWorker()
1058
90
            # actuate a KeyError in try_extract_coverage_xml_path
1059
91
            malevolent_params = {
1060
92
                'gibberish': 'coverage.xml',
1061
93
                'ticket_id': 'fake_ticket_id',
1062
94
                'subtickets': [
1063
95
                    {
1064
96
                        'name': 'libfibonacci',
1065
97
                        'version': '0.1-0ubuntu1',
1066
98
                    },
1067
99
                ],
1068
100
            }
1069
101
            amqp_result, result_data = worker.handle_request(
1070
102
                malevolent_params,
1071
103
                fake_logger
1072
104
            )
1073
105
        self.assertEqual(amqp_utils.progress_failed, amqp_result)
1074
106
        self.assertEqual(
1075
107
            MISSING_PARAMS_TEMPLATE % 'fake_ticket_id',
1076
108
            result_data['message']
1077
109
        )
1078
110
        self.assertEqual(1, len(result_data['artifacts']))
1079
111
        artifact = result_data['artifacts'][0]
1080
112
        self.assertEqual(
1081
113
            'file://' + os.path.join(
1082
114
                os.path.abspath(os.curdir),
1083
115
                'fake_ticket_id/coverage-extractor.output.log'),
1084
116
            artifact['reference'])
1085
117
        self.assertEqual(
1086
118
            MISSING_PARAMS_TEMPLATE % 'fake_ticket_id',
1087
119
            result_data['message']
1088
120
        )
1089
121
        self.assertEqual('LOGS', artifact['type'])
1090
0
122
1091
=== added file 'coverage-extractor/coverageextractor/tests/test_nfss_client.py'
1092
--- coverage-extractor/coverageextractor/tests/test_nfss_client.py	1970-01-01 00:00:00 +0000
1093
+++ coverage-extractor/coverageextractor/tests/test_nfss_client.py	2014-10-23 21:46:26 +0000
1094
@@ -0,0 +1,150 @@
1095
1
#!/usr/bin/env python
1096
2
# Ubuntu CI Engine
1097
3
# Copyright 2014 Canonical Ltd.
1098
4
#
1099
5
# This program is free software: you can redistribute it and/or modify it
1100
6
# under the terms of the GNU Affero General Public License version 3, as
1101
7
# published by the Free Software Foundation.
1102
8
#
1103
9
# This program is distributed in the hope that it will be useful, but
1104
10
# WITHOUT ANY WARRANTY; without even the implied warranties of
1105
11
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1106
12
# PURPOSE.  See the GNU Affero General Public License for more details.
1107
13
#
1108
14
# You should have received a copy of the GNU Affero General Public License
1109
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1110
16
1111
17
import unittest
1112
18
1113
19
from mock import Mock, patch
1114
20
1115
21
from coverageextractor.nfss_client import (
1116
22
    NFSS_CONFIG_PATH,
1117
23
    NfssClient,
1118
24
    NfssClientError,
1119
25
    parse_nfss_config,
1120
26
)
1121
27
1122
28
1123
29
class ParseNfssConfigTestCase(unittest.TestCase):
1124
30
1125
31
    @patch('coverageextractor.nfss_client.ConfigParser')
1126
32
    def test_parse(self, config_parser):
1127
33
        """We can successfully parse an NFSS config."""
1128
34
        nfss_config_dict = {
1129
35
            'client_access_key': 'fake-client-acccess-key',
1130
36
            'resource_owner_key': 'fake-resource-owner-key',
1131
37
            'resource_owner_secret': 'fake-resource-owner-secret',
1132
38
            'backend': 'fake-backend',
1133
39
        }
1134
40
        # yes these are weird due to ConfigParser backwardness
1135
41
        config_parser.return_value.read = Mock()
1136
42
        # "dance like no-one is watching"
1137
43
        config_parser.return_value.__getitem__ = Mock(
1138
44
            return_value=nfss_config_dict
1139
45
        )
1140
46
        self.assertEqual(
1141
47
            nfss_config_dict,
1142
48
            parse_nfss_config('fake-config-path')
1143
49
        )
1144
50
1145
51
    @patch('coverageextractor.nfss_client.ConfigParser')
1146
52
    def test_no_nfss_section_raises(self, config_parser):
1147
53
        """No 'nfss' section in config raises."""
1148
54
        config_parser.return_value.read = Mock()
1149
55
        config_parser.return_value.__getitem__ = Mock(
1150
56
            side_effect=KeyError('client_access_key')
1151
57
        )
1152
58
        with self.assertRaises(KeyError):
1153
59
            parse_nfss_config('fake-config-path')
1154
60
1155
61
    @patch('coverageextractor.nfss_client.ConfigParser')
1156
62
    def test_missing_key_raises(self, config_parser):
1157
63
        """A missing key in the config raises."""
1158
64
        nfss_config_dict = {}
1159
65
        config_parser.return_value.read = Mock()
1160
66
        config_parser.return_value.__getitem__ = Mock(
1161
67
            return_value=nfss_config_dict
1162
68
        )
1163
69
        with self.assertRaises(KeyError):
1164
70
            parse_nfss_config('fake-config-path')
1165
71
1166
72
1167
73
class NfssClientTest(unittest.TestCase):
1168
74
1169
75
    @patch('coverageextractor.nfss_client.OAuth1Session')
1170
76
    @patch('coverageextractor.nfss_client.parse_nfss_config')
1171
77
    def test_init(self, parse_nfss_config, oauth_session):
1172
78
        """We can create a NfssClient."""
1173
79
        parse_nfss_config.return_value = {
1174
80
            'client_access_key': 'fake-client-access-key',
1175
81
            'resource_owner_key': 'fake-resource-owner-key',
1176
82
            'resource_owner_secret': 'fake-resource-owner-secret'
1177
83
        }
1178
84
        NfssClient('fake-config-path')
1179
85
        oauth_session.assert_called_with(
1180
86
            'fake-client-access-key',
1181
87
            resource_owner_key='fake-resource-owner-key',
1182
88
            resource_owner_secret='fake-resource-owner-secret',
1183
89
        )
1184
90
1185
91
    @patch('coverageextractor.nfss_client.OAuth1Session')
1186
92
    @patch('coverageextractor.nfss_client.parse_nfss_config')
1187
93
    def test_no_config_path(self, parse_nfss_config, oauth_session):
1188
94
        """Config path defaults if not passed in as param."""
1189
95
        parse_nfss_config.return_value = {
1190
96
            'client_access_key': 'fake-client-access-key',
1191
97
            'resource_owner_key': 'fake-resource-owner-key',
1192
98
            'resource_owner_secret': 'fake-resource-owner-secret'
1193
99
        }
1194
100
        nfss_client = NfssClient()
1195
101
        oauth_session.assert_called_with(
1196
102
            'fake-client-access-key',
1197
103
            resource_owner_key='fake-resource-owner-key',
1198
104
            resource_owner_secret='fake-resource-owner-secret',
1199
105
        )
1200
106
        self.assertEqual(NFSS_CONFIG_PATH, nfss_client.nfss_config_path)
1201
107
1202
108
    @patch('coverageextractor.nfss_client.parse_nfss_config')
1203
109
    def test_init_raises(self, parse_nfss_config):
1204
110
        """We can create a NfssClient."""
1205
111
        parse_nfss_config.side_effect = KeyError('Mangled config!')
1206
112
        with self.assertRaises(NfssClientError):
1207
113
            NfssClient('fake-config-path')
1208
114
1209
115
    def test_post_data(self):
1210
116
        """Vanilla POST to NFSS."""
1211
117
        with patch.object(
1212
118
                NfssClient,
1213
119
                '__init__',
1214
120
                new=Mock(return_value=None)):
1215
121
            nfss_client = NfssClient()
1216
122
            nfss_client.config = {'backend': 'http://NFSS.io'}
1217
123
            nfss_client.session = Mock(
1218
124
                # successful POST
1219
125
                post=Mock(return_value=Mock(status_code=200)),
1220
126
            )
1221
127
            nfss_client.post_data(
1222
128
                {'foo': 'bar'},
1223
129
                'coverage',
1224
130
                'libfibonacci',
1225
131
            )
1226
132
1227
133
    def test_bad_post_data_raises(self):
1228
134
        """Bad POST to NFSS raises."""
1229
135
        with patch.object(
1230
136
                NfssClient,
1231
137
                '__init__',
1232
138
                new=Mock(return_value=None)):
1233
139
            nfss_client = NfssClient()
1234
140
            nfss_client.config = {'backend': 'http://NFSS.io'}
1235
141
            nfss_client.session = Mock(
1236
142
                # successful POST
1237
143
                post=Mock(return_value=Mock(status_code=500)),
1238
144
            )
1239
145
            with self.assertRaises(NfssClientError):
1240
146
                nfss_client.post_data(
1241
147
                    {'foo': 'bar'},
1242
148
                    'coverage',
1243
149
                    'libfibonacci',
1244
150
                )
1245
0
151
1246
=== added file 'coverage-extractor/setup.py'
1247
--- coverage-extractor/setup.py	1970-01-01 00:00:00 +0000
1248
+++ coverage-extractor/setup.py	2014-10-23 21:46:26 +0000
1249
@@ -0,0 +1,34 @@
1250
1
#!/usr/bin/env python
1251
2
# Ubuntu CI Engine
1252
3
# Copyright 2014 Canonical Ltd.
1253
4
#
1254
5
# This program is free software: you can redistribute it and/or modify it
1255
6
# under the terms of the GNU Affero General Public License version 3, as
1256
7
# published by the Free Software Foundation.
1257
8
#
1258
9
# This program is distributed in the hope that it will be useful, but
1259
10
# WITHOUT ANY WARRANTY; without even the implied warranties of
1260
11
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
1261
12
# PURPOSE.  See the GNU Affero General Public License for more details.
1262
13
#
1263
14
# You should have received a copy of the GNU Affero General Public License
1264
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1265
16
1266
17
1267
18
from setuptools import setup, find_packages
1268
19
1269
20
requires = [
1270
21
    'amqplib==1.0.0',
1271
22
    'python-swiftclient>=1.8.0',
1272
23
    'PyYAML==3.10',
1273
24
    'requests-oauthlib>=0.4.1',
1274
25
    'ucitests==0.1.5',
1275
26
]
1276
27
1277
28
setup(
1278
29
    name='coverageextractor',
1279
30
    version='0.1',
1280
31
    packages=find_packages(),
1281
32
    description='Coverage Retriever',
1282
33
    install_requires=requires,
1283
34
)
1284
0
35
1285
=== added file 'coverage-extractor/tox.ini'
1286
--- coverage-extractor/tox.ini	1970-01-01 00:00:00 +0000
1287
+++ coverage-extractor/tox.ini	2014-10-23 21:46:26 +0000
1288
@@ -0,0 +1,19 @@
1289
1
[tox]
1290
2
envlist = py27, flake8
1291
3
1292
4
[testenv]
1293
5
deps =
1294
6
    coverage
1295
7
    mock
1296
8
commands =
1297
9
    {envpython} setup.py develop
1298
10
    coverage erase
1299
11
    coverage run --omit=.tox/*,*/tests/*,ci_utils/* -m unittest discover -s coverageextractor
1300
12
    coverage report -m
1301
13
    coverage html
1302
14
1303
15
[testenv:flake8]
1304
16
deps =
1305
17
    flake8
1306
18
commands =
1307
19
    flake8 coverageextractor
1308
0
20
1309
=== modified file 'testing/run_tests.py'
1310
--- testing/run_tests.py	2014-10-10 10:00:49 +0000
1311
+++ testing/run_tests.py	2014-10-23 21:46:26 +0000
1312
@@ -121,6 +121,7 @@
1313
121
                  'ppa-creator',
121
                  'ppa-creator',
1314
122
                  'validator',
122
                  'validator',
1315
123
                  'coverage-retriever',
123
                  'coverage-retriever',
1316
124
                  'coverage-extractor',
1317
124
                  ]
125
                  ]
1318
125
    loader = loaders.Loader()
126
    loader = loaders.Loader()
1319
126
    # setuptools tends to leave eggs all over the place
127
    # setuptools tends to leave eggs all over the place
Status:	Needs review
Proposed branch:	lp:~allanlesage/uci-engine/coverage-extractor
Merge into:	lp:uci-engine
Diff against target:	1319 lines (+1251/-0) 12 files modified coverage-extractor/coverageextractor/__init__.py (+75/-0) coverage-extractor/coverageextractor/extraction.py (+226/-0) coverage-extractor/coverageextractor/nfss_client.py (+80/-0) coverage-extractor/coverageextractor/run_worker.py (+64/-0) coverage-extractor/coverageextractor/tests/__init__.py (+86/-0) coverage-extractor/coverageextractor/tests/test_extract_coverage_data.py (+162/-0) coverage-extractor/coverageextractor/tests/test_extraction.py (+233/-0) coverage-extractor/coverageextractor/tests/test_handle_request.py (+121/-0) coverage-extractor/coverageextractor/tests/test_nfss_client.py (+150/-0) coverage-extractor/setup.py (+34/-0) coverage-extractor/tox.ini (+19/-0) testing/run_tests.py (+1/-0)
To merge this branch:	bzr merge lp:~allanlesage/uci-engine/coverage-extractor
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Approve on 2014-10-23
Francis Ginther		2014-10-18	Approve on 2014-10-23
Review via email: mp+238782@code.launchpad.net