tor-browser

test_PreferencesBackupResource_searchEngines.js (8564B)

---

/* Any copyright is dedicated to the Public Domain.
https://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

const { PreferencesBackupResource } = ChromeUtils.importESModule(
 "resource:///modules/backup/PreferencesBackupResource.sys.mjs"
);
const { SearchTestUtils } = ChromeUtils.importESModule(
 "resource://testing-common/SearchTestUtils.sys.mjs"
);
const { SearchUtils } = ChromeUtils.importESModule(
 "moz-src:///toolkit/components/search/SearchUtils.sys.mjs"
);
const { updateAppInfo } = ChromeUtils.importESModule(
 "resource://testing-common/AppInfo.sys.mjs"
);

const SEARCH_PREFS_FILENAME = "search.json.mozlz4";

SearchTestUtils.init(this);

updateAppInfo({ name: "XPCShell", version: "48", platformVersion: "48" });
do_get_profile();

const FAKE_SEARCH_EXTENSION_NAME = "Some WebExtension Search Engine";
const FAKE_PRIVATE_SEARCH_EXTENSION_NAME =
 "Some Private WebExtension Search Engine";

add_setup(async function () {
 Services.prefs.setBoolPref("browser.search.separatePrivateDefault", true);
 Services.prefs.setBoolPref(
   "browser.search.separatePrivateDefault.ui.enabled",
   true
 );

 await SearchTestUtils.setRemoteSettingsConfig([
   { identifier: "engine1" },
   { identifier: "engine2" },
 ]);

 Services.prefs.setCharPref(SearchUtils.BROWSER_SEARCH_PREF + "region", "US");
 Services.locale.availableLocales = ["en-US"];
 Services.locale.requestedLocales = ["en-US"];

 await Services.search.init();

 await SearchTestUtils.installSearchExtension(
   {
     name: FAKE_SEARCH_EXTENSION_NAME,
     search_url: "https://example.com/plain",
   },
   { setAsDefault: true }
 );

 await SearchTestUtils.installSearchExtension(
   {
     name: FAKE_PRIVATE_SEARCH_EXTENSION_NAME,
     search_url: "https://example.com/",
     search_url_get_params: "private={searchTerms}",
   },
   { setAsDefaultPrivate: true }
 );

 await SearchTestUtils.promiseSearchNotification(
   "write-settings-to-disk-complete"
 );
});

/**
* Tests that PreferencesBackupResource will correctly recompute search engine
* verification hashes after a recovery. This is more of an integration test
* than what already exists in test_PreferencesBackupResource.js.
*/
add_task(async function test_recover_searchEngines_verified() {
 let preferencesBackupResource = new PreferencesBackupResource();
 let recoveryPath = await IOUtils.createUniqueDirectory(
   PathUtils.tempDir,
   "PreferencesBackupResource-recovery-test"
 );
 let destProfilePath = await IOUtils.createUniqueDirectory(
   PathUtils.tempDir,
   "PreferencesBackupResource-test-profile"
 );

 await IOUtils.copy(
   PathUtils.join(PathUtils.profileDir, SEARCH_PREFS_FILENAME),
   PathUtils.join(recoveryPath, SEARCH_PREFS_FILENAME)
 );

 let postRecoveryEntry = await preferencesBackupResource.recover(
   { profilePath: PathUtils.profileDir },
   recoveryPath,
   destProfilePath
 );

 Assert.equal(
   postRecoveryEntry,
   null,
   "PreferencesBackupResource.recover should return null as its post recovery entry"
 );

 let originalSearchEngineSettings = await IOUtils.readJSON(
   PathUtils.join(PathUtils.profileDir, SEARCH_PREFS_FILENAME),
   { decompress: true }
 );

 let recoveredSearchEngineSettings = await IOUtils.readJSON(
   PathUtils.join(destProfilePath, SEARCH_PREFS_FILENAME),
   { decompress: true }
 );

 Assert.notEqual(
   originalSearchEngineSettings.metaData.defaultEngineIdHash,
   recoveredSearchEngineSettings.metaData.defaultEngineIdHash,
   "defaultEngineIdHash was updated."
 );
 Assert.equal(
   recoveredSearchEngineSettings.metaData.defaultEngineIdHash,
   SearchUtils.getVerificationHash(
     originalSearchEngineSettings.metaData.defaultEngineId,
     destProfilePath
   ),
   "defaultEngineIdHash was updated correctly."
 );

 Assert.notEqual(
   originalSearchEngineSettings.metaData.privateDefaultEngineIdHash,
   recoveredSearchEngineSettings.metaData.privateDefaultEngineIdHash,
   "privateDefaultEngineIdHash was updated."
 );
 Assert.equal(
   recoveredSearchEngineSettings.metaData.privateDefaultEngineIdHash,
   SearchUtils.getVerificationHash(
     originalSearchEngineSettings.metaData.privateDefaultEngineId,
     destProfilePath
   ),
   "privateDefaultEngineIdHash was updated correctly."
 );

 Assert.equal(
   originalSearchEngineSettings.engines.length,
   recoveredSearchEngineSettings.engines.length,
   "Got the same number of engines"
 );

 for (let i = 0; i < originalSearchEngineSettings.engines.length; ++i) {
   let originalEngine = originalSearchEngineSettings.engines[i];
   let recoveredEngine = recoveredSearchEngineSettings.engines[i];

   if (originalEngine._metaData.loadPathHash) {
     Assert.ok(
       recoveredEngine._metaData.loadPathHash,
       "Recovered engine also has a loadPathHash"
     );
     Assert.notEqual(
       originalEngine._metaData.loadPathHash,
       recoveredEngine._metaData.loadPathHash,
       "loadPathHash was updated."
     );
     Assert.equal(
       recoveredEngine._metaData.loadPathHash,
       SearchUtils.getVerificationHash(
         originalEngine._loadPath,
         destProfilePath
       ),
       "loadPathHash had the expected value."
     );
   } else {
     Assert.deepEqual(
       originalEngine,
       recoveredEngine,
       "Engine was not changed."
     );
   }
 }

 await maybeRemovePath(recoveryPath);
 await maybeRemovePath(destProfilePath);
});

