firefox-main/browser/components/urlbar/tests/browser-UrlbarView/browser_reusable.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info:

/* Any copyright is dedicated to the Public Domain.
"use strict";
// Tests that the elements for results are reusable.
ChromeUtils.defineESModuleGetters(this, {
UrlbarProviderQuickSuggest:
"moz-src:///browser/components/urlbar/UrlbarProviderQuickSuggest.sys.mjs",
});
const SIMPLE_GET_VIEW_TEMPLATE = () => {
return {
children: [
{
name: "text",
tag: "span",
},
],
};
};
const SIMPLE_GET_VIEW_UPDATE = result => {
return {
text: {
textContent: result.payload.value,
},
};
};
add_setup(async function setup() {
let providersManager = ProvidersManager.getInstanceForSap("urlbar");
let originals = providersManager.providers;
providersManager.providers = [];
registerCleanupFunction(async function () {
providersManager.providers = originals;
});
});
add_task(async function provider() {
const TEST_DATA = [
{
first: "SameTestProvider",
second: "SameTestProvider",
expectedReused: true,
},
{
first: "FirstTestProvider",
second: "SecondTestProvider",
expectedReused: false,
},
];
for (let { first, second, expectedReused } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: first,
results: [
makeUrlResult({
payload: {
title: "first example",
},
}),
],
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: second,
results: [
makeUrlResult({
payload: {
title: "second example",
},
}),
],
}),
expectedReused,
});
}
});
add_task(async function isRichSuggestion() {
const TEST_DATA = [
{
first: true,
second: true,
expectedReused: true,
},
{
first: true,
second: false,
expectedReused: false,
},
];
for (let { first, second, expectedReused } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
isRichSuggestion: first,
payload: {
title: "first example",
},
}),
],
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
isRichSuggestion: second,
payload: {
title: "second example",
},
}),
],
}),
expectedReused,
});
}
});
add_task(async function heuristic() {
const TEST_DATA = [
{
first: true,
second: true,
expectedReused: true,
},
{
first: true,
second: false,
expectedReused: false,
},
];
for (let { first, second, expectedReused } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
heuristic: first,
payload: {
title: "first example",
},
}),
],
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
heuristic: second,
payload: {
title: "second example",
},
}),
],
}),
expectedReused,
});
}
});
add_task(async function result_menu() {
const TEST_DATA = [
{
first: true,
second: true,
expectedReused: true,
expectedButtons: {
first: ["result-menu"],
second: ["result-menu"],
},
},
{
first: true,
second: false,
expectedReused: false,
expectedButtons: {
first: ["result-menu"],
second: [],
},
},
];
for (let { first, second, expectedReused, expectedButtons } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
payload: {
isManageable: first,
title: "first example",
},
}),
],
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
payload: {
isBlockable: second,
title: "second example",
},
}),
],
}),
isButtonTest: true,
expectedReused,
expectedButtons,
});
}
});
add_task(async function showFeedbackMenu() {
const TEST_DATA = [
{
first: true,
second: true,
expectedReused: true,
expectedButtons: {
first: ["result-menu"],
second: ["result-menu"],
},
},
{
first: true,
second: false,
expectedReused: false,
expectedButtons: {
first: ["result-menu"],
second: ["result-menu"],
},
},
];
for (let { first, second, expectedReused, expectedButtons } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
showFeedbackMenu: first,
payload: {
isBlockable: true,
title: "first example",
},
}),
],
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
showFeedbackMenu: second,
payload: {
isBlockable: true,
title: "second example",
},
}),
],
}),
expectedReused,
expectedButtons,
});
}
});
add_task(async function buttons() {
const TEST_DATA = [
{
first: [
{
l10n: { id: "urlbar-search-tips-confirm" },
},
{
l10n: { id: "urlbar-search-mode-bookmarks" },
},
],
second: [
{
l10n: { id: "urlbar-search-tips-confirm" },
},
{
l10n: { id: "urlbar-search-mode-bookmarks" },
},
],
expectedReused: true,
expectedButtons: {
first: ["0", "1"],
second: ["0", "1"],
},
},
{
first: [
{
l10n: { id: "urlbar-search-tips-confirm" },
},
],
second: [
{
l10n: { id: "urlbar-search-mode-bookmarks" },
},
],
expectedReused: false,
expectedButtons: {
first: ["0"],
second: ["0"],
},
},
{
first: [
{
l10n: { id: "urlbar-search-tips-confirm" },
},
{
l10n: { id: "urlbar-search-mode-bookmarks" },
},
],
second: [
{
l10n: { id: "urlbar-search-tips-confirm" },
},
],
expectedReused: false,
expectedButtons: {
first: ["0", "1"],
second: ["0"],
},
},
];
for (let { first, second, expectedReused, expectedButtons } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeTipResult({
payload: {
buttons: first,
type: "test",
},
}),
],
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeTipResult({
payload: {
buttons: second,
type: "test",
},
}),
],
}),
expectedReused,
expectedButtons,
});
}
});
add_task(async function switchTab() {
const TEST_DATA = [
{
first: UrlbarUtils.RESULT_TYPE.TAB_SWITCH,
second: UrlbarUtils.RESULT_TYPE.TAB_SWITCH,
expectedReused: true,
},
{
first: UrlbarUtils.RESULT_TYPE.TAB_SWITCH,
second: UrlbarUtils.RESULT_TYPE.URL,
expectedReused: false,
},
];
for (let { first, second, expectedReused } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
type: first,
payload: {
userContextId: 1,
title: "first example",
},
}),
],
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
type: second,
payload: {
title: "second example",
},
}),
],
}),
expectedReused,
});
}
});
add_task(async function dynamic_vs_not_dynamic() {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeDynamicResult({
payload: {
dynamicType: "testDynamic",
value: "first provider",
},
}),
],
getViewTemplate: SIMPLE_GET_VIEW_TEMPLATE,
getViewUpdate: SIMPLE_GET_VIEW_UPDATE,
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeUrlResult({
payload: {
title: "second example",
},
}),
],
}),
expectedReused: false,
});
});
add_task(async function dynamic_dynamicType() {
const TEST_DATA = [
{
first: "same_type",
second: "same_type",
expectedReused: true,
},
{
first: "first_type",
second: "second_type",
expectedReused: false,
},
];
for (let { first, second, expectedReused } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeDynamicResult({
payload: {
dynamicType: first,
value: "first provider",
},
}),
],
getViewTemplate: SIMPLE_GET_VIEW_TEMPLATE,
getViewUpdate: SIMPLE_GET_VIEW_UPDATE,
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeDynamicResult({
payload: {
dynamicType: second,
value: "second provider",
},
}),
],
getViewTemplate: SIMPLE_GET_VIEW_TEMPLATE,
getViewUpdate: SIMPLE_GET_VIEW_UPDATE,
}),
expectedReused,
});
}
});
add_task(async function dynamic_template() {
const TEST_DATA = [
{
first: {
children: [
{
name: "text",
tag: "span",
},
],
},
second: {
children: [
{
name: "text",
tag: "span",
},
],
},
expectedReused: true,
},
{
first: {
children: [
{
name: "text",
tag: "span",
},
],
},
second: {
children: [
{
name: "text",
tag: "div",
},
],
},
expectedReused: false,
},
];
for (let { first, second, expectedReused } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeDynamicResult({
payload: {
dynamicType: "testDynamic",
value: "first provider",
template: first,
},
}),
],
getViewTemplate: result => result.payload.template,
getViewUpdate: SIMPLE_GET_VIEW_UPDATE,
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: "TestProvider",
results: [
makeDynamicResult({
payload: {
dynamicType: "testDynamic",
value: "second provider",
template: second,
},
}),
],
getViewTemplate: result => result.payload.template,
getViewUpdate: SIMPLE_GET_VIEW_UPDATE,
}),
expectedReused,
});
}
});
add_task(async function quickSuggest_suggestionType() {
const TEST_DATA = [
{
first: "same_type",
second: "same_type",
expectedReused: true,
},
{
first: "first_type",
second: "second_type",
expectedReused: false,
},
];
for (let { first, second, expectedReused } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: UrlbarProviderQuickSuggest.name,
results: [
makeDynamicResult({
payload: {
dynamicType: "testDynamic",
suggestionType: first,
value: "first provider",
},
}),
],
getViewTemplate: SIMPLE_GET_VIEW_TEMPLATE,
getViewUpdate: SIMPLE_GET_VIEW_UPDATE,
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: UrlbarProviderQuickSuggest.name,
results: [
makeDynamicResult({
payload: {
dynamicType: "testDynamic",
suggestionType: second,
value: "second provider",
},
}),
],
getViewTemplate: SIMPLE_GET_VIEW_TEMPLATE,
getViewUpdate: SIMPLE_GET_VIEW_UPDATE,
}),
expectedReused,
});
}
});
add_task(async function quickSuggest_items() {
const TEST_DATA = [
{
first: [1, 2],
second: ["one", "two"],
expectedReused: true,
},
{
first: [1, 2],
second: ["one", "two", "three"],
expectedReused: false,
},
];
for (let { first, second, expectedReused } of TEST_DATA) {
await doTest({
firstProvider: new UrlbarTestUtils.TestProvider({
name: UrlbarProviderQuickSuggest.name,
results: [
makeDynamicResult({
payload: {
dynamicType: "testDynamic",
items: first,
value: "first provider",
},
}),
],
getViewTemplate: SIMPLE_GET_VIEW_TEMPLATE,
getViewUpdate: SIMPLE_GET_VIEW_UPDATE,
}),
secondProvider: new UrlbarTestUtils.TestProvider({
name: UrlbarProviderQuickSuggest.name,
results: [
makeDynamicResult({
payload: {
dynamicType: "testDynamic",
items: second,
value: "second provider",
},
}),
],
getViewTemplate: SIMPLE_GET_VIEW_TEMPLATE,
getViewUpdate: SIMPLE_GET_VIEW_UPDATE,
}),
expectedReused,
});
}
});
function makeDynamicResult(override) {
return new UrlbarResult({
type: UrlbarUtils.RESULT_TYPE.DYNAMIC,
source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
suggestedIndex: 0,
...override,
});
}
function makeUrlResult(override) {
return new UrlbarResult({
type: UrlbarUtils.RESULT_TYPE.URL,
source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
suggestedIndex: 0,
...override,
});
}
function makeTipResult(override) {
return new UrlbarResult({
type: UrlbarUtils.RESULT_TYPE.TIP,
source: UrlbarUtils.RESULT_SOURCE.OTHER_LOCAL,
suggestedIndex: 0,
...override,
});
}
async function doTest({
firstProvider,
secondProvider,
expectedReused,
expectedButtons = null,
}) {
info("Show the results of first provider");
let providersManager = ProvidersManager.getInstanceForSap("urlbar");
providersManager.registerProvider(firstProvider);
await UrlbarTestUtils.promiseAutocompleteResultPopup({
window,
value: "any",
});
info("Hold the row element and its _elements");
let { row: firstShownRow } = (
await UrlbarTestUtils.getDetailsOfResultAt(window, 0)
).element;
let firstShownContent = firstShownRow._content;
let firstShownButtons = new Map(firstShownRow._buttons);
let firstShownButtonsElement = firstShownRow._elements.get("buttons");
let firstShownButtonsFirstElement =
firstShownButtonsElement?.firstElementChild;
providersManager.unregisterProvider(firstProvider);
if (expectedButtons) {
info("Sanity check for buttons");
assertButtons(
firstShownButtons,
firstShownButtonsElement,
expectedButtons.first
);
}
info("Show the results of second provider");
providersManager.registerProvider(secondProvider);
await UrlbarTestUtils.promiseAutocompleteResultPopup({
window,
value: "any",
});
info("Check that the element is reused");
let { row: secondShownRow } = (
await UrlbarTestUtils.getDetailsOfResultAt(window, 0)
).element;
info("Assert results");
let isContentReused =
firstShownRow == secondShownRow &&
firstShownContent == secondShownRow._content &&
firstShownContent.firstElementChild ==
secondShownRow._content.firstElementChild;
if (expectedButtons) {
info("Assert buttons");
Assert.ok(
isContentReused,
"The content element should be reused if the changes was only buttons"
);
let secondShownButtons = secondShownRow._buttons;
let secondShownButtonsElement = secondShownRow._elements.get("buttons");
let secondShownButtonsFirstElement =
secondShownButtonsElement.firstElementChild;
Assert.equal(
firstShownButtonsFirstElement == secondShownButtonsFirstElement,
expectedReused,
"Check whether the buttons element is reused or not"
);
assertButtons(
secondShownButtons,
secondShownButtonsElement,
expectedButtons.second
);
} else {
info("Assert content");
Assert.equal(
isContentReused,
expectedReused,
"Check whether the content element is reused or not"
);
}
providersManager.unregisterProvider(secondProvider);
await UrlbarTestUtils.promiseSearchComplete(window);
}
function assertButtons(buttonsMap, buttonsElement, expected) {
Assert.equal([...buttonsMap.keys()].length, expected.length);
for (let name of expected) {
let button = buttonsMap.get(name);
Assert.ok(button);
Assert.ok(buttonsElement.contains(button));
}
}