301 lines
9.4 KiB
Python
301 lines
9.4 KiB
Python
import json
|
||
import os
|
||
import sys
|
||
import importlib
|
||
import threading
|
||
import time
|
||
from collections import deque
|
||
from modules.internal_io import global_status # , test_status, return_code_dict
|
||
|
||
"""
|
||
All modules that can be tested
|
||
Associate the arguments passed to the command line with the modules to be loaded
|
||
argparse argument : [module_name, class_name]
|
||
"""
|
||
_TEST_MODULES = {
|
||
"spidey": ["spidey_test", "SpideyTest"],
|
||
#"test_walk": ["test_template", "TestWalkTemplate"],
|
||
}
|
||
|
||
PROGRAM_VERSION = "1.0.0"
|
||
POST_RUN_ALLOWED = False
|
||
|
||
queue_lock = threading.Lock()
|
||
|
||
CLEAR_CODE = r"""
|
||
_______ _
|
||
(_______) |
|
||
_ | | _____ _____ ____
|
||
| | | || ___ (____ |/ ___)
|
||
| |_____| || ____/ ___ | |
|
||
\______)\_)_____)_____|_|
|
||
"""
|
||
|
||
INFECTED_CODE = r"""
|
||
_ ___ _
|
||
| | / __) _ | |
|
||
| |____ _| |__ _____ ____ _| |_ _____ __| |
|
||
| | _ (_ __) ___ |/ ___|_ _) ___ |/ _ |
|
||
| | | | || | | ____( (___ | |_| ____( (_| |
|
||
|_|_| |_||_| |_____)\____) \__)_____)\____|
|
||
"""
|
||
|
||
if os.name == "nt":
|
||
CLEAR_CODE = r"[32m" + CLEAR_CODE + r"[0m"
|
||
INFECTED_CODE = r"[91m" + INFECTED_CODE + r"[0m"
|
||
|
||
|
||
class TestRunner:
|
||
def __init__(self, args, agnpath):
|
||
"""
|
||
Main spidey runner
|
||
:param args: List of arguments
|
||
:type args: argparse.Namespace
|
||
:param agnpath: The path to the discord folder
|
||
:type agnpath: agnostic_path.AgnosticPath
|
||
"""
|
||
self.ptb = args.ptb
|
||
self.args = args
|
||
self.agnostic_path = agnpath
|
||
self.os_name = agnpath.os
|
||
self.main_path = agnpath.main_path
|
||
self.version = agnpath.version
|
||
|
||
self.is_infected = 0
|
||
self.detections = 0
|
||
self.test_run = {}
|
||
|
||
self.loaded_test_modules = {}
|
||
self.loaded_test_classes = {}
|
||
self.list_of_tests = []
|
||
self.update_module_list()
|
||
|
||
self.finished_tests = deque()
|
||
|
||
self.exec_all_tests()
|
||
|
||
def update_module_list(self):
|
||
"""
|
||
Gets the list of modules to be loaded (in accordance to the config)
|
||
:return: List of modules
|
||
:rtype: list
|
||
"""
|
||
modules = {}
|
||
classes = {}
|
||
module_name = None
|
||
try:
|
||
for module_name, values in _TEST_MODULES.items():
|
||
if self.args.all or self.args.__getattribute__(module_name):
|
||
modules[values[0]] = importlib.import_module(f"modules.{values[0]}")
|
||
classes[values[0]] = getattr(modules[values[0]], values[1])
|
||
|
||
except AttributeError as e:
|
||
print(f"The module {module_name} was not loaded because it was not specified in the config.")
|
||
print(e)
|
||
|
||
self.loaded_test_modules.update(modules)
|
||
self.loaded_test_classes.update(classes)
|
||
|
||
def exec_all_tests(self):
|
||
"""
|
||
Executes all the tests, get their result as they finishes
|
||
:return: The number of test ran, success, failures, skipped (with ran = success+failures+skip)
|
||
:rtype: (int,int,int,int) # TODO: Change this to a nametuple
|
||
"""
|
||
self.list_of_tests = []
|
||
for module_name, test_class in self.loaded_test_classes.items():
|
||
print(f"Starting test {module_name}")
|
||
tc = test_class(self.args, self.agnostic_path, None, self.finished_tests, queue_lock)
|
||
tc = threading.Thread(target=tc.run_test, args=())
|
||
tc.name = str(module_name)
|
||
tc.daemon = True
|
||
self.list_of_tests.append(tc)
|
||
tc.start()
|
||
|
||
# Launch a controller to allow the user to stop all tests
|
||
# controller = threading.Thread(target=self.test_launcher)
|
||
# Allow the user to stop the tests
|
||
tc = threading.Thread(target=self.controller_test, args=())
|
||
tc.daemon = True
|
||
tc.start()
|
||
|
||
# Await the end of the tests or the user interruption
|
||
tc = threading.Thread(target=self.post_test_runner, args=())
|
||
tc.start()
|
||
|
||
# Wait for the end of the tests
|
||
tc = threading.Thread(target=self.test_waiter, args=())
|
||
tc.daemon = True
|
||
tc.start()
|
||
|
||
return self.is_infected, self.detections, self.test_run
|
||
|
||
def controller_test(self):
|
||
"""
|
||
Kills the tests if the user press enter
|
||
"""
|
||
print("Press enter to stop the tests: ")
|
||
while True:
|
||
if input() == "":
|
||
if not self.is_infected:
|
||
global POST_RUN_ALLOWED
|
||
POST_RUN_ALLOWED = True
|
||
return
|
||
|
||
def post_test_runner(self):
|
||
"""
|
||
Runs the post test runner if all tests are finished
|
||
"""
|
||
global POST_RUN_ALLOWED
|
||
if self.args.launch:
|
||
while True:
|
||
if POST_RUN_ALLOWED:
|
||
print("Running post test runner...")
|
||
return 0
|
||
time.sleep(0.5)
|
||
return 0
|
||
|
||
def test_waiter(self):
|
||
"""
|
||
Waits for the end of the tests
|
||
:return:
|
||
"""
|
||
for t in self.list_of_tests: # Can only proceed if all tests are finished
|
||
t.join()
|
||
|
||
# When all tests are finished or the user stopped the tests, we can proceed
|
||
if not self.is_infected:
|
||
global POST_RUN_ALLOWED
|
||
POST_RUN_ALLOWED = True
|
||
|
||
def get_exit_code(self):
|
||
"""
|
||
Gets the exit code of the tests
|
||
:return: The exit code
|
||
:rtype: int
|
||
"""
|
||
global POST_RUN_ALLOWED
|
||
if POST_RUN_ALLOWED:
|
||
for t in self.list_of_tests:
|
||
if t.is_alive():
|
||
return 2 # 2 means that the user stopped the tests before the end
|
||
return self.is_infected # The user didn't stop the tests
|
||
|
||
return -1 # The program is not finished yet
|
||
|
||
def get_status(self):
|
||
"""
|
||
Gets the status of the tests
|
||
:return: The status
|
||
:rtype: str
|
||
"""
|
||
queue_lock.acquire()
|
||
nb_tests = len(self.list_of_tests)
|
||
nb_tests_success = 0
|
||
nb_tests_failure = 0
|
||
nb_tests_skipped = 0
|
||
for test in self.finished_tests:
|
||
print(f"Test {test.name} finished with status {test.status}")
|
||
if test.status == "success":
|
||
nb_tests_success += 1
|
||
elif test.status == "failure":
|
||
nb_tests_failure += 1
|
||
elif test.status == "skipped":
|
||
nb_tests_skipped += 1
|
||
elif test.status == "problem":
|
||
nb_tests_failure += 1
|
||
queue_lock.release()
|
||
nb_tests_ran = nb_tests_success + nb_tests_failure + nb_tests_skipped
|
||
nb_test_running = nb_tests - nb_tests_ran
|
||
return global_status(
|
||
tests_total=nb_tests,
|
||
tests_finished=nb_tests_ran,
|
||
test_success=nb_tests_success,
|
||
tests_failed=nb_tests_failure,
|
||
tests_running=nb_test_running,
|
||
tests_skipped=nb_tests_skipped,
|
||
tests_error=nb_tests_failure
|
||
)
|
||
|
||
def get_test_data(self):
|
||
"""
|
||
Gets the test data
|
||
:return: The test data
|
||
:rtype: dict
|
||
"""
|
||
data = {}
|
||
queue_lock.acquire()
|
||
for test in self.finished_tests:
|
||
for key, value in test.data.items():
|
||
if key not in data:
|
||
data[key] = value
|
||
else:
|
||
data[key].update(value)
|
||
# data.update(test.data)
|
||
queue_lock.release()
|
||
return data
|
||
|
||
|
||
def export_data(test_runner, data):
|
||
"""
|
||
Exports the test data
|
||
:param test_runner: The test runner
|
||
:type test_runner: TestRunner
|
||
:param data: The test data
|
||
:type data: dict
|
||
"""
|
||
main_data = {
|
||
"global":
|
||
{
|
||
"os": test_runner.os_name,
|
||
"ptb": test_runner.ptb,
|
||
"discord_version": test_runner.version,
|
||
"program_version": PROGRAM_VERSION,
|
||
},
|
||
"tests": data,
|
||
}
|
||
return main_data
|
||
|
||
|
||
def run_check(args, agnpath):
|
||
"""
|
||
Runs all operations selected in the config
|
||
:param args: List of arguments
|
||
:param agnpath: Annostic path to the discord folder
|
||
:return: None
|
||
"""
|
||
tr = TestRunner(args, agnpath) # All operation are executed in parallel and the user can stop them
|
||
|
||
print("Waiting for the end of the tests")
|
||
while tr.get_exit_code() == -1:
|
||
print(tr.get_status()) # TODO : Print status in a more readable way
|
||
time.sleep(0.5)
|
||
print("The test sequence is now finished")
|
||
|
||
status = tr.get_status()
|
||
print(status) # TODO: Print the final status, test still running are actually skipped
|
||
if status.tests_failed > 0:
|
||
print(INFECTED_CODE)
|
||
tr.is_infected = True
|
||
else:
|
||
print(CLEAR_CODE)
|
||
tr.is_infected = False
|
||
|
||
if args.gen_data:
|
||
print("Generating data...")
|
||
data = tr.get_test_data()
|
||
file_path = os.path.join(os.path.join("databases", args.gen_data[0]))
|
||
folder = os.path.dirname(file_path)
|
||
if not os.path.exists(folder):
|
||
print("Making folder...")
|
||
os.makedirs(args.gen_data)
|
||
print("Exporting data...") # TODO : Advertize where the data is exported
|
||
main_data = export_data(tr, data)
|
||
# print(main_data)
|
||
with open(file_path, "w") as f:
|
||
json.dump(main_data, f, indent=4)
|
||
|
||
print(f"Exiting in {args.timeout} seconds...")
|
||
time.sleep(args.timeout)
|
||
sys.exit(tr.get_exit_code())
|