/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_source.py

  • Committer: Martin
  • Date: 2018-11-16 16:38:22 UTC
  • mto: This revision was merged to the branch mainline in revision 7172.
  • Revision ID: gzlist@googlemail.com-20181116163822-yg1h1cdng6w7w9kn
Make --profile-imports work on Python 3

Also tweak heading to line up correctly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_source.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""These tests are tests about the source code of bzrlib itself.
 
17
"""These tests are tests about the source code of breezy itself.
18
18
 
19
19
They are useful for testing code quality, checking coverage metric etc.
20
20
"""
21
21
 
22
 
# import system imports here
23
22
import os
24
23
import parser
25
24
import re
27
26
import sys
28
27
import token
29
28
 
30
 
#import bzrlib specific imports here
31
 
from bzrlib import (
 
29
from breezy import (
32
30
    osutils,
33
31
    )
34
 
import bzrlib.branch
35
 
from bzrlib.tests import (
 
32
import breezy.branch
 
33
from breezy.tests import (
36
34
    TestCase,
37
35
    TestSkipped,
38
36
    )
40
38
 
41
39
# Files which are listed here will be skipped when testing for Copyright (or
42
40
# GPL) statements.
43
 
COPYRIGHT_EXCEPTIONS = ['bzrlib/lsprof.py', 'bzrlib/_bencode_py.py',
44
 
    'bzrlib/doc_generate/sphinx_conf.py']
 
41
COPYRIGHT_EXCEPTIONS = [
 
42
    'breezy/_bencode_py.py',
 
43
    'breezy/doc_generate/conf.py',
 
44
    'breezy/lsprof.py',
 
45
    ]
45
46
 
46
 
LICENSE_EXCEPTIONS = ['bzrlib/lsprof.py', 'bzrlib/_bencode_py.py',
47
 
    'bzrlib/doc_generate/sphinx_conf.py']
48
 
# Technically, 'bzrlib/lsprof.py' should be 'bzrlib/util/lsprof.py',
49
 
# (we do not check bzrlib/util/, since that is code bundled from elsewhere)
 
47
LICENSE_EXCEPTIONS = [
 
48
    'breezy/_bencode_py.py',
 
49
    'breezy/doc_generate/conf.py',
 
50
    'breezy/lsprof.py',
 
51
    ]
 
52
# Technically, 'breezy/lsprof.py' should be 'breezy/util/lsprof.py',
 
53
# (we do not check breezy/util/, since that is code bundled from elsewhere)
50
54
# but for compatibility with previous releases, we don't want to move it.
51
55
#
52
56
# sphinx_conf is semi-autogenerated.
70
74
    def find_occurences(self, rule, filename):
71
75
        """Find the number of occurences of rule in a file."""
72
76
        occurences = 0
73
 
        source = file(filename, 'r')
 
77
        source = open(filename, 'r')
74
78
        for line in source:
75
79
            if line.find(rule) > -1:
76
80
                occurences += 1
79
83
    def test_branch_working_tree(self):
80
84
        """Test that the number of uses of working_tree in branch is stable."""
81
85
        occurences = self.find_occurences('self.working_tree()',
82
 
                                          self.source_file_name(bzrlib.branch))
 
86
                                          self.source_file_name(breezy.branch))
83
87
        # do not even think of increasing this number. If you think you need to
84
88
        # increase it, then you almost certainly are doing something wrong as
85
89
        # the relationship from working_tree to branch is one way.
90
94
    def test_branch_WorkingTree(self):
91
95
        """Test that the number of uses of working_tree in branch is stable."""
92
96
        occurences = self.find_occurences('WorkingTree',
93
 
                                          self.source_file_name(bzrlib.branch))
 
97
                                          self.source_file_name(breezy.branch))
94
98
        # Do not even think of increasing this number. If you think you need to
95
99
        # increase it, then you almost certainly are doing something wrong as
96
100
        # the relationship from working_tree to branch is one way.
100
104
 
101
105
class TestSource(TestSourceHelper):
102
106
 
103
 
    def get_bzrlib_dir(self):
104
 
        """Get the path to the root of bzrlib"""
105
 
        source = self.source_file_name(bzrlib)
 
107
    def get_breezy_dir(self):
 
108
        """Get the path to the root of breezy"""
 
109
        source = self.source_file_name(breezy)
106
110
        source_dir = os.path.dirname(source)
107
111
 
