[chromedriver] Implement proxy capability.

chrome/test/chromedriver/capabilities_parser_unittest.cc

Index: chrome/test/chromedriver/capabilities_parser_unittest.cc
diff --git a/chrome/test/chromedriver/capabilities_parser_unittest.cc b/chrome/test/chromedriver/capabilities_parser_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..dddc59fb28d1bf5706bb2fa173c489a6cb63f508
--- /dev/null
+++ b/chrome/test/chromedriver/capabilities_parser_unittest.cc
@@ -0,0 +1,250 @@
+// Copyright (c) 2013 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/test/chromedriver/capabilities_parser.h"
+
+#include "base/bind.h"
+#include "base/values.h"
+#include "chrome/test/chromedriver/chrome/status.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+bool FileAlwaysExists(const base::FilePath& file) {
+  return true;
+}
+
+bool FileNotExists(const base::FilePath& file) {
+  return false;
+}
+
+}  // namespace
+
+TEST(ParseCapabilities, WithAndroidPackage) {
+  Capabilities capabilities;
+  base::DictionaryValue options;
+  options.SetString("android_package", "abc");
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_TRUE(capabilities.HasAndroidPackage());
+  ASSERT_EQ("abc", capabilities.android_package);
+}
+
+TEST(ParseCapabilities, IllegalAndroidPackage) {
+  Capabilities capabilities;
+  base::DictionaryValue options;
+  options.SetInteger("android_package", 123);
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_FALSE(status.IsOk());
+}
+
+TEST(ParseCapabilities, UnsupportedCapabilityForAndroid) {
+  Capabilities capabilities;
+  base::DictionaryValue options;
+  options.SetString("android_package", "abc");
+  options.SetString("logPath", "path/to/log");
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_FALSE(status.IsOk());
+}
+
+TEST(ParseCapabilities, EmptyAndroidPackage) {
+  Capabilities capabilities;
+  base::DictionaryValue options;
+  options.SetString("android_package", "");
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_FALSE(status.IsOk());
+}
+
+TEST(ParseCapabilities, ChromeBinaryExists) {
+  Capabilities capabilities;
+  base::DictionaryValue options;
+  options.SetString("binary", "binary");
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_EQ(FILE_PATH_LITERAL("binary"), capabilities.chrome_exe.value());
+}
+
+TEST(ParseCapabilities, ChromeBinaryNotExists) {
+  Capabilities capabilities;
+  base::DictionaryValue options;
+  options.SetString("binary", "binary");
+  Status status = capabilities.Parse(options, base::Bind(&FileNotExists));
+  ASSERT_FALSE(status.IsOk());
+}
+
+TEST(ParseCapabilities, LogPath) {
+  Capabilities capabilities;
+  base::DictionaryValue options;
+  options.SetString("logPath", "path/to/logfile");
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_EQ("path/to/logfile", capabilities.log_path);
+}
+
+TEST(ParseCapabilities, Args) {
+  Capabilities capabilities;
+  base::ListValue args;
+  args.AppendString("arg1");
+  args.AppendString("arg2=val");
+  base::DictionaryValue options;
+  options.Set("args", args.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_TRUE(capabilities.args.Equals(&args));
+}
+
+TEST(ParseCapabilities, Prefs) {
+  Capabilities capabilities;
+  base::DictionaryValue prefs;
+  prefs.SetString("key1", "value1");
+  prefs.SetString("key2.k", "value2");
+  base::DictionaryValue options;
+  options.Set("prefs", prefs.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_TRUE(capabilities.prefs->Equals(&prefs));
+}
+
+TEST(ParseCapabilities, LocalState) {
+  Capabilities capabilities;
+  base::DictionaryValue local_state;
+  local_state.SetString("s1", "v1");
+  local_state.SetString("s2.s", "v2");
+  base::DictionaryValue options;
+  options.Set("localState", local_state.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_TRUE(capabilities.local_state->Equals(&local_state));
+}
+
+TEST(ParseCapabilities, Extensions) {
+  Capabilities capabilities;
+  base::ListValue extensions;
+  extensions.AppendString("ext1");
+  extensions.AppendString("ext2");
+  base::DictionaryValue options;
+  options.Set("extensions", extensions.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_TRUE(capabilities.extensions->Equals(&extensions));
+}
+
+TEST(ParseCapabilities, UnrecognizedProxyType) {
+  Capabilities capabilities;
+  base::DictionaryValue proxy;
+  proxy.SetString("proxyType", "unknown proxy type");
+  base::DictionaryValue options;
+  options.Set("proxy", proxy.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_FALSE(status.IsOk());
+}
+
+TEST(ParseCapabilities, IllegalProxyType) {
+  Capabilities capabilities;
+  base::DictionaryValue proxy;
+  proxy.SetInteger("proxyType", 123);
+  base::DictionaryValue options;
+  options.Set("proxy", proxy.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_FALSE(status.IsOk());
+}
+
+TEST(ParseCapabilities, DirectProxy) {
+  Capabilities capabilities;
+  base::DictionaryValue proxy;
+  proxy.SetString("proxyType", "DIRECT");
+  base::DictionaryValue options;
+  options.Set("proxy", proxy.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  base::ListValue expected_args;
+  expected_args.AppendString("no-proxy-server");
+  ASSERT_TRUE(capabilities.args.Equals(&expected_args));
+}
+
+TEST(ParseCapabilities, SystemProxy) {
+  Capabilities capabilities;
+  base::DictionaryValue proxy;
+  proxy.SetString("proxyType", "system");
+  base::DictionaryValue options;
+  options.Set("proxy", proxy.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  ASSERT_TRUE(capabilities.args.empty());
+}
+
+TEST(ParseCapabilities, PacProxy) {
+  Capabilities capabilities;
+  base::DictionaryValue proxy;
+  proxy.SetString("proxyType", "PAC");
+  proxy.SetString("proxyAutoconfigUrl", "test.wpad");
+  base::DictionaryValue options;
+  options.Set("proxy", proxy.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  base::ListValue expected_args;
+  expected_args.AppendString("proxy-pac-url=test.wpad");
+  ASSERT_TRUE(capabilities.args.Equals(&expected_args));
+}
+
+TEST(ParseCapabilities, MissingProxyAutoconfigUrl) {
+  Capabilities capabilities;
+  base::DictionaryValue proxy;
+  proxy.SetString("proxyType", "PAC");
+  proxy.SetString("httpProxy", "http://localhost:8001");
+  base::DictionaryValue options;
+  options.Set("proxy", proxy.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_FALSE(status.IsOk());
+}
+
+TEST(ParseCapabilities, AutodetectProxy) {
+  Capabilities capabilities;
+  base::DictionaryValue proxy;
+  proxy.SetString("proxyType", "autodetect");
+  base::DictionaryValue options;
+  options.Set("proxy", proxy.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  base::ListValue expected_args;
+  expected_args.AppendString("proxy-auto-detect");
+  ASSERT_TRUE(capabilities.args.Equals(&expected_args));
+}
+
+TEST(ParseCapabilities, ManualProxy) {
+  Capabilities capabilities;
+  base::DictionaryValue proxy;
+  proxy.SetString("proxyType", "manual");
+  proxy.SetString("ftpProxy", "localhost:9001");
+  proxy.SetString("httpProxy", "localhost:8001");
+  proxy.SetString("sslProxy", "localhost:10001");
+  proxy.SetString("noProxy", "google.com, youtube.com");
+  base::DictionaryValue options;
+  options.Set("proxy", proxy.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_TRUE(status.IsOk());
+  base::ListValue expected_args;
+  expected_args.AppendString("proxy-server=ftp=localhost:9001;"
+                             "http=localhost:8001;https=localhost:10001");
+  expected_args.AppendString("proxy-bypass-list=google.com, youtube.com");
+  ASSERT_TRUE(capabilities.args.Equals(&expected_args));
+}
+
+TEST(ParseCapabilities, MissingSettingForManualProxy) {
+  Capabilities capabilities;
+  base::DictionaryValue proxy;
+  proxy.SetString("proxyType", "manual");
+  base::DictionaryValue options;
+  options.Set("proxy", proxy.DeepCopy());
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_FALSE(status.IsOk());
+}
+
+TEST(ParseCapabilities, UnsupportedCapabilityForDesktopChrome) {
+  Capabilities capabilities;
+  base::DictionaryValue options;
+  options.SetString("abc", "123");
+  Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists));
+  ASSERT_FALSE(status.IsOk());
+}