def test_check_prerequisites(self):
uut = linter(sys.executable)(self.ManualProcessingTestLinter)
self.assertTrue(uut.check_prerequisites())
uut = (linter("invalid_nonexisting_programv412")
(self.ManualProcessingTestLinter))
self.assertEqual(uut.check_prerequisites(),
"'invalid_nonexisting_programv412' is not installed.")
uut = (linter(sys.executable,
prerequisite_check_command=(sys.executable, "--version"))
(self.ManualProcessingTestLinter))
self.assertTrue(uut.check_prerequisites())
uut = (linter(sys.executable,
prerequisite_check_command=("invalid_programv413",))
(self.ManualProcessingTestLinter))
self.assertEqual(uut.check_prerequisites(),
"Prerequisite check failed.")
uut = (linter(sys.executable,
prerequisite_check_command=("invalid_programv413",),
prerequisite_check_fail_message="NOPE")
(self.ManualProcessingTestLinter))
self.assertEqual(uut.check_prerequisites(), "NOPE")
def test_process_output_metadata_omits_on_builtin_formats(self):
uut = (linter(executable='', output_format='corrected')
(self.EmptyTestLinter))
# diff_severity and diff_message should now not occur inside the
# metadata definition.
self.assertNotIn("diff_severity", uut.get_metadata().optional_params)
self.assertNotIn("diff_message", uut.get_metadata().optional_params)
self.assertNotIn("diff_severity",
uut.get_metadata().non_optional_params)
self.assertNotIn("diff_message",
uut.get_metadata().non_optional_params)
# But every parameter manually defined in process_output shall appear
# inside the metadata signature.
class Handler:
@staticmethod
def create_arguments(filename, file, config_file):
pass
@staticmethod
def process_output(output, filename, file, diff_severity):
pass
uut = linter(executable='')(Handler)
self.assertIn("diff_severity", uut.get_metadata().non_optional_params)
def test_process_output_unified_diff_incomplete_hunk(self):
uut = (linter(sys.executable, output_format='unified-diff')
(self.EmptyTestLinter)
(self.section, None))
original = ['void main() {',
'// This comment is missing',
'// in the unified diff',
'return 09;',
'}']
diff = ['--- a/some-file.c',
'+++ b/some-file.c',
'@@ -1,1 +1,2 @@',
'-void main() {',
'+void main()',
'+{',
'@@ -4,2 +5,2 @@',
'-return 09;',
'+ return 9;',
' }']
diff_string = '\n'.join(diff)
results = list(uut.process_output(diff_string,
'some-file.c',
original))
diffs = list(Diff.from_unified_diff(diff_string, original).split_diff())
expected = [Result.from_values(uut,
'Inconsistency found.',
'some-file.c',
1, None, 1, None,
RESULT_SEVERITY.NORMAL,
diffs={'some-file.c': diffs[0]}),
Result.from_values(uut,
'Inconsistency found.',
'some-file.c',
4, None, 4, None,
RESULT_SEVERITY.NORMAL,
diffs={'some-file.c': diffs[1]})]
self.assertEqual(results, expected)
uut = (linter(sys.executable,
output_format='unified-diff',
diff_distance=-1)
(self.EmptyTestLinter)
(self.section, None))
results = list(uut.process_output(diff_string,
'some-file.c',
original))
self.assertEqual(len(results), 2)
def test_section_settings_forwarding(self):
create_arguments_mock = Mock()
generate_config_mock = Mock()
process_output_mock = Mock()
class Handler(self.ManualProcessingTestLinter):
@staticmethod
def create_arguments(filename, file, config_file, my_param: int):
create_arguments_mock(filename, file, config_file, my_param)
# Execute python and do nothing.
return "-c", "print('coala!')"
@staticmethod
def generate_config(filename, file, my_config_param: int):
generate_config_mock(filename, file, my_config_param)
return None
def process_output(self, output, filename, file, makman2: str):
process_output_mock(output, filename, file, makman2)
self.section["my_param"] = "109"
self.section["my_config_param"] = "88"
self.section["makman2"] = "is cool"
uut = linter(sys.executable)(Handler)(self.section, None)
self.assertIsNotNone(list(uut.execute(filename="some_file.cs",
file=[])))
create_arguments_mock.assert_called_once_with(
"some_file.cs", [], None, 109)
generate_config_mock.assert_called_once_with("some_file.cs", [], 88)
process_output_mock.assert_called_once_with(
"coala!\n", "some_file.cs", [], "is cool")
def test_global_linter_bear_with_filename(self):
create_arguments_mock = Mock()
class Handler:
@staticmethod
def create_arguments(config_file):
create_arguments_mock(config_file)
return ['test.txt:MAJOR: Test Message']
output_regex = (
r'(?P<filename>\S+?):(?P<severity>\S+?): (?P<message>.*)'
)
uut = (linter('echo',
global_bear=True,
output_format='regex',
output_regex=output_regex,
severity_map=self.test_program_severity_map)
(Handler)
({}, self.section, None))
results = list(uut.run())
expected = [
Result.from_values(
uut,
'Test Message',
'test.txt',
severity=RESULT_SEVERITY.MAJOR,
)
]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(None)
def test_global_linter_bear_use_stderr(self):
create_arguments_mock = Mock()
class Handler:
@staticmethod
def create_arguments(config_file):
create_arguments_mock(config_file)
return ['MAJOR: Test Message\nasd']
uut = (linter('echo',
global_bear=True,
output_format='regex',
use_stderr=True,
output_regex=self.test_program_regex,
severity_map=self.test_program_severity_map)
(Handler)
({}, self.section, None))
results = list(uut.run())
expected = [Result(uut,
'Test Message',
severity=RESULT_SEVERITY.MAJOR)]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(None)
def test_process_output_corrected(self):
uut = (linter(sys.executable, output_format="corrected")
(self.EmptyTestLinter)
(self.section, None))
original = ["void main() {\n", "return 09;\n", "}\n"]
fixed = ["void main()\n", "{\n", "return 9;\n", "}\n"]
fixed_string = "".join(fixed)
results = list(uut.process_output(fixed_string,
"some-file.c",
original))
diffs = list(Diff.from_string_arrays(original, fixed).split_diff())
expected = [Result.from_values(uut,
"Inconsistency found.",
"some-file.c",
1, None, 2, None,
RESULT_SEVERITY.NORMAL,
diffs={"some-file.c": diffs[0]})]
self.assertEqual(results, expected)
# Test when providing a sequence as output.
results = list(uut.process_output([fixed_string, fixed_string],
"some-file.c",
original))
self.assertEqual(results, 2 * expected)
def test_stdin_stderr_config_correction(self):
create_arguments_mock = Mock()
generate_config_mock = Mock()
# `some_value_A` and `some_value_B` are used to test the different
# delegation to `generate_config()` and `create_arguments()`
# accordingly.
class Handler:
@staticmethod
def generate_config(filename, file, some_value_A):
generate_config_mock(filename, file, some_value_A)
return "\n".join(["use_stdin", "use_stderr", "correct"])
@staticmethod
def create_arguments(filename, file, config_file, some_value_B):
create_arguments_mock(filename, file, config_file,
some_value_B)
return self.test_program_path, "--config", config_file
uut = (linter(sys.executable,
use_stdin=True,
use_stdout=False,
use_stderr=True,
output_format="corrected",
config_suffix=".conf")
(Handler)
(self.section, None))
results = list(uut.run(self.testfile2_path,
self.testfile2_content,
some_value_A=124,
some_value_B=-78))
expected_correction = [s + "\n" for s in ["+", "/", "/", "-"]]
diffs = list(Diff.from_string_arrays(
self.testfile2_content,
expected_correction).split_diff())
expected = [Result.from_values(uut,
"Inconsistency found.",
self.testfile2_path,
1, None, 1, None,
RESULT_SEVERITY.NORMAL,
diffs={self.testfile2_path: diffs[0]}),
Result.from_values(uut,
"Inconsistency found.",
self.testfile2_path,
5, None, 5, None,
RESULT_SEVERITY.NORMAL,
diffs={self.testfile2_path: diffs[1]})]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(
self.testfile2_path, self.testfile2_content, ANY, -78)
self.assertEqual(create_arguments_mock.call_args[0][2][-5:], ".conf")
generate_config_mock.assert_called_once_with(
self.testfile2_path, self.testfile2_content, 124)
def test_stdout_stderr_on_linter_test_fail(self):
class TestLinter:
@staticmethod
def process_output(output, filename, file):
pass
@staticmethod
def create_arguments(filename, file, config_file):
code = '\n'.join(['import sys',
"print('hello stdout')",
"print('hello stderr', file=sys.stderr)"])
return '-c', code
# Testing with both stdout and stderr enabled
uut = (linter(sys.executable, use_stdout=True, use_stderr=True)
(TestLinter)
(Section('TEST_SECTION'), Queue()))
try:
with execute_bear(uut, 'filename', ['file']) as result:
raise AssertionError
except AssertionError as ex:
self.assertIn('Program arguments:\n'
"('-c', \"import sys\\n"
"print('hello stdout')\\n"
"print('hello stderr', file=sys.stderr)\")\n"
'The program yielded the following output:\n\n'
'Stdout:\n'
'hello stdout\n\n'
'Stderr:\n'
'hello stderr', str(ex))
# Testing with only stdout enabled
uut = (linter(sys.executable, use_stdout=True)
(TestLinter)
(Section('TEST_SECTION'), Queue()))
try:
with execute_bear(uut, 'filename', ['file']) as result:
raise AssertionError
except AssertionError as ex:
self.assertIn('Program arguments:\n'
"('-c', \"import sys\\n"
"print('hello stdout')\\n"
"print('hello stderr', file=sys.stderr)\")\n"
'The program yielded the following output:\n\n'
'hello stdout', str(ex))
def test_generate_config(self):
uut = linter("")(self.ManualProcessingTestLinter)
with uut._create_config("filename", []) as config_file:
self.assertIsNone(config_file)
class ConfigurationTestLinter(self.ManualProcessingTestLinter):
@staticmethod
def generate_config(filename, file, val):
return "config_value = " + str(val)
uut = linter("", config_suffix=".xml")(ConfigurationTestLinter)
with uut._create_config("filename", [], val=88) as config_file:
self.assertTrue(os.path.isfile(config_file))
self.assertEqual(config_file[-4:], ".xml")
with open(config_file, mode="r") as fl:
self.assertEqual(fl.read(), "config_value = 88")
self.assertFalse(os.path.isfile(config_file))
def test_repr(self):
uut = (linter(sys.executable)
(self.ManualProcessingTestLinter)
(self.section, None))
self.assertRegex(
repr(uut),
"<ManualProcessingTestLinter linter object \\(wrapping " +
re.escape(repr(sys.executable)) + "\\) at 0x[a-fA-F0-9]+>")
def test_generate_config(self):
uut = linter('')(self.ManualProcessingTestLinter)
with uut._create_config('filename', []) as config_file:
self.assertIsNone(config_file)
class ConfigurationTestLinter(self.ManualProcessingTestLinter):
@staticmethod
def generate_config(filename, file, val):
return 'config_value = ' + str(val)
uut = linter('', config_suffix='.xml')(ConfigurationTestLinter)
with uut._create_config('filename', [], val=88) as config_file:
self.assertTrue(os.path.isfile(config_file))
self.assertEqual(config_file[-4:], '.xml')
with open(config_file, mode='r') as fl:
self.assertEqual(fl.read(), 'config_value = 88')
self.assertFalse(os.path.isfile(config_file))
def test_process_directory(self):
"""
The linter shall run the process in the right directory so tools can
use the current working directory to resolve import like things.
"""
uut = (linter('cmd' if WINDOWS else 'pwd')
(self.RootDirTestLinter)
(self.section, None))
uut.run('', []) # Does an assert in the output processing
def test_process_output_regex(self):
# Also test the case when an unknown severity is matched.
test_output = ("12:4-14:0-Serious issue (error) -> ORIGIN=X\n"
"0:0-0:1-This is a warning (warning) -> ORIGIN=Y\n"
"813:77-1024:32-Just a note (info) -> ORIGIN=Z\n"
"0:0-0:0-Some unknown sev (???) -> ORIGIN=W\n")
regex = (r"(?P<line>\d+):(?P<column>\d+)-"
r"(?P<end_line>\d+):(?P<end_column>\d+)-"
r"(?P<message>.*) \((?P<severity>.*)\) -> "
r"ORIGIN=(?P<origin>.*)")
uut = (linter(sys.executable,
output_format="regex",
output_regex=regex)
(self.EmptyTestLinter)
(self.section, None))
uut.warn = Mock()
sample_file = "some-file.xtx"
results = list(uut.process_output(test_output, sample_file, [""]))
expected = [Result.from_values("EmptyTestLinter (X)",
"Serious issue",
sample_file,
12, 4, 14, 0,
RESULT_SEVERITY.MAJOR),
Result.from_values("EmptyTestLinter (Y)",
"This is a warning",
sample_file,
0, 0, 0, 1,
RESULT_SEVERITY.NORMAL),
Result.from_values("EmptyTestLinter (Z)",
"Just a note",
sample_file,
813, 77, 1024, 32,
RESULT_SEVERITY.INFO),
Result.from_values("EmptyTestLinter (W)",
"Some unknown sev",
sample_file,
0, 0, 0, 0,
RESULT_SEVERITY.NORMAL)]
self.assertEqual(results, expected)
uut.warn.assert_called_once_with(
"'???' not found in severity-map. Assuming "
"`RESULT_SEVERITY.NORMAL`.")
# Test when providing a sequence as output.
test_output = ["", "12:4-14:0-Serious issue (error) -> ORIGIN=X\n"]
results = list(uut.process_output(test_output, sample_file, [""]))
expected = [Result.from_values("EmptyTestLinter (X)",
"Serious issue",
sample_file,
12, 4, 14, 0,
RESULT_SEVERITY.MAJOR)]
self.assertEqual(results, expected)
def test_process_output_corrected(self):
uut = (linter(sys.executable, output_format='corrected')
(self.EmptyTestLinter)
(self.section, None))
original = ['void main() {\n', 'return 09;\n', '}\n']
fixed = ['void main()\n', '{\n', 'return 9;\n', '}\n']
fixed_string = ''.join(fixed)
results = list(uut.process_output(fixed_string,
'some-file.c',
original))
diffs = list(Diff.from_string_arrays(original, fixed).split_diff())
expected = [Result.from_values(uut,
'Inconsistency found.',
'some-file.c',
1, None, 2, None,
RESULT_SEVERITY.NORMAL,
diffs={'some-file.c': diffs[0]})]
self.assertEqual(results, expected)
# Test when providing a sequence as output.
results = list(uut.process_output([fixed_string, fixed_string],
'some-file.c',
original))
self.assertEqual(results, 2 * expected)
# Test diff_distance
uut = (linter(sys.executable,
output_format='corrected',
diff_distance=-1)
(self.EmptyTestLinter)
(self.section, None))
results = list(uut.process_output(fixed_string,
'some-file.c',
original))
self.assertEqual(len(results), 2)
def test_metaclass_repr(self):
uut = linter("my-tool")(self.ManualProcessingTestLinter)
self.assertEqual(
repr(uut),
"<ManualProcessingTestLinter linter class (wrapping 'my-tool')>")
# Test also whether derivatives change the class name accordingly.
class DerivedLinter(uut):
pass
self.assertEqual(repr(DerivedLinter),
"<DerivedLinter linter class (wrapping 'my-tool')>")
def test_invalid_arguments(self):
class InvalidArgumentsLinter(self.ManualProcessingTestLinter):
@staticmethod
def create_arguments(filename, file, config_file):
return None
uut = (linter(sys.executable)(InvalidArgumentsLinter)
(self.section, None))
self.assertEqual(uut.run("", []), None)
def test_check_prerequisites(self):
uut = linter(sys.executable)(self.ManualProcessingTestLinter)
self.assertTrue(uut.check_prerequisites())
uut = (linter('invalid_nonexisting_programv412')
(self.ManualProcessingTestLinter))
self.assertEqual(uut.check_prerequisites(),
"'invalid_nonexisting_programv412' is not installed.")
uut = (linter('invalid_nonexisting_programv412',
executable_check_fail_info="You can't install it.")
(self.ManualProcessingTestLinter))
self.assertEqual(uut.check_prerequisites(),
"'invalid_nonexisting_programv412' is not installed. "
"You can't install it.")
uut = (linter(sys.executable,
prerequisite_check_command=(sys.executable, '--version'))
(self.ManualProcessingTestLinter))
self.assertTrue(uut.check_prerequisites())
uut = (linter(sys.executable,
prerequisite_check_command=('invalid_programv413',))
(self.ManualProcessingTestLinter))
self.assertEqual(uut.check_prerequisites(),
'Prerequisite check failed.')
uut = (linter(sys.executable,
prerequisite_check_command=('invalid_programv413',),
prerequisite_check_fail_message='NOPE')
(self.ManualProcessingTestLinter))
self.assertEqual(uut.check_prerequisites(), 'NOPE')
def test_output_stream(self):
process_output_mock = Mock()
class TestLinter:
@staticmethod
def process_output(output, filename, file):
process_output_mock(output, filename, file)
@staticmethod
def create_arguments(filename, file, config_file):
code = "\n".join(["import sys",
"print('hello stdout')",
"print('hello stderr', file=sys.stderr)"])
return "-c", code
uut = (linter(sys.executable, use_stdout=True)
(TestLinter)
(self.section, None))
uut.run("", [])
process_output_mock.assert_called_once_with("hello stdout\n", "", [])
process_output_mock.reset_mock()
uut = (linter(sys.executable, use_stdout=False, use_stderr=True)
(TestLinter)
(self.section, None))
uut.run("", [])
process_output_mock.assert_called_once_with("hello stderr\n", "", [])
process_output_mock.reset_mock()
uut = (linter(sys.executable, use_stdout=True, use_stderr=True)
(TestLinter)
(self.section, None))
uut.run("", [])
process_output_mock.assert_called_once_with(("hello stdout\n",
"hello stderr\n"), "", [])
def test_stdin_stdout_stderr_config_nocorrection(self):
create_arguments_mock = Mock()
generate_config_mock = Mock()
class Handler:
@staticmethod
def generate_config(filename, file, some_val):
# some_val shall only test the argument delegation from run().
generate_config_mock(filename, file, some_val)
return '\n'.join(['use_stdin', 'use_stderr'])
@staticmethod
def create_arguments(filename, file, config_file, some_val):
create_arguments_mock(filename, file, config_file, some_val)
return self.test_program_path, '--config', config_file
uut = (linter(sys.executable,
use_stdin=True,
use_stderr=True,
output_format='regex',
output_regex=self.test_program_regex,
severity_map=self.test_program_severity_map,
result_message='Invalid char provided!')
(Handler)
(self.section, None))
results = list(uut.run(self.testfile_path,
self.testfile_content,
some_val=33))
expected = [Result.from_values(uut,
'Invalid char provided!',
self.testfile_path,
3, 0, 3, 1,
RESULT_SEVERITY.MAJOR),
Result.from_values(uut,
'Invalid char provided!',
self.testfile_path,
5, 0, 5, 1,
RESULT_SEVERITY.MAJOR),
Result.from_values(uut,
'Invalid char provided!',
self.testfile_path,
9, 0, 9, 1,
RESULT_SEVERITY.MAJOR)]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(
self.testfile_path, self.testfile_content, ANY, 33)
self.assertIsNotNone(create_arguments_mock.call_args[0][2])
generate_config_mock.assert_called_once_with(
self.testfile_path, self.testfile_content, 33)
def test_minimal_regex(self):
uut = (linter(sys.executable,
output_format='regex',
output_regex='an_issue')
(self.EmptyTestLinter)
(self.section, None))
results = list(uut.process_output(['not an issue'], 'file', ['']))
self.assertEqual(results, [])
results = list(uut.process_output(['an_issue'], 'file', ['']))
self.assertEqual(results, [Result.from_values('EmptyTestLinter', '',
file='file')])
def test_minimal_regex(self):
uut = (linter(sys.executable,
output_format="regex",
output_regex="an_issue")
(self.EmptyTestLinter)
(self.section, None))
results = list(uut.process_output(['not an issue'], 'file', [""]))
self.assertEqual(results, [])
results = list(uut.process_output(['an_issue'], 'file', [""]))
self.assertEqual(results, [Result.from_values("EmptyTestLinter", "",
file="file")])
def test_create_arguments_not_implemented(self):
class Handler:
pass
uut = (linter('echo',
global_bear=True,
output_format='regex',
output_regex=self.test_program_regex,
severity_map=self.test_program_severity_map)
(Handler)
({}, self.section, None))
with self.assertRaises(NotImplementedError):
list(uut.run())
def test_nostdin_nostderr_noconfig_correction(self):
create_arguments_mock = Mock()
class Handler:
@staticmethod
def create_arguments(filename, file, config_file):
create_arguments_mock(filename, file, config_file)
return self.test_program_path, "--correct", filename
uut = (linter(sys.executable,
output_format="corrected",
diff_severity=RESULT_SEVERITY.INFO,
diff_message="Custom message")
(Handler)
(self.section, None))
results = list(uut.run(self.testfile_path, self.testfile_content))
expected_correction = [s + "\n"
for s in ["+", "-", "*", "++", "-", "-", "+"]]
diffs = list(Diff.from_string_arrays(
self.testfile_content,
expected_correction).split_diff())
expected = [Result.from_values(uut,
"Custom message",
self.testfile_path,
4, None, 4, None,
RESULT_SEVERITY.INFO,
diffs={self.testfile_path: diffs[0]}),
Result.from_values(uut,
"Custom message",
self.testfile_path,
6, None, 6, None,
RESULT_SEVERITY.INFO,
diffs={self.testfile_path: diffs[1]}),
Result.from_values(uut,
"Custom message",
self.testfile_path,
10, None, 10, None,
RESULT_SEVERITY.INFO,
diffs={self.testfile_path: diffs[2]})]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(
self.testfile_path, self.testfile_content, None)
def test_process_output_regex(self):
# Also test the case when an unknown severity is matched.
test_output = ("12:4-14:0-Serious issue (error) -> ORIGIN=X\n"
"0:0-0:1-This is a warning (warning) -> ORIGIN=Y\n"
"813:77-1024:32-Just a note (info) -> ORIGIN=Z\n"
"0:0-0:0-Some unknown sev (???) -> ORIGIN=W\n")
regex = (r"(?P<line>\d+):(?P<column>\d+)-"
r"(?P<end_line>\d+):(?P<end_column>\d+)-"
r"(?P<message>.*) \((?P<severity>.*)\) -> "
r"ORIGIN=(?P<origin>.*)")
uut = (linter(sys.executable,
output_format="regex",
output_regex=regex)(self.EmptyTestLinter)(self.section,
None))
uut.warn = Mock()
sample_file = "some-file.xtx"
results = list(uut.process_output(test_output, sample_file, [""]))
expected = [
Result.from_values("EmptyTestLinter (X)", "Serious issue",
sample_file, 12, 4, 14, 0,
RESULT_SEVERITY.MAJOR),
Result.from_values("EmptyTestLinter (Y)", "This is a warning",
sample_file, 0, 0, 0, 1,
RESULT_SEVERITY.NORMAL),
Result.from_values("EmptyTestLinter (Z)", "Just a note",
sample_file, 813, 77, 1024, 32,
RESULT_SEVERITY.INFO),
Result.from_values("EmptyTestLinter (W)", "Some unknown sev",
sample_file, 0, 0, 0, 0, RESULT_SEVERITY.NORMAL)
]
self.assertEqual(results, expected)
uut.warn.assert_called_once_with(
"'???' not found in severity-map. Assuming "
"`RESULT_SEVERITY.NORMAL`.")
# Test when providing a sequence as output.
test_output = ["", "12:4-14:0-Serious issue (error) -> ORIGIN=X\n"]
results = list(uut.process_output(test_output, sample_file, [""]))
expected = [
Result.from_values("EmptyTestLinter (X)", "Serious issue",
sample_file, 12, 4, 14, 0,
RESULT_SEVERITY.MAJOR)
]
self.assertEqual(results, expected)
def test_nostdin_nostderr_noconfig_correction(self):
create_arguments_mock = Mock()
class Handler:
@staticmethod
def create_arguments(filename, file, config_file):
create_arguments_mock(filename, file, config_file)
return self.test_program_path, '--correct', filename
uut = (linter(sys.executable,
output_format='corrected',
diff_severity=RESULT_SEVERITY.INFO,
result_message='Custom message')(Handler)(self.section,
None))
results = list(uut.run(self.testfile_path, self.testfile_content))
expected_correction = [
s + '\n' for s in ['+', '-', '*', '++', '-', '-', '+']
]
diffs = list(
Diff.from_string_arrays(self.testfile_content,
expected_correction).split_diff())
expected = [
Result(uut,
'Custom message',
affected_code=(SourceRange.from_values(
self.testfile_path,
4), SourceRange.from_values(self.testfile_path, 6)),
severity=RESULT_SEVERITY.INFO,
diffs={self.testfile_path: diffs[0]}),
Result.from_values(uut,
'Custom message',
self.testfile_path,
10,
None,
10,
None,
RESULT_SEVERITY.INFO,
diffs={self.testfile_path: diffs[1]})
]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(self.testfile_path,
self.testfile_content,
None)
def test_stdin_stdout_stderr_config_nocorrection(self):
create_arguments_mock = Mock()
generate_config_mock = Mock()
class Handler:
@staticmethod
def generate_config(filename, file, some_val):
# some_val shall only test the argument delegation from run().
generate_config_mock(filename, file, some_val)
return '\n'.join(['use_stdin', 'use_stderr'])
@staticmethod
def create_arguments(filename, file, config_file, some_val):
create_arguments_mock(filename, file, config_file, some_val)
return self.test_program_path, '--config', config_file
uut = (linter(sys.executable,
use_stdin=True,
use_stderr=True,
output_format='regex',
output_regex=self.test_program_regex,
severity_map=self.test_program_severity_map,
result_message='Invalid char provided!')(Handler)(
self.section, None))
results = list(
uut.run(self.testfile_path, self.testfile_content, some_val=33))
expected = [
Result.from_values(uut, 'Invalid char provided!',
self.testfile_path, 3, 0, 3, 1,
RESULT_SEVERITY.MAJOR),
Result.from_values(uut, 'Invalid char provided!',
self.testfile_path, 5, 0, 5, 1,
RESULT_SEVERITY.MAJOR),
Result.from_values(uut, 'Invalid char provided!',
self.testfile_path, 9, 0, 9, 1,
RESULT_SEVERITY.MAJOR)
]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(self.testfile_path,
self.testfile_content,
ANY, 33)
self.assertIsNotNone(create_arguments_mock.call_args[0][2])
generate_config_mock.assert_called_once_with(self.testfile_path,
self.testfile_content, 33)
def test_create_arguments_not_iterable(self):
class Handler:
@staticmethod
def create_arguments(config_file):
return None
uut = (linter('echo',
global_bear=True,
output_format='regex',
output_regex=self.test_program_regex,
severity_map=self.test_program_severity_map)
(Handler)
({}, self.section, None))
with self.assertRaises(TypeError):
list(uut.run())
def test_get_non_optional_settings(self):
class Handler(self.ManualProcessingTestLinter):
@staticmethod
def create_arguments(filename, file, config_file, param_x: int):
pass
@staticmethod
def generate_config(filename, file, superparam):
"""
:param superparam: A superparam!
"""
return None
uut = linter(sys.executable)(Handler)
self.assertEqual(uut.get_non_optional_settings(),
{"param_x": ("No description given.", int),
"superparam": ("A superparam!", None)})
def test_get_non_optional_settings(self):
class Handler(self.ManualProcessingTestLinter):
@staticmethod
def create_arguments(filename, file, config_file, param_x: int):
pass
@staticmethod
def generate_config(filename, file, superparam):
"""
:param superparam: A superparam!
"""
return None
uut = linter(sys.executable)(Handler)
self.assertEqual(uut.get_non_optional_settings(),
{"param_x": ("No description given.", int),
"superparam": ("A superparam!", None)})
def test_section_settings_defaults_forwarding(self):
create_arguments_mock = Mock()
generate_config_mock = Mock()
process_output_mock = Mock()
class Handler:
@staticmethod
def generate_config(filename, file, some_default: str = "x"):
generate_config_mock(filename, file, some_default)
return None
@staticmethod
def create_arguments(filename,
file,
config_file,
default: int = 3):
create_arguments_mock(filename, file, config_file, default)
return "-c", "print('hello')"
@staticmethod
def process_output(output, filename, file, xxx: int = 64):
process_output_mock(output, filename, file, xxx)
uut = linter(sys.executable)(Handler)(self.section, None)
self.assertIsNotNone(list(uut.execute(filename="abc.py", file=[])))
create_arguments_mock.assert_called_once_with("abc.py", [], None, 3)
generate_config_mock.assert_called_once_with("abc.py", [], "x")
process_output_mock.assert_called_once_with("hello\n", "abc.py", [],
64)
create_arguments_mock.reset_mock()
generate_config_mock.reset_mock()
process_output_mock.reset_mock()
self.section["default"] = "1000"
self.section["some_default"] = "xyz"
self.section["xxx"] = "-50"
self.assertIsNotNone(list(uut.execute(filename="def.py", file=[])))
create_arguments_mock.assert_called_once_with("def.py", [], None, 1000)
generate_config_mock.assert_called_once_with("def.py", [], "xyz")
process_output_mock.assert_called_once_with("hello\n", "def.py", [],
-50)
def test_section_settings_defaults_forwarding(self):
create_arguments_mock = Mock()
generate_config_mock = Mock()
process_output_mock = Mock()
class Handler:
@staticmethod
def generate_config(filename, file, some_default: str = 'x'):
generate_config_mock(filename, file, some_default)
return None
@staticmethod
def create_arguments(filename,
file,
config_file,
default: int = 3):
create_arguments_mock(filename, file, config_file, default)
return '-c', "print('hello')"
@staticmethod
def process_output(output, filename, file, xxx: int = 64):
process_output_mock(output, filename, file, xxx)
uut = linter(sys.executable)(Handler)(self.section, None)
self.assertIsNotNone(list(uut.execute(filename='abc.py', file=[])))
create_arguments_mock.assert_called_once_with('abc.py', [], None, 3)
generate_config_mock.assert_called_once_with('abc.py', [], 'x')
process_output_mock.assert_called_once_with('hello\n', 'abc.py', [],
64)
create_arguments_mock.reset_mock()
generate_config_mock.reset_mock()
process_output_mock.reset_mock()
self.section['default'] = '1000'
self.section['some_default'] = 'xyz'
self.section['xxx'] = '-50'
self.assertIsNotNone(list(uut.execute(filename='def.py', file=[])))
create_arguments_mock.assert_called_once_with('def.py', [], None, 1000)
generate_config_mock.assert_called_once_with('def.py', [], 'xyz')
process_output_mock.assert_called_once_with('hello\n', 'def.py', [],
-50)
def test_nostdin_nostderr_noconfig_correction(self):
create_arguments_mock = Mock()
class Handler:
@staticmethod
def create_arguments(filename, file, config_file):
create_arguments_mock(filename, file, config_file)
return self.test_program_path, '--correct', filename
uut = (linter(sys.executable,
output_format='corrected',
diff_severity=RESULT_SEVERITY.INFO,
result_message='Custom message')
(Handler)
(self.section, None))
results = list(uut.run(self.testfile_path, self.testfile_content))
expected_correction = [s + '\n'
for s in ['+', '-', '*', '++', '-', '-', '+']]
diffs = list(Diff.from_string_arrays(
self.testfile_content,
expected_correction).split_diff())
expected = [Result(uut, 'Custom message',
affected_code=(
SourceRange.from_values(self.testfile_path, 4),
SourceRange.from_values(self.testfile_path, 6)),
severity=RESULT_SEVERITY.INFO,
diffs={self.testfile_path: diffs[0]}),
Result.from_values(uut,
'Custom message',
self.testfile_path,
10, None, 10, None,
RESULT_SEVERITY.INFO,
diffs={self.testfile_path: diffs[1]})]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(
self.testfile_path, self.testfile_content, None)
def test_section_settings_defaults_forwarding(self):
create_arguments_mock = Mock()
generate_config_mock = Mock()
process_output_mock = Mock()
class Handler:
@staticmethod
def generate_config(filename, file, some_default: str="x"):
generate_config_mock(filename, file, some_default)
return None
@staticmethod
def create_arguments(filename, file, config_file, default: int=3):
create_arguments_mock(
filename, file, config_file, default)
return "-c", "print('hello')"
@staticmethod
def process_output(output, filename, file, xxx: int=64):
process_output_mock(output, filename, file, xxx)
uut = linter(sys.executable)(Handler)(self.section, None)
self.assertIsNotNone(list(uut.execute(filename="abc.py", file=[])))
create_arguments_mock.assert_called_once_with("abc.py", [], None, 3)
generate_config_mock.assert_called_once_with("abc.py", [], "x")
process_output_mock.assert_called_once_with(
"hello\n", "abc.py", [], 64)
create_arguments_mock.reset_mock()
generate_config_mock.reset_mock()
process_output_mock.reset_mock()
self.section["default"] = "1000"
self.section["some_default"] = "xyz"
self.section["xxx"] = "-50"
self.assertIsNotNone(list(uut.execute(filename="def.py", file=[])))
create_arguments_mock.assert_called_once_with("def.py", [], None, 1000)
generate_config_mock.assert_called_once_with("def.py", [], "xyz")
process_output_mock.assert_called_once_with(
"hello\n", "def.py", [], -50)
def test_section_settings_defaults_forwarding(self):
create_arguments_mock = Mock()
generate_config_mock = Mock()
process_output_mock = Mock()
class Handler:
@staticmethod
def generate_config(filename, file, some_default: str='x'):
generate_config_mock(filename, file, some_default)
return None
@staticmethod
def create_arguments(filename, file, config_file, default: int=3):
create_arguments_mock(
filename, file, config_file, default)
return '-c', "print('hello')"
@staticmethod
def process_output(output, filename, file, xxx: int=64):
process_output_mock(output, filename, file, xxx)
uut = linter(sys.executable)(Handler)(self.section, None)
self.assertIsNotNone(list(uut.execute(filename='abc.py', file=[])))
create_arguments_mock.assert_called_once_with('abc.py', [], None, 3)
generate_config_mock.assert_called_once_with('abc.py', [], 'x')
process_output_mock.assert_called_once_with(
'hello\n', 'abc.py', [], 64)
create_arguments_mock.reset_mock()
generate_config_mock.reset_mock()
process_output_mock.reset_mock()
self.section['default'] = '1000'
self.section['some_default'] = 'xyz'
self.section['xxx'] = '-50'
self.assertIsNotNone(list(uut.execute(filename='def.py', file=[])))
create_arguments_mock.assert_called_once_with('def.py', [], None, 1000)
generate_config_mock.assert_called_once_with('def.py', [], 'xyz')
process_output_mock.assert_called_once_with(
'hello\n', 'def.py', [], -50)
def test_stdin_stderr_noconfig_nocorrection(self):
create_arguments_mock = Mock()
class Handler:
@staticmethod
def create_arguments(filename, file, config_file):
create_arguments_mock(filename, file, config_file)
return (self.test_program_path,
"--use_stderr",
"--use_stdin",
filename)
uut = (linter(sys.executable,
use_stdin=True,
use_stdout=False,
use_stderr=True,
output_format="regex",
output_regex=self.test_program_regex,
severity_map=self.test_program_severity_map)
(Handler)
(self.section, None))
results = list(uut.run(self.testfile2_path, self.testfile2_content))
expected = [Result.from_values(uut,
"Invalid char ('X')",
self.testfile2_path,
0, 0, 0, 1,
RESULT_SEVERITY.MAJOR),
Result.from_values(uut,
"Invalid char ('i')",
self.testfile2_path,
4, 0, 4, 1,
RESULT_SEVERITY.MAJOR)]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(
self.testfile2_path, self.testfile2_content, None)
def test_stdin_stderr_noconfig_nocorrection(self):
create_arguments_mock = Mock()
class Handler:
@staticmethod
def create_arguments(filename, file, config_file):
create_arguments_mock(filename, file, config_file)
return (self.test_program_path,
"--use_stderr",
"--use_stdin",
filename)
uut = (linter(sys.executable,
use_stdin=True,
use_stdout=False,
use_stderr=True,
output_format="regex",
output_regex=self.test_program_regex,
severity_map=self.test_program_severity_map)
(Handler)
(self.section, None))
results = list(uut.run(self.testfile2_path, self.testfile2_content))
expected = [Result.from_values(uut,
"Invalid char ('X')",
self.testfile2_path,
0, 0, 0, 1,
RESULT_SEVERITY.MAJOR),
Result.from_values(uut,
"Invalid char ('i')",
self.testfile2_path,
4, 0, 4, 1,
RESULT_SEVERITY.MAJOR)]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(
self.testfile2_path, self.testfile2_content, None)
def test_nostdin_nostderr_noconfig_nocorrection(self):
create_arguments_mock = Mock()
class Handler:
@staticmethod
def create_arguments(filename, file, config_file):
create_arguments_mock(filename, file, config_file)
return self.test_program_path, filename
uut = (linter(sys.executable,
output_format="regex",
output_regex=self.test_program_regex,
severity_map=self.test_program_severity_map)
(Handler)
(self.section, None))
results = list(uut.run(self.testfile_path, self.testfile_content))
expected = [Result.from_values(uut,
"Invalid char ('0')",
self.testfile_path,
3, 0, 3, 1,
RESULT_SEVERITY.MAJOR),
Result.from_values(uut,
"Invalid char ('.')",
self.testfile_path,
5, 0, 5, 1,
RESULT_SEVERITY.MAJOR),
Result.from_values(uut,
"Invalid char ('p')",
self.testfile_path,
9, 0, 9, 1,
RESULT_SEVERITY.MAJOR)]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(
self.testfile_path, self.testfile_content, None)
def test_global_linter_bear_use_stderr(self):
create_arguments_mock = Mock()
class Handler:
@staticmethod
def create_arguments(config_file):
create_arguments_mock(config_file)
return ['MAJOR: Test Message\nasd']
uut = (linter('echo',
global_bear=True,
output_format='regex',
use_stderr=True,
output_regex=self.test_program_regex,
severity_map=self.test_program_severity_map)(Handler)(
{}, self.section, None))
results = list(uut.run())
expected = [
Result(uut, 'Test Message', severity=RESULT_SEVERITY.MAJOR)
]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(None)
def test_decorator_generated_default_interface(self):
uut = linter("some-executable")(self.ManualProcessingTestLinter)
with self.assertRaises(NotImplementedError):
uut.create_arguments("filename", "content", None)
def test_decorator_invalid_states(self):
with self.assertRaises(ValueError) as cm:
linter("some-executable", use_stdout=False, use_stderr=False)
self.assertEqual(str(cm.exception),
"No output streams provided at all.")
with self.assertRaises(ValueError) as cm:
linter("some-executable", output_format="INVALID")
self.assertEqual(str(cm.exception),
"Invalid `output_format` specified.")
with self.assertRaises(ValueError) as cm:
linter("some-executable", output_format="regex")
self.assertEqual(
str(cm.exception),
"`output_regex` needed when specified output-format 'regex'.")
with self.assertRaises(ValueError) as cm:
linter("some-executable",
output_format="regex",
output_regex="",
severity_map={})
self.assertEqual(
str(cm.exception),
"Provided `severity_map` but named group `severity` is not used "
"in `output_regex`.")
with self.assertRaises(ValueError) as cm:
linter("some-executable")(object)
self.assertEqual(
str(cm.exception),
"`process_output` not provided by given class 'object'.")
with self.assertRaises(ValueError) as cm:
(linter("some-executable", output_format="regex", output_regex="")
(self.ManualProcessingTestLinter))
self.assertEqual(
str(cm.exception),
"Found `process_output` already defined by class "
"'ManualProcessingTestLinter', but 'regex' output-format is "
"specified.")
def test_decorator_invalid_parameters(self):
with self.assertRaisesRegex(
ValueError, 'Invalid keyword arguments provided: '
"'ABC', 'invalid_arg'"):
linter('some-executable', invalid_arg=88,
ABC=2000)(self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, 'Invalid keyword arguments provided: '
"'diff_severity'"):
linter('some-executable',
diff_severity=RESULT_SEVERITY.MAJOR)(self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, 'Invalid keyword arguments provided: '
"'result_message'"):
linter('some-executable',
result_message='Custom message')(self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, 'Invalid keyword arguments provided: '
"'output_regex'"):
linter('some-executable',
output_format='corrected',
output_regex='.*')(self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, 'Invalid keyword arguments provided: '
"'severity_map'"):
linter('some-executable',
output_format='corrected',
severity_map={})(self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, 'Invalid keyword arguments provided: '
"'output_regex'"):
linter('some-executable',
output_format='unified-diff',
output_regex='.*')(self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, 'Invalid keyword arguments provided: '
"'severity_map'"):
linter('some-executable',
output_format='unified-diff',
severity_map={})(self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, 'Invalid keyword arguments provided: '
"'prerequisite_check_fail_message'"):
linter('some-executable',
prerequisite_check_fail_message='some_message')(
self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, 'Incompatible arguments provided:'
"'use_stdin' and 'global_bear' can't both"
' be True.'):
linter('some-executable', global_bear=True,
use_stdin=True)(self.EmptyTestLinter)
def test_process_output_regex(self):
# Also test the case when an unknown severity is matched.
test_output = ('12:4-14:0-Serious issue (error) -> ORIGIN=X -> D\n'
'0:0-0:1-This is a warning (warning) -> ORIGIN=Y -> A\n'
'813:77-1024:32-Just a note (info) -> ORIGIN=Z -> C\n'
'0:0-0:0-Some unknown sev (???) -> ORIGIN=W -> B\n')
regex = (r'(?P<line>\d+):(?P<column>\d+)-'
r'(?P<end_line>\d+):(?P<end_column>\d+)-'
r'(?P<message>.*) \((?P<severity>.*)\) -> '
r'ORIGIN=(?P<origin>.*) -> (?P<additional_info>.*)')
uut = (linter(sys.executable,
output_format='regex',
output_regex=regex)(self.EmptyTestLinter)(self.section,
None))
uut.warn = Mock()
sample_file = 'some-file.xtx'
results = list(uut.process_output(test_output, sample_file, ['']))
expected = [
Result.from_values('EmptyTestLinter (X)',
'Serious issue',
sample_file,
12,
4,
14,
0,
RESULT_SEVERITY.MAJOR,
additional_info='D'),
Result.from_values('EmptyTestLinter (Y)',
'This is a warning',
sample_file,
0,
0,
0,
1,
RESULT_SEVERITY.NORMAL,
additional_info='A'),
Result.from_values('EmptyTestLinter (Z)',
'Just a note',
sample_file,
813,
77,
1024,
32,
RESULT_SEVERITY.INFO,
additional_info='C'),
Result.from_values('EmptyTestLinter (W)',
'Some unknown sev',
sample_file,
0,
0,
0,
0,
RESULT_SEVERITY.NORMAL,
additional_info='B')
]
self.assertEqual(results, expected)
uut.warn.assert_called_once_with(
"'???' not found in severity-map. Assuming "
'`RESULT_SEVERITY.NORMAL`.')
# Test when providing a sequence as output.
test_output = [
'', '12:4-14:0-Serious issue (error) -> ORIGIN=X -> XYZ\n'
]
results = list(uut.process_output(test_output, sample_file, ['']))
expected = [
Result.from_values('EmptyTestLinter (X)',
'Serious issue',
sample_file,
12,
4,
14,
0,
RESULT_SEVERITY.MAJOR,
additional_info='XYZ')
]
self.assertEqual(results, expected)
# Test with using `result_message` parameter.
uut = (linter(sys.executable,
output_format='regex',
output_regex=regex,
result_message='Hello world')(self.EmptyTestLinter)(
self.section, None))
results = list(uut.process_output(test_output, sample_file, ['']))
expected = [
Result.from_values('EmptyTestLinter (X)',
'Hello world',
sample_file,
12,
4,
14,
0,
RESULT_SEVERITY.MAJOR,
additional_info='XYZ')
]
self.assertEqual(results, expected)
def test_get_executable(self):
uut = linter('some-executable')(self.ManualProcessingTestLinter)
self.assertEqual(uut.get_executable(), 'some-executable')
def test_decorator_invalid_parameter_types(self):
# Provide some invalid severity maps.
with self.assertRaisesRegex(TypeError, self.PARAM_TYPE_ERROR_RE):
linter('some-executable',
output_format='regex',
output_regex='(?P<severity>)',
severity_map=list())(self.EmptyTestLinter)
with self.assertRaisesRegex(TypeError, self.PARAM_TYPE_ERROR_RE):
linter('some-executable',
output_format='regex',
output_regex='(?P<severity>)',
severity_map={3: 0})(self.EmptyTestLinter)
with self.assertRaisesRegex(
TypeError, "The value 'invalid' for key 'critical' "
'inside given severity-map is no valid '
'severity value.'):
linter('some-executable',
output_format='regex',
output_regex='(?P<severity>)',
severity_map={'critical': 'invalid'})(self.EmptyTestLinter)
with self.assertRaisesRegex(
TypeError, 'Invalid severity value 389274234 for key '
'\'critical-error\' inside given severity-'
'map.'):
linter('some-executable',
output_format='regex',
output_regex='(?P<severity>)',
severity_map={'critical-error':
389274234})(self.EmptyTestLinter)
# Other type-error test cases.
with self.assertRaisesRegex(TypeError, self.PARAM_TYPE_ERROR_RE):
linter('some-executable',
output_format='regex',
output_regex='(?P<message>)',
result_message=None)(self.EmptyTestLinter)
with self.assertRaisesRegex(TypeError, self.PARAM_TYPE_ERROR_RE):
linter('some-executable',
output_format='corrected',
result_message=list())(self.EmptyTestLinter)
with self.assertRaisesRegex(
TypeError, 'Invalid value for `diff_severity`: '
'999888777'):
linter('some-executable',
output_format='corrected',
diff_severity=999888777)(self.EmptyTestLinter)
with self.assertRaisesRegex(TypeError, self.PARAM_TYPE_ERROR_RE):
linter('some-executable',
output_format='unified-diff',
result_message=list())(self.EmptyTestLinter)
with self.assertRaises(TypeError) as cm:
linter('some-executable',
output_format='unified-diff',
diff_severity=123456789)(self.EmptyTestLinter)
self.assertEqual(str(cm.exception),
'Invalid value for `diff_severity`: 123456789')
with self.assertRaisesRegex(TypeError, self.PARAM_TYPE_ERROR_RE):
linter('some-executable',
prerequisite_check_command=('command', ),
prerequisite_check_fail_message=382983)(
self.EmptyTestLinter)
def test_decorator_generated_default_interface(self):
uut = linter('some-executable')(self.ManualProcessingTestLinter)
with self.assertRaisesRegex(NotImplementedError, ''):
uut.create_arguments('filename', 'content', None)
def test_decorator_invalid_states(self):
with self.assertRaisesRegex(ValueError,
'No output streams provided at all.'):
linter('some-executable', use_stdout=False,
use_stderr=False)(self.EmptyTestLinter)
with self.assertRaisesRegex(ValueError,
'Invalid `output_format` specified.'):
linter('some-executable',
output_format='INVALID')(self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, '`output_regex` needed when specified'
" output-format 'regex'."):
linter('some-executable',
output_format='regex')(self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, 'Provided `severity_map` but named group '
'`severity` is not used '
'in `output_regex`.'):
linter('some-executable',
output_format='regex',
output_regex='',
severity_map={})(self.EmptyTestLinter)
with self.assertRaisesRegex(
ValueError, '`process_output` not provided by given '
"class 'object'."):
linter('some-executable')(object)
with self.assertRaisesRegex(
ValueError, 'Found `process_output` already defined '
"by class 'ManualProcessingTestLinter', "
"but 'regex' output-format is "
'specified.'):
(linter('some-executable', output_format='regex',
output_regex='')(self.ManualProcessingTestLinter))
def test_decorator_invalid_parameter_types(self):
# Provide some invalid severity maps.
with self.assertRaises(TypeError):
linter('some-executable',
output_format='regex',
output_regex='(?P<severity>)',
severity_map=list())
with self.assertRaises(TypeError):
linter('some-executable',
output_format='regex',
output_regex='(?P<severity>)',
severity_map={3: 0})
with self.assertRaises(TypeError) as cm:
linter('some-executable',
output_format='regex',
output_regex='(?P<severity>)',
severity_map={'critical': 'invalid'})
self.assertEqual(
str(cm.exception),
"The value 'invalid' for key 'critical' inside given "
'severity-map is no valid severity value.')
with self.assertRaises(TypeError) as cm:
linter('some-executable',
output_format='regex',
output_regex='(?P<severity>)',
severity_map={'critical-error': 389274234})
self.assertEqual(
str(cm.exception), 'Invalid severity value 389274234 for key '
"'critical-error' inside given severity-map.")
# Other type-error test cases.
with self.assertRaises(TypeError):
linter('some-executable',
output_format='regex',
output_regex='(?P<message>)',
result_message=None)
with self.assertRaises(TypeError):
linter('some-executable',
output_format='corrected',
result_message=list())
with self.assertRaises(TypeError) as cm:
linter('some-executable',
output_format='corrected',
diff_severity=999888777)
self.assertEqual(str(cm.exception),
'Invalid value for `diff_severity`: 999888777')
with self.assertRaises(TypeError):
linter('some-executable',
prerequisite_check_command=('command', ),
prerequisite_check_fail_message=382983)
def test_decorator_invalid_parameter_types(self):
# Provide some invalid severity maps.
with self.assertRaises(TypeError):
linter("some-executable",
output_format="regex",
output_regex="(?P<severity>)",
severity_map=list())
with self.assertRaises(TypeError):
linter("some-executable",
output_format="regex",
output_regex="(?P<severity>)",
severity_map={3: 0})
with self.assertRaises(TypeError) as cm:
linter("some-executable",
output_format="regex",
output_regex="(?P<severity>)",
severity_map={"critical": "invalid"})
self.assertEqual(str(cm.exception),
"The value 'invalid' for key 'critical' inside given "
"severity-map is no valid severity value.")
with self.assertRaises(TypeError) as cm:
linter("some-executable",
output_format="regex",
output_regex="(?P<severity>)",
severity_map={"critical-error": 389274234})
self.assertEqual(str(cm.exception),
"Invalid severity value 389274234 for key "
"'critical-error' inside given severity-map.")
# Other type-error test cases.
with self.assertRaises(TypeError):
linter("some-executable",
output_format="regex",
output_regex="(?P<message>)",
result_message=None)
with self.assertRaises(TypeError):
linter("some-executable",
output_format="corrected",
result_message=list())
with self.assertRaises(TypeError) as cm:
linter("some-executable",
output_format="corrected",
diff_severity=999888777)
self.assertEqual(str(cm.exception),
"Invalid value for `diff_severity`: 999888777")
with self.assertRaises(TypeError):
linter("some-executable",
prerequisite_check_command=("command",),
prerequisite_check_fail_message=382983)
def test_decorator_invalid_parameters(self):
with self.assertRaises(ValueError) as cm:
linter("some-executable", invalid_arg=88, ABC=2000)
self.assertEqual(
str(cm.exception),
"Invalid keyword arguments provided: 'ABC', 'invalid_arg'")
with self.assertRaises(ValueError) as cm:
linter("some-executable", diff_severity=RESULT_SEVERITY.MAJOR)
self.assertEqual(str(cm.exception),
"Invalid keyword arguments provided: 'diff_severity'")
with self.assertRaises(ValueError) as cm:
linter("some-executable", result_message="Custom message")
self.assertEqual(str(cm.exception),
"Invalid keyword arguments provided: "
"'result_message'")
with self.assertRaises(ValueError) as cm:
linter("some-executable",
output_format="corrected",
output_regex=".*")
self.assertEqual(str(cm.exception),
"Invalid keyword arguments provided: 'output_regex'")
with self.assertRaises(ValueError) as cm:
linter("some-executable",
output_format="corrected",
severity_map={})
self.assertEqual(str(cm.exception),
"Invalid keyword arguments provided: 'severity_map'")
with self.assertRaises(ValueError) as cm:
linter("some-executable",
prerequisite_check_fail_message="some_message")
self.assertEqual(str(cm.exception),
"Invalid keyword arguments provided: "
"'prerequisite_check_fail_message'")
def test_stdin_stderr_config_correction(self):
create_arguments_mock = Mock()
generate_config_mock = Mock()
# `some_value_A` and `some_value_B` are used to test the different
# delegation to `generate_config()` and `create_arguments()`
# accordingly.
class Handler:
@staticmethod
def generate_config(filename, file, some_value_A):
generate_config_mock(filename, file, some_value_A)
return '\n'.join(['use_stdin', 'use_stderr', 'correct'])
@staticmethod
def create_arguments(filename, file, config_file, some_value_B):
create_arguments_mock(filename, file, config_file,
some_value_B)
return self.test_program_path, '--config', config_file
uut = (linter(sys.executable,
use_stdin=True,
use_stdout=False,
use_stderr=True,
output_format='corrected',
config_suffix='.conf')(Handler)(self.section, None))
results = list(
uut.run(self.testfile2_path,
self.testfile2_content,
some_value_A=124,
some_value_B=-78))
expected_correction = [s + '\n' for s in ['+', '/', '/', '-']]
diffs = list(
Diff.from_string_arrays(self.testfile2_content,
expected_correction).split_diff())
expected = [
Result.from_values(uut,
'Inconsistency found.',
self.testfile2_path,
1,
None,
1,
None,
RESULT_SEVERITY.NORMAL,
diffs={self.testfile2_path: diffs[0]}),
Result.from_values(uut,
'Inconsistency found.',
self.testfile2_path,
5,
None,
5,
None,
RESULT_SEVERITY.NORMAL,
diffs={self.testfile2_path: diffs[1]})
]
self.assertEqual(results, expected)
create_arguments_mock.assert_called_once_with(self.testfile2_path,
self.testfile2_content,
ANY, -78)
self.assertEqual(create_arguments_mock.call_args[0][2][-5:], '.conf')
generate_config_mock.assert_called_once_with(self.testfile2_path,
self.testfile2_content,
124)
def test_decorator_invalid_parameters(self):
with self.assertRaises(ValueError) as cm:
linter('some-executable', invalid_arg=88,
ABC=2000)(self.EmptyTestLinter)
self.assertEqual(
str(cm.exception),
"Invalid keyword arguments provided: 'ABC', 'invalid_arg'")
with self.assertRaises(ValueError) as cm:
linter('some-executable',
diff_severity=RESULT_SEVERITY.MAJOR)(self.EmptyTestLinter)
self.assertEqual(
str(cm.exception),
"Invalid keyword arguments provided: 'diff_severity'")
with self.assertRaises(ValueError) as cm:
linter('some-executable',
result_message='Custom message')(self.EmptyTestLinter)
self.assertEqual(
str(cm.exception), 'Invalid keyword arguments provided: '
"'result_message'")
with self.assertRaises(ValueError) as cm:
linter('some-executable',
output_format='corrected',
output_regex='.*')(self.EmptyTestLinter)
self.assertEqual(str(cm.exception),
"Invalid keyword arguments provided: 'output_regex'")
with self.assertRaises(ValueError) as cm:
linter('some-executable',
output_format='corrected',
severity_map={})(self.EmptyTestLinter)
self.assertEqual(str(cm.exception),
"Invalid keyword arguments provided: 'severity_map'")
with self.assertRaises(ValueError) as cm:
linter('some-executable',
prerequisite_check_fail_message='some_message')(
self.EmptyTestLinter)
self.assertEqual(
str(cm.exception), 'Invalid keyword arguments provided: '
"'prerequisite_check_fail_message'")
