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 117 matching lines @@
   preload_test_name_ = preload_test_name;
 
   ui_test_utils::NavigateToURL(browser(), browse_to);
 
   TestTabStripModelObserver tabstrip_observer(
       browser()->tabstrip_model(), this);
   browser()->Print();
   tabstrip_observer.WaitForObservation();
 }
 
+bool WebUIBrowserTest::WaitForAsyncResult() {
+  return test_handler_->WaitForAsyncResult();
+}
+
 WebUIBrowserTest::WebUIBrowserTest()
     : test_handler_(new WebUITestHandler()),
       libraries_preloaded_(false) {}
 
 void WebUIBrowserTest::SetUpInProcessBrowserTestFixture() {
   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory_));
   test_data_directory_ = test_data_directory_.Append(kWebUITestFolder);
 
   // TODO(dtseng): should this be part of every BrowserTest or just WebUI test.
   FilePath resources_pack_path;
@@ skipping 32 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) {
@@ skipping 94 matching lines @@
 };
 
 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");
 }
+
+// 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_TRUE(RunJavascriptTest("startAsyncTest",
+                                *Value::CreateStringValue("testFailsAssert")));
+  ASSERT_FALSE(WaitForAsyncResult());
+}
+
+// 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_TRUE(RunJavascriptTest("startAsyncTest",
+                                *Value::CreateStringValue("testFailsExpect")));
+  ASSERT_FALSE(WaitForAsyncResult());
+}
+
+// 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(RunJavascriptTest("startAsyncTest",
+                                *Value::CreateStringValue("testPasses")));
+  ASSERT_TRUE(WaitForAsyncResult());
+}
+
+// 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(RunJavascriptTest("startAsyncTest",
+                                *Value::CreateStringValue("testPasses")));
+  ASSERT_TRUE(WaitForAsyncResult());
+}
+
+// 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_TRUE(RunJavascriptTest("startAsyncTest",
+                                *Value::CreateStringValue("testPasses")));
+  ASSERT_FALSE(WaitForAsyncResult());
+}