WebUI Testing: async support - global mocking, deferred runs, continued run.

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"
@@ skipping 61 matching lines @@
   return RunJavascriptFunction(function_name, args);
 }
 
 bool WebUIBrowserTest::RunJavascriptFunction(
     const std::string& function_name,
     const ConstValueVector& function_arguments) {
   return RunJavascriptUsingHandler(
       function_name, function_arguments, false, false, NULL);
 }
 
-bool WebUIBrowserTest::RunJavascriptTestF(const std::string& test_fixture,
+bool WebUIBrowserTest::RunJavascriptTestF(bool is_async,
+                                          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);
+
+  if (is_async)
+    return RunJavascriptAsyncTest("RUN_TEST_F", args);
+  else
+    return RunJavascriptTest("RUN_TEST_F", args);
 }
 
 bool WebUIBrowserTest::RunJavascriptTest(const std::string& test_name) {
   return RunJavascriptTest(test_name, ConstValueVector());
 }
 
 bool WebUIBrowserTest::RunJavascriptTest(const std::string& test_name,
                                          const Value& arg) {
   ConstValueVector args;
   args.push_back(&arg);
@@ skipping 80 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();
 }
 
+const char WebUIBrowserTest::kDummyURL[] = "chrome://DummyURL";
+
 WebUIBrowserTest::WebUIBrowserTest()
     : test_handler_(new WebUITestHandler()),
       libraries_preloaded_(false) {}
 
+namespace {
+
+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);
+  }
+};
+
+base::LazyInstance<MockWebUIProvider> mock_provider_(
+    base::LINKER_INITIALIZED);
+
+}  // namespace
+
 void WebUIBrowserTest::SetUpInProcessBrowserTestFixture() {
+  InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
+  TestChromeWebUIFactory::AddFactoryOverride(GURL(kDummyURL).host(),
+                                             mock_provider_.Pointer());
+
   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;
   PathService::Get(chrome::FILE_RESOURCES_PACK, &resources_pack_path);
   ResourceBundle::AddDataPackToSharedInstance(resources_pack_path);
 
   FilePath mockPath;
   ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &mockPath));
   mockPath = mockPath.AppendASCII("chrome");
   mockPath = mockPath.AppendASCII("third_party");
   mockPath = mockPath.AppendASCII("mock4js");
   mockPath = mockPath.Append(kMockJS);
   AddLibrary(mockPath);
   AddLibrary(FilePath(kWebUILibraryJS));
 }
 
+void WebUIBrowserTest::TearDownInProcessBrowserTestFixture() {
+  InProcessBrowserTest::TearDownInProcessBrowserTestFixture();
+  TestChromeWebUIFactory::RemoveFactoryOverride(GURL(kDummyURL).host());
+}
+
 WebUIMessageHandler* WebUIBrowserTest::GetMockMessageHandler() {
   return NULL;
 }
 
 GURL WebUIBrowserTest::WebUITestDataPathToURL(
     const FilePath::StringType& path) {
   FilePath dir_test_data;
   EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &dir_test_data));
   FilePath test_path(dir_test_data.AppendASCII("webui"));
   test_path = test_path.Append(path);
@@ skipping 173 matching lines @@
   }
 
   // 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(HandleTestFails, void(const ListValue*));
     MOCK_METHOD1(HandleTestPasses, void(const ListValue*));
 
    private:
@@ skipping 15 matching lines @@
       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 after assertion fails (no testContinues
 // message). (Sync version).
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestSyncOkTestFail) {
   ASSERT_FALSE(RunJavascriptTest("testFailsAssert"));
 }
 
 // Test that assertions fail immediately after assertion fails (no testContinues
 // message). (Async version).
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncFailsAssert) {
   EXPECT_CALL(message_handler_, HandleTestFails(::testing::_));
@@ skipping 71 matching lines @@
 // testDone directly and expect pass result.
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestTestDoneEarlyPassesAsync) {
   ASSERT_TRUE(RunJavascriptAsyncTest("testDone"));
 }
 
 // Test that calling testDone during RunJavascriptTest still completes when
 // waiting for async result.
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestTestDoneEarlyPasses) {
   ASSERT_TRUE(RunJavascriptTest("testDone"));
 }