firefox-main/toolkit/components/extensions/test/xpcshell/test_ext_builtin_widget.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

/* Any copyright is dedicated to the Public Domain.
"use strict";
const { AddonSettings } = ChromeUtils.importESModule(
"resource://gre/modules/addons/AddonSettings.sys.mjs"
);
const { sinon } = ChromeUtils.importESModule(
);
const { WidgetManager } = ChromeUtils.importESModule(
"moz-src:///toolkit/components/widgets/WidgetManager.sys.mjs"
);
const EXTENSION_ID = "widget@mochi.test";
const WIDGET = {
page: "widget.html",
sizes: ["small", "medium"],
default_size: "medium",
pref_branch: "test.widget",
};
function loadWidgetExtension({
id = EXTENSION_ID,
isPrivileged = true,
temporarilyInstalled = false,
widget = WIDGET,
} = {}) {
return ExtensionTestUtils.loadExtension({
isPrivileged,
temporarilyInstalled,
manifest: {
name: "Widget Extension",
browser_specific_settings: { gecko: { id } },
builtin_widget: widget,
},
files: { "widget.html": "" },
});
}
add_task(async function test_extension_registers_widget() {
const extension = loadWidgetExtension();
await extension.startup();
const widget = WidgetManager.getWidgetByID(EXTENSION_ID);
Assert.equal(widget.id, EXTENSION_ID, "Id");
Assert.equal(
widget.src,
extension.extension.baseURI.resolve("widget.html"),
"Src"
);
Assert.equal(widget.name, "Widget Extension", "Name");
Assert.deepEqual(widget.sizes, ["small", "medium"], "Sizes");
Assert.equal(widget.size, "medium", "Default size");
widget.enabled = true;
widget.size = "small";
Assert.ok(Services.prefs.getBoolPref("test.widget.enabled"), "Enabled pref");
Assert.equal(
Services.prefs.getStringPref("test.widget.size"),
"small",
"Size pref"
);
Services.prefs.deleteBranch("test.widget.");
await extension.unload();
Assert.equal(WidgetManager.getWidgetByID(EXTENSION_ID), null, "Unregistered");
});
add_task(async function test_unprivileged_extension_is_ignored() {
ExtensionTestUtils.failOnSchemaWarnings(false);
const extension = loadWidgetExtension({ isPrivileged: false });
const { messages } = await promiseConsoleOutput(() => extension.startup());
ExtensionTestUtils.failOnSchemaWarnings(true);
Assert.equal(extension.extension.manifest.builtin_widget, null, "Key nulled");
Assert.equal(WidgetManager.getWidgetByID(EXTENSION_ID), null, "No widget");
Assert.ok(
messages.some(({ message }) => /Ignoring 'builtin_widget'/.test(message)),
"Warning logged"
);
await extension.unload();
});
add_task(
{ pref_set: [["extensions.experiments.enabled", false]] },
async function test_temporary_install_is_rejected() {
ExtensionTestUtils.failOnSchemaWarnings(false);
const extension = loadWidgetExtension({
id: "rejected-widget@mochi.test",
isPrivileged: false,
temporarilyInstalled: true,
});
await Assert.rejects(
extension.startup(),
/Using 'builtin_widget' requires a privileged add-on/,
"Startup rejected"
);
ExtensionTestUtils.failOnSchemaWarnings(true);
}
);
add_task(
{ pref_set: [["extensions.experiments.enabled", true]] },
async function test_temporary_install_with_experiments() {
if (!AddonSettings.EXPERIMENTS_ENABLED) {
info("Experiments cannot be enabled on this build");
return;
}
const extension = loadWidgetExtension({
isPrivileged: false,
temporarilyInstalled: true,
});
await extension.startup();
Assert.ok(WidgetManager.getWidgetByID(EXTENSION_ID), "Registered");
await extension.unload();
}
);
add_task(async function test_invalid_pref_branch() {
ExtensionTestUtils.failOnSchemaWarnings(false);
for (const pref_branch of ["", ".test", "test.", "test..widget"]) {
const extension = loadWidgetExtension({
id: `invalid-${pref_branch}@mochi.test`,
widget: { ...WIDGET, pref_branch },
});
await Assert.rejects(
extension.startup(),
/builtin_widget\.pref_branch/,
`"${pref_branch}"`
);
}
ExtensionTestUtils.failOnSchemaWarnings(true);
});
add_task(async function test_failed_startup_registers_nothing() {
const failed = loadWidgetExtension();
const stub = sinon
.stub(failed.extension, "runManifest")
.callsFake(async function (manifest) {
await stub.wrappedMethod.call(this, manifest);
throw new Error("Startup failed");
});
await Assert.rejects(failed.startup(), /Startup failed/, "Startup rejected");
Assert.ok(stub.calledOnce, "runManifest called");
Assert.equal(WidgetManager.getWidgetByID(EXTENSION_ID), null, "No widget");
stub.restore();
const extension = loadWidgetExtension();
await extension.startup();
Assert.ok(WidgetManager.getWidgetByID(EXTENSION_ID), "Registered on retry");
await extension.unload();
});
add_task(async function test_shutdown_before_ready() {
const extension = loadWidgetExtension();
const { runManifest } = extension.extension;
extension.extension.runManifest = async function (manifest) {
await runManifest.call(this, manifest);
await this.shutdown();
Assert.ok(!this.emitter.has("ready"), "No ready listener");
};
await extension.startup();
Assert.equal(WidgetManager.getWidgetByID(EXTENSION_ID), null, "No widget");
await extension.unload();
});