| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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 // Unit tests for helper functions for the Chrome Extensions Proxy Settings API. | |
| 6 | |
| 7 #include "base/memory/scoped_ptr.h" | |
| 8 #include "base/values.h" | |
| 9 #include "chrome/browser/extensions/extension_proxy_api_constants.h" | |
| 10 #include "chrome/browser/extensions/extension_proxy_api_helpers.h" | |
| 11 #include "chrome/browser/prefs/proxy_config_dictionary.h" | |
| 12 #include "chrome/browser/prefs/proxy_prefs.h" | |
| 13 #include "testing/gtest/include/gtest/gtest.h" | |
| 14 | |
| 15 namespace keys = extension_proxy_api_constants; | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 const char kSamplePacScript[] = "test"; | |
| 20 const char kSamplePacScriptAsDataUrl[] = | |
| 21 "data:application/x-ns-proxy-autoconfig;base64,dGVzdA=="; | |
| 22 const char kSamplePacScriptUrl[] = "http://wpad/wpad.dat"; | |
| 23 | |
| 24 // Helper function to create a ProxyServer dictionary as defined in the | |
| 25 // extension API. | |
| 26 DictionaryValue* CreateTestProxyServerDict(const std::string& host) { | |
| 27 DictionaryValue* dict = new DictionaryValue; | |
| 28 dict->SetString(keys::kProxyConfigRuleHost, host); | |
| 29 return dict; | |
| 30 } | |
| 31 | |
| 32 // Helper function to create a ProxyServer dictionary as defined in the | |
| 33 // extension API. | |
| 34 DictionaryValue* CreateTestProxyServerDict(const std::string& schema, | |
| 35 const std::string& host, | |
| 36 int port) { | |
| 37 DictionaryValue* dict = new DictionaryValue; | |
| 38 dict->SetString(keys::kProxyConfigRuleScheme, schema); | |
| 39 dict->SetString(keys::kProxyConfigRuleHost, host); | |
| 40 dict->SetInteger(keys::kProxyConfigRulePort, port); | |
| 41 return dict; | |
| 42 } | |
| 43 | |
| 44 } // namespace | |
| 45 | |
| 46 namespace extension_proxy_api_helpers { | |
| 47 | |
| 48 TEST(ExtensionProxyApiHelpers, CreateDataURLFromPACScript) { | |
| 49 std::string out; | |
| 50 ASSERT_TRUE(CreateDataURLFromPACScript(kSamplePacScript, &out)); | |
| 51 EXPECT_EQ(kSamplePacScriptAsDataUrl, out); | |
| 52 } | |
| 53 | |
| 54 TEST(ExtensionProxyApiHelpers, CreatePACScriptFromDataURL) { | |
| 55 std::string out; | |
| 56 ASSERT_TRUE(CreatePACScriptFromDataURL(kSamplePacScriptAsDataUrl, &out)); | |
| 57 EXPECT_EQ(kSamplePacScript, out); | |
| 58 | |
| 59 EXPECT_FALSE(CreatePACScriptFromDataURL("http://www.google.com", &out)); | |
| 60 } | |
| 61 | |
| 62 TEST(ExtensionProxyApiHelpers, GetProxyModeFromExtensionPref) { | |
| 63 DictionaryValue proxy_config; | |
| 64 ProxyPrefs::ProxyMode mode; | |
| 65 std::string error; | |
| 66 bool bad_message = false; | |
| 67 | |
| 68 // Test positive case. | |
| 69 proxy_config.SetString( | |
| 70 keys::kProxyConfigMode, | |
| 71 ProxyPrefs::ProxyModeToString(ProxyPrefs::MODE_DIRECT)); | |
| 72 ASSERT_TRUE(GetProxyModeFromExtensionPref(&proxy_config, &mode, &error, | |
| 73 &bad_message)); | |
| 74 EXPECT_EQ(ProxyPrefs::MODE_DIRECT, mode); | |
| 75 EXPECT_EQ(std::string(), error); | |
| 76 EXPECT_FALSE(bad_message); | |
| 77 | |
| 78 // Test negative case. | |
| 79 proxy_config.SetString(keys::kProxyConfigMode, "foobar"); | |
| 80 EXPECT_FALSE(GetProxyModeFromExtensionPref(&proxy_config, &mode, &error, | |
| 81 &bad_message)); | |
| 82 EXPECT_TRUE(bad_message); | |
| 83 | |
| 84 // Do not test |error|, as an invalid enumeration value is considered an | |
| 85 // internal error. It should be filtered by the extensions API. | |
| 86 } | |
| 87 | |
| 88 TEST(ExtensionProxyApiHelpers, GetPacUrlFromExtensionPref) { | |
| 89 std::string out; | |
| 90 std::string error; | |
| 91 bool bad_message = false; | |
| 92 | |
| 93 DictionaryValue proxy_config; | |
| 94 proxy_config.SetString( | |
| 95 keys::kProxyConfigMode, | |
| 96 ProxyPrefs::ProxyModeToString(ProxyPrefs::MODE_PAC_SCRIPT)); | |
| 97 | |
| 98 // Currently we are still missing a PAC script entry. | |
| 99 // This is silently ignored. | |
| 100 ASSERT_TRUE(GetPacUrlFromExtensionPref(&proxy_config, &out, &error, | |
| 101 &bad_message)); | |
| 102 EXPECT_EQ(std::string(), out); | |
| 103 EXPECT_EQ(std::string(), error); | |
| 104 EXPECT_FALSE(bad_message); | |
| 105 | |
| 106 // Set up a pac script. | |
| 107 DictionaryValue* pacScriptDict = new DictionaryValue; | |
| 108 pacScriptDict->SetString(keys::kProxyConfigPacScriptUrl, kSamplePacScriptUrl); | |
| 109 proxy_config.Set(keys::kProxyConfigPacScript, pacScriptDict); | |
| 110 | |
| 111 ASSERT_TRUE(GetPacUrlFromExtensionPref(&proxy_config, &out, &error, | |
| 112 &bad_message)); | |
| 113 EXPECT_EQ(kSamplePacScriptUrl, out); | |
| 114 EXPECT_EQ(std::string(), error); | |
| 115 EXPECT_FALSE(bad_message); | |
| 116 } | |
| 117 | |
| 118 TEST(ExtensionProxyApiHelpers, GetPacDataFromExtensionPref) { | |
| 119 std::string out; | |
| 120 std::string error; | |
| 121 bool bad_message = false; | |
| 122 | |
| 123 DictionaryValue proxy_config; | |
| 124 proxy_config.SetString( | |
| 125 keys::kProxyConfigMode, | |
| 126 ProxyPrefs::ProxyModeToString(ProxyPrefs::MODE_PAC_SCRIPT)); | |
| 127 | |
| 128 // Currently we are still missing a PAC data entry. This is silently ignored. | |
| 129 ASSERT_TRUE(GetPacDataFromExtensionPref(&proxy_config, &out, &error, | |
| 130 &bad_message)); | |
| 131 EXPECT_EQ(std::string(), out); | |
| 132 EXPECT_EQ(std::string(), error); | |
| 133 EXPECT_FALSE(bad_message); | |
| 134 | |
| 135 // Set up a PAC script. | |
| 136 DictionaryValue* pacScriptDict = new DictionaryValue; | |
| 137 pacScriptDict->SetString(keys::kProxyConfigPacScriptData, kSamplePacScript); | |
| 138 proxy_config.Set(keys::kProxyConfigPacScript, pacScriptDict); | |
| 139 | |
| 140 ASSERT_TRUE(GetPacDataFromExtensionPref(&proxy_config, &out, &error, | |
| 141 &bad_message)); | |
| 142 EXPECT_EQ(kSamplePacScript, out); | |
| 143 EXPECT_EQ(std::string(), error); | |
| 144 EXPECT_FALSE(bad_message); | |
| 145 } | |
| 146 | |
| 147 TEST(ExtensionProxyApiHelpers, GetProxyRulesStringFromExtensionPref) { | |
| 148 std::string out; | |
| 149 std::string error; | |
| 150 bool bad_message = false; | |
| 151 | |
| 152 DictionaryValue proxy_config; | |
| 153 proxy_config.SetString( | |
| 154 keys::kProxyConfigMode, | |
| 155 ProxyPrefs::ProxyModeToString(ProxyPrefs::MODE_FIXED_SERVERS)); | |
| 156 | |
| 157 // Currently we are still missing a proxy config entry. | |
| 158 // This is silently ignored. | |
| 159 ASSERT_TRUE( | |
| 160 GetProxyRulesStringFromExtensionPref(&proxy_config, &out, &error, | |
| 161 &bad_message)); | |
| 162 EXPECT_EQ(std::string(), out); | |
| 163 EXPECT_EQ(std::string(), error); | |
| 164 | |
| 165 DictionaryValue* proxy_rules = new DictionaryValue; | |
| 166 proxy_rules->Set(keys::field_name[1], CreateTestProxyServerDict("proxy1")); | |
| 167 proxy_rules->Set(keys::field_name[2], CreateTestProxyServerDict("proxy2")); | |
| 168 proxy_config.Set(keys::kProxyConfigRules, proxy_rules); | |
| 169 | |
| 170 ASSERT_TRUE( | |
| 171 GetProxyRulesStringFromExtensionPref(&proxy_config, &out, &error, | |
| 172 &bad_message)); | |
| 173 EXPECT_EQ("http=proxy1:80;https=proxy2:80", out); | |
| 174 EXPECT_EQ(std::string(), error); | |
| 175 EXPECT_FALSE(bad_message); | |
| 176 } | |
| 177 | |
| 178 TEST(ExtensionProxyApiHelpers, GetBypassListFromExtensionPref) { | |
| 179 std::string out; | |
| 180 std::string error; | |
| 181 bool bad_message = false; | |
| 182 | |
| 183 DictionaryValue proxy_config; | |
| 184 proxy_config.SetString( | |
| 185 keys::kProxyConfigMode, | |
| 186 ProxyPrefs::ProxyModeToString(ProxyPrefs::MODE_FIXED_SERVERS)); | |
| 187 | |
| 188 // Currently we are still missing a proxy config entry. | |
| 189 // This is silently ignored. | |
| 190 ASSERT_TRUE( | |
| 191 GetBypassListFromExtensionPref(&proxy_config, &out, &error, | |
| 192 &bad_message)); | |
| 193 EXPECT_EQ(std::string(), out); | |
| 194 EXPECT_EQ(std::string(), error); | |
| 195 EXPECT_FALSE(bad_message); | |
| 196 | |
| 197 ListValue* bypass_list = new ListValue; | |
| 198 bypass_list->Append(Value::CreateStringValue("host1")); | |
| 199 bypass_list->Append(Value::CreateStringValue("host2")); | |
| 200 DictionaryValue* proxy_rules = new DictionaryValue; | |
| 201 proxy_rules->Set(keys::kProxyConfigBypassList, bypass_list); | |
| 202 proxy_config.Set(keys::kProxyConfigRules, proxy_rules); | |
| 203 | |
| 204 ASSERT_TRUE( | |
| 205 GetBypassListFromExtensionPref(&proxy_config, &out, &error, | |
| 206 &bad_message)); | |
| 207 EXPECT_EQ("host1,host2", out); | |
| 208 EXPECT_EQ(std::string(), error); | |
| 209 EXPECT_FALSE(bad_message); | |
| 210 } | |
| 211 | |
| 212 TEST(ExtensionProxyApiHelpers, CreateProxyConfigDict) { | |
| 213 std::string error; | |
| 214 scoped_ptr<DictionaryValue> exp_direct(ProxyConfigDictionary::CreateDirect()); | |
| 215 scoped_ptr<DictionaryValue> out_direct( | |
| 216 CreateProxyConfigDict(ProxyPrefs::MODE_DIRECT, false, "", "", "", "", | |
| 217 &error)); | |
| 218 EXPECT_TRUE(Value::Equals(exp_direct.get(), out_direct.get())); | |
| 219 | |
| 220 scoped_ptr<DictionaryValue> exp_auto( | |
| 221 ProxyConfigDictionary::CreateAutoDetect()); | |
| 222 scoped_ptr<DictionaryValue> out_auto( | |
| 223 CreateProxyConfigDict(ProxyPrefs::MODE_AUTO_DETECT, false, "", "", "", "", | |
| 224 &error)); | |
| 225 EXPECT_TRUE(Value::Equals(exp_auto.get(), out_auto.get())); | |
| 226 | |
| 227 scoped_ptr<DictionaryValue> exp_pac_url( | |
| 228 ProxyConfigDictionary::CreatePacScript(kSamplePacScriptUrl, false)); | |
| 229 scoped_ptr<DictionaryValue> out_pac_url( | |
| 230 CreateProxyConfigDict(ProxyPrefs::MODE_PAC_SCRIPT, false, | |
| 231 kSamplePacScriptUrl, "", "", "", &error)); | |
| 232 EXPECT_TRUE(Value::Equals(exp_pac_url.get(), out_pac_url.get())); | |
| 233 | |
| 234 scoped_ptr<DictionaryValue> exp_pac_data( | |
| 235 ProxyConfigDictionary::CreatePacScript(kSamplePacScriptAsDataUrl, false)); | |
| 236 scoped_ptr<DictionaryValue> out_pac_data( | |
| 237 CreateProxyConfigDict(ProxyPrefs::MODE_PAC_SCRIPT, false, "", | |
| 238 kSamplePacScript, "", "", &error)); | |
| 239 EXPECT_TRUE(Value::Equals(exp_pac_data.get(), out_pac_data.get())); | |
| 240 | |
| 241 scoped_ptr<DictionaryValue> exp_fixed( | |
| 242 ProxyConfigDictionary::CreateFixedServers("foo:80", "localhost")); | |
| 243 scoped_ptr<DictionaryValue> out_fixed( | |
| 244 CreateProxyConfigDict(ProxyPrefs::MODE_FIXED_SERVERS, false, "", "", | |
| 245 "foo:80", "localhost", &error)); | |
| 246 EXPECT_TRUE(Value::Equals(exp_fixed.get(), out_fixed.get())); | |
| 247 | |
| 248 scoped_ptr<DictionaryValue> exp_system(ProxyConfigDictionary::CreateSystem()); | |
| 249 scoped_ptr<DictionaryValue> out_system( | |
| 250 CreateProxyConfigDict(ProxyPrefs::MODE_SYSTEM, false, "", "", "", "", | |
| 251 &error)); | |
| 252 EXPECT_TRUE(Value::Equals(exp_system.get(), out_system.get())); | |
| 253 | |
| 254 // Neither of them should have set an error. | |
| 255 EXPECT_EQ(std::string(), error); | |
| 256 } | |
| 257 | |
| 258 TEST(ExtensionProxyApiHelpers, GetProxyServer) { | |
| 259 DictionaryValue proxy_server_dict; | |
| 260 net::ProxyServer created; | |
| 261 std::string error; | |
| 262 bool bad_message = false; | |
| 263 | |
| 264 // Test simplest case, no schema nor port specified --> defaults are used. | |
| 265 proxy_server_dict.SetString(keys::kProxyConfigRuleHost, "proxy_server"); | |
| 266 ASSERT_TRUE( | |
| 267 GetProxyServer(&proxy_server_dict, net::ProxyServer::SCHEME_HTTP, | |
| 268 &created, &error, &bad_message)); | |
| 269 EXPECT_EQ("PROXY proxy_server:80", created.ToPacString()); | |
| 270 EXPECT_FALSE(bad_message); | |
| 271 | |
| 272 // Test complete case. | |
| 273 proxy_server_dict.SetString(keys::kProxyConfigRuleScheme, "socks4"); | |
| 274 proxy_server_dict.SetInteger(keys::kProxyConfigRulePort, 1234); | |
| 275 ASSERT_TRUE( | |
| 276 GetProxyServer(&proxy_server_dict, net::ProxyServer::SCHEME_HTTP, | |
| 277 &created, &error, &bad_message)); | |
| 278 EXPECT_EQ("SOCKS proxy_server:1234", created.ToPacString()); | |
| 279 EXPECT_FALSE(bad_message); | |
| 280 } | |
| 281 | |
| 282 TEST(ExtensionProxyApiHelpers, JoinUrlList) { | |
| 283 bool bad_message = false; | |
| 284 ListValue list; | |
| 285 list.Append(Value::CreateStringValue("s1")); | |
| 286 list.Append(Value::CreateStringValue("s2")); | |
| 287 list.Append(Value::CreateStringValue("s3")); | |
| 288 | |
| 289 std::string out; | |
| 290 std::string error; | |
| 291 ASSERT_TRUE(JoinUrlList(&list, ";", &out, &error, &bad_message)); | |
| 292 EXPECT_EQ("s1;s2;s3", out); | |
| 293 EXPECT_FALSE(bad_message); | |
| 294 } | |
| 295 | |
| 296 // This tests CreateProxyServerDict as well. | |
| 297 TEST(ExtensionProxyApiHelpers, CreateProxyRulesDict) { | |
| 298 scoped_ptr<DictionaryValue> browser_pref( | |
| 299 ProxyConfigDictionary::CreateFixedServers( | |
| 300 "http=proxy1:80;https=proxy2:80;ftp=proxy3:80;socks=proxy4:80", | |
| 301 "localhost")); | |
| 302 ProxyConfigDictionary config(browser_pref.get()); | |
| 303 scoped_ptr<DictionaryValue> extension_pref(CreateProxyRulesDict(config)); | |
| 304 ASSERT_TRUE(extension_pref.get()); | |
| 305 | |
| 306 scoped_ptr<DictionaryValue> expected(new DictionaryValue); | |
| 307 expected->Set("proxyForHttp", | |
| 308 CreateTestProxyServerDict("http", "proxy1", 80)); | |
| 309 expected->Set("proxyForHttps", | |
| 310 CreateTestProxyServerDict("http", "proxy2", 80)); | |
| 311 expected->Set("proxyForFtp", | |
| 312 CreateTestProxyServerDict("http", "proxy3", 80)); | |
| 313 expected->Set("fallbackProxy", | |
| 314 CreateTestProxyServerDict("socks4", "proxy4", 80)); | |
| 315 ListValue* bypass_list = new ListValue; | |
| 316 bypass_list->Append(Value::CreateStringValue("localhost")); | |
| 317 expected->Set(keys::kProxyConfigBypassList, bypass_list); | |
| 318 | |
| 319 EXPECT_TRUE(Value::Equals(expected.get(), extension_pref.get())); | |
| 320 } | |
| 321 | |
| 322 // Test if a PAC script URL is specified. | |
| 323 TEST(ExtensionProxyApiHelpers, CreatePacScriptDictWithUrl) { | |
| 324 scoped_ptr<DictionaryValue> browser_pref( | |
| 325 ProxyConfigDictionary::CreatePacScript(kSamplePacScriptUrl, false)); | |
| 326 ProxyConfigDictionary config(browser_pref.get()); | |
| 327 scoped_ptr<DictionaryValue> extension_pref(CreatePacScriptDict(config)); | |
| 328 ASSERT_TRUE(extension_pref.get()); | |
| 329 | |
| 330 scoped_ptr<DictionaryValue> expected(new DictionaryValue); | |
| 331 expected->SetString(keys::kProxyConfigPacScriptUrl, kSamplePacScriptUrl); | |
| 332 expected->SetBoolean(keys::kProxyConfigPacScriptMandatory, false); | |
| 333 | |
| 334 EXPECT_TRUE(Value::Equals(expected.get(), extension_pref.get())); | |
| 335 } | |
| 336 | |
| 337 // Test if a PAC script is encoded in a data URL. | |
| 338 TEST(ExtensionProxyApiHelpers, CreatePacScriptDictWidthData) { | |
| 339 scoped_ptr<DictionaryValue> browser_pref( | |
| 340 ProxyConfigDictionary::CreatePacScript(kSamplePacScriptAsDataUrl, false)); | |
| 341 ProxyConfigDictionary config(browser_pref.get()); | |
| 342 scoped_ptr<DictionaryValue> extension_pref(CreatePacScriptDict(config)); | |
| 343 ASSERT_TRUE(extension_pref.get()); | |
| 344 | |
| 345 scoped_ptr<DictionaryValue> expected(new DictionaryValue); | |
| 346 expected->SetString(keys::kProxyConfigPacScriptData, kSamplePacScript); | |
| 347 expected->SetBoolean(keys::kProxyConfigPacScriptMandatory, false); | |
| 348 | |
| 349 EXPECT_TRUE(Value::Equals(expected.get(), extension_pref.get())); | |
| 350 } | |
| 351 | |
| 352 TEST(ExtensionProxyApiHelpers, TokenizeToStringList) { | |
| 353 ListValue expected; | |
| 354 expected.Append(Value::CreateStringValue("s1")); | |
| 355 expected.Append(Value::CreateStringValue("s2")); | |
| 356 expected.Append(Value::CreateStringValue("s3")); | |
| 357 | |
| 358 scoped_ptr<ListValue> out(TokenizeToStringList("s1;s2;s3", ";")); | |
| 359 EXPECT_TRUE(Value::Equals(&expected, out.get())); | |
| 360 } | |
| 361 | |
| 362 } // namespace extension_proxy_api_helpers | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 9690006:
Move Proxy Settings API from chrome/browser/extensions to chrome/browser/eextensions/api/proxy (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src