diff options
Diffstat (limited to 'browser/base/content/test/popupNotifications')
18 files changed, 3863 insertions, 0 deletions
diff --git a/browser/base/content/test/popupNotifications/browser.ini b/browser/base/content/test/popupNotifications/browser.ini new file mode 100644 index 0000000000..a5a8ab4eb9 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser.ini @@ -0,0 +1,38 @@ +[DEFAULT] +support-files = + head.js + +[browser_displayURI.js] +skip-if = (os == "linux" && (debug || asan)) +[browser_popupNotification.js] +skip-if = (os == "linux" && (debug || asan)) +[browser_popupNotification_2.js] +https_first_disabled = true +skip-if = (os == "linux" && (debug || asan)) || (os == "linux" && bits == 64 && os_version == "18.04") # bug 1251135 +[browser_popupNotification_3.js] +https_first_disabled = true +skip-if = (os == "linux" && (debug || asan)) || verify +[browser_popupNotification_4.js] +skip-if = (os == "linux" && (debug || asan)) +[browser_popupNotification_5.js] +skip-if = true # bug 1332646 +[browser_popupNotification_accesskey.js] +skip-if = (os == "linux" && (debug || asan)) || os == "mac" +[browser_popupNotification_checkbox.js] +skip-if = (os == "linux" && (debug || asan)) +[browser_popupNotification_hide_after_identity_panel.js] +skip-if = (os == "linux" && (debug || asan)) +[browser_popupNotification_hide_after_protections_panel.js] +skip-if = (os == "linux" && (debug || asan)) +[browser_popupNotification_keyboard.js] +skip-if = (os == "linux" && (debug || asan)) +[browser_popupNotification_learnmore.js] +skip-if = (os == "linux" && (debug || asan)) +[browser_popupNotification_no_anchors.js] +https_first_disabled = true +skip-if = (os == "linux" && (debug || asan)) +[browser_popupNotification_security_delay.js] +[browser_popupNotification_selection_required.js] +skip-if = (os == "linux" && (debug || asan)) +[browser_reshow_in_background.js] +skip-if = (os == "linux" && (debug || asan)) diff --git a/browser/base/content/test/popupNotifications/browser_displayURI.js b/browser/base/content/test/popupNotifications/browser_displayURI.js new file mode 100644 index 0000000000..c9e677cd45 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_displayURI.js @@ -0,0 +1,159 @@ +/* + * Make sure that the correct origin is shown for permission prompts. + */ + +async function check(contentTask, options = {}) { + await BrowserTestUtils.withNewTab( + "https://test1.example.com/", + async function (browser) { + let popupShownPromise = waitForNotificationPanel(); + await SpecialPowers.spawn(browser, [], contentTask); + let panel = await popupShownPromise; + let notification = panel.children[0]; + let body = notification.querySelector(".popup-notification-body"); + ok( + body.innerHTML.includes("example.com"), + "Check that at least the eTLD+1 is present in the markup" + ); + } + ); + + let channel = NetUtil.newChannel({ + uri: getRootDirectory(gTestPath), + loadUsingSystemPrincipal: true, + }); + channel = channel.QueryInterface(Ci.nsIFileChannel); + + await BrowserTestUtils.withNewTab( + channel.file.path, + async function (browser) { + let popupShownPromise = waitForNotificationPanel(); + await SpecialPowers.spawn(browser, [], contentTask); + let panel = await popupShownPromise; + let notification = panel.children[0]; + let body = notification.querySelector(".popup-notification-body"); + if ( + notification.id == "geolocation-notification" || + notification.id == "xr-notification" + ) { + ok( + body.innerHTML.includes("local file"), + `file:// URIs should be displayed as local file.` + ); + } else { + ok( + body.innerHTML.includes("Unknown origin"), + "file:// URIs should be displayed as unknown origin." + ); + } + } + ); + + if (!options.skipOnExtension) { + // Test the scenario also on the extension page if not explicitly unsupported + // (e.g. an extension page can't be navigated on a blob URL). + let extension = ExtensionTestUtils.loadExtension({ + manifest: { + name: "Test Extension Name", + }, + background() { + let { browser } = this; + browser.test.sendMessage( + "extension-tab-url", + browser.runtime.getURL("extension-tab-page.html") + ); + }, + files: { + "extension-tab-page.html": `<!DOCTYPE html><html><body></body></html>`, + }, + }); + + await extension.startup(); + let extensionURI = await extension.awaitMessage("extension-tab-url"); + + await BrowserTestUtils.withNewTab(extensionURI, async function (browser) { + let popupShownPromise = waitForNotificationPanel(); + await SpecialPowers.spawn(browser, [], contentTask); + let panel = await popupShownPromise; + let notification = panel.children[0]; + let body = notification.querySelector(".popup-notification-body"); + ok( + body.innerHTML.includes("Test Extension Name"), + "Check the the extension name is present in the markup" + ); + }); + + await extension.unload(); + } +} + +add_setup(async function () { + await SpecialPowers.pushPrefEnv({ + set: [ + ["media.navigator.permission.fake", true], + ["media.navigator.permission.force", true], + ["dom.vr.always_support_vr", true], + ], + }); +}); + +add_task(async function test_displayURI_geo() { + await check(async function () { + content.navigator.geolocation.getCurrentPosition(() => {}); + }); +}); + +const kVREnabled = SpecialPowers.getBoolPref("dom.vr.enabled"); +if (kVREnabled) { + add_task(async function test_displayURI_xr() { + await check(async function () { + content.navigator.getVRDisplays(); + }); + }); +} + +add_task(async function test_displayURI_camera() { + await check(async function () { + content.navigator.mediaDevices.getUserMedia({ video: true, fake: true }); + }); +}); + +add_task(async function test_displayURI_geo_blob() { + await check( + async function () { + let text = + "<script>navigator.geolocation.getCurrentPosition(() => {})</script>"; + let blob = new Blob([text], { type: "text/html" }); + let url = content.URL.createObjectURL(blob); + content.location.href = url; + }, + { skipOnExtension: true } + ); +}); + +if (kVREnabled) { + add_task(async function test_displayURI_xr_blob() { + await check( + async function () { + let text = "<script>navigator.getVRDisplays()</script>"; + let blob = new Blob([text], { type: "text/html" }); + let url = content.URL.createObjectURL(blob); + content.location.href = url; + }, + { skipOnExtension: true } + ); + }); +} + +add_task(async function test_displayURI_camera_blob() { + await check( + async function () { + let text = + "<script>navigator.mediaDevices.getUserMedia({video: true, fake: true})</script>"; + let blob = new Blob([text], { type: "text/html" }); + let url = content.URL.createObjectURL(blob); + content.location.href = url; + }, + { skipOnExtension: true } + ); +}); diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification.js b/browser/base/content/test/popupNotifications/browser_popupNotification.js new file mode 100644 index 0000000000..235aa90b5f --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification.js @@ -0,0 +1,394 @@ +/* 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/. */ + +// These are shared between test #4 to #5 +var wrongBrowserNotificationObject = new BasicNotification("wrongBrowser"); +var wrongBrowserNotification; + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + setup(); +} + +var tests = [ + { + id: "Test#1", + run() { + this.notifyObj = new BasicNotification(this.id); + showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + triggerMainCommand(popup); + }, + onHidden(popup) { + ok(this.notifyObj.mainActionClicked, "mainAction was clicked"); + ok( + !this.notifyObj.dismissalCallbackTriggered, + "dismissal callback wasn't triggered" + ); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + is( + this.notifyObj.mainActionSource, + "button", + "main action should have been triggered by button." + ); + is( + this.notifyObj.secondaryActionSource, + undefined, + "shouldn't have a secondary action source." + ); + }, + }, + { + id: "Test#2", + run() { + this.notifyObj = new BasicNotification(this.id); + showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + triggerSecondaryCommand(popup, 0); + }, + onHidden(popup) { + ok(this.notifyObj.secondaryActionClicked, "secondaryAction was clicked"); + ok( + !this.notifyObj.dismissalCallbackTriggered, + "dismissal callback wasn't triggered" + ); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + is( + this.notifyObj.mainActionSource, + undefined, + "shouldn't have a main action source." + ); + is( + this.notifyObj.secondaryActionSource, + "button", + "secondary action should have been triggered by button." + ); + }, + }, + { + id: "Test#2b", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.secondaryActions.push({ + label: "Extra Secondary Action", + accessKey: "E", + callback: () => (this.extraSecondaryActionClicked = true), + }); + showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + triggerSecondaryCommand(popup, 1); + }, + onHidden(popup) { + ok( + this.extraSecondaryActionClicked, + "extra secondary action was clicked" + ); + ok( + !this.notifyObj.dismissalCallbackTriggered, + "dismissal callback wasn't triggered" + ); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + }, + }, + { + id: "Test#2c", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.secondaryActions.push( + { + label: "Extra Secondary Action", + accessKey: "E", + callback: () => ok(false, "unexpected callback invocation"), + }, + { + label: "Other Extra Secondary Action", + accessKey: "O", + callback: () => (this.extraSecondaryActionClicked = true), + } + ); + showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + triggerSecondaryCommand(popup, 2); + }, + onHidden(popup) { + ok( + this.extraSecondaryActionClicked, + "extra secondary action was clicked" + ); + ok( + !this.notifyObj.dismissalCallbackTriggered, + "dismissal callback wasn't triggered" + ); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + }, + }, + { + id: "Test#3", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + dismissNotification(popup); + }, + onHidden(popup) { + ok( + this.notifyObj.dismissalCallbackTriggered, + "dismissal callback triggered" + ); + this.notification.remove(); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + }, + }, + // test opening a notification for a background browser + // Note: test 4 to 6 share a tab. + { + id: "Test#4", + async run() { + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + let tab = BrowserTestUtils.addTab(gBrowser, "http://example.com/"); + await BrowserTestUtils.browserLoaded(tab.linkedBrowser); + isnot(gBrowser.selectedTab, tab, "new tab isn't selected"); + wrongBrowserNotificationObject.browser = gBrowser.getBrowserForTab(tab); + let promiseTopic = TestUtils.topicObserved( + "PopupNotifications-backgroundShow" + ); + wrongBrowserNotification = showNotification( + wrongBrowserNotificationObject + ); + await promiseTopic; + is(PopupNotifications.isPanelOpen, false, "panel isn't open"); + ok( + !wrongBrowserNotificationObject.mainActionClicked, + "main action wasn't clicked" + ); + ok( + !wrongBrowserNotificationObject.secondaryActionClicked, + "secondary action wasn't clicked" + ); + ok( + !wrongBrowserNotificationObject.dismissalCallbackTriggered, + "dismissal callback wasn't called" + ); + goNext(); + }, + }, + // now select that browser and test to see that the notification appeared + { + id: "Test#5", + run() { + this.oldSelectedTab = gBrowser.selectedTab; + gBrowser.selectedTab = gBrowser.tabs[gBrowser.tabs.length - 1]; + }, + onShown(popup) { + checkPopup(popup, wrongBrowserNotificationObject); + is( + PopupNotifications.isPanelOpen, + true, + "isPanelOpen getter doesn't lie" + ); + + // switch back to the old browser + gBrowser.selectedTab = this.oldSelectedTab; + }, + onHidden(popup) { + // actually remove the notification to prevent it from reappearing + ok( + wrongBrowserNotificationObject.dismissalCallbackTriggered, + "dismissal callback triggered due to tab switch" + ); + wrongBrowserNotification.remove(); + ok( + wrongBrowserNotificationObject.removedCallbackTriggered, + "removed callback triggered" + ); + wrongBrowserNotification = null; + }, + }, + // test that the removed notification isn't shown on browser re-select + { + id: "Test#6", + async run() { + let promiseTopic = TestUtils.topicObserved( + "PopupNotifications-updateNotShowing" + ); + gBrowser.selectedTab = gBrowser.tabs[gBrowser.tabs.length - 1]; + await promiseTopic; + is(PopupNotifications.isPanelOpen, false, "panel isn't open"); + gBrowser.removeTab(gBrowser.selectedTab); + goNext(); + }, + }, + // Test that two notifications with the same ID result in a single displayed + // notification. + { + id: "Test#7", + run() { + this.notifyObj = new BasicNotification(this.id); + // Show the same notification twice + this.notification1 = showNotification(this.notifyObj); + this.notification2 = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + this.notification2.remove(); + }, + onHidden(popup) { + ok( + !this.notifyObj.dismissalCallbackTriggered, + "dismissal callback wasn't triggered" + ); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + }, + }, + // Test that two notifications with different IDs are displayed + { + id: "Test#8", + run() { + this.testNotif1 = new BasicNotification(this.id); + this.testNotif1.message += " 1"; + showNotification(this.testNotif1); + this.testNotif2 = new BasicNotification(this.id); + this.testNotif2.message += " 2"; + this.testNotif2.id += "-2"; + showNotification(this.testNotif2); + }, + onShown(popup) { + is(popup.children.length, 2, "two notifications are shown"); + // Trigger the main command for the first notification, and the secondary + // for the second. Need to do mainCommand first since the secondaryCommand + // triggering is async. + triggerMainCommand(popup); + is(popup.children.length, 1, "only one notification left"); + triggerSecondaryCommand(popup, 0); + }, + onHidden(popup) { + ok(this.testNotif1.mainActionClicked, "main action #1 was clicked"); + ok( + !this.testNotif1.secondaryActionClicked, + "secondary action #1 wasn't clicked" + ); + ok( + !this.testNotif1.dismissalCallbackTriggered, + "dismissal callback #1 wasn't called" + ); + + ok(!this.testNotif2.mainActionClicked, "main action #2 wasn't clicked"); + ok( + this.testNotif2.secondaryActionClicked, + "secondary action #2 was clicked" + ); + ok( + !this.testNotif2.dismissalCallbackTriggered, + "dismissal callback #2 wasn't called" + ); + }, + }, + // Test notification without mainAction or secondaryActions, it should fall back + // to a default button that dismisses the notification in place of the main action. + { + id: "Test#9", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.mainAction = null; + this.notifyObj.secondaryActions = null; + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + let notification = popup.children[0]; + ok( + notification.hasAttribute("buttonhighlight"), + "default action is highlighted" + ); + triggerMainCommand(popup); + }, + onHidden(popup) { + ok(!this.notifyObj.mainActionClicked, "mainAction was not clicked"); + ok( + !this.notifyObj.dismissalCallbackTriggered, + "dismissal callback wasn't triggered" + ); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + }, + }, + // Test notification without mainAction but with secondaryActions, it should fall back + // to a default button that dismisses the notification in place of the main action + // and ignore the passed secondaryActions. + { + id: "Test#10", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.mainAction = null; + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + let notification = popup.children[0]; + is( + notification.getAttribute("secondarybuttonhidden"), + "true", + "secondary button is hidden" + ); + ok( + notification.hasAttribute("buttonhighlight"), + "default action is highlighted" + ); + triggerMainCommand(popup); + }, + onHidden(popup) { + ok(!this.notifyObj.mainActionClicked, "mainAction was not clicked"); + ok( + !this.notifyObj.dismissalCallbackTriggered, + "dismissal callback wasn't triggered" + ); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + }, + }, + // Test two notifications with different anchors + { + id: "Test#11", + run() { + this.notifyObj = new BasicNotification(this.id); + this.firstNotification = showNotification(this.notifyObj); + this.notifyObj2 = new BasicNotification(this.id); + this.notifyObj2.id += "-2"; + this.notifyObj2.anchorID = "addons-notification-icon"; + // Second showNotification() overrides the first + this.secondNotification = showNotification(this.notifyObj2); + }, + onShown(popup) { + // This also checks that only one element is shown. + checkPopup(popup, this.notifyObj2); + is( + document.getElementById("geo-notification-icon").getBoundingClientRect() + .width, + 0, + "geo anchor shouldn't be visible" + ); + dismissNotification(popup); + }, + onHidden(popup) { + // Remove the notifications + this.firstNotification.remove(); + this.secondNotification.remove(); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + ok( + this.notifyObj2.removedCallbackTriggered, + "removed callback triggered" + ); + }, + }, +]; diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_2.js b/browser/base/content/test/popupNotifications/browser_popupNotification_2.js new file mode 100644 index 0000000000..8738a3b605 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_2.js @@ -0,0 +1,315 @@ +/* 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/. */ + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + setup(); +} + +var tests = [ + // Test optional params + { + id: "Test#1", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.secondaryActions = undefined; + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + dismissNotification(popup); + }, + onHidden(popup) { + ok( + this.notifyObj.dismissalCallbackTriggered, + "dismissal callback triggered" + ); + this.notification.remove(); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + }, + }, + // Test that icons appear + { + id: "Test#2", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.id = "geolocation"; + this.notifyObj.anchorID = "geo-notification-icon"; + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + isnot( + document.getElementById("geo-notification-icon").getBoundingClientRect() + .width, + 0, + "geo anchor should be visible" + ); + dismissNotification(popup); + }, + onHidden(popup) { + let icon = document.getElementById("geo-notification-icon"); + isnot( + icon.getBoundingClientRect().width, + 0, + "geo anchor should be visible after dismissal" + ); + this.notification.remove(); + is( + icon.getBoundingClientRect().width, + 0, + "geo anchor should not be visible after removal" + ); + }, + }, + + // Test that persistence allows the notification to persist across reloads + { + id: "Test#3", + async run() { + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.addOptions({ + persistence: 2, + }); + this.notification = showNotification(this.notifyObj); + }, + async onShown(popup) { + this.complete = false; + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.org/"); + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.com/"); + // Next load will remove the notification + this.complete = true; + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.org/"); + }, + onHidden(popup) { + ok( + this.complete, + "Should only have hidden the notification after 3 page loads" + ); + ok(this.notifyObj.removedCallbackTriggered, "removal callback triggered"); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + }, + }, + // Test that a timeout allows the notification to persist across reloads + { + id: "Test#4", + async run() { + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + this.notifyObj = new BasicNotification(this.id); + // Set a timeout of 10 minutes that should never be hit + this.notifyObj.addOptions({ + timeout: Date.now() + 600000, + }); + this.notification = showNotification(this.notifyObj); + }, + async onShown(popup) { + this.complete = false; + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.org/"); + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.com/"); + // Next load will hide the notification + this.notification.options.timeout = Date.now() - 1; + this.complete = true; + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.org/"); + }, + onHidden(popup) { + ok( + this.complete, + "Should only have hidden the notification after the timeout was passed" + ); + this.notification.remove(); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + }, + }, + // Test that setting persistWhileVisible allows a visible notification to + // persist across location changes + { + id: "Test#5", + async run() { + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.addOptions({ + persistWhileVisible: true, + }); + this.notification = showNotification(this.notifyObj); + }, + async onShown(popup) { + this.complete = false; + + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.org/"); + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.com/"); + // Notification should persist across location changes + this.complete = true; + dismissNotification(popup); + }, + onHidden(popup) { + ok( + this.complete, + "Should only have hidden the notification after it was dismissed" + ); + this.notification.remove(); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + }, + }, + + // Test that nested icon nodes correctly activate popups + { + id: "Test#6", + run() { + // Add a temporary box as the anchor with a button + this.box = document.createXULElement("box"); + PopupNotifications.iconBox.appendChild(this.box); + + let button = document.createXULElement("button"); + button.setAttribute("label", "Please click me!"); + this.box.appendChild(button); + + // The notification should open up on the box + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.anchorID = this.box.id = "nested-box"; + this.notifyObj.addOptions({ dismissed: true }); + this.notification = showNotification(this.notifyObj); + + // This test places a normal button in the notification area, which has + // standard GTK styling and dimensions. Due to the clip-path, this button + // gets clipped off, which makes it necessary to synthesize the mouse click + // a little bit downward. To be safe, I adjusted the x-offset with the same + // amount. + EventUtils.synthesizeMouse(button, 4, 4, {}); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + dismissNotification(popup); + }, + onHidden(popup) { + this.notification.remove(); + this.box.remove(); + }, + }, + // Test that popupnotifications without popups have anchor icons shown + { + id: "Test#7", + async run() { + let notifyObj = new BasicNotification(this.id); + notifyObj.anchorID = "geo-notification-icon"; + notifyObj.addOptions({ neverShow: true }); + let promiseTopic = TestUtils.topicObserved( + "PopupNotifications-updateNotShowing" + ); + showNotification(notifyObj); + await promiseTopic; + isnot( + document.getElementById("geo-notification-icon").getBoundingClientRect() + .width, + 0, + "geo anchor should be visible" + ); + goNext(); + }, + }, + // Test that autoplay media icon is shown + { + id: "Test#8", + async run() { + let notifyObj = new BasicNotification(this.id); + notifyObj.anchorID = "autoplay-media-notification-icon"; + notifyObj.addOptions({ neverShow: true }); + let promiseTopic = TestUtils.topicObserved( + "PopupNotifications-updateNotShowing" + ); + showNotification(notifyObj); + await promiseTopic; + isnot( + document + .getElementById("autoplay-media-notification-icon") + .getBoundingClientRect().width, + 0, + "autoplay media icon should be visible" + ); + goNext(); + }, + }, + // Test notification close button + { + id: "Test#9", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + EventUtils.synthesizeMouseAtCenter(notification.closebutton, {}); + }, + onHidden(popup) { + ok( + this.notifyObj.dismissalCallbackTriggered, + "dismissal callback triggered" + ); + this.notification.remove(); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + ok( + !this.notifyObj.secondaryActionClicked, + "secondary action not clicked" + ); + }, + }, + // Test notification when chrome is hidden + { + id: "Test#11", + run() { + window.locationbar.visible = false; + this.notifyObj = new BasicNotification(this.id); + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + is( + popup.anchorNode.className, + "tabbrowser-tab", + "notification anchored to tab" + ); + dismissNotification(popup); + }, + onHidden(popup) { + ok( + this.notifyObj.dismissalCallbackTriggered, + "dismissal callback triggered" + ); + this.notification.remove(); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + window.locationbar.visible = true; + }, + }, +]; diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_3.js b/browser/base/content/test/popupNotifications/browser_popupNotification_3.js new file mode 100644 index 0000000000..e0954e39ca --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_3.js @@ -0,0 +1,377 @@ +/* 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/. */ +/* eslint-disable mozilla/no-arbitrary-setTimeout */ + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + setup(); +} + +var tests = [ + // Test notification is removed when dismissed if removeOnDismissal is true + { + id: "Test#1", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.addOptions({ + removeOnDismissal: true, + }); + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + dismissNotification(popup); + }, + onHidden(popup) { + ok( + !this.notifyObj.dismissalCallbackTriggered, + "dismissal callback wasn't triggered" + ); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + }, + }, + // Test multiple notification icons are shown + { + id: "Test#2", + run() { + this.notifyObj1 = new BasicNotification(this.id); + this.notifyObj1.id += "_1"; + this.notifyObj1.anchorID = "default-notification-icon"; + this.notification1 = showNotification(this.notifyObj1); + + this.notifyObj2 = new BasicNotification(this.id); + this.notifyObj2.id += "_2"; + this.notifyObj2.anchorID = "geo-notification-icon"; + this.notification2 = showNotification(this.notifyObj2); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj2); + + // check notifyObj1 anchor icon is showing + isnot( + document + .getElementById("default-notification-icon") + .getBoundingClientRect().width, + 0, + "default anchor should be visible" + ); + // check notifyObj2 anchor icon is showing + isnot( + document.getElementById("geo-notification-icon").getBoundingClientRect() + .width, + 0, + "geo anchor should be visible" + ); + + dismissNotification(popup); + }, + onHidden(popup) { + this.notification1.remove(); + ok( + this.notifyObj1.removedCallbackTriggered, + "removed callback triggered" + ); + + this.notification2.remove(); + ok( + this.notifyObj2.removedCallbackTriggered, + "removed callback triggered" + ); + }, + }, + // Test that multiple notification icons are removed when switching tabs + { + id: "Test#3", + async run() { + // show the notification on old tab. + this.notifyObjOld = new BasicNotification(this.id); + this.notifyObjOld.anchorID = "default-notification-icon"; + this.notificationOld = showNotification(this.notifyObjOld); + + // switch tab + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + + // show the notification on new tab. + this.notifyObjNew = new BasicNotification(this.id); + this.notifyObjNew.anchorID = "geo-notification-icon"; + this.notificationNew = showNotification(this.notifyObjNew); + }, + onShown(popup) { + checkPopup(popup, this.notifyObjNew); + + // check notifyObjOld anchor icon is removed + is( + document + .getElementById("default-notification-icon") + .getBoundingClientRect().width, + 0, + "default anchor shouldn't be visible" + ); + // check notifyObjNew anchor icon is showing + isnot( + document.getElementById("geo-notification-icon").getBoundingClientRect() + .width, + 0, + "geo anchor should be visible" + ); + + dismissNotification(popup); + }, + onHidden(popup) { + this.notificationNew.remove(); + gBrowser.removeTab(gBrowser.selectedTab); + + gBrowser.selectedTab = this.oldSelectedTab; + this.notificationOld.remove(); + }, + }, + // test security delay - too early + { + id: "Test#4", + async run() { + // Set the security delay to 100s + await SpecialPowers.pushPrefEnv({ + set: [["security.notification_enable_delay", 100000]], + }); + + this.notifyObj = new BasicNotification(this.id); + showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + triggerMainCommand(popup); + + // Wait to see if the main command worked + executeSoon(function delayedDismissal() { + dismissNotification(popup); + }); + }, + onHidden(popup) { + ok( + !this.notifyObj.mainActionClicked, + "mainAction was not clicked because it was too soon" + ); + ok( + this.notifyObj.dismissalCallbackTriggered, + "dismissal callback was triggered" + ); + }, + }, + // test security delay - after delay + { + id: "Test#5", + async run() { + // Set the security delay to 10ms + + await SpecialPowers.pushPrefEnv({ + set: [["security.notification_enable_delay", 10]], + }); + + this.notifyObj = new BasicNotification(this.id); + showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + + // Wait until after the delay to trigger the main action + setTimeout(function delayedDismissal() { + triggerMainCommand(popup); + }, 500); + }, + onHidden(popup) { + ok( + this.notifyObj.mainActionClicked, + "mainAction was clicked after the delay" + ); + ok( + !this.notifyObj.dismissalCallbackTriggered, + "dismissal callback was not triggered" + ); + }, + }, + // reload removes notification + { + id: "Test#6", + async run() { + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.com/"); + let notifyObj = new BasicNotification(this.id); + notifyObj.options.eventCallback = function (eventName) { + if (eventName == "removed") { + ok(true, "Notification removed in background tab after reloading"); + goNext(); + } + }; + showNotification(notifyObj); + executeSoon(function () { + gBrowser.selectedBrowser.reload(); + }); + }, + }, + // location change in background tab removes notification + { + id: "Test#7", + async run() { + let oldSelectedTab = gBrowser.selectedTab; + let newTab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + gBrowser.selectedTab = oldSelectedTab; + let browser = gBrowser.getBrowserForTab(newTab); + + let notifyObj = new BasicNotification(this.id); + notifyObj.browser = browser; + notifyObj.options.eventCallback = function (eventName) { + if (eventName == "removed") { + ok(true, "Notification removed in background tab after reloading"); + executeSoon(function () { + gBrowser.removeTab(newTab); + goNext(); + }); + } + }; + showNotification(notifyObj); + executeSoon(function () { + browser.reload(); + }); + }, + }, + // Popup notification anchor shouldn't disappear when a notification with the same ID is re-added in a background tab + { + id: "Test#8", + async run() { + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.com/"); + let originalTab = gBrowser.selectedTab; + let bgTab = await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + let anchor = document.createXULElement("box"); + anchor.id = "test26-anchor"; + anchor.className = "notification-anchor-icon"; + PopupNotifications.iconBox.appendChild(anchor); + + gBrowser.selectedTab = originalTab; + + let fgNotifyObj = new BasicNotification(this.id); + fgNotifyObj.anchorID = anchor.id; + fgNotifyObj.options.dismissed = true; + let fgNotification = showNotification(fgNotifyObj); + + let bgNotifyObj = new BasicNotification(this.id); + bgNotifyObj.anchorID = anchor.id; + bgNotifyObj.browser = gBrowser.getBrowserForTab(bgTab); + // show the notification in the background tab ... + let bgNotification = showNotification(bgNotifyObj); + // ... and re-show it + bgNotification = showNotification(bgNotifyObj); + + ok(fgNotification.id, "notification has id"); + is(fgNotification.id, bgNotification.id, "notification ids are the same"); + is(anchor.getAttribute("showing"), "true", "anchor still showing"); + + fgNotification.remove(); + gBrowser.removeTab(bgTab); + goNext(); + }, + }, + // location change in an embedded frame should not remove a notification + { + id: "Test#9", + async run() { + await promiseTabLoadEvent( + gBrowser.selectedTab, + "data:text/html;charset=utf8,<iframe%20id='iframe'%20src='http://example.com/'>" + ); + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.options.eventCallback = function (eventName) { + if (eventName == "removed") { + ok( + false, + "Notification removed from browser when subframe navigated" + ); + } + }; + showNotification(this.notifyObj); + }, + async onShown(popup) { + info("Adding observer and performing navigation"); + + await Promise.all([ + BrowserUtils.promiseObserved("window-global-created", wgp => + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + wgp.documentURI.spec.startsWith("http://example.org/") + ), + SpecialPowers.spawn(gBrowser.selectedBrowser, [], function () { + content.document + .getElementById("iframe") + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + .setAttribute("src", "http://example.org/"); + }), + ]); + + executeSoon(() => { + let notification = PopupNotifications.getNotification( + this.notifyObj.id, + this.notifyObj.browser + ); + ok( + notification != null, + "Notification remained when subframe navigated" + ); + this.notifyObj.options.eventCallback = undefined; + + notification.remove(); + }); + }, + onHidden() {}, + }, + // Popup Notifications should catch exceptions from callbacks + { + id: "Test#10", + run() { + this.testNotif1 = new BasicNotification(this.id); + this.testNotif1.message += " 1"; + this.notification1 = showNotification(this.testNotif1); + this.testNotif1.options.eventCallback = function (eventName) { + info("notifyObj1.options.eventCallback: " + eventName); + if (eventName == "dismissed") { + throw new Error("Oops 1!"); + } + }; + + this.testNotif2 = new BasicNotification(this.id); + this.testNotif2.message += " 2"; + this.testNotif2.id += "-2"; + this.testNotif2.options.eventCallback = function (eventName) { + info("notifyObj2.options.eventCallback: " + eventName); + if (eventName == "dismissed") { + throw new Error("Oops 2!"); + } + }; + this.notification2 = showNotification(this.testNotif2); + }, + onShown(popup) { + is(popup.children.length, 2, "two notifications are shown"); + dismissNotification(popup); + }, + onHidden() { + this.notification1.remove(); + this.notification2.remove(); + }, + }, +]; diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_4.js b/browser/base/content/test/popupNotifications/browser_popupNotification_4.js new file mode 100644 index 0000000000..b0e8f016ef --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_4.js @@ -0,0 +1,290 @@ +/* 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/. */ + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + setup(); +} + +var tests = [ + // Popup Notifications main actions should catch exceptions from callbacks + { + id: "Test#1", + run() { + this.testNotif = new ErrorNotification(this.id); + showNotification(this.testNotif); + }, + onShown(popup) { + checkPopup(popup, this.testNotif); + triggerMainCommand(popup); + }, + onHidden(popup) { + ok(this.testNotif.mainActionClicked, "main action has been triggered"); + }, + }, + // Popup Notifications secondary actions should catch exceptions from callbacks + { + id: "Test#2", + run() { + this.testNotif = new ErrorNotification(this.id); + showNotification(this.testNotif); + }, + onShown(popup) { + checkPopup(popup, this.testNotif); + triggerSecondaryCommand(popup, 0); + }, + onHidden(popup) { + ok( + this.testNotif.secondaryActionClicked, + "secondary action has been triggered" + ); + }, + }, + // Existing popup notification shouldn't disappear when adding a dismissed notification + { + id: "Test#3", + run() { + this.notifyObj1 = new BasicNotification(this.id); + this.notifyObj1.id += "_1"; + this.notifyObj1.anchorID = "default-notification-icon"; + this.notification1 = showNotification(this.notifyObj1); + }, + onShown(popup) { + // Now show a dismissed notification, and check that it doesn't clobber + // the showing one. + this.notifyObj2 = new BasicNotification(this.id); + this.notifyObj2.id += "_2"; + this.notifyObj2.anchorID = "geo-notification-icon"; + this.notifyObj2.options.dismissed = true; + this.notification2 = showNotification(this.notifyObj2); + + checkPopup(popup, this.notifyObj1); + + // check that both anchor icons are showing + is( + document + .getElementById("default-notification-icon") + .getAttribute("showing"), + "true", + "notification1 anchor should be visible" + ); + is( + document + .getElementById("geo-notification-icon") + .getAttribute("showing"), + "true", + "notification2 anchor should be visible" + ); + + dismissNotification(popup); + }, + onHidden(popup) { + this.notification1.remove(); + this.notification2.remove(); + }, + }, + // Showing should be able to modify the popup data + { + id: "Test#4", + run() { + this.notifyObj = new BasicNotification(this.id); + let normalCallback = this.notifyObj.options.eventCallback; + this.notifyObj.options.eventCallback = function (eventName) { + if (eventName == "showing") { + this.mainAction.label = "Alternate Label"; + } + normalCallback.call(this, eventName); + }; + showNotification(this.notifyObj); + }, + onShown(popup) { + // checkPopup checks for the matching label. Note that this assumes that + // this.notifyObj.mainAction is the same as notification.mainAction, + // which could be a problem if we ever decided to deep-copy. + checkPopup(popup, this.notifyObj); + triggerMainCommand(popup); + }, + onHidden() {}, + }, + // Moving a tab to a new window should remove non-swappable notifications. + { + id: "Test#5", + async run() { + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + + let notifyObj = new BasicNotification(this.id); + + let shown = waitForNotificationPanel(); + showNotification(notifyObj); + await shown; + + let promiseWin = BrowserTestUtils.waitForNewWindow(); + gBrowser.replaceTabWithWindow(gBrowser.selectedTab); + let win = await promiseWin; + + let anchor = win.document.getElementById("default-notification-icon"); + win.PopupNotifications._reshowNotifications(anchor); + ok( + !win.PopupNotifications.panel.children.length, + "no notification displayed in new window" + ); + ok( + notifyObj.swappingCallbackTriggered, + "the swapping callback was triggered" + ); + ok( + notifyObj.removedCallbackTriggered, + "the removed callback was triggered" + ); + + await BrowserTestUtils.closeWindow(win); + await waitForWindowReadyForPopupNotifications(window); + + goNext(); + }, + }, + // Moving a tab to a new window should preserve swappable notifications. + { + id: "Test#6", + async run() { + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + let notifyObj = new BasicNotification(this.id); + let originalCallback = notifyObj.options.eventCallback; + notifyObj.options.eventCallback = function (eventName) { + originalCallback(eventName); + return eventName == "swapping"; + }; + + let shown = waitForNotificationPanel(); + let notification = showNotification(notifyObj); + await shown; + + let promiseWin = BrowserTestUtils.waitForNewWindow(); + gBrowser.replaceTabWithWindow(gBrowser.selectedTab); + let win = await promiseWin; + await waitForWindowReadyForPopupNotifications(win); + + await new Promise(resolve => { + let callback = notification.options.eventCallback; + notification.options.eventCallback = function (eventName) { + callback(eventName); + if (eventName == "shown") { + resolve(); + } + }; + info("Showing the notification again"); + notification.reshow(); + }); + + checkPopup(win.PopupNotifications.panel, notifyObj); + ok( + notifyObj.swappingCallbackTriggered, + "the swapping callback was triggered" + ); + + await BrowserTestUtils.closeWindow(win); + await waitForWindowReadyForPopupNotifications(window); + + goNext(); + }, + }, + // the main action callback can keep the notification. + { + id: "Test#8", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.mainAction.dismiss = true; + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + triggerMainCommand(popup); + }, + onHidden(popup) { + ok( + this.notifyObj.dismissalCallbackTriggered, + "dismissal callback was triggered" + ); + ok( + !this.notifyObj.removedCallbackTriggered, + "removed callback wasn't triggered" + ); + this.notification.remove(); + }, + }, + // a secondary action callback can keep the notification. + { + id: "Test#9", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.secondaryActions[0].dismiss = true; + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + triggerSecondaryCommand(popup, 0); + }, + onHidden(popup) { + ok( + this.notifyObj.dismissalCallbackTriggered, + "dismissal callback was triggered" + ); + ok( + !this.notifyObj.removedCallbackTriggered, + "removed callback wasn't triggered" + ); + this.notification.remove(); + }, + }, + // returning true in the showing callback should dismiss the notification. + { + id: "Test#10", + run() { + let notifyObj = new BasicNotification(this.id); + let originalCallback = notifyObj.options.eventCallback; + notifyObj.options.eventCallback = function (eventName) { + originalCallback(eventName); + return eventName == "showing"; + }; + + let notification = showNotification(notifyObj); + ok( + notifyObj.showingCallbackTriggered, + "the showing callback was triggered" + ); + ok( + !notifyObj.shownCallbackTriggered, + "the shown callback wasn't triggered" + ); + notification.remove(); + goNext(); + }, + }, + // the main action button should apply non-default(no highlight) style. + { + id: "Test#11", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.secondaryActions = undefined; + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + dismissNotification(popup); + }, + onHidden() {}, + }, +]; diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_5.js b/browser/base/content/test/popupNotifications/browser_popupNotification_5.js new file mode 100644 index 0000000000..839262caa0 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_5.js @@ -0,0 +1,501 @@ +/* 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/. */ + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + setup(); +} + +var gNotification; + +var tests = [ + // panel updates should fire the showing and shown callbacks again. + { + id: "Test#1", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + + this.notifyObj.showingCallbackTriggered = false; + this.notifyObj.shownCallbackTriggered = false; + + // Force an update of the panel. This is typically called + // automatically when receiving 'activate' or 'TabSelect' events, + // but from a setTimeout, which is inconvenient for the test. + PopupNotifications._update(); + + checkPopup(popup, this.notifyObj); + + this.notification.remove(); + }, + onHidden() {}, + }, + // A first dismissed notification shouldn't stop _update from showing a second notification + { + id: "Test#2", + run() { + this.notifyObj1 = new BasicNotification(this.id); + this.notifyObj1.id += "_1"; + this.notifyObj1.anchorID = "default-notification-icon"; + this.notifyObj1.options.dismissed = true; + this.notification1 = showNotification(this.notifyObj1); + + this.notifyObj2 = new BasicNotification(this.id); + this.notifyObj2.id += "_2"; + this.notifyObj2.anchorID = "geo-notification-icon"; + this.notifyObj2.options.dismissed = true; + this.notification2 = showNotification(this.notifyObj2); + + this.notification2.dismissed = false; + PopupNotifications._update(); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj2); + this.notification1.remove(); + this.notification2.remove(); + }, + onHidden(popup) {}, + }, + // The anchor icon should be shown for notifications in background windows. + { + id: "Test#3", + async run() { + let notifyObj = new BasicNotification(this.id); + notifyObj.options.dismissed = true; + + let win = await BrowserTestUtils.openNewBrowserWindow(); + + // Open the notification in the original window, now in the background. + let notification = showNotification(notifyObj); + let anchor = document.getElementById("default-notification-icon"); + is(anchor.getAttribute("showing"), "true", "the anchor is shown"); + notification.remove(); + + await BrowserTestUtils.closeWindow(win); + await waitForWindowReadyForPopupNotifications(window); + + goNext(); + }, + }, + // Test that persistent doesn't allow the notification to persist after + // navigation. + { + id: "Test#4", + async run() { + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.addOptions({ + persistent: true, + }); + this.notification = showNotification(this.notifyObj); + }, + async onShown(popup) { + this.complete = false; + + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.org/"); + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.com/"); + + // This code should not be executed. + ok(false, "Should have removed the notification after navigation"); + // Properly dismiss and cleanup in case the unthinkable happens. + this.complete = true; + triggerSecondaryCommand(popup, 0); + }, + onHidden(popup) { + ok( + !this.complete, + "Should have hidden the notification after navigation" + ); + this.notification.remove(); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + }, + }, + // Test that persistent allows the notification to persist until explicitly + // dismissed. + { + id: "Test#5", + async run() { + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.addOptions({ + persistent: true, + }); + this.notification = showNotification(this.notifyObj); + }, + async onShown(popup) { + this.complete = false; + + // Notification should persist after attempt to dismiss by clicking on the + // content area. + let browser = gBrowser.selectedBrowser; + await BrowserTestUtils.synthesizeMouseAtCenter("body", {}, browser); + + // Notification should be hidden after dismissal via Don't Allow. + this.complete = true; + triggerSecondaryCommand(popup, 0); + }, + onHidden(popup) { + ok( + this.complete, + "Should have hidden the notification after clicking Not Now" + ); + this.notification.remove(); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + }, + }, + // Test that persistent panels are still open after switching to another tab + // and back. + { + id: "Test#6a", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.options.persistent = true; + gNotification = showNotification(this.notifyObj); + }, + async onShown(popup) { + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + }, + onHidden(popup) { + ok(true, "Should have hidden the notification after tab switch"); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + }, + }, + // Second part of the previous test that compensates for the limitation in + // runNextTest that expects a single onShown/onHidden invocation per test. + { + id: "Test#6b", + run() { + let id = + PopupNotifications.panel.firstElementChild.getAttribute("popupid"); + ok( + id.endsWith("Test#6a"), + "Should have found the notification from Test6a" + ); + ok( + PopupNotifications.isPanelOpen, + "Should have shown the popup again after getting back to the tab" + ); + gNotification.remove(); + gNotification = null; + goNext(); + }, + }, + // Test that persistent panels are still open after switching to another + // window and back. + { + id: "Test#7", + async run() { + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + let firstTab = gBrowser.selectedTab; + + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + + let shown = waitForNotificationPanel(); + let notifyObj = new BasicNotification(this.id); + notifyObj.options.persistent = true; + this.notification = showNotification(notifyObj); + await shown; + + ok( + notifyObj.shownCallbackTriggered, + "Should have triggered the shown event" + ); + ok( + notifyObj.showingCallbackTriggered, + "Should have triggered the showing event" + ); + // Reset to false so that we can ensure these are not fired a second time. + notifyObj.shownCallbackTriggered = false; + notifyObj.showingCallbackTriggered = false; + let timeShown = this.notification.timeShown; + + let promiseWin = BrowserTestUtils.waitForNewWindow(); + gBrowser.replaceTabWithWindow(firstTab); + let win = await promiseWin; + + let anchor = win.document.getElementById("default-notification-icon"); + win.PopupNotifications._reshowNotifications(anchor); + ok( + !win.PopupNotifications.panel.children.length, + "no notification displayed in new window" + ); + + await BrowserTestUtils.closeWindow(win); + await waitForWindowReadyForPopupNotifications(window); + + let id = + PopupNotifications.panel.firstElementChild.getAttribute("popupid"); + ok( + id.endsWith("Test#7"), + "Should have found the notification from Test7" + ); + ok( + PopupNotifications.isPanelOpen, + "Should have kept the popup on the first window" + ); + ok( + !notifyObj.dismissalCallbackTriggered, + "Should not have triggered a dismissed event" + ); + ok( + !notifyObj.shownCallbackTriggered, + "Should not have triggered a second shown event" + ); + ok( + !notifyObj.showingCallbackTriggered, + "Should not have triggered a second showing event" + ); + ok( + this.notification.timeShown > timeShown, + "should have updated timeShown to restart the security delay" + ); + + this.notification.remove(); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + + goNext(); + }, + }, + // Test that only the first persistent notification is shown on update + { + id: "Test#8", + run() { + this.notifyObj1 = new BasicNotification(this.id); + this.notifyObj1.id += "_1"; + this.notifyObj1.anchorID = "default-notification-icon"; + this.notifyObj1.options.persistent = true; + this.notification1 = showNotification(this.notifyObj1); + + this.notifyObj2 = new BasicNotification(this.id); + this.notifyObj2.id += "_2"; + this.notifyObj2.anchorID = "geo-notification-icon"; + this.notifyObj2.options.persistent = true; + this.notification2 = showNotification(this.notifyObj2); + + PopupNotifications._update(); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj1); + this.notification1.remove(); + this.notification2.remove(); + }, + onHidden(popup) {}, + }, + // Test that persistent notifications are shown stacked by anchor on update + { + id: "Test#9", + run() { + this.notifyObj1 = new BasicNotification(this.id); + this.notifyObj1.id += "_1"; + this.notifyObj1.anchorID = "default-notification-icon"; + this.notifyObj1.options.persistent = true; + this.notification1 = showNotification(this.notifyObj1); + + this.notifyObj2 = new BasicNotification(this.id); + this.notifyObj2.id += "_2"; + this.notifyObj2.anchorID = "geo-notification-icon"; + this.notifyObj2.options.persistent = true; + this.notification2 = showNotification(this.notifyObj2); + + this.notifyObj3 = new BasicNotification(this.id); + this.notifyObj3.id += "_3"; + this.notifyObj3.anchorID = "default-notification-icon"; + this.notifyObj3.options.persistent = true; + this.notification3 = showNotification(this.notifyObj3); + + PopupNotifications._update(); + }, + onShown(popup) { + let notifications = popup.children; + is(notifications.length, 2, "two notifications displayed"); + let [notification1, notification2] = notifications; + is( + notification1.id, + this.notifyObj1.id + "-notification", + "id 1 matches" + ); + is( + notification2.id, + this.notifyObj3.id + "-notification", + "id 2 matches" + ); + + this.notification1.remove(); + this.notification2.remove(); + this.notification3.remove(); + }, + onHidden(popup) {}, + }, + // Test that on closebutton click, only the persistent notification + // that contained the closebutton loses its persistent status. + { + id: "Test#10", + run() { + this.notifyObj1 = new BasicNotification(this.id); + this.notifyObj1.id += "_1"; + this.notifyObj1.anchorID = "geo-notification-icon"; + this.notifyObj1.options.persistent = true; + this.notifyObj1.options.hideClose = false; + this.notification1 = showNotification(this.notifyObj1); + + this.notifyObj2 = new BasicNotification(this.id); + this.notifyObj2.id += "_2"; + this.notifyObj2.anchorID = "geo-notification-icon"; + this.notifyObj2.options.persistent = true; + this.notifyObj2.options.hideClose = false; + this.notification2 = showNotification(this.notifyObj2); + + this.notifyObj3 = new BasicNotification(this.id); + this.notifyObj3.id += "_3"; + this.notifyObj3.anchorID = "geo-notification-icon"; + this.notifyObj3.options.persistent = true; + this.notifyObj3.options.hideClose = false; + this.notification3 = showNotification(this.notifyObj3); + + PopupNotifications._update(); + }, + onShown(popup) { + let notifications = popup.children; + is(notifications.length, 3, "three notifications displayed"); + EventUtils.synthesizeMouseAtCenter(notifications[1].closebutton, {}); + }, + onHidden(popup) { + let notifications = popup.children; + is(notifications.length, 2, "two notifications displayed"); + + ok(this.notification1.options.persistent, "notification 1 is persistent"); + ok( + !this.notification2.options.persistent, + "notification 2 is not persistent" + ); + ok(this.notification3.options.persistent, "notification 3 is persistent"); + + this.notification1.remove(); + this.notification2.remove(); + this.notification3.remove(); + }, + }, + // Test clicking the anchor icon. + // Clicking the anchor of an already visible persistent notification should + // focus the main action button, but not cause additional showing/shown event + // callback calls. + // Clicking the anchor of a dismissed notification should show it, even when + // the currently displayed notification is a persistent one. + { + id: "Test#11", + async run() { + await SpecialPowers.pushPrefEnv({ set: [["accessibility.tabfocus", 7]] }); + + function clickAnchor(notifyObj) { + let anchor = document.getElementById(notifyObj.anchorID); + EventUtils.synthesizeMouseAtCenter(anchor, {}); + } + + let popup = PopupNotifications.panel; + + let notifyObj1 = new BasicNotification(this.id); + notifyObj1.id += "_1"; + notifyObj1.anchorID = "default-notification-icon"; + notifyObj1.options.persistent = true; + let shown = waitForNotificationPanel(); + let notification1 = showNotification(notifyObj1); + await shown; + checkPopup(popup, notifyObj1); + ok( + !notifyObj1.dismissalCallbackTriggered, + "Should not have dismissed the notification" + ); + notifyObj1.shownCallbackTriggered = false; + notifyObj1.showingCallbackTriggered = false; + + // Click the anchor. This should focus the closebutton + // (because it's the first focusable element), but not + // call event callbacks on the notification object. + clickAnchor(notifyObj1); + is(document.activeElement, popup.children[0].closebutton); + ok( + !notifyObj1.dismissalCallbackTriggered, + "Should not have dismissed the notification" + ); + ok( + !notifyObj1.shownCallbackTriggered, + "Should have triggered the shown event again" + ); + ok( + !notifyObj1.showingCallbackTriggered, + "Should have triggered the showing event again" + ); + + // Add another notification. + let notifyObj2 = new BasicNotification(this.id); + notifyObj2.id += "_2"; + notifyObj2.anchorID = "geo-notification-icon"; + notifyObj2.options.dismissed = true; + let notification2 = showNotification(notifyObj2); + + // Click the anchor of the second notification, this should dismiss the + // first notification. + shown = waitForNotificationPanel(); + clickAnchor(notifyObj2); + await shown; + checkPopup(popup, notifyObj2); + ok( + notifyObj1.dismissalCallbackTriggered, + "Should have dismissed the first notification" + ); + + // Click the anchor of the first notification, it should be shown again. + shown = waitForNotificationPanel(); + clickAnchor(notifyObj1); + await shown; + checkPopup(popup, notifyObj1); + ok( + notifyObj2.dismissalCallbackTriggered, + "Should have dismissed the second notification" + ); + + // Cleanup. + notification1.remove(); + notification2.remove(); + goNext(); + }, + }, +]; diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_accesskey.js b/browser/base/content/test/popupNotifications/browser_popupNotification_accesskey.js new file mode 100644 index 0000000000..4a68105e27 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_accesskey.js @@ -0,0 +1,44 @@ +/* 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/. */ + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + setup(); +} + +let buttonPressed = false; + +function commandTriggered() { + buttonPressed = true; +} + +var tests = [ + // This test ensures that the accesskey closes the popup. + { + id: "Test#1", + run() { + this.notifyObj = new BasicNotification(this.id); + showNotification(this.notifyObj); + }, + onShown(popup) { + window.addEventListener("command", commandTriggered, true); + checkPopup(popup, this.notifyObj); + EventUtils.synthesizeKey("VK_ALT", { type: "keydown" }); + EventUtils.synthesizeKey("M", { altKey: true }); + EventUtils.synthesizeKey("VK_ALT", { type: "keyup" }); + + // If bug xxx was present, then the popup would be in the + // process of being hidden right now. + isnot(popup.state, "hiding", "popup is not hiding"); + }, + onHidden(popup) { + window.removeEventListener("command", commandTriggered, true); + ok(buttonPressed, "button pressed"); + }, + }, +]; diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_checkbox.js b/browser/base/content/test/popupNotifications/browser_popupNotification_checkbox.js new file mode 100644 index 0000000000..c1d82042c8 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_checkbox.js @@ -0,0 +1,248 @@ +/* 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/. */ + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + setup(); +} + +function checkCheckbox(checkbox, label, checked = false, hidden = false) { + is(checkbox.label, label, "Checkbox should have the correct label"); + is(checkbox.hidden, hidden, "Checkbox should be shown"); + is(checkbox.checked, checked, "Checkbox should be checked by default"); +} + +function checkMainAction(notification, disabled = false) { + let mainAction = notification.button; + let warningLabel = notification.querySelector(".popup-notification-warning"); + is(warningLabel.hidden, !disabled, "Warning label should be shown"); + is(mainAction.disabled, disabled, "MainAction should be disabled"); +} + +function promiseElementVisible(element) { + // HTMLElement.offsetParent is null when the element is not visisble + // (or if the element has |position: fixed|). See: + // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetParent + return TestUtils.waitForCondition( + () => element.offsetParent !== null, + "Waiting for element to be visible" + ); +} + +var gNotification; + +var tests = [ + // Test that passing the checkbox field shows the checkbox. + { + id: "show_checkbox", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.options.checkbox = { + label: "This is a checkbox", + }; + gNotification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + checkCheckbox(notification.checkbox, "This is a checkbox"); + triggerMainCommand(popup); + }, + onHidden() {}, + }, + + // Test checkbox being checked by default + { + id: "checkbox_checked", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.options.checkbox = { + label: "Check this", + checked: true, + }; + gNotification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + checkCheckbox(notification.checkbox, "Check this", true); + triggerMainCommand(popup); + }, + onHidden() {}, + }, + + // Test checkbox passing the checkbox state on mainAction + { + id: "checkbox_passCheckboxChecked_mainAction", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.mainAction.callback = ({ checkboxChecked }) => + (this.mainActionChecked = checkboxChecked); + this.notifyObj.options.checkbox = { + label: "This is a checkbox", + }; + gNotification = showNotification(this.notifyObj); + }, + async onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + let checkbox = notification.checkbox; + checkCheckbox(checkbox, "This is a checkbox"); + await promiseElementVisible(checkbox); + EventUtils.synthesizeMouseAtCenter(checkbox, {}); + checkCheckbox(checkbox, "This is a checkbox", true); + triggerMainCommand(popup); + }, + onHidden() { + is( + this.mainActionChecked, + true, + "mainAction callback is passed the correct checkbox value" + ); + }, + }, + + // Test checkbox passing the checkbox state on secondaryAction + { + id: "checkbox_passCheckboxChecked_secondaryAction", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.secondaryActions = [ + { + label: "Test Secondary", + accessKey: "T", + callback: ({ checkboxChecked }) => + (this.secondaryActionChecked = checkboxChecked), + }, + ]; + this.notifyObj.options.checkbox = { + label: "This is a checkbox", + }; + gNotification = showNotification(this.notifyObj); + }, + async onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + let checkbox = notification.checkbox; + checkCheckbox(checkbox, "This is a checkbox"); + await promiseElementVisible(checkbox); + EventUtils.synthesizeMouseAtCenter(checkbox, {}); + checkCheckbox(checkbox, "This is a checkbox", true); + triggerSecondaryCommand(popup, 0); + }, + onHidden() { + is( + this.secondaryActionChecked, + true, + "secondaryAction callback is passed the correct checkbox value" + ); + }, + }, + + // Test checkbox preserving its state through re-opening the doorhanger + { + id: "checkbox_reopen", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.options.checkbox = { + label: "This is a checkbox", + checkedState: { + disableMainAction: true, + warningLabel: "Testing disable", + }, + }; + gNotification = showNotification(this.notifyObj); + }, + async onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + let checkbox = notification.checkbox; + checkCheckbox(checkbox, "This is a checkbox"); + await promiseElementVisible(checkbox); + EventUtils.synthesizeMouseAtCenter(checkbox, {}); + dismissNotification(popup); + }, + async onHidden(popup) { + let icon = document.getElementById("default-notification-icon"); + let shown = waitForNotificationPanel(); + EventUtils.synthesizeMouseAtCenter(icon, {}); + await shown; + let notification = popup.children[0]; + let checkbox = notification.checkbox; + checkCheckbox(checkbox, "This is a checkbox", true); + checkMainAction(notification, true); + gNotification.remove(); + }, + }, + + // Test no checkbox hides warning label + { + id: "no_checkbox", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.options.checkbox = null; + gNotification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + checkCheckbox(notification.checkbox, "", false, true); + checkMainAction(notification); + triggerMainCommand(popup); + }, + onHidden() {}, + }, +]; + +// Test checkbox disabling the main action in different combinations +["checkedState", "uncheckedState"].forEach(function (state) { + [true, false].forEach(function (checked) { + tests.push({ + id: `checkbox_disableMainAction_${state}_${ + checked ? "checked" : "unchecked" + }`, + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.options.checkbox = { + label: "This is a checkbox", + checked, + [state]: { + disableMainAction: true, + warningLabel: "Testing disable", + }, + }; + gNotification = showNotification(this.notifyObj); + }, + async onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + let checkbox = notification.checkbox; + let disabled = + (state === "checkedState" && checked) || + (state === "uncheckedState" && !checked); + + checkCheckbox(checkbox, "This is a checkbox", checked); + checkMainAction(notification, disabled); + await promiseElementVisible(checkbox); + EventUtils.synthesizeMouseAtCenter(checkbox, {}); + checkCheckbox(checkbox, "This is a checkbox", !checked); + checkMainAction(notification, !disabled); + EventUtils.synthesizeMouseAtCenter(checkbox, {}); + checkCheckbox(checkbox, "This is a checkbox", checked); + checkMainAction(notification, disabled); + + // Unblock the main command if it's currently disabled. + if (disabled) { + EventUtils.synthesizeMouseAtCenter(checkbox, {}); + } + triggerMainCommand(popup); + }, + onHidden() {}, + }); + }); +}); diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_hide_after_identity_panel.js b/browser/base/content/test/popupNotifications/browser_popupNotification_hide_after_identity_panel.js new file mode 100644 index 0000000000..de930375f6 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_hide_after_identity_panel.js @@ -0,0 +1,36 @@ +/* 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/. */ + +add_task(async function test_displayURI_geo() { + await BrowserTestUtils.withNewTab( + "https://test1.example.com/", + async function (browser) { + let popupShownPromise = waitForNotificationPanel(); + await SpecialPowers.spawn(browser, [], async function () { + content.navigator.geolocation.getCurrentPosition(() => {}); + }); + await popupShownPromise; + + popupShownPromise = BrowserTestUtils.waitForEvent( + window, + "popupshown", + true, + event => event.target == gIdentityHandler._identityPopup + ); + EventUtils.synthesizeMouseAtCenter(gIdentityHandler._identityIconBox, {}); + await popupShownPromise; + + Assert.ok(!PopupNotifications.isPanelOpen, "Geolocation popup is hidden"); + + let popupHidden = BrowserTestUtils.waitForEvent( + gIdentityHandler._identityPopup, + "popuphidden" + ); + gIdentityHandler._identityPopup.hidePopup(); + await popupHidden; + + Assert.ok(PopupNotifications.isPanelOpen, "Geolocation popup is showing"); + } + ); +}); diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_hide_after_protections_panel.js b/browser/base/content/test/popupNotifications/browser_popupNotification_hide_after_protections_panel.js new file mode 100644 index 0000000000..f47f20a2d7 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_hide_after_protections_panel.js @@ -0,0 +1,44 @@ +/* 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/. */ + +add_task(async function test_hide_popup_with_protections_panel_showing() { + await BrowserTestUtils.withNewTab( + "https://test1.example.com/", + async function (browser) { + // Request location permissions and wait for that prompt to appear. + let popupShownPromise = waitForNotificationPanel(); + await SpecialPowers.spawn(browser, [], async function () { + content.navigator.geolocation.getCurrentPosition(() => {}); + }); + await popupShownPromise; + + // Click on the icon for the protections panel, to show the panel. + popupShownPromise = BrowserTestUtils.waitForEvent( + window, + "popupshown", + true, + event => event.target == gProtectionsHandler._protectionsPopup + ); + EventUtils.synthesizeMouseAtCenter( + document.getElementById("tracking-protection-icon-container"), + {} + ); + await popupShownPromise; + + // Make sure the location permission prompt closed. + Assert.ok(!PopupNotifications.isPanelOpen, "Geolocation popup is hidden"); + + // Close the protections panel. + let popupHidden = BrowserTestUtils.waitForEvent( + gProtectionsHandler._protectionsPopup, + "popuphidden" + ); + gProtectionsHandler._protectionsPopup.hidePopup(); + await popupHidden; + + // Make sure the location permission prompt came back. + Assert.ok(PopupNotifications.isPanelOpen, "Geolocation popup is showing"); + } + ); +}); diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_keyboard.js b/browser/base/content/test/popupNotifications/browser_popupNotification_keyboard.js new file mode 100644 index 0000000000..5c20751c3f --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_keyboard.js @@ -0,0 +1,273 @@ +/* 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/. */ + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + // Force tabfocus for all elements on OSX. + SpecialPowers.pushPrefEnv({ set: [["accessibility.tabfocus", 7]] }).then( + setup + ); +} + +// Focusing on notification icon buttons is handled by the ToolbarKeyboardNavigator +// component and arrow keys (see browser/base/content/browser-toolbarKeyNav.js). +function focusNotificationAnchor(anchor) { + let urlbarContainer = anchor.closest("#urlbar-container"); + urlbarContainer.querySelector("toolbartabstop").focus(); + const trackingProtectionIconContainer = urlbarContainer.querySelector( + "#tracking-protection-icon-container" + ); + is( + document.activeElement, + trackingProtectionIconContainer, + "tracking protection icon container is focused." + ); + while (document.activeElement !== anchor) { + EventUtils.synthesizeKey("ArrowRight"); + } +} + +var tests = [ + // Test that for persistent notifications, + // the secondary action is triggered by pressing the escape key. + { + id: "Test#1", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.options.persistent = true; + showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + EventUtils.synthesizeKey("KEY_Escape"); + }, + onHidden(popup) { + ok(!this.notifyObj.mainActionClicked, "mainAction was not clicked"); + ok(this.notifyObj.secondaryActionClicked, "secondaryAction was clicked"); + ok( + !this.notifyObj.dismissalCallbackTriggered, + "dismissal callback wasn't triggered" + ); + ok(this.notifyObj.removedCallbackTriggered, "removed callback triggered"); + is( + this.notifyObj.mainActionSource, + undefined, + "shouldn't have a main action source." + ); + is( + this.notifyObj.secondaryActionSource, + "esc-press", + "secondary action should be from ESC key press" + ); + }, + }, + // Test that for non-persistent notifications, the escape key dismisses the notification. + { + id: "Test#2", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + EventUtils.synthesizeKey("KEY_Escape"); + }, + onHidden(popup) { + ok(!this.notifyObj.mainActionClicked, "mainAction was not clicked"); + ok( + !this.notifyObj.secondaryActionClicked, + "secondaryAction was not clicked" + ); + ok( + this.notifyObj.dismissalCallbackTriggered, + "dismissal callback triggered" + ); + ok( + !this.notifyObj.removedCallbackTriggered, + "removed callback was not triggered" + ); + is( + this.notifyObj.mainActionSource, + undefined, + "shouldn't have a main action source." + ); + is( + this.notifyObj.secondaryActionSource, + undefined, + "shouldn't have a secondary action source." + ); + this.notification.remove(); + }, + }, + // Test that the space key on an anchor element focuses an active notification + { + id: "Test#3", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.anchorID = "geo-notification-icon"; + this.notifyObj.addOptions({ + persistent: true, + }); + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + let anchor = document.getElementById(this.notifyObj.anchorID); + focusNotificationAnchor(anchor); + EventUtils.sendString(" "); + is(document.activeElement, popup.children[0].closebutton); + this.notification.remove(); + }, + onHidden(popup) {}, + }, + // Test that you can switch between active notifications with the space key + // and that the notification is focused on selection. + { + id: "Test#4", + async run() { + let notifyObj1 = new BasicNotification(this.id); + notifyObj1.id += "_1"; + notifyObj1.anchorID = "default-notification-icon"; + notifyObj1.addOptions({ + hideClose: true, + checkbox: { + label: "Test that elements inside the panel can be focused", + }, + persistent: true, + }); + let opened = waitForNotificationPanel(); + let notification1 = showNotification(notifyObj1); + await opened; + + let notifyObj2 = new BasicNotification(this.id); + notifyObj2.id += "_2"; + notifyObj2.anchorID = "geo-notification-icon"; + notifyObj2.addOptions({ + persistent: true, + }); + opened = waitForNotificationPanel(); + let notification2 = showNotification(notifyObj2); + let popup = await opened; + + // Make sure notification 2 is visible + checkPopup(popup, notifyObj2); + + // Activate the anchor for notification 1 and wait until it's shown. + let anchor = document.getElementById(notifyObj1.anchorID); + focusNotificationAnchor(anchor); + is(document.activeElement, anchor); + opened = waitForNotificationPanel(); + EventUtils.sendString(" "); + popup = await opened; + checkPopup(popup, notifyObj1); + + is(document.activeElement, popup.children[0].checkbox); + + // Activate the anchor for notification 2 and wait until it's shown. + anchor = document.getElementById(notifyObj2.anchorID); + focusNotificationAnchor(anchor); + is(document.activeElement, anchor); + opened = waitForNotificationPanel(); + EventUtils.sendString(" "); + popup = await opened; + checkPopup(popup, notifyObj2); + + is(document.activeElement, popup.children[0].closebutton); + + notification1.remove(); + notification2.remove(); + goNext(); + }, + }, + // Test that passing the autofocus option will focus an opened notification. + { + id: "Test#5", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.anchorID = "geo-notification-icon"; + this.notifyObj.addOptions({ + autofocus: true, + }); + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + + // Initial focus on open is null because a panel itself + // can not be focused, next tab focus will be inside the panel. + is(Services.focus.focusedElement, null); + + EventUtils.synthesizeKey("KEY_Tab"); + is(Services.focus.focusedElement, popup.children[0].closebutton); + dismissNotification(popup); + }, + async onHidden() { + // Focus the urlbar to check that it stays focused. + gURLBar.focus(); + + // Show another notification and make sure it's not autofocused. + let notifyObj = new BasicNotification(this.id); + notifyObj.id += "_2"; + notifyObj.anchorID = "default-notification-icon"; + + let opened = waitForNotificationPanel(); + let notification = showNotification(notifyObj); + let popup = await opened; + checkPopup(popup, notifyObj); + + // Check that the urlbar is still focused. + is(Services.focus.focusedElement, gURLBar.inputField); + + this.notification.remove(); + notification.remove(); + }, + }, + // Test that focus is not moved out of a content element if autofocus is not set. + { + id: "Test#6", + async run() { + let id = this.id; + await BrowserTestUtils.withNewTab( + "data:text/html,<input id='test-input'/>", + async function (browser) { + let notifyObj = new BasicNotification(id); + await SpecialPowers.spawn(browser, [], function () { + content.document.getElementById("test-input").focus(); + }); + + let opened = waitForNotificationPanel(); + let notification = showNotification(notifyObj); + await opened; + + // Check that the focused element in the chrome window + // is either the browser in case we're running on e10s + // or the input field in case of non-e10s. + if (gMultiProcessBrowser) { + is(Services.focus.focusedElement, browser); + } else { + is( + Services.focus.focusedElement, + browser.contentDocument.getElementById("test-input") + ); + } + + // Check that the input field is still focused inside the browser. + await SpecialPowers.spawn(browser, [], function () { + is( + content.document.activeElement, + content.document.getElementById("test-input") + ); + }); + + notification.remove(); + } + ); + goNext(); + }, + }, +]; diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_learnmore.js b/browser/base/content/test/popupNotifications/browser_popupNotification_learnmore.js new file mode 100644 index 0000000000..fc3946598c --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_learnmore.js @@ -0,0 +1,64 @@ +/* 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/. */ + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + setup(); +} + +var tests = [ + // Test checkbox being checked by default + { + id: "without_learn_more", + run() { + this.notifyObj = new BasicNotification(this.id); + showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + let link = notification.querySelector( + ".popup-notification-learnmore-link" + ); + ok(!link.href, "no href"); + is( + window.getComputedStyle(link).getPropertyValue("display"), + "none", + "link hidden" + ); + dismissNotification(popup); + }, + onHidden() {}, + }, + + // Test that passing the learnMoreURL field sets up the link. + { + id: "with_learn_more", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.options.learnMoreURL = "https://mozilla.org"; + showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + let link = notification.querySelector( + ".popup-notification-learnmore-link" + ); + is(link.textContent, "Learn more", "correct label"); + is(link.href, "https://mozilla.org", "correct href"); + isnot( + window.getComputedStyle(link).getPropertyValue("display"), + "none", + "link not hidden" + ); + dismissNotification(popup); + }, + onHidden() {}, + }, +]; diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_no_anchors.js b/browser/base/content/test/popupNotifications/browser_popupNotification_no_anchors.js new file mode 100644 index 0000000000..a73e1f5948 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_no_anchors.js @@ -0,0 +1,288 @@ +/* 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/. */ + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + setup(); +} + +const FALLBACK_ANCHOR = gURLBar.searchButton + ? "urlbar-search-button" + : "identity-icon"; + +var tests = [ + // Test that popupnotifications are anchored to the fallback anchor on + // about:blank, where anchor icons are hidden. + { + id: "Test#1", + async run() { + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank"); + + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.anchorID = "geo-notification-icon"; + this.notification = showNotification(this.notifyObj); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + is( + document.getElementById("geo-notification-icon").getBoundingClientRect() + .width, + 0, + "geo anchor shouldn't be visible" + ); + is( + popup.anchorNode.id, + FALLBACK_ANCHOR, + "notification anchored to fallback anchor" + ); + dismissNotification(popup); + }, + onHidden(popup) { + this.notification.remove(); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + }, + }, + // Test that popupnotifications are anchored to the fallback anchor after + // navigation to about:blank. + { + id: "Test#2", + async run() { + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.anchorID = "geo-notification-icon"; + this.notifyObj.addOptions({ + persistence: 1, + }); + this.notification = showNotification(this.notifyObj); + }, + async onShown(popup) { + await promiseTabLoadEvent(gBrowser.selectedTab, "about:blank"); + + checkPopup(popup, this.notifyObj); + is( + document.getElementById("geo-notification-icon").getBoundingClientRect() + .width, + 0, + "geo anchor shouldn't be visible" + ); + is( + popup.anchorNode.id, + FALLBACK_ANCHOR, + "notification anchored to fallback anchor" + ); + dismissNotification(popup); + }, + onHidden(popup) { + this.notification.remove(); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + }, + }, + // Test that dismissed popupnotifications cannot be opened on about:blank, but + // can be opened after navigation. + { + id: "Test#3", + async run() { + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab(gBrowser, "about:blank"); + + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.anchorID = "geo-notification-icon"; + this.notifyObj.addOptions({ + dismissed: true, + persistence: 1, + }); + this.notification = showNotification(this.notifyObj); + + is( + document.getElementById("geo-notification-icon").getBoundingClientRect() + .width, + 0, + "geo anchor shouldn't be visible" + ); + + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + await promiseTabLoadEvent(gBrowser.selectedTab, "http://example.com/"); + + isnot( + document.getElementById("geo-notification-icon").getBoundingClientRect() + .width, + 0, + "geo anchor should be visible" + ); + + EventUtils.synthesizeMouse( + document.getElementById("geo-notification-icon"), + 2, + 2, + {} + ); + }, + onShown(popup) { + checkPopup(popup, this.notifyObj); + dismissNotification(popup); + }, + onHidden(popup) { + this.notification.remove(); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + }, + }, + // Test that popupnotifications are hidden while editing the URL in the + // location bar, anchored to the fallback anchor when the focus is moved away + // from the location bar, and restored when the URL is reverted. + { + id: "Test#4", + async run() { + for (let persistent of [false, true]) { + let shown = waitForNotificationPanel(); + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.anchorID = "geo-notification-icon"; + this.notifyObj.addOptions({ persistent }); + this.notification = showNotification(this.notifyObj); + await shown; + + checkPopup(PopupNotifications.panel, this.notifyObj); + + // Typing in the location bar should hide the notification. + let hidden = waitForNotificationPanelHidden(); + gURLBar.select(); + EventUtils.sendString("*"); + await hidden; + + is( + document + .getElementById("geo-notification-icon") + .getBoundingClientRect().width, + 0, + "geo anchor shouldn't be visible" + ); + + // Moving focus to the next control should show the notifications again, + // anchored to the fallback anchor. We clear the URL bar before moving the + // focus so that the awesomebar popup doesn't get in the way. + shown = waitForNotificationPanel(); + EventUtils.synthesizeKey("KEY_Backspace"); + EventUtils.synthesizeKey("KEY_Tab"); + await shown; + + is( + PopupNotifications.panel.anchorNode.id, + FALLBACK_ANCHOR, + "notification anchored to fallback anchor" + ); + + // Moving focus to the location bar should hide the notification again. + hidden = waitForNotificationPanelHidden(); + EventUtils.synthesizeKey("KEY_Tab", { shiftKey: true }); + await hidden; + + // Reverting the URL should show the notification again. + shown = waitForNotificationPanel(); + EventUtils.synthesizeKey("KEY_Escape"); + await shown; + + checkPopup(PopupNotifications.panel, this.notifyObj); + + hidden = waitForNotificationPanelHidden(); + this.notification.remove(); + await hidden; + } + goNext(); + }, + }, + // Test that popupnotifications triggered while editing the URL in the + // location bar are only shown later when the URL is reverted. + { + id: "Test#5", + async run() { + for (let persistent of [false, true]) { + // Start editing the URL, ensuring that the awesomebar popup is hidden. + gURLBar.select(); + EventUtils.sendString("*"); + EventUtils.synthesizeKey("KEY_Backspace"); + // autoOpen behavior will show the panel, so it must be closed. + gURLBar.view.close(); + + // Trying to show a notification should display nothing. + let notShowing = TestUtils.topicObserved( + "PopupNotifications-updateNotShowing" + ); + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.anchorID = "geo-notification-icon"; + this.notifyObj.addOptions({ persistent }); + this.notification = showNotification(this.notifyObj); + await notShowing; + + // Reverting the URL should show the notification. + let shown = waitForNotificationPanel(); + EventUtils.synthesizeKey("KEY_Escape"); + await shown; + + checkPopup(PopupNotifications.panel, this.notifyObj); + + let hidden = waitForNotificationPanelHidden(); + this.notification.remove(); + await hidden; + } + + goNext(); + }, + }, + // Test that persistent panels are still open after switching to another tab + // and back, even while editing the URL in the new tab. + { + id: "Test#6", + async run() { + let shown = waitForNotificationPanel(); + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.anchorID = "geo-notification-icon"; + this.notifyObj.addOptions({ + persistent: true, + }); + this.notification = showNotification(this.notifyObj); + await shown; + + // Switching to a new tab should hide the notification. + let hidden = waitForNotificationPanelHidden(); + this.oldSelectedTab = gBrowser.selectedTab; + await BrowserTestUtils.openNewForegroundTab( + gBrowser, + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + "http://example.com/" + ); + await hidden; + + // Start editing the URL. + gURLBar.select(); + EventUtils.sendString("*"); + + // Switching to the old tab should show the notification again. + shown = waitForNotificationPanel(); + gBrowser.removeTab(gBrowser.selectedTab); + gBrowser.selectedTab = this.oldSelectedTab; + await shown; + + checkPopup(PopupNotifications.panel, this.notifyObj); + + hidden = waitForNotificationPanelHidden(); + this.notification.remove(); + await hidden; + + goNext(); + }, + }, +]; diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_security_delay.js b/browser/base/content/test/popupNotifications/browser_popupNotification_security_delay.js new file mode 100644 index 0000000000..515895f35a --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_security_delay.js @@ -0,0 +1,296 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +"use strict"; + +const TEST_SECURITY_DELAY = 5000; + +/** + * Shows a test PopupNotification. + */ +function showNotification() { + PopupNotifications.show( + gBrowser.selectedBrowser, + "foo", + "Hello, World!", + "default-notification-icon", + { + label: "ok", + accessKey: "o", + callback: () => {}, + }, + [ + { + label: "cancel", + accessKey: "c", + callback: () => {}, + }, + ], + { + // Make test notifications persistent to ensure they are only closed + // explicitly by test actions and survive tab switches. + persistent: true, + } + ); +} + +add_setup(async function () { + // Set a longer security delay for PopupNotification actions so we can test + // the delay even if the test runs slowly. + await SpecialPowers.pushPrefEnv({ + set: [["security.notification_enable_delay", TEST_SECURITY_DELAY]], + }); +}); + +async function ensureSecurityDelayReady() { + /** + * The security delay calculation in PopupNotification.sys.mjs is dependent on + * the monotonically increasing value of performance.now. This timestamp is + * not relative to a fixed date, but to runtime. + * We need to wait for the value performance.now() to be larger than the + * security delay in order to observe the bug. Only then does the + * timeSinceShown check in PopupNotifications.sys.mjs lead to a timeSinceShown + * value that is unconditionally greater than lazy.buttonDelay for + * notification.timeShown = null = 0. + * See: https://searchfox.org/mozilla-central/rev/f32d5f3949a3f4f185122142b29f2e3ab776836e/toolkit/modules/PopupNotifications.sys.mjs#1870-1872 + * + * When running in automation as part of a larger test suite performance.now() + * should usually be already sufficiently high in which case this check should + * directly resolve. + */ + await TestUtils.waitForCondition( + () => performance.now() > TEST_SECURITY_DELAY, + "Wait for performance.now() > SECURITY_DELAY", + 500, + 50 + ); +} + +/** + * Tests that when we show a second notification while the panel is open the + * timeShown attribute is correctly set and the security delay is enforced + * properly. + */ +add_task(async function test_timeShownMultipleNotifications() { + await ensureSecurityDelayReady(); + + ok( + !PopupNotifications.isPanelOpen, + "PopupNotification panel should not be open initially." + ); + + info("Open the first notification."); + let popupShownPromise = waitForNotificationPanel(); + showNotification(); + await popupShownPromise; + ok( + PopupNotifications.isPanelOpen, + "PopupNotification should be open after first show call." + ); + + is( + PopupNotifications._currentNotifications.length, + 1, + "There should only be one notification" + ); + + let notification = PopupNotifications.getNotification( + "foo", + gBrowser.selectedBrowser + ); + is(notification?.id, "foo", "There should be a notification with id foo"); + ok(notification.timeShown, "The notification should have timeShown set"); + + info( + "Call show again with the same notification id while the PopupNotification panel is still open." + ); + showNotification(); + ok( + PopupNotifications.isPanelOpen, + "PopupNotification should still open after second show call." + ); + notification = PopupNotifications.getNotification( + "foo", + gBrowser.selectedBrowser + ); + is( + PopupNotifications._currentNotifications.length, + 1, + "There should still only be one notification" + ); + + is( + notification?.id, + "foo", + "There should still be a notification with id foo" + ); + ok(notification.timeShown, "The notification should have timeShown set"); + + let notificationHiddenPromise = waitForNotificationPanelHidden(); + + info("Trigger main action via button click during security delay"); + triggerMainCommand(PopupNotifications.panel); + + await new Promise(resolve => setTimeout(resolve, 0)); + + ok(PopupNotifications.isPanelOpen, "PopupNotification should still be open."); + notification = PopupNotifications.getNotification( + "foo", + gBrowser.selectedBrowser + ); + ok( + notification, + "Notification should still be open because we clicked during the security delay." + ); + + // If the notification is no longer shown (test failure) skip the remaining + // checks. + if (!notification) { + return; + } + + // Ensure that once the security delay has passed the notification can be + // closed again. + let fakeTimeShown = TEST_SECURITY_DELAY + 500; + info(`Manually set timeShown to ${fakeTimeShown}ms in the past.`); + notification.timeShown = performance.now() - fakeTimeShown; + + info("Trigger main action via button click outside security delay"); + triggerMainCommand(PopupNotifications.panel); + + info("Wait for panel to be hidden."); + await notificationHiddenPromise; + + ok( + !PopupNotifications.getNotification("foo", gBrowser.selectedBrowser), + "Should not longer see the notification." + ); +}); + +/** + * Tests that when we reshow a notification after a tab switch the timeShown + * attribute is correctly reset and the security delay is enforced. + */ +add_task(async function test_notificationReshowTabSwitch() { + await ensureSecurityDelayReady(); + + ok( + !PopupNotifications.isPanelOpen, + "PopupNotification panel should not be open initially." + ); + + info("Open the first notification."); + let popupShownPromise = waitForNotificationPanel(); + showNotification(); + await popupShownPromise; + ok( + PopupNotifications.isPanelOpen, + "PopupNotification should be open after first show call." + ); + + let notification = PopupNotifications.getNotification( + "foo", + gBrowser.selectedBrowser + ); + is(notification?.id, "foo", "There should be a notification with id foo"); + ok(notification.timeShown, "The notification should have timeShown set"); + + info("Trigger main action via button click during security delay"); + triggerMainCommand(PopupNotifications.panel); + + await new Promise(resolve => setTimeout(resolve, 0)); + + ok(PopupNotifications.isPanelOpen, "PopupNotification should still be open."); + notification = PopupNotifications.getNotification( + "foo", + gBrowser.selectedBrowser + ); + ok( + notification, + "Notification should still be open because we clicked during the security delay." + ); + + // If the notification is no longer shown (test failure) skip the remaining + // checks. + if (!notification) { + return; + } + + let panelHiddenPromise = waitForNotificationPanelHidden(); + let panelShownPromise; + + info("Open a new tab which hides the notification panel."); + await BrowserTestUtils.withNewTab("https://example.com", async browser => { + info("Wait for panel to be hidden by tab switch."); + await panelHiddenPromise; + info( + "Keep the tab open until the security delay for the original notification show has expired." + ); + await new Promise(resolve => + // eslint-disable-next-line mozilla/no-arbitrary-setTimeout + setTimeout(resolve, TEST_SECURITY_DELAY + 500) + ); + + panelShownPromise = waitForNotificationPanel(); + }); + info( + "Wait for the panel to show again after the tab close. We're showing the original tab again." + ); + await panelShownPromise; + + ok( + PopupNotifications.isPanelOpen, + "PopupNotification should be shown after tab close." + ); + notification = PopupNotifications.getNotification( + "foo", + gBrowser.selectedBrowser + ); + is( + notification?.id, + "foo", + "There should still be a notification with id foo" + ); + + let notificationHiddenPromise = waitForNotificationPanelHidden(); + + info( + "Because we re-show the panel after tab close / switch the security delay should have reset." + ); + info("Trigger main action via button click during the new security delay."); + triggerMainCommand(PopupNotifications.panel); + + await new Promise(resolve => setTimeout(resolve, 0)); + + ok(PopupNotifications.isPanelOpen, "PopupNotification should still be open."); + notification = PopupNotifications.getNotification( + "foo", + gBrowser.selectedBrowser + ); + ok( + notification, + "Notification should still be open because we clicked during the security delay." + ); + // If the notification is no longer shown (test failure) skip the remaining + // checks. + if (!notification) { + return; + } + + // Ensure that once the security delay has passed the notification can be + // closed again. + let fakeTimeShown = TEST_SECURITY_DELAY + 500; + info(`Manually set timeShown to ${fakeTimeShown}ms in the past.`); + notification.timeShown = performance.now() - fakeTimeShown; + + info("Trigger main action via button click outside security delay"); + triggerMainCommand(PopupNotifications.panel); + + info("Wait for panel to be hidden."); + await notificationHiddenPromise; + + ok( + !PopupNotifications.getNotification("foo", gBrowser.selectedBrowser), + "Should not longer see the notification." + ); +}); diff --git a/browser/base/content/test/popupNotifications/browser_popupNotification_selection_required.js b/browser/base/content/test/popupNotifications/browser_popupNotification_selection_required.js new file mode 100644 index 0000000000..31463f5345 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_popupNotification_selection_required.js @@ -0,0 +1,57 @@ +/* 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/. */ + +function test() { + waitForExplicitFinish(); + + ok(PopupNotifications, "PopupNotifications object exists"); + ok(PopupNotifications.panel, "PopupNotifications panel exists"); + + setup(); +} + +function promiseElementVisible(element) { + // HTMLElement.offsetParent is null when the element is not visisble + // (or if the element has |position: fixed|). See: + // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetParent + return TestUtils.waitForCondition( + () => element.offsetParent !== null, + "Waiting for element to be visible" + ); +} + +var gNotification; + +var tests = [ + // Test that passing selection required prevents the button from clicking + { + id: "require_selection_check", + run() { + this.notifyObj = new BasicNotification(this.id); + this.notifyObj.options.checkbox = { + label: "This is a checkbox", + }; + gNotification = showNotification(this.notifyObj); + }, + async onShown(popup) { + checkPopup(popup, this.notifyObj); + let notification = popup.children[0]; + notification.setAttribute("invalidselection", true); + await promiseElementVisible(notification.checkbox); + EventUtils.synthesizeMouseAtCenter(notification.checkbox, {}); + ok( + notification.button.disabled, + "should be disabled when invalidselection" + ); + notification.removeAttribute("invalidselection"); + EventUtils.synthesizeMouseAtCenter(notification.checkbox, {}); + ok( + !notification.button.disabled, + "should not be disabled when invalidselection is not present" + ); + triggerMainCommand(popup); + }, + onHidden() {}, + }, +]; diff --git a/browser/base/content/test/popupNotifications/browser_reshow_in_background.js b/browser/base/content/test/popupNotifications/browser_reshow_in_background.js new file mode 100644 index 0000000000..bb2494a5b5 --- /dev/null +++ b/browser/base/content/test/popupNotifications/browser_reshow_in_background.js @@ -0,0 +1,72 @@ +"use strict"; + +/** + * Tests that when PopupNotifications for background tabs are reshown, they + * don't show up in the foreground tab, but only in the background tab that + * they belong to. + */ +add_task( + async function test_background_notifications_dont_reshow_in_foreground() { + // Our initial tab will be A. Let's open two more tabs B and C, but keep + // A selected. Then, we'll trigger a PopupNotification in C, and then make + // it reshow. + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + let tabB = BrowserTestUtils.addTab(gBrowser, "http://example.com/"); + await BrowserTestUtils.browserLoaded(tabB.linkedBrowser); + + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + let tabC = BrowserTestUtils.addTab(gBrowser, "http://example.com/"); + await BrowserTestUtils.browserLoaded(tabC.linkedBrowser); + + let seenEvents = []; + + let options = { + dismissed: false, + eventCallback(popupEvent) { + seenEvents.push(popupEvent); + }, + }; + + let notification = PopupNotifications.show( + tabC.linkedBrowser, + "test-notification", + "", + "plugins-notification-icon", + null, + null, + options + ); + Assert.deepEqual(seenEvents, [], "Should have seen no events yet."); + + await BrowserTestUtils.switchTab(gBrowser, tabB); + Assert.deepEqual(seenEvents, [], "Should have seen no events yet."); + + notification.reshow(); + Assert.deepEqual(seenEvents, [], "Should have seen no events yet."); + + let panelShown = BrowserTestUtils.waitForEvent( + PopupNotifications.panel, + "popupshown" + ); + await BrowserTestUtils.switchTab(gBrowser, tabC); + await panelShown; + + Assert.equal(seenEvents.length, 2, "Should have seen two events."); + Assert.equal( + seenEvents[0], + "showing", + "Should have said popup was showing." + ); + Assert.equal(seenEvents[1], "shown", "Should have said popup was shown."); + + let panelHidden = BrowserTestUtils.waitForEvent( + PopupNotifications.panel, + "popuphidden" + ); + PopupNotifications.remove(notification); + await panelHidden; + + BrowserTestUtils.removeTab(tabB); + BrowserTestUtils.removeTab(tabC); + } +); diff --git a/browser/base/content/test/popupNotifications/head.js b/browser/base/content/test/popupNotifications/head.js new file mode 100644 index 0000000000..f347f8dbf2 --- /dev/null +++ b/browser/base/content/test/popupNotifications/head.js @@ -0,0 +1,367 @@ +ChromeUtils.defineESModuleGetters(this, { + PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs", +}); + +/** + * Called after opening a new window or switching windows, this will wait until + * we are sure that an attempt to display a notification will not fail. + */ +async function waitForWindowReadyForPopupNotifications(win) { + // These are the same checks that PopupNotifications.sys.mjs makes before it + // allows a notification to open. + await TestUtils.waitForCondition( + () => win.gBrowser.selectedBrowser.docShellIsActive, + "The browser should be active" + ); + await TestUtils.waitForCondition( + () => Services.focus.activeWindow == win, + "The window should be active" + ); +} + +/** + * Waits for a load (or custom) event to finish in a given tab. If provided + * load an uri into the tab. + * + * @param tab + * The tab to load into. + * @param [optional] url + * The url to load, or the current url. + * @return {Promise} resolved when the event is handled. + * @resolves to the received event + * @rejects if a valid load event is not received within a meaningful interval + */ +function promiseTabLoadEvent(tab, url) { + let browser = tab.linkedBrowser; + + if (url) { + BrowserTestUtils.loadURIString(browser, url); + } + + return BrowserTestUtils.browserLoaded(browser, false, url); +} + +// Tests that call setup() should have a `tests` array defined for the actual +// tests to be run. +/* global tests */ +function setup() { + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + BrowserTestUtils.openNewForegroundTab(gBrowser, "http://example.com/").then( + goNext + ); + registerCleanupFunction(() => { + gBrowser.removeTab(gBrowser.selectedTab); + }); +} + +function goNext() { + executeSoon(() => executeSoon(runNextTest)); +} + +async function runNextTest() { + if (!tests.length) { + executeSoon(finish); + return; + } + + let nextTest = tests.shift(); + if (nextTest.onShown) { + let shownState = false; + onPopupEvent("popupshowing", function () { + info("[" + nextTest.id + "] popup showing"); + }); + onPopupEvent("popupshown", function () { + shownState = true; + info("[" + nextTest.id + "] popup shown"); + (nextTest.onShown(this) || Promise.resolve()).then(undefined, ex => + Assert.ok(false, "onShown failed: " + ex) + ); + }); + onPopupEvent( + "popuphidden", + function () { + info("[" + nextTest.id + "] popup hidden"); + (nextTest.onHidden(this) || Promise.resolve()).then( + () => goNext(), + ex => Assert.ok(false, "onHidden failed: " + ex) + ); + }, + () => shownState + ); + info( + "[" + + nextTest.id + + "] added listeners; panel is open: " + + PopupNotifications.isPanelOpen + ); + } + + info("[" + nextTest.id + "] running test"); + await nextTest.run(); +} + +function showNotification(notifyObj) { + info("Showing notification " + notifyObj.id); + return PopupNotifications.show( + notifyObj.browser, + notifyObj.id, + notifyObj.message, + notifyObj.anchorID, + notifyObj.mainAction, + notifyObj.secondaryActions, + notifyObj.options + ); +} + +function dismissNotification(popup) { + info("Dismissing notification " + popup.childNodes[0].id); + executeSoon(() => EventUtils.synthesizeKey("KEY_Escape")); +} + +function BasicNotification(testId) { + this.browser = gBrowser.selectedBrowser; + this.id = "test-notification-" + testId; + this.message = testId + ": Will you allow <> to perform this action?"; + this.anchorID = null; + this.mainAction = { + label: "Main Action", + accessKey: "M", + callback: ({ source }) => { + this.mainActionClicked = true; + this.mainActionSource = source; + }, + }; + this.secondaryActions = [ + { + label: "Secondary Action", + accessKey: "S", + callback: ({ source }) => { + this.secondaryActionClicked = true; + this.secondaryActionSource = source; + }, + }, + ]; + this.options = { + // eslint-disable-next-line @microsoft/sdl/no-insecure-url + name: "http://example.com", + eventCallback: eventName => { + switch (eventName) { + case "dismissed": + this.dismissalCallbackTriggered = true; + break; + case "showing": + this.showingCallbackTriggered = true; + break; + case "shown": + this.shownCallbackTriggered = true; + break; + case "removed": + this.removedCallbackTriggered = true; + break; + case "swapping": + this.swappingCallbackTriggered = true; + break; + } + }, + }; +} + +BasicNotification.prototype.addOptions = function (options) { + for (let [name, value] of Object.entries(options)) { + this.options[name] = value; + } +}; + +function ErrorNotification(testId) { + BasicNotification.call(this, testId); + this.mainAction.callback = () => { + this.mainActionClicked = true; + throw new Error("Oops!"); + }; + this.secondaryActions[0].callback = () => { + this.secondaryActionClicked = true; + throw new Error("Oops!"); + }; +} + +ErrorNotification.prototype = BasicNotification.prototype; + +function checkPopup(popup, notifyObj) { + info("Checking notification " + notifyObj.id); + + ok(notifyObj.showingCallbackTriggered, "showing callback was triggered"); + ok(notifyObj.shownCallbackTriggered, "shown callback was triggered"); + + let notifications = popup.childNodes; + is(notifications.length, 1, "one notification displayed"); + let notification = notifications[0]; + if (!notification) { + return; + } + + // PopupNotifications are not expected to show icons + // unless popupIconURL or popupIconClass is passed in the options object. + if (notifyObj.options.popupIconURL || notifyObj.options.popupIconClass) { + let icon = notification.querySelector(".popup-notification-icon"); + if (notifyObj.id == "geolocation") { + isnot(icon.getBoundingClientRect().width, 0, "icon for geo displayed"); + ok( + popup.anchorNode.classList.contains("notification-anchor-icon"), + "notification anchored to icon" + ); + } + } + + let description = notifyObj.message.split("<>"); + let text = {}; + text.start = description[0]; + text.end = description[1]; + is(notification.getAttribute("label"), text.start, "message matches"); + is( + notification.getAttribute("name"), + notifyObj.options.name, + "message matches" + ); + is(notification.getAttribute("endlabel"), text.end, "message matches"); + + is(notification.id, notifyObj.id + "-notification", "id matches"); + if (notifyObj.mainAction) { + is( + notification.getAttribute("buttonlabel"), + notifyObj.mainAction.label, + "main action label matches" + ); + is( + notification.getAttribute("buttonaccesskey"), + notifyObj.mainAction.accessKey, + "main action accesskey matches" + ); + } + if (notifyObj.secondaryActions && notifyObj.secondaryActions.length) { + let secondaryAction = notifyObj.secondaryActions[0]; + is( + notification.getAttribute("secondarybuttonlabel"), + secondaryAction.label, + "secondary action label matches" + ); + is( + notification.getAttribute("secondarybuttonaccesskey"), + secondaryAction.accessKey, + "secondary action accesskey matches" + ); + } + // Additional secondary actions appear as menu items. + let actualExtraSecondaryActions = Array.prototype.filter.call( + notification.menupopup.childNodes, + child => child.nodeName == "menuitem" + ); + let extraSecondaryActions = notifyObj.secondaryActions + ? notifyObj.secondaryActions.slice(1) + : []; + is( + actualExtraSecondaryActions.length, + extraSecondaryActions.length, + "number of extra secondary actions matches" + ); + extraSecondaryActions.forEach(function (a, i) { + is( + actualExtraSecondaryActions[i].getAttribute("label"), + a.label, + "label for extra secondary action " + i + " matches" + ); + is( + actualExtraSecondaryActions[i].getAttribute("accesskey"), + a.accessKey, + "accessKey for extra secondary action " + i + " matches" + ); + }); +} + +XPCOMUtils.defineLazyGetter(this, "gActiveListeners", () => { + let listeners = new Map(); + registerCleanupFunction(() => { + for (let [listener, eventName] of listeners) { + PopupNotifications.panel.removeEventListener(eventName, listener); + } + }); + return listeners; +}); + +function onPopupEvent(eventName, callback, condition) { + let listener = event => { + if ( + event.target != PopupNotifications.panel || + (condition && !condition()) + ) { + return; + } + PopupNotifications.panel.removeEventListener(eventName, listener); + gActiveListeners.delete(listener); + executeSoon(() => callback.call(PopupNotifications.panel)); + }; + gActiveListeners.set(listener, eventName); + PopupNotifications.panel.addEventListener(eventName, listener); +} + +function waitForNotificationPanel() { + return new Promise(resolve => { + onPopupEvent("popupshown", function () { + resolve(this); + }); + }); +} + +function waitForNotificationPanelHidden() { + return new Promise(resolve => { + onPopupEvent("popuphidden", function () { + resolve(this); + }); + }); +} + +function triggerMainCommand(popup) { + let notifications = popup.childNodes; + ok(!!notifications.length, "at least one notification displayed"); + let notification = notifications[0]; + info("Triggering main command for notification " + notification.id); + EventUtils.synthesizeMouseAtCenter(notification.button, {}); +} + +function triggerSecondaryCommand(popup, index) { + let notifications = popup.childNodes; + ok(!!notifications.length, "at least one notification displayed"); + let notification = notifications[0]; + info("Triggering secondary command for notification " + notification.id); + + if (index == 0) { + EventUtils.synthesizeMouseAtCenter(notification.secondaryButton, {}); + return; + } + + // Extra secondary actions appear in a menu. + notification.secondaryButton.nextElementSibling.focus(); + + popup.addEventListener( + "popupshown", + function () { + info("Command popup open for notification " + notification.id); + // Press down until the desired command is selected. Decrease index by one + // since the secondary action was handled above. + for (let i = 0; i <= index - 1; i++) { + EventUtils.synthesizeKey("KEY_ArrowDown"); + } + // Activate + EventUtils.synthesizeKey("KEY_Enter"); + }, + { once: true } + ); + + // One down event to open the popup + info( + "Open the popup to trigger secondary command for notification " + + notification.id + ); + EventUtils.synthesizeKey("KEY_ArrowDown", { + altKey: !navigator.platform.includes("Mac"), + }); +} |