/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: 2018-05-06 11:48:54 UTC
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@jelmer.uk-20180506114854-h4qd9ojaqy8wxjsd
Move .mailmap to root.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_source.py
31
31
    )
32
32
import breezy.branch
33
33
from breezy.tests import (
34
 
    features,
35
34
    TestCase,
36
35
    TestSkipped,
37
36
    )
75
74
    def find_occurences(self, rule, filename):
76
75
        """Find the number of occurences of rule in a file."""
77
76
        occurences = 0
78
 
        source = open(filename, 'r')
 
77
        source = file(filename, 'r')
79
78
        for line in source:
80
79
            if line.find(rule) > -1:
81
80
                occurences += 1
89
88
        # increase it, then you almost certainly are doing something wrong as
90
89
        # the relationship from working_tree to branch is one way.
91
90
        # Note that this is an exact equality so that when the number drops,
92
 
        # it is not given a buffer but rather has this test updated immediately.
 
91
        #it is not given a buffer but rather has this test updated immediately.
93
92
        self.assertEqual(0, occurences)
94
93
 
95
94
    def test_branch_WorkingTree(self):
146
145
 
147
146
    def get_source_file_contents(self, extensions=None):
148
147
        for fname in self.get_source_files(extensions=extensions):
149
 
            with open(fname, 'r') as f:
150
 
                yield fname, f.read()
 
148
            f = open(fname, 'rb')
 
149
            try:
 
150
                text = f.read()
 
151
            finally:
 
152
                f.close()
 
153
            yield fname, text
151
154
 
152
155
    def is_our_code(self, fname):
153
156
        """True if it's a "real" part of breezy rather than external code"""
206
209
            else:
207
210
                if 'by Canonical' in match.group():
208
211
                    incorrect.append((fname,
209
 
                                      'should not have: "by Canonical": %s'
210
 
                                      % (match.group(),)))
 
212
                        'should not have: "by Canonical": %s'
 
213
                        % (match.group(),)))
211
214
 
212
215
        if incorrect:
213
216
            help_text = ["Some files have missing or incorrect copyright"
220
223
                         "or add '# Copyright (C)"
221
224
                         " 2007 Bazaar hackers' to these files:",
222
225
                         "",
223
 
                         ]
 
226
                        ]
224
227
            for fname, comment in incorrect:
225
228
                help_text.append(fname)
226
229
                help_text.append((' ' * 4) + comment)
276
279
 
277
280
    def _format_message(self, dict_, message):
278
281
        files = sorted(["%s: %s" % (f, ', '.join([str(i + 1) for i in lines]))
279
 
                        for f, lines in dict_.items()])
 
282
                for f, lines in dict_.items()])
280
283
        return message + '\n\n    %s' % ('\n    '.join(files))
281
284
 
282
285
    def test_coding_style(self):
310
313
        problems = []
311
314
        if tabs:
312
315
            problems.append(self._format_message(tabs,
313
 
                                                 'Tab characters were found in the following source files.'
314
 
                                                 '\nThey should either be replaced by "\\t" or by spaces:'))
 
316
                'Tab characters were found in the following source files.'
 
317
                '\nThey should either be replaced by "\\t" or by spaces:'))
315
318
        if illegal_newlines:
316
319
            problems.append(self._format_message(illegal_newlines,
317
 
                                                 'Non-unix newlines were found in the following source files:'))
 
320
                'Non-unix newlines were found in the following source files:'))
318
321
        if no_newline_at_eof:
319
322
            no_newline_at_eof.sort()
320
323
            problems.append("The following source files doesn't have a "
321
 
                            "newline at the end:"
322
 
                            '\n\n    %s'
323
 
                            % ('\n    '.join(no_newline_at_eof)))
 
324
                "newline at the end:"
 
325
               '\n\n    %s'
 
326
               % ('\n    '.join(no_newline_at_eof)))
324
327
        if problems:
325
328
            self.fail('\n\n'.join(problems))
326
329
 
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
 
 
361
330
    def test_no_asserts(self):
362
331
        """bzr shouldn't use the 'assert' statement."""
363
332
        # assert causes too much variation between -O and not, and tends to
381
350
                continue
382
351
            if not assert_re.search(text):
383
352
                continue
384
 
            st = parser.suite(text)
385
 
            code = parser.st2tuple(st)
386
 
            if search(code):
 
353
            ast = parser.ast2tuple(parser.suite(text))
 
354
            if search(ast):
387
355
                badfiles.append(fname)
388
356
        if badfiles:
389
357
            self.fail(
399
367
        """
400
368
        both_exc_and_no_exc = []
401
369
        missing_except = []
402
 
        common_classes = ('StaticTuple',)
403
370
        class_re = re.compile(r'^(cdef\s+)?(public\s+)?'
404
371
                              r'(api\s+)?class (\w+).*:', re.MULTILINE)
 
372
        extern_class_re = re.compile(r'## extern cdef class (\w+)',
 
373
                                     re.MULTILINE)
405
374
        except_re = re.compile(
406
375
            r'cdef\s+'        # start with cdef
407
376
            r'([\w *]*?)\s*'  # this is the return signature
412
381
        for fname, text in self.get_source_file_contents(
413
382
                extensions=('.pyx',)):
414
383
            known_classes = {m[-1] for m in class_re.findall(text)}
415
 
            known_classes.update(common_classes)
 
384
            known_classes.update(extern_class_re.findall(text))
416
385
            cdefs = except_re.findall(text)
417
386
            for sig, func, exc_clause, no_exc_comment in cdefs:
418
387
                if sig.startswith('api '):
457
426
            if "/tests/" in fname or "test_" in fname:
458
427
                # We don't really care about tests
459
428
                continue
460
 
            if "from __future__ import absolute_import" not in text:
 
429
            if not "from __future__ import absolute_import" in text:
461
430
                missing_absolute_import.append(fname)
462
431
 
463
432
        if missing_absolute_import: