addon-sdk/source/test/test-simple-prefs.js

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4 "use strict";
   5
   6 const { Cc, Ci, Cu } = require('chrome');
   7 const { Loader } = require("sdk/test/loader");
   8 const { setTimeout } = require("sdk/timers");
   9 const { emit } = require("sdk/system/events");
  10 const simplePrefs = require("sdk/simple-prefs");
  11 const { prefs: sp } = simplePrefs;
  12 const { defer, resolve, reject, all } = require("sdk/core/promise");
  13 const AddonInstaller = require("sdk/addon/installer");
  14 const fixtures = require("./fixtures");
  15 const { pathFor } = require("sdk/system");
  16 const file = require("sdk/io/file");
  17 const { install, uninstall } = require("sdk/addon/installer");
  18 const { open } = require('sdk/preferences/utils');
  19 const { toFilename } = require('sdk/url');
  20 const { AddonManager } = Cu.import('resource://gre/modules/AddonManager.jsm', {});
  21 const { ZipWriter } = require('./zip/utils');
  22 const { getTabForId } = require('sdk/tabs/utils');
  23 const { preferencesBranch, id } = require('sdk/self');
  24 const { Tab } = require('sdk/tabs/tab');
  25 require('sdk/tabs');
  26
  27 const prefsrv = Cc['@mozilla.org/preferences-service;1'].
  28                     getService(Ci.nsIPrefService);
  29
  30 const specialChars = "!@#$%^&*()_-=+[]{}~`\'\"<>,./?;:";
  31
  32 exports.testIterations = function(assert) {
  33   sp["test"] = true;
  34   sp["test.test"] = true;
  35   let prefAry = [];
  36   for (var name in sp ) {
  37     prefAry.push(name);
  38   }
  39   assert.ok("test" in sp);
  40   assert.ok(!sp.getPropertyDescriptor);
  41   assert.ok(Object.prototype.hasOwnProperty.call(sp, "test"));
  42   assert.equal(["test", "test.test"].toString(), prefAry.sort().toString(), "for (x in y) part 1/2 works");
  43   assert.equal(["test", "test.test"].toString(), Object.keys(sp).sort().toString(), "Object.keys works");
  44
  45   delete sp["test"];
  46   delete sp["test.test"];
  47   let prefAry = [];
  48   for (var name in sp ) {
  49     prefAry.push(name);
  50   }
  51   assert.equal([].toString(), prefAry.toString(), "for (x in y) part 2/2 works");
  52 }
  53
  54 exports.testSetGetBool = function(assert) {
  55   assert.equal(sp.test, undefined, "Value should not exist");
  56   sp.test = true;
  57   assert.ok(sp.test, "Value read should be the value previously set");
  58   delete sp.test;
  59 };
  60
  61 // TEST: setting and getting preferences with special characters work
  62 exports.testSpecialChars = function(assert, done) {
  63   let chars = specialChars.split("");
  64   let len = chars.length;
  65
  66   let count = 0;
  67   chars.forEach(function(char) {
  68     let rand = Math.random() + "";
  69     simplePrefs.on(char, function onPrefChanged() {
  70       simplePrefs.removeListener(char, onPrefChanged);
  71       assert.equal(sp[char], rand, "setting pref with a name that is a special char, " + char + ", worked!");
  72       delete sp[char];
  73
  74       // end test
  75       if (++count == len)
  76         done();
  77     })
  78     sp[char] = rand;
  79   });
  80 };
  81
  82 exports.testSetGetInt = function(assert) {
  83   assert.equal(sp["test-int"], undefined, "Value should not exist");
  84   sp["test-int"] = 1;
  85   assert.equal(sp["test-int"], 1, "Value read should be the value previously set");
  86   delete sp["test-int"];
  87 };
  88
  89 exports.testSetComplex = function(assert) {
  90   try {
  91     sp["test-complex"] = {test: true};
  92     assert.fail("Complex values are not allowed");
  93   }
  94   catch (e) {
  95     assert.pass("Complex values are not allowed");
  96   }
  97 };
  98
  99 exports.testSetGetString = function(assert) {
 100   assert.equal(sp["test-string"], undefined, "Value should not exist");
 101   sp["test-string"] = "test";
 102   assert.equal(sp["test-string"], "test", "Value read should be the value previously set");
 103   delete sp["test-string"];
 104 };
 105
 106 exports.testHasAndRemove = function(assert) {
 107   sp.test = true;
 108   assert.ok(("test" in sp), "Value exists");
 109   delete sp.test;
 110   assert.equal(sp.test, undefined, "Value should be undefined");
 111 };
 112
 113 exports.testPrefListener = function(assert, done) {
 114   let listener = function(prefName) {
 115     simplePrefs.removeListener('test-listener', listener);
 116     assert.equal(prefName, "test-listen", "The prefs listener heard the right event");
 117     delete sp["test-listen"];
 118     done();
 119   };
 120
 121   simplePrefs.on("test-listen", listener);
 122
 123   sp["test-listen"] = true;
 124
 125   // Wildcard listen
 126   let toSet = ['wildcard1','wildcard.pref2','wildcard.even.longer.test'];
 127   let observed = [];
 128
 129   let wildlistener = function(prefName) {
 130     if (toSet.indexOf(prefName) > -1) observed.push(prefName);
 131   };
 132
 133   simplePrefs.on('',wildlistener);
 134
 135   toSet.forEach(function(pref) {
 136     sp[pref] = true;
 137     delete sp[pref];
 138   });
 139
 140   assert.ok((observed.length === 6 && toSet.length === 3),
 141       "Wildcard lengths inconsistent" + JSON.stringify([observed.length, toSet.length]));
 142
 143   toSet.forEach(function(pref,ii) {
 144     assert.equal(observed[2*ii], pref, "Wildcard observed " + pref);
 145   });
 146
 147   simplePrefs.removeListener('',wildlistener);
 148
 149 };
 150
 151 exports.testBtnListener = function(assert, done) {
 152   let name = "test-btn-listen";
 153   simplePrefs.on(name, function listener() {
 154     simplePrefs.removeListener(name, listener);
 155     assert.pass("Button press event was heard");
 156     done();
 157   });
 158   emit((id + "-cmdPressed"), { subject: "", data: name });
 159 };
 160
 161 exports.testPrefRemoveListener = function(assert, done) {
 162   let counter = 0;
 163
 164   let listener = function() {
 165     assert.pass("The prefs listener was not removed yet");
 166
 167     if (++counter > 1)
 168       assert.fail("The prefs listener was not removed");
 169
 170     simplePrefs.removeListener("test-listen2", listener);
 171
 172     sp["test-listen2"] = false;
 173
 174     setTimeout(function() {
 175       assert.pass("The prefs listener was removed");
 176       delete sp["test-listen2"];
 177       done();
 178     }, 250);
 179   };
 180
 181   simplePrefs.on("test-listen2", listener);
 182
 183   // emit change
 184   sp["test-listen2"] = true;
 185 };
 186
 187 // Bug 710117: Test that simple-pref listeners are removed on unload
 188 exports.testPrefUnloadListener = function(assert, done) {
 189   let loader = Loader(module);
 190   let sp = loader.require("sdk/simple-prefs");
 191   let counter = 0;
 192
 193   let listener = function() {
 194     assert.equal(++counter, 1, "This listener should only be called once");
 195
 196     loader.unload();
 197
 198     // this may not execute after unload, but definitely shouldn't fire listener
 199     sp.prefs["test-listen3"] = false;
 200     // this should execute, but also definitely shouldn't fire listener
 201     require("sdk/simple-prefs").prefs["test-listen3"] = false;
 202
 203     delete sp.prefs["test-listen3"];
 204     done();
 205   };
 206
 207   sp.on("test-listen3", listener);
 208
 209   // emit change
 210   sp.prefs["test-listen3"] = true;
 211 };
 212
 213
 214 // Bug 710117: Test that simple-pref listeners are removed on unload
 215 exports.testPrefUnloadWildcardListener = function(assert, done) {
 216   let testpref = "test-wildcard-unload-listener";
 217   let loader = Loader(module);
 218   let sp = loader.require("sdk/simple-prefs");
 219   let counter = 0;
 220
 221   let listener = function() {
 222     assert.equal(++counter, 1, "This listener should only be called once");
 223
 224     loader.unload();
 225
 226     // this may not execute after unload, but definitely shouldn't fire listener
 227     sp.prefs[testpref] = false;
 228     // this should execute, but also definitely shouldn't fire listener
 229     require("sdk/simple-prefs").prefs[testpref] = false;
 230
 231     delete sp.prefs[testpref];
 232     done();
 233   };
 234
 235   sp.on("", listener);
 236   // emit change
 237   sp.prefs[testpref] = true;
 238 };
 239
 240
 241 // Bug 732919 - JSON.stringify() fails on simple-prefs.prefs
 242 exports.testPrefJSONStringification = function(assert) {
 243   var sp = require("sdk/simple-prefs").prefs;
 244   assert.equal(
 245       Object.keys(sp).join(),
 246       Object.keys(JSON.parse(JSON.stringify(sp))).join(),
 247       "JSON stringification should work.");
 248 };
 249
 250 exports.testUnloadOfDynamicPrefGeneration = function(assert, done) {
 251   let loader = Loader(module);
 252   let branch = prefsrv.getDefaultBranch('extensions.' + preferencesBranch);
 253
 254   let { enable } = loader.require("sdk/preferences/native-options");
 255
 256   let addon_id = "test-bootstrap-addon@mozilla.com";
 257   let xpi_path = file.join(pathFor("ProfD"), addon_id + ".xpi");
 258
 259   // zip the add-on
 260   let zip = new ZipWriter(xpi_path);
 261   assert.pass("start creating the xpi");
 262   zip.addFile("", toFilename(fixtures.url("bootstrap-addon/"))).
 263   then(zip.close()).
 264   then(_ => install(xpi_path)).
 265   // get the addon
 266   then(id => {
 267     let { promise, resolve } = defer();
 268     AddonManager.getAddonByID(id, resolve);
 269     return promise;
 270   }).
 271   // insatll the add-on
 272   then(addon => {
 273     assert.pass('installed');
 274
 275     assert.pass('addon id: ' + addon.id);
 276     addon.userDisabled = false;
 277     assert.ok(!addon.userDisabled, 'the add-on is enabled');
 278     assert.ok(addon.isActive, 'the add-on is enabled');
 279
 280     // setup dynamic prefs
 281     return enable({
 282       id: addon.id,
 283       preferences: [{
 284         "name": "test",
 285         "description": "test",
 286         "title": "Test",
 287         "type": "string",
 288         "value": "default"
 289       }, {
 290         "name": "test-int",
 291         "description": "test",
 292         "type": "integer",
 293         "value": 5,
 294         "title": "How Many?"
 295       }]
 296     });
 297   }).
 298   then(args => {
 299     assert.pass('enabled');
 300     return args;
 301   }).
 302   // show inline prefs
 303   then(open).
 304   then(args => {
 305     assert.pass('opened');
 306     return args;
 307   }).
 308   // confirm dynamic pref generation did occur
 309   then(args => {
 310     let results = args.document.querySelectorAll("*[data-jetpack-id=\"" +args.id + "\"]");
 311     assert.ok(results.length > 0, "the prefs were setup");
 312     return args;
 313   }).
 314   // unload dynamic prefs
 315   then(args => {
 316     loader.unload();
 317     assert.pass('unload');
 318     return args;
 319   }).
 320   // hide and show the inline prefs
 321   then(({ tabId, id, document }) => {
 322     let { promise, resolve } = defer();
 323     let tab = Tab({ tab: getTabForId(tabId) });
 324
 325     tab.close(_ => resolve({ id: id }));
 326
 327     return promise;
 328   }).
 329   // reopen the add-on prefs page
 330   then(open).
 331   // confirm dynamic pref generation did not occur
 332   then(({ id, tabId, document }) => {
 333     let { promise, resolve } = defer();
 334     let tab = Tab({ tab: getTabForId(tabId) });
 335
 336     let results = document.querySelectorAll("*[data-jetpack-id=\"" + id + "\"]");
 337     assert.equal(0, results.length, "the prefs were not setup after unload");
 338
 339     tab.close(_ => resolve({ id: id }));
 340
 341     return promise;
 342   }).
 343   // uninstall the add-on
 344   then(({ id }) => uninstall(id)).
 345   // delete the pref branch
 346   then(_ => branch.deleteBranch('')).
 347   then(done, assert.fail);
 348 }
 349
 350 require("sdk/test").run(exports);