/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: Jelmer Vernooij
  • Date: 2019-01-01 21:38:07 UTC
  • mfrom: (7228 work)
  • mto: This revision was merged to the branch mainline in revision 7233.
  • Revision ID: jelmer@jelmer.uk-20190101213807-ay6uqghz0nnrgjvx
Merge trunk.

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 (
 
34
    features,
36
35
    TestCase,
37
36
    TestSkipped,
38
37
    )
40
39
 
41
40
# Files which are listed here will be skipped when testing for Copyright (or
42
41
# GPL) statements.
43
 
COPYRIGHT_EXCEPTIONS = ['bzrlib/lsprof.py', 'bzrlib/_bencode_py.py',
44
 
    'bzrlib/doc_generate/sphinx_conf.py']
 
42
COPYRIGHT_EXCEPTIONS = [
 
43
    'breezy/_bencode_py.py',
 
44
    'breezy/doc_generate/conf.py',
 
45
    'breezy/lsprof.py',
 
46
    ]
45
47
 
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)
 
48
LICENSE_EXCEPTIONS = [
 
49
    'breezy/_bencode_py.py',
 
50
    'breezy/doc_generate/conf.py',
 
51
    'breezy/lsprof.py',
 
52
    ]
 
53
# Technically, 'breezy/lsprof.py' should be 'breezy/util/lsprof.py',
 
54
# (we do not check breezy/util/, since that is code bundled from elsewhere)
50
55
# but for compatibility with previous releases, we don't want to move it.
51
56
#
52
57
# sphinx_conf is semi-autogenerated.
70
75
    def find_occurences(self, rule, filename):
71
76
        """Find the number of occurences of rule in a file."""
72
77
        occurences = 0
73
 
        source = file(filename, 'r')
 
78
        source = open(filename, 'r')
74
79
        for line in source:
75
80
            if line.find(rule) > -1:
76
81
                occurences += 1
79
84
    def test_branch_working_tree(self):
80
85
        """Test that the number of uses of working_tree in branch is stable."""
81
86
        occurences = self.find_occurences('self.working_tree()',
82
 
                                          self.source_file_name(bzrlib.branch))
 
87
                                          self.source_file_name(breezy.branch))
83
88
        # do not even think of increasing this number. If you think you need to
84
89
        # increase it, then you almost certainly are doing something wrong as
85
90
        # the relationship from working_tree to branch is one way.
86
91
        # Note that this is an exact equality so that when the number drops,
87
 
        #it is not given a buffer but rather has this test updated immediately.
 
92
        # it is not given a buffer but rather has this test updated immediately.
88
93
        self.assertEqual(0, occurences)
89
94
 
90
95
    def test_branch_WorkingTree(self):
91
96
        """Test that the number of uses of working_tree in branch is stable."""
92
97
        occurences = self.find_occurences('WorkingTree',
93
 
                                          self.source_file_name(bzrlib.branch))
 
98
                                          self.source_file_name(breezy.branch))
94
99
        # Do not even think of increasing this number. If you think you need to
95
100
        # increase it, then you almost certainly are doing something wrong as
96
101
        # the relationship from working_tree to branch is one way.
100
105
 
101
106
class TestSource(TestSourceHelper):
102
107
 
103
 
    def get_bzrlib_dir(self):
104
 
        """Get the path to the root of bzrlib"""
105
 
        source = self.source_file_name(bzrlib)
 
108
    def get_breezy_dir(self):
 
109
        """Get the path to the root of breezy"""
 
110
        source = self.source_file_name(breezy)
106
111
        source_dir = os.path.dirname(source)
107
112
 
108
 
        # Avoid the case when bzrlib is packaged in a zip file
 
113
        # Avoid the case when breezy is packaged in a zip file
109
114
        if not os.path.isdir(source_dir):
110
 
            raise TestSkipped('Cannot find bzrlib source directory. Expected %s'
111
 
                              % source_dir)
 