108
 
        # Avoid the case when bzrlib is packaged in a zip file
 
112
        # Avoid the case when breezy is packaged in a zip file
109
113
        if not os.path.isdir(source_dir):
110
 
            raise TestSkipped('Cannot find bzrlib source directory. Expected %s'
111
 
                              % source_dir)
 
114
            raise TestSkipped(
 
115
                'Cannot find breezy source directory. Expected %s'
 
116
                % source_dir)
112
117
        return source_dir
113
118
 
114
119
    def get_source_files(self, extensions=None):
115
 
        """Yield all source files for bzr and bzrlib
 
120
        """Yield all source files for bzr and breezy
116
121
 
117
122
        :param our_files_only: If true, exclude files from included libraries
118
123
            or plugins.
119
124
        """
120
 
        bzrlib_dir = self.get_bzrlib_dir()
 
125
        breezy_dir = self.get_breezy_dir()
121
126
        if extensions is None:
122
127
            extensions = ('.py',)
123
128
 
124
129
        # This is the front-end 'bzr' script
125
 
        bzr_path = self.get_bzr_path()
 
130
        bzr_path = self.get_brz_path()
126
131
        yield bzr_path
127
132
 
128
 
        for root, dirs, files in os.walk(bzrlib_dir):
 
133
        for root, dirs, files in os.walk(breezy_dir):
129
134
            for d in dirs:
130
135
                if d.endswith('.tmp'):
131
136
                    dirs.remove(d)
140
145
 
141
146
    def get_source_file_contents(self, extensions=None):
142
147
        for fname in self.get_source_files(extensions=extensions):
143
 
            f = open(fname, 'rb')
144
 
            try:
145
 
                text = f.read()
146
 
            finally:
147
 
                f.close()
148
 
            yield fname, text
 
148
            with open(fname, 'r') as f:
 
149
                yield fname, f.read()
149
150
 
150
151
    def is_our_code(self, fname):
151
 
        """Return true if it's a "real" part of bzrlib rather than external code"""
 
152
        """True if it's a "real" part of breezy rather than external code"""
152
153
        if '/util/' in fname or '/plugins/' in fname:
153
154
            return False
154
155
        else:
157
158
    def is_copyright_exception(self, fname):
158
159
        """Certain files are allowed to be different"""
159
160
        if not self.is_our_code(fname):
160
 
            # We don't ask that external utilities or plugins be
161
 
            # (C) Canonical Ltd
162
161
            return True
163
162
        for exc in COPYRIGHT_EXCEPTIONS:
164
163
            if fname.endswith(exc):
187
186
        incorrect = []
188
187
 
189
188
        copyright_re = re.compile('#\\s*copyright.*(?=\n)', re.I)
190
 
        copyright_canonical_re = re.compile(
191
 
            r'# Copyright \(C\) ' # Opening "# Copyright (C)"
192
 
            r'(\d+)(, \d+)*' # Followed by a series of dates
193
 
            r'.*Canonical Ltd' # And containing 'Canonical Ltd'
194
 
            )
 
189
        copyright_statement_re = re.compile(
 
190
            r'# Copyright \(C\) '  # Opening "# Copyright (C)"
 
191
            r'(\d+?)((, |-)\d+)*'  # followed by a series of dates
 
192
            r' [^ ]*')             # and then whoever.
195
193
 
196
194
        for fname, text in self.get_source_file_contents(
197
195
                extensions=('.py', '.pyx')):
198
196
            if self.is_copyright_exception(fname):
199
197
                continue
200
 
            match = copyright_canonical_re.search(text)
 
198
            match = copyright_statement_re.search(text)
201
199
            if not match:
202
200
                match = copyright_re.search(text)
203
201
                if match:
216
214
                         "",
217
215
                         "Please either add them to the list of"
218
216
                         " COPYRIGHT_EXCEPTIONS in"
219
 
                         " bzrlib/tests/test_source.py",
 
217
                         " breezy/tests/test_source.py",
220
218
                         # this is broken to prevent a false match
221
219
                         "or add '# Copyright (C)"
222
 
                         " 2007 Canonical Ltd' to these files:",
 
220
                         " 2007 Bazaar hackers' to these files:",
223
221
                         "",
224
222
                        ]
225
223
            for fname, comment in incorrect:
226
224
                help_text.append(fname)
227
 
                help_text.append((' '*4) + comment)
 
225
                help_text.append((' ' * 4) + comment)
