browser/components/preferences/tests/browser_localSearchShortcuts.js

   1 /* Any copyright is dedicated to the Public Domain.
   2  * http://creativecommons.org/publicdomain/zero/1.0/ */
   3
   4 /**
   5  * Checks the local shortcut rows in the engines list of the search pane.
   6  */
   7
   8 "use strict";
   9
  10 ChromeUtils.defineESModuleGetters(this, {
  11   UrlbarPrefs: "resource:///modules/UrlbarPrefs.sys.mjs",
  12   UrlbarUtils: "resource:///modules/UrlbarUtils.sys.mjs",
  13 });
  14
  15 let gTree;
  16
  17 add_setup(async function () {
  18   let prefs = await openPreferencesViaOpenPreferencesAPI("search", {
  19     leaveOpen: true,
  20   });
  21   registerCleanupFunction(() => {
  22     BrowserTestUtils.removeTab(gBrowser.selectedTab);
  23   });
  24
  25   Assert.equal(
  26     prefs.selectedPane,
  27     "paneSearch",
  28     "Sanity check: Search pane is selected by default"
  29   );
  30
  31   gTree = gBrowser.contentDocument.querySelector("#engineList");
  32   gTree.scrollIntoView();
  33   gTree.focus();
  34 });
  35
  36 // The rows should be visible and checked by default.
  37 add_task(async function visible() {
  38   await checkRowVisibility(true);
  39   await forEachLocalShortcutRow(async (row, shortcut) => {
  40     Assert.equal(
  41       gTree.view.getCellValue(row, gTree.columns.getNamedColumn("engineShown")),
  42       "true",
  43       "Row is checked initially"
  44     );
  45   });
  46 });
  47
  48 // Toggling the browser.urlbar.shortcuts.* prefs should toggle the corresponding
  49 // checkboxes in the rows.
  50 add_task(async function syncFromPrefs() {
  51   let col = gTree.columns.getNamedColumn("engineShown");
  52   await forEachLocalShortcutRow(async (row, shortcut) => {
  53     Assert.equal(
  54       gTree.view.getCellValue(row, col),
  55       "true",
  56       "Row is checked initially"
  57     );
  58     await SpecialPowers.pushPrefEnv({
  59       set: [[getUrlbarPrefName(shortcut.pref), false]],
  60     });
  61     Assert.equal(
  62       gTree.view.getCellValue(row, col),
  63       "false",
  64       "Row is unchecked after disabling pref"
  65     );
  66     await SpecialPowers.popPrefEnv();
  67     Assert.equal(
  68       gTree.view.getCellValue(row, col),
  69       "true",
  70       "Row is checked after re-enabling pref"
  71     );
  72   });
  73 });
  74
  75 // Pressing the space key while a row is selected should toggle its checkbox
  76 // and pref.
  77 add_task(async function syncToPrefs_spaceKey() {
  78   let col = gTree.columns.getNamedColumn("engineShown");
  79   await forEachLocalShortcutRow(async (row, shortcut) => {
  80     Assert.ok(
  81       UrlbarPrefs.get(shortcut.pref),
  82       "Sanity check: Pref is enabled initially"
  83     );
  84     Assert.equal(
  85       gTree.view.getCellValue(row, col),
  86       "true",
  87       "Row is checked initially"
  88     );
  89     gTree.view.selection.select(row);
  90     EventUtils.synthesizeKey(" ", {}, gTree.ownerGlobal);
  91     Assert.ok(
  92       !UrlbarPrefs.get(shortcut.pref),
  93       "Pref is disabled after pressing space key"
  94     );
  95     Assert.equal(
  96       gTree.view.getCellValue(row, col),
  97       "false",
  98       "Row is unchecked after pressing space key"
  99     );
 100     Services.prefs.clearUserPref(getUrlbarPrefName(shortcut.pref));
 101   });
 102 });
 103
 104 // Clicking the checkbox in a local shortcut row should toggle the checkbox and
 105 // pref.
 106 add_task(async function syncToPrefs_click() {
 107   let col = gTree.columns.getNamedColumn("engineShown");
 108   await forEachLocalShortcutRow(async (row, shortcut) => {
 109     Assert.ok(
 110       UrlbarPrefs.get(shortcut.pref),
 111       "Sanity check: Pref is enabled initially"
 112     );
 113     Assert.equal(
 114       gTree.view.getCellValue(row, col),
 115       "true",
 116       "Row is checked initially"
 117     );
 118
 119     let rect = gTree.getCoordsForCellItem(row, col, "cell");
 120     let x = rect.x + rect.width / 2;
 121     let y = rect.y + rect.height / 2;
 122     EventUtils.synthesizeMouse(gTree.body, x, y, {}, gTree.ownerGlobal);
 123
 124     Assert.ok(
 125       !UrlbarPrefs.get(shortcut.pref),
 126       "Pref is disabled after clicking checkbox"
 127     );
 128     Assert.equal(
 129       gTree.view.getCellValue(row, col),
 130       "false",
 131       "Row is unchecked after clicking checkbox"
 132     );
 133     Services.prefs.clearUserPref(getUrlbarPrefName(shortcut.pref));
 134   });
 135 });
 136
 137 // The keyword column should not be editable according to isEditable().
 138 add_task(async function keywordNotEditable_isEditable() {
 139   await forEachLocalShortcutRow(async (row, shortcut) => {
 140     Assert.ok(
 141       !gTree.view.isEditable(
 142         row,
 143         gTree.columns.getNamedColumn("engineKeyword")
 144       ),
 145       "Keyword column is not editable"
 146     );
 147   });
 148 });
 149
 150 // Pressing the enter key while a row is selected shouldn't allow the keyword to
 151 // be edited.
 152 add_task(async function keywordNotEditable_enterKey() {
 153   let col = gTree.columns.getNamedColumn("engineKeyword");
 154   await forEachLocalShortcutRow(async (row, shortcut) => {
 155     Assert.ok(
 156       shortcut.restrict,
 157       "Sanity check: Shortcut restriction char is non-empty"
 158     );
 159     Assert.equal(
 160       gTree.view.getCellText(row, col),
 161       shortcut.restrict,
 162       "Sanity check: Keyword column has correct restriction char initially"
 163     );
 164
 165     gTree.view.selection.select(row);
 166     EventUtils.synthesizeKey("KEY_Enter", {}, gTree.ownerGlobal);
 167     EventUtils.sendString("newkeyword");
 168     EventUtils.synthesizeKey("KEY_Enter", {}, gTree.ownerGlobal);
 169
 170     // Wait a moment to allow for any possible asynchronicity.
 171     // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
 172     await new Promise(r => setTimeout(r, 500));
 173
 174     Assert.equal(
 175       gTree.view.getCellText(row, col),
 176       shortcut.restrict,
 177       "Keyword column is still restriction char"
 178     );
 179   });
 180 });
 181
 182 // Double-clicking the keyword column shouldn't allow the keyword to be edited.
 183 add_task(async function keywordNotEditable_click() {
 184   let col = gTree.columns.getNamedColumn("engineKeyword");
 185   await forEachLocalShortcutRow(async (row, shortcut) => {
 186     Assert.ok(
 187       shortcut.restrict,
 188       "Sanity check: Shortcut restriction char is non-empty"
 189     );
 190     Assert.equal(
 191       gTree.view.getCellText(row, col),
 192       shortcut.restrict,
 193       "Sanity check: Keyword column has correct restriction char initially"
 194     );
 195
 196     let rect = gTree.getCoordsForCellItem(row, col, "text");
 197     let x = rect.x + rect.width / 2;
 198     let y = rect.y + rect.height / 2;
 199
 200     let promise = BrowserTestUtils.waitForEvent(gTree, "dblclick");
 201
 202     // Click once to select the row.
 203     EventUtils.synthesizeMouse(
 204       gTree.body,
 205       x,
 206       y,
 207       { clickCount: 1 },
 208       gTree.ownerGlobal
 209     );
 210
 211     // Now double-click the keyword column.
 212     EventUtils.synthesizeMouse(
 213       gTree.body,
 214       x,
 215       y,
 216       { clickCount: 2 },
 217       gTree.ownerGlobal
 218     );
 219
 220     await promise;
 221
 222     EventUtils.sendString("newkeyword");
 223     EventUtils.synthesizeKey("KEY_Enter", {}, gTree.ownerGlobal);
 224
 225     // Wait a moment to allow for any possible asynchronicity.
 226     // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
 227     await new Promise(r => setTimeout(r, 500));
 228
 229     Assert.equal(
 230       gTree.view.getCellText(row, col),
 231       shortcut.restrict,
 232       "Keyword column is still restriction char"
 233     );
 234   });
 235 });
 236
 237 /**
 238  * Asserts that the engine and local shortcut rows are present in the tree.
 239  */
 240 async function checkRowVisibility() {
 241   let engines = await Services.search.getVisibleEngines();
 242
 243   Assert.equal(
 244     gTree.view.rowCount,
 245     engines.length + UrlbarUtils.LOCAL_SEARCH_MODES.length,
 246     "Expected number of tree rows"
 247   );
 248
 249   // Check the engine rows.
 250   for (let row = 0; row < engines.length; row++) {
 251     let engine = engines[row];
 252     let text = gTree.view.getCellText(
 253       row,
 254       gTree.columns.getNamedColumn("engineName")
 255     );
 256     Assert.equal(
 257       text,
 258       engine.name,
 259       `Sanity check: Tree row ${row} has expected engine name`
 260     );
 261   }
 262
 263   // Check the shortcut rows.
 264   await forEachLocalShortcutRow(async (row, shortcut) => {
 265     let text = gTree.view.getCellText(
 266       row,
 267       gTree.columns.getNamedColumn("engineName")
 268     );
 269     let name = UrlbarUtils.getResultSourceName(shortcut.source);
 270     let l10nName = await gTree.ownerDocument.l10n.formatValue(
 271       `urlbar-search-mode-${name}`
 272     );
 273     Assert.ok(l10nName, "Sanity check: l10n name is non-empty");
 274     Assert.equal(text, l10nName, `Tree row ${row} has expected shortcut name`);
 275   });
 276 }
 277
 278 /**
 279  * Calls a callback for each local shortcut row in the tree.
 280  *
 281  * @param {function} callback
 282  *   Called for each local shortcut row like: callback(rowIndex, shortcutObject)
 283  */
 284 async function forEachLocalShortcutRow(callback) {
 285   let engines = await Services.search.getVisibleEngines();
 286   for (let i = 0; i < UrlbarUtils.LOCAL_SEARCH_MODES.length; i++) {
 287     let shortcut = UrlbarUtils.LOCAL_SEARCH_MODES[i];
 288     let row = engines.length + i;
 289     // These tests assume LOCAL_SEARCH_MODES are enabled, this can be removed
 290     // when we enable QuickActions. We cant just enable the pref in browser.ini
 291     // as this test calls clearUserPref.
 292     if (shortcut.pref == "shortcuts.quickactions") {
 293       continue;
 294     }
 295     await callback(row, shortcut);
 296   }
 297 }
 298
 299 /**
 300  * Prepends the `browser.urlbar.` branch to the given relative pref.
 301  *
 302  * @param {string} relativePref
 303  *   A pref name relative to the `browser.urlbar.`.
 304  * @returns {string}
 305  *   The full pref name with `browser.urlbar.` prepended.
 306  */
 307 function getUrlbarPrefName(relativePref) {
 308   return `browser.urlbar.${relativePref}`;
 309 }