115
            raise TestSkipped(
 
116
                'Cannot find breezy source directory. Expected %s'
 
117
                % source_dir)
112
118
        return source_dir
113
119
 
114
120
    def get_source_files(self, extensions=None):
115
 
        """Yield all source files for bzr and bzrlib
 
121
        """Yield all source files for bzr and breezy
116
122
 
117
123
        :param our_files_only: If true, exclude files from included libraries
118
124
            or plugins.
119
125
        """
120
 
        bzrlib_dir = self.get_bzrlib_dir()
 
126
        breezy_dir = self.get_breezy_dir()
121
127
        if extensions is None:
122
128
            extensions = ('.py',)
123
129
 
124
130
        # This is the front-end 'bzr' script
125
 
        bzr_path = self.get_bzr_path()
 
131
        bzr_path = self.get_brz_path()
126
132
        yield bzr_path
127
133
 
128
 
        for root, dirs, files in os.walk(bzrlib_dir):
 
134
        for root, dirs, files in os.walk(breezy_dir):
129
135
            for d in dirs:
130
136
                if d.endswith('.tmp'):
131
137
                    dirs.remove(d)
140
146
 
141
147
    def get_source_file_contents(self, extensions=None):
142
148
        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
 
149
            with open(fname, 'r') as f:
 
150
                yield fname, f.read()
149
151
 
150
152
    def is_our_code(self, fname):
151
 
        """Return true if it's a "real" part of bzrlib rather than external code"""
 
153
        """True if it's a "real" part of breezy rather than external code"""
152
154
        if '/util/' in fname or '/plugins/' in fname:
153
155
            return False
154
156
        else:
157
159
    def is_copyright_exception(self, fname):
158
160
        """Certain files are allowed to be different"""
159
161
        if not self.is_our_code(fname):
160
 
            # We don't ask that external utilities or plugins be
161
 
            # (C) Canonical Ltd
162
162
            return True
163
163
        for exc in COPYRIGHT_EXCEPTIONS:
164
164
            if fname.endswith(exc):
187
187
        incorrect = []
188
188
 
189
189
        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
 
            )
 
190
        copyright_statement_re = re.compile(
 
191
            r'# Copyright \(C\) '  # Opening "# Copyright (C)"
 
192
            r'(\d+?)((, |-)\d+)*'  # followed by a series of dates
 
193
            r' [^ ]*')             # and then whoever.
195
194
 
196
195
        for fname, text in self.get_source_file_contents(
197
196
                extensions=('.py', '.pyx')):
198
197
            if self.is_copyright_exception(fname):
199
198
                continue
200
 
            match = copyright_canonical_re.search(text)
 
199
            match = copyright_statement_re.search(text)
201
200
            if not match:
202
201
                match = copyright_re.search(text)
203
202
                if match:
207
206
            else:
208
207
                if 'by Canonical' in match.group():
209
208
                    incorrect.append((fname,
210
 
                        'should not have: "by Canonical": %s'
211
 
                        % (match.group(),)))
 
209
                                      'should not have: "by Canonical": %s'
 
210
                                      % (match.group(),)))
212
211
 
213
212
        if incorrect:
214
213
            help_text = ["Some files have missing or incorrect copyright"
216
215
                         "",
217
216
                         "Please either add them to the list of"
218
217
                         " COPYRIGHT_EXCEPTIONS in"
219
 
                         " bzrlib/tests/test_source.py",
 
218
                         " breezy/tests/test_source.py",
220
219
                         # this is broken to prevent a false match
221
220
                         "or add '# Copyright (C)"
222
 
                         " 2007 Canonical Ltd' to these files:",
 
221
                         " 2007 Bazaar hackers' to these files:",
223
222
                         "",
224
 
                        ]
 
223
                         ]
225
224
            for fname, comment in incorrect:
226
225
                help_text.append(fname)
227
 
                help_text.append((' '*4) + comment)
 
226
                help_text.append((' ' * 4) + comment)
228
227
 
229
228
            self.fail('\n'.join(help_text))
230
229
 
