Provide ability for WebUIBrowserTests to run asynchronous tests.

chrome/browser/ui/webui/web_ui_browsertest.cc

 // 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.
 #include "chrome/browser/ui/webui/web_ui_browsertest.h"
 
 #include <string>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/webui/chrome_web_ui.h"
+#include "chrome/browser/ui/webui/test_chrome_web_ui_factory.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/test_tab_strip_model_observer.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest-spi.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace {
 
 const FilePath::CharType kMockJS[] = FILE_PATH_LITERAL("mock4js.js");
 const FilePath::CharType kWebUILibraryJS[] = FILE_PATH_LITERAL("test_api.js");
 const FilePath::CharType kWebUITestFolder[] = FILE_PATH_LITERAL("webui");
 base::LazyInstance<std::vector<std::string> > error_messages_(
     base::LINKER_INITIALIZED);
@@ skipping 35 matching lines @@
   ConstValueVector args;
   args.push_back(&arg1);
   args.push_back(&arg2);
   return RunJavascriptFunction(function_name, args);
 }
 
 bool WebUIBrowserTest::RunJavascriptFunction(
     const std::string& function_name,
     const ConstValueVector& function_arguments) {
   return RunJavascriptUsingHandler(
-      function_name, function_arguments, false, NULL);
+      function_name, function_arguments, false, false, NULL);
 }
 
 bool WebUIBrowserTest::RunJavascriptTestF(const std::string& test_fixture,
                                           const std::string& test_name) {
   ConstValueVector args;
   args.push_back(Value::CreateStringValue(test_fixture));
   args.push_back(Value::CreateStringValue(test_name));
   return RunJavascriptTest("RUN_TEST_F", args);
 }
 
