~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_source.py

  • Committer: Martin Pool
  • Date: 2006-03-22 20:00:48 UTC
  • mto: (1668.1.8 bzr-0.8.mbp)
  • mto: This revision was merged to the branch mainline in revision 1710.
  • Revision ID: mbp@sourcefrog.net-20060322200048-4a2718c8e8770351
(register-branch) Add command-line options
Refactor the way the BranchRegistrationRequest is constructed

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2011 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
"""These tests are tests about the source code of bzrlib itself.
18
 
 
19
 
They are useful for testing code quality, checking coverage metric etc.
20
 
"""
21
 
 
22
 
import os
23
 
import parser
24
 
import re
25
 
import symbol
26
 
import sys
27
 
import token
28
 
 
29
 
from bzrlib import (
30
 
    osutils,
31
 
    )
32
 
import bzrlib.branch
33
 
from bzrlib.tests import (
34
 
    TestCase,
35
 
    TestSkipped,
36
 
    )
37
 
 
38
 
 
39
 
# Files which are listed here will be skipped when testing for Copyright (or
40
 
# GPL) statements.
41
 
COPYRIGHT_EXCEPTIONS = [
42
 
    'bzrlib/_bencode_py.py',
43
 
    'bzrlib/doc_generate/conf.py',
44
 
    'bzrlib/lsprof.py',
45
 
    ]
46
 
 
47
 
LICENSE_EXCEPTIONS = [
48
 
    'bzrlib/_bencode_py.py',
49
 
    'bzrlib/doc_generate/conf.py',
50
 
    'bzrlib/lsprof.py',
51
 
    ]
52
 
# Technically, 'bzrlib/lsprof.py' should be 'bzrlib/util/lsprof.py',
53
 
# (we do not check bzrlib/util/, since that is code bundled from elsewhere)
54
 
# but for compatibility with previous releases, we don't want to move it.
55
 
#
56
 
# sphinx_conf is semi-autogenerated.
57
 
 
58
 
 
59
 
class TestSourceHelper(TestCase):
60
 
 
61
 
    def source_file_name(self, package):
62
 
        """Return the path of the .py file for package."""
63
 
        if getattr(sys, "frozen", None) is not None:
64
 
            raise TestSkipped("can't test sources in frozen distributions.")
65
 
        path = package.__file__
66
 
        if path[-1] in 'co':
67
 
            return path[:-1]
68
 
        else:
69
 
            return path
70
 
 
71
 
 
72
 
class TestApiUsage(TestSourceHelper):
73
 
 
74
 
    def find_occurences(self, rule, filename):
75
 
        """Find the number of occurences of rule in a file."""
76
 
        occurences = 0
77
 
        source = file(filename, 'r')
78
 
        for line in source:
79
 
            if line.find(rule) > -1:
80
 
                occurences += 1
81
 
        return occurences
82
 
 
83
 
    def test_branch_working_tree(self):
84
 
        """Test that the number of uses of working_tree in branch is stable."""
85
 
        occurences = self.find_occurences('self.working_tree()',
86
 
                                          self.source_file_name(bzrlib.branch))
87
 
        # do not even think of increasing this number. If you think you need to
88
 
        # increase it, then you almost certainly are doing something wrong as
89
 
        # the relationship from working_tree to branch is one way.
90
 
        # Note that this is an exact equality so that when the number drops,
91
 
        #it is not given a buffer but rather has this test updated immediately.
92
 
        self.assertEqual(0, occurences)
93
 
 
94
 
    def test_branch_WorkingTree(self):
95
 
        """Test that the number of uses of working_tree in branch is stable."""
96
 
        occurences = self.find_occurences('WorkingTree',
97
 
                                          self.source_file_name(bzrlib.branch))
98
 
        # Do not even think of increasing this number. If you think you need to
99
 
        # increase it, then you almost certainly are doing something wrong as
100
 
        # the relationship from working_tree to branch is one way.
101
 
        # As of 20070809, there are no longer any mentions at all.
102
 
        self.assertEqual(0, occurences)
103
 
 
104
 
 
105
 
class TestSource(TestSourceHelper):
106
 
 
107
 
    def get_bzrlib_dir(self):
108
 
        """Get the path to the root of bzrlib"""
109
 
        source = self.source_file_name(bzrlib)
110
 
        source_dir = os.path.dirname(source)
111
 
 
112
 
        # Avoid the case when bzrlib is packaged in a zip file
113
 
        if not os.path.isdir(source_dir):
114
 
            raise TestSkipped(
115
 
                'Cannot find bzrlib source directory. Expected %s'
116
 
                % source_dir)
117
 
        return source_dir
118
 
 
119
 
    def get_source_files(self, extensions=None):
120
 
        """Yield all source files for bzr and bzrlib
121
 
 
122
 
        :param our_files_only: If true, exclude files from included libraries
123
 
            or plugins.
124
 
        """
