mozilla-central/browser/components/customizableui/test/browser_history_recently_closed.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Errors

/* 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(
);
const { TabStateFlusher } = ChromeUtils.importESModule(
"resource:///modules/sessionstore/TabStateFlusher.sys.mjs"
);
const triggeringPrincipal_base64 = E10SUtils.SERIALIZED_SYSTEMPRINCIPAL;
SessionStoreTestUtils.init(this, window);
const TEST_PATH = getRootDirectory(gTestPath).replace(
);
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",
];
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,
);
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({
});
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",
];
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"
);
await hideHistoryPanel();
SpecialPowers.popPrefEnv();
while (gBrowser.tabs.length > 1) {
await SessionStoreTestUtils.closeTab(
gBrowser.tabs[gBrowser.tabs.length - 1]
);
}
});
add_task(async function testRecentlyClosedTabGroupsSingleTab() {
// We need to make sure the history is cleared before starting the test
await Sanitizer.sanitize(["history"]);
await resetClosedTabsAndWindows();
prepareHistoryPanel();
is(gBrowser.visibleTabs.length, 1, "We start with one tab already open");
let aboutMozillaTab = BrowserTestUtils.addTab(gBrowser, "about:mozilla");
let aboutLogoTab = BrowserTestUtils.addTab(gBrowser, "about:logo");
let mozillaTabGroup = gBrowser.addTabGroup([aboutMozillaTab, aboutLogoTab], {
color: "red",
label: "mozilla stuff",
});
const mozillaTabGroupId = mozillaTabGroup.id;
const mozillaTabGroupName = mozillaTabGroup.label;
let aboutRobotsTab = BrowserTestUtils.addTab(gBrowser, "about:robots");
info("load all of the tabs");
await Promise.all(
[aboutMozillaTab, aboutLogoTab, aboutRobotsTab].map(async t => {
await BrowserTestUtils.browserLoaded(t.linkedBrowser);
await TabStateFlusher.flush(t.linkedBrowser);
})
);
info("close the tab group and wait for it to be removed");
let removePromise = BrowserTestUtils.waitForEvent(
mozillaTabGroup,
"TabGroupRemoved"
);
gBrowser.removeTabGroup(mozillaTabGroup);
await removePromise;
is(
gBrowser.visibleTabs.length,
2,
"The tab from before the test plus about:robots should still be open"
);
info("Open the 'Recently closed tabs' panel.");
let closeTabsPanel = await openRecentlyClosedTabsMenu();
// Click the tab group button in the panel.
let tabGroupToolbarButton = closeTabsPanel.querySelector(
`.panel-subview-body toolbarbutton[label="${mozillaTabGroupName}"]`
);
ok(tabGroupToolbarButton, "should find the tab group toolbar button");
let tabGroupPanelview = document.getElementById(
`closed-tabs-tab-group-${mozillaTabGroupId}`
);
ok(tabGroupPanelview, "should find the tab group panelview");
EventUtils.sendMouseEvent({ type: "click" }, tabGroupToolbarButton, window);
await BrowserTestUtils.waitForEvent(tabGroupPanelview, "ViewShown");
info("restore the first tab from the closed tab group");
let newTabPromise = BrowserTestUtils.waitForNewTab(gBrowser, null, true);
let tabToolbarButton = tabGroupPanelview.querySelector(
".panel-subview-body toolbarbutton"
);
ok(tabToolbarButton, "should find at least one tab to restore");
let tabTitle = tabToolbarButton.label;
EventUtils.sendMouseEvent({ type: "click" }, tabToolbarButton, window);
let reopenedTab = await newTabPromise;
is(reopenedTab.label, tabTitle, "Opened the first URL");
info(`restored tab, total open tabs: ${gBrowser.tabs.length}`);
// clean up extra tabs
while (gBrowser.tabs.length > 1) {
BrowserTestUtils.removeTab(gBrowser.tabs.at(-1));
}
});