@@ skipping 13 matching lines @@
                                          const Value& arg2) {
   ConstValueVector args;
   args.push_back(&arg1);
   args.push_back(&arg2);
   return RunJavascriptTest(test_name, args);
 }
 
 bool WebUIBrowserTest::RunJavascriptTest(
     const std::string& test_name,
     const ConstValueVector& test_arguments) {
-  return RunJavascriptUsingHandler(test_name, test_arguments, true, NULL);
+  return RunJavascriptUsingHandler(
+      test_name, test_arguments, true, false, NULL);
+}
+
+bool WebUIBrowserTest::RunJavascriptAsyncTest(const std::string& test_name) {
+  return RunJavascriptAsyncTest(test_name, ConstValueVector());
+}
+
+bool WebUIBrowserTest::RunJavascriptAsyncTest(const std::string& test_name,
+                                         const Value& arg) {
+  ConstValueVector args;
+  args.push_back(&arg);
+  return RunJavascriptAsyncTest(test_name, args);
+}
+
+bool WebUIBrowserTest::RunJavascriptAsyncTest(const std::string& test_name,
+                                         const Value& arg1,
+                                         const Value& arg2) {
+  ConstValueVector args;
+  args.push_back(&arg1);
+  args.push_back(&arg2);
+  return RunJavascriptAsyncTest(test_name, args);
+}
+
+bool WebUIBrowserTest::RunJavascriptAsyncTest(
+    const std::string& test_name,
+    const ConstValueVector& test_arguments) {
+  return RunJavascriptUsingHandler(test_name, test_arguments, true, true, NULL);
 }
 
 void WebUIBrowserTest::PreLoadJavascriptLibraries(
     const std::string& preload_test_fixture,
     const std::string& preload_test_name,
     RenderViewHost* preload_host) {
   ASSERT_FALSE(libraries_preloaded_);
   ConstValueVector args;
   args.push_back(Value::CreateStringValue(preload_test_fixture));
   args.push_back(Value::CreateStringValue(preload_test_name));
   RunJavascriptUsingHandler(
-      "preloadJavascriptLibraries", args, false, preload_host);
+      "preloadJavascriptLibraries", args, false, false, preload_host);
   libraries_preloaded_ = true;
 }
 
 void WebUIBrowserTest::BrowsePreload(const GURL& browse_to,
                                      const std::string& preload_test_fixture,
                                      const std::string& preload_test_name) {
   // Remember for callback OnJsInjectionReady().
   preload_test_fixture_ = preload_test_fixture;
   preload_test_name_ = preload_test_name;
 
@@ skipping 67 matching lines @@
 void WebUIBrowserTest::BuildJavascriptLibraries(string16* content) {
   ASSERT_TRUE(content != NULL);
   std::string utf8_content;
   std::vector<FilePath>::iterator user_libraries_iterator;
   for (user_libraries_iterator = user_libraries_.begin();
        user_libraries_iterator != user_libraries_.end();
        ++user_libraries_iterator) {
     std::string library_content;
     if (user_libraries_iterator->IsAbsolute()) {
       ASSERT_TRUE(file_util::ReadFileToString(*user_libraries_iterator,
-                                              &library_content));
+                                              &library_content))
+          << user_libraries_iterator->value();
     } else {
       ASSERT_TRUE(file_util::ReadFileToString(
           test_data_directory_.Append(*user_libraries_iterator),
-              &library_content));
+          &library_content)) << user_libraries_iterator->value();
     }
     utf8_content.append(library_content);
     utf8_content.append(";\n");
   }
   content->append(UTF8ToUTF16(utf8_content));
 }
 
 string16 WebUIBrowserTest::BuildRunTestJSCall(
     const std::string& function_name,
     const WebUIBrowserTest::ConstValueVector& test_func_args) {
   WebUIBrowserTest::ConstValueVector arguments;
   StringValue function_name_arg(function_name);
   arguments.push_back(&function_name_arg);
   ListValue baked_argument_list;
   WebUIBrowserTest::ConstValueVector::const_iterator arguments_iterator;
   for (arguments_iterator = test_func_args.begin();
        arguments_iterator != test_func_args.end();
        ++arguments_iterator) {
     baked_argument_list.Append((Value *)*arguments_iterator);
   }
   arguments.push_back(&baked_argument_list);
   return WebUI::GetJavascriptCall(std::string("runTest"), arguments);
 }
 
 bool WebUIBrowserTest::RunJavascriptUsingHandler(
     const std::string& function_name,
     const ConstValueVector& function_arguments,
     bool is_test,
+    bool is_async,
     RenderViewHost* preload_host) {
 
   string16 content;
   if (!libraries_preloaded_)
     BuildJavascriptLibraries(&content);
 
   if (!function_name.empty()) {
     string16 called_function;
     if (is_test) {
       called_function = BuildRunTestJSCall(function_name, function_arguments);
     } else {
       called_function = WebUI::GetJavascriptCall(function_name,
                                                  function_arguments);
     }
     content.append(called_function);
   }
 
   if (!preload_host)
     SetupHandlers();
 
   logging::SetLogMessageHandler(&LogHandler);
   bool result = true;
 
   if (is_test)
-    result = test_handler_->RunJavaScriptTestWithResult(content);
+    result = test_handler_->RunJavaScriptTestWithResult(content, is_async);
   else if (preload_host)
     test_handler_->PreloadJavaScript(content, preload_host);
   else
     test_handler_->RunJavaScript(content);
 
   logging::SetLogMessageHandler(NULL);
 
   if (error_messages_.Get().size() > 0) {
     LOG(ERROR) << "Encountered javascript console error(s)";
     result = false;
@@ skipping 29 matching lines @@
   virtual ~WebUIBrowserExpectFailTest() {
     EXPECT_TRUE(s_test_);
     s_test_ = NULL;
   }
 
   static void RunJavascriptTestNoReturn(const std::string& testname) {
     EXPECT_TRUE(s_test_);
     s_test_->RunJavascriptTest(testname);
   }
 
+  static void RunJavascriptAsyncTestNoReturn(const std::string& testname) {
+    EXPECT_TRUE(s_test_);
+    s_test_->RunJavascriptAsyncTest(testname);
+  }
+
  private:
   static WebUIBrowserTest* s_test_;
 };
 
 WebUIBrowserTest* WebUIBrowserExpectFailTest::s_test_ = NULL;
 
 IN_PROC_BROWSER_TEST_F(WebUIBrowserExpectFailTest, TestFailsFast) {
   AddLibrary(FilePath(FILE_PATH_LITERAL("sample_downloads.js")));
   ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIDownloadsURL));
   EXPECT_FATAL_FAILURE(RunJavascriptTestNoReturn("FAILS_BogusFunctionName"),
                        "WebUITestHandler::Observe");
 }
