Seed test for SyncUI: sign in successfully with mocks.

chrome/test/data/webui/test_api.js

 // Copyright (c) 2011 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 Library providing basic test framework functionality.
  */
 
 /**
  * Namespace for |Test|.
@@ skipping 92 matching lines @@
      */
     isAsync: false,
 
     /**
      * True when the test is expected to fail for testing the test framework.
      * @type {boolean}
      */
     testShouldFail: false,
 
     /**
+     * Create a new class to handle |messageNames|, assign it to
+     * |this.mockHandler|, register its messages and return it.
+     * @return {Mock} Mock handler class assigned to |this.mockHandler|.
+     */
+    makeAndRegisterMockHandler: function(messageNames) {
+      var MockClass = makeMockClass(messageNames);
+      this.mockHandler = mock(MockClass);
+      registerMockMessageCallbacks(this.mockHandler, MockClass);
+      return this.mockHandler;
+    },
+
+    /**
+     * Create a new class to handle |functionNames|, assign it to
+     * |this.mockGlobals|, register its global overrides, and return it.
+     * @return {Mock} Mock handler class assigned to |this.mockGlobals|.
+     */
+    makeAndRegisterMockGlobals: function(functionNames) {

[James Hawkins, 2011/11/09 17:15:56]

Is this referring to JS globals?  Why are we mocking those?

[James Hawkins, 2011/11/10 00:24:43]

Still not answered.

[Sheridan Rawlins, 2011/11/10 02:02:12]

Yes.  This gives the facility to stub out an existing global function with a
mock so that expectations can be set and test will fail if the global function
is not called or called incorrectly.  It also remembers the global function so
that it can be called as well.

+      var MockClass = makeMockClass(functionNames);
+      this.mockGlobals = mock(MockClass);
+      registerMockGlobals(this.mockGlobals, MockClass);
+      return this.mockGlobals;
+    },
+
+    /**
      * Override this method to perform initialization during preload (such as
      * creating mocks and registering handlers).
      * @type {Function}
      */
     preLoad: function() {},
 
     /**
      * Override this method to perform tasks before running your test.
      * @type {Function}
      */
@@ skipping 258 matching lines @@
     globalOverrides[name] = {
       object: object,
       callback: callback,
     };
 
     if (!deferGlobalOverrides)
       overrideGlobal(name);
   }
 
   /**
+   * Empty function for use in making mocks.
+   * @const
+   */
+  function emptyFunction() {}
+
+  /**
+   * Make a mock from the supplied |methodNames| array.
+   * @param {Array.<string>} methodNames Array of names of methods to mock.
+   * @return {Function} Constructor with prototype filled in with methods
+   *     matching |methodNames|.
+   */
+  function makeMockClass(methodNames) {
+    function MockConstructor() {}
+    for(var i = 0; i < methodNames.length; i++)
+      MockConstructor.prototype[methodNames[i]] = emptyFunction;
+    return MockConstructor;
+  }
+
+  /**
    * Register all methods of {@code mockClass.prototype} as overrides to global
    * functions of the same name as the method, using the proxy of the
    * |mockObject| to handle the functions.
    * @param {Mock4JS.Mock} mockObject The mock to register callbacks against.
    * @param {function(new:Object)} mockClass Constructor for the mocked class.
    * @see registerMessageCallback
    */
   function registerMockGlobals(mockObject, mockClass) {
     var mockProxy = mockObject.proxy();
     for (var func in mockClass.prototype) {
@@ skipping 901 matching lines @@
   window.SaveMockArguments = SaveMockArguments;
   window.DUMMY_URL = DUMMY_URL;
   window.TEST = TEST;
   window.TEST_F = TEST_F;
   window.GEN = GEN;
   window.WhenTestDone = WhenTestDone;
 
   // Import the Mock4JS helpers.
   Mock4JS.addMockSupport(window);
 })(('window' in this) ? window : this);