test_stickyprefs.js

Enable keyboard shortcuts

/* Any copyright is dedicated to the Public Domain.

 * http://creativecommons.org/licenses/publicdomain/  */

const ps = Services.prefs;

// It is necessary to manually disable `xpc::IsInAutomation` since

// `resetPrefs` will flip the preference to re-enable `once`-synced

// preference change assertions, and also change the value of those

// preferences.

Services.prefs.setBoolPref(

  "security.turn_off_all_security_so_that_viruses_can_take_over_this_computer",

  false

);

// A little helper to reset the service and load one pref file.

function resetAndLoadDefaults() {

  ps.resetPrefs();

  ps.readDefaultPrefsFromFile(do_get_file("data/testPrefSticky.js"));

// A little helper to reset the service and load two pref files.

function resetAndLoadAll() {

  ps.resetPrefs();

  ps.readDefaultPrefsFromFile(do_get_file("data/testPrefSticky.js"));

  ps.readUserPrefsFromFile(do_get_file("data/testPrefStickyUser.js"));

// A little helper that saves the current state to a file in the profile

// dir, then resets the service and re-reads the file it just saved.

// Used to test what gets actually written - things the pref service decided

// not to write don't exist at all after this call.

function saveAndReload() {

  let file = do_get_profile();

  file.append("prefs.js");

  ps.savePrefFile(file);

  // Now reset the pref service and re-read what we saved.

  ps.resetPrefs();

  // Hack alert: on Windows nsLocalFile caches the size of savePrefFile from

  // the .create() call above as 0. We call .exists() to reset the cache.

  file.exists();

  ps.readUserPrefsFromFile(file);

// A sticky pref should not be written if the value is unchanged.

add_test(function notWrittenWhenUnchanged() {

  resetAndLoadDefaults();

  Assert.strictEqual(ps.getBoolPref("testPref.unsticky.bool"), true);

  Assert.strictEqual(ps.getBoolPref("testPref.sticky.bool"), false);

  // write prefs - but we haven't changed the sticky one, so it shouldn't be written.

  saveAndReload();

  // sticky should not have been written to the new file.

  try {

    ps.getBoolPref("testPref.sticky.bool");

    Assert.ok(false, "expected failure reading this pref");

  } catch (ex) {

    Assert.ok(ex, "exception reading regular pref");

  run_next_test();

});

// Loading a sticky `pref` then a `user_pref` for the same pref means it should

// always be written.

add_test(function writtenOnceLoadedWithoutChange() {

  // Load the same pref file *as well as* a pref file that has a user_pref for

  // our sticky with the default value. It should be re-written without us

  // touching it.

  resetAndLoadAll();

  // reset and re-read what we just wrote - it should be written.

  saveAndReload();

  Assert.strictEqual(

    ps.getBoolPref("testPref.sticky.bool"),

    false,

    "user_pref was written with default value"

);

  run_next_test();

});

// If a sticky pref is explicicitly changed, even to the default, it is written.

add_test(function writtenOnceLoadedWithChangeNonDefault() {

  // Load the same pref file *as well as* a pref file that has a user_pref for

  // our sticky - then change the pref. It should be written.

  resetAndLoadAll();

  // Set a new val and check we wrote it.

  ps.setBoolPref("testPref.sticky.bool", false);

  saveAndReload();

  Assert.strictEqual(

    ps.getBoolPref("testPref.sticky.bool"),

    false,

    "user_pref was written with custom value"

);

  run_next_test();

});

// If a sticky pref is changed to the non-default value, it is written.

add_test(function writtenOnceLoadedWithChangeNonDefault() {

  // Load the same pref file *as well as* a pref file that has a user_pref for

  // our sticky - then change the pref. It should be written.

  resetAndLoadAll();

  // Set a new val and check we wrote it.

  ps.setBoolPref("testPref.sticky.bool", true);

  saveAndReload();

  Assert.strictEqual(

    ps.getBoolPref("testPref.sticky.bool"),

    true,

    "user_pref was written with custom value"

);

  run_next_test();

});

// Test that prefHasUserValue always returns true whenever there is a sticky

// value, even when that value matches the default. This is mainly for

// about:config semantics - prefs with a sticky value always remain bold and

// always offer "reset" (which fully resets and drops the sticky value as if

// the pref had never changed.)

add_test(function hasUserValue() {

  // sticky pref without user value.

  resetAndLoadDefaults();

  Assert.strictEqual(ps.getBoolPref("testPref.sticky.bool"), false);

  Assert.ok(

    !ps.prefHasUserValue("testPref.sticky.bool"),

    "should not initially reflect a user value"

);

  ps.setBoolPref("testPref.sticky.bool", false);

  Assert.ok(

    ps.prefHasUserValue("testPref.sticky.bool"),

    "should reflect a user value after set to default"

);

  ps.setBoolPref("testPref.sticky.bool", true);

  Assert.ok(

    ps.prefHasUserValue("testPref.sticky.bool"),

    "should reflect a user value after change to non-default"

);

  ps.clearUserPref("testPref.sticky.bool");

  Assert.ok(

    !ps.prefHasUserValue("testPref.sticky.bool"),

    "should reset to no user value"

);

  ps.setBoolPref("testPref.sticky.bool", false, "expected default");

  // And make sure the pref immediately reflects a user value after load.

  resetAndLoadAll();

  Assert.strictEqual(ps.getBoolPref("testPref.sticky.bool"), false);

  Assert.ok(

    ps.prefHasUserValue("testPref.sticky.bool"),

    "should have a user value when loaded value is the default"

);

  run_next_test();

});

// Test that clearUserPref removes the "sticky" value.

add_test(function clearUserPref() {

  // load things such that we have a sticky value which is the same as the

  // default.

  resetAndLoadAll();

  ps.clearUserPref("testPref.sticky.bool");

  // Once we save prefs the sticky pref should no longer be written.

  saveAndReload();

  try {

    ps.getBoolPref("testPref.sticky.bool");

    Assert.ok(false, "expected failure reading this pref");

  } catch (ex) {

    Assert.ok(ex, "pref doesn't have a sticky value");

  run_next_test();

});

// Test that a pref observer gets a notification fired when a sticky pref

// has it's value changed to the same value as the default. The reason for

// this behaviour is that later we might have other code that cares about a

// pref being sticky (IOW, we notify due to the "state" of the pref changing

// even if the value has not)

add_test(function observerFires() {

  // load things so there's no sticky value.

  resetAndLoadDefaults();

  function observe(subject, topic, data) {

    Assert.equal(data, "testPref.sticky.bool");

    ps.removeObserver("testPref.sticky.bool", observe);

    run_next_test();

  ps.addObserver("testPref.sticky.bool", observe);

  ps.setBoolPref(

    "testPref.sticky.bool",

    ps.getBoolPref("testPref.sticky.bool")

);

  // and the observer will fire triggering the next text.

});