def run_raptor(self, **kwargs): build_obj = self is_android = Conditions.is_android(build_obj) or \ kwargs['app'] in FIREFOX_ANDROID_BROWSERS if is_android: from mozrunner.devices.android_device import ( verify_android_device, InstallIntent) from mozdevice import ADBAndroid, ADBHost install = InstallIntent.NO if kwargs.pop( 'noinstall', False) else InstallIntent.PROMPT if not verify_android_device( build_obj, install=install, app=kwargs['binary'], xre=True): # Equivalent to 'run_local' = True. return 1 debug_command = '--debug-command' if debug_command in sys.argv: sys.argv.remove(debug_command) raptor = self._spawn(RaptorRunner) try: if is_android and kwargs['power_test']: device = ADBAndroid(verbose=True) adbhost = ADBHost(verbose=True) device_serial = "{}:5555".format(device.get_ip_address()) device.command_output(["tcpip", "5555"]) six.input( "Please disconnect your device from USB then press Enter/return..." ) adbhost.command_output(["connect", device_serial]) while len(adbhost.devices()) > 1: six.input( "You must disconnect your device from USB before continuing." ) # must reset the environment DEVICE_SERIAL which was set during # verify_android_device to match our new tcpip value. os.environ["DEVICE_SERIAL"] = device_serial return raptor.run_test(sys.argv[2:], kwargs) except Exception as e: print(repr(e)) return 1 finally: try: if is_android and kwargs['power_test']: six.input( "Connect device via USB and press Enter/return...") device = ADBAndroid(device=device_serial, verbose=True) device.command_output(["usb"]) adbhost.command_output(["disconnect", device_serial]) except Exception: adbhost.command_output(["kill-server"])
def run_raptor_test(self, **kwargs): build_obj = MozbuildObject.from_environment(cwd=HERE) firefox_android_browsers = ["fennec", "geckoview", "refbrow", "fenix"] if conditions.is_android( build_obj) or kwargs['app'] in firefox_android_browsers: from mozrunner.devices.android_device import verify_android_device from mozdevice import ADBAndroid, ADBHost if not verify_android_device( build_obj, install=True, app=kwargs['binary'], xre=True): # Equivalent to 'run_local' = True. return 1 debug_command = '--debug-command' if debug_command in sys.argv: sys.argv.remove(debug_command) raptor = self._spawn(RaptorRunner) try: if kwargs['app'] in firefox_android_browsers and kwargs[ 'power_test']: device = ADBAndroid(verbose=True) adbhost = ADBHost(verbose=True) device_serial = "%s:5555" % device.get_ip_address() device.command_output(["tcpip", "5555"]) raw_input( "Please disconnect your device from USB then press Enter/return..." ) adbhost.command_output(["connect", device_serial]) while len(adbhost.devices()) > 1: raw_input( "You must disconnect your device from USB before continuing." ) # must reset the environment DEVICE_SERIAL which was set during # verify_android_device to match our new tcpip value. os.environ["DEVICE_SERIAL"] = device_serial return raptor.run_test(sys.argv[2:], kwargs) except Exception as e: print(repr(e)) return 1 finally: try: if kwargs['app'] in firefox_android_browsers and kwargs[ 'power_test']: raw_input( "Connect device via USB and press Enter/return...") device = ADBAndroid(device=device_serial, verbose=True) device.command_output(["usb"]) adbhost.command_output(["disconnect", device_serial]) except Exception: adbhost.command_output(["kill-server"])
def __init__(self, app, binary, run_local=False, obj_path=None, gecko_profile=False, gecko_profile_interval=None, gecko_profile_entries=None, symbols_path=None): self.config = {} self.config['app'] = app self.config['binary'] = binary self.config['platform'] = mozinfo.os self.config['processor'] = mozinfo.processor self.config['run_local'] = run_local self.config['obj_path'] = obj_path self.config['gecko_profile'] = gecko_profile self.config['gecko_profile_interval'] = gecko_profile_interval self.config['gecko_profile_entries'] = gecko_profile_entries self.config['symbols_path'] = symbols_path self.raptor_venv = os.path.join(os.getcwd(), 'raptor-venv') self.log = get_default_logger(component='raptor-main') self.control_server = None self.playback = None self.benchmark = None self.gecko_profiler = None self.post_startup_delay = 30000 # raptor webext pause time after browser startup # Create the profile; for geckoview we want a firefox profile type if self.config['app'] == 'geckoview': self.profile = create_profile('firefox') else: self.profile = create_profile(self.config['app']) # Merge in base profiles with open(os.path.join(self.profile_data_dir, 'profiles.json'), 'r') as fh: base_profiles = json.load(fh)['raptor'] for name in base_profiles: path = os.path.join(self.profile_data_dir, name) self.log.info("Merging profile: {}".format(path)) self.profile.merge(path) # create results holder self.results_handler = RaptorResultsHandler() # when testing desktop browsers we use mozrunner to start the browser; when # testing on android (i.e. geckoview) we use mozdevice to control the device app if self.config['app'] == "geckoview": # create the android device handler; it gets initiated and sets up adb etc self.log.info("creating android device handler using mozdevice") self.device = ADBAndroid(verbose=True) self.device.clear_logcat() else: # create the desktop browser runner self.log.info("creating browser runner using mozrunner") self.output_handler = OutputHandler() process_args = { 'processOutputLine': [self.output_handler], } runner_cls = runners[app] self.runner = runner_cls( binary, profile=self.profile, process_args=process_args) self.log.info("raptor config: %s" % str(self.config))
def run_raptor(self, **kwargs): build_obj = self is_android = Conditions.is_android(build_obj) or \ kwargs['app'] in FIREFOX_ANDROID_BROWSERS if is_android: from mozrunner.devices.android_device import ( verify_android_device, InstallIntent) from mozdevice import ADBAndroid install = InstallIntent.NO if kwargs.pop( 'noinstall', False) else InstallIntent.PROMPT if not verify_android_device( build_obj, install=install, app=kwargs['binary'], xre=True): # Equivalent to 'run_local' = True. return 1 debug_command = '--debug-command' if debug_command in sys.argv: sys.argv.remove(debug_command) raptor = self._spawn(RaptorRunner) device = None try: if kwargs['power_test'] and is_android: device = ADBAndroid(verbose=True) disable_charging(device) return raptor.run_test(sys.argv[2:], kwargs) except Exception as e: print(repr(e)) return 1 finally: if kwargs['power_test'] and device: enable_charging(device)
class Robocop(object): device = ADBAndroid() logger = logging.getLogger() def __init__(self, app, log): self.app = app self.log = log def run(self, identifier): # build browser environment # setup robotium config # setup remote profile # build browser args cmd = [ "am", "instrument", "-e quit_and_finish 1", "-e deviceroot {}".format(self.device.test_root), "-e class org.mozilla.gecko.tests.{}".format(identifier), "org.mozilla.roboexample.test/org.mozilla.gecko.FennecInstrumentationTestRunner", ] self.device.clear_logcat() self.logger.info("Running: {}".format(" ".join(cmd))) self.device.shell(" ".join(cmd)) # wait for process to end top = self.app while top == self.app: time.sleep(0.5) top = self.device.get_top_activity(timeout=60) log = "\n".join(self.device.get_logcat()) with open(self.log, "w") as f: f.writelines(log) assert "Failed: 0" in log
def run_tests_remote(tests, num_tests, prefix, options, slog): # Setup device with everything needed to run our tests. from mozdevice import ADBAndroid device = ADBAndroid(device=options.device_serial, test_root=options.remote_test_root) # Update the test root to point to our test directory. jit_tests_dir = posixpath.join(options.remote_test_root, 'jit-tests') options.remote_test_root = posixpath.join(jit_tests_dir, 'jit-tests') # Push js shell and libraries. device.rm(jit_tests_dir, force=True, recursive=True) device.mkdir(options.remote_test_root, parents=True) push_libs(options, device) push_progs(options, device, [prefix[0]]) device.chmod(options.remote_test_root, recursive=True, root=True) JitTest.CacheDir = posixpath.join(options.remote_test_root, '.js-cache') device.mkdir(JitTest.CacheDir) device.push(JS_TESTS_DIR, posixpath.join(jit_tests_dir, 'tests'), timeout=600) device.push(os.path.dirname(TEST_DIR), options.remote_test_root, timeout=600) prefix[0] = os.path.join(options.remote_test_root, 'js') # Run all tests. pb = create_progressbar(num_tests, options) gen = get_remote_results(tests, device, prefix, options) ok = process_test_results(gen, num_tests, pb, options, slog) return ok
def __init__(self, log, options): self.log = log verbose = False if options.log_tbpl_level == 'debug' or options.log_mach_level == 'debug': verbose = True self.device = ADBAndroid(adb=options.adbPath or 'adb', device=options.deviceSerial, test_root=options.remoteTestRoot, verbose=verbose) self.options = options self.log.debug("options=%s" % vars(options)) update_mozinfo() self.remote_profile = posixpath.join(self.device.test_root, 'junit-profile') if self.options.coverage and not self.options.coverage_output_path: raise Exception("--coverage-output-path is required when using --enable-coverage") self.remote_coverage_output_path = posixpath.join(self.device.test_root, 'junit-coverage.ec') self.server_init() self.cleanup() self.device.clear_logcat() self.build_profile() self.startServers( self.options, debuggerInfo=None, ignoreSSLTunnelExts=True) self.log.debug("Servers started")
def _install(self, dest): # get info now, as dest may be removed self.app_info = mozversion.get_version(binary=dest) self.package_name = self.app_info.get("package_name", "org.mozilla.fennec") self.adb = ADBAndroid() self.adb.uninstall_app(self.package_name) self.adb.install_app(dest)
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 = ADBAndroid(adb=self.adb, device=device_serial)
def __init__(self, log, options): self.log = log self.device = ADBAndroid(adb=options.adbPath or 'adb', device=options.deviceSerial, test_root=options.remoteTestRoot) self.options = options self.appname = self.options.app.split('/')[-1] self.logcat = None self.build_profile() self.log.debug("options=%s" % vars(options))
def get_device(self, adb_path, device_serial): # Create a mozdevice.ADBAndroid 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 = ADBAndroid(adb=adb_path, device=device_serial) devices[device_serial] = device return device
def _get_device(substs, device_serial=None): global devices if device_serial in devices: device = devices[device_serial] else: adb_path = _find_sdk_exe(substs, 'adb', False) if not adb_path: adb_path = 'adb' device = ADBAndroid(adb=adb_path, verbose=verbose_logging, device=device_serial) devices[device_serial] = device return device
def _install(self, dest): if self._get_device_status(): self.adb = ADBAndroid() if "y" != raw_input("WARNING: bisecting nightly fennec builds will" " clobber your existing nightly profile." " Continue? (y or n)"): raise Exception("Aborting!") self.adb.uninstall_app("org.mozilla.fennec") self.adb.install_app(dest) # get info now, as dest may be removed self.app_info = mozversion.get_version(binary=dest)
def __init__(self, options, progs): cppunittests.CPPUnitTests.__init__(self) self.options = options self.device = ADBAndroid(adb=options.adb_path or 'adb', device=options.device_serial, test_root=options.remote_test_root) self.remote_test_root = posixpath.join(self.device.test_root, "cppunittests") self.remote_bin_dir = posixpath.join(self.remote_test_root, "b") self.remote_tmp_dir = posixpath.join(self.remote_test_root, "tmp") self.remote_home_dir = posixpath.join(self.remote_test_root, "h") if options.setup: self.setup_bin(progs)
def __init__(self, options, message_logger): """ Simple one-time initialization. """ MochitestDesktop.__init__(self, options.flavor, vars(options)) verbose = False if options.log_tbpl_level == 'debug' or options.log_mach_level == 'debug': verbose = True self.device = ADBAndroid(adb=options.adbPath or 'adb', device=options.deviceSerial, test_root=options.remoteTestRoot, verbose=verbose) # Check that Firefox is installed expected = options.app.split('/')[-1] if not self.device.is_app_installed(expected): raise Exception("%s is not installed on this device" % expected) options.logFile = "robocop.log" if options.remoteTestRoot is None: options.remoteTestRoot = self.device.test_root self.remoteProfile = posixpath.join(options.remoteTestRoot, "profile") self.remoteProfileCopy = posixpath.join(options.remoteTestRoot, "profile-copy") self.remoteModulesDir = posixpath.join(options.remoteTestRoot, "modules/") self.remoteConfigFile = posixpath.join(options.remoteTestRoot, "robotium.config") self.remoteLogFile = posixpath.join(options.remoteTestRoot, "logs", "robocop.log") self.options = options process_args = {'messageLogger': message_logger} self.auto = RemoteAutomation(self.device, options.remoteappname, self.remoteProfile, self.remoteLogFile, processArgs=process_args) self.environment = self.auto.environment self.remoteScreenshots = "/mnt/sdcard/Robotium-Screenshots" self.remoteMozLog = posixpath.join(options.remoteTestRoot, "mozlog") self.localLog = options.logFile self.localProfile = None self.certdbNew = True self.passed = 0 self.failed = 0 self.todo = 0
def _install(self, dest): # get info now, as dest may be removed self.app_info = safe_get_version(binary=dest) self.package_name = self.app_info.get("package_name", "org.mozilla.fennec") self.adb = ADBAndroid() try: self.adb.uninstall_app(self.package_name) except ADBError, msg: LOG.warning( "Failed to uninstall %s (%s)\nThis is normal if it is the" " first time the application is installed." % (self.package_name, msg))
def run_raptor(self, **kwargs): # Defers this import so that a transitive dependency doesn't # stop |mach bootstrap| from running from raptor.power import enable_charging, disable_charging build_obj = self is_android = Conditions.is_android(build_obj) or \ kwargs['app'] in ANDROID_BROWSERS if is_android: from mozrunner.devices.android_device import ( verify_android_device, InstallIntent) from mozdevice import ADBAndroid install = InstallIntent.NO if kwargs.pop( 'noinstall', False) else InstallIntent.YES verbose = False if kwargs.get('log_mach_verbose') or kwargs.get('log_tbpl_level') == 'debug' or \ kwargs.get('log_mach_level') == 'debug' or kwargs.get('log_raw_level') == 'debug': verbose = True if not verify_android_device( build_obj, install=install, app=kwargs['binary'], verbose=verbose, xre=True): # Equivalent to 'run_local' = True. return 1 debug_command = '--debug-command' if debug_command in sys.argv: sys.argv.remove(debug_command) raptor = self._spawn(RaptorRunner) device = None try: if kwargs['power_test'] and is_android: device = ADBAndroid(verbose=True) disable_charging(device) return raptor.run_test(sys.argv[2:], kwargs) except BinaryNotFoundException as e: self.log(logging.ERROR, 'raptor', {'error': str(e)}, 'ERROR: {error}') self.log(logging.INFO, 'raptor', {'help': e.help()}, '{help}') return 1 except Exception as e: print(repr(e)) return 1 finally: if kwargs['power_test'] and device: enable_charging(device)
def _install(self, dest): # get info now, as dest may be removed self.app_info = safe_get_version(binary=dest) self.package_name = self.app_info.get("package_name", self._get_package_name()) self.adb = ADBAndroid(require_root=False) try: self.adb.uninstall_app(self.package_name) except ADBError as msg: LOG.warning( "Failed to uninstall %s (%s)\nThis is normal if it is the" " first time the application is installed." % (self.package_name, msg)) self.adb.install_app(dest)
def setup_app(self): # create the android device handler; it gets initiated and sets up adb etc self.log.info("creating android device handler using mozdevice") self.device = ADBAndroid(verbose=True, logger_name="recorder-adb - ") self.device_raptor_dir = "/sdcard/raptor" self.config['device_raptor_dir'] = self.device_raptor_dir if self.device.is_dir(self.device_raptor_dir): self.log.info("deleting existing device raptor dir: %s" % self.device_raptor_dir) self.device.rm(self.device_raptor_dir, recursive=True) self.log.info("creating raptor folder on sdcard: %s" % self.device_raptor_dir) self.device.mkdir(self.device_raptor_dir) self.device.chmod(self.device_raptor_dir, recursive=True)
def setup_device(self): self.device = ADBAndroid() if self.binary and self.proxy.mode is "record": if not self.skip_install: if self.device.is_app_installed(self.APP_NAME): print("Uninstalling app %s" % self.APP_NAME) self.device.uninstall_app(self.APP_NAME) print("Installing app %s" % self.APP_NAME) self.device.install_app(apk_path=self.binary) self.skip_install = True else: print("App already installed in a previous recording!!!!") else: print( "No binary provided or proxy in replay mode! Using existing app on the device." )
def verify_device(self, adb_path, device): """ Check that the specified device is available and rooted. """ try: device = ADBAndroid(adb=adb_path, device=device, timeout=10) if device._have_su or device._have_android_su or device._have_root_shell: return True except Exception: self.build_obj.log( logging.WARN, "autophone", {}, "Unable to verify root on device.") if self.verbose: self.build_obj.log(logging.ERROR, "autophone", {}, str(sys.exc_info()[0])) return False
def run_raptor(self, **kwargs): build_obj = self is_android = Conditions.is_android(build_obj) or \ kwargs['app'] in ANDROID_BROWSERS if is_android: from mozrunner.devices.android_device import ( verify_android_device, InstallIntent) from mozdevice import ADBAndroid install = InstallIntent.NO if kwargs.pop( 'noinstall', False) else InstallIntent.YES if not verify_android_device( build_obj, install=install, app=kwargs['binary'], xre=True): # Equivalent to 'run_local' = True. return 1 debug_command = '--debug-command' if debug_command in sys.argv: sys.argv.remove(debug_command) raptor = self._spawn(RaptorRunner) device = None try: if kwargs['power_test'] and is_android: device = ADBAndroid(verbose=True) disable_charging(device) return raptor.run_test(sys.argv[2:], kwargs) except BinaryNotFoundException as e: self.log(logging.ERROR, 'raptor', {'error': str(e)}, 'ERROR: {error}') self.log(logging.INFO, 'raptor', {'help': e.help()}, '{help}') return 1 except Exception as e: print(repr(e)) return 1 finally: if kwargs['power_test'] and device: enable_charging(device)
def __init__(self, log, options): self.log = log verbose = False if options.log_tbpl_level == 'debug' or options.log_mach_level == 'debug': verbose = True self.device = ADBAndroid(adb=options.adbPath or 'adb', device=options.deviceSerial, test_root=options.remoteTestRoot, verbose=verbose) self.options = options self.log.debug("options=%s" % vars(options)) update_mozinfo() self.remote_profile = posixpath.join(self.device.test_root, 'junit-profile') self.server_init() self.cleanup() self.device.clear_logcat() self.build_profile() self.startServers( self.options, debuggerInfo=None, ignoreSSLTunnelExts=True) self.log.debug("Servers started")
def __init__(self, options): MochitestDesktop.__init__(self, options.flavor, vars(options)) verbose = False if options.log_tbpl_level == 'debug' or options.log_mach_level == 'debug': verbose = True if hasattr(options, 'log'): delattr(options, 'log') self.certdbNew = True self.chromePushed = False self.mozLogName = "moz.log" self.device = ADBAndroid(adb=options.adbPath, device=options.deviceSerial, test_root=options.remoteTestRoot, verbose=verbose) if options.remoteTestRoot is None: options.remoteTestRoot = self.device.test_root options.dumpOutputDirectory = options.remoteTestRoot self.remoteLogFile = posixpath.join(options.remoteTestRoot, "logs", "mochitest.log") logParent = posixpath.dirname(self.remoteLogFile) self.device.rm(logParent, force=True, recursive=True) self.device.mkdir(logParent) self.remoteProfile = posixpath.join(options.remoteTestRoot, "profile/") self.device.rm(self.remoteProfile, force=True, recursive=True) self.counts = dict() self.message_logger = MessageLogger(logger=None) self.message_logger.logger = self.log process_args = { 'messageLogger': self.message_logger, 'counts': self.counts } self.automation = RemoteAutomation(self.device, options.remoteappname, self.remoteProfile, self.remoteLogFile, processArgs=process_args) self.environment = self.automation.environment # Check that Firefox is installed expected = options.app.split('/')[-1] if not self.device.is_app_installed(expected): raise Exception("%s is not installed on this device" % expected) self.automation.deleteANRs() self.automation.deleteTombstones() self.device.clear_logcat() self.remoteModulesDir = posixpath.join(options.remoteTestRoot, "modules/") self.remoteCache = posixpath.join(options.remoteTestRoot, "cache/") self.device.rm(self.remoteCache, force=True, recursive=True) # move necko cache to a location that can be cleaned up options.extraPrefs += [ "browser.cache.disk.parent_directory=%s" % self.remoteCache ] self.remoteMozLog = posixpath.join(options.remoteTestRoot, "mozlog") self.device.rm(self.remoteMozLog, force=True, recursive=True) self.device.mkdir(self.remoteMozLog) self.remoteChromeTestDir = posixpath.join(options.remoteTestRoot, "chrome") self.device.rm(self.remoteChromeTestDir, force=True, recursive=True) self.device.mkdir(self.remoteChromeTestDir) procName = options.app.split('/')[-1] self.device.stop_application(procName) if self.device.process_exist(procName): self.log.warning("unable to kill %s before running tests!" % procName) # Add Android version (SDK level) to mozinfo so that manifest entries # can be conditional on android_version. self.log.info( "Android sdk version '%s'; will use this to filter manifests" % str(self.device.version)) mozinfo.info['android_version'] = str(self.device.version)
def parse_sites_json(self): print("Parsing sites json") sites = [] if self.sites_path is not None: with open(self.sites_path, "r") as sites_file: sites_json = json.loads(sites_file.read()) self.information["app"] = self.app.lower() self.information["platform"] = { "system": platform.system(), "release": platform.release(), "version": platform.version(), "machine": platform.machine(), "processor": platform.processor(), } platform_name = platform.system().lower() if issubclass(APPS[self.app], AbstractAndroidFirefox): device = ADBAndroid() for property in [ "ro.product.model", "ro.build.user", "ro.build.version.release", ]: self.information[property] = device.shell_output( "getprop {}".format(property)) platform_name = "".join( e for e in self.information["ro.product.model"] if e.isalnum()).lower() for site in sites_json: site["domain"] = tldextract.extract(site["url"]).domain name = [ self.proxy, platform_name, "gve" if self.app == "GeckoViewExample" else self.app.lower(), site["domain"], ] label = site.get("label") if label: name.append(label) name = "-".join(name) site["path"] = os.path.join(self.path, name, name) site["name"] = name site["recording_path"] = "%s.mp" % site["path"] site["json_path"] = "%s.json" % site["path"] site["screen_shot_path"] = "%s.png" % site["path"] site["zip_path"] = os.path.join(self.path, "%s.zip" % site["name"]) site["manifest_path"] = os.path.join( self.path, "%s.manifest" % site["name"]) sites.append(site) else: raise Exception("No site JSON file found!!!") return sites
def cli(record, certutil, url, path): # create profile profile = create_profile("firefox") print("Created profile: {}".format(profile.profile)) mitmproxy_home = os.path.join(os.path.expanduser("~"), ".mitmproxy") cert = os.path.join(mitmproxy_home, "mitmproxy-ca-cert.cer") # start mitmdump scripts = os.path.join(os.getcwd(), "scripts") mitmdump = os.path.join(os.getcwd(), "utils", "mitmdump") if record: command = [mitmdump, "--wfile", path] else: command = [ mitmdump, "--replay-kill-extra", "--script", " ".join( [os.path.join(scripts, "alternate-server-replay.py"), path]), ] try: print(command) mitmdump_process = subprocess.Popen(command) # create certificate database certdb = "sql:{}/".format(profile.profile) print("Creating certificate database") command = [certutil, "-N", "-v", "-d", certdb, "--empty-password"] subprocess.call(command) # install mitmproxy certificate command = [ certutil, "-A", "-d", certdb, "-n", "mitmproxy-cert", "-t", "TC,,", "-a", "-i", cert, ] print("Installing {} into certificate database".format(cert)) subprocess.call(command) # verify certificate is installed command = [certutil, "-d", certdb, "-L"] assert "mitmproxy-cert" in subprocess.check_output(command) # setup device device = ADBAndroid() device.create_socket_connection("reverse", "tcp:8080", "tcp:8080") device_storage = "/sdcard/raptor" device_profile = os.path.join(device_storage, "profile") if device.is_dir(device_storage): device.rm(device_storage, recursive=True) device.mkdir(device_storage) device.mkdir(device_profile) userjs = os.path.join(profile.profile, "user.js") with open(userjs) as f: prefs = f.readlines() prefs = [p for p in prefs if "network.proxy" not in p] with open(userjs, "w") as f: f.writelines(prefs) proxy = { "network.proxy.type": 1, "network.proxy.http": "127.0.0.1", "network.proxy.http_port": 8080, "network.proxy.ssl": "127.0.0.1", "network.proxy.ssl_port": 8080, "network.proxy.no_proxies_on": "localhost, 127.0.0.1", } profile.set_preferences(proxy) device.push(profile.profile, device_profile) device.chmod(device_storage, recursive=True) app_args = [ "-profile", device_profile, "--marionette", "--es", "env0", "LOG_VERBOSE=1", "--es", "env1", "R_LOG_LEVEL=6", ] # start app app_name = "org.mozilla.geckoview_example" activity_name = "GeckoViewActivity" device.stop_application(app_name) device.launch_activity( app_name, activity_name, extra_args=app_args, url=url, e10s=True, fail_if_running=False, ) # wait for mitmdump to finish mitmdump_process.wait() finally: if mitmdump_process is None: mitmdump_process.terminate() exit(mitmdump_process.returncode)
def __init__(self, options, log): xpcshell.XPCShellTests.__init__(self, log) self.options = options verbose = False if options['log_tbpl_level'] == 'debug' or options[ 'log_mach_level'] == 'debug': verbose = True self.device = ADBAndroid(adb=options['adbPath'], device=options['deviceSerial'], test_root=options['remoteTestRoot'], verbose=verbose) self.remoteTestRoot = posixpath.join(self.device.test_root, "xpc") # Add Android version (SDK level) to mozinfo so that manifest entries # can be conditional on android_version. mozinfo.info['android_version'] = self.device.version self.localLib = options['localLib'] self.localBin = options['localBin'] self.pathMapping = [] # remoteBinDir contains xpcshell and its wrapper script, both of which must # be executable. Since +x permissions cannot usually be set on /mnt/sdcard, # and the test root may be on /mnt/sdcard, remoteBinDir is set to be on # /data/local, always. self.remoteBinDir = posixpath.join("/data", "local", "xpcb") # Terse directory names are used here ("c" for the components directory) # to minimize the length of the command line used to execute # xpcshell on the remote device. adb has a limit to the number # of characters used in a shell command, and the xpcshell command # line can be quite complex. self.remoteTmpDir = posixpath.join(self.remoteTestRoot, "tmp") self.remoteScriptsDir = self.remoteTestRoot self.remoteComponentsDir = posixpath.join(self.remoteTestRoot, "c") self.remoteModulesDir = posixpath.join(self.remoteTestRoot, "m") self.remoteMinidumpDir = posixpath.join(self.remoteTestRoot, "minidumps") self.remoteClearDirScript = posixpath.join(self.remoteBinDir, "cleardir") self.profileDir = posixpath.join(self.remoteTestRoot, "p") self.remoteDebugger = options['debugger'] self.remoteDebuggerArgs = options['debuggerArgs'] self.testingModulesDir = options['testingModulesDir'] self.env = {} if options['objdir']: self.xpcDir = os.path.join(options['objdir'], "_tests/xpcshell") elif os.path.isdir(os.path.join(here, 'tests')): self.xpcDir = os.path.join(here, 'tests') else: print("Couldn't find local xpcshell test directory", file=sys.stderr) sys.exit(1) if options['localAPK']: self.localAPKContents = ZipFile(options['localAPK']) if options['setup']: self.setupTestDir() self.setupUtilities() self.setupModules() self.setupMinidumpDir() self.remoteAPK = None if options['localAPK']: self.remoteAPK = posixpath.join( self.remoteBinDir, os.path.basename(options['localAPK'])) self.setAppRoot() # data that needs to be passed to the RemoteXPCShellTestThread self.mobileArgs = { 'device': self.device, 'remoteBinDir': self.remoteBinDir, 'remoteScriptsDir': self.remoteScriptsDir, 'remoteComponentsDir': self.remoteComponentsDir, 'remoteModulesDir': self.remoteModulesDir, 'options': self.options, 'remoteDebugger': self.remoteDebugger, 'pathMapping': self.pathMapping, 'profileDir': self.profileDir, 'remoteTmpDir': self.remoteTmpDir, 'remoteMinidumpDir': self.remoteMinidumpDir, 'remoteClearDirScript': self.remoteClearDirScript, } if self.remoteAPK: self.mobileArgs['remoteAPK'] = self.remoteAPK
def __init__(self, app, binary, run_local=False, obj_path=None, gecko_profile=False, gecko_profile_interval=None, gecko_profile_entries=None, symbols_path=None, host=None, is_release_build=False, debug_mode=False): self.config = {} self.config['app'] = app self.config['binary'] = binary self.config['platform'] = mozinfo.os self.config['processor'] = mozinfo.processor self.config['run_local'] = run_local self.config['obj_path'] = obj_path self.config['gecko_profile'] = gecko_profile self.config['gecko_profile_interval'] = gecko_profile_interval self.config['gecko_profile_entries'] = gecko_profile_entries self.config['symbols_path'] = symbols_path self.config['host'] = host self.config['is_release_build'] = is_release_build self.raptor_venv = os.path.join(os.getcwd(), 'raptor-venv') self.log = get_default_logger(component='raptor-main') self.control_server = None self.playback = None self.benchmark = None self.gecko_profiler = None self.post_startup_delay = 30000 # debug mode is currently only supported when running locally self.debug_mode = debug_mode if self.config['run_local'] else False # if running debug-mode reduce the pause after browser startup if self.debug_mode: self.post_startup_delay = 3000 self.log.info( "debug-mode enabled, reducing post-browser startup pause to %d ms" % self.post_startup_delay) # Create the profile; for geckoview we want a firefox profile type if self.config['app'] == 'geckoview': self.profile = create_profile('firefox') else: self.profile = create_profile(self.config['app']) # Clear any existing mozilla.cfg file to prevent earlier # runs using mitmproxy from interfering with settings. remove_autoconfig(binary) # Merge in base profiles with open(os.path.join(self.profile_data_dir, 'profiles.json'), 'r') as fh: base_profiles = json.load(fh)['raptor'] for name in base_profiles: path = os.path.join(self.profile_data_dir, name) self.log.info("Merging profile: {}".format(path)) self.profile.merge(path) # create results holder self.results_handler = RaptorResultsHandler() # when testing desktop browsers we use mozrunner to start the browser; when # testing on android (i.e. geckoview) we use mozdevice to control the device app if self.config['app'] == "geckoview": # create the android device handler; it gets initiated and sets up adb etc self.log.info("creating android device handler using mozdevice") self.device = ADBAndroid(verbose=True) self.device.clear_logcat() else: # create the desktop browser runner self.log.info("creating browser runner using mozrunner") self.output_handler = OutputHandler() process_args = { 'processOutputLine': [self.output_handler], } runner_cls = runners[app] self.runner = runner_cls(binary, profile=self.profile, process_args=process_args) self.log.info("raptor config: %s" % str(self.config))
def __init__(self, options, scriptDir): RefTest.__init__(self, options.suite) self.run_by_manifest = False self.scriptDir = scriptDir self.localLogName = options.localLogName verbose = False if options.log_tbpl_level == 'debug' or options.log_mach_level == 'debug': verbose = True print "set verbose!" self.device = ADBAndroid(adb=options.adb_path, device=options.deviceSerial, test_root=options.remoteTestRoot, verbose=verbose) if options.remoteTestRoot is None: options.remoteTestRoot = posixpath.join(self.device.test_root, "reftest") options.remoteProfile = posixpath.join(options.remoteTestRoot, "profile") options.remoteLogFile = posixpath.join(options.remoteTestRoot, "reftest.log") options.logFile = options.remoteLogFile self.remoteProfile = options.remoteProfile self.remoteTestRoot = options.remoteTestRoot if not options.ignoreWindowSize: parts = self.device.get_info('screen')['screen'][0].split() width = int(parts[0].split(':')[1]) height = int(parts[1].split(':')[1]) if (width < 1366 or height < 1050): self.error("ERROR: Invalid screen resolution %sx%s, " "please adjust to 1366x1050 or higher" % (width, height)) self._populate_logger(options) self.outputHandler = OutputHandler(self.log, options.utilityPath, options.symbolsPath) # RemoteAutomation.py's 'messageLogger' is also used by mochitest. Mimic a mochitest # MessageLogger object to re-use this code path. self.outputHandler.write = self.outputHandler.__call__ self.automation = RemoteAutomation(self.device, options.app, self.remoteProfile, options.remoteLogFile, processArgs=None) self.automation._processArgs['messageLogger'] = self.outputHandler self.environment = self.automation.environment if self.automation.IS_DEBUG_BUILD: self.SERVER_STARTUP_TIMEOUT = 180 else: self.SERVER_STARTUP_TIMEOUT = 90 self.remoteCache = os.path.join(options.remoteTestRoot, "cache/") # Check that Firefox is installed expected = options.app.split('/')[-1] if not self.device.is_app_installed(expected): raise Exception("%s is not installed on this device" % expected) self.automation.deleteANRs() self.automation.deleteTombstones() self.device.clear_logcat() self.device.rm(self.remoteCache, force=True, recursive=True) procName = options.app.split('/')[-1] self.device.pkill(procName) if self.device.process_exist(procName): self.log.error("unable to kill %s before starting tests!" % procName)
def _install(self, dest): self.adb = ADBAndroid() self.adb.uninstall_app("org.mozilla.fennec") self.adb.install_app(dest) # get info now, as dest may be removed self.app_info = mozversion.get_version(binary=dest)