diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
commit | 36d22d82aa202bb199967e9512281e9a53db42c9 (patch) | |
tree | 105e8c98ddea1c1e4784a60a5a6410fa416be2de /testing/mozbase/mozrunner | |
parent | Initial commit. (diff) | |
download | firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip |
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'testing/mozbase/mozrunner')
28 files changed, 3569 insertions, 0 deletions
diff --git a/testing/mozbase/mozrunner/mozrunner/__init__.py b/testing/mozbase/mozrunner/mozrunner/__init__.py new file mode 100644 index 0000000000..13cb5e428f --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/__init__.py @@ -0,0 +1,12 @@ +# flake8: noqa +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +import mozrunner.base +import mozrunner.devices +import mozrunner.utils + +from .cli import * +from .errors import * +from .runners import * diff --git a/testing/mozbase/mozrunner/mozrunner/application.py b/testing/mozbase/mozrunner/mozrunner/application.py new file mode 100644 index 0000000000..d1dd91e4c0 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/application.py @@ -0,0 +1,156 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import os +import posixpath +from abc import ABCMeta, abstractmethod +from distutils.spawn import find_executable + +import six +from mozdevice import ADBDeviceFactory +from mozprofile import ( + ChromeProfile, + ChromiumProfile, + FirefoxProfile, + Profile, + ThunderbirdProfile, +) + +here = os.path.abspath(os.path.dirname(__file__)) + + +def get_app_context(appname): + context_map = { + "chrome": ChromeContext, + "chromium": ChromiumContext, + "default": DefaultContext, + "fennec": FennecContext, + "firefox": FirefoxContext, + "thunderbird": ThunderbirdContext, + } + if appname not in context_map: + raise KeyError("Application '%s' not supported!" % appname) + return context_map[appname] + + +class DefaultContext(object): + profile_class = Profile + + +@six.add_metaclass(ABCMeta) +class RemoteContext(object): + device = None + _remote_profile = None + _adb = None + profile_class = Profile + _bindir = None + remote_test_root = "" + remote_process = None + + @property + def bindir(self): + if self._bindir is None: + paths = [find_executable("emulator")] + paths = [p for p in paths if p is not None if os.path.isfile(p)] + if not paths: + self._bindir = "" + else: + self._bindir = os.path.dirname(paths[0]) + return self._bindir + + @property + def adb(self): + if not self._adb: + paths = [ + os.environ.get("ADB"), + os.environ.get("ADB_PATH"), + self.which("adb"), + ] + paths = [p for p in paths if p is not None if os.path.isfile(p)] + if not paths: + raise OSError( + "Could not find the adb binary, make sure it is on your" + "path or set the $ADB_PATH environment variable." + ) + self._adb = paths[0] + return self._adb + + @property + def remote_profile(self): + if not self._remote_profile: + self._remote_profile = posixpath.join(self.remote_test_root, "profile") + return self._remote_profile + + def which(self, binary): + paths = os.environ.get("PATH", {}).split(os.pathsep) + if self.bindir is not None and os.path.abspath(self.bindir) not in paths: + paths.insert(0, os.path.abspath(self.bindir)) + os.environ["PATH"] = os.pathsep.join(paths) + + return find_executable(binary) + + @abstractmethod + def stop_application(self): + """Run (device manager) command to stop application.""" + pass + + +devices = {} + + +class FennecContext(RemoteContext): + _remote_profiles_ini = None + _remote_test_root = None + + def __init__(self, app=None, adb_path=None, avd_home=None, device_serial=None): + self._adb = adb_path + self.avd_home = avd_home + self.remote_process = app + self.device_serial = device_serial + self.device = self.get_device(self.adb, device_serial) + + def get_device(self, adb_path, device_serial): + # Create a mozdevice.ADBDevice object for the specified device_serial + # and cache it for future use. If the same device_serial is subsequently + # requested, retrieve it from the cache to avoid costly re-initialization. + global devices + if device_serial in devices: + device = devices[device_serial] + else: + device = ADBDeviceFactory(adb=adb_path, device=device_serial) + devices[device_serial] = device + return device + + def stop_application(self): + self.device.stop_application(self.remote_process) + + @property + def remote_test_root(self): + if not self._remote_test_root: + self._remote_test_root = self.device.test_root + return self._remote_test_root + + @property + def remote_profiles_ini(self): + if not self._remote_profiles_ini: + self._remote_profiles_ini = posixpath.join( + "/data", "data", self.remote_process, "files", "mozilla", "profiles.ini" + ) + return self._remote_profiles_ini + + +class FirefoxContext(object): + profile_class = FirefoxProfile + + +class ThunderbirdContext(object): + profile_class = ThunderbirdProfile + + +class ChromeContext(object): + profile_class = ChromeProfile + + +class ChromiumContext(object): + profile_class = ChromiumProfile diff --git a/testing/mozbase/mozrunner/mozrunner/base/__init__.py b/testing/mozbase/mozrunner/mozrunner/base/__init__.py new file mode 100644 index 0000000000..373dde1807 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/base/__init__.py @@ -0,0 +1,8 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +# flake8: noqa +from .browser import BlinkRuntimeRunner, GeckoRuntimeRunner +from .device import DeviceRunner, FennecRunner +from .runner import BaseRunner diff --git a/testing/mozbase/mozrunner/mozrunner/base/browser.py b/testing/mozbase/mozrunner/mozrunner/base/browser.py new file mode 100644 index 0000000000..0d7b88adc5 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/base/browser.py @@ -0,0 +1,122 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +import copy +import os +import sys + +import mozinfo + +from ..application import DefaultContext, FirefoxContext +from .runner import BaseRunner + + +class GeckoRuntimeRunner(BaseRunner): + """ + The base runner class used for local gecko runtime binaries, + such as Firefox and Thunderbird. + """ + + def __init__(self, binary, cmdargs=None, **runner_args): + self.show_crash_reporter = runner_args.pop("show_crash_reporter", False) + BaseRunner.__init__(self, **runner_args) + + self.binary = binary + self.cmdargs = copy.copy(cmdargs) or [] + + if ( + mozinfo.isWin + and ( + isinstance(self.app_ctx, FirefoxContext) + or isinstance(self.app_ctx, DefaultContext) + ) + and "--wait-for-browser" not in self.cmdargs + ): + # The launcher process is present in this configuration. Always + # pass this flag so that we can wait for the browser to complete + # its execution. + self.cmdargs.append("--wait-for-browser") + + # allows you to run an instance of Firefox separately from any other instances + self.env["MOZ_NO_REMOTE"] = "1" + + # Disable crash reporting dialogs that interfere with debugging + self.env["GNOME_DISABLE_CRASH_DIALOG"] = "1" + self.env["XRE_NO_WINDOWS_CRASH_DIALOG"] = "1" + + # set the library path if needed on linux + if sys.platform == "linux2" and self.binary.endswith("-bin"): + dirname = os.path.dirname(self.binary) + if os.environ.get("LD_LIBRARY_PATH", None): + self.env["LD_LIBRARY_PATH"] = "%s:%s" % ( + os.environ["LD_LIBRARY_PATH"], + dirname, + ) + else: + self.env["LD_LIBRARY_PATH"] = dirname + + @property + def command(self): + command = [self.binary, "-profile", self.profile.profile] + + _cmdargs = [i for i in self.cmdargs if i != "-foreground"] + if len(_cmdargs) != len(self.cmdargs): + # foreground should be last; see + # https://bugzilla.mozilla.org/show_bug.cgi?id=625614 + self.cmdargs = _cmdargs + self.cmdargs.append("-foreground") + if mozinfo.isMac and "-foreground" not in self.cmdargs: + # runner should specify '-foreground' on Mac; see + # https://bugzilla.mozilla.org/show_bug.cgi?id=916512 + self.cmdargs.append("-foreground") + + # Bug 775416 - Ensure that binary options are passed in first + command[1:1] = self.cmdargs + return command + + def start(self, *args, **kwargs): + # ensure the profile exists + if not self.profile.exists(): + self.profile.reset() + assert self.profile.exists(), ( + "%s : failure to reset profile" % self.__class__.__name__ + ) + + has_debugger = "debug_args" in kwargs and kwargs["debug_args"] + if has_debugger: + self.env["MOZ_CRASHREPORTER_DISABLE"] = "1" + else: + if not self.show_crash_reporter: + # hide the crash reporter window + self.env["MOZ_CRASHREPORTER_NO_REPORT"] = "1" + self.env["MOZ_CRASHREPORTER"] = "1" + + BaseRunner.start(self, *args, **kwargs) + + +class BlinkRuntimeRunner(BaseRunner): + """A base runner class for running apps like Google Chrome or Chromium.""" + + def __init__(self, binary, cmdargs=None, **runner_args): + super(BlinkRuntimeRunner, self).__init__(**runner_args) + self.binary = binary + self.cmdargs = cmdargs or [] + + data_dir, name = os.path.split(self.profile.profile) + profile_args = [ + "--user-data-dir={}".format(data_dir), + "--profile-directory={}".format(name), + "--no-first-run", + ] + self.cmdargs.extend(profile_args) + + @property + def command(self): + cmd = self.cmdargs[:] + if self.profile.addons: + cmd.append("--load-extension={}".format(",".join(self.profile.addons))) + return [self.binary] + cmd + + def check_for_crashes(self, *args, **kwargs): + raise NotImplementedError diff --git a/testing/mozbase/mozrunner/mozrunner/base/device.py b/testing/mozbase/mozrunner/mozrunner/base/device.py new file mode 100644 index 0000000000..bf3c5965ff --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/base/device.py @@ -0,0 +1,199 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import codecs +import datetime +import re +import signal +import sys +import tempfile +import time + +import mozfile +import six + +from ..devices import BaseEmulator +from .runner import BaseRunner + + +class DeviceRunner(BaseRunner): + """ + The base runner class used for running gecko on + remote devices (or emulators). + """ + + env = { + "MOZ_CRASHREPORTER": "1", + "MOZ_CRASHREPORTER_NO_REPORT": "1", + "MOZ_CRASHREPORTER_SHUTDOWN": "1", + "MOZ_HIDE_RESULTS_TABLE": "1", + "MOZ_IN_AUTOMATION": "1", + "MOZ_LOG": "signaling:3,mtransport:4,DataChannel:4,jsep:4", + "R_LOG_LEVEL": "6", + "R_LOG_DESTINATION": "stderr", + "R_LOG_VERBOSE": "1", + } + + def __init__(self, device_class, device_args=None, **kwargs): + process_log = tempfile.NamedTemporaryFile(suffix="pidlog") + # the env will be passed to the device, it is not a *real* env + self._device_env = dict(DeviceRunner.env) + self._device_env["MOZ_PROCESS_LOG"] = process_log.name + # be sure we do not pass env to the parent class ctor + env = kwargs.pop("env", None) + if env: + self._device_env.update(env) + + if six.PY2: + stdout = codecs.getwriter("utf-8")(sys.stdout) + else: + stdout = codecs.getwriter("utf-8")(sys.stdout.buffer) + process_args = { + "stream": stdout, + "processOutputLine": self.on_output, + "onFinish": self.on_finish, + "onTimeout": self.on_timeout, + } + process_args.update(kwargs.get("process_args") or {}) + + kwargs["process_args"] = process_args + BaseRunner.__init__(self, **kwargs) + + device_args = device_args or {} + self.device = device_class(**device_args) + + @property + def command(self): + # command built by mozdevice -- see start() below + return None + + def start(self, *args, **kwargs): + if isinstance(self.device, BaseEmulator) and not self.device.connected: + self.device.start() + self.device.connect() + self.device.setup_profile(self.profile) + + app = self.app_ctx.remote_process + self.device.run_as_package = app + args = ["-no-remote", "-profile", self.app_ctx.remote_profile] + args.extend(self.cmdargs) + env = self._device_env + url = None + if "geckoview" in app: + activity = "TestRunnerActivity" + self.app_ctx.device.launch_activity( + app, activity, e10s=True, moz_env=env, extra_args=args, url=url + ) + else: + self.app_ctx.device.launch_fennec( + app, moz_env=env, extra_args=args, url=url + ) + + timeout = 10 # seconds + end_time = datetime.datetime.now() + datetime.timedelta(seconds=timeout) + while not self.is_running() and datetime.datetime.now() < end_time: + time.sleep(0.5) + if not self.is_running(): + print( + "timed out waiting for '%s' process to start" + % self.app_ctx.remote_process + ) + + def stop(self, sig=None): + if not sig and self.is_running(): + self.app_ctx.stop_application() + + if self.is_running(): + timeout = 10 + + self.app_ctx.device.pkill(self.app_ctx.remote_process, sig=sig) + if self.wait(timeout) is None and sig is not None: + print( + "timed out waiting for '{}' process to exit, trying " + "without signal {}".format(self.app_ctx.remote_process, sig) + ) + + # need to call adb stop otherwise the system will attempt to + # restart the process + self.app_ctx.stop_application() + if self.wait(timeout) is None: + print( + "timed out waiting for '{}' process to exit".format( + self.app_ctx.remote_process + ) + ) + + @property + def returncode(self): + """The returncode of the remote process. + + A value of None indicates the process is still running. Otherwise 0 is + returned, because there is no known way yet to retrieve the real exit code. + """ + if self.app_ctx.device.process_exist(self.app_ctx.remote_process): + return None + + return 0 + + def wait(self, timeout=None): + """Wait for the remote process to exit. + + :param timeout: if not None, will return after timeout seconds. + + :returns: the process return code or None if timeout was reached + and the process is still running. + """ + end_time = None + if timeout is not None: + end_time = datetime.datetime.now() + datetime.timedelta(seconds=timeout) + + while self.is_running(): + if end_time is not None and datetime.datetime.now() > end_time: + break + time.sleep(0.5) + + return self.returncode + + def on_output(self, line): + match = re.findall(r"TEST-START \| ([^\s]*)", line) + if match: + self.last_test = match[-1] + + def on_timeout(self): + self.stop(sig=signal.SIGABRT) + msg = "DeviceRunner TEST-UNEXPECTED-FAIL | %s | application timed out after %s seconds" + if self.timeout: + timeout = self.timeout + else: + timeout = self.output_timeout + msg = "%s with no output" % msg + + print(msg % (self.last_test, timeout)) + self.check_for_crashes() + + def on_finish(self): + self.check_for_crashes() + + def check_for_crashes(self, dump_save_path=None, test_name=None, **kwargs): + test_name = test_name or self.last_test + dump_dir = self.device.pull_minidumps() + crashed = BaseRunner.check_for_crashes( + self, + dump_directory=dump_dir, + dump_save_path=dump_save_path, + test_name=test_name, + **kwargs + ) + mozfile.remove(dump_dir) + return crashed + + def cleanup(self, *args, **kwargs): + BaseRunner.cleanup(self, *args, **kwargs) + self.device.cleanup() + + +class FennecRunner(DeviceRunner): + def __init__(self, cmdargs=None, **kwargs): + super(FennecRunner, self).__init__(**kwargs) + self.cmdargs = cmdargs or [] diff --git a/testing/mozbase/mozrunner/mozrunner/base/runner.py b/testing/mozbase/mozrunner/mozrunner/base/runner.py new file mode 100644 index 0000000000..e90813f918 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/base/runner.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +import os +import subprocess +import sys +import traceback +from abc import ABCMeta, abstractproperty + +import six +from mozlog import get_default_logger +from mozprocess import ProcessHandler +from six import ensure_str, string_types + +try: + import mozcrash +except ImportError: + mozcrash = None +from six import reraise + +from ..application import DefaultContext +from ..errors import RunnerNotStartedError + + +@six.add_metaclass(ABCMeta) +class BaseRunner(object): + """ + The base runner class for all mozrunner objects, both local and remote. + """ + + last_test = "mozrunner-startup" + process_handler = None + timeout = None + output_timeout = None + + def __init__( + self, + app_ctx=None, + profile=None, + clean_profile=True, + env=None, + process_class=None, + process_args=None, + symbols_path=None, + dump_save_path=None, + addons=None, + explicit_cleanup=False, + ): + self.app_ctx = app_ctx or DefaultContext() + + if isinstance(profile, string_types): + self.profile = self.app_ctx.profile_class(profile=profile, addons=addons) + else: + self.profile = profile or self.app_ctx.profile_class( + **getattr(self.app_ctx, "profile_args", {}) + ) + + self.logger = get_default_logger() + + # process environment + if env is None: + self.env = os.environ.copy() + else: + self.env = env.copy() + + self.clean_profile = clean_profile + self.process_class = process_class or ProcessHandler + self.process_args = process_args or {} + self.symbols_path = symbols_path + self.dump_save_path = dump_save_path + + self.crashed = 0 + self.explicit_cleanup = explicit_cleanup + + def __del__(self): + if not self.explicit_cleanup: + # If we're relying on the gc for cleanup do the same with the profile + self.cleanup(keep_profile=True) + + @abstractproperty + def command(self): + """Returns the command list to run.""" + pass + + @property + def returncode(self): + """ + The returncode of the process_handler. A value of None + indicates the process is still running. A negative + value indicates the process was killed with the + specified signal. + + :raises: RunnerNotStartedError + """ + if self.process_handler: + return self.process_handler.poll() + else: + raise RunnerNotStartedError("returncode accessed before runner started") + + def start( + self, debug_args=None, interactive=False, timeout=None, outputTimeout=None + ): + """ + Run self.command in the proper environment. + + :param debug_args: arguments for a debugger + :param interactive: uses subprocess.Popen directly + :param timeout: see process_handler.run() + :param outputTimeout: see process_handler.run() + :returns: the process id + + :raises: RunnerNotStartedError + """ + self.timeout = timeout + self.output_timeout = outputTimeout + cmd = self.command + + # ensure the runner is stopped + self.stop() + + # attach a debugger, if specified + if debug_args: + cmd = list(debug_args) + cmd + + if self.logger: + self.logger.info("Application command: %s" % " ".join(cmd)) + + str_env = {} + for k in self.env: + v = self.env[k] + str_env[ensure_str(k)] = ensure_str(v) + + if interactive: + self.process_handler = subprocess.Popen(cmd, env=str_env) + # TODO: other arguments + else: + # this run uses the managed processhandler + try: + process = self.process_class(cmd, env=str_env, **self.process_args) + process.run(self.timeout, self.output_timeout) + + self.process_handler = process + except Exception as e: + reraise( + RunnerNotStartedError, + RunnerNotStartedError("Failed to start the process: {}".format(e)), + sys.exc_info()[2], + ) + + self.crashed = 0 + return self.process_handler.pid + + def wait(self, timeout=None): + """ + Wait for the process to exit. + + :param timeout: if not None, will return after timeout seconds. + Timeout is ignored if interactive was set to True. + :returns: the process return code if process exited normally, + -<signal> if process was killed (Unix only), + None if timeout was reached and the process is still running. + :raises: RunnerNotStartedError + """ + if self.is_running(): + # The interactive mode uses directly a Popen process instance. It's + # wait() method doesn't have any parameters. So handle it separately. + if isinstance(self.process_handler, subprocess.Popen): + self.process_handler.wait() + else: + self.process_handler.wait(timeout) + + elif not self.process_handler: + raise RunnerNotStartedError("Wait() called before process started") + + return self.returncode + + def is_running(self): + """ + Checks if the process is running. + + :returns: True if the process is active + """ + return self.returncode is None + + def stop(self, sig=None, timeout=None): + """ + Kill the process. + + :param sig: Signal used to kill the process, defaults to SIGKILL + (has no effect on Windows). + :param timeout: Maximum time to wait for the processs to exit + (has no effect on Windows). + :returns: the process return code if process was already stopped, + -<signal> if process was killed (Unix only) + :raises: RunnerNotStartedError + """ + try: + if not self.is_running(): + return self.returncode + except RunnerNotStartedError: + return + + # The interactive mode uses directly a Popen process instance. It's + # kill() method doesn't have any parameters. So handle it separately. + if isinstance(self.process_handler, subprocess.Popen): + self.process_handler.kill() + else: + self.process_handler.kill(sig=sig, timeout=timeout) + + return self.returncode + + def reset(self): + """ + Reset the runner to its default state. + """ + self.stop() + self.process_handler = None + + def check_for_crashes( + self, dump_directory=None, dump_save_path=None, test_name=None, quiet=False + ): + """Check for possible crashes and output the stack traces. + + :param dump_directory: Directory to search for minidump files + :param dump_save_path: Directory to save the minidump files to + :param test_name: Name to use in the crash output + :param quiet: If `True` don't print the PROCESS-CRASH message to stdout + + :returns: Number of crashes which have been detected since the last invocation + """ + crash_count = 0 + + if not dump_directory: + dump_directory = os.path.join(self.profile.profile, "minidumps") + + if not dump_save_path: + dump_save_path = self.dump_save_path + + if not test_name: + test_name = "runner.py" + + try: + if self.logger: + if mozcrash: + crash_count = mozcrash.log_crashes( + self.logger, + dump_directory, + self.symbols_path, + dump_save_path=dump_save_path, + test=test_name, + ) + else: + self.logger.warning("Can not log crashes without mozcrash") + else: + if mozcrash: + crash_count = mozcrash.check_for_crashes( + dump_directory, + self.symbols_path, + dump_save_path=dump_save_path, + test_name=test_name, + quiet=quiet, + ) + + self.crashed += crash_count + except Exception: + traceback.print_exc() + + return crash_count + + def cleanup(self, keep_profile=False): + """ + Cleanup all runner state + """ + self.stop() + if not keep_profile: + self.profile.cleanup() diff --git a/testing/mozbase/mozrunner/mozrunner/cli.py b/testing/mozbase/mozrunner/mozrunner/cli.py new file mode 100644 index 0000000000..941734de5e --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/cli.py @@ -0,0 +1,181 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +import os +import sys + +from mozprofile import MozProfileCLI + +from .application import get_app_context +from .runners import runners +from .utils import findInPath + +# Map of debugging programs to information about them +# from http://mxr.mozilla.org/mozilla-central/source/build/automationutils.py#59 +DEBUGGERS = { + "gdb": { + "interactive": True, + "args": ["-q", "--args"], + }, + "valgrind": {"interactive": False, "args": ["--leak-check=full"]}, +} + + +def debugger_arguments(debugger, arguments=None, interactive=None): + """Finds debugger arguments from debugger given and defaults + + :param debugger: name or path to debugger + :param arguments: arguments for the debugger, or None to use defaults + :param interactive: whether the debugger should run in interactive mode + + """ + # find debugger executable if not a file + executable = debugger + if not os.path.exists(executable): + executable = findInPath(debugger) + if executable is None: + raise Exception("Path to '%s' not found" % debugger) + + # if debugger not in dictionary of knowns return defaults + dirname, debugger = os.path.split(debugger) + if debugger not in DEBUGGERS: + return ([executable] + (arguments or []), bool(interactive)) + + # otherwise use the dictionary values for arguments unless specified + if arguments is None: + arguments = DEBUGGERS[debugger].get("args", []) + if interactive is None: + interactive = DEBUGGERS[debugger].get("interactive", False) + return ([executable] + arguments, interactive) + + +class CLI(MozProfileCLI): + """Command line interface""" + + module = "mozrunner" + + def __init__(self, args=sys.argv[1:]): + MozProfileCLI.__init__(self, args=args) + + # choose appropriate runner and profile classes + app = self.options.app + try: + self.runner_class = runners[app] + self.profile_class = get_app_context(app).profile_class + except KeyError: + self.parser.error( + 'Application "%s" unknown (should be one of "%s")' + % (app, ", ".join(runners.keys())) + ) + + def add_options(self, parser): + """add options to the parser""" + parser.description = ( + "Reliable start/stop/configuration of Mozilla" + " Applications (Firefox, Thunderbird, etc.)" + ) + + # add profile options + MozProfileCLI.add_options(self, parser) + + # add runner options + parser.add_option( + "-b", + "--binary", + dest="binary", + help="Binary path.", + metavar=None, + default=None, + ) + parser.add_option( + "--app", + dest="app", + default="firefox", + help="Application to use [DEFAULT: %default]", + ) + parser.add_option( + "--app-arg", + dest="appArgs", + default=[], + action="append", + help="provides an argument to the test application", + ) + parser.add_option( + "--debugger", + dest="debugger", + help="run under a debugger, e.g. gdb or valgrind", + ) + parser.add_option( + "--debugger-args", + dest="debugger_args", + action="store", + help="arguments to the debugger", + ) + parser.add_option( + "--interactive", + dest="interactive", + action="store_true", + help="run the program interactively", + ) + + # methods for running + + def command_args(self): + """additional arguments for the mozilla application""" + # pylint --py3k: W1636 + return list(map(os.path.expanduser, self.options.appArgs)) + + def runner_args(self): + """arguments to instantiate the runner class""" + return dict(cmdargs=self.command_args(), binary=self.options.binary) + + def create_runner(self): + profile = self.profile_class(**self.profile_args()) + return self.runner_class(profile=profile, **self.runner_args()) + + def run(self): + runner = self.create_runner() + self.start(runner) + runner.cleanup() + + def debugger_arguments(self): + """Get the debugger arguments + + returns a 2-tuple of debugger arguments: + (debugger_arguments, interactive) + + """ + debug_args = self.options.debugger_args + if debug_args is not None: + debug_args = debug_args.split() + interactive = self.options.interactive + if self.options.debugger: + debug_args, interactive = debugger_arguments( + self.options.debugger, debug_args, interactive + ) + return debug_args, interactive + + def start(self, runner): + """Starts the runner and waits for the application to exit + + It can also happen via a keyboard interrupt. It should be + overwritten to provide custom running of the runner instance. + + """ + # attach a debugger if specified + debug_args, interactive = self.debugger_arguments() + runner.start(debug_args=debug_args, interactive=interactive) + print("Starting: " + " ".join(runner.command)) + try: + runner.wait() + except KeyboardInterrupt: + runner.stop() + + +def cli(args=sys.argv[1:]): + CLI(args).run() + + +if __name__ == "__main__": + cli() diff --git a/testing/mozbase/mozrunner/mozrunner/devices/__init__.py b/testing/mozbase/mozrunner/mozrunner/devices/__init__.py new file mode 100644 index 0000000000..7a4ec02e19 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/devices/__init__.py @@ -0,0 +1,17 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +from mozrunner.devices import emulator_battery, emulator_geo, emulator_screen + +from .base import Device +from .emulator import BaseEmulator, EmulatorAVD + +__all__ = [ + "BaseEmulator", + "EmulatorAVD", + "Device", + "emulator_battery", + "emulator_geo", + "emulator_screen", +] diff --git a/testing/mozbase/mozrunner/mozrunner/devices/android_device.py b/testing/mozbase/mozrunner/mozrunner/devices/android_device.py new file mode 100644 index 0000000000..6016425c8a --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/devices/android_device.py @@ -0,0 +1,1063 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import glob +import os +import platform +import posixpath +import re +import shutil +import signal +import subprocess +import sys +import telnetlib +import time +from distutils.spawn import find_executable +from enum import Enum + +import six +from mozdevice import ADBDeviceFactory, ADBHost +from six.moves import input, urllib + +MOZBUILD_PATH = os.environ.get( + "MOZBUILD_STATE_PATH", os.path.expanduser(os.path.join("~", ".mozbuild")) +) + +EMULATOR_HOME_DIR = os.path.join(MOZBUILD_PATH, "android-device") + +EMULATOR_AUTH_FILE = os.path.join( + os.path.expanduser("~"), ".emulator_console_auth_token" +) + +TOOLTOOL_PATH = "python/mozbuild/mozbuild/action/tooltool.py" + +TRY_URL = "https://hg.mozilla.org/try/raw-file/default" + +MANIFEST_PATH = "testing/config/tooltool-manifests" + +SHORT_TIMEOUT = 10 + +verbose_logging = False + +LLDB_SERVER_INSTALL_COMMANDS_SCRIPT = """ +umask 0002 + +mkdir -p {lldb_bin_dir} + +cp /data/local/tmp/lldb-server {lldb_bin_dir} +chmod +x {lldb_bin_dir}/lldb-server + +chmod 0775 {lldb_dir} +""".lstrip() + +LLDB_SERVER_START_COMMANDS_SCRIPT = """ +umask 0002 + +export LLDB_DEBUGSERVER_LOG_FILE={lldb_log_file} +export LLDB_SERVER_LOG_CHANNELS="{lldb_log_channels}" +export LLDB_DEBUGSERVER_DOMAINSOCKET_DIR={socket_dir} + +rm -rf {lldb_tmp_dir} +mkdir {lldb_tmp_dir} +export TMPDIR={lldb_tmp_dir} + +rm -rf {lldb_log_dir} +mkdir {lldb_log_dir} + +touch {lldb_log_file} +touch {platform_log_file} + +cd {lldb_tmp_dir} +{lldb_bin_dir}/lldb-server platform --server --listen {listener_scheme}://{socket_file} \\ + --log-file "{platform_log_file}" --log-channels "{lldb_log_channels}" \\ + < /dev/null > {platform_stdout_log_file} 2>&1 & +""".lstrip() + + +class InstallIntent(Enum): + YES = 1 + NO = 2 + + +class AvdInfo(object): + """ + Simple class to contain an AVD description. + """ + + def __init__(self, description, name, extra_args, x86): + self.description = description + self.name = name + self.extra_args = extra_args + self.x86 = x86 + + +""" + A dictionary to map an AVD type to a description of that type of AVD. + + There is one entry for each type of AVD used in Mozilla automated tests + and the parameters for each reflect those used in mozharness. +""" +AVD_DICT = { + "arm": AvdInfo( + "Android arm", + "mozemulator-armeabi-v7a", + [ + "-skip-adb-auth", + "-verbose", + "-show-kernel", + "-ranchu", + "-selinux", + "permissive", + "-memory", + "3072", + "-cores", + "4", + "-skin", + "800x1280", + "-gpu", + "on", + "-no-snapstorage", + "-no-snapshot", + "-prop", + "ro.test_harness=true", + ], + False, + ), + "arm64": AvdInfo( + "Android arm64", + "mozemulator-arm64", + [ + "-skip-adb-auth", + "-verbose", + "-show-kernel", + "-ranchu", + "-selinux", + "permissive", + "-memory", + "3072", + "-cores", + "4", + "-skin", + "800x1280", + "-gpu", + "on", + "-no-snapstorage", + "-no-snapshot", + "-prop", + "ro.test_harness=true", + ], + False, + ), + "x86_64": AvdInfo( + "Android x86_64", + "mozemulator-x86_64", + [ + "-skip-adb-auth", + "-verbose", + "-show-kernel", + "-ranchu", + "-selinux", + "permissive", + "-memory", + "3072", + "-cores", + "4", + "-skin", + "800x1280", + "-prop", + "ro.test_harness=true", + "-no-snapstorage", + "-no-snapshot", + ], + True, + ), +} + + +def _get_device(substs, device_serial=None): + + adb_path = _find_sdk_exe(substs, "adb", False) + if not adb_path: + adb_path = "adb" + device = ADBDeviceFactory( + adb=adb_path, verbose=verbose_logging, device=device_serial + ) + return device + + +def _install_host_utils(build_obj): + _log_info("Installing host utilities...") + installed = False + host_platform = _get_host_platform() + if host_platform: + path = os.path.join(build_obj.topsrcdir, MANIFEST_PATH) + path = os.path.join(path, host_platform, "hostutils.manifest") + _get_tooltool_manifest( + build_obj.substs, path, EMULATOR_HOME_DIR, "releng.manifest" + ) + _tooltool_fetch(build_obj.substs) + xre_path = glob.glob(os.path.join(EMULATOR_HOME_DIR, "host-utils*")) + for path in xre_path: + if os.path.isdir(path) and os.path.isfile( + os.path.join(path, _get_xpcshell_name()) + ): + os.environ["MOZ_HOST_BIN"] = path + installed = True + elif os.path.isfile(path): + os.remove(path) + if not installed: + _log_warning("Unable to install host utilities.") + else: + _log_warning( + "Unable to install host utilities -- your platform is not supported!" + ) + + +def _get_xpcshell_name(): + """ + Returns the xpcshell binary's name as a string (dependent on operating system). + """ + xpcshell_binary = "xpcshell" + if os.name == "nt": + xpcshell_binary = "xpcshell.exe" + return xpcshell_binary + + +def _maybe_update_host_utils(build_obj): + """ + Compare the installed host-utils to the version name in the manifest; + if the installed version is older, offer to update. + """ + + # Determine existing/installed version + existing_path = None + xre_paths = glob.glob(os.path.join(EMULATOR_HOME_DIR, "host-utils*")) + for path in xre_paths: + if os.path.isdir(path) and os.path.isfile( + os.path.join(path, _get_xpcshell_name()) + ): + existing_path = path + break + if existing_path is None: + # if not installed, no need to upgrade (new version will be installed) + return + existing_version = os.path.basename(existing_path) + + # Determine manifest version + manifest_version = None + host_platform = _get_host_platform() + if host_platform: + # Extract tooltool file name from manifest, something like: + # "filename": "host-utils-58.0a1.en-US-linux-x86_64.tar.gz", + path = os.path.join(build_obj.topsrcdir, MANIFEST_PATH) + manifest_path = os.path.join(path, host_platform, "hostutils.manifest") + with open(manifest_path, "r") as f: + for line in f.readlines(): + m = re.search('.*"(host-utils-.*)"', line) + if m: + manifest_version = m.group(1) + break + + # Compare, prompt, update + if existing_version and manifest_version: + hu_version_regex = "host-utils-([\d\.]*)" + manifest_version = float(re.search(hu_version_regex, manifest_version).group(1)) + existing_version = float(re.search(hu_version_regex, existing_version).group(1)) + if existing_version < manifest_version: + _log_info("Your host utilities are out of date!") + _log_info( + "You have %s installed, but %s is available" + % (existing_version, manifest_version) + ) + response = input("Update host utilities? (Y/n) ").strip() + if response.lower().startswith("y") or response == "": + parts = os.path.split(existing_path) + backup_dir = "_backup-" + parts[1] + backup_path = os.path.join(parts[0], backup_dir) + shutil.move(existing_path, backup_path) + _install_host_utils(build_obj) + + +def verify_android_device( + build_obj, + install=InstallIntent.NO, + xre=False, + debugger=False, + network=False, + verbose=False, + app=None, + device_serial=None, + aab=False, +): + """ + Determine if any Android device is connected via adb. + If no device is found, prompt to start an emulator. + If a device is found or an emulator started and 'install' is + specified, also check whether Firefox is installed on the + device; if not, prompt to install Firefox. + If 'xre' is specified, also check with MOZ_HOST_BIN is set + to a valid xre/host-utils directory; if not, prompt to set + one up. + If 'debugger' is specified, also check that lldb-server is installed; + if it is not found, set it up. + If 'network' is specified, also check that the device has basic + network connectivity. + Returns True if the emulator was started or another device was + already connected. + """ + if "MOZ_DISABLE_ADB_INSTALL" in os.environ: + install = InstallIntent.NO + _log_info( + "Found MOZ_DISABLE_ADB_INSTALL in environment, skipping android app" + "installation" + ) + device_verified = False + emulator = AndroidEmulator("*", substs=build_obj.substs, verbose=verbose) + adb_path = _find_sdk_exe(build_obj.substs, "adb", False) + if not adb_path: + adb_path = "adb" + adbhost = ADBHost(adb=adb_path, verbose=verbose, timeout=SHORT_TIMEOUT) + devices = adbhost.devices(timeout=SHORT_TIMEOUT) + if "device" in [d["state"] for d in devices]: + device_verified = True + elif emulator.is_available(): + response = input( + "No Android devices connected. Start an emulator? (Y/n) " + ).strip() + if response.lower().startswith("y") or response == "": + if not emulator.check_avd(): + _log_info("Android AVD not found, please run |mach bootstrap|") + return + _log_info( + "Starting emulator running %s..." % emulator.get_avd_description() + ) + emulator.start() + emulator.wait_for_start() + device_verified = True + + if device_verified and "DEVICE_SERIAL" not in os.environ: + devices = adbhost.devices(timeout=SHORT_TIMEOUT) + for d in devices: + if d["state"] == "device": + os.environ["DEVICE_SERIAL"] = d["device_serial"] + break + + if device_verified and install != InstallIntent.NO: + # Determine if test app is installed on the device; if not, + # prompt to install. This feature allows a test command to + # launch an emulator, install the test app, and proceed with testing + # in one operation. It is also a basic safeguard against other + # cases where testing is requested but test app installation has + # been forgotten. + # If a test app is installed, there is no way to determine whether + # the current build is installed, and certainly no way to + # determine if the installed build is the desired build. + # Installing every time (without prompting) is problematic because: + # - it prevents testing against other builds (downloaded apk) + # - installation may take a couple of minutes. + if not app: + app = "org.mozilla.geckoview.test_runner" + device = _get_device(build_obj.substs, device_serial) + response = "" + installed = device.is_app_installed(app) + + if not installed: + _log_info("It looks like %s is not installed on this device." % app) + if "fennec" in app or "firefox" in app: + if installed: + device.uninstall_app(app) + _log_info("Installing Firefox...") + build_obj._run_make(directory=".", target="install", ensure_exit_code=False) + elif app == "org.mozilla.geckoview.test": + if installed: + device.uninstall_app(app) + _log_info("Installing geckoview AndroidTest...") + build_obj._mach_context.commands.dispatch( + "android", + build_obj._mach_context, + subcommand="install-geckoview-test", + args=[], + ) + elif app == "org.mozilla.geckoview.test_runner": + if installed: + device.uninstall_app(app) + _log_info("Installing geckoview test_runner...") + sub = ( + "install-geckoview-test_runner-aab" + if aab + else "install-geckoview-test_runner" + ) + build_obj._mach_context.commands.dispatch( + "android", build_obj._mach_context, subcommand=sub, args=[] + ) + elif app == "org.mozilla.geckoview_example": + if installed: + device.uninstall_app(app) + _log_info("Installing geckoview_example...") + sub = ( + "install-geckoview_example-aab" if aab else "install-geckoview_example" + ) + build_obj._mach_context.commands.dispatch( + "android", build_obj._mach_context, subcommand=sub, args=[] + ) + elif not installed: + response = input( + "It looks like %s is not installed on this device,\n" + "but I don't know how to install it.\n" + "Install it now, then hit Enter " % app + ) + + device.run_as_package = app + + if device_verified and xre: + # Check whether MOZ_HOST_BIN has been set to a valid xre; if not, + # prompt to install one. + xre_path = os.environ.get("MOZ_HOST_BIN") + err = None + if not xre_path: + err = ( + "environment variable MOZ_HOST_BIN is not set to a directory " + "containing host xpcshell" + ) + elif not os.path.isdir(xre_path): + err = "$MOZ_HOST_BIN does not specify a directory" + elif not os.path.isfile(os.path.join(xre_path, _get_xpcshell_name())): + err = "$MOZ_HOST_BIN/xpcshell does not exist" + if err: + _maybe_update_host_utils(build_obj) + xre_path = glob.glob(os.path.join(EMULATOR_HOME_DIR, "host-utils*")) + for path in xre_path: + if os.path.isdir(path) and os.path.isfile( + os.path.join(path, _get_xpcshell_name()) + ): + os.environ["MOZ_HOST_BIN"] = path + err = None + break + if err: + _log_info("Host utilities not found: %s" % err) + response = input("Download and setup your host utilities? (Y/n) ").strip() + if response.lower().startswith("y") or response == "": + _install_host_utils(build_obj) + + if device_verified and network: + # Optionally check the network: If on a device that does not look like + # an emulator, verify that the device IP address can be obtained + # and check that this host can ping the device. + serial = device_serial or os.environ.get("DEVICE_SERIAL") + if not serial or ("emulator" not in serial): + device = _get_device(build_obj.substs, serial) + device.run_as_package = app + try: + addr = device.get_ip_address() + if not addr: + _log_warning("unable to get Android device's IP address!") + _log_warning( + "tests may fail without network connectivity to the device!" + ) + else: + _log_info("Android device's IP address: %s" % addr) + response = subprocess.check_output(["ping", "-c", "1", addr]) + _log_debug(response) + except Exception as e: + _log_warning( + "unable to verify network connection to device: %s" % str(e) + ) + _log_warning( + "tests may fail without network connectivity to the device!" + ) + else: + _log_debug("network check skipped on emulator") + + if debugger: + _setup_or_run_lldb_server(app, build_obj.substs, device_serial, setup=True) + + return device_verified + + +def run_lldb_server(app, substs, device_serial): + return _setup_or_run_lldb_server(app, substs, device_serial, setup=False) + + +def _setup_or_run_lldb_server(app, substs, device_serial, setup=True): + device = _get_device(substs, device_serial) + + # Don't use enable_run_as here, as this will not give you what you + # want if we have root access on the device. + pkg_dir = device.shell_output("run-as %s pwd" % app) + if not pkg_dir or pkg_dir == "/": + pkg_dir = "/data/data/%s" % app + _log_warning( + "Unable to resolve data directory for package %s, falling back to hardcoded path" + % app + ) + + pkg_lldb_dir = posixpath.join(pkg_dir, "lldb") + pkg_lldb_bin_dir = posixpath.join(pkg_lldb_dir, "bin") + pkg_lldb_server = posixpath.join(pkg_lldb_bin_dir, "lldb-server") + + if setup: + # Check whether lldb-server is already there + if device.shell_bool("test -x %s" % pkg_lldb_server, enable_run_as=True): + _log_info( + "Found lldb-server binary, terminating any running server processes..." + ) + # lldb-server is already present. Kill any running server. + device.shell("pkill -f lldb-server", enable_run_as=True) + else: + _log_info("lldb-server not found, installing...") + + # We need to do an install + try: + server_path_local = substs["ANDROID_LLDB_SERVER"] + except KeyError: + _log_info( + "ANDROID_LLDB_SERVER is not configured correctly; " + "please re-configure your build." + ) + return + + device.push(server_path_local, "/data/local/tmp") + + install_cmds = LLDB_SERVER_INSTALL_COMMANDS_SCRIPT.format( + lldb_bin_dir=pkg_lldb_bin_dir, lldb_dir=pkg_lldb_dir + ) + + install_cmds = [l for l in install_cmds.splitlines() if l] + + _log_debug( + "Running the following installation commands:\n%r" % (install_cmds,) + ) + + device.batch_execute(install_cmds, enable_run_as=True) + return + + pkg_lldb_sock_file = posixpath.join(pkg_dir, "platform-%d.sock" % int(time.time())) + + pkg_lldb_log_dir = posixpath.join(pkg_lldb_dir, "log") + pkg_lldb_tmp_dir = posixpath.join(pkg_lldb_dir, "tmp") + + pkg_lldb_log_file = posixpath.join(pkg_lldb_log_dir, "lldb-server.log") + pkg_platform_log_file = posixpath.join(pkg_lldb_log_dir, "platform.log") + pkg_platform_stdout_log_file = posixpath.join( + pkg_lldb_log_dir, "platform-stdout.log" + ) + + listener_scheme = "unix-abstract" + log_channels = "lldb process:gdb-remote packets" + + start_cmds = LLDB_SERVER_START_COMMANDS_SCRIPT.format( + lldb_bin_dir=pkg_lldb_bin_dir, + lldb_log_file=pkg_lldb_log_file, + lldb_log_channels=log_channels, + socket_dir=pkg_dir, + lldb_tmp_dir=pkg_lldb_tmp_dir, + lldb_log_dir=pkg_lldb_log_dir, + platform_log_file=pkg_platform_log_file, + listener_scheme=listener_scheme, + platform_stdout_log_file=pkg_platform_stdout_log_file, + socket_file=pkg_lldb_sock_file, + ) + + start_cmds = [l for l in start_cmds.splitlines() if l] + + _log_debug("Running the following start commands:\n%r" % (start_cmds,)) + + device.batch_execute(start_cmds, enable_run_as=True) + + return pkg_lldb_sock_file + + +def get_adb_path(build_obj): + return _find_sdk_exe(build_obj.substs, "adb", False) + + +def grant_runtime_permissions(build_obj, app, device_serial=None): + """ + Grant required runtime permissions to the specified app + (eg. org.mozilla.geckoview.test_runner). + """ + device = _get_device(build_obj.substs, device_serial) + device.run_as_package = app + device.grant_runtime_permissions(app) + + +class AndroidEmulator(object): + """ + Support running the Android emulator with an AVD from Mozilla + test automation. + + Example usage: + emulator = AndroidEmulator() + if not emulator.is_running() and emulator.is_available(): + if not emulator.check_avd(): + print("Android Emulator AVD not found, please run |mach bootstrap|") + emulator.start() + emulator.wait_for_start() + emulator.wait() + """ + + def __init__(self, avd_type=None, verbose=False, substs=None, device_serial=None): + global verbose_logging + self.emulator_log = None + self.emulator_path = "emulator" + verbose_logging = verbose + self.substs = substs + self.avd_type = self._get_avd_type(avd_type) + self.avd_info = AVD_DICT[self.avd_type] + self.gpu = True + self.restarted = False + self.device_serial = device_serial + self.avd_path = os.path.join( + EMULATOR_HOME_DIR, "avd", "%s.avd" % self.avd_info.name + ) + _log_debug("Running on %s" % platform.platform()) + _log_debug("Emulator created with type %s" % self.avd_type) + + def __del__(self): + if self.emulator_log: + self.emulator_log.close() + + def is_running(self): + """ + Returns True if the Android emulator is running. + """ + adb_path = _find_sdk_exe(self.substs, "adb", False) + if not adb_path: + adb_path = "adb" + adbhost = ADBHost(adb=adb_path, verbose=verbose_logging, timeout=SHORT_TIMEOUT) + devs = adbhost.devices(timeout=SHORT_TIMEOUT) + devs = [(d["device_serial"], d["state"]) for d in devs] + _log_debug(devs) + if ("emulator-5554", "device") in devs: + return True + return False + + def is_available(self): + """ + Returns True if an emulator executable is found. + """ + found = False + emulator_path = _find_sdk_exe(self.substs, "emulator", True) + if emulator_path: + self.emulator_path = emulator_path + found = True + return found + + def check_avd(self): + """ + Determine if the AVD is already installed locally. + + Returns True if the AVD is installed. + """ + if os.path.exists(self.avd_path): + _log_debug("AVD found at %s" % self.avd_path) + return True + _log_warning("Could not find AVD at %s" % self.avd_path) + return False + + def start(self, gpu_arg=None): + """ + Launch the emulator. + """ + if self.avd_info.x86 and "linux" in _get_host_platform(): + _verify_kvm(self.substs) + if os.path.exists(EMULATOR_AUTH_FILE): + os.remove(EMULATOR_AUTH_FILE) + _log_debug("deleted %s" % EMULATOR_AUTH_FILE) + self._update_avd_paths() + # create an empty auth file to disable emulator authentication + auth_file = open(EMULATOR_AUTH_FILE, "w") + auth_file.close() + + env = os.environ + env["ANDROID_EMULATOR_HOME"] = EMULATOR_HOME_DIR + env["ANDROID_AVD_HOME"] = os.path.join(EMULATOR_HOME_DIR, "avd") + command = [self.emulator_path, "-avd", self.avd_info.name] + override = os.environ.get("MOZ_EMULATOR_COMMAND_ARGS") + if override: + command += override.split() + _log_debug("Found MOZ_EMULATOR_COMMAND_ARGS in env: %s" % override) + else: + if gpu_arg: + command += ["-gpu", gpu_arg] + # Clear self.gpu to avoid our restart-without-gpu feature: if a specific + # gpu setting is requested, try to use that, and nothing else. + self.gpu = False + elif self.gpu: + command += ["-gpu", "on"] + if self.avd_info.extra_args: + # -enable-kvm option is not valid on OSX and Windows + if ( + _get_host_platform() in ("macosx64", "win32") + and "-enable-kvm" in self.avd_info.extra_args + ): + self.avd_info.extra_args.remove("-enable-kvm") + command += self.avd_info.extra_args + log_path = os.path.join(EMULATOR_HOME_DIR, "emulator.log") + self.emulator_log = open(log_path, "w+") + _log_debug("Starting the emulator with this command: %s" % " ".join(command)) + _log_debug("Emulator output will be written to '%s'" % log_path) + self.proc = subprocess.Popen( + command, + env=env, + stdin=subprocess.PIPE, + stdout=self.emulator_log, + stderr=self.emulator_log, + ) + _log_debug("Emulator started with pid %d" % int(self.proc.pid)) + + def wait_for_start(self): + """ + Verify that the emulator is running, the emulator device is visible + to adb, and Android has booted. + """ + if not self.proc: + _log_warning("Emulator not started!") + return False + if self.check_completed(): + return False + _log_debug("Waiting for device status...") + adb_path = _find_sdk_exe(self.substs, "adb", False) + if not adb_path: + adb_path = "adb" + adbhost = ADBHost(adb=adb_path, verbose=verbose_logging, timeout=SHORT_TIMEOUT) + devs = adbhost.devices(timeout=SHORT_TIMEOUT) + devs = [(d["device_serial"], d["state"]) for d in devs] + while ("emulator-5554", "device") not in devs: + time.sleep(10) + if self.check_completed(): + return False + devs = adbhost.devices(timeout=SHORT_TIMEOUT) + devs = [(d["device_serial"], d["state"]) for d in devs] + _log_debug("Device status verified.") + + _log_debug("Checking that Android has booted...") + device = _get_device(self.substs, self.device_serial) + complete = False + while not complete: + output = "" + try: + output = device.get_prop("sys.boot_completed", timeout=5) + except Exception: + # adb not yet responding...keep trying + pass + if output.strip() == "1": + complete = True + else: + time.sleep(10) + if self.check_completed(): + return False + _log_debug("Android boot status verified.") + + if not self._verify_emulator(): + return False + if self.avd_info.x86: + _log_info( + "Running the x86/x86_64 emulator; be sure to install an x86 or x86_64 APK!" + ) + else: + _log_info("Running the arm emulator; be sure to install an arm APK!") + return True + + def check_completed(self): + if self.proc.poll() is not None: + if self.gpu: + try: + for line in self.emulator_log.readlines(): + if ( + "Invalid value for -gpu" in line + or "Invalid GPU mode" in line + ): + self.gpu = False + break + except Exception as e: + _log_warning(str(e)) + + if not self.gpu and not self.restarted: + _log_warning( + "Emulator failed to start. Your emulator may be out of date." + ) + _log_warning("Trying to restart the emulator without -gpu argument.") + self.restarted = True + self.start() + return False + _log_warning("Emulator has already completed!") + log_path = os.path.join(EMULATOR_HOME_DIR, "emulator.log") + _log_warning( + "See log at %s and/or use --verbose for more information." % log_path + ) + return True + return False + + def wait(self): + """ + Wait for the emulator to close. If interrupted, close the emulator. + """ + try: + self.proc.wait() + except Exception: + if self.proc.poll() is None: + self.cleanup() + return self.proc.poll() + + def cleanup(self): + """ + Close the emulator. + """ + self.proc.kill(signal.SIGTERM) + + def get_avd_description(self): + """ + Return the human-friendly description of this AVD. + """ + return self.avd_info.description + + def _update_avd_paths(self): + ini_path = os.path.join(EMULATOR_HOME_DIR, "avd", "%s.ini" % self.avd_info.name) + with open(ini_path, "r") as f: + lines = f.readlines() + with open(ini_path, "w") as f: + for line in lines: + if line.startswith("path="): + f.write("path=%s\n" % self.avd_path) + elif line.startswith("path.rel="): + f.write("path.rel=avd/%s.avd\n" % self.avd_info.name) + else: + f.write(line) + + def _telnet_read_until(self, telnet, expected, timeout): + if six.PY3 and isinstance(expected, six.text_type): + expected = expected.encode("ascii") + return telnet.read_until(expected, timeout) + + def _telnet_write(self, telnet, command): + if six.PY3 and isinstance(command, six.text_type): + command = command.encode("ascii") + telnet.write(command) + + def _telnet_cmd(self, telnet, command): + _log_debug(">>> %s" % command) + self._telnet_write(telnet, "%s\n" % command) + result = self._telnet_read_until(telnet, "OK", 10) + _log_debug("<<< %s" % result) + return result + + def _verify_emulator(self): + telnet_ok = False + tn = None + while not telnet_ok: + try: + tn = telnetlib.Telnet("localhost", 5554, 10) + if tn is not None: + self._telnet_read_until(tn, "OK", 10) + self._telnet_cmd(tn, "avd status") + self._telnet_cmd(tn, "redir list") + self._telnet_cmd(tn, "network status") + self._telnet_write(tn, "quit\n") + tn.read_all() + telnet_ok = True + else: + _log_warning("Unable to connect to port 5554") + except Exception: + _log_warning("Trying again after unexpected exception") + finally: + if tn is not None: + tn.close() + if not telnet_ok: + time.sleep(10) + if self.proc.poll() is not None: + _log_warning("Emulator has already completed!") + return False + return telnet_ok + + def _get_avd_type(self, requested): + if requested in AVD_DICT.keys(): + return requested + if self.substs: + target_cpu = self.substs["TARGET_CPU"] + if target_cpu == "aarch64": + return "arm64" + elif target_cpu.startswith("arm"): + return "arm" + return "x86_64" + + +def _find_sdk_exe(substs, exe, tools): + if tools: + subdirs = ["emulator", "tools"] + else: + subdirs = ["platform-tools"] + + found = False + if not found and substs: + # It's best to use the tool specified by the build, rather + # than something we find on the PATH or crawl for. + try: + exe_path = substs[exe.upper()] + if os.path.exists(exe_path): + found = True + else: + _log_debug("Unable to find executable at %s" % exe_path) + except KeyError: + _log_debug("%s not set" % exe.upper()) + + # Append '.exe' to the name on Windows if it's not present, + # so that the executable can be found. + if os.name == "nt" and not exe.lower().endswith(".exe"): + exe += ".exe" + + if not found: + # Can exe be found in the Android SDK? + try: + android_sdk_root = os.environ["ANDROID_SDK_ROOT"] + for subdir in subdirs: + exe_path = os.path.join(android_sdk_root, subdir, exe) + if os.path.exists(exe_path): + found = True + break + else: + _log_debug("Unable to find executable at %s" % exe_path) + except KeyError: + _log_debug("ANDROID_SDK_ROOT not set") + + if not found: + # Can exe be found in the default bootstrap location? + for subdir in subdirs: + exe_path = os.path.join(MOZBUILD_PATH, "android-sdk-linux", subdir, exe) + if os.path.exists(exe_path): + found = True + break + else: + _log_debug("Unable to find executable at %s" % exe_path) + + if not found: + # Is exe on PATH? + exe_path = find_executable(exe) + if exe_path: + found = True + else: + _log_debug("Unable to find executable on PATH") + + if found: + _log_debug("%s found at %s" % (exe, exe_path)) + try: + creation_time = os.path.getctime(exe_path) + _log_debug(" ...with creation time %s" % time.ctime(creation_time)) + except Exception: + _log_warning("Could not get creation time for %s" % exe_path) + + prop_path = os.path.join(os.path.dirname(exe_path), "source.properties") + if os.path.exists(prop_path): + with open(prop_path, "r") as f: + for line in f.readlines(): + if line.startswith("Pkg.Revision"): + line = line.strip() + _log_debug( + " ...with SDK version in %s: %s" % (prop_path, line) + ) + break + else: + exe_path = None + return exe_path + + +def _log_debug(text): + if verbose_logging: + print("DEBUG: %s" % text) + + +def _log_warning(text): + print("WARNING: %s" % text) + + +def _log_info(text): + print("%s" % text) + + +def _download_file(url, filename, path): + _log_debug("Download %s to %s/%s..." % (url, path, filename)) + f = urllib.request.urlopen(url) + if not os.path.isdir(path): + try: + os.makedirs(path) + except Exception as e: + _log_warning(str(e)) + return False + local_file = open(os.path.join(path, filename), "wb") + local_file.write(f.read()) + local_file.close() + _log_debug("Downloaded %s to %s/%s" % (url, path, filename)) + return True + + +def _get_tooltool_manifest(substs, src_path, dst_path, filename): + if not os.path.isdir(dst_path): + try: + os.makedirs(dst_path) + except Exception as e: + _log_warning(str(e)) + copied = False + if substs and "top_srcdir" in substs: + src = os.path.join(substs["top_srcdir"], src_path) + if os.path.exists(src): + dst = os.path.join(dst_path, filename) + shutil.copy(src, dst) + copied = True + _log_debug("Copied tooltool manifest %s to %s" % (src, dst)) + if not copied: + url = os.path.join(TRY_URL, src_path) + _download_file(url, filename, dst_path) + + +def _tooltool_fetch(substs): + tooltool_full_path = os.path.join(substs["top_srcdir"], TOOLTOOL_PATH) + command = [ + sys.executable, + tooltool_full_path, + "fetch", + "-o", + "-m", + "releng.manifest", + ] + try: + response = subprocess.check_output(command, cwd=EMULATOR_HOME_DIR) + _log_debug(response) + except Exception as e: + _log_warning(str(e)) + + +def _get_host_platform(): + plat = None + if "darwin" in str(sys.platform).lower(): + plat = "macosx64" + elif "win32" in str(sys.platform).lower(): + plat = "win32" + elif "linux" in str(sys.platform).lower(): + if "64" in platform.architecture()[0]: + plat = "linux64" + else: + plat = "linux32" + return plat + + +def _verify_kvm(substs): + # 'emulator -accel-check' should produce output like: + # accel: + # 0 + # KVM (version 12) is installed and usable + # accel + emulator_path = _find_sdk_exe(substs, "emulator", True) + if not emulator_path: + emulator_path = "emulator" + command = [emulator_path, "-accel-check"] + try: + out = subprocess.check_output(command) + if six.PY3 and not isinstance(out, six.text_type): + out = out.decode("utf-8") + if "is installed and usable" in "".join(out): + return + except Exception as e: + _log_warning(str(e)) + _log_warning("Unable to verify kvm acceleration!") + _log_warning("The x86/x86_64 emulator may fail to start without kvm.") diff --git a/testing/mozbase/mozrunner/mozrunner/devices/base.py b/testing/mozbase/mozrunner/mozrunner/devices/base.py new file mode 100644 index 0000000000..d1fa660052 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/devices/base.py @@ -0,0 +1,256 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import datetime +import os +import posixpath +import shutil +import tempfile +import time + +from mozdevice import ADBError, ADBHost +from six.moves.configparser import ConfigParser, RawConfigParser + + +class Device(object): + connected = False + + def __init__(self, app_ctx, logdir=None, serial=None, restore=True): + self.app_ctx = app_ctx + self.device = self.app_ctx.device + self.restore = restore + self.serial = serial + self.logdir = os.path.abspath(os.path.expanduser(logdir)) + self.added_files = set() + self.backup_files = set() + + @property + def remote_profiles(self): + """ + A list of remote profiles on the device. + """ + remote_ini = self.app_ctx.remote_profiles_ini + if not self.device.is_file(remote_ini): + raise IOError("Remote file '%s' not found" % remote_ini) + + local_ini = tempfile.NamedTemporaryFile() + self.device.pull(remote_ini, local_ini.name) + cfg = ConfigParser() + cfg.read(local_ini.name) + + profiles = [] + for section in cfg.sections(): + if cfg.has_option(section, "Path"): + if cfg.has_option(section, "IsRelative") and cfg.getint( + section, "IsRelative" + ): + profiles.append( + posixpath.join( + posixpath.dirname(remote_ini), cfg.get(section, "Path") + ) + ) + else: + profiles.append(cfg.get(section, "Path")) + return profiles + + def pull_minidumps(self): + """ + Saves any minidumps found in the remote profile on the local filesystem. + + :returns: Path to directory containing the dumps. + """ + remote_dump_dir = posixpath.join(self.app_ctx.remote_profile, "minidumps") + local_dump_dir = tempfile.mkdtemp() + try: + self.device.pull(remote_dump_dir, local_dump_dir) + except ADBError as e: + # OK if directory not present -- sometimes called before browser start + if "does not exist" not in str(e): + try: + shutil.rmtree(local_dump_dir) + except Exception: + pass + finally: + raise e + else: + print("WARNING: {}".format(e)) + if os.listdir(local_dump_dir): + self.device.rm(remote_dump_dir, recursive=True) + self.device.mkdir(remote_dump_dir, parents=True) + return local_dump_dir + + def setup_profile(self, profile): + """ + Copy profile to the device and update the remote profiles.ini + to point to the new profile. + + :param profile: mozprofile object to copy over. + """ + if self.device.is_dir(self.app_ctx.remote_profile): + self.device.rm(self.app_ctx.remote_profile, recursive=True) + + self.device.push(profile.profile, self.app_ctx.remote_profile) + + timeout = 5 # seconds + starttime = datetime.datetime.now() + while datetime.datetime.now() - starttime < datetime.timedelta(seconds=timeout): + if self.device.is_file(self.app_ctx.remote_profiles_ini): + break + time.sleep(1) + local_profiles_ini = tempfile.NamedTemporaryFile() + if not self.device.is_file(self.app_ctx.remote_profiles_ini): + # Unless fennec is already running, and/or remote_profiles_ini is + # not inside the remote_profile (deleted above), this is entirely + # normal. + print("timed out waiting for profiles.ini") + else: + self.device.pull(self.app_ctx.remote_profiles_ini, local_profiles_ini.name) + + config = ProfileConfigParser() + config.read(local_profiles_ini.name) + for section in config.sections(): + if "Profile" in section: + config.set(section, "IsRelative", 0) + config.set(section, "Path", self.app_ctx.remote_profile) + + new_profiles_ini = tempfile.NamedTemporaryFile() + config.write(open(new_profiles_ini.name, "w")) + + self.backup_file(self.app_ctx.remote_profiles_ini) + self.device.push(new_profiles_ini.name, self.app_ctx.remote_profiles_ini) + + # Ideally all applications would read the profile the same way, but in practice + # this isn't true. Perform application specific profile-related setup if necessary. + if hasattr(self.app_ctx, "setup_profile"): + for remote_path in self.app_ctx.remote_backup_files: + self.backup_file(remote_path) + self.app_ctx.setup_profile(profile) + + def _get_online_devices(self): + adbhost = ADBHost(adb=self.app_ctx.adb) + devices = adbhost.devices() + return [ + d["device_serial"] + for d in devices + if d["state"] != "offline" + if not d["device_serial"].startswith("emulator") + ] + + def connect(self): + """ + Connects to a running device. If no serial was specified in the + constructor, defaults to the first entry in `adb devices`. + """ + if self.connected: + return + + online_devices = self._get_online_devices() + if not online_devices: + raise IOError( + "No devices connected. Ensure the device is on and " + "remote debugging via adb is enabled in the settings." + ) + self.serial = online_devices[0] + + self.connected = True + + def reboot(self): + """ + Reboots the device via adb. + """ + self.device.reboot() + + def wait_for_net(self): + active = False + time_out = 0 + while not active and time_out < 40: + if self.device.get_ip_address() is not None: + active = True + time_out += 1 + time.sleep(1) + return active + + def backup_file(self, remote_path): + if not self.restore: + return + + if self.device.exists(remote_path): + self.device.cp(remote_path, "%s.orig" % remote_path, recursive=True) + self.backup_files.add(remote_path) + else: + self.added_files.add(remote_path) + + def cleanup(self): + """ + Cleanup the device. + """ + if not self.restore: + return + + try: + self.device.remount() + # Restore the original profile + for added_file in self.added_files: + self.device.rm(added_file) + + for backup_file in self.backup_files: + if self.device.exists("%s.orig" % backup_file): + self.device.mv("%s.orig" % backup_file, backup_file) + + # Perform application specific profile cleanup if necessary + if hasattr(self.app_ctx, "cleanup_profile"): + self.app_ctx.cleanup_profile() + + # Remove the test profile + self.device.rm(self.app_ctx.remote_profile, force=True, recursive=True) + except Exception as e: + print("cleanup aborted: %s" % str(e)) + + def _rotate_log(self, srclog, index=1): + """ + Rotate a logfile, by recursively rotating logs further in the sequence, + deleting the last file if necessary. + """ + basename = os.path.basename(srclog) + basename = basename[: -len(".log")] + if index > 1: + basename = basename[: -len(".1")] + basename = "%s.%d.log" % (basename, index) + + destlog = os.path.join(self.logdir, basename) + if os.path.isfile(destlog): + if index == 3: + os.remove(destlog) + else: + self._rotate_log(destlog, index + 1) + shutil.move(srclog, destlog) + + +class ProfileConfigParser(RawConfigParser): + """ + Class to create profiles.ini config files + + Subclass of RawConfigParser that outputs .ini files in the exact + format expected for profiles.ini, which is slightly different + than the default format. + """ + + def optionxform(self, optionstr): + return optionstr + + def write(self, fp): + if self._defaults: + fp.write("[%s]\n" % ConfigParser.DEFAULTSECT) + for (key, value) in self._defaults.items(): + fp.write("%s=%s\n" % (key, str(value).replace("\n", "\n\t"))) + fp.write("\n") + for section in self._sections: + fp.write("[%s]\n" % section) + for (key, value) in self._sections[section].items(): + if key == "__name__": + continue + if (value is not None) or (self._optcre == self.OPTCRE): + key = "=".join((key, str(value).replace("\n", "\n\t"))) + fp.write("%s\n" % (key)) + fp.write("\n") diff --git a/testing/mozbase/mozrunner/mozrunner/devices/emulator.py b/testing/mozbase/mozrunner/mozrunner/devices/emulator.py new file mode 100644 index 0000000000..4a2aa81733 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/devices/emulator.py @@ -0,0 +1,224 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import datetime +import os +import shutil +import subprocess +import tempfile +import time +from telnetlib import Telnet + +from mozdevice import ADBHost +from mozprocess import ProcessHandler + +from ..errors import TimeoutException +from .base import Device +from .emulator_battery import EmulatorBattery +from .emulator_geo import EmulatorGeo +from .emulator_screen import EmulatorScreen + + +class ArchContext(object): + def __init__(self, arch, context, binary=None, avd=None, extra_args=None): + homedir = getattr(context, "homedir", "") + kernel = os.path.join(homedir, "prebuilts", "qemu-kernel", "%s", "%s") + sysdir = os.path.join(homedir, "out", "target", "product", "%s") + self.extra_args = [] + self.binary = os.path.join(context.bindir or "", "emulator") + if arch == "x86": + self.binary = os.path.join(context.bindir or "", "emulator-x86") + self.kernel = kernel % ("x86", "kernel-qemu") + self.sysdir = sysdir % "generic_x86" + elif avd: + self.avd = avd + self.extra_args = [ + "-show-kernel", + "-debug", + "init,console,gles,memcheck,adbserver,adbclient,adb,avd_config,socket", + ] + else: + self.kernel = kernel % ("arm", "kernel-qemu-armv7") + self.sysdir = sysdir % "generic" + self.extra_args = ["-cpu", "cortex-a8"] + + if binary: + self.binary = binary + + if extra_args: + self.extra_args.extend(extra_args) + + +class SDCard(object): + def __init__(self, emulator, size): + self.emulator = emulator + self.path = self.create_sdcard(size) + + def create_sdcard(self, sdcard_size): + """ + Creates an sdcard partition in the emulator. + + :param sdcard_size: Size of partition to create, e.g '10MB'. + """ + mksdcard = self.emulator.app_ctx.which("mksdcard") + path = tempfile.mktemp(prefix="sdcard", dir=self.emulator.tmpdir) + sdargs = [mksdcard, "-l", "mySdCard", sdcard_size, path] + sd = subprocess.Popen(sdargs, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) + retcode = sd.wait() + if retcode: + raise Exception( + "unable to create sdcard: exit code %d: %s" + % (retcode, sd.stdout.read()) + ) + return path + + +class BaseEmulator(Device): + port = None + proc = None + telnet = None + + def __init__(self, app_ctx, **kwargs): + self.arch = ArchContext( + kwargs.pop("arch", "arm"), + app_ctx, + binary=kwargs.pop("binary", None), + avd=kwargs.pop("avd", None), + ) + super(BaseEmulator, self).__init__(app_ctx, **kwargs) + self.tmpdir = tempfile.mkdtemp() + # These rely on telnet + self.battery = EmulatorBattery(self) + self.geo = EmulatorGeo(self) + self.screen = EmulatorScreen(self) + + @property + def args(self): + """ + Arguments to pass into the emulator binary. + """ + return [self.arch.binary] + + def start(self): + """ + Starts a new emulator. + """ + if self.proc: + return + + original_devices = set(self._get_online_devices()) + + # QEMU relies on atexit() to remove temporary files, which does not + # work since mozprocess uses SIGKILL to kill the emulator process. + # Use a customized temporary directory so we can clean it up. + os.environ["ANDROID_TMP"] = self.tmpdir + + qemu_log = None + qemu_proc_args = {} + if self.logdir: + # save output from qemu to logfile + qemu_log = os.path.join(self.logdir, "qemu.log") + if os.path.isfile(qemu_log): + self._rotate_log(qemu_log) + qemu_proc_args["logfile"] = qemu_log + else: + qemu_proc_args["processOutputLine"] = lambda line: None + self.proc = ProcessHandler(self.args, **qemu_proc_args) + self.proc.run() + + devices = set(self._get_online_devices()) + now = datetime.datetime.now() + while (devices - original_devices) == set([]): + time.sleep(1) + # Sometimes it takes more than 60s to launch emulator, so we + # increase timeout value to 180s. Please see bug 1143380. + if datetime.datetime.now() - now > datetime.timedelta(seconds=180): + raise TimeoutException("timed out waiting for emulator to start") + devices = set(self._get_online_devices()) + devices = devices - original_devices + self.serial = devices.pop() + self.connect() + + def _get_online_devices(self): + adbhost = ADBHost(adb=self.app_ctx.adb) + return [ + d["device_serial"] + for d in adbhost.devices() + if d["state"] != "offline" + if d["device_serial"].startswith("emulator") + ] + + def connect(self): + """ + Connects to a running device. If no serial was specified in the + constructor, defaults to the first entry in `adb devices`. + """ + if self.connected: + return + + super(BaseEmulator, self).connect() + self.port = int(self.serial[self.serial.rindex("-") + 1 :]) + + def cleanup(self): + """ + Cleans up and kills the emulator, if it was started by mozrunner. + """ + super(BaseEmulator, self).cleanup() + if self.proc: + self.proc.kill() + self.proc = None + self.connected = False + + # Remove temporary files + if os.path.isdir(self.tmpdir): + shutil.rmtree(self.tmpdir) + + def _get_telnet_response(self, command=None): + output = [] + assert self.telnet + if command is not None: + self.telnet.write("%s\n" % command) + while True: + line = self.telnet.read_until("\n") + output.append(line.rstrip()) + if line.startswith("OK"): + return output + elif line.startswith("KO:"): + raise Exception("bad telnet response: %s" % line) + + def _run_telnet(self, command): + if not self.telnet: + self.telnet = Telnet("localhost", self.port) + self._get_telnet_response() + return self._get_telnet_response(command) + + def __del__(self): + if self.telnet: + self.telnet.write("exit\n") + self.telnet.read_all() + + +class EmulatorAVD(BaseEmulator): + def __init__(self, app_ctx, binary, avd, port=5554, **kwargs): + super(EmulatorAVD, self).__init__(app_ctx, binary=binary, avd=avd, **kwargs) + self.port = port + + @property + def args(self): + """ + Arguments to pass into the emulator binary. + """ + qemu_args = super(EmulatorAVD, self).args + qemu_args.extend(["-avd", self.arch.avd, "-port", str(self.port)]) + qemu_args.extend(self.arch.extra_args) + return qemu_args + + def start(self): + if self.proc: + return + + env = os.environ + env["ANDROID_AVD_HOME"] = self.app_ctx.avd_home + + super(EmulatorAVD, self).start() diff --git a/testing/mozbase/mozrunner/mozrunner/devices/emulator_battery.py b/testing/mozbase/mozrunner/mozrunner/devices/emulator_battery.py new file mode 100644 index 0000000000..58d42b0a0e --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/devices/emulator_battery.py @@ -0,0 +1,53 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + + +class EmulatorBattery(object): + def __init__(self, emulator): + self.emulator = emulator + + def get_state(self): + status = {} + state = {} + + response = self.emulator._run_telnet("power display") + for line in response: + if ":" in line: + field, value = line.split(":") + value = value.strip() + if value == "true": + value = True + elif value == "false": + value = False + elif field == "capacity": + value = float(value) + status[field] = value + + # pylint --py3k W1619 + state["level"] = status.get("capacity", 0.0) / 100 + if status.get("AC") == "online": + state["charging"] = True + else: + state["charging"] = False + + return state + + def get_charging(self): + return self.get_state()["charging"] + + def get_level(self): + return self.get_state()["level"] + + def set_level(self, level): + self.emulator._run_telnet("power capacity %d" % (level * 100)) + + def set_charging(self, charging): + if charging: + cmd = "power ac on" + else: + cmd = "power ac off" + self.emulator._run_telnet(cmd) + + charging = property(get_charging, set_charging) + level = property(get_level, set_level) diff --git a/testing/mozbase/mozrunner/mozrunner/devices/emulator_geo.py b/testing/mozbase/mozrunner/mozrunner/devices/emulator_geo.py new file mode 100644 index 0000000000..a1fd6fc8b2 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/devices/emulator_geo.py @@ -0,0 +1,16 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + + +class EmulatorGeo(object): + def __init__(self, emulator): + self.emulator = emulator + + def set_default_location(self): + self.lon = -122.08769 + self.lat = 37.41857 + self.set_location(self.lon, self.lat) + + def set_location(self, lon, lat): + self.emulator._run_telnet("geo fix %0.5f %0.5f" % (self.lon, self.lat)) diff --git a/testing/mozbase/mozrunner/mozrunner/devices/emulator_screen.py b/testing/mozbase/mozrunner/mozrunner/devices/emulator_screen.py new file mode 100644 index 0000000000..8f261c3610 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/devices/emulator_screen.py @@ -0,0 +1,91 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + + +class EmulatorScreen(object): + """Class for screen related emulator commands.""" + + SO_PORTRAIT_PRIMARY = "portrait-primary" + SO_PORTRAIT_SECONDARY = "portrait-secondary" + SO_LANDSCAPE_PRIMARY = "landscape-primary" + SO_LANDSCAPE_SECONDARY = "landscape-secondary" + + def __init__(self, emulator): + self.emulator = emulator + + def initialize(self): + self.orientation = self.SO_PORTRAIT_PRIMARY + + def _get_raw_orientation(self): + """Get the raw value of the current device orientation.""" + response = self.emulator._run_telnet("sensor get orientation") + + return response[0].split("=")[1].strip() + + def _set_raw_orientation(self, data): + """Set the raw value of the specified device orientation.""" + self.emulator._run_telnet("sensor set orientation %s" % data) + + def get_orientation(self): + """Get the current device orientation. + + Returns; + orientation -- Orientation of the device. One of: + SO_PORTRAIT_PRIMARY - system buttons at the bottom + SO_PORTRIAT_SECONDARY - system buttons at the top + SO_LANDSCAPE_PRIMARY - system buttons at the right + SO_LANDSCAPE_SECONDARY - system buttons at the left + + """ + data = self._get_raw_orientation() + + if data == "0:-90:0": + orientation = self.SO_PORTRAIT_PRIMARY + elif data == "0:90:0": + orientation = self.SO_PORTRAIT_SECONDARY + elif data == "0:0:90": + orientation = self.SO_LANDSCAPE_PRIMARY + elif data == "0:0:-90": + orientation = self.SO_LANDSCAPE_SECONDARY + else: + raise ValueError("Unknown orientation sensor value: %s." % data) + + return orientation + + def set_orientation(self, orientation): + """Set the specified device orientation. + + Args + orientation -- Orientation of the device. One of: + SO_PORTRAIT_PRIMARY - system buttons at the bottom + SO_PORTRIAT_SECONDARY - system buttons at the top + SO_LANDSCAPE_PRIMARY - system buttons at the right + SO_LANDSCAPE_SECONDARY - system buttons at the left + """ + orientation = SCREEN_ORIENTATIONS[orientation] + + if orientation == self.SO_PORTRAIT_PRIMARY: + data = "0:-90:0" + elif orientation == self.SO_PORTRAIT_SECONDARY: + data = "0:90:0" + elif orientation == self.SO_LANDSCAPE_PRIMARY: + data = "0:0:90" + elif orientation == self.SO_LANDSCAPE_SECONDARY: + data = "0:0:-90" + else: + raise ValueError("Invalid orientation: %s" % orientation) + + self._set_raw_orientation(data) + + orientation = property(get_orientation, set_orientation) + + +SCREEN_ORIENTATIONS = { + "portrait": EmulatorScreen.SO_PORTRAIT_PRIMARY, + "landscape": EmulatorScreen.SO_LANDSCAPE_PRIMARY, + "portrait-primary": EmulatorScreen.SO_PORTRAIT_PRIMARY, + "landscape-primary": EmulatorScreen.SO_LANDSCAPE_PRIMARY, + "portrait-secondary": EmulatorScreen.SO_PORTRAIT_SECONDARY, + "landscape-secondary": EmulatorScreen.SO_LANDSCAPE_SECONDARY, +} diff --git a/testing/mozbase/mozrunner/mozrunner/errors.py b/testing/mozbase/mozrunner/mozrunner/errors.py new file mode 100644 index 0000000000..2c4ea50d5d --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/errors.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + + +class RunnerException(Exception): + """Base exception handler for mozrunner related errors""" + + +class RunnerNotStartedError(RunnerException): + """Exception handler in case the runner hasn't been started""" + + +class TimeoutException(RunnerException): + """Raised on timeout waiting for targets to start.""" diff --git a/testing/mozbase/mozrunner/mozrunner/runners.py b/testing/mozbase/mozrunner/mozrunner/runners.py new file mode 100644 index 0000000000..75fbf60733 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/runners.py @@ -0,0 +1,144 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + + +""" +This module contains a set of shortcut methods that create runners for commonly +used Mozilla applications, such as Firefox, Firefox for Android or Thunderbird. +""" + +from .application import get_app_context +from .base import BlinkRuntimeRunner, FennecRunner, GeckoRuntimeRunner +from .devices import EmulatorAVD + + +def Runner(*args, **kwargs): + """ + Create a generic GeckoRuntime runner. + + :param binary: Path to binary. + :param cmdargs: Arguments to pass into binary. + :param profile: Profile object to use. + :param env: Environment variables to pass into the gecko process. + :param clean_profile: If True, restores profile back to original state. + :param process_class: Class used to launch the binary. + :param process_args: Arguments to pass into process_class. + :param symbols_path: Path to symbol files used for crash analysis. + :param show_crash_reporter: allow the crash reporter window to pop up. + Defaults to False. + :returns: A generic GeckoRuntimeRunner. + """ + return GeckoRuntimeRunner(*args, **kwargs) + + +def FirefoxRunner(*args, **kwargs): + """ + Create a desktop Firefox runner. + + :param binary: Path to Firefox binary. + :param cmdargs: Arguments to pass into binary. + :param profile: Profile object to use. + :param env: Environment variables to pass into the gecko process. + :param clean_profile: If True, restores profile back to original state. + :param process_class: Class used to launch the binary. + :param process_args: Arguments to pass into process_class. + :param symbols_path: Path to symbol files used for crash analysis. + :param show_crash_reporter: allow the crash reporter window to pop up. + Defaults to False. + :returns: A GeckoRuntimeRunner for Firefox. + """ + kwargs["app_ctx"] = get_app_context("firefox")() + return GeckoRuntimeRunner(*args, **kwargs) + + +def ThunderbirdRunner(*args, **kwargs): + """ + Create a desktop Thunderbird runner. + + :param binary: Path to Thunderbird binary. + :param cmdargs: Arguments to pass into binary. + :param profile: Profile object to use. + :param env: Environment variables to pass into the gecko process. + :param clean_profile: If True, restores profile back to original state. + :param process_class: Class used to launch the binary. + :param process_args: Arguments to pass into process_class. + :param symbols_path: Path to symbol files used for crash analysis. + :param show_crash_reporter: allow the crash reporter window to pop up. + Defaults to False. + :returns: A GeckoRuntimeRunner for Thunderbird. + """ + kwargs["app_ctx"] = get_app_context("thunderbird")() + return GeckoRuntimeRunner(*args, **kwargs) + + +def ChromeRunner(*args, **kwargs): + """ + Create a desktop Google Chrome runner. + + :param binary: Path to Chrome binary. + :param cmdargs: Arguments to pass into the binary. + """ + kwargs["app_ctx"] = get_app_context("chrome")() + return BlinkRuntimeRunner(*args, **kwargs) + + +def ChromiumRunner(*args, **kwargs): + """ + Create a desktop Google Chromium runner. + + :param binary: Path to Chromium binary. + :param cmdargs: Arguments to pass into the binary. + """ + kwargs["app_ctx"] = get_app_context("chromium")() + return BlinkRuntimeRunner(*args, **kwargs) + + +def FennecEmulatorRunner( + avd="mozemulator-arm", + adb_path=None, + avd_home=None, + logdir=None, + serial=None, + binary=None, + app="org.mozilla.fennec", + **kwargs +): + """ + Create a Fennec emulator runner. This can either start a new emulator + (which will use an avd), or connect to an already-running emulator. + + :param avd: name of an AVD available in your environment. + Typically obtained via tooltool: either 'mozemulator-4.3' or 'mozemulator-x86'. + Defaults to 'mozemulator-4.3' + :param avd_home: Path to avd parent directory + :param logdir: Path to save logfiles such as qemu output. + :param serial: Serial of emulator to connect to as seen in `adb devices`. + Defaults to the first entry in `adb devices`. + :param binary: Path to emulator binary. + Defaults to None, which causes the device_class to guess based on PATH. + :param app: Name of Fennec app (often org.mozilla.fennec_$USER) + Defaults to 'org.mozilla.fennec' + :param cmdargs: Arguments to pass into binary. + :returns: A DeviceRunner for Android emulators. + """ + kwargs["app_ctx"] = get_app_context("fennec")( + app, adb_path=adb_path, avd_home=avd_home, device_serial=serial + ) + device_args = { + "app_ctx": kwargs["app_ctx"], + "avd": avd, + "binary": binary, + "logdir": logdir, + } + return FennecRunner(device_class=EmulatorAVD, device_args=device_args, **kwargs) + + +runners = { + "chrome": ChromeRunner, + "chromium": ChromiumRunner, + "default": Runner, + "firefox": FirefoxRunner, + "fennec": FennecEmulatorRunner, + "thunderbird": ThunderbirdRunner, +} diff --git a/testing/mozbase/mozrunner/mozrunner/utils.py b/testing/mozbase/mozrunner/mozrunner/utils.py new file mode 100755 index 0000000000..4b23eb7e02 --- /dev/null +++ b/testing/mozbase/mozrunner/mozrunner/utils.py @@ -0,0 +1,296 @@ +#!/usr/bin/env python + +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +"""Utility functions for mozrunner""" + +import os +import sys + +import mozinfo + +__all__ = ["findInPath", "get_metadata_from_egg"] + + +# python package method metadata by introspection +try: + import pkg_resources + + def get_metadata_from_egg(module): + ret = {} + try: + dist = pkg_resources.get_distribution(module) + except pkg_resources.DistributionNotFound: + return {} + if dist.has_metadata("PKG-INFO"): + key = None + value = "" + for line in dist.get_metadata("PKG-INFO").splitlines(): + # see http://www.python.org/dev/peps/pep-0314/ + if key == "Description": + # descriptions can be long + if not line or line[0].isspace(): + value += "\n" + line + continue + else: + key = key.strip() + value = value.strip() + ret[key] = value + + key, value = line.split(":", 1) + key = key.strip() + value = value.strip() + ret[key] = value + if dist.has_metadata("requires.txt"): + ret["Dependencies"] = "\n" + dist.get_metadata("requires.txt") + return ret + + +except ImportError: + # package resources not avaialable + def get_metadata_from_egg(module): + return {} + + +def findInPath(fileName, path=os.environ["PATH"]): + """python equivalent of which; should really be in the stdlib""" + dirs = path.split(os.pathsep) + for dir in dirs: + if os.path.isfile(os.path.join(dir, fileName)): + return os.path.join(dir, fileName) + if mozinfo.isWin: + if os.path.isfile(os.path.join(dir, fileName + ".exe")): + return os.path.join(dir, fileName + ".exe") + + +if __name__ == "__main__": + for i in sys.argv[1:]: + print(findInPath(i)) + + +def _find_marionette_in_args(*args, **kwargs): + try: + m = [a for a in args + tuple(kwargs.values()) if hasattr(a, "session")][0] + except IndexError: + print("Can only apply decorator to function using a marionette object") + raise + return m + + +def _raw_log(): + import logging + + return logging.getLogger(__name__) + + +def test_environment( + xrePath, env=None, crashreporter=True, debugger=False, useLSan=False, log=None +): + """ + populate OS environment variables for mochitest and reftests. + + Originally comes from automationutils.py. Don't use that for new code. + """ + + env = os.environ.copy() if env is None else env + log = log or _raw_log() + + assert os.path.isabs(xrePath) + + if mozinfo.isMac: + ldLibraryPath = os.path.join(os.path.dirname(xrePath), "MacOS") + else: + ldLibraryPath = xrePath + + envVar = None + if mozinfo.isUnix: + envVar = "LD_LIBRARY_PATH" + elif mozinfo.isMac: + envVar = "DYLD_LIBRARY_PATH" + elif mozinfo.isWin: + envVar = "PATH" + if envVar: + envValue = ( + (env.get(envVar), str(ldLibraryPath)) + if mozinfo.isWin + else (ldLibraryPath, env.get(envVar)) + ) + env[envVar] = os.path.pathsep.join([path for path in envValue if path]) + + # crashreporter + env["GNOME_DISABLE_CRASH_DIALOG"] = "1" + env["XRE_NO_WINDOWS_CRASH_DIALOG"] = "1" + + if crashreporter and not debugger: + env["MOZ_CRASHREPORTER_NO_REPORT"] = "1" + env["MOZ_CRASHREPORTER"] = "1" + env["MOZ_CRASHREPORTER_SHUTDOWN"] = "1" + else: + env["MOZ_CRASHREPORTER_DISABLE"] = "1" + + # Crash on non-local network connections by default. + # MOZ_DISABLE_NONLOCAL_CONNECTIONS can be set to "0" to temporarily + # enable non-local connections for the purposes of local testing. Don't + # override the user's choice here. See bug 1049688. + env.setdefault("MOZ_DISABLE_NONLOCAL_CONNECTIONS", "1") + + # Set WebRTC logging in case it is not set yet + env.setdefault("MOZ_LOG", "signaling:3,mtransport:4,DataChannel:4,jsep:4") + env.setdefault("R_LOG_LEVEL", "6") + env.setdefault("R_LOG_DESTINATION", "stderr") + env.setdefault("R_LOG_VERBOSE", "1") + + # Ask NSS to use lower-security password encryption. See Bug 1594559 + env.setdefault("NSS_MAX_MP_PBE_ITERATION_COUNT", "10") + + # ASan specific environment stuff + if "ASAN_SYMBOLIZER_PATH" in env and os.path.isfile(env["ASAN_SYMBOLIZER_PATH"]): + llvmsym = env["ASAN_SYMBOLIZER_PATH"] + else: + if mozinfo.isMac: + llvmSymbolizerDir = ldLibraryPath + else: + llvmSymbolizerDir = xrePath + llvmsym = os.path.join( + llvmSymbolizerDir, "llvm-symbolizer" + mozinfo.info["bin_suffix"] + ) + asan = bool(mozinfo.info.get("asan")) + if asan: + try: + # Symbolizer support + if os.path.isfile(llvmsym): + env["ASAN_SYMBOLIZER_PATH"] = llvmsym + log.info("INFO | runtests.py | ASan using symbolizer at %s" % llvmsym) + else: + log.error( + "TEST-UNEXPECTED-FAIL | runtests.py | Failed to find" + " ASan symbolizer at %s" % llvmsym + ) + + # Returns total system memory in kilobytes. + if mozinfo.isWin: + # pylint --py3k W1619 + totalMemory = ( + int( + os.popen( + "wmic computersystem get TotalPhysicalMemory" + ).readlines()[1] + ) + / 1024 + ) + elif mozinfo.isMac: + # pylint --py3k W1619 + totalMemory = ( + int(os.popen("sysctl hw.memsize").readlines()[0].split()[1]) / 1024 + ) + else: + totalMemory = int(os.popen("free").readlines()[1].split()[1]) + + # Only 4 GB RAM or less available? Use custom ASan options to reduce + # the amount of resources required to do the tests. Standard options + # will otherwise lead to OOM conditions on the current test machines. + message = "INFO | runtests.py | ASan running in %s configuration" + asanOptions = [] + if totalMemory <= 1024 * 1024 * 4: + message = message % "low-memory" + asanOptions = ["quarantine_size=50331648", "malloc_context_size=5"] + else: + message = message % "default memory" + + if useLSan: + log.info("LSan enabled.") + asanOptions.append("detect_leaks=1") + lsanOptions = ["exitcode=0"] + # Uncomment out the next line to report the addresses of leaked objects. + # lsanOptions.append("report_objects=1") + env["LSAN_OPTIONS"] = ":".join(lsanOptions) + + if len(asanOptions): + env["ASAN_OPTIONS"] = ":".join(asanOptions) + + except OSError as err: + log.info( + "Failed determine available memory, disabling ASan" + " low-memory configuration: %s" % err.strerror + ) + except Exception: + log.info( + "Failed determine available memory, disabling ASan" + " low-memory configuration" + ) + else: + log.info(message) + + tsan = bool(mozinfo.info.get("tsan")) + if tsan and mozinfo.isLinux: + # Symbolizer support. + if os.path.isfile(llvmsym): + env["TSAN_OPTIONS"] = "external_symbolizer_path=%s" % llvmsym + log.info("INFO | runtests.py | TSan using symbolizer at %s" % llvmsym) + else: + log.error( + "TEST-UNEXPECTED-FAIL | runtests.py | Failed to find TSan" + " symbolizer at %s" % llvmsym + ) + + ubsan = bool(mozinfo.info.get("ubsan")) + if ubsan and (mozinfo.isLinux or mozinfo.isMac): + log.info("UBSan enabled.") + + return env + + +def get_stack_fixer_function(utilityPath, symbolsPath, hideErrors=False): + """ + Return a stack fixing function, if possible, to use on output lines. + + A stack fixing function checks if a line conforms to the output from + MozFormatCodeAddressDetails. If the line does not, the line is returned + unchanged. If the line does, an attempt is made to convert the + file+offset into something human-readable (e.g. a function name). + """ + if not mozinfo.info.get("debug"): + return None + + if os.getenv("MOZ_DISABLE_STACK_FIX", 0): + print( + "WARNING: No stack-fixing will occur because MOZ_DISABLE_STACK_FIX is set" + ) + return None + + def import_stack_fixer_module(module_name): + sys.path.insert(0, utilityPath) + module = __import__(module_name, globals(), locals(), []) + sys.path.pop(0) + return module + + if symbolsPath and os.path.exists(symbolsPath): + # Run each line through fix_stacks.py, using breakpad symbol files. + # This method is preferred for automation, since native symbols may + # have been stripped. + stack_fixer_module = import_stack_fixer_module("fix_stacks") + + def stack_fixer_function(line): + return stack_fixer_module.fixSymbols( + line, + slowWarning=True, + breakpadSymsDir=symbolsPath, + hide_errors=hideErrors, + ) + + elif mozinfo.isLinux or mozinfo.isMac or mozinfo.isWin: + # Run each line through fix_stacks.py. This method is preferred for + # developer machines, so we don't have to run "mach buildsymbols". + stack_fixer_module = import_stack_fixer_module("fix_stacks") + + def stack_fixer_function(line): + return stack_fixer_module.fixSymbols( + line, slowWarning=True, hide_errors=hideErrors + ) + + else: + return None + + return stack_fixer_function diff --git a/testing/mozbase/mozrunner/setup.cfg b/testing/mozbase/mozrunner/setup.cfg new file mode 100644 index 0000000000..2a9acf13da --- /dev/null +++ b/testing/mozbase/mozrunner/setup.cfg @@ -0,0 +1,2 @@ +[bdist_wheel] +universal = 1 diff --git a/testing/mozbase/mozrunner/setup.py b/testing/mozbase/mozrunner/setup.py new file mode 100644 index 0000000000..5723a571a3 --- /dev/null +++ b/testing/mozbase/mozrunner/setup.py @@ -0,0 +1,53 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +from setuptools import find_packages, setup + +PACKAGE_NAME = "mozrunner" +PACKAGE_VERSION = "8.2.1" + +desc = """Reliable start/stop/configuration of Mozilla Applications (Firefox, Thunderbird, etc.)""" + +deps = [ + "mozdevice>=4.0.0,<5", + "mozfile>=1.2", + "mozinfo>=0.7,<2", + "mozlog>=6.0", + "mozprocess>=1.3.0,<2", + "mozprofile~=2.3", + "six>=1.13.0,<2", +] + +EXTRAS_REQUIRE = {"crash": ["mozcrash >= 2.0"]} + +setup( + name=PACKAGE_NAME, + version=PACKAGE_VERSION, + description=desc, + long_description="see https://firefox-source-docs.mozilla.org/mozbase/index.html", + classifiers=[ + "Environment :: Console", + "Intended Audience :: Developers", + "License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)", + "Natural Language :: English", + "Operating System :: OS Independent", + "Programming Language :: Python :: 2.7", + "Programming Language :: Python :: 3.5", + "Topic :: Software Development :: Libraries :: Python Modules", + ], + keywords="mozilla", + author="Mozilla Automation and Tools team", + author_email="tools@lists.mozilla.org", + url="https://wiki.mozilla.org/Auto-tools/Projects/Mozbase", + license="MPL 2.0", + packages=find_packages(), + zip_safe=False, + install_requires=deps, + extras_require=EXTRAS_REQUIRE, + entry_points=""" + # -*- Entry points: -*- + [console_scripts] + mozrunner = mozrunner:cli + """, +) diff --git a/testing/mozbase/mozrunner/tests/conftest.py b/testing/mozbase/mozrunner/tests/conftest.py new file mode 100644 index 0000000000..991fc376fb --- /dev/null +++ b/testing/mozbase/mozrunner/tests/conftest.py @@ -0,0 +1,81 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +import os +import threading +from time import sleep + +import mozrunner +import pytest +from moztest.selftest import fixtures + + +@pytest.fixture(scope="session") +def get_binary(): + if "BROWSER_PATH" in os.environ: + os.environ["GECKO_BINARY_PATH"] = os.environ["BROWSER_PATH"] + + def inner(app): + if app not in ("chrome", "chromium", "firefox"): + pytest.xfail(reason="{} support not implemented".format(app)) + + if app == "firefox": + binary = fixtures.binary() + elif app == "chrome": + binary = os.environ.get("CHROME_BINARY_PATH") + elif app == "chromium": + binary = os.environ.get("CHROMIUM_BINARY_PATH") + + if not binary: + pytest.skip("could not find a {} binary".format(app)) + return binary + + return inner + + +@pytest.fixture(params=["firefox", "chrome", "chromium"]) +def runner(request, get_binary): + app = request.param + binary = get_binary(app) + + cmdargs = ["--headless"] + if app in ["chrome", "chromium"]: + # prevents headless chromium from exiting after loading the page + cmdargs.append("--remote-debugging-port=9222") + # only needed on Windows, but no harm in specifying it everywhere + cmdargs.append("--disable-gpu") + runner = mozrunner.runners[app](binary, cmdargs=cmdargs) + runner.app = app + yield runner + runner.stop() + + +class RunnerThread(threading.Thread): + def __init__(self, runner, start=False, timeout=1): + threading.Thread.__init__(self) + self.runner = runner + self.timeout = timeout + self.do_start = start + + def run(self): + sleep(self.timeout) + if self.do_start: + self.runner.start() + else: + self.runner.stop() + + +@pytest.fixture +def create_thread(): + threads = [] + + def inner(*args, **kwargs): + thread = RunnerThread(*args, **kwargs) + threads.append(thread) + return thread + + yield inner + + for thread in threads: + thread.join() diff --git a/testing/mozbase/mozrunner/tests/manifest.ini b/testing/mozbase/mozrunner/tests/manifest.ini new file mode 100644 index 0000000000..7348004fdf --- /dev/null +++ b/testing/mozbase/mozrunner/tests/manifest.ini @@ -0,0 +1,12 @@ +[DEFAULT] +subsuite = mozbase +# We skip these tests in automated Windows builds because they trigger crashes +# in sh.exe; see bug 1489277. +skip-if = automation && os == 'win' +[test_crash.py] +[test_interactive.py] +[test_start.py] +[test_states.py] +[test_stop.py] +[test_threads.py] +[test_wait.py] diff --git a/testing/mozbase/mozrunner/tests/test_crash.py b/testing/mozbase/mozrunner/tests/test_crash.py new file mode 100644 index 0000000000..820851aa1c --- /dev/null +++ b/testing/mozbase/mozrunner/tests/test_crash.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +from unittest.mock import patch + +import mozunit +import pytest + + +@pytest.mark.parametrize("logger", [True, False]) +def test_crash_count_with_or_without_logger(runner, logger): + if runner.app == "chrome": + pytest.xfail("crash checking not implemented for ChromeRunner") + + if not logger: + runner.logger = None + fn = "check_for_crashes" + else: + fn = "log_crashes" + + with patch("mozcrash.{}".format(fn), return_value=2) as mock: + assert runner.crashed == 0 + assert runner.check_for_crashes() == 2 + assert runner.crashed == 2 + assert runner.check_for_crashes() == 2 + assert runner.crashed == 4 + + mock.return_value = 0 + assert runner.check_for_crashes() == 0 + assert runner.crashed == 4 + + +if __name__ == "__main__": + mozunit.main() diff --git a/testing/mozbase/mozrunner/tests/test_interactive.py b/testing/mozbase/mozrunner/tests/test_interactive.py new file mode 100644 index 0000000000..ab700d334c --- /dev/null +++ b/testing/mozbase/mozrunner/tests/test_interactive.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python + +from time import sleep + +import mozunit + + +def test_run_interactive(runner, create_thread): + """Bug 965183: Run process in interactive mode and call wait()""" + runner.start(interactive=True) + + thread = create_thread(runner, timeout=2) + thread.start() + + # This is a blocking call. So the process should be killed by the thread + runner.wait() + thread.join() + assert not runner.is_running() + + +def test_stop_interactive(runner): + """Bug 965183: Explicitely stop process in interactive mode""" + runner.start(interactive=True) + runner.stop() + + +def test_wait_after_process_finished(runner): + """Wait after the process has been stopped should not raise an error""" + runner.start(interactive=True) + sleep(1) + runner.process_handler.kill() + + returncode = runner.wait(1) + + assert returncode not in [None, 0] + assert runner.process_handler is not None + + +if __name__ == "__main__": + mozunit.main() diff --git a/testing/mozbase/mozrunner/tests/test_start.py b/testing/mozbase/mozrunner/tests/test_start.py new file mode 100644 index 0000000000..56e01ae84d --- /dev/null +++ b/testing/mozbase/mozrunner/tests/test_start.py @@ -0,0 +1,61 @@ +#!/usr/bin/env python + +from time import sleep +from unittest.mock import patch + +import mozunit +from mozrunner import RunnerNotStartedError +from pytest import raises + + +def test_start_process(runner): + """Start the process and test properties""" + assert runner.process_handler is None + + runner.start() + + assert runner.is_running() + assert runner.process_handler is not None + + +def test_start_process_called_twice(runner): + """Start the process twice and test that first process is gone""" + runner.start() + # Bug 925480 + # Make a copy until mozprocess can kill a specific process + process_handler = runner.process_handler + + runner.start() + + try: + assert process_handler.wait(1) not in [None, 0] + finally: + process_handler.kill() + + +def test_start_with_timeout(runner): + """Start the process and set a timeout""" + runner.start(timeout=0.1) + sleep(1) + + assert not runner.is_running() + + +def test_start_with_outputTimeout(runner): + """Start the process and set a timeout""" + runner.start(outputTimeout=0.1) + sleep(1) + + assert not runner.is_running() + + +def test_fail_to_start(runner): + with patch("mozprocess.ProcessHandler.__init__") as ph_mock: + ph_mock.side_effect = Exception("Boom!") + with raises(RunnerNotStartedError): + runner.start(outputTimeout=0.1) + sleep(1) + + +if __name__ == "__main__": + mozunit.main() diff --git a/testing/mozbase/mozrunner/tests/test_states.py b/testing/mozbase/mozrunner/tests/test_states.py new file mode 100644 index 0000000000..b2eb3d119c --- /dev/null +++ b/testing/mozbase/mozrunner/tests/test_states.py @@ -0,0 +1,22 @@ +#!/usr/bin/env python + +import mozunit +import pytest +from mozrunner import RunnerNotStartedError + + +def test_errors_before_start(runner): + """Bug 965714: Not started errors before start() is called""" + + with pytest.raises(RunnerNotStartedError): + runner.is_running() + + with pytest.raises(RunnerNotStartedError): + runner.returncode + + with pytest.raises(RunnerNotStartedError): + runner.wait() + + +if __name__ == "__main__": + mozunit.main() diff --git a/testing/mozbase/mozrunner/tests/test_stop.py b/testing/mozbase/mozrunner/tests/test_stop.py new file mode 100644 index 0000000000..a4f2b1fadd --- /dev/null +++ b/testing/mozbase/mozrunner/tests/test_stop.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +import signal + +import mozunit + + +def test_stop_process(runner): + """Stop the process and test properties""" + runner.start() + returncode = runner.stop() + + assert not runner.is_running() + assert returncode not in [None, 0] + assert runner.returncode == returncode + assert runner.process_handler is not None + assert runner.wait(1) == returncode + + +def test_stop_before_start(runner): + """Stop the process before it gets started should not raise an error""" + runner.stop() + + +def test_stop_process_custom_signal(runner): + """Stop the process via a custom signal and test properties""" + runner.start() + returncode = runner.stop(signal.SIGTERM) + + assert not runner.is_running() + assert returncode not in [None, 0] + assert runner.returncode == returncode + assert runner.process_handler is not None + assert runner.wait(1) == returncode + + +if __name__ == "__main__": + mozunit.main() diff --git a/testing/mozbase/mozrunner/tests/test_threads.py b/testing/mozbase/mozrunner/tests/test_threads.py new file mode 100644 index 0000000000..fa77d92688 --- /dev/null +++ b/testing/mozbase/mozrunner/tests/test_threads.py @@ -0,0 +1,57 @@ +#!/usr/bin/env python +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +import mozunit + + +def test_process_start_via_thread(runner, create_thread): + """Start the runner via a thread""" + thread = create_thread(runner, True, 2) + + thread.start() + thread.join() + + assert runner.is_running() + + +def test_process_stop_via_multiple_threads(runner, create_thread): + """Stop the runner via multiple threads""" + runner.start() + threads = [] + for i in range(5): + thread = create_thread(runner, False, 5) + threads.append(thread) + thread.start() + + # Wait until the process has been stopped by another thread + for thread in threads: + thread.join() + returncode = runner.wait(1) + + assert returncode not in [None, 0] + assert runner.returncode == returncode + assert runner.process_handler is not None + assert runner.wait(2) == returncode + + +def test_process_post_stop_via_thread(runner, create_thread): + """Stop the runner and try it again with a thread a bit later""" + runner.start() + thread = create_thread(runner, False, 5) + thread.start() + + # Wait a bit to start the application gets started + runner.wait(1) + returncode = runner.stop() + thread.join() + + assert returncode not in [None, 0] + assert runner.returncode == returncode + assert runner.process_handler is not None + assert runner.wait(2) == returncode + + +if __name__ == "__main__": + mozunit.main() diff --git a/testing/mozbase/mozrunner/tests/test_wait.py b/testing/mozbase/mozrunner/tests/test_wait.py new file mode 100644 index 0000000000..d7ba721b3d --- /dev/null +++ b/testing/mozbase/mozrunner/tests/test_wait.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this file, +# You can obtain one at http://mozilla.org/MPL/2.0/. + +import mozunit + + +def test_wait_while_running(runner): + """Wait for the process while it is running""" + runner.start() + returncode = runner.wait(1) + + assert runner.is_running() + assert returncode is None + assert runner.returncode == returncode + assert runner.process_handler is not None + + +def test_wait_after_process_finished(runner): + """Bug 965714: wait() after stop should not raise an error""" + runner.start() + runner.process_handler.kill() + + returncode = runner.wait(1) + + assert returncode not in [None, 0] + assert runner.process_handler is not None + + +if __name__ == "__main__": + mozunit.main() |