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

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

dom/mobilemessage/tests/marionette/head.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:4b63c00c0666
+/* 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;
+let Promise = Cu.import("resource://gre/modules/Promise.jsm").Promise;
+/**
+* Push required permissions and test if |navigator.mozMobileMessage| exists.
+* Resolve if it does, reject otherwise.
+*
+* Fulfill params:
+*   manager -- an reference to navigator.mozMobileMessage.
+*
+* Reject params: (none)
+*
+* @return A deferred promise.
+*/
+let manager;
+function ensureMobileMessage() {
+let deferred = Promise.defer();
+let permissions = [{
+"type": "sms",
+"allow": 1,
+"context": document,
+}];
+SpecialPowers.pushPermissions(permissions, function() {
+ok(true, "permissions pushed: " + JSON.stringify(permissions));
+manager = window.navigator.mozMobileMessage;
+if (manager) {
+log("navigator.mozMobileMessage is instance of " + manager.constructor);
+} else {
+log("navigator.mozMobileMessage is undefined.");
+}
+if (manager instanceof MozMobileMessageManager) {
+deferred.resolve(manager);
+} else {
+deferred.reject();
+}
+});
+return deferred.promise;
+}
+/**
+* Wait for one named MobileMessageManager event.
+*
+* Resolve if that named event occurs.  Never reject.
+*
+* Fulfill params: the DOMEvent passed.
+*
+* @param aEventName
+*        A string event name.
+*
+* @return A deferred promise.
+*/
+function waitForManagerEvent(aEventName) {
+let deferred = Promise.defer();
+manager.addEventListener(aEventName, function onevent(aEvent) {
+manager.removeEventListener(aEventName, onevent);
+ok(true, "MobileMessageManager event '" + aEventName + "' got.");
+deferred.resolve(aEvent);
+});
+return deferred.promise;
+}
+/**
+* Send a SMS message to a single receiver.  Resolve if it succeeds, reject
+* otherwise.
+*
+* Fulfill params:
+*   message -- the sent SmsMessage.
+*
+* Reject params:
+*   error -- a DOMError.
+*
+* @param aReceiver the address of the receiver.
+* @param aText the text body of the message.
+*
+* @return A deferred promise.
+*/
+function sendSmsWithSuccess(aReceiver, aText) {
+let deferred = Promise.defer();
+let request = manager.send(aReceiver, aText);
+request.onsuccess = function(event) {
+deferred.resolve(event.target.result);
+};
+request.onerror = function(event) {
+deferred.reject(event.target.error);
+};
+return deferred.promise;
+}
+/**
+* Send a MMS message with specified parameters.  Resolve if it fails, reject
+* otherwise.
+*
+* Fulfill params:
+*   {
+*     message,  -- the failed MmsMessage
+*     error,    -- error of the send request
+*   }
+*
+* Reject params: (none)
+*
+* @param aMmsParameters a MmsParameters instance.
+*
+* @param aSendParameters a MmsSendParameters instance.
+*
+* @return A deferred promise.
+*/
+function sendMmsWithFailure(aMmsParameters, aSendParameters) {
+let deferred = Promise.defer();
+let result = { message: null, error: null };
+function got(which, value) {
+result[which] = value;
+if (result.message != null && result.error != null) {
+deferred.resolve(result);
+}
+}
+manager.addEventListener("failed", function onfailed(event) {
+manager.removeEventListener("failed", onfailed);
+got("message", event.message);
+});
+let request = manager.sendMMS(aMmsParameters, aSendParameters);
+request.onsuccess = function(event) {
+deferred.reject();
+};
+request.onerror = function(event) {
+got("error", event.target.error);
+}
+return deferred.promise;
+}
+/**
+* Retrieve messages from database.
+*
+* Fulfill params:
+*   messages -- an array of {Sms,Mms}Message instances.
+*
+* Reject params:
+*   event -- a DOMEvent
+*
+* @param aFilter an optional MozSmsFilter instance.
+* @param aReverse a boolean value indicating whether the order of the messages
+*                 should be reversed.
+*
+* @return A deferred promise.
+*/
+function getMessages(aFilter, aReverse) {
+let deferred = Promise.defer();
+if (!aFilter) {
+aFilter = new MozSmsFilter;
+}
+let messages = [];
+let cursor = manager.getMessages(aFilter, aReverse || false);
+cursor.onsuccess = function(aEvent) {
+if (cursor.result) {
+messages.push(cursor.result);
+cursor.continue();
+return;
+}
+deferred.resolve(messages);
+};
+cursor.onerror = deferred.reject.bind(deferred);
+return deferred.promise;
+}
+/**
+* Retrieve all messages from database.
+*
+* Fulfill params:
+*   messages -- an array of {Sms,Mms}Message instances.
+*
+* Reject params:
+*   event -- a DOMEvent
+*
+* @return A deferred promise.
+*/
+function getAllMessages() {
+return getMessages(null, false);
+}
+/**
+* Retrieve all threads from database.
+*
+* Fulfill params:
+*   threads -- an array of MozMobileMessageThread instances.
+*
+* Reject params:
+*   event -- a DOMEvent
+*
+* @return A deferred promise.
+*/
+function getAllThreads() {
+let deferred = Promise.defer();
+let threads = [];
+let cursor = manager.getThreads();
+cursor.onsuccess = function(aEvent) {
+if (cursor.result) {
+threads.push(cursor.result);
+cursor.continue();
+return;
+}
+deferred.resolve(threads);
+};
+cursor.onerror = deferred.reject.bind(deferred);
+return deferred.promise;
+}
+/**
+* Retrieve a single specified thread from database.
+*
+* Fulfill params:
+*   thread -- a MozMobileMessageThread instance.
+*
+* Reject params:
+*   event -- a DOMEvent if an error occurs in the retrieving process, or
+*            undefined if there's no such thread.
+*
+* @aThreadId a numeric value identifying the target thread.
+*
+* @return A deferred promise.
+*/
+function getThreadById(aThreadId) {
+return getAllThreads()
+.then(function(aThreads) {
+for (let thread of aThreads) {
+if (thread.id === aThreadId) {
+return thread;
+}
+}
+throw undefined;
+});
+}
+/**
+* Delete messages specified from database.
+*
+* Fulfill params:
+*   result -- an array of boolean values indicating whether delesion was
+*             actually performed on the message record with corresponding id.
+*
+* Reject params:
+*   event -- a DOMEvent.
+*
+* @aMessageId an array of numeric values identifying the target messages.
+*
+* @return An empty array if nothing to be deleted; otherwise, a deferred promise.
+*/
+function deleteMessagesById(aMessageIds) {
+if (!aMessageIds.length) {
+ok(true, "no message to be deleted");
+return [];
+}
+let deferred = Promise.defer();
+let request = manager.delete(aMessageIds);
+request.onsuccess = function(event) {
+deferred.resolve(event.target.result);
+};
+request.onerror = deferred.reject.bind(deferred);
+return deferred.promise;
+}
+/**
+* Delete messages specified from database.
+*
+* Fulfill params:
+*   result -- an array of boolean values indicating whether delesion was
+*             actually performed on the message record with corresponding id.
+*
+* Reject params:
+*   event -- a DOMEvent.
+*
+* @aMessages an array of {Sms,Mms}Message instances.
+*
+* @return A deferred promise.
+*/
+function deleteMessages(aMessages) {
+let ids = messagesToIds(aMessages);
+return deleteMessagesById(ids);
+}
+/**
+* Delete all messages from database.
+*
+* Fulfill params:
+*   ids -- an array of numeric values identifying those deleted
+*          {Sms,Mms}Messages.
+*
+* Reject params:
+*   event -- a DOMEvent.
+*
+* @return A deferred promise.
+*/
+function deleteAllMessages() {
+return getAllMessages().then(deleteMessages);
+}
+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.
+*
+* @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[0] === "OK") {
+deferred.resolve(aResult);
+} else {
+deferred.reject(aResult);
+}
+});
+return deferred.promise;
+}
+/**
+* Send simple text SMS to emulator.
+*
+* Fulfill params:
+*   result -- an array of emulator response lines.
+*
+* Reject params:
+*   result -- an array of emulator response lines.
+*
+* @return A deferred promise.
+*/
+function sendTextSmsToEmulator(aFrom, aText) {
+let command = "sms send " + aFrom + " " + aText;
+return runEmulatorCmdSafe(command);
+}
+/**
+* Send raw SMS TPDU to emulator.
+*
+* @param: aPdu
+*         A hex string representing the whole SMS T-PDU.
+*
+* Fulfill params:
+*   result -- an array of emulator response lines.
+*
+* Reject params:
+*   result -- an array of emulator response lines.
+*
+* @return A deferred promise.
+*/
+function sendRawSmsToEmulator(aPdu) {
+let command = "sms pdu " + aPdu;
+return runEmulatorCmdSafe(command);
+}
+/**
+* Send multiple raw SMS TPDU to emulator and wait
+*
+* @param: aPdus
+*         A array of hex strings. Each represents a SMS T-PDU.
+*
+* Fulfill params:
+*   result -- array of resolved Promise, where
+*             result[0].message representing the received message.
+*             result[1-n] represents the response of sent emulator command.
+*
+* Reject params:
+*   result -- an array of emulator response lines.
+*
+* @return A deferred promise.
+*/
+function sendMultipleRawSmsToEmulatorAndWait(aPdus) {
+let promises = [];
+promises.push(waitForManagerEvent("received"));
+for (let pdu of aPdus) {
+promises.push(sendRawSmsToEmulator(pdu));
+}
+return Promise.all(promises);
+}
+/**
+* Create a new array of id attribute of input messages.
+*
+* @param aMessages an array of {Sms,Mms}Message instances.
+*
+* @return an array of numeric values.
+*/
+function messagesToIds(aMessages) {
+let ids = [];
+for (let message of aMessages) {
+ids.push(message.id);
+}
+return ids;
+}
+/**
+* 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 message 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 message tests.
+*
+* This function ensures global |manager| variable is available during the
+* process and performs clean-ups as well.
+*
+* @param aTestCaseMain
+*        A function that takes no parameter.
+*/
+function startTestCommon(aTestCaseMain) {
+startTestBase(function() {
+return ensureMobileMessage()
+.then(deleteAllMessages)
+.then(aTestCaseMain)
+.then(deleteAllMessages);
+});
+}
+/**
+* Helper to run the test case only needed in Multi-SIM environment.
+*
+* @param  aTest
+*         A function which will be invoked w/o parameter.
+* @return a Promise object.
+*/
+function runIfMultiSIM(aTest) {
+let numRIL;
+try {
+numRIL = SpecialPowers.getIntPref("ril.numRadioInterfaces");
+} catch (ex) {
+numRIL = 1;  // Pref not set.
+}
+if (numRIL > 1) {
+return aTest();
+} else {
+log("Not a Multi-SIM environment. Test is skipped.");
+return Promise.resolve();
+}
+}