125
 
        bzrlib_dir = self.get_bzrlib_dir()
126
 
        if extensions is None:
127
 
            extensions = ('.py',)
128
 
 
129
 
        # This is the front-end 'bzr' script
130
 
        bzr_path = self.get_bzr_path()
131
 
        yield bzr_path
132
 
 
133
 
        for root, dirs, files in os.walk(bzrlib_dir):
134
 
            for d in dirs:
135
 
                if d.endswith('.tmp'):
136
 
                    dirs.remove(d)
137
 
            for f in files:
138
 
                for extension in extensions:
139
 
                    if f.endswith(extension):
140
 
                        break
141
 
                else:
142
 
                    # Did not match the accepted extensions
143
 
                    continue
144
 
                yield osutils.pathjoin(root, f)
145
 
 
146
 
    def get_source_file_contents(self, extensions=None):
147
 
        for fname in self.get_source_files(extensions=extensions):
148
 
            f = open(fname, 'rb')
149
 
            try:
150
 
                text = f.read()
151
 
            finally:
152
 
                f.close()
153
 
            yield fname, text
154
 
 
155
 
    def is_our_code(self, fname):
156
 
        """True if it's a "real" part of bzrlib rather than external code"""
157
 
        if '/util/' in fname or '/plugins/' in fname:
158
 
            return False
159
 
        else:
160
 
            return True
161
 
 
162
 
    def is_copyright_exception(self, fname):
163
 
        """Certain files are allowed to be different"""
164
 
        if not self.is_our_code(fname):
165
 
            # We don't ask that external utilities or plugins be
166
 
            # (C) Canonical Ltd
167
 
            return True
168
 
        for exc in COPYRIGHT_EXCEPTIONS:
169
 
            if fname.endswith(exc):
170
 
                return True
171
 
        return False
172
 
 
173
 
    def is_license_exception(self, fname):
174
 
        """Certain files are allowed to be different"""
175
 
        if not self.is_our_code(fname):
176
 
            return True
177
 
        for exc in LICENSE_EXCEPTIONS:
178
 
            if fname.endswith(exc):
179
 
                return True
180
 
        return False
181
 
 
182
 
    def test_tmpdir_not_in_source_files(self):
183
 
        """When scanning for source files, we don't descend test tempdirs"""
184
 
        for filename in self.get_source_files():
185
 
            if re.search(r'test....\.tmp', filename):
186
 
                self.fail("get_source_file() returned filename %r "
187
 
                          "from within a temporary directory"
188
 
                          % filename)
189
 
 
190
 
    def test_copyright(self):
191
 
        """Test that all .py and .pyx files have a valid copyright statement"""
192
 
        incorrect = []
193
 
 
194
 
        copyright_re = re.compile('#\\s*copyright.*(?=\n)', re.I)
