The Tor Browser: comparison dom/mobileconnection/tests/marionette/head.js

comparison: dom/mobileconnection/tests/marionette/head.js

dom/mobileconnection/tests/marionette/head.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:8ac59b0d332d
+/* Any copyright is dedicated to the Public Domain.
+* http://creativecommons.org/publicdomain/zero/1.0/ */
+const {Cc: Cc, Ci: Ci, Cr: Cr, Cu: Cu} = SpecialPowers;
+const SETTINGS_KEY_DATA_ENABLED = "ril.data.enabled";
+const SETTINGS_KEY_DATA_ROAMING_ENABLED = "ril.data.roaming_enabled";
+const SETTINGS_KEY_DATA_APN_SETTINGS = "ril.data.apnSettings";
+let Promise = Cu.import("resource://gre/modules/Promise.jsm").Promise;
+let _pendingEmulatorCmdCount = 0;
+/**
+* Send emulator command with safe guard.
+*
+* We should only call |finish()| after all emulator command transactions
+* end, so here comes with the pending counter.  Resolve when the emulator
+* gives positive response, and reject otherwise.
+*
+* Fulfill params:
+*   result -- an array of emulator response lines.
+* Reject params:
+*   result -- an array of emulator response lines.
+*
+* @param aCommand
+*        A string command to be passed to emulator through its telnet console.
+*
+* @return A deferred promise.
+*/
+function runEmulatorCmdSafe(aCommand) {
+let deferred = Promise.defer();
+++_pendingEmulatorCmdCount;
+runEmulatorCmd(aCommand, function(aResult) {
+--_pendingEmulatorCmdCount;
+ok(true, "Emulator response: " + JSON.stringify(aResult));
+if (Array.isArray(aResult) &&
+aResult[aResult.length - 1] === "OK") {
+deferred.resolve(aResult);
+} else {
+deferred.reject(aResult);
+}
+});
+return deferred.promise;
+}
+/**
+* Wrap DOMRequest onsuccess/onerror events to Promise resolve/reject.
+*
+* Fulfill params: A DOMEvent.
+* Reject params: A DOMEvent.
+*
+* @param aRequest
+*        A DOMRequest instance.
+*
+* @return A deferred promise.
+*/
+function wrapDomRequestAsPromise(aRequest) {
+let deferred = Promise.defer();
+ok(aRequest instanceof DOMRequest,
+"aRequest is instanceof " + aRequest.constructor);
+aRequest.addEventListener("success", function(aEvent) {
+deferred.resolve(aEvent);
+});
+aRequest.addEventListener("error", function(aEvent) {
+deferred.reject(aEvent);
+});
+return deferred.promise;
+}
+let workingFrame;
+/**
+* Get mozSettings value specified by @aKey.
+*
+* Resolve if that mozSettings value is retrieved successfully, reject
+* otherwise.
+*
+* Fulfill params:
+*   The corresponding mozSettings value of the key.
+* Reject params: (none)
+*
+* @param aKey
+*        A string.
+* @param aAllowError [optional]
+*        A boolean value.  If set to true, an error response won't be treated
+*        as test failure.  Default: false.
+*
+* @return A deferred promise.
+*/
+function getSettings(aKey, aAllowError) {
+let request =
+workingFrame.contentWindow.navigator.mozSettings.createLock().get(aKey);
+return wrapDomRequestAsPromise(request)
+.then(function resolve(aEvent) {
+ok(true, "getSettings(" + aKey + ") - success");
+return aEvent.target.result[aKey];
+}, function reject(aEvent) {
+ok(aAllowError, "getSettings(" + aKey + ") - error");
+});
+}
+/**
+* Set mozSettings values.
+*
+* Resolve if that mozSettings value is set successfully, reject otherwise.
+*
+* Fulfill params: (none)
+* Reject params: (none)
+*
+* @param aSettings
+*        An object of format |{key1: value1, key2: value2, ...}|.
+* @param aAllowError [optional]
+*        A boolean value.  If set to true, an error response won't be treated
+*        as test failure.  Default: false.
+*
+* @return A deferred promise.
+*/
+function setSettings(aSettings, aAllowError) {
+let request =
+workingFrame.contentWindow.navigator.mozSettings.createLock().set(aSettings);
+return wrapDomRequestAsPromise(request)
+.then(function resolve() {
+ok(true, "setSettings(" + JSON.stringify(aSettings) + ")");
+}, function reject() {
+ok(aAllowError, "setSettings(" + JSON.stringify(aSettings) + ")");
+});
+}
+/**
+* Set mozSettings value with only one key.
+*
+* Resolve if that mozSettings value is set successfully, reject otherwise.
+*
+* Fulfill params: (none)
+* Reject params: (none)
+*
+* @param aKey
+*        A string key.
+* @param aValue
+*        An object value.
+* @param aAllowError [optional]
+*        A boolean value.  If set to true, an error response won't be treated
+*        as test failure.  Default: false.
+*
+* @return A deferred promise.
+*/
+function setSettings1(aKey, aValue, aAllowError) {
+let settings = {};
+settings[aKey] = aValue;
+return setSettings(settings, aAllowError);
+}
+/**
+* Convenient MozSettings getter for SETTINGS_KEY_DATA_ENABLED.
+*/
+function getDataEnabled(aAllowError) {
+return getSettings(SETTINGS_KEY_DATA_ENABLED, aAllowError);
+}
+/**
+* Convenient MozSettings setter for SETTINGS_KEY_DATA_ENABLED.
+*/
+function setDataEnabled(aEnabled, aAllowError) {
+return setSettings1(SETTINGS_KEY_DATA_ENABLED, aEnabled, aAllowError);
+}
+/**
+* Convenient MozSettings getter for SETTINGS_KEY_DATA_ROAMING_ENABLED.
+*/
+function getDataRoamingEnabled(aAllowError) {
+return getSettings(SETTINGS_KEY_DATA_ROAMING_ENABLED, aAllowError);
+}
+/**
+* Convenient MozSettings setter for SETTINGS_KEY_DATA_ROAMING_ENABLED.
+*/
+function setDataRoamingEnabled(aEnabled, aAllowError) {
+return setSettings1(SETTINGS_KEY_DATA_ROAMING_ENABLED, aEnabled, aAllowError);
+}
+/**
+* Convenient MozSettings getter for SETTINGS_KEY_DATA_APN_SETTINGS.
+*/
+function getDataApnSettings(aAllowError) {
+return getSettings(SETTINGS_KEY_DATA_APN_SETTINGS, aAllowError);
+}
+/**
+* Convenient MozSettings setter for SETTINGS_KEY_DATA_APN_SETTINGS.
+*/
+function setDataApnSettings(aApnSettings, aAllowError) {
+return setSettings1(SETTINGS_KEY_DATA_APN_SETTINGS, aApnSettings, aAllowError);
+}
+let mobileConnection;
+/**
+* Push required permissions and test if
+* |navigator.mozMobileConnections[<aServiceId>]| exists. Resolve if it does,
+* reject otherwise.
+*
+* Fulfill params:
+*   mobileConnection -- an reference to navigator.mozMobileMessage.
+*
+* Reject params: (none)
+*
+* @param aAdditonalPermissions [optional]
+*        An array of permission strings other than "mobileconnection" to be
+*        pushed. Default: empty string.
+* @param aServiceId [optional]
+*        A numeric DSDS service id. Default: 0.
+*
+* @return A deferred promise.
+*/
+function ensureMobileConnection(aAdditionalPermissions, aServiceId) {
+let deferred = Promise.defer();
+aAdditionalPermissions = aAdditionalPermissions || [];
+aServiceId = aServiceId || 0;
+if (aAdditionalPermissions.indexOf("mobileconnection") < 0) {
+aAdditionalPermissions.push("mobileconnection");
+}
+let permissions = [];
+for (let perm of aAdditionalPermissions) {
+permissions.push({ "type": perm, "allow": 1, "context": document });
+}
+SpecialPowers.pushPermissions(permissions, function() {
+ok(true, "permissions pushed: " + JSON.stringify(permissions));
+// Permission changes can't change existing Navigator.prototype
+// objects, so grab our objects from a new Navigator.
+workingFrame = document.createElement("iframe");
+workingFrame.addEventListener("load", function load() {
+workingFrame.removeEventListener("load", load);
+mobileConnection =
+workingFrame.contentWindow.navigator.mozMobileConnections[aServiceId];
+if (mobileConnection) {
+log("navigator.mozMobileConnections[" + aServiceId + "] is instance of " +
+mobileConnection.constructor);
+} else {
+log("navigator.mozMobileConnections[" + aServiceId + "] is undefined");
+}
+if (mobileConnection instanceof MozMobileConnection) {
+deferred.resolve(mobileConnection);
+} else {
+deferred.reject();
+}
+});
+document.body.appendChild(workingFrame);
+});
+return deferred.promise;
+}
+/**
+* Wait for one named MobileConnection event.
+*
+* Resolve if that named event occurs.  Never reject.
+*
+* Fulfill params: the DOMEvent passed.
+*
+* @param aEventName
+*        A string event name.
+* @param aServiceId [optional]
+*        A numeric DSDS service id. Default: the one indicated in
+*        start*TestCommon() or 0 if not indicated.
+*
+* @return A deferred promise.
+*/
+function waitForManagerEvent(aEventName, aServiceId) {
+let deferred = Promise.defer();
+let mobileConn = mobileConnection;
+if (aServiceId !== undefined) {
+mobileConn =
+workingFrame.contentWindow.navigator.mozMobileConnections[aServiceId];
+}
+mobileConn.addEventListener(aEventName, function onevent(aEvent) {
+mobileConn.removeEventListener(aEventName, onevent);
+ok(true, "MobileConnection event '" + aEventName + "' got.");
+deferred.resolve(aEvent);
+});
+return deferred.promise;
+}
+/**
+* Get available networks.
+*
+* Fulfill params:
+*   An array of nsIDOMMozMobileNetworkInfo.
+* Reject params:
+*   A DOMEvent.
+*
+* @return A deferred promise.
+*/
+function getNetworks() {
+let request = mobileConnection.getNetworks();
+return wrapDomRequestAsPromise(request)
+.then(() => request.result);
+}
+/**
+* Manually select a network.
+*
+* Fulfill params: (none)
+* Reject params:
+*   'RadioNotAvailable', 'RequestNotSupported', or 'GenericFailure'
+*
+* @param aNetwork
+*        A nsIDOMMozMobileNetworkInfo.
+*
+* @return A deferred promise.
+*/
+function selectNetwork(aNetwork) {
+let request = mobileConnection.selectNetwork(aNetwork);
+return wrapDomRequestAsPromise(request)
+.then(null, () => { throw request.error });
+}
+/**
+* Manually select a network and wait for a 'voicechange' event.
+*
+* Fulfill params: (none)
+* Reject params:
+*   'RadioNotAvailable', 'RequestNotSupported', or 'GenericFailure'
+*
+* @param aNetwork
+*        A nsIDOMMozMobileNetworkInfo.
+*
+* @return A deferred promise.
+*/
+function selectNetworkAndWait(aNetwork) {
+let promises = [];
+promises.push(waitForManagerEvent("voicechange"));
+promises.push(selectNetwork(aNetwork));
+return Promise.all(promises);
+}
+/**
+* Automatically select a network.
+*
+* Fulfill params: (none)
+* Reject params:
+*   'RadioNotAvailable', 'RequestNotSupported', or 'GenericFailure'
+*
+* @return A deferred promise.
+*/
+function selectNetworkAutomatically() {
+let request = mobileConnection.selectNetworkAutomatically();
+return wrapDomRequestAsPromise(request)
+.then(null, () => { throw request.error });
+}
+/**
+* Automatically select a network and wait for a 'voicechange' event.
+*
+* Fulfill params: (none)
+* Reject params:
+*   'RadioNotAvailable', 'RequestNotSupported', or 'GenericFailure'
+*
+* @return A deferred promise.
+*/
+function selectNetworkAutomaticallyAndWait() {
+let promises = [];
+promises.push(waitForManagerEvent("voicechange"));
+promises.push(selectNetworkAutomatically());
+return Promise.all(promises);
+}
+/**
+* Set data connection enabling state and wait for "datachange" event.
+*
+* Resolve if data connection state changed to the expected one.  Never reject.
+*
+* Fulfill params: (none)
+*
+* @param aEnabled
+*        A boolean state.
+* @param aServiceId [optional]
+*        A numeric DSDS service id. Default: the one indicated in
+*        start*TestCommon() or 0 if not indicated.
+*
+* @return A deferred promise.
+*/
+function setDataEnabledAndWait(aEnabled, aServiceId) {
+let deferred = Promise.defer();
+let promises = [];
+promises.push(waitForManagerEvent("datachange", aServiceId));
+promises.push(setDataEnabled(aEnabled));
+Promise.all(promises).then(function keepWaiting() {
+let mobileConn = mobileConnection;
+if (aServiceId !== undefined) {
+mobileConn =
+workingFrame.contentWindow.navigator.mozMobileConnections[aServiceId];
+}
+// To ignore some transient states, we only resolve that deferred promise
+// when the |connected| state equals to the expected one and never rejects.
+let connected = mobileConn.data.connected;
+if (connected == aEnabled) {
+deferred.resolve();
+return;
+}
+return waitForManagerEvent("datachange", aServiceId).then(keepWaiting);
+});
+return deferred.promise;
+}
+/**
+* Set voice/data state and wait for state change.
+*
+* Fulfill params: (none)
+*
+* @param aWhich
+*        "voice" or "data".
+* @param aState
+*        "unregistered", "searching", "denied", "roaming", or "home".
+* @param aServiceId [optional]
+*        A numeric DSDS service id. Default: the one indicated in
+*        start*TestCommon() or 0 if not indicated.
+*
+* @return A deferred promise.
+*/
+function setEmulatorVoiceDataStateAndWait(aWhich, aState, aServiceId) {
+let promises = [];
+promises.push(waitForManagerEvent(aWhich + "change", aServiceId));
+let cmd = "gsm " + aWhich + " " + aState;
+promises.push(runEmulatorCmdSafe(cmd));
+return Promise.all(promises);
+}
+/**
+* Set voice and data roaming emulation and wait for state change.
+*
+* Fulfill params: (none)
+*
+* @param aRoaming
+*        A boolean state.
+* @param aServiceId [optional]
+*        A numeric DSDS service id. Default: the one indicated in
+*        start*TestCommon() or 0 if not indicated.
+*
+* @return A deferred promise.
+*/
+function setEmulatorRoamingAndWait(aRoaming, aServiceId) {
+function doSetAndWait(aWhich, aRoaming, aServiceId) {
+let state = (aRoaming ? "roaming" : "home");
+return setEmulatorVoiceDataStateAndWait(aWhich, state, aServiceId)
+.then(() => {
+let mobileConn = mobileConnection;
+if (aServiceId !== undefined) {
+mobileConn =
+workingFrame.contentWindow.navigator.mozMobileConnections[aServiceId];
+}
+is(mobileConn[aWhich].roaming, aRoaming,
+aWhich + ".roaming")
+});
+}
+// Set voice registration state first and then data registration state.
+return doSetAndWait("voice", aRoaming, aServiceId)
+.then(() => doSetAndWait("data", aRoaming, aServiceId));
+}
+/**
+* Get GSM location emulation.
+*
+* Fulfill params:
+*   { lac: <lac>, cid: <cid> }
+* Reject params:
+*   result -- an array of emulator response lines.
+*
+* @return A deferred promise.
+*/
+function getEmulatorGsmLocation() {
+let cmd = "gsm location";
+return runEmulatorCmdSafe(cmd)
+.then(function(aResults) {
+// lac: <lac>
+// ci: <cid>
+// OK
+is(aResults[0].substring(0,3), "lac", "lac output");
+is(aResults[1].substring(0,2), "ci", "ci output");
+let lac = parseInt(aResults[0].substring(5));
+lac = (lac < 0 ? 65535 : lac);
+let cid = parseInt(aResults[1].substring(4));
+cid = (cid < 0 ? 268435455 : cid);
+return { lac: lac, cid: cid };
+});
+}
+/**
+* Set GSM location emulation.
+*
+* Fulfill params: (none)
+* Reject params: (none)
+*
+* @param aLac
+* @param aCid
+*
+* @return A deferred promise.
+*/
+function setEmulatorGsmLocation(aLac, aCid) {
+let cmd = "gsm location " + aLac + " " + aCid;
+return runEmulatorCmdSafe(cmd);
+}
+/**
+* Get emulator operators info.
+*
+* Fulfill params:
+*   An array of { longName: <string>, shortName: <string>, mccMnc: <string> }.
+* Reject params:
+*   result -- an array of emulator response lines.
+*
+* @return A deferred promise.
+*/
+function getEmulatorOperatorNames() {
+let cmd = "operator dumpall";
+return runEmulatorCmdSafe(cmd)
+.then(function(aResults) {
+let operators = [];
+for (let i = 0; i < aResults.length - 1; i++) {
+let names = aResults[i].split(',');
+operators.push({
+longName: names[0],
+shortName: names[1],
+mccMnc: names[2],
+});
+}
+ok(true, "emulator operators list: " + JSON.stringify(operators));
+return operators;
+});
+}
+/**
+* Set emulator operators info.
+*
+* Fulfill params: (none)
+* Reject params:
+*   result -- an array of emulator response lines.
+*
+* @param aOperator
+*        "home" or "roaming".
+* @param aLongName
+*        A string.
+* @param aShortName
+*        A string.
+* @param aMcc [optional]
+*        A string.
+* @param aMnc [optional]
+*        A string.
+*
+* @return A deferred promise.
+*/
+function setEmulatorOperatorNames(aOperator, aLongName, aShortName, aMcc, aMnc) {
+const EMULATOR_OPERATORS = [ "home", "roaming" ];
+let index = EMULATOR_OPERATORS.indexOf(aOperator);
+if (index < 0) {
+throw "invalid operator";
+}
+let cmd = "operator set " + index + " " + aLongName + "," + aShortName;
+if (aMcc && aMnc) {
+cmd = cmd + "," + aMcc + aMnc;
+}
+return runEmulatorCmdSafe(cmd)
+.then(function(aResults) {
+let exp = "^" + aLongName + "," + aShortName + ",";
+if (aMcc && aMnc) {
+cmd = cmd + aMcc + aMnc;
+}
+let re = new RegExp(exp);
+ok(aResults[index].match(new RegExp(exp)),
+"Long/short name and/or mcc/mnc should be changed.");
+});
+}
+let _networkManager;
+/**
+* Get internal NetworkManager service.
+*/
+function getNetworkManager() {
+if (!_networkManager) {
+_networkManager = Cc["@mozilla.org/network/manager;1"]
+.getService(Ci.nsINetworkManager);
+ok(_networkManager, "NetworkManager");
+}
+return _networkManager;
+}
+let _numOfRadioInterfaces;
+/*
+* Get number of radio interfaces. Default is 1 if preference is not set.
+*/
+function getNumOfRadioInterfaces() {
+if (!_numOfRadioInterfaces) {
+try {
+_numOfRadioInterfaces = SpecialPowers.getIntPref("ril.numRadioInterfaces");
+} catch (ex) {
+_numOfRadioInterfaces = 1;  // Pref not set.
+}
+}
+return _numOfRadioInterfaces;
+}
+/**
+* Flush permission settings and call |finish()|.
+*/
+function cleanUp() {
+waitFor(function() {
+SpecialPowers.flushPermissions(function() {
+// Use ok here so that we have at least one test run.
+ok(true, "permissions flushed");
+finish();
+});
+}, function() {
+return _pendingEmulatorCmdCount === 0;
+});
+}
+/**
+* Basic test routine helper for mobile connection tests.
+*
+* This helper does nothing but clean-ups.
+*
+* @param aTestCaseMain
+*        A function that takes no parameter.
+*/
+function startTestBase(aTestCaseMain) {
+Promise.resolve()
+.then(aTestCaseMain)
+.then(cleanUp, function() {
+ok(false, 'promise rejects during test.');
+cleanUp();
+});
+}
+/**
+* Common test routine helper for mobile connection tests.
+*
+* This function ensures global |mobileConnection| variable is available during
+* the process and performs clean-ups as well.
+*
+* @param aTestCaseMain
+*        A function that takes one parameter -- mobileConnection.
+* @param aAdditonalPermissions [optional]
+*        An array of permission strings other than "mobileconnection" to be
+*        pushed. Default: empty string.
+* @param aServiceId [optional]
+*        A numeric DSDS service id. Default: 0.
+*/
+function startTestCommon(aTestCaseMain, aAdditionalPermissions, aServiceId) {
+startTestBase(function() {
+return ensureMobileConnection(aAdditionalPermissions, aServiceId)
+.then(aTestCaseMain);
+});
+}
+/**
+* Common test routine helper for multi-sim mobile connection tests. The test
+* ends immediately if the device tested is not multi-sim.
+*
+* This function ensures global |mobileConnection| variable is available during
+* the process and performs clean-ups as well.
+*
+* @param aTestCaseMain
+*        A function that takes one parameter -- mobileConnection.
+* @param aAdditonalPermissions [optional]
+*        An array of permission strings other than "mobileconnection" to be
+*        pushed. Default: empty string.
+* @param aServiceId [optional]
+*        A numeric DSDS service id. Default: 0.
+*/
+function startDSDSTestCommon(aTestCaseMain, aAdditionalPermissions, aServiceId) {
+if (getNumOfRadioInterfaces() > 1) {
+startTestBase(function() {
+return ensureMobileConnection(aAdditionalPermissions, aServiceId)
+.then(aTestCaseMain);
+});
+} else {
+log("Skipping DSDS tests on single SIM device.")
+ok(true);  // We should run at least one test.
+cleanUp();
+}
+}