+
+IN_PROC_BROWSER_TEST_F(WebUIBrowserExpectFailTest, TestFailsAsyncFast) {
+  AddLibrary(FilePath(FILE_PATH_LITERAL("sample_downloads.js")));
+  ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIDownloadsURL));
+  EXPECT_FATAL_FAILURE(RunJavascriptTestNoReturn("FAILS_BogusFunctionName"),

[mmenke, 2011/08/08 16:38:25]

RunJavascriptAsyncTestNoReturn?

[Sheridan Rawlins, 2011/08/10 01:58:53]

RunJavascriptTestNoReturn is not a framework method, but rather a helper
function (above) read the gtest doc - it says that EXPECT_FATAL_FAILURE cannot
be a member, so we have a static member set to this and use that.  This is not
async either.

[mmenke, 2011/08/10 04:17:53]

In that case, you aren't using "RunJavascriptAsyncTestNoReturn" anywhere, just
"RunJavascriptTestNoReturn", so might want to remove
"RunJavascriptAsyncTestNoReturn" unless you intend on using it.

[Sheridan Rawlins, 2011/08/10 05:41:06]

Thanks. When I looked at this, I didn't realize this was the 2nd flavor and had
a copy/paste without rename. It actually uncovered an issue where both the
EXPECT and the ASSERT were being hit (and gtest can only check for FATAL -or-
NONFATAL error).

Done.

+                       "WebUITestHandler::Observe");
+}
+
+IN_PROC_BROWSER_TEST_F(WebUIBrowserExpectFailTest, TestFailsNonAsync) {
+  AddLibrary(FilePath(FILE_PATH_LITERAL("sample_downloads.js")));
+  ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIDownloadsURL));
+  EXPECT_NONFATAL_FAILURE(RunJavascriptTest("asyncTestDone"),
+                          "WebUITestHandler::WaitForResult");
+}
+
+// Tests that the async framework works.
+class WebUIBrowserAsyncTest : public WebUIBrowserTest {
+ public:
+  // Calls the asyncTestDone() function from test_api.js
+  void AsyncTestDone() {
+    RunJavascriptFunction("asyncTestDone");
+  }
+
+  // starts a failing test.
+  void RunTestFailsAssert() {
+    RunJavascriptFunction("runAsync",
+                          *Value::CreateStringValue("testFailsAssert"));
+  }
+
+  // starts a passing test.
+  void RunTestPasses() {
+    RunJavascriptFunction("runAsync", *Value::CreateStringValue("testPasses"));
+  }
+
+ protected:
+
+  WebUIBrowserAsyncTest() {}
+
+  static const char kDummyURL[];
+
+  // Class to synchronize asynchronous javascript activity with the tests.
+  class AsyncWebUIMessageHandler : public WebUIMessageHandler {
+   public:
+    AsyncWebUIMessageHandler() {}
+
+    MOCK_METHOD1(HandleTestContinues, void(const ListValue*));
+    MOCK_METHOD1(HandleTestPasses, void(const ListValue*));
+
+   private:
+    virtual void RegisterMessages() OVERRIDE {
+      web_ui_->RegisterMessageCallback("startAsyncTest", NewCallback(
+          this, &AsyncWebUIMessageHandler::HandleStartAsyncTest));
+      web_ui_->RegisterMessageCallback("testPasses", NewCallback(
+          this, &AsyncWebUIMessageHandler::HandleTestPasses));
+      web_ui_->RegisterMessageCallback("testContinues", NewCallback(
+          this, &AsyncWebUIMessageHandler::HandleTestContinues));
+    }
+
+    // Starts the test in |list_value|[0] with the runAsync wrapper.
+    void HandleStartAsyncTest(const ListValue* list_value) {
+      Value* test_name;
+      ASSERT_TRUE(list_value->Get(0, &test_name));
+      web_ui_->CallJavascriptFunction("runAsync", *test_name);
+    }
+
+    DISALLOW_COPY_AND_ASSIGN(AsyncWebUIMessageHandler);
+  };
+
+  // Handler for this object.
+  ::testing::StrictMock<AsyncWebUIMessageHandler> message_handler_;
+
+ private:
+  // Class to provide a ChromeWebUI for |kDummyURL|.
+  class MockWebUIProvider : public TestChromeWebUIFactory::WebUIProvider {
+   public:
+    MockWebUIProvider() {}
+
+    // Returns a new ChromeWebUI
+    WebUI* NewWebUI(TabContents* tab_contents, const GURL& url) OVERRIDE {
+      return new ChromeWebUI(tab_contents);
+    }
+  };
+
+  // Provide this object's handler.
+  virtual WebUIMessageHandler* GetMockMessageHandler() OVERRIDE {
+    return &message_handler_;
+  }
+
+  // Set up the kDummyURL to be a WebUI page.
+  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
+    WebUIBrowserTest::SetUpInProcessBrowserTestFixture();
+    TestChromeWebUIFactory::AddFactoryOverride(GURL(kDummyURL).host(),
+                                               &mock_provider_);
+  }
+
+  // Tear down the kDummyURL WebUI page.
+  virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
+    WebUIBrowserTest::TearDownInProcessBrowserTestFixture();
+    TestChromeWebUIFactory::RemoveFactoryOverride(GURL(kDummyURL).host());
+  }
+
+  // Set up and browse to kDummyURL for all tests.
+  virtual void SetUpOnMainThread() OVERRIDE {
+    WebUIBrowserTest::SetUpOnMainThread();
+    AddLibrary(FilePath(FILE_PATH_LITERAL("async.js")));
+    ui_test_utils::NavigateToURL(browser(), GURL(kDummyURL));
+  }
+
+  // Provider for this object.
+  MockWebUIProvider mock_provider_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebUIBrowserAsyncTest);
+};
+
+const char WebUIBrowserAsyncTest::kDummyURL[] = "chrome://Dummy";
+
+// Test that assertions fail immediately without calling asyncTestDone().
+IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncFailsAssert) {
+  ASSERT_FALSE(RunJavascriptAsyncTest(
+      "startAsyncTest", *Value::CreateStringValue("testFailsAssert")));
+}
+
+// Test that expectations continue the function, but fail the test without
+// calling asyncTestDone().
+IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncFailsExpect) {
+  EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
+  ASSERT_FALSE(RunJavascriptAsyncTest(
+      "startAsyncTest", *Value::CreateStringValue("testFailsExpect")));
+}
+
+// Test that test passes when this object's handler calls asyncTestDone().
+IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncPasses) {
+  ::testing::InSequence s;
+  EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
+  EXPECT_CALL(message_handler_, HandleTestPasses(::testing::_))
+      .WillOnce(::testing::InvokeWithoutArgs(
+          this, &WebUIBrowserAsyncTest::AsyncTestDone));
+  ASSERT_TRUE(RunJavascriptAsyncTest(
+      "startAsyncTest", *Value::CreateStringValue("testPasses")));
+}
+
+// Test that two tests pass
+IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncPassPass) {
+  ::testing::InSequence s;
+  EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
+  EXPECT_CALL(message_handler_, HandleTestPasses(::testing::_))
+      .WillOnce(::testing::InvokeWithoutArgs(
+          this, &WebUIBrowserAsyncTest::RunTestPasses));
+  EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
+  EXPECT_CALL(message_handler_, HandleTestPasses(::testing::_))
+      .WillOnce(::testing::InvokeWithoutArgs(
+          this, &WebUIBrowserAsyncTest::AsyncTestDone));
+  ASSERT_TRUE(RunJavascriptAsyncTest(
+      "startAsyncTest", *Value::CreateStringValue("testPasses")));
+}
+
+// Test that first test passes; second fails.
+IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncPassThenFail) {
+  ::testing::InSequence s;
+  EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
+  EXPECT_CALL(message_handler_, HandleTestPasses(::testing::_))
+      .WillOnce(::testing::InvokeWithoutArgs(
+          this, &WebUIBrowserAsyncTest::RunTestFailsAssert));
+  ASSERT_FALSE(RunJavascriptAsyncTest(
+      "startAsyncTest", *Value::CreateStringValue("testPasses")));
+}
+
+// Test that calling asyncTestDone during RunJavascriptTest still completes when
+// waiting for async result.
+IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncTestDoneEarly) {
+  ASSERT_TRUE(RunJavascriptAsyncTest("asyncTestDone"));
+}