[chromedriver] Implement reconnection to DevTools.

chrome/test/chromedriver/chrome_impl_unittest.cc

 // Copyright (c) 2012 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 <list>
 #include <string>
 
+#include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/chrome_impl.h"
 #include "chrome/test/chromedriver/devtools_client.h"
 #include "chrome/test/chromedriver/status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+namespace {
+
+Status ParseData(const std::string& data,
+           const base::Callback<Status(base::ListValue*)>& parser) {
+  scoped_ptr<base::Value> value(base::JSONReader::Read(data));
+  if (!value.get())
+    return Status(kUnknownError, "invalid JSON");
+  base::ListValue* list;
+  if (!value->GetAsList(&list))
+    return Status(kUnknownError, "input data should be a json list");
+  return parser.Run(list);
+}
+
+}  // namespace
+
 TEST(ParsePagesInfo, Normal) {
   std::list<std::string> ids;
-  Status status = internal::ParsePagesInfo(
-      "[{\"type\": \"page\", \"id\":\"1\","
+  Status status = ParseData(
+      "[{\"type\": \"page\", \"id\": \"1\","
       "  \"webSocketDebuggerUrl\": \"http://debugurl\"}]",
-      &ids);
+      base::Bind(&internal::ParsePagesInfo, &ids));
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(1u, ids.size());
   ASSERT_EQ("1", ids.front());
 }
 
 TEST(ParsePagesInfo, Multiple) {
   std::list<std::string> ids;
-  Status status = internal::ParsePagesInfo(
-      "[{\"type\": \"page\", \"id\":\"1\","
+  Status status = ParseData(
+      "[{\"type\": \"page\", \"id\": \"1\","
       "  \"webSocketDebuggerUrl\": \"http://debugurl\"},"
-      " {\"type\": \"page\", \"id\":\"2\","
+      " {\"type\": \"page\", \"id\": \"2\","
       "  \"webSocketDebuggerUrl\": \"http://debugurl2\"}]",
-      &ids);
+      base::Bind(&internal::ParsePagesInfo, &ids));
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(2u, ids.size());
   ASSERT_EQ("1", ids.front());
   ASSERT_EQ("2", ids.back());
 }
 