/**
* Tests that PreferencesBackupResource will not update the verification hashes
* for any search engines that fail to verify for the original path.
*/
add_task(async function test_recover_searchEngines_unverified() {
 let preferencesBackupResource = new PreferencesBackupResource();
 let recoveryPath = await IOUtils.createUniqueDirectory(
   PathUtils.tempDir,
   "PreferencesBackupResource-recovery-test"
 );
 let destProfilePath = await IOUtils.createUniqueDirectory(
   PathUtils.tempDir,
   "PreferencesBackupResource-test-profile"
 );

 // Now let's read in the original search preferences file and break some
 // of the verification hashes...
 let searchEngineSettings = await IOUtils.readJSON(
   PathUtils.join(PathUtils.profileDir, SEARCH_PREFS_FILENAME),
   { decompress: true }
 );

 const BOGUS_HASH = "bogus hash!";

 searchEngineSettings.metaData.defaultEngineIdHash = BOGUS_HASH;
 searchEngineSettings.metaData.privateDefaultEngineIdHash = BOGUS_HASH;

 for (let engine of searchEngineSettings.engines) {
   if (engine._metaData.loadPathHash) {
     engine._metaData.loadPathHash = BOGUS_HASH;
   }
 }

 // And now let us write this data out to the recovery path.
 await IOUtils.writeJSON(
   PathUtils.join(recoveryPath, SEARCH_PREFS_FILENAME),
   searchEngineSettings,
   {
     compress: true,
   }
 );

 let postRecoveryEntry = await preferencesBackupResource.recover(
   { profilePath: PathUtils.profileDir },
   recoveryPath,
   destProfilePath
 );

 Assert.equal(
   postRecoveryEntry,
   null,
   "PreferencesBackupResource.recover should return null as its post recovery entry"
 );

 // And now let us write this data out to the recovery path.
 let recoveredSearchEngineSettings = await IOUtils.readJSON(
   PathUtils.join(destProfilePath, SEARCH_PREFS_FILENAME),
   {
     decompress: true,
   }
 );

 Assert.equal(
   recoveredSearchEngineSettings.metaData.defaultEngineIdHash,
   BOGUS_HASH,
   "Bogus defaultEngineIdHash was not changed."
 );

 Assert.equal(
   recoveredSearchEngineSettings.metaData.privateDefaultEngineIdHash,
   BOGUS_HASH,
   "Bogus privateDefaultEngineIdHash was not changed."
 );

 Assert.equal(
   searchEngineSettings.engines.length,
   recoveredSearchEngineSettings.engines.length,
   "Got the same number of engines"
 );

 for (let i = 0; i < searchEngineSettings.engines.length; ++i) {
   let originalEngine = searchEngineSettings.engines[i];
   let recoveredEngine = recoveredSearchEngineSettings.engines[i];

   if (originalEngine._metaData.loadPathHash) {
     Assert.ok(
       recoveredEngine._metaData.loadPathHash,
       "Recovered engine also has a loadPathHash"
     );
     Assert.equal(
       recoveredEngine._metaData.loadPathHash,
       BOGUS_HASH,
       "Bogus loadPathHash was not changed."
     );
   } else {
     Assert.deepEqual(
       originalEngine,
       recoveredEngine,
       "Engine was not changed."
     );
   }
 }

 await maybeRemovePath(recoveryPath);
 await maybeRemovePath(destProfilePath);
});