Support automatic javascript test registry in gtest when creating WebUI 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/at_exit.h"
+#include "base/lazy_instance.h"
+#include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/values.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/webui/web_ui.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "v8/include/v8.h"
 
-static const FilePath::CharType* kWebUILibraryJS =
-    FILE_PATH_LITERAL("test_api.js");
-static const FilePath::CharType* kWebUITestFolder = FILE_PATH_LITERAL("webui");
-static std::vector<std::string> error_messages_;
+namespace {
+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);
+
+// GTEST registration happens at linker initialization. When
+// |linker_initialized| is true, set up and tear down enough to enable the
+// PathService to give us path to the test data directory.
+FilePath GetTestDataDirectory(bool linker_initialized) {
+  scoped_ptr<base::AtExitManager> at_exit_manager;
+  if (linker_initialized) {
+    at_exit_manager.reset(new base::AtExitManager());
+    chrome::RegisterPathProvider();
+  }
+
+  FilePath test_data_directory;
+  EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory));
+  return test_data_directory.Append(kWebUITestFolder);
+}
 
 // Intercepts all log messages.
 bool LogHandler(int severity,
                 const char* file,
                 int line,
                 size_t message_start,
                 const std::string& str) {
   if (severity == logging::LOG_ERROR) {
-    error_messages_.push_back(str);
+    error_messages_.Get().push_back(str);
     return true;
   } else {
     // For debugging messages while developing tests.
     return false;
   }
 }
 
+// Read the specified |library| into |content|, prepending |test_data_directory|
+// when |library| is relative.
+void ReadLibraryToString(const FilePath& test_data_directory,
+                         const FilePath& library,
+                         std::string* content) {
+  ASSERT_TRUE(content);
+  if (library.IsAbsolute()) {

[Paweł Hajdan Jr., 2011/05/30 17:17:58]

I think this may be error prone. Could you add two variants - one for relative,
and one for absolute paths if really needed?

[Sheridan Rawlins, 2011/05/31 23:15:00]

David says we don't need the absolute case.  I'll put an ASSERT and remove the
handling.

(Done.)

On 2011/05/30 17:17:58, Paweł Hajdan Jr. wrote:

[Sheridan Rawlins, 2011/06/08 14:24:45]

The BIDI checker uses third party test script.  Putting back.

http://build.chromium.org/p/tryserver.chromium/builders/win/builds/34811/step...

On 2011/05/31 23:15:00, Sheridan Rawlins wrote:

+    ASSERT_TRUE(file_util::ReadFileToString(library, content));
+  } else {
+    ASSERT_TRUE(file_util::ReadFileToString(test_data_directory.Append(library),
+                                            content));
+  }
+}
+
+// Gets functions defined in |library_path| starting with "test". |testFuncs|
+// may not be NULL.
+bool GetTestFuncs(const FilePath& library_path,
+                  std::vector<std::string>* testFuncs) {
+  DCHECK(testFuncs);
+
+  std::string content = "var window = {};";
+  ReadLibraryToString(GetTestDataDirectory(true), library_path, &content);
+  content.append(
+      "(function () {"

[David Tseng, 2011/05/30 20:44:49]

Is there some way we can ask V8 to give us back the functions within the file
without in lining JS to get the functions?

Also, are we checking to only append functions with "test" prefix?

[Sheridan Rawlins, 2011/05/31 23:15:00]

The only way to get a variable from javascript is to compile/run a script. 
However, once I get a variable, I can iterate across the property names quite
easily/efficiently in v8.  I'll simplify the inlined javascript code.

We are including all functions.  See the sample_passing.js for how to add helper
functions.

On 2011/05/30 20:44:49, David Tseng wrote:

+      "  var funcs = new Array();"
+      "  for (var func in this) {"
+      "    if (typeof this[func] == 'function')"
+      "      funcs.push(func);"
+      "  }"
+      "  return funcs;"
+      "})()");
+
+  v8::HandleScope handle_scope;
+  v8::Persistent<v8::Context> context = v8::Context::New();
+  v8::Context::Scope context_scope(context);
+  v8::Handle<v8::String> source = v8::String::New(content.data(),
+                                                  content.size());
+  v8::Handle<v8::Script> script = v8::Script::Compile(source);
+  v8::TryCatch trycatch;
+  v8::Handle<v8::Array> result = script->Run().As<v8::Array>();
+  context.Dispose();
+  if (result.IsEmpty()) {
+    v8::Handle<v8::Value> exception = trycatch.Exception();
+    v8::String::AsciiValue exception_str(exception);
+    NOTREACHED() << "Exception: " <<  *exception_str;

[Paweł Hajdan Jr., 2011/05/30 17:17:58]

Why should a JS exception crash the entire test (that has then to become
disabled)?

[Sheridan Rawlins, 2011/05/31 23:15:00]

Keep in mind this is a JS exception in examining the js file for functions.  If
you can't get the list of functions, you can't register the tests, so it has to
fail.

On 2011/05/30 17:17:58, Paweł Hajdan Jr. wrote:

+    return false;
+  }
+
+  for (uint32_t index = 0; index < result->Length(); ++index) {
+    v8::Local<v8::String> value(result->Get(index).As<v8::String>());
+    if (value.IsEmpty()) {
+      return false;
+    }
+    v8::String::AsciiValue ascii(value);
+    testFuncs->push_back(std::string(*ascii, ascii.length()));
+  }
+  return true;
+}
+
+}  // namespace
+
 WebUIBrowserTest::~WebUIBrowserTest() {}
 
 bool WebUIBrowserTest::RunJavascriptFunction(const std::string& function_name) {
   return RunJavascriptFunction(function_name, ConstValueVector());
 }
 
 bool WebUIBrowserTest::RunJavascriptFunction(const std::string& function_name,
                                              const Value& arg) {
   ConstValueVector args;
   args.push_back(&arg);
@@ skipping 38 matching lines @@
 bool WebUIBrowserTest::RunJavascriptTest(
     const std::string& test_name,
     const ConstValueVector& test_arguments) {
   return RunJavascriptUsingHandler(test_name, test_arguments, true);
 }
 
 WebUIBrowserTest::WebUIBrowserTest()
     : test_handler_(new WebUITestHandler()) {}
 
 void WebUIBrowserTest::SetUpInProcessBrowserTestFixture() {
-  ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory_));
-  test_data_directory_ = test_data_directory_.Append(kWebUITestFolder);
+  test_data_directory_ = GetTestDataDirectory(false);
 
   // 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);
 
   AddLibrary(FilePath(kWebUILibraryJS));
 }
 
 WebUIMessageHandler* WebUIBrowserTest::GetMockMessageHandler() {
   return NULL;
 }
 
