Source code
Revision control
Copy as Markdown
Other Tools
ChromeUtils.defineESModuleGetters(this, {
});
const BASE = getRootDirectory(gTestPath).replace(
);
ChromeUtils.defineLazyGetter(this, "Management", () => {
// eslint-disable-next-line no-shadow
const { Management } = ChromeUtils.importESModule(
);
return Management;
});
let { CustomizableUITestUtils } = ChromeUtils.importESModule(
);
let gCUITestUtils = new CustomizableUITestUtils(window);
const { PermissionTestUtils } = ChromeUtils.importESModule(
);
let extL10n = null;
/**
* @param {string} id
* @param {object} [args]
* @returns {string}
*/
function formatExtValue(id, args) {
if (!extL10n) {
extL10n = new Localization(
[
"toolkit/global/extensions.ftl",
"toolkit/global/extensionPermissions.ftl",
"branding/brand.ftl",
],
true
);
}
return extL10n.formatValueSync(id, args);
}
/**
* Wait for the given PopupNotification to display
*
* @param {string} name
* The name of the notification to wait for.
*
* @returns {Promise}
* Resolves with the notification window.
*/
function promisePopupNotificationShown(name) {
return new Promise(resolve => {
function popupshown() {
let notification = PopupNotifications.getNotification(name);
if (!notification) {
return;
}
ok(notification, `${name} notification shown`);
ok(PopupNotifications.isPanelOpen, "notification panel open");
PopupNotifications.panel.removeEventListener("popupshown", popupshown);
resolve(PopupNotifications.panel.firstElementChild);
}
PopupNotifications.panel.addEventListener("popupshown", popupshown);
});
}
function promiseAppMenuNotificationShown(id) {
const { AppMenuNotifications } = ChromeUtils.importESModule(
);
return new Promise(resolve => {
function popupshown() {
let notification = AppMenuNotifications.activeNotification;
if (!notification) {
return;
}
is(notification.id, id, `${id} notification shown`);
ok(PanelUI.isNotificationPanelOpen, "notification panel open");
PanelUI.notificationPanel.removeEventListener("popupshown", popupshown);
let popupnotificationID = PanelUI._getPopupId(notification);
let popupnotification = document.getElementById(popupnotificationID);
resolve(popupnotification);
}
PanelUI.notificationPanel.addEventListener("popupshown", popupshown);
});
}
/**
* Wait for a specific install event to fire for a given addon
*
* @param {AddonWrapper} addon
* The addon to watch for an event on
* @param {string}
* The name of the event to watch for (e.g., onInstallEnded)
*
* @returns {Promise}
* Resolves when the event triggers with the first argument
* to the event handler as the resolution value.
*/
function promiseInstallEvent(addon, event) {
return new Promise(resolve => {
let listener = {};
listener[event] = (install, arg) => {
if (install.addon.id == addon.id) {
AddonManager.removeInstallListener(listener);
resolve(arg);
}
};
AddonManager.addInstallListener(listener);
});
}
/**
* Install an (xpi packaged) extension
*
* @param {string} url
* URL of the .xpi file to install
* @param {Object?} installTelemetryInfo
* an optional object that contains additional details used by the telemetry events.
*
* @returns {Promise}
* Resolves when the extension has been installed with the Addon
* object as the resolution value.
*/
async function promiseInstallAddon(url, telemetryInfo) {
let install = await AddonManager.getInstallForURL(url, { telemetryInfo });
install.install();
let addon = await new Promise(resolve => {
install.addListener({
onInstallEnded(_install, _addon) {
resolve(_addon);
},
});
});
if (addon.isWebExtension) {
await new Promise(resolve => {
function listener(event, extension) {
if (extension.id == addon.id) {
Management.off("ready", listener);
resolve();
}
}
Management.on("ready", listener);
});
}
return addon;
}
/**
* Wait for an update to the given webextension to complete.
* (This does not actually perform an update, it just watches for
* the events that occur as a result of an update.)
*
* @param {AddonWrapper} addon
* The addon to be updated.
*
* @returns {Promise}
* Resolves when the extension has ben updated.
*/
async function waitForUpdate(addon) {
let installPromise = promiseInstallEvent(addon, "onInstallEnded");
let readyPromise = new Promise(resolve => {
function listener(event, extension) {
if (extension.id == addon.id) {
Management.off("ready", listener);
resolve();
}
}
Management.on("ready", listener);
});
let [newAddon] = await Promise.all([installPromise, readyPromise]);
return newAddon;
}
function waitAboutAddonsViewLoaded(doc) {
return BrowserTestUtils.waitForEvent(doc, "view-loaded");
}
/**
* Trigger an action from the page options menu.
*/
function triggerPageOptionsAction(win, action) {
win.document.querySelector(`#page-options [action="${action}"]`).click();
}
function isDefaultIcon(icon) {
}
/**
* Check the contents of a permission popup notification
*
* @param {Window} panel
* The popup window.
* @param {string|regexp|function} checkIcon
* The icon expected to appear in the notification. If this is a
* string, it must match the icon url exactly. If it is a
* regular expression it is tested against the icon url, and if
* it is a function, it is called with the icon url and returns
* true if the url is correct.
* @param {array} permissions
* The expected entries in the permissions list. Each element
* in this array is itself a 2-element array with the string key
* for the item (e.g., "webext-perms-description-foo") and an
* optional formatting parameter.
* @param {boolean} sideloaded
* Whether the notification is for a sideloaded extenion.
*/
function checkNotification(panel, checkIcon, permissions, sideloaded) {
let icon = panel.getAttribute("icon");
let ul = document.getElementById("addon-webext-perm-list");
let singleDataEl = document.getElementById("addon-webext-perm-single-entry");
let learnMoreLink = document.getElementById("addon-webext-perm-info");
if (checkIcon instanceof RegExp) {
ok(
checkIcon.test(icon),
`Notification icon is correct ${JSON.stringify(icon)} ~= ${checkIcon}`
);
} else if (typeof checkIcon == "function") {
ok(checkIcon(icon), "Notification icon is correct");
} else {
is(icon, checkIcon, "Notification icon is correct");
}
let description = panel.querySelector(
".popup-notification-description"
).textContent;
let descL10nId = "webext-perms-header";
if (permissions.length) {
descL10nId = "webext-perms-header-with-perms";
}
if (sideloaded) {
descL10nId = "webext-perms-sideload-header";
}
const exp = formatExtValue(descL10nId, { extension: "<>" }).split("<>");
ok(description.startsWith(exp.at(0)), "Description is the expected one");
ok(description.endsWith(exp.at(-1)), "Description is the expected one");
is(
learnMoreLink.hidden,
!permissions.length,
"Permissions learn more is hidden if there are no permissions"
);
if (!permissions.length) {
ok(ul.hidden, "Permissions list is hidden");
ok(singleDataEl.hidden, "Single permission data entry is hidden");
ok(
!(ul.childElementCount || singleDataEl.textContent),
"Permission list and single permission element have no entries"
);
} else if (permissions.length === 1) {
ok(ul.hidden, "Permissions list is hidden");
ok(!ul.childElementCount, "Permission list has no entries");
ok(singleDataEl.textContent, "Single permission data label has been set");
} else {
ok(singleDataEl.hidden, "Single permission data entry is hidden");
ok(
!singleDataEl.textContent,
"Single permission data label has not been set"
);
for (let i in permissions) {
let [key, param] = permissions[i];
const expected = formatExtValue(key, param);
is(
ul.children[i].textContent,
expected,
`Permission number ${i + 1} is correct`
);
}
}
}
/**
* Test that install-time permission prompts work for a given
* installation method.
*
* @param {Function} installFn
* Callable that takes the name of an xpi file to install and
* starts to install it. Should return a Promise that resolves
* when the install is finished or rejects if the install is canceled.
* @param {string} telemetryBase
* If supplied, the base type for telemetry events that should be
* recorded for this install method.
*
* @returns {Promise}
*/
async function testInstallMethod(installFn) {
const PERMS_XPI = "browser_webext_permissions.xpi";
const NO_PERMS_XPI = "browser_webext_nopermissions.xpi";
const ID = "permissions@test.mozilla.org";
await SpecialPowers.pushPrefEnv({
set: [
["extensions.webapi.testing", true],
["extensions.install.requireBuiltInCerts", false],
],
});
PermissionTestUtils.add(testURI, "install", Services.perms.ALLOW_ACTION);
registerCleanupFunction(() => PermissionTestUtils.remove(testURI, "install"));
async function runOnce(filename, cancel) {
let tab = await BrowserTestUtils.openNewForegroundTab(gBrowser);
let installPromise = new Promise(resolve => {
let listener = {
onDownloadCancelled() {
AddonManager.removeInstallListener(listener);
resolve(false);
},
onDownloadFailed() {
AddonManager.removeInstallListener(listener);
resolve(false);
},
onInstallCancelled() {
AddonManager.removeInstallListener(listener);
resolve(false);
},
onInstallEnded() {
AddonManager.removeInstallListener(listener);
resolve(true);
},
onInstallFailed() {
AddonManager.removeInstallListener(listener);
resolve(false);
},
};
AddonManager.addInstallListener(listener);
});
let installMethodPromise = installFn(filename);
let panel = await promisePopupNotificationShown("addon-webext-permissions");
if (filename == PERMS_XPI) {
// The icon should come from the extension, don't bother with the precise
// path, just make sure we've got a jar url pointing to the right path
// inside the jar.
checkNotification(panel, /^jar:file:\/\/.*\/icon\.png$/, [
[
"webext-perms-host-description-wildcard",
{ domain: "wildcard.domain" },
],
[
"webext-perms-host-description-one-site",
{ domain: "singlehost.domain" },
],
["webext-perms-description-nativeMessaging"],
// The below permissions are deliberately in this order as permissions
// are sorted alphabetically by the permission string to match AMO.
["webext-perms-description-history"],
["webext-perms-description-tabs"],
]);
} else if (filename == NO_PERMS_XPI) {
checkNotification(panel, isDefaultIcon, []);
}
if (cancel) {
panel.secondaryButton.click();
try {
await installMethodPromise;
} catch (err) {}
} else {
// Look for post-install notification
let postInstallPromise =
promiseAppMenuNotificationShown("addon-installed");
panel.button.click();
// Press OK on the post-install notification
panel = await postInstallPromise;
panel.button.click();
await installMethodPromise;
}
let result = await installPromise;
let addon = await AddonManager.getAddonByID(ID);
if (cancel) {
ok(!result, "Installation was cancelled");
is(addon, null, "Extension is not installed");
} else {
ok(result, "Installation completed");
isnot(addon, null, "Extension is installed");
await addon.uninstall();
}
BrowserTestUtils.removeTab(tab);
}
// A few different tests for each installation method:
// 1. Start installation of an extension that requests no permissions,
// verify the notification contents, then cancel the install
await runOnce(NO_PERMS_XPI, true);
// 2. Same as #1 but with an extension that requests some permissions.
await runOnce(PERMS_XPI, true);
// 3. Repeat with the same extension from step 2 but this time,
// accept the permissions to install the extension. (Then uninstall
// the extension to clean up.)
await runOnce(PERMS_XPI, false);
await SpecialPowers.popPrefEnv();
}
// Helper function to test a specific scenario for interactive updates.
// `checkFn` is a callable that triggers a check for updates.
// `autoUpdate` specifies whether the test should be run with
// updates applied automatically or not.
async function interactiveUpdateTest(autoUpdate, checkFn) {
AddonTestUtils.initMochitest(this);
Services.fog.testResetFOG();
const ID = "update2@tests.mozilla.org";
const FAKE_INSTALL_SOURCE = "fake-install-source";
await SpecialPowers.pushPrefEnv({
set: [
// We don't have pre-pinned certificates for the local mochitest server
["extensions.install.requireBuiltInCerts", false],
["extensions.update.requireBuiltInCerts", false],
["extensions.update.autoUpdateDefault", autoUpdate],
// Point updates to the local mochitest server
["extensions.update.url", `${BASE}/browser_webext_update.json`],
],
});
AddonTestUtils.hookAMTelemetryEvents();
// Trigger an update check, manually applying the update if we're testing
// without auto-update.
async function triggerUpdate(win, addon) {
let manualUpdatePromise;
if (!autoUpdate) {
manualUpdatePromise = new Promise(resolve => {
let listener = {
onNewInstall() {
AddonManager.removeInstallListener(listener);
resolve();
},
};
AddonManager.addInstallListener(listener);
});
}
let promise = checkFn(win, addon);
if (manualUpdatePromise) {
await manualUpdatePromise;
let doc = win.document;
let showUpdatesBtn = doc.querySelector("addon-updates-message").button;
await TestUtils.waitForCondition(() => {
return !showUpdatesBtn.hidden;
}, "Wait for show updates button");
let viewChanged = waitAboutAddonsViewLoaded(doc);
showUpdatesBtn.click();
await viewChanged;
}
let card = await TestUtils.waitForCondition(() => {
return doc.querySelector(`addon-card[addon-id="${ID}"]`);
}, `Wait addon card for "${ID}"`);
let updateBtn = card.querySelector('panel-item[action="install-update"]');
ok(updateBtn, `Found update button for "${ID}"`);
updateBtn.click();
}
return { promise };
}
// Navigate away from the starting page to force about:addons to load
// in a new tab during the tests below.
BrowserTestUtils.startLoadingURIString(
gBrowser.selectedBrowser,
"about:mozilla"
);
await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
// Install version 1.0 of the test extension
let addon = await promiseInstallAddon(`${BASE}/browser_webext_update1.xpi`, {
source: FAKE_INSTALL_SOURCE,
});
ok(addon, "Addon was installed");
is(addon.version, "1.0", "Version 1 of the addon is installed");
await waitAboutAddonsViewLoaded(win.document);
// Trigger an update check
let popupPromise = promisePopupNotificationShown("addon-webext-permissions");
let { promise: checkPromise } = await triggerUpdate(win, addon);
let panel = await popupPromise;
// Click the cancel button, wait to see the cancel event
let cancelPromise = promiseInstallEvent(addon, "onInstallCancelled");
panel.secondaryButton.click();
const cancelledByUser = await cancelPromise;
is(cancelledByUser, true, "Install cancelled by user");
addon = await AddonManager.getAddonByID(ID);
is(addon.version, "1.0", "Should still be running the old version");
// Make sure the update check is completely finished.
await checkPromise;
// Trigger a new update check
popupPromise = promisePopupNotificationShown("addon-webext-permissions");
checkPromise = (await triggerUpdate(win, addon)).promise;
// This time, accept the upgrade
let updatePromise = waitForUpdate(addon);
panel = await popupPromise;
panel.button.click();
addon = await updatePromise;
is(addon.version, "2.0", "Should have upgraded");
await checkPromise;
BrowserTestUtils.removeTab(gBrowser.selectedTab);
await addon.uninstall();
await SpecialPowers.popPrefEnv();
const collectedUpdateEvents = AddonTestUtils.getAMTelemetryEvents().filter(
evt => {
return evt.method === "update";
}
);
const expectedSteps = [
// First update is cancelled on the permission prompt.
"started",
"download_started",
"download_completed",
"permissions_prompt",
"cancelled",
// Second update is expected to be completed.
"started",
"download_started",
"download_completed",
"permissions_prompt",
"completed",
];
Assert.deepEqual(
expectedSteps,
collectedUpdateEvents.map(evt => evt.extra.step),
"Got the expected sequence on update telemetry events"
);
let gleanEvents = AddonTestUtils.getAMGleanEvents("update");
Services.fog.testResetFOG();
Assert.deepEqual(
expectedSteps,
gleanEvents.map(e => e.step),
"Got the expected sequence on update Glean events."
);
ok(
collectedUpdateEvents.every(evt => evt.extra.addon_id === ID),
"Every update telemetry event should have the expected addon_id extra var"
);
ok(
collectedUpdateEvents.every(
evt => evt.extra.source === FAKE_INSTALL_SOURCE
),
"Every update telemetry event should have the expected source extra var"
);
ok(
collectedUpdateEvents.every(evt => evt.extra.updated_from === "user"),
"Every update telemetry event should have the update_from extra var 'user'"
);
for (let e of gleanEvents) {
is(e.addon_id, ID, "Glean event has the expected addon_id.");
is(e.source, FAKE_INSTALL_SOURCE, "Glean event has the expected source.");
is(e.updated_from, "user", "Glean event has the expected updated_from.");
if (e.step === "permissions_prompt") {
Assert.greater(parseInt(e.num_strings), 0, "Expected num_strings.");
}
if (e.step === "download_completed") {
Assert.greater(parseInt(e.download_time), 0, "Valid download_time.");
}
}
let hasPermissionsExtras = collectedUpdateEvents
.filter(evt => {
return evt.extra.step === "permissions_prompt";
})
.every(evt => {
return Number.isInteger(parseInt(evt.extra.num_strings, 10));
});
ok(
hasPermissionsExtras,
"Every 'permissions_prompt' update telemetry event should have the permissions extra vars"
);
let hasDownloadTimeExtras = collectedUpdateEvents
.filter(evt => {
return evt.extra.step === "download_completed";
})
.every(evt => {
const download_time = parseInt(evt.extra.download_time, 10);
return !isNaN(download_time) && download_time > 0;
});
ok(
hasDownloadTimeExtras,
"Every 'download_completed' update telemetry event should have a download_time extra vars"
);
}
// The tests in this directory install a bunch of extensions but they
// need to uninstall them before exiting, as a stray leftover extension
// after one test can foul up subsequent tests.
// So, add a task to run before any tests that grabs a list of all the
// add-ons that are pre-installed in the test environment and then checks
// the list of installed add-ons at the end of the test to make sure no
// new add-ons have been added.
// Individual tests can store a cleanup function in the testCleanup global
// to ensure it gets called before the final check is performed.
let testCleanup;
add_setup(async function head_setup() {
let addons = await AddonManager.getAllAddons();
let existingAddons = new Set(addons.map(a => a.id));
registerCleanupFunction(async function () {
if (testCleanup) {
await testCleanup();
testCleanup = null;
}
for (let addon of await AddonManager.getAllAddons()) {
// Builtin search extensions may have been installed by SearchService
// during the test run, ignore those.
if (
!existingAddons.has(addon.id) &&
!(addon.isBuiltin && addon.id.endsWith("@search.mozilla.org"))
) {
ok(
false,
`Addon ${addon.id} was left installed at the end of the test`
);
await addon.uninstall();
}
}
});
});