+TEST(ParsePagesInfo, TypeNotPage) {
+  std::list<std::string> ids;
+  Status status = ParseData(
+      "[{\"type\": \"other\", \"id\": \"1\","
+      "  \"webSocketDebuggerUrl\": \"http://debugurl\"},"
+      " {\"type\": \"page\", \"id\": \"2\","
+      "  \"webSocketDebuggerUrl\": \"http://debugurl2\"}]",
+      base::Bind(&internal::ParsePagesInfo, &ids));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_EQ(1u, ids.size());
+  ASSERT_EQ("2", ids.front());
+}
+
 TEST(ParsePagesInfo, WithoutDebuggerUrl) {
   std::list<std::string> ids;
-  Status status = internal::ParsePagesInfo(
-      "[{\"type\": \"page\", \"id\":\"1\","
+  Status status = ParseData(
+      "[{\"type\": \"page\", \"id\": \"1\","
       "  \"webSocketDebuggerUrl\": \"http://debugurl\"},"
-      " {\"type\": \"page\", \"id\":\"2\"}]",
-      &ids);
+      " {\"type\": \"page\", \"id\": \"2\"}]",
+      base::Bind(&internal::ParsePagesInfo, &ids));
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(2u, ids.size());
   ASSERT_EQ("1", ids.front());
   ASSERT_EQ("2", ids.back());
 }
 
 namespace {
 
-void AssertFails(const std::string& data) {
-  std::list<std::string> urls;
-  Status status = internal::ParsePagesInfo(data, &urls);
+void AssertParsePagesInfoFails(const std::string& data) {
+  std::list<std::string> ids;
+  Status status = ParseData(data, base::Bind(&internal::ParsePagesInfo, &ids));
   ASSERT_FALSE(status.IsOk());
-  ASSERT_EQ(0u, urls.size());
+  ASSERT_EQ(0u, ids.size());
 }
 
 }  // namespace
 
-TEST(ParsePagesInfo, InvalidJSON) {
-  AssertFails("[");
+TEST(ParsePagesInfo, NonDictionary) {
+  AssertParsePagesInfoFails("[1]");
 }
 
-TEST(ParsePagesInfo, NonList) {
-  AssertFails("{}");
+TEST(ParsePagesInfo, NoType) {
+  AssertParsePagesInfoFails("[{\"id\": 1}]");
 }
 
-TEST(ParsePagesInfo, NonDictionary) {
-  AssertFails("[1]");
+TEST(ParsePagesInfo, InvalidType) {
+  AssertParsePagesInfoFails("[{\"type\": 1, \"id\": \"1\"}]");
 }
 
-TEST(ParsePagesInfo, NoDebuggerUrl) {
-  AssertFails("[{\"hi\": 1}]");
+TEST(ParsePagesInfo, NoId) {
+  AssertParsePagesInfoFails("[{\"type\": \"page\", \"hi\": 1}]");
 }
 
-TEST(ParsePagesInfo, InvalidDebuggerUrl) {
-  AssertFails("[{\"webSocketDebuggerUrl\": 1}]");
+TEST(ParsePagesInfo, InvalidId) {
+  AssertParsePagesInfoFails("[{\"type\": \"page\", \"id\": 1}]");
 }
+
+TEST(ParseDevToolsInfo, Normal) {
+  std::list<std::string> page_devtools_ids;
+  std::list<std::string> frontend_devtools_ids;
+  Status status = ParseData(
+      "[{\"type\": \"other\",  \"id\": \"1\","
+      "  \"url\": \"chrome-devtools://a\"}]",
+      base::Bind(&internal::ParseDevToolsInfo,
+                 &page_devtools_ids, &frontend_devtools_ids));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_EQ(0u, page_devtools_ids.size());
+  ASSERT_EQ(1u, frontend_devtools_ids.size());
+}
+
+TEST(ParseDevToolsInfo, Multiple) {
+  std::list<std::string> page_devtools_ids;
+  std::list<std::string> frontend_devtools_ids;
+  Status status = ParseData(
+      "[{\"type\": \"other\",  \"id\": \"1\","
+      "  \"url\": \"chrome-devtools://a\"},"
+      " {\"type\": \"page\",  \"id\": \"2\","
+      "  \"url\": \"chrome-devtools://b\"}]",
+      base::Bind(&internal::ParseDevToolsInfo,
+                 &page_devtools_ids, &frontend_devtools_ids));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_EQ(1u, page_devtools_ids.size());
+  ASSERT_EQ(1u, frontend_devtools_ids.size());
+}
+
+TEST(ParseDevToolsInfo, NoDevToolsFrontend) {
+  std::list<std::string> page_devtools_ids;
+  std::list<std::string> frontend_devtools_ids;
+  Status status = ParseData(
+      "[{\"type\": \"page\",  \"id\": \"1\", \"url\": \"http://abc\"}]",
+      base::Bind(&internal::ParseDevToolsInfo,
+                 &page_devtools_ids, &frontend_devtools_ids));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_EQ(0u, page_devtools_ids.size());
+  ASSERT_EQ(0u, frontend_devtools_ids.size());
+}
+
+namespace {
+
+void AssertParseDevToolsInfoFails(const std::string& data) {
+  std::list<std::string> page_devtools_ids;
+  std::list<std::string> frontend_devtools_ids;
+  Status status = ParseData(
+      data, base::Bind(&internal::ParseDevToolsInfo,
+                       &page_devtools_ids, &frontend_devtools_ids));
+  ASSERT_FALSE(status.IsOk());
+  ASSERT_EQ(0u, page_devtools_ids.size());
+  ASSERT_EQ(0u, frontend_devtools_ids.size());
+}
+
+}  // namespace
+
+TEST(ParseDevToolsInfo, NonDictionary) {
+  AssertParsePagesInfoFails("[1]");
+}
+
+TEST(ParseDevToolsInfo, NoUrl) {
+  AssertParseDevToolsInfoFails("[{\"type\": \"page\", \"id\": \"1\"}]");
+}
+
+TEST(ParseDevToolsInfo, InvalidUrl) {
+  AssertParseDevToolsInfoFails(
+      "[{\"type\": \"page\", \"url\": [], \"id\": \"1\"}]");
+}
+
+TEST(ParseDevToolsInfo, NoId) {
+  AssertParseDevToolsInfoFails(
+      "[{\"type\": \"page\", \"url\": \"chrome-devtools://a\"}]");
+}
+
+TEST(ParseDevToolsInfo, InvalidId) {
+  AssertParseDevToolsInfoFails(
+      "[{\"type\": \"page\", \"id\": 1, \"url\": \"chrome-devtools://a\"}]");
+}
+
+TEST(ParseDevToolsInfo, NoType) {
+  AssertParseDevToolsInfoFails(
+      "[{\"url\": \"chrome-devtools://a\", \"id\": \"1\"}]");
+}
+
+TEST(ParseDevToolsInfo, InvalidType) {
+  AssertParseDevToolsInfoFails(
+      "[{\"type\": \"1\", \"id\": 1, \"url\": \"chrome-devtools://a\"}]");
+}
+
+TEST(CheckPageDebuggerUrl, NoDebuggerUrl) {
+  std::string page_id = "1";
+  bool has_debugger_url = true;
+  Status status = ParseData(
+      "[{\"id\": \"1\"}]",
+      base::Bind(&internal::CheckPageDebuggerUrl,
+                 page_id, &has_debugger_url));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_FALSE(has_debugger_url);
+}
+
+TEST(CheckPageDebuggerUrl, HasDebuggerUrl) {
+  std::string page_id = "1";
+  bool has_debugger_url = false;
+  Status status = ParseData(
+      "[{\"id\": \"1\", \"webSocketDebuggerUrl\": \"ws://1\"}]",
+      base::Bind(&internal::CheckPageDebuggerUrl,
+                 page_id, &has_debugger_url));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_TRUE(has_debugger_url);
+}
+
+namespace {
+
+void AssertCheckPageDebuggerUrlFails(const std::string& data) {
+  std::string page_id = "1";
+  bool has_debugger_url = false;
+  Status status = ParseData(
+      data, base::Bind(&internal::CheckPageDebuggerUrl,
+                       page_id, &has_debugger_url));
+  ASSERT_FALSE(status.IsOk());
+  ASSERT_FALSE(has_debugger_url);
+}
+
+}  // namespace
+
+TEST(CheckPageDebuggerUrl, NonDictionary) {
+  AssertCheckPageDebuggerUrlFails("[1]");
+}
+
+TEST(CheckPageDebuggerUrl, NoId) {
+  AssertCheckPageDebuggerUrlFails("[{\"webSocketDebuggerUrl\": \"http://1\"}]");
+}
+
+TEST(CheckPageDebuggerUrl, InvalidId) {
+  AssertCheckPageDebuggerUrlFails(
+      "[{\"id\": 1, \"webSocketDebuggerUrl\": \"http://1\"}]");
+}