diff options
Diffstat (limited to 'browser/components/extensions/test')
119 files changed, 14599 insertions, 0 deletions
diff --git a/browser/components/extensions/test/browser/.eslintrc.js b/browser/components/extensions/test/browser/.eslintrc.js new file mode 100644 index 000000000..0e673ecb9 --- /dev/null +++ b/browser/components/extensions/test/browser/.eslintrc.js @@ -0,0 +1,36 @@ +"use strict"; + +module.exports = { // eslint-disable-line no-undef + "extends": "../../../../../testing/mochitest/browser.eslintrc.js", + + "env": { + "webextensions": true, + }, + + "globals": { + "NetUtil": true, + "XPCOMUtils": true, + "Task": true, + + // Browser window globals. + "PanelUI": false, + + // Test harness globals + "ExtensionTestUtils": false, + "TestUtils": false, + + "clickBrowserAction": true, + "clickPageAction": true, + "closeContextMenu": true, + "closeExtensionContextMenu": true, + "focusWindow": true, + "makeWidgetId": true, + "openContextMenu": true, + "openExtensionContextMenu": true, + "CustomizableUI": true, + }, + + "rules": { + "no-shadow": 0, + }, +}; diff --git a/browser/components/extensions/test/browser/browser.ini b/browser/components/extensions/test/browser/browser.ini new file mode 100644 index 000000000..1e894dcb5 --- /dev/null +++ b/browser/components/extensions/test/browser/browser.ini @@ -0,0 +1,115 @@ +[DEFAULT] +support-files = + head.js + head_pageAction.js + head_sessions.js + context.html + ctxmenu-image.png + context_tabs_onUpdated_page.html + context_tabs_onUpdated_iframe.html + file_popup_api_injection_a.html + file_popup_api_injection_b.html + file_iframe_document.html + file_iframe_document.sjs + file_bypass_cache.sjs + file_language_fr_en.html + file_language_ja.html + file_language_tlh.html + file_dummy.html + searchSuggestionEngine.xml + searchSuggestionEngine.sjs + ../../../../../toolkit/components/extensions/test/mochitest/head_webrequest.js +tags = webextensions + + +[browser_ext_browserAction_context.js] +[browser_ext_browserAction_disabled.js] +[browser_ext_browserAction_pageAction_icon.js] +[browser_ext_browserAction_pageAction_icon_permissions.js] +[browser_ext_browserAction_popup.js] +[browser_ext_browserAction_popup_resize.js] +[browser_ext_browserAction_simple.js] +[browser_ext_commands_execute_browser_action.js] +[browser_ext_commands_execute_page_action.js] +[browser_ext_commands_getAll.js] +[browser_ext_commands_onCommand.js] +[browser_ext_contentscript_connect.js] +[browser_ext_contextMenus.js] +[browser_ext_contextMenus_checkboxes.js] +[browser_ext_contextMenus_icons.js] +[browser_ext_contextMenus_onclick.js] +[browser_ext_contextMenus_radioGroups.js] +[browser_ext_contextMenus_uninstall.js] +[browser_ext_contextMenus_urlPatterns.js] +[browser_ext_currentWindow.js] +[browser_ext_getViews.js] +[browser_ext_incognito_popup.js] +[browser_ext_incognito_views.js] +[browser_ext_lastError.js] +[browser_ext_legacy_extension_context_contentscript.js] +[browser_ext_omnibox.js] +[browser_ext_optionsPage_privileges.js] +[browser_ext_pageAction_context.js] +[browser_ext_pageAction_popup.js] +[browser_ext_pageAction_popup_resize.js] +[browser_ext_pageAction_simple.js] +[browser_ext_pageAction_title.js] +[browser_ext_popup_api_injection.js] +[browser_ext_popup_background.js] +[browser_ext_popup_corners.js] +[browser_ext_popup_sendMessage.js] +[browser_ext_popup_shutdown.js] +[browser_ext_runtime_openOptionsPage.js] +[browser_ext_runtime_openOptionsPage_uninstall.js] +[browser_ext_runtime_setUninstallURL.js] +[browser_ext_sessions_getRecentlyClosed.js] +[browser_ext_sessions_getRecentlyClosed_private.js] +[browser_ext_sessions_getRecentlyClosed_tabs.js] +[browser_ext_sessions_restore.js] +[browser_ext_simple.js] +[browser_ext_tab_runtimeConnect.js] +[browser_ext_tabs_audio.js] +[browser_ext_tabs_captureVisibleTab.js] +[browser_ext_tabs_create.js] +[browser_ext_tabs_create_invalid_url.js] +[browser_ext_tabs_detectLanguage.js] +[browser_ext_tabs_duplicate.js] +[browser_ext_tabs_events.js] +[browser_ext_tabs_executeScript.js] +[browser_ext_tabs_executeScript_good.js] +[browser_ext_tabs_executeScript_bad.js] +[browser_ext_tabs_executeScript_runAt.js] +[browser_ext_tabs_getCurrent.js] +[browser_ext_tabs_insertCSS.js] +[browser_ext_tabs_removeCSS.js] +[browser_ext_tabs_move.js] +[browser_ext_tabs_move_window.js] +[browser_ext_tabs_move_window_multiple.js] +[browser_ext_tabs_move_window_pinned.js] +[browser_ext_tabs_onHighlighted.js] +[browser_ext_tabs_onUpdated.js] +[browser_ext_tabs_query.js] +[browser_ext_tabs_reload.js] +[browser_ext_tabs_reload_bypass_cache.js] +[browser_ext_tabs_sendMessage.js] +[browser_ext_tabs_cookieStoreId.js] +[browser_ext_tabs_update.js] +[browser_ext_tabs_zoom.js] +[browser_ext_tabs_update_url.js] +[browser_ext_topwindowid.js] +[browser_ext_webNavigation_frameId0.js] +[browser_ext_webNavigation_getFrames.js] +[browser_ext_webNavigation_urlbar_transitions.js] +[browser_ext_webRequest.js] +[browser_ext_windows.js] +[browser_ext_windows_allowScriptsToClose.js] +[browser_ext_windows_create.js] +tags = fullscreen +[browser_ext_windows_create_params.js] +[browser_ext_windows_create_tabId.js] +[browser_ext_windows_create_url.js] +[browser_ext_windows_events.js] +[browser_ext_windows_size.js] +skip-if = os == 'mac' # Fails when windows are randomly opened in fullscreen mode +[browser_ext_windows_update.js] +tags = fullscreen diff --git a/browser/components/extensions/test/browser/browser_ext_browserAction_context.js b/browser/components/extensions/test/browser/browser_ext_browserAction_context.js new file mode 100644 index 000000000..8a26dbb3c --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_browserAction_context.js @@ -0,0 +1,398 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function* runTests(options) { + async function background(getTests) { + async function checkDetails(expecting, tabId) { + let title = await browser.browserAction.getTitle({tabId}); + browser.test.assertEq(expecting.title, title, + "expected value from getTitle"); + + let popup = await browser.browserAction.getPopup({tabId}); + browser.test.assertEq(expecting.popup, popup, + "expected value from getPopup"); + + let badge = await browser.browserAction.getBadgeText({tabId}); + browser.test.assertEq(expecting.badge, badge, + "expected value from getBadge"); + + let badgeBackgroundColor = await browser.browserAction.getBadgeBackgroundColor({tabId}); + browser.test.assertEq(String(expecting.badgeBackgroundColor), + String(badgeBackgroundColor), + "expected value from getBadgeBackgroundColor"); + } + + let expectDefaults = expecting => { + return checkDetails(expecting); + }; + + let tabs = []; + let tests = getTests(tabs, expectDefaults); + + { + let tabId = 0xdeadbeef; + let calls = [ + () => browser.browserAction.enable(tabId), + () => browser.browserAction.disable(tabId), + () => browser.browserAction.setTitle({tabId, title: "foo"}), + () => browser.browserAction.setIcon({tabId, path: "foo.png"}), + () => browser.browserAction.setPopup({tabId, popup: "foo.html"}), + () => browser.browserAction.setBadgeText({tabId, text: "foo"}), + () => browser.browserAction.setBadgeBackgroundColor({tabId, color: [0xff, 0, 0, 0xff]}), + ]; + + for (let call of calls) { + await browser.test.assertRejects( + new Promise(resolve => resolve(call())), + RegExp(`Invalid tab ID: ${tabId}`), + "Expected invalid tab ID error"); + } + } + + // Runs the next test in the `tests` array, checks the results, + // and passes control back to the outer test scope. + function nextTest() { + let test = tests.shift(); + + test(async expecting => { + // Check that the API returns the expected values, and then + // run the next test. + let tabs = await browser.tabs.query({active: true, currentWindow: true}); + await checkDetails(expecting, tabs[0].id); + + // Check that the actual icon has the expected values, then + // run the next test. + browser.test.sendMessage("nextTest", expecting, tests.length); + }); + } + + browser.test.onMessage.addListener((msg) => { + if (msg != "runNextTest") { + browser.test.fail("Expecting 'runNextTest' message"); + } + + nextTest(); + }); + + browser.tabs.query({active: true, currentWindow: true}, resultTabs => { + tabs[0] = resultTabs[0].id; + + nextTest(); + }); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: options.manifest, + + files: options.files || {}, + + background: `(${background})(${options.getTests})`, + }); + + let browserActionId; + function checkDetails(details) { + if (!browserActionId) { + browserActionId = `${makeWidgetId(extension.id)}-browser-action`; + } + + let button = document.getElementById(browserActionId); + + ok(button, "button exists"); + + let title = details.title || options.manifest.name; + + is(getListStyleImage(button), details.icon, "icon URL is correct"); + is(button.getAttribute("tooltiptext"), title, "image title is correct"); + is(button.getAttribute("label"), title, "image label is correct"); + is(button.getAttribute("badge"), details.badge, "badge text is correct"); + is(button.getAttribute("disabled") == "true", Boolean(details.disabled), "disabled state is correct"); + + if (details.badge && details.badgeBackgroundColor) { + let badge = button.ownerDocument.getAnonymousElementByAttribute( + button, "class", "toolbarbutton-badge"); + + let badgeColor = window.getComputedStyle(badge).backgroundColor; + let color = details.badgeBackgroundColor; + let expectedColor = `rgb(${color[0]}, ${color[1]}, ${color[2]})`; + + is(badgeColor, expectedColor, "badge color is correct"); + } + + + // TODO: Popup URL. + } + + let awaitFinish = new Promise(resolve => { + extension.onMessage("nextTest", (expecting, testsRemaining) => { + checkDetails(expecting); + + if (testsRemaining) { + extension.sendMessage("runNextTest"); + } else { + resolve(); + } + }); + }); + + yield extension.startup(); + + yield awaitFinish; + + yield extension.unload(); +} + +add_task(function* testTabSwitchContext() { + yield runTests({ + manifest: { + "browser_action": { + "default_icon": "default.png", + "default_popup": "__MSG_popup__", + "default_title": "Default __MSG_title__", + }, + + "default_locale": "en", + + "permissions": ["tabs"], + }, + + "files": { + "_locales/en/messages.json": { + "popup": { + "message": "default.html", + "description": "Popup", + }, + + "title": { + "message": "Title", + "description": "Title", + }, + }, + + "default.png": imageBuffer, + "default-2.png": imageBuffer, + "1.png": imageBuffer, + "2.png": imageBuffer, + }, + + getTests(tabs, expectDefaults) { + const DEFAULT_BADGE_COLOR = [0xd9, 0, 0, 255]; + + let details = [ + {"icon": browser.runtime.getURL("default.png"), + "popup": browser.runtime.getURL("default.html"), + "title": "Default Title", + "badge": "", + "badgeBackgroundColor": DEFAULT_BADGE_COLOR}, + {"icon": browser.runtime.getURL("1.png"), + "popup": browser.runtime.getURL("default.html"), + "title": "Default Title", + "badge": "", + "badgeBackgroundColor": DEFAULT_BADGE_COLOR}, + {"icon": browser.runtime.getURL("2.png"), + "popup": browser.runtime.getURL("2.html"), + "title": "Title 2", + "badge": "2", + "badgeBackgroundColor": [0xff, 0, 0, 0xff], + "disabled": true}, + {"icon": browser.runtime.getURL("1.png"), + "popup": browser.runtime.getURL("default-2.html"), + "title": "Default Title 2", + "badge": "d2", + "badgeBackgroundColor": [0, 0xff, 0, 0xff], + "disabled": true}, + {"icon": browser.runtime.getURL("1.png"), + "popup": browser.runtime.getURL("default-2.html"), + "title": "Default Title 2", + "badge": "d2", + "badgeBackgroundColor": [0, 0xff, 0, 0xff], + "disabled": false}, + {"icon": browser.runtime.getURL("default-2.png"), + "popup": browser.runtime.getURL("default-2.html"), + "title": "Default Title 2", + "badge": "d2", + "badgeBackgroundColor": [0, 0xff, 0, 0xff]}, + ]; + + return [ + async expect => { + browser.test.log("Initial state, expect default properties."); + + await expectDefaults(details[0]); + expect(details[0]); + }, + async expect => { + browser.test.log("Change the icon in the current tab. Expect default properties excluding the icon."); + browser.browserAction.setIcon({tabId: tabs[0], path: "1.png"}); + + await expectDefaults(details[0]); + expect(details[1]); + }, + async expect => { + browser.test.log("Create a new tab. Expect default properties."); + let tab = await browser.tabs.create({active: true, url: "about:blank?0"}); + tabs.push(tab.id); + + await expectDefaults(details[0]); + expect(details[0]); + }, + async expect => { + browser.test.log("Change properties. Expect new properties."); + let tabId = tabs[1]; + browser.browserAction.setIcon({tabId, path: "2.png"}); + browser.browserAction.setPopup({tabId, popup: "2.html"}); + browser.browserAction.setTitle({tabId, title: "Title 2"}); + browser.browserAction.setBadgeText({tabId, text: "2"}); + browser.browserAction.setBadgeBackgroundColor({tabId, color: "#ff0000"}); + browser.browserAction.disable(tabId); + + await expectDefaults(details[0]); + expect(details[2]); + }, + expect => { + browser.test.log("Navigate to a new page. Expect no changes."); + + // TODO: This listener should not be necessary, but the |tabs.update| + // callback currently fires too early in e10s windows. + browser.tabs.onUpdated.addListener(function listener(tabId, changed) { + if (tabId == tabs[1] && changed.url) { + browser.tabs.onUpdated.removeListener(listener); + expect(details[2]); + } + }); + + browser.tabs.update(tabs[1], {url: "about:blank?1"}); + }, + async expect => { + browser.test.log("Switch back to the first tab. Expect previously set properties."); + await browser.tabs.update(tabs[0], {active: true}); + expect(details[1]); + }, + async expect => { + browser.test.log("Change default values, expect those changes reflected."); + browser.browserAction.setIcon({path: "default-2.png"}); + browser.browserAction.setPopup({popup: "default-2.html"}); + browser.browserAction.setTitle({title: "Default Title 2"}); + browser.browserAction.setBadgeText({text: "d2"}); + browser.browserAction.setBadgeBackgroundColor({color: [0, 0xff, 0, 0xff]}); + browser.browserAction.disable(); + + await expectDefaults(details[3]); + expect(details[3]); + }, + async expect => { + browser.test.log("Re-enable by default. Expect enabled."); + browser.browserAction.enable(); + + await expectDefaults(details[4]); + expect(details[4]); + }, + async expect => { + browser.test.log("Switch back to tab 2. Expect former value, unaffected by changes to defaults in previous step."); + await browser.tabs.update(tabs[1], {active: true}); + + await expectDefaults(details[3]); + expect(details[2]); + }, + async expect => { + browser.test.log("Delete tab, switch back to tab 1. Expect previous results again."); + await browser.tabs.remove(tabs[1]); + expect(details[4]); + }, + async expect => { + browser.test.log("Create a new tab. Expect new default properties."); + let tab = await browser.tabs.create({active: true, url: "about:blank?2"}); + tabs.push(tab.id); + expect(details[5]); + }, + async expect => { + browser.test.log("Delete tab."); + await browser.tabs.remove(tabs[2]); + expect(details[4]); + }, + ]; + }, + }); +}); + +add_task(function* testDefaultTitle() { + yield runTests({ + manifest: { + "name": "Foo Extension", + + "browser_action": { + "default_icon": "icon.png", + }, + + "permissions": ["tabs"], + }, + + files: { + "icon.png": imageBuffer, + }, + + getTests(tabs, expectDefaults) { + const DEFAULT_BADGE_COLOR = [0xd9, 0, 0, 255]; + + let details = [ + {"title": "Foo Extension", + "popup": "", + "badge": "", + "badgeBackgroundColor": DEFAULT_BADGE_COLOR, + "icon": browser.runtime.getURL("icon.png")}, + {"title": "Foo Title", + "popup": "", + "badge": "", + "badgeBackgroundColor": DEFAULT_BADGE_COLOR, + "icon": browser.runtime.getURL("icon.png")}, + {"title": "Bar Title", + "popup": "", + "badge": "", + "badgeBackgroundColor": DEFAULT_BADGE_COLOR, + "icon": browser.runtime.getURL("icon.png")}, + {"title": "", + "popup": "", + "badge": "", + "badgeBackgroundColor": DEFAULT_BADGE_COLOR, + "icon": browser.runtime.getURL("icon.png")}, + ]; + + return [ + async expect => { + browser.test.log("Initial state. Expect extension title as default title."); + + await expectDefaults(details[0]); + expect(details[0]); + }, + async expect => { + browser.test.log("Change the title. Expect new title."); + browser.browserAction.setTitle({tabId: tabs[0], title: "Foo Title"}); + + await expectDefaults(details[0]); + expect(details[1]); + }, + async expect => { + browser.test.log("Change the default. Expect same properties."); + browser.browserAction.setTitle({title: "Bar Title"}); + + await expectDefaults(details[2]); + expect(details[1]); + }, + async expect => { + browser.test.log("Clear the title. Expect new default title."); + browser.browserAction.setTitle({tabId: tabs[0], title: ""}); + + await expectDefaults(details[2]); + expect(details[2]); + }, + async expect => { + browser.test.log("Set default title to null string. Expect null string from API, extension title in UI."); + browser.browserAction.setTitle({title: ""}); + + await expectDefaults(details[3]); + expect(details[3]); + }, + ]; + }, + }); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_browserAction_disabled.js b/browser/components/extensions/test/browser/browser_ext_browserAction_disabled.js new file mode 100644 index 000000000..c0b9c1a1d --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_browserAction_disabled.js @@ -0,0 +1,68 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testDisabled() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": {}, + }, + + background: function() { + let clicked = false; + + browser.browserAction.onClicked.addListener(() => { + browser.test.log("Got click event"); + clicked = true; + }); + + browser.test.onMessage.addListener((msg, expectClick) => { + if (msg == "enable") { + browser.test.log("enable browserAction"); + browser.browserAction.enable(); + } else if (msg == "disable") { + browser.test.log("disable browserAction"); + browser.browserAction.disable(); + } else if (msg == "check-clicked") { + browser.test.assertEq(expectClick, clicked, "got click event?"); + clicked = false; + } else { + browser.test.fail("Unexpected message"); + } + + browser.test.sendMessage("next-test"); + }); + + browser.test.sendMessage("ready"); + }, + }); + + yield extension.startup(); + yield extension.awaitMessage("ready"); + + yield clickBrowserAction(extension); + yield new Promise(resolve => setTimeout(resolve, 0)); + + extension.sendMessage("check-clicked", true); + yield extension.awaitMessage("next-test"); + + extension.sendMessage("disable"); + yield extension.awaitMessage("next-test"); + + yield clickBrowserAction(extension); + yield new Promise(resolve => setTimeout(resolve, 0)); + + extension.sendMessage("check-clicked", false); + yield extension.awaitMessage("next-test"); + + extension.sendMessage("enable"); + yield extension.awaitMessage("next-test"); + + yield clickBrowserAction(extension); + yield new Promise(resolve => setTimeout(resolve, 0)); + + extension.sendMessage("check-clicked", true); + yield extension.awaitMessage("next-test"); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_browserAction_pageAction_icon.js b/browser/components/extensions/test/browser/browser_ext_browserAction_pageAction_icon.js new file mode 100644 index 000000000..9665d6832 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_browserAction_pageAction_icon.js @@ -0,0 +1,321 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +// Test that various combinations of icon details specs, for both paths +// and ImageData objects, result in the correct image being displayed in +// all display resolutions. +add_task(function* testDetailsObjects() { + function background() { + function getImageData(color) { + let canvas = document.createElement("canvas"); + canvas.width = 2; + canvas.height = 2; + let canvasContext = canvas.getContext("2d"); + + canvasContext.clearRect(0, 0, canvas.width, canvas.height); + canvasContext.fillStyle = color; + canvasContext.fillRect(0, 0, 1, 1); + + return { + url: canvas.toDataURL("image/png"), + imageData: canvasContext.getImageData(0, 0, canvas.width, canvas.height), + }; + } + + let imageData = { + red: getImageData("red"), + green: getImageData("green"), + }; + + /* eslint-disable comma-dangle, indent */ + let iconDetails = [ + // Only paths. + {details: {"path": "a.png"}, + resolutions: { + "1": browser.runtime.getURL("data/a.png"), + "2": browser.runtime.getURL("data/a.png")}}, + {details: {"path": "/a.png"}, + resolutions: { + "1": browser.runtime.getURL("a.png"), + "2": browser.runtime.getURL("a.png")}}, + {details: {"path": {"19": "a.png"}}, + resolutions: { + "1": browser.runtime.getURL("data/a.png"), + "2": browser.runtime.getURL("data/a.png")}}, + {details: {"path": {"38": "a.png"}}, + resolutions: { + "1": browser.runtime.getURL("data/a.png"), + "2": browser.runtime.getURL("data/a.png")}}, + {details: {"path": {"19": "a.png", "38": "a-x2.png"}}, + resolutions: { + "1": browser.runtime.getURL("data/a.png"), + "2": browser.runtime.getURL("data/a-x2.png")}}, + + // Test that CSS strings are escaped properly. + {details: {"path": 'a.png#" \\'}, + resolutions: { + "1": browser.runtime.getURL("data/a.png#%22%20%5C"), + "2": browser.runtime.getURL("data/a.png#%22%20%5C")}}, + + // Only ImageData objects. + {details: {"imageData": imageData.red.imageData}, + resolutions: { + "1": imageData.red.url, + "2": imageData.red.url}}, + {details: {"imageData": {"19": imageData.red.imageData}}, + resolutions: { + "1": imageData.red.url, + "2": imageData.red.url}}, + {details: {"imageData": {"38": imageData.red.imageData}}, + resolutions: { + "1": imageData.red.url, + "2": imageData.red.url}}, + {details: {"imageData": { + "19": imageData.red.imageData, + "38": imageData.green.imageData}}, + resolutions: { + "1": imageData.red.url, + "2": imageData.green.url}}, + + // Mixed path and imageData objects. + // + // The behavior is currently undefined if both |path| and + // |imageData| specify icons of the same size. + {details: { + "path": {"19": "a.png"}, + "imageData": {"38": imageData.red.imageData}}, + resolutions: { + "1": browser.runtime.getURL("data/a.png"), + "2": imageData.red.url}}, + {details: { + "path": {"38": "a.png"}, + "imageData": {"19": imageData.red.imageData}}, + resolutions: { + "1": imageData.red.url, + "2": browser.runtime.getURL("data/a.png")}}, + + // A path or ImageData object by itself is treated as a 19px icon. + {details: { + "path": "a.png", + "imageData": {"38": imageData.red.imageData}}, + resolutions: { + "1": browser.runtime.getURL("data/a.png"), + "2": imageData.red.url}}, + {details: { + "path": {"38": "a.png"}, + "imageData": imageData.red.imageData}, + resolutions: { + "1": imageData.red.url, + "2": browser.runtime.getURL("data/a.png")}}, + + // Various resolutions + {details: {"path": {"18": "a.png", "36": "a-x2.png"}}, + legacy: true, + resolutions: { + "1": browser.runtime.getURL("data/a.png"), + "2": browser.runtime.getURL("data/a-x2.png")}}, + {details: {"path": {"16": "a.png", "30": "a-x2.png"}}, + resolutions: { + "1": browser.runtime.getURL("data/a.png"), + "2": browser.runtime.getURL("data/a-x2.png")}}, + {details: {"path": {"16": "16.png", "100": "100.png"}}, + resolutions: { + "1": browser.runtime.getURL("data/16.png"), + "2": browser.runtime.getURL("data/100.png")}}, + {details: {"path": {"2": "2.png"}}, + resolutions: { + "1": browser.runtime.getURL("data/2.png"), + "2": browser.runtime.getURL("data/2.png")}}, + {details: {"path": { + "16": "16.svg", + "18": "18.svg"}}, + resolutions: { + "1": browser.runtime.getURL("data/16.svg"), + "2": browser.runtime.getURL("data/18.svg")}}, + {details: {"path": { + "6": "6.png", + "18": "18.png", + "36": "36.png", + "48": "48.png", + "128": "128.png"}}, + legacy: true, + resolutions: { + "1": browser.runtime.getURL("data/18.png"), + "2": browser.runtime.getURL("data/36.png")}, + menuResolutions: { + "1": browser.runtime.getURL("data/36.png"), + "2": browser.runtime.getURL("data/128.png")}}, + {details: {"path": { + "16": "16.png", + "18": "18.png", + "32": "32.png", + "48": "48.png", + "64": "64.png", + "128": "128.png"}}, + resolutions: { + "1": browser.runtime.getURL("data/16.png"), + "2": browser.runtime.getURL("data/32.png")}, + menuResolutions: { + "1": browser.runtime.getURL("data/32.png"), + "2": browser.runtime.getURL("data/64.png")}}, + {details: {"path": { + "18": "18.png", + "32": "32.png", + "48": "48.png", + "128": "128.png"}}, + resolutions: { + "1": browser.runtime.getURL("data/32.png"), + "2": browser.runtime.getURL("data/32.png")}}, + ]; + + // Allow serializing ImageData objects for logging. + ImageData.prototype.toJSON = () => "<ImageData>"; + + let tabId; + + browser.test.onMessage.addListener((msg, test) => { + if (msg != "setIcon") { + browser.test.fail("expecting 'setIcon' message"); + } + + let details = iconDetails[test.index]; + + let detailString = JSON.stringify(details); + browser.test.log(`Setting browerAction/pageAction to ${detailString} expecting URLs ${JSON.stringify(details.resolutions)}`); + + Promise.all([ + browser.browserAction.setIcon(Object.assign({tabId}, details.details)), + browser.pageAction.setIcon(Object.assign({tabId}, details.details)), + ]).then(() => { + browser.test.sendMessage("iconSet"); + }); + }); + + // Generate a list of tests and resolutions to send back to the test + // context. + // + // This process is a bit convoluted, because the outer test context needs + // to handle checking the button nodes and changing the screen resolution, + // but it can't pass us icon definitions with ImageData objects. This + // shouldn't be a problem, since structured clones should handle ImageData + // objects without issue. Unfortunately, |cloneInto| implements a slightly + // different algorithm than we use in web APIs, and does not handle them + // correctly. + let tests = []; + for (let [idx, icon] of iconDetails.entries()) { + tests.push({ + index: idx, + legacy: !!icon.legacy, + menuResolutions: icon.menuResolutions, + resolutions: icon.resolutions, + }); + } + + // Sort by resolution, so we don't needlessly switch back and forth + // between each test. + tests.sort(test => test.resolution); + + browser.tabs.query({active: true, currentWindow: true}, tabs => { + tabId = tabs[0].id; + browser.pageAction.show(tabId).then(() => { + browser.test.sendMessage("ready", tests); + }); + }); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": {}, + "page_action": {}, + "background": { + "page": "data/background.html", + } + }, + + files: { + "data/background.html": `<script src="background.js"></script>`, + "data/background.js": background, + + "data/16.svg": imageBuffer, + "data/18.svg": imageBuffer, + + "data/16.png": imageBuffer, + "data/18.png": imageBuffer, + "data/32.png": imageBuffer, + "data/36.png": imageBuffer, + "data/48.png": imageBuffer, + "data/64.png": imageBuffer, + "data/128.png": imageBuffer, + + "a.png": imageBuffer, + "data/2.png": imageBuffer, + "data/100.png": imageBuffer, + "data/a.png": imageBuffer, + "data/a-x2.png": imageBuffer, + }, + }); + + const RESOLUTION_PREF = "layout.css.devPixelsPerPx"; + + yield extension.startup(); + + let pageActionId = `${makeWidgetId(extension.id)}-page-action`; + let browserActionWidget = getBrowserActionWidget(extension); + + let tests = yield extension.awaitMessage("ready"); + for (let test of tests) { + extension.sendMessage("setIcon", test); + yield extension.awaitMessage("iconSet"); + + let browserActionButton = browserActionWidget.forWindow(window).node; + let pageActionImage = document.getElementById(pageActionId); + + + // Test icon sizes in the toolbar/urlbar. + for (let resolution of Object.keys(test.resolutions)) { + yield SpecialPowers.pushPrefEnv({set: [[RESOLUTION_PREF, resolution]]}); + + is(window.devicePixelRatio, +resolution, "window has the required resolution"); + + let imageURL = test.resolutions[resolution]; + is(getListStyleImage(browserActionButton), imageURL, `browser action has the correct image at ${resolution}x resolution`); + is(getListStyleImage(pageActionImage), imageURL, `page action has the correct image at ${resolution}x resolution`); + + let isLegacy = browserActionButton.classList.contains("toolbarbutton-legacy-addon"); + is(isLegacy, test.legacy, "Legacy class should be present?"); + + yield SpecialPowers.popPrefEnv(); + } + + if (!test.menuResolutions) { + continue; + } + + + // Test icon sizes in the menu panel. + CustomizableUI.addWidgetToArea(browserActionWidget.id, + CustomizableUI.AREA_PANEL); + + yield showBrowserAction(extension); + browserActionButton = browserActionWidget.forWindow(window).node; + + for (let resolution of Object.keys(test.menuResolutions)) { + yield SpecialPowers.pushPrefEnv({set: [[RESOLUTION_PREF, resolution]]}); + + is(window.devicePixelRatio, +resolution, "window has the required resolution"); + + let imageURL = test.menuResolutions[resolution]; + is(getListStyleImage(browserActionButton), imageURL, `browser action has the correct menu image at ${resolution}x resolution`); + + yield SpecialPowers.popPrefEnv(); + } + + yield closeBrowserAction(extension); + + CustomizableUI.addWidgetToArea(browserActionWidget.id, + CustomizableUI.AREA_NAVBAR); + } + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_browserAction_pageAction_icon_permissions.js b/browser/components/extensions/test/browser/browser_ext_browserAction_pageAction_icon_permissions.js new file mode 100644 index 000000000..110746cae --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_browserAction_pageAction_icon_permissions.js @@ -0,0 +1,210 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +// Test that an error is thrown when providing invalid icon sizes +add_task(function* testInvalidIconSizes() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": {}, + "page_action": {}, + }, + + background: function() { + browser.tabs.query({active: true, currentWindow: true}, tabs => { + let tabId = tabs[0].id; + + let promises = []; + for (let api of ["pageAction", "browserAction"]) { + // helper function to run setIcon and check if it fails + let assertSetIconThrows = function(detail, error, message) { + detail.tabId = tabId; + promises.push( + browser.test.assertRejects( + browser[api].setIcon(detail), + /must be an integer/, + "setIcon with invalid icon size")); + }; + + let imageData = new ImageData(1, 1); + + // test invalid icon size inputs + for (let type of ["path", "imageData"]) { + let img = type == "imageData" ? imageData : "test.png"; + + assertSetIconThrows({[type]: {"abcdef": img}}); + assertSetIconThrows({[type]: {"48px": img}}); + assertSetIconThrows({[type]: {"20.5": img}}); + assertSetIconThrows({[type]: {"5.0": img}}); + assertSetIconThrows({[type]: {"-300": img}}); + assertSetIconThrows({[type]: {"abc": img, "5": img}}); + } + + assertSetIconThrows({imageData: {"abcdef": imageData}, path: {"5": "test.png"}}); + assertSetIconThrows({path: {"abcdef": "test.png"}, imageData: {"5": imageData}}); + } + + Promise.all(promises).then(() => { + browser.test.notifyPass("setIcon with invalid icon size"); + }); + }); + }, + }); + + yield Promise.all([extension.startup(), extension.awaitFinish("setIcon with invalid icon size")]); + + yield extension.unload(); +}); + + +// Test that default icon details in the manifest.json file are handled +// correctly. +add_task(function* testDefaultDetails() { + // TODO: Test localized variants. + let icons = [ + "foo/bar.png", + "/foo/bar.png", + {"19": "foo/bar.png"}, + {"38": "foo/bar.png"}, + ]; + + if (window.devicePixelRatio > 1) { + icons.push({"19": "baz/quux.png", "38": "foo/bar.png"}); + } else { + icons.push({"19": "foo/bar.png", "38": "baz/quux@2x.png"}); + } + + let expectedURL = new RegExp(String.raw`^moz-extension://[^/]+/foo/bar\.png$`); + + for (let icon of icons) { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": {"default_icon": icon}, + "page_action": {"default_icon": icon}, + }, + + background: function() { + browser.tabs.query({active: true, currentWindow: true}, tabs => { + let tabId = tabs[0].id; + + browser.pageAction.show(tabId).then(() => { + browser.test.sendMessage("ready"); + }); + }); + }, + + files: { + "foo/bar.png": imageBuffer, + "baz/quux.png": imageBuffer, + "baz/quux@2x.png": imageBuffer, + }, + }); + + yield Promise.all([extension.startup(), extension.awaitMessage("ready")]); + + let browserActionId = makeWidgetId(extension.id) + "-browser-action"; + let pageActionId = makeWidgetId(extension.id) + "-page-action"; + + let browserActionButton = document.getElementById(browserActionId); + let image = getListStyleImage(browserActionButton); + + ok(expectedURL.test(image), `browser action image ${image} matches ${expectedURL}`); + + let pageActionImage = document.getElementById(pageActionId); + image = getListStyleImage(pageActionImage); + + ok(expectedURL.test(image), `page action image ${image} matches ${expectedURL}`); + + yield extension.unload(); + + let node = document.getElementById(pageActionId); + is(node, null, "pageAction image removed from document"); + } +}); + + +// Check that attempts to load a privileged URL as an icon image fail. +add_task(function* testSecureURLsDenied() { + // Test URLs passed to setIcon. + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": {}, + "page_action": {}, + }, + + background: function() { + browser.tabs.query({active: true, currentWindow: true}, tabs => { + let tabId = tabs[0].id; + + let urls = ["chrome://browser/content/browser.xul", + "javascript:true"]; + + let promises = []; + for (let url of urls) { + for (let api of ["pageAction", "browserAction"]) { + promises.push( + browser.test.assertRejects( + browser[api].setIcon({tabId, path: url}), + /Illegal URL/, + `Load of '${url}' should fail.`)); + } + } + + Promise.all(promises).then(() => { + browser.test.notifyPass("setIcon security tests"); + }); + }); + }, + }); + + yield extension.startup(); + + yield extension.awaitFinish("setIcon security tests"); + yield extension.unload(); +}); + + +add_task(function* testSecureManifestURLsDenied() { + // Test URLs included in the manifest. + + let urls = ["chrome://browser/content/browser.xul", + "javascript:true"]; + + let apis = ["browser_action", "page_action"]; + + for (let url of urls) { + for (let api of apis) { + info(`TEST ${api} icon url: ${url}`); + + let matchURLForbidden = url => ({ + message: new RegExp(`match the format "strictRelativeUrl"`), + }); + + let messages = [matchURLForbidden(url)]; + + let waitForConsole = new Promise(resolve => { + // Not necessary in browser-chrome tests, but monitorConsole gripes + // if we don't call it. + SimpleTest.waitForExplicitFinish(); + + SimpleTest.monitorConsole(resolve, messages); + }); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + [api]: { + "default_icon": url, + }, + }, + }); + + yield Assert.rejects(extension.startup(), + null, + "Manifest rejected"); + + SimpleTest.endMonitorConsole(); + yield waitForConsole; + } + } +}); diff --git a/browser/components/extensions/test/browser/browser_ext_browserAction_popup.js b/browser/components/extensions/test/browser/browser_ext_browserAction_popup.js new file mode 100644 index 000000000..9f04b3c11 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_browserAction_popup.js @@ -0,0 +1,413 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function getBrowserAction(extension) { + const {GlobalManager, Management: {global: {browserActionFor}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + let ext = GlobalManager.extensionMap.get(extension.id); + return browserActionFor(ext); +} + +let scriptPage = url => `<html><head><meta charset="utf-8"><script src="${url}"></script></head><body>${url}</body></html>`; + +function* testInArea(area) { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "background": { + "page": "data/background.html", + }, + "browser_action": { + "default_popup": "popup-a.html", + "browser_style": true, + }, + }, + + files: { + "popup-a.html": scriptPage("popup-a.js"), + "popup-a.js": function() { + window.onload = () => { + let color = window.getComputedStyle(document.body).color; + browser.test.assertEq("rgb(34, 36, 38)", color); + browser.runtime.sendMessage("from-popup-a"); + }; + browser.runtime.onMessage.addListener(msg => { + if (msg == "close-popup-using-window.close") { + window.close(); + } + }); + }, + + "data/popup-b.html": scriptPage("popup-b.js"), + "data/popup-b.js": function() { + window.onload = () => { + browser.runtime.sendMessage("from-popup-b"); + }; + }, + + "data/popup-c.html": scriptPage("popup-c.js"), + "data/popup-c.js": function() { + // Close the popup before the document is fully-loaded to make sure that + // we handle this case sanely. + browser.runtime.sendMessage("from-popup-c"); + window.close(); + }, + + "data/background.html": scriptPage("background.js"), + + "data/background.js": function() { + let sendClick; + let tests = [ + () => { + browser.test.log(`Click browser action, expect popup "a".`); + sendClick({expectEvent: false, expectPopup: "a"}); + }, + () => { + browser.test.log(`Click browser action again, expect popup "a".`); + sendClick({expectEvent: false, expectPopup: "a"}); + }, + () => { + browser.test.log(`Call triggerAction, expect popup "a" again. Leave popup open.`); + sendClick({expectEvent: false, expectPopup: "a", closePopup: false}, "trigger-action"); + }, + () => { + browser.test.log(`Call triggerAction again. Expect remaining popup closed.`); + sendClick({expectEvent: false, expectPopup: null}, "trigger-action"); + browser.test.sendMessage("next-test", {waitUntilClosed: true}); + }, + () => { + browser.test.log(`Call triggerAction again. Expect popup "a" again.`); + sendClick({expectEvent: false, expectPopup: "a"}, "trigger-action"); + }, + () => { + browser.test.log(`Set popup to "c" and click browser action. Expect popup "c".`); + browser.browserAction.setPopup({popup: "popup-c.html"}); + sendClick({expectEvent: false, expectPopup: "c", closePopup: false}); + }, + () => { + browser.test.log(`Set popup to "b" and click browser action. Expect popup "b".`); + browser.browserAction.setPopup({popup: "popup-b.html"}); + sendClick({expectEvent: false, expectPopup: "b"}); + }, + () => { + browser.test.log(`Click browser action again, expect popup "b".`); + sendClick({expectEvent: false, expectPopup: "b"}); + }, + () => { + browser.test.log(`Clear popup URL. Click browser action. Expect click event.`); + browser.browserAction.setPopup({popup: ""}); + sendClick({expectEvent: true, expectPopup: null}); + }, + () => { + browser.test.log(`Click browser action again. Expect another click event.`); + sendClick({expectEvent: true, expectPopup: null}); + }, + () => { + browser.test.log(`Call triggerAction. Expect click event.`); + sendClick({expectEvent: true, expectPopup: null}, "trigger-action"); + }, + () => { + browser.test.log(`Set popup to "a" and click browser action. Expect popup "a", and leave open.`); + browser.browserAction.setPopup({popup: "/popup-a.html"}); + sendClick({expectEvent: false, expectPopup: "a", closePopup: false}); + }, + () => { + browser.test.log(`Tell popup "a" to call window.close(). Expect popup closed.`); + browser.test.sendMessage("next-test", {closePopupUsingWindow: true}); + }, + ]; + + let expect = {}; + sendClick = ({expectEvent, expectPopup, runNextTest, waitUntilClosed, closePopup}, message = "send-click") => { + if (closePopup == undefined) { + closePopup = true; + } + + expect = {event: expectEvent, popup: expectPopup, runNextTest, waitUntilClosed, closePopup}; + browser.test.sendMessage(message); + }; + + browser.runtime.onMessage.addListener(msg => { + if (msg == "close-popup-using-window.close") { + return; + } else if (expect.popup) { + browser.test.assertEq(msg, `from-popup-${expect.popup}`, + "expected popup opened"); + } else { + browser.test.fail(`unexpected popup: ${msg}`); + } + + expect.popup = null; + browser.test.sendMessage("next-test", expect); + }); + + browser.browserAction.onClicked.addListener(() => { + if (expect.event) { + browser.test.succeed("expected click event received"); + } else { + browser.test.fail("unexpected click event"); + } + + expect.event = false; + browser.test.sendMessage("next-test", expect); + }); + + browser.test.onMessage.addListener((msg) => { + if (msg == "close-popup-using-window.close") { + browser.runtime.sendMessage("close-popup-using-window.close"); + return; + } + + if (msg != "next-test") { + browser.test.fail("Expecting 'next-test' message"); + } + + if (tests.length) { + let test = tests.shift(); + test(); + } else { + browser.test.notifyPass("browseraction-tests-done"); + } + }); + + browser.test.sendMessage("next-test"); + }, + }, + }); + + extension.onMessage("send-click", () => { + clickBrowserAction(extension); + }); + + extension.onMessage("trigger-action", () => { + getBrowserAction(extension).triggerAction(window); + }); + + let widget; + extension.onMessage("next-test", Task.async(function* (expecting = {}) { + if (!widget) { + widget = getBrowserActionWidget(extension); + CustomizableUI.addWidgetToArea(widget.id, area); + } + if (expecting.waitUntilClosed) { + let panel = getBrowserActionPopup(extension); + if (panel && panel.state != "closed") { + yield promisePopupHidden(panel); + } + } else if (expecting.closePopupUsingWindow) { + let panel = getBrowserActionPopup(extension); + ok(panel, "Expect panel to exist"); + yield promisePopupShown(panel); + + extension.sendMessage("close-popup-using-window.close"); + + yield promisePopupHidden(panel); + ok(true, "Panel is closed"); + } else if (expecting.closePopup) { + yield closeBrowserAction(extension); + } + + extension.sendMessage("next-test"); + })); + + yield Promise.all([extension.startup(), extension.awaitFinish("browseraction-tests-done")]); + + yield extension.unload(); + + let view = document.getElementById(widget.viewId); + is(view, null, "browserAction view removed from document"); +} + +add_task(function* testBrowserActionInToolbar() { + yield testInArea(CustomizableUI.AREA_NAVBAR); +}); + +add_task(function* testBrowserActionInPanel() { + yield testInArea(CustomizableUI.AREA_PANEL); +}); + +add_task(function* testBrowserActionClickCanceled() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": { + "default_popup": "popup.html", + "browser_style": true, + }, + "permissions": ["activeTab"], + }, + + files: { + "popup.html": `<!DOCTYPE html><html><head><meta charset="utf-8"></head></html>`, + }, + }); + + yield extension.startup(); + + const {GlobalManager, Management: {global: {browserActionFor}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + let ext = GlobalManager.extensionMap.get(extension.id); + let browserAction = browserActionFor(ext); + + let widget = getBrowserActionWidget(extension).forWindow(window); + let tab = window.gBrowser.selectedTab; + + // Test canceled click. + EventUtils.synthesizeMouseAtCenter(widget.node, {type: "mousedown", button: 0}, window); + + isnot(browserAction.pendingPopup, null, "Have pending popup"); + is(browserAction.pendingPopup.window, window, "Have pending popup for the correct window"); + + is(browserAction.pendingPopupTimeout, null, "Have no pending popup timeout"); + + is(browserAction.tabToRevokeDuringClearPopup, tab, "Tab to revoke was saved"); + is(browserAction.tabManager.hasActiveTabPermission(tab), true, "Active tab was granted permission"); + + EventUtils.synthesizeMouseAtCenter(document.documentElement, {type: "mouseup", button: 0}, window); + + is(browserAction.pendingPopup, null, "Pending popup was cleared"); + is(browserAction.pendingPopupTimeout, null, "Have no pending popup timeout"); + + is(browserAction.tabToRevokeDuringClearPopup, null, "Tab to revoke was removed"); + is(browserAction.tabManager.hasActiveTabPermission(tab), false, "Permission was revoked from tab"); + + // Test completed click. + EventUtils.synthesizeMouseAtCenter(widget.node, {type: "mousedown", button: 0}, window); + + isnot(browserAction.pendingPopup, null, "Have pending popup"); + is(browserAction.pendingPopup.window, window, "Have pending popup for the correct window"); + + is(browserAction.pendingPopupTimeout, null, "Have no pending popup timeout"); + + // We need to do these tests during the mouseup event cycle, since the click + // and command events will be dispatched immediately after mouseup, and void + // the results. + let mouseUpPromise = BrowserTestUtils.waitForEvent(widget.node, "mouseup", false, event => { + isnot(browserAction.pendingPopup, null, "Pending popup was not cleared"); + isnot(browserAction.pendingPopupTimeout, null, "Have a pending popup timeout"); + return true; + }); + + EventUtils.synthesizeMouseAtCenter(widget.node, {type: "mouseup", button: 0}, window); + + yield mouseUpPromise; + + is(browserAction.pendingPopup, null, "Pending popup was cleared"); + is(browserAction.pendingPopupTimeout, null, "Pending popup timeout was cleared"); + + yield promisePopupShown(getBrowserActionPopup(extension)); + yield closeBrowserAction(extension); + + yield extension.unload(); +}); + +add_task(function* testBrowserActionDisabled() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": { + "default_popup": "popup.html", + "browser_style": true, + }, + }, + + background() { + browser.browserAction.disable(); + }, + + files: { + "popup.html": `<!DOCTYPE html><html><head><meta charset="utf-8"><script src="popup.js"></script></head></html>`, + "popup.js"() { + browser.test.fail("Should not get here"); + }, + }, + }); + + yield extension.startup(); + + const {GlobalManager, Management: {global: {browserActionFor}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + let ext = GlobalManager.extensionMap.get(extension.id); + let browserAction = browserActionFor(ext); + + let widget = getBrowserActionWidget(extension).forWindow(window); + + // Test canceled click. + EventUtils.synthesizeMouseAtCenter(widget.node, {type: "mousedown", button: 0}, window); + + is(browserAction.pendingPopup, null, "Have no pending popup"); + is(browserAction.pendingPopupTimeout, null, "Have no pending popup timeout"); + + EventUtils.synthesizeMouseAtCenter(document.documentElement, {type: "mouseup", button: 0}, window); + + is(browserAction.pendingPopup, null, "Have no pending popup"); + is(browserAction.pendingPopupTimeout, null, "Have no pending popup timeout"); + + + // Test completed click. + EventUtils.synthesizeMouseAtCenter(widget.node, {type: "mousedown", button: 0}, window); + + is(browserAction.pendingPopup, null, "Have no pending popup"); + is(browserAction.pendingPopupTimeout, null, "Have no pending popup timeout"); + + // We need to do these tests during the mouseup event cycle, since the click + // and command events will be dispatched immediately after mouseup, and void + // the results. + let mouseUpPromise = BrowserTestUtils.waitForEvent(widget.node, "mouseup", false, event => { + is(browserAction.pendingPopup, null, "Have no pending popup"); + is(browserAction.pendingPopupTimeout, null, "Have no pending popup timeout"); + return true; + }); + + EventUtils.synthesizeMouseAtCenter(widget.node, {type: "mouseup", button: 0}, window); + + yield mouseUpPromise; + + is(browserAction.pendingPopup, null, "Have no pending popup"); + is(browserAction.pendingPopupTimeout, null, "Have no pending popup timeout"); + + // Give the popup a chance to load and trigger a failure, if it was + // erroneously opened. + yield new Promise(resolve => setTimeout(resolve, 250)); + + yield extension.unload(); +}); + +add_task(function* testBrowserActionTabPopulation() { + // Note: This test relates to https://bugzilla.mozilla.org/show_bug.cgi?id=1310019 + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": { + "default_popup": "popup.html", + "browser_style": true, + }, + "permissions": ["activeTab"], + }, + + files: { + "popup.html": scriptPage("popup.js"), + "popup.js": function() { + browser.tabs.query({active: true, currentWindow: true}).then(tabs => { + browser.test.assertEq("mochitest index /", + tabs[0].title, + "Tab has the expected title on first click"); + browser.test.sendMessage("tabTitle"); + }); + }, + }, + }); + + let win = yield BrowserTestUtils.openNewBrowserWindow(); + yield BrowserTestUtils.loadURI(win.gBrowser.selectedBrowser, "http://example.com/"); + yield BrowserTestUtils.browserLoaded(win.gBrowser.selectedBrowser); + + yield extension.startup(); + + let widget = getBrowserActionWidget(extension).forWindow(win); + EventUtils.synthesizeMouseAtCenter(widget.node, {type: "mousedown", button: 0}, win); + + yield extension.awaitMessage("tabTitle"); + + EventUtils.synthesizeMouseAtCenter(widget.node, {type: "mouseup", button: 0}, win); + + yield extension.unload(); + yield BrowserTestUtils.closeWindow(win); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_browserAction_popup_resize.js b/browser/components/extensions/test/browser/browser_ext_browserAction_popup_resize.js new file mode 100644 index 000000000..6c19b17f1 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_browserAction_popup_resize.js @@ -0,0 +1,304 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function* openPanel(extension, win = window, awaitLoad = false) { + clickBrowserAction(extension, win); + + return yield awaitExtensionPanel(extension, win, awaitLoad); +} + +add_task(function* testBrowserActionPopupResize() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": { + "default_popup": "popup.html", + "browser_style": true, + }, + }, + + files: { + "popup.html": '<!DOCTYPE html><html><head><meta charset="utf-8"></head></html>', + }, + }); + + yield extension.startup(); + + let browser = yield openPanel(extension); + + function* checkSize(expected) { + let dims = yield promiseContentDimensions(browser); + + is(dims.window.innerHeight, expected, `Panel window should be ${expected}px tall`); + is(dims.body.clientHeight, dims.body.scrollHeight, + "Panel body should be tall enough to fit its contents"); + + // Tolerate if it is 1px too wide, as that may happen with the current resizing method. + ok(Math.abs(dims.window.innerWidth - expected) <= 1, `Panel window should be ${expected}px wide`); + is(dims.body.clientWidth, dims.body.scrollWidth, + "Panel body should be wide enough to fit its contents"); + } + + /* eslint-disable mozilla/no-cpows-in-tests */ + function setSize(size) { + content.document.body.style.height = `${size}px`; + content.document.body.style.width = `${size}px`; + } + /* eslint-enable mozilla/no-cpows-in-tests */ + + let sizes = [ + 200, + 400, + 300, + ]; + + for (let size of sizes) { + yield alterContent(browser, setSize, size); + yield checkSize(size); + } + + yield closeBrowserAction(extension); + yield extension.unload(); +}); + +function* testPopupSize(standardsMode, browserWin = window, arrowSide = "top") { + let docType = standardsMode ? "<!DOCTYPE html>" : ""; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": { + "default_popup": "popup.html", + "browser_style": false, + }, + }, + + files: { + "popup.html": `${docType} + <html> + <head> + <meta charset="utf-8"> + <style type="text/css"> + body > span { + display: inline-block; + width: 10px; + height: 150px; + border: 2px solid black; + } + .big > span { + width: 300px; + height: 100px; + } + .bigger > span { + width: 150px; + height: 150px; + } + .huge > span { + height: ${2 * screen.height}px; + } + </style> + </head> + <body> + <span></span> + <span></span> + <span></span> + <span></span> + </body> + </html>`, + }, + }); + + yield extension.startup(); + + /* eslint-disable mozilla/no-cpows-in-tests */ + + if (arrowSide == "top") { + // Test the standalone panel for a toolbar button. + let browser = yield openPanel(extension, browserWin, true); + + let dims = yield promiseContentDimensions(browser); + + is(dims.isStandards, standardsMode, "Document has the expected compat mode"); + + let {innerWidth, innerHeight} = dims.window; + + dims = yield alterContent(browser, () => { + content.document.body.classList.add("bigger"); + }); + + let win = dims.window; + is(win.innerHeight, innerHeight, "Window height should not change"); + ok(win.innerWidth > innerWidth, `Window width should increase (${win.innerWidth} > ${innerWidth})`); + + + dims = yield alterContent(browser, () => { + content.document.body.classList.remove("bigger"); + }); + + win = dims.window; + is(win.innerHeight, innerHeight, "Window height should not change"); + + // The getContentSize calculation is not always reliable to single-pixel + // precision. + ok(Math.abs(win.innerWidth - innerWidth) <= 1, + `Window width should return to approximately its original value (${win.innerWidth} ~= ${innerWidth})`); + + yield closeBrowserAction(extension, browserWin); + } + + + // Test the PanelUI panel for a menu panel button. + let widget = getBrowserActionWidget(extension); + CustomizableUI.addWidgetToArea(widget.id, CustomizableUI.AREA_PANEL); + + let browser = yield openPanel(extension, browserWin); + + let {panel} = browserWin.PanelUI; + let origPanelRect = panel.getBoundingClientRect(); + + // Check that the panel is still positioned as expected. + let checkPanelPosition = () => { + is(panel.getAttribute("side"), arrowSide, "Panel arrow is positioned as expected"); + + let panelRect = panel.getBoundingClientRect(); + if (arrowSide == "top") { + ok(panelRect.top, origPanelRect.top, "Panel has not moved downwards"); + ok(panelRect.bottom >= origPanelRect.bottom, `Panel has not shrunk from original size (${panelRect.bottom} >= ${origPanelRect.bottom})`); + + let screenBottom = browserWin.screen.availTop + browserWin.screen.availHeight; + let panelBottom = browserWin.mozInnerScreenY + panelRect.bottom; + ok(panelBottom <= screenBottom, `Bottom of popup should be on-screen. (${panelBottom} <= ${screenBottom})`); + } else { + ok(panelRect.bottom, origPanelRect.bottom, "Panel has not moved upwards"); + ok(panelRect.top <= origPanelRect.top, `Panel has not shrunk from original size (${panelRect.top} <= ${origPanelRect.top})`); + + let panelTop = browserWin.mozInnerScreenY + panelRect.top; + ok(panelTop >= browserWin.screen.availTop, `Top of popup should be on-screen. (${panelTop} >= ${browserWin.screen.availTop})`); + } + }; + + yield awaitBrowserLoaded(browser); + + // Wait long enough to make sure the initial resize debouncing timer has + // expired. + yield new Promise(resolve => setTimeout(resolve, 100)); + + let dims = yield promiseContentDimensions(browser); + + is(dims.isStandards, standardsMode, "Document has the expected compat mode"); + + // If the browser's preferred height is smaller than the initial height of the + // panel, then it will still take up the full available vertical space. Even + // so, we need to check that we've gotten the preferred height calculation + // correct, so check that explicitly. + let getHeight = () => parseFloat(browser.style.height); + + let {innerWidth, innerHeight} = dims.window; + let height = getHeight(); + + + let setClass = className => { + content.document.body.className = className; + }; + + info("Increase body children's width. " + + "Expect them to wrap, and the frame to grow vertically rather than widen."); + + dims = yield alterContent(browser, setClass, "big"); + let win = dims.window; + + ok(getHeight() > height, `Browser height should increase (${getHeight()} > ${height})`); + + is(win.innerWidth, innerWidth, "Window width should not change"); + ok(win.innerHeight >= innerHeight, `Window height should increase (${win.innerHeight} >= ${innerHeight})`); + is(win.scrollMaxY, 0, "Document should not be vertically scrollable"); + + checkPanelPosition(); + + + info("Increase body children's width and height. " + + "Expect them to wrap, and the frame to grow vertically rather than widen."); + + dims = yield alterContent(browser, setClass, "bigger"); + win = dims.window; + + ok(getHeight() > height, `Browser height should increase (${getHeight()} > ${height})`); + + is(win.innerWidth, innerWidth, "Window width should not change"); + ok(win.innerHeight >= innerHeight, `Window height should increase (${win.innerHeight} >= ${innerHeight})`); + is(win.scrollMaxY, 0, "Document should not be vertically scrollable"); + + checkPanelPosition(); + + + info("Increase body height beyond the height of the screen. " + + "Expect the panel to grow to accommodate, but not larger than the height of the screen."); + + dims = yield alterContent(browser, setClass, "huge"); + win = dims.window; + + ok(getHeight() > height, `Browser height should increase (${getHeight()} > ${height})`); + + is(win.innerWidth, innerWidth, "Window width should not change"); + ok(win.innerHeight > innerHeight, `Window height should increase (${win.innerHeight} > ${innerHeight})`); + ok(win.innerHeight < screen.height, `Window height be less than the screen height (${win.innerHeight} < ${screen.height})`); + ok(win.scrollMaxY > 0, `Document should be vertically scrollable (${win.scrollMaxY} > 0)`); + + checkPanelPosition(); + + + info("Restore original styling. Expect original dimensions."); + dims = yield alterContent(browser, setClass, ""); + win = dims.window; + + is(getHeight(), height, "Browser height should return to its original value"); + + is(win.innerWidth, innerWidth, "Window width should not change"); + is(win.innerHeight, innerHeight, "Window height should return to its original value"); + is(win.scrollMaxY, 0, "Document should not be vertically scrollable"); + + checkPanelPosition(); + + yield closeBrowserAction(extension, browserWin); + + yield extension.unload(); +} + +add_task(function* testBrowserActionMenuResizeStandards() { + yield testPopupSize(true); +}); + +add_task(function* testBrowserActionMenuResizeQuirks() { + yield testPopupSize(false); +}); + +// Test that we still make reasonable maximum size calculations when the window +// is close enough to the bottom of the screen that the menu panel opens above, +// rather than below, its button. +add_task(function* testBrowserActionMenuResizeBottomArrow() { + const WIDTH = 800; + const HEIGHT = 300; + + let left = screen.availLeft + screen.availWidth - WIDTH; + let top = screen.availTop + screen.availHeight - HEIGHT; + + let win = yield BrowserTestUtils.openNewBrowserWindow(); + + win.resizeTo(WIDTH, HEIGHT); + + // Sometimes we run into problems on Linux with resizing being asynchronous + // and window managers not allowing us to move the window so that any part of + // it is off-screen, so we need to try more than once. + for (let i = 0; i < 20; i++) { + win.moveTo(left, top); + + if (win.screenX == left && win.screenY == top) { + break; + } + + yield new Promise(resolve => setTimeout(resolve, 100)); + } + + yield testPopupSize(true, win, "bottom"); + + yield BrowserTestUtils.closeWindow(win); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_browserAction_simple.js b/browser/components/extensions/test/browser/browser_ext_browserAction_simple.js new file mode 100644 index 000000000..e83010958 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_browserAction_simple.js @@ -0,0 +1,59 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": { + "default_popup": "popup.html", + "unrecognized_property": "with-a-random-value", + }, + }, + + files: { + "popup.html": ` + <!DOCTYPE html> + <html><body> + <script src="popup.js"></script> + </body></html> + `, + + "popup.js": function() { + window.onload = () => { + browser.runtime.sendMessage("from-popup"); + }; + }, + }, + + background: function() { + browser.runtime.onMessage.addListener(msg => { + browser.test.assertEq(msg, "from-popup", "correct message received"); + browser.test.sendMessage("popup"); + }); + }, + }); + + SimpleTest.waitForExplicitFinish(); + let waitForConsole = new Promise(resolve => { + SimpleTest.monitorConsole(resolve, [{ + message: /Reading manifest: Error processing browser_action.unrecognized_property: An unexpected property was found/, + }]); + }); + + yield extension.startup(); + + // Do this a few times to make sure the pop-up is reloaded each time. + for (let i = 0; i < 3; i++) { + clickBrowserAction(extension); + + yield extension.awaitMessage("popup"); + + closeBrowserAction(extension); + } + + yield extension.unload(); + + SimpleTest.endMonitorConsole(); + yield waitForConsole; +}); diff --git a/browser/components/extensions/test/browser/browser_ext_commands_execute_browser_action.js b/browser/components/extensions/test/browser/browser_ext_commands_execute_browser_action.js new file mode 100644 index 000000000..f97a735d4 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_commands_execute_browser_action.js @@ -0,0 +1,113 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function* testExecuteBrowserActionWithOptions(options = {}) { + let extensionOptions = {}; + + extensionOptions.manifest = { + "commands": { + "_execute_browser_action": { + "suggested_key": { + "default": "Alt+Shift+J", + }, + }, + }, + "browser_action": { + "browser_style": true, + }, + }; + + if (options.withPopup) { + extensionOptions.manifest.browser_action.default_popup = "popup.html"; + + extensionOptions.files = { + "popup.html": ` + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + <script src="popup.js"></script> + </head> + </html> + `, + + "popup.js": function() { + browser.runtime.sendMessage("from-browser-action-popup"); + }, + }; + } + + extensionOptions.background = () => { + browser.test.onMessage.addListener((message, withPopup) => { + browser.commands.onCommand.addListener((commandName) => { + if (commandName == "_execute_browser_action") { + browser.test.fail("The onCommand listener should never fire for _execute_browser_action."); + } + }); + + browser.browserAction.onClicked.addListener(() => { + if (withPopup) { + browser.test.fail("The onClick listener should never fire if the browserAction has a popup."); + browser.test.notifyFail("execute-browser-action-on-clicked-fired"); + } else { + browser.test.notifyPass("execute-browser-action-on-clicked-fired"); + } + }); + + browser.runtime.onMessage.addListener(msg => { + if (msg == "from-browser-action-popup") { + browser.test.notifyPass("execute-browser-action-popup-opened"); + } + }); + + browser.test.sendMessage("send-keys"); + }); + }; + + let extension = ExtensionTestUtils.loadExtension(extensionOptions); + + extension.onMessage("send-keys", () => { + EventUtils.synthesizeKey("j", {altKey: true, shiftKey: true}); + }); + + yield extension.startup(); + + if (options.inArea) { + let widget = getBrowserActionWidget(extension); + CustomizableUI.addWidgetToArea(widget.id, options.inArea); + } + + extension.sendMessage("withPopup", options.withPopup); + + if (options.withPopup) { + yield extension.awaitFinish("execute-browser-action-popup-opened"); + yield closeBrowserAction(extension); + } else { + yield extension.awaitFinish("execute-browser-action-on-clicked-fired"); + } + yield extension.unload(); +} + +add_task(function* test_execute_browser_action_with_popup() { + yield testExecuteBrowserActionWithOptions({ + withPopup: true, + }); +}); + +add_task(function* test_execute_browser_action_without_popup() { + yield testExecuteBrowserActionWithOptions(); +}); + +add_task(function* test_execute_browser_action_in_hamburger_menu_with_popup() { + yield testExecuteBrowserActionWithOptions({ + withPopup: true, + inArea: CustomizableUI.AREA_PANEL, + }); +}); + +add_task(function* test_execute_browser_action_in_hamburger_menu_without_popup() { + yield testExecuteBrowserActionWithOptions({ + inArea: CustomizableUI.AREA_PANEL, + }); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_commands_execute_page_action.js b/browser/components/extensions/test/browser/browser_ext_commands_execute_page_action.js new file mode 100644 index 000000000..83684493e --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_commands_execute_page_action.js @@ -0,0 +1,133 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* test_execute_page_action_without_popup() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "commands": { + "_execute_page_action": { + "suggested_key": { + "default": "Alt+Shift+J", + }, + }, + "send-keys-command": { + "suggested_key": { + "default": "Alt+Shift+3", + }, + }, + }, + "page_action": {}, + }, + + background: function() { + let isShown = false; + + browser.commands.onCommand.addListener((commandName) => { + if (commandName == "_execute_page_action") { + browser.test.fail(`The onCommand listener should never fire for ${commandName}.`); + } else if (commandName == "send-keys-command") { + if (!isShown) { + isShown = true; + browser.tabs.query({currentWindow: true, active: true}, tabs => { + tabs.forEach(tab => { + browser.pageAction.show(tab.id); + }); + browser.test.sendMessage("send-keys"); + }); + } + } + }); + + browser.pageAction.onClicked.addListener(() => { + browser.test.assertTrue(isShown, "The onClicked event should fire if the page action is shown."); + browser.test.notifyPass("page-action-without-popup"); + }); + + browser.test.sendMessage("send-keys"); + }, + }); + + extension.onMessage("send-keys", () => { + EventUtils.synthesizeKey("j", {altKey: true, shiftKey: true}); + EventUtils.synthesizeKey("3", {altKey: true, shiftKey: true}); + }); + + yield extension.startup(); + yield extension.awaitFinish("page-action-without-popup"); + yield extension.unload(); +}); + +add_task(function* test_execute_page_action_with_popup() { + let scriptPage = url => `<html><head><meta charset="utf-8"><script src="${url}"></script></head><body>Test Popup</body></html>`; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "commands": { + "_execute_page_action": { + "suggested_key": { + "default": "Alt+Shift+J", + }, + }, + "send-keys-command": { + "suggested_key": { + "default": "Alt+Shift+3", + }, + }, + }, + "page_action": { + "default_popup": "popup.html", + }, + }, + + files: { + "popup.html": scriptPage("popup.js"), + "popup.js": function() { + browser.runtime.sendMessage("popup-opened"); + }, + }, + + background: function() { + let isShown = false; + + browser.commands.onCommand.addListener((message) => { + if (message == "_execute_page_action") { + browser.test.fail(`The onCommand listener should never fire for ${message}.`); + } + + if (message == "send-keys-command") { + if (!isShown) { + isShown = true; + browser.tabs.query({currentWindow: true, active: true}, tabs => { + tabs.forEach(tab => { + browser.pageAction.show(tab.id); + }); + browser.test.sendMessage("send-keys"); + }); + } + } + }); + + browser.pageAction.onClicked.addListener(() => { + browser.test.fail(`The onClicked listener should never fire when the pageAction has a popup.`); + }); + + browser.runtime.onMessage.addListener(msg => { + browser.test.assertEq(msg, "popup-opened", "expected popup opened"); + browser.test.assertTrue(isShown, "The onClicked event should fire if the page action is shown."); + browser.test.notifyPass("page-action-with-popup"); + }); + + browser.test.sendMessage("send-keys"); + }, + }); + + extension.onMessage("send-keys", () => { + EventUtils.synthesizeKey("j", {altKey: true, shiftKey: true}); + EventUtils.synthesizeKey("3", {altKey: true, shiftKey: true}); + }); + + yield extension.startup(); + yield extension.awaitFinish("page-action-with-popup"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_commands_getAll.js b/browser/components/extensions/test/browser/browser_ext_commands_getAll.js new file mode 100644 index 000000000..5885e8aee --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_commands_getAll.js @@ -0,0 +1,81 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +var {AppConstants} = Cu.import("resource://gre/modules/AppConstants.jsm"); + +add_task(function* () { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "name": "Commands Extension", + "commands": { + "with-desciption": { + "suggested_key": { + "default": "Ctrl+Shift+Y", + }, + "description": "should have a description", + }, + "without-description": { + "suggested_key": { + "default": "Ctrl+Shift+D", + }, + }, + "with-platform-info": { + "suggested_key": { + "mac": "Ctrl+Shift+M", + "linux": "Ctrl+Shift+L", + "windows": "Ctrl+Shift+W", + "android": "Ctrl+Shift+A", + }, + }, + }, + }, + + background: function() { + browser.test.onMessage.addListener((message, additionalScope) => { + browser.commands.getAll((commands) => { + let errorMessage = "getAll should return an array of commands"; + browser.test.assertEq(commands.length, 3, errorMessage); + + let command = commands.find(c => c.name == "with-desciption"); + + errorMessage = "The description should match what is provided in the manifest"; + browser.test.assertEq("should have a description", command.description, errorMessage); + + errorMessage = "The shortcut should match the default shortcut provided in the manifest"; + browser.test.assertEq("Ctrl+Shift+Y", command.shortcut, errorMessage); + + command = commands.find(c => c.name == "without-description"); + + errorMessage = "The description should be empty when it is not provided"; + browser.test.assertEq(null, command.description, errorMessage); + + errorMessage = "The shortcut should match the default shortcut provided in the manifest"; + browser.test.assertEq("Ctrl+Shift+D", command.shortcut, errorMessage); + + let platformKeys = { + macosx: "M", + linux: "L", + win: "W", + android: "A", + }; + + command = commands.find(c => c.name == "with-platform-info"); + let platformKey = platformKeys[additionalScope.platform]; + let shortcut = `Ctrl+Shift+${platformKey}`; + errorMessage = `The shortcut should match the one provided in the manifest for OS='${additionalScope.platform}'`; + browser.test.assertEq(shortcut, command.shortcut, errorMessage); + + browser.test.notifyPass("commands"); + }); + }); + browser.test.sendMessage("ready"); + }, + }); + + yield extension.startup(); + yield extension.awaitMessage("ready"); + extension.sendMessage("additional-scope", {platform: AppConstants.platform}); + yield extension.awaitFinish("commands"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_commands_onCommand.js b/browser/components/extensions/test/browser/browser_ext_commands_onCommand.js new file mode 100644 index 000000000..dd959dcec --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_commands_onCommand.js @@ -0,0 +1,229 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +Cu.import("resource://gre/modules/AppConstants.jsm"); + +add_task(function* test_user_defined_commands() { + const testCommands = [ + // Ctrl Shortcuts + { + name: "toggle-ctrl-a", + shortcut: "Ctrl+A", + key: "A", + modifiers: { + accelKey: true, + }, + }, + { + name: "toggle-ctrl-up", + shortcut: "Ctrl+Up", + key: "VK_UP", + modifiers: { + accelKey: true, + }, + }, + // Alt Shortcuts + { + name: "toggle-alt-a", + shortcut: "Alt+A", + key: "A", + modifiers: { + altKey: true, + }, + }, + { + name: "toggle-alt-down", + shortcut: "Alt+Down", + key: "VK_DOWN", + modifiers: { + altKey: true, + }, + }, + // Mac Shortcuts + { + name: "toggle-command-shift-page-up", + shortcutMac: "Command+Shift+PageUp", + key: "VK_PAGE_UP", + modifiers: { + accelKey: true, + shiftKey: true, + }, + }, + { + name: "toggle-mac-control-shift+period", + shortcut: "Ctrl+Shift+Period", + shortcutMac: "MacCtrl+Shift+Period", + key: "VK_PERIOD", + modifiers: { + ctrlKey: true, + shiftKey: true, + }, + }, + // Ctrl+Shift Shortcuts + { + name: "toggle-ctrl-shift-left", + shortcut: "Ctrl+Shift+Left", + key: "VK_LEFT", + modifiers: { + accelKey: true, + shiftKey: true, + }, + }, + // Alt+Shift Shortcuts + { + name: "toggle-alt-shift-1", + shortcut: "Alt+Shift+1", + key: "1", + modifiers: { + altKey: true, + shiftKey: true, + }, + }, + { + name: "toggle-alt-shift-a", + shortcut: "Alt+Shift+A", + key: "A", + modifiers: { + altKey: true, + shiftKey: true, + }, + }, + { + name: "toggle-alt-shift-right", + shortcut: "Alt+Shift+Right", + key: "VK_RIGHT", + modifiers: { + altKey: true, + shiftKey: true, + }, + }, + // Misc Shortcuts + { + name: "valid-command-with-unrecognized-property-name", + shortcut: "Alt+Shift+3", + key: "3", + modifiers: { + altKey: true, + shiftKey: true, + }, + unrecognized_property: "with-a-random-value", + }, + { + name: "spaces-in-shortcut-name", + shortcut: " Alt + Shift + 2 ", + key: "2", + modifiers: { + altKey: true, + shiftKey: true, + }, + }, + ]; + + // Create a window before the extension is loaded. + let win1 = yield BrowserTestUtils.openNewBrowserWindow(); + yield BrowserTestUtils.loadURI(win1.gBrowser.selectedBrowser, "about:robots"); + yield BrowserTestUtils.browserLoaded(win1.gBrowser.selectedBrowser); + + let commands = {}; + let isMac = AppConstants.platform == "macosx"; + let totalMacOnlyCommands = 0; + + for (let testCommand of testCommands) { + let command = { + suggested_key: {}, + }; + + if (testCommand.shortcut) { + command.suggested_key.default = testCommand.shortcut; + } + + if (testCommand.shortcutMac) { + command.suggested_key.mac = testCommand.shortcutMac; + } + + if (testCommand.shortcutMac && !testCommand.shortcut) { + totalMacOnlyCommands++; + } + + if (testCommand.unrecognized_property) { + command.unrecognized_property = testCommand.unrecognized_property; + } + + commands[testCommand.name] = command; + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "commands": commands, + }, + + background: function() { + browser.commands.onCommand.addListener(commandName => { + browser.test.sendMessage("oncommand", commandName); + }); + browser.test.sendMessage("ready"); + }, + }); + + SimpleTest.waitForExplicitFinish(); + let waitForConsole = new Promise(resolve => { + SimpleTest.monitorConsole(resolve, [{ + message: /Reading manifest: Error processing commands.*.unrecognized_property: An unexpected property was found/, + }]); + }); + + yield extension.startup(); + yield extension.awaitMessage("ready"); + + function* runTest(window) { + for (let testCommand of testCommands) { + if (testCommand.shortcutMac && !testCommand.shortcut && !isMac) { + continue; + } + EventUtils.synthesizeKey(testCommand.key, testCommand.modifiers, window); + let message = yield extension.awaitMessage("oncommand"); + is(message, testCommand.name, `Expected onCommand listener to fire with the correct name: ${testCommand.name}`); + } + } + + // Create another window after the extension is loaded. + let win2 = yield BrowserTestUtils.openNewBrowserWindow(); + yield BrowserTestUtils.loadURI(win2.gBrowser.selectedBrowser, "about:robots"); + yield BrowserTestUtils.browserLoaded(win2.gBrowser.selectedBrowser); + + let totalTestCommands = Object.keys(testCommands).length; + let expectedCommandsRegistered = isMac ? totalTestCommands : totalTestCommands - totalMacOnlyCommands; + + // Confirm the keysets have been added to both windows. + let keysetID = `ext-keyset-id-${makeWidgetId(extension.id)}`; + let keyset = win1.document.getElementById(keysetID); + ok(keyset != null, "Expected keyset to exist"); + is(keyset.childNodes.length, expectedCommandsRegistered, "Expected keyset to have the correct number of children"); + + keyset = win2.document.getElementById(keysetID); + ok(keyset != null, "Expected keyset to exist"); + is(keyset.childNodes.length, expectedCommandsRegistered, "Expected keyset to have the correct number of children"); + + // Confirm that the commands are registered to both windows. + yield focusWindow(win1); + yield runTest(win1); + + yield focusWindow(win2); + yield runTest(win2); + + yield extension.unload(); + + // Confirm that the keysets have been removed from both windows after the extension is unloaded. + keyset = win1.document.getElementById(keysetID); + is(keyset, null, "Expected keyset to be removed from the window"); + + keyset = win2.document.getElementById(keysetID); + is(keyset, null, "Expected keyset to be removed from the window"); + + yield BrowserTestUtils.closeWindow(win1); + yield BrowserTestUtils.closeWindow(win2); + + SimpleTest.endMonitorConsole(); + yield waitForConsole; +}); diff --git a/browser/components/extensions/test/browser/browser_ext_contentscript_connect.js b/browser/components/extensions/test/browser/browser_ext_contentscript_connect.js new file mode 100644 index 000000000..8b2d9badf --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_contentscript_connect.js @@ -0,0 +1,67 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://mochi.test:8888/"); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["http://mochi.test/"], + }, + + background: function() { + let ports_received = 0; + let port_messages_received = 0; + + browser.runtime.onConnect.addListener((port) => { + browser.test.assertTrue(!!port, "port1 received"); + + ports_received++; + browser.test.assertEq(1, ports_received, "1 port received"); + + port.onMessage.addListener((msg, msgPort) => { + browser.test.assertEq("port message", msg, "listener1 port message received"); + browser.test.assertEq(port, msgPort, "onMessage should receive port as second argument"); + + port_messages_received++; + browser.test.assertEq(1, port_messages_received, "1 port message received"); + }); + }); + browser.runtime.onConnect.addListener((port) => { + browser.test.assertTrue(!!port, "port2 received"); + + ports_received++; + browser.test.assertEq(2, ports_received, "2 ports received"); + + port.onMessage.addListener((msg, msgPort) => { + browser.test.assertEq("port message", msg, "listener2 port message received"); + browser.test.assertEq(port, msgPort, "onMessage should receive port as second argument"); + + port_messages_received++; + browser.test.assertEq(2, port_messages_received, "2 port messages received"); + + browser.test.notifyPass("contentscript_connect.pass"); + }); + }); + + browser.tabs.executeScript({file: "script.js"}).catch(e => { + browser.test.fail(`Error: ${e} :: ${e.stack}`); + browser.test.notifyFail("contentscript_connect.pass"); + }); + }, + + files: { + "script.js": function() { + let port = browser.runtime.connect(); + port.postMessage("port message"); + }, + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("contentscript_connect.pass"); + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_contextMenus.js b/browser/components/extensions/test/browser/browser_ext_contextMenus.js new file mode 100644 index 000000000..fa1483b20 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_contextMenus.js @@ -0,0 +1,342 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +const PAGE = "http://mochi.test:8888/browser/browser/components/extensions/test/browser/context.html"; + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, PAGE); + + gBrowser.selectedTab = tab1; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["contextMenus"], + }, + + background: function() { + browser.contextMenus.create({ + id: "clickme-image", + title: "Click me!", + contexts: ["image"], + }); + browser.contextMenus.create({ + id: "clickme-page", + title: "Click me!", + contexts: ["page"], + }); + browser.test.notifyPass(); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish(); + + let contentAreaContextMenu = yield openContextMenu("#img1"); + let item = contentAreaContextMenu.getElementsByAttribute("label", "Click me!"); + is(item.length, 1, "contextMenu item for image was found"); + yield closeContextMenu(); + + contentAreaContextMenu = yield openContextMenu("body"); + item = contentAreaContextMenu.getElementsByAttribute("label", "Click me!"); + is(item.length, 1, "contextMenu item for page was found"); + yield closeContextMenu(); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab1); +}); + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, PAGE); + + gBrowser.selectedTab = tab1; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["contextMenus"], + }, + + background: async function() { + // A generic onclick callback function. + function genericOnClick(info, tab) { + browser.test.sendMessage("onclick", {info, tab}); + } + + browser.contextMenus.onClicked.addListener((info, tab) => { + browser.test.sendMessage("browser.contextMenus.onClicked", {info, tab}); + }); + + browser.contextMenus.create({ + contexts: ["all"], + type: "separator", + }); + + let contexts = ["page", "selection", "image", "editable"]; + for (let i = 0; i < contexts.length; i++) { + let context = contexts[i]; + let title = context; + browser.contextMenus.create({ + title: title, + contexts: [context], + id: "ext-" + context, + onclick: genericOnClick, + }); + if (context == "selection") { + browser.contextMenus.update("ext-selection", { + title: "selection is: '%s'", + onclick: (info, tab) => { + browser.contextMenus.removeAll(); + genericOnClick(info, tab); + }, + }); + } + } + + let parent = browser.contextMenus.create({ + title: "parent", + }); + browser.contextMenus.create({ + title: "child1", + parentId: parent, + onclick: genericOnClick, + }); + let child2 = browser.contextMenus.create({ + title: "child2", + parentId: parent, + onclick: genericOnClick, + }); + + let parentToDel = browser.contextMenus.create({ + title: "parentToDel", + }); + browser.contextMenus.create({ + title: "child1", + parentId: parentToDel, + onclick: genericOnClick, + }); + browser.contextMenus.create({ + title: "child2", + parentId: parentToDel, + onclick: genericOnClick, + }); + browser.contextMenus.remove(parentToDel); + + browser.contextMenus.create({ + title: "Without onclick property", + id: "ext-without-onclick", + }); + + await browser.test.assertRejects( + browser.contextMenus.update(parent, {parentId: child2}), + /cannot be an ancestor/, + "Should not be able to reparent an item as descendent of itself"); + + browser.test.notifyPass("contextmenus"); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("contextmenus"); + + let expectedClickInfo = { + menuItemId: "ext-image", + mediaType: "image", + srcUrl: "http://mochi.test:8888/browser/browser/components/extensions/test/browser/ctxmenu-image.png", + pageUrl: PAGE, + editable: false, + }; + + function checkClickInfo(result) { + for (let i of Object.keys(expectedClickInfo)) { + is(result.info[i], expectedClickInfo[i], + "click info " + i + " expected to be: " + expectedClickInfo[i] + " but was: " + result.info[i]); + } + is(expectedClickInfo.pageSrc, result.tab.url, "click info page source is the right tab"); + } + + let extensionMenuRoot = yield openExtensionContextMenu(); + + // Check some menu items + let items = extensionMenuRoot.getElementsByAttribute("label", "image"); + is(items.length, 1, "contextMenu item for image was found (context=image)"); + let image = items[0]; + + items = extensionMenuRoot.getElementsByAttribute("label", "selection-edited"); + is(items.length, 0, "contextMenu item for selection was not found (context=image)"); + + items = extensionMenuRoot.getElementsByAttribute("label", "parentToDel"); + is(items.length, 0, "contextMenu item for removed parent was not found (context=image)"); + + items = extensionMenuRoot.getElementsByAttribute("label", "parent"); + is(items.length, 1, "contextMenu item for parent was found (context=image)"); + + is(items[0].childNodes[0].childNodes.length, 2, "child items for parent were found (context=image)"); + + // Click on ext-image item and check the click results + yield closeExtensionContextMenu(image); + + let result = yield extension.awaitMessage("onclick"); + checkClickInfo(result); + result = yield extension.awaitMessage("browser.contextMenus.onClicked"); + checkClickInfo(result); + + + // Test "editable" context and OnClick data property. + extensionMenuRoot = yield openExtensionContextMenu("#edit-me"); + + // Check some menu items. + items = extensionMenuRoot.getElementsByAttribute("label", "editable"); + is(items.length, 1, "contextMenu item for text input element was found (context=editable)"); + let editable = items[0]; + + // Click on ext-editable item and check the click results. + yield closeExtensionContextMenu(editable); + + expectedClickInfo = { + menuItemId: "ext-editable", + pageUrl: PAGE, + editable: true, + }; + + result = yield extension.awaitMessage("onclick"); + checkClickInfo(result); + result = yield extension.awaitMessage("browser.contextMenus.onClicked"); + checkClickInfo(result); + + + // Select some text + yield ContentTask.spawn(gBrowser.selectedBrowser, { }, function* (arg) { + let doc = content.document; + let range = doc.createRange(); + let selection = content.getSelection(); + selection.removeAllRanges(); + let textNode = doc.getElementById("img1").previousSibling; + range.setStart(textNode, 0); + range.setEnd(textNode, 100); + selection.addRange(range); + }); + + // Bring up context menu again + extensionMenuRoot = yield openExtensionContextMenu(); + + // Check some menu items + items = extensionMenuRoot.getElementsByAttribute("label", "Without onclick property"); + is(items.length, 1, "contextMenu item was found (context=page)"); + + yield closeExtensionContextMenu(items[0]); + + expectedClickInfo = { + menuItemId: "ext-without-onclick", + pageUrl: PAGE, + }; + + result = yield extension.awaitMessage("browser.contextMenus.onClicked"); + checkClickInfo(result); + + // Bring up context menu again + extensionMenuRoot = yield openExtensionContextMenu(); + + // Check some menu items + items = extensionMenuRoot.getElementsByAttribute("label", "selection is: 'just some text 123456789012345678901234567890...'"); + is(items.length, 1, "contextMenu item for selection was found (context=selection)"); + let selectionItem = items[0]; + + items = extensionMenuRoot.getElementsByAttribute("label", "selection"); + is(items.length, 0, "contextMenu item label update worked (context=selection)"); + + yield closeExtensionContextMenu(selectionItem); + + expectedClickInfo = { + menuItemId: "ext-selection", + pageUrl: PAGE, + selectionText: "just some text 1234567890123456789012345678901234567890123456789012345678901234567890123456789012", + }; + + result = yield extension.awaitMessage("onclick"); + checkClickInfo(result); + result = yield extension.awaitMessage("browser.contextMenus.onClicked"); + checkClickInfo(result); + + let contentAreaContextMenu = yield openContextMenu("#img1"); + items = contentAreaContextMenu.getElementsByAttribute("ext-type", "top-level-menu"); + is(items.length, 0, "top level item was not found (after removeAll()"); + yield closeContextMenu(); + + yield extension.unload(); + yield BrowserTestUtils.removeTab(tab1); +}); + +add_task(function* testRemoveAllWithTwoExtensions() { + const tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, PAGE); + const manifest = {permissions: ["contextMenus"]}; + + const first = ExtensionTestUtils.loadExtension({manifest, background() { + browser.contextMenus.create({title: "alpha", contexts: ["all"]}); + + browser.contextMenus.onClicked.addListener(() => { + browser.contextMenus.removeAll(); + }); + browser.test.onMessage.addListener(msg => { + if (msg == "ping") { + browser.test.sendMessage("pong-alpha"); + return; + } + browser.contextMenus.create({title: "gamma", contexts: ["all"]}); + }); + }}); + + const second = ExtensionTestUtils.loadExtension({manifest, background() { + browser.contextMenus.create({title: "beta", contexts: ["all"]}); + + browser.contextMenus.onClicked.addListener(() => { + browser.contextMenus.removeAll(); + }); + + browser.test.onMessage.addListener(() => { + browser.test.sendMessage("pong-beta"); + }); + }}); + + yield first.startup(); + yield second.startup(); + + function* confirmMenuItems(...items) { + // Round-trip to extension to make sure that the context menu state has been + // updated by the async contextMenus.create / contextMenus.removeAll calls. + first.sendMessage("ping"); + second.sendMessage("ping"); + yield first.awaitMessage("pong-alpha"); + yield second.awaitMessage("pong-beta"); + + const menu = yield openContextMenu(); + for (const id of ["alpha", "beta", "gamma"]) { + const expected = items.includes(id); + const found = menu.getElementsByAttribute("label", id); + is(found.length, expected, `menu item ${id} ${expected ? "" : "not "}found`); + } + // Return the first menu item, we need to click it. + return menu.getElementsByAttribute("label", items[0])[0]; + } + + // Confirm alpha, beta exist; click alpha to remove it. + const alpha = yield confirmMenuItems("alpha", "beta"); + yield closeExtensionContextMenu(alpha); + + // Confirm only beta exists. + yield confirmMenuItems("beta"); + yield closeContextMenu(); + + // Create gamma, confirm, click. + first.sendMessage("create"); + const beta = yield confirmMenuItems("beta", "gamma"); + yield closeExtensionContextMenu(beta); + + // Confirm only gamma is left. + yield confirmMenuItems("gamma"); + yield closeContextMenu(); + + yield first.unload(); + yield second.unload(); + yield BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_contextMenus_checkboxes.js b/browser/components/extensions/test/browser/browser_ext_contextMenus_checkboxes.js new file mode 100644 index 000000000..a3fa9d32c --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_contextMenus_checkboxes.js @@ -0,0 +1,96 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, + "http://mochi.test:8888/browser/browser/components/extensions/test/browser/context.html"); + + gBrowser.selectedTab = tab1; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["contextMenus"], + }, + + background: function() { + // Report onClickData info back. + browser.contextMenus.onClicked.addListener(info => { + browser.test.sendMessage("contextmenus-click", info); + }); + + browser.contextMenus.create({ + title: "Checkbox", + type: "checkbox", + }); + + browser.contextMenus.create({ + type: "separator", + }); + + browser.contextMenus.create({ + title: "Checkbox", + type: "checkbox", + checked: true, + }); + + browser.contextMenus.create({ + title: "Checkbox", + type: "checkbox", + }); + + browser.test.notifyPass("contextmenus-checkboxes"); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("contextmenus-checkboxes"); + + function confirmCheckboxStates(extensionMenuRoot, expectedStates) { + let checkboxItems = extensionMenuRoot.getElementsByAttribute("type", "checkbox"); + + is(checkboxItems.length, 3, "there should be 3 checkbox items in the context menu"); + + is(checkboxItems[0].hasAttribute("checked"), expectedStates[0], `checkbox item 1 has state (checked=${expectedStates[0]})`); + is(checkboxItems[1].hasAttribute("checked"), expectedStates[1], `checkbox item 2 has state (checked=${expectedStates[1]})`); + is(checkboxItems[2].hasAttribute("checked"), expectedStates[2], `checkbox item 3 has state (checked=${expectedStates[2]})`); + + return extensionMenuRoot.getElementsByAttribute("type", "checkbox"); + } + + function confirmOnClickData(onClickData, id, was, checked) { + is(onClickData.wasChecked, was, `checkbox item ${id} was ${was ? "" : "not "}checked before the click`); + is(onClickData.checked, checked, `checkbox item ${id} is ${checked ? "" : "not "}checked after the click`); + } + + let extensionMenuRoot = yield openExtensionContextMenu(); + let items = confirmCheckboxStates(extensionMenuRoot, [false, true, false]); + yield closeExtensionContextMenu(items[0]); + + let result = yield extension.awaitMessage("contextmenus-click"); + confirmOnClickData(result, 1, false, true); + + extensionMenuRoot = yield openExtensionContextMenu(); + items = confirmCheckboxStates(extensionMenuRoot, [true, true, false]); + yield closeExtensionContextMenu(items[2]); + + result = yield extension.awaitMessage("contextmenus-click"); + confirmOnClickData(result, 3, false, true); + + extensionMenuRoot = yield openExtensionContextMenu(); + items = confirmCheckboxStates(extensionMenuRoot, [true, true, true]); + yield closeExtensionContextMenu(items[0]); + + result = yield extension.awaitMessage("contextmenus-click"); + confirmOnClickData(result, 1, true, false); + + extensionMenuRoot = yield openExtensionContextMenu(); + items = confirmCheckboxStates(extensionMenuRoot, [false, true, true]); + yield closeExtensionContextMenu(items[2]); + + result = yield extension.awaitMessage("contextmenus-click"); + confirmOnClickData(result, 3, true, false); + + yield extension.unload(); + yield BrowserTestUtils.removeTab(tab1); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_contextMenus_icons.js b/browser/components/extensions/test/browser/browser_ext_contextMenus_icons.js new file mode 100644 index 000000000..a3d31bd19 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_contextMenus_icons.js @@ -0,0 +1,76 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, + "http://mochi.test:8888/browser/browser/components/extensions/test/browser/context.html"); + + let encodedImageData = "iVBORw0KGgoAAAANSUhEUgAAACQAAAAkCAYAAADhAJiYAAAC4klEQVRYhdWXLWzbQBSADQtDAwsHC1tUhUxqfL67lk2tdn+OJg0ODU0rLByqgqINBY6tmlbn7LMTJ5FaFVVBk1G0oUGjG2jT2Y7jxmmcbU/6iJ+f36fz+e5sGP9riCGm9hB37RG+scd4Yo/wsDXCZyIE2xuXsce4bY+wXkAsQtzYmExrfFgvkJkRbkzo1ehoxx5iXcgI/9iYUGt8WH9MqDXEcmNChmEYrRCf2SHWeYgQx3x0tLNRIeKQLTtEFyJEep4NTuhk8BC+yMrwEE3+iozo42d8gK7FAOkMsRiiN8QhW2ttSK5QTfRRV4QoymVeJMvPvDp7gCZigD613MN6yRFA3SWarow9QB9LCfG+NeF9qCtjAKOSQjCqVKhfVsiHEQ+grgx/lRGqUihAc1uL8EFD+KCRO+GrF4J61phcoRoPoEzkYhZYpykh5sMb7kOdIeY+jHKur4QI4Feh4AFX1nVeLxrAvQchGsBz5ls6wa2QdwcvIcE2863bTH79KOvsz/uUYJsp+J0pSzNlDckVqqVGUAF+n6uS7txcOl6wot4JVy70ufDLy4pWLUQVPE81pRI0mGe9oxLMHSeohHvMs/STUNaUK6vDPCvOyxMFDx4achehRDJmHnydnkPww5OFfLxrGIZBFDyYl4LpMzlTQFIP6AQx86w2UeYBccFpJrcKv5L9eGDtUAU6RIELqsB74uynjy/UBRF1gS5BTFxwQT1wTiXoUg9MH7m/3NZRRoi5IJytUbMgzv4Wc832+oQkiKgEehmyMkkpKsFkQV11QsRJL5rJYBLItQgRaUZEmnoZXsomz3vGiWw+I9KMF9SVFOqZEemZekli1jN3U/UOqhHHvC6oWWGElhfSpGdOk6+O9prdwvtLj5BjRsQxdRnot+Zeifpy/2/0stktKTRNLmbk0mwXyl8253fyojj+8rxOHNAhjjm5n0/5OOCGOKBzkrMO0Z75lvSAzKlrF32Z/3z8BqLAn+yMV7VhAAAAAElFTkSuQmCC"; + let decodedImageData = atob(encodedImageData); + const IMAGE_ARRAYBUFFER = Uint8Array.from(decodedImageData, byte => byte.charCodeAt(0)).buffer; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["contextMenus"], + "icons": { + "18": "extension.png", + }, + }, + + files: { + "extension.png": IMAGE_ARRAYBUFFER, + }, + + background: function() { + let menuitemId = browser.contextMenus.create({ + title: "child-to-delete", + onclick: () => { + browser.contextMenus.remove(menuitemId); + }, + }); + + browser.contextMenus.create({ + title: "child", + }); + + browser.test.onMessage.addListener(() => { + browser.test.sendMessage("pong"); + }); + browser.test.notifyPass("contextmenus-icons"); + }, + }); + + let confirmContextMenuIcon = (rootElement) => { + let expectedURL = new RegExp(String.raw`^moz-extension://[^/]+/extension\.png$`); + let imageUrl = rootElement.getAttribute("image"); + ok(expectedURL.test(imageUrl), "The context menu should display the extension icon next to the root element"); + }; + + yield extension.startup(); + yield extension.awaitFinish("contextmenus-icons"); + + let extensionMenu = yield openExtensionContextMenu(); + + let contextMenu = document.getElementById("contentAreaContextMenu"); + let topLevelMenuItem = contextMenu.getElementsByAttribute("ext-type", "top-level-menu")[0]; + confirmContextMenuIcon(topLevelMenuItem); + + let childToDelete = extensionMenu.getElementsByAttribute("label", "child-to-delete")[0]; + yield closeExtensionContextMenu(childToDelete); + // Now perform a roundtrip to the extension process to make sure that the + // click event has had a chance to fire. + extension.sendMessage("ping"); + yield extension.awaitMessage("pong"); + + yield openExtensionContextMenu(); + + contextMenu = document.getElementById("contentAreaContextMenu"); + topLevelMenuItem = contextMenu.getElementsByAttribute("label", "child")[0]; + + confirmContextMenuIcon(topLevelMenuItem); + yield closeContextMenu(); + + yield extension.unload(); + yield BrowserTestUtils.removeTab(tab1); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_contextMenus_onclick.js b/browser/components/extensions/test/browser/browser_ext_contextMenus_onclick.js new file mode 100644 index 000000000..96453863d --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_contextMenus_onclick.js @@ -0,0 +1,196 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +// Loaded both as a background script and a tab page. +function testScript() { + let page = location.pathname.includes("tab.html") ? "tab" : "background"; + let clickCounts = { + old: 0, + new: 0, + }; + browser.contextMenus.onClicked.addListener(() => { + // Async to give other onclick handlers a chance to fire. + setTimeout(() => { + browser.test.sendMessage("onClicked-fired", page); + }); + }); + browser.test.onMessage.addListener((toPage, msg) => { + if (toPage !== page) { + return; + } + browser.test.log(`Received ${msg} for ${toPage}`); + if (msg == "get-click-counts") { + browser.test.sendMessage("click-counts", clickCounts); + } else if (msg == "clear-click-counts") { + clickCounts.old = clickCounts.new = 0; + browser.test.sendMessage("next"); + } else if (msg == "create-with-onclick") { + browser.contextMenus.create({ + id: "iden", + title: "tifier", + onclick() { + ++clickCounts.old; + browser.test.log(`onclick fired for original onclick property in ${page}`); + }, + }, () => browser.test.sendMessage("next")); + } else if (msg == "create-without-onclick") { + browser.contextMenus.create({ + id: "iden", + title: "tifier", + }, () => browser.test.sendMessage("next")); + } else if (msg == "update-without-onclick") { + browser.contextMenus.update("iden", { + enabled: true, // Already enabled, so this does nothing. + }, () => browser.test.sendMessage("next")); + } else if (msg == "update-with-onclick") { + browser.contextMenus.update("iden", { + onclick() { + ++clickCounts.new; + browser.test.log(`onclick fired for updated onclick property in ${page}`); + }, + }, () => browser.test.sendMessage("next")); + } else if (msg == "remove") { + browser.contextMenus.remove("iden", () => browser.test.sendMessage("next")); + } else if (msg == "removeAll") { + browser.contextMenus.removeAll(() => browser.test.sendMessage("next")); + } + }); + + if (page == "background") { + browser.test.log("Opening tab.html"); + browser.tabs.create({ + url: "tab.html", + active: false, // To not interfere with the context menu tests. + }); + } else { + // Sanity check - the pages must be in the same process. + let pages = browser.extension.getViews(); + browser.test.assertTrue(pages.includes(window), + "Expected this tab to be an extension view"); + pages = pages.filter(w => w !== window); + browser.test.assertEq(pages[0], browser.extension.getBackgroundPage(), + "Expected the other page to be a background page"); + browser.test.sendMessage("tab.html ready"); + } +} + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, + "http://mochi.test:8888/browser/browser/components/extensions/test/browser/context.html"); + + gBrowser.selectedTab = tab1; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["contextMenus"], + }, + background: testScript, + files: { + "tab.html": `<!DOCTYPE html><meta charset="utf-8"><script src="tab.js"></script>`, + "tab.js": testScript, + }, + }); + yield extension.startup(); + yield extension.awaitMessage("tab.html ready"); + + function* clickContextMenu() { + // Using openContextMenu instead of openExtensionContextMenu because the + // test extension has only one context menu item. + let extensionMenuRoot = yield openContextMenu(); + let items = extensionMenuRoot.getElementsByAttribute("label", "tifier"); + is(items.length, 1, "Expected one context menu item"); + yield closeExtensionContextMenu(items[0]); + // One of them is "tab", the other is "background". + info(`onClicked from: ${yield extension.awaitMessage("onClicked-fired")}`); + info(`onClicked from: ${yield extension.awaitMessage("onClicked-fired")}`); + } + + function* getCounts(page) { + extension.sendMessage(page, "get-click-counts"); + return yield extension.awaitMessage("click-counts"); + } + function* resetCounts() { + extension.sendMessage("tab", "clear-click-counts"); + extension.sendMessage("background", "clear-click-counts"); + yield extension.awaitMessage("next"); + yield extension.awaitMessage("next"); + } + + // During this test, at most one "onclick" attribute is expected at any time. + for (let pageOne of ["background", "tab"]) { + for (let pageTwo of ["background", "tab"]) { + info(`Testing with menu created by ${pageOne} and updated by ${pageTwo}`); + extension.sendMessage(pageOne, "create-with-onclick"); + yield extension.awaitMessage("next"); + + // Test that update without onclick attribute does not clear the existing + // onclick handler. + extension.sendMessage(pageTwo, "update-without-onclick"); + yield extension.awaitMessage("next"); + yield clickContextMenu(); + let clickCounts = yield getCounts(pageOne); + is(clickCounts.old, 1, `Original onclick should still be present in ${pageOne}`); + is(clickCounts.new, 0, `Not expecting any new handlers in ${pageOne}`); + if (pageOne !== pageTwo) { + clickCounts = yield getCounts(pageTwo); + is(clickCounts.old, 0, `Not expecting any handlers in ${pageTwo}`); + is(clickCounts.new, 0, `Not expecting any new handlers in ${pageTwo}`); + } + yield resetCounts(); + + // Test that update with onclick handler in a different page clears the + // existing handler and activates the new onclick handler. + extension.sendMessage(pageTwo, "update-with-onclick"); + yield extension.awaitMessage("next"); + yield clickContextMenu(); + clickCounts = yield getCounts(pageOne); + is(clickCounts.old, 0, `Original onclick should be gone from ${pageOne}`); + if (pageOne !== pageTwo) { + is(clickCounts.new, 0, `Still not expecting new handlers in ${pageOne}`); + } + clickCounts = yield getCounts(pageTwo); + if (pageOne !== pageTwo) { + is(clickCounts.old, 0, `Not expecting an old onclick in ${pageTwo}`); + } + is(clickCounts.new, 1, `New onclick should be triggered in ${pageTwo}`); + yield resetCounts(); + + // Test that updating the handler (different again from the last `update` + // call, but the same as the `create` call) clears the existing handler + // and activates the new onclick handler. + extension.sendMessage(pageOne, "update-with-onclick"); + yield extension.awaitMessage("next"); + yield clickContextMenu(); + clickCounts = yield getCounts(pageOne); + is(clickCounts.new, 1, `onclick should be triggered in ${pageOne}`); + if (pageOne !== pageTwo) { + clickCounts = yield getCounts(pageTwo); + is(clickCounts.new, 0, `onclick should be gone from ${pageTwo}`); + } + yield resetCounts(); + + // Test that removing the context menu and recreating it with the same ID + // (in a different context) does not leave behind any onclick handlers. + extension.sendMessage(pageTwo, "remove"); + yield extension.awaitMessage("next"); + extension.sendMessage(pageTwo, "create-without-onclick"); + yield extension.awaitMessage("next"); + yield clickContextMenu(); + clickCounts = yield getCounts(pageOne); + is(clickCounts.new, 0, `Did not expect any click handlers in ${pageOne}`); + if (pageOne !== pageTwo) { + clickCounts = yield getCounts(pageTwo); + is(clickCounts.new, 0, `Did not expect any click handlers in ${pageTwo}`); + } + yield resetCounts(); + + // Remove context menu for the next iteration of the test. And just to get + // more coverage, let's use removeAll instead of remove. + extension.sendMessage(pageOne, "removeAll"); + yield extension.awaitMessage("next"); + } + } + yield extension.unload(); + yield BrowserTestUtils.removeTab(tab1); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_contextMenus_radioGroups.js b/browser/components/extensions/test/browser/browser_ext_contextMenus_radioGroups.js new file mode 100644 index 000000000..3c5fa584b --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_contextMenus_radioGroups.js @@ -0,0 +1,100 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, + "http://mochi.test:8888/browser/browser/components/extensions/test/browser/context.html"); + + gBrowser.selectedTab = tab1; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["contextMenus"], + }, + + background: function() { + // Report onClickData info back. + browser.contextMenus.onClicked.addListener(info => { + browser.test.sendMessage("contextmenus-click", info); + }); + + browser.contextMenus.create({ + title: "radio-group-1", + type: "radio", + checked: true, + }); + + browser.contextMenus.create({ + type: "separator", + }); + + browser.contextMenus.create({ + title: "radio-group-2", + type: "radio", + }); + + browser.contextMenus.create({ + title: "radio-group-2", + type: "radio", + }); + + browser.test.notifyPass("contextmenus-radio-groups"); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("contextmenus-radio-groups"); + + function confirmRadioGroupStates(extensionMenuRoot, expectedStates) { + let radioItems = extensionMenuRoot.getElementsByAttribute("type", "radio"); + let radioGroup1 = extensionMenuRoot.getElementsByAttribute("label", "radio-group-1"); + let radioGroup2 = extensionMenuRoot.getElementsByAttribute("label", "radio-group-2"); + + is(radioItems.length, 3, "there should be 3 radio items in the context menu"); + is(radioGroup1.length, 1, "the first radio group should only have 1 radio item"); + is(radioGroup2.length, 2, "the second radio group should only have 2 radio items"); + + is(radioGroup1[0].hasAttribute("checked"), expectedStates[0], `radio item 1 has state (checked=${expectedStates[0]})`); + is(radioGroup2[0].hasAttribute("checked"), expectedStates[1], `radio item 2 has state (checked=${expectedStates[1]})`); + is(radioGroup2[1].hasAttribute("checked"), expectedStates[2], `radio item 3 has state (checked=${expectedStates[2]})`); + + return extensionMenuRoot.getElementsByAttribute("type", "radio"); + } + + function confirmOnClickData(onClickData, id, was, checked) { + is(onClickData.wasChecked, was, `radio item ${id} was ${was ? "" : "not "}checked before the click`); + is(onClickData.checked, checked, `radio item ${id} is ${checked ? "" : "not "}checked after the click`); + } + + let extensionMenuRoot = yield openExtensionContextMenu(); + let items = confirmRadioGroupStates(extensionMenuRoot, [true, false, false]); + yield closeExtensionContextMenu(items[1]); + + let result = yield extension.awaitMessage("contextmenus-click"); + confirmOnClickData(result, 2, false, true); + + extensionMenuRoot = yield openExtensionContextMenu(); + items = confirmRadioGroupStates(extensionMenuRoot, [true, true, false]); + yield closeExtensionContextMenu(items[2]); + + result = yield extension.awaitMessage("contextmenus-click"); + confirmOnClickData(result, 3, false, true); + + extensionMenuRoot = yield openExtensionContextMenu(); + items = confirmRadioGroupStates(extensionMenuRoot, [true, false, true]); + yield closeExtensionContextMenu(items[0]); + + result = yield extension.awaitMessage("contextmenus-click"); + confirmOnClickData(result, 1, true, true); + + extensionMenuRoot = yield openExtensionContextMenu(); + items = confirmRadioGroupStates(extensionMenuRoot, [true, false, true]); + yield closeExtensionContextMenu(items[0]); + + result = yield extension.awaitMessage("contextmenus-click"); + confirmOnClickData(result, 1, true, true); + + yield extension.unload(); + yield BrowserTestUtils.removeTab(tab1); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_contextMenus_uninstall.js b/browser/components/extensions/test/browser/browser_ext_contextMenus_uninstall.js new file mode 100644 index 000000000..fdf06d656 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_contextMenus_uninstall.js @@ -0,0 +1,84 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, + "http://mochi.test:8888/browser/browser/components/extensions/test/browser/context.html"); + + // Install an extension. + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["contextMenus"], + }, + + background: function() { + browser.contextMenus.create({title: "a"}); + browser.contextMenus.create({title: "b"}); + browser.test.notifyPass("contextmenus-icons"); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("contextmenus-icons"); + + // Open the context menu. + let contextMenu = yield openContextMenu("#img1"); + + // Confirm that the extension menu item exists. + let topLevelExtensionMenuItems = contextMenu.getElementsByAttribute("ext-type", "top-level-menu"); + is(topLevelExtensionMenuItems.length, 1, "the top level extension menu item exists"); + + yield closeContextMenu(); + + // Uninstall the extension. + yield extension.unload(); + + // Open the context menu. + contextMenu = yield openContextMenu("#img1"); + + // Confirm that the extension menu item has been removed. + topLevelExtensionMenuItems = contextMenu.getElementsByAttribute("ext-type", "top-level-menu"); + is(topLevelExtensionMenuItems.length, 0, "no top level extension menu items should exist"); + + yield closeContextMenu(); + + // Install a new extension. + extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["contextMenus"], + }, + background: function() { + browser.contextMenus.create({title: "c"}); + browser.contextMenus.create({title: "d"}); + browser.test.notifyPass("contextmenus-uninstall-second-extension"); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("contextmenus-uninstall-second-extension"); + + // Open the context menu. + contextMenu = yield openContextMenu("#img1"); + + // Confirm that only the new extension menu item is in the context menu. + topLevelExtensionMenuItems = contextMenu.getElementsByAttribute("ext-type", "top-level-menu"); + is(topLevelExtensionMenuItems.length, 1, "only one top level extension menu item should exist"); + + // Close the context menu. + yield closeContextMenu(); + + // Uninstall the extension. + yield extension.unload(); + + // Open the context menu. + contextMenu = yield openContextMenu("#img1"); + + // Confirm that no extension menu items exist. + topLevelExtensionMenuItems = contextMenu.getElementsByAttribute("ext-type", "top-level-menu"); + is(topLevelExtensionMenuItems.length, 0, "no top level extension menu items should exist"); + + yield closeContextMenu(); + + yield BrowserTestUtils.removeTab(tab1); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_contextMenus_urlPatterns.js b/browser/components/extensions/test/browser/browser_ext_contextMenus_urlPatterns.js new file mode 100644 index 000000000..7849b8778 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_contextMenus_urlPatterns.js @@ -0,0 +1,254 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, + "http://mochi.test:8888/browser/browser/components/extensions/test/browser/context.html"); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["contextMenus"], + }, + + background: function() { + // Test menu items using targetUrlPatterns. + browser.contextMenus.create({ + title: "targetUrlPatterns-patternMatches-contextAll", + targetUrlPatterns: ["*://*/*ctxmenu-image.png", "*://*/*some-link"], + contexts: ["all"], + }); + + browser.contextMenus.create({ + title: "targetUrlPatterns-patternMatches-contextImage", + targetUrlPatterns: ["*://*/*ctxmenu-image.png"], + contexts: ["image"], + }); + + browser.contextMenus.create({ + title: "targetUrlPatterns-patternMatches-contextLink", + targetUrlPatterns: ["*://*/*some-link"], + contexts: ["link"], + }); + + browser.contextMenus.create({ + title: "targetUrlPatterns-patternDoesNotMatch-contextAll", + targetUrlPatterns: ["*://*/does-not-match"], + contexts: ["all"], + }); + + browser.contextMenus.create({ + title: "targetUrlPatterns-patternDoesNotMatch-contextImage", + targetUrlPatterns: ["*://*/does-not-match"], + contexts: ["image"], + }); + + browser.contextMenus.create({ + title: "targetUrlPatterns-patternDoesNotMatch-contextLink", + targetUrlPatterns: ["*://*/does-not-match"], + contexts: ["link"], + }); + + // Test menu items using documentUrlPatterns. + browser.contextMenus.create({ + title: "documentUrlPatterns-patternMatches-contextAll", + documentUrlPatterns: ["*://*/*context.html"], + contexts: ["all"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternMatches-contextImage", + documentUrlPatterns: ["*://*/*context.html", "http://*/url-that-does-not-match"], + contexts: ["image"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternMatches-contextLink", + documentUrlPatterns: ["*://*/*context.html", "*://*/does-not-match"], + contexts: ["link"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternDoesNotMatch-contextAll", + documentUrlPatterns: ["*://*/does-not-match"], + contexts: ["all"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternDoesNotMatch-contextImage", + documentUrlPatterns: ["*://*/does-not-match"], + contexts: ["image"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternDoesNotMatch-contextLink", + documentUrlPatterns: ["*://*/does-not-match"], + contexts: ["link"], + }); + + // Test menu items using both targetUrlPatterns and documentUrlPatterns. + browser.contextMenus.create({ + title: "documentUrlPatterns-patternMatches-targetUrlPatterns-patternMatches-contextAll", + documentUrlPatterns: ["*://*/*context.html"], + targetUrlPatterns: ["*://*/*ctxmenu-image.png"], + contexts: ["all"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternMatches-contextAll", + documentUrlPatterns: ["*://does-not-match"], + targetUrlPatterns: ["*://*/*ctxmenu-image.png"], + contexts: ["all"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternMatches-targetUrlPatterns-patternDoesNotMatch-contextAll", + documentUrlPatterns: ["*://*/*context.html"], + targetUrlPatterns: ["*://does-not-match"], + contexts: ["all"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternDoesNotMatch-contextAll", + documentUrlPatterns: ["*://does-not-match"], + targetUrlPatterns: ["*://does-not-match"], + contexts: ["all"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternMatches-targetUrlPatterns-patternMatches-contextImage", + documentUrlPatterns: ["*://*/*context.html"], + targetUrlPatterns: ["*://*/*ctxmenu-image.png"], + contexts: ["image"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternMatches-contextImage", + documentUrlPatterns: ["*://does-not-match"], + targetUrlPatterns: ["*://*/*ctxmenu-image.png"], + contexts: ["image"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternMatches-targetUrlPatterns-patternDoesNotMatch-contextImage", + documentUrlPatterns: ["*://*/*context.html"], + targetUrlPatterns: ["*://does-not-match"], + contexts: ["image"], + }); + + browser.contextMenus.create({ + title: "documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternDoesNotMatch-contextImage", + documentUrlPatterns: ["*://does-not-match"], + targetUrlPatterns: ["*://does-not-match"], + contexts: ["image"], + }); + + browser.test.notifyPass("contextmenus-urlPatterns"); + }, + }); + + function* confirmContextMenuItems(menu, expected) { + for (let [label, shouldShow] of expected) { + let items = menu.getElementsByAttribute("label", label); + if (shouldShow) { + is(items.length, 1, `The menu item for label ${label} was correctly shown`); + } else { + is(items.length, 0, `The menu item for label ${label} was correctly not shown`); + } + } + } + + yield extension.startup(); + yield extension.awaitFinish("contextmenus-urlPatterns"); + + let extensionContextMenu = yield openExtensionContextMenu("#img1"); + let expected = [ + ["targetUrlPatterns-patternMatches-contextAll", true], + ["targetUrlPatterns-patternMatches-contextImage", true], + ["targetUrlPatterns-patternMatches-contextLink", false], + ["targetUrlPatterns-patternDoesNotMatch-contextAll", false], + ["targetUrlPatterns-patternDoesNotMatch-contextImage", false], + ["targetUrlPatterns-patternDoesNotMatch-contextLink", false], + ["documentUrlPatterns-patternMatches-contextAll", true], + ["documentUrlPatterns-patternMatches-contextImage", true], + ["documentUrlPatterns-patternMatches-contextLink", false], + ["documentUrlPatterns-patternDoesNotMatch-contextAll", false], + ["documentUrlPatterns-patternDoesNotMatch-contextImage", false], + ["documentUrlPatterns-patternDoesNotMatch-contextLink", false], + ["documentUrlPatterns-patternMatches-targetUrlPatterns-patternMatches-contextAll", true], + ["documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternMatches-contextAll", false], + ["documentUrlPatterns-patternMatches-targetUrlPatterns-patternDoesNotMatch-contextAll", false], + ["documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternDoesNotMatch-contextAll", false], + ["documentUrlPatterns-patternMatches-targetUrlPatterns-patternMatches-contextImage", true], + ["documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternMatches-contextImage", false], + ["documentUrlPatterns-patternMatches-targetUrlPatterns-patternDoesNotMatch-contextImage", false], + ["documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternDoesNotMatch-contextImage", false], + ]; + yield confirmContextMenuItems(extensionContextMenu, expected); + yield closeContextMenu(); + + let contextMenu = yield openContextMenu("body"); + expected = [ + ["targetUrlPatterns-patternMatches-contextAll", false], + ["targetUrlPatterns-patternMatches-contextImage", false], + ["targetUrlPatterns-patternMatches-contextLink", false], + ["targetUrlPatterns-patternDoesNotMatch-contextAll", false], + ["targetUrlPatterns-patternDoesNotMatch-contextImage", false], + ["targetUrlPatterns-patternDoesNotMatch-contextLink", false], + ["documentUrlPatterns-patternMatches-contextAll", true], + ["documentUrlPatterns-patternMatches-contextImage", false], + ["documentUrlPatterns-patternMatches-contextLink", false], + ["documentUrlPatterns-patternDoesNotMatch-contextAll", false], + ["documentUrlPatterns-patternDoesNotMatch-contextImage", false], + ["documentUrlPatterns-patternDoesNotMatch-contextLink", false], + ["documentUrlPatterns-patternMatches-targetUrlPatterns-patternMatches-contextAll", false], + ["documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternMatches-contextAll", false], + ["documentUrlPatterns-patternMatches-targetUrlPatterns-patternDoesNotMatch-contextAll", false], + ["documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternDoesNotMatch-contextAll", false], + ["documentUrlPatterns-patternMatches-targetUrlPatterns-patternMatches-contextImage", false], + ["documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternMatches-contextImage", false], + ["documentUrlPatterns-patternMatches-targetUrlPatterns-patternDoesNotMatch-contextImage", false], + ["documentUrlPatterns-patternDoesNotMatch-targetUrlPatterns-patternDoesNotMatch-contextImage", false], + ]; + yield confirmContextMenuItems(contextMenu, expected); + yield closeContextMenu(); + + contextMenu = yield openContextMenu("#link1"); + expected = [ + ["targetUrlPatterns-patternMatches-contextAll", true], + ["targetUrlPatterns-patternMatches-contextImage", false], + ["targetUrlPatterns-patternMatches-contextLink", true], + ["targetUrlPatterns-patternDoesNotMatch-contextAll", false], + ["targetUrlPatterns-patternDoesNotMatch-contextImage", false], + ["targetUrlPatterns-patternDoesNotMatch-contextLink", false], + ["documentUrlPatterns-patternMatches-contextAll", true], + ["documentUrlPatterns-patternMatches-contextImage", false], + ["documentUrlPatterns-patternMatches-contextLink", true], + ["documentUrlPatterns-patternDoesNotMatch-contextAll", false], + ["documentUrlPatterns-patternDoesNotMatch-contextImage", false], + ["documentUrlPatterns-patternDoesNotMatch-contextLink", false], + ]; + yield confirmContextMenuItems(contextMenu, expected); + yield closeContextMenu(); + + contextMenu = yield openContextMenu("#img-wrapped-in-link"); + expected = [ + ["targetUrlPatterns-patternMatches-contextAll", true], + ["targetUrlPatterns-patternMatches-contextImage", true], + ["targetUrlPatterns-patternMatches-contextLink", true], + ["targetUrlPatterns-patternDoesNotMatch-contextAll", false], + ["targetUrlPatterns-patternDoesNotMatch-contextImage", false], + ["targetUrlPatterns-patternDoesNotMatch-contextLink", false], + ["documentUrlPatterns-patternMatches-contextAll", true], + ["documentUrlPatterns-patternMatches-contextImage", true], + ["documentUrlPatterns-patternMatches-contextLink", true], + ["documentUrlPatterns-patternDoesNotMatch-contextAll", false], + ["documentUrlPatterns-patternDoesNotMatch-contextImage", false], + ["documentUrlPatterns-patternDoesNotMatch-contextLink", false], + ]; + yield confirmContextMenuItems(contextMenu, expected); + yield closeContextMenu(); + + yield extension.unload(); + yield BrowserTestUtils.removeTab(tab1); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_currentWindow.js b/browser/components/extensions/test/browser/browser_ext_currentWindow.js new file mode 100644 index 000000000..11660bf4d --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_currentWindow.js @@ -0,0 +1,149 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function genericChecker() { + let kind = "background"; + let path = window.location.pathname; + if (path.includes("/popup.html")) { + kind = "popup"; + } else if (path.includes("/page.html")) { + kind = "page"; + } + + browser.test.onMessage.addListener((msg, ...args) => { + if (msg == kind + "-check-current1") { + browser.tabs.query({ + currentWindow: true, + }, function(tabs) { + browser.test.sendMessage("result", tabs[0].windowId); + }); + } else if (msg == kind + "-check-current2") { + browser.tabs.query({ + windowId: browser.windows.WINDOW_ID_CURRENT, + }, function(tabs) { + browser.test.sendMessage("result", tabs[0].windowId); + }); + } else if (msg == kind + "-check-current3") { + browser.windows.getCurrent(function(window) { + browser.test.sendMessage("result", window.id); + }); + } else if (msg == kind + "-open-page") { + browser.tabs.create({windowId: args[0], url: browser.runtime.getURL("page.html")}); + } else if (msg == kind + "-close-page") { + browser.tabs.query({ + windowId: args[0], + }, tabs => { + let tab = tabs.find(tab => tab.url.includes("/page.html")); + browser.tabs.remove(tab.id, () => { + browser.test.sendMessage("closed"); + }); + }); + } + }); + browser.test.sendMessage(kind + "-ready"); +} + +add_task(function* () { + let win1 = yield BrowserTestUtils.openNewBrowserWindow(); + let win2 = yield BrowserTestUtils.openNewBrowserWindow(); + + yield focusWindow(win2); + + yield BrowserTestUtils.loadURI(win1.gBrowser.selectedBrowser, "about:robots"); + yield BrowserTestUtils.browserLoaded(win1.gBrowser.selectedBrowser); + + yield BrowserTestUtils.loadURI(win2.gBrowser.selectedBrowser, "about:config"); + yield BrowserTestUtils.browserLoaded(win2.gBrowser.selectedBrowser); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + + "browser_action": { + "default_popup": "popup.html", + }, + }, + + files: { + "page.html": ` + <!DOCTYPE html> + <html><body> + <script src="page.js"></script> + </body></html> + `, + + "page.js": genericChecker, + + "popup.html": ` + <!DOCTYPE html> + <html><body> + <script src="popup.js"></script> + </body></html> + `, + + "popup.js": genericChecker, + }, + + background: genericChecker, + }); + + yield Promise.all([extension.startup(), extension.awaitMessage("background-ready")]); + + let {Management: {global: {WindowManager}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + let winId1 = WindowManager.getId(win1); + let winId2 = WindowManager.getId(win2); + + function* checkWindow(kind, winId, name) { + extension.sendMessage(kind + "-check-current1"); + is((yield extension.awaitMessage("result")), winId, `${name} is on top (check 1) [${kind}]`); + extension.sendMessage(kind + "-check-current2"); + is((yield extension.awaitMessage("result")), winId, `${name} is on top (check 2) [${kind}]`); + extension.sendMessage(kind + "-check-current3"); + is((yield extension.awaitMessage("result")), winId, `${name} is on top (check 3) [${kind}]`); + } + + yield focusWindow(win1); + yield checkWindow("background", winId1, "win1"); + yield focusWindow(win2); + yield checkWindow("background", winId2, "win2"); + + function* triggerPopup(win, callback) { + yield clickBrowserAction(extension, win); + yield awaitExtensionPanel(extension, win); + + yield extension.awaitMessage("popup-ready"); + + yield callback(); + + closeBrowserAction(extension, win); + } + + // Set focus to some other window. + yield focusWindow(window); + + yield triggerPopup(win1, function* () { + yield checkWindow("popup", winId1, "win1"); + }); + + yield triggerPopup(win2, function* () { + yield checkWindow("popup", winId2, "win2"); + }); + + function* triggerPage(winId, name) { + extension.sendMessage("background-open-page", winId); + yield extension.awaitMessage("page-ready"); + yield checkWindow("page", winId, name); + extension.sendMessage("background-close-page", winId); + yield extension.awaitMessage("closed"); + } + + yield triggerPage(winId1, "win1"); + yield triggerPage(winId2, "win2"); + + yield extension.unload(); + + yield BrowserTestUtils.closeWindow(win1); + yield BrowserTestUtils.closeWindow(win2); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_getViews.js b/browser/components/extensions/test/browser/browser_ext_getViews.js new file mode 100644 index 000000000..684e19ac5 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_getViews.js @@ -0,0 +1,198 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function genericChecker() { + let kind = "background"; + let path = window.location.pathname; + if (path.indexOf("popup") != -1) { + kind = "popup"; + } else if (path.indexOf("tab") != -1) { + kind = "tab"; + } + window.kind = kind; + + browser.test.onMessage.addListener((msg, ...args) => { + if (msg == kind + "-check-views") { + let windowId = args[0]; + let counts = { + "background": 0, + "tab": 0, + "popup": 0, + "kind": 0, + "window": 0, + }; + if (Number.isInteger(windowId)) { + counts.window = browser.extension.getViews({windowId: windowId}).length; + } + if (kind !== "background") { + counts.kind = browser.extension.getViews({type: kind}).length; + } + let views = browser.extension.getViews(); + let background; + for (let i = 0; i < views.length; i++) { + let view = views[i]; + browser.test.assertTrue(view.kind in counts, "view type is valid"); + counts[view.kind]++; + if (view.kind == "background") { + browser.test.assertTrue(view === browser.extension.getBackgroundPage(), + "background page is correct"); + background = view; + } + } + if (background) { + browser.runtime.getBackgroundPage().then(view => { + browser.test.assertEq(background, view, "runtime.getBackgroundPage() is correct"); + browser.test.sendMessage("counts", counts); + }); + } else { + browser.test.sendMessage("counts", counts); + } + } else if (msg == kind + "-open-tab") { + browser.tabs.create({windowId: args[0], url: browser.runtime.getURL("tab.html")}); + } else if (msg == kind + "-close-tab") { + browser.tabs.query({ + windowId: args[0], + }, tabs => { + let tab = tabs.find(tab => tab.url.indexOf("tab.html") != -1); + browser.tabs.remove(tab.id, () => { + browser.test.sendMessage("closed"); + }); + }); + } + }); + browser.test.sendMessage(kind + "-ready"); +} + +add_task(function* () { + let win1 = yield BrowserTestUtils.openNewBrowserWindow(); + let win2 = yield BrowserTestUtils.openNewBrowserWindow(); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + + "browser_action": { + "default_popup": "popup.html", + }, + }, + + files: { + "tab.html": ` + <!DOCTYPE html> + <html><body> + <script src="tab.js"></script> + </body></html> + `, + + "tab.js": genericChecker, + + "popup.html": ` + <!DOCTYPE html> + <html><body> + <script src="popup.js"></script> + </body></html> + `, + + "popup.js": genericChecker, + }, + + background: genericChecker, + }); + + yield Promise.all([extension.startup(), extension.awaitMessage("background-ready")]); + + info("started"); + + let {Management: {global: {WindowManager}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + let winId1 = WindowManager.getId(win1); + let winId2 = WindowManager.getId(win2); + + function* openTab(winId) { + extension.sendMessage("background-open-tab", winId); + yield extension.awaitMessage("tab-ready"); + } + + function* checkViews(kind, tabCount, popupCount, kindCount, windowId = undefined, windowCount = 0) { + extension.sendMessage(kind + "-check-views", windowId); + let counts = yield extension.awaitMessage("counts"); + is(counts.background, 1, "background count correct"); + is(counts.tab, tabCount, "tab count correct"); + is(counts.popup, popupCount, "popup count correct"); + is(counts.kind, kindCount, "count for type correct"); + is(counts.window, windowCount, "count for window correct"); + } + + yield checkViews("background", 0, 0, 0); + + yield openTab(winId1); + + yield checkViews("background", 1, 0, 0, winId1, 1); + yield checkViews("tab", 1, 0, 1); + + yield openTab(winId2); + + yield checkViews("background", 2, 0, 0, winId2, 1); + + function* triggerPopup(win, callback) { + yield clickBrowserAction(extension, win); + yield awaitExtensionPanel(extension, win); + + yield extension.awaitMessage("popup-ready"); + + yield callback(); + + closeBrowserAction(extension, win); + } + + // The popup occasionally closes prematurely if we open it immediately here. + // I'm not sure what causes it to close (it's something internal, and seems to + // be focus-related, but it's not caused by JS calling hidePopup), but even a + // short timeout seems to consistently fix it. + yield new Promise(resolve => win1.setTimeout(resolve, 10)); + + yield triggerPopup(win1, function* () { + yield checkViews("background", 2, 1, 0, winId1, 2); + yield checkViews("popup", 2, 1, 1); + }); + + yield triggerPopup(win2, function* () { + yield checkViews("background", 2, 1, 0, winId2, 2); + yield checkViews("popup", 2, 1, 1); + }); + + info("checking counts after popups"); + + yield checkViews("background", 2, 0, 0, winId1, 1); + + info("closing one tab"); + + extension.sendMessage("background-close-tab", winId1); + yield extension.awaitMessage("closed"); + + info("one tab closed, one remains"); + + yield checkViews("background", 1, 0, 0); + + info("opening win1 popup"); + + yield triggerPopup(win1, function* () { + yield checkViews("background", 1, 1, 0); + yield checkViews("tab", 1, 1, 1); + yield checkViews("popup", 1, 1, 1); + }); + + info("opening win2 popup"); + + yield triggerPopup(win2, function* () { + yield checkViews("background", 1, 1, 0); + yield checkViews("tab", 1, 1, 1); + yield checkViews("popup", 1, 1, 1); + }); + + yield extension.unload(); + + yield BrowserTestUtils.closeWindow(win1); + yield BrowserTestUtils.closeWindow(win2); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_incognito_popup.js b/browser/components/extensions/test/browser/browser_ext_incognito_popup.js new file mode 100644 index 000000000..174b2179d --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_incognito_popup.js @@ -0,0 +1,108 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testIncognitoPopup() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + "browser_action": { + "default_popup": "popup.html", + }, + "page_action": { + "default_popup": "popup.html", + }, + }, + + background: async function() { + let resolveMessage; + browser.runtime.onMessage.addListener(msg => { + if (resolveMessage && msg.message == "popup-details") { + resolveMessage(msg); + } + }); + + let awaitPopup = windowId => { + return new Promise(resolve => { + resolveMessage = resolve; + }).then(msg => { + browser.test.assertEq(windowId, msg.windowId, "Got popup message from correct window"); + return msg; + }); + }; + + let testWindow = async window => { + let [tab] = await browser.tabs.query({active: true, windowId: window.id}); + + await browser.pageAction.show(tab.id); + browser.test.sendMessage("click-pageAction"); + + let msg = await awaitPopup(window.id); + browser.test.assertEq(window.incognito, msg.incognito, "Correct incognito status in pageAction popup"); + + browser.test.sendMessage("click-browserAction"); + + msg = await awaitPopup(window.id); + browser.test.assertEq(window.incognito, msg.incognito, "Correct incognito status in browserAction popup"); + }; + + const URL = "http://example.com/incognito"; + let windowReady = new Promise(resolve => { + browser.tabs.onUpdated.addListener(function listener(tabId, changed, tab) { + if (changed.status == "complete" && tab.url == URL) { + browser.tabs.onUpdated.removeListener(listener); + resolve(); + } + }); + }); + + try { + { + let window = await browser.windows.getCurrent(); + + await testWindow(window); + } + + { + let window = await browser.windows.create({incognito: true, url: URL}); + await windowReady; + + await testWindow(window); + + await browser.windows.remove(window.id); + } + + browser.test.notifyPass("incognito"); + } catch (error) { + browser.test.fail(`Error: ${error} :: ${error.stack}`); + browser.test.notifyFail("incognito"); + } + }, + + files: { + "popup.html": '<html><head><meta charset="utf-8"><script src="popup.js"></script></head></html>', + + "popup.js": async function() { + let win = await browser.windows.getCurrent(); + browser.runtime.sendMessage({ + message: "popup-details", + windowId: win.id, + incognito: browser.extension.inIncognitoContext, + }); + window.close(); + }, + }, + }); + + extension.onMessage("click-browserAction", () => { + clickBrowserAction(extension, Services.wm.getMostRecentWindow("navigator:browser")); + }); + + extension.onMessage("click-pageAction", () => { + clickPageAction(extension, Services.wm.getMostRecentWindow("navigator:browser")); + }); + + yield extension.startup(); + yield extension.awaitFinish("incognito"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_incognito_views.js b/browser/components/extensions/test/browser/browser_ext_incognito_views.js new file mode 100644 index 000000000..4865b2d4f --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_incognito_views.js @@ -0,0 +1,121 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testIncognitoViews() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + "browser_action": { + "default_popup": "popup.html", + }, + }, + + background: async function() { + window.isBackgroundPage = true; + + let resolveMessage; + browser.runtime.onMessage.addListener(msg => { + if (resolveMessage && msg.message == "popup-details") { + resolveMessage(msg); + } + }); + + let awaitPopup = windowId => { + return new Promise(resolve => { + resolveMessage = resolve; + }).then(msg => { + browser.test.assertEq(windowId, msg.windowId, "Got popup message from correct window"); + return msg; + }); + }; + + let testWindow = async window => { + browser.test.sendMessage("click-browserAction"); + + let msg = await awaitPopup(window.id); + browser.test.assertEq(window.incognito, msg.incognito, "Correct incognito status in browserAction popup"); + }; + + const URL = "http://example.com/incognito"; + let windowReady = new Promise(resolve => { + browser.tabs.onUpdated.addListener(function listener(tabId, changed, tab) { + if (changed.status == "complete" && tab.url == URL) { + browser.tabs.onUpdated.removeListener(listener); + resolve(); + } + }); + }); + + try { + { + let window = await browser.windows.getCurrent(); + + await testWindow(window); + } + + { + let window = await browser.windows.create({incognito: true, url: URL}); + await windowReady; + + await testWindow(window); + + await browser.windows.remove(window.id); + } + + browser.test.notifyPass("incognito-views"); + } catch (error) { + browser.test.fail(`Error: ${error} :: ${error.stack}`); + browser.test.notifyFail("incognito-views"); + } + }, + + files: { + "popup.html": '<html><head><meta charset="utf-8"><script src="popup.js"></script></head></html>', + + "popup.js": async function() { + let views = browser.extension.getViews(); + + if (browser.extension.inIncognitoContext) { + let bgPage = browser.extension.getBackgroundPage(); + browser.test.assertEq(null, bgPage, "Should not be able to access background page in incognito context"); + + bgPage = await browser.runtime.getBackgroundPage(); + browser.test.assertEq(null, bgPage, "Should not be able to access background page in incognito context"); + + browser.test.assertEq(1, views.length, "Should only see one view in incognito popup"); + browser.test.assertEq(window, views[0], "This window should be the only view"); + } else { + let bgPage = browser.extension.getBackgroundPage(); + browser.test.assertEq(true, bgPage.isBackgroundPage, + "Should be able to access background page in non-incognito context"); + + bgPage = await browser.runtime.getBackgroundPage(); + browser.test.assertEq(true, bgPage.isBackgroundPage, + "Should be able to access background page in non-incognito context"); + + browser.test.assertEq(2, views.length, "Should only two views in non-incognito popup"); + browser.test.assertEq(bgPage, views[0], "The background page should be the first view"); + browser.test.assertEq(window, views[1], "This window should be the second view"); + } + + let win = await browser.windows.getCurrent(); + browser.runtime.sendMessage({ + message: "popup-details", + windowId: win.id, + incognito: browser.extension.inIncognitoContext, + }); + + window.close(); + }, + }, + }); + + extension.onMessage("click-browserAction", () => { + clickBrowserAction(extension, Services.wm.getMostRecentWindow("navigator:browser")); + }); + + yield extension.startup(); + yield extension.awaitFinish("incognito-views"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_lastError.js b/browser/components/extensions/test/browser/browser_ext_lastError.js new file mode 100644 index 000000000..499e709aa --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_lastError.js @@ -0,0 +1,55 @@ +"use strict"; + +function* sendMessage(options) { + function background(options) { + browser.runtime.sendMessage(result => { + browser.test.assertEq(undefined, result, "Argument value"); + if (options.checkLastError) { + let lastError = browser[options.checkLastError].lastError; + browser.test.assertEq("runtime.sendMessage's message argument is missing", + lastError && lastError.message, + "lastError value"); + } + browser.test.sendMessage("done"); + }); + } + + let extension = ExtensionTestUtils.loadExtension({ + background: `(${background})(${JSON.stringify(options)})`, + }); + + yield extension.startup(); + + yield extension.awaitMessage("done"); + + yield extension.unload(); +} + +add_task(function* testLastError() { + // Not necessary in browser-chrome tests, but monitorConsole gripes + // if we don't call it. + SimpleTest.waitForExplicitFinish(); + + // Check that we have no unexpected console messages when lastError is + // checked. + for (let api of ["extension", "runtime"]) { + let waitForConsole = new Promise(resolve => { + SimpleTest.monitorConsole(resolve, [{message: /message argument is missing/, forbid: true}]); + }); + + yield sendMessage({checkLastError: api}); + + SimpleTest.endMonitorConsole(); + yield waitForConsole; + } + + // Check that we do have a console message when lastError is not checked. + let waitForConsole = new Promise(resolve => { + SimpleTest.monitorConsole(resolve, [{message: /Unchecked lastError value: Error: runtime.sendMessage's message argument is missing/}]); + }); + + yield sendMessage({}); + + SimpleTest.endMonitorConsole(); + yield waitForConsole; +}); diff --git a/browser/components/extensions/test/browser/browser_ext_legacy_extension_context_contentscript.js b/browser/components/extensions/test/browser/browser_ext_legacy_extension_context_contentscript.js new file mode 100644 index 000000000..01557a745 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_legacy_extension_context_contentscript.js @@ -0,0 +1,173 @@ +"use strict"; + +const { + LegacyExtensionContext, +} = Cu.import("resource://gre/modules/LegacyExtensionsUtils.jsm", {}); + +function promiseAddonStartup(extension) { + const {Management} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + return new Promise((resolve) => { + let listener = (evt, extensionInstance) => { + Management.off("startup", listener); + resolve(extensionInstance); + }; + Management.on("startup", listener); + }); +} + +/** + * This test case ensures that the LegacyExtensionContext can receive a connection + * from a content script and that the received port contains the expected sender + * tab info. + */ +add_task(function* test_legacy_extension_context_contentscript_connection() { + function backgroundScript() { + // Extract the assigned uuid from the background page url and send it + // in a test message. + let uuid = window.location.hostname; + + browser.test.onMessage.addListener(async msg => { + if (msg == "open-test-tab") { + let tab = await browser.tabs.create({url: "http://example.com/"}); + browser.test.sendMessage("get-expected-sender-info", + {uuid, tab}); + } else if (msg == "close-current-tab") { + try { + let [tab] = await browser.tabs.query({active: true}); + await browser.tabs.remove(tab.id); + browser.test.sendMessage("current-tab-closed", true); + } catch (e) { + browser.test.sendMessage("current-tab-closed", false); + } + } + }); + + browser.test.sendMessage("ready"); + } + + function contentScript() { + browser.runtime.sendMessage("webextension -> legacy_extension message", (reply) => { + browser.test.assertEq("legacy_extension -> webextension reply", reply, + "Got the expected reply from the LegacyExtensionContext"); + browser.test.sendMessage("got-reply-message"); + }); + + let port = browser.runtime.connect(); + + port.onMessage.addListener(msg => { + browser.test.assertEq("legacy_extension -> webextension port message", msg, + "Got the expected message from the LegacyExtensionContext"); + port.postMessage("webextension -> legacy_extension port message"); + }); + } + + let extensionData = { + background: `new ${backgroundScript}`, + manifest: { + content_scripts: [ + { + matches: ["http://example.com/*"], + js: ["content-script.js"], + }, + ], + }, + files: { + "content-script.js": `new ${contentScript}`, + }, + }; + + let extension = ExtensionTestUtils.loadExtension(extensionData); + + let waitForExtensionReady = extension.awaitMessage("ready"); + + let waitForExtensionInstance = promiseAddonStartup(extension); + + extension.startup(); + + let extensionInstance = yield waitForExtensionInstance; + + // Connect to the target extension.id as an external context + // using the given custom sender info. + let legacyContext = new LegacyExtensionContext(extensionInstance); + + let waitConnectPort = new Promise(resolve => { + let {browser} = legacyContext.api; + browser.runtime.onConnect.addListener(port => { + resolve(port); + }); + }); + + let waitMessage = new Promise(resolve => { + let {browser} = legacyContext.api; + browser.runtime.onMessage.addListener((singleMsg, msgSender, sendReply) => { + sendReply("legacy_extension -> webextension reply"); + resolve({singleMsg, msgSender}); + }); + }); + + is(legacyContext.envType, "legacy_extension", + "LegacyExtensionContext instance has the expected type"); + + ok(legacyContext.api, "Got the API object"); + + yield waitForExtensionReady; + + extension.sendMessage("open-test-tab"); + + let {uuid, tab} = yield extension.awaitMessage("get-expected-sender-info"); + + let {singleMsg, msgSender} = yield waitMessage; + is(singleMsg, "webextension -> legacy_extension message", + "Got the expected message"); + ok(msgSender, "Got a message sender object"); + + is(msgSender.id, uuid, "The sender has the expected id property"); + is(msgSender.url, "http://example.com/", "The sender has the expected url property"); + ok(msgSender.tab, "The sender has a tab property"); + is(msgSender.tab.id, tab.id, "The port sender has the expected tab.id"); + + // Wait confirmation that the reply has been received. + yield extension.awaitMessage("got-reply-message"); + + let port = yield waitConnectPort; + + ok(port, "Got the Port API object"); + ok(port.sender, "The port has a sender property"); + + is(port.sender.id, uuid, "The port sender has an id property"); + is(port.sender.url, "http://example.com/", "The port sender has the expected url property"); + ok(port.sender.tab, "The port sender has a tab property"); + is(port.sender.tab.id, tab.id, "The port sender has the expected tab.id"); + + let waitPortMessage = new Promise(resolve => { + port.onMessage.addListener((msg) => { + resolve(msg); + }); + }); + + port.postMessage("legacy_extension -> webextension port message"); + + let msg = yield waitPortMessage; + + is(msg, "webextension -> legacy_extension port message", + "LegacyExtensionContext received the expected message from the webextension"); + + let waitForDisconnect = new Promise(resolve => { + port.onDisconnect.addListener(resolve); + }); + + let waitForTestDone = extension.awaitMessage("current-tab-closed"); + + extension.sendMessage("close-current-tab"); + + yield waitForDisconnect; + + info("Got the disconnect event on tab closed"); + + let success = yield waitForTestDone; + + ok(success, "Test completed successfully"); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_omnibox.js b/browser/components/extensions/test/browser/browser_ext_omnibox.js new file mode 100644 index 000000000..98d3573c5 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_omnibox.js @@ -0,0 +1,286 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function* setup() { + const SUGGEST_URLBAR_PREF = "browser.urlbar.suggest.searches"; + Services.prefs.setBoolPref(SUGGEST_URLBAR_PREF, false); + + registerCleanupFunction(() => { + Services.prefs.clearUserPref(SUGGEST_URLBAR_PREF); + }); +} + +add_task(function* () { + let keyword = "test"; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "omnibox": { + "keyword": keyword, + }, + }, + + background: function() { + browser.omnibox.onInputStarted.addListener(() => { + browser.test.sendMessage("on-input-started-fired"); + }); + + let synchronous = true; + let suggestions = null; + let suggestCallback = null; + + browser.omnibox.onInputChanged.addListener((text, suggest) => { + if (synchronous && suggestions) { + suggest(suggestions); + } else { + suggestCallback = suggest; + } + browser.test.sendMessage("on-input-changed-fired", {text}); + }); + + browser.omnibox.onInputCancelled.addListener(() => { + browser.test.sendMessage("on-input-cancelled-fired"); + }); + + browser.omnibox.onInputEntered.addListener((text, disposition) => { + browser.test.sendMessage("on-input-entered-fired", {text, disposition}); + }); + + browser.test.onMessage.addListener((msg, data) => { + switch (msg) { + case "set-suggestions": + suggestions = data.suggestions; + browser.test.sendMessage("suggestions-set"); + break; + case "set-default-suggestion": + browser.omnibox.setDefaultSuggestion(data.suggestion); + browser.test.sendMessage("default-suggestion-set"); + break; + case "set-synchronous": + synchronous = data.synchronous; + break; + case "test-multiple-suggest-calls": + suggestions.forEach(suggestion => suggestCallback([suggestion])); + browser.test.sendMessage("test-ready"); + break; + case "test-suggestions-after-delay": + Promise.resolve().then(() => { + suggestCallback(suggestions); + browser.test.sendMessage("test-ready"); + }); + break; + } + }); + }, + }); + + function* expectEvent(event, expected = {}) { + let actual = yield extension.awaitMessage(event); + if (expected.text) { + is(actual.text, expected.text, + `Expected "${event}" to have fired with text: "${expected.text}".`); + } + if (expected.disposition) { + is(actual.disposition, expected.disposition, + `Expected "${event}" to have fired with disposition: "${expected.disposition}".`); + } + } + + function* startInputSession() { + gURLBar.focus(); + gURLBar.value = keyword; + EventUtils.synthesizeKey(" ", {}); + yield expectEvent("on-input-started-fired"); + EventUtils.synthesizeKey("t", {}); + yield expectEvent("on-input-changed-fired", {text: "t"}); + return "t"; + } + + function* testInputEvents() { + gURLBar.focus(); + + // Start an input session by typing in <keyword><space>. + for (let letter of keyword) { + EventUtils.synthesizeKey(letter, {}); + } + EventUtils.synthesizeKey(" ", {}); + yield expectEvent("on-input-started-fired"); + + // We should expect input changed events now that the keyword is active. + EventUtils.synthesizeKey("b", {}); + yield expectEvent("on-input-changed-fired", {text: "b"}); + + EventUtils.synthesizeKey("c", {}); + yield expectEvent("on-input-changed-fired", {text: "bc"}); + + EventUtils.synthesizeKey("VK_BACK_SPACE", {}); + yield expectEvent("on-input-changed-fired", {text: "b"}); + + // Even though the input is <keyword><space> We should not expect an + // input started event to fire since the keyword is active. + EventUtils.synthesizeKey("VK_BACK_SPACE", {}); + yield expectEvent("on-input-changed-fired", {text: ""}); + + // Make the keyword inactive by hitting backspace. + EventUtils.synthesizeKey("VK_BACK_SPACE", {}); + yield expectEvent("on-input-cancelled-fired"); + + // Activate the keyword by typing a space. + // Expect onInputStarted to fire. + EventUtils.synthesizeKey(" ", {}); + yield expectEvent("on-input-started-fired"); + + // onInputChanged should fire even if a space is entered. + EventUtils.synthesizeKey(" ", {}); + yield expectEvent("on-input-changed-fired", {text: " "}); + + // The active session should cancel if the input blurs. + gURLBar.blur(); + yield expectEvent("on-input-cancelled-fired"); + } + + function* testHeuristicResult(expectedText, setDefaultSuggestion) { + if (setDefaultSuggestion) { + extension.sendMessage("set-default-suggestion", { + suggestion: { + description: expectedText, + }, + }); + yield extension.awaitMessage("default-suggestion-set"); + } + + let text = yield startInputSession(); + + let item = gURLBar.popup.richlistbox.children[0]; + + is(item.getAttribute("title"), expectedText, + `Expected heuristic result to have title: "${expectedText}".`); + + is(item.getAttribute("displayurl"), `${keyword} ${text}`, + `Expected heuristic result to have displayurl: "${keyword} ${text}".`); + + EventUtils.synthesizeMouseAtCenter(item, {}); + + yield expectEvent("on-input-entered-fired", { + text, + disposition: "currentTab", + }); + } + + function* testDisposition(suggestionIndex, expectedDisposition, expectedText) { + yield startInputSession(); + + // Select the suggestion. + for (let i = 0; i < suggestionIndex; i++) { + EventUtils.synthesizeKey("VK_DOWN", {}); + } + + let item = gURLBar.popup.richlistbox.children[suggestionIndex]; + if (expectedDisposition == "currentTab") { + EventUtils.synthesizeMouseAtCenter(item, {}); + } else if (expectedDisposition == "newForegroundTab") { + EventUtils.synthesizeMouseAtCenter(item, {accelKey: true}); + } else if (expectedDisposition == "newBackgroundTab") { + EventUtils.synthesizeMouseAtCenter(item, {shiftKey: true, accelKey: true}); + } + + yield expectEvent("on-input-entered-fired", { + text: expectedText, + disposition: expectedDisposition, + }); + } + + function* testSuggestions(info) { + extension.sendMessage("set-synchronous", {synchronous: false}); + + function expectSuggestion({content, description}, index) { + let item = gURLBar.popup.richlistbox.children[index + 1]; // Skip the heuristic result. + + ok(!!item, "Expected item to exist"); + is(item.getAttribute("title"), description, + `Expected suggestion to have title: "${description}".`); + + is(item.getAttribute("displayurl"), `${keyword} ${content}`, + `Expected suggestion to have displayurl: "${keyword} ${content}".`); + } + + let text = yield startInputSession(); + + extension.sendMessage(info.test); + yield extension.awaitMessage("test-ready"); + + info.suggestions.forEach(expectSuggestion); + + EventUtils.synthesizeMouseAtCenter(gURLBar.popup.richlistbox.children[0], {}); + yield expectEvent("on-input-entered-fired", { + text, + disposition: "currentTab", + }); + } + + yield setup(); + yield extension.startup(); + + yield testInputEvents(); + + // Test the heuristic result with default suggestions. + yield testHeuristicResult("Generated extension", false /* setDefaultSuggestion */); + yield testHeuristicResult("hello world", true /* setDefaultSuggestion */); + yield testHeuristicResult("foo bar", true /* setDefaultSuggestion */); + + let suggestions = [ + {content: "a", description: "select a"}, + {content: "b", description: "select b"}, + {content: "c", description: "select c"}, + ]; + + extension.sendMessage("set-suggestions", {suggestions}); + yield extension.awaitMessage("suggestions-set"); + + // Test each suggestion and search disposition. + yield testDisposition(1, "currentTab", suggestions[0].content); + yield testDisposition(2, "newForegroundTab", suggestions[1].content); + yield testDisposition(3, "newBackgroundTab", suggestions[2].content); + + extension.sendMessage("set-suggestions", {suggestions}); + yield extension.awaitMessage("suggestions-set"); + + // Test adding suggestions asynchronously. + yield testSuggestions({ + test: "test-multiple-suggest-calls", + skipHeuristic: true, + suggestions, + }); + yield testSuggestions({ + test: "test-suggestions-after-delay", + skipHeuristic: true, + suggestions, + }); + + // Start monitoring the console. + SimpleTest.waitForExplicitFinish(); + let waitForConsole = new Promise(resolve => { + SimpleTest.monitorConsole(resolve, [{ + message: new RegExp(`The keyword provided is already registered: "${keyword}"`), + }]); + }); + + // Try registering another extension with the same keyword + let extension2 = ExtensionTestUtils.loadExtension({ + manifest: { + "omnibox": { + "keyword": keyword, + }, + }, + }); + + yield extension2.startup(); + + // Stop monitoring the console and confirm the correct errors are logged. + SimpleTest.endMonitorConsole(); + yield waitForConsole; + + yield extension2.unload(); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_optionsPage_privileges.js b/browser/components/extensions/test/browser/browser_ext_optionsPage_privileges.js new file mode 100644 index 000000000..3e7342dd1 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_optionsPage_privileges.js @@ -0,0 +1,66 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* test_tab_options_privileges() { + function backgroundScript() { + browser.runtime.onMessage.addListener(({msgName, tabId}) => { + if (msgName == "removeTabId") { + browser.tabs.remove(tabId).then(() => { + browser.test.notifyPass("options-ui-privileges"); + }).catch(error => { + browser.test.log(`Error: ${error} :: ${error.stack}`); + browser.test.notifyFail("options-ui-privileges"); + }); + } + }); + browser.runtime.openOptionsPage(); + } + + async function optionsScript() { + try { + let [tab] = await browser.tabs.query({url: "http://example.com/"}); + browser.test.assertEq("http://example.com/", tab.url, "Got the expect tab"); + + tab = await browser.tabs.getCurrent(); + browser.runtime.sendMessage({msgName: "removeTabId", tabId: tab.id}); + } catch (error) { + browser.test.log(`Error: ${error} :: ${error.stack}`); + browser.test.notifyFail("options-ui-privileges"); + } + } + + const ID = "options_privileges@tests.mozilla.org"; + let extension = ExtensionTestUtils.loadExtension({ + useAddonManager: "temporary", + + manifest: { + applications: {gecko: {id: ID}}, + "permissions": ["tabs"], + "options_ui": { + "page": "options.html", + }, + }, + files: { + "options.html": `<!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + <script src="options.js" type="text/javascript"></script> + </head> + </html>`, + "options.js": optionsScript, + }, + background: backgroundScript, + }); + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com/"); + + yield extension.startup(); + + yield extension.awaitFinish("options-ui-privileges"); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_pageAction_context.js b/browser/components/extensions/test/browser/browser_ext_pageAction_context.js new file mode 100644 index 000000000..2c2a4cd2f --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_pageAction_context.js @@ -0,0 +1,178 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +/* global runTests */ + +Services.scriptloader.loadSubScript(new URL("head_pageAction.js", gTestPath).href, + this); + +add_task(function* testTabSwitchContext() { + yield runTests({ + manifest: { + "name": "Foo Extension", + + "page_action": { + "default_icon": "default.png", + "default_popup": "__MSG_popup__", + "default_title": "Default __MSG_title__ \u263a", + }, + + "default_locale": "en", + + "permissions": ["tabs"], + }, + + "files": { + "_locales/en/messages.json": { + "popup": { + "message": "default.html", + "description": "Popup", + }, + + "title": { + "message": "Title", + "description": "Title", + }, + }, + + "_locales/es_ES/messages.json": { + "popup": { + "message": "default.html", + "description": "Popup", + }, + + "title": { + "message": "T\u00edtulo", + "description": "Title", + }, + }, + + "default.png": imageBuffer, + "1.png": imageBuffer, + "2.png": imageBuffer, + }, + + getTests(tabs) { + let details = [ + {"icon": browser.runtime.getURL("default.png"), + "popup": browser.runtime.getURL("default.html"), + "title": "Default T\u00edtulo \u263a"}, + {"icon": browser.runtime.getURL("1.png"), + "popup": browser.runtime.getURL("default.html"), + "title": "Default T\u00edtulo \u263a"}, + {"icon": browser.runtime.getURL("2.png"), + "popup": browser.runtime.getURL("2.html"), + "title": "Title 2"}, + {"icon": browser.runtime.getURL("2.png"), + "popup": browser.runtime.getURL("2.html"), + "title": "Default T\u00edtulo \u263a"}, + ]; + + let promiseTabLoad = details => { + return new Promise(resolve => { + browser.tabs.onUpdated.addListener(function listener(tabId, changed) { + if (tabId == details.id && changed.url == details.url) { + browser.tabs.onUpdated.removeListener(listener); + resolve(); + } + }); + }); + }; + + return [ + expect => { + browser.test.log("Initial state. No icon visible."); + expect(null); + }, + async expect => { + browser.test.log("Show the icon on the first tab, expect default properties."); + await browser.pageAction.show(tabs[0]); + expect(details[0]); + }, + expect => { + browser.test.log("Change the icon. Expect default properties excluding the icon."); + browser.pageAction.setIcon({tabId: tabs[0], path: "1.png"}); + expect(details[1]); + }, + async expect => { + browser.test.log("Create a new tab. No icon visible."); + let tab = await browser.tabs.create({active: true, url: "about:blank?0"}); + tabs.push(tab.id); + expect(null); + }, + expect => { + browser.test.log("Await tab load. No icon visible."); + expect(null); + }, + async expect => { + browser.test.log("Change properties. Expect new properties."); + let tabId = tabs[1]; + await browser.pageAction.show(tabId); + + browser.pageAction.setIcon({tabId, path: "2.png"}); + browser.pageAction.setPopup({tabId, popup: "2.html"}); + browser.pageAction.setTitle({tabId, title: "Title 2"}); + + expect(details[2]); + }, + async expect => { + browser.test.log("Change the hash. Expect same properties."); + + let promise = promiseTabLoad({id: tabs[1], url: "about:blank?0#ref"}); + browser.tabs.update(tabs[1], {url: "about:blank?0#ref"}); + await promise; + + expect(details[2]); + }, + expect => { + browser.test.log("Clear the title. Expect default title."); + browser.pageAction.setTitle({tabId: tabs[1], title: ""}); + + expect(details[3]); + }, + async expect => { + browser.test.log("Navigate to a new page. Expect icon hidden."); + + // TODO: This listener should not be necessary, but the |tabs.update| + // callback currently fires too early in e10s windows. + let promise = promiseTabLoad({id: tabs[1], url: "about:blank?1"}); + + browser.tabs.update(tabs[1], {url: "about:blank?1"}); + + await promise; + expect(null); + }, + async expect => { + browser.test.log("Show the icon. Expect default properties again."); + + await browser.pageAction.show(tabs[1]); + expect(details[0]); + }, + async expect => { + browser.test.log("Switch back to the first tab. Expect previously set properties."); + await browser.tabs.update(tabs[0], {active: true}); + expect(details[1]); + }, + async expect => { + browser.test.log("Hide the icon on tab 2. Switch back, expect hidden."); + await browser.pageAction.hide(tabs[1]); + + await browser.tabs.update(tabs[1], {active: true}); + expect(null); + }, + async expect => { + browser.test.log("Switch back to tab 1. Expect previous results again."); + await browser.tabs.remove(tabs[1]); + expect(details[1]); + }, + async expect => { + browser.test.log("Hide the icon. Expect hidden."); + + await browser.pageAction.hide(tabs[0]); + expect(null); + }, + ]; + }, + }); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_pageAction_popup.js b/browser/components/extensions/test/browser/browser_ext_pageAction_popup.js new file mode 100644 index 000000000..83defdd68 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_pageAction_popup.js @@ -0,0 +1,238 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testPageActionPopup() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com/"); + + let scriptPage = url => `<html><head><meta charset="utf-8"><script src="${url}"></script></head></html>`; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "background": { + "page": "data/background.html", + }, + "page_action": { + "default_popup": "popup-a.html", + }, + }, + + files: { + "popup-a.html": scriptPage("popup-a.js"), + "popup-a.js": function() { + window.onload = () => { + let background = window.getComputedStyle(document.body).backgroundColor; + browser.test.assertEq("transparent", background); + browser.runtime.sendMessage("from-popup-a"); + }; + browser.runtime.onMessage.addListener(msg => { + if (msg == "close-popup") { + window.close(); + } + }); + }, + + "data/popup-b.html": scriptPage("popup-b.js"), + "data/popup-b.js": function() { + browser.runtime.sendMessage("from-popup-b"); + }, + + "data/background.html": scriptPage("background.js"), + + "data/background.js": async function() { + let tabId; + + let sendClick; + let tests = [ + () => { + sendClick({expectEvent: false, expectPopup: "a"}); + }, + () => { + sendClick({expectEvent: false, expectPopup: "a"}); + }, + () => { + browser.pageAction.setPopup({tabId, popup: "popup-b.html"}); + sendClick({expectEvent: false, expectPopup: "b"}); + }, + () => { + sendClick({expectEvent: false, expectPopup: "b"}); + }, + () => { + browser.pageAction.setPopup({tabId, popup: ""}); + sendClick({expectEvent: true, expectPopup: null}); + }, + () => { + sendClick({expectEvent: true, expectPopup: null}); + }, + () => { + browser.pageAction.setPopup({tabId, popup: "/popup-a.html"}); + sendClick({expectEvent: false, expectPopup: "a", runNextTest: true}); + }, + () => { + browser.test.sendMessage("next-test", {expectClosed: true}); + }, + () => { + sendClick({expectEvent: false, expectPopup: "a", runNextTest: true}); + }, + () => { + browser.test.sendMessage("next-test", {closeOnTabSwitch: true}); + }, + ]; + + let expect = {}; + sendClick = ({expectEvent, expectPopup, runNextTest}) => { + expect = {event: expectEvent, popup: expectPopup, runNextTest}; + browser.test.sendMessage("send-click"); + }; + + browser.runtime.onMessage.addListener(msg => { + if (msg == "close-popup") { + return; + } else if (expect.popup) { + browser.test.assertEq(msg, `from-popup-${expect.popup}`, + "expected popup opened"); + } else { + browser.test.fail(`unexpected popup: ${msg}`); + } + + expect.popup = null; + if (expect.runNextTest) { + expect.runNextTest = false; + tests.shift()(); + } else { + browser.test.sendMessage("next-test"); + } + }); + + browser.pageAction.onClicked.addListener(() => { + if (expect.event) { + browser.test.succeed("expected click event received"); + } else { + browser.test.fail("unexpected click event"); + } + + expect.event = false; + browser.test.sendMessage("next-test"); + }); + + browser.test.onMessage.addListener(msg => { + if (msg == "close-popup") { + browser.runtime.sendMessage("close-popup"); + return; + } + + if (msg != "next-test") { + browser.test.fail("Expecting 'next-test' message"); + } + + if (tests.length) { + let test = tests.shift(); + test(); + } else { + browser.test.notifyPass("pageaction-tests-done"); + } + }); + + let [tab] = await browser.tabs.query({active: true, currentWindow: true}); + tabId = tab.id; + + await browser.pageAction.show(tabId); + browser.test.sendMessage("next-test"); + }, + }, + }); + + extension.onMessage("send-click", () => { + clickPageAction(extension); + }); + + let pageActionId, panelId; + extension.onMessage("next-test", Task.async(function* (expecting = {}) { + pageActionId = `${makeWidgetId(extension.id)}-page-action`; + panelId = `${makeWidgetId(extension.id)}-panel`; + let panel = document.getElementById(panelId); + if (expecting.expectClosed) { + ok(panel, "Expect panel to exist"); + yield promisePopupShown(panel); + + extension.sendMessage("close-popup"); + + yield promisePopupHidden(panel); + ok(true, `Panel is closed`); + } else if (expecting.closeOnTabSwitch) { + ok(panel, "Expect panel to exist"); + yield promisePopupShown(panel); + + let oldTab = gBrowser.selectedTab; + ok(oldTab != gBrowser.tabs[0], "Should have an inactive tab to switch to"); + + let hiddenPromise = promisePopupHidden(panel); + + gBrowser.selectedTab = gBrowser.tabs[0]; + yield hiddenPromise; + info("Panel closed"); + + gBrowser.selectedTab = oldTab; + } else if (panel) { + yield promisePopupShown(panel); + panel.hidePopup(); + } + + if (panel) { + panel = document.getElementById(panelId); + is(panel, null, "panel successfully removed from document after hiding"); + } + + extension.sendMessage("next-test"); + })); + + + yield extension.startup(); + yield extension.awaitFinish("pageaction-tests-done"); + + yield extension.unload(); + + let node = document.getElementById(pageActionId); + is(node, null, "pageAction image removed from document"); + + let panel = document.getElementById(panelId); + is(panel, null, "pageAction panel removed from document"); + + yield BrowserTestUtils.removeTab(tab); +}); + + +add_task(function* testPageActionSecurity() { + const URL = "chrome://browser/content/browser.xul"; + + let apis = ["browser_action", "page_action"]; + + for (let api of apis) { + info(`TEST ${api} icon url: ${URL}`); + + let messages = [/Access to restricted URI denied/]; + + let waitForConsole = new Promise(resolve => { + // Not necessary in browser-chrome tests, but monitorConsole gripes + // if we don't call it. + SimpleTest.waitForExplicitFinish(); + + SimpleTest.monitorConsole(resolve, messages); + }); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + [api]: {"default_popup": URL}, + }, + }); + + yield Assert.rejects(extension.startup(), + null, + "Manifest rejected"); + + SimpleTest.endMonitorConsole(); + yield waitForConsole; + } +}); + +add_task(forceGC); diff --git a/browser/components/extensions/test/browser/browser_ext_pageAction_popup_resize.js b/browser/components/extensions/test/browser/browser_ext_pageAction_popup_resize.js new file mode 100644 index 000000000..98c4c3488 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_pageAction_popup_resize.js @@ -0,0 +1,169 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +let delay = ms => new Promise(resolve => { + setTimeout(resolve, ms); +}); + +add_task(function* testPageActionPopupResize() { + let browser; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "page_action": { + "default_popup": "popup.html", + "browser_style": true, + }, + }, + background: function() { + /* global browser */ + browser.tabs.query({active: true, currentWindow: true}, tabs => { + const tabId = tabs[0].id; + + browser.pageAction.show(tabId).then(() => { + browser.test.sendMessage("action-shown"); + }); + }); + }, + + files: { + "popup.html": `<!DOCTYPE html><html><head><meta charset="utf-8"></head><body><div></div></body></html>`, + }, + }); + + yield extension.startup(); + yield extension.awaitMessage("action-shown"); + + clickPageAction(extension, window); + + browser = yield awaitExtensionPanel(extension); + + function* checkSize(expected) { + let dims = yield promiseContentDimensions(browser); + let {body, root} = dims; + + is(dims.window.innerHeight, expected, `Panel window should be ${expected}px tall`); + is(body.clientHeight, body.scrollHeight, + "Panel body should be tall enough to fit its contents"); + is(root.clientHeight, root.scrollHeight, + "Panel root should be tall enough to fit its contents"); + + // Tolerate if it is 1px too wide, as that may happen with the current resizing method. + ok(Math.abs(dims.window.innerWidth - expected) <= 1, `Panel window should be ${expected}px wide`); + is(body.clientWidth, body.scrollWidth, + "Panel body should be wide enough to fit its contents"); + } + + /* eslint-disable mozilla/no-cpows-in-tests */ + function setSize(size) { + let elem = content.document.body.firstChild; + elem.style.height = `${size}px`; + elem.style.width = `${size}px`; + } + /* eslint-enable mozilla/no-cpows-in-tests */ + + let sizes = [ + 200, + 400, + 300, + ]; + + for (let size of sizes) { + yield alterContent(browser, setSize, size); + yield checkSize(size); + } + + yield alterContent(browser, setSize, 1400); + + let dims = yield promiseContentDimensions(browser); + let {body, root} = dims; + + if (AppConstants.platform == "win") { + while (dims.window.innerWidth < 800) { + yield delay(50); + dims = yield promiseContentDimensions(browser); + } + } + + is(dims.window.innerWidth, 800, "Panel window width"); + ok(body.clientWidth <= 800, `Panel body width ${body.clientWidth} is less than 800`); + is(body.scrollWidth, 1400, "Panel body scroll width"); + + is(dims.window.innerHeight, 600, "Panel window height"); + ok(root.clientHeight <= 600, `Panel root height (${root.clientHeight}px) is less than 600px`); + is(root.scrollHeight, 1400, "Panel root scroll height"); + + yield extension.unload(); +}); + +add_task(function* testPageActionPopupReflow() { + let browser; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "page_action": { + "default_popup": "popup.html", + "browser_style": true, + }, + }, + background: function() { + browser.tabs.query({active: true, currentWindow: true}, tabs => { + const tabId = tabs[0].id; + + browser.pageAction.show(tabId).then(() => { + browser.test.sendMessage("action-shown"); + }); + }); + }, + + files: { + "popup.html": `<!DOCTYPE html><html><head><meta charset="utf-8"></head> + <body> + The quick mauve fox jumps over the opalescent toad, with its glowing + eyes, and its vantablack mouth, and its bottomless chasm where you + would hope to find a heart, that looks straight into the deepest + pits of hell. The fox shivers, and cowers, and tries to run, but + the toad is utterly without pity. It turns, ever so slightly... + </body> + </html>`, + }, + }); + + yield extension.startup(); + yield extension.awaitMessage("action-shown"); + + clickPageAction(extension, window); + + browser = yield awaitExtensionPanel(extension); + + /* eslint-disable mozilla/no-cpows-in-tests */ + function setSize(size) { + content.document.body.style.fontSize = `${size}px`; + } + /* eslint-enable mozilla/no-cpows-in-tests */ + + let dims = yield alterContent(browser, setSize, 18); + + if (AppConstants.platform == "win") { + while (dims.window.innerWidth < 800) { + yield delay(50); + dims = yield promiseContentDimensions(browser); + } + } + + is(dims.window.innerWidth, 800, "Panel window should be 800px wide"); + is(dims.body.clientWidth, 800, "Panel body should be 800px wide"); + is(dims.body.clientWidth, dims.body.scrollWidth, + "Panel body should be wide enough to fit its contents"); + + ok(dims.window.innerHeight > 36, + `Panel window height (${dims.window.innerHeight}px) should be taller than two lines of text.`); + + is(dims.body.clientHeight, dims.body.scrollHeight, + "Panel body should be tall enough to fit its contents"); + is(dims.root.clientHeight, dims.root.scrollHeight, + "Panel root should be tall enough to fit its contents"); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_pageAction_simple.js b/browser/components/extensions/test/browser/browser_ext_pageAction_simple.js new file mode 100644 index 000000000..d1d173801 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_pageAction_simple.js @@ -0,0 +1,60 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "page_action": { + "default_popup": "popup.html", + "unrecognized_property": "with-a-random-value", + }, + }, + + files: { + "popup.html": ` + <!DOCTYPE html> + <html><body> + <script src="popup.js"></script> + </body></html> + `, + + "popup.js": function() { + browser.runtime.sendMessage("from-popup"); + }, + }, + + background: function() { + browser.runtime.onMessage.addListener(msg => { + browser.test.assertEq(msg, "from-popup", "correct message received"); + browser.test.sendMessage("popup"); + }); + browser.tabs.query({active: true, currentWindow: true}, tabs => { + let tabId = tabs[0].id; + + browser.pageAction.show(tabId).then(() => { + browser.test.sendMessage("page-action-shown"); + }); + }); + }, + }); + + SimpleTest.waitForExplicitFinish(); + let waitForConsole = new Promise(resolve => { + SimpleTest.monitorConsole(resolve, [{ + message: /Reading manifest: Error processing page_action.unrecognized_property: An unexpected property was found/, + }]); + }); + + yield extension.startup(); + yield extension.awaitMessage("page-action-shown"); + + clickPageAction(extension); + + yield extension.awaitMessage("popup"); + + yield extension.unload(); + + SimpleTest.endMonitorConsole(); + yield waitForConsole; +}); diff --git a/browser/components/extensions/test/browser/browser_ext_pageAction_title.js b/browser/components/extensions/test/browser/browser_ext_pageAction_title.js new file mode 100644 index 000000000..793cd4499 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_pageAction_title.js @@ -0,0 +1,226 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +/* global runTests */ + +Services.scriptloader.loadSubScript(new URL("head_pageAction.js", gTestPath).href, + this); + +add_task(function* testTabSwitchContext() { + yield runTests({ + manifest: { + "name": "Foo Extension", + + "page_action": { + "default_icon": "default.png", + "default_popup": "__MSG_popup__", + "default_title": "Default __MSG_title__ \u263a", + }, + + "default_locale": "en", + + "permissions": ["tabs"], + }, + + "files": { + "_locales/en/messages.json": { + "popup": { + "message": "default.html", + "description": "Popup", + }, + + "title": { + "message": "Title", + "description": "Title", + }, + }, + + "_locales/es_ES/messages.json": { + "popup": { + "message": "default.html", + "description": "Popup", + }, + + "title": { + "message": "T\u00edtulo", + "description": "Title", + }, + }, + + "default.png": imageBuffer, + "1.png": imageBuffer, + "2.png": imageBuffer, + }, + + getTests(tabs) { + let details = [ + {"icon": browser.runtime.getURL("default.png"), + "popup": browser.runtime.getURL("default.html"), + "title": "Default T\u00edtulo \u263a"}, + {"icon": browser.runtime.getURL("1.png"), + "popup": browser.runtime.getURL("default.html"), + "title": "Default T\u00edtulo \u263a"}, + {"icon": browser.runtime.getURL("2.png"), + "popup": browser.runtime.getURL("2.html"), + "title": "Title 2"}, + {"icon": browser.runtime.getURL("2.png"), + "popup": browser.runtime.getURL("2.html"), + "title": "Default T\u00edtulo \u263a"}, + ]; + + let promiseTabLoad = details => { + return new Promise(resolve => { + browser.tabs.onUpdated.addListener(function listener(tabId, changed) { + if (tabId == details.id && changed.url == details.url) { + browser.tabs.onUpdated.removeListener(listener); + resolve(); + } + }); + }); + }; + return [ + expect => { + browser.test.log("Initial state. No icon visible."); + expect(null); + }, + async expect => { + browser.test.log("Show the icon on the first tab, expect default properties."); + await browser.pageAction.show(tabs[0]); + expect(details[0]); + }, + expect => { + browser.test.log("Change the icon. Expect default properties excluding the icon."); + browser.pageAction.setIcon({tabId: tabs[0], path: "1.png"}); + expect(details[1]); + }, + async expect => { + browser.test.log("Create a new tab. No icon visible."); + let tab = await browser.tabs.create({active: true, url: "about:blank?0"}); + tabs.push(tab.id); + expect(null); + }, + expect => { + browser.test.log("Await tab load. No icon visible."); + expect(null); + }, + async expect => { + browser.test.log("Change properties. Expect new properties."); + let tabId = tabs[1]; + + await browser.pageAction.show(tabId); + browser.pageAction.setIcon({tabId, path: "2.png"}); + browser.pageAction.setPopup({tabId, popup: "2.html"}); + browser.pageAction.setTitle({tabId, title: "Title 2"}); + + expect(details[2]); + }, + async expect => { + browser.test.log("Change the hash. Expect same properties."); + + let promise = promiseTabLoad({id: tabs[1], url: "about:blank?0#ref"}); + + browser.tabs.update(tabs[1], {url: "about:blank?0#ref"}); + + await promise; + expect(details[2]); + }, + expect => { + browser.test.log("Clear the title. Expect default title."); + browser.pageAction.setTitle({tabId: tabs[1], title: ""}); + + expect(details[3]); + }, + async expect => { + browser.test.log("Navigate to a new page. Expect icon hidden."); + + // TODO: This listener should not be necessary, but the |tabs.update| + // callback currently fires too early in e10s windows. + let promise = promiseTabLoad({id: tabs[1], url: "about:blank?1"}); + + browser.tabs.update(tabs[1], {url: "about:blank?1"}); + + await promise; + expect(null); + }, + async expect => { + browser.test.log("Show the icon. Expect default properties again."); + await browser.pageAction.show(tabs[1]); + expect(details[0]); + }, + async expect => { + browser.test.log("Switch back to the first tab. Expect previously set properties."); + await browser.tabs.update(tabs[0], {active: true}); + expect(details[1]); + }, + async expect => { + browser.test.log("Hide the icon on tab 2. Switch back, expect hidden."); + await browser.pageAction.hide(tabs[1]); + await browser.tabs.update(tabs[1], {active: true}); + expect(null); + }, + async expect => { + browser.test.log("Switch back to tab 1. Expect previous results again."); + await browser.tabs.remove(tabs[1]); + expect(details[1]); + }, + async expect => { + browser.test.log("Hide the icon. Expect hidden."); + await browser.pageAction.hide(tabs[0]); + expect(null); + }, + ]; + }, + }); +}); + +add_task(function* testDefaultTitle() { + yield runTests({ + manifest: { + "name": "Foo Extension", + + "page_action": { + "default_icon": "icon.png", + }, + + "permissions": ["tabs"], + }, + + files: { + "icon.png": imageBuffer, + }, + + getTests(tabs) { + let details = [ + {"title": "Foo Extension", + "popup": "", + "icon": browser.runtime.getURL("icon.png")}, + {"title": "Foo Title", + "popup": "", + "icon": browser.runtime.getURL("icon.png")}, + ]; + + return [ + expect => { + browser.test.log("Initial state. No icon visible."); + expect(null); + }, + async expect => { + browser.test.log("Show the icon on the first tab, expect extension title as default title."); + await browser.pageAction.show(tabs[0]); + expect(details[0]); + }, + expect => { + browser.test.log("Change the title. Expect new title."); + browser.pageAction.setTitle({tabId: tabs[0], title: "Foo Title"}); + expect(details[1]); + }, + expect => { + browser.test.log("Clear the title. Expect extension title."); + browser.pageAction.setTitle({tabId: tabs[0], title: ""}); + expect(details[0]); + }, + ]; + }, + }); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_popup_api_injection.js b/browser/components/extensions/test/browser/browser_ext_popup_api_injection.js new file mode 100644 index 000000000..6f8a541a9 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_popup_api_injection.js @@ -0,0 +1,101 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testPageActionPopup() { + const BASE = "http://example.com/browser/browser/components/extensions/test/browser"; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": { + "default_popup": `${BASE}/file_popup_api_injection_a.html`, + }, + "page_action": { + "default_popup": `${BASE}/file_popup_api_injection_b.html`, + }, + }, + + files: { + "popup-a.html": `<html><head><meta charset="utf-8"> + <script type="application/javascript" src="popup-a.js"></script></head></html>`, + "popup-a.js": 'browser.test.sendMessage("from-popup-a");', + + "popup-b.html": `<html><head><meta charset="utf-8"> + <script type="application/javascript" src="popup-b.js"></script></head></html>`, + "popup-b.js": 'browser.test.sendMessage("from-popup-b");', + }, + + background: function() { + let tabId; + browser.tabs.query({active: true, currentWindow: true}, tabs => { + tabId = tabs[0].id; + browser.pageAction.show(tabId).then(() => { + browser.test.sendMessage("ready"); + }); + }); + + browser.test.onMessage.addListener(() => { + browser.browserAction.setPopup({popup: "/popup-a.html"}); + browser.pageAction.setPopup({tabId, popup: "popup-b.html"}); + + browser.test.sendMessage("ok"); + }); + }, + }); + + let promiseConsoleMessage = pattern => new Promise(resolve => { + Services.console.registerListener(function listener(msg) { + if (pattern.test(msg.message)) { + resolve(msg.message); + Services.console.unregisterListener(listener); + } + }); + }); + + yield extension.startup(); + yield extension.awaitMessage("ready"); + + + // Check that unprivileged documents don't get the API. + // BrowserAction: + let awaitMessage = promiseConsoleMessage(/WebExt Privilege Escalation: BrowserAction/); + SimpleTest.expectUncaughtException(); + yield clickBrowserAction(extension); + yield promisePopupShown(getBrowserActionPopup(extension)); + + let message = yield awaitMessage; + ok(message.includes("WebExt Privilege Escalation: BrowserAction: typeof(browser) = undefined"), + `No BrowserAction API injection`); + + yield closeBrowserAction(extension); + + // PageAction + awaitMessage = promiseConsoleMessage(/WebExt Privilege Escalation: PageAction/); + SimpleTest.expectUncaughtException(); + yield clickPageAction(extension); + + message = yield awaitMessage; + ok(message.includes("WebExt Privilege Escalation: PageAction: typeof(browser) = undefined"), + `No PageAction API injection: ${message}`); + + yield closePageAction(extension); + + SimpleTest.expectUncaughtException(false); + + + // Check that privileged documents *do* get the API. + extension.sendMessage("next"); + yield extension.awaitMessage("ok"); + + + yield clickBrowserAction(extension); + yield extension.awaitMessage("from-popup-a"); + yield promisePopupShown(getBrowserActionPopup(extension)); + yield closeBrowserAction(extension); + + yield clickPageAction(extension); + yield extension.awaitMessage("from-popup-b"); + yield closePageAction(extension); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_popup_background.js b/browser/components/extensions/test/browser/browser_ext_popup_background.js new file mode 100644 index 000000000..8b310c674 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_popup_background.js @@ -0,0 +1,133 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testPopupBackground() { + let extension = ExtensionTestUtils.loadExtension({ + background() { + browser.tabs.query({active: true, currentWindow: true}, tabs => { + browser.pageAction.show(tabs[0].id); + }); + }, + + manifest: { + "browser_action": { + "default_popup": "popup.html", + "browser_style": false, + }, + + "page_action": { + "default_popup": "popup.html", + "browser_style": false, + }, + }, + + files: { + "popup.html": `<!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + </head> + <body style="width: 100px; height: 100px; background-color: green;"> + </body> + </html>`, + }, + }); + + yield extension.startup(); + + function* testPanel(browser, standAlone) { + let panel = getPanelForNode(browser); + let arrowContent = document.getAnonymousElementByAttribute(panel, "class", "panel-arrowcontent"); + let arrow = document.getAnonymousElementByAttribute(panel, "anonid", "arrow"); + + let borderColor = getComputedStyle(arrowContent).borderTopColor; + + let checkArrow = (background = null) => { + let image = getComputedStyle(arrow).listStyleImage; + + if (background == null || !standAlone) { + ok(image.startsWith('url("chrome://'), `We should have the built-in background image (got: ${image})`); + return; + } + + if (AppConstants.platform == "mac") { + // Panels have a drop shadow rather than a border on OS-X, so we extend + // the background color through the border area instead. + borderColor = background; + } + + image = decodeURIComponent(image); + let borderIndex = image.indexOf(`fill="${borderColor}"`); + let backgroundIndex = image.lastIndexOf(`fill="${background}"`); + + ok(borderIndex >= 0, `Have border fill (index=${borderIndex})`); + ok(backgroundIndex >= 0, `Have background fill (index=${backgroundIndex})`); + is(getComputedStyle(arrowContent).backgroundColor, background, "Arrow content should have correct background"); + isnot(borderIndex, backgroundIndex, "Border and background fills are separate elements"); + }; + + function getBackground(browser) { + return ContentTask.spawn(browser, null, function* () { + return content.getComputedStyle(content.document.body) + .backgroundColor; + }); + } + + /* eslint-disable mozilla/no-cpows-in-tests */ + let setBackground = color => { + content.document.body.style.backgroundColor = color; + }; + /* eslint-enable mozilla/no-cpows-in-tests */ + + yield new Promise(resolve => setTimeout(resolve, 100)); + + info("Test that initial background color is applied"); + + checkArrow(yield getBackground(browser)); + + info("Test that dynamically-changed background color is applied"); + + yield alterContent(browser, setBackground, "black"); + + checkArrow(yield getBackground(browser)); + + info("Test that non-opaque background color results in default styling"); + + yield alterContent(browser, setBackground, "rgba(1, 2, 3, .9)"); + + checkArrow(null); + } + + { + info("Test stand-alone browserAction popup"); + + clickBrowserAction(extension); + let browser = yield awaitExtensionPanel(extension); + yield testPanel(browser, true); + yield closeBrowserAction(extension); + } + + { + info("Test menu panel browserAction popup"); + + let widget = getBrowserActionWidget(extension); + CustomizableUI.addWidgetToArea(widget.id, CustomizableUI.AREA_PANEL); + + clickBrowserAction(extension); + let browser = yield awaitExtensionPanel(extension); + yield testPanel(browser, false); + yield closeBrowserAction(extension); + } + + { + info("Test pageAction popup"); + + clickPageAction(extension); + let browser = yield awaitExtensionPanel(extension); + yield testPanel(browser, true); + yield closePageAction(extension); + } + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_popup_corners.js b/browser/components/extensions/test/browser/browser_ext_popup_corners.js new file mode 100644 index 000000000..52985ee46 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_popup_corners.js @@ -0,0 +1,98 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testPopupBorderRadius() { + let extension = ExtensionTestUtils.loadExtension({ + background() { + browser.tabs.query({active: true, currentWindow: true}, tabs => { + browser.pageAction.show(tabs[0].id); + }); + }, + + manifest: { + "browser_action": { + "default_popup": "popup.html", + "browser_style": false, + }, + + "page_action": { + "default_popup": "popup.html", + "browser_style": false, + }, + }, + + files: { + "popup.html": `<!DOCTYPE html> + <html> + <head><meta charset="utf-8"></head> + <body style="width: 100px; height: 100px;"></body> + </html>`, + }, + }); + + yield extension.startup(); + + function* testPanel(browser, standAlone = true) { + let panel = getPanelForNode(browser); + let arrowContent = document.getAnonymousElementByAttribute(panel, "class", "panel-arrowcontent"); + + let panelStyle = getComputedStyle(arrowContent); + + let viewNode = browser.parentNode === panel ? browser : browser.parentNode; + let viewStyle = getComputedStyle(viewNode); + + let props = ["borderTopLeftRadius", "borderTopRightRadius", + "borderBottomRightRadius", "borderBottomLeftRadius"]; + + /* eslint-disable mozilla/no-cpows-in-tests */ + let bodyStyle = yield ContentTask.spawn(browser, props, function* (props) { + let bodyStyle = content.getComputedStyle(content.document.body); + + return new Map(props.map(prop => [prop, bodyStyle[prop]])); + }); + /* eslint-enable mozilla/no-cpows-in-tests */ + + for (let prop of props) { + if (standAlone) { + is(viewStyle[prop], panelStyle[prop], `Panel and view ${prop} should be the same`); + is(bodyStyle.get(prop), panelStyle[prop], `Panel and body ${prop} should be the same`); + } else { + is(viewStyle[prop], "0px", `View node ${prop} should be 0px`); + is(bodyStyle.get(prop), "0px", `Body node ${prop} should be 0px`); + } + } + } + + { + info("Test stand-alone browserAction popup"); + + clickBrowserAction(extension); + let browser = yield awaitExtensionPanel(extension); + yield testPanel(browser); + yield closeBrowserAction(extension); + } + + { + info("Test menu panel browserAction popup"); + + let widget = getBrowserActionWidget(extension); + CustomizableUI.addWidgetToArea(widget.id, CustomizableUI.AREA_PANEL); + + clickBrowserAction(extension); + let browser = yield awaitExtensionPanel(extension); + yield testPanel(browser, false); + yield closeBrowserAction(extension); + } + + { + info("Test pageAction popup"); + + clickPageAction(extension); + let browser = yield awaitExtensionPanel(extension); + yield testPanel(browser); + yield closePageAction(extension); + } + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_popup_sendMessage.js b/browser/components/extensions/test/browser/browser_ext_popup_sendMessage.js new file mode 100644 index 000000000..472ee7bbd --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_popup_sendMessage.js @@ -0,0 +1,93 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* test_popup_sendMessage_reply() { + let scriptPage = url => `<html><head><meta charset="utf-8"><script src="${url}"></script></head><body>${url}</body></html>`; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "browser_action": { + "default_popup": "popup.html", + "browser_style": true, + }, + + "page_action": { + "default_popup": "popup.html", + "browser_style": true, + }, + }, + + files: { + "popup.html": scriptPage("popup.js"), + "popup.js": async function() { + browser.runtime.onMessage.addListener(async msg => { + if (msg == "popup-ping") { + return Promise.resolve("popup-pong"); + } + }); + + let response = await browser.runtime.sendMessage("background-ping"); + browser.test.sendMessage("background-ping-response", response); + }, + }, + + async background() { + browser.runtime.onMessage.addListener(async msg => { + if (msg == "background-ping") { + let response = await browser.runtime.sendMessage("popup-ping"); + + browser.test.sendMessage("popup-ping-response", response); + + await new Promise(resolve => { + // Wait long enough that we're relatively sure the docShells have + // been swapped. Note that this value is fairly arbitrary. The load + // event that triggers the swap should happen almost immediately + // after the message is sent. The extra quarter of a second gives us + // enough leeway that we can expect to respond after the swap in the + // vast majority of cases. + setTimeout(resolve, 250); + }); + + return "background-pong"; + } + }); + + let [tab] = await browser.tabs.query({active: true, currentWindow: true}); + + await browser.pageAction.show(tab.id); + + browser.test.sendMessage("page-action-ready"); + }, + }); + + yield extension.startup(); + + { + clickBrowserAction(extension); + + let pong = yield extension.awaitMessage("background-ping-response"); + is(pong, "background-pong", "Got pong"); + + pong = yield extension.awaitMessage("popup-ping-response"); + is(pong, "popup-pong", "Got pong"); + + yield closeBrowserAction(extension); + } + + yield extension.awaitMessage("page-action-ready"); + + { + clickPageAction(extension); + + let pong = yield extension.awaitMessage("background-ping-response"); + is(pong, "background-pong", "Got pong"); + + pong = yield extension.awaitMessage("popup-ping-response"); + is(pong, "popup-pong", "Got pong"); + + yield closePageAction(extension); + } + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_popup_shutdown.js b/browser/components/extensions/test/browser/browser_ext_popup_shutdown.js new file mode 100644 index 000000000..66d37e857 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_popup_shutdown.js @@ -0,0 +1,77 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +let getExtension = () => { + return ExtensionTestUtils.loadExtension({ + background: async function() { + let [tab] = await browser.tabs.query({active: true, currentWindow: true}); + await browser.pageAction.show(tab.id); + browser.test.sendMessage("pageAction ready"); + }, + + manifest: { + "browser_action": { + "default_popup": "popup.html", + "browser_style": false, + }, + + "page_action": { + "default_popup": "popup.html", + "browser_style": false, + }, + }, + + files: { + "popup.html": `<!DOCTYPE html> + <html><head><meta charset="utf-8"></head></html>`, + }, + }); +}; + +add_task(function* testStandaloneBrowserAction() { + info("Test stand-alone browserAction popup"); + + let extension = getExtension(); + yield extension.startup(); + yield extension.awaitMessage("pageAction ready"); + + clickBrowserAction(extension); + let browser = yield awaitExtensionPanel(extension); + let panel = getPanelForNode(browser); + + yield extension.unload(); + + is(panel.parentNode, null, "Panel should be removed from the document"); +}); + +add_task(function* testMenuPanelBrowserAction() { + let extension = getExtension(); + yield extension.startup(); + yield extension.awaitMessage("pageAction ready"); + + let widget = getBrowserActionWidget(extension); + CustomizableUI.addWidgetToArea(widget.id, CustomizableUI.AREA_PANEL); + + clickBrowserAction(extension); + let browser = yield awaitExtensionPanel(extension); + let panel = getPanelForNode(browser); + + yield extension.unload(); + + is(panel.state, "closed", "Panel should be closed"); +}); + +add_task(function* testPageAction() { + let extension = getExtension(); + yield extension.startup(); + yield extension.awaitMessage("pageAction ready"); + + clickPageAction(extension); + let browser = yield awaitExtensionPanel(extension); + let panel = getPanelForNode(browser); + + yield extension.unload(); + + is(panel.parentNode, null, "Panel should be removed from the document"); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_runtime_openOptionsPage.js b/browser/components/extensions/test/browser/browser_ext_runtime_openOptionsPage.js new file mode 100644 index 000000000..1631ececa --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_runtime_openOptionsPage.js @@ -0,0 +1,276 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +requestLongerTimeout(2); + +function add_tasks(task) { + add_task(task.bind(null, {embedded: false})); + + add_task(task.bind(null, {embedded: true})); +} + +function* loadExtension(options) { + let extension = ExtensionTestUtils.loadExtension({ + useAddonManager: "temporary", + + embedded: options.embedded, + + manifest: Object.assign({ + "permissions": ["tabs"], + }, options.manifest), + + files: { + "options.html": `<!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + <script src="options.js" type="text/javascript"></script> + </head> + </html>`, + + "options.js": function() { + window.iAmOption = true; + browser.runtime.sendMessage("options.html"); + browser.runtime.onMessage.addListener((msg, sender, respond) => { + if (msg == "ping") { + respond("pong"); + } + }); + }, + }, + + background: options.background, + }); + + yield extension.startup(); + + return extension; +} + +add_tasks(function* test_inline_options(extraOptions) { + info(`Test options opened inline (${JSON.stringify(extraOptions)})`); + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com/"); + + let extension = yield loadExtension(Object.assign({}, extraOptions, { + manifest: { + applications: {gecko: {id: "inline_options@tests.mozilla.org"}}, + "options_ui": { + "page": "options.html", + }, + }, + + background: async function() { + let _optionsPromise; + let awaitOptions = () => { + browser.test.assertFalse(_optionsPromise, "Should not be awaiting options already"); + + return new Promise(resolve => { + _optionsPromise = {resolve}; + }); + }; + + browser.runtime.onMessage.addListener((msg, sender) => { + if (msg == "options.html") { + if (_optionsPromise) { + _optionsPromise.resolve(sender.tab); + _optionsPromise = null; + } else { + browser.test.fail("Saw unexpected options page load"); + } + } + }); + + try { + let [firstTab] = await browser.tabs.query({currentWindow: true, active: true}); + + browser.test.log("Open options page. Expect fresh load."); + + let [, optionsTab] = await Promise.all([ + browser.runtime.openOptionsPage(), + awaitOptions(), + ]); + + browser.test.assertEq("about:addons", optionsTab.url, "Tab contains AddonManager"); + browser.test.assertTrue(optionsTab.active, "Tab is active"); + browser.test.assertTrue(optionsTab.id != firstTab.id, "Tab is a new tab"); + + browser.test.assertEq(0, browser.extension.getViews({type: "popup"}).length, "viewType is not popup"); + browser.test.assertEq(1, browser.extension.getViews({type: "tab"}).length, "viewType is tab"); + browser.test.assertEq(1, browser.extension.getViews({windowId: optionsTab.windowId}).length, "windowId matches"); + + let views = browser.extension.getViews(); + browser.test.assertEq(2, views.length, "Expected the options page and the background page"); + browser.test.assertTrue(views.includes(window), "One of the views is the background page"); + browser.test.assertTrue(views.some(w => w.iAmOption), "One of the views is the options page"); + + browser.test.log("Switch tabs."); + await browser.tabs.update(firstTab.id, {active: true}); + + browser.test.log("Open options page again. Expect tab re-selected, no new load."); + + await browser.runtime.openOptionsPage(); + let [tab] = await browser.tabs.query({currentWindow: true, active: true}); + + browser.test.assertEq(optionsTab.id, tab.id, "Tab is the same as the previous options tab"); + browser.test.assertEq("about:addons", tab.url, "Tab contains AddonManager"); + + browser.test.log("Ping options page."); + let pong = await browser.runtime.sendMessage("ping"); + browser.test.assertEq("pong", pong, "Got pong."); + + browser.test.log("Remove options tab."); + await browser.tabs.remove(optionsTab.id); + + browser.test.log("Open options page again. Expect fresh load."); + [, tab] = await Promise.all([ + browser.runtime.openOptionsPage(), + awaitOptions(), + ]); + browser.test.assertEq("about:addons", tab.url, "Tab contains AddonManager"); + browser.test.assertTrue(tab.active, "Tab is active"); + browser.test.assertTrue(tab.id != optionsTab.id, "Tab is a new tab"); + + await browser.tabs.remove(tab.id); + + browser.test.notifyPass("options-ui"); + } catch (error) { + browser.test.fail(`Error: ${error} :: ${error.stack}`); + browser.test.notifyFail("options-ui"); + } + }, + })); + + yield extension.awaitFinish("options-ui"); + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +}); + +add_tasks(function* test_tab_options(extraOptions) { + info(`Test options opened in a tab (${JSON.stringify(extraOptions)})`); + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com/"); + + let extension = yield loadExtension(Object.assign({}, extraOptions, { + manifest: { + applications: {gecko: {id: "tab_options@tests.mozilla.org"}}, + "options_ui": { + "page": "options.html", + "open_in_tab": true, + }, + }, + + background: async function() { + let _optionsPromise; + let awaitOptions = () => { + browser.test.assertFalse(_optionsPromise, "Should not be awaiting options already"); + + return new Promise(resolve => { + _optionsPromise = {resolve}; + }); + }; + + browser.runtime.onMessage.addListener((msg, sender) => { + if (msg == "options.html") { + if (_optionsPromise) { + _optionsPromise.resolve(sender.tab); + _optionsPromise = null; + } else { + browser.test.fail("Saw unexpected options page load"); + } + } + }); + + let optionsURL = browser.extension.getURL("options.html"); + + try { + let [firstTab] = await browser.tabs.query({currentWindow: true, active: true}); + + browser.test.log("Open options page. Expect fresh load."); + let [, optionsTab] = await Promise.all([ + browser.runtime.openOptionsPage(), + awaitOptions(), + ]); + browser.test.assertEq(optionsURL, optionsTab.url, "Tab contains options.html"); + browser.test.assertTrue(optionsTab.active, "Tab is active"); + browser.test.assertTrue(optionsTab.id != firstTab.id, "Tab is a new tab"); + + browser.test.assertEq(0, browser.extension.getViews({type: "popup"}).length, "viewType is not popup"); + browser.test.assertEq(1, browser.extension.getViews({type: "tab"}).length, "viewType is tab"); + browser.test.assertEq(1, browser.extension.getViews({windowId: optionsTab.windowId}).length, "windowId matches"); + + let views = browser.extension.getViews(); + browser.test.assertEq(2, views.length, "Expected the options page and the background page"); + browser.test.assertTrue(views.includes(window), "One of the views is the background page"); + browser.test.assertTrue(views.some(w => w.iAmOption), "One of the views is the options page"); + + browser.test.log("Switch tabs."); + await browser.tabs.update(firstTab.id, {active: true}); + + browser.test.log("Open options page again. Expect tab re-selected, no new load."); + + await browser.runtime.openOptionsPage(); + let [tab] = await browser.tabs.query({currentWindow: true, active: true}); + + browser.test.assertEq(optionsTab.id, tab.id, "Tab is the same as the previous options tab"); + browser.test.assertEq(optionsURL, tab.url, "Tab contains options.html"); + + // Unfortunately, we can't currently do this, since onMessage doesn't + // currently support responses when there are multiple listeners. + // + // browser.test.log("Ping options page."); + // return new Promise(resolve => browser.runtime.sendMessage("ping", resolve)); + + browser.test.log("Remove options tab."); + await browser.tabs.remove(optionsTab.id); + + browser.test.log("Open options page again. Expect fresh load."); + [, tab] = await Promise.all([ + browser.runtime.openOptionsPage(), + awaitOptions(), + ]); + browser.test.assertEq(optionsURL, tab.url, "Tab contains options.html"); + browser.test.assertTrue(tab.active, "Tab is active"); + browser.test.assertTrue(tab.id != optionsTab.id, "Tab is a new tab"); + + await browser.tabs.remove(tab.id); + + browser.test.notifyPass("options-ui-tab"); + } catch (error) { + browser.test.fail(`Error: ${error} :: ${error.stack}`); + browser.test.notifyFail("options-ui-tab"); + } + }, + })); + + yield extension.awaitFinish("options-ui-tab"); + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +}); + +add_tasks(function* test_options_no_manifest(extraOptions) { + info(`Test with no manifest key (${JSON.stringify(extraOptions)})`); + + let extension = yield loadExtension(Object.assign({}, extraOptions, { + manifest: { + applications: {gecko: {id: "no_options@tests.mozilla.org"}}, + }, + + async background() { + browser.test.log("Try to open options page when not specified in the manifest."); + + await browser.test.assertRejects( + browser.runtime.openOptionsPage(), + /No `options_ui` declared/, + "Expected error from openOptionsPage()"); + + browser.test.notifyPass("options-no-manifest"); + }, + })); + + yield extension.awaitFinish("options-no-manifest"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_runtime_openOptionsPage_uninstall.js b/browser/components/extensions/test/browser/browser_ext_runtime_openOptionsPage_uninstall.js new file mode 100644 index 000000000..0c123b70e --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_runtime_openOptionsPage_uninstall.js @@ -0,0 +1,101 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function* loadExtension(options) { + let extension = ExtensionTestUtils.loadExtension({ + useAddonManager: "temporary", + + manifest: Object.assign({ + "permissions": ["tabs"], + }, options.manifest), + + files: { + "options.html": `<!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + <script src="options.js" type="text/javascript"></script> + </head> + </html>`, + + "options.js": function() { + browser.runtime.sendMessage("options.html"); + browser.runtime.onMessage.addListener((msg, sender, respond) => { + if (msg == "ping") { + respond("pong"); + } + }); + }, + }, + + background: options.background, + }); + + yield extension.startup(); + + return extension; +} + +add_task(function* test_inline_options_uninstall() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com/"); + + let extension = yield loadExtension({ + manifest: { + applications: {gecko: {id: "inline_options_uninstall@tests.mozilla.org"}}, + "options_ui": { + "page": "options.html", + }, + }, + + background: async function() { + let _optionsPromise; + let awaitOptions = () => { + browser.test.assertFalse(_optionsPromise, "Should not be awaiting options already"); + + return new Promise(resolve => { + _optionsPromise = {resolve}; + }); + }; + + browser.runtime.onMessage.addListener((msg, sender) => { + if (msg == "options.html") { + if (_optionsPromise) { + _optionsPromise.resolve(sender.tab); + _optionsPromise = null; + } else { + browser.test.fail("Saw unexpected options page load"); + } + } + }); + + try { + let [firstTab] = await browser.tabs.query({currentWindow: true, active: true}); + + browser.test.log("Open options page. Expect fresh load."); + let [, tab] = await Promise.all([ + browser.runtime.openOptionsPage(), + awaitOptions(), + ]); + + browser.test.assertEq("about:addons", tab.url, "Tab contains AddonManager"); + browser.test.assertTrue(tab.active, "Tab is active"); + browser.test.assertTrue(tab.id != firstTab.id, "Tab is a new tab"); + + browser.test.sendMessage("options-ui-open"); + } catch (error) { + browser.test.fail(`Error: ${error} :: ${error.stack}`); + } + }, + }); + + yield extension.awaitMessage("options-ui-open"); + yield extension.unload(); + + is(gBrowser.selectedBrowser.currentURI.spec, "about:addons", + "Add-on manager tab should still be open"); + + yield BrowserTestUtils.removeTab(gBrowser.selectedTab); + + yield BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_runtime_setUninstallURL.js b/browser/components/extensions/test/browser/browser_ext_runtime_setUninstallURL.js new file mode 100644 index 000000000..1c7ef4969 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_runtime_setUninstallURL.js @@ -0,0 +1,94 @@ +"use strict"; + +let {AddonManager} = Components.utils.import("resource://gre/modules/AddonManager.jsm", {}); +let {Extension} = Components.utils.import("resource://gre/modules/Extension.jsm", {}); + +function* makeAndInstallXPI(id, backgroundScript, loadedURL) { + let xpi = Extension.generateXPI({ + manifest: {applications: {gecko: {id}}}, + background: backgroundScript, + }); + SimpleTest.registerCleanupFunction(function cleanupXPI() { + Services.obs.notifyObservers(xpi, "flush-cache-entry", null); + xpi.remove(false); + }); + + let loadPromise = BrowserTestUtils.waitForNewTab(gBrowser, loadedURL); + + + info(`installing ${xpi.path}`); + let addon = yield AddonManager.installTemporaryAddon(xpi); + info("installed"); + + // A WebExtension is started asynchronously, we have our test extension + // open a new tab to signal that the background script has executed. + let loadTab = yield loadPromise; + yield BrowserTestUtils.removeTab(loadTab); + + return addon; +} + + +add_task(function* test_setuninstallurl_badargs() { + async function background() { + await browser.test.assertRejects( + browser.runtime.setUninstallURL("this is not a url"), + /Invalid URL/, + "setUninstallURL with an invalid URL should fail"); + + await browser.test.assertRejects( + browser.runtime.setUninstallURL("file:///etc/passwd"), + /must have the scheme http or https/, + "setUninstallURL with an illegal URL should fail"); + + browser.test.notifyPass("setUninstallURL bad params"); + } + + let extension = ExtensionTestUtils.loadExtension({ + background, + }); + yield extension.startup(); + yield extension.awaitFinish(); + yield extension.unload(); +}); + +// Test the documented behavior of setUninstallURL() that passing an +// empty string is equivalent to not setting an uninstall URL +// (i.e., no new tab is opened upon uninstall) +add_task(function* test_setuninstall_empty_url() { + async function backgroundScript() { + await browser.runtime.setUninstallURL(""); + browser.tabs.create({url: "http://example.com/addon_loaded"}); + } + + let addon = yield makeAndInstallXPI("test_uinstallurl2@tests.mozilla.org", + backgroundScript, + "http://example.com/addon_loaded"); + + addon.uninstall(true); + info("uninstalled"); + + // no need to explicitly check for the absence of a new tab, + // BrowserTestUtils will eventually complain if one is opened. +}); + +add_task(function* test_setuninstallurl() { + async function backgroundScript() { + await browser.runtime.setUninstallURL("http://example.com/addon_uninstalled"); + browser.tabs.create({url: "http://example.com/addon_loaded"}); + } + + let addon = yield makeAndInstallXPI("test_uinstallurl@tests.mozilla.org", + backgroundScript, + "http://example.com/addon_loaded"); + + // look for a new tab with the uninstall url. + let uninstallPromise = BrowserTestUtils.waitForNewTab(gBrowser, "http://example.com/addon_uninstalled"); + + addon.uninstall(true); + info("uninstalled"); + + let uninstalledTab = yield uninstallPromise; + isnot(uninstalledTab, null, "opened tab with uninstall url"); + yield BrowserTestUtils.removeTab(uninstalledTab); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_sessions_getRecentlyClosed.js b/browser/components/extensions/test/browser/browser_ext_sessions_getRecentlyClosed.js new file mode 100644 index 000000000..413f7bde6 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_sessions_getRecentlyClosed.js @@ -0,0 +1,97 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +/* globals recordInitialTimestamps, onlyNewItemsFilter, checkRecentlyClosed */ + +requestLongerTimeout(2); + +Services.scriptloader.loadSubScript(new URL("head_sessions.js", gTestPath).href, + this); + +add_task(function* test_sessions_get_recently_closed() { + function* openAndCloseWindow(url = "http://example.com", tabUrls) { + let win = yield BrowserTestUtils.openNewBrowserWindow(); + yield BrowserTestUtils.loadURI(win.gBrowser.selectedBrowser, url); + yield BrowserTestUtils.browserLoaded(win.gBrowser.selectedBrowser); + if (tabUrls) { + for (let url of tabUrls) { + yield BrowserTestUtils.openNewForegroundTab(win.gBrowser, url); + } + } + yield BrowserTestUtils.closeWindow(win); + } + + function background() { + Promise.all([ + browser.sessions.getRecentlyClosed(), + browser.tabs.query({active: true, currentWindow: true}), + ]).then(([recentlyClosed, tabs]) => { + browser.test.sendMessage("initialData", {recentlyClosed, currentWindowId: tabs[0].windowId}); + }); + + browser.test.onMessage.addListener((msg, filter) => { + if (msg == "check-sessions") { + browser.sessions.getRecentlyClosed(filter).then(recentlyClosed => { + browser.test.sendMessage("recentlyClosed", recentlyClosed); + }); + } + }); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["sessions", "tabs"], + }, + background, + }); + + // Open and close a window that will be ignored, to prove that we are removing previous entries + yield openAndCloseWindow(); + + yield extension.startup(); + + let {recentlyClosed, currentWindowId} = yield extension.awaitMessage("initialData"); + recordInitialTimestamps(recentlyClosed.map(item => item.lastModified)); + + yield openAndCloseWindow(); + extension.sendMessage("check-sessions"); + recentlyClosed = yield extension.awaitMessage("recentlyClosed"); + checkRecentlyClosed(recentlyClosed.filter(onlyNewItemsFilter), 1, currentWindowId); + + yield openAndCloseWindow("about:config", ["about:robots", "about:mozilla"]); + extension.sendMessage("check-sessions"); + recentlyClosed = yield extension.awaitMessage("recentlyClosed"); + // Check for multiple tabs in most recently closed window + is(recentlyClosed[0].window.tabs.length, 3, "most recently closed window has the expected number of tabs"); + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com"); + yield BrowserTestUtils.removeTab(tab); + + tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com"); + yield BrowserTestUtils.removeTab(tab); + + yield openAndCloseWindow(); + extension.sendMessage("check-sessions"); + recentlyClosed = yield extension.awaitMessage("recentlyClosed"); + let finalResult = recentlyClosed.filter(onlyNewItemsFilter); + checkRecentlyClosed(finalResult, 5, currentWindowId); + + isnot(finalResult[0].window, undefined, "first item is a window"); + is(finalResult[0].tab, undefined, "first item is not a tab"); + isnot(finalResult[1].tab, undefined, "second item is a tab"); + is(finalResult[1].window, undefined, "second item is not a window"); + isnot(finalResult[2].tab, undefined, "third item is a tab"); + is(finalResult[2].window, undefined, "third item is not a window"); + isnot(finalResult[3].window, undefined, "fourth item is a window"); + is(finalResult[3].tab, undefined, "fourth item is not a tab"); + isnot(finalResult[4].window, undefined, "fifth item is a window"); + is(finalResult[4].tab, undefined, "fifth item is not a tab"); + + // test with filter + extension.sendMessage("check-sessions", {maxResults: 2}); + recentlyClosed = yield extension.awaitMessage("recentlyClosed"); + checkRecentlyClosed(recentlyClosed.filter(onlyNewItemsFilter), 2, currentWindowId); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_sessions_getRecentlyClosed_private.js b/browser/components/extensions/test/browser/browser_ext_sessions_getRecentlyClosed_private.js new file mode 100644 index 000000000..217c8e130 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_sessions_getRecentlyClosed_private.js @@ -0,0 +1,61 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +/* globals recordInitialTimestamps, onlyNewItemsFilter, checkRecentlyClosed */ + +SimpleTest.requestCompleteLog(); + +Services.scriptloader.loadSubScript(new URL("head_sessions.js", gTestPath).href, + this); + +add_task(function* test_sessions_get_recently_closed_private() { + function background() { + browser.test.onMessage.addListener((msg, filter) => { + if (msg == "check-sessions") { + browser.sessions.getRecentlyClosed(filter).then(recentlyClosed => { + browser.test.sendMessage("recentlyClosed", recentlyClosed); + }); + } + }); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["sessions", "tabs"], + }, + background, + }); + + // Open a private browsing window. + let privateWin = yield BrowserTestUtils.openNewBrowserWindow({private: true}); + + yield extension.startup(); + + let {Management: {global: {WindowManager}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + let privateWinId = WindowManager.getId(privateWin); + + extension.sendMessage("check-sessions"); + let recentlyClosed = yield extension.awaitMessage("recentlyClosed"); + recordInitialTimestamps(recentlyClosed.map(item => item.lastModified)); + + // Open and close two tabs in the private window + let tab = yield BrowserTestUtils.openNewForegroundTab(privateWin.gBrowser, "http://example.com"); + yield BrowserTestUtils.removeTab(tab); + + tab = yield BrowserTestUtils.openNewForegroundTab(privateWin.gBrowser, "http://example.com"); + yield BrowserTestUtils.removeTab(tab); + + extension.sendMessage("check-sessions"); + recentlyClosed = yield extension.awaitMessage("recentlyClosed"); + checkRecentlyClosed(recentlyClosed.filter(onlyNewItemsFilter), 2, privateWinId, true); + + // Close the private window. + yield BrowserTestUtils.closeWindow(privateWin); + + extension.sendMessage("check-sessions"); + recentlyClosed = yield extension.awaitMessage("recentlyClosed"); + is(recentlyClosed.filter(onlyNewItemsFilter).length, 0, "the closed private window info was not found in recently closed data"); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_sessions_getRecentlyClosed_tabs.js b/browser/components/extensions/test/browser/browser_ext_sessions_getRecentlyClosed_tabs.js new file mode 100644 index 000000000..ae0daff9a --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_sessions_getRecentlyClosed_tabs.js @@ -0,0 +1,96 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function expectedTabInfo(tab, window) { + let browser = tab.linkedBrowser; + return { + url: browser.currentURI.spec, + title: browser.contentTitle, + favIconUrl: window.gBrowser.getIcon(tab), + }; +} + +function checkTabInfo(expected, actual) { + for (let prop in expected) { + is(actual[prop], expected[prop], `Expected value found for ${prop} of tab object.`); + } +} + +add_task(async function test_sessions_get_recently_closed_tabs() { + async function background() { + browser.test.onMessage.addListener(async msg => { + if (msg == "check-sessions") { + let recentlyClosed = await browser.sessions.getRecentlyClosed(); + browser.test.sendMessage("recentlyClosed", recentlyClosed); + } + }); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["sessions", "tabs"], + }, + background, + }); + + let win = await BrowserTestUtils.openNewBrowserWindow(); + await BrowserTestUtils.loadURI(win.gBrowser.selectedBrowser, "about:addons"); + await BrowserTestUtils.browserLoaded(win.gBrowser.selectedBrowser); + let expectedTabs = []; + let tab = win.gBrowser.selectedTab; + expectedTabs.push(expectedTabInfo(tab, win)); + + for (let url of ["about:robots", "about:mozilla"]) { + tab = await BrowserTestUtils.openNewForegroundTab(win.gBrowser, url); + expectedTabs.push(expectedTabInfo(tab, win)); + } + + await extension.startup(); + + // Test with a closed tab. + await BrowserTestUtils.removeTab(tab); + + extension.sendMessage("check-sessions"); + let recentlyClosed = await extension.awaitMessage("recentlyClosed"); + let tabInfo = recentlyClosed[0].tab; + let expectedTab = expectedTabs.pop(); + checkTabInfo(expectedTab, tabInfo); + + // Test with a closed window containing tabs. + await BrowserTestUtils.closeWindow(win); + + extension.sendMessage("check-sessions"); + recentlyClosed = await extension.awaitMessage("recentlyClosed"); + let tabInfos = recentlyClosed[0].window.tabs; + is(tabInfos.length, 2, "Expected number of tabs in closed window."); + for (let x = 0; x < tabInfos.length; x++) { + checkTabInfo(expectedTabs[x], tabInfos[x]); + } + + await extension.unload(); + + // Test without tabs permission. + extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["sessions"], + }, + background, + }); + + await extension.startup(); + + extension.sendMessage("check-sessions"); + recentlyClosed = await extension.awaitMessage("recentlyClosed"); + tabInfos = recentlyClosed[0].window.tabs; + is(tabInfos.length, 2, "Expected number of tabs in closed window."); + for (let tabInfo of tabInfos) { + for (let prop in expectedTabs[0]) { + is(undefined, + tabInfo[prop], + `${prop} of tab object is undefined without tabs permission.`); + } + } + + await extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_sessions_restore.js b/browser/components/extensions/test/browser/browser_ext_sessions_restore.js new file mode 100644 index 000000000..6f1c6cf9a --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_sessions_restore.js @@ -0,0 +1,134 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +SimpleTest.requestCompleteLog(); + +XPCOMUtils.defineLazyModuleGetter(this, "SessionStore", + "resource:///modules/sessionstore/SessionStore.jsm"); + +add_task(function* test_sessions_restore() { + function background() { + browser.test.onMessage.addListener((msg, data) => { + if (msg == "check-sessions") { + browser.sessions.getRecentlyClosed().then(recentlyClosed => { + browser.test.sendMessage("recentlyClosed", recentlyClosed); + }); + } else if (msg == "restore") { + browser.sessions.restore(data).then(sessions => { + browser.test.sendMessage("restored", sessions); + }); + } else if (msg == "restore-reject") { + browser.sessions.restore("not-a-valid-session-id").then( + sessions => { + browser.test.fail("restore rejected with an invalid sessionId"); + }, + error => { + browser.test.assertTrue( + error.message.includes("Could not restore object using sessionId not-a-valid-session-id.")); + browser.test.sendMessage("restore-rejected"); + } + ); + } + }); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["sessions", "tabs"], + }, + background, + }); + + yield extension.startup(); + + let {Management: {global: {WindowManager, TabManager}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + function checkLocalTab(tab, expectedUrl) { + let realTab = TabManager.getTab(tab.id); + let tabState = JSON.parse(SessionStore.getTabState(realTab)); + is(tabState.entries[0].url, expectedUrl, "restored tab has the expected url"); + } + + let win = yield BrowserTestUtils.openNewBrowserWindow(); + yield BrowserTestUtils.loadURI(win.gBrowser.selectedBrowser, "about:config"); + yield BrowserTestUtils.browserLoaded(win.gBrowser.selectedBrowser); + for (let url of ["about:robots", "about:mozilla"]) { + yield BrowserTestUtils.openNewForegroundTab(win.gBrowser, url); + } + yield BrowserTestUtils.closeWindow(win); + + extension.sendMessage("check-sessions"); + let recentlyClosed = yield extension.awaitMessage("recentlyClosed"); + + // Check that our expected window is the most recently closed. + is(recentlyClosed[0].window.tabs.length, 3, "most recently closed window has the expected number of tabs"); + + // Restore the window. + extension.sendMessage("restore"); + let restored = yield extension.awaitMessage("restored"); + + is(restored.length, 1, "restore returned the expected number of sessions"); + is(restored[0].window.tabs.length, 3, "restore returned a window with the expected number of tabs"); + checkLocalTab(restored[0].window.tabs[0], "about:config"); + checkLocalTab(restored[0].window.tabs[1], "about:robots"); + checkLocalTab(restored[0].window.tabs[2], "about:mozilla"); + + // Close the window again. + let window = WindowManager.getWindow(restored[0].window.id); + yield BrowserTestUtils.closeWindow(window); + + // Restore the window using the sessionId. + extension.sendMessage("check-sessions"); + recentlyClosed = yield extension.awaitMessage("recentlyClosed"); + extension.sendMessage("restore", recentlyClosed[0].window.sessionId); + restored = yield extension.awaitMessage("restored"); + + is(restored.length, 1, "restore returned the expected number of sessions"); + is(restored[0].window.tabs.length, 3, "restore returned a window with the expected number of tabs"); + checkLocalTab(restored[0].window.tabs[0], "about:config"); + checkLocalTab(restored[0].window.tabs[1], "about:robots"); + checkLocalTab(restored[0].window.tabs[2], "about:mozilla"); + + // Close the window again. + window = WindowManager.getWindow(restored[0].window.id); + yield BrowserTestUtils.closeWindow(window); + + // Open and close a tab. + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:robots"); + yield BrowserTestUtils.removeTab(tab); + + // Restore the most recently closed item. + extension.sendMessage("restore"); + restored = yield extension.awaitMessage("restored"); + + is(restored.length, 1, "restore returned the expected number of sessions"); + tab = restored[0].tab; + ok(tab, "restore returned a tab"); + checkLocalTab(tab, "about:robots"); + + // Close the tab again. + let realTab = TabManager.getTab(tab.id); + yield BrowserTestUtils.removeTab(realTab); + + // Restore the tab using the sessionId. + extension.sendMessage("check-sessions"); + recentlyClosed = yield extension.awaitMessage("recentlyClosed"); + extension.sendMessage("restore", recentlyClosed[0].tab.sessionId); + restored = yield extension.awaitMessage("restored"); + + is(restored.length, 1, "restore returned the expected number of sessions"); + tab = restored[0].tab; + ok(tab, "restore returned a tab"); + checkLocalTab(tab, "about:robots"); + + // Close the tab again. + realTab = TabManager.getTab(tab.id); + yield BrowserTestUtils.removeTab(realTab); + + // Try to restore something with an invalid sessionId. + extension.sendMessage("restore-reject"); + restored = yield extension.awaitMessage("restore-rejected"); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_simple.js b/browser/components/extensions/test/browser/browser_ext_simple.js new file mode 100644 index 000000000..ffa00c9db --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_simple.js @@ -0,0 +1,57 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* test_simple() { + let extensionData = { + manifest: { + "name": "Simple extension test", + "version": "1.0", + "manifest_version": 2, + "description": "", + }, + }; + + let extension = ExtensionTestUtils.loadExtension(extensionData); + info("load complete"); + yield extension.startup(); + info("startup complete"); + yield extension.unload(); + info("extension unloaded successfully"); +}); + +add_task(function* test_background() { + function backgroundScript() { + browser.test.log("running background script"); + + browser.test.onMessage.addListener((x, y) => { + browser.test.assertEq(x, 10, "x is 10"); + browser.test.assertEq(y, 20, "y is 20"); + + browser.test.notifyPass("background test passed"); + }); + + browser.test.sendMessage("running", 1); + } + + let extensionData = { + background: "(" + backgroundScript.toString() + ")()", + manifest: { + "name": "Simple extension test", + "version": "1.0", + "manifest_version": 2, + "description": "", + }, + }; + + let extension = ExtensionTestUtils.loadExtension(extensionData); + info("load complete"); + let [, x] = yield Promise.all([extension.startup(), extension.awaitMessage("running")]); + is(x, 1, "got correct value from extension"); + info("startup complete"); + extension.sendMessage(10, 20); + yield extension.awaitFinish(); + info("test complete"); + yield extension.unload(); + info("extension unloaded successfully"); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tab_runtimeConnect.js b/browser/components/extensions/test/browser/browser_ext_tab_runtimeConnect.js new file mode 100644 index 000000000..a5541a002 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tab_runtimeConnect.js @@ -0,0 +1,74 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://mochi.test:8888/"); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + let messages_received = []; + + let tabId; + + browser.runtime.onConnect.addListener((port) => { + browser.test.assertTrue(!!port, "tab to background port received"); + browser.test.assertEq("tab-connection-name", port.name, "port name should be defined and equal to connectInfo.name"); + browser.test.assertTrue(!!port.sender.tab, "port.sender.tab should be defined"); + browser.test.assertEq(tabId, port.sender.tab.id, "port.sender.tab.id should be equal to the expected tabId"); + + port.onMessage.addListener((msg) => { + messages_received.push(msg); + + if (messages_received.length == 1) { + browser.test.assertEq("tab to background port message", msg, "'tab to background' port message received"); + port.postMessage("background to tab port message"); + } + + if (messages_received.length == 2) { + browser.test.assertTrue(!!msg.tabReceived, "'background to tab' reply port message received"); + browser.test.assertEq("background to tab port message", msg.tabReceived, "reply port content contains the message received"); + + browser.test.notifyPass("tabRuntimeConnect.pass"); + } + }); + }); + + browser.tabs.create({url: "tab.html"}, + (tab) => { tabId = tab.id; }); + }, + + files: { + "tab.js": function() { + let port = browser.runtime.connect({name: "tab-connection-name"}); + port.postMessage("tab to background port message"); + port.onMessage.addListener((msg) => { + port.postMessage({tabReceived: msg}); + }); + }, + "tab.html": ` + <!DOCTYPE html> + <html> + <head> + <title>test tab extension page</title> + <meta charset="utf-8"> + <script src="tab.js" async></script> + </head> + <body> + <h1>test tab extension page</h1> + </body> + </html> + `, + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabRuntimeConnect.pass"); + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_audio.js b/browser/components/extensions/test/browser/browser_ext_tabs_audio.js new file mode 100644 index 000000000..f9f6956d4 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_audio.js @@ -0,0 +1,203 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank?1"); + let tab2 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank?2"); + + gBrowser.selectedTab = tab1; + + async function background() { + function promiseUpdated(tabId, attr) { + return new Promise(resolve => { + let onUpdated = (tabId_, changeInfo, tab) => { + if (tabId == tabId_ && attr in changeInfo) { + browser.tabs.onUpdated.removeListener(onUpdated); + + resolve({changeInfo, tab}); + } + }; + browser.tabs.onUpdated.addListener(onUpdated); + }); + } + + let deferred = {}; + browser.test.onMessage.addListener((message, tabId, result) => { + if (message == "change-tab-done" && deferred[tabId]) { + deferred[tabId].resolve(result); + } + }); + + function changeTab(tabId, attr, on) { + return new Promise((resolve, reject) => { + deferred[tabId] = {resolve, reject}; + browser.test.sendMessage("change-tab", tabId, attr, on); + }); + } + + + try { + let tabs = await browser.tabs.query({lastFocusedWindow: true}); + browser.test.assertEq(tabs.length, 3, "We have three tabs"); + + for (let tab of tabs) { + // Note: We want to check that these are actual boolean values, not + // just that they evaluate as false. + browser.test.assertEq(false, tab.mutedInfo.muted, "Tab is not muted"); + browser.test.assertEq(undefined, tab.mutedInfo.reason, "Tab has no muted info reason"); + browser.test.assertEq(false, tab.audible, "Tab is not audible"); + } + + let windowId = tabs[0].windowId; + let tabIds = [tabs[1].id, tabs[2].id]; + + browser.test.log("Test initial queries for muted and audible return no tabs"); + let silent = await browser.tabs.query({windowId, audible: false}); + let audible = await browser.tabs.query({windowId, audible: true}); + let muted = await browser.tabs.query({windowId, muted: true}); + let nonMuted = await browser.tabs.query({windowId, muted: false}); + + browser.test.assertEq(3, silent.length, "Three silent tabs"); + browser.test.assertEq(0, audible.length, "No audible tabs"); + + browser.test.assertEq(0, muted.length, "No muted tabs"); + browser.test.assertEq(3, nonMuted.length, "Three non-muted tabs"); + + browser.test.log("Toggle muted and audible externally on one tab each, and check results"); + [muted, audible] = await Promise.all([ + promiseUpdated(tabIds[0], "mutedInfo"), + promiseUpdated(tabIds[1], "audible"), + changeTab(tabIds[0], "muted", true), + changeTab(tabIds[1], "audible", true), + ]); + + for (let obj of [muted.changeInfo, muted.tab]) { + browser.test.assertEq(true, obj.mutedInfo.muted, "Tab is muted"); + browser.test.assertEq("user", obj.mutedInfo.reason, "Tab was muted by the user"); + } + + browser.test.assertEq(true, audible.changeInfo.audible, "Tab audible state changed"); + browser.test.assertEq(true, audible.tab.audible, "Tab is audible"); + + browser.test.log("Re-check queries. Expect one audible and one muted tab"); + silent = await browser.tabs.query({windowId, audible: false}); + audible = await browser.tabs.query({windowId, audible: true}); + muted = await browser.tabs.query({windowId, muted: true}); + nonMuted = await browser.tabs.query({windowId, muted: false}); + + browser.test.assertEq(2, silent.length, "Two silent tabs"); + browser.test.assertEq(1, audible.length, "One audible tab"); + + browser.test.assertEq(1, muted.length, "One muted tab"); + browser.test.assertEq(2, nonMuted.length, "Two non-muted tabs"); + + browser.test.assertEq(true, muted[0].mutedInfo.muted, "Tab is muted"); + browser.test.assertEq("user", muted[0].mutedInfo.reason, "Tab was muted by the user"); + + browser.test.assertEq(true, audible[0].audible, "Tab is audible"); + + browser.test.log("Toggle muted internally on two tabs, and check results"); + [nonMuted, muted] = await Promise.all([ + promiseUpdated(tabIds[0], "mutedInfo"), + promiseUpdated(tabIds[1], "mutedInfo"), + browser.tabs.update(tabIds[0], {muted: false}), + browser.tabs.update(tabIds[1], {muted: true}), + ]); + + for (let obj of [nonMuted.changeInfo, nonMuted.tab]) { + browser.test.assertEq(false, obj.mutedInfo.muted, "Tab is not muted"); + } + for (let obj of [muted.changeInfo, muted.tab]) { + browser.test.assertEq(true, obj.mutedInfo.muted, "Tab is muted"); + } + + for (let obj of [nonMuted.changeInfo, nonMuted.tab, muted.changeInfo, muted.tab]) { + browser.test.assertEq("extension", obj.mutedInfo.reason, "Mute state changed by extension"); + + // FIXME: browser.runtime.id is currently broken. + browser.test.assertEq(browser.i18n.getMessage("@@extension_id"), + obj.mutedInfo.extensionId, + "Mute state changed by extension"); + } + + browser.test.log("Test that mutedInfo is preserved by sessionstore"); + let tab = await changeTab(tabIds[1], "duplicate").then(browser.tabs.get); + + browser.test.assertEq(true, tab.mutedInfo.muted, "Tab is muted"); + + browser.test.assertEq("extension", tab.mutedInfo.reason, "Mute state changed by extension"); + + // FIXME: browser.runtime.id is currently broken. + browser.test.assertEq(browser.i18n.getMessage("@@extension_id"), + tab.mutedInfo.extensionId, + "Mute state changed by extension"); + + browser.test.log("Unmute externally, and check results"); + [nonMuted] = await Promise.all([ + promiseUpdated(tabIds[1], "mutedInfo"), + changeTab(tabIds[1], "muted", false), + browser.tabs.remove(tab.id), + ]); + + for (let obj of [nonMuted.changeInfo, nonMuted.tab]) { + browser.test.assertEq(false, obj.mutedInfo.muted, "Tab is not muted"); + browser.test.assertEq("user", obj.mutedInfo.reason, "Mute state changed by user"); + } + + browser.test.notifyPass("tab-audio"); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("tab-audio"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background, + }); + + extension.onMessage("change-tab", (tabId, attr, on) => { + let {Management: {global: {TabManager}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + let tab = TabManager.getTab(tabId); + + if (attr == "muted") { + // Ideally we'd simulate a click on the tab audio icon for this, but the + // handler relies on CSS :hover states, which are complicated and fragile + // to simulate. + if (tab.muted != on) { + tab.toggleMuteAudio(); + } + } else if (attr == "audible") { + let browser = tab.linkedBrowser; + if (on) { + browser.audioPlaybackStarted(); + } else { + browser.audioPlaybackStopped(); + } + } else if (attr == "duplicate") { + // This is a bit of a hack. It won't be necessary once we have + // `tabs.duplicate`. + let newTab = gBrowser.duplicateTab(tab); + BrowserTestUtils.waitForEvent(newTab, "SSTabRestored", () => true).then(() => { + extension.sendMessage("change-tab-done", tabId, TabManager.getId(newTab)); + }); + return; + } + + extension.sendMessage("change-tab-done", tabId); + }); + + yield extension.startup(); + + yield extension.awaitFinish("tab-audio"); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab1); + yield BrowserTestUtils.removeTab(tab2); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_captureVisibleTab.js b/browser/components/extensions/test/browser/browser_ext_tabs_captureVisibleTab.js new file mode 100644 index 000000000..1491a19ab --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_captureVisibleTab.js @@ -0,0 +1,155 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function* runTest(options) { + options.neutral = [0xaa, 0xaa, 0xaa]; + + let html = ` + <!DOCTYPE html> + <html lang="en"> + <head><meta charset="UTF-8"></head> + <body style="background-color: rgb(${options.color})"> + <!-- Fill most of the image with a neutral color to test edge-to-edge scaling. --> + <div style="position: absolute; + left: 2px; + right: 2px; + top: 2px; + bottom: 2px; + background: rgb(${options.neutral});"></div> + </body> + </html> + `; + + let url = `data:text/html,${encodeURIComponent(html)}`; + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, url, true); + + tab.linkedBrowser.fullZoom = options.fullZoom; + + async function background(options) { + browser.test.log(`Test color ${options.color} at fullZoom=${options.fullZoom}`); + + try { + let [tab] = await browser.tabs.query({currentWindow: true, active: true}); + + let [jpeg, png, ...pngs] = await Promise.all([ + browser.tabs.captureVisibleTab(tab.windowId, {format: "jpeg", quality: 95}), + browser.tabs.captureVisibleTab(tab.windowId, {format: "png", quality: 95}), + browser.tabs.captureVisibleTab(tab.windowId, {quality: 95}), + browser.tabs.captureVisibleTab(tab.windowId), + ]); + + browser.test.assertTrue(pngs.every(url => url == png), "All PNGs are identical"); + + browser.test.assertTrue(jpeg.startsWith("data:image/jpeg;base64,"), "jpeg is JPEG"); + browser.test.assertTrue(png.startsWith("data:image/png;base64,"), "png is PNG"); + + let promises = [jpeg, png].map(url => new Promise(resolve => { + let img = new Image(); + img.src = url; + img.onload = () => resolve(img); + })); + + [jpeg, png] = await Promise.all(promises); + let tabDims = `${tab.width}\u00d7${tab.height}`; + + let images = {jpeg, png}; + for (let format of Object.keys(images)) { + let img = images[format]; + + let dims = `${img.width}\u00d7${img.height}`; + browser.test.assertEq(tabDims, dims, `${format} dimensions are correct`); + + let canvas = document.createElement("canvas"); + canvas.width = img.width; + canvas.height = img.height; + canvas.mozOpaque = true; + + let ctx = canvas.getContext("2d"); + ctx.drawImage(img, 0, 0); + + // Check the colors of the first and last pixels of the image, to make + // sure we capture the entire frame, and scale it correctly. + let coords = [ + {x: 0, y: 0, + color: options.color}, + {x: img.width - 1, + y: img.height - 1, + color: options.color}, + {x: img.width / 2 | 0, + y: img.height / 2 | 0, + color: options.neutral}, + ]; + + for (let {x, y, color} of coords) { + let imageData = ctx.getImageData(x, y, 1, 1).data; + + if (format == "png") { + browser.test.assertEq(`rgba(${color},255)`, `rgba(${[...imageData]})`, `${format} image color is correct at (${x}, ${y})`); + } else { + // Allow for some deviation in JPEG version due to lossy compression. + const SLOP = 3; + + browser.test.log(`Testing ${format} image color at (${x}, ${y}), have rgba(${[...imageData]}), expecting approx. rgba(${color},255)`); + + browser.test.assertTrue(Math.abs(color[0] - imageData[0]) <= SLOP, `${format} image color.red is correct at (${x}, ${y})`); + browser.test.assertTrue(Math.abs(color[1] - imageData[1]) <= SLOP, `${format} image color.green is correct at (${x}, ${y})`); + browser.test.assertTrue(Math.abs(color[2] - imageData[2]) <= SLOP, `${format} image color.blue is correct at (${x}, ${y})`); + browser.test.assertEq(255, imageData[3], `${format} image color.alpha is correct at (${x}, ${y})`); + } + } + } + + browser.test.notifyPass("captureVisibleTab"); + } catch (e) { + browser.test.fail(`Error: ${e} :: ${e.stack}`); + browser.test.notifyFail("captureVisibleTab"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["<all_urls>"], + }, + + background: `(${background})(${JSON.stringify(options)})`, + }); + + yield extension.startup(); + + yield extension.awaitFinish("captureVisibleTab"); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +} + +add_task(function* testCaptureVisibleTab() { + yield runTest({color: [0, 0, 0], fullZoom: 1}); + + yield runTest({color: [0, 0, 0], fullZoom: 2}); + + yield runTest({color: [0, 0, 0], fullZoom: 0.5}); + + yield runTest({color: [255, 255, 255], fullZoom: 1}); +}); + +add_task(function* testCaptureVisibleTabPermissions() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background() { + browser.test.assertFalse("captureVisibleTab" in browser.tabs, + 'Extension without "<all_tabs>" permission should not have access to captureVisibleTab'); + browser.test.notifyPass("captureVisibleTabPermissions"); + }, + }); + + yield extension.startup(); + + yield extension.awaitFinish("captureVisibleTabPermissions"); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_cookieStoreId.js b/browser/components/extensions/test/browser/browser_ext_tabs_cookieStoreId.js new file mode 100644 index 000000000..dc0647e3c --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_cookieStoreId.js @@ -0,0 +1,156 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* setup() { + // make sure userContext is enabled. + return SpecialPowers.pushPrefEnv({"set": [ + ["privacy.userContext.enabled", true], + ]}); +}); + +add_task(function* () { + info("Start testing tabs.create with cookieStoreId"); + + let testCases = [ + // No private window + {privateTab: false, cookieStoreId: null, success: true, expectedCookieStoreId: "firefox-default"}, + {privateTab: false, cookieStoreId: "firefox-default", success: true, expectedCookieStoreId: "firefox-default"}, + {privateTab: false, cookieStoreId: "firefox-container-1", success: true, expectedCookieStoreId: "firefox-container-1"}, + {privateTab: false, cookieStoreId: "firefox-container-2", success: true, expectedCookieStoreId: "firefox-container-2"}, + {privateTab: false, cookieStoreId: "firefox-container-42", failure: "exist"}, + {privateTab: false, cookieStoreId: "firefox-private", failure: "defaultToPrivate"}, + {privateTab: false, cookieStoreId: "wow", failure: "illegal"}, + + // Private window + {privateTab: true, cookieStoreId: null, success: true, expectedCookieStoreId: "firefox-private"}, + {privateTab: true, cookieStoreId: "firefox-private", success: true, expectedCookieStoreId: "firefox-private"}, + {privateTab: true, cookieStoreId: "firefox-default", failure: "privateToDefault"}, + {privateTab: true, cookieStoreId: "firefox-container-1", failure: "privateToDefault"}, + {privateTab: true, cookieStoreId: "wow", failure: "illegal"}, + ]; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs", "cookies"], + }, + + background: function() { + function testTab(data, tab) { + browser.test.assertTrue(data.success, "we want a success"); + browser.test.assertTrue(!!tab, "we have a tab"); + browser.test.assertEq(data.expectedCookieStoreId, tab.cookieStoreId, "tab should have the correct cookieStoreId"); + } + + async function runTest(data) { + try { + // Tab Creation + let tab; + try { + tab = await browser.tabs.create({ + windowId: data.privateTab ? this.privateWindowId : this.defaultWindowId, + cookieStoreId: data.cookieStoreId, + }); + + browser.test.assertTrue(!data.failure, "we want a success"); + } catch (error) { + browser.test.assertTrue(!!data.failure, "we want a failure"); + + if (data.failure == "illegal") { + browser.test.assertTrue(/Illegal cookieStoreId/.test(error.message), + "runtime.lastError should report the expected error message"); + } else if (data.failure == "defaultToPrivate") { + browser.test.assertTrue("Illegal to set private cookieStorageId in a non private window", + error.message, + "runtime.lastError should report the expected error message"); + } else if (data.failure == "privateToDefault") { + browser.test.assertTrue("Illegal to set non private cookieStorageId in a private window", + error.message, + "runtime.lastError should report the expected error message"); + } else if (data.failure == "exist") { + browser.test.assertTrue(/No cookie store exists/.test(error.message), + "runtime.lastError should report the expected error message"); + } else { + browser.test.fail("The test is broken"); + } + + browser.test.sendMessage("test-done"); + return; + } + + // Tests for tab creation + testTab(data, tab); + + { + // Tests for tab querying + let [tab] = await browser.tabs.query({ + windowId: data.privateTab ? this.privateWindowId : this.defaultWindowId, + cookieStoreId: data.cookieStoreId, + }); + + browser.test.assertTrue(tab != undefined, "Tab found!"); + testTab(data, tab); + } + + let stores = await browser.cookies.getAllCookieStores(); + + let store = stores.find(store => store.id === tab.cookieStoreId); + browser.test.assertTrue(!!store, "We have a store for this tab."); + + await browser.tabs.remove(tab.id); + + browser.test.sendMessage("test-done"); + } catch (e) { + browser.test.fail("An exception has been thrown"); + } + } + + async function initialize() { + let win = await browser.windows.create({incognito: true}); + this.privateWindowId = win.id; + + win = await browser.windows.create({incognito: false}); + this.defaultWindowId = win.id; + + browser.test.sendMessage("ready"); + } + + async function shutdown() { + await browser.windows.remove(this.privateWindowId); + await browser.windows.remove(this.defaultWindowId); + browser.test.sendMessage("gone"); + } + + // Waiting for messages + browser.test.onMessage.addListener((msg, data) => { + if (msg == "be-ready") { + initialize(); + } else if (msg == "test") { + runTest(data); + } else { + browser.test.assertTrue("finish", msg, "Shutting down"); + shutdown(); + } + }); + }, + }); + + yield extension.startup(); + + info("Tests must be ready..."); + extension.sendMessage("be-ready"); + yield extension.awaitMessage("ready"); + info("Tests are ready to run!"); + + for (let test of testCases) { + info(`test tab.create with cookieStoreId: "${test.cookieStoreId}"`); + extension.sendMessage("test", test); + yield extension.awaitMessage("test-done"); + } + + info("Waiting for shutting down..."); + extension.sendMessage("finish"); + yield extension.awaitMessage("gone"); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_create.js b/browser/components/extensions/test/browser/browser_ext_tabs_create.js new file mode 100644 index 000000000..8bc5a68a2 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_create.js @@ -0,0 +1,166 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:robots"); + gBrowser.selectedTab = tab; + + // TODO: Multiple windows. + + // Using pre-loaded new tab pages interferes with onUpdated events. + // It probably shouldn't. + SpecialPowers.setBoolPref("browser.newtab.preload", false); + registerCleanupFunction(() => { + SpecialPowers.clearUserPref("browser.newtab.preload"); + }); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + + "background": {"page": "bg/background.html"}, + }, + + files: { + "bg/blank.html": `<html><head><meta charset="utf-8"></head></html>`, + + "bg/background.html": `<html><head> + <meta charset="utf-8"> + <script src="background.js"></script> + </head></html>`, + + "bg/background.js": function() { + let activeTab; + let activeWindow; + + function runTests() { + const DEFAULTS = { + index: 2, + windowId: activeWindow, + active: true, + pinned: false, + url: "about:newtab", + }; + + let tests = [ + { + create: {url: "http://example.com/"}, + result: {url: "http://example.com/"}, + }, + { + create: {url: "blank.html"}, + result: {url: browser.runtime.getURL("bg/blank.html")}, + }, + { + create: {}, + result: {url: "about:newtab"}, + }, + { + create: {active: false}, + result: {active: false}, + }, + { + create: {active: true}, + result: {active: true}, + }, + { + create: {pinned: true}, + result: {pinned: true, index: 0}, + }, + { + create: {pinned: true, active: true}, + result: {pinned: true, active: true, index: 0}, + }, + { + create: {pinned: true, active: false}, + result: {pinned: true, active: false, index: 0}, + }, + { + create: {index: 1}, + result: {index: 1}, + }, + { + create: {index: 1, active: false}, + result: {index: 1, active: false}, + }, + { + create: {windowId: activeWindow}, + result: {windowId: activeWindow}, + }, + ]; + + async function nextTest() { + if (!tests.length) { + browser.test.notifyPass("tabs.create"); + return; + } + + let test = tests.shift(); + let expected = Object.assign({}, DEFAULTS, test.result); + + browser.test.log(`Testing tabs.create(${JSON.stringify(test.create)}), expecting ${JSON.stringify(test.result)}`); + + let updatedPromise = new Promise(resolve => { + let onUpdated = (changedTabId, changed) => { + if (changed.url) { + browser.tabs.onUpdated.removeListener(onUpdated); + resolve({tabId: changedTabId, url: changed.url}); + } + }; + browser.tabs.onUpdated.addListener(onUpdated); + }); + + let createdPromise = new Promise(resolve => { + let onCreated = tab => { + browser.test.assertTrue("id" in tab, `Expected tabs.onCreated callback to receive tab object`); + resolve(); + }; + browser.tabs.onCreated.addListener(onCreated); + }); + + let [tab] = await Promise.all([ + browser.tabs.create(test.create), + createdPromise, + ]); + let tabId = tab.id; + + for (let key of Object.keys(expected)) { + if (key === "url") { + // FIXME: This doesn't get updated until later in the load cycle. + continue; + } + + browser.test.assertEq(expected[key], tab[key], `Expected value for tab.${key}`); + } + + let updated = await updatedPromise; + browser.test.assertEq(tabId, updated.tabId, `Expected value for tab.id`); + browser.test.assertEq(expected.url, updated.url, `Expected value for tab.url`); + + await browser.tabs.remove(tabId); + await browser.tabs.update(activeTab, {active: true}); + + nextTest(); + } + + nextTest(); + } + + browser.tabs.query({active: true, currentWindow: true}, tabs => { + activeTab = tabs[0].id; + activeWindow = tabs[0].windowId; + + runTests(); + }); + }, + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.create"); + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +}); + diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_create_invalid_url.js b/browser/components/extensions/test/browser/browser_ext_tabs_create_invalid_url.js new file mode 100644 index 000000000..49938bf22 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_create_invalid_url.js @@ -0,0 +1,66 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function* testTabsCreateInvalidURL(tabsCreateURL) { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.test.sendMessage("ready"); + browser.test.onMessage.addListener((msg, tabsCreateURL) => { + browser.tabs.create({url: tabsCreateURL}, (tab) => { + browser.test.assertEq(undefined, tab, "on error tab should be undefined"); + browser.test.assertTrue(/Illegal URL/.test(browser.runtime.lastError.message), + "runtime.lastError should report the expected error message"); + + // Remove the opened tab is any. + if (tab) { + browser.tabs.remove(tab.id); + } + browser.test.sendMessage("done"); + }); + }); + }, + }); + + yield extension.startup(); + + yield extension.awaitMessage("ready"); + + info(`test tab.create on invalid URL "${tabsCreateURL}"`); + + extension.sendMessage("start", tabsCreateURL); + yield extension.awaitMessage("done"); + + yield extension.unload(); +} + +add_task(function* () { + info("Start testing tabs.create on invalid URLs"); + + let dataURLPage = `data:text/html, + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + </head> + <body> + <h1>data url page</h1> + </body> + </html>`; + + let testCases = [ + {tabsCreateURL: "about:addons"}, + {tabsCreateURL: "javascript:console.log('tabs.update execute javascript')"}, + {tabsCreateURL: dataURLPage}, + ]; + + for (let {tabsCreateURL} of testCases) { + yield* testTabsCreateInvalidURL(tabsCreateURL); + } + + info("done"); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_detectLanguage.js b/browser/components/extensions/test/browser/browser_ext_tabs_detectLanguage.js new file mode 100644 index 000000000..f28606001 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_detectLanguage.js @@ -0,0 +1,47 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testDetectLanguage() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: async function() { + const BASE_PATH = "browser/browser/components/extensions/test/browser"; + + function loadTab(url) { + return browser.tabs.create({url}); + } + + try { + let tab = await loadTab(`http://example.co.jp/${BASE_PATH}/file_language_ja.html`); + let lang = await browser.tabs.detectLanguage(tab.id); + browser.test.assertEq("ja", lang, "Japanese document should be detected as Japanese"); + await browser.tabs.remove(tab.id); + + tab = await loadTab(`http://example.co.jp/${BASE_PATH}/file_language_fr_en.html`); + lang = await browser.tabs.detectLanguage(tab.id); + browser.test.assertEq("fr", lang, "French/English document should be detected as primarily French"); + await browser.tabs.remove(tab.id); + + tab = await loadTab(`http://example.co.jp/${BASE_PATH}/file_language_tlh.html`); + lang = await browser.tabs.detectLanguage(tab.id); + browser.test.assertEq("und", lang, "Klingon document should not be detected, should return 'und'"); + await browser.tabs.remove(tab.id); + + browser.test.notifyPass("detectLanguage"); + } catch (e) { + browser.test.fail(`Error: ${e} :: ${e.stack}`); + browser.test.notifyFail("detectLanguage"); + } + }, + }); + + yield extension.startup(); + + yield extension.awaitFinish("detectLanguage"); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_duplicate.js b/browser/components/extensions/test/browser/browser_ext_tabs_duplicate.js new file mode 100644 index 000000000..c4b0ffd2d --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_duplicate.js @@ -0,0 +1,146 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testDuplicateTab() { + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.net/"); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.tabs.query({ + lastFocusedWindow: true, + }, function(tabs) { + let source = tabs[1]; + // By moving it 0, we check that the new tab is created next + // to the existing one. + browser.tabs.move(source.id, {index: 0}, () => { + browser.tabs.duplicate(source.id, (tab) => { + browser.test.assertEq("http://example.net/", tab.url); + // Should be the second tab, next to the one duplicated. + browser.test.assertEq(1, tab.index); + // Should be selected by default. + browser.test.assertTrue(tab.selected); + browser.test.notifyPass("tabs.duplicate"); + }); + }); + }); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.duplicate"); + yield extension.unload(); + + while (gBrowser.tabs[0].linkedBrowser.currentURI.spec === "http://example.net/") { + yield BrowserTestUtils.removeTab(gBrowser.tabs[0]); + } +}); + +add_task(function* testDuplicateTabLazily() { + async function background() { + let tabLoadComplete = new Promise(resolve => { + browser.test.onMessage.addListener((message, tabId, result) => { + if (message == "duplicate-tab-done") { + resolve(tabId); + } + }); + }); + + function awaitLoad(tabId) { + return new Promise(resolve => { + browser.tabs.onUpdated.addListener(function listener(tabId_, changed, tab) { + if (tabId == tabId_ && changed.status == "complete") { + browser.tabs.onUpdated.removeListener(listener); + resolve(); + } + }); + }); + } + + try { + let url = "http://example.com/browser/browser/components/extensions/test/browser/file_dummy.html"; + let tab = await browser.tabs.create({url}); + let startTabId = tab.id; + + await awaitLoad(startTabId); + browser.test.sendMessage("duplicate-tab", startTabId); + + let unloadedTabId = await tabLoadComplete; + let loadedtab = await browser.tabs.get(startTabId); + browser.test.assertEq("Dummy test page", loadedtab.title, "Title should be returned for loaded pages"); + browser.test.assertEq("complete", loadedtab.status, "Tab status should be complete for loaded pages"); + + let unloadedtab = await browser.tabs.get(unloadedTabId); + browser.test.assertEq("Dummy test page", unloadedtab.title, "Title should be returned after page has been unloaded"); + + await browser.tabs.remove([tab.id, unloadedTabId]); + browser.test.notifyPass("tabs.hasCorrectTabTitle"); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("tabs.hasCorrectTabTitle"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background, + }); + + extension.onMessage("duplicate-tab", tabId => { + let {Management: {global: {TabManager}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + let tab = TabManager.getTab(tabId); + // This is a bit of a hack to load a tab in the background. + let newTab = gBrowser.duplicateTab(tab, false); + + BrowserTestUtils.waitForEvent(newTab, "SSTabRestored", () => true).then(() => { + extension.sendMessage("duplicate-tab-done", TabManager.getId(newTab)); + }); + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.hasCorrectTabTitle"); + yield extension.unload(); +}); + +add_task(function* testDuplicatePinnedTab() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.net/"); + gBrowser.pinTab(tab); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.tabs.query({ + lastFocusedWindow: true, + }, function(tabs) { + // Duplicate the pinned tab, example.net. + browser.tabs.duplicate(tabs[0].id, (tab) => { + browser.test.assertEq("http://example.net/", tab.url); + // Should be the second tab, next to the one duplicated. + browser.test.assertEq(1, tab.index); + // Should be pinned. + browser.test.assertTrue(tab.pinned); + browser.test.notifyPass("tabs.duplicate.pinned"); + }); + }); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.duplicate.pinned"); + yield extension.unload(); + + while (gBrowser.tabs[0].linkedBrowser.currentURI.spec === "http://example.net/") { + yield BrowserTestUtils.removeTab(gBrowser.tabs[0]); + } +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_events.js b/browser/components/extensions/test/browser/browser_ext_tabs_events.js new file mode 100644 index 000000000..75dea40fd --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_events.js @@ -0,0 +1,280 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testTabEvents() { + async function background() { + let events = []; + browser.tabs.onCreated.addListener(tab => { + events.push({type: "onCreated", tab}); + }); + + browser.tabs.onAttached.addListener((tabId, info) => { + events.push(Object.assign({type: "onAttached", tabId}, info)); + }); + + browser.tabs.onDetached.addListener((tabId, info) => { + events.push(Object.assign({type: "onDetached", tabId}, info)); + }); + + browser.tabs.onRemoved.addListener((tabId, info) => { + events.push(Object.assign({type: "onRemoved", tabId}, info)); + }); + + browser.tabs.onMoved.addListener((tabId, info) => { + events.push(Object.assign({type: "onMoved", tabId}, info)); + }); + + async function expectEvents(names) { + browser.test.log(`Expecting events: ${names.join(", ")}`); + + await new Promise(resolve => setTimeout(resolve, 0)); + + browser.test.assertEq(names.length, events.length, "Got expected number of events"); + for (let [i, name] of names.entries()) { + browser.test.assertEq(name, i in events && events[i].type, + `Got expected ${name} event`); + } + return events.splice(0); + } + + try { + browser.test.log("Create second browser window"); + + let windows = await Promise.all([ + browser.windows.getCurrent(), + browser.windows.create({url: "about:blank"}), + ]); + + let windowId = windows[0].id; + let otherWindowId = windows[1].id; + + let [created] = await expectEvents(["onCreated"]); + let initialTab = created.tab; + + + browser.test.log("Create tab in window 1"); + let tab = await browser.tabs.create({windowId, index: 0, url: "about:blank"}); + let oldIndex = tab.index; + browser.test.assertEq(0, oldIndex, "Tab has the expected index"); + + [created] = await expectEvents(["onCreated"]); + browser.test.assertEq(tab.id, created.tab.id, "Got expected tab ID"); + browser.test.assertEq(oldIndex, created.tab.index, "Got expected tab index"); + + + browser.test.log("Move tab to window 2"); + await browser.tabs.move([tab.id], {windowId: otherWindowId, index: 0}); + + let [detached, attached] = await expectEvents(["onDetached", "onAttached"]); + browser.test.assertEq(oldIndex, detached.oldPosition, "Expected old index"); + browser.test.assertEq(windowId, detached.oldWindowId, "Expected old window ID"); + + browser.test.assertEq(0, attached.newPosition, "Expected new index"); + browser.test.assertEq(otherWindowId, attached.newWindowId, "Expected new window ID"); + + + browser.test.log("Move tab within the same window"); + let [moved] = await browser.tabs.move([tab.id], {index: 1}); + browser.test.assertEq(1, moved.index, "Expected new index"); + + [moved] = await expectEvents(["onMoved"]); + browser.test.assertEq(tab.id, moved.tabId, "Expected tab ID"); + browser.test.assertEq(0, moved.fromIndex, "Expected old index"); + browser.test.assertEq(1, moved.toIndex, "Expected new index"); + browser.test.assertEq(otherWindowId, moved.windowId, "Expected window ID"); + + + browser.test.log("Remove tab"); + await browser.tabs.remove(tab.id); + let [removed] = await expectEvents(["onRemoved"]); + + browser.test.assertEq(tab.id, removed.tabId, "Expected removed tab ID"); + browser.test.assertEq(otherWindowId, removed.windowId, "Expected removed tab window ID"); + // Note: We want to test for the actual boolean value false here. + browser.test.assertEq(false, removed.isWindowClosing, "Expected isWindowClosing value"); + + + browser.test.log("Close second window"); + await browser.windows.remove(otherWindowId); + [removed] = await expectEvents(["onRemoved"]); + browser.test.assertEq(initialTab.id, removed.tabId, "Expected removed tab ID"); + browser.test.assertEq(otherWindowId, removed.windowId, "Expected removed tab window ID"); + browser.test.assertEq(true, removed.isWindowClosing, "Expected isWindowClosing value"); + + + browser.test.log("Create additional tab in window 1"); + tab = await browser.tabs.create({windowId, url: "about:blank"}); + await expectEvents(["onCreated"]); + + + browser.test.log("Create a new window, adopting the new tab"); + // We have to explicitly wait for the event here, since its timing is + // not predictable. + let promiseAttached = new Promise(resolve => { + browser.tabs.onAttached.addListener(function listener(tabId) { + browser.tabs.onAttached.removeListener(listener); + resolve(); + }); + }); + + let [window] = await Promise.all([ + browser.windows.create({tabId: tab.id}), + promiseAttached, + ]); + + [detached, attached] = await expectEvents(["onDetached", "onAttached"]); + + browser.test.assertEq(tab.id, detached.tabId, "Expected onDetached tab ID"); + + browser.test.assertEq(tab.id, attached.tabId, "Expected onAttached tab ID"); + browser.test.assertEq(0, attached.newPosition, "Expected onAttached new index"); + browser.test.assertEq(window.id, attached.newWindowId, + "Expected onAttached new window id"); + + browser.test.log("Close the new window"); + await browser.windows.remove(window.id); + + browser.test.notifyPass("tabs-events"); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("tabs-events"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs-events"); + yield extension.unload(); +}); + +add_task(function* testTabEventsSize() { + function background() { + function sendSizeMessages(tab, type) { + browser.test.sendMessage(`${type}-dims`, {width: tab.width, height: tab.height}); + } + + browser.tabs.onCreated.addListener(tab => { + sendSizeMessages(tab, "on-created"); + }); + + browser.tabs.onUpdated.addListener((tabId, changeInfo, tab) => { + if (changeInfo.status == "complete") { + sendSizeMessages(tab, "on-updated"); + } + }); + + browser.test.onMessage.addListener(async (msg, arg) => { + if (msg === "create-tab") { + let tab = await browser.tabs.create({url: "http://example.com/"}); + sendSizeMessages(tab, "create"); + browser.test.sendMessage("created-tab-id", tab.id); + } else if (msg === "update-tab") { + let tab = await browser.tabs.update(arg, {url: "http://example.org/"}); + sendSizeMessages(tab, "update"); + } else if (msg === "remove-tab") { + browser.tabs.remove(arg); + browser.test.sendMessage("tab-removed"); + } + }); + + browser.test.sendMessage("ready"); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + background, + }); + + const RESOLUTION_PREF = "layout.css.devPixelsPerPx"; + registerCleanupFunction(() => { + SpecialPowers.clearUserPref(RESOLUTION_PREF); + }); + + function checkDimensions(dims, type) { + is(dims.width, gBrowser.selectedBrowser.clientWidth, `tab from ${type} reports expected width`); + is(dims.height, gBrowser.selectedBrowser.clientHeight, `tab from ${type} reports expected height`); + } + + yield Promise.all([extension.startup(), extension.awaitMessage("ready")]); + + for (let resolution of [2, 1]) { + SpecialPowers.setCharPref(RESOLUTION_PREF, String(resolution)); + is(window.devicePixelRatio, resolution, "window has the required resolution"); + + extension.sendMessage("create-tab"); + let tabId = yield extension.awaitMessage("created-tab-id"); + + checkDimensions(yield extension.awaitMessage("create-dims"), "create"); + checkDimensions(yield extension.awaitMessage("on-created-dims"), "onCreated"); + checkDimensions(yield extension.awaitMessage("on-updated-dims"), "onUpdated"); + + extension.sendMessage("update-tab", tabId); + + checkDimensions(yield extension.awaitMessage("update-dims"), "update"); + checkDimensions(yield extension.awaitMessage("on-updated-dims"), "onUpdated"); + + extension.sendMessage("remove-tab", tabId); + yield extension.awaitMessage("tab-removed"); + } + + yield extension.unload(); + SpecialPowers.clearUserPref(RESOLUTION_PREF); +}); + +add_task(function* testTabRemovalEvent() { + async function background() { + function awaitLoad(tabId) { + return new Promise(resolve => { + browser.tabs.onUpdated.addListener(function listener(tabId_, changed, tab) { + if (tabId == tabId_ && changed.status == "complete") { + browser.tabs.onUpdated.removeListener(listener); + resolve(); + } + }); + }); + } + + chrome.tabs.onRemoved.addListener((tabId, info) => { + browser.test.log("Make sure the removed tab is not available in the tabs.query callback."); + chrome.tabs.query({}, tabs => { + for (let tab of tabs) { + browser.test.assertTrue(tab.id != tabId, "Tab query should not include removed tabId"); + } + browser.test.notifyPass("tabs-events"); + }); + }); + + try { + let url = "http://example.com/browser/browser/components/extensions/test/browser/context.html"; + let tab = await browser.tabs.create({url: url}); + await awaitLoad(tab.id); + + await browser.tabs.remove(tab.id); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("tabs-events"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs-events"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_executeScript.js b/browser/components/extensions/test/browser/browser_ext_tabs_executeScript.js new file mode 100644 index 000000000..5a15f2e39 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_executeScript.js @@ -0,0 +1,234 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testExecuteScript() { + let {MessageChannel} = Cu.import("resource://gre/modules/MessageChannel.jsm", {}); + + function countMM(messageManagerMap) { + let count = 0; + // List of permanent message managers in the main process. We should not + // count them in the test because MessageChannel unsubscribes when the + // message manager closes, which never happens to these, of course. + let globalMMs = [ + Services.mm, + Services.ppmm, + Services.ppmm.getChildAt(0), + ]; + for (let mm of messageManagerMap.keys()) { + // Sanity check: mm is a message manager. + try { + mm.QueryInterface(Ci.nsIMessageSender); + } catch (e) { + mm.QueryInterface(Ci.nsIMessageBroadcaster); + } + if (!globalMMs.includes(mm)) { + ++count; + } + } + return count; + } + + let messageManagersSize = countMM(MessageChannel.messageManagers); + let responseManagersSize = countMM(MessageChannel.responseManagers); + + const BASE = "http://mochi.test:8888/browser/browser/components/extensions/test/browser/"; + const URL = BASE + "file_iframe_document.html"; + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, URL, true); + + async function background() { + try { + let [tab] = await browser.tabs.query({active: true, currentWindow: true}); + let frames = await browser.webNavigation.getAllFrames({tabId: tab.id}); + + browser.test.log(`FRAMES: ${frames[1].frameId} ${JSON.stringify(frames)}\n`); + await Promise.all([ + browser.tabs.executeScript({ + code: "42", + }).then(result => { + browser.test.assertEq(1, result.length, "Expected one callback result"); + browser.test.assertEq(42, result[0], "Expected callback result"); + }), + + browser.tabs.executeScript({ + file: "script.js", + code: "42", + }).then(result => { + browser.test.fail("Expected not to be able to execute a script with both file and code"); + }, error => { + browser.test.assertTrue(/a 'code' or a 'file' property, but not both/.test(error.message), + "Got expected error"); + }), + + browser.tabs.executeScript({ + file: "script.js", + }).then(result => { + browser.test.assertEq(1, result.length, "Expected one callback result"); + browser.test.assertEq(undefined, result[0], "Expected callback result"); + }), + + browser.tabs.executeScript({ + file: "script2.js", + }).then(result => { + browser.test.assertEq(1, result.length, "Expected one callback result"); + browser.test.assertEq(27, result[0], "Expected callback result"); + }), + + browser.tabs.executeScript({ + code: "location.href;", + allFrames: true, + }).then(result => { + browser.test.assertTrue(Array.isArray(result), "Result is an array"); + + browser.test.assertEq(2, result.length, "Result has correct length"); + + browser.test.assertTrue(/\/file_iframe_document\.html$/.test(result[0]), "First result is correct"); + browser.test.assertEq("http://mochi.test:8888/", result[1], "Second result is correct"); + }), + + browser.tabs.executeScript({ + code: "location.href;", + runAt: "document_end", + }).then(result => { + browser.test.assertEq(1, result.length, "Expected callback result"); + browser.test.assertEq("string", typeof result[0], "Result is a string"); + + browser.test.assertTrue(/\/file_iframe_document\.html$/.test(result[0]), "Result is correct"); + }), + + browser.tabs.executeScript({ + code: "window", + }).then(result => { + browser.test.fail("Expected error when returning non-structured-clonable object"); + }, error => { + browser.test.assertEq("Script returned non-structured-clonable data", + error.message, "Got expected error"); + }), + + browser.tabs.executeScript({ + code: "Promise.resolve(window)", + }).then(result => { + browser.test.fail("Expected error when returning non-structured-clonable object"); + }, error => { + browser.test.assertEq("Script returned non-structured-clonable data", + error.message, "Got expected error"); + }), + + browser.tabs.executeScript({ + frameId: Number.MAX_SAFE_INTEGER, + code: "42", + }).then(result => { + browser.test.fail("Expected error when specifying invalid frame ID"); + }, error => { + let details = { + frame_id: Number.MAX_SAFE_INTEGER, + matchesHost: ["http://mochi.test/", "http://example.com/"], + }; + browser.test.assertEq(`No window matching ${JSON.stringify(details)}`, + error.message, "Got expected error"); + }), + + browser.tabs.create({url: "http://example.net/", active: false}).then(async tab => { + await browser.tabs.executeScript(tab.id, { + code: "42", + }).then(result => { + browser.test.fail("Expected error when trying to execute on invalid domain"); + }, error => { + let details = { + matchesHost: ["http://mochi.test/", "http://example.com/"], + }; + browser.test.assertEq(`No window matching ${JSON.stringify(details)}`, + error.message, "Got expected error"); + }); + + await browser.tabs.remove(tab.id); + }), + + browser.tabs.executeScript({ + code: "Promise.resolve(42)", + }).then(result => { + browser.test.assertEq(42, result[0], "Got expected promise resolution value as result"); + }), + + browser.tabs.executeScript({ + code: "location.href;", + runAt: "document_end", + allFrames: true, + }).then(result => { + browser.test.assertTrue(Array.isArray(result), "Result is an array"); + + browser.test.assertEq(2, result.length, "Result has correct length"); + + browser.test.assertTrue(/\/file_iframe_document\.html$/.test(result[0]), "First result is correct"); + browser.test.assertEq("http://mochi.test:8888/", result[1], "Second result is correct"); + }), + + browser.tabs.executeScript({ + code: "location.href;", + frameId: frames[0].frameId, + }).then(result => { + browser.test.assertEq(1, result.length, "Expected one result"); + browser.test.assertTrue(/\/file_iframe_document\.html$/.test(result[0]), `Result for frameId[0] is correct: ${result[0]}`); + }), + + browser.tabs.executeScript({ + code: "location.href;", + frameId: frames[1].frameId, + }).then(result => { + browser.test.assertEq(1, result.length, "Expected one result"); + browser.test.assertEq("http://mochi.test:8888/", result[0], "Result for frameId[1] is correct"); + }), + + browser.tabs.create({url: "http://example.com/"}).then(async tab => { + let result = await browser.tabs.executeScript(tab.id, {code: "location.href"}); + + browser.test.assertEq("http://example.com/", result[0], "Script executed correctly in new tab"); + + await browser.tabs.remove(tab.id); + }), + + new Promise(resolve => { + browser.runtime.onMessage.addListener(message => { + browser.test.assertEq("script ran", message, "Expected runtime message"); + resolve(); + }); + }), + ]); + + browser.test.notifyPass("executeScript"); + } catch (e) { + browser.test.fail(`Error: ${e} :: ${e.stack}`); + browser.test.notifyFail("executeScript"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["http://mochi.test/", "http://example.com/", "webNavigation"], + }, + + background, + + files: { + "script.js": function() { + browser.runtime.sendMessage("script ran"); + }, + + "script2.js": "27", + }, + }); + + yield extension.startup(); + + yield extension.awaitFinish("executeScript"); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); + + // Make sure that we're not holding on to references to closed message + // managers. + is(countMM(MessageChannel.messageManagers), messageManagersSize, "Message manager count"); + is(countMM(MessageChannel.responseManagers), responseManagersSize, "Response manager count"); + is(MessageChannel.pendingResponses.size, 0, "Pending response count"); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_bad.js b/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_bad.js new file mode 100644 index 000000000..d11354ead --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_bad.js @@ -0,0 +1,217 @@ +"use strict"; + +// This is a pretty terrible hack, but it's the best we can do until we +// support |executeScript| callbacks and |lastError|. +function* testHasNoPermission(params) { + let contentSetup = params.contentSetup || (() => Promise.resolve()); + + async function background(contentSetup) { + browser.runtime.onMessage.addListener((msg, sender) => { + browser.test.assertEq(msg, "second script ran", "second script ran"); + browser.test.notifyPass("executeScript"); + }); + + browser.test.onMessage.addListener(msg => { + browser.test.assertEq(msg, "execute-script"); + + browser.tabs.query({currentWindow: true}, tabs => { + browser.tabs.executeScript({ + file: "script.js", + }); + + // Execute a script we know we have permissions for in the + // second tab, in the hopes that it will execute after the + // first one. This has intermittent failure written all over + // it, but it's just about the best we can do until we + // support callbacks for executeScript. + browser.tabs.executeScript(tabs[1].id, { + file: "second-script.js", + }); + }); + }); + + await contentSetup(); + + browser.test.sendMessage("ready"); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: params.manifest, + + background: `(${background})(${contentSetup})`, + + files: { + "script.js": function() { + browser.runtime.sendMessage("first script ran"); + }, + + "second-script.js": function() { + browser.runtime.sendMessage("second script ran"); + }, + }, + }); + + yield extension.startup(); + yield extension.awaitMessage("ready"); + + if (params.setup) { + yield params.setup(extension); + } + + extension.sendMessage("execute-script"); + + yield extension.awaitFinish("executeScript"); + yield extension.unload(); +} + +add_task(function* testBadPermissions() { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com/"); + let tab2 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://mochi.test:8888/"); + + info("Test no special permissions"); + yield testHasNoPermission({ + manifest: {"permissions": ["http://example.com/"]}, + }); + + info("Test tabs permissions"); + yield testHasNoPermission({ + manifest: {"permissions": ["http://example.com/", "tabs"]}, + }); + + info("Test no special permissions, commands, key press"); + yield testHasNoPermission({ + manifest: { + "permissions": ["http://example.com/"], + "commands": { + "test-tabs-executeScript": { + "suggested_key": { + "default": "Alt+Shift+K", + }, + }, + }, + }, + contentSetup() { + browser.commands.onCommand.addListener(function(command) { + if (command == "test-tabs-executeScript") { + browser.test.sendMessage("tabs-command-key-pressed"); + } + }); + return Promise.resolve(); + }, + setup: function* (extension) { + yield EventUtils.synthesizeKey("k", {altKey: true, shiftKey: true}); + yield extension.awaitMessage("tabs-command-key-pressed"); + }, + }); + + info("Test active tab, commands, no key press"); + yield testHasNoPermission({ + manifest: { + "permissions": ["http://example.com/", "activeTab"], + "commands": { + "test-tabs-executeScript": { + "suggested_key": { + "default": "Alt+Shift+K", + }, + }, + }, + }, + }); + + info("Test active tab, browser action, no click"); + yield testHasNoPermission({ + manifest: { + "permissions": ["http://example.com/", "activeTab"], + "browser_action": {}, + }, + }); + + info("Test active tab, page action, no click"); + yield testHasNoPermission({ + manifest: { + "permissions": ["http://example.com/", "activeTab"], + "page_action": {}, + }, + async contentSetup() { + let [tab] = await browser.tabs.query({active: true, currentWindow: true}); + await browser.pageAction.show(tab.id); + }, + }); + + yield BrowserTestUtils.removeTab(tab2); + yield BrowserTestUtils.removeTab(tab1); +}); + +add_task(function* testBadURL() { + async function background() { + let promises = [ + new Promise(resolve => { + browser.tabs.executeScript({ + file: "http://example.com/script.js", + }, result => { + browser.test.assertEq(undefined, result, "Result value"); + + browser.test.assertTrue(browser.extension.lastError instanceof Error, + "runtime.lastError is Error"); + + browser.test.assertTrue(browser.runtime.lastError instanceof Error, + "runtime.lastError is Error"); + + browser.test.assertEq( + "Files to be injected must be within the extension", + browser.extension.lastError && browser.extension.lastError.message, + "extension.lastError value"); + + browser.test.assertEq( + "Files to be injected must be within the extension", + browser.runtime.lastError && browser.runtime.lastError.message, + "runtime.lastError value"); + + resolve(); + }); + }), + + browser.tabs.executeScript({ + file: "http://example.com/script.js", + }).catch(error => { + browser.test.assertTrue(error instanceof Error, "Error is Error"); + + browser.test.assertEq(null, browser.extension.lastError, + "extension.lastError value"); + + browser.test.assertEq(null, browser.runtime.lastError, + "runtime.lastError value"); + + browser.test.assertEq( + "Files to be injected must be within the extension", + error && error.message, + "error value"); + }), + ]; + + await Promise.all(promises); + + browser.test.notifyPass("executeScript-lastError"); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["<all_urls>"], + }, + + background, + }); + + yield extension.startup(); + + yield extension.awaitFinish("executeScript-lastError"); + + yield extension.unload(); +}); + +// TODO: Test that |executeScript| fails if the tab has navigated to a +// new page, and no longer matches our expected state. This involves +// intentionally trying to trigger a race condition, and is probably not +// even worth attempting until we have proper |executeScript| callbacks. + +add_task(forceGC); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_good.js b/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_good.js new file mode 100644 index 000000000..cf4721310 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_good.js @@ -0,0 +1,189 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +requestLongerTimeout(2); + +function* testHasPermission(params) { + let contentSetup = params.contentSetup || (() => Promise.resolve()); + + async function background(contentSetup) { + browser.runtime.onMessage.addListener((msg, sender) => { + browser.test.assertEq(msg, "script ran", "script ran"); + browser.test.notifyPass("executeScript"); + }); + + browser.test.onMessage.addListener(msg => { + browser.test.assertEq(msg, "execute-script"); + + browser.tabs.executeScript({ + file: "script.js", + }); + }); + + await contentSetup(); + + browser.test.sendMessage("ready"); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: params.manifest, + + background: `(${background})(${contentSetup})`, + + files: { + "script.js": function() { + browser.runtime.sendMessage("script ran"); + }, + }, + }); + + yield extension.startup(); + yield extension.awaitMessage("ready"); + + if (params.setup) { + yield params.setup(extension); + } + + extension.sendMessage("execute-script"); + + yield extension.awaitFinish("executeScript"); + + if (params.tearDown) { + yield params.tearDown(extension); + } + + yield extension.unload(); +} + +add_task(function* testGoodPermissions() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://mochi.test:8888/", true); + + info("Test explicit host permission"); + yield testHasPermission({ + manifest: {"permissions": ["http://mochi.test/"]}, + }); + + info("Test explicit host subdomain permission"); + yield testHasPermission({ + manifest: {"permissions": ["http://*.mochi.test/"]}, + }); + + info("Test explicit <all_urls> permission"); + yield testHasPermission({ + manifest: {"permissions": ["<all_urls>"]}, + }); + + info("Test activeTab permission with a command key press"); + yield testHasPermission({ + manifest: { + "permissions": ["activeTab"], + "commands": { + "test-tabs-executeScript": { + "suggested_key": { + "default": "Alt+Shift+K", + }, + }, + }, + }, + contentSetup() { + browser.commands.onCommand.addListener(function(command) { + if (command == "test-tabs-executeScript") { + browser.test.sendMessage("tabs-command-key-pressed"); + } + }); + return Promise.resolve(); + }, + setup: function* (extension) { + yield EventUtils.synthesizeKey("k", {altKey: true, shiftKey: true}); + yield extension.awaitMessage("tabs-command-key-pressed"); + }, + }); + + info("Test activeTab permission with a browser action click"); + yield testHasPermission({ + manifest: { + "permissions": ["activeTab"], + "browser_action": {}, + }, + contentSetup() { + browser.browserAction.onClicked.addListener(() => { + browser.test.log("Clicked."); + }); + return Promise.resolve(); + }, + setup: clickBrowserAction, + tearDown: closeBrowserAction, + }); + + info("Test activeTab permission with a page action click"); + yield testHasPermission({ + manifest: { + "permissions": ["activeTab"], + "page_action": {}, + }, + contentSetup: async () => { + let [tab] = await browser.tabs.query({active: true, currentWindow: true}); + await browser.pageAction.show(tab.id); + }, + setup: clickPageAction, + tearDown: closePageAction, + }); + + info("Test activeTab permission with a browser action w/popup click"); + yield testHasPermission({ + manifest: { + "permissions": ["activeTab"], + "browser_action": {"default_popup": "_blank.html"}, + }, + setup: async extension => { + await clickBrowserAction(extension); + return awaitExtensionPanel(extension, window, "_blank.html"); + }, + tearDown: closeBrowserAction, + }); + + info("Test activeTab permission with a page action w/popup click"); + yield testHasPermission({ + manifest: { + "permissions": ["activeTab"], + "page_action": {"default_popup": "_blank.html"}, + }, + contentSetup: async () => { + let [tab] = await browser.tabs.query({active: true, currentWindow: true}); + await browser.pageAction.show(tab.id); + }, + setup: clickPageAction, + tearDown: closePageAction, + }); + + info("Test activeTab permission with a context menu click"); + yield testHasPermission({ + manifest: { + "permissions": ["activeTab", "contextMenus"], + }, + contentSetup() { + browser.contextMenus.create({title: "activeTab", contexts: ["all"]}); + return Promise.resolve(); + }, + setup: function* (extension) { + let contextMenu = document.getElementById("contentAreaContextMenu"); + let awaitPopupShown = BrowserTestUtils.waitForEvent(contextMenu, "popupshown"); + let awaitPopupHidden = BrowserTestUtils.waitForEvent(contextMenu, "popuphidden"); + + yield BrowserTestUtils.synthesizeMouseAtCenter("a[href]", {type: "contextmenu", button: 2}, + gBrowser.selectedBrowser); + yield awaitPopupShown; + + let item = contextMenu.querySelector("[label=activeTab]"); + + yield EventUtils.synthesizeMouseAtCenter(item, {}, window); + + yield awaitPopupHidden; + }, + }); + + yield BrowserTestUtils.removeTab(tab); +}); + +add_task(forceGC); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_no_create.js b/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_no_create.js new file mode 100644 index 000000000..7b2ffe175 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_no_create.js @@ -0,0 +1,67 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testExecuteScriptAtOnUpdated() { + const BASE = "http://mochi.test:8888/browser/browser/components/extensions/test/browser/"; + const URL = BASE + "file_iframe_document.html"; + // This is a regression test for bug 1325830. + // The bug (executeScript not completing any more) occurred when executeScript + // was called early at the onUpdated event, unless the tabs.create method is + // called. So this test does not use tabs.create to open new tabs. + // Note that if this test is run together with other tests that do call + // tabs.create, then this test case does not properly test the conditions of + // the regression any more. To verify that the regression has been resolved, + // this test must be run in isolation. + + function background() { + // Using variables to prevent listeners from running more than once, instead + // of removing the listener. This is to minimize any IPC, since the bug that + // is being tested is sensitive to timing. + let ignore = false; + let url; + browser.tabs.onUpdated.addListener((tabId, changeInfo, tab) => { + if (changeInfo.status === "loading" && tab.url === url && !ignore) { + ignore = true; + browser.tabs.executeScript(tabId, { + code: "document.URL", + }).then(results => { + browser.test.assertEq(url, results[0], "Content script should run"); + browser.test.notifyPass("executeScript-at-onUpdated"); + }, error => { + browser.test.fail(`Unexpected error: ${error} :: ${error.stack}`); + browser.test.notifyFail("executeScript-at-onUpdated"); + }); + // (running this log call after executeScript to minimize IPC between + // onUpdated and executeScript.) + browser.test.log(`Found expected navigation to ${url}`); + } else { + // The bug occurs when executeScript is called before a tab is + // initialized. + browser.tabs.executeScript(tabId, {code: ""}); + } + }); + browser.test.onMessage.addListener(testUrl => { + url = testUrl; + browser.test.sendMessage("open-test-tab"); + }); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["http://mochi.test/", "tabs"], + }, + background, + }); + + yield extension.startup(); + extension.sendMessage(URL); + yield extension.awaitMessage("open-test-tab"); + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, URL, true); + + yield extension.awaitFinish("executeScript-at-onUpdated"); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_runAt.js b/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_runAt.js new file mode 100644 index 000000000..a4c0ed6f1 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_executeScript_runAt.js @@ -0,0 +1,107 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +/** + * These tests ensure that the runAt argument to tabs.executeScript delays + * script execution until the document has reached the correct state. + * + * Since tests of this nature are especially race-prone, it relies on a + * server-JS script to delay the completion of our test page's load cycle long + * enough for us to attempt to load our scripts in the earlies phase we support. + * + * And since we can't actually rely on that timing, it retries any attempts that + * fail to load as early as expected, but don't load at any illegal time. + */ + +add_task(function* testExecuteScript() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank", true); + + async function background() { + let tab; + + const BASE = "http://mochi.test:8888/browser/browser/components/extensions/test/browser/"; + const URL = BASE + "file_iframe_document.sjs"; + + const MAX_TRIES = 10; + + try { + [tab] = await browser.tabs.query({active: true, currentWindow: true}); + + let success = false; + for (let tries = 0; !success && tries < MAX_TRIES; tries++) { + let url = `${URL}?r=${Math.random()}`; + + let loadingPromise = new Promise(resolve => { + browser.tabs.onUpdated.addListener(function listener(tabId, changed, tab_) { + if (tabId == tab.id && changed.status == "loading" && tab_.url == url) { + browser.tabs.onUpdated.removeListener(listener); + resolve(); + } + }); + }); + + // TODO: Test allFrames and frameId. + + await browser.tabs.update({url}); + await loadingPromise; + + let states = await Promise.all([ + // Send the executeScript requests in the reverse order that we expect + // them to execute in, to avoid them passing only because of timing + // races. + browser.tabs.executeScript({ + code: "document.readyState", + runAt: "document_idle", + }), + browser.tabs.executeScript({ + code: "document.readyState", + runAt: "document_end", + }), + browser.tabs.executeScript({ + code: "document.readyState", + runAt: "document_start", + }), + ].reverse()); + + browser.test.log(`Got states: ${states}`); + + // Make sure that none of our scripts executed earlier than expected, + // regardless of retries. + browser.test.assertTrue(states[1] == "interactive" || states[1] == "complete", + `document_end state is valid: ${states[1]}`); + browser.test.assertTrue(states[2] == "complete", + `document_idle state is valid: ${states[2]}`); + + // If we have the earliest valid states for each script, we're done. + // Otherwise, try again. + success = (states[0] == "loading" && + states[1] == "interactive" && + states[2] == "complete"); + } + + browser.test.assertTrue(success, "Got the earliest expected states at least once"); + + browser.test.notifyPass("executeScript-runAt"); + } catch (e) { + browser.test.fail(`Error: ${e} :: ${e.stack}`); + browser.test.notifyFail("executeScript-runAt"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["http://mochi.test/", "tabs"], + }, + + background, + }); + + yield extension.startup(); + + yield extension.awaitFinish("executeScript-runAt"); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_getCurrent.js b/browser/components/extensions/test/browser/browser_ext_tabs_getCurrent.js new file mode 100644 index 000000000..b67d935cb --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_getCurrent.js @@ -0,0 +1,70 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + + "browser_action": {"default_popup": "popup.html"}, + }, + + files: { + "tab.js": function() { + let url = document.location.href; + + browser.tabs.getCurrent(currentTab => { + browser.test.assertEq(currentTab.url, url, "getCurrent in non-active background tab"); + + // Activate the tab. + browser.tabs.onActivated.addListener(function listener({tabId}) { + if (tabId == currentTab.id) { + browser.tabs.onActivated.removeListener(listener); + + browser.tabs.getCurrent(currentTab => { + browser.test.assertEq(currentTab.id, tabId, "in active background tab"); + browser.test.assertEq(currentTab.url, url, "getCurrent in non-active background tab"); + + browser.test.sendMessage("tab-finished"); + }); + } + }); + browser.tabs.update(currentTab.id, {active: true}); + }); + }, + + "popup.js": function() { + browser.tabs.getCurrent(tab => { + browser.test.assertEq(tab, undefined, "getCurrent in popup script"); + browser.test.sendMessage("popup-finished"); + }); + }, + + "tab.html": `<head><meta charset="utf-8"><script src="tab.js"></script></head>`, + "popup.html": `<head><meta charset="utf-8"><script src="popup.js"></script></head>`, + }, + + background: function() { + browser.tabs.getCurrent(tab => { + browser.test.assertEq(tab, undefined, "getCurrent in background script"); + browser.test.sendMessage("background-finished"); + }); + + browser.tabs.create({url: "tab.html", active: false}); + }, + }); + + yield extension.startup(); + + yield extension.awaitMessage("background-finished"); + yield extension.awaitMessage("tab-finished"); + + clickBrowserAction(extension); + yield awaitExtensionPanel(extension); + yield extension.awaitMessage("popup-finished"); + yield closeBrowserAction(extension); + + // The extension tab is automatically closed when the extension unloads. + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_insertCSS.js b/browser/components/extensions/test/browser/browser_ext_tabs_insertCSS.js new file mode 100644 index 000000000..a8e172d94 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_insertCSS.js @@ -0,0 +1,86 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testExecuteScript() { + let {MessageChannel} = Cu.import("resource://gre/modules/MessageChannel.jsm", {}); + + let messageManagersSize = MessageChannel.messageManagers.size; + let responseManagersSize = MessageChannel.responseManagers.size; + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://mochi.test:8888/", true); + + async function background() { + let tasks = [ + { + background: "transparent", + foreground: "rgb(0, 113, 4)", + promise: () => { + return browser.tabs.insertCSS({ + file: "file2.css", + }); + }, + }, + { + background: "rgb(42, 42, 42)", + foreground: "rgb(0, 113, 4)", + promise: () => { + return browser.tabs.insertCSS({ + code: "* { background: rgb(42, 42, 42) }", + }); + }, + }, + ]; + + function checkCSS() { + let computedStyle = window.getComputedStyle(document.body); + return [computedStyle.backgroundColor, computedStyle.color]; + } + + try { + for (let {promise, background, foreground} of tasks) { + let result = await promise(); + + browser.test.assertEq(undefined, result, "Expected callback result"); + + [result] = await browser.tabs.executeScript({ + code: `(${checkCSS})()`, + }); + + browser.test.assertEq(background, result[0], "Expected background color"); + browser.test.assertEq(foreground, result[1], "Expected foreground color"); + } + + browser.test.notifyPass("insertCSS"); + } catch (e) { + browser.test.fail(`Error: ${e} :: ${e.stack}`); + browser.test.notifyFailure("insertCSS"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["http://mochi.test/"], + }, + + background, + + files: { + "file2.css": "* { color: rgb(0, 113, 4) }", + }, + }); + + yield extension.startup(); + + yield extension.awaitFinish("insertCSS"); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); + + // Make sure that we're not holding on to references to closed message + // managers. + is(MessageChannel.messageManagers.size, messageManagersSize, "Message manager count"); + is(MessageChannel.responseManagers.size, responseManagersSize, "Response manager count"); + is(MessageChannel.pendingResponses.size, 0, "Pending response count"); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_move.js b/browser/components/extensions/test/browser/browser_ext_tabs_move.js new file mode 100644 index 000000000..917cdc146 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_move.js @@ -0,0 +1,103 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:robots"); + let tab2 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:config"); + + gBrowser.selectedTab = tab1; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: async function() { + let [tab] = await browser.tabs.query({lastFocusedWindow: true}); + + browser.tabs.move(tab.id, {index: 0}); + let tabs = await browser.tabs.query({lastFocusedWindow: true}); + + browser.test.assertEq(tabs[0].url, tab.url, "should be first tab"); + browser.test.notifyPass("tabs.move.single"); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.move.single"); + yield extension.unload(); + + extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: async function() { + let tabs = await browser.tabs.query({lastFocusedWindow: true}); + + tabs.sort(function(a, b) { return a.url > b.url; }); + + browser.tabs.move(tabs.map(tab => tab.id), {index: 0}); + + tabs = await browser.tabs.query({lastFocusedWindow: true}); + + browser.test.assertEq(tabs[0].url, "about:blank", "should be first tab"); + browser.test.assertEq(tabs[1].url, "about:config", "should be second tab"); + browser.test.assertEq(tabs[2].url, "about:robots", "should be third tab"); + + browser.test.notifyPass("tabs.move.multiple"); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.move.multiple"); + yield extension.unload(); + + extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + async background() { + let [, tab] = await browser.tabs.query({lastFocusedWindow: true}); + + // Assuming that tab.id of 12345 does not exist. + await browser.test.assertRejects( + browser.tabs.move([tab.id, 12345], {index: 0}), + /Invalid tab/, + "Should receive invalid tab error"); + + let tabs = await browser.tabs.query({lastFocusedWindow: true}); + browser.test.assertEq(tabs[1].url, tab.url, "should be second tab"); + browser.test.notifyPass("tabs.move.invalid"); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.move.invalid"); + yield extension.unload(); + + extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: async function() { + let [tab] = await browser.tabs.query({lastFocusedWindow: true}); + browser.tabs.move(tab.id, {index: -1}); + + let tabs = await browser.tabs.query({lastFocusedWindow: true}); + + browser.test.assertEq(tabs[2].url, tab.url, "should be last tab"); + browser.test.notifyPass("tabs.move.last"); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.move.last"); + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab1); + yield BrowserTestUtils.removeTab(tab2); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_move_window.js b/browser/components/extensions/test/browser/browser_ext_tabs_move_window.js new file mode 100644 index 000000000..f3bce364a --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_move_window.js @@ -0,0 +1,98 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.net/"); + let window1 = yield BrowserTestUtils.openNewBrowserWindow(); + yield BrowserTestUtils.openNewForegroundTab(window1.gBrowser, "http://example.com/"); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + async background() { + let tabs = await browser.tabs.query({url: "<all_urls>"}); + let destination = tabs[0]; + let source = tabs[1]; // skip over about:blank in window1 + + // Assuming that this windowId does not exist. + await browser.test.assertRejects( + browser.tabs.move(source.id, {windowId: 123144576, index: 0}), + /Invalid window/, + "Should receive invalid window error"); + + browser.tabs.move(source.id, {windowId: destination.windowId, index: 0}); + + tabs = await browser.tabs.query({url: "<all_urls>"}); + browser.test.assertEq(tabs[0].url, "http://example.com/"); + browser.test.assertEq(tabs[0].windowId, destination.windowId); + browser.test.notifyPass("tabs.move.window"); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.move.window"); + yield extension.unload(); + + for (let tab of window.gBrowser.tabs) { + yield BrowserTestUtils.removeTab(tab); + } + yield BrowserTestUtils.closeWindow(window1); +}); + +add_task(function* test_currentWindowAfterTabMoved() { + const files = { + "current.html": "<meta charset=utf-8><script src=current.js></script>", + "current.js": function() { + browser.test.onMessage.addListener(msg => { + if (msg === "current") { + browser.windows.getCurrent(win => { + browser.test.sendMessage("id", win.id); + }); + } + }); + browser.test.sendMessage("ready"); + }, + }; + + async function background() { + let tabId; + + const url = browser.extension.getURL("current.html"); + + browser.test.onMessage.addListener(async msg => { + if (msg === "move") { + await browser.windows.create({tabId}); + browser.test.sendMessage("moved"); + } else if (msg === "close") { + await browser.tabs.remove(tabId); + browser.test.sendMessage("done"); + } + }); + + let tab = await browser.tabs.create({url}); + tabId = tab.id; + } + + const extension = ExtensionTestUtils.loadExtension({files, background}); + + yield extension.startup(); + yield extension.awaitMessage("ready"); + + extension.sendMessage("current"); + const first = yield extension.awaitMessage("id"); + + extension.sendMessage("move"); + yield extension.awaitMessage("moved"); + + extension.sendMessage("current"); + const second = yield extension.awaitMessage("id"); + + isnot(first, second, "current window id is different after moving the tab"); + + extension.sendMessage("close"); + yield extension.awaitMessage("done"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_move_window_multiple.js b/browser/components/extensions/test/browser/browser_ext_tabs_move_window_multiple.js new file mode 100644 index 000000000..dacd547f2 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_move_window_multiple.js @@ -0,0 +1,43 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let window1 = yield BrowserTestUtils.openNewBrowserWindow(); + yield BrowserTestUtils.openNewForegroundTab(window.gBrowser, "http://example.net/"); + yield BrowserTestUtils.openNewForegroundTab(window.gBrowser, "http://example.com/"); + yield BrowserTestUtils.openNewForegroundTab(window1.gBrowser, "http://example.net/"); + yield BrowserTestUtils.openNewForegroundTab(window1.gBrowser, "http://example.com/"); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.tabs.query( + {url: "<all_urls>"}, + tabs => { + let move1 = tabs[1]; + let move3 = tabs[3]; + browser.tabs.move([move1.id, move3.id], {index: 0}); + browser.tabs.query( + {url: "<all_urls>"}, + tabs => { + browser.test.assertEq(tabs[0].url, move1.url); + browser.test.assertEq(tabs[2].url, move3.url); + browser.test.notifyPass("tabs.move.multiple"); + }); + }); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.move.multiple"); + yield extension.unload(); + + for (let tab of window.gBrowser.tabs) { + yield BrowserTestUtils.removeTab(tab); + } + yield BrowserTestUtils.closeWindow(window1); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_move_window_pinned.js b/browser/components/extensions/test/browser/browser_ext_tabs_move_window_pinned.js new file mode 100644 index 000000000..c592dc56d --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_move_window_pinned.js @@ -0,0 +1,42 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.net/"); + let window1 = yield BrowserTestUtils.openNewBrowserWindow(); + let tab1 = yield BrowserTestUtils.openNewForegroundTab(window1.gBrowser, "http://example.com/"); + window1.gBrowser.pinTab(tab1); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.tabs.query( + {url: "<all_urls>"}, + tabs => { + let destination = tabs[0]; + let source = tabs[1]; // remember, pinning moves it to the left. + browser.tabs.move(source.id, {windowId: destination.windowId, index: 0}); + + browser.tabs.query( + {url: "<all_urls>"}, + tabs => { + browser.test.assertEq(true, tabs[0].pinned); + browser.test.notifyPass("tabs.move.pin"); + }); + }); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.move.pin"); + yield extension.unload(); + + for (let tab of window.gBrowser.tabs) { + yield BrowserTestUtils.removeTab(tab); + } + yield BrowserTestUtils.closeWindow(window1); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_onHighlighted.js b/browser/components/extensions/test/browser/browser_ext_tabs_onHighlighted.js new file mode 100644 index 000000000..9cc2554d6 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_onHighlighted.js @@ -0,0 +1,126 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testTabEvents() { + async function background() { + /** The list of active tab ID's */ + let tabIds = []; + + /** + * Stores the events that fire for each tab. + * + * events { + * tabId1: [event1, event2, ...], + * tabId2: [event1, event2, ...], + * } + */ + let events = {}; + + browser.tabs.onActivated.addListener((info) => { + if (info.tabId in events) { + events[info.tabId].push("onActivated"); + } else { + events[info.tabId] = ["onActivated"]; + } + }); + + browser.tabs.onHighlighted.addListener((info) => { + if (info.tabIds[0] in events) { + events[info.tabIds[0]].push("onHighlighted"); + } else { + events[info.tabIds[0]] = ["onHighlighted"]; + } + }); + + /** + * Asserts that the expected events are fired for the tab with id = tabId. + * The events associated to the specified tab are removed after this check is made. + * + * @param {number} tabId + * @param {Array<string>} expectedEvents + */ + async function expectEvents(tabId, expectedEvents) { + browser.test.log(`Expecting events: ${expectedEvents.join(", ")}`); + + await new Promise(resolve => setTimeout(resolve, 0)); + + browser.test.assertEq(expectedEvents.length, events[tabId].length, + `Got expected number of events for ${tabId}`); + + for (let [i, name] of expectedEvents.entries()) { + browser.test.assertEq(name, i in events[tabId] && events[tabId][i], + `Got expected ${name} event`); + } + delete events[tabId]; + } + + /** + * Opens a new tab and asserts that the correct events are fired. + * + * @param {number} windowId + */ + async function openTab(windowId) { + let tab = await browser.tabs.create({windowId}); + + tabIds.push(tab.id); + browser.test.log(`Opened tab ${tab.id}`); + + await expectEvents(tab.id, [ + "onActivated", + "onHighlighted", + ]); + } + + /** + * Highlights an existing tab and asserts that the correct events are fired. + * + * @param {number} tabId + */ + async function highlightTab(tabId) { + browser.test.log(`Highlighting tab ${tabId}`); + let tab = await browser.tabs.update(tabId, {active: true}); + + browser.test.assertEq(tab.id, tabId, `Tab ${tab.id} highlighted`); + + await expectEvents(tab.id, [ + "onActivated", + "onHighlighted", + ]); + } + + /** + * The main entry point to the tests. + */ + let tabs = await browser.tabs.query({active: true, currentWindow: true}); + + let activeWindow = tabs[0].windowId; + await Promise.all([ + openTab(activeWindow), + openTab(activeWindow), + openTab(activeWindow), + ]); + + await Promise.all([ + highlightTab(tabIds[0]), + highlightTab(tabIds[1]), + highlightTab(tabIds[2]), + ]); + + await Promise.all(tabIds.map(id => browser.tabs.remove(id))); + + browser.test.notifyPass("tabs.highlight"); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.highlight"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_onUpdated.js b/browser/components/extensions/test/browser/browser_ext_tabs_onUpdated.js new file mode 100644 index 000000000..2c26bbd16 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_onUpdated.js @@ -0,0 +1,198 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +requestLongerTimeout(2); + +add_task(function* () { + let win1 = yield BrowserTestUtils.openNewBrowserWindow(); + + yield focusWindow(win1); + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + "content_scripts": [{ + "matches": ["http://mochi.test/*/context_tabs_onUpdated_page.html"], + "js": ["content-script.js"], + "run_at": "document_start", + }], + }, + + background: function() { + let pageURL = "http://mochi.test:8888/browser/browser/components/extensions/test/browser/context_tabs_onUpdated_page.html"; + + let expectedSequence = [ + {status: "loading"}, + {status: "loading", url: pageURL}, + {status: "complete"}, + ]; + let collectedSequence = []; + + browser.tabs.onUpdated.addListener(function(tabId, updatedInfo) { + // onUpdated also fires with updatedInfo.faviconUrl, so explicitly + // check for updatedInfo.status before recording the event. + if ("status" in updatedInfo) { + collectedSequence.push(updatedInfo); + } + }); + + browser.runtime.onMessage.addListener(function() { + if (collectedSequence.length !== expectedSequence.length) { + browser.test.assertEq( + JSON.stringify(expectedSequence), + JSON.stringify(collectedSequence), + "got unexpected number of updateInfo data" + ); + } else { + for (let i = 0; i < expectedSequence.length; i++) { + browser.test.assertEq( + expectedSequence[i].status, + collectedSequence[i].status, + "check updatedInfo status" + ); + if (expectedSequence[i].url || collectedSequence[i].url) { + browser.test.assertEq( + expectedSequence[i].url, + collectedSequence[i].url, + "check updatedInfo url" + ); + } + } + } + + browser.test.notifyPass("tabs.onUpdated"); + }); + + browser.tabs.create({url: pageURL}); + }, + files: { + "content-script.js": ` + window.addEventListener("message", function(evt) { + if (evt.data == "frame-updated") { + browser.runtime.sendMessage("load-completed"); + } + }, true); + `, + }, + }); + + yield Promise.all([ + extension.startup(), + extension.awaitFinish("tabs.onUpdated"), + ]); + + yield extension.unload(); + + yield BrowserTestUtils.closeWindow(win1); +}); + +function* do_test_update(background, withPermissions = true) { + let win1 = yield BrowserTestUtils.openNewBrowserWindow(); + + yield focusWindow(win1); + + let manifest = {}; + if (withPermissions) { + manifest.permissions = ["tabs"]; + } + let extension = ExtensionTestUtils.loadExtension({manifest, background}); + + yield Promise.all([ + yield extension.startup(), + yield extension.awaitFinish("finish"), + ]); + + yield extension.unload(); + + yield BrowserTestUtils.closeWindow(win1); +} + +add_task(function* test_pinned() { + yield do_test_update(function background() { + // Create a new tab for testing update. + browser.tabs.create({}, function(tab) { + browser.tabs.onUpdated.addListener(function onUpdated(tabId, changeInfo) { + // Check callback + browser.test.assertEq(tabId, tab.id, "Check tab id"); + browser.test.log("onUpdate: " + JSON.stringify(changeInfo)); + if ("pinned" in changeInfo) { + browser.test.assertTrue(changeInfo.pinned, "Check changeInfo.pinned"); + browser.tabs.onUpdated.removeListener(onUpdated); + // Remove created tab. + browser.tabs.remove(tabId); + browser.test.notifyPass("finish"); + return; + } + }); + browser.tabs.update(tab.id, {pinned: true}); + }); + }); +}); + +add_task(function* test_unpinned() { + yield do_test_update(function background() { + // Create a new tab for testing update. + browser.tabs.create({pinned: true}, function(tab) { + browser.tabs.onUpdated.addListener(function onUpdated(tabId, changeInfo) { + // Check callback + browser.test.assertEq(tabId, tab.id, "Check tab id"); + browser.test.log("onUpdate: " + JSON.stringify(changeInfo)); + if ("pinned" in changeInfo) { + browser.test.assertFalse(changeInfo.pinned, "Check changeInfo.pinned"); + browser.tabs.onUpdated.removeListener(onUpdated); + // Remove created tab. + browser.tabs.remove(tabId); + browser.test.notifyPass("finish"); + return; + } + }); + browser.tabs.update(tab.id, {pinned: false}); + }); + }); +}); + +add_task(function* test_url() { + yield do_test_update(function background() { + // Create a new tab for testing update. + browser.tabs.create({}, function(tab) { + browser.tabs.onUpdated.addListener(function onUpdated(tabId, changeInfo) { + // Check callback + browser.test.assertEq(tabId, tab.id, "Check tab id"); + browser.test.log("onUpdate: " + JSON.stringify(changeInfo)); + if ("url" in changeInfo) { + browser.test.assertEq("about:blank", changeInfo.url, + "Check changeInfo.url"); + browser.tabs.onUpdated.removeListener(onUpdated); + // Remove created tab. + browser.tabs.remove(tabId); + browser.test.notifyPass("finish"); + return; + } + }); + browser.tabs.update(tab.id, {url: "about:blank"}); + }); + }); +}); + +add_task(function* test_without_tabs_permission() { + yield do_test_update(function background() { + browser.tabs.create({url: "about:blank"}, function(tab) { + browser.tabs.onUpdated.addListener(function onUpdated(tabId, changeInfo) { + if (tabId == tab.id) { + browser.test.assertFalse("url" in changeInfo, "url should not be included without tabs permission"); + browser.test.assertFalse("favIconUrl" in changeInfo, "favIconUrl should not be included without tabs permission"); + + if (changeInfo.status == "complete") { + browser.tabs.onUpdated.removeListener(onUpdated); + browser.tabs.remove(tabId); + browser.test.notifyPass("finish"); + } + } + }); + browser.tabs.reload(tab.id); + }); + }, false /* withPermissions */); +}); + +add_task(forceGC); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_query.js b/browser/components/extensions/test/browser/browser_ext_tabs_query.js new file mode 100644 index 000000000..7804d1454 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_query.js @@ -0,0 +1,224 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +requestLongerTimeout(2); + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:robots"); + let tab2 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:config"); + + gBrowser.selectedTab = tab1; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.tabs.query({ + lastFocusedWindow: true, + }, function(tabs) { + browser.test.assertEq(tabs.length, 3, "should have three tabs"); + + tabs.sort((tab1, tab2) => tab1.index - tab2.index); + + browser.test.assertEq(tabs[0].url, "about:blank", "first tab blank"); + tabs.shift(); + + browser.test.assertTrue(tabs[0].active, "tab 0 active"); + browser.test.assertFalse(tabs[1].active, "tab 1 inactive"); + + browser.test.assertFalse(tabs[0].pinned, "tab 0 unpinned"); + browser.test.assertFalse(tabs[1].pinned, "tab 1 unpinned"); + + browser.test.assertEq(tabs[0].url, "about:robots", "tab 0 url correct"); + browser.test.assertEq(tabs[1].url, "about:config", "tab 1 url correct"); + + browser.test.assertEq(tabs[0].status, "complete", "tab 0 status correct"); + browser.test.assertEq(tabs[1].status, "complete", "tab 1 status correct"); + + browser.test.assertEq(tabs[0].title, "Gort! Klaatu barada nikto!", "tab 0 title correct"); + + browser.test.notifyPass("tabs.query"); + }); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.query"); + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab1); + yield BrowserTestUtils.removeTab(tab2); + + tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com/"); + tab2 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.net/"); + let tab3 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://test1.example.org/MochiKit/"); + + // test simple queries + extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.tabs.query({ + url: "<all_urls>", + }, function(tabs) { + browser.test.assertEq(tabs.length, 3, "should have three tabs"); + + tabs.sort((tab1, tab2) => tab1.index - tab2.index); + + browser.test.assertEq(tabs[0].url, "http://example.com/", "tab 0 url correct"); + browser.test.assertEq(tabs[1].url, "http://example.net/", "tab 1 url correct"); + browser.test.assertEq(tabs[2].url, "http://test1.example.org/MochiKit/", "tab 2 url correct"); + + browser.test.notifyPass("tabs.query"); + }); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.query"); + yield extension.unload(); + + // match pattern + extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.tabs.query({ + url: "http://*/MochiKit*", + }, function(tabs) { + browser.test.assertEq(tabs.length, 1, "should have one tab"); + + browser.test.assertEq(tabs[0].url, "http://test1.example.org/MochiKit/", "tab 0 url correct"); + + browser.test.notifyPass("tabs.query"); + }); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.query"); + yield extension.unload(); + + // match array of patterns + extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.tabs.query({ + url: ["http://*/MochiKit*", "http://*.com/*"], + }, function(tabs) { + browser.test.assertEq(tabs.length, 2, "should have two tabs"); + + tabs.sort((tab1, tab2) => tab1.index - tab2.index); + + browser.test.assertEq(tabs[0].url, "http://example.com/", "tab 0 url correct"); + browser.test.assertEq(tabs[1].url, "http://test1.example.org/MochiKit/", "tab 1 url correct"); + + browser.test.notifyPass("tabs.query"); + }); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.query"); + yield extension.unload(); + + // test width and height + extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.test.onMessage.addListener(async msg => { + let tabs = await browser.tabs.query({active: true}); + + browser.test.assertEq(tabs.length, 1, "should have one tab"); + browser.test.sendMessage("dims", {width: tabs[0].width, height: tabs[0].height}); + }); + browser.test.sendMessage("ready"); + }, + }); + + const RESOLUTION_PREF = "layout.css.devPixelsPerPx"; + registerCleanupFunction(() => { + SpecialPowers.clearUserPref(RESOLUTION_PREF); + }); + + yield Promise.all([extension.startup(), extension.awaitMessage("ready")]); + + for (let resolution of [2, 1]) { + SpecialPowers.setCharPref(RESOLUTION_PREF, String(resolution)); + is(window.devicePixelRatio, resolution, "window has the required resolution"); + + let {clientHeight, clientWidth} = gBrowser.selectedBrowser; + + extension.sendMessage("check-size"); + let dims = yield extension.awaitMessage("dims"); + is(dims.width, clientWidth, "tab reports expected width"); + is(dims.height, clientHeight, "tab reports expected height"); + } + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab1); + yield BrowserTestUtils.removeTab(tab2); + yield BrowserTestUtils.removeTab(tab3); + SpecialPowers.clearUserPref(RESOLUTION_PREF); +}); + +add_task(function* testQueryPermissions() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": [], + }, + + async background() { + try { + let tabs = await browser.tabs.query({currentWindow: true, active: true}); + browser.test.assertEq(tabs.length, 1, "Expect query to return tabs"); + browser.test.notifyPass("queryPermissions"); + } catch (e) { + browser.test.notifyFail("queryPermissions"); + } + }, + }); + + yield extension.startup(); + + yield extension.awaitFinish("queryPermissions"); + + yield extension.unload(); +}); + +add_task(function* testQueryWithURLPermissions() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": [], + }, + + async background() { + await browser.test.assertRejects( + browser.tabs.query({"url": "http://www.bbc.com/"}), + 'The "tabs" permission is required to use the query API with the "url" parameter', + "Expected tabs.query with 'url' to fail with permissions error message"); + + browser.test.notifyPass("queryWithURLPermissions"); + }, + }); + + yield extension.startup(); + + yield extension.awaitFinish("queryWithURLPermissions"); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_reload.js b/browser/components/extensions/test/browser/browser_ext_tabs_reload.js new file mode 100644 index 000000000..99b2d426b --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_reload.js @@ -0,0 +1,54 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + files: { + "tab.js": function() { + browser.runtime.sendMessage("tab-loaded"); + }, + "tab.html": + `<head> + <meta charset="utf-8"> + <script src="tab.js"></script> + </head>`, + }, + + async background() { + let tabLoadedCount = 0; + + let tab = await browser.tabs.create({url: "tab.html", active: true}); + + browser.runtime.onMessage.addListener(msg => { + if (msg == "tab-loaded") { + tabLoadedCount++; + + if (tabLoadedCount == 1) { + // Reload the tab once passing no arguments. + return browser.tabs.reload(); + } + + if (tabLoadedCount == 2) { + // Reload the tab again with explicit arguments. + return browser.tabs.reload(tab.id, { + bypassCache: false, + }); + } + + if (tabLoadedCount == 3) { + browser.test.notifyPass("tabs.reload"); + } + } + }); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.reload"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_reload_bypass_cache.js b/browser/components/extensions/test/browser/browser_ext_tabs_reload_bypass_cache.js new file mode 100644 index 000000000..648361724 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_reload_bypass_cache.js @@ -0,0 +1,58 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs", "<all_urls>"], + }, + + async background() { + const BASE = "http://mochi.test:8888/browser/browser/components/extensions/test/browser/"; + const URL = BASE + "file_bypass_cache.sjs"; + + function awaitLoad(tabId) { + return new Promise(resolve => { + browser.tabs.onUpdated.addListener(function listener(tabId_, changed, tab) { + if (tabId == tabId_ && changed.status == "complete" && tab.url == URL) { + browser.tabs.onUpdated.removeListener(listener); + resolve(); + } + }); + }); + } + + try { + let tab = await browser.tabs.create({url: URL}); + await awaitLoad(tab.id); + + await browser.tabs.reload(tab.id, {bypassCache: false}); + await awaitLoad(tab.id); + + let [textContent] = await browser.tabs.executeScript(tab.id, {code: "document.body.textContent"}); + browser.test.assertEq("", textContent, "`textContent` should be empty when bypassCache=false"); + + await browser.tabs.reload(tab.id, {bypassCache: true}); + await awaitLoad(tab.id); + + [textContent] = await browser.tabs.executeScript(tab.id, {code: "document.body.textContent"}); + + let [pragma, cacheControl] = textContent.split(":"); + browser.test.assertEq("no-cache", pragma, "`pragma` should be set to `no-cache` when bypassCache is true"); + browser.test.assertEq("no-cache", cacheControl, "`cacheControl` should be set to `no-cache` when bypassCache is true"); + + await browser.tabs.remove(tab.id); + + browser.test.notifyPass("tabs.reload_bypass_cache"); + } catch (error) { + browser.test.fail(`${error} :: ${error.stack}`); + browser.test.notifyFail("tabs.reload_bypass_cache"); + } + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("tabs.reload_bypass_cache"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_removeCSS.js b/browser/components/extensions/test/browser/browser_ext_tabs_removeCSS.js new file mode 100644 index 000000000..e0eadab64 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_removeCSS.js @@ -0,0 +1,95 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testExecuteScript() { + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://mochi.test:8888/", true); + + async function background() { + let tasks = [ + // Insert CSS file. + { + background: "transparent", + foreground: "rgb(0, 113, 4)", + promise: () => { + return browser.tabs.insertCSS({ + file: "file2.css", + }); + }, + }, + // Insert CSS code. + { + background: "rgb(42, 42, 42)", + foreground: "rgb(0, 113, 4)", + promise: () => { + return browser.tabs.insertCSS({ + code: "* { background: rgb(42, 42, 42) }", + }); + }, + }, + // Remove CSS code again. + { + background: "transparent", + foreground: "rgb(0, 113, 4)", + promise: () => { + return browser.tabs.removeCSS({ + code: "* { background: rgb(42, 42, 42) }", + }); + }, + }, + // Remove CSS file again. + { + background: "transparent", + foreground: "rgb(0, 0, 0)", + promise: () => { + return browser.tabs.removeCSS({ + file: "file2.css", + }); + }, + }, + ]; + + function checkCSS() { + let computedStyle = window.getComputedStyle(document.body); + return [computedStyle.backgroundColor, computedStyle.color]; + } + + try { + for (let {promise, background, foreground} of tasks) { + let result = await promise(); + browser.test.assertEq(undefined, result, "Expected callback result"); + + [result] = await browser.tabs.executeScript({ + code: `(${checkCSS})()`, + }); + browser.test.assertEq(background, result[0], "Expected background color"); + browser.test.assertEq(foreground, result[1], "Expected foreground color"); + } + + browser.test.notifyPass("removeCSS"); + } catch (e) { + browser.test.fail(`Error: ${e} :: ${e.stack}`); + browser.test.notifyFailure("removeCSS"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["http://mochi.test/"], + }, + + background, + + files: { + "file2.css": "* { color: rgb(0, 113, 4) }", + }, + }); + + yield extension.startup(); + + yield extension.awaitFinish("removeCSS"); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_sendMessage.js b/browser/components/extensions/test/browser/browser_ext_tabs_sendMessage.js new file mode 100644 index 000000000..64e97afb1 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_sendMessage.js @@ -0,0 +1,227 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* tabsSendMessageReply() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + + "content_scripts": [{ + "matches": ["http://example.com/"], + "js": ["content-script.js"], + "run_at": "document_start", + }], + }, + + background: async function() { + let firstTab; + let promiseResponse = new Promise(resolve => { + browser.runtime.onMessage.addListener((msg, sender, respond) => { + if (msg == "content-script-ready") { + let tabId = sender.tab.id; + + Promise.all([ + promiseResponse, + + browser.tabs.sendMessage(tabId, "respond-now"), + browser.tabs.sendMessage(tabId, "respond-now-2"), + new Promise(resolve => browser.tabs.sendMessage(tabId, "respond-soon", resolve)), + browser.tabs.sendMessage(tabId, "respond-promise"), + browser.tabs.sendMessage(tabId, "respond-never"), + new Promise(resolve => { + browser.runtime.sendMessage("respond-never", response => { resolve(response); }); + }), + + browser.tabs.sendMessage(tabId, "respond-error").catch(error => Promise.resolve({error})), + browser.tabs.sendMessage(tabId, "throw-error").catch(error => Promise.resolve({error})), + + browser.tabs.sendMessage(firstTab, "no-listener").catch(error => Promise.resolve({error})), + ]).then(([response, respondNow, respondNow2, respondSoon, respondPromise, respondNever, respondNever2, respondError, throwError, noListener]) => { + browser.test.assertEq("expected-response", response, "Content script got the expected response"); + + browser.test.assertEq("respond-now", respondNow, "Got the expected immediate response"); + browser.test.assertEq("respond-now-2", respondNow2, "Got the expected immediate response from the second listener"); + browser.test.assertEq("respond-soon", respondSoon, "Got the expected delayed response"); + browser.test.assertEq("respond-promise", respondPromise, "Got the expected promise response"); + browser.test.assertEq(undefined, respondNever, "Got the expected no-response resolution"); + browser.test.assertEq(undefined, respondNever2, "Got the expected no-response resolution"); + + browser.test.assertEq("respond-error", respondError.error.message, "Got the expected error response"); + browser.test.assertEq("throw-error", throwError.error.message, "Got the expected thrown error response"); + + browser.test.assertEq("Could not establish connection. Receiving end does not exist.", + noListener.error.message, + "Got the expected no listener response"); + + return browser.tabs.remove(tabId); + }).then(() => { + browser.test.notifyPass("sendMessage"); + }); + + return Promise.resolve("expected-response"); + } else if (msg[0] == "got-response") { + resolve(msg[1]); + } + }); + }); + + let tabs = await browser.tabs.query({currentWindow: true, active: true}); + firstTab = tabs[0].id; + browser.tabs.create({url: "http://example.com/"}); + }, + + files: { + "content-script.js": async function() { + browser.runtime.onMessage.addListener((msg, sender, respond) => { + if (msg == "respond-now") { + respond(msg); + } else if (msg == "respond-soon") { + setTimeout(() => { respond(msg); }, 0); + return true; + } else if (msg == "respond-promise") { + return Promise.resolve(msg); + } else if (msg == "respond-never") { + return; + } else if (msg == "respond-error") { + return Promise.reject(new Error(msg)); + } else if (msg == "throw-error") { + throw new Error(msg); + } + }); + + browser.runtime.onMessage.addListener((msg, sender, respond) => { + if (msg == "respond-now") { + respond("hello"); + } else if (msg == "respond-now-2") { + respond(msg); + } + }); + + let response = await browser.runtime.sendMessage("content-script-ready"); + browser.runtime.sendMessage(["got-response", response]); + }, + }, + }); + + yield extension.startup(); + + yield extension.awaitFinish("sendMessage"); + + yield extension.unload(); +}); + + +add_task(function* tabsSendHidden() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + + "content_scripts": [{ + "matches": ["http://example.com/content*"], + "js": ["content-script.js"], + "run_at": "document_start", + }], + }, + + background: async function() { + let resolveContent; + browser.runtime.onMessage.addListener((msg, sender) => { + if (msg[0] == "content-ready") { + resolveContent(msg[1]); + } + }); + + let awaitContent = url => { + return new Promise(resolve => { + resolveContent = resolve; + }).then(result => { + browser.test.assertEq(url, result, "Expected content script URL"); + }); + }; + + try { + const URL1 = "http://example.com/content1.html"; + const URL2 = "http://example.com/content2.html"; + + let tab = await browser.tabs.create({url: URL1}); + await awaitContent(URL1); + + let url = await browser.tabs.sendMessage(tab.id, URL1); + browser.test.assertEq(URL1, url, "Should get response from expected content window"); + + await browser.tabs.update(tab.id, {url: URL2}); + await awaitContent(URL2); + + url = await browser.tabs.sendMessage(tab.id, URL2); + browser.test.assertEq(URL2, url, "Should get response from expected content window"); + + // Repeat once just to be sure the first message was processed by all + // listeners before we exit the test. + url = await browser.tabs.sendMessage(tab.id, URL2); + browser.test.assertEq(URL2, url, "Should get response from expected content window"); + + await browser.tabs.remove(tab.id); + + browser.test.notifyPass("contentscript-bfcache-window"); + } catch (error) { + browser.test.fail(`Error: ${error} :: ${error.stack}`); + browser.test.notifyFail("contentscript-bfcache-window"); + } + }, + + files: { + "content-script.js": function() { + // Store this in a local variable to make sure we don't touch any + // properties of the possibly-hidden content window. + let href = window.location.href; + + browser.runtime.onMessage.addListener((msg, sender) => { + browser.test.assertEq(href, msg, "Should be in the expected content window"); + + return Promise.resolve(href); + }); + + browser.runtime.sendMessage(["content-ready", href]); + }, + }, + }); + + yield extension.startup(); + + yield extension.awaitFinish("contentscript-bfcache-window"); + + yield extension.unload(); +}); + + +add_task(function* tabsSendMessageNoExceptionOnNonExistentTab() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + async background() { + let url = "http://example.com/mochitest/browser/browser/components/extensions/test/browser/file_dummy.html"; + let tab = await browser.tabs.create({url}); + + try { + browser.tabs.sendMessage(tab.id, "message"); + browser.tabs.sendMessage(tab.id + 100, "message"); + } catch (e) { + browser.test.fail("no exception should be raised on tabs.sendMessage to nonexistent tabs"); + } + + await browser.tabs.remove(tab.id); + + browser.test.notifyPass("tabs.sendMessage"); + }, + }); + + yield Promise.all([ + extension.startup(), + extension.awaitFinish("tabs.sendMessage"), + ]); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_update.js b/browser/components/extensions/test/browser/browser_ext_tabs_update.js new file mode 100644 index 000000000..8e56a746c --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_update.js @@ -0,0 +1,45 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:robots"); + let tab2 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "about:config"); + + gBrowser.selectedTab = tab1; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background: function() { + browser.tabs.query({ + lastFocusedWindow: true, + }, function(tabs) { + browser.test.assertEq(tabs.length, 3, "should have three tabs"); + + tabs.sort((tab1, tab2) => tab1.index - tab2.index); + + browser.test.assertEq(tabs[0].url, "about:blank", "first tab blank"); + tabs.shift(); + + browser.test.assertTrue(tabs[0].active, "tab 0 active"); + browser.test.assertFalse(tabs[1].active, "tab 1 inactive"); + + browser.tabs.update(tabs[1].id, {active: true}, function() { + browser.test.sendMessage("check"); + }); + }); + }, + }); + + yield Promise.all([extension.startup(), extension.awaitMessage("check")]); + + ok(gBrowser.selectedTab == tab2, "correct tab selected"); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab1); + yield BrowserTestUtils.removeTab(tab2); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_update_url.js b/browser/components/extensions/test/browser/browser_ext_tabs_update_url.js new file mode 100644 index 000000000..b43855fb1 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_update_url.js @@ -0,0 +1,110 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function* testTabsUpdateURL(existentTabURL, tabsUpdateURL, isErrorExpected) { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + files: { + "tab.html": ` + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + </head> + <body> + <h1>tab page</h1> + </body> + </html> + `.trim(), + }, + background: function() { + browser.test.sendMessage("ready", browser.runtime.getURL("tab.html")); + + browser.test.onMessage.addListener(async (msg, tabsUpdateURL, isErrorExpected) => { + let tabs = await browser.tabs.query({lastFocusedWindow: true}); + + try { + let tab = await browser.tabs.update(tabs[1].id, {url: tabsUpdateURL}); + + browser.test.assertFalse(isErrorExpected, `tabs.update with URL ${tabsUpdateURL} should be rejected`); + browser.test.assertTrue(tab, "on success the tab should be defined"); + } catch (error) { + browser.test.assertTrue(isErrorExpected, `tabs.update with URL ${tabsUpdateURL} should not be rejected`); + browser.test.assertTrue(/^Illegal URL/.test(error.message), + "tabs.update should be rejected with the expected error message"); + } + + browser.test.sendMessage("done"); + }); + }, + }); + + yield extension.startup(); + + let mozExtTabURL = yield extension.awaitMessage("ready"); + + if (tabsUpdateURL == "self") { + tabsUpdateURL = mozExtTabURL; + } + + info(`tab.update URL "${tabsUpdateURL}" on tab with URL "${existentTabURL}"`); + + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, existentTabURL); + + extension.sendMessage("start", tabsUpdateURL, isErrorExpected); + yield extension.awaitMessage("done"); + + yield BrowserTestUtils.removeTab(tab1); + yield extension.unload(); +} + +add_task(function* () { + info("Start testing tabs.update on javascript URLs"); + + let dataURLPage = `data:text/html, + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + </head> + <body> + <h1>data url page</h1> + </body> + </html>`; + + let checkList = [ + { + tabsUpdateURL: "http://example.net", + isErrorExpected: false, + }, + { + tabsUpdateURL: "self", + isErrorExpected: false, + }, + { + tabsUpdateURL: "about:addons", + isErrorExpected: true, + }, + { + tabsUpdateURL: "javascript:console.log('tabs.update execute javascript')", + isErrorExpected: true, + }, + { + tabsUpdateURL: dataURLPage, + isErrorExpected: true, + }, + ]; + + let testCases = checkList + .map((check) => Object.assign({}, check, {existentTabURL: "about:blank"})); + + for (let {existentTabURL, tabsUpdateURL, isErrorExpected} of testCases) { + yield* testTabsUpdateURL(existentTabURL, tabsUpdateURL, isErrorExpected); + } + + info("done"); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_tabs_zoom.js b/browser/components/extensions/test/browser/browser_ext_tabs_zoom.js new file mode 100644 index 000000000..c2e54d3ea --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_tabs_zoom.js @@ -0,0 +1,222 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +const SITE_SPECIFIC_PREF = "browser.zoom.siteSpecific"; + +add_task(function* () { + let tab1 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com/"); + let tab2 = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.net/"); + + gBrowser.selectedTab = tab1; + + async function background() { + function promiseUpdated(tabId, attr) { + return new Promise(resolve => { + let onUpdated = (tabId_, changeInfo, tab) => { + if (tabId == tabId_ && attr in changeInfo) { + browser.tabs.onUpdated.removeListener(onUpdated); + + resolve({changeInfo, tab}); + } + }; + browser.tabs.onUpdated.addListener(onUpdated); + }); + } + + let deferred = {}; + browser.test.onMessage.addListener((message, msg, result) => { + if (message == "msg-done" && deferred[msg]) { + deferred[msg].resolve(result); + } + }); + + let _id = 0; + function msg(...args) { + return new Promise((resolve, reject) => { + let id = ++_id; + deferred[id] = {resolve, reject}; + browser.test.sendMessage("msg", id, ...args); + }); + } + + + let zoomEvents = []; + let eventPromises = []; + browser.tabs.onZoomChange.addListener(info => { + zoomEvents.push(info); + if (eventPromises.length) { + eventPromises.shift().resolve(); + } + }); + + let awaitZoom = async (tabId, newValue) => { + let listener; + + await new Promise(async resolve => { + listener = info => { + if (info.tabId == tabId && info.newZoomFactor == newValue) { + resolve(); + } + }; + browser.tabs.onZoomChange.addListener(listener); + + let zoomFactor = await browser.tabs.getZoom(tabId); + if (zoomFactor == newValue) { + resolve(); + } + }); + + browser.tabs.onZoomChange.removeListener(listener); + }; + + let checkZoom = async (tabId, newValue, oldValue = null) => { + let awaitEvent; + if (oldValue != null && !zoomEvents.length) { + awaitEvent = new Promise(resolve => { + eventPromises.push({resolve}); + }); + } + + let [apiZoom, realZoom] = await Promise.all([ + browser.tabs.getZoom(tabId), + msg("get-zoom", tabId), + awaitEvent, + ]); + + browser.test.assertEq(newValue, apiZoom, `Got expected zoom value from API`); + browser.test.assertEq(newValue, realZoom, `Got expected zoom value from parent`); + + if (oldValue != null) { + let event = zoomEvents.shift(); + browser.test.assertEq(tabId, event.tabId, `Got expected zoom event tab ID`); + browser.test.assertEq(newValue, event.newZoomFactor, `Got expected zoom event zoom factor`); + browser.test.assertEq(oldValue, event.oldZoomFactor, `Got expected zoom event old zoom factor`); + + browser.test.assertEq(3, Object.keys(event.zoomSettings).length, `Zoom settings should have 3 keys`); + browser.test.assertEq("automatic", event.zoomSettings.mode, `Mode should be "automatic"`); + browser.test.assertEq("per-origin", event.zoomSettings.scope, `Scope should be "per-origin"`); + browser.test.assertEq(1, event.zoomSettings.defaultZoomFactor, `Default zoom should be 1`); + } + }; + + try { + let tabs = await browser.tabs.query({lastFocusedWindow: true}); + browser.test.assertEq(tabs.length, 3, "We have three tabs"); + + let tabIds = [tabs[1].id, tabs[2].id]; + await checkZoom(tabIds[0], 1); + + await browser.tabs.setZoom(tabIds[0], 2); + await checkZoom(tabIds[0], 2, 1); + + let zoomSettings = await browser.tabs.getZoomSettings(tabIds[0]); + browser.test.assertEq(3, Object.keys(zoomSettings).length, `Zoom settings should have 3 keys`); + browser.test.assertEq("automatic", zoomSettings.mode, `Mode should be "automatic"`); + browser.test.assertEq("per-origin", zoomSettings.scope, `Scope should be "per-origin"`); + browser.test.assertEq(1, zoomSettings.defaultZoomFactor, `Default zoom should be 1`); + + + browser.test.log(`Switch to tab 2`); + await browser.tabs.update(tabIds[1], {active: true}); + await checkZoom(tabIds[1], 1); + + + browser.test.log(`Navigate tab 2 to origin of tab 1`); + browser.tabs.update(tabIds[1], {url: "http://example.com"}); + await promiseUpdated(tabIds[1], "url"); + await checkZoom(tabIds[1], 2, 1); + + + browser.test.log(`Update zoom in tab 2, expect changes in both tabs`); + await browser.tabs.setZoom(tabIds[1], 1.5); + await checkZoom(tabIds[1], 1.5, 2); + + + browser.test.log(`Switch to tab 1, expect asynchronous zoom change just after the switch`); + await Promise.all([ + awaitZoom(tabIds[0], 1.5), + browser.tabs.update(tabIds[0], {active: true}), + ]); + await checkZoom(tabIds[0], 1.5, 2); + + + browser.test.log("Set zoom to 0, expect it set to 1"); + await browser.tabs.setZoom(tabIds[0], 0); + await checkZoom(tabIds[0], 1, 1.5); + + + browser.test.log("Change zoom externally, expect changes reflected"); + await msg("enlarge"); + await checkZoom(tabIds[0], 1.1, 1); + + await Promise.all([ + browser.tabs.setZoom(tabIds[0], 0), + browser.tabs.setZoom(tabIds[1], 0), + ]); + await Promise.all([ + checkZoom(tabIds[0], 1, 1.1), + checkZoom(tabIds[1], 1, 1.5), + ]); + + + browser.test.log("Check that invalid zoom values throw an error"); + await browser.test.assertRejects( + browser.tabs.setZoom(tabIds[0], 42), + /Zoom value 42 out of range/, + "Expected an out of range error"); + + browser.test.log("Disable site-specific zoom, expect correct scope"); + await msg("site-specific", false); + zoomSettings = await browser.tabs.getZoomSettings(tabIds[0]); + + browser.test.assertEq("per-tab", zoomSettings.scope, `Scope should be "per-tab"`); + await msg("site-specific", null); + + browser.test.notifyPass("tab-zoom"); + } catch (e) { + browser.test.fail(`Error: ${e} :: ${e.stack}`); + browser.test.notifyFail("tab-zoom"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background, + }); + + extension.onMessage("msg", (id, msg, ...args) => { + let {Management: {global: {TabManager}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + let resp; + if (msg == "get-zoom") { + let tab = TabManager.getTab(args[0]); + resp = ZoomManager.getZoomForBrowser(tab.linkedBrowser); + } else if (msg == "set-zoom") { + let tab = TabManager.getTab(args[0]); + ZoomManager.setZoomForBrowser(tab.linkedBrowser); + } else if (msg == "enlarge") { + FullZoom.enlarge(); + } else if (msg == "site-specific") { + if (args[0] == null) { + SpecialPowers.clearUserPref(SITE_SPECIFIC_PREF); + } else { + SpecialPowers.setBoolPref(SITE_SPECIFIC_PREF, args[0]); + } + } + + extension.sendMessage("msg-done", id, resp); + }); + + yield extension.startup(); + + yield extension.awaitFinish("tab-zoom"); + + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab1); + yield BrowserTestUtils.removeTab(tab2); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_topwindowid.js b/browser/components/extensions/test/browser/browser_ext_topwindowid.js new file mode 100644 index 000000000..9176ac946 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_topwindowid.js @@ -0,0 +1,23 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* test_topwindowid_cleanup() { + let {Frames} = Cu.import("resource://gre/modules/ExtensionManagement.jsm", {}); + + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com/"); + + let {outerWindowID, messageManager} = tab.linkedBrowser; + + ok(Frames.topWindowIds.has(outerWindowID), "Outer window ID is registered"); + + let awaitDisconnect = TestUtils.topicObserved("message-manager-disconnect", + subject => subject === messageManager); + + yield BrowserTestUtils.removeTab(tab); + + yield awaitDisconnect; + + ok(!Frames.topWindowIds.has(outerWindowID), "Outer window ID is no longer registered"); +}); + diff --git a/browser/components/extensions/test/browser/browser_ext_webNavigation_frameId0.js b/browser/components/extensions/test/browser/browser_ext_webNavigation_frameId0.js new file mode 100644 index 000000000..0058ca065 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_webNavigation_frameId0.js @@ -0,0 +1,45 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* webNavigation_getFrameId_of_existing_main_frame() { + // Whether the frame ID in the extension API is 0 is determined by a map that + // is maintained by |Frames| in ExtensionManagement.jsm. This map is filled + // using data from content processes. But if ExtensionManagement.jsm is not + // imported, then the "Extension:TopWindowID" message gets lost. + // As a result, if the state is not synchronized again, the webNavigation API + // will mistakenly report a non-zero frame ID for top-level frames. + // + // If you want to be absolutely sure that the frame ID is correct, don't open + // tabs before starting an extension, or explicitly load the module in the + // main process: + // Cu.import("resource://gre/modules/ExtensionManagement.jsm", {}); + // + // Or simply run the test again. + const BASE = "http://mochi.test:8888/browser/browser/components/extensions/test/browser/"; + const DUMMY_URL = BASE + "file_dummy.html"; + let tab = yield BrowserTestUtils.openNewForegroundTab(gBrowser, DUMMY_URL, true); + + async function background(DUMMY_URL) { + let tabs = await browser.tabs.query({active: true, currentWindow: true}); + let frames = await browser.webNavigation.getAllFrames({tabId: tabs[0].id}); + browser.test.assertEq(1, frames.length, "The dummy page has one frame"); + browser.test.assertEq(0, frames[0].frameId, "Main frame's ID must be 0"); + browser.test.assertEq(DUMMY_URL, frames[0].url, "Main frame URL must match"); + browser.test.notifyPass("frameId checked"); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["webNavigation"], + }, + + background: `(${background})(${JSON.stringify(DUMMY_URL)});`, + }); + + yield extension.startup(); + yield extension.awaitFinish("frameId checked"); + yield extension.unload(); + + yield BrowserTestUtils.removeTab(tab); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_webNavigation_getFrames.js b/browser/components/extensions/test/browser/browser_ext_webNavigation_getFrames.js new file mode 100644 index 000000000..6b4a597ad --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_webNavigation_getFrames.js @@ -0,0 +1,168 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testWebNavigationGetNonExistentTab() { + let extension = ExtensionTestUtils.loadExtension({ + background: async function() { + // There is no "tabId = 0" because the id assigned by TabManager (defined in ext-utils.js) + // starts from 1. + await browser.test.assertRejects( + browser.webNavigation.getAllFrames({tabId: 0}), + "Invalid tab ID: 0", + "getAllFrames rejected Promise should pass the expected error"); + + // There is no "tabId = 0" because the id assigned by TabManager (defined in ext-utils.js) + // starts from 1, processId is currently marked as optional and it is ignored. + await browser.test.assertRejects( + browser.webNavigation.getFrame({tabId: 0, frameId: 15, processId: 20}), + "Invalid tab ID: 0", + "getFrame rejected Promise should pass the expected error"); + + browser.test.sendMessage("getNonExistentTab.done"); + }, + manifest: { + permissions: ["webNavigation"], + }, + }); + info("load complete"); + + yield extension.startup(); + info("startup complete"); + + yield extension.awaitMessage("getNonExistentTab.done"); + + yield extension.unload(); + info("extension unloaded"); +}); + +add_task(function* testWebNavigationFrames() { + let extension = ExtensionTestUtils.loadExtension({ + background: async function() { + let tabId; + let collectedDetails = []; + + browser.webNavigation.onCompleted.addListener(async details => { + collectedDetails.push(details); + + if (details.frameId !== 0) { + // wait for the top level iframe to be complete + return; + } + + let getAllFramesDetails = await browser.webNavigation.getAllFrames({tabId}); + + let getFramePromises = getAllFramesDetails.map(({frameId}) => { + // processId is currently marked as optional and it is ignored. + return browser.webNavigation.getFrame({tabId, frameId, processId: 0}); + }); + + let getFrameResults = await Promise.all(getFramePromises); + browser.test.sendMessage("webNavigationFrames.done", { + collectedDetails, getAllFramesDetails, getFrameResults, + }); + + // Pick a random frameId. + let nonExistentFrameId = Math.floor(Math.random() * 10000); + + // Increment the picked random nonExistentFrameId until it doesn't exists. + while (getAllFramesDetails.filter((details) => details.frameId == nonExistentFrameId).length > 0) { + nonExistentFrameId += 1; + } + + // Check that getFrame Promise is rejected with the expected error message on nonexistent frameId. + await browser.test.assertRejects( + browser.webNavigation.getFrame({tabId, frameId: nonExistentFrameId, processId: 20}), + `No frame found with frameId: ${nonExistentFrameId}`, + "getFrame promise should be rejected with the expected error message on unexistent frameId"); + + await browser.tabs.remove(tabId); + browser.test.sendMessage("webNavigationFrames.done"); + }); + + let tab = await browser.tabs.create({url: "tab.html"}); + tabId = tab.id; + }, + manifest: { + permissions: ["webNavigation", "tabs"], + }, + files: { + "tab.html": ` + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + </head> + <body> + <iframe src="subframe.html"></iframe> + <iframe src="subframe.html"></iframe> + </body> + </html> + `, + "subframe.html": ` + <!DOCTYPE html> + <html> + <head> + <meta charset="utf-8"> + </head> + </html> + `, + }, + }); + info("load complete"); + + yield extension.startup(); + info("startup complete"); + + let { + collectedDetails, + getAllFramesDetails, + getFrameResults, + } = yield extension.awaitMessage("webNavigationFrames.done"); + + is(getAllFramesDetails.length, 3, "expected number of frames found"); + is(getAllFramesDetails.length, collectedDetails.length, + "number of frames found should equal the number onCompleted events collected"); + + is(getAllFramesDetails[0].frameId, 0, "the root frame has the expected frameId"); + is(getAllFramesDetails[0].parentFrameId, -1, "the root frame has the expected parentFrameId"); + + // ordered by frameId + let sortByFrameId = (el1, el2) => { + let val1 = el1 ? el1.frameId : -1; + let val2 = el2 ? el2.frameId : -1; + return val1 - val2; + }; + + collectedDetails = collectedDetails.sort(sortByFrameId); + getAllFramesDetails = getAllFramesDetails.sort(sortByFrameId); + getFrameResults = getFrameResults.sort(sortByFrameId); + + info("check frame details content"); + + is(getFrameResults.length, getAllFramesDetails.length, + "getFrame and getAllFrames should return the same number of results"); + + Assert.deepEqual(getFrameResults, getAllFramesDetails, + "getFrame and getAllFrames should return the same results"); + + info(`check frame details collected and retrieved with getAllFrames`); + + for (let [i, collected] of collectedDetails.entries()) { + let getAllFramesDetail = getAllFramesDetails[i]; + + is(getAllFramesDetail.frameId, collected.frameId, "frameId"); + is(getAllFramesDetail.parentFrameId, collected.parentFrameId, "parentFrameId"); + is(getAllFramesDetail.tabId, collected.tabId, "tabId"); + + // This can be uncommented once Bug 1246125 has been fixed + // is(getAllFramesDetail.url, collected.url, "url"); + } + + info("frame details content checked"); + + yield extension.awaitMessage("webNavigationFrames.done"); + + yield extension.unload(); + info("extension unloaded"); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_webNavigation_urlbar_transitions.js b/browser/components/extensions/test/browser/browser_ext_webNavigation_urlbar_transitions.js new file mode 100644 index 000000000..f2ea0d901 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_webNavigation_urlbar_transitions.js @@ -0,0 +1,251 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils", + "resource://gre/modules/PlacesUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "PlacesTestUtils", + "resource://testing-common/PlacesTestUtils.jsm"); + +const SUGGEST_URLBAR_PREF = "browser.urlbar.suggest.searches"; +const TEST_ENGINE_BASENAME = "searchSuggestionEngine.xml"; + +function* promiseAutocompleteResultPopup(inputText) { + gURLBar.focus(); + gURLBar.value = inputText; + gURLBar.controller.startSearch(inputText); + yield promisePopupShown(gURLBar.popup); + yield BrowserTestUtils.waitForCondition(() => { + return gURLBar.controller.searchStatus >= + Ci.nsIAutoCompleteController.STATUS_COMPLETE_NO_MATCH; + }); +} + +function* addBookmark(bookmark) { + if (bookmark.keyword) { + yield PlacesUtils.keywords.insert({ + keyword: bookmark.keyword, + url: bookmark.url, + }); + } + + yield PlacesUtils.bookmarks.insert({ + parentGuid: PlacesUtils.bookmarks.unfiledGuid, + url: bookmark.url, + title: bookmark.title, + }); + + registerCleanupFunction(function* () { + yield PlacesUtils.bookmarks.eraseEverything(); + }); +} + +function addSearchEngine(basename) { + return new Promise((resolve, reject) => { + info("Waiting for engine to be added: " + basename); + let url = getRootDirectory(gTestPath) + basename; + Services.search.addEngine(url, null, "", false, { + onSuccess: (engine) => { + info(`Search engine added: ${basename}`); + registerCleanupFunction(() => Services.search.removeEngine(engine)); + resolve(engine); + }, + onError: (errCode) => { + ok(false, `addEngine failed with error code ${errCode}`); + reject(); + }, + }); + }); +} + +function* prepareSearchEngine() { + let oldCurrentEngine = Services.search.currentEngine; + Services.prefs.setBoolPref(SUGGEST_URLBAR_PREF, true); + let engine = yield addSearchEngine(TEST_ENGINE_BASENAME); + Services.search.currentEngine = engine; + + registerCleanupFunction(function* () { + Services.prefs.clearUserPref(SUGGEST_URLBAR_PREF); + Services.search.currentEngine = oldCurrentEngine; + + // Make sure the popup is closed for the next test. + gURLBar.blur(); + gURLBar.popup.selectedIndex = -1; + gURLBar.popup.hidePopup(); + ok(!gURLBar.popup.popupOpen, "popup should be closed"); + + // Clicking suggestions causes visits to search results pages, so clear that + // history now. + yield PlacesTestUtils.clearHistory(); + }); +} + +add_task(function* test_webnavigation_urlbar_typed_transitions() { + function backgroundScript() { + browser.webNavigation.onCommitted.addListener((msg) => { + browser.test.assertEq("http://example.com/?q=typed", msg.url, + "Got the expected url"); + // assert from_address_bar transition qualifier + browser.test.assertTrue(msg.transitionQualifiers && + msg.transitionQualifiers.includes("from_address_bar"), + "Got the expected from_address_bar transitionQualifier"); + browser.test.assertEq("typed", msg.transitionType, + "Got the expected transitionType"); + browser.test.notifyPass("webNavigation.from_address_bar.typed"); + }); + + browser.test.sendMessage("ready"); + } + + let extension = ExtensionTestUtils.loadExtension({ + background: backgroundScript, + manifest: { + permissions: ["webNavigation"], + }, + }); + + yield extension.startup(); + + yield extension.awaitMessage("ready"); + + gURLBar.focus(); + gURLBar.textValue = "http://example.com/?q=typed"; + + EventUtils.synthesizeKey("VK_RETURN", {altKey: true}); + + yield extension.awaitFinish("webNavigation.from_address_bar.typed"); + + yield extension.unload(); + info("extension unloaded"); +}); + +add_task(function* test_webnavigation_urlbar_bookmark_transitions() { + function backgroundScript() { + browser.webNavigation.onCommitted.addListener((msg) => { + browser.test.assertEq("http://example.com/?q=bookmark", msg.url, + "Got the expected url"); + + // assert from_address_bar transition qualifier + browser.test.assertTrue(msg.transitionQualifiers && + msg.transitionQualifiers.includes("from_address_bar"), + "Got the expected from_address_bar transitionQualifier"); + browser.test.assertEq("auto_bookmark", msg.transitionType, + "Got the expected transitionType"); + browser.test.notifyPass("webNavigation.from_address_bar.auto_bookmark"); + }); + + browser.test.sendMessage("ready"); + } + + let extension = ExtensionTestUtils.loadExtension({ + background: backgroundScript, + manifest: { + permissions: ["webNavigation"], + }, + }); + + yield addBookmark({ + title: "Bookmark To Click", + url: "http://example.com/?q=bookmark", + }); + + yield extension.startup(); + + yield extension.awaitMessage("ready"); + + yield promiseAutocompleteResultPopup("Bookmark To Click"); + + let item = gURLBar.popup.richlistbox.getItemAtIndex(1); + item.click(); + yield extension.awaitFinish("webNavigation.from_address_bar.auto_bookmark"); + + yield extension.unload(); + info("extension unloaded"); +}); + +add_task(function* test_webnavigation_urlbar_keyword_transition() { + function backgroundScript() { + browser.webNavigation.onCommitted.addListener((msg) => { + browser.test.assertEq(`http://example.com/?q=search`, msg.url, + "Got the expected url"); + + // assert from_address_bar transition qualifier + browser.test.assertTrue(msg.transitionQualifiers && + msg.transitionQualifiers.includes("from_address_bar"), + "Got the expected from_address_bar transitionQualifier"); + browser.test.assertEq("keyword", msg.transitionType, + "Got the expected transitionType"); + browser.test.notifyPass("webNavigation.from_address_bar.keyword"); + }); + + browser.test.sendMessage("ready"); + } + + let extension = ExtensionTestUtils.loadExtension({ + background: backgroundScript, + manifest: { + permissions: ["webNavigation"], + }, + }); + + yield addBookmark({ + title: "Test Keyword", + url: "http://example.com/?q=%s", + keyword: "testkw", + }); + + yield extension.startup(); + + yield extension.awaitMessage("ready"); + + yield promiseAutocompleteResultPopup("testkw search"); + + let item = gURLBar.popup.richlistbox.getItemAtIndex(0); + item.click(); + + yield extension.awaitFinish("webNavigation.from_address_bar.keyword"); + + yield extension.unload(); + info("extension unloaded"); +}); + +add_task(function* test_webnavigation_urlbar_search_transitions() { + function backgroundScript() { + browser.webNavigation.onCommitted.addListener((msg) => { + browser.test.assertEq("http://mochi.test:8888/", msg.url, + "Got the expected url"); + + // assert from_address_bar transition qualifier + browser.test.assertTrue(msg.transitionQualifiers && + msg.transitionQualifiers.includes("from_address_bar"), + "Got the expected from_address_bar transitionQualifier"); + browser.test.assertEq("generated", msg.transitionType, + "Got the expected 'generated' transitionType"); + browser.test.notifyPass("webNavigation.from_address_bar.generated"); + }); + + browser.test.sendMessage("ready"); + } + + let extension = ExtensionTestUtils.loadExtension({ + background: backgroundScript, + manifest: { + permissions: ["webNavigation"], + }, + }); + + yield extension.startup(); + + yield extension.awaitMessage("ready"); + + yield prepareSearchEngine(); + yield promiseAutocompleteResultPopup("foo"); + + let item = gURLBar.popup.richlistbox.getItemAtIndex(0); + item.click(); + + yield extension.awaitFinish("webNavigation.from_address_bar.generated"); + + yield extension.unload(); + info("extension unloaded"); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_webRequest.js b/browser/components/extensions/test/browser/browser_ext_webRequest.js new file mode 100644 index 000000000..ab9f58480 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_webRequest.js @@ -0,0 +1,95 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +/* globals makeExtension */ +"use strict"; + +Services.scriptloader.loadSubScript(new URL("head_webrequest.js", gTestPath).href, + this); + +Cu.import("resource:///modules/HiddenFrame.jsm", this); +const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"; + +function createHiddenBrowser(url) { + let frame = new HiddenFrame(); + return new Promise(resolve => + frame.get().then(subframe => { + let doc = subframe.document; + let browser = doc.createElementNS(XUL_NS, "browser"); + browser.setAttribute("type", "content"); + browser.setAttribute("disableglobalhistory", "true"); + browser.setAttribute("src", url); + + doc.documentElement.appendChild(browser); + resolve({frame: frame, browser: browser}); + })); +} + +let extension; +let dummy = "http://mochi.test:8888/browser/browser/components/extensions/test/browser/file_dummy.html"; + +add_task(function* setup() { + // SelfSupport has a tendency to fire when running this test alone, without + // a good way to turn it off we just set the url to "" + yield SpecialPowers.pushPrefEnv({ + set: [["browser.selfsupport.url", ""]], + }); + extension = makeExtension(); + yield extension.startup(); +}); + +add_task(function* test_newWindow() { + let expect = { + "file_dummy.html": { + type: "main_frame", + }, + }; + // NOTE: When running solo, favicon will be loaded at some point during + // the tests in this file, so all tests ignore it. When running with + // other tests in this directory, favicon gets loaded at some point before + // we run, and we never see the request, thus it cannot be handled as part + // of expect above. + extension.sendMessage("set-expected", {expect, ignore: ["favicon.ico"]}); + yield extension.awaitMessage("continue"); + + let openedWindow = yield BrowserTestUtils.openNewBrowserWindow(); + yield BrowserTestUtils.openNewForegroundTab(openedWindow.gBrowser, dummy + "?newWindow"); + + yield extension.awaitMessage("done"); + yield BrowserTestUtils.closeWindow(openedWindow); +}); + +add_task(function* test_newTab() { + // again, in this window + let expect = { + "file_dummy.html": { + type: "main_frame", + }, + }; + extension.sendMessage("set-expected", {expect, ignore: ["favicon.ico"]}); + yield extension.awaitMessage("continue"); + let tab = yield BrowserTestUtils.openNewForegroundTab(window.gBrowser, dummy + "?newTab"); + + yield extension.awaitMessage("done"); + yield BrowserTestUtils.removeTab(tab); +}); + +add_task(function* test_subframe() { + let expect = { + "file_dummy.html": { + type: "main_frame", + }, + }; + // test a content subframe attached to hidden window + extension.sendMessage("set-expected", {expect, ignore: ["favicon.ico"]}); + yield extension.awaitMessage("continue"); + let frameInfo = yield createHiddenBrowser(dummy + "?subframe"); + yield extension.awaitMessage("done"); + // cleanup + frameInfo.browser.remove(); + frameInfo.frame.destroy(); +}); + +add_task(function* teardown() { + yield extension.unload(); +}); + diff --git a/browser/components/extensions/test/browser/browser_ext_windows.js b/browser/components/extensions/test/browser/browser_ext_windows.js new file mode 100644 index 000000000..d3dd6ecdb --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_windows.js @@ -0,0 +1,33 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + let raisedWin = Services.ww.openWindow( + null, Services.prefs.getCharPref("browser.chromeURL"), "_blank", + "chrome,dialog=no,all,alwaysRaised", null); + + yield TestUtils.topicObserved("browser-delayed-startup-finished", + subject => subject == raisedWin); + + let extension = ExtensionTestUtils.loadExtension({ + background: function() { + browser.windows.getAll((wins) => { + browser.test.assertEq(wins.length, 2, "Expect two windows"); + + browser.test.assertEq(false, wins[0].alwaysOnTop, + "Expect first window not to be always on top"); + browser.test.assertEq(true, wins[1].alwaysOnTop, + "Expect first window to be always on top"); + + browser.test.notifyPass("alwaysOnTop"); + }); + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("alwaysOnTop"); + yield extension.unload(); + + yield BrowserTestUtils.closeWindow(raisedWin); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_windows_allowScriptsToClose.js b/browser/components/extensions/test/browser/browser_ext_windows_allowScriptsToClose.js new file mode 100644 index 000000000..13f8b2eee --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_windows_allowScriptsToClose.js @@ -0,0 +1,61 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +// Tests allowScriptsToClose option +add_task(function* test_allowScriptsToClose() { + const files = { + "dummy.html": "<meta charset=utf-8><script src=close.js></script>", + "close.js": function() { + window.close(); + if (!window.closed) { + browser.test.sendMessage("close-failed"); + } + }, + }; + + function background() { + browser.test.onMessage.addListener((msg, options) => { + function listener(_, {status}, {url}) { + if (status == "complete" && url == options.url) { + browser.tabs.onUpdated.removeListener(listener); + browser.tabs.executeScript({file: "close.js"}); + } + } + options.url = browser.runtime.getURL(options.url); + browser.windows.create(options); + if (msg === "create+execute") { + browser.tabs.onUpdated.addListener(listener); + } + }); + browser.test.notifyPass(); + } + + const example = "http://example.com/"; + const manifest = {permissions: ["tabs", example]}; + + const extension = ExtensionTestUtils.loadExtension({files, background, manifest}); + yield SpecialPowers.pushPrefEnv({set: [["dom.allow_scripts_to_close_windows", false]]}); + + yield extension.startup(); + yield extension.awaitFinish(); + + extension.sendMessage("create", {url: "dummy.html"}); + let win = yield BrowserTestUtils.waitForNewWindow(); + yield BrowserTestUtils.windowClosed(win); + info("script allowed to close the window"); + + extension.sendMessage("create+execute", {url: example}); + win = yield BrowserTestUtils.waitForNewWindow(); + yield extension.awaitMessage("close-failed"); + info("script prevented from closing the window"); + win.close(); + + extension.sendMessage("create+execute", {url: example, allowScriptsToClose: true}); + win = yield BrowserTestUtils.waitForNewWindow(); + yield BrowserTestUtils.windowClosed(win); + info("script allowed to close the window"); + + yield SpecialPowers.popPrefEnv(); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_windows_create.js b/browser/components/extensions/test/browser/browser_ext_windows_create.js new file mode 100644 index 000000000..f209c9836 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_windows_create.js @@ -0,0 +1,142 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +requestLongerTimeout(2); + +add_task(function* testWindowCreate() { + let extension = ExtensionTestUtils.loadExtension({ + async background() { + let _checkWindowPromise; + browser.test.onMessage.addListener(msg => { + if (msg == "checked-window") { + _checkWindowPromise.resolve(); + _checkWindowPromise = null; + } + }); + + let os; + + function checkWindow(expected) { + return new Promise(resolve => { + _checkWindowPromise = {resolve}; + browser.test.sendMessage("check-window", expected); + }); + } + + async function createWindow(params, expected, keep = false) { + let window = await browser.windows.create(...params); + // params is null when testing create without createData + params = params[0] || {}; + + for (let key of Object.keys(params)) { + if (key == "state" && os == "mac" && params.state == "normal") { + // OS-X doesn't have a hard distinction between "normal" and + // "maximized" states. + browser.test.assertTrue(window.state == "normal" || window.state == "maximized", + `Expected window.state (currently ${window.state}) to be "normal" but will accept "maximized"`); + } else { + browser.test.assertEq(params[key], window[key], `Got expected value for window.${key}`); + } + } + + browser.test.assertEq(1, window.tabs.length, "tabs property got populated"); + + await checkWindow(expected); + if (keep) { + return window; + } + + if (params.state == "fullscreen" && os == "win") { + // FIXME: Closing a fullscreen window causes a window leak in + // Windows tests. + await browser.windows.update(window.id, {state: "normal"}); + } + await browser.windows.remove(window.id); + } + + try { + ({os} = await browser.runtime.getPlatformInfo()); + + // Set the current window to state: "normal" because the test is failing on Windows + // where the current window is maximized. + let currentWindow = await browser.windows.getCurrent(); + await browser.windows.update(currentWindow.id, {state: "normal"}); + + await createWindow([], {state: "STATE_NORMAL"}); + await createWindow([{state: "maximized"}], {state: "STATE_MAXIMIZED"}); + await createWindow([{state: "minimized"}], {state: "STATE_MINIMIZED"}); + await createWindow([{state: "normal"}], {state: "STATE_NORMAL", hiddenChrome: []}); + await createWindow([{state: "fullscreen"}], {state: "STATE_FULLSCREEN"}); + + let window = await createWindow( + [{type: "popup"}], + {hiddenChrome: ["menubar", "toolbar", "location", "directories", "status", "extrachrome"], + chromeFlags: ["CHROME_OPENAS_DIALOG"]}, + true); + + let tabs = await browser.tabs.query({windowType: "popup", active: true}); + + browser.test.assertEq(1, tabs.length, "Expected only one popup"); + browser.test.assertEq(window.id, tabs[0].windowId, "Expected new window to be returned in query"); + + await browser.windows.remove(window.id); + + browser.test.notifyPass("window-create"); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("window-create"); + } + }, + }); + + let latestWindow; + let windowListener = (window, topic) => { + if (topic == "domwindowopened") { + latestWindow = window; + } + }; + Services.ww.registerNotification(windowListener); + + extension.onMessage("check-window", expected => { + if (expected.state != null) { + let {windowState} = latestWindow; + if (latestWindow.fullScreen) { + windowState = latestWindow.STATE_FULLSCREEN; + } + + if (expected.state == "STATE_NORMAL" && AppConstants.platform == "macosx") { + ok(windowState == window.STATE_NORMAL || windowState == window.STATE_MAXIMIZED, + `Expected windowState (currently ${windowState}) to be STATE_NORMAL but will accept STATE_MAXIMIZED`); + } else { + is(windowState, window[expected.state], + `Expected window state to be ${expected.state}`); + } + } + if (expected.hiddenChrome) { + let chromeHidden = latestWindow.document.documentElement.getAttribute("chromehidden"); + is(chromeHidden.trim().split(/\s+/).sort().join(" "), + expected.hiddenChrome.sort().join(" "), + "Got expected hidden chrome"); + } + if (expected.chromeFlags) { + let {chromeFlags} = latestWindow.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDocShell) + .treeOwner.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIXULWindow); + for (let flag of expected.chromeFlags) { + ok(chromeFlags & Ci.nsIWebBrowserChrome[flag], + `Expected window to have the ${flag} flag`); + } + } + + extension.sendMessage("checked-window"); + }); + + yield extension.startup(); + yield extension.awaitFinish("window-create"); + yield extension.unload(); + + Services.ww.unregisterNotification(windowListener); + latestWindow = null; +}); diff --git a/browser/components/extensions/test/browser/browser_ext_windows_create_params.js b/browser/components/extensions/test/browser/browser_ext_windows_create_params.js new file mode 100644 index 000000000..c54d94e05 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_windows_create_params.js @@ -0,0 +1,33 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + + +// Tests that incompatible parameters can't be used together. +add_task(function* testWindowCreateParams() { + let extension = ExtensionTestUtils.loadExtension({ + async background() { + try { + for (let state of ["minimized", "maximized", "fullscreen"]) { + for (let param of ["left", "top", "width", "height"]) { + let expected = `"state": "${state}" may not be combined with "left", "top", "width", or "height"`; + + await browser.test.assertRejects( + browser.windows.create({state, [param]: 100}), + RegExp(expected), + `Got expected error from create(${param}=100)`); + } + } + + browser.test.notifyPass("window-create-params"); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("window-create-params"); + } + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("window-create-params"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_windows_create_tabId.js b/browser/components/extensions/test/browser/browser_ext_windows_create_tabId.js new file mode 100644 index 000000000..52ffaea8b --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_windows_create_tabId.js @@ -0,0 +1,140 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testWindowCreate() { + async function background() { + let promiseTabAttached = () => { + return new Promise(resolve => { + browser.tabs.onAttached.addListener(function listener() { + browser.tabs.onAttached.removeListener(listener); + resolve(); + }); + }); + }; + + let promiseTabUpdated = (expected) => { + return new Promise(resolve => { + browser.tabs.onUpdated.addListener(function listener(tabId, changeInfo, tab) { + if (changeInfo.url === expected) { + browser.tabs.onUpdated.removeListener(listener); + resolve(); + } + }); + }); + }; + + try { + let window = await browser.windows.getCurrent(); + let windowId = window.id; + + browser.test.log("Create additional tab in window 1"); + let tab = await browser.tabs.create({windowId, url: "about:blank"}); + let tabId = tab.id; + + browser.test.log("Create a new window, adopting the new tab"); + + // Note that we want to check against actual boolean values for + // all of the `incognito` property tests. + browser.test.assertEq(false, tab.incognito, "Tab is not private"); + + { + let [, window] = await Promise.all([ + promiseTabAttached(), + browser.windows.create({tabId: tabId}), + ]); + browser.test.assertEq(false, window.incognito, "New window is not private"); + browser.test.assertEq(tabId, window.tabs[0].id, "tabs property populated correctly"); + + browser.test.log("Close the new window"); + await browser.windows.remove(window.id); + } + + { + browser.test.log("Create a new private window"); + let privateWindow = await browser.windows.create({incognito: true}); + browser.test.assertEq(true, privateWindow.incognito, "Private window is private"); + + browser.test.log("Create additional tab in private window"); + let privateTab = await browser.tabs.create({windowId: privateWindow.id}); + browser.test.assertEq(true, privateTab.incognito, "Private tab is private"); + + browser.test.log("Create a new window, adopting the new private tab"); + let [, newWindow] = await Promise.all([ + promiseTabAttached(), + browser.windows.create({tabId: privateTab.id}), + ]); + browser.test.assertEq(true, newWindow.incognito, "New private window is private"); + + browser.test.log("Close the new private window"); + await browser.windows.remove(newWindow.id); + + browser.test.log("Close the private window"); + await browser.windows.remove(privateWindow.id); + } + + + browser.test.log("Try to create a window with both a tab and a URL"); + [tab] = await browser.tabs.query({windowId, active: true}); + await browser.test.assertRejects( + browser.windows.create({tabId: tab.id, url: "http://example.com/"}), + /`tabId` may not be used in conjunction with `url`/, + "Create call failed as expected"); + + browser.test.log("Try to create a window with both a tab and an invalid incognito setting"); + await browser.test.assertRejects( + browser.windows.create({tabId: tab.id, incognito: true}), + /`incognito` property must match the incognito state of tab/, + "Create call failed as expected"); + + + browser.test.log("Try to create a window with an invalid tabId"); + await browser.test.assertRejects( + browser.windows.create({tabId: 0}), + /Invalid tab ID: 0/, + "Create call failed as expected"); + + + browser.test.log("Try to create a window with two URLs"); + let readyPromise = Promise.all([ + // tabs.onUpdated can be invoked between the call of windows.create and + // the invocation of its callback/promise, so set up the listeners + // before creating the window. + promiseTabUpdated("http://example.com/"), + promiseTabUpdated("http://example.org/"), + ]); + + window = await browser.windows.create({url: ["http://example.com/", "http://example.org/"]}); + await readyPromise; + + browser.test.assertEq(2, window.tabs.length, "2 tabs were opened in new window"); + browser.test.assertEq("about:blank", window.tabs[0].url, "about:blank, page not loaded yet"); + browser.test.assertEq("about:blank", window.tabs[1].url, "about:blank, page not loaded yet"); + + window = await browser.windows.get(window.id, {populate: true}); + + browser.test.assertEq(2, window.tabs.length, "2 tabs were opened in new window"); + browser.test.assertEq("http://example.com/", window.tabs[0].url, "Correct URL was loaded in tab 1"); + browser.test.assertEq("http://example.org/", window.tabs[1].url, "Correct URL was loaded in tab 2"); + + await browser.windows.remove(window.id); + + browser.test.notifyPass("window-create"); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("window-create"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + "permissions": ["tabs"], + }, + + background, + }); + + yield extension.startup(); + yield extension.awaitFinish("window-create"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_windows_create_url.js b/browser/components/extensions/test/browser/browser_ext_windows_create_url.js new file mode 100644 index 000000000..c5c7aaf20 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_windows_create_url.js @@ -0,0 +1,84 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testWindowCreate() { + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["tabs"], + }, + + background: async function() { + const EXTENSION_URL = browser.runtime.getURL("test.html"); + const REMOTE_URL = browser.runtime.getURL("test.html"); + + let windows = new class extends Map { // eslint-disable-line new-parens + get(id) { + if (!this.has(id)) { + let window = { + tabs: new Map(), + }; + window.promise = new Promise(resolve => { + window.resolvePromise = resolve; + }); + + this.set(id, window); + } + + return super.get(id); + } + }; + + browser.tabs.onUpdated.addListener((tabId, changed, tab) => { + if (changed.status == "complete" && tab.url !== "about:blank") { + let window = windows.get(tab.windowId); + window.tabs.set(tab.index, tab); + + if (window.tabs.size === window.expectedTabs) { + window.resolvePromise(window); + } + } + }); + + async function create(options) { + let window = await browser.windows.create(options); + let win = windows.get(window.id); + + win.expectedTabs = Array.isArray(options.url) ? options.url.length : 1; + + return win.promise; + } + + try { + let windows = await Promise.all([ + create({url: REMOTE_URL}), + create({url: "test.html"}), + create({url: EXTENSION_URL}), + create({url: [REMOTE_URL, "test.html", EXTENSION_URL]}), + ]); + browser.test.assertEq(REMOTE_URL, windows[0].tabs.get(0).url, "Single, absolute, remote URL"); + + browser.test.assertEq(REMOTE_URL, windows[1].tabs.get(0).url, "Single, relative URL"); + + browser.test.assertEq(REMOTE_URL, windows[2].tabs.get(0).url, "Single, absolute, extension URL"); + + browser.test.assertEq(REMOTE_URL, windows[3].tabs.get(0).url, "url[0]: Absolute, remote URL"); + browser.test.assertEq(EXTENSION_URL, windows[3].tabs.get(1).url, "url[1]: Relative URL"); + browser.test.assertEq(EXTENSION_URL, windows[3].tabs.get(2).url, "url[2]: Absolute, extension URL"); + + browser.test.notifyPass("window-create-url"); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("window-create-url"); + } + }, + + files: { + "test.html": `<DOCTYPE html><html><head><meta charset="utf-8"></head></html>`, + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("window-create-url"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_windows_events.js b/browser/components/extensions/test/browser/browser_ext_windows_events.js new file mode 100644 index 000000000..dc3485b98 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_windows_events.js @@ -0,0 +1,115 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +SimpleTest.requestCompleteLog(); + +add_task(function* testWindowsEvents() { + function background() { + browser.windows.onCreated.addListener(window => { + browser.test.log(`onCreated: windowId=${window.id}`); + + browser.test.assertTrue(Number.isInteger(window.id), + "Window object's id is an integer"); + browser.test.assertEq("normal", window.type, + "Window object returned with the correct type"); + browser.test.sendMessage("window-created", window.id); + }); + + let lastWindowId, os; + browser.windows.onFocusChanged.addListener(async windowId => { + browser.test.log(`onFocusChange: windowId=${windowId} lastWindowId=${lastWindowId}`); + + if (windowId === browser.windows.WINDOW_ID_NONE && os === "linux") { + browser.test.log("Ignoring a superfluous WINDOW_ID_NONE (blur) event on Linux"); + return; + } + + browser.test.assertTrue(lastWindowId !== windowId, + "onFocusChanged fired once for the given window"); + lastWindowId = windowId; + + browser.test.assertTrue(Number.isInteger(windowId), + "windowId is an integer"); + + let window = await browser.windows.getLastFocused(); + + browser.test.assertEq(windowId, window.id, + "Last focused window has the correct id"); + browser.test.sendMessage(`window-focus-changed`, window.id); + }); + + browser.windows.onRemoved.addListener(windowId => { + browser.test.log(`onRemoved: windowId=${windowId}`); + + browser.test.assertTrue(Number.isInteger(windowId), + "windowId is an integer"); + browser.test.sendMessage(`window-removed`, windowId); + browser.test.notifyPass("windows.events"); + }); + + browser.runtime.getPlatformInfo(info => { + os = info.os; + browser.test.sendMessage("ready"); + }); + } + + let extension = ExtensionTestUtils.loadExtension({ + background: `(${background})()`, + }); + + yield extension.startup(); + yield extension.awaitMessage("ready"); + + let {Management: {global: {WindowManager}}} = Cu.import("resource://gre/modules/Extension.jsm", {}); + + let currentWindow = window; + let currentWindowId = WindowManager.getId(currentWindow); + info(`Current window ID: ${currentWindowId}`); + + info(`Create browser window 1`); + let win1 = yield BrowserTestUtils.openNewBrowserWindow(); + let win1Id = yield extension.awaitMessage("window-created"); + info(`Window 1 ID: ${win1Id}`); + + // This shouldn't be necessary, but tests intermittently fail, so let's give + // it a try. + win1.focus(); + + let winId = yield extension.awaitMessage(`window-focus-changed`); + is(winId, win1Id, "Got focus change event for the correct window ID."); + + info(`Create browser window 2`); + let win2 = yield BrowserTestUtils.openNewBrowserWindow(); + let win2Id = yield extension.awaitMessage("window-created"); + info(`Window 2 ID: ${win2Id}`); + + win2.focus(); + + winId = yield extension.awaitMessage(`window-focus-changed`); + is(winId, win2Id, "Got focus change event for the correct window ID."); + + info(`Focus browser window 1`); + yield focusWindow(win1); + + winId = yield extension.awaitMessage(`window-focus-changed`); + is(winId, win1Id, "Got focus change event for the correct window ID."); + + info(`Close browser window 2`); + yield BrowserTestUtils.closeWindow(win2); + + winId = yield extension.awaitMessage(`window-removed`); + is(winId, win2Id, "Got removed event for the correct window ID."); + + info(`Close browser window 1`); + yield BrowserTestUtils.closeWindow(win1); + + winId = yield extension.awaitMessage(`window-removed`); + is(winId, win1Id, "Got removed event for the correct window ID."); + + winId = yield extension.awaitMessage(`window-focus-changed`); + is(winId, currentWindowId, "Got focus change event for the correct window ID."); + + yield extension.awaitFinish("windows.events"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/browser_ext_windows_size.js b/browser/components/extensions/test/browser/browser_ext_windows_size.js new file mode 100644 index 000000000..be822fea1 --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_windows_size.js @@ -0,0 +1,114 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* testWindowCreate() { + let extension = ExtensionTestUtils.loadExtension({ + async background() { + let _checkWindowPromise; + browser.test.onMessage.addListener((msg, arg) => { + if (msg == "checked-window") { + _checkWindowPromise.resolve(arg); + _checkWindowPromise = null; + } + }); + + let getWindowSize = () => { + return new Promise(resolve => { + _checkWindowPromise = {resolve}; + browser.test.sendMessage("check-window"); + }); + }; + + const KEYS = ["left", "top", "width", "height"]; + function checkGeom(expected, actual) { + for (let key of KEYS) { + browser.test.assertEq(expected[key], actual[key], `Expected '${key}' value`); + } + } + + let windowId; + async function checkWindow(expected, retries = 5) { + let geom = await getWindowSize(); + + if (retries && KEYS.some(key => expected[key] != geom[key])) { + browser.test.log(`Got mismatched size (${JSON.stringify(expected)} != ${JSON.stringify(geom)}). ` + + `Retrying after a short delay.`); + + await new Promise(resolve => setTimeout(resolve, 200)); + + return checkWindow(expected, retries - 1); + } + + browser.test.log(`Check actual window size`); + checkGeom(expected, geom); + + browser.test.log("Check API-reported window size"); + + geom = await browser.windows.get(windowId); + + checkGeom(expected, geom); + } + + try { + let geom = {left: 100, top: 100, width: 500, height: 300}; + + let window = await browser.windows.create(geom); + windowId = window.id; + + await checkWindow(geom); + + let update = {left: 150, width: 600}; + Object.assign(geom, update); + await browser.windows.update(windowId, update); + await checkWindow(geom); + + update = {top: 150, height: 400}; + Object.assign(geom, update); + await browser.windows.update(windowId, update); + await checkWindow(geom); + + geom = {left: 200, top: 200, width: 800, height: 600}; + await browser.windows.update(windowId, geom); + await checkWindow(geom); + + let platformInfo = await browser.runtime.getPlatformInfo(); + if (platformInfo.os != "linux") { + geom = {left: -50, top: -50, width: 800, height: 600}; + await browser.windows.update(windowId, geom); + await checkWindow(geom); + } + + await browser.windows.remove(windowId); + browser.test.notifyPass("window-size"); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("window-size"); + } + }, + }); + + let latestWindow; + let windowListener = (window, topic) => { + if (topic == "domwindowopened") { + latestWindow = window; + } + }; + Services.ww.registerNotification(windowListener); + + extension.onMessage("check-window", () => { + extension.sendMessage("checked-window", { + top: latestWindow.screenY, + left: latestWindow.screenX, + width: latestWindow.outerWidth, + height: latestWindow.outerHeight, + }); + }); + + yield extension.startup(); + yield extension.awaitFinish("window-size"); + yield extension.unload(); + + Services.ww.unregisterNotification(windowListener); + latestWindow = null; +}); diff --git a/browser/components/extensions/test/browser/browser_ext_windows_update.js b/browser/components/extensions/test/browser/browser_ext_windows_update.js new file mode 100644 index 000000000..b9475547a --- /dev/null +++ b/browser/components/extensions/test/browser/browser_ext_windows_update.js @@ -0,0 +1,189 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +add_task(function* () { + function promiseWaitForFocus(window) { + return new Promise(resolve => { + waitForFocus(function() { + ok(Services.focus.activeWindow === window, "correct window focused"); + resolve(); + }, window); + }); + } + + let window1 = window; + let window2 = yield BrowserTestUtils.openNewBrowserWindow(); + + Services.focus.activeWindow = window2; + yield promiseWaitForFocus(window2); + + let extension = ExtensionTestUtils.loadExtension({ + background: function() { + browser.windows.getAll(undefined, function(wins) { + browser.test.assertEq(wins.length, 2, "should have two windows"); + + // Sort the unfocused window to the lower index. + wins.sort(function(win1, win2) { + if (win1.focused === win2.focused) { + return 0; + } + + return win1.focused ? 1 : -1; + }); + + browser.windows.update(wins[0].id, {focused: true}, function() { + browser.test.sendMessage("check"); + }); + }); + }, + }); + + yield Promise.all([extension.startup(), extension.awaitMessage("check")]); + + yield promiseWaitForFocus(window1); + + yield extension.unload(); + + yield BrowserTestUtils.closeWindow(window2); +}); + + +add_task(function* testWindowUpdate() { + let extension = ExtensionTestUtils.loadExtension({ + async background() { + let _checkWindowPromise; + browser.test.onMessage.addListener(msg => { + if (msg == "checked-window") { + _checkWindowPromise.resolve(); + _checkWindowPromise = null; + } + }); + + let os; + function checkWindow(expected) { + return new Promise(resolve => { + _checkWindowPromise = {resolve}; + browser.test.sendMessage("check-window", expected); + }); + } + + let currentWindowId; + async function updateWindow(windowId, params, expected) { + let window = await browser.windows.update(windowId, params); + + browser.test.assertEq(currentWindowId, window.id, "Expected WINDOW_ID_CURRENT to refer to the same window"); + for (let key of Object.keys(params)) { + if (key == "state" && os == "mac" && params.state == "normal") { + // OS-X doesn't have a hard distinction between "normal" and + // "maximized" states. + browser.test.assertTrue(window.state == "normal" || window.state == "maximized", + `Expected window.state (currently ${window.state}) to be "normal" but will accept "maximized"`); + } else { + browser.test.assertEq(params[key], window[key], `Got expected value for window.${key}`); + } + } + + return checkWindow(expected); + } + + try { + let windowId = browser.windows.WINDOW_ID_CURRENT; + + ({os} = await browser.runtime.getPlatformInfo()); + + let window = await browser.windows.getCurrent(); + currentWindowId = window.id; + + await updateWindow(windowId, {state: "maximized"}, {state: "STATE_MAXIMIZED"}); + await updateWindow(windowId, {state: "minimized"}, {state: "STATE_MINIMIZED"}); + await updateWindow(windowId, {state: "normal"}, {state: "STATE_NORMAL"}); + await updateWindow(windowId, {state: "fullscreen"}, {state: "STATE_FULLSCREEN"}); + await updateWindow(windowId, {state: "normal"}, {state: "STATE_NORMAL"}); + + browser.test.notifyPass("window-update"); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("window-update"); + } + }, + }); + + extension.onMessage("check-window", expected => { + if (expected.state != null) { + let {windowState} = window; + if (window.fullScreen) { + windowState = window.STATE_FULLSCREEN; + } + + // Temporarily accepting STATE_MAXIMIZED on Linux because of bug 1307759. + if (expected.state == "STATE_NORMAL" && (AppConstants.platform == "macosx" || AppConstants.platform == "linux")) { + ok(windowState == window.STATE_NORMAL || windowState == window.STATE_MAXIMIZED, + `Expected windowState (currently ${windowState}) to be STATE_NORMAL but will accept STATE_MAXIMIZED`); + } else { + is(windowState, window[expected.state], + `Expected window state to be ${expected.state}`); + } + } + + extension.sendMessage("checked-window"); + }); + + yield extension.startup(); + yield extension.awaitFinish("window-update"); + yield extension.unload(); +}); + +add_task(function* () { + let window2 = yield BrowserTestUtils.openNewBrowserWindow(); + + let extension = ExtensionTestUtils.loadExtension({ + background: function() { + browser.windows.getAll(undefined, function(wins) { + browser.test.assertEq(wins.length, 2, "should have two windows"); + + let unfocused = wins.find(win => !win.focused); + browser.windows.update(unfocused.id, {drawAttention: true}, function() { + browser.test.sendMessage("check"); + }); + }); + }, + }); + + yield Promise.all([extension.startup(), extension.awaitMessage("check")]); + + yield extension.unload(); + + yield BrowserTestUtils.closeWindow(window2); +}); + + +// Tests that incompatible parameters can't be used together. +add_task(function* testWindowUpdateParams() { + let extension = ExtensionTestUtils.loadExtension({ + async background() { + try { + for (let state of ["minimized", "maximized", "fullscreen"]) { + for (let param of ["left", "top", "width", "height"]) { + let expected = `"state": "${state}" may not be combined with "left", "top", "width", or "height"`; + + let windowId = browser.windows.WINDOW_ID_CURRENT; + await browser.test.assertRejects( + browser.windows.update(windowId, {state, [param]: 100}), + RegExp(expected), + `Got expected error for create(${param}=100`); + } + } + + browser.test.notifyPass("window-update-params"); + } catch (e) { + browser.test.fail(`${e} :: ${e.stack}`); + browser.test.notifyFail("window-update-params"); + } + }, + }); + + yield extension.startup(); + yield extension.awaitFinish("window-update-params"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/browser/context.html b/browser/components/extensions/test/browser/context.html new file mode 100644 index 000000000..954feea52 --- /dev/null +++ b/browser/components/extensions/test/browser/context.html @@ -0,0 +1,23 @@ +<html> + <head> + <meta charset="utf-8"> + </head> + <body> + just some text 12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 + <img src="ctxmenu-image.png" id="img1"> + + <p> + <a href="some-link" id="link1">Some link</a> + </p> + + <p> + <a href="image-around-some-link"> + <img src="ctxmenu-image.png" id="img-wrapped-in-link"> + </a> + </p> + + <p> + <input type="text" id="edit-me"> + </p> + </body> +</html> diff --git a/browser/components/extensions/test/browser/context_tabs_onUpdated_iframe.html b/browser/components/extensions/test/browser/context_tabs_onUpdated_iframe.html new file mode 100644 index 000000000..0e9b54b52 --- /dev/null +++ b/browser/components/extensions/test/browser/context_tabs_onUpdated_iframe.html @@ -0,0 +1,19 @@ +<html> + <body> + <h3>test iframe</h3> + <script> + "use strict"; + + window.onload = function() { + window.onhashchange = function() { + window.parent.postMessage("updated-iframe-url", "*"); + }; + // NOTE: without the this setTimeout the location change is not fired + // even without the "fire only for top level windows" fix + setTimeout(function() { + window.location.hash = "updated-iframe-url"; + }, 0); + }; + </script> + </body> +</html> diff --git a/browser/components/extensions/test/browser/context_tabs_onUpdated_page.html b/browser/components/extensions/test/browser/context_tabs_onUpdated_page.html new file mode 100644 index 000000000..0f2ce1e8f --- /dev/null +++ b/browser/components/extensions/test/browser/context_tabs_onUpdated_page.html @@ -0,0 +1,18 @@ +<html> + <body> + <h3>test page</h3> + <iframe src="about:blank"></iframe> + <script> + "use strict"; + + window.onmessage = function(evt) { + if (evt.data === "updated-iframe-url") { + window.postMessage("frame-updated", "*"); + } + }; + window.onload = function() { + document.querySelector("iframe").setAttribute("src", "context_tabs_onUpdated_iframe.html"); + }; + </script> + </body> +</html> diff --git a/browser/components/extensions/test/browser/ctxmenu-image.png b/browser/components/extensions/test/browser/ctxmenu-image.png Binary files differnew file mode 100644 index 000000000..4c3be5084 --- /dev/null +++ b/browser/components/extensions/test/browser/ctxmenu-image.png diff --git a/browser/components/extensions/test/browser/file_bypass_cache.sjs b/browser/components/extensions/test/browser/file_bypass_cache.sjs new file mode 100644 index 000000000..c91c76b88 --- /dev/null +++ b/browser/components/extensions/test/browser/file_bypass_cache.sjs @@ -0,0 +1,11 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80 ft=javascript: */ +"use strict"; + +function handleRequest(request, response) { + response.setHeader("Content-Type", "text/plain; charset=UTF-8", false); + + if (request.hasHeader("pragma") && request.hasHeader("cache-control")) { + response.write(`${request.getHeader("pragma")}:${request.getHeader("cache-control")}`); + } +}
\ No newline at end of file diff --git a/browser/components/extensions/test/browser/file_dummy.html b/browser/components/extensions/test/browser/file_dummy.html new file mode 100644 index 000000000..1a87e2840 --- /dev/null +++ b/browser/components/extensions/test/browser/file_dummy.html @@ -0,0 +1,9 @@ +<html> +<head> +<title>Dummy test page</title> +<meta http-equiv="Content-Type" content="text/html;charset=utf-8"></meta> +</head> +<body> +<p>Dummy test page</p> +</body> +</html> diff --git a/browser/components/extensions/test/browser/file_iframe_document.html b/browser/components/extensions/test/browser/file_iframe_document.html new file mode 100644 index 000000000..fcadccf02 --- /dev/null +++ b/browser/components/extensions/test/browser/file_iframe_document.html @@ -0,0 +1,10 @@ +<!DOCTYPE html> +<html lang="en"> +<head> + <meta charset="UTF-8"> + <title></title> +</head> +<body> + <iframe src="/"></iframe> +</body> +</html> diff --git a/browser/components/extensions/test/browser/file_iframe_document.sjs b/browser/components/extensions/test/browser/file_iframe_document.sjs new file mode 100644 index 000000000..661a768af --- /dev/null +++ b/browser/components/extensions/test/browser/file_iframe_document.sjs @@ -0,0 +1,41 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80 ft=javascript: */ +"use strict"; + +// This script slows the load of an HTML document so that we can reliably test +// all phases of the load cycle supported by the extension API. + +/* eslint-disable no-unused-vars */ + +const DELAY = 1 * 1000; // Delay one second before completing the request. + +const Ci = Components.interfaces; + +let nsTimer = Components.Constructor("@mozilla.org/timer;1", "nsITimer", "initWithCallback"); + +let timer; + +function handleRequest(request, response) { + response.processAsync(); + + response.setHeader("Content-Type", "text/html", false); + response.setHeader("Cache-Control", "no-cache", false); + response.write(`<!DOCTYPE html> + <html lang="en"> + <head> + <meta charset="UTF-8"> + <title></title> + </head> + <body> + `); + + // Note: We need to store a reference to the timer to prevent it from being + // canceled when it's GCed. + timer = new nsTimer(() => { + response.write(` + <iframe src="/"></iframe> + </body> + </html>`); + response.finish(); + }, DELAY, Ci.nsITimer.TYPE_ONE_SHOT); +} diff --git a/browser/components/extensions/test/browser/file_language_fr_en.html b/browser/components/extensions/test/browser/file_language_fr_en.html new file mode 100644 index 000000000..5e3c7b3b0 --- /dev/null +++ b/browser/components/extensions/test/browser/file_language_fr_en.html @@ -0,0 +1,14 @@ +<!DOCTYPE html> +<html lang="fr"> +<head> + <meta charset="UTF-8"> + <title></title> +</head> +<body> + France is the largest country in Western Europe and the third-largest in Europe as a whole. + A accès aux chiens et aux frontaux qui lui ont été il peut consulter et modifier ses collections et exporter + Cet article concerne le pays européen aujourd’hui appelé République française. Pour d’autres usages du nom France, + Pour une aide rapide et effective, veuiller trouver votre aide dans le menu ci-dessus. + Motoring events began soon after the construction of the first successful gasoline-fueled automobiles. The quick brown fox jumps over the lazy dog. +</body> +</html> diff --git a/browser/components/extensions/test/browser/file_language_ja.html b/browser/components/extensions/test/browser/file_language_ja.html new file mode 100644 index 000000000..ed07ba70e --- /dev/null +++ b/browser/components/extensions/test/browser/file_language_ja.html @@ -0,0 +1,10 @@ +<!DOCTYPE html> +<html lang="ja"> +<head> + <meta charset="UTF-8"> + <title></title> +</head> +<body> + このペ ジでは アカウントに指定された予算の履歴を一覧にしています それぞれの項目には 予算額と特定期間のステ タスが表示されます 現在または今後の予算を設定するには +</body> +</html> diff --git a/browser/components/extensions/test/browser/file_language_tlh.html b/browser/components/extensions/test/browser/file_language_tlh.html new file mode 100644 index 000000000..dd7da7bdb --- /dev/null +++ b/browser/components/extensions/test/browser/file_language_tlh.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<html lang="tlh"> +<head> + <meta charset="UTF-8"> + <title></title> +</head> +<body> + tlhIngan maH! + Hab SoSlI' Quch! + Heghlu'meH QaQ jajvam +</body> +</html> diff --git a/browser/components/extensions/test/browser/file_popup_api_injection_a.html b/browser/components/extensions/test/browser/file_popup_api_injection_a.html new file mode 100644 index 000000000..750ff1db3 --- /dev/null +++ b/browser/components/extensions/test/browser/file_popup_api_injection_a.html @@ -0,0 +1,10 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> + <script type="application/javascript"> + "use strict"; + throw new Error(`WebExt Privilege Escalation: BrowserAction: typeof(browser) = ${typeof(browser)}`); + </script> +</head> +</html> diff --git a/browser/components/extensions/test/browser/file_popup_api_injection_b.html b/browser/components/extensions/test/browser/file_popup_api_injection_b.html new file mode 100644 index 000000000..b8c287e55 --- /dev/null +++ b/browser/components/extensions/test/browser/file_popup_api_injection_b.html @@ -0,0 +1,10 @@ +<!DOCTYPE html> +<html> +<head> + <meta charset="utf-8"> + <script type="application/javascript"> + "use strict"; + throw new Error(`WebExt Privilege Escalation: PageAction: typeof(browser) = ${typeof(browser)}`); + </script> +</head> +</html> diff --git a/browser/components/extensions/test/browser/head.js b/browser/components/extensions/test/browser/head.js new file mode 100644 index 000000000..f8d59c944 --- /dev/null +++ b/browser/components/extensions/test/browser/head.js @@ -0,0 +1,263 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +/* exported CustomizableUI makeWidgetId focusWindow forceGC + * getBrowserActionWidget + * clickBrowserAction clickPageAction + * getBrowserActionPopup getPageActionPopup + * closeBrowserAction closePageAction + * promisePopupShown promisePopupHidden + * openContextMenu closeContextMenu + * openExtensionContextMenu closeExtensionContextMenu + * imageBuffer getListStyleImage getPanelForNode + * awaitExtensionPanel awaitPopupResize + * promiseContentDimensions alterContent + */ + +var {AppConstants} = Cu.import("resource://gre/modules/AppConstants.jsm"); +var {CustomizableUI} = Cu.import("resource:///modules/CustomizableUI.jsm"); + +// Bug 1239884: Our tests occasionally hit a long GC pause at unpredictable +// times in debug builds, which results in intermittent timeouts. Until we have +// a better solution, we force a GC after certain strategic tests, which tend to +// accumulate a high number of unreaped windows. +function forceGC() { + if (AppConstants.DEBUG) { + Cu.forceGC(); + } +} + +function makeWidgetId(id) { + id = id.toLowerCase(); + return id.replace(/[^a-z0-9_-]/g, "_"); +} + +var focusWindow = Task.async(function* focusWindow(win) { + let fm = Cc["@mozilla.org/focus-manager;1"].getService(Ci.nsIFocusManager); + if (fm.activeWindow == win) { + return; + } + + let promise = new Promise(resolve => { + win.addEventListener("focus", function listener() { + win.removeEventListener("focus", listener, true); + resolve(); + }, true); + }); + + win.focus(); + yield promise; +}); + +let img = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQImWNgYGBgAAAABQABh6FO1AAAAABJRU5ErkJggg=="; +var imageBuffer = Uint8Array.from(atob(img), byte => byte.charCodeAt(0)).buffer; + +function getListStyleImage(button) { + let style = button.ownerDocument.defaultView.getComputedStyle(button); + + let match = /^url\("(.*)"\)$/.exec(style.listStyleImage); + + return match && match[1]; +} + +function promisePopupShown(popup) { + return new Promise(resolve => { + if (popup.state == "open") { + resolve(); + } else { + let onPopupShown = event => { + popup.removeEventListener("popupshown", onPopupShown); + resolve(); + }; + popup.addEventListener("popupshown", onPopupShown); + } + }); +} + +function promisePopupHidden(popup) { + return new Promise(resolve => { + let onPopupHidden = event => { + popup.removeEventListener("popuphidden", onPopupHidden); + resolve(); + }; + popup.addEventListener("popuphidden", onPopupHidden); + }); +} + +function promiseContentDimensions(browser) { + return ContentTask.spawn(browser, null, function* () { + function copyProps(obj, props) { + let res = {}; + for (let prop of props) { + res[prop] = obj[prop]; + } + return res; + } + + return { + window: copyProps(content, + ["innerWidth", "innerHeight", "outerWidth", "outerHeight", + "scrollX", "scrollY", "scrollMaxX", "scrollMaxY"]), + body: copyProps(content.document.body, + ["clientWidth", "clientHeight", "scrollWidth", "scrollHeight"]), + root: copyProps(content.document.documentElement, + ["clientWidth", "clientHeight", "scrollWidth", "scrollHeight"]), + + isStandards: content.document.compatMode !== "BackCompat", + }; + }); +} + +function* awaitPopupResize(browser) { + return BrowserTestUtils.waitForEvent(browser, "WebExtPopupResized", + event => event.detail === "delayed"); +} + +function alterContent(browser, task, arg = null) { + return Promise.all([ + ContentTask.spawn(browser, arg, task), + awaitPopupResize(browser), + ]).then(() => { + return promiseContentDimensions(browser); + }); +} + +function getPanelForNode(node) { + while (node.localName != "panel") { + node = node.parentNode; + } + return node; +} + +var awaitBrowserLoaded = browser => ContentTask.spawn(browser, null, () => { + if (content.document.readyState !== "complete") { + return ContentTaskUtils.waitForEvent(content, "load").then(() => {}); + } +}); + +var awaitExtensionPanel = Task.async(function* (extension, win = window, awaitLoad = true) { + let {originalTarget: browser} = yield BrowserTestUtils.waitForEvent( + win.document, "WebExtPopupLoaded", true, + event => event.detail.extension.id === extension.id); + + yield Promise.all([ + promisePopupShown(getPanelForNode(browser)), + + awaitLoad && awaitBrowserLoaded(browser), + ]); + + return browser; +}); + +function getBrowserActionWidget(extension) { + return CustomizableUI.getWidget(makeWidgetId(extension.id) + "-browser-action"); +} + +function getBrowserActionPopup(extension, win = window) { + let group = getBrowserActionWidget(extension); + + if (group.areaType == CustomizableUI.TYPE_TOOLBAR) { + return win.document.getElementById("customizationui-widget-panel"); + } + return win.PanelUI.panel; +} + +var showBrowserAction = Task.async(function* (extension, win = window) { + let group = getBrowserActionWidget(extension); + let widget = group.forWindow(win); + + if (group.areaType == CustomizableUI.TYPE_TOOLBAR) { + ok(!widget.overflowed, "Expect widget not to be overflowed"); + } else if (group.areaType == CustomizableUI.TYPE_MENU_PANEL) { + yield win.PanelUI.show(); + } +}); + +var clickBrowserAction = Task.async(function* (extension, win = window) { + yield showBrowserAction(extension, win); + + let widget = getBrowserActionWidget(extension).forWindow(win); + + EventUtils.synthesizeMouseAtCenter(widget.node, {}, win); +}); + +function closeBrowserAction(extension, win = window) { + let group = getBrowserActionWidget(extension); + + let node = win.document.getElementById(group.viewId); + CustomizableUI.hidePanelForNode(node); + + return Promise.resolve(); +} + +function* openContextMenu(selector = "#img1") { + let contentAreaContextMenu = document.getElementById("contentAreaContextMenu"); + let popupShownPromise = BrowserTestUtils.waitForEvent(contentAreaContextMenu, "popupshown"); + yield BrowserTestUtils.synthesizeMouseAtCenter(selector, {type: "contextmenu"}, gBrowser.selectedBrowser); + yield popupShownPromise; + return contentAreaContextMenu; +} + +function* closeContextMenu() { + let contentAreaContextMenu = document.getElementById("contentAreaContextMenu"); + let popupHiddenPromise = BrowserTestUtils.waitForEvent(contentAreaContextMenu, "popuphidden"); + contentAreaContextMenu.hidePopup(); + yield popupHiddenPromise; +} + +function* openExtensionContextMenu(selector = "#img1") { + let contextMenu = yield openContextMenu(selector); + let topLevelMenu = contextMenu.getElementsByAttribute("ext-type", "top-level-menu"); + + // Return null if the extension only has one item and therefore no extension menu. + if (topLevelMenu.length == 0) { + return null; + } + + let extensionMenu = topLevelMenu[0].childNodes[0]; + let popupShownPromise = BrowserTestUtils.waitForEvent(contextMenu, "popupshown"); + EventUtils.synthesizeMouseAtCenter(extensionMenu, {}); + yield popupShownPromise; + return extensionMenu; +} + +function* closeExtensionContextMenu(itemToSelect) { + let contentAreaContextMenu = document.getElementById("contentAreaContextMenu"); + let popupHiddenPromise = BrowserTestUtils.waitForEvent(contentAreaContextMenu, "popuphidden"); + EventUtils.synthesizeMouseAtCenter(itemToSelect, {}); + yield popupHiddenPromise; +} + +function getPageActionPopup(extension, win = window) { + let panelId = makeWidgetId(extension.id) + "-panel"; + return win.document.getElementById(panelId); +} + +function clickPageAction(extension, win = window) { + // This would normally be set automatically on navigation, and cleared + // when the user types a value into the URL bar, to show and hide page + // identity info and icons such as page action buttons. + // + // Unfortunately, that doesn't happen automatically in browser chrome + // tests. + /* globals SetPageProxyState */ + SetPageProxyState("valid"); + + let pageActionId = makeWidgetId(extension.id) + "-page-action"; + let elem = win.document.getElementById(pageActionId); + + EventUtils.synthesizeMouseAtCenter(elem, {}, win); + return new Promise(SimpleTest.executeSoon); +} + +function closePageAction(extension, win = window) { + let node = getPageActionPopup(extension, win); + if (node) { + return promisePopupShown(node).then(() => { + node.hidePopup(); + }); + } + + return Promise.resolve(); +} diff --git a/browser/components/extensions/test/browser/head_pageAction.js b/browser/components/extensions/test/browser/head_pageAction.js new file mode 100644 index 000000000..f2d81e512 --- /dev/null +++ b/browser/components/extensions/test/browser/head_pageAction.js @@ -0,0 +1,157 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +/* exported runTests */ +/* globals getListStyleImage */ + +function* runTests(options) { + function background(getTests) { + let tabs; + let tests; + + // Gets the current details of the page action, and returns a + // promise that resolves to an object containing them. + async function getDetails() { + let [tab] = await browser.tabs.query({active: true, currentWindow: true}); + let tabId = tab.id; + + browser.test.log(`Get details: tab={id: ${tabId}, url: ${JSON.stringify(tab.url)}}`); + + return { + title: await browser.pageAction.getTitle({tabId}), + popup: await browser.pageAction.getPopup({tabId}), + }; + } + + + // Runs the next test in the `tests` array, checks the results, + // and passes control back to the outer test scope. + function nextTest() { + let test = tests.shift(); + + test(async expecting => { + function finish() { + // Check that the actual icon has the expected values, then + // run the next test. + browser.test.sendMessage("nextTest", expecting, tests.length); + } + + if (expecting) { + // Check that the API returns the expected values, and then + // run the next test. + let details = await getDetails(); + + browser.test.assertEq(expecting.title, details.title, + "expected value from getTitle"); + + browser.test.assertEq(expecting.popup, details.popup, + "expected value from getPopup"); + } + + finish(); + }); + } + + async function runTests() { + tabs = []; + tests = getTests(tabs); + + let resultTabs = await browser.tabs.query({active: true, currentWindow: true}); + + tabs[0] = resultTabs[0].id; + + nextTest(); + } + + browser.test.onMessage.addListener((msg) => { + if (msg == "runTests") { + runTests(); + } else if (msg == "runNextTest") { + nextTest(); + } else { + browser.test.fail(`Unexpected message: ${msg}`); + } + }); + + runTests(); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: options.manifest, + + files: options.files || {}, + + background: `(${background})(${options.getTests})`, + }); + + let pageActionId; + let currentWindow = window; + let windows = []; + + function checkDetails(details) { + let image = currentWindow.document.getElementById(pageActionId); + if (details == null) { + ok(image == null || image.hidden, "image is hidden"); + } else { + ok(image, "image exists"); + + is(getListStyleImage(image), details.icon, "icon URL is correct"); + + let title = details.title || options.manifest.name; + is(image.getAttribute("tooltiptext"), title, "image title is correct"); + is(image.getAttribute("aria-label"), title, "image aria-label is correct"); + // TODO: Popup URL. + } + } + + let testNewWindows = 1; + + let awaitFinish = new Promise(resolve => { + extension.onMessage("nextTest", (expecting, testsRemaining) => { + if (!pageActionId) { + pageActionId = `${makeWidgetId(extension.id)}-page-action`; + } + + checkDetails(expecting); + + if (testsRemaining) { + extension.sendMessage("runNextTest"); + } else if (testNewWindows) { + testNewWindows--; + + BrowserTestUtils.openNewBrowserWindow().then(window => { + windows.push(window); + currentWindow = window; + return focusWindow(window); + }).then(() => { + extension.sendMessage("runTests"); + }); + } else { + resolve(); + } + }); + }); + + yield SpecialPowers.pushPrefEnv({set: [["general.useragent.locale", "es-ES"]]}); + + yield extension.startup(); + + yield awaitFinish; + + yield extension.unload(); + + yield SpecialPowers.popPrefEnv(); + + let node = document.getElementById(pageActionId); + is(node, null, "pageAction image removed from document"); + + currentWindow = null; + for (let win of windows.splice(0)) { + node = win.document.getElementById(pageActionId); + is(node, null, "pageAction image removed from second document"); + + yield BrowserTestUtils.closeWindow(win); + } +} + diff --git a/browser/components/extensions/test/browser/head_sessions.js b/browser/components/extensions/test/browser/head_sessions.js new file mode 100644 index 000000000..ca3a86c24 --- /dev/null +++ b/browser/components/extensions/test/browser/head_sessions.js @@ -0,0 +1,47 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +/* exported recordInitialTimestamps onlyNewItemsFilter checkRecentlyClosed */ + +let initialTimestamps = []; + +function recordInitialTimestamps(timestamps) { + initialTimestamps = timestamps; +} + +function onlyNewItemsFilter(item) { + return !initialTimestamps.includes(item.lastModified); +} + +function checkWindow(window) { + for (let prop of ["focused", "incognito", "alwaysOnTop"]) { + is(window[prop], false, `closed window has the expected value for ${prop}`); + } + for (let prop of ["state", "type"]) { + is(window[prop], "normal", `closed window has the expected value for ${prop}`); + } +} + +function checkTab(tab, windowId, incognito) { + for (let prop of ["selected", "highlighted", "active", "pinned"]) { + is(tab[prop], false, `closed tab has the expected value for ${prop}`); + } + is(tab.windowId, windowId, "closed tab has the expected value for windowId"); + is(tab.incognito, incognito, "closed tab has the expected value for incognito"); +} + +function checkRecentlyClosed(recentlyClosed, expectedCount, windowId, incognito = false) { + let sessionIds = new Set(); + is(recentlyClosed.length, expectedCount, "the expected number of closed tabs/windows was found"); + for (let item of recentlyClosed) { + if (item.window) { + sessionIds.add(item.window.sessionId); + checkWindow(item.window); + } else if (item.tab) { + sessionIds.add(item.tab.sessionId); + checkTab(item.tab, windowId, incognito); + } + } + is(sessionIds.size, expectedCount, "each item has a unique sessionId"); +} diff --git a/browser/components/extensions/test/browser/searchSuggestionEngine.sjs b/browser/components/extensions/test/browser/searchSuggestionEngine.sjs new file mode 100644 index 000000000..1978b4f66 --- /dev/null +++ b/browser/components/extensions/test/browser/searchSuggestionEngine.sjs @@ -0,0 +1,9 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +function handleRequest(req, resp) { + let suffixes = ["foo", "bar"]; + let data = [req.queryString, suffixes.map(s => req.queryString + s)]; + resp.setHeader("Content-Type", "application/json", false); + resp.write(JSON.stringify(data)); +} diff --git a/browser/components/extensions/test/browser/searchSuggestionEngine.xml b/browser/components/extensions/test/browser/searchSuggestionEngine.xml new file mode 100644 index 000000000..703d45925 --- /dev/null +++ b/browser/components/extensions/test/browser/searchSuggestionEngine.xml @@ -0,0 +1,9 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ --> + +<SearchPlugin xmlns="http://www.mozilla.org/2006/browser/search/"> +<ShortName>browser_searchSuggestionEngine searchSuggestionEngine.xml</ShortName> +<Url type="application/x-suggestions+json" method="GET" template="http://mochi.test:8888/browser/browser/components/extensions/test/browser/searchSuggestionEngine.sjs?{searchTerms}"/> +<Url type="text/html" method="GET" template="http://mochi.test:8888/" rel="searchform"/> +</SearchPlugin> diff --git a/browser/components/extensions/test/mochitest/mochitest.ini b/browser/components/extensions/test/mochitest/mochitest.ini new file mode 100644 index 000000000..39290db61 --- /dev/null +++ b/browser/components/extensions/test/mochitest/mochitest.ini @@ -0,0 +1,6 @@ +[DEFAULT] +support-files = + ../../../../../toolkit/components/extensions/test/mochitest/test_ext_all_apis.js +tags = webextensions + +[test_ext_all_apis.html] diff --git a/browser/components/extensions/test/mochitest/test_ext_all_apis.html b/browser/components/extensions/test/mochitest/test_ext_all_apis.html new file mode 100644 index 000000000..176d380c2 --- /dev/null +++ b/browser/components/extensions/test/mochitest/test_ext_all_apis.html @@ -0,0 +1,75 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>WebExtension test</title> + <meta charset="utf-8"> + <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="/tests/SimpleTest/SpawnTask.js"></script> + <script type="text/javascript" src="/tests/SimpleTest/ExtensionTestUtils.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"> +</head> +<body> +<script> +"use strict"; +/* exported expectedContentApisTargetSpecific, expectedBackgroundApisTargetSpecific */ +let expectedContentApisTargetSpecific = [ +]; + +let expectedBackgroundApisTargetSpecific = [ + "tabs.MutedInfoReason", + "tabs.TAB_ID_NONE", + "tabs.TabStatus", + "tabs.WindowType", + "tabs.ZoomSettingsMode", + "tabs.ZoomSettingsScope", + "tabs.connect", + "tabs.create", + "tabs.detectLanguage", + "tabs.duplicate", + "tabs.executeScript", + "tabs.get", + "tabs.getCurrent", + "tabs.getZoom", + "tabs.getZoomSettings", + "tabs.highlight", + "tabs.insertCSS", + "tabs.move", + "tabs.onActivated", + "tabs.onAttached", + "tabs.onCreated", + "tabs.onDetached", + "tabs.onHighlighted", + "tabs.onMoved", + "tabs.onRemoved", + "tabs.onReplaced", + "tabs.onUpdated", + "tabs.onZoomChange", + "tabs.query", + "tabs.reload", + "tabs.remove", + "tabs.removeCSS", + "tabs.sendMessage", + "tabs.setZoom", + "tabs.setZoomSettings", + "tabs.update", + "windows.CreateType", + "windows.WINDOW_ID_CURRENT", + "windows.WINDOW_ID_NONE", + "windows.WindowState", + "windows.WindowType", + "windows.create", + "windows.get", + "windows.getAll", + "windows.getCurrent", + "windows.getLastFocused", + "windows.onCreated", + "windows.onFocusChanged", + "windows.onRemoved", + "windows.remove", + "windows.update", +]; +</script> +<script src="test_ext_all_apis.js"></script> + +</body> +</html> diff --git a/browser/components/extensions/test/xpcshell/.eslintrc.js b/browser/components/extensions/test/xpcshell/.eslintrc.js new file mode 100644 index 000000000..2bfe540ea --- /dev/null +++ b/browser/components/extensions/test/xpcshell/.eslintrc.js @@ -0,0 +1,9 @@ +"use strict"; + +module.exports = { // eslint-disable-line no-undef + "extends": "../../../../../testing/xpcshell/xpcshell.eslintrc.js", + + "globals": { + "browser": false, + }, +}; diff --git a/browser/components/extensions/test/xpcshell/head.js b/browser/components/extensions/test/xpcshell/head.js new file mode 100644 index 000000000..de4a4a3f6 --- /dev/null +++ b/browser/components/extensions/test/xpcshell/head.js @@ -0,0 +1,55 @@ +"use strict"; + +const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components; + +/* exported createHttpServer */ + +Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); + +XPCOMUtils.defineLazyModuleGetter(this, "AppConstants", + "resource://gre/modules/AppConstants.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Extension", + "resource://gre/modules/Extension.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "ExtensionData", + "resource://gre/modules/Extension.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "ExtensionManagement", + "resource://gre/modules/ExtensionManagement.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "ExtensionTestUtils", + "resource://testing-common/ExtensionXPCShellUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "FileUtils", + "resource://gre/modules/FileUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "HttpServer", + "resource://testing-common/httpd.js"); +XPCOMUtils.defineLazyModuleGetter(this, "NetUtil", + "resource://gre/modules/NetUtil.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Schemas", + "resource://gre/modules/Schemas.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Services", + "resource://gre/modules/Services.jsm"); + +ExtensionTestUtils.init(this); + + +/** + * Creates a new HttpServer for testing, and begins listening on the + * specified port. Automatically shuts down the server when the test + * unit ends. + * + * @param {integer} [port] + * The port to listen on. If omitted, listen on a random + * port. The latter is the preferred behavior. + * + * @returns {HttpServer} + */ +function createHttpServer(port = -1) { + let server = new HttpServer(); + server.start(port); + + do_register_cleanup(() => { + return new Promise(resolve => { + server.stop(resolve); + }); + }); + + return server; +} diff --git a/browser/components/extensions/test/xpcshell/test_ext_bookmarks.js b/browser/components/extensions/test/xpcshell/test_ext_bookmarks.js new file mode 100644 index 000000000..142c0a37c --- /dev/null +++ b/browser/components/extensions/test/xpcshell/test_ext_bookmarks.js @@ -0,0 +1,601 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function backgroundScript() { + let unsortedId, ourId; + let initialBookmarkCount = 0; + let createdBookmarks = new Set(); + let createdFolderId; + let collectedEvents = []; + const nonExistentId = "000000000000"; + const bookmarkGuids = { + menuGuid: "menu________", + toolbarGuid: "toolbar_____", + unfiledGuid: "unfiled_____", + }; + + function checkOurBookmark(bookmark) { + browser.test.assertEq(ourId, bookmark.id, "Bookmark has the expected Id"); + browser.test.assertTrue("parentId" in bookmark, "Bookmark has a parentId"); + browser.test.assertEq(0, bookmark.index, "Bookmark has the expected index"); // We assume there are no other bookmarks. + browser.test.assertEq("http://example.org/", bookmark.url, "Bookmark has the expected url"); + browser.test.assertEq("test bookmark", bookmark.title, "Bookmark has the expected title"); + browser.test.assertTrue("dateAdded" in bookmark, "Bookmark has a dateAdded"); + browser.test.assertFalse("dateGroupModified" in bookmark, "Bookmark does not have a dateGroupModified"); + browser.test.assertFalse("unmodifiable" in bookmark, "Bookmark is not unmodifiable"); + } + + function checkBookmark(expected, bookmark) { + browser.test.assertEq(expected.url, bookmark.url, "Bookmark has the expected url"); + browser.test.assertEq(expected.title, bookmark.title, "Bookmark has the expected title"); + browser.test.assertEq(expected.index, bookmark.index, "Bookmark has expected index"); + if ("parentId" in expected) { + browser.test.assertEq(expected.parentId, bookmark.parentId, "Bookmark has the expected parentId"); + } + } + + function expectedError() { + browser.test.fail("Did not get expected error"); + } + + function checkOnCreated(id, parentId, index, title, url, dateAdded) { + let createdData = collectedEvents.pop(); + browser.test.assertEq("onCreated", createdData.event, "onCreated was the last event received"); + browser.test.assertEq(id, createdData.id, "onCreated event received the expected id"); + let bookmark = createdData.bookmark; + browser.test.assertEq(id, bookmark.id, "onCreated event received the expected bookmark id"); + browser.test.assertEq(parentId, bookmark.parentId, "onCreated event received the expected bookmark parentId"); + browser.test.assertEq(index, bookmark.index, "onCreated event received the expected bookmark index"); + browser.test.assertEq(title, bookmark.title, "onCreated event received the expected bookmark title"); + browser.test.assertEq(url, bookmark.url, "onCreated event received the expected bookmark url"); + browser.test.assertEq(dateAdded, bookmark.dateAdded, "onCreated event received the expected bookmark dateAdded"); + } + + function checkOnChanged(id, url, title) { + // If both url and title are changed, then url is fired last. + let changedData = collectedEvents.pop(); + browser.test.assertEq("onChanged", changedData.event, "onChanged was the last event received"); + browser.test.assertEq(id, changedData.id, "onChanged event received the expected id"); + browser.test.assertEq(url, changedData.info.url, "onChanged event received the expected url"); + // title is fired first. + changedData = collectedEvents.pop(); + browser.test.assertEq("onChanged", changedData.event, "onChanged was the last event received"); + browser.test.assertEq(id, changedData.id, "onChanged event received the expected id"); + browser.test.assertEq(title, changedData.info.title, "onChanged event received the expected title"); + } + + function checkOnMoved(id, parentId, oldParentId, index, oldIndex) { + let movedData = collectedEvents.pop(); + browser.test.assertEq("onMoved", movedData.event, "onMoved was the last event received"); + browser.test.assertEq(id, movedData.id, "onMoved event received the expected id"); + let info = movedData.info; + browser.test.assertEq(parentId, info.parentId, "onMoved event received the expected parentId"); + browser.test.assertEq(oldParentId, info.oldParentId, "onMoved event received the expected oldParentId"); + browser.test.assertEq(index, info.index, "onMoved event received the expected index"); + browser.test.assertEq(oldIndex, info.oldIndex, "onMoved event received the expected oldIndex"); + } + + function checkOnRemoved(id, parentId, index, url) { + let removedData = collectedEvents.pop(); + browser.test.assertEq("onRemoved", removedData.event, "onRemoved was the last event received"); + browser.test.assertEq(id, removedData.id, "onRemoved event received the expected id"); + let info = removedData.info; + browser.test.assertEq(parentId, removedData.info.parentId, "onRemoved event received the expected parentId"); + browser.test.assertEq(index, removedData.info.index, "onRemoved event received the expected index"); + let node = info.node; + browser.test.assertEq(id, node.id, "onRemoved event received the expected node id"); + browser.test.assertEq(parentId, node.parentId, "onRemoved event received the expected node parentId"); + browser.test.assertEq(index, node.index, "onRemoved event received the expected node index"); + browser.test.assertEq(url, node.url, "onRemoved event received the expected node url"); + } + + browser.bookmarks.onChanged.addListener((id, info) => { + collectedEvents.push({event: "onChanged", id, info}); + }); + + browser.bookmarks.onCreated.addListener((id, bookmark) => { + collectedEvents.push({event: "onCreated", id, bookmark}); + }); + + browser.bookmarks.onMoved.addListener((id, info) => { + collectedEvents.push({event: "onMoved", id, info}); + }); + + browser.bookmarks.onRemoved.addListener((id, info) => { + collectedEvents.push({event: "onRemoved", id, info}); + }); + + browser.bookmarks.get(["not-a-bookmark-guid"]).then(expectedError, invalidGuidError => { + browser.test.assertTrue( + invalidGuidError.message.includes("Invalid value for property 'guid': not-a-bookmark-guid"), + "Expected error thrown when trying to get a bookmark using an invalid guid" + ); + + return browser.bookmarks.get([nonExistentId]).then(expectedError, nonExistentIdError => { + browser.test.assertTrue( + nonExistentIdError.message.includes("Bookmark not found"), + "Expected error thrown when trying to get a bookmark using a non-existent Id" + ); + }); + }).then(() => { + return browser.bookmarks.search({}); + }).then(results => { + initialBookmarkCount = results.length; + return browser.bookmarks.create({title: "test bookmark", url: "http://example.org"}); + }).then(result => { + ourId = result.id; + checkOurBookmark(result); + browser.test.assertEq(1, collectedEvents.length, "1 expected event received"); + checkOnCreated(ourId, bookmarkGuids.unfiledGuid, 0, "test bookmark", "http://example.org/", result.dateAdded); + + return browser.bookmarks.get(ourId); + }).then(results => { + browser.test.assertEq(results.length, 1); + checkOurBookmark(results[0]); + + unsortedId = results[0].parentId; + return browser.bookmarks.get(unsortedId); + }).then(results => { + let folder = results[0]; + browser.test.assertEq(1, results.length, "1 bookmark was returned"); + + browser.test.assertEq(unsortedId, folder.id, "Folder has the expected id"); + browser.test.assertTrue("parentId" in folder, "Folder has a parentId"); + browser.test.assertTrue("index" in folder, "Folder has an index"); + browser.test.assertFalse("url" in folder, "Folder does not have a url"); + browser.test.assertEq("Other Bookmarks", folder.title, "Folder has the expected title"); + browser.test.assertTrue("dateAdded" in folder, "Folder has a dateAdded"); + browser.test.assertTrue("dateGroupModified" in folder, "Folder has a dateGroupModified"); + browser.test.assertFalse("unmodifiable" in folder, "Folder is not unmodifiable"); // TODO: Do we want to enable this? + + return browser.bookmarks.getChildren(unsortedId); + }).then(results => { + browser.test.assertEq(1, results.length, "The folder has one child"); + checkOurBookmark(results[0]); + + return browser.bookmarks.update(nonExistentId, {title: "new test title"}).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("No bookmarks found for the provided GUID"), + "Expected error thrown when trying to update a non-existent bookmark" + ); + + return browser.bookmarks.update(ourId, {title: "new test title", url: "http://example.com/"}); + }); + }).then(result => { + browser.test.assertEq("new test title", result.title, "Updated bookmark has the expected title"); + browser.test.assertEq("http://example.com/", result.url, "Updated bookmark has the expected URL"); + browser.test.assertEq(ourId, result.id, "Updated bookmark has the expected id"); + + browser.test.assertEq(2, collectedEvents.length, "2 expected events received"); + checkOnChanged(ourId, "http://example.com/", "new test title"); + + return Promise.resolve().then(() => { + return browser.bookmarks.update(ourId, {url: "this is not a valid url"}); + }).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("Invalid bookmark:"), + "Expected error thrown when trying update with an invalid url" + ); + return browser.bookmarks.getTree(); + }); + }).then(results => { + browser.test.assertEq(1, results.length, "getTree returns one result"); + let bookmark = results[0].children.find(bookmarkItem => bookmarkItem.id == unsortedId); + browser.test.assertEq( + "Other Bookmarks", + bookmark.title, + "Folder returned from getTree has the expected title" + ); + + return browser.bookmarks.create({parentId: "invalid"}).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("Invalid bookmark"), + "Expected error thrown when trying to create a bookmark with an invalid parentId" + ); + browser.test.assertTrue( + error.message.includes(`"parentGuid":"invalid"`), + "Expected error thrown when trying to create a bookmark with an invalid parentId" + ); + }); + }).then(() => { + return browser.bookmarks.remove(ourId); + }).then(result => { + browser.test.assertEq(undefined, result, "Removing a bookmark returns undefined"); + + browser.test.assertEq(1, collectedEvents.length, "1 expected events received"); + checkOnRemoved(ourId, bookmarkGuids.unfiledGuid, 0, "http://example.com/"); + + return browser.bookmarks.get(ourId).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("Bookmark not found"), + "Expected error thrown when trying to get a removed bookmark" + ); + }); + }).then(() => { + return browser.bookmarks.remove(nonExistentId).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("No bookmarks found for the provided GUID"), + "Expected error thrown when trying removed a non-existent bookmark" + ); + }); + }).then(() => { + // test bookmarks.search + return Promise.all([ + browser.bookmarks.create({title: "MØzillä", url: "http://møzîllä.örg/"}), + browser.bookmarks.create({title: "Example", url: "http://example.org/"}), + browser.bookmarks.create({title: "Mozilla Folder"}), + browser.bookmarks.create({title: "EFF", url: "http://eff.org/"}), + browser.bookmarks.create({title: "Menu Item", url: "http://menu.org/", parentId: bookmarkGuids.menuGuid}), + browser.bookmarks.create({title: "Toolbar Item", url: "http://toolbar.org/", parentId: bookmarkGuids.toolbarGuid}), + ]); + }).then(results => { + browser.test.assertEq(6, collectedEvents.length, "6 expected events received"); + checkOnCreated(results[5].id, bookmarkGuids.toolbarGuid, 0, "Toolbar Item", "http://toolbar.org/", results[5].dateAdded); + checkOnCreated(results[4].id, bookmarkGuids.menuGuid, 0, "Menu Item", "http://menu.org/", results[4].dateAdded); + checkOnCreated(results[3].id, bookmarkGuids.unfiledGuid, 0, "EFF", "http://eff.org/", results[3].dateAdded); + checkOnCreated(results[2].id, bookmarkGuids.unfiledGuid, 0, "Mozilla Folder", undefined, results[2].dateAdded); + checkOnCreated(results[1].id, bookmarkGuids.unfiledGuid, 0, "Example", "http://example.org/", results[1].dateAdded); + checkOnCreated(results[0].id, bookmarkGuids.unfiledGuid, 0, "MØzillä", "http://møzîllä.örg/", results[0].dateAdded); + + for (let result of results) { + if (result.title !== "Mozilla Folder") { + createdBookmarks.add(result.id); + } + } + let folderResult = results[2]; + createdFolderId = folderResult.id; + return Promise.all([ + browser.bookmarks.create({title: "Mozilla", url: "http://allizom.org/", parentId: createdFolderId}), + browser.bookmarks.create({title: "Mozilla Corporation", url: "http://allizom.com/", parentId: createdFolderId}), + browser.bookmarks.create({title: "Firefox", url: "http://allizom.org/firefox/", parentId: createdFolderId}), + ]).then(newBookmarks => { + browser.test.assertEq(3, collectedEvents.length, "3 expected events received"); + checkOnCreated(newBookmarks[2].id, createdFolderId, 0, "Firefox", "http://allizom.org/firefox/", newBookmarks[2].dateAdded); + checkOnCreated(newBookmarks[1].id, createdFolderId, 0, "Mozilla Corporation", "http://allizom.com/", newBookmarks[1].dateAdded); + checkOnCreated(newBookmarks[0].id, createdFolderId, 0, "Mozilla", "http://allizom.org/", newBookmarks[0].dateAdded); + + return browser.bookmarks.create({ + title: "About Mozilla", + url: "http://allizom.org/about/", + parentId: createdFolderId, + index: 1, + }); + }).then(result => { + browser.test.assertEq(1, collectedEvents.length, "1 expected events received"); + checkOnCreated(result.id, createdFolderId, 1, "About Mozilla", "http://allizom.org/about/", result.dateAdded); + + // returns all items on empty object + return browser.bookmarks.search({}); + }).then(bookmarksSearchResults => { + browser.test.assertTrue(bookmarksSearchResults.length >= 9, "At least as many bookmarks as added were returned by search({})"); + + return Promise.resolve().then(() => { + return browser.bookmarks.remove(createdFolderId); + }).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("Cannot remove a non-empty folder"), + "Expected error thrown when trying to remove a non-empty folder" + ); + return browser.bookmarks.getSubTree(createdFolderId); + }); + }); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of nodes returned by getSubTree"); + browser.test.assertEq("Mozilla Folder", results[0].title, "Folder has the expected title"); + let children = results[0].children; + browser.test.assertEq(4, children.length, "Expected number of bookmarks returned by getSubTree"); + browser.test.assertEq("Firefox", children[0].title, "Bookmark has the expected title"); + browser.test.assertEq("About Mozilla", children[1].title, "Bookmark has the expected title"); + browser.test.assertEq(1, children[1].index, "Bookmark has the expected index"); + browser.test.assertEq("Mozilla Corporation", children[2].title, "Bookmark has the expected title"); + browser.test.assertEq("Mozilla", children[3].title, "Bookmark has the expected title"); + + // throws an error for invalid query objects + Promise.resolve().then(() => { + return browser.bookmarks.search(); + }).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("Incorrect argument types for bookmarks.search"), + "Expected error thrown when trying to search with no arguments" + ); + }); + + Promise.resolve().then(() => { + return browser.bookmarks.search(null); + }).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("Incorrect argument types for bookmarks.search"), + "Expected error thrown when trying to search with null as an argument" + ); + }); + + Promise.resolve().then(() => { + return browser.bookmarks.search(function() {}); + }).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("Incorrect argument types for bookmarks.search"), + "Expected error thrown when trying to search with a function as an argument" + ); + }); + + Promise.resolve().then(() => { + return browser.bookmarks.search({banana: "banana"}); + }).then(expectedError, error => { + let substr = `an unexpected "banana" property`; + browser.test.assertTrue( + error.message.includes(substr), + `Expected error ${JSON.stringify(error.message)} to contain ${JSON.stringify(substr)}`); + }); + + Promise.resolve().then(() => { + return browser.bookmarks.search({url: "spider-man vs. batman"}); + }).then(expectedError, error => { + let substr = 'must match the format "url"'; + browser.test.assertTrue( + error.message.includes(substr), + `Expected error ${JSON.stringify(error.message)} to contain ${JSON.stringify(substr)}`); + }); + + // queries the full url + return browser.bookmarks.search("http://example.org/"); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of results returned for url search"); + checkBookmark({title: "Example", url: "http://example.org/", index: 2}, results[0]); + + // queries a partial url + return browser.bookmarks.search("example.org"); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of results returned for url search"); + checkBookmark({title: "Example", url: "http://example.org/", index: 2}, results[0]); + + // queries the title + return browser.bookmarks.search("EFF"); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of results returned for title search"); + checkBookmark({title: "EFF", url: "http://eff.org/", index: 0, parentId: bookmarkGuids.unfiledGuid}, results[0]); + + // finds menu items + return browser.bookmarks.search("Menu Item"); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of results returned for menu item search"); + checkBookmark({title: "Menu Item", url: "http://menu.org/", index: 0, parentId: bookmarkGuids.menuGuid}, results[0]); + + // finds toolbar items + return browser.bookmarks.search("Toolbar Item"); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of results returned for toolbar item search"); + checkBookmark({title: "Toolbar Item", url: "http://toolbar.org/", index: 0, parentId: bookmarkGuids.toolbarGuid}, results[0]); + + // finds folders + return browser.bookmarks.search("Mozilla Folder"); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of folders returned"); + browser.test.assertEq("Mozilla Folder", results[0].title, "Folder has the expected title"); + + // is case-insensitive + return browser.bookmarks.search("corporation"); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of results returnedfor case-insensitive search"); + browser.test.assertEq("Mozilla Corporation", results[0].title, "Bookmark has the expected title"); + + // is case-insensitive for non-ascii + return browser.bookmarks.search("MøZILLÄ"); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of results returned for non-ascii search"); + browser.test.assertEq("MØzillä", results[0].title, "Bookmark has the expected title"); + + // returns multiple results + return browser.bookmarks.search("allizom"); + }).then(results => { + browser.test.assertEq(4, results.length, "Expected number of multiple results returned"); + browser.test.assertEq("Mozilla", results[0].title, "Bookmark has the expected title"); + browser.test.assertEq("Mozilla Corporation", results[1].title, "Bookmark has the expected title"); + browser.test.assertEq("Firefox", results[2].title, "Bookmark has the expected title"); + browser.test.assertEq("About Mozilla", results[3].title, "Bookmark has the expected title"); + + // accepts a url field + return browser.bookmarks.search({url: "http://allizom.com/"}); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of results returned for url field"); + checkBookmark({title: "Mozilla Corporation", url: "http://allizom.com/", index: 2}, results[0]); + + // normalizes urls + return browser.bookmarks.search({url: "http://allizom.com"}); + }).then(results => { + browser.test.assertEq(results.length, 1, "Expected number of results returned for normalized url field"); + checkBookmark({title: "Mozilla Corporation", url: "http://allizom.com/", index: 2}, results[0]); + + // normalizes urls even more + return browser.bookmarks.search({url: "http:allizom.com"}); + }).then(results => { + browser.test.assertEq(results.length, 1, "Expected number of results returned for normalized url field"); + checkBookmark({title: "Mozilla Corporation", url: "http://allizom.com/", index: 2}, results[0]); + + // accepts a title field + return browser.bookmarks.search({title: "Mozilla"}); + }).then(results => { + browser.test.assertEq(results.length, 1, "Expected number of results returned for title field"); + checkBookmark({title: "Mozilla", url: "http://allizom.org/", index: 3}, results[0]); + + // can combine title and query + return browser.bookmarks.search({title: "Mozilla", query: "allizom"}); + }).then(results => { + browser.test.assertEq(1, results.length, "Expected number of results returned for title and query fields"); + checkBookmark({title: "Mozilla", url: "http://allizom.org/", index: 3}, results[0]); + + // uses AND conditions + return browser.bookmarks.search({title: "EFF", query: "allizom"}); + }).then(results => { + browser.test.assertEq( + 0, + results.length, + "Expected number of results returned for non-matching title and query fields" + ); + + // returns an empty array on item not found + return browser.bookmarks.search("microsoft"); + }).then(results => { + browser.test.assertEq(0, results.length, "Expected number of results returned for non-matching search"); + + return Promise.resolve().then(() => { + return browser.bookmarks.getRecent(""); + }).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("Incorrect argument types for bookmarks.getRecent"), + "Expected error thrown when calling getRecent with an empty string" + ); + }); + }).then(() => { + return Promise.resolve().then(() => { + return browser.bookmarks.getRecent(1.234); + }).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("Incorrect argument types for bookmarks.getRecent"), + "Expected error thrown when calling getRecent with a decimal number" + ); + }); + }).then(() => { + return Promise.all([ + browser.bookmarks.search("corporation"), + browser.bookmarks.getChildren(bookmarkGuids.menuGuid), + ]); + }).then(results => { + let corporationBookmark = results[0][0]; + let childCount = results[1].length; + + browser.test.assertEq(2, corporationBookmark.index, "Bookmark has the expected index"); + + return browser.bookmarks.move(corporationBookmark.id, {index: 0}).then(result => { + browser.test.assertEq(0, result.index, "Bookmark has the expected index"); + + browser.test.assertEq(1, collectedEvents.length, "1 expected events received"); + checkOnMoved(corporationBookmark.id, createdFolderId, createdFolderId, 0, 2); + + return browser.bookmarks.move(corporationBookmark.id, {parentId: bookmarkGuids.menuGuid}); + }).then(result => { + browser.test.assertEq(bookmarkGuids.menuGuid, result.parentId, "Bookmark has the expected parent"); + browser.test.assertEq(childCount, result.index, "Bookmark has the expected index"); + + browser.test.assertEq(1, collectedEvents.length, "1 expected events received"); + checkOnMoved(corporationBookmark.id, bookmarkGuids.menuGuid, createdFolderId, 1, 0); + + return browser.bookmarks.move(corporationBookmark.id, {index: 0}); + }).then(result => { + browser.test.assertEq(bookmarkGuids.menuGuid, result.parentId, "Bookmark has the expected parent"); + browser.test.assertEq(0, result.index, "Bookmark has the expected index"); + + browser.test.assertEq(1, collectedEvents.length, "1 expected events received"); + checkOnMoved(corporationBookmark.id, bookmarkGuids.menuGuid, bookmarkGuids.menuGuid, 0, 1); + + return browser.bookmarks.move(corporationBookmark.id, {parentId: bookmarkGuids.toolbarGuid, index: 1}); + }).then(result => { + browser.test.assertEq(bookmarkGuids.toolbarGuid, result.parentId, "Bookmark has the expected parent"); + browser.test.assertEq(1, result.index, "Bookmark has the expected index"); + + browser.test.assertEq(1, collectedEvents.length, "1 expected events received"); + checkOnMoved(corporationBookmark.id, bookmarkGuids.toolbarGuid, bookmarkGuids.menuGuid, 1, 0); + + createdBookmarks.add(corporationBookmark.id); + }); + }).then(() => { + return browser.bookmarks.getRecent(4); + }).then(results => { + browser.test.assertEq(4, results.length, "Expected number of results returned by getRecent"); + let prevDate = results[0].dateAdded; + for (let bookmark of results) { + browser.test.assertTrue(bookmark.dateAdded <= prevDate, "The recent bookmarks are sorted by dateAdded"); + prevDate = bookmark.dateAdded; + } + let bookmarksByTitle = results.sort((a, b) => { + return a.title.localeCompare(b.title); + }); + browser.test.assertEq("About Mozilla", bookmarksByTitle[0].title, "Bookmark has the expected title"); + browser.test.assertEq("Firefox", bookmarksByTitle[1].title, "Bookmark has the expected title"); + browser.test.assertEq("Mozilla", bookmarksByTitle[2].title, "Bookmark has the expected title"); + browser.test.assertEq("Mozilla Corporation", bookmarksByTitle[3].title, "Bookmark has the expected title"); + + return browser.bookmarks.search({}); + }).then(results => { + let startBookmarkCount = results.length; + + return browser.bookmarks.search({title: "Mozilla Folder"}).then(result => { + return browser.bookmarks.removeTree(result[0].id); + }).then(() => { + browser.test.assertEq(1, collectedEvents.length, "1 expected events received"); + checkOnRemoved(createdFolderId, bookmarkGuids.unfiledGuid, 1); + + return browser.bookmarks.search({}).then(searchResults => { + browser.test.assertEq( + startBookmarkCount - 4, + searchResults.length, + "Expected number of results returned after removeTree"); + }); + }); + }).then(() => { + return browser.bookmarks.create({title: "Empty Folder"}); + }).then(result => { + let emptyFolderId = result.id; + + browser.test.assertEq(1, collectedEvents.length, "1 expected events received"); + checkOnCreated(emptyFolderId, bookmarkGuids.unfiledGuid, 3, "Empty Folder", undefined, result.dateAdded); + + browser.test.assertEq("Empty Folder", result.title, "Folder has the expected title"); + return browser.bookmarks.remove(emptyFolderId).then(() => { + browser.test.assertEq(1, collectedEvents.length, "1 expected events received"); + checkOnRemoved(emptyFolderId, bookmarkGuids.unfiledGuid, 3); + + return browser.bookmarks.get(emptyFolderId).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("Bookmark not found"), + "Expected error thrown when trying to get a removed folder" + ); + }); + }); + }).then(() => { + return browser.bookmarks.getChildren(nonExistentId).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("root is null"), + "Expected error thrown when trying to getChildren for a non-existent folder" + ); + }); + }).then(() => { + return Promise.resolve().then(() => { + return browser.bookmarks.move(nonExistentId, {}); + }).then(expectedError, error => { + browser.test.assertTrue( + error.message.includes("No bookmarks found for the provided GUID"), + "Expected error thrown when calling move with a non-existent bookmark" + ); + }); + }).then(() => { + // remove all created bookmarks + let promises = Array.from(createdBookmarks, guid => browser.bookmarks.remove(guid)); + return Promise.all(promises); + }).then(() => { + browser.test.assertEq(createdBookmarks.size, collectedEvents.length, "expected number of events received"); + + return browser.bookmarks.search({}); + }).then(results => { + browser.test.assertEq(initialBookmarkCount, results.length, "All created bookmarks have been removed"); + + return browser.test.notifyPass("bookmarks"); + }).catch(error => { + browser.test.fail(`Error: ${String(error)} :: ${error.stack}`); + browser.test.notifyFail("bookmarks"); + }); +} + +let extensionData = { + background: `(${backgroundScript})()`, + manifest: { + permissions: ["bookmarks"], + }, +}; + +add_task(function* test_contentscript() { + let extension = ExtensionTestUtils.loadExtension(extensionData); + yield extension.startup(); + yield extension.awaitFinish("bookmarks"); + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/xpcshell/test_ext_history.js b/browser/components/extensions/test/xpcshell/test_ext_history.js new file mode 100644 index 000000000..78df33151 --- /dev/null +++ b/browser/components/extensions/test/xpcshell/test_ext_history.js @@ -0,0 +1,487 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +XPCOMUtils.defineLazyModuleGetter(this, "PlacesTestUtils", + "resource://testing-common/PlacesTestUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "PlacesUtils", + "resource://gre/modules/PlacesUtils.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "ExtensionUtils", + "resource://gre/modules/ExtensionUtils.jsm"); + +add_task(function* test_delete() { + function background() { + let historyClearedCount = 0; + let removedUrls = []; + + browser.history.onVisitRemoved.addListener(data => { + if (data.allHistory) { + historyClearedCount++; + browser.test.assertEq(0, data.urls.length, "onVisitRemoved received an empty urls array"); + } else { + browser.test.assertEq(1, data.urls.length, "onVisitRemoved received one URL"); + removedUrls.push(data.urls[0]); + } + }); + + browser.test.onMessage.addListener((msg, arg) => { + if (msg === "delete-url") { + browser.history.deleteUrl({url: arg}).then(result => { + browser.test.assertEq(undefined, result, "browser.history.deleteUrl returns nothing"); + browser.test.sendMessage("url-deleted"); + }); + } else if (msg === "delete-range") { + browser.history.deleteRange(arg).then(result => { + browser.test.assertEq(undefined, result, "browser.history.deleteRange returns nothing"); + browser.test.sendMessage("range-deleted", removedUrls); + }); + } else if (msg === "delete-all") { + browser.history.deleteAll().then(result => { + browser.test.assertEq(undefined, result, "browser.history.deleteAll returns nothing"); + browser.test.sendMessage("history-cleared", [historyClearedCount, removedUrls]); + }); + } + }); + + browser.test.sendMessage("ready"); + } + + const BASE_URL = "http://mozilla.com/test_history/"; + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["history"], + }, + background: `(${background})()`, + }); + + yield extension.startup(); + yield extension.awaitMessage("ready"); + yield PlacesTestUtils.clearHistory(); + + let historyClearedCount; + let visits = []; + let visitDate = new Date(1999, 9, 9, 9, 9).getTime(); + + function pushVisit(subvisits) { + visitDate += 1000; + subvisits.push({date: new Date(visitDate)}); + } + + // Add 5 visits for one uri and 3 visits for 3 others + for (let i = 0; i < 4; ++i) { + let visit = { + url: `${BASE_URL}${i}`, + title: "visit " + i, + visits: [], + }; + if (i === 0) { + for (let j = 0; j < 5; ++j) { + pushVisit(visit.visits); + } + } else { + pushVisit(visit.visits); + } + visits.push(visit); + } + + yield PlacesUtils.history.insertMany(visits); + equal((yield PlacesTestUtils.visitsInDB(visits[0].url)), 5, "5 visits for uri found in history database"); + + let testUrl = visits[2].url; + ok((yield PlacesTestUtils.isPageInDB(testUrl)), "expected url found in history database"); + + extension.sendMessage("delete-url", testUrl); + yield extension.awaitMessage("url-deleted"); + equal((yield PlacesTestUtils.isPageInDB(testUrl)), false, "expected url not found in history database"); + + // delete 3 of the 5 visits for url 1 + let filter = { + startTime: visits[0].visits[0].date, + endTime: visits[0].visits[2].date, + }; + + extension.sendMessage("delete-range", filter); + let removedUrls = yield extension.awaitMessage("range-deleted"); + ok(!removedUrls.includes(visits[0].url), `${visits[0].url} not received by onVisitRemoved`); + ok((yield PlacesTestUtils.isPageInDB(visits[0].url)), "expected uri found in history database"); + equal((yield PlacesTestUtils.visitsInDB(visits[0].url)), 2, "2 visits for uri found in history database"); + ok((yield PlacesTestUtils.isPageInDB(visits[1].url)), "expected uri found in history database"); + equal((yield PlacesTestUtils.visitsInDB(visits[1].url)), 1, "1 visit for uri found in history database"); + + // delete the rest of the visits for url 1, and the visit for url 2 + filter.startTime = visits[0].visits[0].date; + filter.endTime = visits[1].visits[0].date; + + extension.sendMessage("delete-range", filter); + yield extension.awaitMessage("range-deleted"); + + equal((yield PlacesTestUtils.isPageInDB(visits[0].url)), false, "expected uri not found in history database"); + equal((yield PlacesTestUtils.visitsInDB(visits[0].url)), 0, "0 visits for uri found in history database"); + equal((yield PlacesTestUtils.isPageInDB(visits[1].url)), false, "expected uri not found in history database"); + equal((yield PlacesTestUtils.visitsInDB(visits[1].url)), 0, "0 visits for uri found in history database"); + + ok((yield PlacesTestUtils.isPageInDB(visits[3].url)), "expected uri found in history database"); + + extension.sendMessage("delete-all"); + [historyClearedCount, removedUrls] = yield extension.awaitMessage("history-cleared"); + equal(PlacesUtils.history.hasHistoryEntries, false, "history is empty"); + equal(historyClearedCount, 2, "onVisitRemoved called for each clearing of history"); + equal(removedUrls.length, 3, "onVisitRemoved called the expected number of times"); + for (let i = 1; i < 3; ++i) { + let url = visits[i].url; + ok(removedUrls.includes(url), `${url} received by onVisitRemoved`); + } + yield extension.unload(); +}); + +add_task(function* test_search() { + const SINGLE_VISIT_URL = "http://example.com/"; + const DOUBLE_VISIT_URL = "http://example.com/2/"; + const MOZILLA_VISIT_URL = "http://mozilla.com/"; + const REFERENCE_DATE = new Date(); + // pages/visits to add via History.insert + const PAGE_INFOS = [ + { + url: SINGLE_VISIT_URL, + title: `test visit for ${SINGLE_VISIT_URL}`, + visits: [ + {date: new Date(Number(REFERENCE_DATE) - 1000)}, + ], + }, + { + url: DOUBLE_VISIT_URL, + title: `test visit for ${DOUBLE_VISIT_URL}`, + visits: [ + {date: REFERENCE_DATE}, + {date: new Date(Number(REFERENCE_DATE) - 2000)}, + ], + }, + { + url: MOZILLA_VISIT_URL, + title: `test visit for ${MOZILLA_VISIT_URL}`, + visits: [ + {date: new Date(Number(REFERENCE_DATE) - 3000)}, + ], + }, + ]; + + function background(BGSCRIPT_REFERENCE_DATE) { + const futureTime = Date.now() + 24 * 60 * 60 * 1000; + + browser.test.onMessage.addListener(msg => { + browser.history.search({text: ""}).then(results => { + browser.test.sendMessage("empty-search", results); + return browser.history.search({text: "mozilla.com"}); + }).then(results => { + browser.test.sendMessage("text-search", results); + return browser.history.search({text: "example.com", maxResults: 1}); + }).then(results => { + browser.test.sendMessage("max-results-search", results); + return browser.history.search({text: "", startTime: BGSCRIPT_REFERENCE_DATE - 2000, endTime: BGSCRIPT_REFERENCE_DATE - 1000}); + }).then(results => { + browser.test.sendMessage("date-range-search", results); + return browser.history.search({text: "", startTime: futureTime}); + }).then(results => { + browser.test.assertEq(0, results.length, "no results returned for late start time"); + return browser.history.search({text: "", endTime: 0}); + }).then(results => { + browser.test.assertEq(0, results.length, "no results returned for early end time"); + return browser.history.search({text: "", startTime: Date.now(), endTime: 0}); + }).then(results => { + browser.test.fail("history.search rejects with startTime that is after the endTime"); + }, error => { + browser.test.assertEq( + "The startTime cannot be after the endTime", + error.message, + "history.search rejects with startTime that is after the endTime"); + }).then(() => { + browser.test.notifyPass("search"); + }); + }); + + browser.test.sendMessage("ready"); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["history"], + }, + background: `(${background})(${Number(REFERENCE_DATE)})`, + }); + + function findResult(url, results) { + return results.find(r => r.url === url); + } + + function checkResult(results, url, expectedCount) { + let result = findResult(url, results); + notEqual(result, null, `history.search result was found for ${url}`); + equal(result.visitCount, expectedCount, `history.search reports ${expectedCount} visit(s)`); + equal(result.title, `test visit for ${url}`, "title for search result is correct"); + } + + yield extension.startup(); + yield extension.awaitMessage("ready"); + yield PlacesTestUtils.clearHistory(); + + yield PlacesUtils.history.insertMany(PAGE_INFOS); + + extension.sendMessage("check-history"); + + let results = yield extension.awaitMessage("empty-search"); + equal(results.length, 3, "history.search with empty text returned 3 results"); + checkResult(results, SINGLE_VISIT_URL, 1); + checkResult(results, DOUBLE_VISIT_URL, 2); + checkResult(results, MOZILLA_VISIT_URL, 1); + + results = yield extension.awaitMessage("text-search"); + equal(results.length, 1, "history.search with specific text returned 1 result"); + checkResult(results, MOZILLA_VISIT_URL, 1); + + results = yield extension.awaitMessage("max-results-search"); + equal(results.length, 1, "history.search with maxResults returned 1 result"); + checkResult(results, DOUBLE_VISIT_URL, 2); + + results = yield extension.awaitMessage("date-range-search"); + equal(results.length, 2, "history.search with a date range returned 2 result"); + checkResult(results, DOUBLE_VISIT_URL, 2); + checkResult(results, SINGLE_VISIT_URL, 1); + + yield extension.awaitFinish("search"); + yield extension.unload(); + yield PlacesTestUtils.clearHistory(); +}); + +add_task(function* test_add_url() { + function background() { + const TEST_DOMAIN = "http://example.com/"; + + browser.test.onMessage.addListener((msg, testData) => { + let [details, type] = testData; + details.url = details.url || `${TEST_DOMAIN}${type}`; + if (msg === "add-url") { + details.title = `Title for ${type}`; + browser.history.addUrl(details).then(() => { + return browser.history.search({text: details.url}); + }).then(results => { + browser.test.assertEq(1, results.length, "1 result found when searching for added URL"); + browser.test.sendMessage("url-added", {details, result: results[0]}); + }); + } else if (msg === "expect-failure") { + let expectedMsg = testData[2]; + browser.history.addUrl(details).then(() => { + browser.test.fail(`Expected error thrown for ${type}`); + }, error => { + browser.test.assertTrue( + error.message.includes(expectedMsg), + `"Expected error thrown when trying to add a URL with ${type}` + ); + browser.test.sendMessage("add-failed"); + }); + } + }); + + browser.test.sendMessage("ready"); + } + + let addTestData = [ + [{}, "default"], + [{visitTime: new Date()}, "with_date"], + [{visitTime: Date.now()}, "with_ms_number"], + [{visitTime: new Date().toISOString()}, "with_iso_string"], + [{transition: "typed"}, "valid_transition"], + ]; + + let failTestData = [ + [{transition: "generated"}, "an invalid transition", "|generated| is not a supported transition for history"], + [{visitTime: Date.now() + 1000000}, "a future date", "cannot be a future date"], + [{url: "about.config"}, "an invalid url", "about.config is not a valid URL"], + ]; + + function* checkUrl(results) { + ok((yield PlacesTestUtils.isPageInDB(results.details.url)), `${results.details.url} found in history database`); + ok(PlacesUtils.isValidGuid(results.result.id), "URL was added with a valid id"); + equal(results.result.title, results.details.title, "URL was added with the correct title"); + if (results.details.visitTime) { + equal(results.result.lastVisitTime, + Number(ExtensionUtils.normalizeTime(results.details.visitTime)), + "URL was added with the correct date"); + } + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["history"], + }, + background: `(${background})()`, + }); + + yield PlacesTestUtils.clearHistory(); + yield extension.startup(); + yield extension.awaitMessage("ready"); + + for (let data of addTestData) { + extension.sendMessage("add-url", data); + let results = yield extension.awaitMessage("url-added"); + yield checkUrl(results); + } + + for (let data of failTestData) { + extension.sendMessage("expect-failure", data); + yield extension.awaitMessage("add-failed"); + } + + yield extension.unload(); +}); + +add_task(function* test_get_visits() { + function background() { + const TEST_DOMAIN = "http://example.com/"; + const FIRST_DATE = Date.now(); + const INITIAL_DETAILS = { + url: TEST_DOMAIN, + visitTime: FIRST_DATE, + transition: "link", + }; + + let visitIds = new Set(); + + function checkVisit(visit, expected) { + visitIds.add(visit.visitId); + browser.test.assertEq(expected.visitTime, visit.visitTime, "visit has the correct visitTime"); + browser.test.assertEq(expected.transition, visit.transition, "visit has the correct transition"); + browser.history.search({text: expected.url}).then(results => { + // all results will have the same id, so we only need to use the first one + browser.test.assertEq(results[0].id, visit.id, "visit has the correct id"); + }); + } + + let details = Object.assign({}, INITIAL_DETAILS); + + browser.history.addUrl(details).then(() => { + return browser.history.getVisits({url: details.url}); + }).then(results => { + browser.test.assertEq(1, results.length, "the expected number of visits were returned"); + checkVisit(results[0], details); + details.url = `${TEST_DOMAIN}/1/`; + return browser.history.addUrl(details); + }).then(() => { + return browser.history.getVisits({url: details.url}); + }).then(results => { + browser.test.assertEq(1, results.length, "the expected number of visits were returned"); + checkVisit(results[0], details); + details.visitTime = FIRST_DATE - 1000; + details.transition = "typed"; + return browser.history.addUrl(details); + }).then(() => { + return browser.history.getVisits({url: details.url}); + }).then(results => { + browser.test.assertEq(2, results.length, "the expected number of visits were returned"); + checkVisit(results[0], INITIAL_DETAILS); + checkVisit(results[1], details); + }).then(() => { + browser.test.assertEq(3, visitIds.size, "each visit has a unique visitId"); + browser.test.notifyPass("get-visits"); + }); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["history"], + }, + background: `(${background})()`, + }); + + yield PlacesTestUtils.clearHistory(); + yield extension.startup(); + + yield extension.awaitFinish("get-visits"); + yield extension.unload(); +}); + +add_task(function* test_on_visited() { + const SINGLE_VISIT_URL = "http://example.com/1/"; + const DOUBLE_VISIT_URL = "http://example.com/2/"; + let visitDate = new Date(1999, 9, 9, 9, 9).getTime(); + + // pages/visits to add via History.insertMany + const PAGE_INFOS = [ + { + url: SINGLE_VISIT_URL, + title: `visit to ${SINGLE_VISIT_URL}`, + visits: [ + {date: new Date(visitDate)}, + ], + }, + { + url: DOUBLE_VISIT_URL, + title: `visit to ${DOUBLE_VISIT_URL}`, + visits: [ + {date: new Date(visitDate += 1000)}, + {date: new Date(visitDate += 1000)}, + ], + }, + ]; + + function background() { + let onVisitedData = []; + + browser.history.onVisited.addListener(data => { + if (data.url.includes("moz-extension")) { + return; + } + onVisitedData.push(data); + if (onVisitedData.length == 3) { + browser.test.sendMessage("on-visited-data", onVisitedData); + } + }); + + browser.test.sendMessage("ready"); + } + + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + permissions: ["history"], + }, + background: `(${background})()`, + }); + + yield PlacesTestUtils.clearHistory(); + yield extension.startup(); + yield extension.awaitMessage("ready"); + + yield PlacesUtils.history.insertMany(PAGE_INFOS); + + let onVisitedData = yield extension.awaitMessage("on-visited-data"); + + function checkOnVisitedData(index, expected) { + let onVisited = onVisitedData[index]; + ok(PlacesUtils.isValidGuid(onVisited.id), "onVisited received a valid id"); + equal(onVisited.url, expected.url, "onVisited received the expected url"); + // Title will be blank until bug 1287928 lands + // https://bugzilla.mozilla.org/show_bug.cgi?id=1287928 + equal(onVisited.title, "", "onVisited received a blank title"); + equal(onVisited.lastVisitTime, expected.time, "onVisited received the expected time"); + equal(onVisited.visitCount, expected.visitCount, "onVisited received the expected visitCount"); + } + + let expected = { + url: PAGE_INFOS[0].url, + title: PAGE_INFOS[0].title, + time: PAGE_INFOS[0].visits[0].date.getTime(), + visitCount: 1, + }; + checkOnVisitedData(0, expected); + + expected.url = PAGE_INFOS[1].url; + expected.title = PAGE_INFOS[1].title; + expected.time = PAGE_INFOS[1].visits[0].date.getTime(); + checkOnVisitedData(1, expected); + + expected.time = PAGE_INFOS[1].visits[1].date.getTime(); + expected.visitCount = 2; + checkOnVisitedData(2, expected); + + yield extension.unload(); +}); diff --git a/browser/components/extensions/test/xpcshell/test_ext_manifest_commands.js b/browser/components/extensions/test/xpcshell/test_ext_manifest_commands.js new file mode 100644 index 000000000..4de7afe01 --- /dev/null +++ b/browser/components/extensions/test/xpcshell/test_ext_manifest_commands.js @@ -0,0 +1,24 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + + +add_task(function* test_manifest_commands() { + let normalized = yield ExtensionTestUtils.normalizeManifest({ + "commands": { + "toggle-feature": { + "suggested_key": {"default": "Shifty+Y"}, + "description": "Send a 'toggle-feature' event to the extension", + }, + }, + }); + + let expectedError = ( + String.raw`commands.toggle-feature.suggested_key.default: Value must either: ` + + String.raw`match the pattern /^\s*(Alt|Ctrl|Command|MacCtrl)\s*\+\s*(Shift\s*\+\s*)?([A-Z0-9]|Comma|Period|Home|End|PageUp|PageDown|Space|Insert|Delete|Up|Down|Left|Right)\s*$/, or ` + + String.raw`match the pattern /^(MediaNextTrack|MediaPlayPause|MediaPrevTrack|MediaStop)$/` + ); + + ok(normalized.error.includes(expectedError), + `The manifest error ${JSON.stringify(normalized.error)} must contain ${JSON.stringify(expectedError)}`); +}); diff --git a/browser/components/extensions/test/xpcshell/test_ext_manifest_omnibox.js b/browser/components/extensions/test/xpcshell/test_ext_manifest_omnibox.js new file mode 100644 index 000000000..2cb141235 --- /dev/null +++ b/browser/components/extensions/test/xpcshell/test_ext_manifest_omnibox.js @@ -0,0 +1,61 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +function* testKeyword(params) { + let normalized = yield ExtensionTestUtils.normalizeManifest({ + "omnibox": { + "keyword": params.keyword, + }, + }); + + if (params.expectError) { + let expectedError = ( + String.raw`omnibox.keyword: String "${params.keyword}" ` + + String.raw`must match /^[^?\s:]([^\s:]*[^/\s:])?$/` + ); + ok(normalized.error.includes(expectedError), + `The manifest error ${JSON.stringify(normalized.error)} ` + + `must contain ${JSON.stringify(expectedError)}`); + } else { + equal(normalized.error, undefined, "Should not have an error"); + equal(normalized.errors.length, 0, "Should not have warnings"); + } +} + +add_task(function* test_manifest_commands() { + // accepted single character keywords + yield testKeyword({keyword: "a", expectError: false}); + yield testKeyword({keyword: "-", expectError: false}); + yield testKeyword({keyword: "嗨", expectError: false}); + yield testKeyword({keyword: "*", expectError: false}); + yield testKeyword({keyword: "/", expectError: false}); + + // rejected single character keywords + yield testKeyword({keyword: "?", expectError: true}); + yield testKeyword({keyword: " ", expectError: true}); + yield testKeyword({keyword: ":", expectError: true}); + + // accepted multi-character keywords + yield testKeyword({keyword: "aa", expectError: false}); + yield testKeyword({keyword: "http", expectError: false}); + yield testKeyword({keyword: "f?a", expectError: false}); + yield testKeyword({keyword: "fa?", expectError: false}); + yield testKeyword({keyword: "f/x", expectError: false}); + yield testKeyword({keyword: "/fx", expectError: false}); + + // rejected multi-character keywords + yield testKeyword({keyword: " a", expectError: true}); + yield testKeyword({keyword: "a ", expectError: true}); + yield testKeyword({keyword: " ", expectError: true}); + yield testKeyword({keyword: " a ", expectError: true}); + yield testKeyword({keyword: "?fx", expectError: true}); + yield testKeyword({keyword: "fx/", expectError: true}); + yield testKeyword({keyword: "f:x", expectError: true}); + yield testKeyword({keyword: "fx:", expectError: true}); + yield testKeyword({keyword: "f x", expectError: true}); + + // miscellaneous tests + yield testKeyword({keyword: "こんにちは", expectError: false}); + yield testKeyword({keyword: "http://", expectError: true}); +}); diff --git a/browser/components/extensions/test/xpcshell/test_ext_manifest_permissions.js b/browser/components/extensions/test/xpcshell/test_ext_manifest_permissions.js new file mode 100644 index 000000000..2c436535d --- /dev/null +++ b/browser/components/extensions/test/xpcshell/test_ext_manifest_permissions.js @@ -0,0 +1,57 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +"use strict"; + +/* globals chrome */ + +function* testPermission(options) { + function background(bgOptions) { + browser.test.sendMessage("typeof-namespace", { + browser: typeof browser[bgOptions.namespace], + chrome: typeof chrome[bgOptions.namespace], + }); + } + + let extensionDetails = { + background: `(${background})(${JSON.stringify(options)})`, + }; + + let extension = ExtensionTestUtils.loadExtension(extensionDetails); + + yield extension.startup(); + + let types = yield extension.awaitMessage("typeof-namespace"); + equal(types.browser, "undefined", `Type of browser.${options.namespace} without manifest entry`); + equal(types.chrome, "undefined", `Type of chrome.${options.namespace} without manifest entry`); + + yield extension.unload(); + + extensionDetails.manifest = options.manifest; + extension = ExtensionTestUtils.loadExtension(extensionDetails); + + yield extension.startup(); + + types = yield extension.awaitMessage("typeof-namespace"); + equal(types.browser, "object", `Type of browser.${options.namespace} with manifest entry`); + equal(types.chrome, "object", `Type of chrome.${options.namespace} with manifest entry`); + + yield extension.unload(); +} + +add_task(function* test_browserAction() { + yield testPermission({ + namespace: "browserAction", + manifest: { + browser_action: {}, + }, + }); +}); + +add_task(function* test_pageAction() { + yield testPermission({ + namespace: "pageAction", + manifest: { + page_action: {}, + }, + }); +}); diff --git a/browser/components/extensions/test/xpcshell/xpcshell.ini b/browser/components/extensions/test/xpcshell/xpcshell.ini new file mode 100644 index 000000000..b9148a697 --- /dev/null +++ b/browser/components/extensions/test/xpcshell/xpcshell.ini @@ -0,0 +1,11 @@ +[DEFAULT] +head = head.js +tail = +firefox-appdir = browser +tags = webextensions + +[test_ext_bookmarks.js] +[test_ext_history.js] +[test_ext_manifest_commands.js] +[test_ext_manifest_omnibox.js] +[test_ext_manifest_permissions.js] |
