pyproteum 0.2__tar.gz → 0.2.4__tar.gz

{pyproteum-0.2/pyproteum.egg-info → pyproteum-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyproteum
-Version: 0.2
+Version: 0.2.4
 Summary: A tool for mutation testing in Python. Implemented as a Python module.
 Author: Delamaro
 Author-email: Delamaro <delamaro@icmc.usp.br>
@@ -49,6 +49,14 @@ Dynamic: requires-python
 
 > - Introduces the second argument for `mutagen` selection of mutant operatos.
 
+> **V0.2.2**
+
+> - Introduces argument `--assert` to enable mutation on assert statements.
+
+> **V0.2.4**
+
+> - Bug fixes.
+
 ---
 
 ## Features
@@ -170,6 +178,11 @@ Generate mutants for all operators:
 python -m pyproteum mutagen --create --D /home/user/proteum foo_session
 ```
 
+By default `assert` statements are not considered to generate mutants. This can be changed with `--assert` argument.
+```bash
+python -m pyproteum mutagen --create --D /home/user/proteum --assert foo_session
+```
+
 Generate only `orrn` mutants, with 50% random sampling:
 ```bash
 python -m pyproteum mutagen --create --D /home/user/proteum --orrn 50 0 foo_session

{pyproteum-0.2 → pyproteum-0.2.4}/README.md

@@ -34,6 +34,14 @@
 
 > - Introduces the second argument for `mutagen` selection of mutant operatos.
 
+> **V0.2.2**
+
+> - Introduces argument `--assert` to enable mutation on assert statements.
+
+> **V0.2.4**
+
+> - Bug fixes.
+
 ---
 
 ## Features
@@ -155,6 +163,11 @@ Generate mutants for all operators:
 python -m pyproteum mutagen --create --D /home/user/proteum foo_session
 ```
 
+By default `assert` statements are not considered to generate mutants. This can be changed with `--assert` argument.
+```bash
+python -m pyproteum mutagen --create --D /home/user/proteum --assert foo_session
+```
+
 Generate only `orrn` mutants, with 50% random sampling:
 ```bash
 python -m pyproteum mutagen --create --D /home/user/proteum --orrn 50 0 foo_session

{pyproteum-0.2 → pyproteum-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyproteum"
-version = "0.2"
+version = "0.2.4"
 description = "A tool for mutation testing in Python. Implemented as a Python module."
 authors = [
     {name = "Delamaro", email = "delamaro@icmc.usp.br"}

pyproteum-0.2.4/pyproteum/exemuta.py

@@ -0,0 +1,598 @@
+import types, sys, ast, multiprocessing
+from contextlib import redirect_stdout, redirect_stderr
+import sys, csv
+import os,io,json
+from pyproteum.models.models import * 
+import unittest
+import pickle
+import types
+import platform
+from pyproteum.moperators.myoperator import *
+from pyproteum.tcase import change_dir_connect
+from pyproteum.tcase import load_module, get_all_test_names, _ensure_module_hierarchy
+from pyproteum.utiles import red,green
+import timeout_decorator as tmtdecor
+import subprocess as sb
+from pyproteum.execution_reg import ExecutionReg
+
+
+class MutantTimeout(Exception):
+	pass
+
+class RegistrandoResultado(unittest.TextTestResult):
+	def __init__(self, stream=None, descriptions=None, verbosity=0, number=0, research=False):
+		super().__init__(stream, descriptions, verbosity)
+		self.my_successes = []  # armazena os testes que passaram
+		self.timeouts = []
+		self.all = []		# todos os testes executados
+		self.all_order = {}
+		self.order = number
+		self.count = 0
+		self.research = research
+
+	def startTest(self, test):
+		self.all.append(test)
+		self.count += 1
+		self.all_order[test.id()] = '{}:{}'.format(self.order, self.count)
+		super().startTest(test)
+
+	def addSuccess(self, test):
+		self.my_successes.append(test)
+		super().addSuccess(test)
+
+	def stopTest(self, test):
+		super().stopTest(test)
+	
+
+	def addFailure(self, test, err):
+		etype, evalue, tb = err
+		# sys.__stderr__.write(
+		# f"[addFailure] test={test.id()}\n"
+		# f"[addFailure] etype={etype} (module={getattr(etype, '__module__', '?')}, name={getattr(etype, '__name__', '?')})\n"
+		# f"[addFailure] evalue={repr(evalue)}\n"
+		# )		
+		# sys.__stderr__.write(f"addFailure etype id={id(etype)}\n")
+		# sys.__stderr__.write(f"addFailure MutantTimeout(ref) id={id(MutantTimeout)}\n")
+
+		try:
+			if issubclass(etype, MutantTimeout):
+				self.timeouts.append(test)
+		except TypeError:
+			if isinstance(evalue, MutantTimeout):
+				self.timeouts.append(test)
+		super().addFailure(test, err)
+		if not self.research:
+			self.stop()
+
+
+	def addError(self, test, err):
+		etype, evalue, tb = err
+		# sys.__stderr__.write(
+		# f"[addError] test={test.id()}\n"
+		# f"[addError] etype={etype} (module={getattr(etype, '__module__', '?')}, name={getattr(etype, '__name__', '?')})\n"
+		# f"[addError] len(timeouts) antes={len(self.timeouts)} id(list)={id(self.timeouts)}\n"
+		# f"[addError] evalue={repr(evalue)}\n"
+		# )		
+		# sys.__stderr__.write(f"etype id={id(etype)}\n")
+		# sys.__stderr__.write(f"MutantTimeout(ref) id={id(MutantTimeout)}\n")
+		# sys.__stderr__.write(f"[addError] self id={id(self)}\n")
+		# sys.__stderr__.flush()		
+
+		try:
+			if issubclass(etype, MutantTimeout):
+				self.timeouts.append(test)
+				# sys.__stderr__.write(f"[addError] APPEND OK len(timeouts) depois={len(self.timeouts)}\n")
+				# sys.__stderr__.flush()
+		except TypeError:
+			if isinstance(evalue, MutantTimeout):
+				self.timeouts.append(test)
+		super().addError(test, err)
+		# sys.__stderr__.write(f"[addError] len(timeouts) após super={len(self.timeouts)}\n")
+		# sys.__stderr__.flush()		
+		
+		if not self.research:
+			self.stop()
+
+
+class RegistrandoRunner(unittest.TextTestRunner):
+
+	def __init__(self, *args, number=0, research=False, **kwargs):
+		super().__init__(*args, **kwargs)
+		self.number = number
+		self.research = research
+
+	def _makeResult(self):
+		return RegistrandoResultado(self.stream, self.descriptions, self.verbosity, self.number,self.research)
+
+
+
+def _check_ast_executes(code_obj, path_filename, suppress_output):
+	module_name, parent, parts = _ensure_module_hierarchy(path_filename)
+
+	modulo = types.ModuleType(module_name)
+	if suppress_output:
+		with open(os.devnull, 'w') as fnull, redirect_stdout(fnull), redirect_stderr(fnull):
+			exec(code_obj, modulo.__dict__)
+	else:
+		exec(code_obj, modulo.__dict__)
+
+	sys.modules[module_name] = modulo
+	if parent is not None:
+		setattr(parent, parts[-1], modulo)
+
+def _check_ast_executes_source(code_str, path_filename, suppress_output):
+	code = compile(code_str, filename="<ast>", mode="exec")
+	_check_ast_executes(code, path_filename, suppress_output)
+
+def create_module_from_ast(path_filename, arvore_ast, timeout=3, suppress_output=True):
+
+	code = compile(arvore_ast, filename="<ast>", mode="exec")
+	code_src = ast.unparse(arvore_ast)
+	p = multiprocessing.Process(target=_check_ast_executes_source, args=(code_src, path_filename, suppress_output))
+
+
+	# Testa em subprocesso com timeout
+	p.start()	
+	p.join(timeout)
+	if p.is_alive():
+		p.terminate()
+		p.join()
+		raise TimeoutError(f"O módulo '{path_filename}' não respondeu em {timeout} segundos.")
+	p.close()
+	
+	# Executa de verdade no processo principal
+	module_name, parent, parts = _ensure_module_hierarchy(path_filename)
+
+	modulo = types.ModuleType(module_name)
+	if suppress_output:
+		with open(os.devnull, 'w') as fnull, redirect_stdout(fnull), redirect_stderr(fnull):
+			exec(code, modulo.__dict__)
+	else:
+		exec(code, modulo.__dict__)
+
+	sys.modules[module_name] = modulo
+	if parent is not None:
+		setattr(parent, parts[-1], modulo)
+
+	return modulo
+
+def simple_create_module_from_ast(path_filename, arvore_ast, suppress_output=True):
+
+
+	code = compile(arvore_ast, filename="<ast>", mode="exec")
+
+	# Executa de verdade no processo principal
+	module_name, parent, parts = _ensure_module_hierarchy(path_filename)
+
+	modulo = types.ModuleType(module_name)
+	sys.modules[module_name] = modulo
+	if suppress_output:
+		with open(os.devnull, 'w') as fnull, redirect_stdout(fnull), redirect_stderr(fnull):
+			exec(code, modulo.__dict__)
+	else:
+		exec(code, modulo.__dict__)
+
+	if parent is not None:
+		setattr(parent, parts[-1], modulo)
+
+	return modulo
+
+
+def parse_runner_json(s):
+	a = s.find("<<<PYPROTEUM_JSON>>>")
+	b = s.find("<<<END_PYPROTEUM_JSON>>>")
+	if a < 0 or b < 0 or b <= a:
+		raise ValueError("Runner did not output delimited JSON")
+	body = s[a + len("<<<PYPROTEUM_JSON>>>"):b].strip()
+
+	return json.loads(body)
+
+def call_runner_windows(muta_name, muta_source, filename, research, number):
+	env = os.environ.copy()
+
+	cp = sb.run(
+		[sys.executable, "-m", "pyproteum.runner_tests_myself", filename, str(TIMEOUT_SEGUNDOS), str(research), str(number), muta_name],
+		env=env,
+		cwd=os.getcwd(),
+		input=muta_source,	
+		check=False,
+		capture_output=True,
+		text=True
+		)
+
+	stdout = (cp.stdout or "").strip()
+	stderr = (cp.stderr or "").strip()
+
+	#print(stdout)
+	data = None
+	if stdout:
+		try:
+			data = parse_runner_json(stdout)
+		except json.JSONDecodeError as ex:
+			print(ex)
+			data = None
+
+	# runner quebrou ou não gerou JSON
+	if data is None:
+		fallback = {
+			"ok": False,
+			"testsRun": 0,
+			"my_successes": [],
+			"timeouts": [],
+			"all": [],
+			"all_order": {},
+			"failures": [],
+			"errors": [("runner", f"Runner failed. returncode={cp.returncode}. stderr={stderr}")],
+			"skipped": [],
+			"expectedFailures": [],
+			"unexpectedSuccesses": [],
+			"output": stdout,
+			"order": int(number),
+			"research": bool(research),
+			"runner_returncode": cp.returncode,
+			"runner_stderr": cp.stderr,
+		}
+		return resultado_from_runner_json(fallback)
+
+	# anexa metadados sempre
+	data["runner_returncode"] = cp.returncode
+	data["runner_stderr"] = cp.stderr
+	if "order" not in data:
+		data["order"] = int(number)
+	if "research" not in data:
+		data["research"] = bool(research)
+
+	return resultado_from_runner_json(data)
+
+def resultado_from_runner_json(data):
+
+	class Fake_test:
+		def __init__(self, tid):
+			self._id = tid
+
+		def id(self):
+			return self._id
+
+		def __hash__(self):
+			return hash(self._id)
+
+		def __eq__(self, other):
+			return isinstance(other, Fake_test) and self._id == other._id
+
+	def _parse_bool(v):
+		if isinstance(v, bool):
+			return v
+		return str(v).strip().lower() in ("1", "true", "yes")
+
+	# cache pra garantir identidade consistente por id
+	cache = {}
+	def T(tid):
+		if tid not in cache:
+			cache[tid] = Fake_test(tid)
+		return cache[tid]
+
+	res = RegistrandoResultado(
+		number=int(data.get("order", 0)),
+		research=_parse_bool(data.get("research", False))
+	)
+
+	res.testsRun = int(data.get("testsRun", 0))
+
+	res.my_successes = [T(tid) for tid in data.get("my_successes", [])]
+	res.timeouts = [T(tid) for tid in data.get("timeouts", [])]
+	res.all = [T(tid) for tid in data.get("all", [])]
+	res.all_order = dict(data.get("all_order", {}))
+
+	# IMPORTANTÍSSIMO: failures/errors/skipped são listas de pares (id, texto)
+	res.failures = [(T(tid), tb) for (tid, tb) in data.get("failures", [])]
+	res.errors = [(T(tid), tb) for (tid, tb) in data.get("errors", [])]
+
+
+	res.runner_returncode = data.get("runner_returncode", None)
+
+	# semântica: runner_ok (execução do runner OK)
+	res._ok = _parse_bool(data.get("runner_ok", False))
+
+	res.count = len(res.all)
+
+	return res
+
+
+
+def __exec():
+	session_name = sys.argv[-1]
+	directory = None
+	i = 2
+	keep = False
+	verbose = False
+	is_windows = False
+	while i < len(sys.argv[:-1]):
+		s = sys.argv[i]
+		match s:
+			case '--D':
+				i += 1
+				directory = sys.argv[i]
+			case '--keep':
+				keep = True
+			case '--v':
+				verbose = True
+			case '--win':
+				is_windows = True
+			case _:
+				usage()
+		i += 1
+	
+	change_dir_connect(directory, session_name)
+	session = Session.get(Session.id==1)
+	rse = session.type == 'research'
+
+	fields = get_all_test_names()
+
+	cont_dead = 0
+	cont_live = 0
+	cont_equiv = 0
+	is_windows = is_windows or platform.system() == 'Windows'
+
+	with db.atomic():
+		for muta in Mutant.select():
+
+			reg_muta, created = Execution.get_or_create(
+    			mutant=muta,
+    			)
+
+			if created:
+				er = ExecutionReg()
+			else:
+				er = ExecutionReg(reg_muta.execucao)
+			er.update(fields)
+			
+			reg_muta.execucao = str(er)
+
+
+			if muta.status == 'equiv':
+				cont_equiv += 1
+				reg_muta.save()
+				continue
+
+			if keep and muta.status != 'live' and not rse:
+				cont_dead += 1
+				reg_muta.save()
+				continue
+
+			print('Mutant {} -- {}'.format(muta.id, muta.operator))
+			tree = pickle.loads(muta.ast)
+			muta_source_code = ast.unparse(tree)
+			simple_create_module_from_ast(muta.source.filename, tree)
+
+			#print(reg_muta)
+			dead = False
+			for testfile in TestCase:
+				try:
+					if  is_windows:
+						resultado = call_runner_windows(muta.source.filename, muta_source_code, testfile.filename,rse, testfile.id)
+						if not resultado._ok :
+							#print(resultado.msg)
+							raise MutantTimeout('Can not start Windows runner.')
+					else:
+						with open(os.devnull, 'w') as fnull, redirect_stdout(fnull), redirect_stderr(fnull):
+							module_test = load_module(testfile.filename)
+							suite = unittest.TestLoader().loadTestsFromModule(module_test)		
+							decor = tmtdecor.timeout(TIMEOUT_SEGUNDOS, use_signals=True,timeout_exception=MutantTimeout)					
+							aplicar_timeout_em_suite(suite, decorador=decor)
+							resultado = RegistrandoRunner(stream=io.StringIO(), research=rse,verbosity=0,number=testfile.id).run(suite)
+				except Exception as ex:
+						print(red(f'Error. Can not run test file {testfile.filename}'))
+						print(red(ex))
+						sys.exit(1)
+				
+
+				for test in resultado.my_successes:
+					t = resultado.all_order[test.id()]
+					if verbose:
+						print(f'{t} passed.')
+					er.registro[test.id()] = 'live'
+					reg_muta.execucao = str(er)
+					reg_muta.save()
+					
+				for test,tb in resultado.failures:
+					t = resultado.all_order[test.id()]
+					if test in resultado.timeouts:
+						s = 'timeout'
+					else:
+						s = 'fail'
+					if verbose:
+						print(f'{t} {s}.')
+						#print('failure', test.id())
+						#print(tb)
+					
+					er.registro[test.id()] = s
+					reg_muta.execucao = str(er)
+					reg_muta.save()					
+					dead = True
+					
+
+				for test,_ in resultado.errors:
+					t = resultado.all_order[test.id()]
+					if test in resultado.timeouts:
+						s = 'timeout'
+					else:
+						s = 'error'
+					if verbose:
+						print(f'{t} {s}.')
+					#	print('error', test.id())
+						#print(tb)
+	
+					er.registro[test.id()] = s
+					reg_muta.execucao = str(er)
+					reg_muta.save()	
+					dead = True
+				if dead and not rse:
+					break
+
+					
+			if dead:
+				muta.status = 'dead'
+				print('Dead')
+				cont_dead += 1
+				muta.save()
+			else:
+				cont_live += 1
+				muta.status = 'live'
+				muta.save()
+	
+	print(green(f'Alive: {cont_live}'))
+	print(green(f'Dead: {cont_dead}'))
+	print(green(f'Equivalent: {cont_equiv}'))
+	if cont_live+cont_dead == 0:
+		print(green('Mutation score: {:.2f}'.format(0.0)))
+	else:
+		print(green('Mutation score: {:.3f}'.format(cont_dead/(cont_live+cont_dead))))
+
+
+
+TIMEOUT_SEGUNDOS = 2
+
+
+def aplicar_timeout_em_suite(suite, timeout_segundos=None, use_signals=False, decorador=None):
+	if decorador is None:
+		if timeout_segundos is None:
+			timeout_segundos = TIMEOUT_SEGUNDOS
+		decorador = tmtdecor.timeout(timeout_segundos, use_signals=use_signals, timeout_exception=MutantTimeout)
+	for item in suite:
+		if isinstance(item, unittest.TestSuite):
+			aplicar_timeout_em_suite(item, timeout_segundos, use_signals, decorador)
+		elif isinstance(item, unittest.TestCase):
+			nome_metodo = item._testMethodName
+			metodo_original = getattr(item, nome_metodo)
+
+			func_original = getattr(metodo_original, "__func__", metodo_original)
+			func_decorada = decorador(func_original)
+
+			setattr(item, nome_metodo, func_decorada.__get__(item, item.__class__))
+
+
+def __csv():
+	session_name = sys.argv.pop()
+	directory = None
+	outname = None
+	i = 2
+	while i < len(sys.argv[:-1]):
+		s = sys.argv[i]
+		match s:
+			case '--D':
+				i += 1
+				directory = sys.argv[i]
+			case '--O':
+				i += 1
+				outname = sys.argv[i]
+			case _:
+				usage()
+		i += 1
+
+	change_dir_connect(directory, session_name)
+
+	if outname is None:
+		outname = session_name+'.csv'
+
+
+	try:
+		with open(outname, 'w') as out:
+			writer = csv.writer(out)
+			for registro in Execution.select():
+				execucao = json.loads(registro.execucao)
+				if registro.id == 1:
+					row = ['mutant_id']
+					for campo in  execucao.keys():
+						row.append(campo)
+					writer.writerow(row)
+				row = [registro.mutant_id]
+				for campo,valor in execucao.items():
+					row.append(valor)
+
+				writer.writerow(row)
+
+		print(f'{outname} successfully generated')
+	except Exception as ex:
+		print(red(f'Could not generate {outname}'))
+		print(red(ex))
+		sys.exit(1)
+
+
+def __equiv():
+	session_name = sys.argv[-1]
+	directory = None
+	list_number = None
+	i = 2
+	while i < len(sys.argv[:-1]):
+		s = sys.argv[i]
+		match s:
+			case '--D':
+				i += 1
+				directory = sys.argv[i]
+			case '--x':
+				i += 1
+				list_number = sys.argv[i]
+			case _:
+				usage()
+		i += 1
+
+
+	try: 
+		change_dir_connect(directory, session_name)
+	except Exception as ex:
+		print(red(f'Can not access test session'))
+		print(red(ex))
+		sys.exit(1)	
+
+	# se os número não foram fornecidos, marca todos os vivos
+	if  list_number is None:
+		list_number = [] 
+		for numero in Mutant.select().where(Mutant.status == "live"):
+			list_number.append(numero.id)
+	else:
+		list_number = list_number.split()
+
+	with db.atomic():
+		for muta_number in list_number:
+			try:
+				muta_number = int(muta_number)
+				reg_muta = Mutant.get(Mutant.id==muta_number)
+				print('Mutant: ', reg_muta.id)
+				if not reg_muta.status in ['live','equiv']:
+					print(f'Warning: mutant {reg_muta.id} is not alive. It is {reg_muta.status}')
+				else:
+					reg_muta.status = 'equiv'
+					reg_muta.save()
+			except Exception as ex:
+				print(red(f'Can not access mutant number {muta_number}'))
+				print(red(ex))
+				sys.exit(1)
+
+def main():
+	n = len(sys.argv)-2
+	if n < 1:
+		usage()
+	
+	if sys.argv[1] == '--exec':
+		__exec()
+	elif sys.argv[1] == '--csv':
+		__csv()
+	elif sys.argv[1] == '--equiv':
+		__equiv()
+	else:
+		usage()
+
+
+def usage():
+	print('Usage:')
+	print('exemuta --exec [--keep] [--D <directory> ]  <session name>')
+	print('\tExecute the mutants with the test cases in the session')
+	print('\t--keep: execute only the live mutants')
+	print('exemuta --csv [--D <directory> ]  <session name>')
+	print('\tExports the last execution to a csv file')
+	print('exemuta --equiv --x <list of numbers> [--D <directory> ]  <session name>')
+	print('\tMarks mutants as equivalents') 
+	sys.exit(1)
+
+if __name__ == '__main__' :
+	main()

{pyproteum-0.2 → pyproteum-0.2.4}/pyproteum/moperators/cccr.py

@@ -4,8 +4,8 @@ from pyproteum.moperators.myoperator import *
 
 class Cccr(MyOperator):
 	
-	def __init__(self, original,filename,max):
-		super().__init__(original, filename, max)
+	def __init__(self, original,filename,max, **kwargs):
+		super().__init__(original, filename, max, **kwargs)
 		self.seq = 1
 		self.const_set = list()
 

{pyproteum-0.2 → pyproteum-0.2.4}/pyproteum/moperators/ccsr.py

@@ -5,8 +5,8 @@ import copy
 
 class Ccsr(MyOperator):
 	
-	def __init__(self, original,filename,max):
-		super().__init__(original, filename, max)
+	def __init__(self, original,filename,max, **kwargs):
+		super().__init__(original, filename, max, **kwargs)
 		self.seq = 1
 		self.scalar_set = set()
 		ParentSetter().visit(self.original)
@@ -21,13 +21,15 @@ class Ccsr(MyOperator):
 
 	def visit_Name(self, node):
 		if isinstance(node.ctx, ast.Store) :
-			self.scalar_set.add(node.id)
+			if not node.id in self.scalar_set:
+				self.scalar_set.add(node.id)
 		self.generic_visit(node)
 		return node
 
 	def visit_arg(self, node):
 		if node.arg != 'self':
-			self.scalar_set.add(node.arg)
+			if not node.arg in self.scalar_set:
+				self.scalar_set.add(node.arg)
 		self.generic_visit(node)
 		return node