browser/components/urlbar/tests/browser-tips/browser_searchTips_interaction.js

   1 /* Any copyright is dedicated to the Public Domain.
   2  * http://creativecommons.org/publicdomain/zero/1.0/ */
   3
   4 // Tests the Search Tips feature, which displays a prompt to use the Urlbar on
   5 // the newtab page and on the user's default search engine's homepage.
   6 // Specifically, it tests that the Tips appear when they should be appearing.
   7 // This doesn't test the max-shown-count limit because it requires restarting
   8 // the browser.
   9
  10 "use strict";
  11
  12 ChromeUtils.defineESModuleGetters(this, {
  13   AppMenuNotifications: "resource://gre/modules/AppMenuNotifications.sys.mjs",
  14   HttpServer: "resource://testing-common/httpd.sys.mjs",
  15   UrlbarPrefs: "resource:///modules/UrlbarPrefs.sys.mjs",
  16   UrlbarProviderSearchTips:
  17     "resource:///modules/UrlbarProviderSearchTips.sys.mjs",
  18   UrlbarUtils: "resource:///modules/UrlbarUtils.sys.mjs",
  19 });
  20
  21 XPCOMUtils.defineLazyServiceGetter(
  22   this,
  23   "clipboardHelper",
  24   "@mozilla.org/widget/clipboardhelper;1",
  25   "nsIClipboardHelper"
  26 );
  27
  28 // These should match the same consts in UrlbarProviderSearchTips.jsm.
  29 const MAX_SHOWN_COUNT = 4;
  30 const LAST_UPDATE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
  31
  32 // We test some of the bigger Google domains.
  33 const GOOGLE_DOMAINS = [
  34   "www.google.com",
  35   "www.google.ca",
  36   "www.google.co.uk",
  37   "www.google.com.au",
  38   "www.google.co.nz",
  39 ];
  40
  41 // In order for the persist tip to appear, the scheme of the
  42 // search engine has to be the same as the scheme of the SERP url.
  43 // withDNSRedirect() loads an http: url while the searchform
  44 // of the default engine uses https. To enable the search term
  45 // to be shown, we use the Example engine because it doesn't require
  46 // a redirect.
  47 const SEARCH_TERM = "chocolate";
  48 const SEARCH_SERP_URL = `https://example.com/?q=${SEARCH_TERM}`;
  49
  50 add_setup(async function () {
  51   await PlacesUtils.history.clear();
  52   await PlacesUtils.bookmarks.eraseEverything();
  53
  54   await SpecialPowers.pushPrefEnv({
  55     set: [
  56       [
  57         `browser.urlbar.tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.ONBOARD}`,
  58         0,
  59       ],
  60       [
  61         `browser.urlbar.tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.PERSIST}`,
  62         0,
  63       ],
  64       [
  65         `browser.urlbar.tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.REDIRECT}`,
  66         0,
  67       ],
  68       // Set following prefs so tips are actually shown.
  69       ["browser.laterrun.bookkeeping.profileCreationTime", 0],
  70       ["browser.laterrun.bookkeeping.updateAppliedTime", 0],
  71     ],
  72   });
  73
  74   // Remove update history and the current active update so tips are shown.
  75   let updateRootDir = Services.dirsvc.get("UpdRootD", Ci.nsIFile);
  76   let updatesFile = updateRootDir.clone();
  77   updatesFile.append("updates.xml");
  78   let activeUpdateFile = updateRootDir.clone();
  79   activeUpdateFile.append("active-update.xml");
  80   try {
  81     updatesFile.remove(false);
  82   } catch (e) {}
  83   try {
  84     activeUpdateFile.remove(false);
  85   } catch (e) {}
  86
  87   let defaultEngine = await Services.search.getDefault();
  88   let defaultEngineName = defaultEngine.name;
  89   Assert.equal(defaultEngineName, "Google", "Default engine should be Google.");
  90
  91   // Add a mock engine so we don't hit the network loading the SERP.
  92   await SearchTestUtils.installSearchExtension();
  93
  94   registerCleanupFunction(async () => {
  95     await setDefaultEngine(defaultEngineName);
  96     resetSearchTipsProvider();
  97   });
  98 });
  99
 100 // Picking the tip's button should cause the Urlbar to blank out and the tip to
 101 // be not to be shown again in any session. Telemetry should be updated.
 102 add_task(async function pickButton_onboard() {
 103   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 104   await SpecialPowers.pushPrefEnv({
 105     set: [["browser.urlbar.eventTelemetry.enabled", true]],
 106   });
 107
 108   Services.telemetry.clearEvents();
 109   let tab = await BrowserTestUtils.openNewForegroundTab({
 110     gBrowser,
 111     url: "about:newtab",
 112     waitForLoad: false,
 113   });
 114   await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.ONBOARD, false);
 115
 116   // Click the tip button.
 117   let result = await UrlbarTestUtils.getDetailsOfResultAt(window, 0);
 118   let button = result.element.row._buttons.get("0");
 119   await UrlbarTestUtils.promisePopupClose(window, () => {
 120     EventUtils.synthesizeMouseAtCenter(button, {});
 121   });
 122   gURLBar.blur();
 123
 124   // Check telemetry.
 125   const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
 126   TelemetryTestUtils.assertKeyedScalar(
 127     scalars,
 128     "urlbar.tips",
 129     `${UrlbarProviderSearchTips.TIP_TYPE.ONBOARD}-picked`,
 130     1
 131   );
 132   TelemetryTestUtils.assertEvents(
 133     [
 134       {
 135         category: "urlbar",
 136         method: "engagement",
 137         object: "click",
 138         value: "typed",
 139       },
 140     ],
 141     { category: "urlbar" }
 142   );
 143
 144   Assert.equal(
 145     UrlbarPrefs.get(
 146       `tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.ONBOARD}`
 147     ),
 148     MAX_SHOWN_COUNT,
 149     "Onboarding tips are disabled after tip button is picked."
 150   );
 151   Assert.equal(gURLBar.value, "", "The Urlbar should be empty.");
 152   resetSearchTipsProvider();
 153
 154   BrowserTestUtils.removeTab(tab);
 155   await SpecialPowers.popPrefEnv();
 156 });
 157
 158 // Picking the tip's button should cause the Urlbar to blank out and the tip to
 159 // be not to be shown again in any session. Telemetry should be updated.
 160 add_task(async function pickButton_redirect() {
 161   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 162   await SpecialPowers.pushPrefEnv({
 163     set: [["browser.urlbar.eventTelemetry.enabled", true]],
 164   });
 165   Services.telemetry.clearEvents();
 166
 167   await setDefaultEngine("Google");
 168   await BrowserTestUtils.withNewTab("about:blank", async () => {
 169     await withDNSRedirect("www.google.com", "/", async url => {
 170       BrowserTestUtils.startLoadingURIString(gBrowser.selectedBrowser, url);
 171       await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
 172       await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.REDIRECT, false);
 173
 174       // Click the tip button.
 175       let result = await UrlbarTestUtils.getDetailsOfResultAt(window, 0);
 176       let button = result.element.row._buttons.get("0");
 177       await UrlbarTestUtils.promisePopupClose(window, () => {
 178         EventUtils.synthesizeMouseAtCenter(button, {});
 179       });
 180       gURLBar.blur();
 181     });
 182   });
 183
 184   // Check telemetry.
 185   const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
 186   TelemetryTestUtils.assertKeyedScalar(
 187     scalars,
 188     "urlbar.tips",
 189     `${UrlbarProviderSearchTips.TIP_TYPE.REDIRECT}-picked`,
 190     1
 191   );
 192   TelemetryTestUtils.assertEvents(
 193     [
 194       {
 195         category: "urlbar",
 196         method: "engagement",
 197         object: "click",
 198         value: "typed",
 199       },
 200     ],
 201     { category: "urlbar" }
 202   );
 203
 204   Assert.equal(
 205     UrlbarPrefs.get(
 206       `tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.REDIRECT}`
 207     ),
 208     MAX_SHOWN_COUNT,
 209     "Redirect tips are disabled after tip button is picked."
 210   );
 211   Assert.equal(gURLBar.value, "", "The Urlbar should be empty.");
 212   resetSearchTipsProvider();
 213   await SpecialPowers.popPrefEnv();
 214 });
 215
 216 // Picking the tip's button should cause the Urlbar to keep its current
 217 // value and the tip to be not to be shown again in any session.
 218 // Telemetry should be updated.
 219 add_task(async function pickButton_persist() {
 220   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 221   await SpecialPowers.pushPrefEnv({
 222     set: [
 223       ["browser.urlbar.eventTelemetry.enabled", true],
 224       ["browser.urlbar.showSearchTerms.featureGate", true],
 225     ],
 226   });
 227   Services.telemetry.clearEvents();
 228
 229   await setDefaultEngine("Example");
 230
 231   await BrowserTestUtils.withNewTab("about:blank", async () => {
 232     let browserLoadedPromise = BrowserTestUtils.browserLoaded(
 233       gBrowser.selectedBrowser,
 234       false,
 235       SEARCH_SERP_URL
 236     );
 237     BrowserTestUtils.startLoadingURIString(
 238       gBrowser.selectedBrowser,
 239       SEARCH_SERP_URL
 240     );
 241     await browserLoadedPromise;
 242     await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.PERSIST, false);
 243
 244     let result = await UrlbarTestUtils.getDetailsOfResultAt(window, 0);
 245     let button = result.element.row._buttons.get("0");
 246
 247     await UrlbarTestUtils.promisePopupClose(window, () => {
 248       EventUtils.synthesizeMouseAtCenter(button, {});
 249     });
 250     gURLBar.blur();
 251
 252     Assert.equal(
 253       gURLBar.value,
 254       SEARCH_TERM,
 255       "The Urlbar should keep its existing value."
 256     );
 257   });
 258
 259   // Check telemetry.
 260   const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
 261   TelemetryTestUtils.assertKeyedScalar(
 262     scalars,
 263     "urlbar.tips",
 264     `${UrlbarProviderSearchTips.TIP_TYPE.PERSIST}-picked`,
 265     1
 266   );
 267   TelemetryTestUtils.assertEvents(
 268     [
 269       {
 270         category: "urlbar",
 271         method: "engagement",
 272         object: "click",
 273         value: "typed",
 274       },
 275     ],
 276     { category: "urlbar" }
 277   );
 278
 279   Assert.equal(
 280     UrlbarPrefs.get(
 281       `tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.PERSIST}`
 282     ),
 283     MAX_SHOWN_COUNT,
 284     "Persist tips are disabled after tip button is picked."
 285   );
 286   Assert.equal(gURLBar.value, "", "The Urlbar should be empty.");
 287   resetSearchTipsProvider();
 288   await SpecialPowers.popPrefEnv();
 289 });
 290
 291 // Clicking in the input while the onboard tip is showing should have the same
 292 // effect as picking the tip.
 293 add_task(async function clickInInput_onboard() {
 294   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 295   await SpecialPowers.pushPrefEnv({
 296     set: [["browser.urlbar.eventTelemetry.enabled", true]],
 297   });
 298   Services.telemetry.clearEvents();
 299
 300   await setDefaultEngine("Google");
 301   let tab = await BrowserTestUtils.openNewForegroundTab({
 302     gBrowser,
 303     url: "about:newtab",
 304     waitForLoad: false,
 305   });
 306   await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.ONBOARD, false);
 307
 308   // Click in the input.
 309   await UrlbarTestUtils.promisePopupClose(window, () => {
 310     EventUtils.synthesizeMouseAtCenter(gURLBar.textbox.parentNode, {});
 311   });
 312   gURLBar.blur();
 313
 314   // Check telemetry.
 315   const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
 316   TelemetryTestUtils.assertKeyedScalar(
 317     scalars,
 318     "urlbar.tips",
 319     `${UrlbarProviderSearchTips.TIP_TYPE.ONBOARD}-picked`,
 320     1
 321   );
 322   TelemetryTestUtils.assertEvents(
 323     [
 324       {
 325         category: "urlbar",
 326         method: "engagement",
 327         object: "click",
 328         value: "typed",
 329       },
 330     ],
 331     { category: "urlbar" }
 332   );
 333
 334   Assert.equal(
 335     UrlbarPrefs.get(
 336       `tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.ONBOARD}`
 337     ),
 338     MAX_SHOWN_COUNT,
 339     "Onboarding tips are disabled after tip button is picked."
 340   );
 341   Assert.equal(gURLBar.value, "", "The Urlbar should be empty.");
 342   resetSearchTipsProvider();
 343
 344   BrowserTestUtils.removeTab(tab);
 345   await SpecialPowers.popPrefEnv();
 346 });
 347
 348 // Pressing Ctrl+L (the open location command) while the onboard tip is showing
 349 // should have the same effect as picking the tip.
 350 add_task(async function openLocation_onboard() {
 351   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 352   await SpecialPowers.pushPrefEnv({
 353     set: [["browser.urlbar.eventTelemetry.enabled", true]],
 354   });
 355   Services.telemetry.clearEvents();
 356
 357   await setDefaultEngine("Google");
 358   let tab = await BrowserTestUtils.openNewForegroundTab({
 359     gBrowser,
 360     url: "about:newtab",
 361     waitForLoad: false,
 362   });
 363   await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.ONBOARD, false);
 364
 365   // Trigger the open location command.
 366   await UrlbarTestUtils.promisePopupClose(window, () => {
 367     document.getElementById("Browser:OpenLocation").doCommand();
 368   });
 369   gURLBar.blur();
 370
 371   // Check telemetry.
 372   const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
 373   TelemetryTestUtils.assertKeyedScalar(
 374     scalars,
 375     "urlbar.tips",
 376     `${UrlbarProviderSearchTips.TIP_TYPE.ONBOARD}-picked`,
 377     1
 378   );
 379   TelemetryTestUtils.assertEvents(
 380     [
 381       {
 382         category: "urlbar",
 383         method: "engagement",
 384         object: "enter",
 385         value: "typed",
 386       },
 387     ],
 388     { category: "urlbar" }
 389   );
 390
 391   Assert.equal(
 392     UrlbarPrefs.get(
 393       `tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.ONBOARD}`
 394     ),
 395     MAX_SHOWN_COUNT,
 396     "Onboarding tips are disabled after tip button is picked."
 397   );
 398   Assert.equal(gURLBar.value, "", "The Urlbar should be empty.");
 399   resetSearchTipsProvider();
 400
 401   BrowserTestUtils.removeTab(tab);
 402   await SpecialPowers.popPrefEnv();
 403 });
 404
 405 // Clicking in the input while the redirect tip is showing should have the same
 406 // effect as picking the tip.
 407 add_task(async function clickInInput_redirect() {
 408   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 409   await SpecialPowers.pushPrefEnv({
 410     set: [["browser.urlbar.eventTelemetry.enabled", true]],
 411   });
 412   Services.telemetry.clearEvents();
 413
 414   await setDefaultEngine("Google");
 415   await BrowserTestUtils.withNewTab("about:blank", async () => {
 416     await withDNSRedirect("www.google.com", "/", async url => {
 417       BrowserTestUtils.startLoadingURIString(gBrowser.selectedBrowser, url);
 418       await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
 419       await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.REDIRECT, false);
 420
 421       // Click in the input.
 422       await UrlbarTestUtils.promisePopupClose(window, () => {
 423         EventUtils.synthesizeMouseAtCenter(gURLBar.textbox.parentNode, {});
 424       });
 425       gURLBar.blur();
 426     });
 427   });
 428
 429   // Check telemetry.
 430   const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
 431   TelemetryTestUtils.assertKeyedScalar(
 432     scalars,
 433     "urlbar.tips",
 434     `${UrlbarProviderSearchTips.TIP_TYPE.REDIRECT}-picked`,
 435     1
 436   );
 437   TelemetryTestUtils.assertEvents(
 438     [
 439       {
 440         category: "urlbar",
 441         method: "engagement",
 442         object: "click",
 443         value: "typed",
 444       },
 445     ],
 446     { category: "urlbar" }
 447   );
 448
 449   Assert.equal(
 450     UrlbarPrefs.get(
 451       `tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.REDIRECT}`
 452     ),
 453     MAX_SHOWN_COUNT,
 454     "Redirect tips are disabled after tip button is picked."
 455   );
 456   Assert.equal(gURLBar.value, "", "The Urlbar should be empty.");
 457   resetSearchTipsProvider();
 458   await SpecialPowers.popPrefEnv();
 459 });
 460
 461 // Clicking in the input while the persist tip is showing should have the same
 462 // effect as picking the tip.
 463 add_task(async function clickInInput_persist() {
 464   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 465   await SpecialPowers.pushPrefEnv({
 466     set: [
 467       ["browser.urlbar.eventTelemetry.enabled", true],
 468       ["browser.urlbar.showSearchTerms.featureGate", true],
 469     ],
 470   });
 471   Services.telemetry.clearEvents();
 472
 473   await setDefaultEngine("Example");
 474   await BrowserTestUtils.withNewTab("about:blank", async () => {
 475     let browserLoadedPromise = BrowserTestUtils.browserLoaded(
 476       gBrowser.selectedBrowser,
 477       false,
 478       SEARCH_SERP_URL
 479     );
 480     BrowserTestUtils.startLoadingURIString(
 481       gBrowser.selectedBrowser,
 482       SEARCH_SERP_URL
 483     );
 484     await browserLoadedPromise;
 485     await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.PERSIST, false);
 486
 487     // Click in the input.
 488     await UrlbarTestUtils.promisePopupClose(window, () => {
 489       EventUtils.synthesizeMouseAtCenter(gURLBar.textbox.parentNode, {});
 490     });
 491     gURLBar.blur();
 492     Assert.equal(
 493       gURLBar.value,
 494       SEARCH_TERM,
 495       "The Urlbar should keep its existing value."
 496     );
 497   });
 498
 499   // Check telemetry.
 500   const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
 501   TelemetryTestUtils.assertKeyedScalar(
 502     scalars,
 503     "urlbar.tips",
 504     `${UrlbarProviderSearchTips.TIP_TYPE.PERSIST}-picked`,
 505     1
 506   );
 507   TelemetryTestUtils.assertEvents(
 508     [
 509       {
 510         category: "urlbar",
 511         method: "engagement",
 512         object: "click",
 513         value: "typed",
 514       },
 515     ],
 516     { category: "urlbar" }
 517   );
 518
 519   Assert.equal(
 520     UrlbarPrefs.get(
 521       `tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.PERSIST}`
 522     ),
 523     MAX_SHOWN_COUNT,
 524     "Persist tips are disabled after tip button is picked."
 525   );
 526   Assert.equal(gURLBar.value, "", "The Urlbar should be empty.");
 527   resetSearchTipsProvider();
 528   await SpecialPowers.popPrefEnv();
 529 });
 530
 531 // Pressing Ctrl+L (the open location command) while the redirect tip is showing
 532 // should have the same effect as picking the tip.
 533 add_task(async function openLocation_redirect() {
 534   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 535   await SpecialPowers.pushPrefEnv({
 536     set: [["browser.urlbar.eventTelemetry.enabled", true]],
 537   });
 538   Services.telemetry.clearEvents();
 539
 540   await setDefaultEngine("Google");
 541   await BrowserTestUtils.withNewTab("about:blank", async () => {
 542     await withDNSRedirect("www.google.com", "/", async url => {
 543       BrowserTestUtils.startLoadingURIString(gBrowser.selectedBrowser, url);
 544       await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
 545       await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.REDIRECT, false);
 546
 547       // Trigger the open location command.
 548       await UrlbarTestUtils.promisePopupClose(window, () => {
 549         document.getElementById("Browser:OpenLocation").doCommand();
 550       });
 551       gURLBar.blur();
 552     });
 553   });
 554
 555   // Check telemetry.
 556   const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
 557   TelemetryTestUtils.assertKeyedScalar(
 558     scalars,
 559     "urlbar.tips",
 560     `${UrlbarProviderSearchTips.TIP_TYPE.REDIRECT}-picked`,
 561     1
 562   );
 563   TelemetryTestUtils.assertEvents(
 564     [
 565       {
 566         category: "urlbar",
 567         method: "engagement",
 568         object: "enter",
 569         value: "typed",
 570       },
 571     ],
 572     { category: "urlbar" }
 573   );
 574
 575   Assert.equal(
 576     UrlbarPrefs.get(
 577       `tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.REDIRECT}`
 578     ),
 579     MAX_SHOWN_COUNT,
 580     "Redirect tips are disabled after tip button is picked."
 581   );
 582   Assert.equal(gURLBar.value, "", "The Urlbar should be empty.");
 583   resetSearchTipsProvider();
 584   await SpecialPowers.popPrefEnv();
 585 });
 586
 587 // Pressing Ctrl+L (the open location command) while the persist tip is showing
 588 // should have the same effect as picking the tip.
 589 add_task(async function openLocation_persist() {
 590   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 591   await SpecialPowers.pushPrefEnv({
 592     set: [
 593       ["browser.urlbar.eventTelemetry.enabled", true],
 594       ["browser.urlbar.showSearchTerms.featureGate", true],
 595     ],
 596   });
 597   Services.telemetry.clearEvents();
 598
 599   await setDefaultEngine("Example");
 600   await BrowserTestUtils.withNewTab("about:blank", async () => {
 601     let browserLoadedPromise = BrowserTestUtils.browserLoaded(
 602       gBrowser.selectedBrowser,
 603       false,
 604       SEARCH_SERP_URL
 605     );
 606     BrowserTestUtils.startLoadingURIString(
 607       gBrowser.selectedBrowser,
 608       SEARCH_SERP_URL
 609     );
 610     await browserLoadedPromise;
 611     await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.PERSIST, false);
 612
 613     // Trigger the open location command.
 614     await UrlbarTestUtils.promisePopupClose(window, () => {
 615       document.getElementById("Browser:OpenLocation").doCommand();
 616     });
 617     gURLBar.blur();
 618     Assert.equal(
 619       gURLBar.value,
 620       SEARCH_TERM,
 621       "The Urlbar should keep its existing value."
 622     );
 623   });
 624
 625   // Check telemetry.
 626   const scalars = TelemetryTestUtils.getProcessScalars("parent", true, true);
 627   TelemetryTestUtils.assertKeyedScalar(
 628     scalars,
 629     "urlbar.tips",
 630     `${UrlbarProviderSearchTips.TIP_TYPE.PERSIST}-picked`,
 631     1
 632   );
 633   TelemetryTestUtils.assertEvents(
 634     [
 635       {
 636         category: "urlbar",
 637         method: "engagement",
 638         object: "enter",
 639         value: "typed",
 640       },
 641     ],
 642     { category: "urlbar" }
 643   );
 644
 645   Assert.equal(
 646     UrlbarPrefs.get(
 647       `tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.PERSIST}`
 648     ),
 649     MAX_SHOWN_COUNT,
 650     "Persist tips are disabled after tip button is picked."
 651   );
 652   Assert.equal(gURLBar.value, "", "The Urlbar should be empty.");
 653   resetSearchTipsProvider();
 654   await SpecialPowers.popPrefEnv();
 655 });
 656
 657 add_task(async function pickingTipDoesNotDisableOtherKinds() {
 658   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 659   await setDefaultEngine("Google");
 660   let tab = await BrowserTestUtils.openNewForegroundTab({
 661     gBrowser,
 662     url: "about:newtab",
 663     waitForLoad: false,
 664   });
 665   await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.ONBOARD, false);
 666
 667   // Click the tip button.
 668   let result = await UrlbarTestUtils.getDetailsOfResultAt(window, 0);
 669   let button = result.element.row._buttons.get("0");
 670   await UrlbarTestUtils.promisePopupClose(window, () => {
 671     EventUtils.synthesizeMouseAtCenter(button, {});
 672   });
 673
 674   gURLBar.blur();
 675   Assert.equal(
 676     UrlbarPrefs.get(
 677       `tipShownCount.${UrlbarProviderSearchTips.TIP_TYPE.ONBOARD}`
 678     ),
 679     MAX_SHOWN_COUNT,
 680     "Onboarding tips are disabled after tip button is picked."
 681   );
 682
 683   BrowserTestUtils.removeTab(tab);
 684
 685   // Simulate a new session.
 686   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 687
 688   // Onboarding tips should no longer be shown.
 689   let tab2 = await BrowserTestUtils.openNewForegroundTab({
 690     gBrowser,
 691     url: "about:newtab",
 692     waitForLoad: false,
 693   });
 694   await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.NONE);
 695
 696   // We should still show redirect tips.
 697   await withDNSRedirect("www.google.com", "/", async url => {
 698     await checkTab(window, url, UrlbarProviderSearchTips.TIP_TYPE.REDIRECT);
 699   });
 700
 701   BrowserTestUtils.removeTab(tab2);
 702   resetSearchTipsProvider();
 703 });
 704
 705 // The tip shouldn't be shown when there's another notification present.
 706 add_task(async function notification() {
 707   await BrowserTestUtils.withNewTab("about:blank", async () => {
 708     let box = gBrowser.getNotificationBox();
 709     let note = box.appendNotification("urlbar-test", {
 710       label: "Test",
 711       priority: box.PRIORITY_INFO_HIGH,
 712     });
 713     // Give it a big persistence so it doesn't go away on page load.
 714     note.persistence = 100;
 715     await withDNSRedirect("www.google.com", "/", async url => {
 716       BrowserTestUtils.startLoadingURIString(gBrowser.selectedBrowser, url);
 717       await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
 718       await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.NONE);
 719       box.removeNotification(note, true);
 720     });
 721   });
 722   resetSearchTipsProvider();
 723 });
 724
 725 // The tip should be shown when switching to a tab where it should be shown.
 726 add_task(async function tabSwitch() {
 727   let tab = BrowserTestUtils.addTab(gBrowser, "about:newtab");
 728   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 729   Services.telemetry.clearScalars();
 730   await BrowserTestUtils.switchTab(gBrowser, tab);
 731   await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.ONBOARD);
 732   BrowserTestUtils.removeTab(tab);
 733   resetSearchTipsProvider();
 734 });
 735
 736 // The engagement event should be ended if the user ignores a tip.
 737 // See bug 1610024.
 738 add_task(async function ignoreEndsEngagement() {
 739   await setDefaultEngine("Google");
 740   await BrowserTestUtils.withNewTab("about:blank", async () => {
 741     await withDNSRedirect("www.google.com", "/", async url => {
 742       BrowserTestUtils.startLoadingURIString(gBrowser.selectedBrowser, url);
 743       await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
 744       await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.REDIRECT, false);
 745       // We're just looking for any target outside the Urlbar.
 746       let spring = gURLBar.inputField
 747         .closest("#nav-bar")
 748         .querySelector("toolbarspring");
 749       await UrlbarTestUtils.promisePopupClose(window, async () => {
 750         await EventUtils.synthesizeMouseAtCenter(spring, {});
 751       });
 752       Assert.ok(
 753         UrlbarProviderSearchTips.showedTipTypeInCurrentEngagement ==
 754           UrlbarProviderSearchTips.TIP_TYPE.NONE,
 755         "The engagement should have ended after the tip was ignored."
 756       );
 757     });
 758   });
 759   resetSearchTipsProvider();
 760 });
 761
 762 add_task(async function pasteAndGo_url() {
 763   await doPasteAndGoTest("http://example.com/", "http://example.com/");
 764 });
 765
 766 add_task(async function pasteAndGo_nonURL() {
 767   await setDefaultEngine("Example");
 768   await doPasteAndGoTest(
 769     "pasteAndGo_nonURL",
 770     "https://example.com/?q=pasteAndGo_nonURL"
 771   );
 772   await setDefaultEngine("Google");
 773 });
 774
 775 async function doPasteAndGoTest(searchString, expectedURL) {
 776   UrlbarProviderSearchTips.disableTipsForCurrentSession = false;
 777   let tab = await BrowserTestUtils.openNewForegroundTab({
 778     gBrowser,
 779     url: "about:newtab",
 780     waitForLoad: false,
 781   });
 782   await checkTip(window, UrlbarProviderSearchTips.TIP_TYPE.ONBOARD, false);
 783
 784   await SimpleTest.promiseClipboardChange(searchString, () => {
 785     clipboardHelper.copyString(searchString);
 786   });
 787
 788   let textBox = gURLBar.querySelector("moz-input-box");
 789   let cxmenu = textBox.menupopup;
 790   let cxmenuPromise = BrowserTestUtils.waitForEvent(cxmenu, "popupshown");
 791   EventUtils.synthesizeMouseAtCenter(gURLBar.inputField, {
 792     type: "contextmenu",
 793     button: 2,
 794   });
 795   await cxmenuPromise;
 796   let menuitem = textBox.getMenuItem("paste-and-go");
 797
 798   let browserLoadedPromise = BrowserTestUtils.browserLoaded(
 799     gBrowser.selectedBrowser,
 800     false,
 801     expectedURL
 802   );
 803   cxmenu.activateItem(menuitem);
 804   await browserLoadedPromise;
 805   BrowserTestUtils.removeTab(tab);
 806   resetSearchTipsProvider();
 807 }
 808
 809 // Since we coupled the logic that decides whether to show the tip with our
 810 // gURLBar.search call, we should make sure search isn't called when
 811 // the conditions for a tip are met but the provider is disabled.
 812 add_task(async function noActionWhenDisabled() {
 813   await setDefaultEngine("Bing");
 814   await withDNSRedirect("www.bing.com", "/", async url => {
 815     await checkTab(window, url, UrlbarProviderSearchTips.TIP_TYPE.REDIRECT);
 816   });
 817
 818   await SpecialPowers.pushPrefEnv({
 819     set: [
 820       [
 821         "browser.newtabpage.activity-stream.asrouter.userprefs.cfr.features",
 822         false,
 823       ],
 824     ],
 825   });
 826
 827   await withDNSRedirect("www.bing.com", "/", async url => {
 828     Assert.ok(
 829       !UrlbarTestUtils.isPopupOpen(window),
 830       "The UrlbarView should not be open."
 831     );
 832   });
 833
 834   await SpecialPowers.popPrefEnv();
 835 });