def get_marionette(self):
if not self.m:
self.m = Marionette(port=self.port)
self.m.start_session()
self.device = GaiaDevice(self.m)
self.device.add_device_manager(self.dm)
self.gaia_apps = GaiaApps(self.m)
else:
tries = 5
while tries > 0:
try:
self.m.get_url()
break
except MarionetteException as e:
if "Please start a session" in str(e):
time.sleep(5)
self.m = Marionette(port=self.port)
self.m.start_session()
self.device = GaiaDevice(self.m)
self.device.add_device_manager(self.dm)
self.gaia_apps = GaiaApps(self.m)
tries -= 1
else:
raise e
else:
self.run_log.error("Can't connect to marionette, rebooting")
self.restart_device()
return self.m
def start_marionette(self):
assert (self.baseurl is not None)
if self.address:
host, port = self.address.split(':')
if self.emulator:
self.marionette = Marionette(host=host,
port=int(port),
connectToRunningEmulator=True,
homedir=self.homedir,
baseurl=self.baseurl,
logcat_dir=self.logcat_dir)
if self.b2gbin:
self.marionette = Marionette(host=host,
port=int(port),
b2gbin=self.b2gbin,
baseurl=self.baseurl)
else:
self.marionette = Marionette(host=host,
port=int(port),
baseurl=self.baseurl)
elif self.emulator:
self.marionette = Marionette(emulator=self.emulator,
emulatorBinary=self.emulatorBinary,
homedir=self.homedir,
baseurl=self.baseurl,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir)
else:
raise Exception("must specify address or emulator")
def get_marionette(self):
if not self.m:
self.m = Marionette(port=self.port)
self.m.start_session()
self.device = GaiaDevice(self.m)
self.device.add_device_manager(self.dm)
self.gaia_apps = GaiaApps(self.m)
else:
tries = 5
while tries > 0:
try:
self.m.get_url()
break
except MarionetteException as e:
if "Please start a session" in str(e):
time.sleep(5)
self.m = Marionette(port=self.port)
self.m.start_session()
self.device = GaiaDevice(self.m)
self.device.add_device_manager(self.dm)
self.gaia_apps = GaiaApps(self.m)
tries -= 1
else:
raise e
else:
self.run_log.error("Can't connect to marionette, rebooting")
self.restart_device()
return self.m
def setup(self):
try:
self.client = Marionette(host='localhost', port=2828)
self.client.start_session()
self.client.set_pref('general.warnOnAboutConfig', False)
except:
sys.exit("Could not find Firefox browser running")
def cli():
parser = OptionParser(usage='%prog gaia_atoms_path app_name [app_name] ...')
options, args = parser.parse_args()
if not args:
parser.print_usage()
parser.exit()
if not os.path.isdir(args[0]):
parser.print_usage()
print 'must specify valid path for gaia atoms'
parser.exit()
if len(args) != 2:
parser.print_usage()
print 'must specify at one app name'
parser.exit()
marionette = Marionette(host='localhost', port=2828) # TODO command line option for address
marionette.start_session()
launchApp(
marionette,
gaia_atoms=args[0],
app_name=args[1])
def start_marionette(self):
assert(self.baseurl is not None)
if self.bin:
if self.address:
host, port = self.address.split(':')
else:
host = 'localhost'
port = 2828
self.marionette = Marionette(host=host, port=int(port),
bin=self.bin, profile=self.profile,
baseurl=self.baseurl)
elif self.address:
host, port = self.address.split(':')
if self.emulator:
self.marionette = Marionette(host=host, port=int(port),
connectToRunningEmulator=True,
homedir=self.homedir,
baseurl=self.baseurl,
logcat_dir=self.logcat_dir)
else:
self.marionette = Marionette(host=host,
port=int(port),
baseurl=self.baseurl)
elif self.emulator:
self.marionette = Marionette(emulator=self.emulator,
emulatorBinary=self.emulatorBinary,
emulatorImg=self.emulatorImg,
emulator_res=self.emulator_res,
homedir=self.homedir,
baseurl=self.baseurl,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir)
else:
raise Exception("must specify binary, address or emulator")
def run_marionette(self, dir):
self.logger.info("Starting test run")
# Start up marionette
m = Marionette(emulator=True, homedir=dir)
assert m.start_session()
for test in self.testlist:
run_test(test, m)
m.delete_session()
def get_new_emulator(self):
_qemu = Marionette(emulator=True,
homedir=self.marionette.homedir,
baseurl=self.marionette.baseurl,
noWindow=self.marionette.noWindow)
_qemu.start_session()
self._qemu.append(_qemu)
return _qemu
def get_new_emulator(self):
_qemu = Marionette(emulator=True,
homedir=self.marionette.homedir,
baseurl=self.marionette.baseurl,
noWindow=self.marionette.noWindow)
_qemu.start_session()
self._qemu.append(_qemu)
return _qemu
def unplug_and_instruct(self, message):
self.instruct(
"Unplug the phone.\n%s\nPlug the phone back in after you are "
"done, and unlock the screen if necessary.\n" % message)
dm = mozdevice.DeviceManagerADB()
dm.forward("tcp:2828", "tcp:2828")
self.marionette = Marionette()
self.marionette.start_session()
self.use_cert_app()
def run_marionette_script(self):
self.marionette = Marionette(**self.marionette_args)
assert (self.marionette.wait_for_port())
self.marionette.start_session()
self.marionette.set_context(self.marionette.CONTEXT_CHROME)
if os.path.isfile(self.test_script):
f = open(self.test_script, 'r')
self.test_script = f.read()
f.close()
self.marionette.execute_script(self.test_script)
def create_marionette():
"""Creates a new Marionette session if one does not exist."""
m = TestCase.stored.marionette
if not m:
m = Marionette()
m.start_session()
TestCase.stored.marionette = m
return TestCase.stored.marionette
def __init__(self, **kwargs):
# Added parser
parser = OptionParser()
parser.add_option(
'-a',
'--address',
action='store',
type='string',
dest='address',
default='localhost',
help='The host address of b2g instance. Default=localhost')
parser.add_option('-p',
'--port',
action='store',
type='int',
dest='port',
default=2828,
help='The port of b2g instance.')
parser.add_option('-l',
'--list',
action='store_true',
dest='enable_list',
default='False',
help='List all apps of b2g instance. Default=False')
parser.add_option('-c', '--connect',
action='store', type='string', dest='connect',
default=None,
help='Connect to the App iframe.' \
'Use # ID or App URL to connect.')
(options, args) = parser.parse_args()
self.connect = options.connect
# start marionette session
self.m = Marionette(options.address, options.port)
self.m.start_session()
# list all iframes
if options.enable_list:
self.list_all_iframes()
# list active iframes
elif self.connect == None:
self.list_active_iframes()
# connect to App
if self.connect == None:
exit(0)
else:
# connect App
print 'Start...'
if self.open_app(self.connect):
self.start_js()
else:
exit(-1)
def __init__(self, app_name, app_id, device=False):
self.device = device
if self.device:
call(['adb', 'forward', 'tcp:2828', 'tcp:2828'])
self._app_name = app_name
self._app_id = app_id
self._marionette = Marionette()
self._marionette.start_session()
self._gaia_apps = GaiaApps(self._marionette)
self._gaia_data = GaiaData(self._marionette)
self._gaia_device = GaiaDevice(self._marionette)
''' Deprecated
def get_new_emulator(self):
self.extra_emulator_index += 1
if len(self.marionette.extra_emulators) == self.extra_emulator_index:
qemu = Marionette(emulator=self.marionette.emulator.arch,
homedir=self.marionette.homedir,
baseurl=self.marionette.baseurl,
noWindow=self.marionette.noWindow)
qemu.start_session()
self.marionette.extra_emulators.append(qemu)
else:
qemu = self.marionette.extra_emulators[self.extra_emulator_index]
return qemu
def get_marionette(args):
mc = Marionette('localhost', args.adb_port)
for i in range(3):
try:
mc.start_session()
break
# Catching SystemExit because tracebacks are suppressed.
# This won't be necessary after
# https://bugzilla.mozilla.org/show_bug.cgi?id=863377
except (socket.error, SystemExit):
sh('adb forward tcp:%s tcp:%s' % (args.adb_port, args.adb_port))
return mc
def start_marionette(self):
assert(self.baseurl is not None)
if self.bin:
if self.address:
host, port = self.address.split(':')
else:
host = 'localhost'
port = 2828
self.marionette = Marionette(host=host,
port=int(port),
app=self.app,
bin=self.bin,
profile=self.profile,
baseurl=self.baseurl,
timeout=self.timeout)
elif self.address:
host, port = self.address.split(':')
try:
#establish a telnet connection so we can vertify the data come back
tlconnection = Telnet(host, port)
except:
raise Exception("could not connect to given marionette host/port")
if self.emulator:
self.marionette = Marionette.getMarionetteOrExit(
host=host, port=int(port),
connectToRunningEmulator=True,
homedir=self.homedir,
baseurl=self.baseurl,
logcat_dir=self.logcat_dir,
gecko_path=self.gecko_path,
symbols_path=self.symbols_path,
timeout=self.timeout)
else:
self.marionette = Marionette(host=host,
port=int(port),
baseurl=self.baseurl,
timeout=self.timeout)
elif self.emulator:
self.marionette = Marionette.getMarionetteOrExit(
emulator=self.emulator,
emulatorBinary=self.emulatorBinary,
emulatorImg=self.emulatorImg,
emulator_res=self.emulator_res,
homedir=self.homedir,
baseurl=self.baseurl,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
gecko_path=self.gecko_path,
symbols_path=self.symbols_path,
timeout=self.timeout)
else:
raise Exception("must specify binary, address or emulator")
def get_marionette(args):
mc = Marionette('localhost', args.adb_port)
for i in range(3):
try:
mc.start_session()
break
# Catching SystemExit because tracebacks are suppressed.
# This won't be necessary after
# https://bugzilla.mozilla.org/show_bug.cgi?id=863377
except (socket.error, SystemExit):
sh('adb forward tcp:%s tcp:%s' % (args.adb_port, args.adb_port))
return mc
def ftu_toggler(skip_ftu=True):
dm = mozdevice.DeviceManagerADB(runAdbAsRoot=True)
dm.forward("tcp:2828", "tcp:2828")
m = Marionette()
m.start_session()
data_layer = GaiaData(m)
url = "null" if skip_ftu else "app://ftu.gaiamobile.org/manifest.webapp"
data_layer.set_setting('ftu.manifestURL', url)
m.close()
# restart b2g to enable
dm.reboot()
def startMarionette():
# FW port for ADB via USB
return_code = subprocess.call(["adb root"], shell=True)
if return_code:
raise Exception("Failed to start adb in root mode. Ensure device is attached to USB.")
return_code = subprocess.call(["adb forward tcp:2828 tcp:2828"], shell=True)
if return_code:
raise Exception("Failed to connect to device via ADB; ensure device is attached to USB.")
# Start Marionette
marionette = Marionette(host='localhost', port=2828)
marionette.start_session()
marionette.set_script_timeout(60000)
return marionette
def get_new_emulator(self):
self.extra_emulator_index += 1
if len(self.marionette.extra_emulators) == self.extra_emulator_index:
qemu = Marionette(emulator=self.marionette.emulator.arch,
emulatorBinary=self.marionette.emulator.binary,
homedir=self.marionette.homedir,
baseurl=self.marionette.baseurl,
noWindow=self.marionette.noWindow)
qemu.start_session()
self.marionette.extra_emulators.append(qemu)
else:
qemu = self.marionette.extra_emulators[self.extra_emulator_index]
return qemu
def execute(self):
self.marionette.cleanup()
self.marionette = Marionette(device_serial=self.serial, port=self.port)
self.marionette.wait_for_port()
# run test runner here
self.remove_settings_opt()
self.kwargs = {}
if self.port:
self.kwargs['address'] = "localhost:" + str(self.port)
logger.info("Using address[localhost:" + str(self.port) + "]")
self.start_monitoring()
self.mtbf_daily()
self.run_mtbf()
self.stop_monitoring()
def run_marionette_script(self):
self.marionette = Marionette(**self.marionette_args)
assert (self.marionette.wait_for_port())
self.marionette.start_session()
if self.build_type == "mulet":
self._wait_for_homescreen(timeout=15)
self._unlockScreen()
self.marionette.set_context(self.marionette.CONTEXT_CHROME)
if os.path.isfile(self.test_script):
f = open(self.test_script, 'r')
self.test_script = f.read()
f.close()
self.marionette.execute_script(self.test_script)
def create_marionette():
"""Returns current Marionette session, or creates one if
one does not exist.
"""
m = TestCase.stored.marionette
if m is None:
m = Marionette()
m.wait_for_port()
m.start_session()
TestCase.stored.marionette = m
return TestCase.stored.marionette
def restart_b2g(self):
#restart b2g so we start with a clean slate
self.dm.checkCmd(['shell', 'stop', 'b2g'])
# Wait for a bit to make sure B2G has completely shut down.
time.sleep(10)
self.dm.checkCmd(['shell', 'start', 'b2g'])
#wait for marionette port to come up
if not self.wait_for_port(30000):
raise Exception(
"Could not communicate with Marionette port after restarting B2G"
)
self.marionette = Marionette(self.marionette_host,
self.marionette_port)
def setupMarionette(self):
"""
Start a marionette session.
If no host is given, then this will get the ip
of the device, and set up networking if needed.
"""
if not self.marionetteHost:
self.setupDHCP()
self.marionetteHost = self.getIP()
if not self.marionette:
self.marionette = Marionette(self.marionetteHost,
self.marionettePort)
if not self.marionette.session:
self.waitForPort(30)
self.marionette.start_session()
def run_desktop_mochitests(parser, options):
automation = B2GDesktopAutomation()
# create our Marionette instance
kwargs = {}
if options.marionette:
host, port = options.marionette.split(':')
kwargs['host'] = host
kwargs['port'] = int(port)
marionette = Marionette.getMarionetteOrExit(**kwargs)
automation.marionette = marionette
mochitest = B2GDesktopMochitest(automation)
# b2g desktop builds don't always have a b2g-bin file
if options.app[-4:] == '-bin':
options.app = options.app[:-4]
options = MochitestOptions.verifyOptions(parser, options, mochitest)
if options == None:
sys.exit(1)
if options.desktop and not options.profile:
raise Exception("must specify --profile when specifying --desktop")
automation.setServerInfo(options.webServer,
options.httpPort,
options.sslPort,
options.webSocketPort)
sys.exit(mochitest.runTests(options,
onLaunch=mochitest.startTests))
def restart_device(self, restart_tries=0):
self.run_log.info("rebooting")
# TODO restarting b2g doesn't seem to work... reboot then
while restart_tries < 3:
restart_tries += 1
self.dm.reboot(wait=True)
self.run_log.info("forwarding")
if not self.forward_port():
self.run_log.error("couldn't forward port in time, rebooting")
continue
self.m = Marionette(port=self.port)
if not self.m.wait_for_port(180):
self.run_log.error("couldn't contact marionette in time, rebooting")
continue
time.sleep(1)
self.m.start_session()
try:
Wait(self.m, timeout=240).until(lambda m: m.find_element("id", "lockscreen-container").is_displayed())
# It retuns a little early
time.sleep(2)
self.device = GaiaDevice(self.m)
self.device.add_device_manager(self.dm)
self.device.unlock()
self.gaia_apps = GaiaApps(self.m)
except (MarionetteException, IOError, socket.error) as e:
self.run_log.error("got exception: %s, going to retry" % e)
try:
self.m.delete_session()
except:
# at least attempt to clear the session if possible
pass
continue
break
else:
raise Exception("Couldn't restart the device in time, even after 3 tries")
def run_desktop_mochitests(parser, options):
# create our Marionette instance
kwargs = {}
if options.marionette:
host, port = options.marionette.split(':')
kwargs['host'] = host
kwargs['port'] = int(port)
marionette = Marionette.getMarionetteOrExit(**kwargs)
mochitest = B2GDesktopMochitest(marionette, options.profile_data_dir)
# add a -bin suffix if b2g-bin exists, but just b2g was specified
if options.app[-4:] != '-bin':
if os.path.isfile("%s-bin" % options.app):
options.app = "%s-bin" % options.app
options = MochitestOptions.verifyOptions(parser, options, mochitest)
if options == None:
sys.exit(1)
if options.desktop and not options.profile:
raise Exception("must specify --profile when specifying --desktop")
options.browserArgs += ['-marionette']
sys.exit(mochitest.runTests(options, onLaunch=mochitest.startTests))
def run_desktop_mochitests(parser, options):
automation = B2GDesktopAutomation()
# create our Marionette instance
kwargs = {}
if options.marionette:
host, port = options.marionette.split(':')
kwargs['host'] = host
kwargs['port'] = int(port)
marionette = Marionette.getMarionetteOrExit(**kwargs)
automation.marionette = marionette
mochitest = B2GDesktopMochitest(automation, options)
# b2g desktop builds don't always have a b2g-bin file
if options.app[-4:] == '-bin':
options.app = options.app[:-4]
options = MochitestOptions.verifyOptions(parser, options, mochitest)
if options == None:
sys.exit(1)
if options.desktop and not options.profile:
raise Exception("must specify --profile when specifying --desktop")
automation.setServerInfo(options.webServer, options.httpPort,
options.sslPort, options.webSocketPort)
sys.exit(mochitest.runTests(options, onLaunch=mochitest.startTests))
def setup(self):
try:
self.client = Marionette(host='localhost', port=2828)
self.client.start_session()
self.client.set_pref('general.warnOnAboutConfig', False)
except:
sys.exit("Could not find Firefox browser running")
def _StartProcess(self):
if not self.isEmulatorInitialized:
print("Starting Emulator ...")
self.emulatorProcess = subprocess.Popen(
[self.emulatorStartScript], cwd=os.path.dirname(self.emulatorStartScript), shell=True)
# adb shell setprop net.dns1 10.0.2.3
self._isBootFinished()
self.monitoringProcessId = self.adb.getPID(self.monitoredProcessName)
print("Forwarding TCP port %d ..." % self.forwardedPortADB)
self.adb.command(["forward", "tcp:%d" % self.forwardedPortADB, "tcp:%d" % self.forwardedPortADB])
self.isEmulatorInitialized = True
time.sleep(20)
if self.crashSuccess:
print("Restarting %s ..." % self.monitoredProcessName)
self.adb.killProcess(self.monitoredProcessName, True)
time.sleep(40)
self.monitoringProcessId = self.adb.getPID(self.monitoredProcessName)
self.crashSuccess = False
self.debugLogData = str()
self.adb.checkCmd(["logcat", "-c"])
print("Starting Marionette session ...")
marionette = Marionette('localhost', self.forwardedPortADB)
print(marionette.status())
marionette.start_session()
marionette.set_script_timeout(self.scriptTimeout)
marionette.switch_to_frame()
lock = gaia.LockScreen(marionette)
lock.unlock()
apps = gaia.GaiaApps(marionette)
print(apps.runningApps())
print("Launching Browser application")
apps.launch(self.appName, switch_to_frame=True)
print("Navigating to %s ..." % self.publisherURL)
marionette.execute_script("return window.wrappedJSObject.Browser.navigate('%s')" % self.publisherURL)
self.isMonitorInitialized = True
def main():
parser = B2GOptions()
options, args = parser.parse_args()
options = parser.verifyRemoteOptions(options)
# Create the Marionette instance
kwargs = {}
if options.emulator:
kwargs['emulator'] = options.emulator
if options.no_window:
kwargs['noWindow'] = True
if options.geckoPath:
kwargs['gecko_path'] = options.geckoPath
if options.logcat_dir:
kwargs['logcat_dir'] = options.logcat_dir
if options.busybox:
kwargs['busybox'] = options.busybox
if options.symbolsPath:
kwargs['symbols_path'] = options.symbolsPath
if options.b2g_path:
kwargs['homedir'] = options.emu_path or options.b2g_path
if options.address:
host, port = options.address.split(':')
kwargs['host'] = host
kwargs['port'] = int(port)
kwargs['baseurl'] = 'http://%s:%d/' % (host, int(port))
if options.emulator:
kwargs['connectToRunningEmulator'] = True
marionette = Marionette(**kwargs)
if options.emulator:
dm = marionette.emulator.dm
else:
# Create the DeviceManager instance
kwargs = {'adbPath': options.adb_path}
if options.deviceIP:
kwargs['host'] = options.deviceIP
kwargs['port'] = options.devicePort
kwargs['deviceRoot'] = options.remoteTestRoot
dm = devicemanagerADB.DeviceManagerADB(**kwargs)
if not options.remoteTestRoot:
options.remoteTestRoot = dm.getDeviceRoot()
xpcsh = B2GXPCShellRemote(dm, options, args)
# we don't run concurrent tests on mobile
options.sequential = True
try:
if not xpcsh.runTests(xpcshell='xpcshell',
testdirs=args[0:],
testClass=B2GXPCShellTestThread,
mobileArgs=xpcsh.mobileArgs,
**options.__dict__):
sys.exit(1)
except:
print "Automation Error: Exception caught while running tests"
traceback.print_exc()
sys.exit(1)
def setupMarionette(self, scriptTimeout=60000):
"""
Starts a marionette session.
If no host was given at init, the ip of the device will be retrieved
and networking will be established.
"""
if not self.marionetteHost:
self.setupDHCP()
self.marionetteHost = self.getIP()
if not self.marionette:
self.marionette = Marionette(self.marionetteHost,
self.marionettePort)
if not self.marionette.session:
self.waitForPort(30)
self.marionette.start_session()
self.marionette.set_script_timeout(scriptTimeout)
def init():
ret = subprocess.check_output("adb devices", shell=True)
print(ret)
## TODO: find more error handling if available
import socket
s = socket.socket()
try:
s.bind(("localhost", 2828))
s.close()
ret = subprocess.check_output("adb forward tcp:2828 tcp:2828",
shell=True)
except socket.error:
print("address already in use")
mar = Marionette()
mar.start_session()
return mar
def main():
scriptdir = os.path.abspath(os.path.realpath(os.path.dirname(__file__)))
auto = B2GRemoteAutomation(None, "fennec")
parser = B2GOptions(auto, scriptdir)
options, args = parser.parse_args()
# create our Marionette instance
kwargs = {'emulator': options.emulator}
if options.b2gPath:
kwargs['homedir'] = options.b2gPath
if options.marionette:
host,port = options.marionette.split(':')
kwargs['host'] = host
kwargs['port'] = int(port)
marionette = Marionette(**kwargs)
auto.marionette = marionette
# create the DeviceManager
kwargs = {'adbPath': options.adbPath}
if options.deviceIP:
kwargs.update({'host': options.deviceIP,
'port': options.devicePort})
dm = devicemanagerADB.DeviceManagerADB(**kwargs)
auto.setDeviceManager(dm)
options = parser.verifyRemoteOptions(options, auto)
if (options == None):
print "ERROR: Invalid options specified, use --help for a list of valid options"
sys.exit(1)
auto.setProduct("b2g")
mochitest = B2GMochitest(auto, dm, options)
options = parser.verifyOptions(options, mochitest)
if (options == None):
sys.exit(1)
logParent = os.path.dirname(options.remoteLogFile)
dm.mkDir(logParent);
auto.setRemoteLog(options.remoteLogFile)
auto.setServerInfo(options.webServer, options.httpPort, options.sslPort)
retVal = 1
try:
retVal = mochitest.runTests(options)
except:
print "TEST-UNEXPECTED-FAIL | %s | Exception caught while running tests." % sys.exc_info()[1]
mochitest.stopWebServer(options)
mochitest.stopWebSocketServer(options)
try:
mochitest.cleanup(None, options)
except:
pass
sys.exit(1)
sys.exit(retVal)
def start_marionette(self):
assert (self.baseurl is not None)
if self.bin:
if self.address:
host, port = self.address.split(':')
else:
host = 'localhost'
port = 2828
self.marionette = Marionette(host=host,
port=int(port),
app=self.app,
app_args=self.app_args,
bin=self.bin,
profile=self.profile,
baseurl=self.baseurl,
timeout=self.timeout,
device_serial=self.device_serial)
elif self.address:
host, port = self.address.split(':')
try:
#establish a socket connection so we can vertify the data come back
connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
connection.connect((host, int(port)))
connection.close()
except Exception, e:
raise Exception(
"Could not connect to given marionette host:port: %s" % e)
if self.emulator:
self.marionette = Marionette.getMarionetteOrExit(
host=host,
port=int(port),
connectToRunningEmulator=True,
homedir=self.homedir,
baseurl=self.baseurl,
logcat_dir=self.logcat_dir,
gecko_path=self.gecko_path,
symbols_path=self.symbols_path,
timeout=self.timeout,
device_serial=self.device_serial)
else:
self.marionette = Marionette(host=host,
port=int(port),
baseurl=self.baseurl,
timeout=self.timeout,
device_serial=self.device_serial)
def init():
ret = subprocess.check_output("adb devices", shell=True)
if("unagi" in ret):
print(ret)
else:
print("No unagi connected")
sys.exit(1)
import socket
s = socket.socket()
try:
s.bind(("localhost", 2828))
s.close()
ret = subprocess.check_output("adb forward tcp:2828 tcp:2828", shell=True)
except socket.error:
print("address already in use")
mar = Marionette()
mar.start_session()
return mar
def run(self, args=sys.argv[1:]):
args = self.parser.parse_args()
host, port = args.address.split(':')
self.marionette = Marionette(host=host, port=int(port))
self.marionette.start_session()
self.apps = gaiatest.GaiaApps(self.marionette)
self.data_layer = gaiatest.GaiaData(self.marionette)
self.lock_screen = gaiatest.LockScreen(self.marionette)
ret = args.func(args)
if ret is None:
ret = 0
self.marionette.delete_session()
sys.exit(ret)
def setup(self):
if not self.serial or not self.port:
logger.error("Fail to get device")
raise DMError
self.config_raptor()
self.marionette and self.marionette.session and self.marionette.cleanup(
)
self.dm = mozdevice.DeviceManagerADB(deviceSerial=self.serial,
port=self.port)
self.marionette = Marionette(device_serial=self.serial, port=self.port)
self.marionette.wait_for_port()
self.marionette.start_session()
self.device = GaiaDevice(marionette=self.marionette, manager=self.dm)
self.apps = GaiaApps(self.marionette)
self.data_layer = GaiaData(self.marionette)
if self.flashed:
self.device.wait_for_b2g_ready()
def startTests(self):
# This is run in a separate thread because otherwise, the app's
# stdout buffer gets filled (which gets drained only after this
# function returns, by waitForFinish), which causes the app to hang.
self.marionette = Marionette(**self.marionette_args)
thread = threading.Thread(target=self.runMarionetteScript,
args=(self.marionette, self.test_script,
self.test_script_args))
thread.start()
def init():
ret = subprocess.check_output("adb devices", shell=True)
# if("unagi" in ret):
# print(ret)
# else:
# print("No unagi connected")
# sys.exit(1)
import socket
s = socket.socket()
try:
s.bind(("localhost", 2828))
s.close()
ret = subprocess.check_output("adb forward tcp:2828 tcp:2828", shell=True)
except socket.error:
print("address already in use")
mar = Marionette()
mar.start_session()
return mar
def unplug_and_instruct(self, message):
self.instruct(
"Unplug the phone.\n%s\nPlug the phone back in after you are "
"done, and unlock the screen if necessary.\n" % message)
dm = mozdevice.DeviceManagerADB()
dm.forward("tcp:2828", "tcp:2828")
self.marionette = Marionette()
self.marionette.start_session()
self.use_cert_app()
def start_marionette(self):
assert(self.baseurl is not None)
if self.bin:
if self.address:
host, port = self.address.split(':')
else:
host = 'localhost'
port = 2828
self.marionette = Marionette(host=host,
port=int(port),
app=self.app,
bin=self.bin,
profile=self.profile,
baseurl=self.baseurl)
elif self.address:
host, port = self.address.split(':')
if self.emulator:
self.marionette = Marionette.getMarionetteOrExit(
host=host, port=int(port),
connectToRunningEmulator=True,
homedir=self.homedir,
baseurl=self.baseurl,
logcat_dir=self.logcat_dir,
gecko_path=self.gecko_path,
symbols_path=self.symbols_path)
else:
self.marionette = Marionette(host=host,
port=int(port),
baseurl=self.baseurl)
elif self.emulator:
self.marionette = Marionette.getMarionetteOrExit(
emulator=self.emulator,
emulatorBinary=self.emulatorBinary,
emulatorImg=self.emulatorImg,
emulator_res=self.emulator_res,
homedir=self.homedir,
baseurl=self.baseurl,
noWindow=self.noWindow,
logcat_dir=self.logcat_dir,
gecko_path=self.gecko_path,
symbols_path=self.symbols_path)
else:
raise Exception("must specify binary, address or emulator")
def init():
ret = subprocess.check_output("adb devices", shell=True)
print(ret)
## TODO: find more error handling if available
import socket
s = socket.socket()
try:
s.bind(("localhost", 2828))
s.close()
ret = subprocess.check_output(
"adb forward tcp:2828 tcp:2828",
shell=True
)
except socket.error:
print("address already in use")
mar = Marionette()
mar.start_session()
return mar
def restart_b2g(self):
#restart b2g so we start with a clean slate
self.dm.checkCmd(['shell', 'stop', 'b2g'])
# Wait for a bit to make sure B2G has completely shut down.
time.sleep(10)
self.dm.checkCmd(['shell', 'start', 'b2g'])
#wait for marionette port to come up
if not self.wait_for_port(30000):
raise Exception("Could not communicate with Marionette port after restarting B2G")
self.marionette = Marionette(self.marionette_host, self.marionette_port)
def run_marionette_script(self):
self.marionette = Marionette(**self.marionette_args)
assert(self.marionette.wait_for_port())
self.marionette.start_session()
self.marionette.set_context(self.marionette.CONTEXT_CHROME)
if os.path.isfile(self.test_script):
f = open(self.test_script, 'r')
self.test_script = f.read()
f.close()
self.marionette.execute_script(self.test_script)
def __init__(self, app_name, app_id, device=False):
self.device = device
if self.device:
call(['adb', 'forward', 'tcp:2828', 'tcp:2828'])
self._app_name = app_name
self._app_id = app_id
self._marionette = Marionette()
self._marionette.start_session()
self._gaia_apps = GaiaApps(self._marionette)
self._gaia_data = GaiaData(self._marionette)
self._gaia_device = GaiaDevice(self._marionette)
''' Deprecated
def execute(self):
self.marionette.cleanup()
self.marionette = Marionette(device_serial=self.serial, port=self.port)
self.marionette.wait_for_port()
# run test runner here
self.remove_settings_opt()
self.kwargs = {}
if self.port:
self.kwargs['address'] = "localhost:" + str(self.port)
logger.info("Using address[localhost:" + str(self.port) + "]")
self.mtbf_daily()
self.run_mtbf()
def setup(self):
if not self.serial or not self.port:
logger.error("Fail to get device")
raise DMError
self.marionette and self.marionette.session and self.marionette.cleanup()
self.dm = mozdevice.DeviceManagerADB(deviceSerial=self.serial, port=self.port)
self.marionette = Marionette(device_serial=self.serial, port=self.port)
self.marionette.start_session()
self.device = GaiaDevice(marionette=self.marionette, manager=self.dm)
self.apps = GaiaApps(self.marionette)
self.data_layer = GaiaData(self.marionette)
self.device.wait_for_b2g_ready()
def _StartProcess(self):
if not self.isDeviceInitialized:
print("Starting ...")
self.monitoringProcessId = self.adb.getPID(self.monitoredProcessName)
print("Forwarding TCP port %d ..." % self.forwardedPortADB)
self.adb.command(["forward", "tcp:%d" % self.forwardedPortADB, "tcp:%d" % self.forwardedPortADB])
self.isDeviceInitialized = True
print("Sleeping ...")
time.sleep(20)
if self.crashSuccess:
print("Restarting %s" % self.monitoredProcessName)
self.adb.killProcess(self.monitoredProcessName, True)
time.sleep(40)
self.monitoringProcessId = self.adb.getPID(self.monitoredProcessName)
self.crashSuccess = False
self.debugLogData = str()
self.adb.checkCmd(["logcat", "-c"])
print("Starting Marionette session")
marionette = Marionette('localhost', self.forwardedPortADB)
print(marionette.status())
marionette.start_session()
marionette.set_script_timeout(self.scriptTimeout)
marionette.switch_to_frame()
lock = gaia.LockScreen(marionette)
assert(lock.unlock())
apps = gaia.GaiaApps(marionette)
print(apps.runningApps())
print("Launching Browser application")
apps.launch(self.appName, switch_to_frame=True)
print("Navigating to %s ..." % self.publisherURL)
marionette.execute_script("return window.wrappedJSObject.Browser.navigate('%s')" % self.publisherURL)
self.isMonitorInitialized = True
def start(self):
'''
This method starts MATS.
'''
print 'Using ' + MatsController.__name__ + ' as controller.'
print 'Loading config from "' + self.config_file + '"...',
self.config = get_config(self.config_file) #get_config makes sure that the config makes sense. More details in get_config.py
self.marionette_port = self.config['Marionette']['port']
print 'OK'
print 'Starting Firefox/Nightly from "' + self.config['Firefox']['binary'] + '" with Marionette on port ' + str(self.marionette_port) + '.'
self.FirefoxThread = FirefoxThread(self.config['Firefox']['binary'], self.marionette_port)
self.FirefoxThread.start()
print 'Creating controller'
pid = self.FirefoxThread.getPID() # this function blocks until PID is available from FirefoxThread
self.controller = MatsController(pid)
print 'Starting controller'
self.controller.start()
self.controller.wait_for_ready()
print 'Waiting for Marionette port to open (' + str(self.marionette_port) + ')'
portReady = self.FirefoxThread.waitForMarionettePortOpenReady(self.config['Marionette']['port_timeout'])
if portReady:
print 'Marionette port open'
else:
print 'Error: timeout, shutting down MATS'
self.controller.stop()
self.FirefoxThread.stop()
return
#TODO: remove line below once https://bugzilla.mozilla.org/show_bug.cgi?id=753273 is fixed
#sleep(10)
try:
print 'Starting Marionette'
self.marionette = Marionette('localhost', self.marionette_port)
#TODO: move starting session and navigation to separate methods
print 'Starting session'
sleep(5) #TODO temporary workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=757078
self.marionette_session = self.marionette.start_session()
print 'Navigating to ' + self.url
print self.marionette.navigate(self.url)
except Exception as e:
print 'Error starting Marionette'
fall(e)
self.controller.stop()
self.FirefoxThread.stop()
print 'MATS up and running. Waiting until Firefox/Nightly stops.'
def main():
parser = B2GOptions()
options, args = parser.parse_args()
if options.objdir is None:
try:
options.objdir = os.path.join(options.b2g_path, 'objdir-gecko')
except:
print >> sys.stderr, "Need to specify a --b2gpath"
sys.exit(1)
# Create the Marionette instance
kwargs = {}
if options.emulator:
kwargs['emulator'] = options.emulator
if options.no_window:
kwargs['noWindow'] = True
if options.b2g_path:
kwargs['homedir'] = options.emu_path or options.b2g_path
if options.address:
host, port = options.address.split(':')
kwargs['host'] = host
kwargs['port'] = int(port)
kwargs['baseurl'] = 'http://%s:%d/' % (host, int(port))
if options.emulator:
kwargs['connectToRunningEmulator'] = True
marionette = Marionette(**kwargs)
# Create the DeviceManager instance
kwargs = {'adbPath': options.adb_path}
if options.deviceIP:
kwargs['host'] = options.deviceIP
kwargs['port'] = options.devicePort
kwargs['deviceRoot'] = DEVICE_TEST_ROOT
dm = devicemanagerADB.DeviceManagerADB(**kwargs)
options.remoteTestRoot = dm.getDeviceRoot()
xpcsh = B2GXPCShellRemote(dm, options, args)
try:
success = xpcsh.runTests(xpcshell='xpcshell',
testdirs=args[0:],
**options.__dict__)
except:
print "TEST-UNEXPECTED-FAIL | %s | Exception caught while running tests." % sys.exc_info(
)[1]
traceback.print_exc()
sys.exit(1)
sys.exit(int(success))
def restart_device(self, restart_tries=0):
self.run_log.info("rebooting")
# TODO restarting b2g doesn't seem to work... reboot then
while restart_tries < 3:
restart_tries += 1
self.dm.reboot(wait=True)
self.run_log.info("forwarding")
if not self.forward_port():
self.run_log.error("couldn't forward port in time, rebooting")
continue
self.m = Marionette(port=self.port)
if not self.m.wait_for_port(180):
self.run_log.error(
"couldn't contact marionette in time, rebooting")
continue
time.sleep(1)
self.m.start_session()
try:
Wait(self.m, timeout=240).until(lambda m: m.find_element(
"id", "lockscreen-container").is_displayed())
# It retuns a little early
time.sleep(2)
self.device = GaiaDevice(self.m)
self.device.add_device_manager(self.dm)
self.device.unlock()
self.gaia_apps = GaiaApps(self.m)
except (MarionetteException, IOError, socket.error) as e:
self.run_log.error("got exception: %s, going to retry" % e)
try:
self.m.delete_session()
except:
# at least attempt to clear the session if possible
pass
continue
break
else:
raise Exception(
"Couldn't restart the device in time, even after 3 tries")
def setupMarionette(self):
"""
Starts a marionette session.
If no host was given at init, the ip of the device will be retrieved
and networking will be established.
"""
if not self.marionetteHost:
self.setupDHCP()
self.marionetteHost = self.getIP()
if not self.marionette:
self.marionette = Marionette(self.marionetteHost, self.marionettePort)
if not self.marionette.session:
self.waitForPort(30)
self.marionette.start_session()
def setupMarionette(self):
"""
Start a marionette session.
If no host is given, then this will get the ip
of the device, and set up networking if needed.
"""
if not self.marionetteHost:
self.setupDHCP()
self.marionetteHost = self.getIP()
if not self.marionette:
self.marionette = Marionette(self.marionetteHost, self.marionettePort)
if not self.marionette.session:
self.waitForPort(30)
self.marionette.start_session()
def runemulator(homedir=None, url=None, pidfile=None, arch='x86'):
qemu = Emulator(homedir=homedir, arch=arch)
qemu.start()
port = qemu.setup_port_forwarding(2828)
assert (qemu.wait_for_port())
if pidfile:
f = open(pidfile, 'w')
f.write("%d" % qemu.proc.pid)
f.close()
print 'emulator launched, pid:', qemu.proc.pid
if url:
marionette = Marionette(port=port)
marionette.start_session()
marionette.navigate(url)
marionette.delete_session()
def run_marionette_script(self):
self.marionette = Marionette(**self.marionette_args)
assert(self.marionette.wait_for_port())
self.marionette.start_session()
if self.build_type == "mulet":
self._wait_for_homescreen(timeout=15)
self._unlockScreen()
self.marionette.set_context(self.marionette.CONTEXT_CHROME)
if os.path.isfile(self.test_script):
f = open(self.test_script, 'r')
self.test_script = f.read()
f.close()
self.marionette.execute_script(self.test_script)