228
226
 
229
227
            self.fail('\n'.join(help_text))
230
228
 
261
259
                         "",
262
260
                         "Please either add them to the list of"
263
261
                         " LICENSE_EXCEPTIONS in"
264
 
                         " bzrlib/tests/test_source.py",
 
262
                         " breezy/tests/test_source.py",
265
263
                         "Or add the following text to the beginning:",
266
 
                         gpl_txt
267
 
                        ]
 
264
                         gpl_txt]
268
265
            for fname in incorrect:
269
 
                help_text.append((' '*4) + fname)
 
266
                help_text.append((' ' * 4) + fname)
270
267
 
271
268
            self.fail('\n'.join(help_text))
272
269
 
277
274
            dict_[fname].append(line_no)
278
275
 
279
276
    def _format_message(self, dict_, message):
280
 
        files = ["%s: %s" % (f, ', '.join([str(i+1) for i in lines]))
281
 
                for f, lines in dict_.items()]
282
 
        files.sort()
 
277
        files = sorted(["%s: %s" % (f, ', '.join([str(i + 1) for i in lines]))
 
278
                for f, lines in dict_.items()])
283
279
        return message + '\n\n    %s' % ('\n    '.join(files))
284
280
 
285
281
    def test_coding_style(self):
286
282
        """Check if bazaar code conforms to some coding style conventions.
287
283
 
288
 
        Currently we assert that the following is not present:
289
 
         * any tab characters
290
 
         * non-unix newlines
291
 
         * no newline at end of files
 
284
        Generally we expect PEP8, but we do not generally strictly enforce
 
285
        this, and there are existing files that do not comply.  The 'pep8'
 
286
        tool, available separately, will check for more cases.
292
287
 
293
 
        Print how many files have
294
 
         * trailing white space
295
 
         * lines longer than 79 chars
 
288
        This test only enforces conditions that are globally true at the
 
289
        moment, and that should cause a patch to be rejected: spaces rather
 
290
        than tabs, unix newlines, and a newline at the end of the file.
296
291
        """
297
292
        tabs = {}
298
 
        trailing_ws = {}
299
293
        illegal_newlines = {}
300
 
        long_lines = {}
301
294
        no_newline_at_eof = []
302
295
        for fname, text in self.get_source_file_contents(
303
296
                extensions=('.py', '.pyx')):
309
302
                if '\t' in line:
310
303
                    self._push_file(tabs, fname, line_no)
311
304
                if not line.endswith('\n') or line.endswith('\r\n'):
312
 
                    if line_no != last_line_no: # not no_newline_at_eof
 
305
                    if line_no != last_line_no:  # not no_newline_at_eof
313
306
                        self._push_file(illegal_newlines, fname, line_no)
314
 
                if line.endswith(' \n'):
315
 
                    self._push_file(trailing_ws, fname, line_no)
316
 
                if len(line) > 80:
317
 
                    self._push_file(long_lines, fname, line_no)
318
307
            if not lines[-1].endswith('\n'):
319
308
                no_newline_at_eof.append(fname)
320
309
        problems = []
322
311
            problems.append(self._format_message(tabs,
323
312
                'Tab characters were found in the following source files.'
324
313
                '\nThey should either be replaced by "\\t" or by spaces:'))
325
 
        if trailing_ws:
326
 
            print ("There are %i lines with trailing white space in %i files."
327
 
                % (sum([len(lines) for f, lines in trailing_ws.items()]),
328
 
                    len(trailing_ws)))
329
314
        if illegal_newlines:
330
315
            problems.append(self._format_message(illegal_newlines,
331
316
                'Non-unix newlines were found in the following source files:'))
332
 
        if long_lines:
333
 
            print ("There are %i lines longer than 79 characters in %i files."
334
 
                % (sum([len(lines) for f, lines in long_lines.items()]),
335
 
                    len(long_lines)))
336
317
        if no_newline_at_eof:
337
318
            no_newline_at_eof.sort()
