1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
|
# Copyright (c) 2012-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr>
# Copyright (c) 2012 FELD Boris <lothiraldan@gmail.com>
# Copyright (c) 2013-2017 Claudiu Popa <pcmanticore@gmail.com>
# Copyright (c) 2013-2014 Google, Inc.
# Copyright (c) 2013 buck@yelp.com <buck@yelp.com>
# Copyright (c) 2014 LCD 47 <lcd047@gmail.com>
# Copyright (c) 2014 Brett Cannon <brett@python.org>
# Copyright (c) 2014 Ricardo Gemignani <ricardo.gemignani@gmail.com>
# Copyright (c) 2014 Arun Persaud <arun@nubati.net>
# Copyright (c) 2015 Pavel Roskin <proski@gnu.org>
# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro>
# Copyright (c) 2016 Derek Gustafson <degustaf@gmail.com>
# Copyright (c) 2016 Roy Williams <roy.williams.iii@gmail.com>
# Copyright (c) 2016 xmo-odoo <xmo-odoo@users.noreply.github.com>
# Copyright (c) 2017 Bryce Guinta <bryce.paul.guinta@gmail.com>
# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com>
# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com>
# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html
# For details: https://github.com/PyCQA/pylint/blob/master/COPYING
"""functional/non regression tests for pylint"""
from __future__ import print_function
import collections
import contextlib
import functools
from glob import glob
import os
from os import linesep, getcwd, sep
from os.path import abspath, basename, dirname, join, splitext
import sys
import tempfile
import tokenize
from io import StringIO
import astroid
from pylint import checkers
from pylint.utils import PyLintASTWalker
from pylint.reporters import BaseReporter
from pylint.interfaces import IReporter
from pylint.lint import PyLinter
# Utils
SYS_VERS_STR = '%d%d%d' % sys.version_info[:3]
TITLE_UNDERLINES = ['', '=', '-', '.']
PREFIX = abspath(dirname(__file__))
PY3K = sys.version_info[0] == 3
def _get_tests_info(input_dir, msg_dir, prefix, suffix):
"""get python input examples and output messages
We use following conventions for input files and messages:
for different inputs:
test for python >= x.y -> input = <name>_pyxy.py
test for python < x.y -> input = <name>_py_xy.py
for one input and different messages:
message for python >= x.y -> message = <name>_pyxy.txt
lower versions -> message with highest num
"""
result = []
for fname in glob(join(input_dir, prefix + '*' + suffix)):
infile = basename(fname)
fbase = splitext(infile)[0]
# filter input files :
pyrestr = fbase.rsplit('_py', 1)[-1] # like _26 or 26
if pyrestr.isdigit(): # '24', '25'...
if SYS_VERS_STR < pyrestr:
continue
if pyrestr.startswith('_') and pyrestr[1:].isdigit():
# skip test for higher python versions
if SYS_VERS_STR >= pyrestr[1:]:
continue
messages = glob(join(msg_dir, fbase + '*.txt'))
# the last one will be without ext, i.e. for all or upper versions:
if messages:
for outfile in sorted(messages, reverse=True):
py_rest = outfile.rsplit('_py', 1)[-1][:-4]
if py_rest.isdigit() and SYS_VERS_STR >= py_rest:
break
else:
# This will provide an error message indicating the missing filename.
outfile = join(msg_dir, fbase + '.txt')
result.append((infile, outfile))
return result
class TestReporter(BaseReporter):
"""reporter storing plain text messages"""
__implements__ = IReporter
def __init__(self): # pylint: disable=super-init-not-called
self.message_ids = {}
self.reset()
self.path_strip_prefix = getcwd() + sep
def reset(self):
self.out = StringIO()
self.messages = []
def handle_message(self, msg):
"""manage message of different type and in the context of path """
obj = msg.obj
line = msg.line
msg_id = msg.msg_id
msg = msg.msg
self.message_ids[msg_id] = 1
if obj:
obj = ':%s' % obj
sigle = msg_id[0]
if PY3K and linesep != '\n':
# 2to3 writes os.linesep instead of using
# the previosly used line separators
msg = msg.replace('\r\n', '\n')
self.messages.append('%s:%3s%s: %s' % (sigle, line, obj, msg))
def finalize(self):
self.messages.sort()
for msg in self.messages:
print(msg, file=self.out)
result = self.out.getvalue()
self.reset()
return result
# pylint: disable=unused-argument
def on_set_current_module(self, module, filepath):
pass
# pylint: enable=unused-argument
def display_reports(self, layout):
"""ignore layouts"""
_display = None
class MinimalTestReporter(BaseReporter):
def handle_message(self, msg):
self.messages.append(msg)
def on_set_current_module(self, module, filepath):
self.messages = []
_display = None
class Message(collections.namedtuple('Message',
['msg_id', 'line', 'node', 'args', 'confidence'])):
def __new__(cls, msg_id, line=None, node=None, args=None, confidence=None):
return tuple.__new__(cls, (msg_id, line, node, args, confidence))
def __eq__(self, other):
if isinstance(other, Message):
if self.confidence and other.confidence:
return super(Message, self).__eq__(other)
return self[:-1] == other[:-1]
return NotImplemented # pragma: no cover
__hash__ = None
class UnittestLinter:
"""A fake linter class to capture checker messages."""
# pylint: disable=unused-argument, no-self-use
def __init__(self):
self._messages = []
self.stats = {}
def release_messages(self):
try:
return self._messages
finally:
self._messages = []
def add_message(self, msg_id, line=None, node=None, args=None, confidence=None,
col_offset=None):
# Do not test col_offset for now since changing Message breaks everything
self._messages.append(Message(msg_id, line, node, args, confidence))
def is_message_enabled(self, *unused_args, **unused_kwargs):
return True
def add_stats(self, **kwargs):
for name, value in kwargs.items():
self.stats[name] = value
return self.stats
@property
def options_providers(self):
return linter.options_providers
def set_config(**kwargs):
"""Decorator for setting config values on a checker."""
def _wrapper(fun):
@functools.wraps(fun)
def _forward(self):
for key, value in kwargs.items():
setattr(self.checker.config, key, value)
if isinstance(self, CheckerTestCase):
# reopen checker in case, it may be interested in configuration change
self.checker.open()
fun(self)
return _forward
return _wrapper
class CheckerTestCase:
"""A base testcase class for unit testing individual checker classes."""
CHECKER_CLASS = None
CONFIG = {}
def setup_method(self):
self.linter = UnittestLinter()
self.checker = self.CHECKER_CLASS(self.linter) # pylint: disable=not-callable
for key, value in self.CONFIG.items():
setattr(self.checker.config, key, value)
self.checker.open()
@contextlib.contextmanager
def assertNoMessages(self):
"""Assert that no messages are added by the given method."""
with self.assertAddsMessages():
yield
@contextlib.contextmanager
def assertAddsMessages(self, *messages):
"""Assert that exactly the given method adds the given messages.
The list of messages must exactly match *all* the messages added by the
method. Additionally, we check to see whether the args in each message can
actually be substituted into the message string.
"""
yield
got = self.linter.release_messages()
msg = ('Expected messages did not match actual.\n'
'Expected:\n%s\nGot:\n%s' % ('\n'.join(repr(m) for m in messages),
'\n'.join(repr(m) for m in got)))
assert list(messages) == got, msg
def walk(self, node):
"""recursive walk on the given node"""
walker = PyLintASTWalker(linter)
walker.add_checker(self.checker)
walker.walk(node)
# Init
test_reporter = TestReporter()
linter = PyLinter()
linter.set_reporter(test_reporter)
linter.config.persistent = 0
checkers.initialize(linter)
def _tokenize_str(code):
return list(tokenize.generate_tokens(StringIO(code).readline))
@contextlib.contextmanager
def _create_tempfile(content=None):
"""Create a new temporary file.
If *content* parameter is given, then it will be written
in the temporary file, before passing it back.
This is a context manager and should be used with a *with* statement.
"""
# Can't use tempfile.NamedTemporaryFile here
# because on Windows the file must be closed before writing to it,
# see http://bugs.python.org/issue14243
file_handle, tmp = tempfile.mkstemp()
if content:
if sys.version_info >= (3, 0):
# erff
os.write(file_handle, bytes(content, 'ascii'))
else:
os.write(file_handle, content)
try:
yield tmp
finally:
os.close(file_handle)
os.remove(tmp)
@contextlib.contextmanager
def _create_file_backed_module(code):
"""Create an astroid module for the given code, backed by a real file."""
with _create_tempfile() as temp:
module = astroid.parse(code)
module.file = temp
yield module
|