deleted file mode 100644
--- a/testing/marionette/harness/marionette/b2g_update_test.py
+++ /dev/null
@@ -1,442 +0,0 @@
-# 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 cStringIO import StringIO
-import imp
-import os
-import re
-import subprocess
-import time
-import types
-import weakref
-
-from marionette_driver.marionette import Marionette
-from marionette_driver import transport
-
-from .marionette_test import MarionetteTestCase
-
-from b2ginstance import B2GInstance
-from .runtests import MarionetteTestRunner, cli
-
-
-class B2GUpdateMarionetteClient(transport.TcpTransport):
- RETRY_TIMEOUT = 5
- CONNECT_TIMEOUT = 30
- SEND_TIMEOUT = 60 * 5
- MAX_RETRIES = 24
-
- def __init__(self, addr, port, runner):
- super(B2GUpdateMarionetteClient, self).__init__(addr, port, self.CONNECT_TIMEOUT)
- self.runner = runner
-
- def connect(self):
- """ When using ADB port forwarding, the ADB server will actually accept
- connections even though there isn't a listening socket open on the
- device. Here we add a retry loop since we have to restart the debug
- server / b2g process for update tests
- """
- for i in range(self.MAX_RETRIES):
- try:
- transport.TcpTransport.connect(self)
- break
- except:
- if i == self.MAX_RETRIES - 1:
- raise
-
- time.sleep(self.RETRY_TIMEOUT)
- self.runner.port_forward()
-
- # Upon success, reset the socket timeout to something more reasonable
- self.sock.settimeout(self.SEND_TIMEOUT)
-
-
-class B2GUpdateTestRunner(MarionetteTestRunner):
- match_re = re.compile(r'update_(smoke)?test_(.*)\.py$')
-
- def __init__(self, **kwargs):
- MarionetteTestRunner.__init__(self, **kwargs)
- if self.emulator or self.bin:
- raise Exception('Update tests do not support emulator or custom binaries')
-
- if not self.address:
- raise Exception('Update tests must be run with '
- '--address=localhost:<port>')
-
- self.host, port = self.address.split(':')
- self.port = int(port)
- self.test_handlers.append(self)
-
- self.b2g = B2GInstance(homedir=kwargs.get('homedir'))
- self.update_tools = self.b2g.import_update_tools()
- self.adb = self.update_tools.AdbTool(path=self.b2g.adb_path,
- device=self.device_serial)
-
- def match(self, filename):
- return self.match_re.match(filename) is not None
-
- def add_tests_to_suite(self, mod_name, filepath, suite, testloader,
- marionette, testvars):
- """ Here the runner itself is a handler so we can forward along the
- instance to test cases.
- """
- test_mod = imp.load_source(mod_name, filepath)
-
- def add_test(testcase, testname, **kwargs):
- suite.addTest(testcase(weakref.ref(marionette),
- methodName=testname,
- filepath=filepath,
- testvars=testvars,
- **kwargs))
-
- # The TestCase classes are apparently being loaded multiple times, so
- # using "isinstance" doesn't actually work. This function just compares
- # type names as a close enough analog.
- def has_super(cls, super_names):
- if not isinstance(super_names, (tuple, list)):
- super_names = (super_names)
-
- base = cls
- while base:
- if base.__name__ in super_names:
- return True
- base = base.__base__
- return False
-
- for name in dir(test_mod):
- testcase = getattr(test_mod, name)
- if not isinstance(testcase, (type, types.ClassType)):
- continue
-
- # Support both B2GUpdateTestCase and MarionetteTestCase
- if has_super(testcase, 'B2GUpdateTestCase'):
- for testname in testloader.getTestCaseNames(testcase):
- add_test(testcase, testname, runner=self)
- elif has_super(testcase, ('MarionetteTestCase', 'TestCase')):
- for testname in testloader.getTestCaseNames(testcase):
- add_test(testcase, testname)
-
- def start_marionette(self):
- MarionetteTestRunner.start_marionette(self)
- self.marionette.client = B2GUpdateMarionetteClient(self.host,
- self.port,
- self)
-
- def reset(self, b2g_pid):
- if self.marionette.instance:
- self.marionette.instance.close()
- self.marionette.instance = None
- del self.marionette
-
- self.start_marionette()
- self.b2g_pid = b2g_pid
- return self.marionette
-
- def find_b2g_pid(self):
- pids = self.adb.get_pids('b2g')
- if len(pids) == 0:
- return None
- return pids[0]
-
- def port_forward(self):
- try:
- self.adb.run('forward', 'tcp:%d' % self.port, 'tcp:2828')
- except:
- # This command causes non-0 return codes even though it succeeds
- pass
-
-OTA, FOTA = "OTA", "FOTA"
-class B2GUpdateTestCase(MarionetteTestCase):
- """ A high level unit test for an OTA or FOTA update. This test case class
- has structural support for automatically waiting on an update to apply,
- and provides additional javascript support for separating a test into
- 'pre-update' and 'post-update' lifecycles.
-
- See test examples in toolkit/mozapps/update/test/marionette/update_test_*.py
- """
-
- MAX_OTA_WAIT = 60 * 2 # 2 minutes
- MAX_FOTA_WAIT = 60 * 10 # 10 minutes
-
- def __init__(self, marionette_weakref, **kwargs):
- if 'runner' in kwargs:
- self.runner = kwargs['runner']
- del kwargs['runner']
-
- update_test_js = os.path.join(os.path.dirname(__file__), 'atoms',
- 'b2g_update_test.js')
- with open(update_test_js, 'r') as f:
- self.update_test_js = f.read()
-
- self.b2g_pid = self.runner.find_b2g_pid()
- if not self.b2g_pid:
- raise Exception('B2G PID could not be found for update test')
- MarionetteTestCase.__init__(self, marionette_weakref, **kwargs)
-
- self.testvars = self.testvars or {}
- self.status_newline = True
- self.loglines = []
-
- def print_status(self, status, message=None):
- if self.status_newline:
- print ''
- self.status_newline = False
-
- status_msg = 'UPDATE-TEST-' + status
- if message:
- status_msg += ': ' + message
- print status_msg
-
- def setUp(self):
- MarionetteTestCase.setUp(self)
- self.marionette.set_context(Marionette.CONTEXT_CHROME)
-
- def tearDown(self):
- # This completey overrides MarionetteTestCase.tearDown so we can control
- # logs being appended between various marionette runs
- self.marionette.set_context(Marionette.CONTEXT_CONTENT)
- self.marionette.execute_script("log('TEST-END: %s:%s')" %
- (self.filepath.replace('\\', '\\\\'), self.methodName))
- self.marionette.test_name = None
-
- self.duration = time.time() - self.start_time
- if self.marionette.session is not None:
- self.loglines.extend(self.marionette.get_logs())
- self.marionette.delete_session()
- self.marionette = None
-
- def reset(self, b2g_pid):
- self.print_status('RESET-MARIONETTE')
- self._marionette_weakref = weakref.ref(self.runner.reset(b2g_pid))
- self.marionette = self._marionette_weakref()
- if self.marionette.session is None:
- self.marionette.start_session()
- self.marionette.set_context(Marionette.CONTEXT_CHROME)
-
- def execute_update_test(self, path, apply=None):
- self.execute_update_js(path, stage='pre-update',
- will_restart=(apply is not None))
- if not apply:
- return
-
- if self.marionette.session is not None:
- self.loglines.extend(self.marionette.get_logs())
-
- # This function will probably force-kill b2g, so we can't capture logs
- self.execute_update_js(path, stage='apply-update')
- self.wait_for_update(apply)
-
- self.execute_update_js(path, stage='post-update')
-
- def execute_update_js(self, path, stage=None, will_restart=True):
- data = self.update_test_js[:]
- with open(path, "r") as f:
- data += f.read()
-
- status = 'EXEC'
- if stage:
- status += '-' + stage.upper()
- data += '\nrunUpdateTest("%s");' % stage
-
- self.print_status(status, os.path.basename(path))
-
- results = self.marionette.execute_async_script(data,
- script_args=[self.testvars])
- self.handle_results(path, stage, results)
-
- def handle_results(self, path, stage, results):
- passed = results['passed']
- failed = results['failed']
-
- fails = StringIO()
- stage_msg = ' %s' % stage if stage else ''
- fails.write('%d%s tests failed:\n' % (failed, stage_msg))
-
- for failure in results['failures']:
- diag = failure.get('diag')
- diag_msg = "" if not diag else "| %s " % diag
- name = failure.get('name') or 'got false, expected true'
- fails.write('TEST-UNEXPECTED-FAIL | %s %s| %s\n' %
- (os.path.basename(path), diag_msg, name))
- self.assertEqual(0, failed, fails.getvalue())
- self.assertTrue(passed + failed > 0, 'no tests run')
-
- def stage_update(self, **kwargs):
- mar = kwargs.get('complete_mar') or kwargs.get('partial_mar')
- short_mar = os.path.relpath(mar, os.path.dirname(os.path.dirname(mar)))
- self.print_status('STAGE', short_mar)
-
- prefs = kwargs.pop('prefs', {})
- update_xml = kwargs.get('update_xml')
- if not update_xml:
- xml_kwargs = kwargs.copy()
- if 'update_dir' in xml_kwargs:
- del xml_kwargs['update_dir']
- if 'only_override' in xml_kwargs:
- del xml_kwargs['only_override']
- builder = self.runner.update_tools.UpdateXmlBuilder(**xml_kwargs)
- update_xml = builder.build_xml()
-
- test_kwargs = {
- 'adb_path': self.runner.adb.tool,
- 'update_xml': update_xml,
- 'only_override': kwargs.get('only_override', False),
- }
- for key in ('complete_mar', 'partial_mar', 'url_template', 'update_dir'):
- test_kwargs[key] = kwargs.get(key)
-
- test_update = self.runner.update_tools.TestUpdate(**test_kwargs)
- test_update.test_update(write_url_pref=False, restart=False)
- if 'prefs' not in self.testvars:
- self.testvars['prefs'] = {}
-
- self.testvars['prefs']['app.update.url.override'] = test_update.update_url
- self.testvars['prefs'].update(prefs)
-
- def wait_for_update(self, type):
- if type == OTA:
- self.wait_for_ota_restart()
- elif type == FOTA:
- self.wait_for_fota_reboot()
-
- def wait_for_new_b2g_pid(self, max_wait):
- for i in range(max_wait):
- b2g_pid = self.runner.find_b2g_pid()
- if b2g_pid and b2g_pid != self.b2g_pid:
- return b2g_pid
- time.sleep(1)
-
- return None
-
- def wait_for_ota_restart(self):
- self.print_status('WAIT-FOR-OTA-RESTART')
-
- new_b2g_pid = self.wait_for_new_b2g_pid(self.MAX_OTA_WAIT)
- if not new_b2g_pid:
- self.fail('Timed out waiting for B2G process during OTA update')
- return
-
- self.reset(new_b2g_pid)
-
- def wait_for_fota_reboot(self):
- self.print_status('WAIT-FOR-FOTA-REBOOT')
-
- # First wait for the device to go offline
- for i in range(self.MAX_FOTA_WAIT):
- online = self.runner.adb.get_online_devices()
- if self.runner.device not in online:
- break
- time.sleep(1)
-
- if i == self.MAX_FOTA_WAIT - 1:
- self.fail('Timed out waiting for device to go offline during FOTA update')
-
- # Now wait for the device to come back online
- for j in range(i, self.MAX_FOTA_WAIT):
- online = self.runner.adb.get_online_devices()
- if self.runner.device in online:
- break
- time.sleep(1)
-
- if j == self.MAX_FOTA_WAIT - 1:
- self.fail('Timed out waiting for device to come back online during FOTA update')
-
- # Finally wait for the B2G process
- for k in range(j, self.MAX_FOTA_WAIT):
- b2g_pid = self.runner.find_b2g_pid()
- if b2g_pid:
- self.reset(b2g_pid)
- return
- time.sleep(1)
-
- self.fail('Timed out waiting for B2G process to start during FOTA update')
-
- def flash(self, flash_script):
- flash_build = os.path.basename(os.path.dirname(flash_script))
- self.print_status('FLASH-BUILD', flash_build)
-
- subprocess.check_call([flash_script, self.runner.device])
- self.runner.adb.run('wait-for-device')
- self.runner.port_forward()
-
- self.b2g_pid = None
- b2g_pid = self.wait_for_new_b2g_pid(self.MAX_OTA_WAIT)
- if not b2g_pid:
- self.fail('Timed out waiting for B2G process to start after a flash')
-
- self.reset(b2g_pid)
-
-class B2GUpdateSmokeTestCase(B2GUpdateTestCase):
- """ An even higher-level update test that is meant to be run with builds
- and updates generated in an automated build environment.
-
- Update smoke tests have two main differences from a plain update test:
- - They are meant to be passed various MARs and system images through the
- --testvars Marionette argument.
- - Before each test, the device can be flashed with a specified set of images
- by the test case.
-
- See smoketest examples in
- toolkit/mozapps/update/test/marionette/update_smoketest_*.py
- """
-
- "The path of the Javascript file that has assertions to run"
- JS_PATH = None
-
- """ Which build to flash and vars to stage before the test is run.
- Possible values: 'start', 'finish', or None
- """
- START_WITH_BUILD = 'start'
-
- "A map of prefs to set while staging, before the test is run"
- STAGE_PREFS = None
-
- "Marionette script timeout"
- TIMEOUT = 2 * 60 * 1000
-
- """What kind of update to apply after the 'pre-update' tests have
- finished. Possible values: OTA, FOTA, None. None means "Don't apply"
- """
- APPLY = OTA
-
- def setUp(self):
- if self.START_WITH_BUILD:
- build = self.testvars[self.START_WITH_BUILD]
- self.flash(build['flash_script'])
-
- B2GUpdateTestCase.setUp(self)
-
- def stage_update(self, build=None, mar=None, **kwargs):
- if build and not mar:
- raise Exception('mar required with build')
- if mar and not build:
- raise Exception('build required with mar')
-
- if not build:
- B2GUpdateTestCase.stage_update(self, **kwargs)
- return
-
- build_vars = self.testvars[build]
- mar_key = mar + '_mar'
- mar_path = build_vars[mar_key]
-
- stage_kwargs = {
- 'build_id': build_vars['app_build_id'],
- 'app_version': build_vars['app_version'],
- 'platform_version': build_vars['platform_milestone'],
- mar_key: mar_path
- }
- stage_kwargs.update(kwargs)
-
- if self.STAGE_PREFS:
- if 'prefs' not in stage_kwargs:
- stage_kwargs['prefs'] = self.STAGE_PREFS
-
- B2GUpdateTestCase.stage_update(self, **stage_kwargs)
-
- def execute_smoketest(self):
- self.marionette.set_script_timeout(self.TIMEOUT)
- self.execute_update_test(self.JS_PATH, apply=self.APPLY)
-
-if __name__ == '__main__':
- cli(B2GUpdateTestRunner)
--- a/testing/marionette/harness/marionette/marionette_test.py
+++ b/testing/marionette/harness/marionette/marionette_test.py
@@ -423,58 +423,32 @@ class CommonTestCase(unittest.TestCase):
def id(self):
# TBPL starring requires that the "test name" field of a failure message
# not differ over time. The test name to be used is passed to
# mozlog via the test id, so this is overriden to maintain
# consistency.
return self.test_name
- def set_up_test_page(self, emulator, url="test.html", permissions=None):
- emulator.set_context("content")
- url = emulator.absolute_url(url)
- emulator.navigate(url)
-
- if not permissions:
- return
-
- emulator.set_context("chrome")
- emulator.execute_script("""
-Components.utils.import("resource://gre/modules/Services.jsm");
-let [url, permissions] = arguments;
-let uri = Services.io.newURI(url, null, null);
-permissions.forEach(function (perm) {
- Services.perms.add(uri, "sms", Components.interfaces.nsIPermissionManager.ALLOW_ACTION);
-});
- """, [url, permissions])
- emulator.set_context("content")
-
def setUp(self):
# Convert the marionette weakref to an object, just for the
# duration of the test; this is deleted in tearDown() to prevent
# a persistent circular reference which in turn would prevent
# proper garbage collection.
self.start_time = time.time()
self.marionette = self._marionette_weakref()
if self.marionette.session is None:
self.marionette.start_session()
if self.marionette.timeout is not None:
self.marionette.timeouts(self.marionette.TIMEOUT_SEARCH, self.marionette.timeout)
self.marionette.timeouts(self.marionette.TIMEOUT_SCRIPT, self.marionette.timeout)
self.marionette.timeouts(self.marionette.TIMEOUT_PAGE, self.marionette.timeout)
else:
self.marionette.timeouts(self.marionette.TIMEOUT_PAGE, 30000)
- if hasattr(self, 'test_container') and self.test_container:
- self.switch_into_test_container()
- elif hasattr(self, 'test_container') and self.test_container is False:
- if self.marionette.session_capabilities.has_key('b2g') \
- and self.marionette.session_capabilities['b2g'] == True:
- self.close_test_container()
-
def tearDown(self):
pass
def cleanTest(self):
self._deleteSession()
def _deleteSession(self):
if hasattr(self, 'start_time'):
@@ -491,68 +465,16 @@ permissions.forEach(function (perm) {
# Gecko has crashed?
self.marionette.session = None
try:
self.marionette.client.close()
except socket.error:
pass
self.marionette = None
- def switch_into_test_container(self):
- self.marionette.set_context(self.marionette.CONTEXT_CONTENT)
-
- frame = Wait(self.marionette, timeout=10, interval=0.2).until(element_present(
- 'css selector',
- 'iframe[src*="app://test-container.gaiamobile.org/index.html"]'
- ))
-
- self.marionette.switch_to_frame(frame)
-
- def close_test_container(self):
- self.marionette.set_context(self.marionette.CONTEXT_CONTENT)
-
- result = self.marionette.execute_async_script("""
-if((navigator.mozSettings == undefined) || (navigator.mozSettings == null) || (navigator.mozApps == undefined) || (navigator.mozApps == null)) {
- marionetteScriptFinished(false);
- return;
-}
-let setReq = navigator.mozSettings.createLock().set({'lockscreen.enabled': false});
-setReq.onsuccess = function() {
- let appsReq = navigator.mozApps.mgmt.getAll();
- appsReq.onsuccess = function() {
- let apps = appsReq.result;
- for (let i = 0; i < apps.length; i++) {
- let app = apps[i];
- if (app.manifest.name === 'Test Container') {
- window.wrappedJSObject.Service.request('AppWindowManager:kill', app.origin).then(function() {
- marionetteScriptFinished(true);
- }).catch(function() {
- marionetteScriptFinished(false);
- });
- return;
- }
- }
- marionetteScriptFinished(false);
- }
- appsReq.onerror = function() {
- marionetteScriptFinished(false);
- }
-}
-setReq.onerror = function() {
- marionetteScriptFinished(false);
-}""", script_timeout=60000)
-
- if not result:
- raise Exception('Failed to close Test Container app')
-
- Wait(self.marionette, timeout=10, interval=0.2).until(element_not_present(
- 'css selector',
- 'iframe[src*="app://test-container.gaiamobile.org/index.html"]'
- ))
-
def setup_SpecialPowers_observer(self):
self.marionette.set_context("chrome")
self.marionette.execute_script("""
let SECURITY_PREF = "security.turn_off_all_security_so_that_viruses_can_take_over_this_computer";
Components.utils.import("resource://gre/modules/Preferences.jsm");
Preferences.set(SECURITY_PREF, true);
if (!testUtils.hasOwnProperty("specialPowersObserver")) {
@@ -688,17 +610,16 @@ setReq.onerror = function() {
class MarionetteTestCase(CommonTestCase):
match_re = re.compile(r"test_(.*)\.py$")
def __init__(self, marionette_weakref, methodName='runTest',
filepath='', **kwargs):
self._marionette_weakref = marionette_weakref
self.marionette = None
- self.extra_emulator_index = -1
self.methodName = methodName
self.filepath = filepath
self.testvars = kwargs.pop('testvars', None)
self.test_container = kwargs.pop('test_container', None)
CommonTestCase.__init__(self, methodName, **kwargs)
@classmethod
def add_tests_to_suite(cls, mod_name, filepath, suite, testloader, marionette, testvars, **kwargs):
@@ -748,31 +669,16 @@ class MarionetteTestCase(CommonTestCase)
self.marionette.test_name = None
except (MarionetteException, IOError):
# We have tried to log the test end when there is no listener
# object that we can access
pass
CommonTestCase.tearDown(self)
- 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,
- gecko_path=self.marionette.gecko_path)
- qemu.start_session()
- self.marionette.extra_emulators.append(qemu)
- else:
- qemu = self.marionette.extra_emulators[self.extra_emulator_index]
- return qemu
-
def wait_for_condition(self, method, timeout=30):
timeout = float(timeout) + time.time()
while time.time() < timeout:
value = method(self.marionette)
if value:
return value
time.sleep(0.5)
else:
--- a/testing/marionette/harness/marionette/runner/base.py
+++ b/testing/marionette/harness/marionette/runner/base.py
@@ -63,23 +63,22 @@ class MarionetteTestResult(StructuredTes
def __init__(self, *args, **kwargs):
self.marionette = kwargs.pop('marionette')
TestResultCollection.__init__(self, 'MarionetteTest')
self.passed = 0
self.testsRun = 0
self.result_modifiers = [] # used by mixins to modify the result
pid = kwargs.pop('b2g_pid')
- logcat_stdout = kwargs.pop('logcat_stdout')
if pid:
if B2GTestResultMixin not in self.__class__.__bases__:
bases = [b for b in self.__class__.__bases__]
bases.append(B2GTestResultMixin)
self.__class__.__bases__ = tuple(bases)
- B2GTestResultMixin.__init__(self, b2g_pid=pid, logcat_stdout=logcat_stdout)
+ B2GTestResultMixin.__init__(self, b2g_pid=pid)
StructuredTestResult.__init__(self, *args, **kwargs)
@property
def skipped(self):
return [t for t in self if t.result == 'SKIPPED']
@skipped.setter
def skipped(self, value):
@@ -225,17 +224,16 @@ class MarionetteTextTestRunner(Structure
resultclass = MarionetteTestResult
def __init__(self, **kwargs):
self.marionette = kwargs.pop('marionette')
self.capabilities = kwargs.pop('capabilities')
self.pre_run_functions = []
self.b2g_pid = None
- self.logcat_stdout = kwargs.pop('logcat_stdout')
if self.capabilities["device"] != "desktop" and self.capabilities["browserName"] == "B2G":
def b2g_pre_run():
dm_type = os.environ.get('DM_TRANS', 'adb')
if dm_type == 'adb':
self.b2g_pid = get_b2g_pid(get_dm(self.marionette))
self.pre_run_functions.append(b2g_pre_run)
@@ -244,17 +242,16 @@ class MarionetteTextTestRunner(Structure
def _makeResult(self):
return self.resultclass(self.stream,
self.descriptions,
self.verbosity,
marionette=self.marionette,
b2g_pid=self.b2g_pid,
logger=self.logger,
- logcat_stdout=self.logcat_stdout,
result_callbacks=self.result_callbacks)
def run(self, test):
"Run the given test case or test suite."
for pre_run_func in self.pre_run_functions:
pre_run_func()
result = super(MarionetteTextTestRunner, self).run(test)
@@ -278,54 +275,21 @@ class BaseMarionetteArguments(ArgumentPa
self.add_argument('tests',
nargs='*',
default=[],
help='Tests to run.')
self.add_argument('-v', '--verbose',
action='count',
help='Increase verbosity to include debug messages with -v, '
'and trace messages with -vv.')
- self.add_argument('--emulator',
- choices=['x86', 'arm'],
- help='if no --address is given, then the harness will launch a B2G emulator on which to run '
- 'emulator tests. if --address is given, then the harness assumes you are running an '
- 'emulator already, and will run the emulator tests using that emulator. you need to '
- 'specify which architecture to emulate for both cases')
- self.add_argument('--emulator-binary',
- help='launch a specific emulator binary rather than launching from the B2G built emulator')
- self.add_argument('--emulator-img',
- help='use a specific image file instead of a fresh one')
- self.add_argument('--emulator-res',
- help='set a custom resolution for the emulator'
- 'Example: "480x800"')
- self.add_argument('--sdcard',
- help='size of sdcard to create for the emulator')
- self.add_argument('--no-window',
- action='store_true',
- default=False,
- help='when Marionette launches an emulator, start it with the -no-window argument')
- self.add_argument('--logcat-dir',
- dest='logdir',
- help='directory to store logcat dump files',
- type=dir_path)
- self.add_argument('--logcat-stdout',
- action='store_true',
- default=False,
- help='dump adb logcat to stdout')
self.add_argument('--address',
help='host:port of running Gecko instance to connect to')
self.add_argument('--device',
dest='device_serial',
help='serial ID of a device to use for adb / fastboot')
- self.add_argument('--adb-host',
- help='host to use for adb connection')
- self.add_argument('--adb-port',
- help='port to use for adb connection')
- self.add_argument('--homedir',
- help='home directory of emulator files')
self.add_argument('--app',
help='application to use')
self.add_argument('--app-arg',
dest='app_args',
action='append',
default=[],
help='specify a command line argument to be passed onto the application')
self.add_argument('--binary',
@@ -469,36 +433,20 @@ class BaseMarionetteArguments(ArgumentPa
print 'must specify one or more test files, manifests, or directories'
sys.exit(1)
for path in args.tests:
if not os.path.exists(path):
print '{0} does not exist'.format(path)
sys.exit(1)
- if not args.emulator and not args.address and not args.binary:
- print 'must specify --binary, --emulator or --address'
- sys.exit(1)
-
- if args.emulator and args.binary:
- print 'can\'t specify both --emulator and --binary'
+ if not args.address and not args.binary:
+ print 'must specify --binary, or --address'
sys.exit(1)
- # check for valid resolution string, strip whitespaces
- try:
- if args.emulator_res:
- dims = args.emulator_res.split('x')
- assert len(dims) == 2
- width = str(int(dims[0]))
- height = str(int(dims[1]))
- args.emulator_res = 'x'.join([width, height])
- except:
- raise ValueError('Invalid emulator resolution format. '
- 'Should be like "480x800".')
-
if args.total_chunks is not None and args.this_chunk is None:
self.error('You must specify which chunk to run.')
if args.this_chunk is not None and args.total_chunks is None:
self.error('You must specify how many chunks to split the tests into.')
if args.total_chunks is not None:
if not 1 <= args.total_chunks:
@@ -525,50 +473,41 @@ class BaseMarionetteArguments(ArgumentPa
return args
class BaseMarionetteTestRunner(object):
textrunnerclass = MarionetteTextTestRunner
driverclass = Marionette
- def __init__(self, address=None, emulator=None, emulator_binary=None,
- emulator_img=None, emulator_res='480x800', homedir=None,
+ def __init__(self, address=None,
app=None, app_args=None, binary=None, profile=None,
- logger=None, no_window=False, logdir=None, logcat_stdout=False,
+ logger=None, logdir=None,
repeat=0, testvars=None, tree=None,
- device_serial=None, symbols_path=None, timeout=None,
+ symbols_path=None, timeout=None,
shuffle=False, shuffle_seed=random.randint(0, sys.maxint),
sdcard=None, this_chunk=1, total_chunks=1, sources=None,
server_root=None, gecko_log=None, result_callbacks=None,
- adb_host=None, adb_port=None, prefs=None, test_tags=None,
+ prefs=None, test_tags=None,
socket_timeout=BaseMarionetteArguments.socket_timeout_default,
startup_timeout=None, addons=None, workspace=None,
verbose=0, e10s=True, **kwargs):
self.address = address
- self.emulator = emulator
- self.emulator_binary = emulator_binary
- self.emulator_img = emulator_img
- self.emulator_res = emulator_res
- self.homedir = homedir
self.app = app
self.app_args = app_args or []
self.bin = binary
self.profile = profile
self.addons = addons
self.logger = logger
- self.no_window = no_window
self.httpd = None
self.marionette = None
self.logdir = logdir
- self.logcat_stdout = logcat_stdout
self.repeat = repeat
self.test_kwargs = kwargs
self.tree = tree
- self.device_serial = device_serial
self.symbols_path = symbols_path
self.timeout = timeout
self.socket_timeout = socket_timeout
self._device = None
self._capabilities = None
self._appinfo = None
self._appName = None
self.shuffle = shuffle
@@ -577,23 +516,21 @@ class BaseMarionetteTestRunner(object):
self.sources = sources
self.server_root = server_root
self.this_chunk = this_chunk
self.total_chunks = total_chunks
self.mixin_run_tests = []
self.manifest_skipped_tests = []
self.tests = []
self.result_callbacks = result_callbacks or []
- self._adb_host = adb_host
- self._adb_port = adb_port
self.prefs = prefs or {}
self.test_tags = test_tags
self.startup_timeout = startup_timeout
self.workspace = workspace
- # If no workspace is set, default location for logcat and gecko.log is .
+ # If no workspace is set, default location for gecko.log is .
# and default location for profile is TMP
self.workspace_path = workspace or os.getcwd()
self.verbose = verbose
self.e10s = e10s
def gather_debug(test, status):
rv = {}
marionette = test._marionette_weakref()
@@ -618,19 +555,16 @@ class BaseMarionetteTestRunner(object):
self.test_handlers = []
self.reset_test_stats()
self.logger.info('Using workspace for temporary data: '
'"{}"'.format(self.workspace_path))
- if self.emulator and not self.logdir:
- self.logdir = os.path.join(self.workspace_path or '', 'logcat')
-
if not gecko_log:
self.gecko_log = os.path.join(self.workspace_path or '', 'gecko.log')
else:
self.gecko_log = gecko_log
self.results = []
@property
@@ -742,70 +676,49 @@ class BaseMarionetteTestRunner(object):
self.skipped = 0
self.failures = []
def _build_kwargs(self):
if self.logdir and not os.access(self.logdir, os.F_OK):
os.mkdir(self.logdir)
kwargs = {
- 'device_serial': self.device_serial,
- 'symbols_path': self.symbols_path,
'timeout': self.timeout,
'socket_timeout': self.socket_timeout,
- 'adb_host': self._adb_host,
- 'adb_port': self._adb_port,
'prefs': self.prefs,
'startup_timeout': self.startup_timeout,
'verbose': self.verbose,
}
if self.bin:
kwargs.update({
'host': 'localhost',
'port': 2828,
'app': self.app,
'app_args': self.app_args,
'bin': self.bin,
'profile': self.profile,
'addons': self.addons,
'gecko_log': self.gecko_log,
})
- if self.emulator:
- kwargs.update({
- 'homedir': self.homedir,
- 'logdir': self.logdir,
- })
-
if self.address:
host, port = self.address.split(':')
kwargs.update({
'host': host,
'port': int(port),
})
- if self.emulator:
- kwargs['connectToRunningEmulator'] = True
if not self.bin:
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("Connection attempt to %s:%s failed with error: %s" %(host,port,e))
- elif self.emulator:
- kwargs.update({
- 'emulator': self.emulator,
- 'emulator_binary': self.emulator_binary,
- 'emulator_img': self.emulator_img,
- 'emulator_res': self.emulator_res,
- 'no_window': self.no_window,
- 'sdcard': self.sdcard,
- })
if self.workspace:
kwargs['workspace'] = self.workspace_path
return kwargs
def start_marionette(self):
self.marionette = self.driverclass(**self._build_kwargs())
def launch_test_container(self):
@@ -912,20 +825,17 @@ setReq.onerror = function() {
if invalid_tests:
raise Exception("Tests file names must starts with 'test_'."
" Invalid test names:\n %s"
% '\n '.join(invalid_tests))
self.logger.info("running with e10s: {}".format(self.e10s))
version_info = mozversion.get_version(binary=self.bin,
sources=self.sources,
- dm_type=os.environ.get('DM_TRANS', 'adb'),
- device_serial=self.device_serial,
- adb_host=self.marionette.adb_host,
- adb_port=self.marionette.adb_port)
+ dm_type=os.environ.get('DM_TRANS', 'adb') )
self.logger.suite_start(self.tests,
version_info=version_info,
device_info=device_info)
for test in self.manifest_skipped_tests:
name = os.path.basename(test['path'])
self.logger.test_start(name)
@@ -1086,17 +996,16 @@ setReq.onerror = function() {
self.testvars,
**self.test_kwargs)
break
if suite.countTestCases():
runner = self.textrunnerclass(logger=self.logger,
marionette=self.marionette,
capabilities=self.capabilities,
- logcat_stdout=self.logcat_stdout,
result_callbacks=self.result_callbacks)
if test_container:
self.launch_test_container()
results = runner.run(suite)
self.results.append(results)
--- a/testing/marionette/harness/marionette/tests/harness_unit/test_marionette_runner.py
+++ b/testing/marionette/harness/marionette/tests/harness_unit/test_marionette_runner.py
@@ -62,46 +62,39 @@ def logger():
@pytest.fixture()
def mach_parsed_kwargs(logger):
"""
Parsed and verified dictionary used during simplest
call to mach marionette-test
"""
return {
- 'adb_host': None,
- 'adb_port': None,
'addon': None,
'address': None,
'app': None,
'app_args': [],
'binary': u'/path/to/firefox',
'device_serial': None,
'e10s': False,
- 'emulator': None,
- 'emulator_binary': None,
- 'emulator_img': None,
- 'emulator_res': None,
'gecko_log': None,
'homedir': None,
'jsdebugger': False,
'log_errorsummary': None,
'log_html': None,
'log_mach': None,
'log_mach_buffer': None,
'log_mach_level': None,
'log_mach_verbose': None,
'log_raw': None,
'log_raw_level': None,
'log_tbpl': None,
'log_tbpl_buffer': None,
'log_tbpl_level': None,
'log_unittest': None,
'log_xunit': None,
- 'logcat_stdout': False,
'logdir': None,
'logger_name': 'Marionette-based Tests',
'no_window': False,
'prefs': {},
'prefs_args': None,
'prefs_files': None,
'profile': None,
'pydebugger': None,
@@ -245,17 +238,17 @@ def test_parsing_testvars(mach_parsed_kw
@pytest.mark.parametrize("has_crashed", [True, False])
def test_crash_is_recorded_as_error(empty_marionette_test,
logger,
has_crashed):
""" Number of errors is incremented by stopTest iff has_crashed is true """
# collect results from the empty test
result = MarionetteTestResult(
marionette=empty_marionette_test._marionette_weakref(),
- b2g_pid=0, logcat_stdout=False, logger=logger, verbosity=None,
+ b2g_pid=0, logger=logger, verbosity=None,
stream=None, descriptions=None,
)
result.startTest(empty_marionette_test)
assert len(result.errors) == 0
assert len(result.failures) == 0
assert result.testsRun == 1
assert result.shouldStop == False
result.stopTest(empty_marionette_test)
deleted file mode 100644
--- a/testing/marionette/harness/marionette/tests/unit/test_emulator.py
+++ /dev/null
@@ -1,152 +0,0 @@
-# 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 import skip
-
-from marionette.marionette_test import MarionetteTestCase, skip_if_desktop, skip_unless_protocol
-from marionette_driver.errors import MarionetteException, JavascriptException
-
-
-class TestEmulatorContent(MarionetteTestCase):
- @skip_if_desktop
- def test_emulator_cmd(self):
- self.marionette.set_script_timeout(10000)
- expected = ["<build>", "OK"]
- res = self.marionette.execute_async_script(
- "runEmulatorCmd('avd name', marionetteScriptFinished)");
- self.assertEqual(res, expected)
-
- @skip_if_desktop
- def test_emulator_shell(self):
- self.marionette.set_script_timeout(10000)
- expected = ["Hello World!"]
- res = self.marionette.execute_async_script(
- "runEmulatorShell(['echo', 'Hello World!'], marionetteScriptFinished)")
- self.assertEqual(res, expected)
-
- @skip_if_desktop
- def test_emulator_order(self):
- self.marionette.set_script_timeout(10000)
- with self.assertRaises(MarionetteException):
- self.marionette.execute_async_script("""
- runEmulatorCmd("gsm status", function(res) {});
- marionetteScriptFinished(true);
- """)
-
-
-class TestEmulatorChrome(TestEmulatorContent):
- def setUp(self):
- super(TestEmulatorChrome, self).setUp()
- self.marionette.set_context("chrome")
-
-
-class TestEmulatorScreen(MarionetteTestCase):
- @skip_if_desktop
- def test_emulator_orientation(self):
- self.screen = self.marionette.emulator.screen
- self.screen.initialize()
-
- self.assertEqual(self.screen.orientation, self.screen.SO_PORTRAIT_PRIMARY,
- 'Orientation has been correctly initialized.')
-
- self.screen.orientation = self.screen.SO_PORTRAIT_SECONDARY
- self.assertEqual(self.screen.orientation, self.screen.SO_PORTRAIT_SECONDARY,
- 'Orientation has been set to portrait-secondary')
-
- self.screen.orientation = self.screen.SO_LANDSCAPE_PRIMARY
- self.assertEqual(self.screen.orientation, self.screen.SO_LANDSCAPE_PRIMARY,
- 'Orientation has been set to landscape-primary')
-
- self.screen.orientation = self.screen.SO_LANDSCAPE_SECONDARY
- self.assertEqual(self.screen.orientation, self.screen.SO_LANDSCAPE_SECONDARY,
- 'Orientation has been set to landscape-secondary')
-
- self.screen.orientation = self.screen.SO_PORTRAIT_PRIMARY
- self.assertEqual(self.screen.orientation, self.screen.SO_PORTRAIT_PRIMARY,
- 'Orientation has been set to portrait-primary')
-
-
-class TestEmulatorCallbacks(MarionetteTestCase):
- def setUp(self):
- MarionetteTestCase.setUp(self)
- self.original_emulator_cmd = self.marionette._emulator_cmd
- self.original_emulator_shell = self.marionette._emulator_shell
- self.marionette._emulator_cmd = self.mock_emulator_cmd
- self.marionette._emulator_shell = self.mock_emulator_shell
-
- def tearDown(self):
- self.marionette._emulator_cmd = self.original_emulator_cmd
- self.marionette._emulator_shell = self.original_emulator_shell
-
- def mock_emulator_cmd(self, *args):
- return self.marionette._send_emulator_result("cmd response")
-
- def mock_emulator_shell(self, *args):
- return self.marionette._send_emulator_result("shell response")
-
- def _execute_emulator(self, action, args):
- script = "%s(%s, function(res) { marionetteScriptFinished(res); })" % (action, args)
- return self.marionette.execute_async_script(script)
-
- def emulator_cmd(self, cmd):
- return self._execute_emulator("runEmulatorCmd", escape(cmd))
-
- def emulator_shell(self, *args):
- js_args = ", ".join(map(escape, args))
- js_args = "[%s]" % js_args
- return self._execute_emulator("runEmulatorShell", js_args)
-
- def test_emulator_cmd_content(self):
- with self.marionette.using_context("content"):
- res = self.emulator_cmd("yo")
- self.assertEqual("cmd response", res)
-
- def test_emulator_shell_content(self):
- with self.marionette.using_context("content"):
- res = self.emulator_shell("first", "second")
- self.assertEqual("shell response", res)
-
- @skip_unless_protocol(lambda level: level >= 3)
- def test_emulator_result_error_content(self):
- with self.marionette.using_context("content"):
- with self.assertRaisesRegexp(JavascriptException, "TypeError"):
- self.marionette.execute_async_script("runEmulatorCmd()")
-
- def test_emulator_cmd_chrome(self):
- with self.marionette.using_context("chrome"):
- res = self.emulator_cmd("yo")
- self.assertEqual("cmd response", res)
-
- def test_emulator_shell_chrome(self):
- with self.marionette.using_context("chrome"):
- res = self.emulator_shell("first", "second")
- self.assertEqual("shell response", res)
-
- @skip_unless_protocol(lambda level: level >= 3)
- def test_emulator_result_error_chrome(self):
- with self.marionette.using_context("chrome"):
- with self.assertRaisesRegexp(JavascriptException, "TypeError"):
- self.marionette.execute_async_script("runEmulatorCmd()")
-
- def test_multiple_callbacks(self):
- res = self.marionette.execute_async_script("""
- runEmulatorCmd("what");
- runEmulatorCmd("ho");
- marionetteScriptFinished("Frobisher");
- """)
- self.assertEqual("Frobisher", res)
-
- # This should work, but requires work on emulator callbacks:
- """
- def test_multiple_nested_callbacks(self):
- res = self.marionette.execute_async_script('''
- runEmulatorCmd("what", function(res) {
- runEmulatorCmd("ho", marionetteScriptFinished);
- });''')
- self.assertEqual("cmd response", res)
- """
-
-
-def escape(word):
- return "'%s'" % word
--- a/testing/marionette/harness/marionette/tests/unit/test_getactiveframe_oop.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_getactiveframe_oop.py
@@ -85,14 +85,8 @@ class TestGetActiveFrameOOP(MarionetteTe
self.marionette.switch_to_frame()
self.marionette.switch_to_frame(active_frame1)
self.assertTrue("test_oop_1.html" in self.marionette.execute_script("return document.wrappedJSObject.location.href"))
# Switch to top-level then back to active frame 2, verify correct frame
self.marionette.switch_to_frame()
self.marionette.switch_to_frame(active_frame2)
self.assertTrue("test_oop_2.html" in self.marionette.execute_script("return document.wrappedJSObject.location.href"))
-
- # NOTE: For some reason the emulator, the contents of the OOP iframes are not
- # actually rendered, even though the page_source is correct. When this test runs
- # on a b2g device, the contents do appear
- # print self.marionette.get_url()
- # print self.marionette.page_source
--- a/testing/marionette/harness/marionette/tests/unit/test_transport.py
+++ b/testing/marionette/harness/marionette/tests/unit/test_transport.py
@@ -134,28 +134,16 @@ class TestProto2Command(MessageTestCase)
cmd = self.create()
self.assert_attr(cmd, "id")
self.assert_attr(cmd, "name")
self.assert_attr(cmd, "params")
self.assertEqual(None, cmd.id)
self.assertEqual("name", cmd.name)
self.assertEqual("params", cmd.params)
- def test_from_data_emulator_cmd(self):
- data = {"emulator_cmd": "emulator_cmd"}
- cmd = Proto2Command.from_data(data)
- self.assertEqual("runEmulatorCmd", cmd.name)
- self.assertEqual(data, cmd.params)
-
- def test_from_data_emulator_shell(self):
- data = {"emulator_shell": "emulator_shell"}
- cmd = Proto2Command.from_data(data)
- self.assertEqual("runEmulatorShell", cmd.name)
- self.assertEqual(data, cmd.params)
-
def test_from_data_unknown(self):
with self.assertRaises(ValueError):
cmd = Proto2Command.from_data({})
class TestProto2Response(MessageTestCase):
def create(self, error="error", result="result"):
return Proto2Response(error, result)
--- a/testing/marionette/harness/marionette/tests/unit/unit-tests.ini
+++ b/testing/marionette/harness/marionette/tests/unit/unit-tests.ini
@@ -27,17 +27,16 @@ skip-if = buildapp == 'b2g'
[test_text.py]
[test_text_chrome.py]
skip-if = true # "Bug 896046"
[test_clearing.py]
[test_typing.py]
[test_log.py]
-[test_emulator.py]
[test_about_pages.py]
skip-if = buildapp == 'b2g'
[test_execute_async_script.py]
[test_execute_script.py]
[test_simpletest_fail.js]
[test_findelement.py]