261
260
                         "",
262
261
                         "Please either add them to the list of"
263
262
                         " LICENSE_EXCEPTIONS in"
264
 
                         " bzrlib/tests/test_source.py",
 
263
                         " breezy/tests/test_source.py",
265
264
                         "Or add the following text to the beginning:",
266
 
                         gpl_txt
267
 
                        ]
 
265
                         gpl_txt]
268
266
            for fname in incorrect:
269
 
                help_text.append((' '*4) + fname)
 
267
                help_text.append((' ' * 4) + fname)
270
268
 
271
269
            self.fail('\n'.join(help_text))
272
270
 
277
275
            dict_[fname].append(line_no)
278
276
 
279
277
    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()
 
278
        files = sorted(["%s: %s" % (f, ', '.join([str(i + 1) for i in lines]))
 
279
                        for f, lines in dict_.items()])
283
280
        return message + '\n\n    %s' % ('\n    '.join(files))
284
281
 
285
282
    def test_coding_style(self):
286
283
        """Check if bazaar code conforms to some coding style conventions.
287
284
 
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
 
285
        Generally we expect PEP8, but we do not generally strictly enforce
 
286
        this, and there are existing files that do not comply.  The 'pep8'
 
287
        tool, available separately, will check for more cases.
292
288
 
293
 
        Print how many files have
294
 
         * trailing white space
295
 
         * lines longer than 79 chars
 
289
        This test only enforces conditions that are globally true at the
 
290
        moment, and that should cause a patch to be rejected: spaces rather
 
291
        than tabs, unix newlines, and a newline at the end of the file.
296
292
        """
297
293
        tabs = {}
298
 
        trailing_ws = {}
299
294
        illegal_newlines = {}
300
 
        long_lines = {}
301
295
        no_newline_at_eof = []
302
296
        for fname, text in self.get_source_file_contents(
303
297
                extensions=('.py', '.pyx')):
309
303
                if '\t' in line:
310
304
                    self._push_file(tabs, fname, line_no)
311
305
                if not line.endswith('\n') or line.endswith('\r\n'):
312
 
                    if line_no != last_line_no: # not no_newline_at_eof
 
306
                    if line_no != last_line_no:  # not no_newline_at_eof
313
307
                        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
308
            if not lines[-1].endswith('\n'):
319
309
                no_newline_at_eof.append(fname)
320
310
        problems = []
321
311
        if tabs:
322
312
            problems.append(self._format_message(tabs,
323
 
                'Tab characters were found in the following source files.'
324
 
                '\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)))
 
313
                                                 'Tab characters were found in the following source files.'
 
314
                                                 '\nThey should either be replaced by "\\t" or by spaces:'))
329
315
        if illegal_newlines:
330
316
            problems.append(self._format_message(illegal_newlines,
331
 
                '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)))
 
317
                                                 'Non-unix newlines were found in the following source files:'))
336
318
        if no_newline_at_eof:
337
319
            no_newline_at_eof.sort()
338
320
            problems.append("The following source files doesn't have a "
339
 
                "newline at the end:"
340
 
               '\n\n    %s'
341
 
               % ('\n    '.join(no_newline_at_eof)))
 
321
                            "newline at the end:"
 
322
                            '\n\n    %s'
 
323
                            % ('\n    '.join(no_newline_at_eof)))
342
324
        if problems:
343
325
            self.fail('\n\n'.join(problems))
344
326
 
 
327
    def test_flake8(self):
 
328
        self.requireFeature(features.flake8)
 
329
        # Older versions of flake8 don't support the 'paths'
 
330
        # variable
 
331
        new_path = list(sys.path)
 
332
        new_path.insert(
 
333
            0, os.path.join(os.path.dirname(__file__), '..', '..', 'tools'))
 
334
        self.overrideAttr(sys, 'path', new_path)
 
335
        from flake8.api import legacy as flake8
 
336
        style_guide = flake8.get_style_guide(config=u'setup.cfg', jobs="1")
 
