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>}
+   */
+  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;
     }
   },
 
 };