02fbf941fd
We import the ActorConstants into the ASRouter unit-entry.js script because ASRouterChild.sys.mjs loads ActorConstants.sys.mjs, and the ResourceUriPlugin that does the rewriting for the Karma tests doesn't understand how to do remapping outside of the newtab folder. So instead of trying to hack that capability into ResourceUriPlugin, we just import the ActorConstants into the Karma global scope. Differential Revision: https://phabricator.services.mozilla.com/D200087
429 lines
14 KiB
JavaScript
429 lines
14 KiB
JavaScript
import { ASRouterParentProcessMessageHandler } from "modules/ASRouterParentProcessMessageHandler.jsm";
|
|
import { _ASRouter } from "modules/ASRouter.jsm";
|
|
import { MESSAGE_TYPE_HASH as msg } from "modules/ActorConstants.sys.mjs";
|
|
|
|
describe("ASRouterParentProcessMessageHandler", () => {
|
|
let handler = null;
|
|
let sandbox = null;
|
|
let config = null;
|
|
beforeEach(() => {
|
|
sandbox = sinon.createSandbox();
|
|
const returnValue = { value: 1 };
|
|
const router = new _ASRouter();
|
|
[
|
|
"addImpression",
|
|
"evaluateExpression",
|
|
"forceAttribution",
|
|
"forceWNPanel",
|
|
"closeWNPanel",
|
|
"forcePBWindow",
|
|
"resetGroupsState",
|
|
"resetMessageState",
|
|
"resetScreenImpressions",
|
|
"editState",
|
|
].forEach(method => sandbox.stub(router, `${method}`).resolves());
|
|
[
|
|
"blockMessageById",
|
|
"loadMessagesFromAllProviders",
|
|
"sendTriggerMessage",
|
|
"routeCFRMessage",
|
|
"setMessageById",
|
|
"updateTargetingParameters",
|
|
"unblockMessageById",
|
|
"unblockAll",
|
|
].forEach(method =>
|
|
sandbox.stub(router, `${method}`).resolves(returnValue)
|
|
);
|
|
router._storage = {
|
|
set: sandbox.stub().resolves(),
|
|
get: sandbox.stub().resolves(),
|
|
};
|
|
sandbox.stub(router, "setState").callsFake(callback => {
|
|
if (typeof callback === "function") {
|
|
callback({
|
|
messageBlockList: [
|
|
{
|
|
id: 0,
|
|
},
|
|
{
|
|
id: 1,
|
|
},
|
|
{
|
|
id: 2,
|
|
},
|
|
{
|
|
id: 3,
|
|
},
|
|
{
|
|
id: 4,
|
|
},
|
|
],
|
|
});
|
|
}
|
|
return Promise.resolve(returnValue);
|
|
});
|
|
const preferences = {
|
|
enableOrDisableProvider: sandbox.stub(),
|
|
resetProviderPref: sandbox.stub(),
|
|
setUserPreference: sandbox.stub(),
|
|
};
|
|
const specialMessageActions = {
|
|
handleAction: sandbox.stub(),
|
|
};
|
|
const queryCache = {
|
|
expireAll: sandbox.stub(),
|
|
};
|
|
const sendTelemetry = sandbox.stub();
|
|
config = {
|
|
router,
|
|
preferences,
|
|
specialMessageActions,
|
|
queryCache,
|
|
sendTelemetry,
|
|
};
|
|
handler = new ASRouterParentProcessMessageHandler(config);
|
|
});
|
|
afterEach(() => {
|
|
sandbox.restore();
|
|
handler = null;
|
|
config = null;
|
|
});
|
|
describe("constructor", () => {
|
|
it("does not throw", () => {
|
|
assert.isNotNull(handler);
|
|
assert.isNotNull(config);
|
|
});
|
|
});
|
|
describe("handleCFRAction", () => {
|
|
it("non-telemetry type isn't sent to telemetry", () => {
|
|
handler.handleCFRAction({
|
|
type: msg.BLOCK_MESSAGE_BY_ID,
|
|
data: { id: 1 },
|
|
});
|
|
assert.notCalled(config.sendTelemetry);
|
|
assert.calledOnce(config.router.blockMessageById);
|
|
});
|
|
it("passes browser to handleMessage", async () => {
|
|
await handler.handleCFRAction(
|
|
{
|
|
type: msg.USER_ACTION,
|
|
data: { id: 1 },
|
|
},
|
|
{ ownerGlobal: {} }
|
|
);
|
|
assert.notCalled(config.sendTelemetry);
|
|
assert.calledOnce(config.specialMessageActions.handleAction);
|
|
assert.calledWith(
|
|
config.specialMessageActions.handleAction,
|
|
{ id: 1 },
|
|
{ ownerGlobal: {} }
|
|
);
|
|
});
|
|
[
|
|
msg.AS_ROUTER_TELEMETRY_USER_EVENT,
|
|
msg.TOOLBAR_BADGE_TELEMETRY,
|
|
msg.TOOLBAR_PANEL_TELEMETRY,
|
|
msg.MOMENTS_PAGE_TELEMETRY,
|
|
msg.DOORHANGER_TELEMETRY,
|
|
].forEach(type => {
|
|
it(`telemetry type "${type}" is sent to telemetry`, () => {
|
|
handler.handleCFRAction({
|
|
type,
|
|
data: { id: 1 },
|
|
});
|
|
assert.calledOnce(config.sendTelemetry);
|
|
assert.notCalled(config.router.blockMessageById);
|
|
});
|
|
});
|
|
});
|
|
describe("#handleMessage", () => {
|
|
it("#default: should throw for unknown msg types", () => {
|
|
handler.handleMessage("err").then(
|
|
() => assert.fail("It should not succeed"),
|
|
() => assert.ok(true)
|
|
);
|
|
});
|
|
describe("#AS_ROUTER_TELEMETRY_USER_EVENT", () => {
|
|
it("should route AS_ROUTER_TELEMETRY_USER_EVENT to handleTelemetry", async () => {
|
|
const data = { data: "foo" };
|
|
await handler.handleMessage(msg.AS_ROUTER_TELEMETRY_USER_EVENT, data);
|
|
|
|
assert.calledOnce(handler.handleTelemetry);
|
|
assert.calledWithExactly(handler.handleTelemetry, {
|
|
type: msg.AS_ROUTER_TELEMETRY_USER_EVENT,
|
|
data,
|
|
});
|
|
});
|
|
});
|
|
describe("BLOCK_MESSAGE_BY_ID action", () => {
|
|
it("with preventDismiss returns false", async () => {
|
|
const result = await handler.handleMessage(msg.BLOCK_MESSAGE_BY_ID, {
|
|
id: 1,
|
|
preventDismiss: true,
|
|
});
|
|
assert.calledOnce(config.router.blockMessageById);
|
|
assert.isFalse(result);
|
|
});
|
|
it("by default returns true", async () => {
|
|
const result = await handler.handleMessage(msg.BLOCK_MESSAGE_BY_ID, {
|
|
id: 1,
|
|
});
|
|
assert.calledOnce(config.router.blockMessageById);
|
|
assert.isTrue(result);
|
|
});
|
|
});
|
|
describe("USER_ACTION action", () => {
|
|
it("default calls SpecialMessageActions.handleAction", async () => {
|
|
await handler.handleMessage(
|
|
msg.USER_ACTION,
|
|
{
|
|
type: "SOMETHING",
|
|
},
|
|
{ browser: { ownerGlobal: {} } }
|
|
);
|
|
assert.calledOnce(config.specialMessageActions.handleAction);
|
|
assert.calledWith(
|
|
config.specialMessageActions.handleAction,
|
|
{ type: "SOMETHING" },
|
|
{ ownerGlobal: {} }
|
|
);
|
|
});
|
|
});
|
|
describe("IMPRESSION action", () => {
|
|
it("default calls addImpression", () => {
|
|
handler.handleMessage(msg.IMPRESSION, {
|
|
id: 1,
|
|
});
|
|
assert.calledOnce(config.router.addImpression);
|
|
});
|
|
});
|
|
describe("TRIGGER action", () => {
|
|
it("default calls sendTriggerMessage and returns state", async () => {
|
|
const result = await handler.handleMessage(
|
|
msg.TRIGGER,
|
|
{
|
|
trigger: { stuff: {} },
|
|
},
|
|
{ id: 100, browser: { ownerGlobal: {} } }
|
|
);
|
|
assert.calledOnce(config.router.sendTriggerMessage);
|
|
assert.calledWith(config.router.sendTriggerMessage, {
|
|
stuff: {},
|
|
tabId: 100,
|
|
browser: { ownerGlobal: {} },
|
|
});
|
|
assert.deepEqual(result, { value: 1 });
|
|
});
|
|
});
|
|
describe("ADMIN_CONNECT_STATE action", () => {
|
|
it("with endpoint url calls loadMessagesFromAllProviders, and returns state", async () => {
|
|
const result = await handler.handleMessage(msg.ADMIN_CONNECT_STATE, {
|
|
endpoint: {
|
|
url: "test",
|
|
},
|
|
});
|
|
assert.calledOnce(config.router.loadMessagesFromAllProviders);
|
|
assert.deepEqual(result, { value: 1 });
|
|
});
|
|
it("default returns state", async () => {
|
|
const result = await handler.handleMessage(msg.ADMIN_CONNECT_STATE);
|
|
assert.calledOnce(config.router.updateTargetingParameters);
|
|
assert.deepEqual(result, { value: 1 });
|
|
});
|
|
});
|
|
describe("UNBLOCK_MESSAGE_BY_ID action", () => {
|
|
it("default calls unblockMessageById", async () => {
|
|
const result = await handler.handleMessage(msg.UNBLOCK_MESSAGE_BY_ID, {
|
|
id: 1,
|
|
});
|
|
assert.calledOnce(config.router.unblockMessageById);
|
|
assert.deepEqual(result, { value: 1 });
|
|
});
|
|
});
|
|
describe("UNBLOCK_ALL action", () => {
|
|
it("default calls unblockAll", async () => {
|
|
const result = await handler.handleMessage(msg.UNBLOCK_ALL);
|
|
assert.calledOnce(config.router.unblockAll);
|
|
assert.deepEqual(result, { value: 1 });
|
|
});
|
|
});
|
|
describe("BLOCK_BUNDLE action", () => {
|
|
it("default calls unblockMessageById", async () => {
|
|
const result = await handler.handleMessage(msg.BLOCK_BUNDLE, {
|
|
bundle: [
|
|
{
|
|
id: 8,
|
|
},
|
|
{
|
|
id: 13,
|
|
},
|
|
],
|
|
});
|
|
assert.calledOnce(config.router.blockMessageById);
|
|
assert.deepEqual(result, { value: 1 });
|
|
});
|
|
});
|
|
describe("UNBLOCK_BUNDLE action", () => {
|
|
it("default calls setState", async () => {
|
|
const result = await handler.handleMessage(msg.UNBLOCK_BUNDLE, {
|
|
bundle: [
|
|
{
|
|
id: 1,
|
|
},
|
|
{
|
|
id: 3,
|
|
},
|
|
],
|
|
});
|
|
assert.calledOnce(config.router.setState);
|
|
assert.deepEqual(result, { value: 1 });
|
|
});
|
|
});
|
|
describe("DISABLE_PROVIDER action", () => {
|
|
it("default calls ASRouterPreferences.enableOrDisableProvider", () => {
|
|
handler.handleMessage(msg.DISABLE_PROVIDER, {});
|
|
assert.calledOnce(config.preferences.enableOrDisableProvider);
|
|
});
|
|
});
|
|
describe("ENABLE_PROVIDER action", () => {
|
|
it("default calls ASRouterPreferences.enableOrDisableProvider", () => {
|
|
handler.handleMessage(msg.ENABLE_PROVIDER, {});
|
|
assert.calledOnce(config.preferences.enableOrDisableProvider);
|
|
});
|
|
});
|
|
describe("EVALUATE_JEXL_EXPRESSION action", () => {
|
|
it("default calls evaluateExpression", () => {
|
|
handler.handleMessage(msg.EVALUATE_JEXL_EXPRESSION, {});
|
|
assert.calledOnce(config.router.evaluateExpression);
|
|
});
|
|
});
|
|
describe("EXPIRE_QUERY_CACHE action", () => {
|
|
it("default calls QueryCache.expireAll", () => {
|
|
handler.handleMessage(msg.EXPIRE_QUERY_CACHE);
|
|
assert.calledOnce(config.queryCache.expireAll);
|
|
});
|
|
});
|
|
describe("FORCE_ATTRIBUTION action", () => {
|
|
it("default calls forceAttribution", () => {
|
|
handler.handleMessage(msg.FORCE_ATTRIBUTION, {});
|
|
assert.calledOnce(config.router.forceAttribution);
|
|
});
|
|
});
|
|
describe("FORCE_WHATSNEW_PANEL action", () => {
|
|
it("default calls forceWNPanel", () => {
|
|
handler.handleMessage(
|
|
msg.FORCE_WHATSNEW_PANEL,
|
|
{},
|
|
{ browser: { ownerGlobal: {} } }
|
|
);
|
|
assert.calledOnce(config.router.forceWNPanel);
|
|
assert.calledWith(config.router.forceWNPanel, { ownerGlobal: {} });
|
|
});
|
|
});
|
|
describe("CLOSE_WHATSNEW_PANEL action", () => {
|
|
it("default calls closeWNPanel", () => {
|
|
handler.handleMessage(
|
|
msg.CLOSE_WHATSNEW_PANEL,
|
|
{},
|
|
{ browser: { ownerGlobal: {} } }
|
|
);
|
|
assert.calledOnce(config.router.closeWNPanel);
|
|
assert.calledWith(config.router.closeWNPanel, { ownerGlobal: {} });
|
|
});
|
|
});
|
|
describe("FORCE_PRIVATE_BROWSING_WINDOW action", () => {
|
|
it("default calls forcePBWindow", () => {
|
|
handler.handleMessage(
|
|
msg.FORCE_PRIVATE_BROWSING_WINDOW,
|
|
{},
|
|
{ browser: { ownerGlobal: {} } }
|
|
);
|
|
assert.calledOnce(config.router.forcePBWindow);
|
|
assert.calledWith(config.router.forcePBWindow, { ownerGlobal: {} });
|
|
});
|
|
});
|
|
describe("MODIFY_MESSAGE_JSON action", () => {
|
|
it("default calls routeCFRMessage", async () => {
|
|
const result = await handler.handleMessage(
|
|
msg.MODIFY_MESSAGE_JSON,
|
|
{
|
|
content: {
|
|
text: "something",
|
|
},
|
|
},
|
|
{ browser: { ownerGlobal: {} }, id: 100 }
|
|
);
|
|
assert.calledOnce(config.router.routeCFRMessage);
|
|
assert.calledWith(
|
|
config.router.routeCFRMessage,
|
|
{ text: "something" },
|
|
{ ownerGlobal: {} },
|
|
{ content: { text: "something" } },
|
|
true
|
|
);
|
|
assert.deepEqual(result, { value: 1 });
|
|
});
|
|
});
|
|
describe("OVERRIDE_MESSAGE action", () => {
|
|
it("default calls setMessageById", async () => {
|
|
const result = await handler.handleMessage(
|
|
msg.OVERRIDE_MESSAGE,
|
|
{
|
|
id: 1,
|
|
},
|
|
{ id: 100, browser: { ownerGlobal: {} } }
|
|
);
|
|
assert.calledOnce(config.router.setMessageById);
|
|
assert.calledWith(config.router.setMessageById, { id: 1 }, true, {
|
|
ownerGlobal: {},
|
|
});
|
|
assert.deepEqual(result, { value: 1 });
|
|
});
|
|
});
|
|
describe("RESET_PROVIDER_PREF action", () => {
|
|
it("default calls ASRouterPreferences.resetProviderPref", () => {
|
|
handler.handleMessage(msg.RESET_PROVIDER_PREF);
|
|
assert.calledOnce(config.preferences.resetProviderPref);
|
|
});
|
|
});
|
|
describe("SET_PROVIDER_USER_PREF action", () => {
|
|
it("default calls ASRouterPreferences.setUserPreference", () => {
|
|
handler.handleMessage(msg.SET_PROVIDER_USER_PREF, {
|
|
id: 1,
|
|
value: true,
|
|
});
|
|
assert.calledOnce(config.preferences.setUserPreference);
|
|
assert.calledWith(config.preferences.setUserPreference, 1, true);
|
|
});
|
|
});
|
|
describe("RESET_GROUPS_STATE action", () => {
|
|
it("default calls resetGroupsState, loadMessagesFromAllProviders, and returns state", async () => {
|
|
const result = await handler.handleMessage(msg.RESET_GROUPS_STATE, {
|
|
property: "value",
|
|
});
|
|
assert.calledOnce(config.router.resetGroupsState);
|
|
assert.calledOnce(config.router.loadMessagesFromAllProviders);
|
|
assert.deepEqual(result, { value: 1 });
|
|
});
|
|
});
|
|
describe("RESET_MESSAGE_STATE action", () => {
|
|
it("default calls resetMessageState", () => {
|
|
handler.handleMessage(msg.RESET_MESSAGE_STATE);
|
|
assert.calledOnce(config.router.resetMessageState);
|
|
});
|
|
});
|
|
describe("RESET_SCREEN_IMPRESSIONS action", () => {
|
|
it("default calls resetScreenImpressions", () => {
|
|
handler.handleMessage(msg.RESET_SCREEN_IMPRESSIONS);
|
|
assert.calledOnce(config.router.resetScreenImpressions);
|
|
});
|
|
});
|
|
describe("EDIT_STATE action", () => {
|
|
it("default calls editState with correct args", () => {
|
|
handler.handleMessage(msg.EDIT_STATE, { property: "value" });
|
|
assert.calledWith(config.router.editState, "property", "value");
|
|
});
|
|
});
|
|
});
|
|
});
|