337
        report = style_guide.check_files(list(self.get_source_files()))
 
338
        self.assertEqual([], report.get_statistics(''))
 
339
 
345
340
    def test_no_asserts(self):
346
341
        """bzr shouldn't use the 'assert' statement."""
347
342
        # assert causes too much variation between -O and not, and tends to
365
360
                continue
366
361
            if not assert_re.search(text):
367
362
                continue
368
 
            ast = parser.ast2tuple(parser.suite(text))
369
 
            if search(ast):
 
363
            st = parser.suite(text)
 
364
            code = parser.st2tuple(st)
 
365
            if search(code):
370
366
                badfiles.append(fname)
371
367
        if badfiles:
372
368
            self.fail(
376
372
    def test_extension_exceptions(self):
377
373
        """Extension functions should propagate exceptions.
378
374
 
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.
 
375
        Either they should return an object, have an 'except' clause, or
 
376
        have a "# cannot_raise" to indicate that we've audited them and
 
377
        defined them as not raising exceptions.
382
378
        """
383
379
        both_exc_and_no_exc = []
384
380
        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
 
                              )
 
381
        common_classes = ('StaticTuple',)
 
382
        class_re = re.compile(r'^(cdef\s+)?(public\s+)?'
 
383
                              r'(api\s+)?class (\w+).*:', re.MULTILINE)
 
384
        except_re = re.compile(
 
385
            r'cdef\s+'        # start with cdef
 
386
            r'([\w *]*?)\s*'  # this is the return signature
 
387
            r'(\w+)\s*\('     # the function name
 
388
            r'[^)]*\)\s*'     # parameters
 
389
            r'(.*)\s*:'       # the except clause
 
390
            r'\s*(#\s*cannot[- _]raise)?')  # cannot raise comment
394
391
        for fname, text in self.get_source_file_contents(
395
392
                extensions=('.pyx',)):
396
 
            known_classes = set([m[-1] for m in class_re.findall(text)])
 
393
            known_classes = {m[-1] for m in class_re.findall(text)}
 
394
            known_classes.update(common_classes)
397
395
            cdefs = except_re.findall(text)
398
396
            for sig, func, exc_clause, no_exc_comment in cdefs:
399
397
                if sig.startswith('api '):
408
406
                    missing_except.append((fname, func))
409
407
        error_msg = []
410
408
        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:')
 
409
            error_msg.append(
 
410
                'The following functions had "cannot raise" comments'
 
411
                ' but did have an except clause set:')
413
412
            for fname, func in both_exc_and_no_exc:
414
413
                error_msg.append('%s:%s' % (fname, func))
415
414
            error_msg.extend(('', ''))
416
415
        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".')
 
416
            error_msg.append(
 
417
                'The following functions have fixed return types,'
 
418
                ' but no except clause.')
 
419
            error_msg.append(
 
420
                'Either add an except or append "# cannot_raise".')
420
421
            for fname, func in missing_except:
421
422
                error_msg.append('%s:%s' % (fname, func))
422
423
            error_msg.extend(('', ''))
423
424
        if error_msg:
424
425
            self.fail('\n'.join(error_msg))
 
426
 
 
427
    def test_feature_absolute_import(self):
 
428
        """Using absolute imports means avoiding unnecesary stat and
 
429
        open calls.
 
430
 
 
431
        Make sure that all non-test files have absolute imports enabled.
 
432
        """
 
433
        missing_absolute_import = []
 
434
        for fname, text in self.get_source_file_contents(
 
435
                extensions=('.py', '.pyx')):
 
436
            if "/tests/" in fname or "test_" in fname:
 
437
                # We don't really care about tests
 
438
                continue
 
439
            if "from __future__ import absolute_import" not in text:
 
440
                missing_absolute_import.append(fname)
 
441
 
 
442
        if missing_absolute_import:
 
443
            self.fail(
 
444
                'The following files do not have absolute_import enabled:\n'
 
445
                '\n' + '\n'.join(missing_absolute_import))