← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_source.py

  • Committer: Vincent Ladeuil
  • Date: 2017-01-30 14:30:10 UTC
  • mfrom: (6615.3.7 merges)
  • mto: This revision was merged to the branch mainline in revision 6621.
  • Revision ID: v.ladeuil+lp@free.fr-20170130143010-p31t1ranfeqbaeki
Merge  2.7 into trunk including fix for bug #1657238

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_source.py
1
 
# Copyright (C) 2005, 2006, 2008 Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
3
 
#            and others
 
1
# Copyright (C) 2005-2011 Canonical Ltd
4
2
#
5
3
# This program is free software; you can redistribute it and/or modify
6
4
# it under the terms of the GNU General Public License as published by
21
19
They are useful for testing code quality, checking coverage metric etc.
22
20
"""
23
21
 
24
 
# import system imports here
25
22
import os
26
23
import parser
27
24
import re
29
26
import sys
30
27
import token
31
28
 
32
 
#import bzrlib specific imports here
33
29
from bzrlib import (
34
30
    osutils,
35
31
    )
42
38
 
43
39
# Files which are listed here will be skipped when testing for Copyright (or
44
40
# GPL) statements.
45
 
COPYRIGHT_EXCEPTIONS = ['bzrlib/lsprof.py', 'bzrlib/_bencode_py.py']
 
41
COPYRIGHT_EXCEPTIONS = [
 
42
    'bzrlib/_bencode_py.py',
 
43
    'bzrlib/doc_generate/conf.py',
 
44
    'bzrlib/lsprof.py',
 
45
    ]
46
46
 
47
 
LICENSE_EXCEPTIONS = ['bzrlib/lsprof.py', 'bzrlib/_bencode_py.py']
 
47
LICENSE_EXCEPTIONS = [
 
48
    'bzrlib/_bencode_py.py',
 
49
    'bzrlib/doc_generate/conf.py',
 
50
    'bzrlib/lsprof.py',
 
51
    ]
48
52
# Technically, 'bzrlib/lsprof.py' should be 'bzrlib/util/lsprof.py',
49
53
# (we do not check bzrlib/util/, since that is code bundled from elsewhere)
50
54
# but for compatibility with previous releases, we don't want to move it.
 
55
#
 
56
# sphinx_conf is semi-autogenerated.
51
57
 
52
58
 
53
59
class TestSourceHelper(TestCase):
105
111
 
106
112
        # Avoid the case when bzrlib is packaged in a zip file
107
113
        if not os.path.isdir(source_dir):
108
 
            raise TestSkipped('Cannot find bzrlib source directory. Expected %s'
109
 
                              % source_dir)
 
114
            raise TestSkipped(
 
115
                'Cannot find bzrlib source directory. Expected %s'
 
116
                % source_dir)
110
117
        return source_dir
111
118
 
112
119
    def get_source_files(self, extensions=None):
146
153
            yield fname, text
147
154
 
148
155
    def is_our_code(self, fname):
149
 
        """Return true if it's a "real" part of bzrlib rather than external code"""
 
156
        """True if it's a "real" part of bzrlib rather than external code"""
150
157
        if '/util/' in fname or '/plugins/' in fname:
151
158
            return False
152
159
        else:
186
193
 
187
194
        copyright_re = re.compile('#\\s*copyright.*(?=\n)', re.I)
188
195
        copyright_canonical_re = re.compile(
189
 
            r'# Copyright \(C\) ' # Opening "# Copyright (C)"
190
 
            r'(\d+)(, \d+)*' # Followed by a series of dates
191
 
            r'.*Canonical Ltd' # And containing 'Canonical Ltd'
192
 
            )
 
196
            r'# Copyright \(C\) '  # Opening "# Copyright (C)"
 
197
            r'(\d+)(, \d+)*'       # followed by a series of dates
 
198
            r'.*Canonical Ltd')    # and containing 'Canonical Ltd'.
193
199
 
194
200
        for fname, text in self.get_source_file_contents(
195
201
                extensions=('.py', '.pyx')):
222
228
                        ]
223
229
            for fname, comment in incorrect:
224
230
                help_text.append(fname)
225
 
                help_text.append((' '*4) + comment)
 
