def gather_debug(self):
debug = {}
# In the event we're gathering debug without starting a session, skip marionette commands
if self.marionette.session is not None:
try:
self.marionette.set_context(self.marionette.CONTEXT_CHROME)
debug["screenshot"] = self.marionette.screenshot()
self.marionette.set_context(self.marionette.CONTEXT_CONTENT)
debug["source"] = self.marionette.page_source
self.marionette.switch_to_frame()
debug["settings"] = json.dumps(
self.marionette.execute_async_script(
"""
SpecialPowers.addPermission('settings-read', true, document);
SpecialPowers.addPermission('settings-api-read', true, document);
var req = window.navigator.mozSettings.createLock().get('*');
req.onsuccess = function() {
marionetteScriptFinished(req.result);
}""",
special_powers=True,
),
sort_keys=True,
indent=4,
separators=(",", ": "),
)
except:
logger = get_default_logger()
logger.warning("Failed to gather test failure debug.", exc_info=True)
return debug
def gather_debug(self):
debug = {}
try:
self.marionette.set_context(self.marionette.CONTEXT_CHROME)
debug['screenshot'] = self.marionette.screenshot()
self.marionette.set_context(self.marionette.CONTEXT_CONTENT)
debug['source'] = self.marionette.page_source
self.marionette.switch_to_frame()
debug['settings'] = json.dumps(
self.marionette.execute_async_script("""
SpecialPowers.addPermission('settings-read', true, document);
SpecialPowers.addPermission('settings-api-read', true, document);
var req = window.navigator.mozSettings.createLock().get('*');
req.onsuccess = function() {
marionetteScriptFinished(req.result);
}""",
special_powers=True),
sort_keys=True,
indent=4,
separators=(',', ': '))
except:
logger = get_default_logger()
logger.warning('Failed to gather test failure debug.',
exc_info=True)
return debug
def listen(pulse_args):
global logger
global work_queues
logger = structuredlog.get_default_logger()
sanitized_args = pulse_args.copy()
if 'password' in sanitized_args:
sanitized_args['password'] = '******'
logger.info("Starting pulse listener with args: \n{}".format(
json.dumps(sanitized_args, indent=2)))
logger.info("Placing jobs on the following queues: {}".format(', '.join(
settings['work_queues'])))
work_queues = [all_queues[q]() for q in settings['work_queues']]
consumer = NormalizedBuildConsumer(callback=on_test_event, **pulse_args)
while True:
try:
consumer.listen()
except IOError:
pass
except KeyboardInterrupt:
logger.warning("Received SIGINT, exiting")
sys.exit(1)
except:
logger.error(traceback.format_exc())
def process_test_job(data):
global logger
logger = logger or structuredlog.get_default_logger()
build_name = "{}-{} {}".format(data['platform'], data['buildtype'],
data['test'])
logger.debug("now processing a '{}' job".format(build_name))
log_url = None
for name, url in data['blobber_files'].iteritems():
if name in settings['structured_log_names']:
log_url = url
break
log_path = _download_log(log_url)
try:
backend = settings['datastore']
db_args = config.database
store = get_storage_backend(backend, **db_args)
# TODO commit metadata about the test run
handler = StoreResultsHandler(store)
with open(log_path, 'r') as log:
iterator = reader.read(log)
reader.handle_log(iterator, handler)
finally:
mozfile.remove(log_path)
def process_test_job(data):
global logger
logger = logger or structuredlog.get_default_logger()
build_name = "{}-{} {}".format(data['platform'], data['buildtype'], data['test'])
logger.debug("now processing a '{}' job".format(build_name))
log_url = None
for name, url in data['blobber_files'].iteritems():
if name in settings['structured_log_names']:
log_url = url
break
log_path = _download_log(log_url)
try:
backend = settings['datastore']
db_args = config.database
store = get_storage_backend(backend, **db_args)
# TODO commit metadata about the test run
handler = StoreResultsHandler(store)
with open(log_path, 'r') as log:
iterator = reader.read(log)
reader.handle_log(iterator, handler)
finally:
mozfile.remove(log_path)
def __init__(self, methodName, **kwargs):
unittest.TestCase.__init__(self, methodName)
self.loglines = []
self.duration = 0
self.start_time = 0
self.expected = kwargs.pop('expected', 'pass')
self.logger = get_default_logger()
def __init__(self, methodName, **kwargs):
unittest.TestCase.__init__(self, methodName)
self.loglines = []
self.duration = 0
self.start_time = 0
self.expected = kwargs.pop('expected', 'pass')
self.logger = get_default_logger()
def get_logger():
logger = get_default_logger('test-runtimes')
if logger:
return logger
log = {
'log_{}'.format(k.replace('-', '_')): v
for k, v in dict(config.log).iteritems()
}
return setup_logging('test-runtimes', log)
def use():
if _using_mozlog:
return
globals()["_using_mozlog"] = True
with suppress_exception:
from mozlog.structured import structuredlog
global logger
logger = structuredlog.get_default_logger()
ToMozLog.logger = logger
ToMozLog.old_class = Log
globals()["Log"] = ToMozLog
def use():
if _using_mozlog:
return
globals()["_using_mozlog"] = True
with suppress_exception:
from mozlog.structured import structuredlog
global logger
logger = structuredlog.get_default_logger()
ToMozLog.logger = logger
ToMozLog.old_class = Log
globals()["Log"] = ToMozLog
def __call__(self, manifests, buildconfig):
global logger
logger = logger or structuredlog.get_default_logger()
if not isinstance(manifests, Iterable):
manifests = [manifests]
m = TestManifest(manifests)
active = [t['path'] for t in m.active_tests(exists=False, disabled=False, **buildconfig)]
skipped = [t['path'] for t in m.tests if t['path'] not in active]
return active, skipped
def gather_debug(test, status):
rv = {}
marionette = test._marionette_weakref()
# In the event we're gathering debug without starting a session, skip marionette commands
if marionette.session is not None:
try:
with marionette.using_context(marionette.CONTEXT_CHROME):
rv['screenshot'] = marionette.screenshot()
with marionette.using_context(marionette.CONTEXT_CONTENT):
rv['source'] = marionette.page_source
except:
logger = get_default_logger()
logger.warning('Failed to gather test failure debug.', exc_info=True)
return rv
def listen(pulse_args):
global logger
global work_queues
logger = structuredlog.get_default_logger()
work_queues = [all_queues[q]() for q in settings['work_queues']]
consumer = NormalizedBuildConsumer(callback=on_test_event, **pulse_args)
while True:
try:
consumer.listen()
except IOError:
pass
except KeyboardInterrupt:
raise
except:
traceback.print_exc()
def gather_debug(self):
debug = {}
# In the event we're gathering debug without starting a session, skip marionette commands
if self.marionette.session is not None:
try:
self.marionette.set_context(self.marionette.CONTEXT_CHROME)
debug['screenshot'] = self.marionette.screenshot()
self.marionette.set_context(self.marionette.CONTEXT_CONTENT)
debug['source'] = self.marionette.page_source
self.marionette.switch_to_frame()
self.marionette.push_permission('settings-read', True)
self.marionette.push_permission('settings-api-read', True)
debug['settings'] = json.dumps(self.marionette.execute_async_script("""
var req = window.navigator.mozSettings.createLock().get('*');
req.onsuccess = function() {
marionetteScriptFinished(req.result);
}""", sandbox='system'), sort_keys=True, indent=4, separators=(',', ': '))
except:
logger = get_default_logger()
logger.warning('Failed to gather test failure debug.', exc_info=True)
return debug
def get_logger(*args, **kwargs):
return get_default_logger() or create_logger(*args, **kwargs)
def get_logger():
structured_logger = structuredlog.get_default_logger("mozcrash")
if structured_logger is None:
return mozlog.getLogger('mozcrash')
return structured_logger
def runTest(self):
if self.marionette.session is None:
self.marionette.start_session()
self.marionette.test_name = os.path.basename(self.jsFile)
self.marionette.execute_script("log('TEST-START: %s');" %
self.jsFile.replace('\\', '\\\\'))
f = open(self.jsFile, 'r')
js = f.read()
args = []
if os.path.basename(self.jsFile).startswith('test_'):
head_js = self.head_js_re.search(js)
if head_js:
head_js = head_js.group(3)
head = open(
os.path.join(os.path.dirname(self.jsFile), head_js), 'r')
js = head.read() + js
context = self.context_re.search(js)
if context:
context = context.group(3)
self.marionette.set_context(context)
if context != "chrome":
self.marionette.navigate('data:text/html,<html>test page</html>')
timeout = self.timeout_re.search(js)
if timeout:
timeout = timeout.group(3)
self.marionette.set_script_timeout(timeout)
inactivity_timeout = self.inactivity_timeout_re.search(js)
if inactivity_timeout:
inactivity_timeout = inactivity_timeout.group(3)
try:
results = self.marionette.execute_js_script(
js,
args,
special_powers=True,
inactivity_timeout=inactivity_timeout,
filename=os.path.basename(self.jsFile))
self.assertTrue(not 'timeout' in self.jsFile,
'expected timeout not triggered')
if 'fail' in self.jsFile:
self.assertTrue(
len(results['failures']) > 0,
"expected test failures didn't occur")
else:
logger = get_default_logger()
for failure in results['failures']:
diag = "" if failure.get(
'diag') is None else failure['diag']
name = "got false, expected true" if failure.get(
'name') is None else failure['name']
logger.test_status(self.test_name,
name,
'FAIL',
message=diag)
for failure in results['expectedFailures']:
diag = "" if failure.get(
'diag') is None else failure['diag']
name = "got false, expected false" if failure.get(
'name') is None else failure['name']
logger.test_status(self.test_name,
name,
'FAIL',
expected='FAIL',
message=diag)
for failure in results['unexpectedSuccesses']:
diag = "" if failure.get(
'diag') is None else failure['diag']
name = "got true, expected false" if failure.get(
'name') is None else failure['name']
logger.test_status(self.test_name,
name,
'PASS',
expected='FAIL',
message=diag)
self.assertEqual(0, len(results['failures']),
'%d tests failed' % len(results['failures']))
if len(results['unexpectedSuccesses']) > 0:
raise _UnexpectedSuccess('')
if len(results['expectedFailures']) > 0:
raise _ExpectedFailure(
(AssertionError, AssertionError(''), None))
self.assertTrue(
results['passed'] + len(results['failures']) +
len(results['expectedFailures']) +
len(results['unexpectedSuccesses']) > 0, 'no tests run')
except ScriptTimeoutException:
if 'timeout' in self.jsFile:
# expected exception
pass
else:
self.loglines = self.marionette.get_logs()
raise
self.marionette.execute_script("log('TEST-END: %s');" %
self.jsFile.replace('\\', '\\\\'))
self.marionette.test_name = None
def main():
args = wptcommandline.parse_args_update()
logger = setup_logging(args, {"mach": sys.stdout})
assert structuredlog.get_default_logger() is not None
success = run_update(logger, **args)
sys.exit(0 if success else 1)
def main():
args = wptcommandline.parse_args_update()
logger = setup_logging(args, {"mach": sys.stdout})
assert structuredlog.get_default_logger() is not None
success = run_update(logger, **args)
sys.exit(0 if success else 1)
def runTest(self):
if self.marionette.session is None:
self.marionette.start_session()
self.marionette.test_name = os.path.basename(self.jsFile)
self.marionette.execute_script("log('TEST-START: %s');" % self.jsFile.replace('\\', '\\\\'))
f = open(self.jsFile, 'r')
js = f.read()
args = []
if os.path.basename(self.jsFile).startswith('test_'):
head_js = self.head_js_re.search(js);
if head_js:
head_js = head_js.group(3)
head = open(os.path.join(os.path.dirname(self.jsFile), head_js), 'r')
js = head.read() + js;
if self.oop:
print 'running oop'
frame = None
try:
frame = self.marionette.find_element(
'css selector',
'iframe[src*="app://test-container.gaiamobile.org/index.html"]'
)
except NoSuchElementException:
result = self.marionette.execute_async_script("""
let setReq = navigator.mozSettings.createLock().set({'lockscreen.enabled': false});
setReq.onsuccess = function() {
let appsReq = navigator.mozApps.mgmt.getAll();
appsReq.onsuccess = function() {
let apps = appsReq.result;
for (let i = 0; i < apps.length; i++) {
let app = apps[i];
if (app.manifest.name === 'Test Container') {
app.launch();
window.addEventListener('apploadtime', function apploadtime(){
window.removeEventListener('apploadtime', apploadtime);
marionetteScriptFinished(true);
});
return;
}
}
marionetteScriptFinished(false);
}
appsReq.onerror = function() {
marionetteScriptFinished(false);
}
}
setReq.onerror = function() {
marionetteScriptFinished(false);
}""", script_timeout=60000)
self.assertTrue(result)
frame = self.marionette.find_element(
'css selector',
'iframe[src*="app://test-container.gaiamobile.org/index.html"]'
)
self.marionette.switch_to_frame(frame)
main_process = self.marionette.execute_script("""
return SpecialPowers.isMainProcess();
""")
self.assertFalse(main_process)
context = self.context_re.search(js)
if context:
context = context.group(3)
self.marionette.set_context(context)
if context != "chrome":
self.marionette.navigate('data:text/html,<html>test page</html>')
timeout = self.timeout_re.search(js)
if timeout:
timeout = timeout.group(3)
self.marionette.set_script_timeout(timeout)
inactivity_timeout = self.inactivity_timeout_re.search(js)
if inactivity_timeout:
inactivity_timeout = inactivity_timeout.group(3)
try:
results = self.marionette.execute_js_script(js,
args,
special_powers=True,
inactivity_timeout=inactivity_timeout,
filename=os.path.basename(self.jsFile))
self.assertTrue(not 'timeout' in self.jsFile,
'expected timeout not triggered')
if 'fail' in self.jsFile:
self.assertTrue(len(results['failures']) > 0,
"expected test failures didn't occur")
else:
logger = get_default_logger()
for failure in results['failures']:
diag = "" if failure.get('diag') is None else failure['diag']
name = "got false, expected true" if failure.get('name') is None else failure['name']
logger.test_status(self.test_name, name, 'FAIL',
message=diag)
for failure in results['expectedFailures']:
diag = "" if failure.get('diag') is None else failure['diag']
name = "got false, expected false" if failure.get('name') is None else failure['name']
logger.test_status(self.test_name, name, 'FAIL',
expected='FAIL', message=diag)
for failure in results['unexpectedSuccesses']:
diag = "" if failure.get('diag') is None else failure['diag']
name = "got true, expected false" if failure.get('name') is None else failure['name']
logger.test_status(self.test_name, name, 'PASS',
expected='FAIL', message=diag)
self.assertEqual(0, len(results['failures']),
'%d tests failed' % len(results['failures']))
if len(results['unexpectedSuccesses']) > 0:
raise _UnexpectedSuccess('')
if len(results['expectedFailures']) > 0:
raise _ExpectedFailure((AssertionError, AssertionError(''), None))
self.assertTrue(results['passed']
+ len(results['failures'])
+ len(results['expectedFailures'])
+ len(results['unexpectedSuccesses']) > 0,
'no tests run')
except ScriptTimeoutException:
if 'timeout' in self.jsFile:
# expected exception
pass
else:
self.loglines = self.marionette.get_logs()
raise
if self.oop:
self.marionette.switch_to_frame()
self.marionette.execute_script("log('TEST-END: %s');" % self.jsFile.replace('\\', '\\\\'))
self.marionette.test_name = None
def get_logger(*args, **kwargs):
return get_default_logger() or create_logger(*args, **kwargs)
def runTest(self):
if self.marionette.session is None:
self.marionette.start_session()
self.marionette.test_name = os.path.basename(self.jsFile)
self.marionette.execute_script("log('TEST-START: %s');" % self.jsFile.replace("\\", "\\\\"))
f = open(self.jsFile, "r")
js = f.read()
args = []
if os.path.basename(self.jsFile).startswith("test_"):
head_js = self.head_js_re.search(js)
if head_js:
head_js = head_js.group(3)
head = open(os.path.join(os.path.dirname(self.jsFile), head_js), "r")
js = head.read() + js
if self.oop:
print "running oop"
frame = None
try:
frame = self.marionette.find_element(
"css selector", 'iframe[src*="app://test-container.gaiamobile.org/index.html"]'
)
except NoSuchElementException:
result = self.marionette.execute_async_script(
"""
let setReq = navigator.mozSettings.createLock().set({'lockscreen.enabled': false});
setReq.onsuccess = function() {
let appsReq = navigator.mozApps.mgmt.getAll();
appsReq.onsuccess = function() {
let apps = appsReq.result;
for (let i = 0; i < apps.length; i++) {
let app = apps[i];
if (app.manifest.name === 'Test Container') {
app.launch();
window.addEventListener('apploadtime', function apploadtime(){
window.removeEventListener('apploadtime', apploadtime);
marionetteScriptFinished(true);
});
return;
}
}
marionetteScriptFinished(false);
}
appsReq.onerror = function() {
marionetteScriptFinished(false);
}
}
setReq.onerror = function() {
marionetteScriptFinished(false);
}""",
script_timeout=60000,
)
self.assertTrue(result)
frame = self.marionette.find_element(
"css selector", 'iframe[src*="app://test-container.gaiamobile.org/index.html"]'
)
self.marionette.switch_to_frame(frame)
main_process = self.marionette.execute_script(
"""
return SpecialPowers.isMainProcess();
"""
)
self.assertFalse(main_process)
context = self.context_re.search(js)
if context:
context = context.group(3)
self.marionette.set_context(context)
if context != "chrome":
self.marionette.navigate("data:text/html,<html>test page</html>")
timeout = self.timeout_re.search(js)
if timeout:
timeout = timeout.group(3)
self.marionette.set_script_timeout(timeout)
inactivity_timeout = self.inactivity_timeout_re.search(js)
if inactivity_timeout:
inactivity_timeout = inactivity_timeout.group(3)
try:
results = self.marionette.execute_js_script(
js,
args,
special_powers=True,
inactivity_timeout=inactivity_timeout,
filename=os.path.basename(self.jsFile),
)
self.assertTrue(not "timeout" in self.jsFile, "expected timeout not triggered")
if "fail" in self.jsFile:
self.assertTrue(results["failed"] > 0, "expected test failures didn't occur")
else:
logger = get_default_logger()
for failure in results["failures"]:
diag = "" if failure.get("diag") is None else failure["diag"]
name = "got false, expected true" if failure.get("name") is None else failure["name"]
logger.test_status(self.test_name, name, "FAIL", message=diag)
self.assertEqual(0, results["failed"], "%d tests failed" % (results["failed"]))
self.assertTrue(results["passed"] + results["failed"] > 0, "no tests run")
except ScriptTimeoutException:
if "timeout" in self.jsFile:
# expected exception
pass
else:
self.loglines = self.marionette.get_logs()
raise
if self.oop:
self.marionette.switch_to_frame()
self.marionette.execute_script("log('TEST-END: %s');" % self.jsFile.replace("\\", "\\\\"))
self.marionette.test_name = None
def get_logger():
structured_logger = structuredlog.get_default_logger("mozcrash")
if structured_logger is None:
return mozlog.getLogger('mozcrash')
return structured_logger
def runTest(self):
if self.marionette.session is None:
self.marionette.start_session()
self.marionette.test_name = os.path.basename(self.jsFile)
self.marionette.execute_script("log('TEST-START: %s');" % self.jsFile.replace('\\', '\\\\'))
f = open(self.jsFile, 'r')
js = f.read()
args = []
if os.path.basename(self.jsFile).startswith('test_'):
head_js = self.head_js_re.search(js);
if head_js:
head_js = head_js.group(3)
head = open(os.path.join(os.path.dirname(self.jsFile), head_js), 'r')
js = head.read() + js;
context = self.context_re.search(js)
if context:
context = context.group(3)
self.marionette.set_context(context)
if context != "chrome":
self.marionette.navigate('data:text/html,<html>test page</html>')
timeout = self.timeout_re.search(js)
if timeout:
timeout = timeout.group(3)
self.marionette.set_script_timeout(timeout)
inactivity_timeout = self.inactivity_timeout_re.search(js)
if inactivity_timeout:
inactivity_timeout = inactivity_timeout.group(3)
try:
results = self.marionette.execute_js_script(js,
args,
special_powers=True,
inactivity_timeout=inactivity_timeout,
filename=os.path.basename(self.jsFile))
self.assertTrue(not 'timeout' in self.jsFile,
'expected timeout not triggered')
if 'fail' in self.jsFile:
self.assertTrue(len(results['failures']) > 0,
"expected test failures didn't occur")
else:
logger = get_default_logger()
for failure in results['failures']:
diag = "" if failure.get('diag') is None else failure['diag']
name = "got false, expected true" if failure.get('name') is None else failure['name']
logger.test_status(self.test_name, name, 'FAIL',
message=diag)
for failure in results['expectedFailures']:
diag = "" if failure.get('diag') is None else failure['diag']
name = "got false, expected false" if failure.get('name') is None else failure['name']
logger.test_status(self.test_name, name, 'FAIL',
expected='FAIL', message=diag)
for failure in results['unexpectedSuccesses']:
diag = "" if failure.get('diag') is None else failure['diag']
name = "got true, expected false" if failure.get('name') is None else failure['name']
logger.test_status(self.test_name, name, 'PASS',
expected='FAIL', message=diag)
self.assertEqual(0, len(results['failures']),
'%d tests failed' % len(results['failures']))
if len(results['unexpectedSuccesses']) > 0:
raise _UnexpectedSuccess('')
if len(results['expectedFailures']) > 0:
raise _ExpectedFailure((AssertionError, AssertionError(''), None))
self.assertTrue(results['passed']
+ len(results['failures'])
+ len(results['expectedFailures'])
+ len(results['unexpectedSuccesses']) > 0,
'no tests run')
except ScriptTimeoutException:
if 'timeout' in self.jsFile:
# expected exception
pass
else:
self.loglines = self.marionette.get_logs()
raise
self.marionette.execute_script("log('TEST-END: %s');" % self.jsFile.replace('\\', '\\\\'))
self.marionette.test_name = None
here = os.path.split(__file__)[0]
sys.path.insert(0, os.path.abspath(os.path.join(here, os.pardir, "harness")))
sys.path.insert(
0,
os.path.abspath(os.path.join(here, os.pardir, "tests", "tools",
"scripts")))
from wptrunner.update import setup_logging, WPTUpdate
from wptrunner.update.base import exit_unclean
from . import updatecommandline
from .update import UpdateRunner
def run_update(logger, **kwargs):
updater = WPTUpdate(logger, runner_cls=UpdateRunner, **kwargs)
return updater.run()
if __name__ == "__main__":
args = updatecommandline.parse_args()
logger = setup_logging(args, {})
assert structuredlog.get_default_logger() is not None
rv = run_update(logger, **args)
if rv is exit_unclean:
sys.exit(1)
else:
sys.exit(0)
def __init__(self):
threading.Thread.__init__(self, target=self.do_work)
self.daemon = True
global logger
logger = logger or structuredlog.get_default_logger()
from mozlog.structured import structuredlog
here = os.path.split(__file__)[0]
sys.path.insert(0, os.path.abspath(os.path.join(here, os.pardir, "harness")))
sys.path.insert(0, os.path.abspath(os.path.join(here, os.pardir, "tests", "tools", "scripts")))
from wptrunner.update import setup_logging, WPTUpdate
from wptrunner.update.base import exit_unclean
from . import updatecommandline
from .update import UpdateRunner
def run_update(logger, **kwargs):
updater = WPTUpdate(logger, runner_cls=UpdateRunner, **kwargs)
return updater.run()
if __name__ == "__main__":
args = updatecommandline.parse_args()
logger = setup_logging(args, {"mach": sys.stdout})
assert structuredlog.get_default_logger() is not None
rv = run_update(logger, **args)
if rv is exit_unclean:
sys.exit(1)
else:
sys.exit(0)
def runTest(self):
if self.marionette.session is None:
self.marionette.start_session()
self.marionette.test_name = os.path.basename(self.jsFile)
self.marionette.execute_script("log('TEST-START: %s');" %
self.jsFile.replace('\\', '\\\\'))
f = open(self.jsFile, 'r')
js = f.read()
args = []
# if this is a browser_ test, prepend head.js to it
if os.path.basename(self.jsFile).startswith('browser_'):
local_head = open(
os.path.join(os.path.dirname(__file__), 'tests', 'head.js'),
'r')
js = local_head.read() + js
head = open(os.path.join(os.path.dirname(self.jsFile), 'head.js'),
'r')
for line in head:
# we need a bigger timeout than the default specified by the
# 'real' head.js
if 'const kDefaultWait' in line:
js += 'const kDefaultWait = 45000;\n'
else:
js += line
if os.path.basename(self.jsFile).startswith('test_'):
head_js = self.head_js_re.search(js)
if head_js:
head_js = head_js.group(3)
head = open(
os.path.join(os.path.dirname(self.jsFile), head_js), 'r')
js = head.read() + js
if self.oop:
print 'running oop'
frame = None
try:
frame = self.marionette.find_element(
'css selector',
'iframe[src*="app://test-container.gaiamobile.org/index.html"]'
)
except NoSuchElementException:
result = self.marionette.execute_async_script(
"""
let setReq = navigator.mozSettings.createLock().set({'lockscreen.enabled': false});
setReq.onsuccess = function() {
let appsReq = navigator.mozApps.mgmt.getAll();
appsReq.onsuccess = function() {
let apps = appsReq.result;
for (let i = 0; i < apps.length; i++) {
let app = apps[i];
if (app.manifest.name === 'Test Container') {
app.launch();
window.addEventListener('apploadtime', function apploadtime(){
window.removeEventListener('apploadtime', apploadtime);
marionetteScriptFinished(true);
});
return;
}
}
marionetteScriptFinished(false);
}
appsReq.onerror = function() {
marionetteScriptFinished(false);
}
}
setReq.onerror = function() {
marionetteScriptFinished(false);
}""",
script_timeout=60000)
self.assertTrue(result)
frame = self.marionette.find_element(
'css selector',
'iframe[src*="app://test-container.gaiamobile.org/index.html"]'
)
self.marionette.switch_to_frame(frame)
main_process = self.marionette.execute_script("""
return SpecialPowers.isMainProcess();
""")
self.assertFalse(main_process)
context = self.context_re.search(js)
if context:
context = context.group(3)
self.marionette.set_context(context)
if context != "chrome":
self.marionette.navigate('data:text/html,<html>test page</html>')
timeout = self.timeout_re.search(js)
if timeout:
timeout = timeout.group(3)
self.marionette.set_script_timeout(timeout)
inactivity_timeout = self.inactivity_timeout_re.search(js)
if inactivity_timeout:
inactivity_timeout = inactivity_timeout.group(3)
try:
results = self.marionette.execute_js_script(
js,
args,
special_powers=True,
inactivity_timeout=inactivity_timeout,
filename=os.path.basename(self.jsFile))
self.assertTrue(not 'timeout' in self.jsFile,
'expected timeout not triggered')
if 'fail' in self.jsFile:
self.assertTrue(results['failed'] > 0,
"expected test failures didn't occur")
else:
logger = get_default_logger()
for failure in results['failures']:
diag = "" if failure.get(
'diag') is None else failure['diag']
name = "got false, expected true" if failure.get(
'name') is None else failure['name']
logger.test_status(self.test_name,
name,
'FAIL',
message=diag)
self.assertEqual(0, results['failed'],
'%d tests failed' % (results['failed']))
self.assertTrue(results['passed'] + results['failed'] > 0,
'no tests run')
except ScriptTimeoutException:
if 'timeout' in self.jsFile:
# expected exception
pass
else:
self.loglines = self.marionette.get_logs()
raise
if self.oop:
self.marionette.switch_to_frame()
self.marionette.execute_script("log('TEST-END: %s');" %
self.jsFile.replace('\\', '\\\\'))
self.marionette.test_name = None
