MD Settings: FakeSettingsPrivate for tests

chrome/browser/resources/settings/prefs/prefs.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
  * 'settings-prefs' exposes a singleton model of Chrome settings and
  * preferences, which listens to changes to Chrome prefs whitelisted in
  * chrome.settingsPrivate. When changing prefs in this element's 'prefs'
  * property via the UI, the singleton model tries to set those preferences in
@@ skipping 134 matching lines @@
         value: document.createElement('settings-prefs-singleton'),
       },
     },
 
     observers: [
       'prefsChanged_(prefs.*)',
     ],
 
     /** @override */
     ready: function() {
-      this.singleton_.initialize();
+      // Register a callback on CrSettingsPrefs.initialized immediately so prefs
+      // is set as soon as the settings API returns. This enables other elements
+      // dependent on |prefs| to add their own callbacks to
+      // CrSettingsPrefs.initialized.
       this.startListening_();
+      if (!CrSettingsPrefs.deferInitialization)

[michaelpg, 2015/11/20 00:45:25]

This is how a test tells <settings-prefs> not to initialize using the default
api (the real chrome.settingsPrivate).

[Dan Beam, 2015/11/20 02:16:06]

Acknowledged.

+        this.initialize();
     },
 
     /**
      * Binds this.prefs to the settings-prefs-singleton's shared prefs once
      * preferences are initialized.
      * @private
      */
     startListening_: function() {
       CrSettingsPrefs.initialized.then(function() {
         // Ignore changes to prevent prefsChanged_ from notifying singleton_.
@@ skipping 48 matching lines @@
     runWhileIgnoringChanges_: function(fn) {
       assert(!this.ignoreChanges_,
              'Nested calls to runWhileIgnoringChanges_ are not supported');
       this.ignoreChanges_ = true;
       fn.call(this);
       // We can unset ignoreChanges_ now because change notifications
       // are synchronous.
       this.ignoreChanges_ = false;
     },
 
+    /** Initializes the singleton, which will fetch the prefs. */
+    initialize: function() {
+      this.singleton_.initialize();
+    },
+
+    /**
+     * Used to initialize the singleton with a fake SettingsPrivate.
+     * @param {SettingsPrivate} settingsApi Fake implementation to use.
+     */
+    initializeForTesting: function(settingsApi) {
+      this.singleton_.initialize(settingsApi);
+    },
+
     /**
      * Uninitializes this element to remove it from tests. Also resets
      * settings-prefs-singleton, allowing newly created elements to
      * re-initialize it.
      */
     resetForTesting: function() {
-      this.stopListening_();
       this.singleton_.resetForTesting();
     },
   });
 
   /**
    * Privately used element that contains, listens to and updates the shared
    * prefs state.
    */
   Polymer({
     is: 'settings-prefs-singleton',
@@ skipping 18 matching lines @@
         type: Object,
         value: function() { return {}; },
       },
     },
 
     // Listen for the manually fired prefs-changed event.
     listeners: {
       'prefs-changed': 'prefsChanged_',
     },
 
-    settingsApi_: chrome.settingsPrivate,
+    /** @type {SettingsPrivate} */
+    settingsApi_: /** @type {SettingsPrivate} */(chrome.settingsPrivate),

[michaelpg, 2015/11/20 00:45:25]

I got lazy and decided there was no reason to create a SettingsPrivateImpl that
just wraps chrome.settingsPrivate.

[Dan Beam, 2015/11/20 02:16:06]

if this works, I suppose it still accomplishes the goal of being able to inject
a double

 
-    initialize: function() {
+    /**
+     * @param {SettingsPrivate=} opt_settingsApi SettingsPrivate implementation
+     *     to use (chrome.settingsPrivate by default).
+     */
+    initialize: function(opt_settingsApi) {
       // Only initialize once (or after resetForTesting() is called).
       if (this.initialized_)
         return;
       this.initialized_ = true;
 
-      // Set window.mockApi to pass a custom settings API, i.e. for tests.
-      // TODO(michaelpg): don't use a global.
-      if (window.mockApi)
-        this.settingsApi_ = window.mockApi;
+      if (opt_settingsApi)
+        this.settingsApi_ = opt_settingsApi;
 
       this.settingsApi_.onPrefsChanged.addListener(
           this.onSettingsPrivatePrefsChanged_.bind(this));
       this.settingsApi_.getAllPrefs(
           this.onSettingsPrivatePrefsFetched_.bind(this));
     },
 
     /**
      * Polymer callback for changes to this.prefs.
      * @param {!CustomEvent} e
@@ skipping 106 matching lines @@
         if (this.lastPrefValues_.hasOwnProperty(key))
           return key;
       }
       return '';
     },
 
     /**
      * Resets the element so it can be re-initialized with a new prefs state.
      */
     resetForTesting: function() {
+      if (!this.initialized_)
+        return;
       this.prefs = undefined;
       this.lastPrefValues_ = {};
       this.initialized_ = false;
+      this.settingsApi_ =
+          /** @type {SettingsPrivate} */(chrome.settingsPrivate);
     },
   });
 })();