MD Settings: FakeSettingsPrivate for tests

chrome/test/data/webui/settings/prefs_tests.js

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** @fileoverview Suite of tests for settings-prefs. */
 cr.define('settings_prefs', function() {
   /**
    * Creates a deep copy of the object.
    * @param {!Object} obj
    * @return {!Object}
    */
   function deepCopy(obj) {
     return JSON.parse(JSON.stringify(obj));
   }
 
-  /**
-   * Mock of chrome.settingsPrivate API.
-   * @constructor
-   * @extends {chrome.settingsPrivate}
-   */
-  function MockSettingsApi() {
-    this.prefs = {};
-
-    // Hack alert: bind this instance's onPrefsChanged members to this.
-    this.onPrefsChanged = {
-      addListener: this.onPrefsChanged.addListener.bind(this),
-      removeListener: this.onPrefsChanged.removeListener.bind(this),
-    };
-
-    for (var testCase of prefsTestCases)
-      this.addPref_(testCase.type, testCase.key, testCase.values[0]);
-  }
-
-  // Make the listener static because it refers to a singleton.
-  MockSettingsApi.listener_ = null;
-
-  MockSettingsApi.prototype = {
-    // chrome.settingsPrivate overrides.
-    onPrefsChanged: {
-      addListener: function(listener) {
-        MockSettingsApi.listener_ = listener;
-      },
-
-      removeListener: function(listener) {
-        MockSettingsApi.listener_ = null;
-      },
-    },
-
-    getAllPrefs: function(callback) {
-      // Send a copy of prefs to keep our internal state private.
-      var prefs = [];
-      for (var key in this.prefs)
-        prefs.push(deepCopy(this.prefs[key]));
-
-      // Run the callback asynchronously to test that the prefs aren't actually
-      // used before they become available.
-      setTimeout(callback.bind(null, prefs));
-    },
-
-    setPref: function(key, value, pageId, callback) {
-      var pref = this.prefs[key];
-      assertNotEquals(undefined, pref);
-      assertEquals(typeof value, typeof pref.value);
-      assertEquals(Array.isArray(value), Array.isArray(pref.value));
-
-      if (this.failNextSetPref_) {
-        callback(false);
-        this.failNextSetPref_ = false;
-        return;
-      }
-      assertNotEquals(true, this.disallowSetPref_);
-
-      var changed = JSON.stringify(pref.value) != JSON.stringify(value);
-      pref.value = deepCopy(value);
-      callback(true);
-
-      // Like chrome.settingsPrivate, send a notification when prefs change.
-      if (changed)
-        this.sendPrefChanges([{key: key, value: deepCopy(value)}]);
-    },
-
-    getPref: function(key, callback) {
-      var pref = this.prefs[key];
-      assertNotEquals(undefined, pref);
-      callback(deepCopy(pref));
-    },
-
-    // Functions used by tests.
-
-    /** Instructs the API to return a failure when setPref is next called. */
-    failNextSetPref: function() {
-      this.failNextSetPref_ = true;
-    },
-
-    /** Instructs the API to assert (fail the test) if setPref is called. */
-    disallowSetPref: function() {
-      this.disallowSetPref_ = true;
-    },
-
-    allowSetPref: function() {
-      this.disallowSetPref_ = false;
-    },
-
-    /**
-     * Notifies the listener of pref changes.
-     * @param {!Object<{key: string, value: *}>} changes
-     */
-    sendPrefChanges: function(changes) {
-      var prefs = [];
-      for (var change of changes) {
-        var pref = this.prefs[change.key];
-        assertNotEquals(undefined, pref);
-        pref.value = change.value;
-        prefs.push(deepCopy(pref));
-      }
-      MockSettingsApi.listener_(prefs);
-    },
-
-    // Private methods for use by the mock API.
-
-    /**
-     * @param {!chrome.settingsPrivate.PrefType} type
-     * @param {string} key
-     * @param {*} value
-     */
-    addPref_: function(type, key, value) {
-      this.prefs[key] = {
-        type: type,
-        key: key,
-        value: value,
-      };
-    },
-  };
-
   function registerTests() {
     suite('CrSettingsPrefs', function() {
       /**
        * Prefs instance created before each test.
        * @type {CrSettingsPrefsElement|undefined}
        */
       var prefs;
 
-      /** @type {MockSettingsApi} */
+      /** @type {settings.MockSettingsPrivate} */
       var mockApi = null;
 
       /**
        * @param {!Object} prefStore Pref store from <settings-prefs>.
        * @param {string} key Pref key of the pref to return.
        * @return {chrome.settingsPrivate.PrefObject|undefined}
        */
       function getPrefFromKey(prefStore, key) {
         var path = key.split('.');
         var pref = prefStore;
@@ skipping 35 matching lines @@
       }
 
       /**
        * List of CrSettingsPref elements created for testing.
        * @type {!Array<!CrSettingsPrefs>}
        */
       var createdElements = [];
 
       // Initialize <settings-prefs> elements before each test.
       setup(function() {
-        mockApi = new MockSettingsApi();
-        // TODO(michaelpg): don't use global variables to inject the API.
-        window.mockApi = mockApi;
+        // Override chrome.settingsPrivate with MockSettingsPrivate.
+        mockApi = new settings.MockSettingsPrivate();
+        mockApi.register();
 
         // Create and attach the <settings-prefs> elements. Make several of
         // them to test that the shared state model scales correctly.
         createdElements = [];
         for (var i = 0; i < 100; i++) {
           var prefsInstance = document.createElement('settings-prefs');
           document.body.appendChild(prefsInstance);
           createdElements.push(prefsInstance);
         }
         // For simplicity, only use one prefs element in the tests. Use an
         // arbitrary index instead of the first or last element created.
         prefs = createdElements[42];
 
         // getAllPrefs is asynchronous, so return the prefs promise.
         return CrSettingsPrefs.initialized;
       });
 
       teardown(function() {
         CrSettingsPrefs.resetForTesting();
 
-        // Reset each <settings-prefs>.
+        // Reset each <settings-prefs>. TODO(michaelpg): make settings-prefs
+        // less dependent on testing state so we don't have to do this.
         for (var i = 0; i < createdElements.length; i++)
           createdElements[i].resetForTesting();
 
         PolymerTest.clearBody();
-        window.mockApi = undefined;
+        mockApi.unregister();
       });
 
       test('receives and caches prefs', function() {
         // Test that each pref has been successfully copied to the Polymer
         // |prefs| property.
         for (var key in mockApi.prefs) {
           var expectedPref = mockApi.prefs[key];
           var actualPref = getPrefFromKey(prefs.prefs, key);
           if (!expectNotEquals(undefined, actualPref)) {
             // We've already registered an error, so skip the pref.
@@ skipping 57 matching lines @@
         mockApi.sendPrefChanges(prefChanges);
         assertPrefsSet(2);
       });
     });
   }
 
   return {
     registerTests: registerTests,
   };
 });