def run(config, args): logger = structuredlog.StructuredLogger("web-platform-tests") logger.add_handler(ResultHandler(logger=logger, verbose=args.verbose)) setup_wptrunner_logging(logger) parser = wptcommandline.create_parser() logger.suite_start(tests=[]) for product, product_settings in config["products"].iteritems(): if args.product and product not in args.product: continue settings = test_settings() settings.update(config["general"]) settings.update(product_settings) settings["product"] = product set_from_args(settings, args) kwargs = vars(parser.parse_args(settings_to_argv(settings))) wptcommandline.check_args(kwargs) logger.send_message("wptrunner-test", "set-product", product) run_tests(product, kwargs) logger.send_message("wptrunner-test", "set-product", None) logger.suite_end()
def __init__(self, suite_name, size, test_source_cls, test_source_kwargs, browser_cls, browser_kwargs, executor_cls, executor_kwargs, pause_on_unexpected=False, debug_args=None): """Main thread object that owns all the TestManager threads.""" self.suite_name = suite_name self.size = size self.test_source_cls = test_source_cls self.test_source_kwargs = test_source_kwargs self.browser_cls = browser_cls self.browser_kwargs = browser_kwargs self.executor_cls = executor_cls self.executor_kwargs = executor_kwargs self.pause_on_unexpected = pause_on_unexpected self.debug_args = debug_args self.pool = set() # Event that is polled by threads so that they can gracefully exit in the face # of sigint self.stop_flag = threading.Event() self.logger = structuredlog.StructuredLogger(suite_name) self.test_queue = None
def setUp(self): self.position = 0 self.logger = structuredlog.StructuredLogger("test_%s" % type(self).__name__) self.output_file = StringIO.StringIO() self.handler = handlers.StreamHandler( self.output_file, self.get_formatter()) self.logger.add_handler(self.handler)
def setup_logging(log_f): global logger logger = structuredlog.StructuredLogger("firefox-os-cert-suite") logger.add_handler(stdio_handler) logger.add_handler( handlers.StreamHandler(log_f, formatters.JSONFormatter())) set_default_logger(logger)
def test_multiple_loggers_suite_start(self): logger1 = structuredlog.StructuredLogger("test") self.logger.suite_start([]) logger1.suite_start([]) last_item = self.pop_last_item() self.assertEquals(last_item["action"], "log") self.assertEquals(last_item["level"], "ERROR")
def __init__(self, reference_omni_ja, logger=None): self.reference_omni_ja = reference_omni_ja self.omni_ja_on_device = '/system/b2g/omni.ja' if logger is None: self.logger = structuredlog.StructuredLogger("omni-analyzer") else: self.logger = logger
def test_filter_default_component(self): component_logger = structuredlog.StructuredLogger(self.logger.name, "test_component") self.logger.debug("Test") self.assertFalse(self.handler.empty) self.assert_log_equals({"action": "log", "level": "DEBUG", "message": "Test"}) self.logger.component_filter = handlers.LogLevelFilter(lambda x:x, "info") self.logger.debug("Test 1") self.assertTrue(self.handler.empty) component_logger.debug("Test 2") self.assertFalse(self.handler.empty) self.assert_log_equals({"action": "log", "level": "DEBUG", "message": "Test 2", "component": "test_component"}) self.logger.component_filter = None self.logger.debug("Test 3") self.assertFalse(self.handler.empty) self.assert_log_equals({"action": "log", "level": "DEBUG", "message": "Test 3"})
def setup_logging(log_f): global logger logger = structuredlog.StructuredLogger("firefox-os-cert-suite") logger.add_handler( handlers.StreamHandler(sys.stderr, formatters.MachFormatter())) logger.add_handler( handlers.StreamHandler(log_f, formatters.JSONFormatter()))
def run_test(self, suite, groups, temp_dir): logger.info('Running suite %s' % suite) def on_output(line): written = False if line.startswith("{"): try: data = json.loads(line.strip()) if "action" in data: sub_logger.log_raw(data) written = True except ValueError: pass if not written: logger.process_output(proc.pid, line.decode("utf8", "replace"), command=" ".join(cmd)) try: cmd, output_files, structured_path = self.build_command( suite, groups, temp_dir) logger.debug(cmd) logger.debug(output_files) env = dict(os.environ) env['PYTHONUNBUFFERED'] = '1' proc = mozprocess.ProcessHandler(cmd, env=env, processOutputLine=on_output) logger.debug("Process '%s' is running" % " ".join(cmd)) #TODO: move timeout handling to here instead of each test? with open(structured_path, "w") as structured_log: sub_logger = structuredlog.StructuredLogger(suite) sub_logger.add_handler(stdio_handler) sub_logger.add_handler( handlers.StreamHandler(structured_log, formatters.JSONFormatter())) proc.run() proc.wait() logger.debug("Process finished") except Exception: logger.error("Error running suite %s:\n%s" % (suite, traceback.format_exc())) raise finally: try: proc.kill() except: pass return output_files, structured_path
def create_log(self, *args, **kwargs): logger = structuredlog.StructuredLogger("expected_test") data = StringIO.StringIO() handler = handlers.StreamHandler(data, formatters.JSONFormatter()) logger.add_handler(handler) log_entries = ([("suite_start", { "tests": [], "run_info": kwargs.get("run_info", {}) })] + list(args) + [("suite_end", {})]) for item in log_entries: action, kwargs = item getattr(logger, action)(**kwargs) logger.remove_handler(handler) data.seek(0) return data
def __init__(self, vfile, results, dir, mode=None, vserver=None, dump=False, logger=structuredlog.StructuredLogger("omni-analyzer")): self.generate_reference = mode self.verification_server = vserver self.verify_file = vfile self.results_file = results self.results_dict = {} self.workdir = dir self.logger = logger warnings = 0 if os.path.isdir(self.workdir): shutil.rmtree(self.workdir) self.results_dict = self.run() if not self.generate_reference: ref = self._get_reference() warnings, self.results_dict = self.verify(ref, self.results_dict) f = open(self.results_file, "w") json.dump(self.results_dict, f) f.close() if os.path.isdir(self.workdir): shutil.rmtree(self.workdir) # Also print our results to stdout - TODO: Necessary or desired? if dump: print json.dumps(self.results_dict, indent=2) if warnings: print "Found %s changes in omni.ja" % warnings else: print "No warnings detected in omni.ja"
def setUp(self): self.logger = structuredlog.StructuredLogger("test") self.handler = TestHandler() self.logger.add_handler(self.handler)
def run(self): """Main loop for the TestManager. TestManagers generally receive commands from their TestRunner updating them on the status of a test. They may also have a stop flag set by the main thread indicating that the manager should shut down the next time the event loop spins.""" self.logger = structuredlog.StructuredLogger(self.suite_name) with self.browser_cls(self.logger, **self.browser_kwargs) as browser: self.browser = browser try: self.init() while True: commands = { "init_succeeded": self.init_succeeded, "init_failed": self.init_failed, "test_start": self.test_start, "test_ended": self.test_ended, "restart_runner": self.restart_runner, "runner_teardown": self.runner_teardown, "log": self.log, "error": self.error } try: command, data = self.command_queue.get(True, 1) except IOError: if not self.should_stop(): self.logger.error("Got IOError from poll") self.restart_count += 1 if self.restart_runner() is Stop: break except Empty: command = None if self.should_stop(): self.logger.debug("A flag was set; stopping") break if command is not None: self.restart_count = 0 if commands[command](*data) is Stop: break else: if not self.test_runner_proc.is_alive(): if not self.command_queue.empty(): # We got a new message so process that continue # If we got to here the runner presumably shut down # unexpectedly self.logger.info("Test runner process shut down") if self.test is not None: # This could happen if the test runner crashed for some other # reason # Need to consider the unlikely case where one test causes the # runner process to repeatedly die self.logger.info( "Last test did not complete, requeueing") self.requeue_test() self.logger.warning( "More tests found, but runner process died, restarting" ) self.restart_count += 1 if self.restart_runner() is Stop: break finally: self.logger.debug( "TestRunnerManager main loop terminating, starting cleanup" ) self.stop_runner() self.teardown() self.logger.debug("TestRunnerManager main loop terminated")
def create_logger(): logger = structuredlog.StructuredLogger("unknown") logger.add_handler( handlers.StreamHandler(sys.stdout, formatters.JSONFormatter())) return logger
def setUp(self): self.logger = structuredlog.StructuredLogger("test") self.output_file = StringIO.StringIO() self.handler = handlers.StreamHandler( self.output_file, formatters.MachFormatter(disable_colors=True)) self.logger.add_handler(self.handler)
import tempfile import types import uuid from collections import defaultdict from mozlog.structured import reader from mozlog.structured import structuredlog import expected import manifestupdate import wptmanifest import wpttest from vcs import git manifest = None # Module that will be imported relative to test_root logger = structuredlog.StructuredLogger("web-platform-tests") def manifest_path(metadata_root): return os.path.join(metadata_root, "MANIFEST.json") def load_test_manifest(test_root, metadata_root): do_test_relative_imports(test_root) return manifest.load(manifest_path(metadata_root)) def update_manifest(git_root, metadata_root): manifest.setup_git(git_root) # Create an entirely new manifest new_manifest = manifest.Manifest(None)
def setUp(self): self.logger = structuredlog.StructuredLogger("testBuffer") self.handler = handlers.BufferHandler(TestHandler(), message_limit=4) self.logger.add_handler(self.handler)