231
                help_text.append((' ' * 4) + comment)
226
232
 
227
233
            self.fail('\n'.join(help_text))
228
234
 
261
267
                         " LICENSE_EXCEPTIONS in"
262
268
                         " bzrlib/tests/test_source.py",
263
269
                         "Or add the following text to the beginning:",
264
 
                         gpl_txt
265
 
                        ]
 
270
                         gpl_txt]
266
271
            for fname in incorrect:
267
 
                help_text.append((' '*4) + fname)
 
272
                help_text.append((' ' * 4) + fname)
268
273
 
269
274
            self.fail('\n'.join(help_text))
270
275
 
275
280
            dict_[fname].append(line_no)
276
281
 
277
282
    def _format_message(self, dict_, message):
278
 
        files = ["%s: %s" % (f, ', '.join([str(i+1) for i in lines]))
 
283
        files = ["%s: %s" % (f, ', '.join([str(i + 1) for i in lines]))
279
284
                for f, lines in dict_.items()]
280
285
        files.sort()
281
286
        return message + '\n\n    %s' % ('\n    '.join(files))
283
288
    def test_coding_style(self):
284
289
        """Check if bazaar code conforms to some coding style conventions.
285
290
 
286
 
        Currently we assert that the following is not present:
287
 
         * any tab characters
288
 
         * non-unix newlines
289
 
         * no newline at end of files
 
291
        Generally we expect PEP8, but we do not generally strictly enforce
 
292
        this, and there are existing files that do not comply.  The 'pep8'
 
293
        tool, available separately, will check for more cases.
290
294
 
291
 
        Print how many files have
292
 
         * trailing white space
293
 
         * lines longer than 79 chars
 
295
        This test only enforces conditions that are globally true at the
 
296
        moment, and that should cause a patch to be rejected: spaces rather
 
297
        than tabs, unix newlines, and a newline at the end of the file.
294
298
        """
295
299
        tabs = {}
296
 
        trailing_ws = {}
297
300
        illegal_newlines = {}
298
 
        long_lines = {}
299
301
        no_newline_at_eof = []
300
302
        for fname, text in self.get_source_file_contents(
301
303
                extensions=('.py', '.pyx')):
307
309
                if '\t' in line:
308
310
                    self._push_file(tabs, fname, line_no)
309
311
                if not line.endswith('\n') or line.endswith('\r\n'):
310
 
                    if line_no != last_line_no: # not no_newline_at_eof
 
312
                    if line_no != last_line_no:  # not no_newline_at_eof
311
313
                        self._push_file(illegal_newlines, fname, line_no)
312
 
                if line.endswith(' \n'):
313
 
                    self._push_file(trailing_ws, fname, line_no)
314
 
                if len(line) > 80:
315
 
                    self._push_file(long_lines, fname, line_no)
316
314
            if not lines[-1].endswith('\n'):
317
315
                no_newline_at_eof.append(fname)
318
316
        problems = []
320
318
            problems.append(self._format_message(tabs,
321
319
                'Tab characters were found in the following source files.'
322
320
                '\nThey should either be replaced by "\\t" or by spaces:'))
323
 
        if trailing_ws:
324
 
            print ("There are %i lines with trailing white space in %i files."
325
 
                % (sum([len(lines) for f, lines in trailing_ws.items()]),
326
 
                    len(trailing_ws)))
327
321
        if illegal_newlines:
328
322
            problems.append(self._format_message(illegal_newlines,
329
323
                'Non-unix newlines were found in the following source files:'))
330
 
        if long_lines:
331
 
            print ("There are %i lines longer than 79 characters in %i files."
332
 
                % (sum([len(lines) for f, lines in long_lines.items()]),
333
 
                    len(long_lines)))
334
324
        if no_newline_at_eof:
335
325
            no_newline_at_eof.sort()
336
326
            problems.append("The following source files doesn't have a "
357
347
                    return True
358
348
            return False
359
349
        badfiles = []
 
350
        assert_re = re.compile(r'\bassert\b')
360
351
        for fname, text in self.get_source_file_contents():
361
352
            if not self.is_our_code(fname):
362
353
                continue
363
 
            ast = parser.ast2tuple(parser.suite(''.join(text)))
 
354
            if not assert_re.search(text):
 
355
                continue
 
356
            ast = parser.ast2tuple(parser.suite(text))
364
357
            if search(ast):
365
358
                badfiles.append(fname)
366
359
        if badfiles:
367
360
            self.fail(
368
361
                "these files contain an assert statement and should not:\n%s"
369
362
                % '\n'.join(badfiles))
 
363
 
 
364
    def test_extension_exceptions(self):
 
365
        """Extension functions should propagate exceptions.
 
366
 
 
367
        Either they should return an object, have an 'except' clause, or
 
368
        have a "# cannot_raise" to indicate that we've audited them and
 
369
        defined them as not raising exceptions.
 
370
        """
 
371
        both_exc_and_no_exc = []
 
372
        missing_except = []
 
373
        class_re = re.compile(r'^(cdef\s+)?(public\s+)?'
 
374
                              r'(api\s+)?class (\w+).*:', re.MULTILINE)
 
375
        extern_class_re = re.compile(r'## extern cdef class (\w+)',
 
376
                                     re.MULTILINE)
 
377
        except_re = re.compile(
 
378
            r'cdef\s+'        # start with cdef
 
379
            r'([\w *]*?)\s*'  # this is the return signature
 
380
            r'(\w+)\s*\('     # the function name
 
381
            r'[^)]*\)\s*'     # parameters
 
382
            r'(.*)\s*:'       # the except clause
 
383
            r'\s*(#\s*cannot[- _]raise)?')  # cannot raise comment
 
384
        for fname, text in self.get_source_file_contents(
 
385
                extensions=('.pyx',)):
 
386
            known_classes = set([m[-1] for m in class_re.findall(text)])
 
387
            known_classes.update(extern_class_re.findall(text))
 
388
            cdefs = except_re.findall(text)
 
389
            for sig, func, exc_clause, no_exc_comment in cdefs:
 
390
                if sig.startswith('api '):
 
391
                    sig = sig[4:]
 
392
                if not sig or sig in known_classes:
 
393
                    sig = 'object'
 
394
                if 'nogil' in exc_clause:
 
395
                    exc_clause = exc_clause.replace('nogil', '').strip()
 
396
                if exc_clause and no_exc_comment:
 
397
                    both_exc_and_no_exc.append((fname, func))
 
398
                if sig != 'object' and not (exc_clause or no_exc_comment):
 
399
                    missing_except.append((fname, func))
 
400
        error_msg = []
 
401
        if both_exc_and_no_exc:
 
402
            error_msg.append(
 
403
                'The following functions had "cannot raise" comments'
 
404
                ' but did have an except clause set:')
 
405
            for fname, func in both_exc_and_no_exc:
 
406
                error_msg.append('%s:%s' % (fname, func))
 
407
            error_msg.extend(('', ''))
 
408
        if missing_except:
 
409
            error_msg.append(
 
410
                'The following functions have fixed return types,'
 
411
                ' but no except clause.')
 
412
            error_msg.append(
 
413
                'Either add an except or append "# cannot_raise".')
 
414
            for fname, func in missing_except:
 
415
                error_msg.append('%s:%s' % (fname, func))
 
416
            error_msg.extend(('', ''))
 
417
        if error_msg:
 
418
            self.fail('\n'.join(error_msg))
 
419
 
 
420
    def test_feature_absolute_import(self):
 
421
        """Using absolute imports means avoiding unnecesary stat and
 
422
        open calls.
 
423
 
 
424
        Make sure that all non-test files have absolute imports enabled.
 
425
        """
 
426
        missing_absolute_import = []
 
427
        for fname, text in self.get_source_file_contents(
 
428
                extensions=('.py', )):
 
429
            if "/tests/" in fname or "test_" in fname:
 
430
                # We don't really care about tests
 
431
                continue
 
432
            if not "from __future__ import absolute_import" in text:
 
433
                missing_absolute_import.append(fname)
 
434
 
 
435
        if missing_absolute_import:
 
436
            self.fail(
 
437
                'The following files do not have absolute_import enabled:\n'
 
438
                '\n' + '\n'.join(missing_absolute_import))