def prepare_for_run(self):
"""Prepare the report folders for Kissenium execution
:return:
"""
self.clean_reports_folder()
SmallTools.check_path("reports/tmp")
def clean_tmp(self):
try:
g = glob.glob("reports/tmp/" + self.test + "*")
SmallTools.delete_from_glob(g)
except Exception as e:
self.logger.error(e)
self.logger.error(traceback.format_exc())
def clean_reports_folder():
"""Clean reports folder on every run
:return:
"""
reports_list = glob.glob("reports/*")
globs = [reports_list]
for g in globs:
SmallTools.delete_from_glob(g)
def test_logger(self):
"""Test the logger functions"""
#Setup the logger
logger = Log4Kissenium().setup(self._testMethodName, self.__class__.__name__)
message = 'Test of logger write to file'
logger.debug(message)
r = SmallTools.get_lines_from_file('reports/' + self.__class__.__name__ + '/', self._testMethodName + '.log')
self.assertIn(message, r[-1])
#Test the get logger
second_logger = Log4Kissenium().get_logger(self._testMethodName)
message = "Test the get logger function"
second_logger.info(message)
r = SmallTools.get_lines_from_file('reports/' + self.__class__.__name__ + '/', self._testMethodName + '.log')
self.assertIn(message, r[-1])
def generate(self):
logger = Log4Kissenium.get_logger("Kissenium")
try:
root = ET.Element("testsuites")
#root.set('duration', self.stats['duration'])
for k, v in self.results.items():
test, successes, errors, failures, skipped = (0, ) * 5
# Create the testsuite element, this will be completed after the testcases iteration
xml_ts = ET.SubElement(root, "testsuite")
# Iterate over testcases
for ki, vi in v.items():
test += 1
if (vi['status'] == 'success'):
successes += 1
elif (vi['status'] == 'error'):
errors += 1
elif (vi['status'] == 'failure'):
failures += 1
elif (vi['status'] == 'skipped'):
skipped += 1
xml_tc = ET.SubElement(xml_ts,
"testcase",
classname=k.replace('.', '/'),
name=k)
if not vi['status'] == "success":
ET.SubElement(xml_tc,
vi['status']).text = vi['message']
xml_ts.set('errors', str(errors))
xml_ts.set('failures', str(failures))
xml_ts.set('skipped', str(skipped))
xml_ts.set('tests', str(test))
xml_ts.set('name', k.split('.')[-1])
xml_ts.set('package', k.replace('.', '/'))
tree = ET.ElementTree(root)
s = minidom.parseString(ET.tostring(root, 'utf-8'))
SmallTools.create_file('Kissenium/', 'reports.xml',
s.toprettyxml(indent=" "))
except Exception as e:
logger.error(e)
logger.error(traceback.format_exc())
def capture_browser(self, browser, filename):
"""
Capture the test inside the brpwser
:param browser: Selenium instance
:param filename: Filename to use
:return:
"""
reports_folder = SmallTools.get_reports_folder(self.scenario)
browser.get_screenshot_as_file(reports_folder + filename)
def __init__(self, scenario, test):
# Note: if we wan't to record distant execution of kissenium (not implemented for now), we could think of using
# vnc server on the remote executor
threading.Thread.__init__(self)
self.scenario = scenario
self.reports_folder = SmallTools.get_reports_folder(self.scenario)
self.test = test
self.cancelled = False
self.config = Config()
self.logger = Log4Kissenium.get_logger("Kissenium")
def __init__(self, scenario, test):
"""
Initializing the Screenshot class
:param scenario: Scenario name
:param test: Test name
"""
self.scenario = scenario
self.test = test
self.cancelled = False
self.config = Config()
self.reports_folder = SmallTools.get_reports_folder(self.scenario)
def capture(self, browser, suffix=''):
"""
Capture the current test
:param browser: Selenium instance
:param suffix: Suffix to put to filename
:return:
"""
if suffix != '':
suffix = '-' + suffix
filename = SmallTools.sanitize_filename('%s%s.png' %
(self.test, suffix))
if self.config.get_capture_size() == 'Full':
self.capture_screen(filename)
else:
self.capture_browser(browser, filename)
def setup(self, name, path):
"""
Every log file will be created in "reports/" folder.
:param name: Filename of the log
:param path: Relative path of the log
:return: logger
"""
final_path = SmallTools.get_reports_folder(path)
logger = logging.getLogger(name)
logger.setLevel(self.get_log_level())
formatter = logging.Formatter(
'%(asctime)s :: %(levelname)s :: %(message)s')
file_handler = RotatingFileHandler(final_path + name + '.log', 'a',
1000000, 1)
file_handler.setLevel(self.get_log_level())
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
return logger
def setUp(self):
reports_list = glob.glob("reports/*")
globs = [reports_list]
for g in globs:
SmallTools.delete_from_glob(g)
SmallTools.check_path("reports/tmp")