-void WebUIBrowserTest::BuildJavascriptLibraries(std::string* content) {
+int WebUIBrowserTest::AddJSToRegistry(
+    const FilePath& library_path,
+    const char* test_case_name, const char* name,
+    const char* type_param,
+    const char* value_param,
+    ::testing::internal::TypeId fixture_class_id,
+      ::testing::internal::SetUpTestCaseFunc set_up_tc,
+    ::testing::internal::TearDownTestCaseFunc tear_down_tc,
+    ::testing::internal::TestMetaFactoryBase<std::string>* meta_factory) {
+  std::vector<std::string> testFuncs;
+  EXPECT_TRUE(GetTestFuncs(library_path, &testFuncs));
+  for (std::vector<std::string>::const_iterator it = testFuncs.begin();
+      it != testFuncs.end(); ++it) {
+    std::string test_name = *it + "/" + name;

[David Tseng, 2011/05/30 20:44:49]

Should
    std::string test_name = *it + "/" + name; 
just be
    std::string test_name = *it; 
(see other comment).

or
    std::string test_name = name + "/" + *it; 

since *it is the more specific identifier?

[Sheridan Rawlins, 2011/05/31 23:15:00]

I prefer to have the C++ Testname available (as mentioned in my comment on
web_ui_browsertest.h, for the case where you want to run the same .js file
against different locations, or, more probably, with different mock side-effects
(ACTIONs).

The javascript test name (*it) must come first in order for DISABLED_ & FLAKY_
to work properly.

On 2011/05/30 20:44:49, David Tseng wrote:

+    ::testing::internal::MakeAndRegisterTestInfo(
+        test_case_name, test_name.c_str(),
+        type_param,
+        value_param,
+        fixture_class_id,
+        set_up_tc,
+        tear_down_tc,
+        meta_factory->CreateTestFactory(*it));
+  }
+  return testFuncs.size();
+}
+
+void WebUIBrowserTest::BuildJavascriptLibraries(std::string* content) const {
   ASSERT_TRUE(content != NULL);
-  std::string library_content, src_content;
+  std::string library_content;
 
-  std::vector<FilePath>::iterator user_libraries_iterator;
-  for (user_libraries_iterator = user_libraries.begin();
-       user_libraries_iterator != user_libraries.end();
+  std::vector<FilePath>::const_iterator user_libraries_iterator;
+  for (user_libraries_iterator = user_libraries_.begin();
+       user_libraries_iterator != user_libraries_.end();
        ++user_libraries_iterator) {
-    if (user_libraries_iterator->IsAbsolute()) {
-      ASSERT_TRUE(file_util::ReadFileToString(*user_libraries_iterator,
-                                              &library_content));
-    } else {
-      ASSERT_TRUE(file_util::ReadFileToString(
-          test_data_directory_.Append(*user_libraries_iterator),
-              &library_content));
-    }
+    ReadLibraryToString(test_data_directory_, *user_libraries_iterator,
+                        &library_content);
     content->append(library_content);
     content->append(";\n");
   }
 }
 
 string16 WebUIBrowserTest::BuildRunTestJSCall(
     const std::string& function_name,
     const WebUIBrowserTest::ConstValueVector& test_func_args) {
   WebUIBrowserTest::ConstValueVector arguments;
   StringValue function_name_arg(function_name);
@@ skipping 24 matching lines @@
       called_function = WebUI::GetJavascriptCall(function_name,
                                                  function_arguments);
     }
     content.append(UTF16ToUTF8(called_function));
   }
   SetupHandlers();
   logging::SetLogMessageHandler(&LogHandler);
   bool result = test_handler_->RunJavascript(content, is_test);
   logging::SetLogMessageHandler(NULL);
 
-  if (error_messages_.size() > 0) {
+  if (error_messages_.Get().size() > 0) {
     LOG(ERROR) << "Encountered javascript console error(s)";
     result = false;
-    error_messages_.clear();
+    error_messages_.Get().clear();
   }
   return result;
 }
 
 void WebUIBrowserTest::SetupHandlers() {
   WebUI* web_ui_instance =
       browser()->GetSelectedTabContents()->web_ui();
   ASSERT_TRUE(web_ui_instance != NULL);
   web_ui_instance->register_callback_overwrites(true);
   test_handler_->Attach(web_ui_instance);
 
   if (GetMockMessageHandler())
     GetMockMessageHandler()->Attach(web_ui_instance);
 }
 
 void WebUIBrowserTest::AddLibrary(const FilePath& library_path) {
-  user_libraries.push_back(library_path);
+  user_libraries_.push_back(library_path);
 }
 
 IN_PROC_BROWSER_TEST_F(WebUIBrowserTest, TestSamplePass) {
-  AddLibrary(FilePath(FILE_PATH_LITERAL("sample_downloads.js")));
+  AddLibrary(FilePath(FILE_PATH_LITERAL("sample_passing.js")));
 
   // Navigate to UI.
   // TODO(dtseng): make accessor for subclasses to return?
   ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIDownloadsURL));
 
   ASSERT_TRUE(RunJavascriptTest("testAssertFalse"));
   ASSERT_TRUE(RunJavascriptTest("testInitialFocus"));
+}
+
+IN_PROC_BROWSER_TEST_F(WebUIBrowserTest, TestSampleFail) {
+  AddLibrary(FilePath(FILE_PATH_LITERAL("sample_failing.js")));
+
+  // Navigate to UI.
+  // TODO(dtseng): make accessor for subclasses to return?
+  ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIDownloadsURL));
+
   ASSERT_FALSE(RunJavascriptTest("testConsoleError"));
 }
+
+WEB_UI_BROWSER_TEST_JS(WebUIBrowserTest, TestJSPass,
+                       FILE_PATH_LITERAL("sample_passing.js")) {
+  ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIDownloadsURL));
+}
+
+WEB_UI_BROWSER_TEST_JS_FALSE(WebUIBrowserTest, TestJSFail,
+                             FILE_PATH_LITERAL("sample_failing.js")) {
+  ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIDownloadsURL));
+}