def main(argv=None):
"""Application entry-point.
This will read the given coverage data file and prints a JSON object with
the following fields to stdout:
``covered``
An array of line numbers that are covered.
``excluded``
An array of line numbers that have been excluded from being subject
to coverage checks.
``missing``
An array of line numbers that have not been covered.
"""
args = parse_args(argv)
coverage = Coverage(data_file=str(args.coverage[0]))
_, covered, excluded, missing, _ = coverage.analysis2(str(args.file[0]))
print(json.dumps({
"covered": covered,
"excluded": excluded,
"missing": missing,
}))
return 0
def main(argv=None):
"""Application entry-point.
This will read the given coverage data file and prints a JSON object with
the following fields to stdout:
``covered``
An array of line numbers that are covered.
``excluded``
An array of line numbers that have been excluded from being subject
to coverage checks.
``missing``
An array of line numbers that have not been covered.
"""
args = parse_args(argv)
coverage = Coverage(data_file=str(args.coverage[0]))
coverage.load()
_, covered, excluded, missing, _ = coverage.analysis2(str(args.file[0]))
print(
json.dumps({
"covered": covered,
"excluded": excluded,
"missing": missing,
}))
return 0
def terminate_process(cov: coverage.coverage) -> None:
"""
Once the process is finished, stop and save coverage
:param cov: the coverage instance
"""
cov.stop()
cov.save()
def main():
list_of_test_files = list()
for directory in os.walk('.'):
for filename in directory[2]:
if re.search(".*_tests?\.py", filename):
list_of_test_files.append(filename)
list_of_test_files.append('config_testing.py')
coverage = Coverage(omit=list_of_test_files)
list_of_test_files.pop()
coverage.start()
# no log messages
logger.setLevel(1000000000000)
loader = unittest.TestLoader()
suite = loader.discover('.', '*_test.py')
test_runner = unittest.TextTestRunner(verbosity=2)
test_result = test_runner.run(suite)
coverage.stop()
coverage.report(file=sys.stdout)
if args.html_report:
coverage.html_report(directory=args.html_report)
print(test_result)
def run_tests(self, test_labels, extra_tests=None, **kwargs):
coverage = Caverage()
coverage.start()
test_results = super(CaverageTestSuiteRunner, self).run_tests(test_labels, extra_tests=None, **kwargs)
coverage.stop()
if kwargs.get('verbosity', 1) >= 1:
print "Generating coverage report..."
coverage_modules = []
for app in test_labels:
try:
module = __import__(app, globals(), locals(), [''])
except ImportError:
coverage_modules = None
break
if module:
base_path = os.path.join(os.path.split(module.__file__)[0], "")
for root, dirs, files in os.walk(base_path):
if not root.endswith(self.omit_folders):
for fname in files:
if fname.endswith(".py") and os.path.getsize(os.path.join(root, fname)) > 1:
try:
mname = os.path.join(app, os.path.join(root, fname).replace(base_path, ""))
coverage_modules.append(mname)
except ImportError:
pass #do nothing
if coverage_modules or not test_labels:
coverage.html_report(coverage_modules, directory=settings.COVERAGE_REPORT_PATH)
return test_results
def __init__(self, runner, xml_out=None, html_out=None):
self.runner = runner
self.enable = xml_out is not None or html_out is not None
self.xml_out = xml_out
self.html_out = html_out
if self.enable:
self.coverage = Coverage(config_file=False,
source=self.runner.coverage_report)
self.coverage.exclude(r"^\s*$") # Exclude empty lines
self.coverage.exclude(r"^\s*#.*$") # Exclude comment blocks
self.coverage.exclude(r"^\s*(import|from)\s") # Exclude import statements
else:
self.coverage = None
class CoverageContext(object):
"""
Coverage context manager
"""
def __init__(self, runner, xml_out=None, html_out=None):
self.runner = runner
self.enable = xml_out is not None or html_out is not None
self.xml_out = xml_out
self.html_out = html_out
if self.enable:
self.coverage = Coverage(config_file=False,
source=self.runner.coverage_report)
self.coverage.exclude(r"^\s*$") # Exclude empty lines
self.coverage.exclude(r"^\s*#.*$") # Exclude comment blocks
self.coverage.exclude(r"^\s*(import|from)\s") # Exclude import statements
else:
self.coverage = None
def info(self, message):
logging.info(message)
def __enter__(self):
if self.coverage:
self.info("Starting coverage")
self.coverage.start()
def __exit__(self, exc_type, exc_value, traceback):
if self.coverage:
self.info("Stopping coverage")
self.coverage.stop()
if self.xml_out:
self.info("Writing Cobertura-compatible XML coverage report "
" to %s" % self.xml_out)
self.coverage.xml_report(outfile=self.xml_out)
if self.html_out:
self.info("Writing HTML coverage report to %s" % self.html_out)
self.coverage.html_report(directory=self.html_out)
def runUnitTest(target, run_doctest=True):
from coverage import coverage as Coverage
warns_list = []
testerrors = []
result = TestResult()
cov = Coverage()
cov.start()
with warnings.catch_warnings():
# suppress dafault stdout warning from python builtin
def warn_record_traceback(message,
category,
filename,
lineno,
file=None,
line=None):
exc_type, exc_value, exc_tb = sys.exc_info()
warns_list.append((message, traceback.extract_stack()))
warnings.showwarning = warn_record_traceback
result.startTestRun()
try:
test, doctests = loadTarget(target)
test.run(result)
if doctests and run_doctest:
doctests.run(result)
except:
error_type, error_value, error_traceback = sys.exc_info()
filename, lineno, funcname, line = matchFileInTraceback(
target, error_traceback)
testerrors.append({
'path': filename,
'row': int(lineno),
'col': 1,
'code': 'U202',
'text': repr(error_value)
})
finally:
result.stopTestRun()
cov.stop()
warns = []
for message, warn_traceback in warns_list:
filename, lineno, funcname, line = matchFileInTraceback(
target, warn_traceback)
warns.append({
'path': filename,
'row': lineno,
'col': 1,
'code': 'U101',
'text': message
})
for test, (error_type, error_value, error_traceback) \
in result.unsuccess_list:
casefile, caselineno, casename, is_doctest = getTestCaseLine(test)
if error_type is not None:
# when result is not UnexpectedSuccess
if is_doctest:
filename, lineno, funcname, excepted, got = \
doctest_regex(error_value.args[0]).groups()
testerrors.append({
'path':
filename,
'row':
int(lineno),
'col':
1,
'code':
'U203',
'text':
'Excepted: {}; Got: {}'.format(excepted, got)
})
else:
filename, lineno, funcname, line = matchFileInTraceback(
casefile, error_traceback)
testerrors.append({
'path': filename,
'row': lineno,
'col': 1,
'code': 'U202',
'text': repr(error_value)
})
testerrors.append({
'path':
casefile,
'row':
caselineno,
'col':
1,
'code':
'U201',
'text':
'{} failed'.format('doctest' if is_doctest else 'unittest')
})
missing_linenos = cov.analysis(target)[2]
missings = []
for lineno in missing_linenos:
missings.append({
'path': target,
'row': lineno,
'col': 0,
'code': 'V100',
'text': 'never executed'
})
return warns, testerrors, missings
