diff options
Diffstat (limited to 'browser/base/content/test/menubar')
8 files changed, 756 insertions, 0 deletions
diff --git a/browser/base/content/test/menubar/browser.toml b/browser/base/content/test/menubar/browser.toml new file mode 100644 index 0000000000..4ba2101891 --- /dev/null +++ b/browser/base/content/test/menubar/browser.toml @@ -0,0 +1,22 @@ +[DEFAULT] +prefs = [ + "browser.sessionstore.closedTabsFromAllWindows=true", + "browser.sessionstore.closedTabsFromClosedWindows=true", +] + +["browser_file_close_tabs.js"] + +["browser_file_menu_import_wizard.js"] + +["browser_file_share.js"] +https_first_disabled = true +run-if = ["os == 'mac'"] # Mac only feature + +["browser_history_recently_closed_tabs.js"] +skip-if = ["os == 'mac'"] # No menubar on macOS. + +support-files = ["file_shareurl.html"] + +["browser_search_bookmarks.js"] + +["browser_search_history.js"] diff --git a/browser/base/content/test/menubar/browser_file_close_tabs.js b/browser/base/content/test/menubar/browser_file_close_tabs.js new file mode 100644 index 0000000000..15abd92bba --- /dev/null +++ b/browser/base/content/test/menubar/browser_file_close_tabs.js @@ -0,0 +1,60 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +/** + * This test verifies behavior from bug 1732375: + * https://bugzilla.mozilla.org/show_bug.cgi?id=1732375 + * + * If there are multiple tabs selected, the 'Close' entry + * under the File menu should correctly reflect the number of + * selected tabs + */ +add_task(async function test_menu_close_tab_count() { + // Window should have one tab open already, so we + // just need to add one more to have a total of two + info("Adding new tabs"); + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com"); + + info("Selecting all tabs"); + await gBrowser.selectAllTabs(); + is(gBrowser.multiSelectedTabsCount, 2, "Two (2) tabs are selected"); + + let fileMenu = document.getElementById("menu_FilePopup"); + await simulateMenuOpen(fileMenu); + + let closeMenuEntry = document.getElementById("menu_close"); + let closeMenuL10nArgsObject = document.l10n.getAttributes(closeMenuEntry); + + is( + closeMenuL10nArgsObject.args.tabCount, + 2, + "Menu bar reflects multi-tab selection number (Close 2 Tabs)" + ); + + let onClose = BrowserTestUtils.waitForEvent( + gBrowser.tabContainer, + "TabClose" + ); + + BrowserTestUtils.removeTab(gBrowser.selectedTab); + + await onClose; + + info("Tabs closed"); +}); + +async function simulateMenuOpen(menu) { + return new Promise(resolve => { + menu.addEventListener("popupshown", resolve, { once: true }); + menu.dispatchEvent(new MouseEvent("popupshowing")); + menu.dispatchEvent(new MouseEvent("popupshown")); + }); +} + +async function simulateMenuClosed(menu) { + return new Promise(resolve => { + menu.addEventListener("popuphidden", resolve, { once: true }); + menu.dispatchEvent(new MouseEvent("popuphiding")); + menu.dispatchEvent(new MouseEvent("popuphidden")); + }); +} diff --git a/browser/base/content/test/menubar/browser_file_menu_import_wizard.js b/browser/base/content/test/menubar/browser_file_menu_import_wizard.js new file mode 100644 index 0000000000..9fb969b777 --- /dev/null +++ b/browser/base/content/test/menubar/browser_file_menu_import_wizard.js @@ -0,0 +1,23 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +add_setup(async () => { + // Load the initial tab at example.com. This makes it so that when the + // about:preferences hosting the migration wizard opens, we'll load + // the about:preferences page in a new tab rather than overtaking the + // initial one. This makes it easier to be more explicit when cleaning + // up because we can just remove the opened tab. + let browser = gBrowser.selectedBrowser; + BrowserTestUtils.startLoadingURIString(browser, "https://example.com"); + await BrowserTestUtils.browserLoaded(browser); +}); + +add_task(async function file_menu_import_wizard() { + let wizardTabPromise = BrowserTestUtils.waitForMigrationWizard(window); + document.getElementById("menu_importFromAnotherBrowser").doCommand(); + let wizardTab = await wizardTabPromise; + ok(wizardTab, "Migration wizard tab opened"); + BrowserTestUtils.removeTab(wizardTab); +}); diff --git a/browser/base/content/test/menubar/browser_file_share.js b/browser/base/content/test/menubar/browser_file_share.js new file mode 100644 index 0000000000..bd6a4c3f60 --- /dev/null +++ b/browser/base/content/test/menubar/browser_file_share.js @@ -0,0 +1,136 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const { sinon } = ChromeUtils.importESModule( + "resource://testing-common/Sinon.sys.mjs" +); +const BASE = getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com" +); +const TEST_URL = BASE + "file_shareurl.html"; + +let mockShareData = [ + { + name: "Test", + menuItemTitle: "Sharing Service Test", + image: + "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAKE" + + "lEQVR42u3NQQ0AAAgEoNP+nTWFDzcoQE1udQQCgUAgEAgEAsGTYAGjxAE/G/Q2tQAAAABJRU5ErkJggg==", + }, +]; + +// Setup spies for observing function calls from MacSharingService +let shareUrlSpy = sinon.spy(); +let openSharingPreferencesSpy = sinon.spy(); +let getSharingProvidersSpy = sinon.spy(); + +let stub = sinon.stub(gBrowser, "MacSharingService").get(() => { + return { + getSharingProviders(url) { + getSharingProvidersSpy(url); + return mockShareData; + }, + shareUrl(name, url, title) { + shareUrlSpy(name, url, title); + }, + openSharingPreferences() { + openSharingPreferencesSpy(); + }, + }; +}); + +registerCleanupFunction(async function () { + stub.restore(); +}); + +/** + * Test the "Share" item menus in the tab contextmenu on MacOSX. + */ +add_task(async function test_file_menu_share() { + await BrowserTestUtils.withNewTab(TEST_URL, async () => { + // We can't toggle menubar items on OSX, so mocking instead. + let menu = document.getElementById("menu_FilePopup"); + await simulateMenuOpen(menu); + + await BrowserTestUtils.waitForMutationCondition( + menu, + { childList: true }, + () => menu.querySelector(".share-tab-url-item") + ); + ok(true, "Got Share item"); + + let popup = menu.querySelector(".share-tab-url-item").menupopup; + await simulateMenuOpen(popup); + ok(getSharingProvidersSpy.calledOnce, "getSharingProviders called"); + + info( + "Check we have a service and one extra menu item for the More... button" + ); + let items = popup.querySelectorAll("menuitem"); + is(items.length, 2, "There should be 2 sharing services."); + + info("Click on the sharing service"); + let shareButton = items[0]; + is( + shareButton.label, + mockShareData[0].menuItemTitle, + "Share button's label should match the service's menu item title. " + ); + is( + shareButton.getAttribute("share-name"), + mockShareData[0].name, + "Share button's share-name value should match the service's name. " + ); + + shareButton.doCommand(); + + ok(shareUrlSpy.calledOnce, "shareUrl called"); + + info("Check the correct data was shared."); + let [name, url, title] = shareUrlSpy.getCall(0).args; + is(name, mockShareData[0].name, "Shared correct service name"); + is(url, TEST_URL, "Shared correct URL"); + is(title, "Sharing URL", "Shared the correct title."); + await simulateMenuClosed(popup); + await simulateMenuClosed(menu); + + info("Test the More... button"); + + await simulateMenuOpen(menu); + popup = menu.querySelector(".share-tab-url-item").menupopup; + await simulateMenuOpen(popup); + // Since the menu was collapsed previously, the popup needs to get the + // providers again. + ok(getSharingProvidersSpy.calledTwice, "getSharingProviders called again"); + items = popup.querySelectorAll("menuitem"); + is(items.length, 2, "There should be 2 sharing services."); + + info("Click on the More Button"); + let moreButton = items[1]; + moreButton.doCommand(); + ok(openSharingPreferencesSpy.calledOnce, "openSharingPreferences called"); + // Tidy up: + await simulateMenuClosed(popup); + await simulateMenuClosed(menu); + }); +}); + +async function simulateMenuOpen(menu) { + return new Promise(resolve => { + menu.addEventListener("popupshown", resolve, { once: true }); + menu.dispatchEvent(new MouseEvent("popupshowing")); + menu.dispatchEvent(new MouseEvent("popupshown")); + }); +} + +async function simulateMenuClosed(menu) { + return new Promise(resolve => { + menu.addEventListener("popuphidden", resolve, { once: true }); + menu.dispatchEvent(new MouseEvent("popuphiding")); + menu.dispatchEvent(new MouseEvent("popuphidden")); + }); +} diff --git a/browser/base/content/test/menubar/browser_history_recently_closed_tabs.js b/browser/base/content/test/menubar/browser_history_recently_closed_tabs.js new file mode 100644 index 0000000000..246dce4db0 --- /dev/null +++ b/browser/base/content/test/menubar/browser_history_recently_closed_tabs.js @@ -0,0 +1,397 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ +/** + * This test verifies behavior from bug 1819675: + * https://bugzilla.mozilla.org/show_bug.cgi?id=1819675 + * + * The recently closed tabs menu item should be enabled when there are tabs + * closed from any window that is in the same private/non-private bucket as + * the current window. + */ + +const { SessionStoreTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SessionStoreTestUtils.sys.mjs" +); +const triggeringPrincipal_base64 = E10SUtils.SERIALIZED_SYSTEMPRINCIPAL; +SessionStoreTestUtils.init(this, window); + +async function checkMenu(window, expected) { + await SimpleTest.promiseFocus(window); + const historyMenubarItem = window.document.getElementById("history-menu"); + const historyMenu = window.document.getElementById("historyMenuPopup"); + const recentlyClosedTabsItem = historyMenu.querySelector("#historyUndoMenu"); + + const menuShown = BrowserTestUtils.waitForEvent(historyMenu, "popupshown"); + historyMenubarItem.openMenu(true); + info("checkMenu:, waiting for menuShown"); + await menuShown; + + Assert.equal( + recentlyClosedTabsItem.disabled, + expected.menuItemDisabled, + `Recently closed tabs menu item is ${ + expected.menuItemDisabled ? "disabled" : "not disabled" + }` + ); + const menuHidden = BrowserTestUtils.waitForEvent(historyMenu, "popuphidden"); + historyMenu.hidePopup(); + info("checkMenu:, waiting for menuHidden"); + await menuHidden; + info("checkMenu:, menuHidden, returning"); +} + +function resetClosedTabsAndWindows() { + // Clear the lists of closed windows and tabs. + Services.obs.notifyObservers(null, "browser:purge-session-history"); + is(SessionStore.getClosedWindowCount(), 0, "Expect 0 closed windows"); + for (const win of BrowserWindowTracker.orderedWindows) { + is( + SessionStore.getClosedTabCountForWindow(win), + 0, + "Expect 0 closed tabs for this window" + ); + } +} + +add_task(async function test_recently_closed_tabs_nonprivate() { + await resetClosedTabsAndWindows(); + + const win1 = window; + const win2 = await BrowserTestUtils.openNewBrowserWindow(); + await BrowserTestUtils.openNewForegroundTab( + win1.gBrowser, + "https://example.com" + ); + // we're going to close a tab and don't want to accidentally close the window when it has 0 tabs + await BrowserTestUtils.openNewForegroundTab(win2.gBrowser, "about:about"); + await BrowserTestUtils.openNewForegroundTab( + win2.gBrowser, + "https://example.org" + ); + + info("Checking the menuitem is initially disabled in both windows"); + for (let win of [win1, win2]) { + await checkMenu(win, { + menuItemDisabled: true, + }); + } + + await SessionStoreTestUtils.closeTab(win2.gBrowser.selectedTab); + is( + SessionStore.getClosedTabCount(), + 1, + "Expect closed tab count of 1 after closing a tab" + ); + + for (let win of [win1, win2]) { + await checkMenu(win, { + menuItemDisabled: false, + }); + } + + // clean up + info("clean up opened window"); + const sessionStoreChanged = TestUtils.topicObserved( + "sessionstore-closed-objects-changed" + ); + await BrowserTestUtils.closeWindow(win2); + await sessionStoreChanged; + + info("starting tab cleanup"); + while (gBrowser.tabs.length > 1) { + await SessionStoreTestUtils.closeTab( + gBrowser.tabs[gBrowser.tabs.length - 1] + ); + } + info("finished tab cleanup"); +}); + +add_task(async function test_recently_closed_tabs_nonprivate_pref_off() { + await SpecialPowers.pushPrefEnv({ + set: [["browser.sessionstore.closedTabsFromAllWindows", false]], + }); + await resetClosedTabsAndWindows(); + + const win1 = window; + const win2 = await BrowserTestUtils.openNewBrowserWindow(); + await BrowserTestUtils.openNewForegroundTab( + win1.gBrowser, + "https://example.com" + ); + // we're going to close a tab and don't want to accidentally close the window when it has 0 tabs + await BrowserTestUtils.openNewForegroundTab(win2.gBrowser, "about:about"); + await BrowserTestUtils.openNewForegroundTab( + win2.gBrowser, + "https://example.org" + ); + + info("Checking the menuitem is initially disabled in both windows"); + for (let win of [win1, win2]) { + await checkMenu(win, { + menuItemDisabled: true, + }); + } + await SimpleTest.promiseFocus(win2); + await SessionStoreTestUtils.closeTab(win2.gBrowser.selectedTab); + is( + SessionStore.getClosedTabCount(), + 1, + "Expect closed tab count of 1 after closing a tab" + ); + + await checkMenu(win1, { + menuItemDisabled: true, + }); + await checkMenu(win2, { + menuItemDisabled: false, + }); + + // clean up + info("clean up opened window"); + const sessionStoreChanged = TestUtils.topicObserved( + "sessionstore-closed-objects-changed" + ); + await BrowserTestUtils.closeWindow(win2); + await sessionStoreChanged; + + info("starting tab cleanup"); + while (gBrowser.tabs.length > 1) { + await SessionStoreTestUtils.closeTab( + gBrowser.tabs[gBrowser.tabs.length - 1] + ); + } + info("finished tab cleanup"); + SpecialPowers.popPrefEnv(); +}); + +add_task(async function test_recently_closed_tabs_mixed_private() { + await resetClosedTabsAndWindows(); + is( + SessionStore.getClosedTabCount(), + 0, + "Expect closed tab count of 0 after reset" + ); + + await BrowserTestUtils.openNewForegroundTab(window.gBrowser, "about:robots"); + await BrowserTestUtils.openNewForegroundTab( + window.gBrowser, + "https://example.com" + ); + + const privateWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + await BrowserTestUtils.openNewForegroundTab( + privateWin.gBrowser, + "about:about" + ); + await BrowserTestUtils.openNewForegroundTab( + privateWin.gBrowser, + "https://example.org" + ); + + for (let win of [window, privateWin]) { + await checkMenu(win, { + menuItemDisabled: true, + }); + } + + await SessionStoreTestUtils.closeTab(privateWin.gBrowser.selectedTab); + is( + SessionStore.getClosedTabCount(privateWin), + 1, + "Expect closed tab count of 1 for private windows" + ); + is( + SessionStore.getClosedTabCount(window), + 0, + "Expect closed tab count of 0 for non-private windows" + ); + + // the menu should be enabled only for the private window + await checkMenu(window, { + menuItemDisabled: true, + }); + await checkMenu(privateWin, { + menuItemDisabled: false, + }); + + await resetClosedTabsAndWindows(); + await SimpleTest.promiseFocus(window); + + info("closing tab in non-private window"); + await SessionStoreTestUtils.closeTab(window.gBrowser.selectedTab); + is( + SessionStore.getClosedTabCount(window), + 1, + "Expect 1 closed tab count after closing the a tab in the non-private window" + ); + + // the menu should be enabled only for the non-private window + await checkMenu(window, { + menuItemDisabled: false, + }); + await checkMenu(privateWin, { + menuItemDisabled: true, + }); + + // clean up + info("closing private window"); + await BrowserTestUtils.closeWindow(privateWin); + await TestUtils.waitForTick(); + + info("starting tab cleanup"); + while (gBrowser.tabs.length > 1) { + await SessionStoreTestUtils.closeTab( + gBrowser.tabs[gBrowser.tabs.length - 1] + ); + } + info("finished tab cleanup"); +}); + +add_task(async function test_recently_closed_tabs_mixed_private_pref_off() { + await SpecialPowers.pushPrefEnv({ + set: [["browser.sessionstore.closedTabsFromAllWindows", false]], + }); + await resetClosedTabsAndWindows(); + + await BrowserTestUtils.openNewForegroundTab(window.gBrowser, "about:robots"); + await BrowserTestUtils.openNewForegroundTab( + window.gBrowser, + "https://example.com" + ); + + const privateWin = await BrowserTestUtils.openNewBrowserWindow({ + private: true, + }); + await BrowserTestUtils.openNewForegroundTab( + privateWin.gBrowser, + "about:about" + ); + await BrowserTestUtils.openNewForegroundTab( + privateWin.gBrowser, + "https://example.org" + ); + + for (let win of [window, privateWin]) { + await checkMenu(win, { + menuItemDisabled: true, + }); + } + + await SimpleTest.promiseFocus(privateWin); + await SessionStoreTestUtils.closeTab(privateWin.gBrowser.selectedTab); + is( + SessionStore.getClosedTabCount(privateWin), + 1, + "Expect closed tab count of 1 for private windows" + ); + is( + SessionStore.getClosedTabCount(window), + 0, + "Expect closed tab count of 0 for non-private windows" + ); + + // the menu should be enabled only for the private window + await checkMenu(window, { + menuItemDisabled: true, + }); + await checkMenu(privateWin, { + menuItemDisabled: false, + }); + + await resetClosedTabsAndWindows(); + is( + SessionStore.getClosedTabCount(privateWin), + 0, + "Expect 0 closed tab count after reset" + ); + is( + SessionStore.getClosedTabCount(window), + 0, + "Expect 0 closed tab count after reset" + ); + + info("closing tab in non-private window"); + await SimpleTest.promiseFocus(window); + await SessionStoreTestUtils.closeTab(window.gBrowser.selectedTab); + + // the menu should be enabled only for the non-private window + await checkMenu(window, { + menuItemDisabled: false, + }); + await checkMenu(privateWin, { + menuItemDisabled: true, + }); + + // clean up + info("closing private window"); + await BrowserTestUtils.closeWindow(privateWin); + await TestUtils.waitForTick(); + + info("starting tab cleanup"); + while (gBrowser.tabs.length > 1) { + await SessionStoreTestUtils.closeTab( + gBrowser.tabs[gBrowser.tabs.length - 1] + ); + } + info("finished tab cleanup"); + SpecialPowers.popPrefEnv(); +}); + +add_task(async function test_recently_closed_tabs_closed_windows() { + // prepare window state with closed tabs from closed windows + await SpecialPowers.pushPrefEnv({ + set: [["sessionstore.closedTabsFromClosedWindows", true]], + }); + const closedTabUrls = ["about:robots"]; + const closedWindowState = { + tabs: [ + { + entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }], + }, + ], + _closedTabs: closedTabUrls.map(url => { + return { + state: { + entries: [ + { + url, + triggeringPrincipal_base64, + }, + ], + }, + }; + }), + }; + await SessionStoreTestUtils.promiseBrowserState({ + windows: [ + { + tabs: [ + { + entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }], + }, + ], + }, + ], + _closedWindows: [closedWindowState], + }); + + // verify the recently-closed-tabs menu item is enabled + await checkMenu(window, { + menuItemDisabled: false, + }); + + // flip the pref + await SpecialPowers.popPrefEnv(); + await SpecialPowers.pushPrefEnv({ + set: [["browser.sessionstore.closedTabsFromClosedWindows", false]], + }); + + // verify the recently-closed-tabs menu item is disabled + await checkMenu(window, { + menuItemDisabled: true, + }); + + SpecialPowers.popPrefEnv(); +}); diff --git a/browser/base/content/test/menubar/browser_search_bookmarks.js b/browser/base/content/test/menubar/browser_search_bookmarks.js new file mode 100644 index 0000000000..1c0da6071e --- /dev/null +++ b/browser/base/content/test/menubar/browser_search_bookmarks.js @@ -0,0 +1,60 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * Tests the Search Bookmarks option from the menubar starts Address Bar search + * mode for bookmarks. + */ +ChromeUtils.defineLazyGetter(this, "UrlbarTestUtils", () => { + const { UrlbarTestUtils: module } = ChromeUtils.importESModule( + "resource://testing-common/UrlbarTestUtils.sys.mjs" + ); + module.init(this); + return module; +}); + +add_task(async function test_menu_search_bookmarks_with_window_open() { + info("Opening bookmarks menu"); + let searchBookmarksMenuEntry = document.getElementById( + "menu_searchBookmarks" + ); + + searchBookmarksMenuEntry.doCommand(); + + await isUrlbarInBookmarksSearchMode(window); +}); + +add_task(async function test_menu_search_bookmarks_opens_new_window() { + let newWindowPromise = TestUtils.topicObserved( + "browser-delayed-startup-finished" + ); + + info( + "Executing command in untracked browser window (simulating non-browser window)." + ); + BrowserWindowTracker.untrackForTestsOnly(window); + let searchBookmarksMenuEntry = document.getElementById( + "menu_searchBookmarks" + ); + searchBookmarksMenuEntry.doCommand(); + BrowserWindowTracker.track(window); + + info("Waiting for new window to open."); + let [newWindow] = await newWindowPromise; + await isUrlbarInBookmarksSearchMode(newWindow); + await BrowserTestUtils.closeWindow(newWindow); +}); + +async function isUrlbarInBookmarksSearchMode(targetWin) { + is( + targetWin, + BrowserWindowTracker.getTopWindow(), + "Target window is top window." + ); + await UrlbarTestUtils.promisePopupOpen(targetWin, () => {}); + + // Verify URLBar is in search mode with correct restriction + let searchMode = UrlbarUtils.searchModeForToken("*"); + searchMode.entry = "bookmarkmenu"; + await UrlbarTestUtils.assertSearchMode(targetWin, searchMode); +} diff --git a/browser/base/content/test/menubar/browser_search_history.js b/browser/base/content/test/menubar/browser_search_history.js new file mode 100644 index 0000000000..06c1402362 --- /dev/null +++ b/browser/base/content/test/menubar/browser_search_history.js @@ -0,0 +1,56 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +/** + * Tests the Search History option from the menubar starts Address Bar search + * mode for history. + */ +ChromeUtils.defineLazyGetter(this, "UrlbarTestUtils", () => { + const { UrlbarTestUtils: module } = ChromeUtils.importESModule( + "resource://testing-common/UrlbarTestUtils.sys.mjs" + ); + module.init(this); + return module; +}); + +add_task(async function test_menu_search_history_with_window_open() { + info("Opening history menu"); + let searchHistoryMenuEntry = document.getElementById("menu_searchHistory"); + + searchHistoryMenuEntry.doCommand(); + + await isUrlbarInHistorySearchMode(window); +}); + +add_task(async function test_menu_search_history_opens_new_window() { + let newWindowPromise = TestUtils.topicObserved( + "browser-delayed-startup-finished" + ); + + info( + "Executing command in untracked browser window (simulating non-browser window)." + ); + BrowserWindowTracker.untrackForTestsOnly(window); + let searchHistoryMenuEntry = document.getElementById("menu_searchHistory"); + searchHistoryMenuEntry.doCommand(); + BrowserWindowTracker.track(window); + + info("Waiting for new window to open."); + let [newWindow] = await newWindowPromise; + await isUrlbarInHistorySearchMode(newWindow); + await BrowserTestUtils.closeWindow(newWindow); +}); + +async function isUrlbarInHistorySearchMode(targetWin) { + is( + targetWin, + BrowserWindowTracker.getTopWindow(), + "Target window is top window." + ); + await UrlbarTestUtils.promisePopupOpen(targetWin, () => {}); + + // Verify URLBar is in search mode with correct restriction + let searchMode = UrlbarUtils.searchModeForToken("^"); + searchMode.entry = "historymenu"; + await UrlbarTestUtils.assertSearchMode(targetWin, searchMode); +} diff --git a/browser/base/content/test/menubar/file_shareurl.html b/browser/base/content/test/menubar/file_shareurl.html new file mode 100644 index 0000000000..c7fb193972 --- /dev/null +++ b/browser/base/content/test/menubar/file_shareurl.html @@ -0,0 +1,2 @@ +<!DOCTYPE html> +<title>Sharing URL</title> |