| 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("android_package", "abc"); |
| 28 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 29 ASSERT_TRUE(status.IsOk()); |
| 30 ASSERT_TRUE(capabilities.HasAndroidPackage()); |
| 31 ASSERT_EQ("abc", capabilities.android_package); |
| 32 } |
| 33 |
| 34 TEST(ParseCapabilities, IllegalAndroidPackage) { |
| 35 Capabilities capabilities; |
| 36 base::DictionaryValue options; |
| 37 options.SetInteger("android_package", 123); |
| 38 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 39 ASSERT_FALSE(status.IsOk()); |
| 40 } |
| 41 |
| 42 TEST(ParseCapabilities, UnsupportedCapabilityForAndroid) { |
| 43 Capabilities capabilities; |
| 44 base::DictionaryValue options; |
| 45 options.SetString("android_package", "abc"); |
| 46 options.SetString("logPath", "path/to/log"); |
| 47 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 48 ASSERT_FALSE(status.IsOk()); |
| 49 } |
| 50 |
| 51 TEST(ParseCapabilities, EmptyAndroidPackage) { |
| 52 Capabilities capabilities; |
| 53 base::DictionaryValue options; |
| 54 options.SetString("android_package", ""); |
| 55 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 56 ASSERT_FALSE(status.IsOk()); |
| 57 } |
| 58 |
| 59 TEST(ParseCapabilities, ChromeBinaryExists) { |
| 60 Capabilities capabilities; |
| 61 base::DictionaryValue options; |
| 62 options.SetString("binary", "binary"); |
| 63 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 64 ASSERT_TRUE(status.IsOk()); |
| 65 ASSERT_EQ(FILE_PATH_LITERAL("binary"), capabilities.chrome_exe.value()); |
| 66 } |
| 67 |
| 68 TEST(ParseCapabilities, ChromeBinaryNotExists) { |
| 69 Capabilities capabilities; |
| 70 base::DictionaryValue options; |
| 71 options.SetString("binary", "binary"); |
| 72 Status status = capabilities.Parse(options, base::Bind(&FileNotExists)); |
| 73 ASSERT_FALSE(status.IsOk()); |
| 74 } |
| 75 |
| 76 TEST(ParseCapabilities, LogPath) { |
| 77 Capabilities capabilities; |
| 78 base::DictionaryValue options; |
| 79 options.SetString("logPath", "path/to/logfile"); |
| 80 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 81 ASSERT_TRUE(status.IsOk()); |
| 82 ASSERT_EQ("path/to/logfile", capabilities.log_path); |
| 83 } |
| 84 |
| 85 TEST(ParseCapabilities, Args) { |
| 86 Capabilities capabilities; |
| 87 base::ListValue args; |
| 88 args.AppendString("arg1"); |
| 89 args.AppendString("arg2=val"); |
| 90 base::DictionaryValue options; |
| 91 options.Set("args", args.DeepCopy()); |
| 92 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 93 ASSERT_TRUE(status.IsOk()); |
| 94 ASSERT_TRUE(capabilities.args.Equals(&args)); |
| 95 } |
| 96 |
| 97 TEST(ParseCapabilities, Prefs) { |
| 98 Capabilities capabilities; |
| 99 base::DictionaryValue prefs; |
| 100 prefs.SetString("key1", "value1"); |
| 101 prefs.SetString("key2.k", "value2"); |
| 102 base::DictionaryValue options; |
| 103 options.Set("prefs", prefs.DeepCopy()); |
| 104 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 105 ASSERT_TRUE(status.IsOk()); |
| 106 ASSERT_TRUE(capabilities.prefs->Equals(&prefs)); |
| 107 } |
| 108 |
| 109 TEST(ParseCapabilities, LocalState) { |
| 110 Capabilities capabilities; |
| 111 base::DictionaryValue local_state; |
| 112 local_state.SetString("s1", "v1"); |
| 113 local_state.SetString("s2.s", "v2"); |
| 114 base::DictionaryValue options; |
| 115 options.Set("localState", local_state.DeepCopy()); |
| 116 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 117 ASSERT_TRUE(status.IsOk()); |
| 118 ASSERT_TRUE(capabilities.local_state->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("extensions", extensions.DeepCopy()); |
| 128 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 129 ASSERT_TRUE(status.IsOk()); |
| 130 ASSERT_TRUE(capabilities.extensions->Equals(&extensions)); |
| 131 } |
| 132 |
| 133 TEST(ParseCapabilities, UnrecognizedProxyType) { |
| 134 Capabilities capabilities; |
| 135 base::DictionaryValue proxy; |
| 136 proxy.SetString("proxyType", "unknown proxy type"); |
| 137 base::DictionaryValue options; |
| 138 options.Set("proxy", proxy.DeepCopy()); |
| 139 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 140 ASSERT_FALSE(status.IsOk()); |
| 141 } |
| 142 |
| 143 TEST(ParseCapabilities, IllegalProxyType) { |
| 144 Capabilities capabilities; |
| 145 base::DictionaryValue proxy; |
| 146 proxy.SetInteger("proxyType", 123); |
| 147 base::DictionaryValue options; |
| 148 options.Set("proxy", proxy.DeepCopy()); |
| 149 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 150 ASSERT_FALSE(status.IsOk()); |
| 151 } |
| 152 |
| 153 TEST(ParseCapabilities, DirectProxy) { |
| 154 Capabilities capabilities; |
| 155 base::DictionaryValue proxy; |
| 156 proxy.SetString("proxyType", "DIRECT"); |
| 157 base::DictionaryValue options; |
| 158 options.Set("proxy", proxy.DeepCopy()); |
| 159 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 160 ASSERT_TRUE(status.IsOk()); |
| 161 base::ListValue expected_args; |
| 162 expected_args.AppendString("no-proxy-server"); |
| 163 ASSERT_TRUE(capabilities.args.Equals(&expected_args)); |
| 164 } |
| 165 |
| 166 TEST(ParseCapabilities, SystemProxy) { |
| 167 Capabilities capabilities; |
| 168 base::DictionaryValue proxy; |
| 169 proxy.SetString("proxyType", "system"); |
| 170 base::DictionaryValue options; |
| 171 options.Set("proxy", proxy.DeepCopy()); |
| 172 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 173 ASSERT_TRUE(status.IsOk()); |
| 174 ASSERT_TRUE(capabilities.args.empty()); |
| 175 } |
| 176 |
| 177 TEST(ParseCapabilities, PacProxy) { |
| 178 Capabilities capabilities; |
| 179 base::DictionaryValue proxy; |
| 180 proxy.SetString("proxyType", "PAC"); |
| 181 proxy.SetString("proxyAutoconfigUrl", "test.wpad"); |
| 182 base::DictionaryValue options; |
| 183 options.Set("proxy", proxy.DeepCopy()); |
| 184 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 185 ASSERT_TRUE(status.IsOk()); |
| 186 base::ListValue expected_args; |
| 187 expected_args.AppendString("proxy-pac-url=test.wpad"); |
| 188 ASSERT_TRUE(capabilities.args.Equals(&expected_args)); |
| 189 } |
| 190 |
| 191 TEST(ParseCapabilities, MissingProxyAutoconfigUrl) { |
| 192 Capabilities capabilities; |
| 193 base::DictionaryValue proxy; |
| 194 proxy.SetString("proxyType", "PAC"); |
| 195 proxy.SetString("httpProxy", "http://localhost:8001"); |
| 196 base::DictionaryValue options; |
| 197 options.Set("proxy", proxy.DeepCopy()); |
| 198 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 199 ASSERT_FALSE(status.IsOk()); |
| 200 } |
| 201 |
| 202 TEST(ParseCapabilities, AutodetectProxy) { |
| 203 Capabilities capabilities; |
| 204 base::DictionaryValue proxy; |
| 205 proxy.SetString("proxyType", "autodetect"); |
| 206 base::DictionaryValue options; |
| 207 options.Set("proxy", proxy.DeepCopy()); |
| 208 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 209 ASSERT_TRUE(status.IsOk()); |
| 210 base::ListValue expected_args; |
| 211 expected_args.AppendString("proxy-auto-detect"); |
| 212 ASSERT_TRUE(capabilities.args.Equals(&expected_args)); |
| 213 } |
| 214 |
| 215 TEST(ParseCapabilities, ManualProxy) { |
| 216 Capabilities capabilities; |
| 217 base::DictionaryValue proxy; |
| 218 proxy.SetString("proxyType", "manual"); |
| 219 proxy.SetString("ftpProxy", "localhost:9001"); |
| 220 proxy.SetString("httpProxy", "localhost:8001"); |
| 221 proxy.SetString("sslProxy", "localhost:10001"); |
| 222 proxy.SetString("noProxy", "google.com, youtube.com"); |
| 223 base::DictionaryValue options; |
| 224 options.Set("proxy", proxy.DeepCopy()); |
| 225 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 226 ASSERT_TRUE(status.IsOk()); |
| 227 base::ListValue expected_args; |
| 228 expected_args.AppendString("proxy-server=ftp=localhost:9001;" |
| 229 "http=localhost:8001;https=localhost:10001"); |
| 230 expected_args.AppendString("proxy-bypass-list=google.com, youtube.com"); |
| 231 ASSERT_TRUE(capabilities.args.Equals(&expected_args)); |
| 232 } |
| 233 |
| 234 TEST(ParseCapabilities, MissingSettingForManualProxy) { |
| 235 Capabilities capabilities; |
| 236 base::DictionaryValue proxy; |
| 237 proxy.SetString("proxyType", "manual"); |
| 238 base::DictionaryValue options; |
| 239 options.Set("proxy", proxy.DeepCopy()); |
| 240 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 241 ASSERT_FALSE(status.IsOk()); |
| 242 } |
| 243 |
| 244 TEST(ParseCapabilities, UnsupportedCapabilityForDesktopChrome) { |
| 245 Capabilities capabilities; |
| 246 base::DictionaryValue options; |
| 247 options.SetString("abc", "123"); |
| 248 Status status = capabilities.Parse(options, base::Bind(&FileAlwaysExists)); |
| 249 ASSERT_FALSE(status.IsOk()); |
| 250 } |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 13185004:
[chromedriver] Implement proxy capability. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src