WebUI test framework: fix Mock4JS verification, allow chrome.send passthrough.

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|.
  * @type {Object}
  */
 var testing = {};
 (function(exports) {
   /**
+   * Holds the original version of the |chrome| object.
+   */
+  var originalChrome = null;
+
+  /**
    * Hold the currentTestCase across between preLoad and run.
    * @type {TestCase}
    */
   var currentTestCase = null;
 
   /**
    * The string representation of the currently running test function.
    * @type {?string}
    */
   var currentTestFunction = null;
@@ skipping 305 matching lines @@
     sendCallbacks[name] = [messageHandler, callback];
   }
 
   /**
    * Register all methods of {@code mockClass.prototype} with messages of the
    * same name as the method, using the proxy of the |mockObject| as the
    * |messageHandler| when registering.
    * @param {Mock4JS.Mock} mockObject The mock to register callbacks against.
    * @param {function(new:Object)} mockClAss Constructor for the mocked class.
    * @see registerMessageCallback
+   * @see overrideChrome
    */
   function registerMockMessageCallbacks(mockObject, mockClass) {
+    if (!deferGlobalOverrides && !originalChrome)
+      overrideChrome();
     var mockProxy = mockObject.proxy();
     for (var func in mockClass.prototype) {
       if (typeof mockClass.prototype[func] === 'function') {
         registerMessageCallback(func, mockProxy, mockProxy[func]);
       }
     }
   }
 
   /**
    * Holds the mapping of name -> global override information.
@@ skipping 196 matching lines @@
    * @param {Array.<boolean, string>=} result When passed, this is used for the
    *     testResult message.
    */
   function testDone(result) {
     if (!testIsDone) {
       testIsDone = true;
       if (currentTestCase) {
         try {
           currentTestCase.tearDown();
         } catch (e) {
+          // Caught an exception in tearDown; Register the error and recreate
+          // the result if it is passed in.
           errors.push(e);
+          if (result)
+            result = [false, errorsToMessage([e], result[1])];
         }
         currentTestCase = null;
       }
       chrome.send('testResult', result ? result : testResult());
       errors.splice(0, errors.length);
     } else {
       console.warn('testIsDone already');
     }
   }
 
   /**
+   * Converts each Error in |errors| to a suitable message, adding them to
+   * |message|, and returns the message string.
+   * @param {Array.<Error>} errors Array of errors to add to |message|.
+   * @param {string?} message When supplied, error messages are appended to it.
+   * @return {string} |message| + messages of all |errors|.
+   */
+  function errorsToMessage(errors, message) {
+    for (var i = 0; i < errors.length; ++i) {
+      var errorMessage = errors[i].stack || errors[i].message;
+      if (message)
+        message += '\n';
+
+      message += 'Failed: ' + currentTestFunction + '(' +
+          currentTestArguments.map(JSON.stringify) +
+          ')\n' + errorMessage;
+    }
+    return message;
+  }
+
+  /**
    * Returns [success, message] & clears |errors|.
    * @param {boolean} errorsOk When true, errors are ok.
    * @return {Array.<boolean, string>}
    */
   function testResult(errorsOk) {
     var result = [true, ''];
     if (errors.length) {
-      var message = '';
-      for (var i = 0; i < errors.length; ++i) {
-        message += 'Failed: ' + currentTestFunction + '(' +
-                   currentTestArguments.map(JSON.stringify) +
-                   ')\n' + errors[i].stack;
-      }
-      result = [!!errorsOk, message];
+      result = [!!errorsOk, errorsToMessage(errors)];
     }
     return result;
   }
 
   // Asserts.
   // Use the following assertions to verify a condition within a test.
   // If assertion fails, throw an Error with information pertinent to the test.
 
   /**
    * When |test| !== true, aborts the current test.
@@ skipping 219 matching lines @@
    */
   function createTestCase(testFixture, testName) {
     var fixtureConstructor = this[testFixture];
     var testBody = fixtureConstructor.testCaseBodies[testName];
     var fixture = new fixtureConstructor();
     fixture.name = testFixture;
     return new TestCase(testName, fixture, testBody);
   }
 
   /**
+   * Overrides the |chrome| object to enable mocking calls to chrome.send().
+   */
+  function overrideChrome() {
+    if (originalChrome) {
+      console.error('chrome object already overridden');
+      return;
+    }
+
+    originalChrome = chrome;
+    chrome = {
+      __proto__: originalChrome,
+      send: send,
+      originalSend: originalChrome.send.bind(originalChrome),
+    };
+  }
+
+  /**
    * Used by WebUIBrowserTest to preload the javascript libraries at the
    * appropriate time for javascript injection into the current page. This
    * creates a test case and calls its preLoad for any early initialization such
    * as registering handlers before the page's javascript runs it's OnLoad
    * method. This is called before the page is loaded, so the |chrome| object is
    * not yet bound and this DOMContentLoaded listener will be called first to
    * override |chrome| in order to route messages registered in |sendCallbacks|.
    * @param {string} testFixture The test fixture name.
    * @param {string} testName The test name.
    * @see sendCallbacks
    */
   function preloadJavascriptLibraries(testFixture, testName) {
     deferGlobalOverrides = true;
 
-    exports.addEventListener('DOMContentLoaded', function() {
-      var oldChrome = chrome;
-      chrome = {
-        __proto__: oldChrome,
-        send: send,
-      };
+    window.addEventListener('DOMContentLoaded', function() {
+      overrideChrome();
 
       // Override globals at load time so they will be defined.
       assertTrue(deferGlobalOverrides);
       deferGlobalOverrides = false;
       for (var funcName in globalOverrides)
         overrideGlobal(funcName);
     });
     currentTestCase = createTestCase(testFixture, testName);
     currentTestCase.preLoad();
   }
@@ skipping 460 matching lines @@
   exports.DUMMY_URL = DUMMY_URL;
   exports.TEST = TEST;
   exports.TEST_F = TEST_F;
   exports.GEN = GEN;
   exports.GEN_INCLUDE = GEN_INCLUDE;
   exports.WhenTestDone = WhenTestDone;
 
   // Import the Mock4JS helpers.
   Mock4JS.addMockSupport(exports);
 })(this);