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
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
|
"""Testing `tabnanny` module.
Glossary:
* errored : Whitespace related problems present in file.
"""
from unittest import TestCase, mock
import errno
import os
import tabnanny
import tokenize
import tempfile
import textwrap
from test.support import (captured_stderr, captured_stdout, script_helper,
findfile)
from test.support.os_helper import unlink
SOURCE_CODES = {
"incomplete_expression": (
'fruits = [\n'
' "Apple",\n'
' "Orange",\n'
' "Banana",\n'
'\n'
'print(fruits)\n'
),
"wrong_indented": (
'if True:\n'
' print("hello")\n'
' print("world")\n'
'else:\n'
' print("else called")\n'
),
"nannynag_errored": (
'if True:\n'
' \tprint("hello")\n'
'\tprint("world")\n'
'else:\n'
' print("else called")\n'
),
"error_free": (
'if True:\n'
' print("hello")\n'
' print("world")\n'
'else:\n'
' print("else called")\n'
),
"tab_space_errored_1": (
'def my_func():\n'
'\t print("hello world")\n'
'\t if True:\n'
'\t\tprint("If called")'
),
"tab_space_errored_2": (
'def my_func():\n'
'\t\tprint("Hello world")\n'
'\t\tif True:\n'
'\t print("If called")'
)
}
class TemporaryPyFile:
"""Create a temporary python source code file."""
def __init__(self, source_code='', directory=None):
self.source_code = source_code
self.dir = directory
def __enter__(self):
with tempfile.NamedTemporaryFile(
mode='w', dir=self.dir, suffix=".py", delete=False
) as f:
f.write(self.source_code)
self.file_path = f.name
return self.file_path
def __exit__(self, exc_type, exc_value, exc_traceback):
unlink(self.file_path)
class TestFormatWitnesses(TestCase):
"""Testing `tabnanny.format_witnesses()`."""
def test_format_witnesses(self):
"""Asserting formatter result by giving various input samples."""
tests = [
('Test', 'at tab sizes T, e, s, t'),
('', 'at tab size '),
('t', 'at tab size t'),
(' t ', 'at tab sizes , , t, , '),
]
for words, expected in tests:
with self.subTest(words=words, expected=expected):
self.assertEqual(tabnanny.format_witnesses(words), expected)
class TestErrPrint(TestCase):
"""Testing `tabnanny.errprint()`."""
def test_errprint(self):
"""Asserting result of `tabnanny.errprint()` by giving sample inputs."""
tests = [
(['first', 'second'], 'first second\n'),
(['first'], 'first\n'),
([1, 2, 3], '1 2 3\n'),
([], '\n')
]
for args, expected in tests:
with self.subTest(arguments=args, expected=expected):
with self.assertRaises(SystemExit):
with captured_stderr() as stderr:
tabnanny.errprint(*args)
self.assertEqual(stderr.getvalue() , expected)
class TestNannyNag(TestCase):
def test_all_methods(self):
"""Asserting behaviour of `tabnanny.NannyNag` exception."""
tests = [
(
tabnanny.NannyNag(0, "foo", "bar"),
{'lineno': 0, 'msg': 'foo', 'line': 'bar'}
),
(
tabnanny.NannyNag(5, "testmsg", "testline"),
{'lineno': 5, 'msg': 'testmsg', 'line': 'testline'}
)
]
for nanny, expected in tests:
line_number = nanny.get_lineno()
msg = nanny.get_msg()
line = nanny.get_line()
with self.subTest(
line_number=line_number, expected=expected['lineno']
):
self.assertEqual(expected['lineno'], line_number)
with self.subTest(msg=msg, expected=expected['msg']):
self.assertEqual(expected['msg'], msg)
with self.subTest(line=line, expected=expected['line']):
self.assertEqual(expected['line'], line)
class TestCheck(TestCase):
"""Testing tabnanny.check()."""
def setUp(self):
self.addCleanup(setattr, tabnanny, 'verbose', tabnanny.verbose)
tabnanny.verbose = 0 # Forcefully deactivating verbose mode.
def verify_tabnanny_check(self, dir_or_file, out="", err=""):
"""Common verification for tabnanny.check().
Use this method to assert expected values of `stdout` and `stderr` after
running tabnanny.check() on given `dir` or `file` path. Because
tabnanny.check() captures exceptions and writes to `stdout` and
`stderr`, asserting standard outputs is the only way.
"""
with captured_stdout() as stdout, captured_stderr() as stderr:
tabnanny.check(dir_or_file)
self.assertEqual(stdout.getvalue(), out)
self.assertEqual(stderr.getvalue(), err)
def test_correct_file(self):
"""A python source code file without any errors."""
with TemporaryPyFile(SOURCE_CODES["error_free"]) as file_path:
self.verify_tabnanny_check(file_path)
def test_correct_directory_verbose(self):
"""Directory containing few error free python source code files.
Because order of files returned by `os.lsdir()` is not fixed, verify the
existence of each output lines at `stdout` using `in` operator.
`verbose` mode of `tabnanny.verbose` asserts `stdout`.
"""
with tempfile.TemporaryDirectory() as tmp_dir:
lines = [f"{tmp_dir!r}: listing directory\n",]
file1 = TemporaryPyFile(SOURCE_CODES["error_free"], directory=tmp_dir)
file2 = TemporaryPyFile(SOURCE_CODES["error_free"], directory=tmp_dir)
with file1 as file1_path, file2 as file2_path:
for file_path in (file1_path, file2_path):
lines.append(f"{file_path!r}: Clean bill of health.\n")
tabnanny.verbose = 1
with captured_stdout() as stdout, captured_stderr() as stderr:
tabnanny.check(tmp_dir)
stdout = stdout.getvalue()
for line in lines:
with self.subTest(line=line):
self.assertIn(line, stdout)
self.assertEqual(stderr.getvalue(), "")
def test_correct_directory(self):
"""Directory which contains few error free python source code files."""
with tempfile.TemporaryDirectory() as tmp_dir:
with TemporaryPyFile(SOURCE_CODES["error_free"], directory=tmp_dir):
self.verify_tabnanny_check(tmp_dir)
def test_when_wrong_indented(self):
"""A python source code file eligible for raising `IndentationError`."""
with TemporaryPyFile(SOURCE_CODES["wrong_indented"]) as file_path:
err = ('unindent does not match any outer indentation level'
' (<tokenize>, line 3)\n')
err = f"{file_path!r}: Indentation Error: {err}"
with self.assertRaises(SystemExit):
self.verify_tabnanny_check(file_path, err=err)
def test_when_tokenize_tokenerror(self):
"""A python source code file eligible for raising 'tokenize.TokenError'."""
with TemporaryPyFile(SOURCE_CODES["incomplete_expression"]) as file_path:
err = "('EOF in multi-line statement', (7, 0))\n"
err = f"{file_path!r}: Token Error: {err}"
with self.assertRaises(SystemExit):
self.verify_tabnanny_check(file_path, err=err)
def test_when_nannynag_error_verbose(self):
"""A python source code file eligible for raising `tabnanny.NannyNag`.
Tests will assert `stdout` after activating `tabnanny.verbose` mode.
"""
with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as file_path:
out = f"{file_path!r}: *** Line 3: trouble in tab city! ***\n"
out += "offending line: '\\tprint(\"world\")'\n"
out += "inconsistent use of tabs and spaces in indentation\n"
tabnanny.verbose = 1
self.verify_tabnanny_check(file_path, out=out)
def test_when_nannynag_error(self):
"""A python source code file eligible for raising `tabnanny.NannyNag`."""
with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as file_path:
out = f"{file_path} 3 '\\tprint(\"world\")'\n"
self.verify_tabnanny_check(file_path, out=out)
def test_when_no_file(self):
"""A python file which does not exist actually in system."""
path = 'no_file.py'
err = (f"{path!r}: I/O Error: [Errno {errno.ENOENT}] "
f"{os.strerror(errno.ENOENT)}: {path!r}\n")
with self.assertRaises(SystemExit):
self.verify_tabnanny_check(path, err=err)
def test_errored_directory(self):
"""Directory containing wrongly indented python source code files."""
with tempfile.TemporaryDirectory() as tmp_dir:
error_file = TemporaryPyFile(
SOURCE_CODES["wrong_indented"], directory=tmp_dir
)
code_file = TemporaryPyFile(
SOURCE_CODES["error_free"], directory=tmp_dir
)
with error_file as e_file, code_file as c_file:
err = ('unindent does not match any outer indentation level'
' (<tokenize>, line 3)\n')
err = f"{e_file!r}: Indentation Error: {err}"
with self.assertRaises(SystemExit):
self.verify_tabnanny_check(tmp_dir, err=err)
class TestProcessTokens(TestCase):
"""Testing `tabnanny.process_tokens()`."""
@mock.patch('tabnanny.NannyNag')
def test_with_correct_code(self, MockNannyNag):
"""A python source code without any whitespace related problems."""
with TemporaryPyFile(SOURCE_CODES["error_free"]) as file_path:
with open(file_path) as f:
tabnanny.process_tokens(tokenize.generate_tokens(f.readline))
self.assertFalse(MockNannyNag.called)
def test_with_errored_codes_samples(self):
"""A python source code with whitespace related sampled problems."""
# "tab_space_errored_1": executes block under type == tokenize.INDENT
# at `tabnanny.process_tokens()`.
# "tab space_errored_2": executes block under
# `check_equal and type not in JUNK` condition at
# `tabnanny.process_tokens()`.
for key in ["tab_space_errored_1", "tab_space_errored_2"]:
with self.subTest(key=key):
with TemporaryPyFile(SOURCE_CODES[key]) as file_path:
with open(file_path) as f:
tokens = tokenize.generate_tokens(f.readline)
with self.assertRaises(tabnanny.NannyNag):
tabnanny.process_tokens(tokens)
class TestCommandLine(TestCase):
"""Tests command line interface of `tabnanny`."""
def validate_cmd(self, *args, stdout="", stderr="", partial=False, expect_failure=False):
"""Common function to assert the behaviour of command line interface."""
if expect_failure:
_, out, err = script_helper.assert_python_failure('-m', 'tabnanny', *args)
else:
_, out, err = script_helper.assert_python_ok('-m', 'tabnanny', *args)
# Note: The `splitlines()` will solve the problem of CRLF(\r) added
# by OS Windows.
out = os.fsdecode(out)
err = os.fsdecode(err)
if partial:
for std, output in ((stdout, out), (stderr, err)):
_output = output.splitlines()
for _std in std.splitlines():
with self.subTest(std=_std, output=_output):
self.assertIn(_std, _output)
else:
self.assertListEqual(out.splitlines(), stdout.splitlines())
self.assertListEqual(err.splitlines(), stderr.splitlines())
def test_with_errored_file(self):
"""Should displays error when errored python file is given."""
with TemporaryPyFile(SOURCE_CODES["wrong_indented"]) as file_path:
stderr = f"{file_path!r}: Indentation Error: "
stderr += ('unindent does not match any outer indentation level'
' (<string>, line 3)')
self.validate_cmd(file_path, stderr=stderr, expect_failure=True)
def test_with_error_free_file(self):
"""Should not display anything if python file is correctly indented."""
with TemporaryPyFile(SOURCE_CODES["error_free"]) as file_path:
self.validate_cmd(file_path)
def test_command_usage(self):
"""Should display usage on no arguments."""
path = findfile('tabnanny.py')
stderr = f"Usage: {path} [-v] file_or_directory ..."
self.validate_cmd(stderr=stderr, expect_failure=True)
def test_quiet_flag(self):
"""Should display less when quite mode is on."""
with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as file_path:
stdout = f"{file_path}\n"
self.validate_cmd("-q", file_path, stdout=stdout)
def test_verbose_mode(self):
"""Should display more error information if verbose mode is on."""
with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as path:
stdout = textwrap.dedent(
"offending line: '\\tprint(\"world\")'"
).strip()
self.validate_cmd("-v", path, stdout=stdout, partial=True)
def test_double_verbose_mode(self):
"""Should display detailed error information if double verbose is on."""
with TemporaryPyFile(SOURCE_CODES["nannynag_errored"]) as path:
stdout = textwrap.dedent(
"offending line: '\\tprint(\"world\")'"
).strip()
self.validate_cmd("-vv", path, stdout=stdout, partial=True)
|