195
 
        copyright_canonical_re = re.compile(
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'.
199
 
 
200
 
        for fname, text in self.get_source_file_contents(
201
 
                extensions=('.py', '.pyx')):
202
 
            if self.is_copyright_exception(fname):
203
 
                continue
204
 
            match = copyright_canonical_re.search(text)
205
 
            if not match:
206
 
                match = copyright_re.search(text)
207
 
                if match:
208
 
                    incorrect.append((fname, 'found: %s' % (match.group(),)))
209
 
                else:
210
 
                    incorrect.append((fname, 'no copyright line found\n'))
211
 
            else:
212
 
                if 'by Canonical' in match.group():
213
 
                    incorrect.append((fname,
214
 
                        'should not have: "by Canonical": %s'
215
 
                        % (match.group(),)))
216
 
 
217
 
        if incorrect:
218
 
            help_text = ["Some files have missing or incorrect copyright"
219
 
                         " statements.",
220
 
                         "",
221
 
                         "Please either add them to the list of"
222
 
                         " COPYRIGHT_EXCEPTIONS in"
223
 
                         " bzrlib/tests/test_source.py",
224
 
                         # this is broken to prevent a false match
225
 
                         "or add '# Copyright (C)"
226
 
                         " 2007 Canonical Ltd' to these files:",
227
 
                         "",
228
 
                        ]
229
 
            for fname, comment in incorrect:
230
 
                help_text.append(fname)
231
 
                help_text.append((' ' * 4) + comment)
232
 
 
233
 
            self.fail('\n'.join(help_text))
234
 
 
235
 
    def test_gpl(self):
236
 
        """Test that all .py and .pyx files have a GPL disclaimer."""
237
 
        incorrect = []
238
 
 
239
 
        gpl_txt = """
240
 
# This program is free software; you can redistribute it and/or modify
241
 
# it under the terms of the GNU General Public License as published by
242
 
# the Free Software Foundation; either version 2 of the License, or
243
 
# (at your option) any later version.
244
 
#
245
 
# This program is distributed in the hope that it will be useful,
246
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
247
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
248
 
# GNU General Public License for more details.
249
 
#
250
 
# You should have received a copy of the GNU General Public License
251
 
# along with this program; if not, write to the Free Software
252
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
253
 
"""
254
 
        gpl_re = re.compile(re.escape(gpl_txt), re.MULTILINE)
255
 
 
256
 
        for fname, text in self.get_source_file_contents(
257
 
                extensions=('.py', '.pyx')):
258
 
            if self.is_license_exception(fname):
259
 
                continue
260
 
            if not gpl_re.search(text):
261
 
                incorrect.append(fname)
262
 
 
263
 
        if incorrect:
264
 
            help_text = ['Some files have missing or incomplete GPL statement',
265
 
                         "",
266
 
                         "Please either add them to the list of"
267
 
                         " LICENSE_EXCEPTIONS in"
268
 
                         " bzrlib/tests/test_source.py",
269
 
                         "Or add the following text to the beginning:",
270
 
                         gpl_txt]
271
 
            for fname in incorrect:
272
 
                help_text.append((' ' * 4) + fname)
273
 
 
274
 
            self.fail('\n'.join(help_text))
275
 
 
276
 
    def _push_file(self, dict_, fname, line_no):
277
 
        if fname not in dict_:
278
 
            dict_[fname] = [line_no]
279
 
        else:
280
 
            dict_[fname].append(line_no)
281
 
 
282
 
    def _format_message(self, dict_, message):
283
 
        files = ["%s: %s" % (f, ', '.join([str(i + 1) for i in lines]))
284
 
                for f, lines in dict_.items()]
285
 
        files.sort()
286
 
        return message + '\n\n    %s' % ('\n    '.join(files))
287
 
 
288
 
    def test_coding_style(self):
289
 
        """Check if bazaar code conforms to some coding style conventions.
290
 
 
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.
298
 
        """
299
 
        tabs = {}
300
 
        illegal_newlines = {}
301
 
        no_newline_at_eof = []
302
 
        for fname, text in self.get_source_file_contents(
303
 
                extensions=('.py', '.pyx')):
304
 
            if not self.is_our_code(fname):
305
 
                continue
306
 
            lines = text.splitlines(True)
307
 
            last_line_no = len(lines) - 1
308
 
            for line_no, line in enumerate(lines):
309
 
                if '\t' in line:
310
 
                    self._push_file(tabs, fname, line_no)
311
 
                if not line.endswith('\n') or line.endswith('\r\n'):
312
 
                    if line_no != last_line_no:  # not no_newline_at_eof
313
 
                        self._push_file(illegal_newlines, fname, line_no)
314
 
            if not lines[-1].endswith('\n'):
315
 
                no_newline_at_eof.append(fname)
316
 
        problems = []
317
 
        if tabs:
318
 
            problems.append(self._format_message(tabs,
319
 
                'Tab characters were found in the following source files.'
320
 
                '\nThey should either be replaced by "\\t" or by spaces:'))
321
 
        if illegal_newlines:
322
 
            problems.append(self._format_message(illegal_newlines,
323
 
                'Non-unix newlines were found in the following source files:'))
324
 
        if no_newline_at_eof:
325
 
            no_newline_at_eof.sort()
326
 
            problems.append("The following source files doesn't have a "
327
 
                "newline at the end:"
328
 
               '\n\n    %s'
329
 
               % ('\n    '.join(no_newline_at_eof)))
330
 
        if problems:
331
 
            self.fail('\n\n'.join(problems))
332
 
 
333
 
    def test_no_asserts(self):
334
 
        """bzr shouldn't use the 'assert' statement."""
335
 
        # assert causes too much variation between -O and not, and tends to
336
 
        # give bad errors to the user
337
 
        def search(x):
338
 
            # scan down through x for assert statements, report any problems
339
 
            # this is a bit cheesy; it may get some false positives?
340
 
            if x[0] == symbol.assert_stmt:
341
 
                return True
342
 
            elif x[0] == token.NAME:
343
 
                # can't search further down
344
 
                return False
345
 
            for sub in x[1:]:
346
 
                if sub and search(sub):
347
 
                    return True
348
 
            return False
349
 
        badfiles = []
350
 
        assert_re = re.compile(r'\bassert\b')
351
 
        for fname, text in self.get_source_file_contents():
352
 
            if not self.is_our_code(fname):
353
 
                continue
354
 
            if not assert_re.search(text):
355
 
                continue
356
 
            ast = parser.ast2tuple(parser.suite(text))
357
 
            if search(ast):
358
 
                badfiles.append(fname)
359
 
        if badfiles:
360
 
            self.fail(
361
 
                "these files contain an assert statement and should not:\n%s"
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))