Move WebExtensions enabled Add-ons Manager

1 files changed, 698 insertions, 0 deletions

diff --git a/toolkit/mozapps/webextensions/test/browser/browser_searching.js b/toolkit/mozapps/webextensions/test/browser/browser_searching.js
new file mode 100644
index 000000000..907d9b105
--- /dev/null
+++ b/toolkit/mozapps/webextensions/test/browser/browser_searching.js
@@ -0,0 +1,698 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+// Tests that searching for add-ons works correctly
+
+const PREF_GETADDONS_GETSEARCHRESULTS = "extensions.getAddons.search.url";
+const SEARCH_URL = TESTROOT + "browser_searching.xml";
+const NO_MATCH_URL = TESTROOT + "browser_searching_empty.xml";
+
+const QUERY = "SEARCH";
+const NO_MATCH_QUERY = "NOMATCHQUERY";
+const REMOTE_TO_INSTALL = "remote1";
+const REMOTE_INSTALL_URL = TESTROOT + "addons/browser_searching.xpi";
+
+var gManagerWindow;
+var gCategoryUtilities;
+var gProvider;
+var gServer;
+var gAddonInstalled = false;
+
+function test() {
+  requestLongerTimeout(2);
+  // Turn on searching for this test
+  Services.prefs.setIntPref(PREF_SEARCH_MAXRESULTS, 15);
+  Services.prefs.setBoolPref(PREF_STRICT_COMPAT, true);
+
+  waitForExplicitFinish();
+
+  gProvider = new MockProvider();
+
+  gProvider.createAddons([{
+    id: "addon1@tests.mozilla.org",
+    name: "PASS - f",
+    description: "Test description - SEARCH",
+    size: 3,
+    version: "1.0",
+    updateDate: new Date(2010, 4, 2, 0, 0, 1)
+  }, {
+    id: "fail-addon1@tests.mozilla.org",
+    name: "FAIL",
+    description: "Does not match query"
+  }, {
+    id: "addon2@tests.mozilla.org",
+    name: "PASS - c",
+    description: "Test description - reSEARCHing SEARCH SEARCH",
+    size: 6,
+    version: "2.0",
+    updateDate: new Date(2010, 4, 2, 0, 0, 0)
+  }]);
+
+  var installs = gProvider.createInstalls([{
+    name: "PASS - a - SEARCHing",
+    sourceURI: "http://example.com/install1.xpi"
+  }, {
+    name: "PASS - g - reSEARCHing SEARCH",
+    sourceURI: "http://example.com/install2.xpi"
+  }, {
+    // Does not match query
+    name: "FAIL",
+    sourceURI: "http://example.com/fail-install1.xpi"
+  }]);
+
+  for (let install of installs )
+    install.install();
+
+  open_manager("addons://list/extension", function(aWindow) {
+    gManagerWindow = aWindow;
+    gCategoryUtilities = new CategoryUtilities(gManagerWindow);
+    run_next_test();
+  });
+}
+
+function end_test() {
+  close_manager(gManagerWindow, function() {
+    var installedAddon = get_addon_item(REMOTE_TO_INSTALL).mAddon;
+    installedAddon.uninstall();
+
+    AddonManager.getAllInstalls(function(aInstallsList) {
+      for (var install of aInstallsList) {
+        var sourceURI = install.sourceURI.spec;
+        if (sourceURI == REMOTE_INSTALL_URL ||
+            sourceURI.match(/^http:\/\/example\.com\/(.+)\.xpi$/) != null)
+          install.cancel();
+      }
+
+      finish();
+    });
+  });
+}
+
+function getAnonymousElementByAttribute(aElement, aName, aValue) {
+  return gManagerWindow.document.getAnonymousElementByAttribute(aElement,
+                                                                aName,
+                                                                aValue);
+}
+
+/*
+ * Checks whether or not the Add-ons Manager is currently searching
+ *
+ * @param  aExpectedSearching
+ *         The expected isSearching state
+ */
+function check_is_searching(aExpectedSearching) {
+  var loading = gManagerWindow.document.getElementById("search-loading");
+  is(!is_hidden(loading), aExpectedSearching,
+     "Search throbber should be showing iff currently searching");
+}
+
+/*
+ * Completes a search
+ *
+ * @param  aQuery
+ *         The query to search for
+ * @param  aFinishImmediately
+ *         Boolean representing whether or not the search is expected to
+ *         finish immediately
+ * @param  aCallback
+ *         The callback to call when the search is done
+ * @param  aCategoryType
+ *         The expected selected category after the search is done.
+ *         Optional and defaults to "search"
+ */
+function search(aQuery, aFinishImmediately, aCallback, aCategoryType) {
+  // Point search to the correct xml test file
+  var url = (aQuery == NO_MATCH_QUERY) ? NO_MATCH_URL : SEARCH_URL;
+  Services.prefs.setCharPref(PREF_GETADDONS_GETSEARCHRESULTS, url);
+
+  aCategoryType = aCategoryType ? aCategoryType : "search";
+
+  var searchBox = gManagerWindow.document.getElementById("header-search");
+  searchBox.value = aQuery;
+
+  EventUtils.synthesizeMouseAtCenter(searchBox, { }, gManagerWindow);
+  EventUtils.synthesizeKey("VK_RETURN", { }, gManagerWindow);
+
+  var finishImmediately = true;
+  wait_for_view_load(gManagerWindow, function() {
+    is(gCategoryUtilities.selectedCategory, aCategoryType, "Expected category view should be selected");
+    is(gCategoryUtilities.isTypeVisible("search"), aCategoryType == "search",
+       "Search category should only be visible if it is the current view");
+    check_is_searching(false);
+    is(finishImmediately, aFinishImmediately, "Search should finish immediately only if expected");
+
+    aCallback();
+  });
+
+  finishImmediately = false
+  if (!aFinishImmediately)
+    check_is_searching(true);
+}
+
+/*
+ * Return results of a search
+ *
+ * @return Array of objects, each containing the name and item of a specific
+ *         result
+ */
+function get_actual_results() {
+  var list = gManagerWindow.document.getElementById("search-list");
+  var rows = list.getElementsByTagName("richlistitem");
+
+  var results = [];
+  for (var item of rows) {
+
+    // Only consider items that are currently showing
+    var style = gManagerWindow.document.defaultView.getComputedStyle(item, "");
+    if (style.display == "none" || style.visibility != "visible")
+      continue;
+
+    if (item.mInstall || item.isPending("install")) {
+      var sourceURI = item.mInstall.sourceURI.spec;
+      if (sourceURI == REMOTE_INSTALL_URL) {
+        results.push({name: REMOTE_TO_INSTALL, item: item});
+        continue;
+      }
+
+      let result = sourceURI.match(/^http:\/\/example\.com\/(.+)\.xpi$/);
+      if (result != null) {
+        is(item.mInstall.name.indexOf("PASS"), 0, "Install name should start with PASS");
+        results.push({name: result[1], item: item});
+        continue;
+      }
+    }
+    else if (item.mAddon) {
+      let result = item.mAddon.id.match(/^(.+)@tests\.mozilla\.org$/);
+      if (result != null) {
+        is(item.mAddon.name.indexOf("PASS"), 0, "Addon name should start with PASS");
+        results.push({name: result[1], item: item});
+        continue;
+      }
+    }
+    else {
+      ok(false, "Found an item in the list that was neither installing or installed");
+    }
+  }
+
+  return results;
+}
+
+/*
+ * Returns expected results when searching for QUERY with default ordering
+ *
+ * @param  aSortBy
+ *         How the results are sorted (e.g. "name")
+ * @param  aLocalExpected
+ *         Boolean representing if local results are expected
+ * @return A pair: [array of results with an expected order,
+ *                  array of results with unknown order]
+ */
+function get_expected_results(aSortBy, aLocalExpected) {
+  var expectedOrder = null, unknownOrder = null;
+  switch (aSortBy) {
+    case "relevancescore":
+      expectedOrder = [ "addon2", "remote1", "install2", "addon1",
+                        "install1", "remote2", "remote3", "remote4" ];
+      unknownOrder = [];
+      break;
+    case "name":
+      // Defaults to ascending order
+      expectedOrder = [ "install1", "remote1",  "addon2", "remote2",
+                        "remote3", "addon1", "install2", "remote4" ];
+      unknownOrder = [];
+      break;
+    case "dateUpdated":
+      expectedOrder = [ "addon1", "addon2" ];
+      // Updated date not available for installs and remote add-ons
+      unknownOrder = [ "install1", "install2", "remote1",
+                       "remote2", "remote3", "remote4" ];
+      break;
+    default:
+      ok(false, "Should recognize sortBy when checking the order of items");
+  }
+
+  // Only keep expected results
+  function filterResults(aId) {
+    // Include REMOTE_TO_INSTALL as a local add-on if it has been installed
+    if (gAddonInstalled && aId == REMOTE_TO_INSTALL)
+      return aLocalExpected;
+
+    if (aId.indexOf("addon") == 0 || aId.indexOf("install") == 0)
+      return aLocalExpected;
+    if (aId.indexOf("remote") == 0)
+      return !aLocalExpected;
+
+    return false;
+  }
+
+
+  return [expectedOrder.filter(filterResults),
+          unknownOrder.filter(filterResults)]
+}
+
+/*
+ * Check that the actual and expected results are the same
+ *
+ * @param  aQuery
+ *         The search query used
+ * @param  aSortBy
+ *         How the results are sorted (e.g. "name")
+ * @param  aReverseOrder
+ *         Boolean representing if the results are in reverse default order
+ * @param  aShowLocal
+ *         Boolean representing if local results are being shown
+ */
+function check_results(aQuery, aSortBy, aReverseOrder, aShowLocal) {
+
+  var xpinstall_enabled = true;
+  try {
+    xpinstall_enabled = Services.prefs.getBoolPref(PREF_XPI_ENABLED);
+  }
+  catch (e) {}
+
+  // When XPI Instalation is disabled, those buttons are hidden and unused
+  if (xpinstall_enabled) {
+    var localFilterSelected = gManagerWindow.document.getElementById("search-filter-local").selected;
+    var remoteFilterSelected = gManagerWindow.document.getElementById("search-filter-remote").selected;
+    is(localFilterSelected, aShowLocal, "Local filter should be selected if showing local items");
+    is(remoteFilterSelected, !aShowLocal, "Remote filter should be selected if showing remote items");
+  }
+
+  // Get expected order assuming default order
+  var expectedOrder = [], unknownOrder = [];
+  if (aQuery == QUERY)
+    [expectedOrder, unknownOrder] = get_expected_results(aSortBy, aShowLocal);
+
+  // Get actual order of results
+  var actualResults = get_actual_results();
+  var actualOrder = actualResults.map(result => result.name);
+
+  // Reverse array of actual results if supposed to be in reverse order.
+  // Reverse actualOrder instead of expectedOrder so can always check
+  // expectedOrder before unknownOrder
+  if (aReverseOrder)
+    actualOrder.reverse();
+
+  // Check actual vs. expected list of results
+  var totalExpectedResults = expectedOrder.length + unknownOrder.length;
+  is(actualOrder.length, totalExpectedResults, "Should get correct number of results");
+
+  // Check the "first" and "last" attributes are set correctly
+  for (let i = 0; i < actualResults.length; i++) {
+    if (i == 0) {
+      is(actualResults[0].item.hasAttribute("first"), true,
+         "First item should have 'first' attribute set");
+      is(actualResults[0].item.hasAttribute("last"), false,
+         "First item should not have 'last' attribute set");
+    } else if (i == (actualResults.length - 1)) {
+      is(actualResults[actualResults.length - 1].item.hasAttribute("first"), false,
+         "Last item should not have 'first' attribute set");
+      is(actualResults[actualResults.length - 1].item.hasAttribute("last"), true,
+         "Last item should have 'last' attribute set");
+    } else {
+      is(actualResults[i].item.hasAttribute("first"), false,
+         "Item " + i + " should not have 'first' attribute set");
+      is(actualResults[i].item.hasAttribute("last"), false,
+         "Item " + i + " should not have 'last' attribute set");
+    }
+  }
+
+  var i = 0;
+  for (; i < expectedOrder.length; i++)
+    is(actualOrder[i], expectedOrder[i], "Should have seen expected item");
+
+  // Items with data that is unknown can appear in any order among themselves,
+  // so just check that these items exist
+  for (; i < actualOrder.length; i++) {
+    var unknownOrderIndex = unknownOrder.indexOf(actualOrder[i]);
+    ok(unknownOrderIndex >= 0, "Should expect to see item with data that is unknown");
+    unknownOrder[unknownOrderIndex] = null;
+  }
+
+  // Check status of empty notice
+  var emptyNotice = gManagerWindow.document.getElementById("search-list-empty");
+  is(emptyNotice.hidden, totalExpectedResults > 0,
+     "Empty notice should be hidden only if expecting shown items");
+}
+
+/*
+ * Check results of a search with different filterings
+ *
+ * @param  aQuery
+ *         The search query used
+ * @param  aSortBy
+ *         How the results are sorted (e.g. "name")
+ * @param  aReverseOrder
+ *         Boolean representing if the results are in reverse default order
+ * @param  aLocalOnly
+ *         Boolean representing if the results are local only, can be undefined
+ */
+function check_filtered_results(aQuery, aSortBy, aReverseOrder, aLocalOnly) {
+  var localFilter = gManagerWindow.document.getElementById("search-filter-local");
+  var remoteFilter = gManagerWindow.document.getElementById("search-filter-remote");
+
+  var list = gManagerWindow.document.getElementById("search-list");
+  list.ensureElementIsVisible(localFilter);
+
+  // Check with showing local add-ons
+  EventUtils.synthesizeMouseAtCenter(localFilter, { }, gManagerWindow);
+  check_results(aQuery, aSortBy, aReverseOrder, true);
+
+  // Check with showing remote add-ons
+  aLocalOnly = aLocalOnly || false;
+  EventUtils.synthesizeMouseAtCenter(remoteFilter, { }, gManagerWindow);
+  check_results(aQuery, aSortBy, aReverseOrder, aLocalOnly);
+}
+
+/*
+ * Get item for a specific add-on by name
+ *
+ * @param  aName
+ *         The name of the add-on to search for
+ * @return Row of add-on if found, null otherwise
+ */
+function get_addon_item(aName) {
+  var id = aName + "@tests.mozilla.org";
+  var list = gManagerWindow.document.getElementById("search-list");
+  var rows = list.getElementsByTagName("richlistitem");
+  for (var row of rows) {
+    if (row.mAddon && row.mAddon.id == id)
+      return row;
+  }
+
+  return null;
+}
+
+/*
+ * Get item for a specific install by name
+ *
+ * @param  aName
+ *         The name of the install to search for
+ * @return Row of install if found, null otherwise
+ */
+function get_install_item(aName) {
+  var sourceURI = "http://example.com/" + aName + ".xpi";
+  var list = gManagerWindow.document.getElementById("search-list");
+  var rows = list.getElementsByTagName("richlistitem");
+  for (var row of rows) {
+    if (row.mInstall && row.mInstall.sourceURI.spec == sourceURI)
+      return row;
+  }
+
+  return null;
+}
+
+/*
+ * Gets the install button for a specific item
+ *
+ * @param  aItem
+ *         The item to get the install button for
+ * @return The install button for aItem
+ */
+function get_install_button(aItem) {
+  isnot(aItem, null, "Item should not be null when checking state of install button");
+  var installStatus = getAnonymousElementByAttribute(aItem, "anonid", "install-status");
+  return getAnonymousElementByAttribute(installStatus, "anonid", "install-remote-btn");
+}
+
+
+// Tests that searching for the empty string does nothing when not in the search view
+add_test(function() {
+  is(gCategoryUtilities.isTypeVisible("search"), false, "Search category should initially be hidden");
+
+  var selectedCategory = gCategoryUtilities.selectedCategory;
+  isnot(selectedCategory, "search", "Selected type should not initially be the search view");
+  search("", true, run_next_test, selectedCategory);
+});
+
+// Tests that the results from a query are sorted by relevancescore in descending order.
+// Also test that double clicking non-install items goes to the detail view, and that
+// only remote items have install buttons showing
+add_test(function() {
+  search(QUERY, false, function() {
+    check_filtered_results(QUERY, "relevancescore", false);
+
+    var list = gManagerWindow.document.getElementById("search-list");
+    var results = get_actual_results();
+    for (var result of results) {
+      var installBtn = get_install_button(result.item);
+      is(installBtn.hidden, result.name.indexOf("remote") != 0,
+         "Install button should only be showing for remote items");
+    }
+
+    var currentIndex = -1;
+    function run_next_double_click_test() {
+      currentIndex++;
+      if (currentIndex >= results.length) {
+        run_next_test();
+        return;
+      }
+
+      var result = results[currentIndex];
+      if (result.name.indexOf("install") == 0) {
+        run_next_double_click_test();
+        return;
+      }
+
+      var item = result.item;
+      list.ensureElementIsVisible(item);
+      EventUtils.synthesizeMouseAtCenter(item, { clickCount: 1 }, gManagerWindow);
+      EventUtils.synthesizeMouseAtCenter(item, { clickCount: 2 }, gManagerWindow);
+      wait_for_view_load(gManagerWindow, function() {
+        var name = gManagerWindow.document.getElementById("detail-name").textContent;
+        is(name, item.mAddon.name, "Name in detail view should be correct");
+        var version = gManagerWindow.document.getElementById("detail-version").value;
+        is(version, item.mAddon.version, "Version in detail view should be correct");
+
+        EventUtils.synthesizeMouseAtCenter(gManagerWindow.document.getElementById("category-search"),
+                                           { }, gManagerWindow);
+        wait_for_view_load(gManagerWindow, run_next_double_click_test);
+      });
+    }
+
+    run_next_double_click_test();
+  });
+});
+
+// Tests that the sorters and filters correctly manipulate the results
+add_test(function() {
+  var sorters = gManagerWindow.document.getElementById("search-sorters");
+  var originalHandler = sorters.handler;
+
+  var sorterNames = ["name", "dateUpdated"];
+  var buttonIds = ["name-btn", "date-btn"];
+  var currentIndex = 0;
+  var currentReversed = false;
+
+  function run_sort_test() {
+    if (currentIndex >= sorterNames.length) {
+      sorters.handler = originalHandler;
+      run_next_test();
+      return;
+    }
+
+    // Simulate clicking on a specific sorter
+    var buttonId = buttonIds[currentIndex];
+    var sorter = getAnonymousElementByAttribute(sorters, "anonid", buttonId);
+    is_element_visible(sorter);
+    EventUtils.synthesizeMouseAtCenter(sorter, { }, gManagerWindow);
+  }
+
+  sorters.handler = {
+    onSortChanged: function(aSortBy, aAscending) {
+      if (originalHandler && "onSortChanged" in originalHandler)
+        originalHandler.onSortChanged(aSortBy, aAscending);
+
+      check_filtered_results(QUERY, sorterNames[currentIndex], currentReversed);
+
+      if (currentReversed)
+        currentIndex++;
+      currentReversed = !currentReversed;
+
+      run_sort_test();
+    }
+  };
+
+  check_filtered_results(QUERY, "relevancescore", false);
+  run_sort_test();
+});
+
+// Tests that searching for the empty string does nothing when in search view
+add_test(function() {
+  search("", true, function() {
+    check_filtered_results(QUERY, "dateUpdated", true);
+    run_next_test();
+  });
+});
+
+// Tests that clicking a different category hides the search query
+add_test(function() {
+  gCategoryUtilities.openType("extension", function() {
+    is(gCategoryUtilities.isTypeVisible("search"), false, "Search category should be hidden");
+    is(gCategoryUtilities.selectedCategory, "extension", "View should have changed to extension");
+    run_next_test();
+  });
+});
+
+// Tests that re-searching for query doesn't actually complete a new search,
+// and the last sort is still used
+add_test(function() {
+  search(QUERY, true, function() {
+    check_filtered_results(QUERY, "dateUpdated", true);
+    run_next_test();
+  });
+});
+
+// Tests that getting zero results works correctly
+add_test(function() {
+  search(NO_MATCH_QUERY, false, function() {
+    check_filtered_results(NO_MATCH_QUERY, "relevancescore", false);
+    run_next_test();
+  });
+});
+
+// Tests that installing a remote add-on works
+add_test(function() {
+  var installBtn = null;
+
+  var listener = {
+    onInstallEnded: function(aInstall, aAddon) {
+      // Don't immediately consider the installed add-on as local because
+      // if the user was filtering out local add-ons, the installed add-on
+      // would vanish. Only consider add-on as local on new searches.
+
+      aInstall.removeListener(this);
+
+      is(installBtn.hidden, true, "Install button should be hidden after install ended");
+      check_filtered_results(QUERY, "relevancescore", false);
+      run_next_test();
+    }
+  }
+
+  search(QUERY, false, function() {
+    var list = gManagerWindow.document.getElementById("search-list");
+    var remoteItem = get_addon_item(REMOTE_TO_INSTALL);
+    list.ensureElementIsVisible(remoteItem);
+
+    installBtn = get_install_button(remoteItem);
+    is(installBtn.hidden, false, "Install button should be showing before install");
+    remoteItem.mAddon.install.addListener(listener);
+    EventUtils.synthesizeMouseAtCenter(installBtn, { }, gManagerWindow);
+  });
+});
+
+// Tests that re-searching for query results in correct results
+add_test(function() {
+  // Select a different category
+  gCategoryUtilities.openType("extension", function() {
+    is(gCategoryUtilities.isTypeVisible("search"), false, "Search category should be hidden");
+    is(gCategoryUtilities.selectedCategory, "extension", "View should have changed to extension");
+
+    var installBtn = get_install_button(get_addon_item(REMOTE_TO_INSTALL));
+    is(installBtn.hidden, true, "Install button should be hidden for installed item");
+
+    search(QUERY, true, function() {
+      check_filtered_results(QUERY, "relevancescore", false);
+      run_next_test();
+    });
+  });
+});
+
+// Tests that incompatible add-ons are shown with a warning if compatibility checking is disabled
+add_test(function() {
+  AddonManager.checkCompatibility = false;
+  search("incompatible", false, function() {
+    var item = get_addon_item("remote5");
+    is_element_visible(item, "Incompatible addon should be visible");
+    is(item.getAttribute("notification"), "warning", "Compatibility warning should be shown");
+
+    item = get_addon_item("remote6");
+    is(item, null, "Addon incompatible with the product should not be visible");
+
+    AddonManager.checkCompatibility = true;
+    run_next_test();
+  });
+});
+
+// Tests that compatible-by-default addons are shown if strict compatibility checking is disabled
+add_test(function() {
+  restart_manager(gManagerWindow, "addons://list/extension", function(aWindow) {
+    gManagerWindow = aWindow;
+    gCategoryUtilities = new CategoryUtilities(gManagerWindow);
+
+    Services.prefs.setBoolPref(PREF_STRICT_COMPAT, false);
+    search("incompatible", false, function() {
+      var item = get_addon_item("remote5");
+      is_element_visible(item, "Incompatible addon should be visible");
+      isnot(item.getAttribute("notification"), "warning", "Compatibility warning should not be shown");
+
+      item = get_addon_item("remote6");
+      is(item, null, "Addon incompatible with the product should not be visible");
+
+      Services.prefs.setBoolPref(PREF_STRICT_COMPAT, true);
+      run_next_test();
+    });
+  });
+});
+
+
+// Tests that restarting the manager doesn't change search results
+add_test(function() {
+  restart_manager(gManagerWindow, null, function(aWindow) {
+    gManagerWindow = aWindow;
+    gCategoryUtilities = new CategoryUtilities(gManagerWindow);
+
+    // We never restore to the search pane
+    is(gCategoryUtilities.selectedCategory, "discover", "View should have changed to discover");
+
+    // Installed add-on is considered local on new search
+    gAddonInstalled = true;
+
+    // Switch over to extensions list so we can do a new search
+    gCategoryUtilities.openType("extension", function() {
+      search(QUERY, false, function() {
+        check_filtered_results(QUERY, "relevancescore", false);
+
+        var installBtn = get_install_button(get_addon_item(REMOTE_TO_INSTALL));
+        is(installBtn.hidden, true, "Install button should be hidden for installed item");
+
+        run_next_test();
+      });
+    });
+  });
+});
+
+function bug_815120_test_search(aLocalOnly) {
+  restart_manager(gManagerWindow, "addons://list/extension", function(aWindow) {
+    gManagerWindow = aWindow;
+    gCategoryUtilities = new CategoryUtilities(gManagerWindow);
+
+    // Installed add-on is considered local on new search
+    gAddonInstalled = true;
+
+    // The search buttons should be hidden in the LocalOnly setup
+    var localFilterButton = aWindow.document.getElementById("search-filter-local");
+    is(aLocalOnly, is_hidden(localFilterButton), "Local filter button visibility does not match, aLocalOnly = " + aLocalOnly);
+
+    var remoteFilterButton = aWindow.document.getElementById("search-filter-remote");
+    is(aLocalOnly, is_hidden(remoteFilterButton), "Remote filter button visibility does not match, aLocalOnly = " + aLocalOnly);
+
+    search(QUERY, false, function() {
+      check_filtered_results(QUERY, "relevancescore", false, aLocalOnly);
+      run_next_test();
+    });
+  });
+}
+
+// Tests for Bug 815120
+add_test(function() {
+  Services.prefs.setBoolPref(PREF_XPI_ENABLED, false);
+  bug_815120_test_search(true);
+});
+
+add_test(function() {
+  Services.prefs.setBoolPref(PREF_XPI_ENABLED, true);
+  bug_815120_test_search(false);
+});
+