firefox-main/browser/components/urlbar/tests/browser-engagementTelemetry/head-groups.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

/* Any copyright is dedicated to the Public Domain.
"use strict";
/* import-globals-from head.js */
ChromeUtils.defineESModuleGetters(this, {
ProvidersManager:
"moz-src:///browser/components/urlbar/UrlbarProvidersManager.sys.mjs",
});
async function doHeuristicsTest({ trigger, assert }) {
await doTest(async () => {
await openPopup("x");
await trigger();
await assert();
});
}
async function doAdaptiveHistoryTest({ trigger, assert }) {
await SpecialPowers.pushPrefEnv({
set: [["browser.urlbar.autoFill", false]],
});
await doTest(async () => {
await PlacesTestUtils.addVisits(["https://example.com/test"]);
await UrlbarUtils.addToInputHistory("https://example.com/test", "examp");
await openPopup("exa");
await selectRowByURL("https://example.com/test");
await trigger();
await assert();
});
await SpecialPowers.popPrefEnv();
}
async function doAdaptiveHistorySerpHistoryTest({ trigger, assert }) {
let defaultEngine = await SearchService.getDefault();
let serpUrl = defaultEngine.getSubmission("test search", null).uri.spec;
await doTest(async () => {
await PlacesTestUtils.addVisits(serpUrl);
await UrlbarUtils.addToInputHistory(serpUrl, "test sea");
await openPopup("test sea");
await selectRowByProvider("UrlbarProviderInputHistory");
await trigger();
await assert();
});
}
async function doAdaptiveHistoryBookmarkTest({ trigger, assert }) {
await doTest(async () => {
await PlacesTestUtils.addVisits("https://example.com/test");
await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
title: "bookmark",
});
await UrlbarUtils.addToInputHistory("https://example.com/test", "test");
await openPopup("test");
await selectRowByProvider("UrlbarProviderInputHistory");
await trigger();
await assert();
});
}
async function doAdaptiveHistoryBookmarkSerpHistoryTest({ trigger, assert }) {
await doTest(async () => {
let defaultEngine = await SearchService.getDefault();
let serpUrl = defaultEngine.getSubmission("test search", null).uri.spec;
await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
url: serpUrl,
title: "bookmark",
});
await PlacesTestUtils.addVisits(serpUrl);
await UrlbarUtils.addToInputHistory(serpUrl, "test");
await openPopup("test");
await selectRowByProvider("UrlbarProviderInputHistory");
await trigger();
await assert();
});
}
async function doSearchHistoryTest({ trigger, assert }) {
await SpecialPowers.pushPrefEnv({
set: [
["browser.urlbar.suggest.searches", true],
["browser.urlbar.maxHistoricalSearchSuggestions", 2],
],
});
await doTest(async () => {
await UrlbarTestUtils.formHistory.add(["foofoo", "foobar"]);
await openPopup("foo");
await selectRowByURL("http://mochi.test:8888/?terms=foofoo");
await trigger();
await assert();
});
await SpecialPowers.popPrefEnv();
}
async function doRecentSearchTest({ trigger, assert }) {
await SpecialPowers.pushPrefEnv({
set: [["browser.urlbar.recentsearches.featureGate", true]],
});
await doTest(async () => {
await UrlbarTestUtils.formHistory.add([
{ value: "foofoo", source: SearchService.defaultEngine.name },
]);
await openPopup("");
await selectRowByURL("http://mochi.test:8888/?terms=foofoo");
await trigger();
await assert();
});
await SpecialPowers.popPrefEnv();
}
async function doSearchSuggestTest({ trigger, assert }) {
await SpecialPowers.pushPrefEnv({
set: [
["browser.urlbar.suggest.searches", true],
["browser.urlbar.maxHistoricalSearchSuggestions", 2],
],
});
await doTest(async () => {
await openPopup("foo");
await selectRowByURL("http://mochi.test:8888/?terms=foofoo");
await trigger();
await assert();
});
await SpecialPowers.popPrefEnv();
}
async function doTailSearchSuggestTest({ trigger, assert }) {
const cleanup = await _useTailSuggestionsEngine();
await doTest(async () => {
await openPopup("hello");
await selectRowByProvider("UrlbarProviderSearchSuggestions");
await trigger();
await assert();
});
await cleanup();
}
async function doTopPickTest({ trigger, assert }) {
const cleanupQuickSuggest = await ensureQuickSuggestInit({
merinoSuggestions: [
{
title: "Navigational suggestion",
provider: "top_picks",
is_sponsored: false,
score: 0.25,
block_id: 0,
is_top_pick: true,
},
],
});
await doTest(async () => {
await openPopup("navigational");
await trigger();
await assert();
});
await cleanupQuickSuggest();
}
async function doTopSiteTest({ trigger, assert }) {
await doTest(async () => {
await addTopSites("https://example.com/");
await showResultByArrowDown();
await selectRowByURL("https://example.com/");
await trigger();
await assert();
});
}
async function doClipboardTest({ trigger, assert }) {
await SpecialPowers.pushPrefEnv({
set: [
["browser.urlbar.clipboard.featureGate", true],
["browser.urlbar.suggest.clipboard", true],
],
});
SpecialPowers.clipboardCopyString("https://example.com/clipboard");
await doTest(async () => {
await showResultByArrowDown();
await selectRowByURL("https://example.com/clipboard");
await trigger();
await assert();
});
SpecialPowers.clipboardCopyString("");
let providersManager = ProvidersManager.getInstanceForSap("urlbar");
providersManager
.getProvider("UrlbarProviderClipboard")
.setPreviousClipboardValue("");
await SpecialPowers.popPrefEnv();
}
async function doRemoteTabTest({ trigger, assert }) {
const remoteTab = await loadRemoteTab("https://example.com");
await doTest(async () => {
await openPopup("example");
await selectRowByProvider("UrlbarProviderRemoteTabs");
await trigger();
await assert();
});
await remoteTab.unload();
}
async function doAddonTest({ trigger, assert }) {
const addon = loadOmniboxAddon({ keyword: "omni" });
await addon.startup();
await doTest(async () => {
await openPopup("omni test");
await trigger();
await assert();
});
await addon.unload();
}
async function doGeneralBookmarkTest({ trigger, assert }) {
await doTest(async () => {
await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
title: "bookmark",
});
await openPopup("bookmark");
await selectRowByURL("https://example.com/bookmark");
await trigger();
await assert();
});
}
async function doGeneralHistoryTest({ trigger, assert }) {
await SpecialPowers.pushPrefEnv({
set: [["browser.urlbar.autoFill", false]],
});
await doTest(async () => {
await PlacesTestUtils.addVisits("https://example.com/test");
await openPopup("example");
await selectRowByURL("https://example.com/test");
await trigger();
await assert();
});
await SpecialPowers.popPrefEnv();
}
async function doSuggestTest({ trigger, assert }) {
const cleanupQuickSuggest = await ensureQuickSuggestInit();
await doTest(async () => {
await openPopup("wikipedia");
await selectRowByURL("https://example.com/wikipedia");
await trigger();
await assert();
});
await cleanupQuickSuggest();
}
async function doAboutPageTest({ trigger, assert }) {
await SpecialPowers.pushPrefEnv({
set: [["browser.urlbar.maxRichResults", 3]],
});
await doTest(async () => {
await openPopup("about:");
await selectRowByURL("about:robots");
await trigger();
await assert();
});
await SpecialPowers.popPrefEnv();
}
async function doSuggestedIndexTest({ trigger, assert }) {
await SpecialPowers.pushPrefEnv({
set: [["browser.urlbar.unitConversion.enabled", true]],
});
await doTest(async () => {
await openPopup("1m to cm");
await selectRowByProvider("UrlbarProviderUnitConversion");
await trigger();
await assert();
});
await SpecialPowers.popPrefEnv();
}
async function doRestrictKeywordsTest({ trigger, assert }) {
await SpecialPowers.pushPrefEnv({
set: [["browser.urlbar.searchRestrictKeywords.featureGate", true]],
});
await doTest(async () => {
await openPopup("@");
let totalResults = await UrlbarTestUtils.getResultCount(window);
let restrictSymbols = Object.values(UrlbarTokenizer.RESTRICT);
for (let i = 0; i < totalResults; i++) {
let details = await UrlbarTestUtils.getDetailsOfResultAt(window, i);
let symbol = details.result.payload.keyword;
let keyword = details.result.payload.l10nRestrictKeywords
?.at(0)
.toLowerCase();
if (restrictSymbols.includes(symbol)) {
let rowToSelect = await UrlbarTestUtils.waitForAutocompleteResultAt(
window,
i
);
await trigger(rowToSelect, keyword);
await openPopup("@");
}
}
await assert();
});
await SpecialPowers.popPrefEnv();
}
async function doSemanticHistoryTest({ trigger, assert }) {
const historyUrl = "https://www.example.com/semantic/";
await doTestWithSemantic(
[
{
id: 1,
title: "Test Page",
url: historyUrl,
frecency: 100,
},
],
async () => {
// Must be longer than `browser.urlbar.suggest.semanticHistory.minLength`.
await openPopup("testing semantic");
await selectRowByURL(historyUrl);
await trigger();
await assert();
}
);
}
async function doSerpHistoryTest({ trigger, assert }) {
let defaultEngine = await SearchService.getDefault();
const searchUrl = defaultEngine.getSubmission("serp history", null).uri.spec;
await doTest(async () => {
await PlacesTestUtils.addVisits(searchUrl);
await openPopup("serp");
await selectRowByURL(searchUrl);
await trigger();
await assert();
});
}
async function doBookmarkSerpHistoryTest({ trigger, assert }) {
await doTest(async () => {
let defaultEngine = await SearchService.getDefault();
let serpUrl = defaultEngine.getSubmission("test search", null).uri.spec;
await PlacesUtils.bookmarks.insert({
parentGuid: PlacesUtils.bookmarks.unfiledGuid,
url: serpUrl,
title: "bookmark",
});
await openPopup("test");
await selectRowByURL(serpUrl);
await trigger();
await assert();
});
}
async function doTabAdaptiveTest({ trigger, assert }) {
let visited = PlacesTestUtils.waitForNotification("page-visited", visits =>
visits.some(({ url }) => url == "https://example.com/")
);
let tab = BrowserTestUtils.addTab(gBrowser, "https://example.com/");
await visited;
await doTest(async () => {
await PlacesTestUtils.addVisits("https://example.com/");
await UrlbarUtils.addToInputHistory("https://example.com/", "exa");
await openPopup("exa");
await selectRowByProvider("UrlbarProviderInputHistory");
await trigger();
await assert();
});
BrowserTestUtils.removeTab(tab);
}
async function doTabAdaptiveSerpHistoryTest({ trigger, assert }) {
let defaultEngine = await SearchService.getDefault();
const searchUrl = defaultEngine.getSubmission("serp history", null).uri.spec;
let visited = PlacesTestUtils.waitForNotification("page-visited", visits =>
visits.some(({ url }) => url == searchUrl)
);
let tab = BrowserTestUtils.addTab(gBrowser, searchUrl);
await visited;
await doTest(async () => {
await PlacesTestUtils.addVisits(searchUrl);
await UrlbarUtils.addToInputHistory(searchUrl, "serp");
await openPopup("serp");
await selectRowByURL(searchUrl);
await trigger();
await assert();
});
BrowserTestUtils.removeTab(tab);
}
async function doTabSerpHistoryTest({ trigger, assert }) {
let defaultEngine = await SearchService.getDefault();
const searchUrl = defaultEngine.getSubmission("serp history", null).uri.spec;
let visited = PlacesTestUtils.waitForNotification("page-visited", visits =>
visits.some(({ url }) => url == searchUrl)
);
let tab = BrowserTestUtils.addTab(gBrowser, searchUrl);
await visited;
await doTest(async () => {
await openPopup("serp");
await selectRowByURL(searchUrl);
await trigger();
await assert();
});
BrowserTestUtils.removeTab(tab);
}
/**
* Creates a search engine that returns tail suggestions and sets it as the
* default engine.
*
* @returns {Function}
* A cleanup function that will revert the default search engine and stop http
* server.
*/
async function _useTailSuggestionsEngine() {
await SpecialPowers.pushPrefEnv({
set: [
["browser.search.suggest.enabled", true],
["browser.urlbar.suggest.searches", true],
["browser.urlbar.richSuggestions.tail", true],
],
});
const engineName = "TailSuggestions";
const httpServer = new HttpServer();
httpServer.start(-1);
httpServer.registerPathHandler("/suggest", (req, resp) => {
const params = new URLSearchParams(req.queryString);
const searchStr = params.get("q");
const suggestions = [
searchStr,
[searchStr + "-tail"],
[],
{
"google:suggestdetail": [{ t: "-tail", mp: "… " }],
},
];
resp.setHeader("Content-Type", "application/json", false);
resp.write(JSON.stringify(suggestions));
});
await SearchTestUtils.installSearchExtension({
name: engineName,
search_url: `http://localhost:${httpServer.identity.primaryPort}/search`,
suggest_url: `http://localhost:${httpServer.identity.primaryPort}/suggest`,
suggest_url_get_params: "?q={searchTerms}",
});
const tailEngine = SearchService.getEngineByName(engineName);
const originalEngine = await SearchService.getDefault();
SearchService.setDefault(tailEngine, SearchService.CHANGE_REASON.UNKNOWN);
return async () => {
SearchService.setDefault(
originalEngine,
SearchService.CHANGE_REASON.UNKNOWN
);
httpServer.stop(() => {});
await SpecialPowers.popPrefEnv();
};
}