def _check_console_report(self, git_diff_path, expected_console_path,
tool_args):
"""
Verify that the tool produces the expected console report.
`git_diff_path` is a path to a fixture containing the (patched) output of
the call to `git diff`.
`expected_console_path` is a path to the fixture containing
the expected console output of the tool.
`tool_args` is a list of command line arguments to pass
to the tool. You should include the name of the tool
as the first argument.
"""
# Patch the output of `git diff`
with open(git_diff_path) as git_diff_file:
self._set_git_diff_output(git_diff_file.read(), "")
# Capture stdout to a string buffer
string_buffer = StringIO()
self._capture_stdout(string_buffer)
# Patch sys.argv
self._set_sys_args(tool_args)
# Execute the tool
main()
# Check the console report
with open(expected_console_path) as expected_file:
report = string_buffer.getvalue()
expected = expected_file.read()
assert_long_str_equal(expected, report, strip=True)
def _check_console_report(self, git_diff_path, expected_console_path, tool_args):
"""
Verify that the tool produces the expected console report.
`git_diff_path` is a path to a fixture containing the (patched) output of
the call to `git diff`.
`expected_console_path` is a path to the fixture containing
the expected console output of the tool.
`tool_args` is a list of command line arguments to pass
to the tool. You should include the name of the tool
as the first argument.
"""
# Patch the output of `git diff`
with open(git_diff_path) as git_diff_file:
self._set_git_diff_output(git_diff_file.read(), "")
# Capture stdout to a string buffer
string_buffer = BytesIO()
self._capture_stdout(string_buffer)
# Patch sys.argv
self._set_sys_args(tool_args)
# Execute the tool
main()
# Check the console report
with open(expected_console_path) as expected_file:
report = string_buffer.getvalue()
expected = expected_file.read()
assert_long_str_equal(expected, report, strip=True)
def _check_console_report(self, git_diff_path, coverage_xml_paths,
expected_console_path, quality_reporter='pep8'):
"""
If `coverage_xml_paths` is not empty, assert that given `git_diff_path`
and `coverage_xml_paths`, diff-cover generates the expected console report.
If `coverage_xml_paths` is empty, asserts that given `git_diff_path` and
`quality_reporter` generates the expected console report.
"""
# Patch the output of `git diff`
with open(git_diff_path) as git_diff_file:
self._set_git_diff_output(git_diff_file.read(), "")
# Capture stdout to a string buffer
string_buffer = StringIO()
self._capture_stdout(string_buffer)
# Patch sys.argv
if len(coverage_xml_paths) > 0:
input_list = ['diff-cover'] + coverage_xml_paths
self._set_sys_args(input_list)
else:
self._set_sys_args(['diff-quality',
'--violations', quality_reporter])
# Run diff-cover or diff-quality, as specified
main()
# Check the console report
with open(expected_console_path) as expected_file:
report = string_buffer.getvalue()
expected = expected_file.read()
self.assertEqual(report, expected)
def test_git_diff_error(self):
# Patch the output of `git diff` to return an error
self._set_git_diff_output('', 'fatal error')
# Expect an error
with self.assertRaises(CommandError):
main(['diff-cover', 'coverage.xml'])
def test_git_diff_error_diff_quality(self):
# Patch the output of `git diff` to return an error
self._set_git_diff_output('', 'fatal error')
# Expect an error
with self.assertRaises(CommandError):
main(['diff-quality', '--violations', 'pycodestyle'])
def test_git_diff_error_diff_quality(self):
# Patch the output of `git diff` to return an error
self._set_git_diff_output("", "fatal error")
# Expect an error
with self.assertRaises(CommandError):
main(["diff-quality", "--violations", "pep8"])
def test_git_diff_error(self):
# Patch the output of `git diff` to return an error
self._set_git_diff_output('', 'fatal error')
# Expect an error
with self.assertRaises(GitDiffError):
main(['diff-cover', 'coverage.xml'])
def test_git_diff_error_diff_quality(self):
# Patch the output of `git diff` to return an error
self._set_git_diff_output('', 'fatal error')
# Expect an error
with self.assertRaises(GitDiffError):
main(['diff-quality', '--violations', 'pep8'])
def _run_main(self, argv):
gen_report_patch = patch("diff_cover.tool.generate_quality_report",
return_value=100)
with gen_report_patch as p:
main(argv)
quality_reporter = p.call_args[0][0]
assert quality_reporter.driver.name == 'pylint'
assert quality_reporter.options == '--foobar'
def _run_main(self, argv):
gen_report_patch = patch("diff_cover.tool.generate_quality_report",
return_value=100)
with gen_report_patch as p:
main(argv)
quality_reporter = p.call_args[0][0]
assert quality_reporter.driver.name == 'pylint'
assert quality_reporter.options == '--foobar'
def test_git_diff_error(self):
# Patch the output of `git diff` to return an error
self._set_git_diff_output("", "fatal error")
# Expect an error
with self.assertRaises(CommandError):
main(["diff-cover", "coverage.xml"])
def test_git_diff_error_diff_quality(self):
# Patch sys.argv
self._set_sys_args(['diff-quality', '--violations', 'pep8'])
# Patch the output of `git diff` to return an error
self._set_git_diff_output('', 'fatal error')
# Expect an error
with self.assertRaises(GitDiffError):
main()
def test_git_diff_error(self):
# Patch sys.argv
self._set_sys_args(['diff-cover', 'coverage.xml'])
# Patch the output of `git diff` to return an error
self._set_git_diff_output('', 'fatal error')
# Expect an error
with self.assertRaises(GitDiffError):
main()
def test_parse_options_without_quotes(self):
argv = ["diff-quality", "--violations", "pylint", "--options=--foobar"]
fake_pylint_reporter = Mock()
reporter_patch = patch.dict("diff_cover.tool.QUALITY_REPORTERS", {"pylint": fake_pylint_reporter})
gen_report_patch = patch("diff_cover.tool.generate_quality_report", return_value=100)
with reporter_patch:
with gen_report_patch:
main(argv)
self.assertTrue(fake_pylint_reporter.called)
call = fake_pylint_reporter.call_args
user_options = call[1]["user_options"]
self.assertEqual(user_options, "--foobar")
def test_parse_prog_name(self):
# Windows will give the full path to the tool.
argv = [
# Using forward slashes so the tests work everywhere.
'C:/diff-cover/diff-quality-script.py',
'--violations', 'pylint',
'--options=--foobar',
]
self._run_main(argv)
# No silent failures if the tool name is unrecognized.
with self.assertRaises(AssertionError):
main(['diff-foobar'])
def _check_html_report(self, git_diff_path, expected_html_path, tool_args, expected_status=0):
"""
Verify that the tool produces the expected HTML report.
`git_diff_path` is a path to a fixture containing the (patched) output of
the call to `git diff`.
`expected_console_path` is a path to the fixture containing
the expected HTML output of the tool.
`tool_args` is a list of command line arguments to pass
to the tool. You should include the name of the tool
as the first argument.
"""
# Patch the output of `git diff`
with open(git_diff_path) as git_diff_file:
self._set_git_diff_output(git_diff_file.read(), "")
# Create a temporary directory to hold the output HTML report
# Add a cleanup to ensure the directory gets deleted
temp_dir = tempfile.mkdtemp()
self.addCleanup(lambda: shutil.rmtree(temp_dir))
html_report_path = os.path.join(temp_dir, 'diff_coverage.html')
# Execute the tool
code = main(tool_args + ['--html-report', html_report_path])
self.assertEquals(code, expected_status)
# Check the HTML report
with open(expected_html_path) as expected_file:
with open(html_report_path) as html_report:
html = html_report.read()
expected = expected_file.read()
assert_long_str_equal(expected, html, strip=True)
def _check_html_report(self, git_diff_path, expected_html_path, tool_args, expected_status=0):
"""
Verify that the tool produces the expected HTML report.
`git_diff_path` is a path to a fixture containing the (patched) output of
the call to `git diff`.
`expected_console_path` is a path to the fixture containing
the expected HTML output of the tool.
`tool_args` is a list of command line arguments to pass
to the tool. You should include the name of the tool
as the first argument.
"""
# Patch the output of `git diff`
with open(git_diff_path) as git_diff_file:
self._set_git_diff_output(git_diff_file.read(), "")
# Create a temporary directory to hold the output HTML report
# Add a cleanup to ensure the directory gets deleted
temp_dir = tempfile.mkdtemp()
self.addCleanup(lambda: shutil.rmtree(temp_dir))
html_report_path = os.path.join(temp_dir, 'diff_coverage.html')
# Execute the tool
code = main(tool_args + ['--html-report', html_report_path])
self.assertEquals(code, expected_status)
# Check the HTML report
with open(expected_html_path) as expected_file:
with open(html_report_path) as html_report:
html = html_report.read()
expected = expected_file.read()
assert_long_str_equal(expected, html, strip=True)
def test_parse_options_without_quotes(self):
argv = [
"diff-quality",
"--violations",
"pylint",
'--options=--foobar',
]
fake_pylint_reporter = Mock()
reporter_patch = patch.dict("diff_cover.tool.QUALITY_REPORTERS",
{"pylint": fake_pylint_reporter})
gen_report_patch = patch("diff_cover.tool.generate_quality_report",
return_value=100)
with reporter_patch:
with gen_report_patch:
main(argv)
self.assertTrue(fake_pylint_reporter.called)
call = fake_pylint_reporter.call_args
user_options = call[1]["user_options"]
self.assertEqual(user_options, "--foobar")
def _check_html_report(self, git_diff_path, coverage_xml_paths,
expected_html_path, quality_reporter='pep8'):
"""
If `coverage_xml_paths` is not empty,
assert that given `git_diff_path`
and `coverage_xml_paths`, diff-cover
generates the expected HTML report.
If `coverage_xml_paths` is empty,
asserts that given `git_diff_path` and
`quality_reporter` generates the expected HTML report.
"""
# Patch the output of `git diff`
with open(git_diff_path) as git_diff_file:
self._set_git_diff_output(git_diff_file.read(), "")
# Create a temporary directory to hold the output HTML report
# Add a cleanup to ensure the directory gets deleted
temp_dir = tempfile.mkdtemp()
self.addCleanup(lambda: shutil.rmtree(temp_dir))
html_report_path = os.path.join(temp_dir, 'diff_coverage.html')
if len(coverage_xml_paths) > 0:
input_list = ['diff-cover'] + coverage_xml_paths + ['--html-report', html_report_path]
self._set_sys_args(input_list)
else:
self._set_sys_args(['diff-quality',
'--violations', quality_reporter,
'--html-report', html_report_path])
# Run diff-cover or diff-quality, as specified
main()
# Check the HTML report
with open(expected_html_path) as expected_file:
with open(html_report_path) as html_report:
html = html_report.read()
expected = expected_file.read()
assert_long_str_equal(expected, html, strip=True)
def _call_quality_expecting_error(self, tool_name, expected_error):
"""
Makes calls to diff_quality that should fail to ensure
we get back the correct failure.
Takes in a string which is a tool to call and
an string which is the error you expect to see
"""
self._set_git_diff_output("does/not/matter", "")
argv = ["diff-quality", "--violations={0}".format(tool_name), "pylint_report.txt"]
with patch("diff_cover.tool.LOGGER") as logger:
exit_value = main(argv)
logger.error.assert_called_with(expected_error)
self.assertEqual(exit_value, 1)
def _call_quality_expecting_error(self, tool_name, expected_error, report_arg="pylint_report.txt"):
"""
Makes calls to diff_quality that should fail to ensure
we get back the correct failure.
Takes in a string which is a tool to call and
an string which is the error you expect to see
"""
with io.open("git_diff_add.txt", encoding="utf-8") as git_diff_file:
self._set_git_diff_output(git_diff_file.read(), "")
argv = ["diff-quality", "--violations={0}".format(tool_name), report_arg]
with patch("diff_cover.tool.LOGGER") as logger:
exit_value = main(argv)
logger.error.assert_called_with(expected_error)
self.assertEqual(exit_value, 1)
def _call_quality_expecting_error(self, tool_name, expected_error):
"""
Makes calls to diff_quality that should fail to ensure
we get back the correct failure.
Takes in a string which is a tool to call and
an string which is the error you expect to see
"""
self._set_git_diff_output("does/not/matter", "")
argv = ['diff-quality',
'--violations={0}'.format(tool_name),
'pylint_report.txt']
with patch('diff_cover.tool.LOGGER') as logger:
exit_value = main(argv)
logger.error.assert_called_with(expected_error)
self.assertEqual(exit_value, 1)
def _call_quality_expecting_error(self, tool_name, expected_error, report_arg='pylint_report.txt'):
"""
Makes calls to diff_quality that should fail to ensure
we get back the correct failure.
Takes in a string which is a tool to call and
an string which is the error you expect to see
"""
with io.open('git_diff_add.txt', encoding='utf-8') as git_diff_file:
self._set_git_diff_output(git_diff_file.read(), "")
argv = ['diff-quality',
'--violations={0}'.format(tool_name),
report_arg]
with patch('diff_cover.tool.LOGGER') as logger:
exit_value = main(argv)
logger.error.assert_called_with(expected_error)
self.assertEqual(exit_value, 1)
def _check_html_report(self, git_diff_path, expected_html_path, tool_args, expected_status=0, css_file=None):
"""
Verify that the tool produces the expected HTML report.
`git_diff_path` is a path to a fixture containing the (patched) output of
the call to `git diff`.
`expected_console_path` is a path to the fixture containing
the expected HTML output of the tool.
`tool_args` is a list of command line arguments to pass
to the tool. You should include the name of the tool
as the first argument.
"""
# Patch the output of `git diff`
with io.open(git_diff_path, encoding="utf-8") as git_diff_file:
self._set_git_diff_output(git_diff_file.read(), "")
# Create a temporary directory to hold the output HTML report
# Add a cleanup to ensure the directory gets deleted
temp_dir = tempfile.mkdtemp()
self.addCleanup(lambda: shutil.rmtree(temp_dir))
html_report_path = os.path.join(temp_dir, "diff_coverage.html")
args = tool_args + ["--html-report", html_report_path]
if css_file:
css_file = os.path.join(temp_dir, css_file)
args += ["--external-css-file", css_file]
# Execute the tool
code = main(args)
self.assertEquals(code, expected_status)
# Check the HTML report
with io.open(expected_html_path, encoding="utf-8") as expected_file:
with io.open(html_report_path, encoding="utf-8") as html_report:
html = html_report.read()
expected = expected_file.read()
if css_file is None:
html = self._clear_css(html)
expected = self._clear_css(expected)
assert_long_str_equal(expected, html, strip=True)
return temp_dir
