def test_fail(name, opts, expected):
stack = """
SimpleTest.is@SimpleTest/SimpleTest.js:312:5
@caps/tests/mochitest/test_bug246699.html:53:1
""".strip('\n')
buf = BytesIO()
fmt = formatters[name](**opts)
logger = StructuredLogger('test_logger')
logger.add_handler(StreamHandler(buf, fmt))
logger.suite_start(['test_foo', 'test_bar', 'test_baz'])
logger.test_start('test_foo')
logger.test_end('test_foo', 'FAIL', 'PASS', 'expected 0 got 1')
logger.test_start('test_bar')
logger.test_status('test_bar', 'a subtest', 'FAIL', 'PASS',
'expected 0 got 1', stack)
logger.test_status('test_bar', 'another subtest', 'TIMEOUT')
logger.test_end('test_bar', 'OK')
logger.test_start('test_baz')
logger.test_end('test_baz', 'PASS', 'FAIL')
logger.suite_end()
result = buf.getvalue()
print("Dumping result for copy/paste:")
print(result)
assert result == expected
def test_known_intermittent(name, opts, expected):
buf = BytesIO()
fmt = formatters[name](**opts)
logger = StructuredLogger('test_logger')
logger.add_handler(StreamHandler(buf, fmt))
logger.suite_start(['test_foo', 'test_bar', 'test_baz'])
logger.test_start('test_foo')
logger.test_end('test_foo', 'FAIL', 'PASS', known_intermittent=['FAIL'])
logger.test_start('test_bar')
logger.test_status('test_bar',
'a subtest',
'PASS',
'FAIL',
known_intermittent=['PASS'])
logger.test_end('test_bar', 'OK')
logger.test_start('test_baz')
logger.test_end('test_baz',
'FAIL',
'FAIL',
'expected 0 got 1',
known_intermittent=['PASS'])
logger.suite_end()
result = buf.getvalue()
print("Dumping result for copy/paste:")
print(result)
assert result == expected
def test_check_stability_iterations():
logger = StructuredLogger("test-stability")
logger.add_handler(StreamHandler(sys.stdout, TbplFormatter()))
kwargs = {"verify_log_full": False}
def mock_run_tests(**kwargs):
repeats = kwargs.get("repeat", 1)
for _ in range(repeats):
logger.suite_start(tests=[], name="test")
for _ in range(kwargs.get("rerun", 1)):
logger.test_start("/example/test.html")
logger.test_status("/example/test.html",
subtest="test1",
status="PASS")
logger.test_end("/example/test.html", status="OK")
logger.suite_end()
status = wptrunner.TestStatus()
status.total_tests = 1
status.repeated_runs = repeats
status.expected_repeated_runs = repeats
return (None, status)
# Don't actually load wptrunner, because that will end up starting a browser
# which we don't want to do in this test.
with mock.patch("wptrunner.stability.wptrunner.run_tests") as mock_run:
mock_run.side_effect = mock_run_tests
assert stability.check_stability(logger,
repeat_loop=10,
repeat_restart=5,
chaos_mode=False,
output_results=False,
**kwargs) is None
def logger():
logger = StructuredLogger("mochitest_message_logger")
buf = six.StringIO()
handler = StreamHandler(buf, JSONFormatter())
logger.add_handler(handler)
return logger
def main():
logger = StructuredLogger("mozregression-gui")
set_default_logger(logger)
# Create a Qt application
log_model = LogModel()
logger.add_handler(log_model)
argv = [sys.argv[0].replace("mozregression-gui.py", "mozregression")
] + sys.argv[1:]
# enable hi-dpi scaling
QApplication.setAttribute(Qt.AA_EnableHighDpiScaling, True)
app = QApplication(argv)
crash_reporter = CrashReporter(app)
crash_reporter.install()
app.setOrganizationName("mozilla")
app.setOrganizationDomain("mozilla.org")
app.setApplicationName("mozregression-gui")
set_default_prefs()
# Create the main window and show it
win = MainWindow()
app.aboutToQuit.connect(win.bisect_runner.stop)
app.aboutToQuit.connect(win.single_runner.stop)
app.aboutToQuit.connect(win.clear)
release_checker = CheckRelease(win)
release_checker.check()
log_model.log.connect(win.ui.log_view.on_log_received)
win.show()
# Enter Qt application main loop
sys.exit(app.exec_())
def main():
logger = StructuredLogger('mozregression-gui')
set_default_logger(logger)
# Create a Qt application
log_model = LogModel()
logger.add_handler(log_model)
argv = [sys.argv[0].replace("main.py", "mozregression")] + sys.argv[1:]
app = QApplication(argv)
crash_reporter = CrashReporter(app)
crash_reporter.install()
app.setOrganizationName('mozilla')
app.setOrganizationDomain('mozilla.org')
app.setApplicationName('mozregression-gui')
set_default_prefs()
# Create the main window and show it
win = MainWindow()
app.aboutToQuit.connect(win.bisect_runner.stop)
app.aboutToQuit.connect(win.single_runner.stop)
app.aboutToQuit.connect(win.clear)
release_checker = CheckRelease(win)
release_checker.check()
log_model.log.connect(win.ui.log_view.on_log_received)
win.show()
# Enter Qt application main loop
sys.exit(app.exec_())
def init_logger(debug=True, allow_color=ALLOW_COLOR, output=None):
"""
Initialize the mozlog logger. Must be called once before using logs.
"""
# late binding of sys.stdout is required for windows color to work
output = output or sys.stdout
start = time.time() * 1000
level_color = {
'WARNING': Fore.MAGENTA + Style.BRIGHT,
'CRITICAL': Fore.RED + Style.BRIGHT,
'ERROR': Fore.RED + Style.BRIGHT,
'DEBUG': Fore.CYAN + Style.BRIGHT,
'INFO': Style.BRIGHT,
}
time_color = Fore.BLUE
if mozinfo.os == "win":
time_color += Style.BRIGHT # this is unreadable on windows without it
def format_log(data):
level = data['level']
elapsed = _format_seconds((data['time'] - start) / 1000)
if allow_color:
elapsed = time_color + elapsed + Style.RESET_ALL
if level in level_color:
level = level_color[level] + level + Style.RESET_ALL
return "%s %s: %s\n" % (elapsed, level, data['message'])
logger = StructuredLogger("mozregression")
handler = LogLevelFilter(StreamHandler(output, format_log),
'debug' if debug else 'info')
logger.add_handler(handler)
set_default_logger(logger)
return logger
def test_precondition_failed(name, opts, expected):
buf = BytesIO()
fmt = formatters[name](**opts)
logger = StructuredLogger('test_logger')
logger.add_handler(StreamHandler(buf, fmt))
logger.suite_start(['test_foo', 'test_bar'])
logger.test_start('test_foo')
logger.test_end('test_foo', 'PRECONDITION_FAILED')
logger.test_start('test_bar')
logger.test_status('test_bar', 'a subtest', 'PASS')
logger.test_status('test_bar', 'another subtest', 'PRECONDITION_FAILED')
logger.test_end('test_bar', 'OK')
logger.suite_end()
result = buf.getvalue()
print("Dumping result for copy/paste:")
print(result)
assert result == expected
class FormatterTest(unittest.TestCase):
def setUp(self):
self.position = 0
self.logger = StructuredLogger("test_%s" % type(self).__name__)
self.output_file = BytesIO()
self.handler = StreamHandler(self.output_file, self.get_formatter())
self.logger.add_handler(self.handler)
def set_position(self, pos=None):
if pos is None:
pos = self.output_file.tell()
self.position = pos
def get_formatter(self):
raise NotImplementedError(
"FormatterTest subclasses must implement get_formatter")
@property
def loglines(self):
self.output_file.seek(self.position)
return [line.rstrip() for line in self.output_file.readlines()]
def init_logger(debug=True, allow_color=ALLOW_COLOR, output=None):
"""
Initialize the mozlog logger. Must be called once before using logs.
"""
# late binding of sys.stdout is required for windows color to work
output = output or sys.stdout
start = time.time() * 1000
level_color = {
"WARNING": Fore.MAGENTA + Style.BRIGHT,
"CRITICAL": Fore.RED + Style.BRIGHT,
"ERROR": Fore.RED + Style.BRIGHT,
"DEBUG": Fore.CYAN + Style.BRIGHT,
"INFO": Style.BRIGHT,
}
time_color = Fore.BLUE
if mozinfo.os == "win":
time_color += Style.BRIGHT # this is unreadable on windows without it
def format_log(data):
level = data["level"]
elapsed = _format_seconds((data["time"] - start) / 1000)
if allow_color:
elapsed = time_color + elapsed + Style.RESET_ALL
if level in level_color:
level = level_color[level] + level + Style.RESET_ALL
msg = data["message"]
if "stack" in data:
msg += "\n%s" % data["stack"]
return "%s %s: %s\n" % (elapsed, level, msg)
logger = StructuredLogger("mozregression")
handler = LogLevelFilter(StreamHandler(output, format_log),
"debug" if debug else "info")
logger.add_handler(handler)
init_python_redirect_logger(logger)
set_default_logger(logger)
return logger
def test(self, what, extra_args):
"""Run tests from names or paths.
mach test accepts arguments specifying which tests to run. Each argument
can be:
* The path to a test file
* A directory containing tests
* A test suite name
* An alias to a test suite name (codes used on TreeHerder)
If no input is provided, tests will be run based on files changed in
the local tree. Relevant tests, tags, or flavors are determined by
IMPACTED_TESTS annotations in moz.build files relevant to the
changed files.
When paths or directories are given, they are first resolved to test
files known to the build system.
If resolved tests belong to more than one test type/flavor/harness,
the harness for each relevant type/flavor will be invoked. e.g. if
you specify a directory with xpcshell and browser chrome mochitests,
both harnesses will be invoked.
"""
from mozlog.commandline import log_formatters
from mozlog.handlers import StreamHandler, LogLevelFilter
from mozlog.structuredlog import StructuredLogger
from moztest.resolve import TestResolver, TEST_FLAVORS, TEST_SUITES
resolver = self._spawn(TestResolver)
run_suites, run_tests = resolver.resolve_metadata(what)
if not run_suites and not run_tests:
print(UNKNOWN_TEST)
return 1
# Create shared logger
formatter = log_formatters[self._mach_context.settings['test']
['format']][0]()
formatter.summary_on_shutdown = True
level = self._mach_context.settings['test']['level']
log = StructuredLogger('mach-test')
log.add_handler(
StreamHandler(sys.stdout, LogLevelFilter(formatter, level)))
status = None
for suite_name in run_suites:
suite = TEST_SUITES[suite_name]
kwargs = suite['kwargs']
kwargs['log'] = log
if 'mach_command' in suite:
res = self._mach_context.commands.dispatch(
suite['mach_command'],
self._mach_context,
argv=extra_args,
**kwargs)
if res:
status = res
buckets = {}
for test in run_tests:
key = (test['flavor'], test.get('subsuite', ''))
buckets.setdefault(key, []).append(test)
for (flavor, subsuite), tests in sorted(buckets.items()):
if flavor not in TEST_FLAVORS:
print(UNKNOWN_FLAVOR % flavor)
status = 1
continue
m = TEST_FLAVORS[flavor]
if 'mach_command' not in m:
print(UNKNOWN_FLAVOR % flavor)
status = 1
continue
kwargs = dict(m['kwargs'])
kwargs['log'] = log
kwargs['subsuite'] = subsuite
res = self._mach_context.commands.dispatch(m['mach_command'],
self._mach_context,
argv=extra_args,
test_objects=tests,
**kwargs)
if res:
status = res
log.shutdown()
return status
def inner(name, **fmt_args):
buf = StringIO()
fmt = formatters[name](**fmt_args)
logger = StructuredLogger("test_logger")
logger.add_handler(StreamHandler(buf, fmt))
return logger