338
319
            problems.append("The following source files doesn't have a "
365
346
                continue
366
347
            if not assert_re.search(text):
367
348
                continue
368
 
            ast = parser.ast2tuple(parser.suite(text))
369
 
            if search(ast):
 
349
            st = parser.suite(text)
 
350
            code = parser.st2tuple(st)
 
351
            if search(code):
370
352
                badfiles.append(fname)
371
353
        if badfiles:
372
354
            self.fail(
376
358
    def test_extension_exceptions(self):
377
359
        """Extension functions should propagate exceptions.
378
360
 
379
 
        Either they should return an object, have an 'except' clause, or have a
380
 
        "# cannot_raise" to indicate that we've audited them and defined them as not
381
 
        raising exceptions.
 
361
        Either they should return an object, have an 'except' clause, or
 
362
        have a "# cannot_raise" to indicate that we've audited them and
 
363
        defined them as not raising exceptions.
382
364
        """
383
365
        both_exc_and_no_exc = []
384
366
        missing_except = []
385
 
        class_re = re.compile(r'^(cdef\s+)?(public\s+)?(api\s+)?class (\w+).*:',
386
 
                              re.MULTILINE)
387
 
        except_re = re.compile(r'cdef\s+' # start with cdef
388
 
                               r'([\w *]*?)\s*' # this is the return signature
389
 
                               r'(\w+)\s*\(' # the function name
390
 
                               r'[^)]*\)\s*' # parameters
391
 
                               r'(.*)\s*:' # the except clause
392
 
                               r'\s*(#\s*cannot[- _]raise)?' # cannot raise comment
393
 
                              )
 
367
        common_classes = ('StaticTuple',)
 
368
        class_re = re.compile(r'^(cdef\s+)?(public\s+)?'
 
369
                              r'(api\s+)?class (\w+).*:', re.MULTILINE)
 
370
        except_re = re.compile(
 
371
            r'cdef\s+'        # start with cdef
 
372
            r'([\w *]*?)\s*'  # this is the return signature
 
373
            r'(\w+)\s*\('     # the function name
 
374
            r'[^)]*\)\s*'     # parameters
 
375
            r'(.*)\s*:'       # the except clause
 
376
            r'\s*(#\s*cannot[- _]raise)?')  # cannot raise comment
394
377
        for fname, text in self.get_source_file_contents(
395
378
                extensions=('.pyx',)):
396
 
            known_classes = set([m[-1] for m in class_re.findall(text)])
 
379
            known_classes = {m[-1] for m in class_re.findall(text)}
 
380
            known_classes.update(common_classes)
397
381
            cdefs = except_re.findall(text)
398
382
            for sig, func, exc_clause, no_exc_comment in cdefs:
399
383
                if sig.startswith('api '):
408
392
                    missing_except.append((fname, func))
409
393
        error_msg = []
410
394
        if both_exc_and_no_exc:
411
 
            error_msg.append('The following functions had "cannot raise" comments'
412
 
                             ' but did have an except clause set:')
 
395
            error_msg.append(
 
396
                'The following functions had "cannot raise" comments'
 
397
                ' but did have an except clause set:')
413
398
            for fname, func in both_exc_and_no_exc:
414
399
                error_msg.append('%s:%s' % (fname, func))
415
400
            error_msg.extend(('', ''))
416
401
        if missing_except:
417
 
            error_msg.append('The following functions have fixed return types,'
418
 
                             ' but no except clause.')
419
 
            error_msg.append('Either add an except or append "# cannot_raise".')
 
402
            error_msg.append(
 
403
                'The following functions have fixed return types,'
 
404
                ' but no except clause.')
 
405
            error_msg.append(
 
406
                'Either add an except or append "# cannot_raise".')
420
407
            for fname, func in missing_except:
421
408
                error_msg.append('%s:%s' % (fname, func))
422
409
            error_msg.extend(('', ''))
423
410
        if error_msg:
424
411
            self.fail('\n'.join(error_msg))
 
412
 
 
413
    def test_feature_absolute_import(self):
 
414
        """Using absolute imports means avoiding unnecesary stat and
 
415
        open calls.
 
416
 
 
417
        Make sure that all non-test files have absolute imports enabled.
 
418
        """
 
419
        missing_absolute_import = []
 
420
        for fname, text in self.get_source_file_contents(
 
421
                extensions=('.py', '.pyx')):
 
422
            if "/tests/" in fname or "test_" in fname:
 
423
                # We don't really care about tests
 
424
                continue
 
425
            if not "from __future__ import absolute_import" in text:
 
426
                missing_absolute_import.append(fname)
 
427
 
 
428
        if missing_absolute_import:
 
429
            self.fail(
 
430
                'The following files do not have absolute_import enabled:\n'
 
431
                '\n' + '\n'.join(missing_absolute_import))