/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: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

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.main.application import Application
 
336
        from flake8.formatting.base import BaseFormatter
 
337
        app = Application()
 
338
        app.config = u'setup.cfg'
 
339
        app.jobs = 1
 
340
 
 
341
        class Formatter(BaseFormatter):
 
342
 
 
343
            def __init__(self):
 
344
                self.errors = []
 
345
 
 
346
            def start(self):
 
347
                pass
 
348
 
 
349
            def stop(self):
 
350
                app.file_checker_manager.report()
 
351
 
 
352
            def handle(self, error):
 
353
                self.errors.append(error)
 
354
 
 
355
        app.formatter = Formatter()
 
356
        app.initialize([])
 
357
        app.run_checks()
 
358
        app.report()
 
359
        self.assertEqual(app.formatter.errors, [])
 
360
 
345
361
    def test_no_asserts(self):
346
362
        """bzr shouldn't use the 'assert' statement."""
347
363
        # assert causes too much variation between -O and not, and tends to
365
381
                continue
366
382
            if not assert_re.search(text):
367
383
                continue
368
 
            ast = parser.ast2tuple(parser.suite(text))
369
 
            if search(ast):
 
384
            st = parser.suite(text)
 
385
            code = parser.st2tuple(st)
 
386
            if search(code):
370
387
                badfiles.append(fname)
371
388
        if badfiles:
372
389
            self.fail(
376
393
    def test_extension_exceptions(self):
377
394
        """Extension functions should propagate exceptions.
378
395
 
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.
 
396
        Either they should return an object, have an 'except' clause, or
 
397
        have a "# cannot_raise" to indicate that we've audited them and
 
398
        defined them as not raising exceptions.
382
399
        """
383
400
        both_exc_and_no_exc = []
384
401
        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
 
                              )
 
402
        common_classes = ('StaticTuple',)
 
403
        class_re = re.compile(r'^(cdef\s+)?(public\s+)?'
 
404
                              r'(api\s+)?class (\w+).*:', re.MULTILINE)
 
405
        except_re = re.compile(
 
406
            r'cdef\s+'        # start with cdef
 
407
            r'([\w *]*?)\s*'  # this is the return signature
 
408
            r'(\w+)\s*\('     # the function name
 
409
            r'[^)]*\)\s*'     # parameters
 
410
            r'(.*)\s*:'       # the except clause
 
411
            r'\s*(#\s*cannot[- _]raise)?')  # cannot raise comment
394
412
        for fname, text in self.get_source_file_contents(
395
413
                extensions=('.pyx',)):
396
 
            known_classes = set([m[-1] for m in class_re.findall(text)])
 
414
            known_classes = {m[-1] for m in class_re.findall(text)}
 
415
            known_classes.update(common_classes)
397
416
            cdefs = except_re.findall(text)
398
417
            for sig, func, exc_clause, no_exc_comment in cdefs:
399
418
                if sig.startswith('api '):
408
427
                    missing_except.append((fname, func))
409
428
        error_msg = []
410
429
        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:')
 
430
            error_msg.append(
 
431
                'The following functions had "cannot raise" comments'
 
432
                ' but did have an except clause set:')
413
433
            for fname, func in both_exc_and_no_exc:
414
434
                error_msg.append('%s:%s' % (fname, func))
415
435
            error_msg.extend(('', ''))
416
436
        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".')
 
437
            error_msg.append(
 
438
                'The following functions have fixed return types,'
 
439
                ' but no except clause.')
 
440
            error_msg.append(
 
441
                'Either add an except or append "# cannot_raise".')
420
442
            for fname, func in missing_except:
421
443
                error_msg.append('%s:%s' % (fname, func))
422
444
            error_msg.extend(('', ''))
423
445
        if error_msg:
424
446
            self.fail('\n'.join(error_msg))
 
447
 
 
448
    def test_feature_absolute_import(self):
 
449
        """Using absolute imports means avoiding unnecesary stat and
 
450
        open calls.
 
451
 
 
452
        Make sure that all non-test files have absolute imports enabled.
 
453
        """
 
454
        missing_absolute_import = []
 
455
        for fname, text in self.get_source_file_contents(
 
456
                extensions=('.py', '.pyx')):
 
457
            if "/tests/" in fname or "test_" in fname:
 
458
                # We don't really care about tests
 
459
                continue
 
460
            if "from __future__ import absolute_import" not in text:
 
461
                missing_absolute_import.append(fname)
 
462
 
 
463
        if missing_absolute_import:
 
464
            self.fail(
 
465
                'The following files do not have absolute_import enabled:\n'
 
466
                '\n' + '\n'.join(missing_absolute_import))