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