Source code
Revision control
Copy as Markdown
Other Tools
Test Info: Warnings
- This test gets skipped with pattern: os == 'android'
- Manifest: browser/components/extensions/test/xpcshell/xpcshell.toml
"use strict";
ChromeUtils.defineESModuleGetters(this, {
ExtensionMenus: "resource://gre/modules/ExtensionMenus.sys.mjs",
KeyValueService: "resource://gre/modules/kvstore.sys.mjs",
Management: "resource://gre/modules/Extension.sys.mjs",
});
const { AddonTestUtils } = ChromeUtils.importESModule(
);
AddonTestUtils.init(this);
AddonTestUtils.overrideCertDB();
AddonTestUtils.createAppInfo(
"xpcshell@tests.mozilla.org",
"XPCShell",
"42",
"42"
);
Services.prefs.setBoolPref("extensions.eventPages.enabled", true);
function getExtension(id, background, useAddonManager, version = "1.0") {
return {
useAddonManager,
manifest: {
version,
browser_specific_settings: { gecko: { id } },
permissions: ["menus"],
background: { persistent: false },
},
background,
};
}
async function expectPersistedMenus(extensionId, extensionVersion, expect) {
let menusFromStore = await ExtensionMenus._getStoredMenusForTesting(
extensionId,
extensionVersion
);
equal(menusFromStore.size, expect.length, "stored menus size");
let createProperties = Array.from(menusFromStore.values());
// The menus are loaded from disk for extensions using a non-persistent
// background page and kept in memory in a map, the order is significant
// for recreating menus on startup. Ensure that they are in
// the expected order.
for (let i in createProperties) {
Assert.deepEqual(
createProperties[i],
expect[i],
"expected properties exist in the menus store"
);
}
}
async function expectExtensionMenus(
testExtension,
expect,
{ checkSaved } = {}
) {
const extension = WebExtensionPolicy.getByID(testExtension.id).extension;
let menusInMemory = ExtensionMenus.getMenus(extension);
let createProperties = Array.from(menusInMemory.values());
equal(menusInMemory.size, expect.length, "menus map size");
for (let i in createProperties) {
Assert.deepEqual(
createProperties[i],
expect[i],
"expected properties exist in the menus map"
);
}
if (!checkSaved) {
return;
}
await expectPersistedMenus(testExtension.id, testExtension.version, expect);
}
function promiseExtensionEvent(wrapper, event) {
return new Promise(resolve => {
wrapper.extension.once(event, (kind, data) => {
resolve(data);
});
});
}
async function mockBrowserRestart(
extTestWrapper,
{ shutdownAndRecreateStore = true, waitForMenuRecreated = true } = {}
) {
if (shutdownAndRecreateStore) {
info("Mock browser shutdown");
let menusManager = ExtensionMenus._getManager(extTestWrapper.extension);
await AddonTestUtils.promiseShutdownManager();
// Wait data to be flushed as part of the extension shutdown and recreate the store.
info("Wait for store to be flushed");
await menusManager._finalizeStoreTaskForTesting();
info("Recreate menus store");
ExtensionMenus._recreateStoreForTesting();
}
let promiseMenusRecreated;
if (waitForMenuRecreated) {
Management.once("startup", (kind, ext) => {
info(`management ${kind} ${ext.id}`);
promiseMenusRecreated = promiseExtensionEvent(
{ extension: ext },
"webext-menus-created"
);
});
}
info("Mock browser startup");
await AddonTestUtils.promiseStartupManager();
await extTestWrapper.awaitStartup();
if (waitForMenuRecreated) {
info("Wait for persisted menus to be recreated");
}
await promiseMenusRecreated;
}
function extPageScriptWithMenusCreateAndUpdateTestHandler() {
browser.test.onMessage.addListener((msg, ...args) => {
switch (msg) {
case "menusCreate": {
const menuDetails = args[0];
browser.menus.create(menuDetails, () => {
browser.test.assertEq(
undefined,
browser.runtime.lastError?.message,
"Expect the menu to be created successfully"
);
browser.test.sendMessage(`${msg}:done`);
});
break;
}
case "menusUpdate": {
const menuId = args[0];
const menuDetails = args[1];
browser.test.log(`Updating "${menuId}: ${JSON.stringify(menuDetails)}`);
browser.menus.update(menuId, menuDetails, () => {
browser.test.assertEq(
undefined,
browser.runtime.lastError?.message,
"Expect the menu to be created successfully"
);
browser.test.sendMessage(`${msg}:done`);
});
break;
}
default:
browser.test.fail(`Got unexpected test message: ${msg}`);
browser.test.sendMessage(`${msg}:done`);
}
});
browser.test.sendMessage("extpage:ready");
}
add_setup(async () => {
// Reduce the amount of time we wait to write menus
// data on disk while running this test.
Services.prefs.setIntPref(
"extensions.webextensions.menus.writeDebounceTime",
200
);
await AddonTestUtils.promiseStartupManager();
});
add_task(async function test_menu_onInstalled() {
async function background() {
browser.runtime.onInstalled.addListener(async () => {
const parentId = browser.menus.create({
contexts: ["all"],
title: "parent",
id: "test-parent",
});
browser.menus.create({
parentId,
title: "click A",
id: "test-click-a",
});
browser.menus.create(
{
parentId,
title: "click B",
id: "test-click-b",
},
() => {
browser.test.sendMessage("onInstalled");
}
);
});
browser.menus.create(
{
contexts: ["tab"],
title: "top-level",
id: "test-top-level",
},
() => {
browser.test.sendMessage("create", browser.runtime.lastError?.message);
}
);
browser.test.onMessage.addListener(async msg => {
browser.test.log(`onMessage ${msg}`);
if (msg == "updatemenu") {
await browser.menus.update("test-click-a", { title: "click updated" });
} else if (msg == "removemenu") {
await browser.menus.remove("test-click-b");
} else if (msg == "removeall") {
await browser.menus.removeAll();
}
browser.test.sendMessage("updated");
});
}
const extension = ExtensionTestUtils.loadExtension(
getExtension("test-persist@mochitest", background, "permanent")
);
await extension.startup();
let lastError = await extension.awaitMessage("create");
Assert.equal(lastError, undefined, "no error creating menu");
await extension.awaitMessage("onInstalled");
await extension.terminateBackground();
await expectExtensionMenus(extension, [
{
contexts: ["tab"],
id: "test-top-level",
title: "top-level",
},
{ contexts: ["all"], id: "test-parent", title: "parent" },
{
id: "test-click-a",
parentId: "test-parent",
title: "click A",
},
{
id: "test-click-b",
parentId: "test-parent",
title: "click B",
},
]);
await extension.wakeupBackground();
lastError = await extension.awaitMessage("create");
Assert.equal(
lastError,
"The menu id test-top-level already exists in menus.create.",
"correct error creating menu"
);
await mockBrowserRestart(extension);
// After the extension or the AddonManager has been shutdown,
// we expect the menu store task to have written the menus
// on disk and so we expect these menus to be loaded back
// in memory and also stored on disk.
await expectExtensionMenus(
extension,
[
{
contexts: ["tab"],
id: "test-top-level",
title: "top-level",
},
{ contexts: ["all"], id: "test-parent", title: "parent" },
{
id: "test-click-a",
parentId: "test-parent",
title: "click A",
},
{
id: "test-click-b",
parentId: "test-parent",
title: "click B",
},
],
{ checkSaved: true }
);
equal(
extension.extension.backgroundState,
"stopped",
"background is not running"
);
await extension.wakeupBackground();
lastError = await extension.awaitMessage("create");
Assert.equal(
lastError,
"The menu id test-top-level already exists in menus.create.",
"correct error creating menu"
);
let promisePersistedMenusUpdated = TestUtils.topicObserved(
"webext-persisted-menus-updated"
);
extension.sendMessage("updatemenu");
await extension.awaitMessage("updated");
await extension.terminateBackground();
// Title change is persisted.
// (awaiting on the promise resolved when the ExtensionMenus
// DeferredTask are been executed and the data expected to be
// written on disk, to confirm the menu data is being persisted
// on disk also while the extension and the app are still
// running).
await promisePersistedMenusUpdated;
await expectExtensionMenus(
extension,
[
{
contexts: ["tab"],
id: "test-top-level",
title: "top-level",
},
{ contexts: ["all"], id: "test-parent", title: "parent" },
{
id: "test-click-a",
parentId: "test-parent",
title: "click updated",
},
{
id: "test-click-b",
parentId: "test-parent",
title: "click B",
},
],
{ checkSaved: true }
);
await extension.wakeupBackground();
lastError = await extension.awaitMessage("create");
Assert.equal(
lastError,
"The menu id test-top-level already exists in menus.create.",
"correct error creating menu"
);
extension.sendMessage("removemenu");
await extension.awaitMessage("updated");
await extension.terminateBackground();
// menu removed
await expectExtensionMenus(extension, [
{
contexts: ["tab"],
id: "test-top-level",
title: "top-level",
},
{ contexts: ["all"], id: "test-parent", title: "parent" },
{
id: "test-click-a",
parentId: "test-parent",
title: "click updated",
},
]);
await extension.wakeupBackground();
lastError = await extension.awaitMessage("create");
Assert.equal(
lastError,
"The menu id test-top-level already exists in menus.create.",
"correct error creating menu"
);
promisePersistedMenusUpdated = TestUtils.topicObserved(
"webext-persisted-menus-updated"
);
extension.sendMessage("removeall");
await extension.awaitMessage("updated");
await extension.terminateBackground();
// menus removed
// We expect the persisted menus store to still have an
// entry for the extension even when all menus have been
// removed.
await promisePersistedMenusUpdated;
equal(
await ExtensionMenus._hasStoredExtensionData(extension.id),
true,
"persisted menus store have an entry for the test extension"
);
await expectExtensionMenus(extension, [], { checkSaved: true });
promisePersistedMenusUpdated = TestUtils.topicObserved(
"webext-persisted-menus-updated"
);
await extension.unload();
await promisePersistedMenusUpdated;
// Expect the entry to have been removed completely from
// the persised menus store the test extension is uninstalled.
equal(
await ExtensionMenus._hasStoredExtensionData(extension.id),
false,
"uninstalled extension should NOT have an entry in the persisted menus store"
);
});
add_task(async function test_menu_persisted_cleared_after_ext_update() {
async function background() {
browser.test.onMessage.addListener(async (action, properties) => {
browser.test.log(`onMessage ${action}`);
switch (action) {
case "create":
await new Promise(resolve => {
browser.menus.create(properties, resolve);
});
break;
default:
browser.test.fail(`Got unexpected test message "${action}"`);
break;
}
browser.test.sendMessage("updated");
});
}
const extension = ExtensionTestUtils.loadExtension(
getExtension("test-nesting@mochitest", background, "permanent", "1.0")
);
await extension.startup();
extension.sendMessage("create", {
id: "stored-menu",
contexts: ["all"],
title: "some-menu",
});
await extension.awaitMessage("updated");
const expectedMenus = [
{ contexts: ["all"], id: "stored-menu", title: "some-menu" },
];
await expectExtensionMenus(extension, expectedMenus);
info(
"Re-install the same add-on version and expect persisted menus to still exist"
);
await extension.upgrade(
getExtension("test-nesting@mochitest", background, "permanent", "1.0")
);
await expectExtensionMenus(extension, expectedMenus);
info(
"Upgrade to a new add-on version and expect persisted menus to be cleared"
);
await extension.upgrade(
getExtension("test-nesting@mochitest", background, "permanent", "2.0")
);
await expectExtensionMenus(extension, []);
await extension.unload();
});
add_task(async function test_menu_nested() {
async function background() {
browser.test.onMessage.addListener(async (action, properties) => {
browser.test.log(`onMessage ${action}`);
switch (action) {
case "create":
await new Promise(resolve => {
browser.menus.create(properties, resolve);
});
break;
case "update":
{
let { id, ...update } = properties;
await browser.menus.update(id, update);
}
break;
case "remove":
{
let { id } = properties;
await browser.menus.remove(id);
}
break;
case "removeAll":
await browser.menus.removeAll();
break;
}
browser.test.sendMessage("updated");
});
}
const extension = ExtensionTestUtils.loadExtension(
getExtension("test-nesting@mochitest", background, "permanent")
);
await extension.startup();
extension.sendMessage("create", {
id: "first",
contexts: ["all"],
title: "first",
});
await extension.awaitMessage("updated");
await expectExtensionMenus(extension, [
{ contexts: ["all"], id: "first", title: "first" },
]);
extension.sendMessage("create", {
id: "second",
contexts: ["all"],
title: "second",
});
await extension.awaitMessage("updated");
await expectExtensionMenus(extension, [
{ contexts: ["all"], id: "first", title: "first" },
{ contexts: ["all"], id: "second", title: "second" },
]);
extension.sendMessage("create", {
id: "third",
contexts: ["all"],
title: "third",
parentId: "first",
});
await extension.awaitMessage("updated");
await expectExtensionMenus(extension, [
{ contexts: ["all"], id: "first", title: "first" },
{ contexts: ["all"], id: "second", title: "second" },
{
contexts: ["all"],
id: "third",
parentId: "first",
title: "third",
},
]);
extension.sendMessage("create", {
id: "fourth",
contexts: ["all"],
title: "fourth",
});
await extension.awaitMessage("updated");
await expectExtensionMenus(extension, [
{ contexts: ["all"], id: "first", title: "first" },
{ contexts: ["all"], id: "second", title: "second" },
{
contexts: ["all"],
id: "third",
parentId: "first",
title: "third",
},
{ contexts: ["all"], id: "fourth", title: "fourth" },
]);
extension.sendMessage("update", {
id: "first",
parentId: "second",
});
await extension.awaitMessage("updated");
await expectExtensionMenus(extension, [
{ contexts: ["all"], id: "second", title: "second" },
{ contexts: ["all"], id: "fourth", title: "fourth" },
{
contexts: ["all"],
id: "first",
title: "first",
parentId: "second",
},
{
contexts: ["all"],
id: "third",
parentId: "first",
title: "third",
},
]);
await AddonTestUtils.promiseShutdownManager();
// We need to attach an event listener before the
// startup event is emitted. Fortunately, we
// emit via Management before emitting on extension.
let promiseMenus;
Management.once("startup", (kind, ext) => {
info(`management ${kind} ${ext.id}`);
promiseMenus = promiseExtensionEvent(
{ extension: ext },
"webext-menus-created"
);
});
await AddonTestUtils.promiseStartupManager();
await extension.awaitStartup();
await extension.wakeupBackground();
await expectExtensionMenus(
extension,
[
{ contexts: ["all"], id: "second", title: "second" },
{ contexts: ["all"], id: "fourth", title: "fourth" },
{
contexts: ["all"],
id: "first",
title: "first",
parentId: "second",
},
{
contexts: ["all"],
id: "third",
parentId: "first",
title: "third",
},
],
{ checkSaved: true }
);
// validate nesting
let menus = await promiseMenus;
equal(menus.get("first").parentId, "second", "menuitem parent is correct");
equal(
menus.get("second").children.length,
1,
"menuitem parent has correct number of children"
);
equal(
menus.get("second").root.children.length,
2, // second and forth
"menuitem root has correct number of children"
);
extension.sendMessage("remove", {
id: "second",
});
await extension.awaitMessage("updated");
await expectExtensionMenus(extension, [
{ contexts: ["all"], id: "fourth", title: "fourth" },
]);
extension.sendMessage("removeAll");
await extension.awaitMessage("updated");
await expectExtensionMenus(extension, []);
await extension.unload();
});
add_task(async function test_ExtensionMenus_after_extension_hasShutdown() {
const assertEmptyMenusManagersMap = () => {
let weakMapKeys = ChromeUtils.nondeterministicGetWeakMapKeys(
ExtensionMenus._menusManagers
);
Assert.deepEqual(
weakMapKeys.length,
0,
"Expect ExtensionMenus._menusManagers weakmap to be empty"
);
};
// Sanity check.
assertEmptyMenusManagersMap();
const addonId = "test-menu-after-shutdown@mochitest";
const testExtWrapper = ExtensionTestUtils.loadExtension(
getExtension(addonId, () => {}, "permanent")
);
await testExtWrapper.startup();
const { extension } = testExtWrapper;
Assert.equal(
extension.hasShutdown,
false,
"Extension hasShutdown should be false"
);
await testExtWrapper.unload();
Assert.equal(
extension.hasShutdown,
true,
"Extension hasShutdown should be true"
);
// Sanity check.
assertEmptyMenusManagersMap();
await Assert.rejects(
ExtensionMenus.asyncInitForExtension(extension),
new RegExp(
`Error on creating new ExtensionMenusManager after extension shutdown: ${addonId}`
),
"Got the expected error on ExtensionMenus.asyncInitForExtension called for a shutdown extension"
);
assertEmptyMenusManagersMap();
Assert.throws(
() => ExtensionMenus.getMenus(extension),
new RegExp(`No ExtensionMenusManager instance found for ${addonId}`),
"Got the expected error on ExtensionMenus.getMenus called for a shutdown extension"
);
assertEmptyMenusManagersMap();
});
// This test ensures that menus created by an extension without a background page
// are not persisted.
add_task(async function test_extension_without_background() {
let extension = ExtensionTestUtils.loadExtension({
useAddonManager: "permanent",
manifest: {
permissions: ["menus"],
},
files: {
"extpage.html": `<!DOCTYPE html><script src="extpage.js"></script>`,
"extpage.js": extPageScriptWithMenusCreateAndUpdateTestHandler,
},
});
async function testCreateMenu() {
const extPageUrl = extension.extension.baseURI.resolve("extpage.html");
let page = await ExtensionTestUtils.loadContentPage(extPageUrl);
await extension.awaitMessage("extpage:ready");
const menuDetails = { id: "test-menu", title: "menu title" };
extension.sendMessage("menusCreate", menuDetails);
await extension.awaitMessage("menusCreate:done");
await page.close();
}
await extension.startup();
await testCreateMenu();
info(
"Simulated browser restart and verify no menu was persisted or restored"
);
await mockBrowserRestart(extension, { waitForMenuRecreated: false });
// Try to create the same menu again, if it does fail the menu was unexpectectly
// restored.
await testCreateMenu();
equal(
await ExtensionMenus._hasStoredExtensionData(extension.id),
false,
"Extensions without a background page should not have any data stored for their menus"
);
await extension.unload();
});
// Verify that corrupted menus store data is handled gracefully.
add_task(async function test_corrupted_menus_store_data() {
let extension = ExtensionTestUtils.loadExtension({
useAddonManager: "permanent",
manifest: {
permissions: ["menus"],
background: { persistent: false },
},
background: extPageScriptWithMenusCreateAndUpdateTestHandler,
});
await extension.startup();
await extension.awaitMessage("extpage:ready");
const menuDetails = { id: "test-menu", title: "menu title" };
const menuDetailsUnsupported = {
new_unsupported_property: "fake-prop-value",
};
const menuDetailsUpdate = { title: "Updated menu title" };
extension.sendMessage("menusCreate", menuDetails);
await extension.awaitMessage("menusCreate:done");
let menus = ExtensionMenus.getMenus(extension.extension);
Assert.deepEqual(
menus.get("test-menu"),
menuDetails,
"Got the expected menuDetails from ExtensionMenus.getMenus"
);
// Inject invalid menu properties into the store to simulate
// restoring menus from menus data stored by a future version
// with additional menus properties older versions would not
// have support for.
//
// This test covers additive changes, but technically changes
// to the format of existing properties may not be handled
// gracefully (but changes to the type/format of existing menu
// properties are more likely to be part of a manifest version
// update, and so they may be less likely, and downgrades not
// officially supported).
info("Inject unsupported properties in the persisted menu details");
let store = ExtensionMenus._getStoreForTesting();
menus.set("test-menu", { ...menuDetails, ...menuDetailsUnsupported });
await store.updatePersistedMenus(extension.id, extension.version, menus);
equal(
await ExtensionMenus._hasStoredExtensionData(extension.id),
true,
"persisted menus store have an entry for the test extension"
);
// Mock a browser restart and verify the unsupported property injected
// in the persisted menu data is handled gracefully.
await mockBrowserRestart(extension);
await extension.awaitMessage("extpage:ready");
menus = ExtensionMenus.getMenus(extension.extension);
info("Verify the recreated menu can still be updated as expected");
extension.sendMessage("menusUpdate", menuDetails.id, menuDetailsUpdate);
await extension.awaitMessage("menusUpdate:done");
menus = ExtensionMenus.getMenus(extension.extension);
Assert.deepEqual(
menus.get("test-menu"),
Object.assign({}, menuDetails, menuDetailsUnsupported, menuDetailsUpdate),
"Got the expected menuDetails from ExtensionMenus.getMenus"
);
info("Inject orphan menu entry in the persisted menus data");
store = ExtensionMenus._getStoreForTesting();
const orphanedMenuDetails = {
id: "orphaned-test-menu",
parentId: "non-existing-parent-id",
title: "An orphaned menu item",
};
menus.set(orphanedMenuDetails.id, orphanedMenuDetails);
await store.updatePersistedMenus(extension.id, extension.version, menus);
// Mock a browser restart and verify that orphaned menus
// from the persisted menu data are handled gracefully.
{
const { messages } = await AddonTestUtils.promiseConsoleOutput(async () => {
await mockBrowserRestart(extension);
await extension.awaitMessage("extpage:ready");
});
// Make sure the test is hitting the expected error.
AddonTestUtils.checkMessages(messages, {
expected: [
{
message: new RegExp(
`Unexpected error on recreating persisted menu ${orphanedMenuDetails.id} for ${extension.id}`
),
},
],
});
}
menus = ExtensionMenus.getMenus(extension.extension);
info("Verify the recreated menu can still be updated as expected");
extension.sendMessage("menusUpdate", menuDetails.id, menuDetailsUpdate);
await extension.awaitMessage("menusUpdate:done");
menus = ExtensionMenus.getMenus(extension.extension);
Assert.deepEqual(
menus.get("test-menu"),
Object.assign({}, menuDetails, menuDetailsUnsupported, menuDetailsUpdate),
"Got the expected menuDetails from ExtensionMenus.getMenus"
);
info("Verify the orphaned menu has been dropped");
Assert.equal(
menus.has(orphanedMenuDetails.id),
false,
"Expect orphaned menu to not exist anymore"
);
info("Verify invalid stored json menus data is handled gracefully");
await AddonTestUtils.promiseShutdownManager();
ExtensionMenus._recreateStoreForTesting();
let menuStorePath = PathUtils.join(
PathUtils.profileDir,
ExtensionMenus.KVSTORE_DIRNAME
);
const kvstore = await KeyValueService.getOrCreateWithOptions(
menuStorePath,
"menus",
{ strategy: KeyValueService.RecoveryStrategy.RENAME }
);
await kvstore.put(extension.id, "invalid-json-data");
{
const { messages } = await AddonTestUtils.promiseConsoleOutput(async () => {
await mockBrowserRestart(extension, { shutdownAndRecreateStore: false });
await extension.awaitMessage("extpage:ready");
});
// Make sure the test is hitting the expected error.
AddonTestUtils.checkMessages(messages, {
expected: [
{
message: new RegExp(
`Error loading ${extension.id} persisted menus: SyntaxError`
),
},
],
});
}
menus = ExtensionMenus.getMenus(extension.extension);
Assert.equal(menus.size, 0, "Expect persisted menus map to be empty");
// Verify new menu can still be created.
extension.sendMessage("menusCreate", menuDetails);
await extension.awaitMessage("menusCreate:done");
menus = ExtensionMenus.getMenus(extension.extension);
Assert.equal(menus.size, 1, "Expect persisted menus map to not be empty");
await extension.unload();
});
// Verify that ExtensionMenus.clearPersistedMenusOnUninstall isn't going
// to create an unnecessary menus kvstore directory when that directory does
// not exist yet, e.g. because the extension never used the contextMenus API.
// This includes builds that do not support the contextMenus API.
add_task(async function test_unnecessary_kvstore_dir_not_created() {
// Create a new store instance to ensure the lazy store initialization
// isn't already executed due to the previous test tasks.
await AddonTestUtils.promiseRestartManager();
ExtensionMenus._recreateStoreForTesting();
let menuStorePath = PathUtils.join(
PathUtils.profileDir,
ExtensionMenus.KVSTORE_DIRNAME
);
await IOUtils.remove(menuStorePath, { ignoreAbsent: true, recursive: true });
equal(
await IOUtils.exists(menuStorePath),
false,
`Expect no ${ExtensionMenus.KVSTORE_DIRNAME} in the Gecko profile`
);
await ExtensionMenus.clearPersistedMenusOnUninstall("fakeextid@test");
equal(
await IOUtils.exists(menuStorePath),
false,
`Expect no ${ExtensionMenus.KVSTORE_DIRNAME} in the Gecko profile`
);
});