Provide ability for WebUIBrowserTests to run asynchronous tests.

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 = {};
 
 /**
  * Hold the currentTestCase across between PreLoad and Run.
  * @type {TestCase}
  **/
 var currentTestCase = null;
 
+/**
+ * @type {?string} The string representation of the currently running test
+ *     function.
+ */
+var currentTestFunction = null;
+
+/**
+ * @type {?Array} The arguments of the currently running test.
+ */
+var currentTestArguments = null;
+
 (function() {
   // Provide global objects for generation case.
   if (this['window'] === undefined)
     this['window'] = this;
   if (this['chrome'] === undefined) {
     this['chrome'] = {
       send: function() {},
     };
   }
   if (this['console'] === undefined) {
@@ skipping 271 matching lines @@
       return callMessage;
     },
   };
 
   /**
    * Help register calls for better error reporting.
    * @type {CallHelper}
    **/
   var helper = new CallHelper();
 
+  /**
+   * true when asyncTestDone has been called.
+   * @type {boolean}
+   */
+  var asyncTestIsDone = false;
+
+  /**
+   * Notifies the running browser test that any async javascript is complete.
+   * @param {Array.<boolean, string>=} result When passed, this is used for the
+   *     asyncTestResult message.
+   **/
+  function asyncTestDone(result) {
+    if (!asyncTestIsDone) {
+      asyncTestIsDone = true;
+      chrome.send('asyncTestResult', result ? result : testResult());
+    }
+  }
+
+  /**
+   * Returns [success, message] & clears |errors|.
+   * @return {Array.<boolean, string>}
+   **/
+  function testResult() {
+    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;
+      }
+      errors.splice(0, errors.length);
+      result = [false, message];
+    }
+    return result;
+  }
+
   // Asserts.
   // Use the following assertions to verify a condition within a test.
   // If assertion fails, the C++ backend will be immediately notified.
   // If assertion passes, no notification will be sent to the C++ backend.
 
   /**
    * When |test| !== true, aborts the current test.
    * @param {boolean} test The predicate to check against |expected|.
    * @param {string=} message The message to include in the Error thrown.
    * @throws {Error} upon failure.
@@ skipping 119 matching lines @@
    **/
   function assertNotReached(message) {
     helper.registerCall();
     throw new Error(helper.getCallMessage(message));
   }
 
   /**
    * Holds the errors, if any, caught by expects so that the test case can fail.
    * @type {Array.<Error>}
    **/
   var errors = [];

[mmenke, 2011/08/05 16:08:28]

This should go above "function testResult()"

[Sheridan Rawlins, 2011/08/05 16:59:56]

Actually after responding to your comment below, moved above asyncTestDone().

 
   /**
    * Creates a function based upon a function that thows an exception on
    * failure. The new function stuffs any errors into the |errors| array for
    * checking by runTest. This allows tests to continue running other checks,
    * while failing the overal test if any errors occurrred.
    * @param {Function} assertFunc The function which may throw an Error.
    * @return {Function} A function that applies its arguments to |assertFunc|.
    * @see errors
    * @see runTest
@@ skipping 18 matching lines @@
    * @param {string} testFunction The function name to call.
    * @param {Array} testArguments The arguments to call |testFunction| with.
    * @return {Array.<boolean, string>} [test-succeeded, message-if-failed]
    * @see errors
    * @see runTestFunction
    **/
   function runTest(testFunction, testArguments) {
     // Avoid eval() if at all possible, since it will not work on pages
     // that have enabled content-security-policy.
     var testBody = this[testFunction];    // global object -- not a method.
-    if (typeof testBody === "undefined")
+    var testName = testFunction;
+    if (typeof testBody === "undefined") {
       testBody = eval(testFunction);
+      testName = testBody.toString();
+    }
     if (testBody != RUN_TEST_F) {
-      var testName =
-          testFunction.name ? testFunction.name : testBody.toString();
       console.log('Running test ' + testName);
     }
     return runTestFunction(testFunction, testBody, testArguments);
   }
 
   /**
    * This is the guts of WebUIBrowserTest. It clears |errors|, runs the
    * test surrounded by an expect to catch Errors. If |errors| is
    * non-empty, it reports a failure and a message by joining |errors|.
    * Consumers can use this to use assert/expect functions asynchronously,
    * but are then responsible for reporting errors to the browser themselves.
    * @param {string} testFunction The function name to report on failure.
    * @param {Function} testBody The function to call.
    * @param {Array} testArguments The arguments to call |testBody| with.
    * @return {Array.<boolean, string>} [test-succeeded, message-if-failed]
    * @see errors
    * @see createExpect
    **/
   function runTestFunction(testFunction, testBody, testArguments) {
     errors.splice(0, errors.length);

[mmenke, 2011/08/05 16:08:28]

I'm still not sure about calling this here.  Seems to me that it makes the most
sense to clear the errors array right after results are reported, which would be
at the end of runTest (Which you currently don't do), and asyncTestDone (Which
you currently do).

[Sheridan Rawlins, 2011/08/05 16:59:56]

Wow, I just had the insight that this allows the call to runTestFunction to be
the "peek" we talked about.  It is a peek at the current state of errors in the
form of pass/fail + message. Moved the clearing to runTest and asyncTestDone,
where testResults (and hence runTestFunction) just returns the current results.

+    currentTestFunction = testFunction;
+    currentTestArguments = testArguments;
     createExpect(testBody).apply(null, testArguments);
-
-    var result = [true];
-    if (errors.length) {
-      var message = '';
-      for (var i = 0; i < errors.length; ++i) {
-        message += 'Failed: ' + testFunction + '(' +
-                   testArguments.map(JSON.stringify) +
-                   ')\n' + errors[i].stack;
-      }
-      errors.splice(0, errors.length);
-      result = [false, message];
-    }
-    return result;
+    return testResult();
   }
 
   /**
    * Creates a new test case for the given |testFixture| and |testName|. Assumes
    * |testFixture| describes a globally available subclass of type Test.
    * @param {string} testFixture The fixture for this test case.
    * @param {string} testName The name for this test case.
    * @return {TestCase} A newly created TestCase.
    **/
   function createTestCase(testFixture, testName) {
@@ skipping 164 matching lines @@
      * @return {string} description of the matcher for this argument.
      **/
     describe: function() {
       return 'SaveArguments(' +
           this.realMatcher_.describe.call(this.realMatcher_) + ')';
     },
   };
 
   // Exports.
   testing.Test = Test;
+  window.asyncTestDone = asyncTestDone;
   window.assertTrue = assertTrue;
   window.assertFalse = assertFalse;
   window.assertGE = assertGE;
   window.assertGT = assertGT;
   window.assertEquals = assertEquals;
   window.assertLE = assertLE;
   window.assertLT = assertLT;
   window.assertNotEquals = assertNotEquals;
   window.assertNotReached = assertNotReached;
   window.callFunction = callFunction;
@@ skipping 12 matching lines @@
   window.runTest = runTest;
   window.runTestFunction = runTestFunction;
   window.SaveArgumentsMatcher = SaveArgumentsMatcher;
   window.TEST = TEST;
   window.TEST_F = TEST_F;
   window.GEN = GEN;
 
   // Import the Mock4JS helpers.
   Mock4JS.addMockSupport(window);
 })();