From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../test/browser_history_recently_closed.js | 430 +++++++++++++++++++++ 1 file changed, 430 insertions(+) create mode 100644 browser/components/customizableui/test/browser_history_recently_closed.js (limited to 'browser/components/customizableui/test/browser_history_recently_closed.js') diff --git a/browser/components/customizableui/test/browser_history_recently_closed.js b/browser/components/customizableui/test/browser_history_recently_closed.js new file mode 100644 index 0000000000..32c75ec8e2 --- /dev/null +++ b/browser/components/customizableui/test/browser_history_recently_closed.js @@ -0,0 +1,430 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +const { SessionStoreTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/SessionStoreTestUtils.sys.mjs" +); +const triggeringPrincipal_base64 = E10SUtils.SERIALIZED_SYSTEMPRINCIPAL; + +SessionStoreTestUtils.init(this, window); + +const TEST_PATH = getRootDirectory(gTestPath).replace( + "chrome://mochitests/content", + "http://example.com" +); + +let panelMenuWidgetAdded = false; +function prepareHistoryPanel() { + if (panelMenuWidgetAdded) { + return; + } + CustomizableUI.addWidgetToArea( + "history-panelmenu", + CustomizableUI.AREA_FIXED_OVERFLOW_PANEL + ); + registerCleanupFunction(() => CustomizableUI.reset()); +} + +async function openRecentlyClosedTabsMenu() { + prepareHistoryPanel(); + await openHistoryPanel(); + + let recentlyClosedTabs = document.getElementById("appMenuRecentlyClosedTabs"); + Assert.ok( + !recentlyClosedTabs.getAttribute("disabled"), + "Recently closed tabs button enabled" + ); + let closeTabsPanel = document.getElementById( + "appMenu-library-recentlyClosedTabs" + ); + let panelView = closeTabsPanel && PanelView.forNode(closeTabsPanel); + if (!panelView?.active) { + recentlyClosedTabs.click(); + closeTabsPanel = document.getElementById( + "appMenu-library-recentlyClosedTabs" + ); + await BrowserTestUtils.waitForEvent(closeTabsPanel, "ViewShown"); + ok( + PanelView.forNode(closeTabsPanel)?.active, + "Opened 'Recently closed tabs' panel" + ); + } + + return closeTabsPanel; +} + +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" + ); + } +} + +registerCleanupFunction(async () => { + await resetClosedTabsAndWindows(); +}); + +add_task(async function testRecentlyClosedDisabled() { + info("Check history recently closed tabs/windows section"); + + prepareHistoryPanel(); + // We need to make sure the history is cleared before starting the test + await Sanitizer.sanitize(["history"]); + + await openHistoryPanel(); + + let recentlyClosedTabs = document.getElementById("appMenuRecentlyClosedTabs"); + let recentlyClosedWindows = document.getElementById( + "appMenuRecentlyClosedWindows" + ); + + // Wait for the disabled attribute to change, as we receive + // the "viewshown" event before this changes + await BrowserTestUtils.waitForCondition( + () => recentlyClosedTabs.getAttribute("disabled"), + "Waiting for button to become disabled" + ); + Assert.ok( + recentlyClosedTabs.getAttribute("disabled"), + "Recently closed tabs button disabled" + ); + Assert.ok( + recentlyClosedWindows.getAttribute("disabled"), + "Recently closed windows button disabled" + ); + + await hideHistoryPanel(); + + gBrowser.selectedTab.focus(); + await SessionStoreTestUtils.openAndCloseTab( + window, + TEST_PATH + "dummy_history_item.html" + ); + + await openHistoryPanel(); + + await BrowserTestUtils.waitForCondition( + () => !recentlyClosedTabs.getAttribute("disabled"), + "Waiting for button to be enabled" + ); + Assert.ok( + !recentlyClosedTabs.getAttribute("disabled"), + "Recently closed tabs is available" + ); + Assert.ok( + recentlyClosedWindows.getAttribute("disabled"), + "Recently closed windows button disabled" + ); + + await hideHistoryPanel(); + + let newWin = await BrowserTestUtils.openNewBrowserWindow(); + let loadedPromise = BrowserTestUtils.browserLoaded( + newWin.gBrowser.selectedBrowser + ); + BrowserTestUtils.startLoadingURIString( + newWin.gBrowser.selectedBrowser, + "about:mozilla" + ); + await loadedPromise; + await BrowserTestUtils.closeWindow(newWin); + + await openHistoryPanel(); + + await BrowserTestUtils.waitForCondition( + () => !recentlyClosedWindows.getAttribute("disabled"), + "Waiting for button to be enabled" + ); + Assert.ok( + !recentlyClosedTabs.getAttribute("disabled"), + "Recently closed tabs is available" + ); + Assert.ok( + !recentlyClosedWindows.getAttribute("disabled"), + "Recently closed windows is available" + ); + + await hideHistoryPanel(); +}); + +add_task(async function testRecentlyClosedTabsDisabledPersists() { + info("Check history recently closed tabs/windows section"); + + prepareHistoryPanel(); + + // We need to make sure the history is cleared before starting the test + await Sanitizer.sanitize(["history"]); + + await openHistoryPanel(); + + let recentlyClosedTabs = document.getElementById("appMenuRecentlyClosedTabs"); + Assert.ok( + recentlyClosedTabs.getAttribute("disabled"), + "Recently closed tabs button disabled" + ); + + await hideHistoryPanel(); + + let newWin = await BrowserTestUtils.openNewBrowserWindow(); + + await openHistoryPanel(newWin.document); + recentlyClosedTabs = newWin.document.getElementById( + "appMenuRecentlyClosedTabs" + ); + Assert.ok( + recentlyClosedTabs.getAttribute("disabled"), + "Recently closed tabs is disabled" + ); + + // We close the window without hiding the panel first, which used to interfere + // with populating the view subsequently. + await BrowserTestUtils.closeWindow(newWin); + + newWin = await BrowserTestUtils.openNewBrowserWindow(); + await openHistoryPanel(newWin.document); + recentlyClosedTabs = newWin.document.getElementById( + "appMenuRecentlyClosedTabs" + ); + Assert.ok( + recentlyClosedTabs.getAttribute("disabled"), + "Recently closed tabs is disabled" + ); + await hideHistoryPanel(newWin.document); + await BrowserTestUtils.closeWindow(newWin); +}); + +add_task(async function testRecentlyClosedRestoreAllTabs() { + // We need to make sure the history is cleared before starting the test + await Sanitizer.sanitize(["history"]); + await resetClosedTabsAndWindows(); + const initialTabCount = gBrowser.visibleTabs.length; + + const closedTabUrls = [ + "about:robots", + "https://example.com/", + "https://example.org/", + ]; + const windowState = { + tabs: [ + { + entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }], + }, + ], + _closedTabs: closedTabUrls.map(url => { + return { + title: url, + state: { + entries: [ + { + url, + triggeringPrincipal_base64, + }, + ], + }, + }; + }), + }; + await SessionStoreTestUtils.promiseBrowserState({ + windows: [windowState], + }); + + is(gBrowser.visibleTabs.length, 1, "We start with one tab open"); + // Open the "Recently closed tabs" panel. + let closeTabsPanel = await openRecentlyClosedTabsMenu(); + + // Click the first toolbar button in the panel. + let toolbarButton = closeTabsPanel.querySelector( + ".panel-subview-body toolbarbutton" + ); + let newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true); + EventUtils.sendMouseEvent({ type: "click" }, toolbarButton, window); + + info( + "We should reopen the first of closedTabUrls: " + + JSON.stringify(closedTabUrls) + ); + let reopenedTab = await newTabPromise; + is( + reopenedTab.linkedBrowser.currentURI.spec, + closedTabUrls[0], + "Opened the first URL" + ); + info(`restored tab, total open tabs: ${gBrowser.tabs.length}`); + + info("waiting for closeTab"); + await SessionStoreTestUtils.closeTab(reopenedTab); + + await openRecentlyClosedTabsMenu(); + let restoreAllItem = closeTabsPanel.querySelector(".restoreallitem"); + ok( + restoreAllItem && !restoreAllItem.hidden, + "Restore all menu item is not hidden" + ); + + // Click the restore-all toolbar button in the panel. + EventUtils.sendMouseEvent({ type: "click" }, restoreAllItem, window); + + info("waiting for restored tabs"); + await BrowserTestUtils.waitForCondition( + () => SessionStore.getClosedTabCount() === 0, + "Waiting for all the closed tabs to be opened" + ); + + is( + gBrowser.tabs.length, + initialTabCount + closedTabUrls.length, + "The expected number of closed tabs were restored" + ); + + // clean up extra tabs + while (gBrowser.tabs.length > 1) { + BrowserTestUtils.removeTab(gBrowser.tabs.at(-1)); + } +}); + +add_task(async function testRecentlyClosedWindows() { + // We need to make sure the history is cleared before starting the test + await Sanitizer.sanitize(["history"]); + await resetClosedTabsAndWindows(); + + // Open and close a new window. + let newWin = await BrowserTestUtils.openNewBrowserWindow(); + let loadedPromise = BrowserTestUtils.browserLoaded( + newWin.gBrowser.selectedBrowser + ); + BrowserTestUtils.startLoadingURIString( + newWin.gBrowser.selectedBrowser, + "https://example.com" + ); + await loadedPromise; + let closedObjectsChangePromise = TestUtils.topicObserved( + "sessionstore-closed-objects-changed" + ); + await BrowserTestUtils.closeWindow(newWin); + await closedObjectsChangePromise; + + prepareHistoryPanel(); + await openHistoryPanel(); + + // Open the "Recently closed windows" panel. + document.getElementById("appMenuRecentlyClosedWindows").click(); + + let winPanel = document.getElementById( + "appMenu-library-recentlyClosedWindows" + ); + await BrowserTestUtils.waitForEvent(winPanel, "ViewShown"); + ok(true, "Opened 'Recently closed windows' panel"); + + // Click the first toolbar button in the panel. + let panelBody = winPanel.querySelector(".panel-subview-body"); + let toolbarButton = panelBody.querySelector("toolbarbutton"); + let newWindowPromise = BrowserTestUtils.waitForNewWindow({ + url: "https://example.com/", + }); + closedObjectsChangePromise = TestUtils.topicObserved( + "sessionstore-closed-objects-changed" + ); + EventUtils.sendMouseEvent({ type: "click" }, toolbarButton, window); + + newWin = await newWindowPromise; + await closedObjectsChangePromise; + is(gBrowser.tabs.length, 1, "Did not open new tabs"); + + await BrowserTestUtils.closeWindow(newWin); +}); + +add_task(async function testRecentlyClosedTabsFromClosedWindows() { + await resetClosedTabsAndWindows(); + const closedTabUrls = [ + "about:robots", + "https://example.com/", + "https://example.org/", + ]; + const closedWindowState = { + tabs: [ + { + entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }], + }, + ], + _closedTabs: closedTabUrls.map(url => { + return { + title: url, + state: { + entries: [ + { + url, + triggeringPrincipal_base64, + }, + ], + }, + }; + }), + }; + await SessionStoreTestUtils.promiseBrowserState({ + windows: [ + { + tabs: [ + { + entries: [{ url: "about:mozilla", triggeringPrincipal_base64 }], + }, + ], + }, + ], + _closedWindows: [closedWindowState], + }); + Assert.equal( + SessionStore.getClosedTabCountFromClosedWindows(), + closedTabUrls.length, + "Sanity check number of closed tabs from closed windows" + ); + + prepareHistoryPanel(); + let closeTabsPanel = await openRecentlyClosedTabsMenu(); + // make sure we can actually restore one of these closed tabs + const closedTabItems = closeTabsPanel.querySelectorAll( + "toolbarbutton[targetURI]" + ); + Assert.equal( + closedTabItems.length, + closedTabUrls.length, + "We have expected number of closed tab items" + ); + + const newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true); + const closedObjectsChangePromise = TestUtils.topicObserved( + "sessionstore-closed-objects-changed" + ); + EventUtils.sendMouseEvent({ type: "click" }, closedTabItems[0], window); + await newTabPromise; + await closedObjectsChangePromise; + + // flip the pref so none of the closed tabs from closed window are included + await SpecialPowers.pushPrefEnv({ + set: [["browser.sessionstore.closedTabsFromClosedWindows", false]], + }); + await openHistoryPanel(); + + // verify the recently-closed-tabs menu item is disabled + let recentlyClosedTabsItem = document.getElementById( + "appMenuRecentlyClosedTabs" + ); + Assert.ok( + recentlyClosedTabsItem.hasAttribute("disabled"), + "Recently closed tabs button is now disabled" + ); + SpecialPowers.popPrefEnv(); + while (gBrowser.tabs.length > 1) { + await SessionStoreTestUtils.closeTab( + gBrowser.tabs[gBrowser.tabs.length - 1] + ); + } +}); -- cgit v1.2.3