505 lines
17 KiB
Python
505 lines
17 KiB
Python
import json
|
|
import os
|
|
import subprocess
|
|
import sys
|
|
import importlib
|
|
import threading
|
|
import time
|
|
from collections import deque
|
|
|
|
from modules.internal_io import global_status
|
|
from modules import size_test, adler_test # noqa # Used to force import of modules by pyinstaller
|
|
|
|
"""
|
|
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]
|
|
"""
|
|
from termcolor import colored
|
|
os.system('color')
|
|
# red, green, yellow, blue, magenta, cyan, white.
|
|
|
|
_TEST_MODULES = {
|
|
"spidey": ["spidey_test", "SpideyTest"],
|
|
# "test_walk": ["test_template", "TestWalkTemplate"],
|
|
"size_test": ["size_test", "SizeTest"],
|
|
"adler_test": ["adler_test", "AdlerTest"],
|
|
}
|
|
|
|
PROGRAM_VERSION = "1.0.0"
|
|
POST_RUN_ALLOWED = False # TODO : Remove this line, only use is_infected
|
|
RUN_OVER = False
|
|
|
|
queue_lock = threading.Lock()
|
|
processes_lock = threading.Lock()
|
|
|
|
CLEAR_CODE = colored(r"""
|
|
_______ _
|
|
(_______) |
|
|
_ | | _____ _____ ____
|
|
| | | || ___ (____ |/ ___)
|
|
| |_____| || ____/ ___ | |
|
|
\______)\_)_____)_____|_|
|
|
""", 'green')
|
|
|
|
INFECTED_CODE = colored(r"""
|
|
_ ___ _
|
|
| | / __) _ | |
|
|
| |____ _| |__ _____ ____ _| |_ _____ __| |
|
|
| | _ (_ __) ___ |/ ___|_ _) ___ |/ _ |
|
|
| | | | || | | ____( (___ | |_| ____( (_| |
|
|
|_|_| |_||_| |_____)\____) \__)_____)\____|
|
|
""", 'red')
|
|
|
|
LOGO = colored(r"""
|
|
__ \ _) | | | |
|
|
| | | __| __| _ \ __| _` | | | _ \ | __ \ _ \ __|
|
|
| | | \__ \ ( ( | | ( | ___ | __/ | | | __/ |
|
|
____/ _| ____/ \___| \___/ _| \__,_| _| _| \___| _| .__/ \___| _|
|
|
_|
|
|
""", "cyan")
|
|
|
|
|
|
class TestRunner:
|
|
def __init__(self, args, agnpath, start_time):
|
|
"""
|
|
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
|
|
:param start_time: The time the test started
|
|
:type start_time: float
|
|
"""
|
|
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.start_time = start_time
|
|
|
|
self.is_infected = 0
|
|
self.detections = 0
|
|
self.test_run = {}
|
|
|
|
self.loaded_test_modules = {}
|
|
self.loaded_test_classes = {}
|
|
self.list_of_tests = []
|
|
self.dict_of_processes = {} # To get a more granular view of the processes
|
|
self.update_module_list()
|
|
|
|
self.base_data = {}
|
|
self.finished_tests = deque()
|
|
|
|
self.open_base_data()
|
|
self.exec_all_tests()
|
|
|
|
def open_base_data(self):
|
|
"""
|
|
Opens the base data file
|
|
"""
|
|
|
|
default_database = resource_path(self.agnostic_path.default_database)
|
|
if not self.args.database:
|
|
self.args.database = default_database
|
|
|
|
if os.path.exists(self.args.database):
|
|
print(colored(f" > Opening specified database {self.args.database}", "green")) # TODO : Only if verbose
|
|
with open(self.args.database, "r") as f:
|
|
self.base_data = json.load(f)
|
|
return self.base_data
|
|
elif os.path.exists(resource_path(default_database)): # Try opening the default database
|
|
print(colored(
|
|
"\n > The database file specified does not exist, "
|
|
"trying to open the default one for your os...\n", "yellow"
|
|
))
|
|
with open(resource_path(default_database), "r") as f:
|
|
self.base_data = json.load(f)
|
|
return self.base_data
|
|
|
|
else:
|
|
print(colored(
|
|
"\n > The database file does not exist, and the default "
|
|
"one for your os does not exist either.\n", "red"
|
|
))
|
|
self.base_data = {}
|
|
return self.base_data
|
|
|
|
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
|
|
"""
|
|
self.list_of_tests = []
|
|
for module_name, test_class in self.loaded_test_classes.items():
|
|
print(colored(f" > Starting test {module_name}...", "blue"))
|
|
tc = test_class(
|
|
self.args,
|
|
self.agnostic_path,
|
|
self.base_data,
|
|
self.finished_tests,
|
|
queue_lock,
|
|
self.dict_of_processes,
|
|
processes_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()
|
|
|
|
def controller_test(self):
|
|
"""
|
|
Kills the tests if the user press enter
|
|
"""
|
|
print(colored("\n > All test started, press ENTER to abort...\n", "blue"))
|
|
while True:
|
|
# print("Controller still up")
|
|
try:
|
|
if input() == "":
|
|
global POST_RUN_ALLOWED, RUN_OVER
|
|
print(colored("\n > Aborting tests...\n", "red"))
|
|
if not self.is_infected:
|
|
POST_RUN_ALLOWED = True
|
|
RUN_OVER = True
|
|
return
|
|
except KeyboardInterrupt:
|
|
RUN_OVER = True
|
|
return
|
|
except:
|
|
sys.exit()
|
|
|
|
def post_test_runner(self):
|
|
"""
|
|
Runs the post test runner if all tests are finished
|
|
"""
|
|
global POST_RUN_ALLOWED, RUN_OVER
|
|
if self.args.launch:
|
|
while True:
|
|
if RUN_OVER:
|
|
if POST_RUN_ALLOWED and self.is_infected == 0: # Second part is redundant
|
|
print(colored("\n > Running post test runner...", "green"))
|
|
if self.agnostic_path.os == "windows":
|
|
subprocess.Popen([self.agnostic_path.main_path + f"\\Discord{self.agnostic_path.ptb}.exe"])
|
|
return 0
|
|
return 1
|
|
time.sleep(0.1)
|
|
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()
|
|
self.get_status()
|
|
# time.sleep(0.5)
|
|
# When all tests are finished or the user stopped the tests, we can proceed
|
|
if self.is_infected == 0:
|
|
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
|
|
"""
|
|
status = self.get_status()
|
|
if status.tests_finished == status.tests_total:
|
|
if status.tests_failed != 0:
|
|
exit_code = 1 # There is one failure, so the test failed
|
|
elif status.tests_success == status.tests_total:
|
|
exit_code = 0 # All tests passed
|
|
else:
|
|
# print("Something went wrong, please report this bug.")
|
|
# print(status)
|
|
exit_code = 2 # Something went wrong
|
|
else:
|
|
global RUN_OVER
|
|
if RUN_OVER:
|
|
print(colored("\n > Tests aborted, please check the logs.", "red"))
|
|
exit_code = 3
|
|
else:
|
|
exit_code = -1 # The tests are not finished
|
|
return exit_code
|
|
|
|
def get_status(self):
|
|
"""
|
|
Gets the status of the tests
|
|
:return: The status
|
|
:rtype: internal_io.global_status
|
|
"""
|
|
queue_lock.acquire(timeout=0.5)
|
|
nb_tests = len(self.list_of_tests)
|
|
nb_tests_success = 0
|
|
nb_tests_failure = 0
|
|
nb_tests_skipped = 0
|
|
progress = 0
|
|
for test in self.finished_tests:
|
|
if test.status == "success":
|
|
nb_tests_success += 1
|
|
elif test.status == "failure":
|
|
nb_tests_failure += 1
|
|
self.is_infected += 1
|
|
elif test.status == "skipped":
|
|
nb_tests_skipped += 1
|
|
elif test.status == "problem":
|
|
nb_tests_failure += 1
|
|
# progress += test.progress
|
|
queue_lock.release()
|
|
|
|
for test_name, test in self.dict_of_processes.items():
|
|
progress += test.progress
|
|
progress = int(progress / nb_tests)
|
|
|
|
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,
|
|
tests_success=nb_tests_success,
|
|
tests_failed=nb_tests_failure,
|
|
tests_running=nb_test_running,
|
|
tests_skipped=nb_tests_skipped,
|
|
tests_error=nb_tests_failure,
|
|
progress=progress
|
|
)
|
|
|
|
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)
|
|
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 print_status(status, timer_start):
|
|
"""
|
|
Prints the status
|
|
:param status: The status
|
|
:type status: internal_io.global_status
|
|
:param timer_start: The start time of the tests
|
|
:type timer_start: float
|
|
"""
|
|
if status.tests_failed != 0:
|
|
color = "red"
|
|
else:
|
|
color = "green"
|
|
|
|
print(colored("\n > Status:", color))
|
|
if status.tests_total == 0:
|
|
print(colored(" > No test found", "red"))
|
|
return
|
|
|
|
print(colored(
|
|
f" > Test finished {status.tests_finished}/{status.tests_total}"
|
|
f": {status.tests_success} success, "
|
|
f"{status.tests_failed} failed, "
|
|
f"{status.tests_error} problem", color
|
|
))
|
|
if status.tests_running != 0:
|
|
ellapsed_time = time.time() - timer_start
|
|
if status.progress == 0:
|
|
estimated_time = "∞"
|
|
else:
|
|
mon, sec = divmod(ellapsed_time * 100 / status.progress, 60)
|
|
hr, mon = divmod(mon, 60)
|
|
estimated_time = "%d:%02d:%02d" % (hr, mon, sec)
|
|
print(colored(
|
|
f" > Overall progress: {status.progress}%"
|
|
f" in {time.time() - timer_start:.2f} seconds"
|
|
f" estimaded time ({estimated_time})", color
|
|
))
|
|
|
|
|
|
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
|
|
"""
|
|
# Initialize the test runner
|
|
print(LOGO)
|
|
start = time.time()
|
|
tr = TestRunner(args, agnpath, start_time=start) # All operation are executed in parallel and the user can stop them
|
|
|
|
# Poll information from the tests
|
|
POLLRATE, PRINT_RATE, COUNTER = args.pollrate, args.printrate, 0
|
|
COUNTER_MAX = int(PRINT_RATE / POLLRATE)
|
|
|
|
# Main test polling loop
|
|
while tr.get_exit_code() == -1:
|
|
if (COUNTER % COUNTER_MAX) == 0:
|
|
print_status(tr.get_status(), start)
|
|
time.sleep(POLLRATE)
|
|
COUNTER += 1
|
|
|
|
# Print the final status
|
|
global RUN_OVER
|
|
RUN_OVER = True
|
|
|
|
# Final status
|
|
print_final_status(tr, start, args)
|
|
|
|
# Export the data
|
|
if args.gen_data:
|
|
gen_save_data(args, tr)
|
|
|
|
# Sleep for a while to let the user see the final status
|
|
time.sleep(args.timeout)
|
|
sys.exit(tr.get_exit_code())
|
|
|
|
|
|
def resource_path(relative_path):
|
|
""" Get absolute path to resource, works for dev and for PyInstaller """
|
|
try:
|
|
# PyInstaller creates a temp folder and stores path in _MEIPASS
|
|
base_path = sys._MEIPASS # noqa
|
|
except Exception:
|
|
base_path = os.path.abspath(".")
|
|
return os.path.join(base_path, relative_path)
|
|
|
|
|
|
def print_final_status(testrunner, start_time, args):
|
|
"""
|
|
Prints the final status
|
|
"""
|
|
status = testrunner.get_status()
|
|
if status.tests_failed == 0:
|
|
color = "green"
|
|
print(CLEAR_CODE)
|
|
else:
|
|
color = "red"
|
|
print(INFECTED_CODE)
|
|
print(colored(f"\nThe test sequence is now finished, DiscordHelper ran for {round(time.time() - start_time,2)} seconds", color))
|
|
SIZE = args.size
|
|
for test, test_object in testrunner.dict_of_processes.items():
|
|
if test_object.status_code == "success":
|
|
print(colored(f" > {fill_it(SIZE,test,'SUCCESS')}", "green"))
|
|
elif test_object.status_code == "failure":
|
|
print(colored(f" > {fill_it(SIZE,test,'FAILURE')}", "red"))
|
|
error_message = fit_it_under(test_object.status, SIZE-3, ' > ')
|
|
if args.max_shown != -1: # TODO : Correct this abomination
|
|
table = error_message.split("\n")
|
|
extra = [f" > ... {len(table) - args.max_shown} more lines"] if len(table) > args.max_shown else []
|
|
error_message = "\n".join(table[:args.max_shown] + extra)
|
|
print(colored(f"{error_message}", "red"))
|
|
else:
|
|
print(colored(f" > {fill_it(SIZE,test,test_object.status_code.upper())}", "yellow"))
|
|
msg_error = "sucessfully" if status.tests_failed == 0 else f"with {status.tests_error} errors"
|
|
print(colored(f"\nThe program executed {msg_error}, exiting in {args.timeout} seconds...", color))
|
|
|
|
|
|
def fill_it(size, string1, string2):
|
|
"""
|
|
Fills a string with a character
|
|
"""
|
|
return string1 + max(size - len(string1)-len(string2), 0) * "." + string2
|
|
|
|
|
|
def fit_it_under(message, size, start_line=""):
|
|
"""
|
|
Fits a message under a size
|
|
"""
|
|
final_message = ""
|
|
for line in message.split('\n'):
|
|
if len(line) > size:
|
|
final_message += start_line + line[:size] + "\n"
|
|
final_message += fit_it_under(line[size:], size, start_line)
|
|
else:
|
|
final_message += start_line + line + "\n"
|
|
# final_message += start_line + line + '\n'
|
|
# if len(message) > size:
|
|
# return message[:size-3] + "..."
|
|
return final_message
|
|
|
|
|
|
def gen_save_data(args, test_runner):
|
|
"""
|
|
Generates the save data
|
|
"""
|
|
print(colored("\n > Generating data...", "blue"))
|
|
data = test_runner.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(colored(" > Making folder...", "blue"))
|
|
os.makedirs(folder)
|
|
print(colored(f" > Exporting the test data to {file_path}", "blue"))
|
|
main_data = export_data(test_runner, data)
|
|
# print(main_data)
|
|
with open(file_path, "w") as f:
|
|
json.dump(main_data, f, indent=4)
|