class Run(object):
def __init__(self, config=None):
self.config = Configuration(config)
self.module_list = []
self.run_log = Logger()
def execute_tests(self):
Logger.count_time()
# Initialize Engine
self.run_log.separate(
"Pyroute Acceptance Testing Framework (insert logo)")
session = Pyroute.EngineInitializer(self.config)
# Start testing
session.start()
class PyrouteTestEngine(object):
"""
Pyroute's default engine "PYT", runs every test listed in config.
Check the documentation for more details about the test format.
"""
def __init__(self, config, module_engine):
self.config = config
self.module_engine = module_engine
self.loaded_methods = self.module_engine.loaded_methods
self.I = ITester(*self.loaded_methods)
self.engine_log = Logger()
def get_tests(self):
"""
Test finder allows the user to specify tests with
and without a '.py' and also allows the user to
specify a directory path with and without "/" if
there's a file and a folder with the same name,
the file and the folder and its files will be
loaded.
"""
tests_path = []
for test in self.config._tests['path']:
test_path = '{}/{}'.format(os.getcwd(),test)
py_file = '{}.py'.format(test_path)
if os.path.isdir(test_path):
folder = os.listdir(test_path)
files =[os.path.join(test_path, file) for\
file in folder if file.endswith(".py")]
[tests_path.append(file) for file in files]
if os.path.isfile(py_file):
tests_path.append(py_file)
else:
tests_path.append(test_path)
return tests_path
def load_tests(self):
"""
Loads tests. Self explanatory. This method uses PyrouteImporter,
the same mechanism behind the module system, to load them. More
details in 'utils.py'
"""
paths = self.get_tests()
loaded_tests = {}
for testpath in paths:
testfile = os.path.basename(testpath)
testname = str(testfile)[:-3] # Name without the '.py' extension
loaded = PyrouteImporter.load(testfile, testpath)
loaded_tests[testname] = loaded
return loaded_tests
def get_test_cases(self, test):
"""
Comprehension to filter the test cases we are interested in.
Before this, the test object has some properties we don't case about,
thus we filter them out. We also filter out those tests that don't
start with the preffix specified in the configuration file.
"""
cases = (case_name for case_name in dir(test)
if not case_name.startswith("__") and
case_name.startswith(self.config._tests['preffix']))
return cases
def run_cases(self, test_name, test, cases):
"""
Runs cases, self explanatory. The process method is explained in
the Logger, but basically it acts as a wrapper.
"""
for case in cases:
message = "Running test: {0} - Case: {1}".format(test_name, case)
self.engine_log.process(message, getattr(test, case), self.I)
def _start_engine(self):
"""
This function is called by the EngineInitializer.
For now, it counts the passed tests, and runs each case, per test.
The Logger here does nothing, it is intended to run the background
tracer to deal with errors.
"""
passed = 0
loaded_tests = self.engine_log.process("Loading tests", self.load_tests)
loaded = len(loaded_tests.keys())
self.engine_log.custom("[{:0>3}]".format(loaded), "Tests loaded")
for name, test in loaded_tests.items():
cases = self.get_test_cases(test)
self.run_cases(name, test, cases)
message_end = "Test: {0} --- Finished".format(name)
self.engine_log.custom("[-O-]", message_end)
passed += 1
self.finish(passed)
# This function runs at the end of all tests, anything done at that time goes here
def finish(self, passed_tests):
self.engine_log.custom("[>:D]", "All tests completed")
self.engine_log.separate("<<<< {0} Passed in {1:.3}s >>>>".format(passed_tests, Logger.elapsed_time()))