def test_read_coverage_data(filesystem):
assert read_coverage_data() == {}
def main(command, argument, argument2, paths_to_mutate, backup, runner,
tests_dir, test_time_multiplier, test_time_base, swallow_output,
use_coverage, dict_synonyms, cache_only, version, suspicious_policy,
untested_policy, pre_mutation, post_mutation, use_patch_file,
paths_to_exclude):
"""return exit code, after performing an mutation test run.
:return: the exit code from executing the mutation tests
:rtype: int
"""
if version:
print("mutmut version {}".format(__version__))
return 0
if use_coverage and use_patch_file:
raise click.BadArgumentUsage(
"You can't combine --use-coverage and --use-patch")
valid_commands = [
'run', 'results', 'apply', 'show', 'junitxml', 'html', 'update-cache'
]
if command not in valid_commands:
raise click.BadArgumentUsage(
'{} is not a valid command, must be one of {}'.format(
command, ', '.join(valid_commands)))
if command == 'results' and argument:
raise click.BadArgumentUsage(
'The {} command takes no arguments'.format(command))
dict_synonyms = [x.strip() for x in dict_synonyms.split(',')]
if command in ('show', 'diff'):
if not argument:
print_result_cache()
return 0
if argument == 'all':
print_result_cache(show_diffs=True,
dict_synonyms=dict_synonyms,
print_only_filename=argument2)
return 0
if os.path.isfile(argument):
print_result_cache(show_diffs=True, only_this_file=argument)
return 0
print(get_unified_diff(argument, dict_synonyms))
return 0
if use_coverage and not exists('.coverage'):
raise FileNotFoundError(
'No .coverage file found. You must generate a coverage file to use this feature.'
)
if command == 'results':
print_result_cache()
return 0
if command == 'junitxml':
print_result_cache_junitxml(dict_synonyms, suspicious_policy,
untested_policy)
return 0
if command == 'html':
create_html_report(dict_synonyms)
return 0
if command == 'apply':
do_apply(argument, dict_synonyms, backup)
return 0
if paths_to_mutate is None:
paths_to_mutate = guess_paths_to_mutate()
if not isinstance(paths_to_mutate, (list, tuple)):
paths_to_mutate = [x.strip() for x in paths_to_mutate.split(',')]
if not paths_to_mutate:
raise click.BadOptionUsage(
'--paths-to-mutate',
'You must specify a list of paths to mutate. Either as a command line argument, or by setting paths_to_mutate under the section [mutmut] in setup.cfg'
)
tests_dirs = []
for p in tests_dir.split(':'):
tests_dirs.extend(glob(p, recursive=True))
for p in paths_to_mutate:
for pt in tests_dir.split(':'):
tests_dirs.extend(glob(p + '/**/' + pt, recursive=True))
del tests_dir
current_hash_of_tests = hash_of_tests(tests_dirs)
os.environ[
'PYTHONDONTWRITEBYTECODE'] = '1' # stop python from creating .pyc files
using_testmon = '--testmon' in runner
print("""
- Mutation testing starting -
These are the steps:
1. A full test suite run will be made to make sure we
can run the tests successfully and we know how long
it takes (to detect infinite loops for example)
2. Mutants will be generated and checked
Results are stored in .mutmut-cache.
Print found mutants with `mutmut results`.
Legend for output:
🎉 Killed mutants. The goal is for everything to end up in this bucket.
⏰ Timeout. Test suite took 10 times as long as the baseline so were killed.
🤔 Suspicious. Tests took a long time, but not long enough to be fatal.
🙁 Survived. This means your tests needs to be expanded.
🔇 Skipped. Skipped.
""")
baseline_time_elapsed = time_test_suite(
swallow_output=not swallow_output,
test_command=runner,
using_testmon=using_testmon,
current_hash_of_tests=current_hash_of_tests,
)
if hasattr(mutmut_config, 'init'):
mutmut_config.init()
if using_testmon:
copy('.testmondata', '.testmondata-initial')
# if we're running in a mode with externally whitelisted lines
covered_lines_by_filename = None
coverage_data = None
if use_coverage or use_patch_file:
covered_lines_by_filename = {}
if use_coverage:
coverage_data = read_coverage_data()
check_coverage_data_filepaths(coverage_data)
else:
assert use_patch_file
covered_lines_by_filename = read_patch_data(use_patch_file)
if command != 'run' and command != 'update-cache':
raise click.BadArgumentUsage("Invalid command {}".format(command))
mutations_by_file = {}
paths_to_exclude = paths_to_exclude or ''
if paths_to_exclude:
paths_to_exclude = [
path.strip() for path in paths_to_exclude.split(',')
]
config = Config(
total=0, # we'll fill this in later!
swallow_output=not swallow_output,
test_command=runner,
covered_lines_by_filename=covered_lines_by_filename,
coverage_data=coverage_data,
baseline_time_elapsed=baseline_time_elapsed,
backup=backup,
dict_synonyms=dict_synonyms,
using_testmon=using_testmon,
cache_only=cache_only,
tests_dirs=tests_dirs,
hash_of_tests=current_hash_of_tests,
test_time_multiplier=test_time_multiplier,
test_time_base=test_time_base,
pre_mutation=pre_mutation,
post_mutation=post_mutation,
paths_to_mutate=paths_to_mutate,
)
parse_run_argument(argument, config, dict_synonyms, mutations_by_file,
paths_to_exclude, paths_to_mutate, tests_dirs)
if command == 'update-cache':
print('Finished updating cash')
return
config.total = sum(
len(mutations) for mutations in mutations_by_file.values())
print()
print('2. Checking mutants')
progress = Progress(total=config.total)
try:
run_mutation_tests(config=config,
progress=progress,
mutations_by_file=mutations_by_file)
except Exception as e:
traceback.print_exc()
return compute_exit_code(progress, e)
else:
return compute_exit_code(progress)
finally:
print() # make sure we end the output with a newline
# Close all active multiprocessing queues to avoid hanging up the main process
close_active_queues()