def parse_run_argument(argument, config, dict_synonyms, mutations_by_file,
paths_to_exclude, paths_to_mutate, tests_dirs):
if argument is None:
for path in paths_to_mutate:
for filename in python_source_files(path, tests_dirs,
paths_to_exclude):
if filename.startswith('test_') or filename.endswith(
'__tests.py'):
continue
update_line_numbers(filename)
add_mutations_by_file(mutations_by_file, filename,
dict_synonyms, config)
else:
try:
int(argument)
except ValueError:
filename = argument
if not os.path.exists(filename):
raise click.BadArgumentUsage(
'The run command takes either an integer that is the mutation id or a path to a file to mutate'
)
update_line_numbers(filename)
add_mutations_by_file(mutations_by_file, filename, dict_synonyms,
config)
return
filename, mutation_id = filename_and_mutation_id_from_pk(int(argument))
update_line_numbers(filename)
mutations_by_file[filename] = [mutation_id]
def do_apply(mutation_pk, dict_synonyms, backup):
"""Apply a specified mutant to the source code
:param mutation_pk: mutmut cache primary key of the mutant to apply
:type mutation_pk: str
:param dict_synonyms: list of synonym keywords for a python dictionary
:type dict_synonyms: list[str]
:param backup: if :obj:`True` create a backup of the source file
before applying the mutation
:type backup: bool
"""
filename, mutation_id = filename_and_mutation_id_from_pk(int(mutation_pk))
update_line_numbers(filename)
context = Context(
mutation_id=mutation_id,
filename=filename,
dict_synonyms=dict_synonyms,
)
mutate_file(
backup=backup,
context=context,
)
def do_apply(mutation_pk, dict_synonyms, backup):
"""Apply a specified mutant to the source code
:param mutation_pk: mutmut cache primary key of the mutant to apply
:type mutation_pk: str
:param dict_synonyms: list of synonym keywords for a python dictionary
:type dict_synonyms: list[str]
:param backup: if :obj:`True` create a backup of the source file
before applying the mutation
:type backup: bool
"""
filename, mutation_id = filename_and_mutation_id_from_pk(int(mutation_pk))
context = Context(
mutation_id=mutation_id,
filename=filename,
dict_synonyms=dict_synonyms,
)
mutate_file(
backup=backup,
context=context,
)
if context.number_of_performed_mutations == 0:
raise RuntimeError(
'No mutations performed. Are you sure the index is not too big?')
def do_apply(mutation_pk, dict_synonyms, backup):
filename, mutation_id = filename_and_mutation_id_from_pk(int(mutation_pk))
context = Context(
mutation_id=mutation_id,
filename=filename,
dict_synonyms=dict_synonyms,
)
mutate_file(
backup=backup,
context=context,
)
if context.number_of_performed_mutations == 0:
raise ErrorMessage('ERROR: no mutations performed. Are you sure the index is not too big?')
def get_mutations_by_file_from_cache(mutation_pk):
from mutmut.cache import filename_and_mutation_id_from_pk
filename, mutation_id = filename_and_mutation_id_from_pk(int(mutation_pk))
return {filename: [mutation_id]}
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']
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
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 == '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
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.
""")
baseline_time_elapsed = time_test_suite(
swallow_output=not swallow_output,
test_command=runner,
using_testmon=using_testmon
)
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()
else:
assert use_patch_file
covered_lines_by_filename = read_patch_data(use_patch_file)
if command != 'run':
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=hash_of_tests(tests_dirs),
test_time_multiplier=test_time_multiplier,
test_time_base=test_time_base,
pre_mutation=pre_mutation,
post_mutation=post_mutation,
)
if argument is None:
for path in paths_to_mutate:
for filename in python_source_files(path, tests_dirs, paths_to_exclude):
update_line_numbers(filename)
add_mutations_by_file(mutations_by_file, filename, dict_synonyms, config)
else:
filename, mutation_id = filename_and_mutation_id_from_pk(int(argument))
mutations_by_file[filename] = [mutation_id]
config.total = sum(len(mutations) for mutations in mutations_by_file.values())
print()
print('2. Checking mutants')
progress = Progress()
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
def main(command, argument, paths_to_mutate, backup, runner, tests_dir, s, use_coverage, dict_synonyms, cache_only, version, suspicious_policy, untested_policy):
"""
commands:\n
run [mutation id]\n
Runs mutmut. You probably want to start with just trying this. If you supply a mutation ID mutmut will check just this mutant.\n
results\n
Print the results.\n
apply [mutation id]\n
Apply a mutation on disk.\n
show [mutation id]\n
Show a mutation diff.\n
"""
if version:
print("mutmut version %s" % __version__)
return
valid_commands = ['run', 'results', 'apply', 'show', 'junitxml']
if command not in valid_commands:
print('%s is not a valid command, must be one of %s' % (command, ', '.join(valid_commands)))
return
if command == 'results' and argument:
print('The %s command takes no arguments' % command)
return
dict_synonyms = [x.strip() for x in dict_synonyms.split(',')]
if command in ('show', 'diff'):
if not argument:
print_result_cache()
return
print(get_unified_diff(argument, dict_synonyms))
return
if use_coverage and not exists('.coverage'):
print('No .coverage file found. You must generate a coverage file to use this feature.')
return
if command == 'results':
print_result_cache()
return
if command == 'junitxml':
print_result_cache_junitxml(dict_synonyms, suspicious_policy, untested_policy)
return
if command == 'apply':
do_apply(argument, dict_synonyms, backup)
return
paths_to_mutate = get_or_guess_paths_to_mutate(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 ErrorMessage('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
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
Mutants are written to the cache in the .mutmut-cache
directory. 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.
""")
try:
baseline_time_elapsed = time_test_suite(swallow_output=not s, test_command=runner, using_testmon=using_testmon)
if using_testmon:
copy('.testmondata', '.testmondata-initial')
if not use_coverage:
def _exclude(context):
return False
else:
covered_lines_by_filename = {}
coverage_data = read_coverage_data(use_coverage)
def _exclude(context):
try:
covered_lines = covered_lines_by_filename[context.filename]
except KeyError:
covered_lines = coverage_data.lines(os.path.abspath(context.filename))
covered_lines_by_filename[context.filename] = covered_lines
if covered_lines is None:
return True
current_line = context.current_line_index + 1
if current_line not in covered_lines:
return True
return False
assert command == 'run'
mutations_by_file = {}
if argument is None:
for path in paths_to_mutate:
for filename in python_source_files(path, tests_dirs):
update_line_numbers(filename)
add_mutations_by_file(mutations_by_file, filename, _exclude, dict_synonyms)
else:
filename, mutation_id = filename_and_mutation_id_from_pk(int(argument))
mutations_by_file[filename] = [mutation_id]
total = sum(len(mutations) for mutations in mutations_by_file.values())
print()
print('2. Checking mutants')
config = Config(
swallow_output=not s,
test_command=runner,
exclude_callback=_exclude,
baseline_time_elapsed=baseline_time_elapsed,
backup=backup,
dict_synonyms=dict_synonyms,
total=total,
using_testmon=using_testmon,
cache_only=cache_only,
tests_dirs=tests_dirs,
hash_of_tests=hash_of_tests(tests_dirs),
)
run_mutation_tests(config=config, mutations_by_file=mutations_by_file)
print()
except ErrorMessage as e:
print('\nERROR %s' % e)
