From deb826f3fbdac775ab91839a4aae58add20f2e91 Mon Sep 17 00:00:00 2001 From: Alessio Placitelli Date: Fri, 9 Jan 2015 11:18:00 +0100 Subject: [PATCH] Bug 1111022 - Tests for the SelfSupport backend. r=gfritzsche --- browser/modules/test/browser.ini | 4 + .../test/browser_SelfSupportBackend.js | 158 ++++++++++++++++++ layout/tools/reftest/reftest-preferences.js | 3 + testing/mochitest/browser-test.js | 4 + testing/profiles/prefs_general.js | 3 + testing/xpcshell/head.js | 1 + 6 files changed, 173 insertions(+) create mode 100644 browser/modules/test/browser_SelfSupportBackend.js diff --git a/browser/modules/test/browser.ini b/browser/modules/test/browser.ini index a5bfb92a82ae..927644f651f9 100644 --- a/browser/modules/test/browser.ini +++ b/browser/modules/test/browser.ini @@ -12,6 +12,10 @@ support-files = contentSearchSuggestions.xml [browser_NetworkPrioritizer.js] skip-if = e10s # Bug 666804 - Support NetworkPrioritizer in e10s +[browser_SelfSupportBackend.js] +support-files = + ../../components/uitour/test/uitour.html + ../../components/uitour/UITour-lib.js [browser_SignInToWebsite.js] skip-if = e10s # Bug 941426 - SignIntoWebsite.jsm not e10s friendly [browser_taskbar_preview.js] diff --git a/browser/modules/test/browser_SelfSupportBackend.js b/browser/modules/test/browser_SelfSupportBackend.js new file mode 100644 index 000000000000..781d9044c8cc --- /dev/null +++ b/browser/modules/test/browser_SelfSupportBackend.js @@ -0,0 +1,158 @@ +/* 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/. */ + +"use strict"; + +// Pass an empty scope object to the import to prevent "leaked window property" +// errors in tests. +let Preferences = Cu.import("resource://gre/modules/Preferences.jsm", {}).Preferences; +let PromiseUtils = Cu.import("resource://gre/modules/PromiseUtils.jsm", {}).PromiseUtils; +let SelfSupportBackend = + Cu.import("resource:///modules/SelfSupportBackend.jsm", {}).SelfSupportBackend; + +const PREF_SELFSUPPORT_ENABLED = "browser.selfsupport.enabled"; +const PREF_SELFSUPPORT_URL = "browser.selfsupport.url"; +const PREF_UITOUR_ENABLED = "browser.uitour.enabled"; + +const TEST_WAIT_RETRIES = 60; + +const TEST_PAGE_URL = getRootDirectory(gTestPath) + "uitour.html"; + +/** + * Find a browser, with an IFRAME as parent, who has aURL as the source attribute. + * + * @param aURL The URL to look for to identify the browser. + * + * @returns {Object} The browser element or null on failure. + */ +function findSelfSupportBrowser(aURL) { + let frames = Services.appShell.hiddenDOMWindow.document.querySelectorAll('iframe'); + for (let frame of frames) { + try { + let browser = frame.contentDocument.getElementById("win").querySelectorAll('browser')[0]; + let url = browser.getAttribute("src"); + if (url == aURL) { + return browser; + } + } catch (e) { + continue; + } + } + return null; +} + +/** + * Wait for self support page to load. + * + * @param aURL The URL to look for to identify the browser. + * + * @returns {Promise} Return a promise which is resolved when SelfSupport page is fully + * loaded. + */ +function promiseSelfSupportLoad(aURL) { + return new Promise((resolve, reject) => { + // Find the SelfSupport browser. + let browserPromise = waitForConditionPromise(() => !!findSelfSupportBrowser(aURL), + "SelfSupport browser not found.", + TEST_WAIT_RETRIES); + + // Once found, append a "load" listener to catch page loads. + browserPromise.then(() => { + let browser = findSelfSupportBrowser(aURL); + if (browser.contentDocument.readyState === "complete") { + resolve(browser); + } else { + let handler = () => { + browser.removeEventListener("load", handler, true); + resolve(browser); + }; + browser.addEventListener("load", handler, true); + } + }, reject); + }); +} + +/** + * Wait for self support to close. + * + * @param aURL The URL to look for to identify the browser. + * + * @returns {Promise} Return a promise which is resolved when SelfSupport browser cannot + * be found anymore. + */ +function promiseSelfSupportClose(aURL) { + return waitForConditionPromise(() => !findSelfSupportBrowser(aURL), + "SelfSupport browser is still open.", TEST_WAIT_RETRIES); +} + +/** + * Prepare the test environment. + */ +add_task(function* setupEnvironment() { + // We always run the SelfSupportBackend in tests to check for weird behaviours. + // Disable it to test its start-up. + SelfSupportBackend.uninit(); + + // Testing prefs are set via |user_pref|, so we need to get their value in order + // to restore them. + let selfSupportEnabled = Preferences.get(PREF_SELFSUPPORT_ENABLED, true); + let uitourEnabled = Preferences.get(PREF_UITOUR_ENABLED, false); + let selfSupportURL = Preferences.get(PREF_SELFSUPPORT_URL, ""); + + // Enable the SelfSupport backend and set the page URL. We also make sure UITour + // is enabled. + Preferences.set(PREF_SELFSUPPORT_ENABLED, true); + Preferences.set(PREF_UITOUR_ENABLED, true); + Preferences.set(PREF_SELFSUPPORT_URL, TEST_PAGE_URL); + + registerCleanupFunction(() => { + Preferences.set(PREF_SELFSUPPORT_ENABLED, selfSupportEnabled); + Preferences.set(PREF_UITOUR_ENABLED, uitourEnabled); + Preferences.set(PREF_SELFSUPPORT_URL, selfSupportURL); + }); +}); + +/** + * Test that the self support page can use the UITour API and close itself. + */ +add_task(function* test_selfSupport() { + // Initialise the SelfSupport backend and trigger the load. + SelfSupportBackend.init(); + + // SelfSupportBackend waits for "sessionstore-windows-restored" to start loading. Send it. + info("Sending sessionstore-windows-restored"); + Services.obs.notifyObservers(null, "sessionstore-windows-restored", null); + + // Wait for the SelfSupport page to load. + info("Waiting for the SelfSupport local page to load."); + let selfSupportBrowser = yield promiseSelfSupportLoad(TEST_PAGE_URL); + Assert.ok(!!selfSupportBrowser, "SelfSupport browser must exist."); + + // Get a reference to the UITour API. + info("Testing access to the UITour API."); + let contentWindow = + Cu.waiveXrays(selfSupportBrowser.contentDocument.defaultView); + let uitourAPI = contentWindow.Mozilla.UITour; + + // Test the UITour API with a ping. + let pingPromise = new Promise((resolve) => { + uitourAPI.ping(resolve); + }); + yield pingPromise; + + // Close SelfSupport from content. + contentWindow.close(); + + // Wait until SelfSupport closes. + info("Waiting for the SelfSupport to close."); + yield promiseSelfSupportClose(TEST_PAGE_URL); + + // Find the SelfSupport browser, again. We don't expect to find it. + selfSupportBrowser = findSelfSupportBrowser(TEST_PAGE_URL); + Assert.ok(!selfSupportBrowser, "SelfSupport browser must not exist."); + + // We shouldn't need this, but let's keep it to make sure closing SelfSupport twice + // doesn't create any problem. + SelfSupportBackend.uninit(); +}); diff --git a/layout/tools/reftest/reftest-preferences.js b/layout/tools/reftest/reftest-preferences.js index be1363f22522..a4ff8f6e092e 100644 --- a/layout/tools/reftest/reftest-preferences.js +++ b/layout/tools/reftest/reftest-preferences.js @@ -58,3 +58,6 @@ // desired side-effect of preventing our geoip lookup. branch.setBoolPref("browser.search.isUS", true); branch.setCharPref("browser.search.countryCode", "US"); + + // Make sure SelfSupport doesn't hit the network. + branch.setCharPref("browser.selfsupport.url", "https://%(server)s/selfsupport-dummy/"); diff --git a/testing/mochitest/browser-test.js b/testing/mochitest/browser-test.js index 11ada9fd82ef..11cba28e34f9 100644 --- a/testing/mochitest/browser-test.js +++ b/testing/mochitest/browser-test.js @@ -25,6 +25,9 @@ XPCOMUtils.defineLazyModuleGetter(this, "CustomizationTabPreloader", XPCOMUtils.defineLazyModuleGetter(this, "ContentSearch", "resource:///modules/ContentSearch.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "SelfSupportBackend", + "resource:///modules/SelfSupportBackend.jsm"); + const SIMPLETEST_OVERRIDES = ["ok", "is", "isnot", "ise", "todo", "todo_is", "todo_isnot", "info", "expectAssertions", "requestCompleteLog"]; @@ -523,6 +526,7 @@ Tester.prototype = { gBrowser.getNotificationBox(browser).remove(); } + SelfSupportBackend.uninit(); CustomizationTabPreloader.uninit(); SocialFlyout.unload(); SocialShare.uninit(); diff --git a/testing/profiles/prefs_general.js b/testing/profiles/prefs_general.js index d98e80b9a067..a773d09b96b7 100644 --- a/testing/profiles/prefs_general.js +++ b/testing/profiles/prefs_general.js @@ -281,6 +281,9 @@ user_pref("browser.uitour.url", "http://%(server)s/uitour-dummy/tour"); user_pref("browser.search.isUS", true); user_pref("browser.search.countryCode", "US"); +// Make sure the self support tab doesn't hit the network. +user_pref("browser.selfsupport.url", "https://%(server)s/selfsupport-dummy/"); + user_pref("media.eme.enabled", true); user_pref("media.eme.apiVisible", true); diff --git a/testing/xpcshell/head.js b/testing/xpcshell/head.js index 5f46863385cd..e65f1f3fcde8 100644 --- a/testing/xpcshell/head.js +++ b/testing/xpcshell/head.js @@ -1417,5 +1417,6 @@ try { .getService(Components.interfaces.nsIPrefBranch); prefs.setCharPref("media.gmp-manager.url.override", "http://%(server)s/dummy-gmp-manager.xml"); + prefs.setCharPref("browser.selfsupport.url", "https://%(server)s/selfsupport-dummy/"); } } catch (e) { }