def run_xpcshell_test(self, test_objects=None, **params):
from mozbuild.controller.building import BuildDriver
if test_objects is not None:
from manifestparser import TestManifest
m = TestManifest()
m.tests.extend(test_objects)
params['manifest'] = m
driver = self._spawn(BuildDriver)
driver.install_tests(test_objects)
# We should probably have a utility function to ensure the tree is
# ready to run tests. Until then, we just create the state dir (in
# case the tree wasn't built with mach).
self._ensure_state_subdir_exists('.')
params['log'] = structured.commandline.setup_logging(
"XPCShellTests", params, {"mach": sys.stdout}, {"verbose": True})
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self)
xpcshell = self._spawn(AndroidXPCShellRunner)
else:
xpcshell = self._spawn(XPCShellRunner)
xpcshell.cwd = self._mach_context.cwd
try:
return xpcshell.run_test(**params)
except InvalidTestPathError as e:
print(e.message)
return 1
def setup_argument_parser():
build_obj = MozbuildObject.from_environment(cwd=here)
build_path = os.path.join(build_obj.topobjdir, 'build')
if build_path not in sys.path:
sys.path.append(build_path)
mochitest_dir = os.path.join(build_obj.topobjdir, '_tests', 'testing', 'mochitest')
with warnings.catch_warnings():
warnings.simplefilter('ignore')
import imp
path = os.path.join(build_obj.topobjdir, mochitest_dir, 'runtests.py')
if not os.path.exists(path):
path = os.path.join(here, "runtests.py")
with open(path, 'r') as fh:
imp.load_module('mochitest', fh, path,
('.py', 'r', imp.PY_SOURCE))
from mochitest_options import MochitestArgumentParser
if conditions.is_android(build_obj):
# On Android, check for a connected device (and offer to start an
# emulator if appropriate) before running tests. This check must
# be done in this admittedly awkward place because
# MochitestArgumentParser initialization fails if no device is found.
from mozrunner.devices.android_device import verify_android_device
verify_android_device(build_obj, install=True, xre=True)
global parser
parser = MochitestArgumentParser()
return parser
def run_xpcshell_test(self, **params):
from mozbuild.controller.building import BuildDriver
# We should probably have a utility function to ensure the tree is
# ready to run tests. Until then, we just create the state dir (in
# case the tree wasn't built with mach).
self._ensure_state_subdir_exists('.')
driver = self._spawn(BuildDriver)
driver.install_tests(remove=False)
params['log'] = structured.commandline.setup_logging(
"XPCShellTests", params, {"mach": sys.stdout}, {"verbose": True})
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self)
xpcshell = self._spawn(AndroidXPCShellRunner)
elif conditions.is_b2g(self):
xpcshell = self._spawn(B2GXPCShellRunner)
params['b2g_home'] = self.b2g_home
params['device_name'] = self.device_name
else:
xpcshell = self._spawn(XPCShellRunner)
xpcshell.cwd = self._mach_context.cwd
try:
return xpcshell.run_test(**params)
except InvalidTestPathError as e:
print(e.message)
return 1
def setup_junit_argument_parser():
build_obj = MozbuildObject.from_environment(cwd=here)
build_path = os.path.join(build_obj.topobjdir, 'build')
if build_path not in sys.path:
sys.path.append(build_path)
mochitest_dir = os.path.join(build_obj.topobjdir, '_tests', 'testing',
'mochitest')
with warnings.catch_warnings():
warnings.simplefilter('ignore')
# runtests.py contains MochitestDesktop, required by runjunit
import imp
path = os.path.join(build_obj.topobjdir, mochitest_dir, 'runtests.py')
if not os.path.exists(path):
path = os.path.join(here, "runtests.py")
with open(path, 'r') as fh:
imp.load_module('mochitest', fh, path, ('.py', 'r', imp.PY_SOURCE))
import runjunit
from mozrunner.devices.android_device import verify_android_device
verify_android_device(build_obj, install=False, xre=True, network=True)
global parser
parser = runjunit.JunitArgumentParser()
return parser
def kwargs_common(self, kwargs):
tests_src_path = os.path.join(self._here, "tests")
if kwargs["product"] == "fennec":
# package_name may be non-fennec in the future
package_name = kwargs["package_name"]
if not package_name:
package_name = self.substs["ANDROID_PACKAGE_NAME"]
# Note that this import may fail in non-fennec trees
from mozrunner.devices.android_device import verify_android_device, grant_runtime_permissions
verify_android_device(self,
install=True,
verbose=False,
xre=True,
app=package_name)
grant_runtime_permissions(self, package_name,
kwargs["device_serial"])
if kwargs["certutil_binary"] is None:
kwargs["certutil_binary"] = os.path.join(
os.environ.get('MOZ_HOST_BIN'), "certutil")
if kwargs["install_fonts"] is None:
kwargs["install_fonts"] = True
if kwargs["config"] is None:
kwargs["config"] = os.path.join(self.topobjdir, '_tests',
'web-platform',
'wptrunner.local.ini')
if kwargs["prefs_root"] is None:
kwargs["prefs_root"] = os.path.join(self.topsrcdir, 'testing',
'profiles')
if kwargs["stackfix_dir"] is None:
kwargs["stackfix_dir"] = self.bindir
if kwargs["exclude"] is None and kwargs[
"include"] is None and not sys.platform.startswith("linux"):
kwargs["exclude"] = ["css"]
if kwargs["ssl_type"] in (None, "pregenerated"):
cert_root = os.path.join(tests_src_path, "tools", "certs")
if kwargs["ca_cert_path"] is None:
kwargs["ca_cert_path"] = os.path.join(cert_root, "cacert.pem")
if kwargs["host_key_path"] is None:
kwargs["host_key_path"] = os.path.join(
cert_root, "web-platform.test.key")
if kwargs["host_cert_path"] is None:
kwargs["host_cert_path"] = os.path.join(
cert_root, "web-platform.test.pem")
if kwargs["log_mach_screenshot"] is None:
kwargs["log_mach_screenshot"] = True
kwargs["capture_stdio"] = True
return kwargs
def _run_reftest(self, **kwargs):
kwargs["topsrcdir"] = self.topsrcdir
process_test_objects(kwargs)
reftest = self._spawn(ReftestRunner)
# Unstructured logging must be enabled prior to calling
# adb which uses an unstructured logger in its constructor.
reftest.log_manager.enable_unstructured()
if conditions.is_android(self):
from mozrunner.devices.android_device import (
verify_android_device, InstallIntent)
install = InstallIntent.NO if kwargs.get(
'no_install') else InstallIntent.YES
verbose = False
if kwargs.get('log_mach_verbose') or kwargs.get('log_tbpl_level') == 'debug' or \
kwargs.get('log_mach_level') == 'debug' or kwargs.get('log_raw_level') == 'debug':
verbose = True
verify_android_device(self,
install=install,
xre=True,
network=True,
app=kwargs["app"],
device_serial=kwargs["deviceSerial"],
verbose=verbose)
return reftest.run_android_test(**kwargs)
return reftest.run_desktop_test(**kwargs)
def kwargs_common(self, kwargs):
tests_src_path = os.path.join(self._here, "tests")
if kwargs["product"] == "firefox_android":
# package_name may be different in the future
package_name = kwargs["package_name"]
if not package_name:
kwargs[
"package_name"] = package_name = "org.mozilla.geckoview.test"
# Note that this import may fail in non-firefox-for-android trees
from mozrunner.devices.android_device import (
verify_android_device, InstallIntent)
verify_android_device(self,
install=InstallIntent.PROMPT,
verbose=False,
xre=True,
app=package_name)
if kwargs["certutil_binary"] is None:
kwargs["certutil_binary"] = os.path.join(
os.environ.get('MOZ_HOST_BIN'), "certutil")
if kwargs["install_fonts"] is None:
kwargs["install_fonts"] = True
if kwargs["config"] is None:
kwargs["config"] = os.path.join(self.topobjdir, '_tests',
'web-platform',
'wptrunner.local.ini')
if kwargs["prefs_root"] is None:
kwargs["prefs_root"] = os.path.join(self.topsrcdir, 'testing',
'profiles')
if kwargs["stackfix_dir"] is None:
kwargs["stackfix_dir"] = self.bindir
if kwargs["exclude"] is None and kwargs[
"include"] is None and not sys.platform.startswith("linux"):
kwargs["exclude"] = ["css"]
if kwargs["ssl_type"] in (None, "pregenerated"):
cert_root = os.path.join(tests_src_path, "tools", "certs")
if kwargs["ca_cert_path"] is None:
kwargs["ca_cert_path"] = os.path.join(cert_root, "cacert.pem")
if kwargs["host_key_path"] is None:
kwargs["host_key_path"] = os.path.join(
cert_root, "web-platform.test.key")
if kwargs["host_cert_path"] is None:
kwargs["host_cert_path"] = os.path.join(
cert_root, "web-platform.test.pem")
if kwargs["reftest_screenshot"] is None:
kwargs["reftest_screenshot"] = "fail"
kwargs["capture_stdio"] = True
return kwargs
def run_xpcshell_test(self, test_objects=None, **params):
from mozbuild.controller.building import BuildDriver
if test_objects is not None:
from manifestparser import TestManifest
m = TestManifest()
m.tests.extend(test_objects)
params['manifest'] = m
driver = self._spawn(BuildDriver)
driver.install_tests(test_objects)
# We should probably have a utility function to ensure the tree is
# ready to run tests. Until then, we just create the state dir (in
# case the tree wasn't built with mach).
self._ensure_state_subdir_exists('.')
params['log'] = structured.commandline.setup_logging("XPCShellTests",
params,
{"mach": sys.stdout},
{"verbose": True})
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self)
xpcshell = self._spawn(AndroidXPCShellRunner)
else:
xpcshell = self._spawn(XPCShellRunner)
xpcshell.cwd = self._mach_context.cwd
try:
return xpcshell.run_test(**params)
except InvalidTestPathError as e:
print(e.message)
return 1
def run_cppunit_test(self, **params):
from mozlog import commandline
log = params.get("log")
if not log:
log = commandline.setup_logging("cppunittest", {}, {"tbpl": sys.stdout})
# See if we have crash symbols
symbols_path = os.path.join(self.distdir, "crashreporter-symbols")
if not os.path.isdir(symbols_path):
symbols_path = None
# If no tests specified, run all tests in main manifest
tests = params["test_files"]
if not tests:
tests = [os.path.join(self.distdir, "cppunittests")]
manifest_path = os.path.join(self.topsrcdir, "testing", "cppunittest.ini")
else:
manifest_path = None
utility_path = self.bindir
if conditions.is_android(self):
from mozrunner.devices.android_device import (
verify_android_device,
InstallIntent,
)
verify_android_device(self, install=InstallIntent.NO)
return self.run_android_test(tests, symbols_path, manifest_path, log)
return self.run_desktop_test(
tests, symbols_path, manifest_path, utility_path, log
)
def run_junit(self, **kwargs):
self._ensure_state_subdir_exists('.')
from mozrunner.devices.android_device import (
grant_runtime_permissions, get_adb_path, verify_android_device)
# verify installation
app = kwargs.get('app')
device_serial = kwargs.get('deviceSerial')
verify_android_device(self,
install=True,
xre=False,
app=app,
device_serial=device_serial)
grant_runtime_permissions(self, app, device_serial=device_serial)
if not kwargs.get('adbPath'):
kwargs['adbPath'] = get_adb_path(self)
if not kwargs.get('log'):
from mozlog.commandline import setup_logging
format_args = {
'level': self._mach_context.settings['test']['level']
}
default_format = self._mach_context.settings['test']['format']
kwargs['log'] = setup_logging('mach-mochitest', kwargs,
{default_format: sys.stdout},
format_args)
mochitest = self._spawn(MochitestRunner)
return mochitest.run_geckoview_junit_test(self._mach_context, **kwargs)
def run_xpcshell_test(self, **params):
from mozbuild.controller.building import BuildDriver
# We should probably have a utility function to ensure the tree is
# ready to run tests. Until then, we just create the state dir (in
# case the tree wasn't built with mach).
self._ensure_state_subdir_exists('.')
driver = self._spawn(BuildDriver)
driver.install_tests(remove=False)
params['log'] = structured.commandline.setup_logging("XPCShellTests",
params,
{"mach": sys.stdout},
{"verbose": True})
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self)
xpcshell = self._spawn(AndroidXPCShellRunner)
elif conditions.is_b2g(self):
xpcshell = self._spawn(B2GXPCShellRunner)
params['b2g_home'] = self.b2g_home
params['device_name'] = self.device_name
else:
xpcshell = self._spawn(XPCShellRunner)
xpcshell.cwd = self._mach_context.cwd
try:
return xpcshell.run_test(**params)
except InvalidTestPathError as e:
print(e.message)
return 1
def run_cppunit_test(self, **params):
import mozinfo
from mozlog import commandline
log = commandline.setup_logging("cppunittest",
{},
{"tbpl": sys.stdout})
# See if we have crash symbols
symbols_path = os.path.join(self.distdir, 'crashreporter-symbols')
if not os.path.isdir(symbols_path):
symbols_path = None
# If no tests specified, run all tests in main manifest
tests = params['test_files']
if len(tests) == 0:
tests = [os.path.join(self.distdir, 'cppunittests')]
manifest_path = os.path.join(self.topsrcdir, 'testing', 'cppunittest.ini')
else:
manifest_path = None
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self, install=False)
return self.run_android_test(tests, symbols_path, manifest_path, log)
return self.run_desktop_test(tests, symbols_path, manifest_path, log)
def run_cppunit_test(self, **params):
from mozlog import commandline
log = commandline.setup_logging("cppunittest", {},
{"tbpl": sys.stdout})
# See if we have crash symbols
symbols_path = os.path.join(self.distdir, 'crashreporter-symbols')
if not os.path.isdir(symbols_path):
symbols_path = None
# If no tests specified, run all tests in main manifest
tests = params['test_files']
if len(tests) == 0:
tests = [os.path.join(self.distdir, 'cppunittests')]
manifest_path = os.path.join(self.topsrcdir, 'testing',
'cppunittest.ini')
else:
manifest_path = None
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self, install=False)
return self.run_android_test(tests, symbols_path, manifest_path,
log)
return self.run_desktop_test(tests, symbols_path, manifest_path, log)
def setup_argument_parser():
build_obj = MozbuildObject.from_environment(cwd=here)
build_path = os.path.join(build_obj.topobjdir, 'build')
if build_path not in sys.path:
sys.path.append(build_path)
mochitest_dir = os.path.join(build_obj.topobjdir, '_tests', 'testing',
'mochitest')
with warnings.catch_warnings():
warnings.simplefilter('ignore')
import imp
path = os.path.join(build_obj.topobjdir, mochitest_dir, 'runtests.py')
if not os.path.exists(path):
path = os.path.join(here, "runtests.py")
with open(path, 'r') as fh:
imp.load_module('mochitest', fh, path, ('.py', 'r', imp.PY_SOURCE))
from mochitest_options import MochitestArgumentParser
if conditions.is_android(build_obj):
# On Android, check for a connected device (and offer to start an
# emulator if appropriate) before running tests. This check must
# be done in this admittedly awkward place because
# MochitestArgumentParser initialization fails if no device is found.
from mozrunner.devices.android_device import verify_android_device
# verify device and xre
verify_android_device(build_obj, install=False, xre=True)
global parser
parser = MochitestArgumentParser()
return parser
def _run_reftest(self, **kwargs):
process_test_objects(kwargs)
reftest = self._spawn(ReftestRunner)
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self, install=True, xre=True)
return reftest.run_android_test(**kwargs)
return reftest.run_desktop_test(**kwargs)
def _run_reftest(self, **kwargs):
process_test_objects(kwargs)
reftest = self._spawn(ReftestRunner)
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self, install=True, xre=True)
return reftest.run_android_test(**kwargs)
return reftest.run_desktop_test(**kwargs)
def run_robocop(self, serve=False, **kwargs):
if serve:
kwargs['autorun'] = False
if not kwargs.get('robocopIni'):
kwargs['robocopIni'] = os.path.join(self.topobjdir, '_tests',
'testing', 'mochitest',
'robocop.ini')
from mozbuild.controller.building import BuildDriver
self._ensure_state_subdir_exists('.')
test_paths = kwargs['test_paths']
kwargs['test_paths'] = []
from moztest.resolve import TestResolver
resolver = self._spawn(TestResolver)
tests = list(
resolver.resolve_tests(paths=test_paths,
cwd=self._mach_context.cwd,
flavor='instrumentation',
subsuite='robocop'))
driver = self._spawn(BuildDriver)
driver.install_tests(tests)
if len(tests) < 1:
print(
ROBOCOP_TESTS_NOT_FOUND.format('\n'.join(
sorted(list(test_paths)))))
return 1
from mozrunner.devices.android_device import grant_runtime_permissions, get_adb_path
from mozrunner.devices.android_device import verify_android_device
# verify installation
app = kwargs.get('app')
if not app:
kwargs['app'] = app = self.substs["ANDROID_PACKAGE_NAME"]
device_serial = kwargs.get('deviceSerial')
# setup adb logging so that grant_runtime_permissions can log
from mozlog.commandline import setup_logging
format_args = {'level': self._mach_context.settings['test']['level']}
default_format = self._mach_context.settings['test']['format']
setup_logging('adb', kwargs, {default_format: sys.stdout}, format_args)
verify_android_device(self,
install=True,
xre=False,
network=True,
app=app,
device_serial=device_serial)
grant_runtime_permissions(self, app, device_serial=device_serial)
if not kwargs['adbPath']:
kwargs['adbPath'] = get_adb_path(self)
mochitest = self._spawn(MochitestRunner)
return mochitest.run_robocop_test(self._mach_context, tests, **kwargs)
def run_xpcshell_test(self, test_objects=None, **params):
from mozbuild.controller.building import BuildDriver
if test_objects is not None:
from manifestparser import TestManifest
m = TestManifest()
m.tests.extend(test_objects)
params["manifest"] = m
driver = self._spawn(BuildDriver)
driver.install_tests()
# We should probably have a utility function to ensure the tree is
# ready to run tests. Until then, we just create the state dir (in
# case the tree wasn't built with mach).
self._ensure_state_subdir_exists(".")
if not params.get("log"):
log_defaults = {
self._mach_context.settings["test"]["format"]: sys.stdout
}
fmt_defaults = {
"level": self._mach_context.settings["test"]["level"],
"verbose": True,
}
params["log"] = structured.commandline.setup_logging(
"XPCShellTests", params, log_defaults, fmt_defaults)
if not params["threadCount"]:
# pylint --py3k W1619
params["threadCount"] = int((cpu_count() * 3) / 2)
if conditions.is_android(self) or self.substs.get(
"MOZ_BUILD_APP") == "b2g":
from mozrunner.devices.android_device import (
verify_android_device,
get_adb_path,
)
device_serial = params.get("deviceSerial")
verify_android_device(self,
network=True,
device_serial=device_serial)
if not params["adbPath"]:
params["adbPath"] = get_adb_path(self)
xpcshell = self._spawn(AndroidXPCShellRunner)
else:
xpcshell = self._spawn(XPCShellRunner)
xpcshell.cwd = self._mach_context.cwd
try:
return xpcshell.run_test(**params)
except InvalidTestPathError as e:
print(str(e))
return 1
def _run_reftest(self, **kwargs):
kwargs["topsrcdir"] = self.topsrcdir
process_test_objects(kwargs)
reftest = self._spawn(ReftestRunner)
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self, install=True, xre=True, app=kwargs["app"],
device_serial=kwargs["deviceSerial"])
return reftest.run_android_test(**kwargs)
return reftest.run_desktop_test(**kwargs)
def install(self, verbose=False):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self, verbose=verbose)
ret = self._run_make(directory='.',
target='install',
ensure_exit_code=False)
if ret == 0:
self.notify('Install complete')
return ret
def run(self,
url=None,
no_install=None,
no_wait=None,
fail_if_running=None):
from mozrunner.devices.android_device import verify_android_device, run_firefox_for_android
verify_android_device(self, install=not no_install)
return run_firefox_for_android(self, [],
url=url,
wait=not no_wait,
fail_if_running=fail_if_running)
def _run_reftest(self, **kwargs):
kwargs["topsrcdir"] = self.topsrcdir
process_test_objects(kwargs)
reftest = self._spawn(ReftestRunner)
# Unstructured logging must be enabled prior to calling
# adb which uses an unstructured logger in its constructor.
reftest.log_manager.enable_unstructured()
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device
verify_android_device(self, install=True, xre=True, network=True,
app=kwargs["app"], device_serial=kwargs["deviceSerial"])
return reftest.run_android_test(**kwargs)
return reftest.run_desktop_test(**kwargs)
def run_xpcshell_test(self, test_objects=None, **params):
from mozbuild.controller.building import BuildDriver
if test_objects is not None:
from manifestparser import TestManifest
m = TestManifest()
m.tests.extend(test_objects)
params['manifest'] = m
driver = self._spawn(BuildDriver)
driver.install_tests(test_objects)
# We should probably have a utility function to ensure the tree is
# ready to run tests. Until then, we just create the state dir (in
# case the tree wasn't built with mach).
self._ensure_state_subdir_exists('.')
if not params.get('log'):
log_defaults = {
self._mach_context.settings['test']['format']: sys.stdout
}
fmt_defaults = {
"level": self._mach_context.settings['test']['level'],
"verbose": True
}
params['log'] = structured.commandline.setup_logging(
"XPCShellTests", params, log_defaults, fmt_defaults)
if not params['threadCount']:
params['threadCount'] = int((cpu_count() * 3) / 2)
if conditions.is_android(self):
from mozrunner.devices.android_device import verify_android_device, get_adb_path
device_serial = params.get('deviceSerial')
verify_android_device(self,
network=True,
device_serial=device_serial)
if not params['adbPath']:
params['adbPath'] = get_adb_path(self)
xpcshell = self._spawn(AndroidXPCShellRunner)
else:
xpcshell = self._spawn(XPCShellRunner)
xpcshell.cwd = self._mach_context.cwd
try:
return xpcshell.run_test(**params)
except InvalidTestPathError as e:
print(e.message)
return 1
def run_raptor(self, **kwargs):
build_obj = self
is_android = Conditions.is_android(build_obj) or \
kwargs['app'] in FIREFOX_ANDROID_BROWSERS
if is_android:
from mozrunner.devices.android_device import (
verify_android_device, InstallIntent)
from mozdevice import ADBAndroid
install = InstallIntent.NO if kwargs.pop(
'noinstall', False) else InstallIntent.PROMPT
if not verify_android_device(
build_obj, install=install, app=kwargs['binary'],
xre=True): # Equivalent to 'run_local' = True.
return 1
debug_command = '--debug-command'
if debug_command in sys.argv:
sys.argv.remove(debug_command)
raptor = self._spawn(RaptorRunner)
device = None
try:
if kwargs['power_test'] and is_android:
device = ADBAndroid(verbose=True)
disable_charging(device)
return raptor.run_test(sys.argv[2:], kwargs)
except Exception as e:
print(repr(e))
return 1
finally:
if kwargs['power_test'] and device:
enable_charging(device)
def run_robocop(self, serve=False, **kwargs):
if serve:
kwargs['autorun'] = False
if not kwargs.get('robocopIni'):
kwargs['robocopIni'] = os.path.join(self.topobjdir, '_tests',
'testing', 'mochitest',
'robocop.ini')
from mozbuild.controller.building import BuildDriver
self._ensure_state_subdir_exists('.')
test_paths = kwargs['test_paths']
kwargs['test_paths'] = []
from moztest.resolve import TestResolver
resolver = self._spawn(TestResolver)
tests = list(
resolver.resolve_tests(paths=test_paths,
cwd=self._mach_context.cwd,
flavor='instrumentation',
subsuite='robocop'))
driver = self._spawn(BuildDriver)
driver.install_tests(tests)
if len(tests) < 1:
print(
ROBOCOP_TESTS_NOT_FOUND.format('\n'.join(
sorted(list(test_paths)))))
return 1
from mozrunner.devices.android_device import grant_runtime_permissions, get_adb_path
from mozrunner.devices.android_device import verify_android_device
# verify installation
app = kwargs.get('app')
if not app:
app = self.substs["ANDROID_PACKAGE_NAME"]
verify_android_device(self, install=True, xre=False, app=app)
grant_runtime_permissions(self, app)
if not kwargs['adbPath']:
kwargs['adbPath'] = get_adb_path(self)
mochitest = self._spawn(MochitestRunner)
return mochitest.run_robocop_test(self._mach_context, tests, 'robocop',
**kwargs)
def run_raptor(self, **kwargs):
# Defers this import so that a transitive dependency doesn't
# stop |mach bootstrap| from running
from raptor.power import enable_charging, disable_charging
build_obj = self
is_android = (Conditions.is_android(build_obj)
or kwargs["app"] in ANDROID_BROWSERS)
if is_android:
from mozrunner.devices.android_device import (
verify_android_device,
InstallIntent,
)
from mozdevice import ADBDeviceFactory
install = (InstallIntent.NO if kwargs.pop("noinstall", False) else
InstallIntent.YES)
verbose = False
if (kwargs.get("log_mach_verbose")
or kwargs.get("log_tbpl_level") == "debug"
or kwargs.get("log_mach_level") == "debug"
or kwargs.get("log_raw_level") == "debug"):
verbose = True
if not verify_android_device(
build_obj,
install=install,
app=kwargs["binary"],
verbose=verbose,
xre=True,
): # Equivalent to 'run_local' = True.
return 1
debug_command = "--debug-command"
if debug_command in sys.argv:
sys.argv.remove(debug_command)
raptor = self._spawn(RaptorRunner)
device = None
try:
if kwargs["power_test"] and is_android:
device = ADBDeviceFactory(verbose=True)
disable_charging(device)
return raptor.run_test(sys.argv[2:], kwargs)
except BinaryNotFoundException as e:
self.log(logging.ERROR, "raptor", {"error": str(e)},
"ERROR: {error}")
self.log(logging.INFO, "raptor", {"help": e.help()}, "{help}")
return 1
except Exception as e:
print(repr(e))
return 1
finally:
if kwargs["power_test"] and device:
enable_charging(device)
def run_raptor_test(self, **kwargs):
build_obj = MozbuildObject.from_environment(cwd=HERE)
firefox_android_browsers = ["fennec", "geckoview", "refbrow", "fenix"]
if conditions.is_android(
build_obj) or kwargs['app'] in firefox_android_browsers:
from mozrunner.devices.android_device import verify_android_device
from mozdevice import ADBAndroid, ADBHost
if not verify_android_device(
build_obj, install=True, app=kwargs['binary'],
xre=True): # Equivalent to 'run_local' = True.
return 1
debug_command = '--debug-command'
if debug_command in sys.argv:
sys.argv.remove(debug_command)
raptor = self._spawn(RaptorRunner)
try:
if kwargs['app'] in firefox_android_browsers and kwargs[
'power_test']:
device = ADBAndroid(verbose=True)
adbhost = ADBHost(verbose=True)
device_serial = "%s:5555" % device.get_ip_address()
device.command_output(["tcpip", "5555"])
raw_input(
"Please disconnect your device from USB then press Enter/return..."
)
adbhost.command_output(["connect", device_serial])
while len(adbhost.devices()) > 1:
raw_input(
"You must disconnect your device from USB before continuing."
)
# must reset the environment DEVICE_SERIAL which was set during
# verify_android_device to match our new tcpip value.
os.environ["DEVICE_SERIAL"] = device_serial
return raptor.run_test(sys.argv[2:], kwargs)
except Exception as e:
print(repr(e))
return 1
finally:
try:
if kwargs['app'] in firefox_android_browsers and kwargs[
'power_test']:
raw_input(
"Connect device via USB and press Enter/return...")
device = ADBAndroid(device=device_serial, verbose=True)
device.command_output(["usb"])
adbhost.command_output(["disconnect", device_serial])
except Exception:
adbhost.command_output(["kill-server"])
def run_raptor(self, **kwargs):
build_obj = self
is_android = Conditions.is_android(build_obj) or \
kwargs['app'] in FIREFOX_ANDROID_BROWSERS
if is_android:
from mozrunner.devices.android_device import (
verify_android_device, InstallIntent)
from mozdevice import ADBAndroid, ADBHost
install = InstallIntent.NO if kwargs.pop(
'noinstall', False) else InstallIntent.PROMPT
if not verify_android_device(
build_obj, install=install, app=kwargs['binary'],
xre=True): # Equivalent to 'run_local' = True.
return 1
debug_command = '--debug-command'
if debug_command in sys.argv:
sys.argv.remove(debug_command)
raptor = self._spawn(RaptorRunner)
try:
if is_android and kwargs['power_test']:
device = ADBAndroid(verbose=True)
adbhost = ADBHost(verbose=True)
device_serial = "{}:5555".format(device.get_ip_address())
device.command_output(["tcpip", "5555"])
six.input(
"Please disconnect your device from USB then press Enter/return..."
)
adbhost.command_output(["connect", device_serial])
while len(adbhost.devices()) > 1:
six.input(
"You must disconnect your device from USB before continuing."
)
# must reset the environment DEVICE_SERIAL which was set during
# verify_android_device to match our new tcpip value.
os.environ["DEVICE_SERIAL"] = device_serial
return raptor.run_test(sys.argv[2:], kwargs)
except Exception as e:
print(repr(e))
return 1
finally:
try:
if is_android and kwargs['power_test']:
six.input(
"Connect device via USB and press Enter/return...")
device = ADBAndroid(device=device_serial, verbose=True)
device.command_output(["usb"])
adbhost.command_output(["disconnect", device_serial])
except Exception:
adbhost.command_output(["kill-server"])
def run_raptor(self, **kwargs):
# Defers this import so that a transitive dependency doesn't
# stop |mach bootstrap| from running
from raptor.power import enable_charging, disable_charging
build_obj = self
is_android = Conditions.is_android(build_obj) or \
kwargs['app'] in ANDROID_BROWSERS
if is_android:
from mozrunner.devices.android_device import (
verify_android_device, InstallIntent)
from mozdevice import ADBAndroid
install = InstallIntent.NO if kwargs.pop(
'noinstall', False) else InstallIntent.YES
verbose = False
if kwargs.get('log_mach_verbose') or kwargs.get('log_tbpl_level') == 'debug' or \
kwargs.get('log_mach_level') == 'debug' or kwargs.get('log_raw_level') == 'debug':
verbose = True
if not verify_android_device(
build_obj,
install=install,
app=kwargs['binary'],
verbose=verbose,
xre=True): # Equivalent to 'run_local' = True.
return 1
debug_command = '--debug-command'
if debug_command in sys.argv:
sys.argv.remove(debug_command)
raptor = self._spawn(RaptorRunner)
device = None
try:
if kwargs['power_test'] and is_android:
device = ADBAndroid(verbose=True)
disable_charging(device)
return raptor.run_test(sys.argv[2:], kwargs)
except BinaryNotFoundException as e:
self.log(logging.ERROR, 'raptor', {'error': str(e)},
'ERROR: {error}')
self.log(logging.INFO, 'raptor', {'help': e.help()}, '{help}')
return 1
except Exception as e:
print(repr(e))
return 1
finally:
if kwargs['power_test'] and device:
enable_charging(device)
def setup_junit_argument_parser():
build_obj = MozbuildObject.from_environment(cwd=here)
build_path = os.path.join(build_obj.topobjdir, "build")
if build_path not in sys.path:
sys.path.append(build_path)
mochitest_dir = os.path.join(build_obj.topobjdir, "_tests", "testing",
"mochitest")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
# runtests.py contains MochitestDesktop, required by runjunit
import imp
path = os.path.join(build_obj.topobjdir, mochitest_dir, "runtests.py")
if not os.path.exists(path):
path = os.path.join(here, "runtests.py")
with open(path, "r") as fh:
imp.load_module("mochitest", fh, path, (".py", "r", imp.PY_SOURCE))
import runjunit
from mozrunner.devices.android_device import (
verify_android_device,
InstallIntent,
)
verify_android_device(build_obj,
install=InstallIntent.NO,
xre=True,
network=True)
global parser
parser = runjunit.JunitArgumentParser()
return parser
def run_junit(command_context, no_install, **kwargs):
command_context._ensure_state_subdir_exists(".")
from mozrunner.devices.android_device import (
get_adb_path,
verify_android_device,
InstallIntent,
)
# verify installation
app = kwargs.get("app")
device_serial = kwargs.get("deviceSerial")
verify_android_device(
command_context,
install=InstallIntent.NO if no_install else InstallIntent.YES,
xre=False,
app=app,
device_serial=device_serial,
)
if not kwargs.get("adbPath"):
kwargs["adbPath"] = get_adb_path(command_context)
if not kwargs.get("log"):
from mozlog.commandline import setup_logging
format_args = {
"level": command_context._mach_context.settings["test"]["level"]
}
default_format = command_context._mach_context.settings["test"][
"format"]
kwargs["log"] = setup_logging("mach-mochitest", kwargs,
{default_format: sys.stdout},
format_args)
mochitest = command_context._spawn(MochitestRunner)
return mochitest.run_geckoview_junit_test(command_context._mach_context,
**kwargs)
def run_raptor_test(self, **kwargs):
from mozrunner.devices.android_device import verify_android_device
build_obj = MozbuildObject.from_environment(cwd=HERE)
if not verify_android_device(build_obj, install=True, app=kwargs['binary']):
return 1
debug_command = '--debug-command'
if debug_command in sys.argv:
sys.argv.remove(debug_command)
raptor = self._spawn(RaptorRunner)
try:
return raptor.run_test(sys.argv[2:], app=kwargs['app'])
except Exception as e:
print(str(e))
return 1
def run_raptor(self, **kwargs):
build_obj = self
is_android = Conditions.is_android(build_obj) or \
kwargs['app'] in ANDROID_BROWSERS
if is_android:
from mozrunner.devices.android_device import (
verify_android_device, InstallIntent)
from mozdevice import ADBAndroid
install = InstallIntent.NO if kwargs.pop(
'noinstall', False) else InstallIntent.YES
if not verify_android_device(
build_obj, install=install, app=kwargs['binary'],
xre=True): # Equivalent to 'run_local' = True.
return 1
debug_command = '--debug-command'
if debug_command in sys.argv:
sys.argv.remove(debug_command)
raptor = self._spawn(RaptorRunner)
device = None
try:
if kwargs['power_test'] and is_android:
device = ADBAndroid(verbose=True)
disable_charging(device)
return raptor.run_test(sys.argv[2:], kwargs)
except BinaryNotFoundException as e:
self.log(logging.ERROR, 'raptor', {'error': str(e)},
'ERROR: {error}')
self.log(logging.INFO, 'raptor', {'help': e.help()}, '{help}')
return 1
except Exception as e:
print(repr(e))
return 1
finally:
if kwargs['power_test'] and device:
enable_charging(device)
def run_mochitest_general(self,
flavor=None,
test_objects=None,
resolve_tests=True,
**kwargs):
from mochitest_options import ALL_FLAVORS
from mozlog.commandline import setup_logging
from mozlog.handlers import StreamHandler
from moztest.resolve import get_suite_definition
buildapp = None
for app in SUPPORTED_APPS:
if is_buildapp_in(app)(self):
buildapp = app
break
flavors = None
if flavor:
for fname, fobj in ALL_FLAVORS.iteritems():
if flavor in fobj['aliases']:
if buildapp not in fobj['enabled_apps']:
continue
flavors = [fname]
break
else:
flavors = [
f for f, v in ALL_FLAVORS.iteritems()
if buildapp in v['enabled_apps']
]
from mozbuild.controller.building import BuildDriver
self._ensure_state_subdir_exists('.')
test_paths = kwargs['test_paths']
kwargs['test_paths'] = []
mochitest = self._spawn(MochitestRunner)
tests = []
if resolve_tests:
tests = mochitest.resolve_tests(test_paths,
test_objects,
cwd=self._mach_context.cwd)
if not kwargs.get('log'):
# Create shared logger
format_args = {
'level': self._mach_context.settings['test']['level']
}
if len(tests) == 1:
format_args['verbose'] = True
format_args['compact'] = False
default_format = self._mach_context.settings['test']['format']
kwargs['log'] = setup_logging('mach-mochitest', kwargs,
{default_format: sys.stdout},
format_args)
for handler in kwargs['log'].handlers:
if isinstance(handler, StreamHandler):
handler.formatter.inner.summary_on_shutdown = True
driver = self._spawn(BuildDriver)
driver.install_tests(tests)
subsuite = kwargs.get('subsuite')
if subsuite == 'default':
kwargs['subsuite'] = None
suites = defaultdict(list)
unsupported = set()
for test in tests:
# Filter out non-mochitests and unsupported flavors.
if test['flavor'] not in ALL_FLAVORS:
continue
key = (test['flavor'], test.get('subsuite', ''))
if test['flavor'] not in flavors:
unsupported.add(key)
continue
if subsuite == 'default':
# "--subsuite default" means only run tests that don't have a subsuite
if test.get('subsuite'):
unsupported.add(key)
continue
elif subsuite and test.get('subsuite', '') != subsuite:
unsupported.add(key)
continue
suites[key].append(test)
if ('mochitest', 'media') in suites:
req = os.path.join('testing', 'tools', 'websocketprocessbridge',
'websocketprocessbridge_requirements.txt')
self.virtualenv_manager.activate()
self.virtualenv_manager.install_pip_requirements(
req, require_hashes=False)
# sys.executable is used to start the websocketprocessbridge, though for some
# reason it doesn't get set when calling `activate_this.py` in the virtualenv.
sys.executable = self.virtualenv_manager.python_path
# This is a hack to introduce an option in mach to not send
# filtered tests to the mochitest harness. Mochitest harness will read
# the master manifest in that case.
if not resolve_tests:
for flavor in flavors:
key = (flavor, kwargs.get('subsuite'))
suites[key] = []
if not suites:
# Make it very clear why no tests were found
if not unsupported:
print(
TESTS_NOT_FOUND.format('\n'.join(
sorted(list(test_paths or test_objects)))))
return 1
msg = []
for f, s in unsupported:
fobj = ALL_FLAVORS[f]
apps = fobj['enabled_apps']
name = fobj['aliases'][0]
if s:
name = '{} --subsuite {}'.format(name, s)
if buildapp not in apps:
reason = 'requires {}'.format(' or '.join(apps))
else:
reason = 'excluded by the command line'
msg.append(' mochitest -f {} ({})'.format(name, reason))
print(
SUPPORTED_TESTS_NOT_FOUND.format(buildapp,
'\n'.join(sorted(msg))))
return 1
if buildapp == 'android':
from mozrunner.devices.android_device import grant_runtime_permissions
from mozrunner.devices.android_device import verify_android_device
app = kwargs.get('app')
if not app:
app = self.substs["ANDROID_PACKAGE_NAME"]
device_serial = kwargs.get('deviceSerial')
# verify installation
verify_android_device(self,
install=True,
xre=False,
network=True,
app=app,
device_serial=device_serial)
grant_runtime_permissions(self, app, device_serial=device_serial)
run_mochitest = mochitest.run_android_test
else:
run_mochitest = mochitest.run_desktop_test
overall = None
for (flavor, subsuite), tests in sorted(suites.items()):
_, suite = get_suite_definition(flavor, subsuite)
if 'test_paths' in suite['kwargs']:
del suite['kwargs']['test_paths']
harness_args = kwargs.copy()
harness_args.update(suite['kwargs'])
result = run_mochitest(self._mach_context,
tests=tests,
**harness_args)
if result:
overall = result
# Halt tests on keyboard interrupt
if result == -1:
break
# Only shutdown the logger if we created it
if kwargs['log'].name == 'mach-mochitest':
kwargs['log'].shutdown()
return overall
def run(self,
app='org.mozilla.geckoview_example',
intent=None,
env=[],
profile=None,
url=None,
no_install=None,
no_wait=None,
fail_if_running=None,
restart=None):
from mozrunner.devices.android_device import verify_android_device, _get_device
from six.moves import shlex_quote
if app == 'org.mozilla.geckoview_example':
activity_name = 'org.mozilla.geckoview_example.GeckoViewActivity'
elif app == 'org.mozilla.geckoview.test':
activity_name = 'org.mozilla.geckoview.test.TestRunnerActivity'
elif 'fennec' in app or 'firefox' in app:
activity_name = 'org.mozilla.gecko.BrowserApp'
else:
raise RuntimeError('Application not recognized: {}'.format(app))
# `verify_android_device` respects `DEVICE_SERIAL` if it is set and sets it otherwise.
verify_android_device(self, app=app, install=not no_install)
device_serial = os.environ.get('DEVICE_SERIAL')
if not device_serial:
print('No ADB devices connected.')
return 1
device = _get_device(self.substs, device_serial=device_serial)
args = []
if profile:
if os.path.isdir(profile):
host_profile = profile
# Always /data/local/tmp, rather than `device.test_root`, because GeckoView only
# takes its configuration file from /data/local/tmp, and we want to follow suit.
target_profile = '/data/local/tmp/{}-profile'.format(app)
device.rm(target_profile, recursive=True, force=True)
device.push(host_profile, target_profile)
self.log(
logging.INFO, "run", {
'host_profile': host_profile,
'target_profile': target_profile
},
'Pushed profile from host "{host_profile}" to target "{target_profile}"'
)
else:
target_profile = profile
self.log(logging.INFO, "run",
{'target_profile': target_profile},
'Using profile from target "{target_profile}"')
args = ['--profile', shlex_quote(target_profile)]
extras = {}
for i, e in enumerate(env):
extras['env{}'.format(i)] = e
if args:
extras['args'] = " ".join(args)
extras[
'use_multiprocess'] = True # Only GVE and TRA process this extra.
if env or args:
restart = True
if restart:
fail_if_running = False
self.log(logging.INFO, "run", {'app': app},
'Stopping {app} to ensure clean restart.')
device.stop_application(app)
# We'd prefer to log the actual `am start ...` command, but it's not trivial to wire the
# device's logger to mach's logger.
self.log(logging.INFO, "run", {
'app': app,
'activity_name': activity_name
}, 'Starting {app}/{activity_name}.')
device.launch_application(app_name=app,
activity_name=activity_name,
intent=intent,
extras=extras,
url=url,
wait=not no_wait,
fail_if_running=fail_if_running)
return 0
