Unit test for sync online wallpaper

chrome/test/data/webui/mock_controller.js

 // Copyright 2013 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.
 
 /**
  * Create a mock function that records function calls and validates against
  * expectations.
  * @constructor.
  */
 function MockMethod() {
   var fn = function() {
     var args = Array.prototype.slice.call(arguments);
+    var callbacks =
+        args.filter(function(arg) { return (typeof arg == 'function'); });
+
+    if (callbacks.length > 1) {
+      console.error('Only support mocking function with at most one callback.');
+      return;
+    }
+
     fn.recordCall(args);
-    return this.returnValue;
+    if (callbacks.length == 1) {
+      callbacks[0].apply(undefined, fn.callbackData);
+      return;
+    }
+    return fn.returnValue;
   };
 
   /**
    * List of signatures for fucntion calls.
    * @type {!Array.<!Array>}
    * @private
    */
   fn.calls_ = [];
 
   /**
    * List of expected call signatures.
    * @type {!Array.<!Array>}
    * @private
    */
   fn.expectations_ = [];
 
   /**
    * Value returned from call to function.
    * @type {*}
    */
   fn.returnValue = undefined;
 
+  /**
+   * List of arguments for callback function.
+   * @type {!Array.<!Array>}
+   * @private

[kevers, 2014/09/30 18:12:03]

Based on direct access from test case, this is not private.  If the intention is
the make it private, then the variable should end in an underscore and be
modified via a  setter.

[bshe, 2014/09/30 21:59:48]

Dooh. It should not be private.

+   */
+  fn.callbackData = [];
+
   fn.__proto__ = MockMethod.prototype;
   return fn;
 }
 
 MockMethod.prototype = {
   /**
    * Adds an expected call signature.
    * @param {...}  var_args Expected arguments for the function call.
    */
   addExpectation: function() {
     var args = Array.prototype.slice.call(arguments);
-    this.expectations_.push(args);
+    this.expectations_.push(args.filter(this.notFunction_));
   },
 
   /**
    * Adds a call signature.
    * @param {!Array} args.
    */
   recordCall: function(args) {
-    this.calls_.push(args);
+    this.calls_.push(args.filter(this.notFunction_));
   },
 
   /**
    * Verifies that the function is called the expected number of times and with
    * the correct signature for each call.
    */
   verifyMock: function() {
     var errorMessage =  'Number of method calls did not match expectation.';
     if (this.functionName)
       errorMessage = 'Error in ' + this.functionName + ':\n' + errorMessage;
@@ skipping 10 matching lines @@
    * Override if strict equality is not required.
    * @param {number} index Canonical index of the function call. Unused in the
    *     base implementation, but provides context that may be useful for
    *     overrides.
    * @param {!Array} expected The expected arguments.
    * @parma {!Array} observed The observed arguments.
    */
   validateCall: function(index, expected, observed) {
     assertDeepEquals(expected, observed);
   },
+
+  /**
+   * Test if arg is a function.
+   * @param {*} arg The argument to test.
+   * @return True if arg is not function type.
+   */
+  notFunction_: function(arg) {
+    return typeof arg != 'function';
+  }
 };
 
 /**
  * Controller for mocking methods. Tracks calls to mocked methods and verifies
  * that call signatures match expectations.
  * @constructor.
  */
 function MockController() {
   /**
    * Original functions implementations, which are restored when |reset| is
@@ skipping 52 matching lines @@
    * Discard mocks reestoring default behavior.
    */
   reset: function() {
     for (var i = 0; i < this.overrides_.length; i++) {
       var override = this.overrides_[i];
       override.parent[override.functionName] = override.originalFunction;
     }
   },
 
 };