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)
