← 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: Patch Queue Manager
  • Date: 2015-10-05 13:45:00 UTC
  • mfrom: (6603.3.1 bts794146)
  • Revision ID: pqm@pqm.ubuntu.com-20151005134500-v244rho557tv0ukd
(vila) Resolve Bug #1480015: Test failure: hexify removed from paramiko
 (Andrew Starr-Bochicchio) (Andrew Starr-Bochicchio)

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
    )
36
32
import bzrlib.branch
37
33
from bzrlib.tests import (
38
 
    KnownFailure,
39
34
    TestCase,
40
35
    TestSkipped,
41
36
    )
43
38
 
44
39
# Files which are listed here will be skipped when testing for Copyright (or
45
40
# GPL) statements.
46
 
COPYRIGHT_EXCEPTIONS = ['bzrlib/lsprof.py']
 
41
COPYRIGHT_EXCEPTIONS = [
 
42
    'bzrlib/_bencode_py.py',
 
43
    'bzrlib/doc_generate/conf.py',
 
44
    'bzrlib/lsprof.py',
 
45
    ]
47
46
 
48
 
LICENSE_EXCEPTIONS = ['bzrlib/lsprof.py']
 
47
LICENSE_EXCEPTIONS = [
 
48
    'bzrlib/_bencode_py.py',
 
49
    'bzrlib/doc_generate/conf.py',
 
50
    'bzrlib/lsprof.py',
 
51
    ]
49
52
# Technically, 'bzrlib/lsprof.py' should be 'bzrlib/util/lsprof.py',
50
53
# (we do not check bzrlib/util/, since that is code bundled from elsewhere)
51
54
# but for compatibility with previous releases, we don't want to move it.
 
55
#
 
56
# sphinx_conf is semi-autogenerated.
52
57
 
53
58
 
54
59
class TestSourceHelper(TestCase):
106
111
 
107
112
        # Avoid the case when bzrlib is packaged in a zip file
108
113
        if not os.path.isdir(source_dir):
109
 
            raise TestSkipped('Cannot find bzrlib source directory. Expected %s'
110
 
                              % source_dir)
 
114
            raise TestSkipped(
 
115
                'Cannot find bzrlib source directory. Expected %s'
 
116
                % source_dir)
111
117
        return source_dir
112
118
 
113
119
    def get_source_files(self, extensions=None):
147
153
            yield fname, text
148
154
 
149
155
    def is_our_code(self, fname):
150
 
        """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"""
151
157
        if '/util/' in fname or '/plugins/' in fname:
152
158
            return False
153
159
        else:
187
193
 
188
194
        copyright_re = re.compile('#\\s*copyright.*(?=\n)', re.I)
189
195
        copyright_canonical_re = re.compile(
190
 
            r'# Copyright \(C\) ' # Opening "# Copyright (C)"
191
 
            r'(\d+)(, \d+)*' # Followed by a series of dates
192
 
            r'.*Canonical Ltd' # And containing 'Canonical Ltd'
193
 
            )
 
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'.
194
199
 
195
200
        for fname, text in self.get_source_file_contents(
196
201
                extensions=('.py', '.pyx')):
223
228
                        ]
224
229
            for fname, comment in incorrect:
225
230
                help_text.append(fname)
226
 
                help_text.append((' '*4) + comment)
 
231
                help_text.append((' ' * 4) + comment)
227
232
 
228
233
            self.fail('\n'.join(help_text))
229
234
 
262
267
                         " LICENSE_EXCEPTIONS in"
263
268
                         " bzrlib/tests/test_source.py",
264
269
                         "Or add the following text to the beginning:",
265
 
                         gpl_txt
266
 
                        ]
 
270
                         gpl_txt]
267
271
            for fname in incorrect:
268
 
                help_text.append((' '*4) + fname)
 
272
                help_text.append((' ' * 4) + fname)
269
273
 
270
274
            self.fail('\n'.join(help_text))
271
275
 
276
280
            dict_[fname].append(line_no)
277
281
 
278
282
    def _format_message(self, dict_, message):
279
 
        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]))
280
284
                for f, lines in dict_.items()]
281
285
        files.sort()
282
286
        return message + '\n\n    %s' % ('\n    '.join(files))
284
288
    def test_coding_style(self):
285
289
        """Check if bazaar code conforms to some coding style conventions.
286
290
 
287
 
        Currently we check for:
288
 
         * any tab characters
289
 
         * trailing white space
290
 
         * non-unix newlines
291
 
         * no newline at end of files
292
 
         * lines longer than 79 chars
293
 
           (only print how many files and lines are in violation)
 
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.
 
294
 
 
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
 
            problems.append(self._format_message(trailing_ws,
325
 
                'Trailing white space was found in the following source files:'
326
 
                ))
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 "
338
328
               '\n\n    %s'
339
329
               % ('\n    '.join(no_newline_at_eof)))
340
330
        if problems:
341
 
            raise KnownFailure("test_coding_style has failed")
342
331
            self.fail('\n\n'.join(problems))
343
332
 
344
333
    def test_no_asserts(self):
358
347
                    return True
359
348
            return False
360
349
        badfiles = []
 
350
        assert_re = re.compile(r'\bassert\b')
361
351
        for fname, text in self.get_source_file_contents():
362
352
            if not self.is_our_code(fname):
363
353
                continue
364
 
            ast = parser.ast2tuple(parser.suite(''.join(text)))
 
354
            if not assert_re.search(text):
 
355
                continue
 
356
            ast = parser.ast2tuple(parser.suite(text))
365
357
            if search(ast):
366
358
                badfiles.append(fname)
367
359
        if badfiles:
368
360
            self.fail(
369
361
                "these files contain an assert statement and should not:\n%s"
370
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))