def app_installed(device, apk):
pkg = apk_helper.GetPackageName(apk)
device.Install(apk)
try:
yield
finally:
device.Uninstall(pkg)
def __init__(self, args, error_func):
"""Constructor.
Args:
args: Command line arguments.
"""
super(UirobotTestInstance, self).__init__()
if not args.app_under_test:
error_func('Must set --app-under-test.')
self._app_under_test = args.app_under_test
self._minutes = args.minutes
if args.remote_device_file:
with open(args.remote_device_file) as remote_device_file:
device_json = json.load(remote_device_file)
else:
device_json = {}
device_type = device_json.get('device_type', 'Android')
if args.device_type:
if device_type and device_type != args.device_type:
logging.info('Overriding device_type from %s to %s',
device_type, args.device_type)
device_type = args.device_type
if device_type == 'Android':
self._suite = 'Android Uirobot'
self._package_name = apk_helper.GetPackageName(self._app_under_test)
elif device_type == 'iOS':
self._suite = 'iOS Uirobot'
self._package_name = self._app_under_test
def UpdateExecutableIfNeeded(self):
# TODO(crbug.com/815133): This logic should belong to backend_settings.
for apk in self._support_apk_list:
logging.warn('Installing %s on device if needed.', apk)
self.platform.InstallApplication(apk)
apk_name = self._backend_settings.GetApkName(
self._platform_backend.device)
is_webview_apk = apk_name is not None and (
'SystemWebView' in apk_name or 'system_webview' in apk_name or
'TrichromeWebView' in apk_name or 'trichrome_webview' in apk_name)
# The WebView fallback logic prevents sideloaded WebView APKs from being
# installed and set as the WebView implementation correctly. Disable the
# fallback logic before installing the WebView APK to make sure the fallback
# logic doesn't interfere.
if is_webview_apk:
self._platform_backend.device.SetWebViewFallbackLogic(False)
if self._local_apk:
logging.warn('Installing %s on device if needed.', self._local_apk)
self.platform.InstallApplication(self._local_apk,
modules=self._modules_to_install)
if ((is_webview_apk or apk_name == 'Monochrome.apk')
and self._platform_backend.device.build_version_sdk >=
version_codes.NOUGAT):
package_name = apk_helper.GetPackageName(self._local_apk)
logging.warn('Setting %s as WebView implementation.', package_name)
self._platform_backend.device.SetWebViewImplementation(
package_name)
def run_android_webview(device, adapter):
if adapter.options.package_name:
logger.warn(
'--package-name has no effect for android_webview, provider'
'will be set to the --apk if it is provided.')
if adapter.options.system_webview_shell:
shell_pkg = apk_helper.GetPackageName(
adapter.options.system_webview_shell)
if shell_pkg != SYSTEM_WEBVIEW_SHELL_PKG:
raise Exception(
'{} has incorrect package name: {}, expected {}.'.format(
'--system-webview-shell apk', shell_pkg,
SYSTEM_WEBVIEW_SHELL_PKG))
install_shell_as_needed = system_app.ReplaceSystemApp(
device, shell_pkg, adapter.options.system_webview_shell)
logger.info('Will install ' + shell_pkg + ' at ' +
adapter.options.system_webview_shell)
else:
install_shell_as_needed = no_op()
if adapter.options.apk:
install_webview_as_needed = webview_app.UseWebViewProvider(
device, adapter.options.apk)
logger.info('Will install WebView apk at ' + adapter.options.apk)
else:
install_webview_as_needed = no_op()
with install_shell_as_needed, install_webview_as_needed:
return adapter.run_test()
def __init__(self, device):
super(WPTWebviewAdapter, self).__init__(device)
if self.options.system_webview_shell is not None:
self.system_webview_shell_pkg = apk_helper.GetPackageName(
self.options.system_webview_shell)
else:
self.system_webview_shell_pkg = 'org.chromium.webview_shell'
def _TemporarilyInstallApp(device, apk):
"""A context manager that installs an app while in scope."""
device.Install(apk, reinstall=True)
try:
yield
finally:
device.Uninstall(apk_helper.GetPackageName(apk))
def TriggerSymlinkScript(options):
device = build_device.GetBuildDeviceFromPath(
options.build_device_configuration)
if not device:
return
apk_package = apk_helper.GetPackageName(options.apk)
apk_libraries_dir = '/data/data/%s/lib' % apk_package
device_dir = os.path.dirname(options.script_device_path)
mkdir_cmd = ('if [ ! -e %(dir)s ]; then mkdir -p %(dir)s; fi ' % {
'dir': device_dir
})
RunShellCommand(device, mkdir_cmd)
device.PushChangedFiles([(os.path.abspath(options.script_host_path),
options.script_device_path)])
trigger_cmd = ('APK_LIBRARIES_DIR=%(apk_libraries_dir)s; '
'STRIPPED_LIBRARIES_DIR=%(target_dir)s; '
'. %(script_device_path)s') % {
'apk_libraries_dir': apk_libraries_dir,
'target_dir': options.target_dir,
'script_device_path': options.script_device_path
}
RunShellCommand(device, trigger_cmd)
def main():
parser = optparse.OptionParser()
parser.add_option('--apk-path', help='Path to .apk to install.')
parser.add_option(
'--split-apk-path',
help='Path to .apk splits (can specify multiple times, causes '
'--install-multiple to be used.',
action='append')
parser.add_option('--android-sdk-tools',
help='Path to the Android SDK build tools folder. ' +
'Required when using --split-apk-path.')
parser.add_option(
'--install-record',
help='Path to install record (touched only when APK is installed).')
parser.add_option('--build-device-configuration',
help='Path to build device configuration.')
parser.add_option('--stamp', help='Path to touch on success.')
parser.add_option('--configuration-name',
help='The build CONFIGURATION_NAME')
parser.add_option('--output-directory', help='The output directory.')
options, _ = parser.parse_args()
constants.SetBuildType(options.configuration_name)
devil_chromium.Initialize(
output_directory=os.path.abspath(options.output_directory))
device = build_device.GetBuildDeviceFromPath(
options.build_device_configuration)
if not device:
return
serial_number = device.GetSerialNumber()
apk_package = apk_helper.GetPackageName(options.apk_path)
metadata_path = '%s.%s.device.time.stamp' % (options.apk_path,
serial_number)
# If the APK on the device does not match the one that was last installed by
# the build, then the APK has to be installed (regardless of the md5 record).
force_install = HasInstallMetadataChanged(device, apk_package,
metadata_path)
def Install():
if options.split_apk_path:
device.InstallSplitApk(options.apk_path, options.split_apk_path)
else:
device.Install(options.apk_path, reinstall=True)
RecordInstallMetadata(device, apk_package, metadata_path)
build_utils.Touch(options.install_record)
record_path = '%s.%s.md5.stamp' % (options.apk_path, serial_number)
md5_check.CallAndRecordIfStale(Install,
record_path=record_path,
input_paths=[options.apk_path],
force=force_install)
if options.stamp:
build_utils.Touch(options.stamp)
def _FindAllPossibleBrowsers(finder_options, android_platform):
"""Testable version of FindAllAvailableBrowsers."""
if not android_platform:
return []
possible_browsers = []
for apk in finder_options.webview_embedder_apk:
if not os.path.exists(apk):
raise exceptions.PathMissingError(
'Unable to find apk specified by --webview-embedder-apk=%s' % apk)
# Add the exact APK if given.
if _CanPossiblyHandlePath(finder_options.browser_executable):
if not os.path.exists(finder_options.browser_executable):
raise exceptions.PathMissingError(
'Unable to find exact apk specified by --browser-executable=%s' %
finder_options.browser_executable)
package_name = apk_helper.GetPackageName(finder_options.browser_executable)
try:
backend_settings = next(
b for b in ANDROID_BACKEND_SETTINGS if b.package == package_name)
except StopIteration:
raise exceptions.UnknownPackageError(
'%s specified by --browser-executable has an unknown package: %s' %
(finder_options.browser_executable, package_name))
possible_browsers.append(PossibleAndroidBrowser(
'exact',
finder_options,
android_platform,
backend_settings,
finder_options.browser_executable))
if finder_options.IsBrowserTypeRelevant('reference'):
reference_browser = _GetReferenceAndroidBrowser(
android_platform, finder_options)
if reference_browser:
possible_browsers.append(reference_browser)
# Add any other known available browsers.
for settings in ANDROID_BACKEND_SETTINGS:
if finder_options.IsBrowserTypeRelevant(settings.browser_type):
local_apk = None
if finder_options.IsBrowserTypeReference():
local_apk = _FetchReferenceApk(
android_platform, finder_options.IsBrowserTypeBundle())
if settings.IsWebView():
p_browser = PossibleAndroidBrowser(
settings.browser_type, finder_options, android_platform, settings,
local_apk=local_apk, target_os='android_webview')
else:
p_browser = PossibleAndroidBrowser(
settings.browser_type, finder_options, android_platform, settings,
local_apk=local_apk)
if p_browser.IsAvailable():
possible_browsers.append(p_browser)
return possible_browsers
def Create(self, finder_options):
self._InitPlatformIfNeeded()
mandoline_backend = android_mandoline_backend.AndroidMandolineBackend(
self._platform_backend, finder_options.browser_options,
finder_options.target_arch, self.browser_type, self._build_path,
apk_helper.GetPackageName(self._local_apk), self._chrome_root)
return browser.Browser(mandoline_backend, self._platform_backend,
self._credentials_path)
def _InstallApp(device, apk):
""" Make apk installed while in scope. """
package_name = apk_helper.GetPackageName(apk)
device.Install(apk, reinstall=True, timeout=_WEBVIEW_INSTALL_TIMEOUT)
try:
yield
finally:
device.Uninstall(package_name)
def _InstallApp(device, apk):
""" Make apk installed while in scope. """
package_name = apk_helper.GetPackageName(apk)
device.Install(apk, reinstall=True)
try:
yield
finally:
device.Uninstall(package_name)
def __init__(self, config, chrome_root): self.adb_path = adb_wrapper.AdbWrapper.GetAdbPath() self.config = config self.paths = Paths(config, chrome_root) self.device = None self.shell_args = [] self.target_package = apk_helper.GetPackageName(self.paths.apk_path) self.temp_gdb_dir = None
def _FindAllPossibleBrowsers(finder_options, android_platform):
"""Testable version of FindAllAvailableBrowsers."""
if not android_platform:
return []
possible_browsers = []
# Add the exact APK if given.
if _CanPossiblyHandlePath(finder_options.browser_executable):
if not os.path.exists(finder_options.browser_executable):
raise exceptions.PathMissingError(
'Unable to find exact apk specified by --browser-executable=%s'
% finder_options.browser_executable)
package_name = apk_helper.GetPackageName(
finder_options.browser_executable)
try:
backend_settings = next(backend_settings
for target_package, backend_settings in
CHROME_PACKAGE_NAMES.itervalues()
if package_name == target_package)
except StopIteration:
raise exceptions.UnknownPackageError(
'%s specified by --browser-executable has an unknown package: %s'
% (finder_options.browser_executable, package_name))
possible_browsers.append(
PossibleAndroidBrowser('exact', finder_options, android_platform,
backend_settings(package_name),
finder_options.browser_executable))
# Add the reference build if found.
os_version = dependency_util.GetChromeApkOsVersion(
android_platform.GetOSVersionName())
arch = android_platform.GetArchName()
try:
reference_build = binary_manager.FetchPath('chrome_stable', arch,
'android', os_version)
except (binary_manager.NoPathFoundError, binary_manager.CloudStorageError):
reference_build = None
if reference_build and os.path.exists(reference_build):
# TODO(aiolos): how do we stably map the android chrome_stable apk to the
# correct package name?
package, backend_settings = CHROME_PACKAGE_NAMES['android-chrome']
possible_browsers.append(
PossibleAndroidBrowser('reference',
finder_options, android_platform,
backend_settings(package), reference_build))
# Add any known local versions.
for name, package_info in CHROME_PACKAGE_NAMES.iteritems():
package, backend_settings = package_info
p_browser = PossibleAndroidBrowser(name, finder_options,
android_platform,
backend_settings(package))
if p_browser.IsAvailable():
possible_browsers.append(p_browser)
return possible_browsers
def main():
parser = argparse.ArgumentParser(
description="Script to do semi-automated upgrade testing.")
parser.add_argument('-v',
'--verbose',
action='count',
help='Print verbose log information.')
parser.add_argument('--blacklist-file',
dest='denylist_file',
help=argparse.SUPPRESS)
parser.add_argument('--denylist-file', help='Device denylist JSON file.')
command_parsers = parser.add_subparsers(dest='command')
subparser = command_parsers.add_parser('create_app_data')
subparser.add_argument('--old-apk',
required=True,
help='Path to apk to update from.')
subparser.add_argument('--app-data',
required=True,
help='Path to where the app data backup should be '
'saved to.')
subparser.add_argument('--package-name', help='Chrome apk package name.')
subparser = command_parsers.add_parser('test_update')
subparser.add_argument('--old-apk',
required=True,
help='Path to apk to update from.')
subparser.add_argument('--new-apk',
required=True,
help='Path to apk to update to.')
subparser.add_argument('--app-data',
required=True,
help='Path to where the app data backup is saved.')
subparser.add_argument('--package-name', help='Chrome apk package name.')
args = parser.parse_args()
run_tests_helper.SetLogLevel(args.verbose)
devil_chromium.Initialize()
denylist = (device_denylist.Denylist(args.denylist_file)
if args.denylist_file else None)
devices = device_utils.DeviceUtils.HealthyDevices(denylist)
if not devices:
raise device_errors.NoDevicesError()
device = devices[0]
logging.info('Using device %s for testing.', str(device))
package_name = (args.package_name if args.package_name else
apk_helper.GetPackageName(args.old_apk))
if args.command == 'create_app_data':
CreateAppData(device, args.old_apk, args.app_data, package_name)
elif args.command == 'test_update':
TestUpdate(device, args.old_apk, args.new_apk, args.app_data,
package_name)
else:
raise Exception('Unknown test command: %s' % args.command)
def rest_args(self):
rest_args = super(WPTAndroidAdapter, self).rest_args
# Here we add all of the arguments required to run WPT tests on Android.
rest_args.extend([self.options.wpt_path])
# vpython has packages needed by wpt, so force it to skip the setup
rest_args.extend(["--venv=../../", "--skip-venv-setup"])
rest_args.extend([
"run",
"--test-type=" + self.options.test_type,
self.options.product,
"--webdriver-binary",
self.options.webdriver_binary,
"--headless",
"--no-pause-after-test",
"--no-capture-stdio",
"--no-manifest-download",
"--no-fail-on-unexpected",
#TODO(aluo): Tune this as tests are stabilized
"--timeout-multiplier",
"0.25",
])
# Lets weblayer know it's running in test mode.
if self.options.product == 'android_weblayer':
rest_args.extend(["--binary-arg=--run-web-tests"])
# Default to the apk's package name for chrome_android
if not self.options.package_name:
if self.options.product == 'chrome_android':
if self.options.apk:
pkg = apk_helper.GetPackageName(self.options.apk)
logger.info(
"Defaulting --package-name to that of the apk: %s",
pkg)
rest_args.extend(['--package-name', pkg])
else:
raise Exception(
'chrome_android requires --package-name or --apk.')
else:
rest_args.extend(['--package-name', self.options.package_name])
if self.options.verbose >= 3:
rest_args.extend([
"--log-mach=-", "--log-mach-level=debug", "--log-mach-verbose"
])
if self.options.verbose >= 4:
rest_args.extend([
'--webdriver-arg=--verbose', '--webdriver-arg="--log-path=-"'
])
rest_args.extend(self.pass_through_wpt_args)
return rest_args
def __init__(self, apk_path, jar_path, test_support_apk_path):
test_jar.TestJar.__init__(self, jar_path)
if not os.path.exists(apk_path):
raise Exception('%s not found, please build it' % apk_path)
self._apk_path = apk_path
self._apk_name = os.path.splitext(os.path.basename(apk_path))[0]
self._package_name = apk_helper.GetPackageName(self._apk_path)
self._test_support_apk_path = test_support_apk_path
def SetUpProcess(cls):
"""Prepares the test device"""
super(WebViewCrxSmokeTests, cls).SetUpProcess()
assert cls._finder_options.crx_file, '--crx-file is required'
assert cls._finder_options.component_name, '--component-name is required'
cls.SetBrowserOptions(cls._finder_options)
webview_package_name = cls._finder_options.webview_package_name
if not webview_package_name:
webview_provider_apk = (cls._browser_to_create
.settings.GetApkName(cls._device))
webview_apk_path = util.FindLatestApkOnHost(
cls._finder_options.chrome_root, webview_provider_apk)
webview_package_name = apk_helper.GetPackageName(webview_apk_path)
cls._device_components_dir = ('/data/data/%s/app_webview/components' %
webview_package_name)
logcat_output_dir = (
os.path.dirname(cls._typ_runner.args.write_full_results_to or '') or
os.getcwd())
# Set up a logcat monitor
cls._logcat_monitor = logcat_monitor.LogcatMonitor(
cls._device.adb,
output_file=os.path.join(logcat_output_dir,
'%s_logcat.txt' % cls.Name()),
filter_specs=_LOGCAT_FILTERS)
cls._logcat_monitor.Start()
cls._MaybeClearOutComponentsDir()
component_id = _COMPONENT_NAME_TO_DATA.get(
cls._finder_options.component_name).component_id
with zipfile.ZipFile(cls._finder_options.crx_file) as crx_archive, \
NamedTemporaryDirectory() as tmp_dir, \
crx_archive.open('manifest.json') as manifest:
crx_device_dir = posixpath.join(
cls._device_components_dir, 'cps',
component_id, '1_%s' % json.loads(manifest.read())['version'])
try:
# Create directory on the test device for the CRX files
logger.info('Creating directory %r on device' % crx_device_dir)
output = cls._device.RunShellCommand(
['mkdir', '-p', crx_device_dir])
logger.debug('Recieved the following output from adb: %s' % output)
except Exception as e:
logger.exception('Exception %r was raised' % str(e))
raise
# Move CRX files to the device directory
crx_archive.extractall(tmp_dir)
cls._MoveNewCrxToDevice(tmp_dir, crx_device_dir)
# Start the browser after the device is in a clean state and the CRX
# files are loaded onto the device
cls.StartBrowser()
def UpdateExecutableIfNeeded(self):
# TODO(crbug.com/815133): This logic should belong to backend_settings.
for apk in self._support_apk_list:
logging.warn('Installing %s on device if needed.', apk)
self.platform.InstallApplication(apk)
apk_name = self._backend_settings.GetApkName(
self._platform_backend.device)
is_webview_apk = apk_name is not None and (
'SystemWebView' in apk_name or 'system_webview' in apk_name or
'TrichromeWebView' in apk_name or 'trichrome_webview' in apk_name)
# The WebView fallback logic prevents sideloaded WebView APKs from being
# installed and set as the WebView implementation correctly. Disable the
# fallback logic before installing the WebView APK to make sure the fallback
# logic doesn't interfere.
if is_webview_apk:
self._platform_backend.device.SetWebViewFallbackLogic(False)
if self._local_apk:
logging.warn('Installing %s on device if needed.', self._local_apk)
self.platform.InstallApplication(self._local_apk,
modules=self._modules_to_install)
if self._compile_apk:
package_name = apk_helper.GetPackageName(self._local_apk)
logging.warn('Compiling %s.', package_name)
self._platform_backend.device.RunShellCommand(
[
'cmd', 'package', 'compile', '-m', self._compile_apk,
'-f', package_name
],
check_return=True)
sdk_version = self._platform_backend.device.build_version_sdk
# Bundles are in the ../bin directory, so it's safer to just check the
# correct name is part of the path.
is_monochrome = apk_name is not None and (
apk_name == 'Monochrome.apk' or 'monochrome_bundle' in apk_name)
if ((is_webview_apk or
(is_monochrome and sdk_version < version_codes.Q))
and sdk_version >= version_codes.NOUGAT):
package_name = apk_helper.GetPackageName(self._local_apk)
logging.warn('Setting %s as WebView implementation.', package_name)
self._platform_backend.device.SetWebViewImplementation(
package_name)
def get_package_name(apk_path):
"""Get package name from apk
Args:
apk_path: Path to apk
Returns:
Package name of apk
"""
return apk_helper.GetPackageName(apk_path)
def __init__(self, config, chrome_root):
self.adb_path = constants.GetAdbPath()
self.config = config
self.paths = Paths(config, chrome_root)
self.device = None
self.shell_args = []
self.target_package = apk_helper.GetPackageName(self.paths.apk_path)
self.temp_gdb_dir = None
# This is used by decive_utils.Install to check if the apk needs updating.
constants.SetOutputDirectory(self.paths.build_dir)
def _FindAllPossibleBrowsers(finder_options, android_platform):
"""Testable version of FindAllAvailableBrowsers."""
if not android_platform:
return []
possible_browsers = []
# Add the exact APK if given.
if _CanPossiblyHandlePath(finder_options.browser_executable):
if not os.path.exists(finder_options.browser_executable):
raise exceptions.PathMissingError(
'Unable to find exact apk specified by --browser-executable=%s'
% finder_options.browser_executable)
package_name = apk_helper.GetPackageName(
finder_options.browser_executable)
try:
backend_settings = next(b for b in ANDROID_BACKEND_SETTINGS
if b.package == package_name)
except StopIteration:
raise exceptions.UnknownPackageError(
'%s specified by --browser-executable has an unknown package: %s'
% (finder_options.browser_executable, package_name))
possible_browsers.append(
PossibleAndroidBrowser('exact', finder_options, android_platform,
backend_settings,
finder_options.browser_executable))
# Add the reference build if found.
os_version = dependency_util.GetChromeApkOsVersion(
android_platform.GetOSVersionName())
arch = android_platform.GetArchName()
try:
reference_build = binary_manager.FetchPath('chrome_stable', arch,
'android', os_version)
except (binary_manager.NoPathFoundError, binary_manager.CloudStorageError):
reference_build = None
if reference_build and os.path.exists(reference_build):
# TODO(aiolos): how do we stably map the android chrome_stable apk to the
# correct backend settings?
possible_browsers.append(
PossibleAndroidBrowser(
'reference', finder_options, android_platform,
android_browser_backend_settings.ANDROID_CHROME,
reference_build))
# Add any other known available browsers.
for settings in ANDROID_BACKEND_SETTINGS:
p_browser = PossibleAndroidBrowser(settings.browser_type,
finder_options, android_platform,
settings)
if p_browser.IsAvailable():
possible_browsers.append(p_browser)
return possible_browsers
def _TemporarilyInstallApp(device, apk, install_timeout=None):
"""A context manager that installs an app while in scope."""
if install_timeout is None:
device.Install(apk, reinstall=True)
else:
device.Install(apk, reinstall=True, timeout=install_timeout)
try:
yield
finally:
device.Uninstall(apk_helper.GetPackageName(apk))
def rest_args(self):
rest_args = super(WPTAndroidAdapter, self).rest_args
# Here we add all of the arguments required to run WPT tests on Android.
rest_args.extend([self.options.wpt_path])
# vpython has packages needed by wpt, so force it to skip the setup
rest_args.extend(["--venv=../../", "--skip-venv-setup"])
rest_args.extend([
"run",
"--test-type=" + self.options.test_type,
self.options.product,
"--webdriver-binary",
self.options.webdriver_binary,
"--headless",
"--no-pause-after-test",
"--no-capture-stdio",
"--no-manifest-download",
])
# if metadata was created then add the metadata directory
# to the list of wpt arguments
if self._metadata_dir:
rest_args.extend(['--metadata', self._metadata_dir])
# Default to the apk's package name for chrome_android
if not self.options.package_name:
if self.options.product == 'chrome_android':
if self.options.apk:
pkg = apk_helper.GetPackageName(self.options.apk)
logger.info(
"Defaulting --package-name to that of the apk: %s",
pkg)
rest_args.extend(['--package-name', pkg])
else:
raise Exception(
'chrome_android requires --package-name or --apk.')
else:
rest_args.extend(['--package-name', self.options.package_name])
if self.options.verbose >= 3:
rest_args.extend([
"--log-mach=-", "--log-mach-level=debug", "--log-mach-verbose"
])
if self.options.verbose >= 4:
rest_args.extend([
'--webdriver-arg=--verbose', '--webdriver-arg="--log-path=-"'
])
rest_args.extend(self.pass_through_wpt_args)
return rest_args
def rest_args(self):
args = super(WPTClankAdapter, self).rest_args
if not self.options.chrome_package_name and not self.options.chrome_apk:
raise Exception('Either the --chrome-package-name or --chrome-apk '
'command line arguments must be used.')
if not self.options.chrome_package_name:
self.options.chrome_package_name = apk_helper.GetPackageName(
self.options.chrome_apk)
logger.info("Using Chrome apk's default package %s." %
self.options.chrome_package_name)
args.extend(['--package-name', self.options.chrome_package_name])
# add the product postional argument
args.append(CHROME_ANDROID)
return args
def rest_args(self):
rest_args = super(WPTAndroidAdapter, self).rest_args
# Here we add all of the arguments required to run WPT tests on Android.
rest_args.extend([self.options.wpt_path])
# vpython has packages needed by wpt, so force it to skip the setup
rest_args.extend(["--venv=../../", "--skip-venv-setup"])
rest_args.extend([
"run",
"--test-type=" + self.options.test_type,
self.options.product,
"--webdriver-binary",
self.options.webdriver_binary,
"--headless",
"--no-pause-after-test",
"--no-capture-stdio",
"--no-manifest-download",
"--no-fail-on-unexpected",
#TODO(aluo): Tune this as tests are stabilized
"--timeout-multiplier",
"0.25",
])
# Default to the apk's package name for chrome_android
if not self.options.package_name:
if self.options.product == 'chrome_android':
if self.options.apk:
pkg = apk_helper.GetPackageName(self.options.apk)
print("Defaulting --package-name to that of the apk: {}.".
format(pkg))
rest_args.extend(['--package-name', pkg])
else:
raise Exception(
'chrome_android requires --package-name or --apk.')
else:
rest_args.extend(['--package-name', self.options.package_name])
if self.options.include:
for i in self.options.include:
rest_args.extend(['--include', i])
if self.options.list_tests:
rest_args.extend(['--list-tests'])
return rest_args
def _FindAllPossibleBrowsers(finder_options, android_platform):
"""Testable version of FindAllAvailableBrowsers."""
if not android_platform:
return []
possible_browsers = []
# Add the exact APK if given.
if (finder_options.browser_executable
and CanPossiblyHandlePath(finder_options.browser_executable)):
apk_name = os.path.basename(finder_options.browser_executable)
package_info = next((info
for info in CHROME_PACKAGE_NAMES.itervalues()
if info[2] == apk_name), None)
# It is okay if the APK name doesn't match any of known chrome browser APKs,
# since it may be of a different browser (say, mandoline).
if package_info:
normalized_path = os.path.expanduser(
finder_options.browser_executable)
exact_package = apk_helper.GetPackageName(normalized_path)
if not exact_package:
raise exceptions.PackageDetectionError(
'Unable to find package for %s specified by --browser-executable'
% normalized_path)
[package, backend_settings, _] = package_info
if package == exact_package:
possible_browsers.append(
PossibleAndroidBrowser('exact', finder_options,
android_platform,
backend_settings(package),
normalized_path))
else:
raise exceptions.UnknownPackageError(
'%s specified by --browser-executable has an unknown package: %s'
% (normalized_path, exact_package))
for name, package_info in CHROME_PACKAGE_NAMES.iteritems():
package, backend_settings, local_apk = package_info
b = PossibleAndroidBrowser(name, finder_options, android_platform,
backend_settings(package), local_apk)
if b.platform.CanLaunchApplication(package) or b.HaveLocalAPK():
possible_browsers.append(b)
return possible_browsers
def install(device):
print 'Installing %s...' % args.shell_apk_path
device.Install(args.shell_apk_path,
reinstall=True,
allow_downgrade=True)
print 'Success'
for path in args.support_apk_path:
print 'Installing %s...' % path
device.Install(path, reinstall=True, allow_downgrade=True)
print 'Success'
if args.switch_webview_to:
print 'Installing %s...' % args.switch_webview_to
device.Install(args.switch_webview_to,
reinstall=True,
allow_downgrade=True)
package = apk_helper.GetPackageName(args.switch_webview_to)
print 'Setting WebView implementation to %s' % package
device.SetWebViewImplementation(package)
print 'Done'
if os.path.basename(args.shell_apk_path) == 'WebLayerShell.apk':
# When launching weblayer shell use 'weblayer_shell_apk', which supports
# more options.
launch_cmd = [
os.path.join(os.path.dirname(args.shell_apk_path), os.pardir,
'bin', 'weblayer_shell_apk'), 'launch'
]
launch_cmd.extend(args.remaining_args)
subprocess.call(launch_cmd)
elif (os.path.basename(
args.shell_apk_path) == 'WebLayerShellSystemWebView.apk'):
# When launching weblayer shell use 'weblayer_shell_apk', which supports
# more options.
launch_cmd = [
os.path.join(os.path.dirname(args.shell_apk_path), os.pardir,
'bin', 'weblayer_shell_system_webview_apk'),
'launch'
]
launch_cmd.extend(args.remaining_args)
subprocess.call(launch_cmd)
else:
device.adb.Shell('monkey -p org.chromium.weblayer.shell 1')
def maybe_install_user_apk(device, apk, expected_pkg=None):
"""contextmanager to install apk on device.
Args:
device: DeviceUtils instance on which to install the apk.
apk: Apk file path on host.
expected_pkg: Optional, check that apk's package name matches.
Returns:
If apk evaluates to false, returns a do-nothing contextmanager.
Otherwise, returns a contextmanager to install apk on device.
"""
if apk:
pkg = apk_helper.GetPackageName(apk)
if expected_pkg and pkg != expected_pkg:
raise ValueError('{} has incorrect package name: {}, expected {}.'.format(
apk, pkg, expected_pkg))
install_as_needed = app_installed(device, apk, pkg)
logger.info('Will install ' + pkg + ' at ' + apk)
else:
install_as_needed = no_op()
return install_as_needed
def _FindAllPossibleBrowsers(finder_options, android_platform):
"""Testable version of FindAllAvailableBrowsers."""
if not android_platform:
return []
possible_browsers = []
# Add the exact APK if given.
if (finder_options.browser_executable
and CanPossiblyHandlePath(finder_options.browser_executable)):
apk_name = os.path.basename(finder_options.browser_executable)
normalized_path = os.path.expanduser(finder_options.browser_executable)
exact_package = apk_helper.GetPackageName(normalized_path)
package_info = next(
(info for info in CHROME_PACKAGE_NAMES.itervalues()
if info[0] == exact_package or info[2] == apk_name), None)
# It is okay if the APK name or package doesn't match any of known chrome
# browser APKs, since it may be of a different browser.
if package_info:
if not exact_package:
raise exceptions.PackageDetectionError(
'Unable to find package for %s specified by --browser-executable'
% normalized_path)
[package, backend_settings, _] = package_info
if package == exact_package:
possible_browsers.append(
PossibleAndroidBrowser('exact', finder_options,
android_platform,
backend_settings(package),
normalized_path))
else:
raise exceptions.UnknownPackageError(
'%s specified by --browser-executable has an unknown package: %s'
% (normalized_path, exact_package))
# Add the reference build if found.
os_version = dependency_util.GetChromeApkOsVersion(
android_platform.GetOSVersionName())
arch = android_platform.GetArchName()
try:
reference_build = binary_manager.FetchPath('chrome_stable', arch,
'android', os_version)
except (binary_manager.NoPathFoundError, binary_manager.CloudStorageError):
reference_build = None
if reference_build and os.path.exists(reference_build):
# TODO(aiolos): how do we stably map the android chrome_stable apk to the
# correct package name?
package, backend_settings, _ = CHROME_PACKAGE_NAMES['android-chrome']
possible_browsers.append(
PossibleAndroidBrowser('reference',
finder_options, android_platform,
backend_settings(package), reference_build))
# Add any known local versions.
for name, package_info in CHROME_PACKAGE_NAMES.iteritems():
package, backend_settings, apk_name = package_info
if apk_name and not finder_options.chrome_root:
continue
b = PossibleAndroidBrowser(name, finder_options, android_platform,
backend_settings(package), apk_name)
if b.platform.CanLaunchApplication(package) or b.HaveLocalAPK():
possible_browsers.append(b)
return possible_browsers
