mozilla-central/browser/components/extensions/test/xpcshell/test_ext_normandyAddonStudy.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: Warnings

"use strict";
ChromeUtils.defineESModuleGetters(this, {
AddonManager: "resource://gre/modules/AddonManager.sys.mjs",
});
const { AddonStudies } = ChromeUtils.importESModule(
"resource://normandy/lib/AddonStudies.sys.mjs"
);
const { NormandyTestUtils } = ChromeUtils.importESModule(
);
const { TestUtils } = ChromeUtils.importESModule(
);
var { AddonTestUtils } = ChromeUtils.importESModule(
);
const { addonStudyFactory } = NormandyTestUtils.factories;
AddonTestUtils.init(this);
// All tests run privileged unless otherwise specified not to.
function createExtension(backgroundScript, permissions, isPrivileged = true) {
let extensionData = {
background: backgroundScript,
manifest: {
browser_specific_settings: {
gecko: {
id: "test@shield.mozilla.com",
},
},
permissions,
},
isPrivileged,
};
return ExtensionTestUtils.loadExtension(extensionData);
}
async function run(test) {
let extension = createExtension(
test.backgroundScript,
test.permissions || ["normandyAddonStudy"],
test.isPrivileged
);
const promiseValidation = test.validationScript
? test.validationScript(extension)
: Promise.resolve();
await extension.startup();
await promiseValidation;
if (test.doneSignal) {
await extension.awaitFinish(test.doneSignal);
}
await extension.unload();
}
add_task(async function setup() {
await ExtensionTestUtils.startAddonManager();
});
add_task(
async function test_normandyAddonStudy_without_normandyAddonStudy_permission_privileged() {
await run({
backgroundScript: () => {
browser.test.assertTrue(
!browser.normandyAddonStudy,
"'normandyAddonStudy' permission is required"
);
browser.test.notifyPass("normandyAddonStudy_permission");
},
permissions: [],
doneSignal: "normandyAddonStudy_permission",
});
}
);
add_task(async function test_normandyAddonStudy_without_privilege() {
await run({
backgroundScript: () => {
browser.test.assertTrue(
!browser.normandyAddonStudy,
"Extension must be privileged"
);
browser.test.notifyPass("normandyAddonStudy_permission");
},
isPrivileged: false,
doneSignal: "normandyAddonStudy_permission",
});
});
add_task(async function test_normandyAddonStudy_temporary_without_privilege() {
let extension = ExtensionTestUtils.loadExtension({
temporarilyInstalled: true,
isPrivileged: false,
manifest: {
permissions: ["normandyAddonStudy"],
},
});
ExtensionTestUtils.failOnSchemaWarnings(false);
let { messages } = await promiseConsoleOutput(async () => {
await Assert.rejects(
extension.startup(),
/Using the privileged permission/,
"Startup failed with privileged permission"
);
});
ExtensionTestUtils.failOnSchemaWarnings(true);
AddonTestUtils.checkMessages(
messages,
{
expected: [
{
message:
/Using the privileged permission 'normandyAddonStudy' requires a privileged add-on/,
},
],
},
true
);
});
add_task(async function test_getStudy_works() {
const study = addonStudyFactory({
addonId: "test@shield.mozilla.com",
});
const testWrapper = AddonStudies.withStudies([study]);
const test = testWrapper(async () => {
await run({
backgroundScript: async () => {
const result = await browser.normandyAddonStudy.getStudy();
browser.test.sendMessage("study", result);
},
validationScript: async extension => {
let studyResult = await extension.awaitMessage("study");
deepEqual(
studyResult,
study,
"normandyAddonStudy.getStudy returns the correct study"
);
},
});
});
await test();
});
add_task(async function test_endStudy_works() {
const study = addonStudyFactory({
addonId: "test@shield.mozilla.com",
});
const testWrapper = AddonStudies.withStudies([study]);
const test = testWrapper(async () => {
await run({
backgroundScript: async () => {
await browser.normandyAddonStudy.endStudy("test");
},
validationScript: async () => {
// Check that `AddonStudies.markAsEnded` was called
await TestUtils.topicObserved(
"shield-study-ended",
(subject, message) => {
return message === `${study.recipeId}`;
}
);
const addon = await AddonManager.getAddonByID(study.addonId);
equal(addon, undefined, "Addon should be uninstalled.");
},
});
});
await test();
});
add_task(async function test_getClientMetadata_works() {
const study = addonStudyFactory({
addonId: "test@shield.mozilla.com",
slug: "test-slug",
branch: "test-branch",
});
const testWrapper = AddonStudies.withStudies([study]);
const test = testWrapper(async () => {
await run({
backgroundScript: async () => {
const metadata = await browser.normandyAddonStudy.getClientMetadata();
browser.test.sendMessage("clientMetadata", metadata);
},
validationScript: async extension => {
let clientMetadata = await extension.awaitMessage("clientMetadata");
Assert.strictEqual(
clientMetadata.updateChannel,
Services.appinfo.defaultUpdateChannel,
"clientMetadata contains correct updateChannel"
);
Assert.strictEqual(
clientMetadata.fxVersion,
Services.appinfo.version,
"clientMetadata contains correct fxVersion"
);
ok("clientID" in clientMetadata, "clientMetadata contains a clientID");
},
});
});
await test();
});
add_task(async function test_onUnenroll_works() {
const study = addonStudyFactory({
addonId: "test@shield.mozilla.com",
});
const testWrapper = AddonStudies.withStudies([study]);
const test = testWrapper(async () => {
await run({
backgroundScript: () => {
browser.normandyAddonStudy.onUnenroll.addListener(reason => {
browser.test.sendMessage("unenrollReason", reason);
});
browser.test.sendMessage("bgpageReady");
},
validationScript: async extension => {
await extension.awaitMessage("bgpageReady");
await AddonStudies.markAsEnded(study, "test");
const unenrollReason = await extension.awaitMessage("unenrollReason");
equal(unenrollReason, "test", "Unenroll listener should be called.");
},
});
});
await test();
});