| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "chrome/test/chromedriver/capabilities_parser.h" |
| 6 |
| 7 #include "base/bind.h" |
| 8 #include "base/values.h" |
| 9 #include "chrome/test/chromedriver/chrome/status.h" |
| 10 #include "testing/gtest/include/gtest/gtest.h" |
| 11 |
| 12 namespace { |
| 13 |
| 14 bool FileAlwaysExists(const base::FilePath& file) { |
| 15 return true; |
| 16 } |
| 17 |
| 18 bool FileNotExists(const base::FilePath& file) { |
| 19 return false; |
| 20 } |
| 21 |
| 22 } // namespace |
| 23 |
| 24 TEST(ParseCapabilities, WithAndroidPackage) { |
| 25 Capabilities capabilities; |
| 26 base::DictionaryValue options; |
| 27 options.SetString("chromeOptions.android_package", "abc"); |
| 28 Status status = ParseCapabilities( |
| 29 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 30 ASSERT_TRUE(status.IsOk()); |
| 31 ASSERT_TRUE(capabilities.HasAndroidPackage()); |
| 32 ASSERT_EQ("abc", capabilities.android_package); |
| 33 } |
| 34 |
| 35 TEST(ParseCapabilities, IllegalAndroidPackage) { |
| 36 Capabilities capabilities; |
| 37 base::DictionaryValue options; |
| 38 options.SetInteger("chromeOptions.android_package", 123); |
| 39 Status status = ParseCapabilities( |
| 40 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 41 ASSERT_FALSE(status.IsOk()); |
| 42 } |
| 43 |
| 44 TEST(ParseCapabilities, EmptyAndroidPackage) { |
| 45 Capabilities capabilities; |
| 46 base::DictionaryValue options; |
| 47 options.SetString("chromeOptions.android_package", ""); |
| 48 Status status = ParseCapabilities( |
| 49 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 50 ASSERT_FALSE(status.IsOk()); |
| 51 } |
| 52 |
| 53 TEST(ParseCapabilities, ChromeBinaryExists) { |
| 54 Capabilities capabilities; |
| 55 base::DictionaryValue options; |
| 56 options.SetString("chromeOptions.binary", "binary"); |
| 57 Status status = ParseCapabilities( |
| 58 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 59 ASSERT_TRUE(status.IsOk()); |
| 60 ASSERT_EQ(FILE_PATH_LITERAL("binary"), capabilities.chrome_exe.value()); |
| 61 } |
| 62 |
| 63 TEST(ParseCapabilities, ChromeBinaryNotExists) { |
| 64 Capabilities capabilities; |
| 65 base::DictionaryValue options; |
| 66 options.SetString("chromeOptions.binary", "binary"); |
| 67 Status status = ParseCapabilities( |
| 68 options, &capabilities, base::Bind(&FileNotExists)); |
| 69 ASSERT_FALSE(status.IsOk()); |
| 70 } |
| 71 |
| 72 TEST(ParseCapabilities, LogPath) { |
| 73 Capabilities capabilities; |
| 74 base::DictionaryValue options; |
| 75 options.SetString("chromeOptions.logPath", "path/to/logfile"); |
| 76 Status status = ParseCapabilities( |
| 77 options, &capabilities, base::Bind(&FileNotExists)); |
| 78 ASSERT_TRUE(status.IsOk()); |
| 79 ASSERT_EQ("path/to/logfile", capabilities.log_path); |
| 80 } |
| 81 |
| 82 TEST(ParseCapabilities, Args) { |
| 83 Capabilities capabilities; |
| 84 base::ListValue args; |
| 85 args.AppendString("arg1"); |
| 86 args.AppendString("arg2=val"); |
| 87 base::DictionaryValue options; |
| 88 options.Set("chromeOptions.args", args.DeepCopy()); |
| 89 Status status = ParseCapabilities( |
| 90 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 91 ASSERT_TRUE(status.IsOk()); |
| 92 ASSERT_TRUE(capabilities.args_list.Equals(&args)); |
| 93 } |
| 94 |
| 95 TEST(ParseCapabilities, Prefs) { |
| 96 Capabilities capabilities; |
| 97 base::DictionaryValue prefs; |
| 98 prefs.SetString("key1", "value1"); |
| 99 prefs.SetString("key2.k", "value2"); |
| 100 base::DictionaryValue options; |
| 101 options.Set("chromeOptions.prefs", prefs.DeepCopy()); |
| 102 Status status = ParseCapabilities( |
| 103 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 104 ASSERT_TRUE(status.IsOk()); |
| 105 ASSERT_TRUE(capabilities.prefs_dict->Equals(&prefs)); |
| 106 } |
| 107 |
| 108 TEST(ParseCapabilities, LocalState) { |
| 109 Capabilities capabilities; |
| 110 base::DictionaryValue local_state; |
| 111 local_state.SetString("s1", "v1"); |
| 112 local_state.SetString("s2.s", "v2"); |
| 113 base::DictionaryValue options; |
| 114 options.Set("chromeOptions.localState", local_state.DeepCopy()); |
| 115 Status status = ParseCapabilities( |
| 116 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 117 ASSERT_TRUE(status.IsOk()); |
| 118 ASSERT_TRUE(capabilities.local_state_dict->Equals(&local_state)); |
| 119 } |
| 120 |
| 121 TEST(ParseCapabilities, Extensions) { |
| 122 Capabilities capabilities; |
| 123 base::ListValue extensions; |
| 124 extensions.AppendString("ext1"); |
| 125 extensions.AppendString("ext2"); |
| 126 base::DictionaryValue options; |
| 127 options.Set("chromeOptions.extensions", extensions.DeepCopy()); |
| 128 Status status = ParseCapabilities( |
| 129 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 130 ASSERT_TRUE(status.IsOk()); |
| 131 ASSERT_TRUE(capabilities.extensions_list->Equals(&extensions)); |
| 132 } |
| 133 |
| 134 TEST(ParseCapabilities, UnrecognizedProxyType) { |
| 135 Capabilities capabilities; |
| 136 base::DictionaryValue proxy; |
| 137 proxy.SetString("proxyType", "unknown proxy type"); |
| 138 base::DictionaryValue options; |
| 139 options.Set("chromeOptions.proxy", proxy.DeepCopy()); |
| 140 Status status = ParseCapabilities( |
| 141 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 142 ASSERT_FALSE(status.IsOk()); |
| 143 } |
| 144 |
| 145 TEST(ParseCapabilities, IllegalProxyType) { |
| 146 Capabilities capabilities; |
| 147 base::DictionaryValue proxy; |
| 148 proxy.SetInteger("proxyType", 123); |
| 149 base::DictionaryValue options; |
| 150 options.Set("chromeOptions.proxy", proxy.DeepCopy()); |
| 151 Status status = ParseCapabilities( |
| 152 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 153 ASSERT_FALSE(status.IsOk()); |
| 154 } |
| 155 |
| 156 TEST(ParseCapabilities, DirectProxy) { |
| 157 Capabilities capabilities; |
| 158 base::DictionaryValue proxy; |
| 159 proxy.SetString("proxyType", "DIRECT"); |
| 160 base::DictionaryValue options; |
| 161 options.Set("chromeOptions.proxy", proxy.DeepCopy()); |
| 162 Status status = ParseCapabilities( |
| 163 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 164 ASSERT_TRUE(status.IsOk()); |
| 165 base::ListValue expected_args_list; |
| 166 expected_args_list.AppendString("no-proxy-server"); |
| 167 ASSERT_TRUE(capabilities.args_list.Equals(&expected_args_list)); |
| 168 } |
| 169 |
| 170 TEST(ParseCapabilities, SystemProxy) { |
| 171 Capabilities capabilities; |
| 172 base::DictionaryValue proxy; |
| 173 proxy.SetString("proxyType", "system"); |
| 174 base::DictionaryValue options; |
| 175 options.Set("chromeOptions.proxy", proxy.DeepCopy()); |
| 176 Status status = ParseCapabilities( |
| 177 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 178 ASSERT_TRUE(status.IsOk()); |
| 179 ASSERT_TRUE(capabilities.args_list.empty()); |
| 180 } |
| 181 |
| 182 TEST(ParseCapabilities, PacProxy) { |
| 183 Capabilities capabilities; |
| 184 base::DictionaryValue proxy; |
| 185 proxy.SetString("proxyType", "PAC"); |
| 186 proxy.SetString("proxyAutoconfigUrl", "test.wpad"); |
| 187 base::DictionaryValue options; |
| 188 options.Set("chromeOptions.proxy", proxy.DeepCopy()); |
| 189 Status status = ParseCapabilities( |
| 190 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 191 ASSERT_TRUE(status.IsOk()); |
| 192 base::ListValue expected_args_list; |
| 193 expected_args_list.AppendString("proxy-pac-url=test.wpad"); |
| 194 ASSERT_TRUE(capabilities.args_list.Equals(&expected_args_list)); |
| 195 } |
| 196 |
| 197 TEST(ParseCapabilities, MissingProxyAutoconfigUrl) { |
| 198 Capabilities capabilities; |
| 199 base::DictionaryValue proxy; |
| 200 proxy.SetString("proxyType", "PAC"); |
| 201 proxy.SetString("httpProxy", "http://localhost:8001"); |
| 202 base::DictionaryValue options; |
| 203 options.Set("chromeOptions.proxy", proxy.DeepCopy()); |
| 204 Status status = ParseCapabilities( |
| 205 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 206 ASSERT_FALSE(status.IsOk()); |
| 207 } |
| 208 |
| 209 TEST(ParseCapabilities, AutodetectProxy) { |
| 210 Capabilities capabilities; |
| 211 base::DictionaryValue proxy; |
| 212 proxy.SetString("proxyType", "autodetect"); |
| 213 base::DictionaryValue options; |
| 214 options.Set("chromeOptions.proxy", proxy.DeepCopy()); |
| 215 Status status = ParseCapabilities( |
| 216 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 217 ASSERT_TRUE(status.IsOk()); |
| 218 base::ListValue expected_args_list; |
| 219 expected_args_list.AppendString("proxy-auto-detect"); |
| 220 ASSERT_TRUE(capabilities.args_list.Equals(&expected_args_list)); |
| 221 } |
| 222 |
| 223 TEST(ParseCapabilities, ManualProxy) { |
| 224 Capabilities capabilities; |
| 225 base::DictionaryValue proxy; |
| 226 proxy.SetString("proxyType", "manual"); |
| 227 proxy.SetString("ftpProxy", "localhost:9001"); |
| 228 proxy.SetString("httpProxy", "localhost:8001"); |
| 229 proxy.SetString("sslProxy", "localhost:10001"); |
| 230 proxy.SetString("noProxy", "google.com, youtube.com"); |
| 231 base::DictionaryValue options; |
| 232 options.Set("chromeOptions.proxy", proxy.DeepCopy()); |
| 233 Status status = ParseCapabilities( |
| 234 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 235 ASSERT_TRUE(status.IsOk()); |
| 236 base::ListValue expected_args_list; |
| 237 expected_args_list.AppendString("proxy-server=ftp=localhost:9001;" |
| 238 "http=localhost:8001;https=localhost:10001"); |
| 239 expected_args_list.AppendString("proxy-bypass-list=google.com, youtube.com"); |
| 240 ASSERT_TRUE(capabilities.args_list.Equals(&expected_args_list)); |
| 241 } |
| 242 |
| 243 TEST(ParseCapabilities, MissingSettingForManualProxy) { |
| 244 Capabilities capabilities; |
| 245 base::DictionaryValue proxy; |
| 246 proxy.SetString("proxyType", "manual"); |
| 247 base::DictionaryValue options; |
| 248 options.Set("chromeOptions.proxy", proxy.DeepCopy()); |
| 249 Status status = ParseCapabilities( |
| 250 options, &capabilities, base::Bind(&FileAlwaysExists)); |
| 251 ASSERT_FALSE(status.IsOk()); |
| 252 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 13185004:
[chromedriver] Implement proxy capability. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src