def run(self):
fs.mkdirs(self.output)
log_conf = {
"version": 1,
"disable_existing_loggers": False,
"formatters": {"verbose": {"format": DEFAULT_LOG_LAYOUT}},
"handlers": {
"console": {"class": "logging.StreamHandler", "level": "DEBUG", "formatter": "verbose"},
"file_cli": {
"class": "logging.handlers.RotatingFileHandler",
"level": "DEBUG",
"formatter": "verbose",
"filename": os.path.join(self.output, "main.log"),
"maxBytes": 50000000,
"backupCount": 10,
},
},
"root": {"level": "DEBUG", "handlers": ["console", "file_cli"]},
}
logging.config.dictConfig(log_conf)
runner_node = self.setting.etree.find("testrunner")
failfast = True if self.failfast else get_boolean_from_string(runner_node.get("failfast", "False"))
context = TestContext()
runner = TestRunner(failfast=failfast, context=context)
runner.context.add_listener(TestCaseLogFileInterceptor(self.output))
runner.context.add_listener(TestResultShelveInterceptor(os.path.join(self.output, "result.shelve")))
context_node = runner_node.find("context")
if context_node is not None:
for name, value in context_node.attrib.items():
setattr(context, name, value)
testfixture_node = context_node.find("fixture")
if testfixture_node is not None:
if self.TestFixtureFactory is None:
raise RuntimeError("Require TestFixtureFactory class to build the testfixture.")
context.fixture = self.TestFixtureFactory.build_testfixture_by_element(testfixture_node)
for testsuite_node in list(runner_node.find("testsuites")):
loader = TestSuiteXmlLoader(testsuite_node)
runner.add_testsuite(loader.as_dict())
try:
runner.run()
finally:
report_node = self.setting.etree.find("report")
summary = self.setting.get("//report/summary/text()")
tester = self.setting.get("//report/tester/text()")
template = report_node.get("template")
report = SimpleHtmlReporter(runner.result, runner.context, template, summary, tester)
output = report_node.get("output") or os.path.join(self.output, "report.html")
report.generate(output)
def run(self, report_basename: str = None) -> None:
fs.mkdirs(self.output_dir)
result = TestResult()
runners = self.new_runners(result)
try:
for runner in runners:
try:
runner.run()
except:
logger.exception("")
finally:
self.generate_report(result, report_basename)
def getdir(self, rsrc, ldst, exclude):
fs.mkdirs(ldst)
for name in self.listdir(rsrc):
rsrc_name = posixpath.join(rsrc, name)
if exclude and exclude.search(rsrc_name):
logger.info("scp get: skip %s", rsrc_name)
continue
ldst_name = os.path.join(ldst, name)
if self.isdir(rsrc_name):
self.getdir(rsrc_name, ldst_name, exclude)
else:
logger.debug("scp get: %s -> %s", rsrc_name, ldst_name)
self.get(rsrc_name, ldst_name)
def __create_simple(self, fp):
template = self._j2_env.get_template(self._template)
duration = self._result.finish_time - self._result.start_time
stream = template.stream(
title=self._title or "Test Report",
ts_records=self._ts_records,
start_time=self._result.start_time.strftime("%Y-%m-%d %H:%M:%S"),
duration=str(duration)[0:-7],
tester=self._tester,
context=self._context
)
if isinstance(fp, str):
fs.mkdirs(os.path.dirname(fp))
stream.dump(fp)
def __create_simple(self, filename: str) -> None:
j2_loader = jinja2.FileSystemLoader(self.template_dirs)
j2_env = jinja2.Environment(loader=j2_loader, trim_blocks=True, lstrip_blocks=True, autoescape=True)
j2_env.filters["path_basename"] = os.path.basename
j2_env.filters["path_dirname"] = os.path.dirname
j2_env.filters["path_relpath"] = os.path.relpath
j2_template = j2_env.get_template(self.template)
output_dir = os.path.dirname(filename)
stream = j2_template.stream(
_result_=self.result,
_output_dir_=output_dir,
_chart_position_=self.chart_position,
_chart_display_=self.chart_display,
_detail_display_=self.detail_display,
**self.extras
)
fs.mkdirs(output_dir)
stream.dump(filename)
def scp_get(self, rsrc: str, ldst: str, exclude: str=None) -> None:
logger.info("scp get: rsrc=%s, ldst=%s, exclude=%s", rsrc, ldst, exclude)
if self.isdir(rsrc):
self.getdir(rsrc, ldst, exclude)
else:
name = os.path.basename(rsrc)
if os.path.exists(ldst):
if os.path.isdir(ldst):
ldst_path = posixpath.join(ldst, name)
else:
ldst_path = ldst
else:
if ldst.endswith("\\") or ldst.endswith("/"):
fs.mkdirs(ldst)
ldst_path = posixpath.join(ldst, name)
else:
fs.mkdirs(os.path.dirname(ldst))
ldst_path = ldst
logger.debug("scp get: %s -> %s", rsrc, ldst_path)
self.get(rsrc, ldst_path)
def init(cls, dest_dir: str, include_sample: bool = True) -> None:
"""
Init destination dir as work dir.
Parameters
----------
dest_dir: str
Specify destination dir.
include_sample: bool, optional
Whether include sample cases when initialize work dir.
"""
logging.basicConfig(level=logging.DEBUG)
fs.mkdirs(dest_dir)
ngta_dir = os.path.dirname(__file__)
init_dir = os.path.join(ngta_dir, INIT_DIR_BASENAME)
conf_dir = os.path.join(init_dir, CONF_DIR_BASENAME)
exclude = None if include_sample else 'sample'
fs.copy(init_dir, dest_dir, exclude)
fs.mkdirs(os.path.join(dest_dir, LIBS_DIR_BASENAME))
fs.mkdirs(os.path.join(dest_dir, LOGS_DIR_BASENAME))
for src_conf in fs.find(conf_dir, top_dir=False):
src_base = os.path.basename(src_conf)
dst_conf = os.path.join(dest_dir, CONF_DIR_BASENAME, src_base.replace("_sample", ""))
if os.path.exists(dst_conf):
_diff(src_conf, dst_conf)
else:
fs.copy(src_conf, dst_conf)
def on_testcase_stop(self, testcase):
log.remove_log_handler(self.log_handler)
if self.classify and testcase.record.status in (TestCaseResultRecord.Status.SKIPPED,
TestCaseResultRecord.Status.FAILED,
TestCaseResultRecord.Status.ERRONEOUS,
TestCaseResultRecord.Status.WARNING):
new_log_dir = os.path.join(testcase.log_dir, testcase.record.status.name.lower())
testcase.log_dir = new_log_dir
try:
fs.mkdirs(new_log_dir)
src = self.log_name
dst = os.path.join(new_log_dir, os.path.basename(self.log_name))
logger.info("move: %s -> %s", src, dst)
shutil.move(src, dst)
for index, ext_log_name in enumerate(testcase.ext_log_names):
logger.info("move: %s -> %s", ext_log_name, new_log_dir)
shutil.move(ext_log_name, new_log_dir)
testcase.ext_log_names[index] = os.path.join(new_log_dir, os.path.basename(ext_log_name))
except (shutil.Error, IOError):
logger.exception("")
self.log_name = None
self.log_handler = None
def scp_get(self, rsrc, ldst, exclude=None):
logger.info("scp get: rsrc=%s, ldst=%s, exclude=%s", rsrc, ldst, exclude)
if exclude is not None and not isinstance(exclude, re._pattern_type):
exclude = re.compile(exclude)
if self.isdir(rsrc):
self.getdir(rsrc, ldst, exclude)
else:
name = os.path.basename(rsrc)
if os.path.exists(ldst):
if os.path.isdir(ldst):
ldst_path = posixpath.join(ldst, name)
else:
ldst_path = ldst
else:
if ldst.endswith("\\") or ldst.endswith("/"):
fs.mkdirs(ldst)
ldst_path = posixpath.join(ldst, name)
else:
fs.mkdirs(os.path.dirname(ldst))
ldst_path = ldst
logger.debug("scp get: %s -> %s", rsrc, ldst_path)
self.get(rsrc, ldst_path)
def create_log_handler(self, runner_id):
fs.mkdirs(self.log_dir)
filename = os.path.join(self.log_dir, str(runner_id) + ".log")
return logging.FileHandler(filename, delay=True)
def on_testsuite_start(self, testsuite):
sub_test_log_dir = self._gen_testsuite_log_dir(testsuite.log_dir, testsuite)
fs.mkdirs(sub_test_log_dir)
for test in getattr(testsuite, "_tests"):
test.log_dir = sub_test_log_dir
