def test_replace_continue_by_break(self):
self.assert_mutation(
utils.f("""
for x in y:
continue
"""), [utils.f("""
for x in y:
break
""")])
def test_deletion_with_arguments(self):
self.assert_mutation(
utils.f("""
@a(1)
def f():
pass
"""), [utils.f("""
def f():
pass
""")])
def test_single_decorator_deletion(self):
self.assert_mutation(
utils.f("""
@a
def f():
pass
"""), [utils.f("""
def f():
pass
""")])
def test_double_decorators_deletion(self):
self.assert_mutation(
utils.f("""
@a
@b
def f():
pass
"""), [utils.f("""
def f():
pass
""")])
def test_add_staticmethod_decorator(self):
self.assert_mutation(
utils.f("""
class X:
def f():
pass
"""),
utils.f("""
class X:
@staticmethod
def f():
pass
"""))
def test_change_position_from_first_to_last(self):
self.assert_mutation(
utils.f("""
class A:
def foo(self, x):
super().foo(x)
"""), [
utils.f("""
class A:
def foo(self, x):
pass
""")
])
def test_delete_overriding_method_when_base_class_from_other_module(self):
self.assert_mutation(utils.f("""
import ast
class A(ast.NodeTransformer):
def visit(self):
pass
"""), [
utils.f("""
import ast
class A(ast.NodeTransformer):
pass
""")
],
with_exec=True)
def test_delete_variable_if_two_hiding_in_two_targets(self):
self.assert_mutation(utils.f("""
class B:
(x, y) = (1, 2)
class A(B):
(x, y) = (3, 4)
"""), [
utils.f("""
class B:
(x, y) = (1, 2)
class A(B):
pass
""")
],
with_exec=True)
def test_swallow_exception(self):
self.assert_mutation(
utils.f("""
try:
pass
except:
raise
"""), [
utils.f("""
try:
pass
except:
pass
""")
])
def test_delete_variable_if_one_hiding_in_three_targets(self):
self.assert_mutation(utils.f("""
class B:
x = 1
class A(B):
(x, y, z) = (2, 3, 4)
"""), [
utils.f("""
class B:
x = 1
class A(B):
(y, z) = (3, 4)
""")
],
with_exec=True)
def test_delete_variable(self):
self.assert_mutation(utils.f("""
class B:
x = 1
class A(B):
x = 2
"""), [
utils.f("""
class B:
x = 1
class A(B):
pass
""")
],
with_exec=True)
class MutationControllerTest(unittest.TestCase):
TARGET_SRC = 'def mul(x): return x * x'
TEST_SRC = utils.f("""
import target
from unittest import TestCase
class MulTest(TestCase):
def test_mul(self):
self.assertEqual(target.mul(2), 4)
def test_not_used(self):
pass
""")
def setUp(self):
target_loader = MockModulesLoader('target', self.TARGET_SRC)
test_loader = MockModulesLoader('test', self.TEST_SRC)
self.score_view = MutationScoreStoreView()
mutator = FirstOrderMutator([operators.ArithmeticOperatorReplacement],
percentage=100)
self.mutation_controller = MockMutationController(
runner_cls=UnittestTestRunner,
target_loader=target_loader,
test_loader=test_loader,
views=[self.score_view],
mutant_generator=mutator,
mutate_covered=True,
)
def test_run(self):
self.mutation_controller.run()
score = self.score_view.score
self.assertEqual(score.all_mutants, 3)
self.assertEqual(score.killed_mutants, 2)
self.assertEqual(score.survived_mutants, 1)
def test_not_change_position_if_single_statement(self):
self.assert_mutation(
utils.f("""
class A:
def foo(self):
super().foo()
"""), [])
def test_not_add_if_already_has_staticmethod(self):
self.assert_no_mutation(
utils.f("""
class X:
@staticmethod
def f():
pass
"""))
def test_not_delete_if_raise(self):
self.assert_mutation(
utils.f("""
try:
pass
except:
raise
"""), [])
def test_not_swallow_if_pass(self):
self.assert_mutation(
utils.f("""
try:
pass
except:
pass
"""), [])
def test_delete_overriding_method(self):
self.assert_mutation(utils.f("""
class A:
def foo(self):
pass
class B(A):
def foo(self):
pass
"""), [
utils.f("""
class A:
def foo(self):
pass
class B(A):
pass
""")
],
with_exec=True)
def test_change_position_from_first_to_last(self):
self.assert_mutation(utils.f("""
class B:
def foo(self, x, y=1, *args, **kwargs):
pass
class A(B):
def foo(self, x, y=1, *args, **kwargs):
pass
"""), [
utils.f("""
class B:
def foo(self, x, y=1, *args, **kwargs):
pass
class A(B):
def foo(self, x, y=1, *args, **kwargs):
super().foo(x, y=1, *args, **kwargs)
pass
""")
],
with_exec=True)
def test_double_mutation(self):
self.assert_mutation(
utils.f("""
while x:
pass
for x in y:
pass
"""), [
utils.f("""
while x:
pass
break
for x in y:
pass
"""),
utils.f("""
while x:
pass
for x in y:
pass
break
"""),
])
def test_func_def_coverage(self):
node = utils.create_ast(
utils.f("""
def foo(x):
pass
"""))
self.coverage_injector.inject(node)
func_node = node.body[0]
func_body_el = func_node.body[0]
arg_node = func_node.args.args[0]
#self.assert_covered([func_node, arg_node])
self.assert_not_covered([func_body_el])
def test_class_def_coverage(self):
node = utils.create_ast(
utils.f("""
class X(object):
def foo(x):
pass
"""))
self.coverage_injector.inject(node)
class_node = node.body[0]
base_node = class_node.bases[0]
func_body_el = class_node.body[0].body[0]
self.assert_covered([class_node, base_node])
self.assert_not_covered([func_body_el])
def test_for_coverage(self):
node = utils.create_ast(
utils.f("""
for x in []:
pass
else:
pass
"""))
self.coverage_injector.inject(node)
for_node = node.body[0]
for_body_el = for_node.body[0]
else_body_el = for_node.orelse[0]
self.assert_covered(
[for_node, for_node.target, for_node.iter, else_body_el])
self.assert_not_covered([for_body_el])
def test_except_coverage(self):
node = utils.create_ast(
utils.f("""
try:
raise KeyError
except KeyError:
pass
"""))
self.coverage_injector.inject(node)
try_node = node.body[0]
try_body_el = try_node.body[0]
except_node = try_node.handlers[0]
except_body_el = except_node.body[0]
self.assert_covered(
[try_node, try_body_el, except_node, except_body_el])
def test_while__coverage(self):
node = utils.create_ast(
utils.f("""
while False:
pass
else:
pass
"""))
self.coverage_injector.inject(node)
while_node = node.body[0]
while_test_node = while_node.test
while_body_el = while_node.body[0]
while_else_body_el = while_node.orelse[0]
self.assert_covered([while_test_node, while_else_body_el])
self.assert_not_covered([while_body_el])
def test_inject(self):
target_module_content = utils.f("""
def x():
import source
return source
""")
target_module = types.ModuleType('target')
source_module_before = types.ModuleType('source')
source_module_before.__file__ = 'source.py'
source_module_after = types.ModuleType('source')
sys.modules['source'] = source_module_before
importer = utils.InjectImporter(source_module_after)
eval(compile(target_module_content, 'target.py', 'exec'),
target_module.__dict__)
importer.install()
source_module = target_module.x()
self.assertEqual(source_module, source_module_after)
self.assertEqual(source_module.__loader__, importer)
del sys.modules['source']
importer.uninstall()
def test_if_coverage(self):
node = utils.create_ast(
utils.f("""
if False:
pass
elif True:
pass
else:
pass
"""))
self.coverage_injector.inject(node)
if_node = node.body[0]
first_if_test_node = if_node.test
first_if_body_el = if_node.body[0]
second_if_node = if_node.orelse[0]
second_if_test_node = second_if_node.test
second_if_body_el = second_if_node.body[0]
else_body_el = second_if_node.orelse[0]
self.assert_covered(
[first_if_test_node, second_if_test_node, second_if_body_el])
self.assert_not_covered([first_if_body_el, else_body_el])
def test_f(self):
self.assertEqual(
utils.f("""
def f():
pass
"""), 'def f():\n pass')
